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 3105158237d67..2cf6e5ea679ed 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 @@ -2,7 +2,7 @@ import { EnvironmentId, ProjectId } from "@t3tools/contracts"; import { describe, expect, it } from "vite-plus/test"; import type { EnvironmentProject } from "@t3tools/client-runtime/state/shell"; -import type { HomeProjectScope } from "../home/homeThreadList"; +import { buildHomeProjectScopes, type HomeProjectScope } from "../home/homeThreadList"; import { getProjectScopeSelectionTarget, isSameRepository, @@ -60,6 +60,29 @@ function makeScope(projects: ReadonlyArray): HomeProjectScop } describe("getProjectScopeSelectionTarget", () => { + it("chooses an open copy of a repository over an archived copy on the preferred machine", () => { + const repo = { repositoryKey: "github.com/t3tools/t3code" }; + const archived = { + ...makeProject("archived-copy", "mac", repo), + archivedAt: "2026-07-02T00:00:00.000Z", + }; + const open = makeProject("open-copy", "server", repo); + const [scope] = buildHomeProjectScopes({ + projects: [archived, open], + environmentId: null, + projectGroupingMode: "repository", + }); + if (!scope || scope.archived) throw new Error("Expected a pickable repository group"); + + expect( + getProjectScopeSelectionTarget( + scope, + archived.environmentId, + new Set([archived.environmentId, open.environmentId]), + ).id, + ).toBe(open.id); + }); + it("prefers a connected copy of a project that spans environments", () => { const mac = makeProject("t3code", "mac"); const server = makeProject("t3code", "server"); 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 58f7adcf27b64..8ca977ceea1cc 100644 --- a/apps/mobile/src/features/threads/new-task-project-selection.ts +++ b/apps/mobile/src/features/threads/new-task-project-selection.ts @@ -1,34 +1,54 @@ 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 type { EnvironmentProject } from "@t3tools/client-runtime/state/shell"; import { repositoryGroupingKeyOf, type EnvironmentId, type ServerConfig } from "@t3tools/contracts"; import { scopedProjectKey } from "../../lib/scopedEntities"; import type { HomeProjectScope } from "../home/homeThreadList"; +type ProjectRef = { readonly environmentId: string; readonly projectId: string }; + type DraftProjectSelectionResolution = | { readonly kind: "preserve" } | { readonly kind: "select"; readonly project: EnvironmentProject } | { readonly kind: "pick" } | { readonly kind: "dismiss" }; -/** - * The copy of a project a new thread starts in: the preferred environment's, then the - * representative. A connected copy wins over a disconnected one. - */ -export function getProjectScopeSelectionTarget( +function selectOpenProjectScopeMember( scope: HomeProjectScope, preferredEnvironmentId: EnvironmentId | null, connectedEnvironmentIds: ReadonlySet, -): EnvironmentProject { + lastProject?: ProjectRef, +): EnvironmentProject | undefined { + const open = scope.projects.filter(isPickableProjectMember); + const remembered = + lastProject && + open.find( + (project) => + project.environmentId === lastProject.environmentId && project.id === lastProject.projectId, + ); + if (remembered) return remembered; + const rank = (project: EnvironmentProject) => project.environmentId === preferredEnvironmentId ? 0 : project === scope.representative ? 1 : 2; - const ordered = [...scope.projects].sort((left, right) => rank(left) - rank(right)); - return ( - ordered.find((project) => connectedEnvironmentIds.has(project.environmentId)) ?? - ordered[0] ?? - scope.representative + open.sort((left, right) => rank(left) - rank(right)); + return open.find((project) => connectedEnvironmentIds.has(project.environmentId)) ?? open[0]; +} + +/** Picker scopes have an open copy; prefer a connected one, then the selected environment. */ +export function getProjectScopeSelectionTarget( + scope: HomeProjectScope, + preferredEnvironmentId: EnvironmentId | null, + connectedEnvironmentIds: ReadonlySet, +): EnvironmentProject { + const project = selectOpenProjectScopeMember( + scope, + preferredEnvironmentId, + connectedEnvironmentIds, ); + if (!project) throw new Error("A pickable project group must have an open workspace"); + return project; } export function filterProjectScopes( @@ -174,8 +194,6 @@ export function resolveDraftProjectSelection( return onlyScope ? { kind: "select", project: onlyScope.representative } : { kind: "pick" }; } -type ProjectRef = { readonly environmentId: string; readonly projectId: string }; - /** The live copy of the thread list's filtered project a new thread starts in: the remembered one if it is a copy. */ export function newTaskFilteredProject( scope: HomeProjectScope, @@ -183,20 +201,13 @@ export function newTaskFilteredProject( connectedEnvironmentIds: ReadonlySet, lastProject: ProjectRef | undefined, ): ProjectRef | undefined { - const live = scope.projects.filter((project) => project.archivedAt == null); - if (live.length === 0) return undefined; - const project = - live.find( - (candidate) => - candidate.environmentId === lastProject?.environmentId && - candidate.id === lastProject.projectId, - ) ?? - getProjectScopeSelectionTarget( - { ...scope, projects: live }, - preferredEnvironmentId, - connectedEnvironmentIds, - ); - return { environmentId: project.environmentId, projectId: project.id }; + const project = selectOpenProjectScopeMember( + scope, + preferredEnvironmentId, + connectedEnvironmentIds, + lastProject, + ); + return project && { environmentId: project.environmentId, projectId: project.id }; } export function newTaskDestination(options: { diff --git a/apps/web/src/components/CommandPalette.browser.test.tsx b/apps/web/src/components/CommandPalette.browser.test.tsx index d53e02a5a0df3..f29feada58e0a 100644 --- a/apps/web/src/components/CommandPalette.browser.test.tsx +++ b/apps/web/src/components/CommandPalette.browser.test.tsx @@ -15,6 +15,7 @@ import { CommandPalette } from "./CommandPalette"; const entities = vi.hoisted(() => ({ projects: [] as ReadonlyArray, threads: [] as ReadonlyArray, + activeThread: undefined as Thread | undefined, delegatedUnderParent: new Set() as ReadonlySet, handleNewThread: vi.fn(async () => undefined), })); @@ -38,6 +39,7 @@ vi.mock("../hooks/useHandleNewThread", async (original) => { ...actual, useHandleNewThread: () => ({ ...actual.useHandleNewThread(), + activeThread: entities.activeThread, handleNewThread: entities.handleNewThread, }), }; @@ -56,6 +58,7 @@ function setup(state: Partial = {}) { useCommandPaletteStore.setState(useCommandPaletteStore.getInitialState(), true); entities.projects = state.projects ?? []; entities.threads = state.threads ?? []; + entities.activeThread = state.activeThread; entities.delegatedUnderParent = state.delegatedUnderParent ?? new Set(); entities.handleNewThread.mockClear(); } @@ -248,6 +251,45 @@ describe("CommandPalette open intents", () => { await vi.waitFor(() => expect(screen.router?.state.location.pathname).toBe("/local/parent")); }); + it("starts a thread in an open copy when the current project's copy is archived", async () => { + const repositoryIdentity = { + canonicalKey: "github.com/example/acme", + locator: { + source: "git-remote" as const, + remoteName: "origin", + remoteUrl: "https://github.com/example/acme.git", + }, + }; + const archived = { + ...makeProject("acme"), + repositoryIdentity, + archivedAt: "2026-03-02T00:00:00.000Z", + }; + const open = { + ...makeProject("acme"), + environmentId: EnvironmentId.make("remote"), + repositoryIdentity, + }; + setup({ + projects: [archived, open], + activeThread: makeThreadFixture({ + environmentId: archived.environmentId, + projectId: archived.id, + }), + }); + await using _screen = await render({null}); + + openCommandPalette({ open: "new-thread-in" }); + await page.getByRole("option", { name: /acme/i }).click(); + + await vi.waitFor(() => + expect(entities.handleNewThread).toHaveBeenCalledWith({ + environmentId: open.environmentId, + projectId: open.id, + }), + ); + }); + it("numbers filtered New thread in... rows from 1 and jumps to them", async () => { using _platform = vi.spyOn(navigator, "platform", "get").mockReturnValue("Linux x86_64"); setup({ projects: [makeProject("server"), makeProject("lima")] }); diff --git a/apps/web/src/components/CommandPalette.tsx b/apps/web/src/components/CommandPalette.tsx index a7a86ca21752e..1eb1a9bcba599 100644 --- a/apps/web/src/components/CommandPalette.tsx +++ b/apps/web/src/components/CommandPalette.tsx @@ -277,7 +277,10 @@ import { suggestAppAccessForRemote } from "./sourceControlAppAccessToast"; import { Tooltip, TooltipPopup, TooltipTrigger } from "./ui/tooltip"; import { ComposerHandleContext, useComposerHandleContext } from "../composerHandleContext"; import type { ChatComposerHandle } from "./chat/ChatComposer"; -import { pickableProjectGroups } from "@t3tools/client-runtime/state/project-grouping"; +import { + isPickableProjectMember, + pickableProjectGroups, +} from "@t3tools/client-runtime/state/project-grouping"; import { buildSidebarProjectPickerEntries } from "../sidebarProjectGrouping"; import { PullRequestGlyph } from "~/components/pullRequest/pullRequestIcons"; import { readPullRequestListPreferences } from "~/components/pullRequest/pullRequestListPreferences"; @@ -893,15 +896,16 @@ function OpenCommandPaletteDialog(props: { pin: projectPin, runProject: async (project) => { const group = projectGroupByTargetKey.get(`${project.environmentId}:${project.id}`); - const contextualRefBelongsToGroup = + const contextualProjectIsEligible = contextualProjectRef !== null && - group?.memberProjectRefs.some( - (projectRef) => - projectRef.environmentId === contextualProjectRef.environmentId && - projectRef.projectId === contextualProjectRef.projectId, + group?.memberProjects.some( + (member) => + member.environmentId === contextualProjectRef.environmentId && + member.id === contextualProjectRef.projectId && + isPickableProjectMember(member), ); await handleNewThread( - contextualRefBelongsToGroup + contextualProjectIsEligible ? contextualProjectRef : scopeProjectRef(project.environmentId, project.id), ); diff --git a/apps/web/src/environmentGrouping.test.ts b/apps/web/src/environmentGrouping.test.ts index b2081b4b8fe9a..9a531c3b76ad6 100644 --- a/apps/web/src/environmentGrouping.test.ts +++ b/apps/web/src/environmentGrouping.test.ts @@ -279,6 +279,34 @@ describe("environment grouping", () => { }); }); + it("targets an open copy when the preferred project is archived", () => { + const archived = makeProject({ + repositoryIdentity, + archivedAt: "2026-01-02T00:00:00.000Z", + }); + const open = makeProject({ + id: ProjectId.make("open-copy"), + environmentId: remoteEnvironmentId, + repositoryIdentity, + }); + const groups = buildSidebarProjectSnapshots({ + projects: [archived, open], + settings: defaultGroupingSettings, + primaryEnvironmentId, + resolveEnvironmentLabel: () => null, + }); + const [entry] = buildSidebarProjectPickerEntries({ + groups: pickableProjectGroups(groups), + preferredProjectRef: { environmentId: archived.environmentId, projectId: archived.id }, + }); + + expect(entry?.targetProject).toMatchObject({ environmentId: open.environmentId, id: open.id }); + expect(entry?.group.memberProjectRefs).toContainEqual({ + environmentId: archived.environmentId, + projectId: archived.id, + }); + }); + it("puts the preferred project before pinned projects", () => { const project = (title: string, pinnedAt: string | null = null) => makeProject({ diff --git a/apps/web/src/sidebarProjectGrouping.ts b/apps/web/src/sidebarProjectGrouping.ts index b8931f32051d1..9a28f40855aa4 100644 --- a/apps/web/src/sidebarProjectGrouping.ts +++ b/apps/web/src/sidebarProjectGrouping.ts @@ -6,6 +6,7 @@ import type { import { buildProjectGroups, derivePhysicalProjectKey, + isPickableProjectMember, resolveScratchProjectScopeKey, type ProjectGroupingSettings, } from "@t3tools/client-runtime/state/project-grouping"; @@ -221,6 +222,7 @@ export function buildSidebarProjectPickerEntries(input: { }) { const preferredProjectRef = input.preferredProjectRef; const entries = input.groups.flatMap((group): SidebarProjectPickerEntry[] => { + const members = group.memberProjects.filter(isPickableProjectMember); const isPreferred = preferredProjectRef ? group.memberProjectRefs.some( (projectRef) => @@ -229,21 +231,18 @@ export function buildSidebarProjectPickerEntries(input: { ) : false; const preferredProject = preferredProjectRef - ? (group.memberProjects.find( + ? (members.find( (project) => project.environmentId === preferredProjectRef.environmentId && project.id === preferredProjectRef.projectId, - ) ?? - group.memberProjects.find( - (project) => project.environmentId === preferredProjectRef.environmentId, - )) + ) ?? members.find((project) => project.environmentId === preferredProjectRef.environmentId)) : null; const targetProject = preferredProject ?? - group.memberProjects.find( + members.find( (project) => project.environmentId === group.environmentId && project.id === group.id, ) ?? - group.memberProjects[0]; + members[0]; if (!targetProject) return []; return [{ group, targetProject, isPreferred }]; diff --git a/packages/client-runtime/src/state/projectGrouping.ts b/packages/client-runtime/src/state/projectGrouping.ts index 3fcddf3d0580c..2ae5fb99f5022 100644 --- a/packages/client-runtime/src/state/projectGrouping.ts +++ b/packages/client-runtime/src/state/projectGrouping.ts @@ -273,6 +273,10 @@ export function pickableProjectGroups< return [...open.filter((group) => group.pinned), ...open.filter((group) => !group.pinned)]; } +export function isPickableProjectMember(member: Pick): boolean { + return member.archivedAt == null; +} + function projectFreshnessTime(project: EnvironmentProject): number { const updatedAtTime = Date.parse(project.updatedAt); if (Number.isFinite(updatedAtTime)) { @@ -397,7 +401,7 @@ export function buildProjectGroups( members, memberProjectRefs: projectRefsByLogicalKey.get(key) ?? [], pinned: members.some((member) => member.project.pinnedAt != null), - archived: members.every((member) => member.project.archivedAt != null), + archived: !members.some(({ project }) => isPickableProjectMember(project)), }; }); }