@jaybeeuu/agent-cortex 2.0.0 → 2.1.0

package/test/pending-gates.test.mjs

@@ -0,0 +1,147 @@
+import { describe, it } from 'node:test';
+import assert from 'node:assert/strict';
+
+import {
+  EPIC_GATE_LABEL,
+  FEATURE_GATE_LABEL,
+  HITL_GATE_LABELS,
+  fetchGateState,
+  resolveGateState,
+  runCli,
+} from '../skills/workflow/ralph/scripts/pending-gates.mjs';
+
+function createBead({ id, title = `${id} title` }) {
+  return { id, title };
+}
+
+/**
+ * Fake `bd` for the query-contract tests: answers the three queries ralph makes
+ * and refuses anything else, so an unexpected query fails loudly.
+ */
+function makeExec({ ready = [], open = [], epics = [] } = {}) {
+  const calls = [];
+
+  const exec = async (args) => {
+    calls.push(args);
+    if (args[0] === 'ready') return JSON.stringify(ready);
+    if (args[0] === 'list' && args.includes(EPIC_GATE_LABEL)) return JSON.stringify(epics);
+    if (args[0] === 'list') return JSON.stringify(open);
+    throw new Error(`unexpected bd call: ${args.join(' ')}`);
+  };
+
+  return { exec, calls };
+}
+
+function capture() {
+  let output = '';
+  return { write: (chunk) => { output += chunk; }, read: () => JSON.parse(output) };
+}
+
+describe('resolveGateState', () => {
+  it('leaves dispatch unblocked while every gate is still parked behind its own pipeline', () => {
+    const state = resolveGateState({
+      readyGates: [],
+      openGates: [
+        createBead({ id: 'proj-1.5' }),
+        createBead({ id: 'proj-2.5' }),
+        createBead({ id: 'proj-3.5' }),
+        createBead({ id: 'proj-4.5' }),
+      ],
+      epicsAwaitingMerge: [],
+    });
+
+    assert.deepEqual(state.pendingHumanAction, []);
+    assert.deepEqual(state.parked, [
+      { id: 'proj-1.5', title: 'proj-1.5 title' },
+      { id: 'proj-2.5', title: 'proj-2.5 title' },
+      { id: 'proj-3.5', title: 'proj-3.5 title' },
+      { id: 'proj-4.5', title: 'proj-4.5 title' },
+    ]);
+  });
+
+  it('reports an unblocked gate as pending human action', () => {
+    const state = resolveGateState({
+      readyGates: [createBead({ id: 'proj-1.5', title: 'PR Review and Merge' })],
+      openGates: [createBead({ id: 'proj-1.5', title: 'PR Review and Merge' })],
+      epicsAwaitingMerge: [],
+    });
+
+    assert.deepEqual(state.pendingHumanAction, [
+      { id: 'proj-1.5', title: 'PR Review and Merge', kind: 'feature-pr' },
+    ]);
+    assert.deepEqual(state.parked, []);
+  });
+
+  it('separates an unblocked gate from gates that are still parked', () => {
+    const state = resolveGateState({
+      readyGates: [createBead({ id: 'proj-1.5' })],
+      openGates: [createBead({ id: 'proj-1.5' }), createBead({ id: 'proj-2.5' })],
+      epicsAwaitingMerge: [],
+    });
+
+    assert.deepEqual(state.pendingHumanAction.map((gate) => gate.id), ['proj-1.5']);
+    assert.deepEqual(state.parked.map((gate) => gate.id), ['proj-2.5']);
+  });
+
+  it('reports an epic awaiting merge as pending human action alongside feature gates', () => {
+    const state = resolveGateState({
+      readyGates: [],
+      openGates: [],
+      epicsAwaitingMerge: [createBead({ id: 'epic-9', title: 'Merge epic into main' })],
+    });
+
+    assert.deepEqual(state.pendingHumanAction, [
+      { id: 'epic-9', title: 'Merge epic into main', kind: 'epic-pr' },
+    ]);
+    assert.deepEqual(state.parked, []);
+  });
+});
+
+describe('fetchGateState', () => {
+  it('asks bd for unblocked gates, all gates, and epics awaiting merge on either HITL axis', async () => {
+    const { exec, calls } = makeExec();
+
+    await fetchGateState({ exec });
+
+    assert.deepEqual(calls, [
+      ['ready', '--json', '-l', FEATURE_GATE_LABEL, '--label-any', HITL_GATE_LABELS.join(',')],
+      ['list', '--json', '--limit', '0', '-l', FEATURE_GATE_LABEL, '--label-any', HITL_GATE_LABELS.join(',')],
+      ['list', '--json', '--limit', '0', '-l', EPIC_GATE_LABEL],
+    ]);
+  });
+
+  it('covers both the current and the legacy HITL label axis', () => {
+    assert.deepEqual(HITL_GATE_LABELS, ['execution:hitl', 'implementation-type:hitl']);
+  });
+
+  it('treats a gate that only the list query returns as parked', async () => {
+    const { exec } = makeExec({ ready: [], open: [createBead({ id: 'proj-1.5' })] });
+
+    const state = await fetchGateState({ exec });
+
+    assert.deepEqual(state.pendingHumanAction, []);
+    assert.deepEqual(state.parked, [{ id: 'proj-1.5', title: 'proj-1.5 title' }]);
+  });
+});
+
+describe('pending-gates CLI', () => {
+  it('prints the resolved gate state as JSON', async () => {
+    const { exec } = makeExec({
+      ready: [createBead({ id: 'proj-1.5' })],
+      open: [createBead({ id: 'proj-1.5' }), createBead({ id: 'proj-2.5' })],
+      epics: [createBead({ id: 'epic-9' })],
+    });
+    const out = capture();
+
+    const code = await runCli({ argv: [], exec, write: out.write });
+
+    assert.equal(code, 0);
+    assert.deepEqual(out.read(), {
+      pendingHumanAction: [
+        { id: 'proj-1.5', title: 'proj-1.5 title', kind: 'feature-pr' },
+        { id: 'epic-9', title: 'epic-9 title', kind: 'epic-pr' },
+      ],
+      parked: [{ id: 'proj-2.5', title: 'proj-2.5 title' }],
+    });
+  });
+});

package/test/skill-frontmatter.test.mjs

@@ -0,0 +1,137 @@
+// 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");
+  });
+});