test(cli): add Jest test suite for PromptKit CLI

Add comprehensive test coverage for the CLI module:

- manifest.js: loadManifest, getTemplates, persona/protocol/format/
  taxonomy lookups, resolveTemplateDeps (19 tests)
- assemble.js: stripFrontmatter, loadComponent, full assembly with
  section ordering, param substitution, verbatim inclusion (18 tests)
- launch.js: detectCli priority order with mocked child_process,
  copyContentToTemp file/directory operations (9 tests)
- cli.js: integration tests for list, assemble, --version, error
  handling via subprocess execution (7 tests)

Infrastructure:
- Jest dev dependency with test and test:coverage scripts
- Test fixtures (manifest, persona, protocols, format, taxonomy,
  templates) in __tests__/fixtures/
- CI workflow (.github/workflows/cli-tests.yml) triggers on cli/ changes
- coverage/ added to .gitignore

Co-authored-by: Copilot <223556219+Copilot@users.noreply.github.com>

Author: abeltrano

.github/workflows/cli-tests.yml

@@ -0,0 +1,32 @@
+# SPDX-License-Identifier: MIT
+# Copyright (c) PromptKit Contributors
+
+name: CLI Tests
+
+on:
+  push:
+    paths:
+      - 'cli/**'
+  pull_request:
+    paths:
+      - 'cli/**'
+
+jobs:
+  test:
+    name: Run CLI tests
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v4
+
+      - name: Set up Node.js
+        uses: actions/setup-node@v4
+        with:
+          node-version: '22'
+
+      - name: Install dependencies
+        working-directory: cli
+        run: npm ci
+
+      - name: Run tests
+        working-directory: cli
+        run: npm test

cli/.gitignore

@@ -1,2 +1,3 @@
 node_modules/
 content/
+coverage/

cli/__tests__/assemble.test.js

@@ -0,0 +1,194 @@
+// SPDX-License-Identifier: MIT
+
+const path = require("path");
+const fs = require("fs");
+const {
+  assemble,
+  loadComponent,
+  stripFrontmatter,
+} = require("../lib/assemble");
+const { loadManifest, getTemplates } = require("../lib/manifest");
+
+const fixtureDir = path.resolve(__dirname, "fixtures");
+
+describe("assemble", () => {
+  describe("stripFrontmatter", () => {
+    test("removes YAML frontmatter delimited by ---", () => {
+      const input = "---\nname: test\ntype: foo\n---\n# Body\n\nContent here.";
+      expect(stripFrontmatter(input)).toBe("# Body\n\nContent here.");
+    });
+
+    test("returns content unchanged when no frontmatter present", () => {
+      const input = "# Just a heading\n\nSome content.";
+      expect(stripFrontmatter(input)).toBe(input);
+    });
+
+    test("handles frontmatter with Windows-style line endings", () => {
+      const input = "---\r\nname: test\r\n---\r\n# Body";
+      expect(stripFrontmatter(input)).toBe("# Body");
+    });
+
+    test("trims leading/trailing whitespace after stripping", () => {
+      const input = "---\nname: test\n---\n\n  # Body  \n\n";
+      expect(stripFrontmatter(input)).toBe("# Body");
+    });
+  });
+
+  describe("loadComponent", () => {
+    test("loads a persona and strips HTML comments and frontmatter", () => {
+      const body = loadComponent(fixtureDir, "personas/test-engineer.md");
+      expect(body).not.toContain("SPDX-License-Identifier");
+      expect(body).not.toContain("---");
+      expect(body).toContain("# Persona: Test Engineer");
+      expect(body).toContain("You are a test engineer");
+    });
+
+    test("loads a protocol and strips HTML comments and frontmatter", () => {
+      const body = loadComponent(
+        fixtureDir,
+        "protocols/guardrails/anti-hallucination.md"
+      );
+      expect(body).not.toContain("SPDX-License-Identifier");
+      expect(body).toContain("# Protocol: Anti-Hallucination");
+      expect(body).toContain("KNOWN, INFERRED, or ASSUMED");
+    });
+
+    test("returns null for missing component and warns", () => {
+      const warnSpy = jest.spyOn(console, "warn").mockImplementation();
+      const result = loadComponent(fixtureDir, "nonexistent.md");
+
+      expect(result).toBeNull();
+      expect(warnSpy).toHaveBeenCalledWith(
+        expect.stringContaining("nonexistent.md")
+      );
+      warnSpy.mockRestore();
+    });
+  });
+
+  describe("assemble (full)", () => {
+    let manifest;
+
+    beforeAll(() => {
+      manifest = loadManifest(fixtureDir);
+    });
+
+    test("assembles a complete prompt with all sections", () => {
+      const templates = getTemplates(manifest);
+      const bug = templates.find((t) => t.name === "investigate-bug");
+      const result = assemble(fixtureDir, manifest, bug);
+
+      // Check section headers are present in order
+      expect(result).toContain("# Identity");
+      expect(result).toContain("# Reasoning Protocols");
+      expect(result).toContain("# Output Format");
+      expect(result).toContain("# Task");
+
+      // Verify section order
+      const identityPos = result.indexOf("# Identity");
+      const protocolsPos = result.indexOf("# Reasoning Protocols");
+      const formatPos = result.indexOf("# Output Format");
+      const taskPos = result.indexOf("# Task");
+      expect(identityPos).toBeLessThan(protocolsPos);
+      expect(protocolsPos).toBeLessThan(formatPos);
+      expect(formatPos).toBeLessThan(taskPos);
+    });
+
+    test("includes persona body text verbatim", () => {
+      const templates = getTemplates(manifest);
+      const bug = templates.find((t) => t.name === "investigate-bug");
+      const result = assemble(fixtureDir, manifest, bug);
+
+      expect(result).toContain("# Persona: Test Engineer");
+      expect(result).toContain("You are a test engineer who writes thorough tests.");
+    });
+
+    test("includes all protocol bodies", () => {
+      const templates = getTemplates(manifest);
+      const bug = templates.find((t) => t.name === "investigate-bug");
+      const result = assemble(fixtureDir, manifest, bug);
+
+      expect(result).toContain("# Protocol: Anti-Hallucination");
+      expect(result).toContain("# Protocol: Root Cause Analysis");
+    });
+
+    test("includes taxonomy when referenced", () => {
+      const templates = getTemplates(manifest);
+      const review = templates.find((t) => t.name === "review-code");
+      const result = assemble(fixtureDir, manifest, review);
+
+      expect(result).toContain("# Classification Taxonomy");
+      expect(result).toContain("# Taxonomy: Stack Lifetime Hazards");
+    });
+
+    test("omits taxonomy section when not referenced", () => {
+      const templates = getTemplates(manifest);
+      const bug = templates.find((t) => t.name === "investigate-bug");
+      const result = assemble(fixtureDir, manifest, bug);
+
+      expect(result).not.toContain("# Classification Taxonomy");
+    });
+
+    test("includes format body text", () => {
+      const templates = getTemplates(manifest);
+      const bug = templates.find((t) => t.name === "investigate-bug");
+      const result = assemble(fixtureDir, manifest, bug);
+
+      expect(result).toContain("# Format: Investigation Report");
+      expect(result).toContain("## Findings");
+    });
+
+    test("includes template task body", () => {
+      const templates = getTemplates(manifest);
+      const bug = templates.find((t) => t.name === "investigate-bug");
+      const result = assemble(fixtureDir, manifest, bug);
+
+      expect(result).toContain("# Task: Investigate Bug");
+      expect(result).toContain("{{bug_description}}");
+    });
+
+    test("substitutes parameters when provided", () => {
+      const templates = getTemplates(manifest);
+      const bug = templates.find((t) => t.name === "investigate-bug");
+      const result = assemble(fixtureDir, manifest, bug, {
+        bug_description: "Use-after-free in socket handler",
+        context: "See socket.c line 42",
+      });
+
+      expect(result).toContain("Use-after-free in socket handler");
+      expect(result).toContain("See socket.c line 42");
+      expect(result).not.toContain("{{bug_description}}");
+      expect(result).not.toContain("{{context}}");
+    });
+
+    test("leaves unfilled params as placeholders", () => {
+      const templates = getTemplates(manifest);
+      const bug = templates.find((t) => t.name === "investigate-bug");
+      const result = assemble(fixtureDir, manifest, bug, {
+        bug_description: "memory leak",
+      });
+
+      expect(result).toContain("memory leak");
+      expect(result).toContain("{{context}}");
+    });
+
+    test("does not contain YAML frontmatter or SPDX headers", () => {
+      const templates = getTemplates(manifest);
+      const bug = templates.find((t) => t.name === "investigate-bug");
+      const result = assemble(fixtureDir, manifest, bug);
+
+      expect(result).not.toContain("SPDX-License-Identifier");
+      // Section dividers (---) are expected; YAML frontmatter (---\nkey: val\n---) is not
+      expect(result).not.toMatch(/^---\r?\n\w+:/m);
+    });
+
+    test("separates sections with --- dividers", () => {
+      const templates = getTemplates(manifest);
+      const bug = templates.find((t) => t.name === "investigate-bug");
+      const result = assemble(fixtureDir, manifest, bug);
+
+      // Sections are joined with \n\n---\n\n
+      const sections = result.split("\n\n---\n\n");
+      expect(sections.length).toBeGreaterThanOrEqual(4);
+    });
+  });
+});

cli/__tests__/cli.test.js

@@ -0,0 +1,129 @@
+// SPDX-License-Identifier: MIT
+
+const path = require("path");
+const { execFileSync } = require("child_process");
+
+const cliPath = path.resolve(__dirname, "..", "bin", "cli.js");
+
+// Integration tests run the actual CLI as a subprocess.
+// They require the content/ directory to be populated via the prepare script,
+// OR we point at the repo root content using the real manifest.
+
+describe("cli integration", () => {
+  // Use the test fixtures by running assemble/list via node directly
+  // with a patched content directory
+
+  describe("list command", () => {
+    test("lists templates as JSON", () => {
+      const result = runCli(["list", "--json"]);
+      const templates = JSON.parse(result);
+
+      expect(Array.isArray(templates)).toBe(true);
+      expect(templates.length).toBeGreaterThan(0);
+      expect(templates[0]).toHaveProperty("name");
+      expect(templates[0]).toHaveProperty("category");
+    });
+
+    test("lists templates in human-readable format", () => {
+      const result = runCli(["list"]);
+
+      expect(result).toContain("Available PromptKit templates:");
+      expect(result).toContain("investigate-bug");
+    });
+  });
+
+  describe("assemble command", () => {
+    const outputPath = path.join(
+      require("os").tmpdir(),
+      `promptkit-test-${Date.now()}.md`
+    );
+
+    afterAll(() => {
+      try {
+        require("fs").unlinkSync(outputPath);
+      } catch {
+        // ignore cleanup errors
+      }
+    });
+
+    test("assembles a template to a file", () => {
+      runCli(["assemble", "investigate-bug", "--output", outputPath]);
+
+      const fs = require("fs");
+      expect(fs.existsSync(outputPath)).toBe(true);
+
+      const content = fs.readFileSync(outputPath, "utf8");
+      expect(content).toContain("# Identity");
+      expect(content).toContain("# Task");
+    });
+
+    test("substitutes params via --param", () => {
+      runCli([
+        "assemble",
+        "investigate-bug",
+        "--output",
+        outputPath,
+        "--param",
+        "problem_description=test bug",
+        "--param",
+        "code_context=test context",
+        "--param",
+        "environment=test env",
+      ]);
+
+      const content = require("fs").readFileSync(outputPath, "utf8");
+      expect(content).toContain("test bug");
+      expect(content).toContain("test context");
+      expect(content).not.toContain("{{problem_description}}");
+    });
+
+    test("reports unfilled parameters", () => {
+      const result = runCli(["assemble", "investigate-bug", "--output", outputPath]);
+
+      expect(result).toContain("unfilled parameter");
+    });
+
+    test("exits with error for unknown template", () => {
+      expect(() => {
+        runCli(["assemble", "nonexistent-template"]);
+      }).toThrow();
+    });
+  });
+
+  describe("--version", () => {
+    test("prints the version number", () => {
+      const result = runCli(["--version"]);
+      expect(result.trim()).toMatch(/^\d+\.\d+\.\d+/);
+    });
+  });
+});
+
+/**
+ * Runs the CLI with the given arguments, using the repo-root content
+ * (via the prepare script output) or falling back to the fixture
+ * content by pointing contentDir.
+ */
+function runCli(args) {
+  // The CLI reads content from ../content relative to bin/cli.js.
+  // We need the prepare script to have run, or we run it first.
+  const contentDir = path.resolve(__dirname, "..", "content");
+  const fs = require("fs");
+
+  if (!fs.existsSync(path.join(contentDir, "manifest.yaml"))) {
+    // Run prepare to copy content
+    execFileSync(process.execPath, [
+      path.resolve(__dirname, "..", "scripts", "copy-content.js"),
+    ], { cwd: path.resolve(__dirname, "..") });
+  }
+
+  const result = execFileSync(
+    process.execPath,
+    [cliPath, ...args],
+    {
+      encoding: "utf8",
+      cwd: path.resolve(__dirname, ".."),
+      timeout: 10000,
+    }
+  );
+  return result;
+}

cli/__tests__/fixtures/formats/investigation-report.md

@@ -0,0 +1,19 @@
+<!-- SPDX-License-Identifier: MIT -->
+
+---
+name: investigation-report
+type: format
+description: Structured investigation report.
+produces: investigation-report
+---
+
+# Format: Investigation Report
+
+## Findings
+
+| # | Finding | Severity | Confidence |
+|---|---------|----------|------------|
+
+## Root Cause
+
+## Remediation