forgedock 1.1.3 → 1.1.4

package/bin/forgedock.mjs

@@ -7,6 +7,7 @@ import { dirname, join, relative, resolve } from "path";
 import { mkdir, lstat, readlink, readdir, unlink, readFile, writeFile } from "fs/promises";
 import {
   existsSync,
+  lstatSync,
   readFileSync,
   writeFileSync,
   renameSync,
@@ -63,7 +64,64 @@ import { buildMinimalForgeYaml } from "./init-detect.mjs";
 
 const __filename = fileURLToPath(import.meta.url);
 const __dirname = dirname(__filename);
-const FORGE_HOME = dirname(__dirname);
+
+/**
+ * Resolve the real ForgeDock installation root, guarding against the case
+ * where forgedock.mjs is executed from inside a git worktree.
+ *
+ * A git worktree always has a `.git` FILE (not directory) at its root that
+ * points back to the main repository's `.git` directory. When forgedock runs
+ * from a worktree, `dirname(__dirname)` resolves to the ephemeral worktree
+ * path — causing symlinks in `~/.claude/commands/` to point inside the
+ * worktree. After the worktree is cleaned up, those symlinks become dangling
+ * refs and all slash commands fail.
+ *
+ * Detection: if `dir/.git` is a regular file, we are inside a worktree.
+ * Resolution: run `git rev-parse --git-common-dir` (cwd: dir) which returns
+ * the path to the main `.git` directory; its parent is the stable repo root.
+ *
+ * Falls back to `dir` unchanged when:
+ *  - `dir/.git` is a directory (normal git clone — already correct)
+ *  - `dir/.git` does not exist (npm-installed package — already correct)
+ *  - Any error occurs (git not available, unexpected structure, etc.)
+ *
+ * @param {string} dir - Candidate FORGE_HOME (typically dirname(__dirname))
+ * @returns {string} Stable repo root, or `dir` if no worktree is detected
+ */
+function resolveRealForgeHome(dir) {
+  try {
+    const gitEntry = join(dir, ".git");
+    let stat;
+    try {
+      stat = lstatSync(gitEntry);
+    } catch {
+      // ENOENT → npm-installed package with no .git at all — return as-is
+      return dir;
+    }
+    if (!stat.isFile()) {
+      // .git is a directory → normal git clone, already points at the real root
+      return dir;
+    }
+    // .git is a file → we are inside a git worktree.
+    // `git rev-parse --git-common-dir` returns the path to the shared .git dir
+    // of the main worktree.  On some git versions the path is relative to cwd,
+    // so resolve it against `dir` before taking dirname.
+    const commonDir = execSync("git rev-parse --git-common-dir", {
+      cwd: dir,
+      encoding: "utf-8",
+      stdio: ["pipe", "pipe", "pipe"],
+      timeout: 5000,
+    }).trim();
+    // dirname(".git") = "." when commonDir is a bare ".git" string
+    const mainRepoRoot = dirname(resolve(dir, commonDir));
+    return mainRepoRoot;
+  } catch {
+    // Any failure (git not found, exit non-zero, etc.) — fail safe
+    return dir;
+  }
+}
+
+const FORGE_HOME = resolveRealForgeHome(dirname(__dirname));
 const COMMANDS_DIR = join(FORGE_HOME, "commands");
 
 // Resolve home cross-platform: HOME on Unix, USERPROFILE on Windows, with
@@ -929,9 +987,23 @@ async function update() {
         cwd: FORGE_HOME,
         encoding: "utf-8",
       }).trim();
-      if (branch !== "main") {
-        console.log(`  Not on main branch (${branch}) — skipping`);
-        return;
+
+      // If on a non-main branch, switch to main for the update then restore.
+      // Detached HEAD ("HEAD") is treated as non-restorable — we leave on main
+      // after the update and warn the user.
+      const isDetached = branch === "HEAD";
+      const needsCheckout = branch !== "main";
+      if (needsCheckout) {
+        if (isDetached) {
+          console.log(
+            `  ${YELLOW}Detached HEAD state — switching to main for update.${RESET}`,
+          );
+        } else {
+          console.log(
+            `  On branch ${CYAN}${branch}${RESET} — switching to ${CYAN}main${RESET} for update...`,
+          );
+        }
+        execSync("git checkout main --quiet", { cwd: FORGE_HOME });
       }
 
       const before = execSync("git rev-parse HEAD", {
@@ -953,6 +1025,20 @@ async function update() {
         console.log(`  ${GREEN}Updated to latest.${RESET}`);
       }
       await relinkAndHint();
+
+      // Restore original branch after a successful update.
+      if (needsCheckout && !isDetached) {
+        try {
+          execSync(`git checkout ${branch} --quiet`, { cwd: FORGE_HOME });
+          console.log(
+            `  Restored branch ${CYAN}${branch}${RESET}.`,
+          );
+        } catch {
+          console.log(
+            `  ${YELLOW}⚠  Could not restore branch ${branch} — you are now on main.${RESET}`,
+          );
+        }
+      }
     } catch (err) {
       console.log(
         `  ${YELLOW}Cannot fast-forward — local changes exist. Skipping.${RESET}`,

package/bin/journey.mjs

@@ -470,6 +470,68 @@ async function saveCopiedManifest(manifestPath, manifest) {
 
 const isLinkPermissionError = (err) => err.code === "EPERM" || err.code === "EACCES";
 
+/**
+ * Recursively walk targetDir and remove any symlink whose target begins with
+ * commandsDir (i.e. a ForgeDock-managed link) but whose target file no longer
+ * exists on disk. These are "orphaned" symlinks left behind when a command is
+ * renamed or deleted.
+ *
+ * Safety invariant: only symlinks whose readlink() result starts with
+ * commandsDir + "/" are touched. User-owned symlinks and third-party links are
+ * never removed.
+ *
+ * @param {string} targetDir   - ~/.claude/commands (installed commands root)
+ * @param {string} commandsDir - FORGE_HOME/commands (source commands root)
+ * @returns {Promise<number>} Number of orphaned symlinks removed.
+ */
+async function pruneOrphanedSymlinks(targetDir, commandsDir) {
+  const prefix = commandsDir + "/";
+  let pruned = 0;
+
+  async function walk(dir) {
+    let entries;
+    try {
+      entries = await readdir(dir, { withFileTypes: true });
+    } catch (err) {
+      if (err.code === "ENOENT") return; // targetDir doesn't exist yet — nothing to prune
+      throw err;
+    }
+    for (const entry of entries) {
+      const full = join(dir, entry.name);
+      if (entry.isDirectory()) {
+        await walk(full);
+      } else if (entry.isSymbolicLink()) {
+        let target;
+        try {
+          target = await readlink(full);
+        } catch {
+          continue; // can't read link — skip
+        }
+        // Only manage links that point into our commandsDir
+        if (!target.startsWith(prefix)) continue;
+        // Check whether the target file still exists
+        try {
+          await lstat(target);
+          // target exists — not orphaned
+        } catch (err) {
+          if (err.code !== "ENOENT") continue; // unexpected error — skip to be safe
+          // target is gone → orphaned symlink
+          try {
+            await unlink(full);
+            pruned++;
+          } catch (unlinkErr) {
+            if (unlinkErr.code !== "ENOENT") throw unlinkErr;
+            // already gone — race condition, that's fine
+          }
+        }
+      }
+    }
+  }
+
+  await walk(targetDir);
+  return pruned;
+}
+
 /**
  * Act II: link commands into ~/.claude/commands with a molten progress line,
  * then register the SessionStart hook.
@@ -611,6 +673,10 @@ export async function forge(ctx) {
   }
   if (barShown) w.write("\x1b[1A\x1b[2K");
 
+  // Prune orphaned symlinks: links that point into commandsDir but whose
+  // target file no longer exists (e.g. after a command is renamed or deleted).
+  const pruned = await pruneOrphanedSymlinks(targetDir, commandsDir);
+
   const hookScript = join(ctx.forgeHome, "bin", "hooks", "session-start.mjs");
   const settingsPath = join(ctx.home, ".claude", "settings.json");
   const { status: hookStatus } = installSessionStartHook(settingsPath, hookScript);
@@ -648,6 +714,9 @@ export async function forge(ctx) {
     ? `(new ${installed}, copied ${copied}, updated ${updated}, unchanged ${skipped})`
     : `(new ${installed}, updated ${updated}, unchanged ${skipped})`;
   w.write(`  ${glyph(true)} ${files.length} slash commands ${headlineVerb} ${dimLine(ctx, headlineDetail)}\n`);
+  if (pruned > 0) {
+    w.write(`  ${glyph(true)} ${pruned} orphaned symlink${pruned === 1 ? "" : "s"} removed ${dimLine(ctx, "(commands deleted or renamed since last install)")}\n`);
+  }
   if (copied > 0) {
     w.write(`  ${glyph(false)} ${copied} copied (not linked) ${dimLine(ctx, "— enable Windows Developer Mode for live-updating links")}\n`);
   }
@@ -677,7 +746,7 @@ export async function forge(ctx) {
     w.write(`  ${glyph(true)} SubagentStop enforcement hook removed ${dimLine(ctx, "(non-functional — see forge#1527)")}\n`);
   }
 
-  return { installed, updated, skipped, copied, total: files.length, hookStatus, preToolUseStatus, subagentStopEnforceStatus };
+  return { installed, updated, skipped, copied, pruned, total: files.length, hookStatus, preToolUseStatus, subagentStopEnforceStatus };
 }
 
 // ---------------------------------------------------------------------------

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "forgedock",
-  "version": "1.1.3",
+  "version": "1.1.4",
   "description": "Autonomous dev pipeline for Claude Code. GitHub as institutional memory — every issue, PR, and annotation survives context resets and makes the next agent smarter.",
   "bin": {
     "forgedock": "bin/forgedock.mjs"