@kata-sh/cli 0.1.0 → 0.1.2

package/src/resources/extensions/kata/tests/requirements.test.ts

@@ -0,0 +1,151 @@
+import { parseRequirementCounts } from "../files.ts";
+import { mkdtempSync, mkdirSync, rmSync, writeFileSync } from "node:fs";
+import { join } from "node:path";
+import { tmpdir } from "node:os";
+import { deriveState } from "../state.ts";
+import { runKataDoctor } from "../doctor.ts";
+
+let passed = 0;
+let failed = 0;
+
+function assert(condition: boolean, message: string): void {
+  if (condition) passed++;
+  else {
+    failed++;
+    console.error(`  FAIL: ${message}`);
+  }
+}
+
+function assertEq<T>(actual: T, expected: T, message: string): void {
+  if (JSON.stringify(actual) === JSON.stringify(expected)) passed++;
+  else {
+    failed++;
+    console.error(
+      `  FAIL: ${message} — expected ${JSON.stringify(expected)}, got ${JSON.stringify(actual)}`,
+    );
+  }
+}
+
+console.log("\n=== requirement counts parser ===");
+{
+  const counts = parseRequirementCounts(`# Requirements
+
+## Active
+
+### R001 — Foo
+- Status: active
+
+### R002 — Bar
+- Status: blocked
+
+## Validated
+
+### R010 — Baz
+- Status: validated
+
+## Deferred
+
+### R020 — Qux
+- Status: deferred
+
+## Out of Scope
+
+### R030 — No
+- Status: out-of-scope
+`);
+  assertEq(counts.active, 2, "counts active requirements by section");
+  assertEq(counts.validated, 1, "counts validated requirements");
+  assertEq(counts.deferred, 1, "counts deferred requirements");
+  assertEq(counts.outOfScope, 1, "counts out of scope requirements");
+  assertEq(counts.blocked, 1, "counts blocked statuses");
+}
+
+const base = mkdtempSync(join(tmpdir(), "kata-requirements-test-"));
+const kata = join(base, ".kata");
+const mDir = join(kata, "milestones", "M001");
+const sDir = join(mDir, "slices", "S01");
+const tDir = join(sDir, "tasks");
+mkdirSync(tDir, { recursive: true });
+writeFileSync(
+  join(kata, "REQUIREMENTS.md"),
+  `# Requirements
+
+## Active
+
+### R001 — Missing owner
+- Class: core-capability
+- Status: active
+- Description: thing
+- Why it matters: thing
+- Source: user
+- Primary owning slice: none yet
+- Supporting slices: none
+- Validation: unmapped
+- Notes: none
+
+## Validated
+
+## Deferred
+
+## Out of Scope
+
+## Traceability
+`,
+  "utf-8",
+);
+writeFileSync(
+  join(mDir, "M001-ROADMAP.md"),
+  `# M001: Demo
+
+## Slices
+- [ ] **S01: Demo Slice** \`risk:low\` \`depends:[]\`
+  > After this: demo works
+`,
+  "utf-8",
+);
+writeFileSync(
+  join(sDir, "S01-PLAN.md"),
+  `# S01: Demo Slice
+
+**Goal:** Demo
+**Demo:** Demo
+
+## Must-Haves
+- done
+
+## Tasks
+- [ ] **T01: Implement thing** \`est:10m\`
+  Task is in progress.
+`,
+  "utf-8",
+);
+
+console.log("\n=== deriveState includes requirements counts ===");
+{
+  const state = await deriveState(base);
+  assert(
+    state.requirements !== undefined,
+    "state includes requirements summary",
+  );
+  assertEq(
+    state.requirements?.active,
+    1,
+    "state reports active requirement count",
+  );
+}
+
+console.log("\n=== doctor flags orphaned active requirement ===");
+{
+  const report = await runKataDoctor(base);
+  assert(
+    report.issues.some(
+      (issue) => issue.code === "active_requirement_missing_owner",
+    ),
+    "doctor flags missing owner",
+  );
+}
+
+rmSync(base, { recursive: true, force: true });
+console.log(`\nResults: ${passed} passed, ${failed} failed`);
+if (failed > 0) process.exit(1);
+console.log("All tests passed ✓");

package/src/resources/extensions/kata/tests/resolve-ts-hooks.mjs

@@ -0,0 +1,17 @@
+// ESM resolve hook: .js → .ts rewriting for test environments.
+// Only rewrites relative imports from our own source files — not from node_modules.
+
+export function resolve(specifier, context, nextResolve) {
+  const parentURL = context.parentURL || '';
+  const isFromNodeModules = parentURL.includes('/node_modules/');
+
+  if (specifier.endsWith('.js') && !specifier.startsWith('node:') && !isFromNodeModules) {
+    const tsSpecifier = specifier.replace(/\.js$/, '.ts');
+    try {
+      return nextResolve(tsSpecifier, context);
+    } catch {
+      // fall through to default resolution
+    }
+  }
+  return nextResolve(specifier, context);
+}

package/src/resources/extensions/kata/tests/resolve-ts.mjs

@@ -0,0 +1,11 @@
+// Custom ESM resolver: rewrites .js imports to .ts for node --test with TypeScript sources.
+// Usage: node --import ./agent/extensions/kata/tests/resolve-ts.mjs --test ...
+//
+// This is needed because pi extension source files use .js import specifiers
+// (the pi runtime bundler convention), but only .ts files exist on disk.
+// Node's built-in TypeScript support strips types but doesn't rewrite specifiers.
+
+import { register } from 'node:module';
+import { pathToFileURL } from 'node:url';
+
+register(new URL('./resolve-ts-hooks.mjs', import.meta.url), pathToFileURL('./'));

package/src/resources/extensions/kata/tests/run-uat.test.ts

@@ -0,0 +1,383 @@
+// Tests for extractUatType — the core UAT classification primitive — plus
+// prompt template loading and dispatch precondition assertions (via
+// resolveSliceFile / extractUatType on real fixture files).
+//
+// Sections:
+//   (a)–(j)  extractUatType classification (17 assertions from T01)
+//   (k)      run-uat prompt template loading and content integrity (8 assertions)
+//   (l)      dispatch precondition assertions via resolveSliceFile (4 assertions)
+
+import {
+  mkdtempSync,
+  mkdirSync,
+  readFileSync,
+  rmSync,
+  writeFileSync,
+} from "node:fs";
+import { join, dirname } from "node:path";
+import { tmpdir } from "node:os";
+import { fileURLToPath } from "node:url";
+
+import { extractUatType } from "../files.ts";
+import { resolveSliceFile } from "../paths.ts";
+
+// ─── Worktree-aware prompt loader ──────────────────────────────────────────
+// Resolves prompts relative to this test file so the worktree copy is used
+// instead of the main checkout copy (matches complete-milestone.test.ts pattern).
+
+const __dirname = dirname(fileURLToPath(import.meta.url));
+const worktreePromptsDir = join(__dirname, "..", "prompts");
+
+function loadPromptFromWorktree(
+  name: string,
+  vars: Record<string, string> = {},
+): string {
+  const path = join(worktreePromptsDir, `${name}.md`);
+  let content = readFileSync(path, "utf-8");
+  for (const [key, value] of Object.entries(vars)) {
+    content = content.replaceAll(`{{${key}}}`, value);
+  }
+  return content.trim();
+}
+
+// ─── Assertion helpers ─────────────────────────────────────────────────────
+
+let passed = 0;
+let failed = 0;
+
+function assert(condition: boolean, message: string): void {
+  if (condition) {
+    passed++;
+  } else {
+    failed++;
+    console.error(`  FAIL: ${message}`);
+  }
+}
+
+function assertEq<T>(actual: T, expected: T, message: string): void {
+  if (JSON.stringify(actual) === JSON.stringify(expected)) {
+    passed++;
+  } else {
+    failed++;
+    console.error(
+      `  FAIL: ${message} — expected ${JSON.stringify(expected)}, got ${JSON.stringify(actual)}`,
+    );
+  }
+}
+
+// ─── Fixture helpers ───────────────────────────────────────────────────────
+
+function createFixtureBase(): string {
+  const base = mkdtempSync(join(tmpdir(), "kata-run-uat-test-"));
+  mkdirSync(join(base, ".kata", "milestones"), { recursive: true });
+  return base;
+}
+
+function writeSliceFile(
+  base: string,
+  mid: string,
+  sid: string,
+  suffix: string,
+  content: string,
+): void {
+  const dir = join(base, ".kata", "milestones", mid, "slices", sid);
+  mkdirSync(dir, { recursive: true });
+  writeFileSync(join(dir, `${sid}-${suffix}.md`), content);
+}
+
+function cleanup(base: string): void {
+  rmSync(base, { recursive: true, force: true });
+}
+
+function makeUatContent(mode: string): string {
+  return `# UAT File\n\n## UAT Type\n\n- UAT mode: ${mode}\n- Some other bullet: value\n`;
+}
+
+// ═══════════════════════════════════════════════════════════════════════════
+// Tests
+// ═══════════════════════════════════════════════════════════════════════════
+
+async function main(): Promise<void> {
+  // ─── (a) artifact-driven ──────────────────────────────────────────────────
+  console.log("\n── (a) artifact-driven");
+
+  assertEq(
+    extractUatType(makeUatContent("artifact-driven")),
+    "artifact-driven",
+    "plain artifact-driven → artifact-driven",
+  );
+
+  assertEq(
+    extractUatType("## UAT Type\n\n- UAT mode: artifact-driven\n"),
+    "artifact-driven",
+    "minimal content, artifact-driven",
+  );
+
+  // ─── (b) live-runtime ─────────────────────────────────────────────────────
+  console.log("\n── (b) live-runtime");
+
+  assertEq(
+    extractUatType(makeUatContent("live-runtime")),
+    "live-runtime",
+    "plain live-runtime → live-runtime",
+  );
+
+  // ─── (c) human-experience ─────────────────────────────────────────────────
+  console.log("\n── (c) human-experience");
+
+  assertEq(
+    extractUatType(makeUatContent("human-experience")),
+    "human-experience",
+    "plain human-experience → human-experience",
+  );
+
+  // ─── (d) mixed standalone ─────────────────────────────────────────────────
+  console.log("\n── (d) mixed standalone");
+
+  assertEq(
+    extractUatType(makeUatContent("mixed")),
+    "mixed",
+    "plain mixed → mixed",
+  );
+
+  // ─── (e) mixed with parenthetical ─────────────────────────────────────────
+  console.log("\n── (e) mixed parenthetical");
+
+  assertEq(
+    extractUatType(makeUatContent("mixed (artifact-driven + live-runtime)")),
+    "mixed",
+    "mixed (artifact-driven + live-runtime) → mixed (leading keyword only)",
+  );
+
+  assertEq(
+    extractUatType(makeUatContent("mixed (some other description)")),
+    "mixed",
+    "mixed with arbitrary parenthetical → mixed",
+  );
+
+  // ─── (f) missing ## UAT Type section ──────────────────────────────────────
+  console.log("\n── (f) missing UAT Type section");
+
+  assertEq(
+    extractUatType("# UAT File\n\n## Overview\n\nSome content.\n"),
+    undefined,
+    "no ## UAT Type section → undefined",
+  );
+
+  assertEq(extractUatType(""), undefined, "empty content → undefined");
+
+  // ─── (g) ## UAT Type present but no UAT mode: bullet ─────────────────────
+  console.log("\n── (g) UAT Type section present, no UAT mode: bullet");
+
+  assertEq(
+    extractUatType(
+      "## UAT Type\n\n- Some other bullet: value\n- Another bullet\n",
+    ),
+    undefined,
+    "section present but no UAT mode: bullet → undefined",
+  );
+
+  assertEq(
+    extractUatType("## UAT Type\n\n"),
+    undefined,
+    "section present but empty → undefined",
+  );
+
+  // ─── (h) unknown keyword ──────────────────────────────────────────────────
+  console.log("\n── (h) unknown keyword");
+
+  assertEq(
+    extractUatType(makeUatContent("automated")),
+    undefined,
+    "unknown keyword automated → undefined",
+  );
+
+  assertEq(
+    extractUatType(makeUatContent("fully-automated")),
+    undefined,
+    "unknown keyword fully-automated → undefined",
+  );
+
+  // ─── (i) extra whitespace around value ────────────────────────────────────
+  console.log("\n── (i) extra whitespace");
+
+  assertEq(
+    extractUatType("## UAT Type\n\n- UAT mode:   artifact-driven   \n"),
+    "artifact-driven",
+    "leading/trailing whitespace around value → still classified correctly",
+  );
+
+  assertEq(
+    extractUatType(
+      "## UAT Type\n\n- UAT mode:  mixed (artifact-driven + live-runtime)  \n",
+    ),
+    "mixed",
+    "whitespace around mixed parenthetical → mixed",
+  );
+
+  // ─── (j) case sensitivity ─────────────────────────────────────────────────
+  console.log("\n── (j) case sensitivity");
+
+  assertEq(
+    extractUatType(makeUatContent("Artifact-Driven")),
+    "artifact-driven",
+    "Artifact-Driven (title case) → artifact-driven (function lowercases before matching)",
+  );
+
+  assertEq(
+    extractUatType(makeUatContent("MIXED")),
+    "mixed",
+    "MIXED (upper case) → mixed (function lowercases before matching)",
+  );
+
+  // ─── (k) prompt template loading and content integrity ────────────────────
+  console.log("\n── (k) run-uat prompt template");
+
+  const milestoneId = "M001";
+  const sliceId = "S01";
+  const uatPath = ".kata/milestones/M001/slices/S01/S01-UAT.md";
+  const uatResultAbsPath = "/tmp/kata-test/S01-UAT-RESULT.md";
+  const uatResultPath = ".kata/milestones/M001/slices/S01/S01-UAT-RESULT.md";
+  const uatType = "artifact-driven";
+  const inlinedContext = "<!-- no context -->";
+
+  let promptResult: string | undefined;
+  let promptThrew = false;
+  try {
+    promptResult = loadPromptFromWorktree("run-uat", {
+      milestoneId,
+      sliceId,
+      uatPath,
+      uatResultAbsPath,
+      uatResultPath,
+      uatType,
+      inlinedContext,
+    });
+  } catch {
+    promptThrew = true;
+  }
+
+  assert(
+    !promptThrew,
+    'loadPromptFromWorktree("run-uat", vars) does not throw',
+  );
+  assert(
+    typeof promptResult === "string" && promptResult.length > 0,
+    "run-uat prompt result is a non-empty string",
+  );
+  assert(
+    promptResult?.includes(milestoneId) ?? false,
+    `prompt contains milestoneId value "${milestoneId}" after substitution`,
+  );
+  assert(
+    promptResult?.includes(sliceId) ?? false,
+    `prompt contains sliceId value "${sliceId}" after substitution`,
+  );
+  assert(
+    promptResult?.includes(uatResultAbsPath) ?? false,
+    `prompt contains uatResultAbsPath value after substitution`,
+  );
+  assert(
+    !/\{\{[^}]+\}\}/.test(promptResult ?? ""),
+    "no unreplaced {{...}} tokens remain after variable substitution",
+  );
+  assert(
+    /artifact|execute|run/i.test(promptResult ?? ""),
+    "prompt contains artifact-driven execution language (artifact/execute/run)",
+  );
+  assert(
+    /surfaced for human review/i.test(promptResult ?? ""),
+    'prompt contains "surfaced for human review" text for non-artifact-driven path',
+  );
+
+  // ─── (l) dispatch precondition assertions via resolveSliceFile ────────────
+  console.log("\n── (l) dispatch preconditions via resolveSliceFile");
+
+  // State A: UAT file exists, UAT-RESULT file does NOT — triggers dispatch
+  {
+    const base = createFixtureBase();
+    const uatContent = makeUatContent("artifact-driven");
+    try {
+      writeSliceFile(base, "M001", "S01", "UAT", uatContent);
+
+      const uatFilePath = resolveSliceFile(base, "M001", "S01", "UAT");
+      assert(
+        uatFilePath !== null,
+        'resolveSliceFile(..., "UAT") returns non-null when UAT file exists (dispatch trigger state)',
+      );
+
+      const uatResultFilePath = resolveSliceFile(
+        base,
+        "M001",
+        "S01",
+        "UAT-RESULT",
+      );
+      assertEq(
+        uatResultFilePath,
+        null,
+        'resolveSliceFile(..., "UAT-RESULT") returns null when result file missing (dispatch trigger state)',
+      );
+
+      // End-to-end: file content → parse → classify
+      const rawContent = readFileSync(uatFilePath!, "utf-8");
+      assertEq(
+        extractUatType(rawContent),
+        "artifact-driven",
+        "extractUatType on fixture UAT file returns expected type (end-to-end data flow)",
+      );
+    } finally {
+      cleanup(base);
+    }
+  }
+
+  // State B: UAT-RESULT file exists — dispatch is skipped (idempotent)
+  {
+    const base = createFixtureBase();
+    try {
+      writeSliceFile(
+        base,
+        "M001",
+        "S01",
+        "UAT",
+        makeUatContent("artifact-driven"),
+      );
+      writeSliceFile(
+        base,
+        "M001",
+        "S01",
+        "UAT-RESULT",
+        "# UAT Result\n\nverdict: PASS\n",
+      );
+
+      const uatResultFilePath = resolveSliceFile(
+        base,
+        "M001",
+        "S01",
+        "UAT-RESULT",
+      );
+      assert(
+        uatResultFilePath !== null,
+        'resolveSliceFile(..., "UAT-RESULT") returns non-null when result file exists (idempotent skip state)',
+      );
+    } finally {
+      cleanup(base);
+    }
+  }
+
+  // ═══════════════════════════════════════════════════════════════════════════
+  // Results
+  // ═══════════════════════════════════════════════════════════════════════════
+
+  console.log(`\n${"=".repeat(40)}`);
+  console.log(`Results: ${passed} passed, ${failed} failed`);
+  if (failed > 0) {
+    process.exit(1);
+  } else {
+    console.log("All tests passed ✓");
+  }
+}
+
+main().catch((error) => {
+  console.error(error);
+  process.exit(1);
+});