git-worktree-organize 1.0.13 → 1.1.0

package/README.md

@@ -1,5 +1,7 @@
 # git-worktree-organize
 
+> ⚠️ **Use at your own risk.** This tool works for me and passes all tested scenarios, but it modifies your git repository structure. **Make a full backup first** before running on any repository you care about.
+
 Convert any git repository into the canonical bare-hub worktree layout, so every branch lives in its own directory and you never need to stash or switch again.
 
 ## What it does
@@ -11,7 +13,7 @@ Takes an existing git repo (any type) and migrates it into this structure:
 ├── .bare/       ← bare git repo (the actual git database)
 ├── .git         ← plain file: "gitdir: ./.bare"
 ├── main/        ← worktree for the main branch
-└── feature-x/  ← worktree for each other branch
+└── feature-x/   ← worktree for each other branch
 ```
 
 Each branch directory is a fully functional working tree. Open them in separate terminals or IDE windows simultaneously — no stashing, no switching.
@@ -40,32 +42,60 @@ git-worktree-organize <source> [destination]
 | Argument      | Description                                                      |
 |---------------|------------------------------------------------------------------|
 | `source`      | Path to the existing git repository to migrate                   |
-| `destination` | Target hub directory (default: `<parent>/<repo-name>-bare`)      |
+| `destination` | Target hub directory (omit for in-place migration prompt)        |
+
+**Without a destination**, the tool prompts for in-place migration:
+- Renames `<source>` to `<source>.old`
+- Creates the hub at the original `<source>` path
+
+**With a destination**, the tool migrates to the specified path.
 
 The tool shows a preview of what will be created and asks for confirmation before making any changes.
 
-## Example
+## Examples
 
-Given a repo at `/projects/myrepo` with branches `main`, `feature-x`, and `hotfix`:
+### In-place migration (recommended)
 
 ```sh
-git-worktree-organize /projects/myrepo /projects/myrepo-bare
+git-worktree-organize /projects/myrepo
 ```
 
-Result:
+Prompts to reorganize in place, resulting in:
 
 ```
-/projects/myrepo-bare/
+/projects/myrepo/          ← hub (was renamed from myrepo.old)
 ├── .bare/
 ├── .git
 ├── main/
+└── feature-x/
+
+/projects/myrepo.old/      ← backup of original
+```
+
+### Migrate to new location
+
+```sh
+git-worktree-organize /projects/myrepo /projects/myrepo-organized
+```
+
+Result:
+
+```
+/projects/myrepo-organized/
+├── .bare/
+├── .git
+├── main/          ← original /projects/myrepo moved here
 ├── feature-x/
 └── hotfix/
 ```
 
-The original `/projects/myrepo` is moved to `/projects/myrepo-bare/main/`. No data is lost.
+The original `/projects/myrepo` becomes the `main/` worktree. No data is lost.
 
-## Supported repo types
+## Features
+
+### Repository Migration
+
+Convert any git repository type to the bare-hub layout:
 
 - **Standard repos** — ordinary repos with a `.git` directory
 - **Bare-root** — bare repo with git internals at the root (`HEAD`, `refs/`, `objects/`)
@@ -73,12 +103,81 @@ The original `/projects/myrepo` is moved to `/projects/myrepo-bare/main/`. No da
 - **Bare-external** — repo where `.git` is a file pointing to a gitdir elsewhere
 - **Bare-hub** — already in the bare-hub layout (re-organizes worktrees into the canonical structure)
 
-Branch names with slashes (e.g. `feature/auth`) are mapped to hyphenated directory names (`feature-auth`).
+### Resume & Recovery
+
+If a migration was interrupted or worktrees have moved, running the tool on the hub directory will:
+
+1. **Resume partial migrations** — Continue moving worktrees that weren't fully processed
+2. **Repair stale `.git` pointers** — Fix worktrees with broken connections to the bare repo
+3. **Search for missing worktrees** — Find worktrees that were moved outside the hub (searches up to 3 directory levels deep)
+4. **Fix parent directory renames** — Automatically detect and repair when a hub's parent directory was renamed
+
+### Safety Features
+
+- **Interactive confirmation** — Preview all changes before execution
+- **Branch name sanitization** — Names with slashes (e.g. `feature/auth`) become hyphenated directories (`feature-auth`)
+- **Collision detection** — Warns if sanitized names would conflict
+- **Zero runtime dependencies** — Only requires Node.js and git
+
+## Recovery Scenarios
+
+### Partial Migration
+
+If migration was interrupted:
+
+```sh
+git-worktree-organize /path/to/hub
+```
+
+The tool detects the partial state, shows which worktrees still need to be moved, and offers to resume.
+
+### Moved Worktrees
+
+If worktrees were manually moved outside the hub:
+
+```sh
+git-worktree-organize /path/to/hub
+```
+
+The tool searches for missing worktrees by branch name and offers to repair their `.git` pointers.
+
+### Parent Directory Rename
+
+If you renamed a parent directory, worktree `.git` files will have stale paths. Run the tool on any worktree path inside the hub:
+
+```sh
+git-worktree-organize /new/path/to/hub/some-worktree
+```
+
+The tool detects the hub, navigates to it, and repairs all worktree connections.
 
 ## Why this layout
 
 Having every branch as a sibling directory means you can work on multiple branches simultaneously without stashing or switching. It is also easier to run branch-specific build artifacts side by side, and the `.git` file at the hub root ensures IDE and tooling compatibility without any special configuration.
 
+## Requirements
+
+- Node.js 18+
+- Git 2.5+ (for worktree support)
+
+## Development
+
+```sh
+# Clone and install
+git clone https://github.com/drmikecrowe/git-worktree-organize.git
+cd git-worktree-organize
+npm install
+
+# Run tests
+npm test
+
+# Build
+npm run build
+
+# Test locally
+node dist/cli.js /path/to/test/repo
+```
+
 ## License
 
 MIT — see [github.com/drmikecrowe/git-worktree-organize](https://github.com/drmikecrowe/git-worktree-organize).

package/dist/cli.js

@@ -1,8 +1,8 @@
 #!/usr/bin/env node
 
 // src/cli.ts
-import { resolve as resolve3, join as join3, dirname as dirname2, basename as basename2 } from "node:path";
-import { existsSync as existsSync3 } from "node:fs";
+import { resolve as resolve3, join as join5, dirname as dirname3, basename as basename3 } from "node:path";
+import { existsSync as existsSync5, statSync as statSync5, readFileSync as readFileSync5 } from "node:fs";
 
 // src/run.ts
 import { spawnSync } from "node:child_process";
@@ -46,8 +46,7 @@ async function detect(repoPath) {
       }
     } else if (stat.isFile()) {
       const contents = readFileSync(gitEntryPath, "utf8");
-      const firstLine = contents.split(`
-`)[0].trim();
+      const firstLine = contents.split("\n")[0].trim();
       const match = firstLine.match(/^gitdir:\s*(.+)$/);
       if (!match) {
         throw new Error(`not a git repository: ${repoPath}`);
@@ -80,10 +79,8 @@ function parsePorcelain(output) {
   const worktrees = [];
   const blocks = output.trim().split(/\n\n+/);
   for (const block of blocks) {
-    if (!block.trim())
-      continue;
-    const lines = block.trim().split(`
-`);
+    if (!block.trim()) continue;
+    const lines = block.trim().split("\n");
     let path = "";
     let head = "";
     let branch = null;
@@ -113,131 +110,190 @@ async function listWorktrees(repoPath) {
 }
 
 // src/migrate.ts
-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";
+import { mkdirSync, writeFileSync, readFileSync as readFileSync2, existsSync as existsSync3, statSync as statSync3, readdirSync, renameSync as renameSync2 } from "node:fs";
+import { join as join2, dirname as dirname2, basename, resolve as resolve2 } from "node:path";
 
 // src/git.ts
 async function git(args, options) {
   const result = run("git", args, {
     cwd: options?.cwd,
-    env: options?.env ? { ...process.env, ...options.env } : undefined
+    env: options?.env ? { ...process.env, ...options.env } : void 0
   });
   return result.stdout;
 }
 async function setGitConfig(key, value, options) {
   const env = {};
-  if (options?.gitdir)
-    env["GIT_DIR"] = options.gitdir;
+  if (options?.gitdir) env["GIT_DIR"] = options.gitdir;
   await git(["config", key, value], { cwd: options?.cwd, env });
 }
 
-// src/migrate.ts
-async function moveDir(src, dest) {
+// src/fs.ts
+import { statSync as statSync2, renameSync, existsSync as existsSync2 } from "node:fs";
+import { dirname } from "node:path";
+async function move(src, dest) {
   const destForStat = existsSync2(dest) ? dest : dirname(dest);
-  if (statSync2(src).dev === statSync2(destForStat).dev) {
+  if (samefs(src, destForStat)) {
     renameSync(src, dest);
   } else {
     run("cp", ["-a", src, dest]);
     run("rm", ["-rf", src]);
   }
 }
+function samefs(a, b) {
+  return statSync2(a).dev === statSync2(b).dev;
+}
+
+// src/migrate.ts
 function sanitizeBranch(branch) {
   return branch.replace(/\//g, "-");
 }
 function resolveWorktreePath(worktreePath, dest, sourceParent) {
-  if (existsSync2(worktreePath))
-    return worktreePath;
+  if (existsSync3(worktreePath)) return worktreePath;
   if (worktreePath.startsWith(dest + "/")) {
     const remapped = sourceParent + worktreePath.slice(dest.length);
-    if (existsSync2(remapped))
-      return remapped;
+    if (existsSync3(remapped)) return remapped;
   }
   return worktreePath;
 }
 function isPartialMigration(dest) {
   const gitFile = join2(dest, ".git");
-  return existsSync2(join2(dest, ".bare")) && existsSync2(gitFile) && statSync2(gitFile).isFile();
+  return existsSync3(join2(dest, ".bare")) && existsSync3(gitFile) && statSync3(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;
+    if (isPartialMigration(current)) return current;
+    const parent = dirname2(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;
+  if (!existsSync3(adminBase)) return;
   for (const adminName of readdirSync(adminBase)) {
     const adminDir = join2(adminBase, adminName);
-    if (!statSync2(adminDir).isDirectory())
-      continue;
+    if (!statSync3(adminDir).isDirectory()) continue;
     const gitdirFile = join2(adminDir, "gitdir");
-    if (!existsSync2(gitdirFile))
-      continue;
+    if (!existsSync3(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 worktreePath = dirname2(registeredGitFile);
+    if (!worktreePath.startsWith(dest + "/")) continue;
+    if (!existsSync3(registeredGitFile) || !statSync3(registeredGitFile).isFile()) continue;
     const content = readFileSync2(registeredGitFile, "utf8");
     const match = content.match(/^gitdir:\s*(.+)/m);
-    if (!match)
-      continue;
-    if (match[1].trim() === adminDir)
-      continue;
+    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) {
+async function resumeMigrate(dest, log = console.log, warn) {
   const destBare = join2(dest, ".bare");
   const hubWorktrees = await listWorktrees(dest);
   const pending = hubWorktrees.filter((wt) => {
-    if (wt.isBare)
-      return false;
+    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.");
+    log("Nothing to resume \u2014 all worktrees are already in place.");
   } 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)) {
+      if (!existsSync3(wtPath)) {
+        if (existsSync3(expectedPath)) {
           wtPath = expectedPath;
         } else {
-          log(`warn: Skipping [${branch}] — path no longer exists: ${wt.path}`);
+          log(`warn: Skipping [${branch}] \u2014 path no longer exists: ${wt.path}`);
           continue;
         }
       }
-      log(`Moving [${branch}] → ${expectedPath}`);
-      await processLinkedWorktree({ ...wt, path: wtPath }, dest, destBare);
+      log(`Moving [${branch}] \u2192 ${expectedPath}`);
+      await processLinkedWorktree({ ...wt, path: wtPath }, dest, destBare, log, warn);
     }
   }
   await repairHub(dest, log);
   return dest;
 }
-async function migrate(config, options) {
+async function migrateInPlace(source, log = console.log, warn) {
+  const resolvedSource = resolve2(source);
+  const oldPath = resolvedSource + ".old";
+  if (existsSync3(oldPath)) {
+    throw new Error(`'${oldPath}' already exists. Remove it and try again.`);
+  }
+  log(`Renaming ${bold(resolvedSource)} to ${bold(oldPath)}`);
+  await move(resolvedSource, oldPath);
+  const allWorktrees = await listWorktrees(oldPath);
+  const worktrees = allWorktrees.filter((wt) => !wt.isBare);
+  if (worktrees.length === 0) {
+    throw new Error("No worktrees found in source repository");
+  }
+  const seen = /* @__PURE__ */ new Map();
+  for (const wt of worktrees) {
+    const branch = wt.branch ?? `detached-${wt.head.slice(0, 8)}`;
+    const safe = sanitizeBranch(branch);
+    if (seen.has(safe)) {
+      throw new Error(`branch name collision: '${seen.get(safe)}' and '${branch}' both map to '${safe}'`);
+    }
+    seen.set(safe, branch);
+  }
+  const mainBranch = worktrees[0].branch;
+  const mainSafe = sanitizeBranch(mainBranch);
+  const destBare = join2(resolvedSource, ".bare");
+  const mainDest = join2(resolvedSource, mainSafe);
+  mkdirSync(destBare, { recursive: true });
+  const gitDir = join2(oldPath, ".git");
+  for (const entry of readdirSync(gitDir)) {
+    const srcPath = join2(gitDir, entry);
+    const destPath = join2(destBare, entry);
+    if (statSync3(srcPath).isDirectory()) {
+      run("cp", ["-a", srcPath + "/.", destPath + "/"]);
+    } else {
+      run("cp", ["-a", srcPath, destPath]);
+    }
+  }
+  await setGitConfig("core.bare", "true", { gitdir: destBare });
+  await setGitConfig("remote.origin.fetch", "+refs/heads/*:refs/remotes/origin/*", { gitdir: destBare });
+  writeFileSync(join2(resolvedSource, ".git"), "gitdir: ./.bare\n");
+  const mainHeadContent = readFileSync2(join2(destBare, "HEAD"), "utf8");
+  log(`Creating main worktree at ${bold(mainDest)}`);
+  run("cp", ["-a", oldPath + "/.", mainDest + "/"]);
+  const mainAdminDir = join2(destBare, "worktrees", mainSafe);
+  mkdirSync(mainAdminDir, { recursive: true });
+  writeFileSync(join2(mainAdminDir, "gitdir"), mainDest + "/.git\n");
+  writeFileSync(join2(mainAdminDir, "commondir"), "../../\n");
+  const headToWrite = mainHeadContent.endsWith("\n") ? mainHeadContent : mainHeadContent + "\n";
+  writeFileSync(join2(mainAdminDir, "HEAD"), headToWrite);
+  const bareIndex = join2(destBare, "index");
+  if (existsSync3(bareIndex)) {
+    renameSync2(bareIndex, join2(mainAdminDir, "index"));
+  }
+  run("rm", ["-rf", join2(mainDest, ".git")]);
+  writeFileSync(join2(mainDest, ".git"), `gitdir: ${mainAdminDir}
+`);
+  for (let i = 1; i < worktrees.length; i++) {
+    await processLinkedWorktree(worktrees[i], resolvedSource, destBare, log, warn);
+  }
+  log(`Original repo backed up at: ${oldPath}`);
+  return resolvedSource;
+}
+function bold(s) {
+  return `\x1B[1m${s}\x1B[0m`;
+}
+async function migrate(config, options, log, warn) {
   const source = resolve2(options.source);
-  const dest = options.dest ? resolve2(options.dest) : join2(dirname(source), basename(source) + "-bare");
+  const dest = options.dest ? resolve2(options.dest) : join2(dirname2(source), basename(source) + "-bare");
   const destBare = join2(dest, ".bare");
-  if (existsSync2(destBare)) {
+  if (existsSync3(destBare)) {
     throw new Error(`'${destBare}' already exists`);
   }
   const allWorktrees = await listWorktrees(source);
   const worktrees = allWorktrees.filter((wt) => !wt.isBare);
-  const seen = new Map;
+  const seen = /* @__PURE__ */ new Map();
   for (const wt of worktrees) {
     const branch = wt.branch ?? `detached-${wt.head.slice(0, 8)}`;
     const safe = sanitizeBranch(branch);
@@ -250,53 +306,50 @@ async function migrate(config, options) {
   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) });
+  writeFileSync(join2(dest, ".git"), "gitdir: ./.bare\n");
+  const sourceParent = dirname2(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");
     run("rm", ["-rf", join2(source, ".git")]);
-    await moveDir(source, mainDest);
+    await move(source, mainDest);
     const mainAdminDir = join2(destBare, "worktrees", mainSafe);
     mkdirSync(mainAdminDir, { recursive: true });
-    writeFileSync(join2(mainAdminDir, "gitdir"), mainDest + `/.git
-`);
-    writeFileSync(join2(mainAdminDir, "commondir"), `../../
-`);
-    const headToWrite = mainHeadContent.endsWith(`
-`) ? mainHeadContent : mainHeadContent + `
-`;
+    writeFileSync(join2(mainAdminDir, "gitdir"), mainDest + "/.git\n");
+    writeFileSync(join2(mainAdminDir, "commondir"), "../../\n");
+    const headToWrite = mainHeadContent.endsWith("\n") ? mainHeadContent : mainHeadContent + "\n";
     writeFileSync(join2(mainAdminDir, "HEAD"), headToWrite);
     const bareIndex = join2(destBare, "index");
-    if (existsSync2(bareIndex)) {
-      renameSync(bareIndex, join2(mainAdminDir, "index"));
+    if (existsSync3(bareIndex)) {
+      renameSync2(bareIndex, join2(mainAdminDir, "index"));
     }
     writeFileSync(join2(mainDest, ".git"), `gitdir: ${mainAdminDir}
 `);
-    for (let i = 1;i < worktreesResolved.length; i++) {
-      await processLinkedWorktree(worktreesResolved[i], dest, destBare);
+    for (let i = 1; i < worktreesResolved.length; i++) {
+      await processLinkedWorktree(worktreesResolved[i], dest, destBare, log, warn);
     }
   } else {
     for (const wt of worktreesResolved) {
-      await processLinkedWorktree(wt, dest, destBare);
+      await processLinkedWorktree(wt, dest, destBare, log, warn);
     }
   }
   return dest;
 }
-async function processLinkedWorktree(wt, dest, destBare) {
+async function processLinkedWorktree(wt, dest, destBare, log, warn) {
   const wtSrc = wt.path;
   const wtBranch = wt.branch ?? `detached-${wt.head.slice(0, 8)}`;
   const wtSafe = sanitizeBranch(wtBranch);
   const wtDest = join2(dest, wtSafe);
-  await moveDir(wtSrc, wtDest);
+  await move(wtSrc, wtDest);
   const gitFileContent = readFileSync2(join2(wtDest, ".git"), "utf8");
   const match = gitFileContent.match(/^gitdir:\s*(.+)/m);
   if (!match) {
-    console.warn(`Could not parse .git file in ${wtDest}`);
+    warn?.(`Could not parse .git file in ${wtDest}`);
     return;
   }
   const oldPath = match[1].trim();
@@ -304,17 +357,100 @@ async function processLinkedWorktree(wt, dest, destBare) {
   const newAdmin = join2(destBare, "worktrees", adminName);
   writeFileSync(join2(wtDest, ".git"), `gitdir: ${newAdmin}
 `);
-  if (existsSync2(newAdmin)) {
-    writeFileSync(join2(newAdmin, "gitdir"), wtDest + `/.git
-`);
+  if (existsSync3(newAdmin)) {
+    writeFileSync(join2(newAdmin, "gitdir"), wtDest + "/.git\n");
   } else {
-    console.warn(`Admin dir ${newAdmin} does not exist for worktree ${wtDest}`);
+    warn?.(`Admin dir ${newAdmin} does not exist for worktree ${wtDest}`);
+  }
+}
+
+// src/recover.ts
+import { existsSync as existsSync4, readdirSync as readdirSync2, statSync as statSync4, readFileSync as readFileSync3, writeFileSync as writeFileSync2 } from "node:fs";
+import { join as join3, basename as basename2 } from "node:path";
+async function searchForWorktree(branch, options, log) {
+  const sanitizedBranch = sanitizeBranch(branch);
+  const candidates = [];
+  for (const searchDir of options.searchDirs) {
+    searchAtDepth(searchDir, sanitizedBranch, 0, options.maxDepth, candidates, log);
+  }
+  const validCandidates = candidates.filter((c) => {
+    const gitPath = join3(c, ".git");
+    return existsSync4(gitPath) && statSync4(gitPath).isFile();
+  });
+  return {
+    branch,
+    sanitizedBranch,
+    foundPath: validCandidates.length === 1 ? validCandidates[0] : null,
+    candidates: validCandidates
+  };
+}
+function searchAtDepth(dir, targetName, currentDepth, maxDepth, candidates, log) {
+  if (currentDepth > maxDepth) return;
+  if (!existsSync4(dir)) return;
+  const entries = readdirSync2(dir);
+  for (const entry of entries) {
+    if (entry.startsWith(".") || entry === "node_modules") continue;
+    const fullPath = join3(dir, entry);
+    if (!statSync4(fullPath).isDirectory()) continue;
+    if (entry === targetName) {
+      log?.(`Found candidate: ${fullPath}`);
+      candidates.push(fullPath);
+    }
+    searchAtDepth(fullPath, targetName, currentDepth + 1, maxDepth, candidates, log);
+  }
+}
+async function findMissingWorktrees(hubPath, searchDirs, log) {
+  const worktrees = await listWorktrees(hubPath);
+  const results = [];
+  for (const wt of worktrees) {
+    if (wt.isBare) continue;
+    if (existsSync4(wt.path)) continue;
+    const branch = wt.branch ?? `detached-${wt.head.slice(0, 8)}`;
+    log?.(`Searching for missing worktree [${branch}]...`);
+    const result = await searchForWorktree(branch, { searchDirs, maxDepth: 3 }, log);
+    results.push(result);
+  }
+  return results;
+}
+async function repairWorktree(worktreePath, hubPath, log) {
+  const bareDir = join3(hubPath, ".bare");
+  const adminBase = join3(bareDir, "worktrees");
+  const gitFile = join3(worktreePath, ".git");
+  const content = readFileSync3(gitFile, "utf8");
+  const match = content.match(/^gitdir:\s*(.+)/m);
+  if (!match) {
+    throw new Error(`Cannot parse .git file in ${worktreePath}`);
+  }
+  const oldAdminPath = match[1].trim();
+  const adminName = basename2(oldAdminPath);
+  const newAdminPath = join3(adminBase, adminName);
+  log?.(`Repairing ${worktreePath} -> ${newAdminPath}`);
+  writeFileSync2(gitFile, `gitdir: ${newAdminPath}
+`);
+  const gitdirFile = join3(newAdminPath, "gitdir");
+  if (existsSync4(gitdirFile)) {
+    writeFileSync2(gitdirFile, `${worktreePath}/.git
+`);
   }
 }
 
+// src/version.ts
+import { readFileSync as readFileSync4 } from "node:fs";
+import { join as join4 } from "node:path";
+function readVersion() {
+  const pkgPath = join4(import.meta.dirname, "..", "package.json");
+  const pkg = JSON.parse(readFileSync4(pkgPath, "utf8"));
+  return pkg.version;
+}
+var VERSION = readVersion();
+function getVersion(withPrefix = false) {
+  return withPrefix ? `v${VERSION}` : VERSION;
+}
+
 // src/cli.ts
 var GREEN = "\x1B[32m";
 var YELLOW = "\x1B[33m";
+var RED = "\x1B[31m";
 var BOLD = "\x1B[1m";
 var RESET = "\x1B[0m";
 function green(s) {
@@ -323,7 +459,10 @@ function green(s) {
 function yellow(s) {
   return `${YELLOW}${s}${RESET}`;
 }
-function bold(s) {
+function red(s) {
+  return `${RED}${s}${RESET}`;
+}
+function bold2(s) {
   return `${BOLD}${s}${RESET}`;
 }
 function prompt() {
@@ -332,37 +471,182 @@ function prompt() {
     process.stdin.once("data", (chunk) => res(chunk.toString().trim()));
   });
 }
+function isGitPointerValid(worktreePath, hubPath) {
+  const gitFile = join5(worktreePath, ".git");
+  if (!existsSync5(gitFile) || !statSync5(gitFile).isFile()) {
+    return false;
+  }
+  const content = readFileSync5(gitFile, "utf8");
+  const match = content.match(/^gitdir:\s*(.+)$/m);
+  if (!match) {
+    return false;
+  }
+  const gitdir = match[1].trim();
+  const bareDir = join5(hubPath, ".bare");
+  return gitdir.includes(bareDir) && gitdir.includes("/worktrees/");
+}
+async function runValidationMode(hubPath) {
+  const worktrees = await listWorktrees(hubPath);
+  const validated = [];
+  for (const wt of worktrees) {
+    if (wt.isBare) continue;
+    let status;
+    if (!existsSync5(wt.path)) {
+      status = "missing";
+    } else if (!isGitPointerValid(wt.path, hubPath)) {
+      status = "stale";
+    } else {
+      status = "healthy";
+    }
+    validated.push({ worktree: wt, status });
+  }
+  console.log();
+  console.log(bold2("Validation Report"));
+  console.log(`Hub: ${hubPath}`);
+  console.log();
+  if (validated.length === 0) {
+    console.log("No worktrees found.");
+    return;
+  }
+  const maxBranchLen = validated.reduce((m, v) => {
+    const branch = v.worktree.branch ?? `detached-${v.worktree.head.slice(0, 8)}`;
+    return Math.max(m, branch.length);
+  }, 0);
+  const headerBranch = "Branch".padEnd(maxBranchLen);
+  const headerStatus = "Status";
+  const headerPath = "Path";
+  console.log(`  ${bold2(headerBranch)}  ${bold2(headerStatus.padEnd(7))}  ${bold2(headerPath)}`);
+  const counts = { healthy: 0, missing: 0, stale: 0 };
+  for (const v of validated) {
+    const branch = v.worktree.branch ?? `detached-${v.worktree.head.slice(0, 8)}`;
+    const branchCol = branch.padEnd(maxBranchLen);
+    let statusCol;
+    if (v.status === "healthy") {
+      statusCol = green("healthy");
+      counts.healthy++;
+    } else if (v.status === "missing") {
+      statusCol = red("missing");
+      counts.missing++;
+    } else {
+      statusCol = yellow("stale");
+      counts.stale++;
+    }
+    console.log(`  ${branchCol}  ${statusCol.padEnd(7 + (statusCol.length - v.status.length))}  ${v.worktree.path}`);
+  }
+  console.log();
+  const summaryParts = [];
+  if (counts.healthy > 0) summaryParts.push(`${counts.healthy} healthy`);
+  if (counts.missing > 0) summaryParts.push(`${counts.missing} missing`);
+  if (counts.stale > 0) summaryParts.push(`${counts.stale} stale`);
+  console.log(`Summary: ${summaryParts.join(", ")}`);
+  const needsRepair = validated.filter((v) => v.status === "missing" || v.status === "stale");
+  if (needsRepair.length === 0) {
+    return;
+  }
+  console.log();
+  console.log(`${yellow("warn:")} ${needsRepair.length} worktree(s) need repair.`);
+  const searchDirs = [dirname3(hubPath)];
+  console.log(`${green("==>")} Searching for missing worktrees...`);
+  const results = await findMissingWorktrees(
+    hubPath,
+    searchDirs,
+    (msg) => console.log(`    ${msg}`)
+  );
+  const found = results.filter((r) => r.candidates.length > 0);
+  const notFound = results.filter((r) => r.candidates.length === 0);
+  const multiple = results.filter((r) => r.candidates.length > 1);
+  if (notFound.length > 0) {
+    console.log(`
+${yellow("Not found:")}`);
+    for (const r of notFound) {
+      console.log(`  [${r.branch}]`);
+    }
+  }
+  if (found.length === 0) {
+    console.log(`
+No worktrees could be located. Consider pruning them with 'git worktree prune'.`);
+    return;
+  }
+  const selections = /* @__PURE__ */ new Map();
+  for (const r of multiple) {
+    console.log(`
+${bold2(`[${r.branch}]`)} has multiple candidates:`);
+    for (let i = 0; i < r.candidates.length; i++) {
+      console.log(`  ${i + 1}) ${r.candidates[i]}`);
+    }
+    process.stdout.write(`Select which to use (1-${r.candidates.length}) [skip]: `);
+    const sel = await prompt();
+    const idx = parseInt(sel) - 1;
+    if (idx >= 0 && idx < r.candidates.length) {
+      selections.set(r.branch, r.candidates[idx]);
+    }
+  }
+  console.log(`
+${green("Found:")}`);
+  const maxFoundBranchLen = found.reduce((m, r) => Math.max(m, r.branch.length), 0);
+  for (const r of found) {
+    const path = selections.get(r.branch) ?? r.candidates[0];
+    const branchCol = bold2(`[${r.branch}]`).padEnd(maxFoundBranchLen + 2 + BOLD.length + RESET.length);
+    console.log(`  ${branchCol}  ${path}`);
+  }
+  console.log();
+  process.stdout.write("Repair these worktrees? [y/N] ");
+  const repairAns = await prompt();
+  process.stdin.destroy();
+  if (!/^[Yy]$/.test(repairAns)) {
+    console.log("Aborted.");
+    return;
+  }
+  console.log();
+  for (const r of found) {
+    const path = selections.get(r.branch) ?? r.candidates[0];
+    await repairWorktree(path, hubPath, (msg) => console.log(`${green("==>")} ${msg}`));
+  }
+  console.log(`${green("==>")} Repaired ${found.length} worktree(s).`);
+}
 function usage() {
   console.log(`Usage: git-worktree-organize <source> [destination]
 
 Convert a git repository into the canonical bare-hub worktree layout:
 
-  <dest>/.bare/    ← bare git repo
-  <dest>/.git      ← plain file: "gitdir: ./.bare"
-  <dest>/<branch>/ ← one directory per worktree
+  <dest>/.bare/    \u2190 bare git repo
+  <dest>/.git      \u2190 plain file: "gitdir: ./.bare"
+  <dest>/<branch>/ \u2190 one directory per worktree
 
 Arguments:
   source       Path to existing git repository
   destination  Target hub directory (default: <parent>/<name>-bare)
 
 Options:
-  -h, --help   Show help`);
+  -h, --help      Show help
+  -v, --version   Show version`);
 }
 async function main() {
   const args = process.argv.slice(2);
+  if (args[0] === "-v" || args[0] === "--version") {
+    console.log(`git-worktree-organize ${getVersion(true)}`);
+    process.exit(0);
+  }
   if (args.length === 0 || args[0] === "-h" || args[0] === "--help") {
     usage();
     process.exit(0);
   }
+  console.log(`${bold2("git-worktree-organize")} ${getVersion(true)}
+`);
   const sourcePath = args[0];
   const destArg = args[1];
   const source = resolve3(sourcePath);
-  const dest = isPartialMigration(source) ? source : destArg ? resolve3(destArg) : join3(dirname2(source), basename2(source) + "-bare");
+  const dest = isPartialMigration(source) ? source : destArg ? resolve3(destArg) : join5(dirname3(source), basename3(source) + "-bare");
+  const config = await detect(source);
+  if (config.type === "bare-hub") {
+    await runValidationMode(source);
+    process.exit(0);
+  }
   if (!isPartialMigration(source) && !destArg) {
-    const ancestorHub = findHub(dirname2(source));
+    const ancestorHub = findHub(dirname3(source));
     if (ancestorHub) {
       console.log(`
-${yellow("warn:")} ${bold(source)} is inside an existing hub at ${bold(ancestorHub)}`);
+${yellow("warn:")} ${bold2(source)} is inside an existing hub at ${bold2(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.
@@ -386,24 +670,104 @@ This looks like manually-placed worktrees with stale .git files.`);
   if (isPartialMigration(dest)) {
     const hubWorktrees = await listWorktrees(dest);
     const pending = hubWorktrees.filter((wt) => {
-      if (wt.isBare)
-        return false;
+      if (wt.isBare) return false;
       const branch = wt.branch ?? `detached-${wt.head.slice(0, 8)}`;
-      return wt.path !== join3(dest, sanitizeBranch(branch));
+      return wt.path !== join5(dest, sanitizeBranch(branch));
+    });
+    const missing2 = hubWorktrees.filter((wt) => {
+      if (wt.isBare) return false;
+      return !existsSync5(wt.path);
     });
     console.log(`
-${yellow("warn:")} Partial migration detected at ${bold(dest)}`);
+${yellow("warn:")} Partial migration detected at ${bold2(dest)}`);
+    if (missing2.length > 0) {
+      console.log(`
+The following worktree paths no longer exist:`);
+      for (const wt of missing2) {
+        const branch = wt.branch ?? `detached-${wt.head.slice(0, 8)}`;
+        console.log(`  [${branch}]  ${wt.path}`);
+      }
+      console.log();
+      const searchDirs = [dirname3(dest)];
+      console.log(`${green("==>")} Searching for missing worktrees...`);
+      const results = await findMissingWorktrees(
+        dest,
+        searchDirs,
+        (msg) => console.log(`    ${msg}`)
+      );
+      const found = results.filter((r) => r.candidates.length > 0);
+      const notFound = results.filter((r) => r.candidates.length === 0);
+      const multiple = results.filter((r) => r.candidates.length > 1);
+      if (notFound.length > 0) {
+        console.log(`
+${yellow("Not found:")}`);
+        for (const r of notFound) {
+          console.log(`  [${r.branch}]`);
+        }
+      }
+      if (found.length === 0) {
+        console.log(`
+No worktrees could be located. Consider pruning them with 'git worktree prune'.`);
+        process.exit(0);
+      }
+      const selections = /* @__PURE__ */ new Map();
+      for (const r of multiple) {
+        console.log(`
+${bold2(`[${r.branch}]`)} has multiple candidates:`);
+        for (let i = 0; i < r.candidates.length; i++) {
+          console.log(`  ${i + 1}) ${r.candidates[i]}`);
+        }
+        process.stdout.write(`Select which to use (1-${r.candidates.length}) [skip]: `);
+        const sel = await prompt();
+        const idx = parseInt(sel) - 1;
+        if (idx >= 0 && idx < r.candidates.length) {
+          selections.set(r.branch, r.candidates[idx]);
+        }
+      }
+      console.log(`
+${green("Found:")}`);
+      const maxBranchLen = found.reduce((m, r) => Math.max(m, r.branch.length), 0);
+      for (const r of found) {
+        const path = selections.get(r.branch) ?? r.candidates[0];
+        const branchCol = bold2(`[${r.branch}]`).padEnd(maxBranchLen + 2 + BOLD.length + RESET.length);
+        console.log(`  ${branchCol}  ${path}`);
+      }
+      console.log();
+      process.stdout.write("Repair these worktrees? [y/N] ");
+      const repairAns = await prompt();
+      if (!/^[Yy]$/.test(repairAns)) {
+        console.log("Aborted.");
+        process.stdin.destroy();
+        process.exit(0);
+      }
+      console.log();
+      for (const r of found) {
+        const path = selections.get(r.branch) ?? r.candidates[0];
+        await repairWorktree(path, dest, (msg) => console.log(`${green("==>")} ${msg}`));
+      }
+      console.log(`${green("==>")} Repaired ${found.length} worktree(s).
+`);
+      const refreshed = await listWorktrees(dest);
+      hubWorktrees.length = 0;
+      hubWorktrees.push(...refreshed);
+      pending.length = 0;
+      pending.push(...hubWorktrees.filter((wt) => {
+        if (wt.isBare) return false;
+        const branch = wt.branch ?? `detached-${wt.head.slice(0, 8)}`;
+        return wt.path !== join5(dest, sanitizeBranch(branch));
+      }));
+    }
     if (pending.length === 0) {
-      console.log("All worktrees are already in place — nothing to resume.");
+      await runValidationMode(dest);
       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 exists = existsSync5(wt.path);
       const status = exists ? "" : `  ${yellow("(path missing)")}`;
-      console.log(`  [${bold(branch)}]  ${wt.path}  →  ${join3(dest, sanitizeBranch(branch))}${status}`);
+      console.log(`  [${bold2(branch)}]  ${wt.path}  \u2192  ${join5(dest, sanitizeBranch(branch))}${status}`);
     }
     console.log();
     process.stdout.write("Resume migration? [y/N] ");
@@ -413,7 +777,11 @@ Worktrees still to move:`);
       process.exit(0);
     }
     console.log();
-    const hubPath2 = await resumeMigrate(dest, (msg) => console.log(`${green("==>")} ${msg}`));
+    const hubPath2 = await resumeMigrate(
+      dest,
+      (msg) => console.log(`${green("==>")} ${msg}`),
+      (msg) => console.log(`${yellow("warn:")} ${msg}`)
+    );
     console.log();
     console.log(`${green("==>")} Verifying with git worktree list...`);
     console.log(run("git", ["-C", hubPath2, "worktree", "list"]).stdout);
@@ -423,30 +791,132 @@ Worktrees still to move:`);
   console.log(`
 ${green("==>")} Reading worktrees from ${source}
 `);
-  const config = await detect(source);
   const allWorktrees = await listWorktrees(source);
+  if (config.type === "standard" && !destArg) {
+    const repoName = basename3(source);
+    let mainBranch2 = "main";
+    if (allWorktrees.length > 0) {
+      mainBranch2 = allWorktrees[0].branch ?? "main";
+    }
+    console.log("Worktrees to migrate:");
+    const maxNameLen2 = allWorktrees.reduce((m, wt) => {
+      const branch = wt.branch ?? `detached-${wt.head.slice(0, 8)}`;
+      return Math.max(m, branch.length);
+    }, 0);
+    for (const wt of allWorktrees) {
+      const branch = wt.branch ?? `detached-${wt.head.slice(0, 8)}`;
+      const safe = sanitizeBranch(branch);
+      const isMain = branch === mainBranch2;
+      const destDir = join5(source, safe);
+      const nameCol = bold2(`[${branch}]`).padEnd(maxNameLen2 + 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();
+    console.log(`Hub destination: ${bold2(source)}  (bare repo at ${source}/.bare)`);
+    console.log();
+    console.log(`No destination specified. Migrate in-place?`);
+    console.log(`This will rename '${bold2(repoName)}' to '${bold2(repoName + ".old")}' and create the hub here.`);
+    console.log();
+    process.stdout.write("Proceed with in-place migration? [y/N] ");
+    const inPlaceAns = await prompt();
+    process.stdin.destroy();
+    if (!/^[Yy]$/.test(inPlaceAns)) {
+      console.log("Aborted.");
+      console.log("Tip: Specify a destination directory to migrate to a new location.");
+      process.exit(0);
+    }
+    console.log();
+    const hubPath2 = await migrateInPlace(
+      source,
+      (msg) => console.log(`${green("==>")} ${msg}`),
+      (msg) => console.log(`${yellow("warn:")} ${msg}`)
+    );
+    console.log(`${green("==>")} Verifying with git worktree list...`);
+    const verifyOutput2 = run("git", ["-C", hubPath2, "worktree", "list"]).stdout;
+    console.log(verifyOutput2);
+    console.log(`Done! Hub: ${hubPath2}`);
+    console.log(`Backup: ${source}.old`);
+    console.log();
+    console.log("Useful commands:");
+    console.log(`  git -C ${hubPath2} worktree list`);
+    console.log(`  git -C ${hubPath2}/main log --oneline -5`);
+    process.exit(0);
+  }
   const missing = allWorktrees.filter((wt) => {
-    if (wt.isBare)
-      return false;
-    const actual = resolveWorktreePath(wt.path, dest, dirname2(source));
-    return !existsSync3(actual);
+    if (wt.isBare) return false;
+    const actual = resolveWorktreePath(wt.path, dest, dirname3(source));
+    return !existsSync5(actual);
   });
   if (missing.length > 0) {
-    console.log(`${yellow("warn:")} The following worktree paths no longer exist:`);
+    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)) {
+    const searchDirs = [dirname3(source)];
+    if (dest !== source) {
+      searchDirs.push(dest);
+    }
+    console.log(`${green("==>")} Searching for missing worktrees...`);
+    const results = await findMissingWorktrees(
+      source,
+      searchDirs,
+      (msg) => console.log(`    ${msg}`)
+    );
+    const found = results.filter((r) => r.candidates.length > 0);
+    const notFound = results.filter((r) => r.candidates.length === 0);
+    const multiple = results.filter((r) => r.candidates.length > 1);
+    if (notFound.length > 0) {
+      console.log(`
+${yellow("Not found:")}`);
+      for (const r of notFound) {
+        console.log(`  [${r.branch}]`);
+      }
+    }
+    if (found.length === 0) {
+      console.log(`
+No worktrees could be located. Consider pruning them with 'git worktree prune'.`);
+      process.exit(0);
+    }
+    const selections = /* @__PURE__ */ new Map();
+    for (const r of multiple) {
+      console.log(`
+${bold2(`[${r.branch}]`)} has multiple candidates:`);
+      for (let i = 0; i < r.candidates.length; i++) {
+        console.log(`  ${i + 1}) ${r.candidates[i]}`);
+      }
+      process.stdout.write(`Select which to use (1-${r.candidates.length}) [skip]: `);
+      const sel = await prompt();
+      const idx = parseInt(sel) - 1;
+      if (idx >= 0 && idx < r.candidates.length) {
+        selections.set(r.branch, r.candidates[idx]);
+      }
+    }
+    console.log(`
+${green("Found:")}`);
+    const maxBranchLen = found.reduce((m, r) => Math.max(m, r.branch.length), 0);
+    for (const r of found) {
+      const path = selections.get(r.branch) ?? r.candidates[0];
+      const branchCol = bold2(`[${r.branch}]`).padEnd(maxBranchLen + 2 + BOLD.length + RESET.length);
+      console.log(`  ${branchCol}  ${path}`);
+    }
+    console.log();
+    process.stdout.write("Repair these worktrees? [y/N] ");
+    const repairAns = await prompt();
+    if (!/^[Yy]$/.test(repairAns)) {
       console.log("Aborted.");
       process.stdin.destroy();
       process.exit(0);
     }
-    run("git", ["-C", source, "worktree", "prune"]);
-    console.log(`${green("==>")} Pruned stale worktrees.
+    console.log();
+    for (const r of found) {
+      const path = selections.get(r.branch) ?? r.candidates[0];
+      await repairWorktree(path, source, (msg) => console.log(`${green("==>")} ${msg}`));
+    }
+    console.log(`${green("==>")} Repaired ${found.length} worktree(s).
 `);
     const refreshed = await listWorktrees(source);
     allWorktrees.length = 0;
@@ -462,19 +932,19 @@ ${green("==>")} Reading worktrees from ${source}
     const branch = wt.branch ?? `detached-${wt.head.slice(0, 8)}`;
     const safe = sanitizeBranch(branch);
     const isMain = branch === mainBranch;
-    const destDir = join3(dest, safe);
+    const destDir = join5(dest, safe);
     return { branch, isMain, destDir };
   });
   const maxNameLen = entries.reduce((m, e) => Math.max(m, e.branch.length), 0);
   for (const { branch, isMain, destDir } of entries) {
     const tag = isMain ? yellow("[main]") : "";
     const tagPad = isMain ? `  (labeled ${yellow("[main]")})` : "";
-    const nameCol = bold(`[${branch}]`).padEnd(maxNameLen + 2 + BOLD.length + RESET.length);
+    const nameCol = bold2(`[${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}  →  ${destDir}`);
+    console.log(`  ${nameCol}${annotation}  \u2192  ${destDir}`);
   }
   console.log();
-  console.log(`Hub destination: ${bold(dest)}  (bare repo at ${dest}/.bare)`);
+  console.log(`Hub destination: ${bold2(dest)}  (bare repo at ${dest}/.bare)`);
   console.log();
   process.stdout.write("Proceed? [y/N] ");
   const ans = await prompt();
@@ -484,7 +954,12 @@ ${green("==>")} Reading worktrees from ${source}
     process.exit(0);
   }
   console.log();
-  const hubPath = await migrate(config, { source: sourcePath, dest: destArg ?? "" });
+  const hubPath = await migrate(
+    config,
+    { source: sourcePath, dest: destArg ?? "" },
+    (msg) => console.log(`${green("==>")} ${msg}`),
+    (msg) => console.log(`${yellow("warn:")} ${msg}`)
+  );
   console.log(`${green("==>")} Verifying with git worktree list...`);
   const verifyOutput = run("git", ["-C", hubPath, "worktree", "list"]).stdout;
   console.log(verifyOutput);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "git-worktree-organize",
-  "version": "1.0.13",
+  "version": "1.1.0",
   "description": "Convert any git repo into the canonical bare-hub worktree layout",
   "type": "module",
   "bin": {
@@ -10,14 +10,15 @@
     "dist/"
   ],
   "scripts": {
-    "build": "bun build src/cli.ts --outfile dist/cli.js --target node",
-    "prepublishOnly": "bun run build",
-    "test": "bun test",
+    "build": "npx esbuild src/cli.ts --bundle --platform=node --format=esm --outfile=dist/cli.js",
+    "prepublishOnly": "npm run build",
+    "test": "vitest run",
     "test:watch": "vitest",
+    "test:coverage": "vitest run --coverage",
     "release": "op run -- npm publish"
   },
   "devDependencies": {
-    "@types/bun": "latest",
+    "@types/node": "^20.0.0",
     "typescript": "^5.0.0",
     "vitest": "^2.0.0"
   },