arcane-cli 0.20.1 → 0.20.2

package/dist/index.js

@@ -6,7 +6,7 @@ const require = __createRequire(import.meta.url);
 import { Command } from "commander";
 import { createRequire as createRequire2 } from "module";
 import { fileURLToPath } from "url";
-import { dirname as dirname3, join as join12 } from "path";
+import { dirname as dirname4, join as join12 } from "path";
 
 // src/commands/init.ts
 import { select as select2, confirm, input as input2 } from "@inquirer/prompts";
@@ -1795,9 +1795,9 @@ async function runAgentsList(targetDir) {
 }
 
 // src/modules/push-safety.ts
-import { mkdir as mkdir4, readFile as readFile4, writeFile as writeFile5, chmod, access as access3, rm as rm2 } from "fs/promises";
+import { mkdir as mkdir4, readFile as readFile4, writeFile as writeFile5, chmod, access as access3, rm as rm2, readdir as readdir3 } from "fs/promises";
 import { constants } from "fs";
-import { join as join4, resolve } from "path";
+import { join as join4, resolve, dirname, basename } from "path";
 
 // src/modules/git.ts
 import { execFile } from "child_process";
@@ -2042,11 +2042,11 @@ async function readHooksPath(cwd) {
   const matched = known.find((candidate) => candidate === scope);
   return { value, scope: matched ?? "unknown" };
 }
-function isArcaneHooksPath(cwd, value) {
+function isArcaneHooksPath(root, value) {
   const windows = process.platform === "win32";
   const normalize = (p) => {
     const separated = windows ? p.replace(/\\/g, "/") : p;
-    const absolute = resolve(cwd, separated).replace(/\\/g, "/").replace(/\/+$/, "");
+    const absolute = resolve(root, separated).replace(/\\/g, "/").replace(/\/+$/, "");
     return windows ? absolute.toLowerCase() : absolute;
   };
   return normalize(value) === normalize(ARCANE_HOOKS_DIR);
@@ -2085,34 +2085,81 @@ function describeConfigScope(scope) {
       return "scope unknown";
   }
 }
-function hookFilePath(cwd) {
-  return join4(cwd, ARCANE_HOOKS_DIR, "pre-push");
+async function repositoryRoot(cwd) {
+  try {
+    const { stdout } = await runGit(cwd, [
+      "rev-parse",
+      "--path-format=absolute",
+      "--git-common-dir"
+    ]);
+    const commonDir = stdout.trim();
+    if (commonDir !== "") {
+      const parent = dirname(commonDir);
+      if (basename(commonDir) === ".git" && parent !== "") return parent;
+    }
+  } catch {
+  }
+  try {
+    const { stdout } = await runGit(cwd, ["rev-parse", "--show-toplevel"]);
+    const top = stdout.trim();
+    if (top !== "") return top;
+  } catch {
+  }
+  return cwd;
+}
+async function hookFilePath(cwd) {
+  return join4(await repositoryRoot(cwd), ARCANE_HOOKS_DIR, "pre-push");
+}
+async function hooksPathValue(cwd) {
+  return join4(await repositoryRoot(cwd), ARCANE_HOOKS_DIR).replace(/\\/g, "/");
 }
 async function installPrePushHook(cwd) {
+  const root = await repositoryRoot(cwd);
   const existing = await readHooksPath(cwd);
   if (existing?.unreadable === true) return { status: "refused-unreadable-config" };
-  if (existing !== void 0 && !isArcaneHooksPath(cwd, existing.value)) {
+  if (existing !== void 0 && !isArcaneHooksPath(root, existing.value)) {
     return {
       status: "refused-foreign-hooks-path",
       existing: existing.value,
       scope: existing.scope
     };
   }
-  const hookPath = hookFilePath(cwd);
+  if (existing === void 0) {
+    const displaced = await defaultHooks(cwd);
+    if (displaced.length > 0) {
+      return { status: "refused-default-hooks", hooks: displaced };
+    }
+  }
+  const hookPath = join4(root, ARCANE_HOOKS_DIR, "pre-push");
   if (existing !== void 0 && await hookBodyMatches(cwd)) return { status: "already-ours" };
-  await mkdir4(join4(cwd, ARCANE_HOOKS_DIR), { recursive: true });
+  await mkdir4(join4(root, ARCANE_HOOKS_DIR), { recursive: true });
   await writeFile5(hookPath, HOOK_BODY, "utf-8");
   await chmod(hookPath, 493);
-  await runGit(cwd, ["config", "--local", "core.hooksPath", ARCANE_HOOKS_DIR]);
+  await runGit(cwd, ["config", "--local", "core.hooksPath", await hooksPathValue(cwd)]);
   return { status: "installed", path: hookPath };
 }
 async function isHookEnforced(cwd) {
   const hooksPath = await readHooksPath(cwd);
-  if (hooksPath === void 0 || !isArcaneHooksPath(cwd, hooksPath.value)) return false;
+  if (hooksPath === void 0 || hooksPath.unreadable === true) return false;
+  if (!isArcaneHooksPath(await repositoryRoot(cwd), hooksPath.value)) return false;
   return hookBodyMatches(cwd);
 }
+async function defaultHooks(cwd) {
+  let hooksDir;
+  try {
+    const { stdout } = await runGit(cwd, ["rev-parse", "--git-common-dir"]);
+    hooksDir = join4(resolve(cwd, stdout.trim()), "hooks");
+  } catch {
+    return [];
+  }
+  try {
+    return (await readdir3(hooksDir)).filter((name) => !name.endsWith(".sample")).sort();
+  } catch {
+    return [];
+  }
+}
 async function hookBodyMatches(cwd) {
-  const hookPath = hookFilePath(cwd);
+  const hookPath = await hookFilePath(cwd);
   if (!await fileExists(hookPath)) return false;
   try {
     if (await readFile4(hookPath, "utf-8") !== HOOK_BODY) return false;
@@ -2130,7 +2177,7 @@ async function hookBodyMatches(cwd) {
 async function removePrePushHook(cwd) {
   const existing = await readHooksPath(cwd);
   if (existing === void 0 || existing.unreadable === true) return;
-  if (!isArcaneHooksPath(cwd, existing.value)) return;
+  if (!isArcaneHooksPath(await repositoryRoot(cwd), existing.value)) return;
   if (existing.scope !== "local" && existing.scope !== "worktree") return;
   const scopeFlag = existing.scope === "worktree" ? "--worktree" : "--local";
   try {
@@ -2138,7 +2185,7 @@ async function removePrePushHook(cwd) {
   } catch {
   }
   try {
-    await rm2(hookFilePath(cwd), { force: true });
+    await rm2(await hookFilePath(cwd), { force: true });
   } catch {
   }
 }
@@ -2183,11 +2230,11 @@ async function readScopedAll(cwd, key) {
   } catch {
     return [];
   }
-  return stdout.split("\n").map((line) => line.trimEnd()).filter(Boolean).map((line) => {
+  return stdout.split("\n").filter((line) => line !== "").map((line) => {
     const separator = line.indexOf("	");
     if (separator === -1) return { scope: "unknown", value: line.trim() };
     return { scope: line.slice(0, separator).trim(), value: line.slice(separator + 1).trim() };
-  }).filter((entry) => entry.value !== "");
+  });
 }
 async function effectivePushUrls(cwd, remote) {
   const scoped = await readScopedAll(cwd, `remote.${remote}.pushurl`);
@@ -2206,13 +2253,18 @@ async function disablePushUrls(cwd) {
 }
 async function disableOneRemote(cwd, remote) {
   const scoped = await readScopedAll(cwd, `remote.${remote}.pushurl`);
-  const foreign = scoped.filter((entry) => entry.scope !== "local" && entry.value !== DISABLED_PUSH_URL);
+  const OVERRIDABLE = /* @__PURE__ */ new Set(["local", "worktree"]);
+  const foreign = scoped.filter(
+    (entry) => !OVERRIDABLE.has(entry.scope) && entry.value !== DISABLED_PUSH_URL
+  );
   if (foreign.length > 0) {
-    const where = [...new Set(foreign.map((entry) => entry.scope))].join(", ");
+    const scopes = [...new Set(foreign.map((entry) => entry.scope))];
+    const where = scopes.join(", ");
+    const flag = scopes[0] === "unknown" ? "<scope>" : `--${scopes[0]}`;
     return {
       remote,
       status: "failed",
-      reason: `a push URL for this remote is configured at ${where} scope, which this repository cannot override \u2014 git would still deliver the push there. Remove it with \`git config --${where.split(", ")[0]} --unset-all remote.${remote}.pushurl\` and re-apply.`
+      reason: `a push URL for this remote is configured at ${where} scope, which this repository cannot override \u2014 git would still deliver the push there. Remove it with \`git config ${flag} --unset-all remote.${remote}.pushurl\` and re-apply.`
     };
   }
   const currentPushUrls = scoped.map((entry) => entry.value);
@@ -2237,6 +2289,15 @@ async function disableOneRemote(cwd, remote) {
     `remote.${remote}.pushurl`,
     DISABLED_PUSH_URL
   ]);
+  const after = await effectivePushUrls(cwd, remote);
+  if (after.length !== 1 || after[0] !== DISABLED_PUSH_URL) {
+    const live = after.filter((url) => url !== DISABLED_PUSH_URL);
+    return {
+      remote,
+      status: "failed",
+      reason: `the sentinel was written but git still resolves a live push URL for this remote (${live.join(", ")}). It most likely comes from a file this repository \`include\`s, which \`--replace-all\` cannot remove. Run \`git config --show-origin --get-all remote.${remote}.pushurl\` to find the file, and clear it there.`
+    };
+  }
   return { remote, status: "disabled" };
 }
 async function undisabledRemotes(cwd) {
@@ -2277,7 +2338,7 @@ async function restoreOneRemote(cwd, remote) {
     hadNone = false;
   }
   if (hadNone) {
-    await runGit(cwd, ["config", "--local", "--unset-all", `remote.${remote}.pushurl`]);
+    await unsetIgnoringMissing(cwd, `remote.${remote}.pushurl`);
   } else {
     await runGit(cwd, [
       "config",
@@ -2292,12 +2353,19 @@ async function restoreOneRemote(cwd, remote) {
   }
   for (const staleKey of [key, NO_PUSH_URL_MARKER(remote), `arcane.originalPushUrl.${remote}`]) {
     try {
-      await runGit(cwd, ["config", "--local", "--unset-all", staleKey]);
+      await unsetIgnoringMissing(cwd, staleKey);
     } catch {
     }
   }
   return { remote, status: "restored" };
 }
+async function unsetIgnoringMissing(cwd, key) {
+  try {
+    await runGit(cwd, ["config", "--local", "--unset-all", key]);
+  } catch (error) {
+    if (error.code !== 5) throw error;
+  }
+}
 async function hadNoPushUrl(cwd, remote) {
   return (await readLocalAll(cwd, NO_PUSH_URL_MARKER(remote)))[0] === "true";
 }
@@ -2659,6 +2727,10 @@ async function runInit(options, targetDir, assetsDir, packageVersion) {
           printWarning(
             "Did not install the pre-push hook: git could not report the current core.hooksPath (unreadable config, or a git too old for `--show-scope`). Installing without knowing whether another hook manager owns that setting could silently disable it. Fix the config and run `spell doctor`."
           );
+        } else if (hook.status === "refused-default-hooks") {
+          printWarning(
+            `Did not install the pre-push hook: this repository has hooks in git's default directory (${hook.hooks.join(", ")}). Setting core.hooksPath would silently stop them running. Move them under \`${ARCANE_HOOKS_DIR}\` yourself and re-run, or add the push guard to your existing pre-push hook.`
+          );
         } else if (hook.status === "refused-foreign-hooks-path") {
           printWarning(
             `Did not install the pre-push hook: core.hooksPath is already "${hook.existing}" (${describeConfigScope(hook.scope)}), so another hook manager owns it. Overwriting would silently disable those hooks. Chain an Arcane pre-push guard into that directory yourself, or unset core.hooksPath first.`
@@ -2819,7 +2891,7 @@ import { join as join8 } from "path";
 
 // src/modules/hub.ts
 import { confirm as confirm2, select as select3, input as input3 } from "@inquirer/prompts";
-import { readdir as readdir3, writeFile as writeFile6 } from "fs/promises";
+import { readdir as readdir4, writeFile as writeFile6 } from "fs/promises";
 import { join as join7 } from "path";
 var MANIFEST_RETROFITS = [
   {
@@ -2963,7 +3035,7 @@ async function offerRegistryScaffold(targetDir, businessRoot) {
   const businessRootPath = join7(targetDir, businessRoot);
   let ventureDirs;
   try {
-    const entries = await readdir3(businessRootPath, { withFileTypes: true });
+    const entries = await readdir4(businessRootPath, { withFileTypes: true });
     ventureDirs = entries.filter((e) => e.isDirectory() && e.name !== "_template").map((e) => e.name);
   } catch {
     return;
@@ -3170,7 +3242,7 @@ async function runUpdate(options, targetDir, assetsDir, packageVersion) {
 
 // src/modules/version-check.ts
 import { readFile as readFile5, writeFile as writeFile7, mkdir as mkdir5 } from "fs/promises";
-import { dirname, join as join9 } from "path";
+import { dirname as dirname2, join as join9 } from "path";
 import { homedir as homedir2 } from "os";
 import { createRequire } from "module";
 var require2 = createRequire(import.meta.url);
@@ -3199,7 +3271,7 @@ async function readCache(cachePath) {
   }
 }
 async function writeCache(cachePath, latest) {
-  await mkdir5(dirname(cachePath), { recursive: true });
+  await mkdir5(dirname2(cachePath), { recursive: true });
   const entry = { latest, checkedAt: (/* @__PURE__ */ new Date()).toISOString() };
   await writeFile7(cachePath, JSON.stringify(entry, null, 2), "utf-8");
 }
@@ -3409,7 +3481,7 @@ Run \`spell unblock-push\` first (interactive), then uninstall.`
 
 // src/commands/doctor.ts
 import { access as access4, readFile as readFile6, mkdir as mkdir6, copyFile as fsCopyFile2 } from "fs/promises";
-import { join as join11, dirname as dirname2 } from "path";
+import { join as join11, dirname as dirname3 } from "path";
 import { execFile as execFile2 } from "child_process";
 import { promisify } from "util";
 
@@ -3502,8 +3574,8 @@ async function checkVSCodeExtension(id, label) {
   ];
   for (const dir of extDirs) {
     try {
-      const { readdir: readdir4 } = await import("fs/promises");
-      const entries = await readdir4(dir);
+      const { readdir: readdir5 } = await import("fs/promises");
+      const entries = await readdir5(dir);
       const prefix = id.toLowerCase() + "-";
       const found = entries.some(
         (e) => e.toLowerCase() === id.toLowerCase() || e.toLowerCase().startsWith(prefix)
@@ -3651,7 +3723,7 @@ async function fixSessionContinuity(targetDir, assetsDir) {
       await access4(destPath);
     } catch {
       const srcPath = join11(assetsDir, file);
-      await mkdir6(dirname2(destPath), { recursive: true });
+      await mkdir6(dirname3(destPath), { recursive: true });
       await fsCopyFile2(srcPath, destPath);
       created.push(file);
     }
@@ -3762,7 +3834,7 @@ async function runDoctor(targetDir, options = {}, assetsDir) {
 }
 
 // src/commands/unblock-push.ts
-import { basename, resolve as resolve2 } from "path";
+import { basename as basename2, resolve as resolve2 } from "path";
 import { input as input4 } from "@inquirer/prompts";
 async function runUnblockPush(targetDir) {
   let manifest;
@@ -3777,10 +3849,16 @@ async function runUnblockPush(targetDir) {
     throw err;
   }
   const policy = manifest.push_policy ?? "open";
-  if (policy === "open") {
+  const stillInForce = await isHookEnforced(targetDir) || (await blockedRemotes(targetDir)).length > 0;
+  if (policy === "open" && !stillInForce) {
     printInfo("This repository is not push-blocked \u2014 nothing to undo.");
     return;
   }
+  if (policy === "open") {
+    printWarning(
+      "The manifest says push_policy: open, but this repository still has Arcane's push block in force \u2014 most likely a previous unblock only partly succeeded. Continuing so it can be finished."
+    );
+  }
   if (!process.stdin.isTTY) {
     console.error(
       "spell unblock-push must be run from an interactive terminal.\nLifting a push block is a deliberate decision, so it cannot be scripted, piped, or run in CI."
@@ -3788,7 +3866,7 @@ async function runUnblockPush(targetDir) {
     process.exit(1);
     return;
   }
-  const repoName = basename(resolve2(targetDir));
+  const repoName = basename2(resolve2(targetDir));
   if (repoName === "") {
     console.error(
       "Could not determine a repository name to confirm against (is this repository at a filesystem root?). Refusing to unblock."
@@ -3857,7 +3935,7 @@ Name did not match ("${typed.trim()}" \u2260 "${repoName}"). Nothing changed.`);
 import { realpathSync } from "fs";
 var require3 = createRequire2(import.meta.url);
 var pkg = require3("../package.json");
-var ASSETS_DIR = process.env["ARCANE_ASSETS_DIR"] ?? join12(dirname3(fileURLToPath(import.meta.url)), "assets");
+var ASSETS_DIR = process.env["ARCANE_ASSETS_DIR"] ?? join12(dirname4(fileURLToPath(import.meta.url)), "assets");
 var program = new Command();
 program.name("spell").description("Arcane framework CLI \u2014 scaffold and manage governance files").version(pkg.version).action(async () => {
   await printWelcome(pkg.version, process.cwd());