sync-worktrees 3.1.0 → 3.2.0

package/dist/mcp-server.js

@@ -803,6 +803,43 @@ import * as fs4 from "fs/promises";
 import * as path4 from "path";
 import simpleGit3 from "simple-git";
 
+// src/errors/index.ts
+var SyncWorktreesError = class extends Error {
+  constructor(message, code, cause) {
+    super(message);
+    this.code = code;
+    this.cause = cause;
+    this.name = this.constructor.name;
+    Object.setPrototypeOf(this, new.target.prototype);
+    if (cause && cause.stack) {
+      this.stack = `${this.stack}
+Caused by: ${cause.stack}`;
+    }
+  }
+};
+var GitError = class extends SyncWorktreesError {
+  constructor(message, code, cause) {
+    super(message, `GIT_${code}`, cause);
+  }
+};
+var GitOperationError = class extends GitError {
+  constructor(operation, details, cause) {
+    super(`Git operation '${operation}' failed: ${details}`, "OPERATION_FAILED", cause);
+  }
+};
+var WorktreeError = class extends SyncWorktreesError {
+  constructor(message, code, cause) {
+    super(message, `WORKTREE_${code}`, cause);
+  }
+};
+var WorktreeNotCleanError = class extends WorktreeError {
+  constructor(path10, reasons) {
+    super(`Worktree at '${path10}' is not clean: ${reasons.join(", ")}`, "NOT_CLEAN");
+    this.path = path10;
+    this.reasons = reasons;
+  }
+};
+
 // src/utils/git-url.ts
 function extractRepoNameFromUrl(gitUrl) {
   const url = gitUrl.trim();
@@ -1101,45 +1138,6 @@ var WorktreeMetadataService = class {
 import * as fs3 from "fs/promises";
 import * as path3 from "path";
 import simpleGit2 from "simple-git";
-
-// src/errors/index.ts
-var SyncWorktreesError = class extends Error {
-  constructor(message, code, cause) {
-    super(message);
-    this.code = code;
-    this.cause = cause;
-    this.name = this.constructor.name;
-    Object.setPrototypeOf(this, new.target.prototype);
-    if (cause && cause.stack) {
-      this.stack = `${this.stack}
-Caused by: ${cause.stack}`;
-    }
-  }
-};
-var GitError = class extends SyncWorktreesError {
-  constructor(message, code, cause) {
-    super(message, `GIT_${code}`, cause);
-  }
-};
-var GitOperationError = class extends GitError {
-  constructor(operation, details, cause) {
-    super(`Git operation '${operation}' failed: ${details}`, "OPERATION_FAILED", cause);
-  }
-};
-var WorktreeError = class extends SyncWorktreesError {
-  constructor(message, code, cause) {
-    super(message, `WORKTREE_${code}`, cause);
-  }
-};
-var WorktreeNotCleanError = class extends WorktreeError {
-  constructor(path10, reasons) {
-    super(`Worktree at '${path10}' is not clean: ${reasons.join(", ")}`, "NOT_CLEAN");
-    this.path = path10;
-    this.reasons = reasons;
-  }
-};
-
-// src/services/worktree-status.service.ts
 var OPERATION_FILES = [
   { file: GIT_OPERATIONS.MERGE_HEAD, type: "merge" },
   { file: GIT_OPERATIONS.CHERRY_PICK_HEAD, type: "cherry-pick" },
@@ -1755,24 +1753,19 @@ var GitService = class {
     } catch {
     }
     try {
-      const branches = await bareGit.branch();
-      const localBranchExists = branches.all.includes(branchName);
-      if (localBranchExists || branchName.includes("/")) {
-        await bareGit.raw(["worktree", "add", absoluteWorktreePath, branchName]);
-        const worktreeGit = this.getCachedGit(absoluteWorktreePath, this.isLfsSkipEnabled());
-        await worktreeGit.branch(["--set-upstream-to", `origin/${branchName}`, branchName]);
+      const { local: localBranchExists, remote: remoteBranchExists } = await this.branchExists(branchName);
+      await this.runWorktreeAddByMatrix(
+        bareGit,
+        branchName,
+        absoluteWorktreePath,
+        localBranchExists,
+        remoteBranchExists
+      );
+      if (localBranchExists && !remoteBranchExists) {
+        this.logger.info(`  - Created worktree for '${branchName}' (no remote yet \u2014 push to set upstream)`);
       } else {
-        await bareGit.raw([
-          "worktree",
-          "add",
-          "--track",
-          "-b",
-          branchName,
-          absoluteWorktreePath,
-          `origin/${branchName}`
-        ]);
+        this.logger.info(`  - Created worktree for '${branchName}' with tracking to origin/${branchName}`);
       }
-      this.logger.info(`  - Created worktree for '${branchName}' with tracking to origin/${branchName}`);
       if (!this.isLfsSkipEnabled()) {
         await this.verifyLfsFilesDownloaded(absoluteWorktreePath, branchName);
       }
@@ -1788,6 +1781,9 @@ var GitService = class {
       }
     } catch (error) {
       const errorMessage = getErrorMessage(error);
+      if (error?.isUpstreamSetupFailure) {
+        throw error;
+      }
       if (errorMessage.includes("Metadata creation failed")) {
         throw error;
       }
@@ -1805,15 +1801,14 @@ var GitService = class {
         } catch {
         }
         try {
-          await bareGit.raw([
-            "worktree",
-            "add",
-            "--track",
-            "-b",
+          const { local: localBranchExists, remote: remoteBranchExists } = await this.branchExists(branchName);
+          await this.runWorktreeAddByMatrix(
+            bareGit,
             branchName,
             absoluteWorktreePath,
-            `origin/${branchName}`
-          ]);
+            localBranchExists,
+            remoteBranchExists
+          );
           this.logger.info(`  - Created worktree for '${branchName}' after pruning`);
           if (!this.isLfsSkipEnabled()) {
             await this.verifyLfsFilesDownloaded(absoluteWorktreePath, branchName);
@@ -1882,6 +1877,43 @@ var GitService = class {
       }
     }
   }
+  async runWorktreeAddByMatrix(bareGit, branchName, absoluteWorktreePath, localExists, remoteExists) {
+    if (localExists && remoteExists) {
+      await bareGit.raw(["worktree", "add", absoluteWorktreePath, branchName]);
+      try {
+        const worktreeGit = this.getCachedGit(absoluteWorktreePath, this.isLfsSkipEnabled());
+        await worktreeGit.branch(["--set-upstream-to", `origin/${branchName}`, branchName]);
+      } catch (error) {
+        let rollbackFailed = false;
+        try {
+          await bareGit.raw(["worktree", "remove", "--force", absoluteWorktreePath]);
+        } catch (rollbackError) {
+          rollbackFailed = true;
+          this.logger.warn(
+            `  - Rollback failed for '${branchName}' at '${absoluteWorktreePath}' after upstream setup error: ${getErrorMessage(rollbackError)}`
+          );
+        }
+        const detail = getErrorMessage(error);
+        const suffix = rollbackFailed ? " (rollback failed; partial worktree may remain)" : "";
+        const wrapped = new Error(`Failed to set upstream for '${branchName}': ${detail}${suffix}`);
+        wrapped.isUpstreamSetupFailure = true;
+        throw wrapped;
+      }
+      return;
+    }
+    if (localExists) {
+      await bareGit.raw(["worktree", "add", absoluteWorktreePath, branchName]);
+      return;
+    }
+    if (remoteExists) {
+      await bareGit.raw(["worktree", "add", "--track", "-b", branchName, absoluteWorktreePath, `origin/${branchName}`]);
+      return;
+    }
+    throw new WorktreeError(
+      `Branch '${branchName}' does not exist locally or on origin; create it first`,
+      "BRANCH_NOT_FOUND"
+    );
+  }
   async removeWorktree(worktreePath) {
     const bareGit = this.getCachedGit(this.bareRepoPath);
     await bareGit.raw(["worktree", "remove", worktreePath, "--force"]);
@@ -2075,10 +2107,18 @@ var GitService = class {
   }
   async branchExists(branchName) {
     const bareGit = this.getCachedGit(this.bareRepoPath);
-    const localBranches = await bareGit.branch();
-    const local = localBranches.all.includes(branchName);
-    const remoteBranches = await bareGit.branch(["-r"]);
-    const remote = remoteBranches.all.includes(`origin/${branchName}`);
+    const checkRef = async (ref) => {
+      try {
+        await bareGit.raw(["show-ref", "--verify", "--quiet", ref]);
+        return true;
+      } catch {
+        return false;
+      }
+    };
+    const [local, remote] = await Promise.all([
+      checkRef(`${GIT_CONSTANTS.REFS.HEADS}${branchName}`),
+      checkRef(`${GIT_CONSTANTS.REFS.REMOTES}/${branchName}`)
+    ]);
     return { local, remote };
   }
   async getLocalBranches() {
@@ -3730,14 +3770,26 @@ function attachProgressReporter(service, extra) {
 var REPO_NAME_DESCRIBE = "Repository name from loaded config. If omitted, uses the current repository set via set_current_repository or the only loaded repo.";
 var PATH_DESCRIBE_SUFFIX = "Absolute path preferred; relative paths resolve from the server's CWD.";
 var SERVER_INSTRUCTIONS = "Before running git worktree operations, call `detect_context` to learn the current repo, current branch, sibling repositories under the workspace root, and which capabilities are available. It walks up to auto-discover sync-worktrees.config.{js,mjs,cjs,ts}, lists sibling worktrees, and reports per-capability {available, reason} so you can tell which tool is gated and why.";
-function createServer(context) {
+function buildInstructions(snapshot) {
+  const d = snapshot?.discovered;
+  if (!d || !d.isWorktree || d.kind !== "managed") return SERVER_INSTRUCTIONS;
+  const lines = ["Connect-time context (call `detect_context` for live state):"];
+  if (d.kind) lines.push(`- kind: ${d.kind}`);
+  if (d.currentWorktreePath) lines.push(`- currentWorktreePath: ${d.currentWorktreePath}`);
+  if (d.currentBranch) lines.push(`- currentBranch: ${d.currentBranch}`);
+  if (d.configPath) lines.push(`- configPath: ${d.configPath}`);
+  return `${SERVER_INSTRUCTIONS}
+
+${lines.join("\n")}`;
+}
+function createServer(context, snapshot) {
   const server = new McpServer(
     {
       name: "sync-worktrees",
       version: "1.0.0"
     },
     {
-      instructions: SERVER_INSTRUCTIONS
+      instructions: buildInstructions(snapshot)
     }
   );
   server.registerResource(
@@ -3970,8 +4022,9 @@ async function main() {
 `);
     }
   }
+  let discovered = null;
   try {
-    const discovered = await context.detectFromPath(process.cwd());
+    discovered = await context.detectFromPath(process.cwd());
     if (discovered.isWorktree) {
       process.stderr.write(
         `[sync-worktrees-mcp] Auto-detected ${discovered.kind} worktree at ${discovered.currentWorktreePath} (branch: ${discovered.currentBranch})
@@ -3982,7 +4035,7 @@ async function main() {
     process.stderr.write(`[sync-worktrees-mcp] Auto-detect failed: ${err.message}
 `);
   }
-  const server = createServer(context);
+  const server = createServer(context, { discovered });
   const transport = new StdioServerTransport();
   await server.connect(transport);
 }