sync-worktrees 3.0.1 → 3.2.0

package/dist/index.js

@@ -83,6 +83,11 @@ var PATH_CONSTANTS = {
   GIT_DIR: ".git",
   README: "README"
 };
+var CONFIG_FILE_NAMES = [
+  "sync-worktrees.config.js",
+  "sync-worktrees.config.mjs",
+  "sync-worktrees.config.cjs"
+];
 var METADATA_CONSTANTS = {
   MAX_HISTORY_ENTRIES: 10,
   METADATA_FILENAME: "sync-metadata.json",
@@ -144,6 +149,24 @@ function filterBranchesByName(branches, include, exclude) {
 
 // src/services/config-loader.service.ts
 var ConfigLoaderService = class {
+  async findConfigUpward(startDir) {
+    let current = path.resolve(startDir);
+    const root = path.parse(current).root;
+    while (true) {
+      for (const name of CONFIG_FILE_NAMES) {
+        const candidate = path.join(current, name);
+        try {
+          await fs.access(candidate);
+          return candidate;
+        } catch {
+        }
+      }
+      if (current === root) return null;
+      const parent = path.dirname(current);
+      if (parent === current) return null;
+      current = parent;
+    }
+  }
   async loadConfigFile(configPath) {
     const absolutePath = path.resolve(configPath);
     try {
@@ -1955,6 +1978,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(path12, reasons) {
+    super(`Worktree at '${path12}' is not clean: ${reasons.join(", ")}`, "NOT_CLEAN");
+    this.path = path12;
+    this.reasons = reasons;
+  }
+};
+
 // src/utils/git-url.ts
 function extractRepoNameFromUrl(gitUrl) {
   const url = gitUrl.trim();
@@ -2352,45 +2412,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(path12, reasons) {
-    super(`Worktree at '${path12}' is not clean: ${reasons.join(", ")}`, "NOT_CLEAN");
-    this.path = path12;
-    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" },
@@ -2447,6 +2468,7 @@ var WorktreeStatusService = class {
     if (hasUnpushedCommits) reasons.push("unpushed commits");
     if (hasOperationInProgress) reasons.push("operation in progress");
     if (hasModifiedSubmodules) reasons.push("modified submodules");
+    if (upstreamGone) reasons.push("upstream gone");
     const canRemove = isClean && !hasUnpushedCommits && !hasOperationInProgress && !hasModifiedSubmodules;
     const details = includeDetails ? this.buildStatusDetails(snap) : void 0;
     return {
@@ -3005,24 +3027,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);
       }
@@ -3038,6 +3055,9 @@ var GitService = class {
       }
     } catch (error) {
       const errorMessage = getErrorMessage(error);
+      if (error?.isUpstreamSetupFailure) {
+        throw error;
+      }
       if (errorMessage.includes("Metadata creation failed")) {
         throw error;
       }
@@ -3055,15 +3075,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);
@@ -3132,6 +3151,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"]);
@@ -3325,10 +3381,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() {
@@ -4274,13 +4338,17 @@ var HookExecutionService = class {
 // src/utils/disk-space.ts
 import fastFolderSize from "fast-folder-size";
 async function calculateDirectorySize(dirPath) {
-  return new Promise((resolve8) => {
+  return new Promise((resolve8, reject) => {
     fastFolderSize(dirPath, (err, bytes) => {
-      if (err || bytes === void 0) {
-        resolve8(0);
-      } else {
-        resolve8(bytes);
+      if (err) {
+        reject(err);
+        return;
       }
+      if (bytes === void 0) {
+        reject(new Error(`fast-folder-size returned no bytes for ${dirPath}`));
+        return;
+      }
+      resolve8(bytes);
     });
   });
 }
@@ -4297,12 +4365,16 @@ async function calculateSyncDiskSpace(repoPaths, worktreeDirs) {
   try {
     let totalBytes = 0;
     for (const repoPath of repoPaths) {
-      const bareSize = await calculateDirectorySize(repoPath);
-      totalBytes += bareSize;
+      try {
+        totalBytes += await calculateDirectorySize(repoPath);
+      } catch {
+      }
     }
     for (const worktreeDir of worktreeDirs) {
-      const worktreeSize = await calculateDirectorySize(worktreeDir);
-      totalBytes += worktreeSize;
+      try {
+        totalBytes += await calculateDirectorySize(worktreeDir);
+      } catch {
+      }
     }
     return formatBytes(totalBytes);
   } catch (error) {
@@ -4742,7 +4814,7 @@ var InteractiveUIService = class {
             originalBranch = match[2];
           }
         }
-        const sizeBytes = await calculateDirectorySize(fullPath);
+        const sizeBytes = await calculateDirectorySize(fullPath).catch(() => 0);
         const sizeFormatted = formatBytes(sizeBytes);
         return {
           name: entry.name,
@@ -5219,9 +5291,8 @@ export default ${serializeToESM(configObject)};
 function getDefaultConfigPath() {
   return path9.join(process.cwd(), "sync-worktrees.config.js");
 }
-var CONFIG_CANDIDATES = ["sync-worktrees.config.js", "sync-worktrees.config.mjs", "sync-worktrees.config.cjs"];
 async function findConfigInCwd(cwd = process.cwd()) {
-  for (const name of CONFIG_CANDIDATES) {
+  for (const name of CONFIG_FILE_NAMES) {
     const full = path9.join(cwd, name);
     try {
       await fs9.access(full);