wind-agent-cli 1.37.2 → 1.38.0

package/server/modules/worktrees/services/worktree-open.service.ts

@@ -1,85 +1,85 @@
-import path from 'node:path';
-
-import type {
-  GitCommandRunner,
-  OpenWorktreeInput,
-  ProjectRepositoryRow,
-  WorktreeProjectGateway,
-  WorktreeProjectView,
-} from '@/shared/types.js';
-import { AppError, normalizeProjectPath } from '@/shared/utils.js';
-import {
-  findWorktreeEntryByPath,
-  listWorktreePorcelainEntries,
-} from '@/modules/worktrees/services/worktree-git.service.js';
-
-function mapRowToProjectView(row: ProjectRepositoryRow): WorktreeProjectView {
-  return {
-    projectId: row.project_id,
-    path: row.project_path,
-    fullPath: row.project_path,
-    displayName: row.custom_project_name || path.basename(row.project_path),
-    isStarred: Boolean(row.isStarred),
-    sessions: [],
-    sessionMeta: { hasMore: false, total: 0 },
-  };
-}
-
-/**
- * Ensures a CloudCLI project exists (and is active) for a worktree directory
- * and returns it, so the caller can switch the UI into that worktree.
- *
- * The path is only accepted when it is a registered worktree of the repository
- * that contains `projectPath` — this endpoint must never become a generic
- * "create project anywhere" backdoor.
- */
-export async function openWorktreeAsProject(
-  input: OpenWorktreeInput,
-  dependencies: {
-    runGit: GitCommandRunner;
-    projects: Pick<
-      WorktreeProjectGateway,
-      'getProjectByPath' | 'createProject' | 'restoreProject'
-    >;
-  },
-): Promise<WorktreeProjectView> {
-  const { projects, runGit } = dependencies;
-  const entries = await listWorktreePorcelainEntries(input.projectPath, runGit);
-  const entry = findWorktreeEntryByPath(entries, input.worktreePath);
-
-  const normalizedWorktreePath = normalizeProjectPath(entry.path);
-  const repoName = path.basename(entries[0].path);
-  // "repo · branch" keeps worktree projects visually grouped next to their
-  // parent repository in the sidebar.
-  const displayName = entry.branch ? `${repoName} · ${entry.branch}` : repoName;
-
-  const existingRow = projects.getProjectByPath(normalizedWorktreePath);
-  if (existingRow) {
-    if (existingRow.isArchived) {
-      await projects.restoreProject(existingRow.project_id);
-    }
-    const refreshedRow = projects.getProjectByPath(normalizedWorktreePath) ?? existingRow;
-    return mapRowToProjectView(refreshedRow);
-  }
-
-  const created = await projects.createProject({
-    projectPath: normalizedWorktreePath,
-    customName: displayName,
-  });
-
-  // `createProject` intentionally keeps reactivated archived rows archived;
-  // an opened worktree must be active so it shows up in the sidebar.
-  if (created.outcome === 'reactivated_archived') {
-    await projects.restoreProject(created.project.projectId);
-  }
-
-  const row = projects.getProjectByPath(normalizedWorktreePath);
-  if (!row) {
-    throw new AppError('Failed to resolve project for worktree', {
-      code: 'WORKTREE_PROJECT_RESOLVE_FAILED',
-      statusCode: 500,
-    });
-  }
-
-  return mapRowToProjectView(row);
-}
+import path from 'node:path';
+
+import type {
+  GitCommandRunner,
+  OpenWorktreeInput,
+  ProjectRepositoryRow,
+  WorktreeProjectGateway,
+  WorktreeProjectView,
+} from '@/shared/types.js';
+import { AppError, normalizeProjectPath } from '@/shared/utils.js';
+import {
+  findWorktreeEntryByPath,
+  listWorktreePorcelainEntries,
+} from '@/modules/worktrees/services/worktree-git.service.js';
+
+function mapRowToProjectView(row: ProjectRepositoryRow): WorktreeProjectView {
+  return {
+    projectId: row.project_id,
+    path: row.project_path,
+    fullPath: row.project_path,
+    displayName: row.custom_project_name || path.basename(row.project_path),
+    isStarred: Boolean(row.isStarred),
+    sessions: [],
+    sessionMeta: { hasMore: false, total: 0 },
+  };
+}
+
+/**
+ * Ensures a WindCli project exists (and is active) for a worktree directory
+ * and returns it, so the caller can switch the UI into that worktree.
+ *
+ * The path is only accepted when it is a registered worktree of the repository
+ * that contains `projectPath` — this endpoint must never become a generic
+ * "create project anywhere" backdoor.
+ */
+export async function openWorktreeAsProject(
+  input: OpenWorktreeInput,
+  dependencies: {
+    runGit: GitCommandRunner;
+    projects: Pick<
+      WorktreeProjectGateway,
+      'getProjectByPath' | 'createProject' | 'restoreProject'
+    >;
+  },
+): Promise<WorktreeProjectView> {
+  const { projects, runGit } = dependencies;
+  const entries = await listWorktreePorcelainEntries(input.projectPath, runGit);
+  const entry = findWorktreeEntryByPath(entries, input.worktreePath);
+
+  const normalizedWorktreePath = normalizeProjectPath(entry.path);
+  const repoName = path.basename(entries[0].path);
+  // "repo · branch" keeps worktree projects visually grouped next to their
+  // parent repository in the sidebar.
+  const displayName = entry.branch ? `${repoName} · ${entry.branch}` : repoName;
+
+  const existingRow = projects.getProjectByPath(normalizedWorktreePath);
+  if (existingRow) {
+    if (existingRow.isArchived) {
+      await projects.restoreProject(existingRow.project_id);
+    }
+    const refreshedRow = projects.getProjectByPath(normalizedWorktreePath) ?? existingRow;
+    return mapRowToProjectView(refreshedRow);
+  }
+
+  const created = await projects.createProject({
+    projectPath: normalizedWorktreePath,
+    customName: displayName,
+  });
+
+  // `createProject` intentionally keeps reactivated archived rows archived;
+  // an opened worktree must be active so it shows up in the sidebar.
+  if (created.outcome === 'reactivated_archived') {
+    await projects.restoreProject(created.project.projectId);
+  }
+
+  const row = projects.getProjectByPath(normalizedWorktreePath);
+  if (!row) {
+    throw new AppError('Failed to resolve project for worktree', {
+      code: 'WORKTREE_PROJECT_RESOLVE_FAILED',
+      statusCode: 500,
+    });
+  }
+
+  return mapRowToProjectView(row);
+}

package/server/modules/worktrees/services/worktree-remove.service.ts

@@ -1,88 +1,88 @@
-import type {
-  GitCommandRunner,
-  RemoveWorktreeInput,
-  RemoveWorktreeResult,
-  WorktreeProjectGateway,
-} from '@/shared/types.js';
-import { AppError } from '@/shared/utils.js';
-import {
-  countChangedFiles,
-  findWorktreeEntryByPath,
-  listWorktreePorcelainEntries,
-} from '@/modules/worktrees/services/worktree-git.service.js';
-
-/**
- * Removes a linked worktree (never the main one), optionally deletes its
- * branch, and archives the CloudCLI project registered for the directory so it
- * disappears from the sidebar while its chat history stays recoverable.
- */
-export async function removeWorktree(
-  input: RemoveWorktreeInput,
-  dependencies: {
-    runGit: GitCommandRunner;
-    projects: Pick<WorktreeProjectGateway, 'getProjectByPath' | 'archiveProject'>;
-  },
-): Promise<RemoveWorktreeResult> {
-  const { projects, runGit } = dependencies;
-  const entries = await listWorktreePorcelainEntries(input.projectPath, runGit);
-  const entry = findWorktreeEntryByPath(entries, input.worktreePath);
-  const repositoryRoot = entries[0].path;
-
-  if (entry.path === repositoryRoot) {
-    throw new AppError('The main worktree cannot be removed', {
-      code: 'WORKTREE_MAIN_NOT_REMOVABLE',
-      statusCode: 400,
-    });
-  }
-
-  if (!input.force) {
-    const changedFileCount = await countChangedFiles(entry.path, runGit);
-    if (changedFileCount > 0) {
-      throw new AppError(
-        `Worktree has ${changedFileCount} uncommitted change${changedFileCount === 1 ? '' : 's'}`,
-        {
-          code: 'WORKTREE_DIRTY',
-          statusCode: 409,
-        },
-      );
-    }
-  }
-
-  const removeArgs = ['worktree', 'remove'];
-  if (input.force) {
-    removeArgs.push('--force');
-  }
-  removeArgs.push(entry.path);
-  await runGit(removeArgs, repositoryRoot);
-
-  let branchDeleted = false;
-  if (input.deleteBranch && entry.branch) {
-    try {
-      await runGit(['branch', '-D', entry.branch], repositoryRoot);
-      branchDeleted = true;
-    } catch {
-      // Branch deletion is best-effort cleanup — the worktree itself is gone,
-      // which is the operation the user asked for.
-    }
-  }
-
-  let archivedProjectId: string | null = null;
-  let archivalError: string | null = null;
-  try {
-    const linkedProject = projects.getProjectByPath(entry.path);
-    if (linkedProject && !linkedProject.isArchived) {
-      await projects.archiveProject(linkedProject.project_id);
-      archivedProjectId = linkedProject.project_id;
-    }
-  } catch (error) {
-    archivalError = error instanceof Error ? error.message : String(error);
-  }
-
-  return {
-    removedPath: entry.path,
-    branch: entry.branch,
-    branchDeleted,
-    archivedProjectId,
-    archivalError,
-  };
-}
+import type {
+  GitCommandRunner,
+  RemoveWorktreeInput,
+  RemoveWorktreeResult,
+  WorktreeProjectGateway,
+} from '@/shared/types.js';
+import { AppError } from '@/shared/utils.js';
+import {
+  countChangedFiles,
+  findWorktreeEntryByPath,
+  listWorktreePorcelainEntries,
+} from '@/modules/worktrees/services/worktree-git.service.js';
+
+/**
+ * Removes a linked worktree (never the main one), optionally deletes its
+ * branch, and archives the WindCli project registered for the directory so it
+ * disappears from the sidebar while its chat history stays recoverable.
+ */
+export async function removeWorktree(
+  input: RemoveWorktreeInput,
+  dependencies: {
+    runGit: GitCommandRunner;
+    projects: Pick<WorktreeProjectGateway, 'getProjectByPath' | 'archiveProject'>;
+  },
+): Promise<RemoveWorktreeResult> {
+  const { projects, runGit } = dependencies;
+  const entries = await listWorktreePorcelainEntries(input.projectPath, runGit);
+  const entry = findWorktreeEntryByPath(entries, input.worktreePath);
+  const repositoryRoot = entries[0].path;
+
+  if (entry.path === repositoryRoot) {
+    throw new AppError('The main worktree cannot be removed', {
+      code: 'WORKTREE_MAIN_NOT_REMOVABLE',
+      statusCode: 400,
+    });
+  }
+
+  if (!input.force) {
+    const changedFileCount = await countChangedFiles(entry.path, runGit);
+    if (changedFileCount > 0) {
+      throw new AppError(
+        `Worktree has ${changedFileCount} uncommitted change${changedFileCount === 1 ? '' : 's'}`,
+        {
+          code: 'WORKTREE_DIRTY',
+          statusCode: 409,
+        },
+      );
+    }
+  }
+
+  const removeArgs = ['worktree', 'remove'];
+  if (input.force) {
+    removeArgs.push('--force');
+  }
+  removeArgs.push(entry.path);
+  await runGit(removeArgs, repositoryRoot);
+
+  let branchDeleted = false;
+  if (input.deleteBranch && entry.branch) {
+    try {
+      await runGit(['branch', '-D', entry.branch], repositoryRoot);
+      branchDeleted = true;
+    } catch {
+      // Branch deletion is best-effort cleanup — the worktree itself is gone,
+      // which is the operation the user asked for.
+    }
+  }
+
+  let archivedProjectId: string | null = null;
+  let archivalError: string | null = null;
+  try {
+    const linkedProject = projects.getProjectByPath(entry.path);
+    if (linkedProject && !linkedProject.isArchived) {
+      await projects.archiveProject(linkedProject.project_id);
+      archivedProjectId = linkedProject.project_id;
+    }
+  } catch (error) {
+    archivalError = error instanceof Error ? error.message : String(error);
+  }
+
+  return {
+    removedPath: entry.path,
+    branch: entry.branch,
+    branchDeleted,
+    archivedProjectId,
+    archivalError,
+  };
+}

package/server/modules/worktrees/tests/worktree-create-and-open.service.test.ts

@@ -1,68 +1,68 @@
-import assert from 'node:assert/strict';
-import test from 'node:test';
-
-import { createAndOpenWorktree } from '@/modules/worktrees/services/worktree-create-and-open.service.js';
-import type { RemoveWorktreeInput } from '@/shared/types.js';
-
-const input = {
-  projectPath: '/workspace/repo',
-  branch: 'feature/login',
-};
-
-test('createAndOpenWorktree returns the registered project', async () => {
-  const result = await createAndOpenWorktree(input, {
-    createWorktree: async () => ({
-      worktreePath: '/workspace/repo-worktrees/feature-login',
-      branch: 'feature/login',
-      createdBranch: true,
-    }),
-    openWorktree: async ({ worktreePath }) => ({
-      projectId: 'project-2',
-      path: worktreePath,
-      fullPath: worktreePath,
-      displayName: 'feature/login',
-      isStarred: false,
-      sessions: [],
-      sessionMeta: { hasMore: false, total: 0 },
-    }),
-    removeWorktree: async () => {
-      throw new Error('unexpected cleanup');
-    },
-  });
-
-  assert.equal(result.project.projectId, 'project-2');
-});
-
-test('createAndOpenWorktree compensates registration failure without deleting an existing branch', async () => {
-  const removals: RemoveWorktreeInput[] = [];
-  const registrationError = new Error('registration failed');
-
-  await assert.rejects(
-    createAndOpenWorktree(input, {
-      createWorktree: async () => ({
-        worktreePath: '/workspace/repo-worktrees/feature-login',
-        branch: 'feature/login',
-        createdBranch: false,
-      }),
-      openWorktree: async () => { throw registrationError; },
-      removeWorktree: async (removeInput) => {
-        removals.push(removeInput);
-        return {
-          removedPath: removeInput.worktreePath,
-          branch: 'feature/login',
-          branchDeleted: false,
-          archivedProjectId: null,
-          archivalError: null,
-        };
-      },
-    }),
-    registrationError,
-  );
-
-  assert.deepEqual(removals, [{
-    projectPath: input.projectPath,
-    worktreePath: '/workspace/repo-worktrees/feature-login',
-    force: true,
-    deleteBranch: false,
-  }]);
-});
+import assert from 'node:assert/strict';
+import test from 'node:test';
+
+import { createAndOpenWorktree } from '@/modules/worktrees/services/worktree-create-and-open.service.js';
+import type { RemoveWorktreeInput } from '@/shared/types.js';
+
+const input = {
+  projectPath: '/workspace/repo',
+  branch: 'feature/login',
+};
+
+test('createAndOpenWorktree returns the registered project', async () => {
+  const result = await createAndOpenWorktree(input, {
+    createWorktree: async () => ({
+      worktreePath: '/workspace/repo-worktrees/feature-login',
+      branch: 'feature/login',
+      createdBranch: true,
+    }),
+    openWorktree: async ({ worktreePath }) => ({
+      projectId: 'project-2',
+      path: worktreePath,
+      fullPath: worktreePath,
+      displayName: 'feature/login',
+      isStarred: false,
+      sessions: [],
+      sessionMeta: { hasMore: false, total: 0 },
+    }),
+    removeWorktree: async () => {
+      throw new Error('unexpected cleanup');
+    },
+  });
+
+  assert.equal(result.project.projectId, 'project-2');
+});
+
+test('createAndOpenWorktree compensates registration failure without deleting an existing branch', async () => {
+  const removals: RemoveWorktreeInput[] = [];
+  const registrationError = new Error('registration failed');
+
+  await assert.rejects(
+    createAndOpenWorktree(input, {
+      createWorktree: async () => ({
+        worktreePath: '/workspace/repo-worktrees/feature-login',
+        branch: 'feature/login',
+        createdBranch: false,
+      }),
+      openWorktree: async () => { throw registrationError; },
+      removeWorktree: async (removeInput) => {
+        removals.push(removeInput);
+        return {
+          removedPath: removeInput.worktreePath,
+          branch: 'feature/login',
+          branchDeleted: false,
+          archivedProjectId: null,
+          archivalError: null,
+        };
+      },
+    }),
+    registrationError,
+  );
+
+  assert.deepEqual(removals, [{
+    projectPath: input.projectPath,
+    worktreePath: '/workspace/repo-worktrees/feature-login',
+    force: true,
+    deleteBranch: false,
+  }]);
+});