@jaybeeuu/agent-cortex 1.41.1 → 1.43.0

package/test/cli.test.mjs

@@ -123,11 +123,6 @@ describe("parseArgs", () => {
     assert.deepStrictEqual(result, { command: "install", harness: "pi", pluginRoot: "/tmp/plugin" });
   });
 
-  it("parses --no-provision for install", async () => {
-    const result = parseArgs(["install", "pi", "--no-provision"]);
-    assert.deepStrictEqual(result, { command: "install", harness: "pi", noProvision: true });
-  });
-
   it("combines multiple install options", async () => {
     const result = parseArgs(["install", "pi", "--dry-run", "--output", "/tmp/out", "--plugin-root", "/tmp/plugin"]);
     assert.deepStrictEqual(result, {
@@ -236,14 +231,6 @@ describe("CLI integration", () => {
     }
   });
 
-  it("exits 0 for install pi --no-provision", async () => {
-    // --no-provision keeps this hermetic: without it the CLI would install the
-    // third-party packages declared in the package manifest.
-    const { exitCode, stdout } = await runCli(["install", "pi", "--no-provision"]);
-    assert.equal(exitCode, 0);
-    assert.ok(stdout.includes("pi"));
-  });
-
   it("exits 1 and prints error for install with no harness", async () => {
     const { exitCode, stderr } = await runCli(["install"]);
     assert.equal(exitCode, 1);
@@ -256,6 +243,12 @@ describe("CLI integration", () => {
     assert.ok(stderr.includes("--bogus"));
   });
 
+  it("exits 1 for the removed --no-provision flag", async () => {
+    const { exitCode, stderr } = await runCli(["install", "pi", "--no-provision"]);
+    assert.equal(exitCode, 1);
+    assert.ok(stderr.includes("--no-provision"), "the removed flag is named in the error");
+  });
+
   it("exits 1 and prints error for install with a missing option value", async () => {
     const { exitCode, stderr } = await runCli(["install", "pi", "--output"]);
     assert.equal(exitCode, 1);
@@ -263,30 +256,33 @@ describe("CLI integration", () => {
   });
 
   it("exits 0 for install pi --dry-run and writes nothing", async () => {
-    const { exitCode, stdout } = await runCli(["install", "pi", "--dry-run"]);
-    assert.equal(exitCode, 0);
-    assert.ok(stdout.includes("ralph.agent.md"));
-    assert.ok(stdout.includes("dry-run"));
+    // A throwaway HOME keeps the registration plan (which reads pi's settings)
+    // off the developer's real ~/.pi/agent.
+    const fakeHome = await mkdtemp(join(tmpdir(), "cli-pi-dry-run-home-"));
+    try {
+      const { exitCode, stdout } = await runCli(["install", "pi", "--dry-run"], { HOME: fakeHome });
+      assert.equal(exitCode, 0);
+      assert.ok(stdout.includes("ralph.agent.md"));
+      assert.ok(stdout.includes("dry-run"));
+    } finally {
+      await rm(fakeHome, { recursive: true, force: true });
+    }
   });
 
-  it("install pi --dry-run lists the pi packages it would install", async () => {
-    // Fake HOME keeps the pi user scope hermetic: both manifest packages are
-    // missing, so the plan contains exactly the declared sources.
+  it("install pi --dry-run reports the bundled pi packages it would stage", async () => {
     const fakeHome = await mkdtemp(join(tmpdir(), "cli-pi-home-"));
     try {
       const { exitCode, stdout } = await runCli(["install", "pi", "--dry-run"], { HOME: fakeHome });
       assert.equal(exitCode, 0);
-      assert.ok(stdout.includes("Would install pi package npm:pi-questions"), "planned pi-questions shown");
-      assert.ok(
-        stdout.includes("Would install pi package npm:pi-web-access@0.10.7"),
-        "planned pi-web-access shown",
-      );
+      assert.ok(stdout.includes("Bundled pi package pi-questions"), "pi-questions staged");
+      assert.ok(stdout.includes("Bundled pi package pi-web-access"), "pi-web-access staged");
+      assert.ok(stdout.includes(join(fakeHome, ".agent-cortex", "pi")), "default output is the home staging dir");
     } finally {
       await rm(fakeHome, { recursive: true, force: true });
     }
   });
 
-  it("exits 0 for install pi --output <tmp> and writes agent and config files", async () => {
+  it("exits 0 for install pi --output <tmp> and stages a loadable pi package", async () => {
     const outDir = await mkdtemp(join(tmpdir(), "cli-pi-install-"));
     try {
       const { exitCode, stdout } = await runCli(["install", "pi", "--output", outDir]);
@@ -294,9 +290,10 @@ describe("CLI integration", () => {
       assert.ok(stdout.includes("ralph.agent.md"));
       const ralph = await readFile(join(outDir, "agents", "ralph.agent.md"), "utf-8");
       assert.ok(ralph.includes("agent-cortex:ralph"));
-      const settings = JSON.parse(await readFile(join(outDir, "settings.json"), "utf-8"));
-      assert.ok(Array.isArray(settings.packages));
-      assert.ok(await readFile(join(outDir, "keybindings.json"), "utf-8"));
+      const manifest = JSON.parse(await readFile(join(outDir, "package.json"), "utf-8"));
+      assert.deepEqual(manifest.keywords, ["pi-package"]);
+      assert.ok(manifest.pi.extensions.includes("./extensions"));
+      assert.ok(manifest.pi.skills.includes("./skills"));
     } finally {
       await rm(outDir, { recursive: true, force: true });
     }

package/test/create-chores.test.mjs

@@ -70,4 +70,16 @@ describe("create-chores", () => {
       ["implementation-type:afk", "stage:code"],
     );
   });
+
+  it("validates the PR gate task but not the stage chores", async () => {
+    const { ids, beads } = await createChoresAgainstFakeBd(["implementation-type:afk"]);
+
+    const gate = beads.find((b) => b.id === ids.featurePrReview);
+    assert.equal(gate.type, "task");
+    assert.equal(gate.validated, true);
+    assert.match(gate.description, /## Acceptance Criteria/);
+
+    const codeChore = beads.find((b) => b.id === ids.code);
+    assert.equal(codeChore.validated, false);
+  });
 });

package/test/fake-bd.test.mjs

@@ -0,0 +1,72 @@
+// Tests for the stateful fake `bd` helper's `--validate` model.
+// The fake mirrors `bd create --validate`: a substantive bead whose description lacks the
+// required section(s) for its type is rejected; chores have no requirements.
+
+import { describe, it } from "node:test";
+import assert from "node:assert/strict";
+import { execFile } from "node:child_process";
+import { mkdtemp, rm } from "node:fs/promises";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+
+import { makeFakeBd } from "./helpers/fake-bd.mjs";
+
+/** Run the fake `bd` binary with the given args. */
+function runFake(bin, state, args) {
+  return new Promise((resolve) => {
+    execFile(bin, args, { env: { ...process.env, FAKE_BD_STATE: state } }, (error, stdout, stderr) => {
+      resolve({ exitCode: error ? error.code ?? 1 : 0, stdout, stderr });
+    });
+  });
+}
+
+/** Create a fresh fake workspace, run `fn`, then remove it. */
+async function withFake(fn) {
+  const dir = await mkdtemp(join(tmpdir(), "fake-bd-"));
+  try {
+    const { bin, state } = await makeFakeBd(dir, { beads: [] });
+    await fn(bin, state);
+  } finally {
+    await rm(dir, { recursive: true, force: true });
+  }
+}
+
+describe("fake bd --validate", () => {
+  it("rejects a section-less task", async () => {
+    await withFake(async (bin, state) => {
+      const { exitCode, stderr } = await runFake(bin, state, ["create", "empty", "--type", "task", "--validate"]);
+      assert.equal(exitCode, 1);
+      assert.match(stderr, /Acceptance Criteria/);
+    });
+  });
+
+  it("accepts a task carrying ## Acceptance Criteria (case-insensitive)", async () => {
+    await withFake(async (bin, state) => {
+      const { exitCode } = await runFake(bin, state, [
+        "create", "ok", "--type", "task",
+        "--description", "## Acceptance criteria\n- [ ] done",
+        "--validate",
+      ]);
+      assert.equal(exitCode, 0);
+    });
+  });
+
+  it("requires ## Success Criteria for an epic", async () => {
+    await withFake(async (bin, state) => {
+      const { exitCode, stderr } = await runFake(bin, state, [
+        "create", "ep", "--type", "epic",
+        "--description", "## Acceptance Criteria\n- [ ] x",
+        "--validate",
+      ]);
+      assert.equal(exitCode, 1);
+      assert.match(stderr, /Success Criteria/);
+    });
+  });
+
+  it("does not require sections for a chore", async () => {
+    await withFake(async (bin, state) => {
+      const { exitCode } = await runFake(bin, state, ["create", "c", "--type", "chore", "--validate"]);
+      assert.equal(exitCode, 0);
+    });
+  });
+});

package/test/helpers/fake-bd.mjs

@@ -1,10 +1,10 @@
 // Shared test helper: a stateful fake `bd` binary for create-chores.ts.
 // `bd` is a genuine external system (its real database must never be touched
 // by tests), so the script is driven against this fake via the BD_PATH
-// override. The fake reproduces the one real behaviour the test depends on —
-// `bd create --parent` inherits the parent's labels unless
-// `--no-inherit-labels` is passed — and records every created bead to a JSON
-// state file the test can read back.
+// override. The fake reproduces the real behaviours the tests depend on —
+// `bd create --parent` label inheritance (unless `--no-inherit-labels` is
+// passed) and `bd create --validate` section enforcement — and records every
+// created bead to a JSON state file the test can read back.
 //
 // State lives in `state.json` next to the binary; the test seeds it with the
 // parent bead and reads the children back after the script runs. Written async
@@ -20,7 +20,7 @@ const FAKE_BD_SCRIPT = [
   "",
   "const stateFile = process.env.FAKE_BD_STATE;",
   "const VALUE_FLAGS = new Set(['--type', '--description', '--priority', '--labels', '--parent']);",
-  "const BOOL_FLAGS = new Set(['--silent', '--no-inherit-labels']);",
+  "const BOOL_FLAGS = new Set(['--silent', '--no-inherit-labels', '--validate']);",
   "",
   "(async () => {",
   "  const argv = process.argv.slice(2);",
@@ -37,13 +37,33 @@ const FAKE_BD_SCRIPT = [
   "  }",
   "",
   "  const state = JSON.parse(await fs.readFile(stateFile, 'utf8'));",
+  "",
+  "  // Model `bd create --validate`: reject a substantive bead whose description lacks the",
+  "  // required section(s) for its type. Chores have no requirements and always pass.",
+  "  if (bools.has('--validate')) {",
+  "    const type = flags['--type'] || 'task';",
+  "    const required = {",
+  "      task: ['## Acceptance Criteria'],",
+  "      feature: ['## Acceptance Criteria'],",
+  "      bug: ['## Steps to Reproduce', '## Acceptance Criteria'],",
+  "      epic: ['## Success Criteria'],",
+  "      chore: [],",
+  "    }[type] || ['## Acceptance Criteria'];",
+  "    const description = flags['--description'] || '';",
+  "    const missing = required.filter((section) => !description.toLowerCase().includes(section.toLowerCase()));",
+  "    if (missing.length > 0) {",
+  "      console.error('missing required sections for ' + type + ': ' + missing.join(', '));",
+  "      process.exit(1);",
+  "    }",
+  "  }",
+  "",
   "  const explicit = (flags['--labels'] || '').split(',').filter(Boolean);",
   "  const parent = state.beads.find((b) => b.id === flags['--parent']);",
   "  const inherited = parent && !bools.has('--no-inherit-labels') ? parent.labels : [];",
   "  const labels = [...new Set([...inherited, ...explicit])];",
   "",
   "  const id = 'bd-' + state.nextId++;",
-  "  state.beads.push({ id, title, labels, parent: flags['--parent'] ?? null });",
+  "  state.beads.push({ id, title, labels, parent: flags['--parent'] ?? null, type: flags['--type'] || 'task', description: flags['--description'] || '', validated: bools.has('--validate') });",
   "  await fs.writeFile(stateFile, JSON.stringify(state));",
   "  process.stdout.write(id + '\\n');",
   "})().catch((err) => {",

package/test/helpers/fake-pi.mjs

@@ -0,0 +1,132 @@
+// Shared test helper: a stateful fake `pi` binary for pi's package commands.
+// The real CLI is a genuine external system (and its user settings must never
+// be touched by tests), so tests drive this fake instead. It records every
+// invocation to `calls.log` (argv, space-joined, one line each) and simulates
+// just enough real behaviour to assert registration state:
+//
+//   --version          → exit 0 (availability probe)
+//   list               → configured package sources
+//   install <source>   → adds <source> to settings.json `packages`, persisted
+//                        relative to the settings file's directory (what real
+//                        pi does) unless an entry already resolves to it
+//   remove <source>    → drops the matching entry; exit 1 when none matches
+//
+// Local sources are resolved the way pi resolves them: relative to the
+// directory holding settings.json. `failWhen` makes any invocation whose argv
+// contains the substring exit 1 (command failures).
+//
+// Written async throughout (the fake is a child process and the helper's own
+// I/O is test code) — the repo's check-no-sync lint scans test/ for *Sync.
+
+import { chmod, writeFile } from "node:fs/promises";
+import { join } from "node:path";
+
+const FAKE_PI_SCRIPT = [
+  "#!/usr/bin/env node",
+  "// Stateful fake for the `pi` package CLI (test/helpers/fake-pi.mjs).",
+  "const fs = require('node:fs/promises');",
+  "const path = require('node:path');",
+  "const os = require('node:os');",
+  "",
+  "const dir = __dirname;",
+  "const settingsFile = path.join(dir, 'settings.json');",
+  "const logFile = path.join(dir, 'calls.log');",
+  "const failWhenFile = path.join(dir, 'failWhen.txt');",
+  "",
+  "const expand = (p) => (p === '~' ? os.homedir() : p.startsWith('~/') ? path.join(os.homedir(), p.slice(2)) : p);",
+  "const sourceOf = (entry) => (typeof entry === 'string' ? entry : entry && entry.source);",
+  "// pi resolves a configured local source against the settings file's directory.",
+  "const resolvedSource = (entry) => path.resolve(dir, expand(sourceOf(entry)));",
+  "const resolvedArgument = (arg) => path.resolve(dir, expand(arg));",
+  "",
+  "(async () => {",
+  "  const argv = process.argv.slice(2);",
+  "  const joined = argv.join(' ');",
+  "  await fs.appendFile(logFile, joined + '\\n');",
+  "",
+  "  const failWhen = await fs.readFile(failWhenFile, 'utf8').catch(() => null);",
+  "  if (failWhen && joined.includes(failWhen)) process.exit(1);",
+  "",
+  "  if (argv[0] === '--version' || argv[0] === '-v') {",
+  "    console.log('1.4.0');",
+  "    process.exit(0);",
+  "  }",
+  "",
+  "  const readSettings = async () => {",
+  "    try {",
+  "      return JSON.parse(await fs.readFile(settingsFile, 'utf8'));",
+  "    } catch {",
+  "      return {};",
+  "    }",
+  "  };",
+  "  const writePackages = async (settings, packages) =>",
+  "    fs.writeFile(settingsFile, JSON.stringify({ ...settings, packages }, null, 2) + '\\n');",
+  "",
+  "  const [command, argument] = argv;",
+  "  const settings = await readSettings();",
+  "  const packages = settings.packages ?? [];",
+  "",
+  "  if (command === 'list') {",
+  "    if (packages.length === 0) {",
+  "      console.log('No packages installed.');",
+  "      process.exit(0);",
+  "    }",
+  "    console.log('User packages:');",
+  "    for (const entry of packages) console.log('  ' + sourceOf(entry));",
+  "    process.exit(0);",
+  "  }",
+  "",
+  "  if (command === 'install') {",
+  "    const target = resolvedArgument(argument);",
+  "    const persisted = path.relative(dir, target) || '.';",
+  "    const index = packages.findIndex((entry) => resolvedSource(entry) === target);",
+  "    if (index === -1) {",
+  "      packages.push(persisted);",
+  "    } else if (typeof packages[index] === 'string') {",
+  "      packages[index] = persisted;",
+  "    } else {",
+  "      packages[index] = { ...packages[index], source: persisted };",
+  "    }",
+  "    await writePackages(settings, packages);",
+  "    console.log('Installed ' + argument);",
+  "    process.exit(0);",
+  "  }",
+  "",
+  "  if (command === 'remove') {",
+  "    const target = resolvedArgument(argument);",
+  "    const next = packages.filter((entry) => resolvedSource(entry) !== target);",
+  "    if (next.length === packages.length) {",
+  "      console.error('No matching package found for ' + argument);",
+  "      process.exit(1);",
+  "    }",
+  "    await writePackages(settings, next);",
+  "    console.log('Removed ' + argument);",
+  "    process.exit(0);",
+  "  }",
+  "",
+  "  process.exit(0);",
+  "})().catch((err) => {",
+  "  console.error(err);",
+  "  process.exit(1);",
+  "});",
+].join("\n");
+
+/** Create a stateful fake `pi` binary in `dir`.
+ *
+ * The binary's own directory doubles as pi's settings directory, so a local
+ * package source is persisted relative to it exactly as real pi does.
+ * @param {string} dir  Directory to hold bin, calls.log, settings.json
+ * @param {{ failWhen?: string|null, packages?: unknown[] }} [options]
+ *   failWhen: invocations whose argv contains the substring exit 1;
+ *   packages: initial `packages` array for settings.json
+ * @returns {Promise<{ bin: string, log: string, settingsPath: string }>} */
+export async function makeFakePi(dir, { failWhen = null, packages = [] } = {}) {
+  const bin = join(dir, "pi");
+  const log = join(dir, "calls.log");
+  const settingsPath = join(dir, "settings.json");
+  await writeFile(bin, FAKE_PI_SCRIPT + "\n");
+  await chmod(bin, 0o755);
+  await writeFile(settingsPath, `${JSON.stringify({ packages }, null, 2)}\n`);
+  if (failWhen) await writeFile(join(dir, "failWhen.txt"), failWhen);
+  return { bin, log, settingsPath };
+}