wind-agent-cli 1.37.2 → 1.37.3

package/server/modules/worktrees/tests/worktrees.routes.test.ts

@@ -1,199 +1,199 @@
-import assert from 'node:assert/strict';
-import { once } from 'node:events';
-import type { AddressInfo } from 'node:net';
-import test from 'node:test';
-
-import express, {
-  type NextFunction,
-  type Request,
-  type Response,
-} from 'express';
-
-import { createWorktreesRouter } from '@/modules/worktrees/worktrees.routes.js';
-import type {
-  CreateWorktreeInput,
-  WorktreeServices,
-} from '@/shared/types.js';
-import { AppError } from '@/shared/utils.js';
-
-function createFakeServices(overrides: Partial<WorktreeServices> = {}): WorktreeServices {
-  const unused = async (): Promise<never> => {
-    throw new Error('Unexpected Worktrees service call');
-  };
-
-  return {
-    resolveProjectPath: () => {
-      throw new Error('Unexpected project resolution');
-    },
-    list: unused,
-    create: unused,
-    createAndOpen: unused,
-    open: unused,
-    merge: unused,
-    remove: unused,
-    ...overrides,
-  };
-}
-
-async function withWorktreesServer(
-  services: WorktreeServices,
-  run: (baseUrl: string) => Promise<void>,
-): Promise<void> {
-  const app = express();
-  app.use(express.json());
-  app.use('/api/worktrees', createWorktreesRouter(services));
-  app.use((error: unknown, _req: Request, res: Response, _next: NextFunction) => {
-    if (error instanceof AppError) {
-      res.status(error.statusCode).json({ error: error.code });
-      return;
-    }
-
-    res.status(500).json({ error: 'INTERNAL_ERROR' });
-  });
-
-  const server = app.listen(0, '127.0.0.1');
-  await once(server, 'listening');
-
-  try {
-    const address = server.address() as AddressInfo;
-    await run(`http://127.0.0.1:${address.port}`);
-  } finally {
-    await new Promise<void>((resolve, reject) => {
-      server.close((error) => error ? reject(error) : resolve());
-    });
-  }
-}
-
-test('create route parses input and invokes the create-and-open application service', async () => {
-  const createInputs: CreateWorktreeInput[] = [];
-  const services = createFakeServices({
-    resolveProjectPath: (projectId) => {
-      assert.equal(projectId, 'project-1');
-      return '/workspace/repo';
-    },
-    createAndOpen: async (input) => {
-      createInputs.push(input);
-      return {
-        worktreePath: '/workspace/repo-worktrees/feature-login',
-        branch: input.branch,
-        createdBranch: true,
-        project: {
-          projectId: 'worktree-project-1',
-          path: '/workspace/repo-worktrees/feature-login',
-          fullPath: '/workspace/repo-worktrees/feature-login',
-          displayName: 'repo worktree',
-          isStarred: false,
-          sessions: [],
-          sessionMeta: { hasMore: false, total: 0 },
-        },
-      };
-    },
-  });
-
-  await withWorktreesServer(services, async (baseUrl) => {
-    const response = await fetch(`${baseUrl}/api/worktrees/create`, {
-      method: 'POST',
-      headers: { 'content-type': 'application/json' },
-      body: JSON.stringify({
-        project: ' project-1 ',
-        branch: ' feature/login ',
-        baseBranch: 'main',
-      }),
-    });
-    const payload = await response.json() as {
-      success: boolean;
-      data: { project: { projectId: string } };
-    };
-
-    assert.equal(response.status, 200);
-    assert.equal(payload.success, true);
-    assert.equal(payload.data.project.projectId, 'worktree-project-1');
-  });
-
-  assert.deepEqual(createInputs, [{
-    projectPath: '/workspace/repo',
-    branch: 'feature/login',
-    baseBranch: 'main',
-  }]);
-});
-
-test('create route rejects missing branch before calling a mutation service', async () => {
-  let createCalled = false;
-  const services = createFakeServices({
-    resolveProjectPath: () => '/workspace/repo',
-    createAndOpen: async () => {
-      createCalled = true;
-      throw new Error('create should not run for invalid input');
-    },
-  });
-
-  await withWorktreesServer(services, async (baseUrl) => {
-    const response = await fetch(`${baseUrl}/api/worktrees/create`, {
-      method: 'POST',
-      headers: { 'content-type': 'application/json' },
-      body: JSON.stringify({ project: 'project-1' }),
-    });
-    const payload = await response.json() as { error: string };
-
-    assert.equal(response.status, 400);
-    assert.equal(payload.error, 'INVALID_REQUEST_BODY');
-  });
-
-  assert.equal(createCalled, false);
-});
-
-test('merge and remove routes do not coerce string booleans to true', async () => {
-  const mergeInputs: Array<{ squash?: boolean; removeAfterMerge?: boolean }> = [];
-  const removeInputs: Array<{ force?: boolean; deleteBranch?: boolean }> = [];
-  const services = createFakeServices({
-    resolveProjectPath: () => '/workspace/repo',
-    merge: async (input) => {
-      mergeInputs.push(input);
-      return {
-        mergedBranch: 'feature/login',
-        targetBranch: 'main',
-        squash: false,
-        removedWorktree: null,
-        cleanupError: null,
-      };
-    },
-    remove: async (input) => {
-      removeInputs.push(input);
-      return {
-        removedPath: input.worktreePath,
-        branch: 'feature/login',
-        branchDeleted: false,
-        archivedProjectId: null,
-        archivalError: null,
-      };
-    },
-  });
-
-  await withWorktreesServer(services, async (baseUrl) => {
-    const body = {
-      project: 'project-1',
-      worktreePath: '/workspace/repo-worktrees/feature-login',
-      squash: 'false',
-      removeAfterMerge: 'false',
-      force: 'false',
-      deleteBranch: 'false',
-    };
-    const mergeResponse = await fetch(`${baseUrl}/api/worktrees/merge`, {
-      method: 'POST',
-      headers: { 'content-type': 'application/json' },
-      body: JSON.stringify(body),
-    });
-    const removeResponse = await fetch(`${baseUrl}/api/worktrees/remove`, {
-      method: 'POST',
-      headers: { 'content-type': 'application/json' },
-      body: JSON.stringify(body),
-    });
-    assert.equal(mergeResponse.status, 200);
-    assert.equal(removeResponse.status, 200);
-  });
-
-  assert.equal(mergeInputs[0].squash, false);
-  assert.equal(mergeInputs[0].removeAfterMerge, false);
-  assert.equal(removeInputs[0].force, false);
-  assert.equal(removeInputs[0].deleteBranch, false);
-});
+import assert from 'node:assert/strict';
+import { once } from 'node:events';
+import type { AddressInfo } from 'node:net';
+import test from 'node:test';
+
+import express, {
+  type NextFunction,
+  type Request,
+  type Response,
+} from 'express';
+
+import { createWorktreesRouter } from '@/modules/worktrees/worktrees.routes.js';
+import type {
+  CreateWorktreeInput,
+  WorktreeServices,
+} from '@/shared/types.js';
+import { AppError } from '@/shared/utils.js';
+
+function createFakeServices(overrides: Partial<WorktreeServices> = {}): WorktreeServices {
+  const unused = async (): Promise<never> => {
+    throw new Error('Unexpected Worktrees service call');
+  };
+
+  return {
+    resolveProjectPath: () => {
+      throw new Error('Unexpected project resolution');
+    },
+    list: unused,
+    create: unused,
+    createAndOpen: unused,
+    open: unused,
+    merge: unused,
+    remove: unused,
+    ...overrides,
+  };
+}
+
+async function withWorktreesServer(
+  services: WorktreeServices,
+  run: (baseUrl: string) => Promise<void>,
+): Promise<void> {
+  const app = express();
+  app.use(express.json());
+  app.use('/api/worktrees', createWorktreesRouter(services));
+  app.use((error: unknown, _req: Request, res: Response, _next: NextFunction) => {
+    if (error instanceof AppError) {
+      res.status(error.statusCode).json({ error: error.code });
+      return;
+    }
+
+    res.status(500).json({ error: 'INTERNAL_ERROR' });
+  });
+
+  const server = app.listen(0, '127.0.0.1');
+  await once(server, 'listening');
+
+  try {
+    const address = server.address() as AddressInfo;
+    await run(`http://127.0.0.1:${address.port}`);
+  } finally {
+    await new Promise<void>((resolve, reject) => {
+      server.close((error) => error ? reject(error) : resolve());
+    });
+  }
+}
+
+test('create route parses input and invokes the create-and-open application service', async () => {
+  const createInputs: CreateWorktreeInput[] = [];
+  const services = createFakeServices({
+    resolveProjectPath: (projectId) => {
+      assert.equal(projectId, 'project-1');
+      return '/workspace/repo';
+    },
+    createAndOpen: async (input) => {
+      createInputs.push(input);
+      return {
+        worktreePath: '/workspace/repo-worktrees/feature-login',
+        branch: input.branch,
+        createdBranch: true,
+        project: {
+          projectId: 'worktree-project-1',
+          path: '/workspace/repo-worktrees/feature-login',
+          fullPath: '/workspace/repo-worktrees/feature-login',
+          displayName: 'repo worktree',
+          isStarred: false,
+          sessions: [],
+          sessionMeta: { hasMore: false, total: 0 },
+        },
+      };
+    },
+  });
+
+  await withWorktreesServer(services, async (baseUrl) => {
+    const response = await fetch(`${baseUrl}/api/worktrees/create`, {
+      method: 'POST',
+      headers: { 'content-type': 'application/json' },
+      body: JSON.stringify({
+        project: ' project-1 ',
+        branch: ' feature/login ',
+        baseBranch: 'main',
+      }),
+    });
+    const payload = await response.json() as {
+      success: boolean;
+      data: { project: { projectId: string } };
+    };
+
+    assert.equal(response.status, 200);
+    assert.equal(payload.success, true);
+    assert.equal(payload.data.project.projectId, 'worktree-project-1');
+  });
+
+  assert.deepEqual(createInputs, [{
+    projectPath: '/workspace/repo',
+    branch: 'feature/login',
+    baseBranch: 'main',
+  }]);
+});
+
+test('create route rejects missing branch before calling a mutation service', async () => {
+  let createCalled = false;
+  const services = createFakeServices({
+    resolveProjectPath: () => '/workspace/repo',
+    createAndOpen: async () => {
+      createCalled = true;
+      throw new Error('create should not run for invalid input');
+    },
+  });
+
+  await withWorktreesServer(services, async (baseUrl) => {
+    const response = await fetch(`${baseUrl}/api/worktrees/create`, {
+      method: 'POST',
+      headers: { 'content-type': 'application/json' },
+      body: JSON.stringify({ project: 'project-1' }),
+    });
+    const payload = await response.json() as { error: string };
+
+    assert.equal(response.status, 400);
+    assert.equal(payload.error, 'INVALID_REQUEST_BODY');
+  });
+
+  assert.equal(createCalled, false);
+});
+
+test('merge and remove routes do not coerce string booleans to true', async () => {
+  const mergeInputs: Array<{ squash?: boolean; removeAfterMerge?: boolean }> = [];
+  const removeInputs: Array<{ force?: boolean; deleteBranch?: boolean }> = [];
+  const services = createFakeServices({
+    resolveProjectPath: () => '/workspace/repo',
+    merge: async (input) => {
+      mergeInputs.push(input);
+      return {
+        mergedBranch: 'feature/login',
+        targetBranch: 'main',
+        squash: false,
+        removedWorktree: null,
+        cleanupError: null,
+      };
+    },
+    remove: async (input) => {
+      removeInputs.push(input);
+      return {
+        removedPath: input.worktreePath,
+        branch: 'feature/login',
+        branchDeleted: false,
+        archivedProjectId: null,
+        archivalError: null,
+      };
+    },
+  });
+
+  await withWorktreesServer(services, async (baseUrl) => {
+    const body = {
+      project: 'project-1',
+      worktreePath: '/workspace/repo-worktrees/feature-login',
+      squash: 'false',
+      removeAfterMerge: 'false',
+      force: 'false',
+      deleteBranch: 'false',
+    };
+    const mergeResponse = await fetch(`${baseUrl}/api/worktrees/merge`, {
+      method: 'POST',
+      headers: { 'content-type': 'application/json' },
+      body: JSON.stringify(body),
+    });
+    const removeResponse = await fetch(`${baseUrl}/api/worktrees/remove`, {
+      method: 'POST',
+      headers: { 'content-type': 'application/json' },
+      body: JSON.stringify(body),
+    });
+    assert.equal(mergeResponse.status, 200);
+    assert.equal(removeResponse.status, 200);
+  });
+
+  assert.equal(mergeInputs[0].squash, false);
+  assert.equal(mergeInputs[0].removeAfterMerge, false);
+  assert.equal(removeInputs[0].force, false);
+  assert.equal(removeInputs[0].deleteBranch, false);
+});

package/server/modules/worktrees/worktrees.module.ts

@@ -1,113 +1,113 @@
-import { access } from 'node:fs/promises';
-
-import { projectsDb } from '@/modules/database/index.js';
-import {
-  createProject,
-  deleteOrArchiveProject,
-  restoreArchivedProject,
-} from '@/modules/projects/index.js';
-import type {
-  WorktreeFileSystem,
-  WorktreeProjectGateway,
-  WorktreeServices,
-} from '@/shared/types.js';
-import { AppError } from '@/shared/utils.js';
-import { createWorktree } from '@/modules/worktrees/services/worktree-create.service.js';
-import { createAndOpenWorktree } from '@/modules/worktrees/services/worktree-create-and-open.service.js';
-import { runGitCommand } from '@/modules/worktrees/services/worktree-git.service.js';
-import { listWorktrees } from '@/modules/worktrees/services/worktree-list.service.js';
-import { mergeWorktree } from '@/modules/worktrees/services/worktree-merge.service.js';
-import { openWorktreeAsProject } from '@/modules/worktrees/services/worktree-open.service.js';
-import { removeWorktree } from '@/modules/worktrees/services/worktree-remove.service.js';
-import { createWorktreesRouter } from '@/modules/worktrees/worktrees.routes.js';
-
-/**
- * Real filesystem adapter used only by Worktrees production composition.
- *
- * Services depend on the shared capability type and therefore cannot touch a
- * developer's filesystem unless this adapter is explicitly supplied.
- */
-const worktreeFileSystem: WorktreeFileSystem = {
-  async pathExists(candidatePath: string): Promise<boolean> {
-    try {
-      await access(candidatePath);
-      return true;
-    } catch {
-      return false;
-    }
-  },
-};
-
-/**
- * Projects boundary for Worktrees production workflows.
- *
- * Imports are deliberately restricted to the Database and Projects barrel
- * files. No Worktrees service knows which repository or project service backs
- * these operations.
- */
-const worktreeProjects: WorktreeProjectGateway = {
-  getProjectPathById: (projectId) => projectsDb.getProjectPathById(projectId),
-  getProjectByPath: (projectPath) => projectsDb.getProjectPath(projectPath),
-  createProject: (input) => createProject(input),
-  restoreProject: (projectId) => restoreArchivedProject(projectId),
-  archiveProject: (projectId) => deleteOrArchiveProject(projectId, false),
-};
-
-const remove: WorktreeServices['remove'] = (input) => removeWorktree(input, {
-  runGit: runGitCommand,
-  projects: worktreeProjects,
-});
-
-const create: WorktreeServices['create'] = (input) => createWorktree(input, {
-  runGit: runGitCommand,
-  fileSystem: worktreeFileSystem,
-});
-
-const open: WorktreeServices['open'] = (input) => openWorktreeAsProject(input, {
-  runGit: runGitCommand,
-  projects: worktreeProjects,
-});
-
-/**
- * Production Worktrees application-service surface.
- *
- * This is the module's composition root: it is the only location that combines
- * concrete adapters with the independently testable workflow functions.
- */
-const worktreeServices: WorktreeServices = {
-  resolveProjectPath(projectId) {
-    const projectPath = worktreeProjects.getProjectPathById(projectId);
-    if (!projectPath) {
-      throw new AppError(`Unable to resolve project path for "${projectId}"`, {
-        code: 'PROJECT_NOT_FOUND',
-        statusCode: 404,
-      });
-    }
-
-    return projectPath;
-  },
-  list: (input) => listWorktrees(input, {
-    runGit: runGitCommand,
-    getProjectByPath: worktreeProjects.getProjectByPath,
-  }),
-  create,
-  createAndOpen: (input) => createAndOpenWorktree(input, {
-    createWorktree: create,
-    openWorktree: open,
-    removeWorktree: remove,
-  }),
-  open,
-  merge: (input) => mergeWorktree(input, {
-    runGit: runGitCommand,
-    removeWorktree: remove,
-  }),
-  remove,
-};
-
-/**
- * Worktrees router mounted by the server entrypoint at `/api/worktrees`.
- *
- * It is assembled here so other modules consume only the Worktrees barrel and
- * cannot depend on route or service implementation files.
- */
-export const worktreesRoutes = createWorktreesRouter(worktreeServices);
+import { access } from 'node:fs/promises';
+
+import { projectsDb } from '@/modules/database/index.js';
+import {
+  createProject,
+  deleteOrArchiveProject,
+  restoreArchivedProject,
+} from '@/modules/projects/index.js';
+import type {
+  WorktreeFileSystem,
+  WorktreeProjectGateway,
+  WorktreeServices,
+} from '@/shared/types.js';
+import { AppError } from '@/shared/utils.js';
+import { createWorktree } from '@/modules/worktrees/services/worktree-create.service.js';
+import { createAndOpenWorktree } from '@/modules/worktrees/services/worktree-create-and-open.service.js';
+import { runGitCommand } from '@/modules/worktrees/services/worktree-git.service.js';
+import { listWorktrees } from '@/modules/worktrees/services/worktree-list.service.js';
+import { mergeWorktree } from '@/modules/worktrees/services/worktree-merge.service.js';
+import { openWorktreeAsProject } from '@/modules/worktrees/services/worktree-open.service.js';
+import { removeWorktree } from '@/modules/worktrees/services/worktree-remove.service.js';
+import { createWorktreesRouter } from '@/modules/worktrees/worktrees.routes.js';
+
+/**
+ * Real filesystem adapter used only by Worktrees production composition.
+ *
+ * Services depend on the shared capability type and therefore cannot touch a
+ * developer's filesystem unless this adapter is explicitly supplied.
+ */
+const worktreeFileSystem: WorktreeFileSystem = {
+  async pathExists(candidatePath: string): Promise<boolean> {
+    try {
+      await access(candidatePath);
+      return true;
+    } catch {
+      return false;
+    }
+  },
+};
+
+/**
+ * Projects boundary for Worktrees production workflows.
+ *
+ * Imports are deliberately restricted to the Database and Projects barrel
+ * files. No Worktrees service knows which repository or project service backs
+ * these operations.
+ */
+const worktreeProjects: WorktreeProjectGateway = {
+  getProjectPathById: (projectId) => projectsDb.getProjectPathById(projectId),
+  getProjectByPath: (projectPath) => projectsDb.getProjectPath(projectPath),
+  createProject: (input) => createProject(input),
+  restoreProject: (projectId) => restoreArchivedProject(projectId),
+  archiveProject: (projectId) => deleteOrArchiveProject(projectId, false),
+};
+
+const remove: WorktreeServices['remove'] = (input) => removeWorktree(input, {
+  runGit: runGitCommand,
+  projects: worktreeProjects,
+});
+
+const create: WorktreeServices['create'] = (input) => createWorktree(input, {
+  runGit: runGitCommand,
+  fileSystem: worktreeFileSystem,
+});
+
+const open: WorktreeServices['open'] = (input) => openWorktreeAsProject(input, {
+  runGit: runGitCommand,
+  projects: worktreeProjects,
+});
+
+/**
+ * Production Worktrees application-service surface.
+ *
+ * This is the module's composition root: it is the only location that combines
+ * concrete adapters with the independently testable workflow functions.
+ */
+const worktreeServices: WorktreeServices = {
+  resolveProjectPath(projectId) {
+    const projectPath = worktreeProjects.getProjectPathById(projectId);
+    if (!projectPath) {
+      throw new AppError(`Unable to resolve project path for "${projectId}"`, {
+        code: 'PROJECT_NOT_FOUND',
+        statusCode: 404,
+      });
+    }
+
+    return projectPath;
+  },
+  list: (input) => listWorktrees(input, {
+    runGit: runGitCommand,
+    getProjectByPath: worktreeProjects.getProjectByPath,
+  }),
+  create,
+  createAndOpen: (input) => createAndOpenWorktree(input, {
+    createWorktree: create,
+    openWorktree: open,
+    removeWorktree: remove,
+  }),
+  open,
+  merge: (input) => mergeWorktree(input, {
+    runGit: runGitCommand,
+    removeWorktree: remove,
+  }),
+  remove,
+};
+
+/**
+ * Worktrees router mounted by the server entrypoint at `/api/worktrees`.
+ *
+ * It is assembled here so other modules consume only the Worktrees barrel and
+ * cannot depend on route or service implementation files.
+ */
+export const worktreesRoutes = createWorktreesRouter(worktreeServices);