@sayansr26/agent-os 0.5.3 → 0.6.0

package/src/plugin.mjs

@@ -1,23 +1,37 @@
 /**
- * Install the Claude Code half of agent-os during `init`.
+ * Install or update the Claude Code half of agent-os during `init`.
  *
  * The CLI compiles rules for every tool. Claude Code additionally gets the
- * agents, skills, per-agent memory and session hook, which ship as a plugin —
- * so `init` should install it rather than printing two slash commands and
- * hoping. `claude plugin ...` with `--yes` is the documented automation path.
+ * agents, skills, per-agent memory and hooks, which ship as a plugin. `init`
+ * brings that plugin to the latest version whatever state it finds:
  *
- * Everything here is best effort and reversible: if the `claude` CLI is not on
- * PATH, or a command fails, `init` reports it and carries on. The rules are the
- * part that must not depend on this.
+ *   not installed        marketplace add + install, at project scope
+ *   installed, disabled  enable
+ *   installed            refresh the marketplace, then update
+ *
+ * An installed plugin is never left behind: Claude Code pins the cached
+ * version, so a project installed once stays on that version until something
+ * updates it — which is how a project ended up running 0.4.1 hooks.
+ *
+ * Every command runs with the project as its working directory, so project
+ * scope means *this* project even with --root. Best effort throughout: if the
+ * `claude` CLI is missing or a command fails, `init` reports it and carries
+ * on. The rules are the part that must not depend on this.
  */
 import { spawnSync } from "node:child_process";
+import { realpathSync } from "node:fs";
+import { bundledVersion, cmpVersion } from "../plugins/agent-os/skills/init/scripts/state.mjs";
 
 export const MARKETPLACE = "sayansr26/agent-os";
 export const MARKETPLACE_NAME = "sayan-plugins";
 export const PLUGIN = "agent-os";
+const ID = `${PLUGIN}@${MARKETPLACE_NAME}`;
 
-const run = (args) =>
-  spawnSync("claude", args, { encoding: "utf8", stdio: ["ignore", "pipe", "pipe"] });
+const run = (args, cwd) =>
+  spawnSync("claude", args, { cwd, encoding: "utf8", stdio: ["ignore", "pipe", "pipe"], timeout: 120000 });
+const json = (r) => { try { return JSON.parse(r.stdout); } catch { return null; } };
+const real = (p) => { try { return realpathSync(p); } catch { return p; } };
+const tail = (r) => (r.stderr || r.stdout || String(r.error || "")).trim().split("\n").slice(-3);
 
 /** Is the Claude Code CLI usable from here? */
 export function claudeAvailable() {
@@ -25,50 +39,77 @@ export function claudeAvailable() {
   return !r.error && r.status === 0;
 }
 
+/** This project's install of the plugin, per `claude plugin list --json`, or null. */
+export function installed(root) {
+  const list = json(run(["plugin", "list", "--json"], root));
+  if (!Array.isArray(list)) return null;
+  const mine = list.filter((p) => p.id === ID &&
+    (p.scope === "user" || (p.projectPath && real(p.projectPath) === real(root))));
+  return mine.find((p) => p.scope === "project" || p.scope === "local") || mine[0] || null;
+}
+
 /**
- * Add the marketplace and install the plugin at project scope, so the setup
- * travels with the repository instead of living on one machine.
+ * Bring the plugin to the latest version for this project.
+ * Returns { ok, reason, from, to, done, hint } with reason one of
+ * "installed" | "updated" | "current" | "dry-run" | "no-cli" | "failed".
  */
-export function installPlugin({ dry = false, scope = "project" } = {}) {
-  const steps = [
-    ["marketplace", ["plugin", "marketplace", "add", MARKETPLACE, "--scope", scope]],
-    ["plugin", ["plugin", "install", `${PLUGIN}@${MARKETPLACE_NAME}`, "--scope", scope, "--yes"]],
-  ];
-
+export function ensurePlugin({ root = process.cwd(), dry = false, scope = "project" } = {}) {
   if (!claudeAvailable())
     return {
-      ok: false,
-      reason: "no-cli",
-      done: [],
+      ok: false, reason: "no-cli", done: [],
       hint: [
-        "The `claude` CLI is not on PATH, so the plugin was not installed.",
+        "The `claude` CLI is not on PATH, so the plugin was not installed or updated.",
         "Inside Claude Code, run:",
         `  /plugin marketplace add ${MARKETPLACE}`,
-        `  /plugin install ${PLUGIN}@${MARKETPLACE_NAME}`,
+        `  /plugin install ${ID}     (or /plugin update ${ID} if it is already there)`,
       ],
     };
 
+  const before = installed(root);
+  const markets = json(run(["plugin", "marketplace", "list", "--json"], root));
+  const haveMarket = Array.isArray(markets) && markets.some((m) => m.name === MARKETPLACE_NAME);
+
+  const steps = [];
+  steps.push(haveMarket
+    ? ["plugin", "marketplace", "update", MARKETPLACE_NAME]
+    : ["plugin", "marketplace", "add", MARKETPLACE, "--scope", scope]);
+  if (!before) steps.push(["plugin", "install", ID, "--scope", scope, "--yes"]);
+  else {
+    if (before.enabled === false) steps.push(["plugin", "enable", ID, "--scope", before.scope]);
+    steps.push(["plugin", "update", ID, "--scope", before.scope, "--yes"]);
+  }
+
   if (dry)
-    return { ok: true, reason: "dry-run", done: steps.map(([, a]) => `claude ${a.join(" ")}`), hint: [] };
+    return { ok: true, reason: "dry-run", from: before?.version || null, done: steps.map((a) => `claude ${a.join(" ")}`), hint: [] };
 
   const done = [];
-  for (const [what, args] of steps) {
-    const r = run(args);
+  for (const args of steps) {
+    const r = run(args, root);
     if (r.status !== 0) {
-      const err = (r.stderr || r.stdout || "").trim().split("\n").slice(-3).join("\n");
       return {
-        ok: false,
-        reason: what,
-        done,
+        ok: false, reason: "failed", from: before?.version || null, done,
         hint: [
           `\`claude ${args.join(" ")}\` failed:`,
-          ...err.split("\n").map((l) => `  ${l}`),
-          "The rules above were still written. Install the plugin by hand inside",
-          `Claude Code: /plugin install ${PLUGIN}@${MARKETPLACE_NAME}`,
+          ...tail(r).map((l) => `  ${l}`),
+          "The rules and settings above were still written. Inside Claude Code:",
+          before ? `  /plugin update ${ID}, then /reload-plugins` : `  /plugin install ${ID}`,
         ],
       };
     }
     done.push(`claude ${args.join(" ")}`);
   }
-  return { ok: true, reason: "installed", done, hint: [] };
+
+  const after = installed(root);
+  const to = after?.version || null;
+  const from = before?.version || null;
+  const want = bundledVersion();
+  const hint = [];
+  // The marketplace serves what is pushed to GitHub; this package may be newer.
+  if (to && want && cmpVersion(to, want) < 0)
+    hint.push(`Marketplace still serves ${to}; this agent-os ships ${want}. It updates once ${MARKETPLACE} is pushed.`);
+  return {
+    ok: true,
+    reason: !before ? "installed" : from !== to ? "updated" : "current",
+    from, to, done, hint,
+  };
 }

package/src/selftest.mjs

@@ -8,6 +8,12 @@ import { spawnSync } from "node:child_process";
 import { fileURLToPath } from "node:url";
 
 const PKG = join(fileURLToPath(new URL(".", import.meta.url)), "..");
+// Every child inherits this, so nothing here can ever touch the real ~/.claude.
+const HOME = mkdtempSync(join(tmpdir(), "agent-os-home-"));
+process.env.CLAUDE_CONFIG_DIR = HOME;
+const PLUGIN = join(PKG, "plugins/agent-os");
+const node = (script, args, opts = {}) =>
+  spawnSync(process.execPath, [join(PLUGIN, script), ...args], { encoding: "utf8", ...opts });
 const cli = (args, cwd) => spawnSync(process.execPath, [join(PKG, "bin/agent-os.mjs"), ...args, "--root", cwd], { encoding: "utf8" });
 let fail = 0;
 const ok = (c, m) => { console.log(`  ${c ? "ok  " : "FAIL"} ${m}`); if (!c) fail++; };
@@ -85,13 +91,14 @@ try {
     ok(existsSync(join(r2, ".agent-os/rules/theming.md")), "existing .claude/rules/ are adopted");
     ok(!existsSync(join(r2, ".agent-os/rules/example.md")), "no example.md when real rules were adopted");
     ok(!existsSync(join(r2, ".claude/rules/example.md")), "no example.md compiled into the project");
-    ok(!i.stdout.includes("Claude Code plugin"), "--no-plugin skips the plugin install");
+    ok(!i.stdout.includes("--no-plugin skips this"), "--no-plugin skips the plugin install");
 
     // init offers the plugin when not told otherwise; --dry-run proves the
     // commands without running them against the machine's real config.
     const r4 = mkdtempSync(join(tmpdir(), "agent-os-plug-"));
     const pi = cli(["init", "--dry-run"], r4);
-    ok(pi.stdout.includes("Claude Code plugin"), "init sets up the Claude Code plugin by default");
+    ok(pi.stdout.includes("--no-plugin skips this"), "init sets up the Claude Code plugin by default");
+    ok(pi.stdout.includes("SETUP  FRESH"), "init on an empty project reports a fresh setup");
     ok(/marketplace add sayansr26\/agent-os|plugin marketplace add|not on PATH/.test(pi.stdout),
        "init names the marketplace step or says why it could not run it");
     rmSync(r4, { recursive: true, force: true });
@@ -129,6 +136,20 @@ try {
     ok(st.env.CLAUDE_CODE_ENABLE_TODO_TOOLS === "1", "todo tools enabled in project settings");
     ok(st.env.FOO === "bar", "existing env keys preserved");
     ok(st.permissions?.deny?.[0] === "Bash(git push *)", "existing permissions preserved");
+    ok(st.permissions.deny.length === 42, "git write protection merged into project settings, no duplicate push rule");
+    ok(!existsSync(join(HOME, "settings.json")), "without --global (and no terminal) ~/.claude is left alone");
+    ok(!existsSync(join(r5, ".claude/settings.json.agent-os.bak")), "no backup litter inside the project");
+
+    const again = cli(["init", "--no-plugin", "--global"], r5).stdout;
+    ok(again.includes("SETUP  REPAIR") && again.includes("MISSING ~/.claude/settings.json git write protection"),
+       "init on a set-up project reports a repair and names what is missing");
+    ok(again.includes("kept .agent-os/"), "repair keeps the existing source instead of re-scaffolding");
+    const us = JSON.parse(readFileSync(join(HOME, "settings.json"), "utf8"));
+    ok(us.permissions.deny.includes("Bash(git commit *)") && us.env.CLAUDE_CODE_ENABLE_TODO_TOOLS === "1",
+       "--global writes git protection and task tools to ~/.claude/settings.json");
+    ok(readFileSync(join(HOME, "CLAUDE.md"), "utf8").includes("TaskCreate"), "--global adds the task rule to ~/.claude/CLAUDE.md");
+    cli(["init", "--no-plugin", "--global"], r5);
+    ok(JSON.parse(readFileSync(join(HOME, "settings.json"), "utf8")).permissions.deny.length === 42, "second --global run adds nothing");
 
     const cm = readFileSync(join(r5, "CLAUDE.md"), "utf8");
     ok(cm.includes("TaskCreate / TaskUpdate"), "task-tracking rule added to CLAUDE.md");
@@ -155,13 +176,51 @@ try {
     rmSync(r6, { recursive: true, force: true });
   }
 
+  console.log("\n  plugin hooks");
+  {
+    const r7 = mkdtempSync(join(tmpdir(), "agent-os-hooks-"));
+    const mem = join(r7, ".claude/agent-memory/agent-os-feature-cartographer");
+    mkdirSync(mem, { recursive: true });
+    for (const f of ["billing", "orders", "search"]) mkdirSync(join(r7, "src/features", f), { recursive: true });
+    writeFileSync(join(mem, "_architecture.md"), "# Architecture\n");
+    writeFileSync(join(mem, "billing.md"), "---\nmapped: 2026-01-01\nentry: src/features/billing/index.ts\n---\n# billing\n");
+    writeFileSync(join(mem, "MEMORY.md"), "- billing — src/features/billing — mapped 2026-01-01\n");
+    mkdirSync(join(r7, ".agent-os/rules"), { recursive: true });
+    writeFileSync(join(r7, ".agent-os/rules/api.md"), '---\npaths:\n  - "src/**"\n---\n\nSource body.\n');
+    mkdirSync(join(r7, ".claude/rules"), { recursive: true });
+    writeFileSync(join(r7, ".claude/rules/api.md"), "---\n---\n\n<!-- agent-os: generated from .agent-os/ — edit the source -->\nEdited in place.\n");
+    const env = { ...process.env, CLAUDE_PROJECT_DIR: r7 };
+
+    const start = node("hooks/session-resume.mjs", [], { cwd: r7, env }).stdout;
+    ok(start.includes("agent-os is active") && start.includes("agent-os:feature-cartographer"), "session start announces the agents");
+    ok(start.includes("Mapped: 1 of 3 features") && start.includes("billing"), "session start says what is mapped");
+
+    const run = `selftest-${process.pid}-${Date.now()}`;
+    const edit = (file, session = run) => node("hooks/pre-edit.mjs", [], {
+      env, input: JSON.stringify({ session_id: session, cwd: r7, tool_input: { file_path: join(r7, file) } }),
+    }).stdout;
+    const denied = edit(".claude/rules/api.md");
+    ok(denied.includes('"deny"') && denied.includes(".agent-os/rules/api.md"), "edit to a generated rule is blocked, source named");
+    ok(edit("src/features/orders/a.ts").includes("no cartographer map"), "first edit to an unmapped feature reminds");
+    ok(edit("src/features/orders/b.ts") === "", "reminder shows once per feature per session");
+    ok(edit("src/features/billing/a.ts") === "", "mapped feature stays silent");
+    ok(edit("src/lib/x.ts") === "", "non-feature path stays silent");
+
+    mkdirSync(join(mem, ".claude/agent-memory"), { recursive: true });
+    const audit = node("skills/init/scripts/audit.mjs", [r7]).stdout;
+    ok(/api\.md was edited in place/.test(audit), "audit flags a generated rule that drifted from its source");
+    ok(audit.includes("folder inside agent memory"), "audit flags a nested folder in agent memory");
+    ok(audit.includes("1 of 3 (33%)"), "audit reports map coverage, not just that a folder exists");
+    rmSync(r7, { recursive: true, force: true });
+  }
+
   console.log("\n  merge, not overwrite");
   writeFileSync(join(root, "opencode.json"), JSON.stringify({ model: "anthropic/x", instructions: ["KEEP.md"] }, null, 2));
   cli(["sync"], root);
   const oc = JSON.parse(read("opencode.json"));
   ok(oc.model === "anthropic/x", "existing keys preserved");
   ok(oc.instructions.includes("KEEP.md"), "existing instructions preserved");
-} finally { rmSync(root, { recursive: true, force: true }); }
+} finally { rmSync(root, { recursive: true, force: true }); rmSync(HOME, { recursive: true, force: true }); }
 
 console.log(`\n${fail ? `FAILED (${fail})` : "PASSED"}\n`);
 process.exit(fail ? 1 : 0);