wind-agent-cli 1.37.2 → 1.38.0

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

@@ -1,143 +1,143 @@
-import type {
-  GitCommandRunner,
-  ListWorktreesInput,
-  ProjectRepositoryRow,
-  WorktreeDescriptor,
-  WorktreeListResult,
-  WorktreePorcelainEntry,
-} from '@/shared/types.js';
-import { normalizeProjectPath } from '@/shared/utils.js';
-import {
-  countChangedFiles,
-  listWorktreePorcelainEntries,
-} from '@/modules/worktrees/services/worktree-git.service.js';
-
-type ListWorktreesDependencies = {
-  runGit: GitCommandRunner;
-  getProjectByPath: (projectPath: string) => ProjectRepositoryRow | null;
-};
-
-const WORKTREE_LIST_CONCURRENCY = 4;
-
-async function mapWithConcurrency<TInput, TOutput>(
-  inputs: TInput[],
-  concurrency: number,
-  mapper: (input: TInput, index: number) => Promise<TOutput>,
-): Promise<TOutput[]> {
-  const results = new Array<TOutput>(inputs.length);
-  let nextIndex = 0;
-
-  async function worker(): Promise<void> {
-    while (nextIndex < inputs.length) {
-      const index = nextIndex;
-      nextIndex += 1;
-      results[index] = await mapper(inputs[index], index);
-    }
-  }
-
-  await Promise.all(
-    Array.from({ length: Math.min(concurrency, inputs.length) }, () => worker()),
-  );
-  return results;
-}
-
-/**
- * Computes how many commits `branch` is ahead/behind `baseBranch`. Runs in the
- * main worktree so both refs are resolvable regardless of which worktree has
- * them checked out. Returns zeros when the comparison is impossible (same
- * branch, detached HEAD, unborn refs).
- */
-async function countAheadBehind(
-  repositoryRoot: string,
-  baseBranch: string | null,
-  branch: string | null,
-  runGit: GitCommandRunner,
-): Promise<{ ahead: number; behind: number }> {
-  if (!baseBranch || !branch || baseBranch === branch) {
-    return { ahead: 0, behind: 0 };
-  }
-
-  try {
-    const { stdout } = await runGit(
-      ['rev-list', '--left-right', '--count', `${baseBranch}...${branch}`],
-      repositoryRoot,
-    );
-    const [behindRaw, aheadRaw] = stdout.trim().split(/\s+/);
-    return {
-      ahead: Number.parseInt(aheadRaw ?? '0', 10) || 0,
-      behind: Number.parseInt(behindRaw ?? '0', 10) || 0,
-    };
-  } catch {
-    return { ahead: 0, behind: 0 };
-  }
-}
-
-/** Reads the last commit subject + ISO date of a worktree's HEAD (null on unborn branches). */
-async function readLastCommit(
-  worktreePath: string,
-  runGit: GitCommandRunner,
-): Promise<{ subject: string | null; date: string | null }> {
-  try {
-    const { stdout } = await runGit(['log', '-1', '--format=%s%x00%cI'], worktreePath);
-    const [subject, date] = stdout.trim().split('\0');
-    return { subject: subject || null, date: date || null };
-  } catch {
-    return { subject: null, date: null };
-  }
-}
-
-/**
- * Builds the full Worktrees panel payload for the repository containing
- * `projectPath`: every worktree with dirty count, ahead/behind vs the base
- * branch, last commit info, and the linked CloudCLI project (when registered).
- */
-export async function listWorktrees(
-  input: ListWorktreesInput,
-  dependencies: ListWorktreesDependencies,
-): Promise<WorktreeListResult> {
-  const { runGit, getProjectByPath } = dependencies;
-  const entries = await listWorktreePorcelainEntries(input.projectPath, runGit);
-
-  // The first porcelain entry is always the main worktree; its checked-out
-  // branch is the merge target ("base branch") offered by the UI.
-  const mainEntry = entries[0];
-  const repositoryRoot = mainEntry.path;
-  const baseBranch = mainEntry.branch;
-
-  const requestedPath = normalizeProjectPath(input.projectPath);
-  const comparable = (value: string) =>
-    process.platform === 'win32' ? value.toLowerCase() : value;
-
-  const worktrees = await mapWithConcurrency(
-    entries,
-    WORKTREE_LIST_CONCURRENCY,
-    async (entry: WorktreePorcelainEntry, index: number): Promise<WorktreeDescriptor> => {
-      const [changedFileCount, aheadBehind, lastCommit] = await Promise.all([
-        countChangedFiles(entry.path, runGit),
-        countAheadBehind(repositoryRoot, baseBranch, index === 0 ? null : entry.branch, runGit),
-        readLastCommit(entry.path, runGit),
-      ]);
-
-      const linkedProject = getProjectByPath(entry.path);
-
-      return {
-        path: entry.path,
-        branch: entry.branch,
-        headSha: entry.headSha,
-        isMain: index === 0,
-        isCurrent: comparable(entry.path) === comparable(requestedPath),
-        isLocked: entry.isLocked,
-        isDetached: entry.isDetached,
-        changedFileCount,
-        ahead: aheadBehind.ahead,
-        behind: aheadBehind.behind,
-        lastCommitSubject: lastCommit.subject,
-        lastCommitDate: lastCommit.date,
-        linkedProjectId: linkedProject?.project_id ?? null,
-        linkedProjectArchived: Boolean(linkedProject?.isArchived),
-      };
-    },
-  );
-
-  return { repositoryRoot, baseBranch, worktrees };
-}
+import type {
+  GitCommandRunner,
+  ListWorktreesInput,
+  ProjectRepositoryRow,
+  WorktreeDescriptor,
+  WorktreeListResult,
+  WorktreePorcelainEntry,
+} from '@/shared/types.js';
+import { normalizeProjectPath } from '@/shared/utils.js';
+import {
+  countChangedFiles,
+  listWorktreePorcelainEntries,
+} from '@/modules/worktrees/services/worktree-git.service.js';
+
+type ListWorktreesDependencies = {
+  runGit: GitCommandRunner;
+  getProjectByPath: (projectPath: string) => ProjectRepositoryRow | null;
+};
+
+const WORKTREE_LIST_CONCURRENCY = 4;
+
+async function mapWithConcurrency<TInput, TOutput>(
+  inputs: TInput[],
+  concurrency: number,
+  mapper: (input: TInput, index: number) => Promise<TOutput>,
+): Promise<TOutput[]> {
+  const results = new Array<TOutput>(inputs.length);
+  let nextIndex = 0;
+
+  async function worker(): Promise<void> {
+    while (nextIndex < inputs.length) {
+      const index = nextIndex;
+      nextIndex += 1;
+      results[index] = await mapper(inputs[index], index);
+    }
+  }
+
+  await Promise.all(
+    Array.from({ length: Math.min(concurrency, inputs.length) }, () => worker()),
+  );
+  return results;
+}
+
+/**
+ * Computes how many commits `branch` is ahead/behind `baseBranch`. Runs in the
+ * main worktree so both refs are resolvable regardless of which worktree has
+ * them checked out. Returns zeros when the comparison is impossible (same
+ * branch, detached HEAD, unborn refs).
+ */
+async function countAheadBehind(
+  repositoryRoot: string,
+  baseBranch: string | null,
+  branch: string | null,
+  runGit: GitCommandRunner,
+): Promise<{ ahead: number; behind: number }> {
+  if (!baseBranch || !branch || baseBranch === branch) {
+    return { ahead: 0, behind: 0 };
+  }
+
+  try {
+    const { stdout } = await runGit(
+      ['rev-list', '--left-right', '--count', `${baseBranch}...${branch}`],
+      repositoryRoot,
+    );
+    const [behindRaw, aheadRaw] = stdout.trim().split(/\s+/);
+    return {
+      ahead: Number.parseInt(aheadRaw ?? '0', 10) || 0,
+      behind: Number.parseInt(behindRaw ?? '0', 10) || 0,
+    };
+  } catch {
+    return { ahead: 0, behind: 0 };
+  }
+}
+
+/** Reads the last commit subject + ISO date of a worktree's HEAD (null on unborn branches). */
+async function readLastCommit(
+  worktreePath: string,
+  runGit: GitCommandRunner,
+): Promise<{ subject: string | null; date: string | null }> {
+  try {
+    const { stdout } = await runGit(['log', '-1', '--format=%s%x00%cI'], worktreePath);
+    const [subject, date] = stdout.trim().split('\0');
+    return { subject: subject || null, date: date || null };
+  } catch {
+    return { subject: null, date: null };
+  }
+}
+
+/**
+ * Builds the full Worktrees panel payload for the repository containing
+ * `projectPath`: every worktree with dirty count, ahead/behind vs the base
+ * branch, last commit info, and the linked WindCli project (when registered).
+ */
+export async function listWorktrees(
+  input: ListWorktreesInput,
+  dependencies: ListWorktreesDependencies,
+): Promise<WorktreeListResult> {
+  const { runGit, getProjectByPath } = dependencies;
+  const entries = await listWorktreePorcelainEntries(input.projectPath, runGit);
+
+  // The first porcelain entry is always the main worktree; its checked-out
+  // branch is the merge target ("base branch") offered by the UI.
+  const mainEntry = entries[0];
+  const repositoryRoot = mainEntry.path;
+  const baseBranch = mainEntry.branch;
+
+  const requestedPath = normalizeProjectPath(input.projectPath);
+  const comparable = (value: string) =>
+    process.platform === 'win32' ? value.toLowerCase() : value;
+
+  const worktrees = await mapWithConcurrency(
+    entries,
+    WORKTREE_LIST_CONCURRENCY,
+    async (entry: WorktreePorcelainEntry, index: number): Promise<WorktreeDescriptor> => {
+      const [changedFileCount, aheadBehind, lastCommit] = await Promise.all([
+        countChangedFiles(entry.path, runGit),
+        countAheadBehind(repositoryRoot, baseBranch, index === 0 ? null : entry.branch, runGit),
+        readLastCommit(entry.path, runGit),
+      ]);
+
+      const linkedProject = getProjectByPath(entry.path);
+
+      return {
+        path: entry.path,
+        branch: entry.branch,
+        headSha: entry.headSha,
+        isMain: index === 0,
+        isCurrent: comparable(entry.path) === comparable(requestedPath),
+        isLocked: entry.isLocked,
+        isDetached: entry.isDetached,
+        changedFileCount,
+        ahead: aheadBehind.ahead,
+        behind: aheadBehind.behind,
+        lastCommitSubject: lastCommit.subject,
+        lastCommitDate: lastCommit.date,
+        linkedProjectId: linkedProject?.project_id ?? null,
+        linkedProjectArchived: Boolean(linkedProject?.isArchived),
+      };
+    },
+  );
+
+  return { repositoryRoot, baseBranch, worktrees };
+}

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

@@ -1,157 +1,157 @@
-import type {
-  GitCommandRunner,
-  MergeWorktreeInput,
-  MergeWorktreeResult,
-  RemoveWorktreeInput,
-  RemoveWorktreeResult,
-} from '@/shared/types.js';
-import { AppError } from '@/shared/utils.js';
-import {
-  countChangedFiles,
-  findWorktreeEntryByPath,
-  listWorktreePorcelainEntries,
-} from '@/modules/worktrees/services/worktree-git.service.js';
-
-/** Reads the paths currently in conflict inside the main worktree (best effort). */
-async function readConflictedFiles(repositoryRoot: string, runGit: GitCommandRunner): Promise<string[]> {
-  try {
-    const { stdout } = await runGit(['diff', '--name-only', '--diff-filter=U'], repositoryRoot);
-    return stdout.split('\n').filter((line) => line.trim().length > 0);
-  } catch {
-    return [];
-  }
-}
-
-/**
- * Merges a worktree's branch back into the base branch (the branch checked out
- * in the main worktree). Runs entirely inside the main worktree, so the user's
- * current worktree never changes underneath them.
- *
- * Both worktrees must be clean: the source so no work is silently left behind,
- * the target so a conflict can be rolled back without touching user changes.
- * On conflict the merge is fully aborted and the conflicting paths are
- * reported back to the client.
- */
-export async function mergeWorktree(
-  input: MergeWorktreeInput,
-  dependencies: {
-    runGit: GitCommandRunner;
-    removeWorktree: (input: RemoveWorktreeInput) => Promise<RemoveWorktreeResult>;
-  },
-): Promise<MergeWorktreeResult> {
-  const { removeWorktree, runGit } = dependencies;
-  const entries = await listWorktreePorcelainEntries(input.projectPath, runGit);
-  const entry = findWorktreeEntryByPath(entries, input.worktreePath);
-  const repositoryRoot = entries[0].path;
-  const targetBranch = entries[0].branch;
-
-  if (entry.path === repositoryRoot) {
-    throw new AppError('The main worktree cannot be merged into itself', {
-      code: 'WORKTREE_MERGE_MAIN',
-      statusCode: 400,
-    });
-  }
-
-  if (!entry.branch) {
-    throw new AppError('Worktree is on a detached HEAD — check out a branch first', {
-      code: 'WORKTREE_DETACHED_HEAD',
-      statusCode: 400,
-    });
-  }
-
-  if (!targetBranch) {
-    throw new AppError('The main worktree is on a detached HEAD — cannot determine merge target', {
-      code: 'WORKTREE_TARGET_DETACHED',
-      statusCode: 400,
-    });
-  }
-
-  const sourceChangedCount = await countChangedFiles(entry.path, runGit);
-  if (sourceChangedCount > 0) {
-    throw new AppError(
-      `Worktree has ${sourceChangedCount} uncommitted change${sourceChangedCount === 1 ? '' : 's'} — commit or discard them first`,
-      { code: 'WORKTREE_SOURCE_DIRTY', statusCode: 409 },
-    );
-  }
-
-  const targetChangedCount = await countChangedFiles(repositoryRoot, runGit);
-  if (targetChangedCount > 0) {
-    throw new AppError(
-      `The base worktree (${targetBranch}) has uncommitted changes — commit or stash them first`,
-      { code: 'WORKTREE_TARGET_DIRTY', statusCode: 409 },
-    );
-  }
-
-  const squash = Boolean(input.squash);
-  const message =
-    input.message?.trim() ||
-    (squash ? `Squash merge branch '${entry.branch}'` : `Merge branch '${entry.branch}'`);
-
-  try {
-    if (squash) {
-      await runGit(['merge', '--squash', entry.branch], repositoryRoot);
-      await runGit(['commit', '-m', message], repositoryRoot);
-    } else {
-      await runGit(['merge', '--no-ff', entry.branch, '-m', message], repositoryRoot);
-    }
-  } catch (error) {
-    const conflictedFiles = await readConflictedFiles(repositoryRoot, runGit);
-    // Roll the main worktree back to its pre-merge state. `--merge` also
-    // clears a half-applied squash since the target was verified clean above.
-    try {
-      await runGit(['reset', '--merge'], repositoryRoot);
-    } catch (rollbackError) {
-      throw new AppError(
-        `Merge of '${entry.branch}' into '${targetBranch}' failed and could not be rolled back`,
-        {
-          code: 'WORKTREE_MERGE_ROLLBACK_FAILED',
-          statusCode: 500,
-          details: {
-            mergeError: error instanceof Error ? error.message : String(error),
-            rollbackError: rollbackError instanceof AppError
-              ? rollbackError.details ?? rollbackError.message
-              : rollbackError instanceof Error ? rollbackError.message : String(rollbackError),
-          },
-        },
-      );
-    }
-
-    if (conflictedFiles.length > 0) {
-      throw new AppError(
-        `Merge of '${entry.branch}' into '${targetBranch}' has conflicts — the merge was aborted`,
-        {
-          code: 'WORKTREE_MERGE_CONFLICT',
-          statusCode: 409,
-          details: conflictedFiles,
-        },
-      );
-    }
-
-    throw error;
-  }
-
-  let removedWorktree: RemoveWorktreeResult | null = null;
-  let cleanupError: string | null = null;
-  if (input.removeAfterMerge) {
-    try {
-      removedWorktree = await removeWorktree(
-        {
-          projectPath: repositoryRoot,
-          worktreePath: entry.path,
-          force: false,
-          deleteBranch: true,
-        },
-      );
-    } catch (error) {
-      cleanupError = error instanceof Error ? error.message : String(error);
-    }
-  }
-
-  return {
-    mergedBranch: entry.branch,
-    targetBranch,
-    squash,
-    removedWorktree,
-    cleanupError,
-  };
-}
+import type {
+  GitCommandRunner,
+  MergeWorktreeInput,
+  MergeWorktreeResult,
+  RemoveWorktreeInput,
+  RemoveWorktreeResult,
+} from '@/shared/types.js';
+import { AppError } from '@/shared/utils.js';
+import {
+  countChangedFiles,
+  findWorktreeEntryByPath,
+  listWorktreePorcelainEntries,
+} from '@/modules/worktrees/services/worktree-git.service.js';
+
+/** Reads the paths currently in conflict inside the main worktree (best effort). */
+async function readConflictedFiles(repositoryRoot: string, runGit: GitCommandRunner): Promise<string[]> {
+  try {
+    const { stdout } = await runGit(['diff', '--name-only', '--diff-filter=U'], repositoryRoot);
+    return stdout.split('\n').filter((line) => line.trim().length > 0);
+  } catch {
+    return [];
+  }
+}
+
+/**
+ * Merges a worktree's branch back into the base branch (the branch checked out
+ * in the main worktree). Runs entirely inside the main worktree, so the user's
+ * current worktree never changes underneath them.
+ *
+ * Both worktrees must be clean: the source so no work is silently left behind,
+ * the target so a conflict can be rolled back without touching user changes.
+ * On conflict the merge is fully aborted and the conflicting paths are
+ * reported back to the client.
+ */
+export async function mergeWorktree(
+  input: MergeWorktreeInput,
+  dependencies: {
+    runGit: GitCommandRunner;
+    removeWorktree: (input: RemoveWorktreeInput) => Promise<RemoveWorktreeResult>;
+  },
+): Promise<MergeWorktreeResult> {
+  const { removeWorktree, runGit } = dependencies;
+  const entries = await listWorktreePorcelainEntries(input.projectPath, runGit);
+  const entry = findWorktreeEntryByPath(entries, input.worktreePath);
+  const repositoryRoot = entries[0].path;
+  const targetBranch = entries[0].branch;
+
+  if (entry.path === repositoryRoot) {
+    throw new AppError('The main worktree cannot be merged into itself', {
+      code: 'WORKTREE_MERGE_MAIN',
+      statusCode: 400,
+    });
+  }
+
+  if (!entry.branch) {
+    throw new AppError('Worktree is on a detached HEAD — check out a branch first', {
+      code: 'WORKTREE_DETACHED_HEAD',
+      statusCode: 400,
+    });
+  }
+
+  if (!targetBranch) {
+    throw new AppError('The main worktree is on a detached HEAD — cannot determine merge target', {
+      code: 'WORKTREE_TARGET_DETACHED',
+      statusCode: 400,
+    });
+  }
+
+  const sourceChangedCount = await countChangedFiles(entry.path, runGit);
+  if (sourceChangedCount > 0) {
+    throw new AppError(
+      `Worktree has ${sourceChangedCount} uncommitted change${sourceChangedCount === 1 ? '' : 's'} — commit or discard them first`,
+      { code: 'WORKTREE_SOURCE_DIRTY', statusCode: 409 },
+    );
+  }
+
+  const targetChangedCount = await countChangedFiles(repositoryRoot, runGit);
+  if (targetChangedCount > 0) {
+    throw new AppError(
+      `The base worktree (${targetBranch}) has uncommitted changes — commit or stash them first`,
+      { code: 'WORKTREE_TARGET_DIRTY', statusCode: 409 },
+    );
+  }
+
+  const squash = Boolean(input.squash);
+  const message =
+    input.message?.trim() ||
+    (squash ? `Squash merge branch '${entry.branch}'` : `Merge branch '${entry.branch}'`);
+
+  try {
+    if (squash) {
+      await runGit(['merge', '--squash', entry.branch], repositoryRoot);
+      await runGit(['commit', '-m', message], repositoryRoot);
+    } else {
+      await runGit(['merge', '--no-ff', entry.branch, '-m', message], repositoryRoot);
+    }
+  } catch (error) {
+    const conflictedFiles = await readConflictedFiles(repositoryRoot, runGit);
+    // Roll the main worktree back to its pre-merge state. `--merge` also
+    // clears a half-applied squash since the target was verified clean above.
+    try {
+      await runGit(['reset', '--merge'], repositoryRoot);
+    } catch (rollbackError) {
+      throw new AppError(
+        `Merge of '${entry.branch}' into '${targetBranch}' failed and could not be rolled back`,
+        {
+          code: 'WORKTREE_MERGE_ROLLBACK_FAILED',
+          statusCode: 500,
+          details: {
+            mergeError: error instanceof Error ? error.message : String(error),
+            rollbackError: rollbackError instanceof AppError
+              ? rollbackError.details ?? rollbackError.message
+              : rollbackError instanceof Error ? rollbackError.message : String(rollbackError),
+          },
+        },
+      );
+    }
+
+    if (conflictedFiles.length > 0) {
+      throw new AppError(
+        `Merge of '${entry.branch}' into '${targetBranch}' has conflicts — the merge was aborted`,
+        {
+          code: 'WORKTREE_MERGE_CONFLICT',
+          statusCode: 409,
+          details: conflictedFiles,
+        },
+      );
+    }
+
+    throw error;
+  }
+
+  let removedWorktree: RemoveWorktreeResult | null = null;
+  let cleanupError: string | null = null;
+  if (input.removeAfterMerge) {
+    try {
+      removedWorktree = await removeWorktree(
+        {
+          projectPath: repositoryRoot,
+          worktreePath: entry.path,
+          force: false,
+          deleteBranch: true,
+        },
+      );
+    } catch (error) {
+      cleanupError = error instanceof Error ? error.message : String(error);
+    }
+  }
+
+  return {
+    mergedBranch: entry.branch,
+    targetBranch,
+    squash,
+    removedWorktree,
+    cleanupError,
+  };
+}