diff --git a/apps/mobile/src/features/threads/new-task-project-selection.test.ts b/apps/mobile/src/features/threads/new-task-project-selection.test.ts index 2cf6e5ea679ed..132c1e4be9bde 100644 --- a/apps/mobile/src/features/threads/new-task-project-selection.test.ts +++ b/apps/mobile/src/features/threads/new-task-project-selection.test.ts @@ -100,6 +100,29 @@ describe("getProjectScopeSelectionTarget", () => { expect(target([], "server")).toBe(server); expect(target([])).toBe(mac); }); + + it("starts in the repository root over an earlier sub-folder in the same environment", () => { + const identity = (project: EnvironmentProject) => ({ + ...project.repositoryIdentity!, + rootPath: "/work/workspace", + }); + const base = makeProject("old-tool", "mac", { + workspaceRoot: "/work/workspace/_archive/old-tool", + repositoryKey: "github.com/owner/workspace", + }); + const subfolder = { ...base, repositoryIdentity: identity(base) }; + const root = { + ...makeProject("workspace", "mac", { workspaceRoot: "/work/workspace" }), + repositoryIdentity: identity(base), + }; + expect( + getProjectScopeSelectionTarget( + { ...makeScope([subfolder, root]), representative: root }, + EnvironmentId.make("mac"), + new Set([EnvironmentId.make("mac")]), + ), + ).toBe(root); + }); }); describe("newTaskFilteredProject", () => { diff --git a/apps/mobile/src/features/threads/new-task-project-selection.ts b/apps/mobile/src/features/threads/new-task-project-selection.ts index 8ca977ceea1cc..8f8708c822919 100644 --- a/apps/mobile/src/features/threads/new-task-project-selection.ts +++ b/apps/mobile/src/features/threads/new-task-project-selection.ts @@ -1,6 +1,9 @@ import type { EnvironmentConnectionPhase } from "@t3tools/client-runtime/connection"; import { availableScratchWorkspaceRoot } from "@t3tools/client-runtime/operations/projects"; -import { isPickableProjectMember } from "@t3tools/client-runtime/state/project-grouping"; +import { + isPickableProjectMember, + isRepositoryRootProject, +} from "@t3tools/client-runtime/state/project-grouping"; import type { EnvironmentProject } from "@t3tools/client-runtime/state/shell"; import { repositoryGroupingKeyOf, type EnvironmentId, type ServerConfig } from "@t3tools/contracts"; @@ -32,11 +35,18 @@ function selectOpenProjectScopeMember( const rank = (project: EnvironmentProject) => project.environmentId === preferredEnvironmentId ? 0 : project === scope.representative ? 1 : 2; - open.sort((left, right) => rank(left) - rank(right)); + open.sort( + (left, right) => + rank(left) - rank(right) || + Number(isRepositoryRootProject(right)) - Number(isRepositoryRootProject(left)), + ); return open.find((project) => connectedEnvironmentIds.has(project.environmentId)) ?? open[0]; } -/** Picker scopes have an open copy; prefer a connected one, then the selected environment. */ +/** + * Picker scopes have an open copy; prefer a connected one, then the selected environment, with a + * repository root ahead of a sub-folder. + */ export function getProjectScopeSelectionTarget( scope: HomeProjectScope, preferredEnvironmentId: EnvironmentId | null, diff --git a/apps/web/src/environmentGrouping.test.ts b/apps/web/src/environmentGrouping.test.ts index 9a531c3b76ad6..9cb42b3d703c1 100644 --- a/apps/web/src/environmentGrouping.test.ts +++ b/apps/web/src/environmentGrouping.test.ts @@ -232,12 +232,23 @@ describe("environment grouping", () => { workspaceRoot: "/tmp/destination", repositoryIdentity: destinationRepositoryIdentity, }); + const destinationRemoteIdentity = { + ...destinationRepositoryIdentity, + rootPath: "/remote/destination", + }; + const destinationRemoteSubfolder = makeProject({ + id: ProjectId.make("destination-remote-subfolder"), + environmentId: remoteEnvironmentId, + title: "destination-app", + workspaceRoot: "/remote/destination/app", + repositoryIdentity: destinationRemoteIdentity, + }); const destinationRemote = makeProject({ id: ProjectId.make("destination-remote"), environmentId: remoteEnvironmentId, title: "destination", workspaceRoot: "/remote/destination", - repositoryIdentity: destinationRepositoryIdentity, + repositoryIdentity: destinationRemoteIdentity, }); const fallbackPrimary = makeProject({ id: ProjectId.make("fallback-primary"), @@ -249,6 +260,7 @@ describe("environment grouping", () => { currentPrimary, currentRemote, destinationPrimary, + destinationRemoteSubfolder, destinationRemote, fallbackPrimary, ], diff --git a/apps/web/src/hooks/useHandleNewThread.ts b/apps/web/src/hooks/useHandleNewThread.ts index 49e8812628b1b..1be24bd9a3489 100644 --- a/apps/web/src/hooks/useHandleNewThread.ts +++ b/apps/web/src/hooks/useHandleNewThread.ts @@ -18,7 +18,9 @@ import { orderItemsByPreferredIds } from "../components/Sidebar.logic"; import { deriveLogicalProjectKeyFromSettings, getProjectOrderKey, + resolveGroupDefaultProject, selectProjectGroupingSettings, + type ProjectGroupingSettings, } from "@t3tools/client-runtime/state/project-grouping"; import { resolveNewThreadEnvMode, resolveProjectSettings } from "@t3tools/shared/projectSettings"; import { @@ -43,7 +45,7 @@ import { environmentSummaries } from "../state/presentation"; import { environmentServerConfigsAtom } from "../state/server"; import { resolveThreadRouteTarget } from "../threadRoutes"; import { legacyProjectCwdPreferenceKey, useUiStateStore } from "../uiStateStore"; -import { getClientSettings } from "./useSettings"; +import { getClientSettings, useClientSettings } from "./useSettings"; import { getLocalStorageItem, useLocalStorage } from "./useLocalStorage"; import * as Schema from "effect/Schema"; import { useAtomValue } from "@effect/atom-react"; @@ -465,6 +467,7 @@ export function resolveDefaultProjectRef( projectOrder: readonly string[], lastUsedProjectKey: string | null, fallbackReady = true, + groupingSettings?: ProjectGroupingSettings, ): ScopedProjectRef | null { const lastUsed = projects.find( (project) => @@ -473,8 +476,9 @@ export function resolveDefaultProjectRef( ); if (lastUsed) return scopeProjectRef(lastUsed.environmentId, lastUsed.id); if (!fallbackReady) return null; - const [defaultProject] = orderItemsByPreferredIds({ - items: projects.filter((project) => project.archivedAt == null), + const liveProjects = projects.filter((project) => project.archivedAt == null); + const [firstProject] = orderItemsByPreferredIds({ + items: liveProjects, preferredIds: projectOrder, getId: getProjectOrderKey, getPreferenceIds: (project) => [ @@ -482,7 +486,11 @@ export function resolveDefaultProjectRef( legacyProjectCwdPreferenceKey(project.workspaceRoot), ], }); - return defaultProject ? scopeProjectRef(defaultProject.environmentId, defaultProject.id) : null; + if (!firstProject) return null; + const defaultProject = groupingSettings + ? resolveGroupDefaultProject(firstProject, liveProjects, groupingSettings) + : firstProject; + return scopeProjectRef(defaultProject.environmentId, defaultProject.id); } export function useHandleNewThread() { @@ -509,11 +517,13 @@ export function useHandleNewThread() { ); const projects = useProjects(); const handleNewThread = useNewThreadHandler(); + const groupingSettings = useClientSettings(selectProjectGroupingSettings); const defaultProjectRef = resolveDefaultProjectRef( projects, projectOrder, lastUsedProjectKey, defaultProjectFallbackReady, + groupingSettings, ); return { diff --git a/apps/web/src/shortcuts/chatRouteCommands.ts b/apps/web/src/shortcuts/chatRouteCommands.ts index a5aeeeefbd638..7cca45fbd81db 100644 --- a/apps/web/src/shortcuts/chatRouteCommands.ts +++ b/apps/web/src/shortcuts/chatRouteCommands.ts @@ -91,6 +91,7 @@ export function installChatRouteCommands(router: AnyRouter): () => void { useUiStateStore.getState().projectOrder, lastUsedProjectKey, appAtomRegistry.get(defaultProjectFallbackReadyAtom(lastUsedProjectKey)), + selectProjectGroupingSettings(getClientSettings()), ), handleNewThread, }; diff --git a/apps/web/src/sidebarProjectGrouping.ts b/apps/web/src/sidebarProjectGrouping.ts index 9a28f40855aa4..aaf4bcf57b1e0 100644 --- a/apps/web/src/sidebarProjectGrouping.ts +++ b/apps/web/src/sidebarProjectGrouping.ts @@ -8,6 +8,7 @@ import { derivePhysicalProjectKey, isPickableProjectMember, resolveScratchProjectScopeKey, + selectGroupDefaultProject, type ProjectGroupingSettings, } from "@t3tools/client-runtime/state/project-grouping"; import { msg } from "gt-react"; @@ -235,7 +236,10 @@ export function buildSidebarProjectPickerEntries(input: { (project) => project.environmentId === preferredProjectRef.environmentId && project.id === preferredProjectRef.projectId, - ) ?? members.find((project) => project.environmentId === preferredProjectRef.environmentId)) + ) ?? + selectGroupDefaultProject( + members.filter((project) => project.environmentId === preferredProjectRef.environmentId), + )) : null; const targetProject = preferredProject ?? diff --git a/packages/client-runtime/src/state/projectGrouping.test.ts b/packages/client-runtime/src/state/projectGrouping.test.ts index a991e7a45cb22..8f01ead8b9df1 100644 --- a/packages/client-runtime/src/state/projectGrouping.test.ts +++ b/packages/client-runtime/src/state/projectGrouping.test.ts @@ -8,6 +8,7 @@ import { deriveLogicalProjectKeyFromSettings, pickableProjectGroups, derivePhysicalProjectKey, + resolveGroupDefaultProject, resolveScratchProjectScopeKey, sortProjectsByGroupOrder, type ProjectGroupingSettings, @@ -265,6 +266,54 @@ describe("buildProjectGroups", () => { } }); + it("represents a repository group by its root checkout, even when it was added last", () => { + const remoteEnvironmentId = EnvironmentId.make("remote"); + const local = { ...repositoryIdentity, rootPath: "/work/workspace" }; + const remote = { ...repositoryIdentity, rootPath: "/srv/workspace" }; + const archivedTool = makeProject("old-tool", "/work/workspace/_archive/old-tool", { + repositoryIdentity: local, + }); + const app = makeProject("app-a", "/work/workspace/app-a", { repositoryIdentity: local }); + const remoteApp = makeProject("remote-app", "/srv/workspace/app-a", { + environmentId: remoteEnvironmentId, + repositoryIdentity: remote, + }); + const remoteRoot = makeProject("remote-root", "/srv/workspace", { + environmentId: remoteEnvironmentId, + repositoryIdentity: remote, + }); + const root = makeProject("workspace", "/work/workspace", { repositoryIdentity: local }); + const representativeOf = ( + projects: ReadonlyArray, + preferredEnvironmentId: EnvironmentId | null = null, + ) => + buildProjectGroups({ projects, settings: settings("repository"), preferredEnvironmentId })[0] + ?.representative.id; + + expect(representativeOf([archivedTool, app, root])).toBe("workspace"); + expect(representativeOf([archivedTool, app, remoteApp, remoteRoot, root], environmentId)).toBe( + "workspace", + ); + expect( + representativeOf([archivedTool, app, remoteApp, remoteRoot, root], remoteEnvironmentId), + ).toBe("remote-root"); + // A local root is not worth leaving the current environment for. + expect(representativeOf([archivedTool, root, remoteApp], remoteEnvironmentId)).toBe( + "remote-app", + ); + expect(representativeOf([archivedTool, app])).toBe("old-tool"); + + // A new thread with no current or last-used project starts from the first project's group. + const all = [archivedTool, app, remoteApp, remoteRoot, root]; + expect(resolveGroupDefaultProject(archivedTool, all, settings("repository")).id).toBe( + "workspace", + ); + expect(resolveGroupDefaultProject(remoteApp, all, settings("repository")).id).toBe( + "remote-root", + ); + expect(resolveGroupDefaultProject(archivedTool, all, settings("separate")).id).toBe("old-tool"); + }); + it("keeps a fork apart from its upstream checkout and labels it by its own remote", () => { const fork = makeProject("fork", "/work/t3code-fork", { repositoryIdentity: { diff --git a/packages/client-runtime/src/state/projectGrouping.ts b/packages/client-runtime/src/state/projectGrouping.ts index 2ae5fb99f5022..164c1bea07d57 100644 --- a/packages/client-runtime/src/state/projectGrouping.ts +++ b/packages/client-runtime/src/state/projectGrouping.ts @@ -70,6 +70,20 @@ function deriveRepositoryRelativeProjectPath( return normalizedProjectPath.slice(rootPrefix.length).replaceAll("\\", "/"); } +/** The project's workspace root is its repository's git top-level, not a sub-folder. */ +export function isRepositoryRootProject( + project: Pick, +): boolean { + return deriveRepositoryRelativeProjectPath(project) === ""; +} + +/** A group's default checkout for new threads: its repository root, else its first member. */ +export function selectGroupDefaultProject< + TProject extends Pick, +>(projects: ReadonlyArray): TProject | undefined { + return projects.find(isRepositoryRootProject) ?? projects[0]; +} + export function derivePhysicalProjectKeyFromPath(environmentId: string, cwd: string): string { return `${environmentId}:${normalizeProjectPathForComparison(cwd)}`; } @@ -165,6 +179,23 @@ export function deriveLogicalProjectKeyFromSettings( }); } +/** The checkout a new thread in `project`'s group starts in on its environment: the group's root. */ +export function resolveGroupDefaultProject( + project: TProject, + projects: ReadonlyArray, + settings: ProjectGroupingSettings, +): TProject { + const groupKey = deriveLogicalProjectKeyFromSettings(project, settings); + return ( + projects.find( + (candidate) => + candidate.environmentId === project.environmentId && + isRepositoryRootProject(candidate) && + deriveLogicalProjectKeyFromSettings(candidate, settings) === groupKey, + ) ?? project + ); +} + export function resolveScratchProjectScopeKey( key: string | null, projects: ReadonlyArray< @@ -381,10 +412,13 @@ export function buildProjectGroups( const preferredEnvironmentId = input.preferredEnvironmentId ?? null; return Array.from(groupedMembers, ([key, members]) => { + const projects = members.map((member) => member.project); const representative = (preferredEnvironmentId - ? members.find((member) => member.project.environmentId === preferredEnvironmentId)?.project - : null) ?? members[0]!.project; + ? selectGroupDefaultProject( + projects.filter((project) => project.environmentId === preferredEnvironmentId), + ) + : undefined) ?? selectGroupDefaultProject(projects)!; return { key, label: