@jaybeeuu/agent-cortex 2.1.0 → 2.3.0

package/test/release-gates.test.mjs

@@ -1,190 +0,0 @@
-// Behaviour tests for the release gates that keep `main` from re-publishing a
-// version: the inverted PR changeset gate and the no-publish release gate.
-// The decision logic is pure; the two CLI adapters are exercised through their
-// process boundary because that is the contract CI depends on.
-
-import { describe, it } from "node:test";
-import assert from "node:assert/strict";
-import { spawn } from "node:child_process";
-import { fileURLToPath } from "node:url";
-import {
-  PUBLISH_COMMAND,
-  NO_PUBLISH_COMMAND,
-  evaluateChangesetGate,
-  parseNameStatus,
-  resolvePublishCommand,
-} from "../scripts/lib/release-gates.mjs";
-
-const CHECK_CHANGESET = fileURLToPath(new URL("../scripts/check-changeset.mjs", import.meta.url));
-const RESOLVE_PUBLISH = fileURLToPath(
-  new URL("../scripts/resolve-publish-command.mjs", import.meta.url),
-);
-
-function runScript(script, { args = [], env = {}, stdin = "" } = {}) {
-  return new Promise((resolve, reject) => {
-    const child = spawn(process.execPath, [script, ...args], {
-      env: { ...process.env, ...env },
-    });
-    let stdout = "";
-    let stderr = "";
-    child.stdout.on("data", (chunk) => {
-      stdout += chunk;
-    });
-    child.stderr.on("data", (chunk) => {
-      stderr += chunk;
-    });
-    child.on("error", reject);
-    child.on("close", (code) => resolve({ code, stdout, stderr }));
-    child.stdin.end(stdin);
-  });
-}
-
-describe("parseNameStatus", () => {
-  it("parses added and modified paths from git diff --name-status output", () => {
-    const changes = parseNameStatus("M\tpackage.json\nA\t.changeset/fix-release.md\n");
-
-    assert.deepEqual(changes, [
-      { status: "M", path: "package.json" },
-      { status: "A", path: ".changeset/fix-release.md" },
-    ]);
-  });
-
-  it("uses the new path for a rename", () => {
-    const changes = parseNameStatus("R087\t.changeset/old.md\t.changeset/new.md\n");
-
-    assert.deepEqual(changes, [{ status: "R", path: ".changeset/new.md" }]);
-  });
-
-  it("returns no changes for empty output", () => {
-    assert.deepEqual(parseNameStatus(""), []);
-  });
-});
-
-describe("evaluateChangesetGate", () => {
-  it("passes a PR that adds a changeset", () => {
-    const result = evaluateChangesetGate({
-      changes: [{ status: "A", path: ".changeset/fix-release.md" }],
-      labels: [],
-      headRef: "fix/release-gate",
-      actor: "jaybeeuu",
-    });
-
-    assert.deepEqual(result, { ok: true, reason: "changeset-added" });
-  });
-
-  it("fails a CI-only change that adds no changeset", () => {
-    const result = evaluateChangesetGate({
-      changes: [{ status: "M", path: ".github/workflows/ci.yml" }],
-      labels: [],
-      headRef: "chore/bump-pnpm",
-      actor: "jaybeeuu",
-    });
-
-    assert.equal(result.ok, false);
-    assert.equal(result.reason, "missing-changeset");
-  });
-
-  it("fails a PR that only modifies an existing changeset", () => {
-    const result = evaluateChangesetGate({
-      changes: [{ status: "M", path: ".changeset/pending.md" }],
-      labels: [],
-      headRef: "chore/edit-changeset",
-      actor: "jaybeeuu",
-    });
-
-    assert.equal(result.ok, false);
-  });
-
-  it("fails a PR that only adds the changeset README", () => {
-    const result = evaluateChangesetGate({
-      changes: [{ status: "A", path: ".changeset/README.md" }],
-      labels: [],
-      headRef: "docs/changesets",
-      actor: "jaybeeuu",
-    });
-
-    assert.equal(result.ok, false);
-  });
-
-  it("passes an unlabelled-change PR carrying the no-publish label", () => {
-    const result = evaluateChangesetGate({
-      changes: [{ status: "M", path: ".github/workflows/ci.yml" }],
-      labels: ["no-publish"],
-      headRef: "chore/bump-pnpm",
-      actor: "jaybeeuu",
-    });
-
-    assert.deepEqual(result, { ok: true, reason: "no-publish-label" });
-  });
-
-  it("passes the Version Packages PR by head branch", () => {
-    const result = evaluateChangesetGate({
-      changes: [{ status: "M", path: "package.json" }],
-      labels: [],
-      headRef: "changeset-release/main",
-      actor: "jaybeeuu",
-    });
-
-    assert.deepEqual(result, { ok: true, reason: "version-packages-pr" });
-  });
-
-  it("passes a PR opened by the GitHub Actions bot", () => {
-    const result = evaluateChangesetGate({
-      changes: [{ status: "M", path: "package.json" }],
-      labels: [],
-      headRef: "automation/some-branch",
-      actor: "github-actions[bot]",
-    });
-
-    assert.deepEqual(result, { ok: true, reason: "version-packages-pr" });
-  });
-});
-
-describe("resolvePublishCommand", () => {
-  it("publishes by default when the merged PR has no labels", () => {
-    assert.equal(resolvePublishCommand([]), PUBLISH_COMMAND);
-  });
-
-  it("publishes when the merged PR carries unrelated labels", () => {
-    assert.equal(resolvePublishCommand(["bug", "priority:p2"]), PUBLISH_COMMAND);
-  });
-
-  it("refuses to publish when the merged PR carries the no-publish label", () => {
-    assert.equal(resolvePublishCommand(["bug", "no-publish"]), NO_PUBLISH_COMMAND);
-  });
-
-  it("matches the label exactly, not as a substring", () => {
-    assert.equal(resolvePublishCommand(["no-publish-ci"]), PUBLISH_COMMAND);
-  });
-});
-
-describe("check-changeset CLI", () => {
-  it("exits 0 for a no-publish PR with no diff", async () => {
-    const { code } = await runScript(CHECK_CHANGESET, {
-      env: { PR_LABELS: '["no-publish"]', PR_HEAD_REF: "chore/bump-pnpm", PR_ACTOR: "jaybeeuu" },
-    });
-
-    assert.equal(code, 0);
-  });
-
-  it("exits 1 and explains the no-publish escape hatch for a changeset-less PR", async () => {
-    const { code, stderr } = await runScript(CHECK_CHANGESET, {
-      stdin: "M\tpackage.json\n",
-      env: { PR_LABELS: "[]", PR_HEAD_REF: "chore/bump-pnpm", PR_ACTOR: "jaybeeuu" },
-    });
-
-    assert.equal(code, 1);
-    assert.match(stderr, /no-publish/);
-  });
-});
-
-describe("resolve-publish-command CLI", () => {
-  it("prints the noop command for a no-publish label set", async () => {
-    const { code, stdout } = await runScript(RESOLVE_PUBLISH, {
-      args: ['["no-publish"]'],
-    });
-
-    assert.equal(code, 0);
-    assert.equal(stdout.trim(), NO_PUBLISH_COMMAND);
-  });
-});

package/test/skill-frontmatter.test.mjs

@@ -1,137 +0,0 @@
-// Behaviour tests for scripts/lib/skill-frontmatter.mjs — the SKILL.md
-// frontmatter check that `pnpm lint` runs. Each case proves one failure mode
-// the check must catch: unparseable YAML, a missing name/description field, and
-// a description longer than the limit.
-
-import { describe, it } from "node:test";
-import assert from "node:assert/strict";
-import { mkdir, mkdtemp, rm, writeFile } from "node:fs/promises";
-import { tmpdir } from "node:os";
-import { dirname, join } from "node:path";
-import { fileURLToPath } from "node:url";
-import {
-  MAX_DESCRIPTION_LENGTH,
-  checkSkills,
-  validateSkillFrontmatter,
-} from "../scripts/lib/skill-frontmatter.mjs";
-
-const REPO_ROOT = join(dirname(fileURLToPath(import.meta.url)), "..");
-
-/** Wrap frontmatter lines in a SKILL.md-shaped document. */
-function skillDocument(frontmatter) {
-  return `---\n${frontmatter}\n---\n\n# Skill body\n`;
-}
-
-/** Throwaway directory to lay out a fake skills tree in. */
-async function makeFixtureRoot() {
-  return await mkdtemp(join(tmpdir(), "agent-cortex-skill-frontmatter-"));
-}
-
-/** Write a SKILL.md at `<root>/<relativeSkillDir>/SKILL.md`. */
-async function writeSkill(root, relativeSkillDir, content) {
-  const dir = join(root, relativeSkillDir);
-  await mkdir(dir, { recursive: true });
-  await writeFile(join(dir, "SKILL.md"), content);
-}
-
-describe("validateSkillFrontmatter", () => {
-  it("accepts frontmatter with a name and a description", () => {
-    const errors = validateSkillFrontmatter(
-      skillDocument("name: example-skill\ndescription: Does a thing. Use when a thing needs doing."),
-    );
-
-    assert.deepEqual(errors, []);
-  });
-
-  it("reports unparseable YAML", () => {
-    const errors = validateSkillFrontmatter(
-      skillDocument("name: example-skill\ndescription: Use when the plan: breaks"),
-    );
-
-    assert.equal(errors.length, 1);
-    assert.match(errors[0], /not valid YAML/);
-  });
-
-  it("reports a missing name", () => {
-    const errors = validateSkillFrontmatter(skillDocument("description: Does a thing."));
-
-    assert.deepEqual(errors, ["frontmatter is missing a non-empty name"]);
-  });
-
-  it("reports a missing description", () => {
-    const errors = validateSkillFrontmatter(skillDocument("name: example-skill"));
-
-    assert.deepEqual(errors, ["frontmatter is missing a non-empty description"]);
-  });
-
-  it("reports a description over the length limit", () => {
-    const errors = validateSkillFrontmatter(
-      skillDocument(`name: example-skill\ndescription: ${"a".repeat(MAX_DESCRIPTION_LENGTH + 1)}`),
-    );
-
-    assert.equal(errors.length, 1);
-    assert.match(errors[0], /description exceeds 1024 characters \(1025\)/);
-  });
-
-  it("accepts a description exactly at the length limit", () => {
-    const errors = validateSkillFrontmatter(
-      skillDocument(`name: example-skill\ndescription: ${"a".repeat(MAX_DESCRIPTION_LENGTH)}`),
-    );
-
-    assert.deepEqual(errors, []);
-  });
-
-  it("reports a file with no frontmatter block", () => {
-    const errors = validateSkillFrontmatter("# Skill body\n\nNo frontmatter here.\n");
-
-    assert.deepEqual(errors, ["frontmatter block is missing (expected '---' delimiters)"]);
-  });
-});
-
-describe("checkSkills", () => {
-  it("reports each failing SKILL.md and counts every file it checked", async () => {
-    const root = await makeFixtureRoot();
-    try {
-      await writeSkill(
-        root,
-        "skills/good",
-        skillDocument("name: good-skill\ndescription: Does a thing. Use when testing the checker."),
-      );
-      await writeSkill(
-        root,
-        "skills/broken",
-        skillDocument("name: broken-skill\ndescription: Use when the plan: breaks"),
-      );
-
-      const result = await checkSkills({ root });
-
-      assert.equal(result.checked, 2);
-      assert.equal(result.failures.length, 1);
-      assert.equal(result.failures[0].file, join("skills", "broken", "SKILL.md"));
-    } finally {
-      await rm(root, { recursive: true, force: true });
-    }
-  });
-
-  it("ignores markdown files that are not SKILL.md", async () => {
-    const root = await makeFixtureRoot();
-    try {
-      await writeSkill(root, "skills/good", skillDocument("name: good-skill\ndescription: Does a thing."));
-      await writeFile(join(root, "skills", "good", "REFERENCE.md"), "---\nnot: a skill\n---\n");
-
-      const result = await checkSkills({ root });
-
-      assert.equal(result.checked, 1);
-      assert.deepEqual(result.failures, []);
-    } finally {
-      await rm(root, { recursive: true, force: true });
-    }
-  });
-
-  it("passes on this repository's own skills tree", async () => {
-    const result = await checkSkills({ root: REPO_ROOT });
-
-    assert.deepEqual(result.failures, []);
-    assert.ok(result.checked > 0, "expected the check to find SKILL.md files");
-  });
-});

package/test/verify-worker-tree.test.mjs

@@ -1,120 +0,0 @@
-// Integration tests for scripts/lib/verify-worker-tree.mjs. The module exists to
-// tell a worker that delivered from one that only said it did, so each case runs
-// a real git repository and asserts the verdict — no mocking of git, because git
-// is the thing whose state the verdict is about.
-
-import { describe, it } from "node:test";
-import assert from "node:assert/strict";
-import { execFile } from "node:child_process";
-import { mkdtemp, writeFile, rm } from "node:fs/promises";
-import { tmpdir } from "node:os";
-import { join } from "node:path";
-import { promisify } from "node:util";
-
-import { verifyWorkerTree } from "../scripts/lib/verify-worker-tree.mjs";
-
-const execFileAsync = promisify(execFile);
-
-/** Run a git command in `cwd`. */
-async function git(cwd, args) {
-  await execFileAsync("git", args, { cwd });
-}
-
-/** A repository with one base commit; returns its directory and that commit. */
-async function createRepo() {
-  const dir = await mkdtemp(join(tmpdir(), "verify-worker-tree-"));
-  await git(dir, ["init", "--quiet"]);
-  await git(dir, ["config", "user.email", "t@example.com"]);
-  await git(dir, ["config", "user.name", "T"]);
-  // A developer's global config may enable commit signing; the fixture must not
-  // depend on a secret key being present.
-  await git(dir, ["config", "commit.gpgsign", "false"]);
-  await writeFile(join(dir, "README.md"), "base\n");
-  await git(dir, ["add", "-A"]);
-  await git(dir, ["commit", "-m", "base"]);
-  const { stdout } = await execFileAsync("git", ["rev-parse", "HEAD"], { cwd: dir });
-  return { dir, base: stdout.trim() };
-}
-
-/** Commit a file in the repo, as a delivering worker would. */
-async function commitWork(dir) {
-  await writeFile(join(dir, "worker-output.txt"), "delivered\n");
-  await git(dir, ["add", "-A"]);
-  await git(dir, ["commit", "-m", "worker: deliver"]);
-}
-
-describe("verifyWorkerTree", () => {
-  it("passes a worker that committed and left a clean tree", async () => {
-    const { dir, base } = await createRepo();
-    try {
-      await commitWork(dir);
-
-      const verdict = await verifyWorkerTree({ worktree: dir, base });
-
-      assert.deepEqual(verdict, { ok: true, reasons: [], commitsAhead: 1 });
-    } finally {
-      await rm(dir, { recursive: true, force: true });
-    }
-  });
-
-  it("fails a worker that reported success but left its work uncommitted", async () => {
-    const { dir, base } = await createRepo();
-    try {
-      await writeFile(join(dir, "left-behind.txt"), "uncommitted\n");
-
-      const verdict = await verifyWorkerTree({ worktree: dir, base });
-
-      assert.equal(verdict.ok, false);
-      assert.equal(verdict.reasons[0], "worktree is dirty: 1 uncommitted path(s)");
-      assert.equal(verdict.commitsAhead, 0);
-    } finally {
-      await rm(dir, { recursive: true, force: true });
-    }
-  });
-
-  it("fails a worker that left a clean tree with nothing committed", async () => {
-    const { dir, base } = await createRepo();
-    try {
-      const verdict = await verifyWorkerTree({ worktree: dir, base });
-
-      assert.equal(verdict.ok, false);
-      assert.equal(verdict.reasons.length, 1);
-      assert.match(verdict.reasons[0], /^no commit ahead of base [0-9a-f]{7}$/);
-    } finally {
-      await rm(dir, { recursive: true, force: true });
-    }
-  });
-
-  it("reports a dirty tree and a missing commit together", async () => {
-    const { dir, base } = await createRepo();
-    try {
-      await writeFile(join(dir, "partial.txt"), "half done\n");
-
-      const verdict = await verifyWorkerTree({ worktree: dir, base });
-
-      assert.equal(verdict.ok, false);
-      assert.equal(verdict.reasons.length, 2);
-      assert.equal(verdict.reasons[0], "worktree is dirty: 1 uncommitted path(s)");
-      assert.match(verdict.reasons[1], /^no commit ahead of base [0-9a-f]{7}$/);
-    } finally {
-      await rm(dir, { recursive: true, force: true });
-    }
-  });
-
-  it("counts every commit the worker made, not just the last", async () => {
-    const { dir, base } = await createRepo();
-    try {
-      await commitWork(dir);
-      await writeFile(join(dir, "second.txt"), "more\n");
-      await git(dir, ["add", "-A"]);
-      await git(dir, ["commit", "-m", "worker: second"]);
-
-      const verdict = await verifyWorkerTree({ worktree: dir, base });
-
-      assert.equal(verdict.ok, true);
-      assert.equal(verdict.commitsAhead, 2);
-    } finally {
-      await rm(dir, { recursive: true, force: true });
-    }
-  });
-});