git-worktree-organize 1.0.10 → 1.0.12

package/dist/cli.js

@@ -1,8 +1,8 @@
-#!/usr/bin/env bun
-// @bun
+#!/usr/bin/env node
 
 // src/cli.ts
-import { resolve as resolve3, join as join3, dirname as dirname2, basename as basename2 } from "path";
+import { resolve as resolve3, join as join3, dirname as dirname2, basename as basename2 } from "node:path";
+import { existsSync as existsSync3 } from "node:fs";
 
 // src/run.ts
 import { spawnSync } from "node:child_process";
@@ -24,28 +24,9 @@ function run(cmd, args, options) {
 // src/detect.ts
 import { existsSync, statSync, readFileSync } from "node:fs";
 import { join, resolve, isAbsolute } from "node:path";
-
-// src/run.ts
-import { spawnSync as spawnSync2 } from "node:child_process";
-function run2(cmd, args, options) {
-  const result = spawnSync2(cmd, args, {
-    encoding: "utf8",
-    cwd: options?.cwd,
-    env: options?.env ?? process.env
-  });
-  if (result.status !== 0) {
-    const err = new Error(`${cmd} ${args.join(" ")} failed: ${result.stderr?.trim() || result.error?.message}`);
-    err.exitCode = result.status;
-    err.stderr = result.stderr;
-    throw err;
-  }
-  return { stdout: result.stdout ?? "", stderr: result.stderr ?? "" };
-}
-
-// src/detect.ts
 function readCoreBare(gitdir) {
   try {
-    const result = run2("git", ["--git-dir", gitdir, "config", "--get", "core.bare"]);
+    const result = run("git", ["--git-dir", gitdir, "config", "--get", "core.bare"]);
     return result.stdout.trim() === "true";
   } catch {
     return false;
@@ -127,7 +108,7 @@ function parsePorcelain(output) {
   return worktrees;
 }
 async function listWorktrees(repoPath) {
-  const result = run2("git", ["-C", repoPath, "worktree", "list", "--porcelain"]);
+  const result = run("git", ["-C", repoPath, "worktree", "list", "--porcelain"]);
   return parsePorcelain(result.stdout);
 }
 
@@ -135,46 +116,9 @@ async function listWorktrees(repoPath) {
 import { mkdirSync, writeFileSync, readFileSync as readFileSync2, existsSync as existsSync2, renameSync, statSync as statSync2 } from "node:fs";
 import { join as join2, dirname, basename, resolve as resolve2 } from "node:path";
 
-// src/worktrees.ts
-function parsePorcelain2(output) {
-  const worktrees = [];
-  const blocks = output.trim().split(/\n\n+/);
-  for (const block of blocks) {
-    if (!block.trim())
-      continue;
-    const lines = block.trim().split(`
-`);
-    let path = "";
-    let head = "";
-    let branch = null;
-    let isBare = false;
-    for (const line of lines) {
-      if (line.startsWith("worktree ")) {
-        path = line.slice("worktree ".length);
-      } else if (line.startsWith("HEAD ")) {
-        head = line.slice("HEAD ".length);
-      } else if (line.startsWith("branch ")) {
-        const ref = line.slice("branch ".length);
-        branch = ref.startsWith("refs/heads/") ? ref.slice("refs/heads/".length) : ref;
-      } else if (line === "detached") {
-        branch = null;
-      } else if (line === "bare") {
-        isBare = true;
-        branch = null;
-      }
-    }
-    worktrees.push({ path, head, branch, isBare });
-  }
-  return worktrees;
-}
-async function listWorktrees2(repoPath) {
-  const result = run2("git", ["-C", repoPath, "worktree", "list", "--porcelain"]);
-  return parsePorcelain2(result.stdout);
-}
-
 // src/git.ts
 async function git(args, options) {
-  const result = run2("git", args, {
+  const result = run("git", args, {
     cwd: options?.cwd,
     env: options?.env ? { ...process.env, ...options.env } : undefined
   });
@@ -193,13 +137,46 @@ async function moveDir(src, dest) {
   if (statSync2(src).dev === statSync2(destForStat).dev) {
     renameSync(src, dest);
   } else {
-    run2("cp", ["-a", src, dest]);
-    run2("rm", ["-rf", src]);
+    run("cp", ["-a", src, dest]);
+    run("rm", ["-rf", src]);
   }
 }
 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();
+}
+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 + "/"));
+  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;
+    }
+    log(`Moving [${branch}] → ${join2(dest, sanitizeBranch(branch))}`);
+    await processLinkedWorktree(wt, dest, destBare);
+  }
+  return dest;
+}
 async function migrate(config, options) {
   const source = resolve2(options.source);
   const dest = options.dest ? resolve2(options.dest) : join2(dirname(source), basename(source) + "-bare");
@@ -207,7 +184,7 @@ async function migrate(config, options) {
   if (existsSync2(destBare)) {
     throw new Error(`'${destBare}' already exists`);
   }
-  const allWorktrees = await listWorktrees2(source);
+  const allWorktrees = await listWorktrees(source);
   const worktrees = allWorktrees.filter((wt) => !wt.isBare);
   const seen = new Map;
   for (const wt of worktrees) {
@@ -219,17 +196,19 @@ async function migrate(config, options) {
     seen.set(safe, branch);
   }
   mkdirSync(destBare, { recursive: true });
-  run2("cp", ["-a", config.gitdir + "/.", destBare + "/"]);
+  run("cp", ["-a", config.gitdir + "/.", destBare + "/"]);
   await setGitConfig("core.bare", "true", { gitdir: destBare });
   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);
     const mainDest = join2(dest, mainSafe);
     const mainHeadContent = readFileSync2(join2(destBare, "HEAD"), "utf8");
-    run2("rm", ["-rf", join2(source, ".git")]);
+    run("rm", ["-rf", join2(source, ".git")]);
     await moveDir(source, mainDest);
     const mainAdminDir = join2(destBare, "worktrees", mainSafe);
     mkdirSync(mainAdminDir, { recursive: true });
@@ -247,11 +226,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);
     }
   }
@@ -296,14 +275,20 @@ function yellow(s) {
 function bold(s) {
   return `${BOLD}${s}${RESET}`;
 }
+function prompt() {
+  return new Promise((res) => {
+    process.stdin.setEncoding("utf8");
+    process.stdin.once("data", (chunk) => res(chunk.toString().trim()));
+  });
+}
 function usage() {
   console.log(`Usage: git-worktree-organize <source> [destination]
 
 Convert a git repository into the canonical bare-hub worktree layout:
 
-  <dest>/.bare/    \u2190 bare git repo
-  <dest>/.git      \u2190 plain file: "gitdir: ./.bare"
-  <dest>/<branch>/ \u2190 one directory per worktree
+  <dest>/.bare/    ← bare git repo
+  <dest>/.git      ← plain file: "gitdir: ./.bare"
+  <dest>/<branch>/ ← one directory per worktree
 
 Arguments:
   source       Path to existing git repository
@@ -321,12 +306,71 @@ async function main() {
   const sourcePath = args[0];
   const destArg = args[1];
   const source = resolve3(sourcePath);
-  const dest = destArg ? resolve3(destArg) : join3(dirname2(source), basename2(source) + "-bare");
+  const dest = isPartialMigration(source) ? source : destArg ? resolve3(destArg) : join3(dirname2(source), basename2(source) + "-bare");
+  if (isPartialMigration(dest)) {
+    const hubWorktrees = await listWorktrees(dest);
+    const pending = hubWorktrees.filter((wt) => !wt.isBare && !wt.path.startsWith(dest + "/"));
+    console.log(`
+${yellow("warn:")} Partial migration detected at ${bold(dest)}`);
+    if (pending.length === 0) {
+      console.log("All worktrees are already in place — nothing to resume.");
+      process.exit(0);
+    }
+    console.log(`
+Worktrees still to move:`);
+    for (const wt of pending) {
+      const branch = wt.branch ?? `detached-${wt.head.slice(0, 8)}`;
+      const exists = existsSync3(wt.path);
+      const status = exists ? "" : `  ${yellow("(path missing)")}`;
+      console.log(`  [${bold(branch)}]  ${wt.path}  →  ${join3(dest, sanitizeBranch(branch))}${status}`);
+    }
+    console.log();
+    process.stdout.write("Resume migration? [y/N] ");
+    const resumeAns = await prompt();
+    if (!/^[Yy]$/.test(resumeAns)) {
+      console.log("Aborted.");
+      process.exit(0);
+    }
+    console.log();
+    const hubPath2 = await resumeMigrate(dest, (msg) => console.log(`${green("==>")} ${msg}`));
+    console.log();
+    console.log(`${green("==>")} Verifying with git worktree list...`);
+    console.log(run("git", ["-C", hubPath2, "worktree", "list"]).stdout);
+    console.log(`Done! Hub: ${hubPath2}`);
+    process.exit(0);
+  }
   console.log(`
 ${green("==>")} Reading worktrees from ${source}
 `);
   const config = await detect(source);
   const allWorktrees = await listWorktrees(source);
+  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) {
+      const branch = wt.branch ?? `detached-${wt.head.slice(0, 8)}`;
+      console.log(`  [${branch}]  ${wt.path}`);
+    }
+    console.log();
+    process.stdout.write("Remove them with `git worktree prune` and continue? [y/N] ");
+    const pruneAns = await prompt();
+    if (!/^[Yy]$/.test(pruneAns)) {
+      console.log("Aborted.");
+      process.stdin.destroy();
+      process.exit(0);
+    }
+    run("git", ["-C", source, "worktree", "prune"]);
+    console.log(`${green("==>")} Pruned stale worktrees.
+`);
+    const refreshed = await listWorktrees(source);
+    allWorktrees.length = 0;
+    allWorktrees.push(...refreshed);
+  }
   const worktrees = allWorktrees.filter((wt) => !wt.isBare);
   let mainBranch = null;
   if (config.type === "standard" && worktrees.length > 0) {
@@ -346,16 +390,13 @@ ${green("==>")} Reading worktrees from ${source}
     const tagPad = isMain ? `  (labeled ${yellow("[main]")})` : "";
     const nameCol = bold(`[${branch}]`).padEnd(maxNameLen + 2 + BOLD.length + RESET.length);
     const annotation = isMain ? `  (labeled ${yellow("[main]")})`.padEnd(18 + YELLOW.length + RESET.length) : "".padEnd(18);
-    console.log(`  ${nameCol}${annotation}  \u2192  ${destDir}`);
+    console.log(`  ${nameCol}${annotation}  →  ${destDir}`);
   }
   console.log();
   console.log(`Hub destination: ${bold(dest)}  (bare repo at ${dest}/.bare)`);
   console.log();
   process.stdout.write("Proceed? [y/N] ");
-  const ans = await new Promise((resolve4) => {
-    process.stdin.setEncoding("utf8");
-    process.stdin.once("data", (chunk) => resolve4(chunk.toString().trim()));
-  });
+  const ans = await prompt();
   process.stdin.destroy();
   if (!/^[Yy]$/.test(ans)) {
     console.log("Aborted.");

package/package.json

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