@jaybeeuu/agent-cortex 1.43.0 → 2.1.0

package/scripts/install-instructions.sh

@@ -1,82 +0,0 @@
-#!/usr/bin/env bash
-# Installs ~/.copilot/copilot-instructions.md with proactive skill directives.
-# Run after cloning this plugin: pnpm install (or bash scripts/install-instructions.sh)
-# Safe to re-run — replaces the agent-cortex section only.
-
-set -euo pipefail
-
-INSTRUCTIONS_FILE="$HOME/.copilot/copilot-instructions.md"
-MARKER_START="<!-- agent-cortex:start -->"
-MARKER_END="<!-- agent-cortex:end -->"
-
-BLOCK="$MARKER_START
-<!-- This block is managed by agent-cortex. Manual edits inside will be overwritten. -->
-
-## Proactive skill use (agent-cortex plugin)
-
-You have a set of custom skills available. Apply them automatically whenever they are relevant — the user should not have to invoke them by name.
-
-### Code & tests
-
-- Apply **style-code** whenever writing, editing, or reviewing code. It defines naming, module boundaries, and architectural conventions.
-- Apply **style-tests** whenever writing, editing, or reviewing tests. It defines assertion strategy, mock discipline, and what to test.
-- Apply **style-comms** whenever writing external-facing communication: tickets, RFCs, PRDs, proposals, or reports.
-- Apply **style-documentation** whenever deciding what to document or reviewing existing docs.
-- Use **tdd** (red-green-refactor loop) whenever building a new feature or fixing a bug where correctness matters.
-- Run **review-security** before committing any changes that touch secrets, auth, or credentials.
-
-### Planning & design
-
-- Use **write-a-prd** when the user wants to plan a new feature or product requirement.
-- Use **prd-to-tasks** after a PRD is approved to break it into phased epics and task beads.
-- Use **create-task** when creating a new trackable task bead.
-- Use **record-idea** when the user shares an early-stage idea that is not yet ready to implement.
-- Use **request-refactor-plan** when the user wants to plan a refactor with safe incremental commits.
-- Use **write-a-ticket** when writing a ticket for an external issue tracker (e.g. Jira).
-- Use **design-an-interface** when the user wants to explore multiple API or module designs.
-- Use **technical-direction** when evaluating architecture or technology choices with tradeoff analysis.
-- Use **grill-me** or **grill-with-docs** when the user wants to stress-test a plan or design.
-- Use **improve-codebase-architecture** when the user wants to find architectural improvement opportunities.
-
-### Task execution
-
-- Use **bd-tool** whenever the user mentions beads, bd, tasks, or asks what work is available.
-- Use **ralph** to run all pending beads end-to-end with review gates.
-- Use **run-pipeline-stage** to work through individual pipeline stages inline.
-- Use **hitl-collab** when a task requires human review, manual steps, or a PR handoff.
-- Use **classify-bead** when a bead is missing its implementation-type label.
-
-### Repo & plugin maintenance
-
-- Use **maintain-agent-docs** when reviewing or updating AGENTS.md or agent-consumed docs.
-- Use **refactor-skill** when restructuring or reviewing an existing skill.
-- Use **write-a-skill** when creating a new skill.
-- Use **init-beads** when setting up the bd task-tracker in a new project.
-
-$MARKER_END"
-
-mkdir -p "$(dirname "$INSTRUCTIONS_FILE")"
-
-if [ ! -f "$INSTRUCTIONS_FILE" ]; then
-  printf '%s\n' "$BLOCK" > "$INSTRUCTIONS_FILE"
-  echo "✓ Created $INSTRUCTIONS_FILE"
-elif grep -qF "$MARKER_START" "$INSTRUCTIONS_FILE"; then
-  # Write replacement block to a temp file so awk can read it with getline
-  BLOCK_FILE=$(mktemp)
-  printf '%s\n' "$BLOCK" > "$BLOCK_FILE"
-  awk -v start="$MARKER_START" -v end="$MARKER_END" -v blockfile="$BLOCK_FILE" '
-    $0 == start {
-      while ((getline line < blockfile) > 0) print line
-      close(blockfile)
-      skip=1; next
-    }
-    $0 == end { skip=0; next }
-    !skip     { print }
-  ' "$INSTRUCTIONS_FILE" > "${INSTRUCTIONS_FILE}.tmp"
-  mv "${INSTRUCTIONS_FILE}.tmp" "$INSTRUCTIONS_FILE"
-  rm -f "$BLOCK_FILE"
-  echo "✓ Updated agent-cortex section in $INSTRUCTIONS_FILE"
-else
-  printf '\n%s\n' "$BLOCK" >> "$INSTRUCTIONS_FILE"
-  echo "✓ Appended agent-cortex section to $INSTRUCTIONS_FILE"
-fi

package/scripts/sync-plugin-version.sh

@@ -1,17 +0,0 @@
-#!/usr/bin/env bash
-# Sync plugin.json version with package.json
-# Called by changesets after versioning to keep them in lockstep
-
-set -euo pipefail
-
-VERSION=$(node -p "require('./package.json').version")
-
-# Update plugin.json version field
-node -e "
-const fs = require('fs');
-const plugin = JSON.parse(fs.readFileSync('plugin.json', 'utf8'));
-plugin.version = '$VERSION';
-fs.writeFileSync('plugin.json', JSON.stringify(plugin, null, 2) + '\n');
-"
-
-echo "✓ Synced plugin.json to version $VERSION"

package/test/copilot-installer.test.mjs

@@ -1,308 +0,0 @@
-// Integration tests for `agent-cortex install copilot`: the install-time
-// generator for the Copilot CLI flat agent files (agents/*.agent.md). All tests
-// install into mkdtemp dirs so the real repo agents/ is never touched.
-
-import { describe, it } from "node:test";
-import assert from "node:assert/strict";
-import { execFile } from "node:child_process";
-import { mkdtemp, mkdir, writeFile, rm, readFile, readdir, stat } from "node:fs/promises";
-import { tmpdir } from "node:os";
-import { fileURLToPath } from "node:url";
-import { join, dirname } from "node:path";
-import { installCopilot } from "../bin/installers/copilot.mjs";
-
-const __dirname = dirname(fileURLToPath(import.meta.url));
-const ROOT = join(__dirname, "..");
-const CLI_PATH = join(ROOT, "bin", "agent-cortex.mjs");
-
-/** True when a path exists (stat succeeds). */
-async function pathExists(p) {
-  try {
-    await stat(p);
-    return true;
-  } catch {
-    return false;
-  }
-}
-
-function runCli(args) {
-  return new Promise((resolve) => {
-    execFile(process.execPath, [CLI_PATH, ...args], (error, stdout, stderr) => {
-      resolve({ exitCode: error ? error.code ?? 1 : 0, stdout, stderr });
-    });
-  });
-}
-
-// ─── Fixtures ────────────────────────────────────────────────────────────────
-
-function tokenMap() {
-  return {
-    name: "fixture token map",
-    version: 1,
-    harnesses: ["copilot"],
-    tools: {
-      bash: { copilot: "bash" },
-      view: { copilot: "view" },
-      task: { copilot: "task" },
-      ask_user: { copilot: "ask_user" },
-    },
-    paths: {
-      plugin_root: { copilot: "~/.copilot/installed-plugins/_direct/agent-cortex" },
-      agents_dir: { copilot: { base: "plugin_root", relative: "agents" } },
-    },
-  };
-}
-
-async function makeFixture() {
-  const root = await mkdtemp(join(tmpdir(), "copilot-installer-"));
-  return {
-    root,
-    output: join(root, "generated"),
-    cleanup: async () => rm(root, { recursive: true, force: true }),
-  };
-}
-
-async function writeFixture(fx, relPath, content) {
-  const p = join(fx.root, relPath);
-  await mkdir(dirname(p), { recursive: true });
-  await writeFile(p, content);
-}
-
-/** Seed a minimal but realistic package tree (agents + token-map). */
-async function seedCopilotPackage(fx, opts = {}) {
-  const { agents = {} } = opts;
-  await writeFixture(fx, "token-map.json", JSON.stringify(tokenMap()));
-  for (const [name, def] of Object.entries(agents)) {
-    await writeFixture(fx, `agents/${name}/agent.md`, def.body ?? `# ${name}\nBody of ${name}.`);
-    await writeFixture(
-      fx,
-      `agents/${name}/copilot/frontmatter.json`,
-      JSON.stringify(
-        def.frontmatter ?? {
-          name: `agent-cortex:${name}`,
-          description: `Description of ${name}`,
-          tools: ["bash", "view"],
-          argumentHint: `Hint for ${name}`,
-        },
-      ),
-    );
-    for (const [section, content] of Object.entries(def.sections ?? {})) {
-      await writeFixture(fx, `agents/${name}/copilot/${section}.md`, content);
-    }
-  }
-}
-
-/** Deterministic snapshot of a directory: relative paths + byte content. */
-async function snapshot(dir) {
-  const entries = [];
-  const walk = async (p) => {
-    for (const e of (await readdir(p, { withFileTypes: true })).sort((a, b) => a.name.localeCompare(b.name))) {
-      const full = join(p, e.name);
-      if (e.isDirectory()) {
-        entries.push([e.name, "dir"]);
-        await walk(full);
-      } else entries.push([e.name, "file", await readFile(full, "utf-8")]);
-    }
-  };
-  await walk(dir);
-  return entries;
-}
-
-// ─── Agent composition ───────────────────────────────────────────────────────
-
-describe("installCopilot — agent composition", () => {
-  it("writes one flat <name>.agent.md per composable agent dir with copilot frontmatter and no leftover tokens", async () => {
-    const fx = await makeFixture();
-    try {
-      await seedCopilotPackage(fx, {
-        agents: {
-          alpha: {
-            body: "# alpha\nUse {{TOOL:view}} to read.\n{{SECTION:polling}}\nRead {{PATH:agents_dir}}.",
-            sections: { polling: "Spawn with {{TOOL:task}}." },
-            frontmatter: {
-              name: "agent-cortex:alpha",
-              description: "Reads things.",
-              tools: ["bash", "view"],
-              argumentHint: "Read something",
-            },
-          },
-        },
-      });
-
-      const result = await installCopilot({ root: fx.root, output: fx.output });
-
-      const file = join(fx.output, "alpha.agent.md");
-      assert.ok(await pathExists(file), "flat agent file written");
-      const content = await readFile(file, "utf-8");
-      assert.ok(content.startsWith("---\n"), "yaml frontmatter");
-      assert.ok(content.includes("# GENERATED from agents/alpha/ by scripts/build-copilot-agents.mjs — DO NOT EDIT."));
-      // Committed flat-file field order: description, name, tools (YAML array), argument-hint.
-      const order = ["description:", "name: \"agent-cortex:alpha\"", "tools: [", "argument-hint:"].map((s) => content.indexOf(s));
-      assert.ok(order.every((i) => i !== -1), "all frontmatter fields present");
-      assert.deepEqual([...order].sort((a, b) => a - b), order, "frontmatter fields in committed order");
-      assert.match(content, /tools: \["bash", "view"\]/, "copilot tools kept as a YAML array (no translation)");
-      assert.ok(content.includes("Use view to read."), "{{TOOL:view}} substituted");
-      assert.ok(content.includes("Spawn with task."), "{{SECTION:polling}} composed from copilot/polling.md");
-      assert.ok(!/{{/.test(content), "no literal tokens remain");
-      assert.equal(result.agents.length, 1);
-      assert.deepEqual(result.agents, ["alpha"]);
-      assert.equal(result.output, fx.output);
-    } finally {
-      await fx.cleanup();
-    }
-  });
-
-  it("skips non-composable entries in agents/ and never clobbers composable sources", async () => {
-    const fx = await makeFixture();
-    try {
-      await seedCopilotPackage(fx, { agents: { alpha: { body: "# alpha" } } });
-      await writeFixture(fx, "agents/README.md", "# agents dir docs\n");
-
-      const result = await installCopilot({ root: fx.root, output: fx.output });
-
-      assert.deepEqual((await readdir(fx.output)).sort(), ["alpha.agent.md"], "no README, no subdirectories written");
-      assert.deepEqual(result.agents, ["alpha"]);
-      // The composable source dir next to the generated file stays untouched.
-      assert.ok(await pathExists(join(fx.root, "agents", "alpha", "agent.md")), "composable source preserved");
-      assert.ok(await pathExists(join(fx.root, "agents", "alpha", "copilot", "frontmatter.json")), "harness dir preserved");
-    } finally {
-      await fx.cleanup();
-    }
-  });
-
-  it("throws when a composable dir lacks copilot/frontmatter.json", async () => {
-    const fx = await makeFixture();
-    try {
-      await seedCopilotPackage(fx, { agents: { alpha: { body: "# alpha" } } });
-      await rm(join(fx.root, "agents", "alpha", "copilot"), { recursive: true, force: true });
-      await assert.rejects(
-        installCopilot({ root: fx.root, output: fx.output }),
-        /without copilot\/frontmatter\.json/,
-      );
-    } finally {
-      await fx.cleanup();
-    }
-  });
-
-  it("defaults to the plugin-scanned agents/ dir of the package root (plugin.json \"agents\": \"agents/\")", async () => {
-    const fx = await makeFixture();
-    try {
-      await seedCopilotPackage(fx, { agents: { alpha: { body: "# alpha" } } });
-
-      const result = await installCopilot({ root: fx.root });
-
-      assert.equal(result.output, join(fx.root, "agents"), "default output is the dir plugin.json scans");
-      assert.ok(await pathExists(join(fx.root, "agents", "alpha.agent.md")), "flat file lands next to the composable dir");
-      assert.ok(await pathExists(join(fx.root, "agents", "alpha", "agent.md")), "composable source untouched");
-    } finally {
-      await fx.cleanup();
-    }
-  });
-
-  it("throws on an unknown tool token", async () => {
-    const fx = await makeFixture();
-    try {
-      await seedCopilotPackage(fx, { agents: { alpha: { body: "# alpha\nUse {{TOOL:nope}} now." } } });
-      await assert.rejects(installCopilot({ root: fx.root, output: fx.output }), /unknown tool token {{TOOL:nope}}/);
-    } finally {
-      await fx.cleanup();
-    }
-  });
-});
-
-// ─── Output / dry-run ────────────────────────────────────────────────────────
-
-describe("installCopilot — output & dry-run", () => {
-  it("dry-run reports the plan without writing anything", async () => {
-    const fx = await makeFixture();
-    try {
-      await seedCopilotPackage(fx, { agents: { alpha: { body: "# alpha" } } });
-
-      const result = await installCopilot({ root: fx.root, output: fx.output, dryRun: true });
-
-      assert.equal(result.dryRun, true);
-      assert.equal(await pathExists(fx.output), false, "no output dir created in dry-run");
-      assert.deepEqual(result.agents, ["alpha"], "planned files still reported");
-    } finally {
-      await fx.cleanup();
-    }
-  });
-
-  it("is deterministic across repeated installs into the same output", async () => {
-    const fx = await makeFixture();
-    try {
-      await seedCopilotPackage(fx, {
-        agents: {
-          alpha: { body: "# alpha\n{{SECTION:polling}}", sections: { polling: "Poll with {{TOOL:task}}." } },
-          beta: { body: "# beta" },
-        },
-      });
-
-      await installCopilot({ root: fx.root, output: fx.output });
-      const first = await snapshot(fx.output);
-      await installCopilot({ root: fx.root, output: fx.output });
-      assert.deepEqual(await snapshot(fx.output), first);
-    } finally {
-      await fx.cleanup();
-    }
-  });
-});
-
-// ─── Integration against the real repo ───────────────────────────────────────
-
-describe("installCopilot — real repo integration", () => {
-  it("regenerates byte-identical copies of the committed agents/*.agent.md files", async () => {
-    const fx = await makeFixture();
-    try {
-      const result = await installCopilot({ root: ROOT, output: fx.output });
-
-      assert.deepEqual(result.agents.sort(), ["plan", "ralph", "ralph-plan", "strategy"]);
-      for (const name of result.agents) {
-        const generated = await readFile(join(fx.output, `${name}.agent.md`), "utf-8");
-        const committed = await readFile(join(ROOT, "agents", `${name}.agent.md`), "utf-8");
-        assert.equal(generated, committed, `${name}.agent.md must match the committed flat file (CI drift check)`);
-      }
-    } finally {
-      await fx.cleanup();
-    }
-  });
-});
-
-// ─── CLI wiring ──────────────────────────────────────────────────────────────
-
-describe("CLI integration", () => {
-  it("exits 0 for install copilot --output <tmp> and writes the flat files", async () => {
-    const fx = await makeFixture();
-    try {
-      const { exitCode, stdout } = await runCli(["install", "copilot", "--output", fx.output]);
-      assert.equal(exitCode, 0);
-      assert.ok(stdout.includes("copilot"), "prints the harness name");
-      assert.ok(stdout.includes("Generated"), "prints the generation summary");
-      assert.ok(await pathExists(join(fx.output, "ralph.agent.md")), "agent files written");
-      assert.ok(await pathExists(join(fx.output, "plan.agent.md")));
-    } finally {
-      await fx.cleanup();
-    }
-  });
-
-  it("exits 0 for install copilot --dry-run and writes nothing", async () => {
-    const fx = await makeFixture();
-    try {
-      const { exitCode, stdout } = await runCli(["install", "copilot", "--output", fx.output, "--dry-run"]);
-      assert.equal(exitCode, 0);
-      assert.ok(/dry-run/i.test(stdout));
-      assert.equal(await pathExists(fx.output), false, "no files written in dry-run");
-    } finally {
-      await fx.cleanup();
-    }
-  });
-
-  it("exits 0 for install copilot (default output) without touching committed files", async () => {
-    const before = await readFile(join(ROOT, "agents", "ralph.agent.md"), "utf-8");
-    const { exitCode } = await runCli(["install", "copilot"]);
-    assert.equal(exitCode, 0);
-    // Default output regenerates the shared agents/ dir in place — output must
-    // stay byte-identical to what is committed.
-    assert.equal(await readFile(join(ROOT, "agents", "ralph.agent.md"), "utf-8"), before);
-  });
-});