git-worktree-organize 1.0.11 → 1.0.13

package/dist/cli.js

@@ -113,7 +113,7 @@ async function listWorktrees(repoPath) {
 }
 
 // src/migrate.ts
-import { mkdirSync, writeFileSync, readFileSync as readFileSync2, existsSync as existsSync2, renameSync, statSync as statSync2 } from "node:fs";
+import { mkdirSync, writeFileSync, readFileSync as readFileSync2, existsSync as existsSync2, renameSync, statSync as statSync2, readdirSync } from "node:fs";
 import { join as join2, dirname, basename, resolve as resolve2 } from "node:path";
 
 // src/git.ts
@@ -144,27 +144,88 @@ async function moveDir(src, dest) {
 function sanitizeBranch(branch) {
   return branch.replace(/\//g, "-");
 }
+function resolveWorktreePath(worktreePath, dest, sourceParent) {
+  if (existsSync2(worktreePath))
+    return worktreePath;
+  if (worktreePath.startsWith(dest + "/")) {
+    const remapped = sourceParent + worktreePath.slice(dest.length);
+    if (existsSync2(remapped))
+      return remapped;
+  }
+  return worktreePath;
+}
 function isPartialMigration(dest) {
   const gitFile = join2(dest, ".git");
   return existsSync2(join2(dest, ".bare")) && existsSync2(gitFile) && statSync2(gitFile).isFile();
 }
+function findHub(startPath) {
+  let current = resolve2(startPath);
+  while (true) {
+    if (isPartialMigration(current))
+      return current;
+    const parent = dirname(current);
+    if (parent === current)
+      return null;
+    current = parent;
+  }
+}
+async function repairHub(dest, log = console.log) {
+  const adminBase = join2(dest, ".bare", "worktrees");
+  if (!existsSync2(adminBase))
+    return;
+  for (const adminName of readdirSync(adminBase)) {
+    const adminDir = join2(adminBase, adminName);
+    if (!statSync2(adminDir).isDirectory())
+      continue;
+    const gitdirFile = join2(adminDir, "gitdir");
+    if (!existsSync2(gitdirFile))
+      continue;
+    const registeredGitFile = readFileSync2(gitdirFile, "utf8").trim();
+    const worktreePath = dirname(registeredGitFile);
+    if (!worktreePath.startsWith(dest + "/"))
+      continue;
+    if (!existsSync2(registeredGitFile) || !statSync2(registeredGitFile).isFile())
+      continue;
+    const content = readFileSync2(registeredGitFile, "utf8");
+    const match = content.match(/^gitdir:\s*(.+)/m);
+    if (!match)
+      continue;
+    if (match[1].trim() === adminDir)
+      continue;
+    log(`Repairing .git for [${basename(worktreePath)}]`);
+    writeFileSync(registeredGitFile, `gitdir: ${adminDir}
+`);
+  }
+}
 async function resumeMigrate(dest, log = console.log) {
   const destBare = join2(dest, ".bare");
   const hubWorktrees = await listWorktrees(dest);
-  const pending = hubWorktrees.filter((wt) => !wt.isBare && !wt.path.startsWith(dest + "/"));
+  const pending = hubWorktrees.filter((wt) => {
+    if (wt.isBare)
+      return false;
+    const branch = wt.branch ?? `detached-${wt.head.slice(0, 8)}`;
+    return wt.path !== join2(dest, sanitizeBranch(branch));
+  });
   if (pending.length === 0) {
     log("Nothing to resume — all worktrees are already in place.");
-    return dest;
-  }
-  for (const wt of pending) {
-    const branch = wt.branch ?? `detached-${wt.head.slice(0, 8)}`;
-    if (!existsSync2(wt.path)) {
-      log(`warn: Skipping [${branch}] — path no longer exists: ${wt.path}`);
-      continue;
+  } else {
+    for (const wt of pending) {
+      const branch = wt.branch ?? `detached-${wt.head.slice(0, 8)}`;
+      const expectedPath = join2(dest, sanitizeBranch(branch));
+      let wtPath = wt.path;
+      if (!existsSync2(wtPath)) {
+        if (existsSync2(expectedPath)) {
+          wtPath = expectedPath;
+        } else {
+          log(`warn: Skipping [${branch}] — path no longer exists: ${wt.path}`);
+          continue;
+        }
+      }
+      log(`Moving [${branch}] → ${expectedPath}`);
+      await processLinkedWorktree({ ...wt, path: wtPath }, dest, destBare);
     }
-    log(`Moving [${branch}] → ${join2(dest, sanitizeBranch(branch))}`);
-    await processLinkedWorktree(wt, dest, destBare);
   }
+  await repairHub(dest, log);
   return dest;
 }
 async function migrate(config, options) {
@@ -191,6 +252,8 @@ async function migrate(config, options) {
   await setGitConfig("remote.origin.fetch", "+refs/heads/*:refs/remotes/origin/*", { gitdir: destBare });
   writeFileSync(join2(dest, ".git"), `gitdir: ./.bare
 `);
+  const sourceParent = dirname(source);
+  const worktreesResolved = worktrees.map((wt, i) => i === 0 && config.type === "standard" ? wt : { ...wt, path: resolveWorktreePath(wt.path, dest, sourceParent) });
   if (config.type === "standard") {
     const mainBranch = worktrees[0].branch;
     const mainSafe = sanitizeBranch(mainBranch);
@@ -214,11 +277,11 @@ async function migrate(config, options) {
     }
     writeFileSync(join2(mainDest, ".git"), `gitdir: ${mainAdminDir}
 `);
-    for (let i = 1;i < worktrees.length; i++) {
-      await processLinkedWorktree(worktrees[i], dest, destBare);
+    for (let i = 1;i < worktreesResolved.length; i++) {
+      await processLinkedWorktree(worktreesResolved[i], dest, destBare);
     }
   } else {
-    for (const wt of worktrees) {
+    for (const wt of worktreesResolved) {
       await processLinkedWorktree(wt, dest, destBare);
     }
   }
@@ -295,9 +358,39 @@ async function main() {
   const destArg = args[1];
   const source = resolve3(sourcePath);
   const dest = isPartialMigration(source) ? source : destArg ? resolve3(destArg) : join3(dirname2(source), basename2(source) + "-bare");
+  if (!isPartialMigration(source) && !destArg) {
+    const ancestorHub = findHub(dirname2(source));
+    if (ancestorHub) {
+      console.log(`
+${yellow("warn:")} ${bold(source)} is inside an existing hub at ${bold(ancestorHub)}`);
+      console.log(`
+This looks like manually-placed worktrees with stale .git files.`);
+      console.log(`Running repair will fix all worktree .git connections in the hub.
+`);
+      process.stdout.write(`Repair hub at ${ancestorHub}? [y/N] `);
+      const repairAns = await prompt();
+      process.stdin.destroy();
+      if (!/^[Yy]$/.test(repairAns)) {
+        console.log("Aborted.");
+        process.exit(0);
+      }
+      console.log();
+      await repairHub(ancestorHub, (msg) => console.log(`${green("==>")} ${msg}`));
+      console.log();
+      console.log(`${green("==>")} Verifying with git worktree list...`);
+      console.log(run("git", ["-C", ancestorHub, "worktree", "list"]).stdout);
+      console.log(`Done! Hub: ${ancestorHub}`);
+      process.exit(0);
+    }
+  }
   if (isPartialMigration(dest)) {
     const hubWorktrees = await listWorktrees(dest);
-    const pending = hubWorktrees.filter((wt) => !wt.isBare && !wt.path.startsWith(dest + "/"));
+    const pending = hubWorktrees.filter((wt) => {
+      if (wt.isBare)
+        return false;
+      const branch = wt.branch ?? `detached-${wt.head.slice(0, 8)}`;
+      return wt.path !== join3(dest, sanitizeBranch(branch));
+    });
     console.log(`
 ${yellow("warn:")} Partial migration detected at ${bold(dest)}`);
     if (pending.length === 0) {
@@ -332,7 +425,12 @@ ${green("==>")} Reading worktrees from ${source}
 `);
   const config = await detect(source);
   const allWorktrees = await listWorktrees(source);
-  const missing = allWorktrees.filter((wt) => !wt.isBare && !existsSync3(wt.path));
+  const missing = allWorktrees.filter((wt) => {
+    if (wt.isBare)
+      return false;
+    const actual = resolveWorktreePath(wt.path, dest, dirname2(source));
+    return !existsSync3(actual);
+  });
   if (missing.length > 0) {
     console.log(`${yellow("warn:")} The following worktree paths no longer exist:`);
     for (const wt of missing) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "git-worktree-organize",
-  "version": "1.0.11",
+  "version": "1.0.13",
   "description": "Convert any git repo into the canonical bare-hub worktree layout",
   "type": "module",
   "bin": {