@kata-sh/cli 0.1.0 → 0.1.2

package/src/resources/extensions/kata/tests/unit-runtime.test.ts

@@ -0,0 +1,388 @@
+import {
+  mkdtempSync,
+  mkdirSync,
+  readFileSync,
+  rmSync,
+  writeFileSync,
+} from "node:fs";
+import { join } from "node:path";
+import { tmpdir } from "node:os";
+import {
+  clearUnitRuntimeRecord,
+  formatExecuteTaskRecoveryStatus,
+  inspectExecuteTaskDurability,
+  readUnitRuntimeRecord,
+  writeUnitRuntimeRecord,
+} from "../unit-runtime.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)}`,
+    );
+  }
+}
+
+const base = mkdtempSync(join(tmpdir(), "kata-unit-runtime-test-"));
+const tasksDir = join(
+  base,
+  ".kata",
+  "milestones",
+  "M100",
+  "slices",
+  "S02",
+  "tasks",
+);
+mkdirSync(tasksDir, { recursive: true });
+writeFileSync(
+  join(base, ".kata", "STATE.md"),
+  "## Next Action\nExecute T09 for S02: do the thing\n",
+  "utf-8",
+);
+writeFileSync(
+  join(base, ".kata", "milestones", "M100", "slices", "S02", "S02-PLAN.md"),
+  "# S02: Test Slice\n\n## Tasks\n\n- [ ] **T09: Do the thing** `est:10m`\n  Description.\n",
+  "utf-8",
+);
+
+console.log("\n=== runtime record write/read/update ===");
+{
+  const first = writeUnitRuntimeRecord(
+    base,
+    "execute-task",
+    "M100/S02/T09",
+    1000,
+    { phase: "dispatched" },
+  );
+  assertEq(first.phase, "dispatched", "initial phase");
+  const second = writeUnitRuntimeRecord(
+    base,
+    "execute-task",
+    "M100/S02/T09",
+    1000,
+    { phase: "wrapup-warning-sent", wrapupWarningSent: true },
+  );
+  assertEq(second.wrapupWarningSent, true, "warning persisted");
+  const loaded = readUnitRuntimeRecord(base, "execute-task", "M100/S02/T09");
+  assert(loaded !== null, "record readable");
+  assertEq(loaded!.phase, "wrapup-warning-sent", "updated phase readable");
+}
+
+console.log("\n=== execute-task durability inspection ===");
+{
+  let status = await inspectExecuteTaskDurability(base, "M100/S02/T09");
+  assert(status !== null, "status exists");
+  assertEq(status!.summaryExists, false, "summary initially missing");
+  assertEq(status!.taskChecked, false, "task initially unchecked");
+  assertEq(status!.nextActionAdvanced, false, "next action initially stale");
+  assert(
+    /summary missing/i.test(formatExecuteTaskRecoveryStatus(status!)),
+    "diagnostic mentions summary",
+  );
+
+  writeFileSync(join(tasksDir, "T09-SUMMARY.md"), "# done\n", "utf-8");
+  writeFileSync(
+    join(base, ".kata", "milestones", "M100", "slices", "S02", "S02-PLAN.md"),
+    "# S02: Test Slice\n\n## Tasks\n\n- [x] **T09: Do the thing** `est:10m`\n  Description.\n",
+    "utf-8",
+  );
+  writeFileSync(
+    join(base, ".kata", "STATE.md"),
+    "## Next Action\nExecute T10 for S02: next thing\n",
+    "utf-8",
+  );
+
+  status = await inspectExecuteTaskDurability(base, "M100/S02/T09");
+  assertEq(status!.summaryExists, true, "summary found after write");
+  assertEq(status!.taskChecked, true, "task checked after update");
+  assertEq(
+    status!.nextActionAdvanced,
+    true,
+    "next action advanced after update",
+  );
+  assertEq(
+    formatExecuteTaskRecoveryStatus(status!),
+    "all durable task artifacts present",
+    "clean diagnostic when complete",
+  );
+}
+
+console.log("\n=== runtime record cleanup ===");
+{
+  clearUnitRuntimeRecord(base, "execute-task", "M100/S02/T09");
+  const loaded = readUnitRuntimeRecord(base, "execute-task", "M100/S02/T09");
+  assertEq(loaded, null, "record removed");
+}
+
+// ─── Must-have durability integration tests ───────────────────────────────
+
+// Create a separate temp base for must-have tests to avoid interference
+const mhBase = mkdtempSync(join(tmpdir(), "kata-unit-runtime-mh-test-"));
+
+console.log("\n=== must-haves: all mentioned in summary ===");
+{
+  const tasksDir2 = join(
+    mhBase,
+    ".kata",
+    "milestones",
+    "M200",
+    "slices",
+    "S01",
+    "tasks",
+  );
+  mkdirSync(tasksDir2, { recursive: true });
+
+  // Slice plan with T01 checked
+  writeFileSync(
+    join(mhBase, ".kata", "milestones", "M200", "slices", "S01", "S01-PLAN.md"),
+    "# S01: Test\n\n## Tasks\n\n- [x] **T01: Build parser** `est:10m`\n  Build the parser.\n",
+    "utf-8",
+  );
+  // Task plan with must-haves containing backtick code tokens
+  writeFileSync(
+    join(tasksDir2, "T01-PLAN.md"),
+    "# T01: Build parser\n\n## Must-Haves\n\n- [ ] `parseWidget` function is exported\n- [ ] `formatWidget` handles edge cases\n- [ ] All existing tests pass\n\n## Steps\n\n1. Do stuff\n",
+    "utf-8",
+  );
+  // Summary that mentions all must-haves
+  writeFileSync(
+    join(tasksDir2, "T01-SUMMARY.md"),
+    "# T01: Build parser\n\nAdded parseWidget function and formatWidget with edge case handling. All existing tests pass without regression.\n",
+    "utf-8",
+  );
+  // STATE.md with next action advanced past T01
+  writeFileSync(
+    join(mhBase, ".kata", "STATE.md"),
+    "## Next Action\nExecute T02 for S01: next thing\n",
+    "utf-8",
+  );
+
+  const status = await inspectExecuteTaskDurability(mhBase, "M200/S01/T01");
+  assert(status !== null, "mh-all: status exists");
+  assertEq(status!.mustHaveCount, 3, "mh-all: mustHaveCount is 3");
+  assertEq(
+    status!.mustHavesMentionedInSummary,
+    3,
+    "mh-all: all 3 must-haves mentioned",
+  );
+  assertEq(status!.summaryExists, true, "mh-all: summary exists");
+  assertEq(status!.taskChecked, true, "mh-all: task checked");
+  const diag = formatExecuteTaskRecoveryStatus(status!);
+  assertEq(
+    diag,
+    "all durable task artifacts present",
+    "mh-all: diagnostic is clean when all must-haves met",
+  );
+}
+
+console.log("\n=== must-haves: partially mentioned in summary ===");
+{
+  const tasksDir3 = join(
+    mhBase,
+    ".kata",
+    "milestones",
+    "M200",
+    "slices",
+    "S02",
+    "tasks",
+  );
+  mkdirSync(tasksDir3, { recursive: true });
+
+  writeFileSync(
+    join(mhBase, ".kata", "milestones", "M200", "slices", "S02", "S02-PLAN.md"),
+    "# S02: Test\n\n## Tasks\n\n- [x] **T01: Build thing** `est:10m`\n  Build.\n",
+    "utf-8",
+  );
+  // Task plan with 3 must-haves, summary will only mention 1
+  writeFileSync(
+    join(tasksDir3, "T01-PLAN.md"),
+    "# T01: Build thing\n\n## Must-Haves\n\n- [ ] `computeScore` function is exported\n- [ ] `validateInput` rejects invalid data\n- [ ] `renderOutput` handles empty arrays\n\n## Steps\n\n1. Do stuff\n",
+    "utf-8",
+  );
+  // Summary only mentions computeScore
+  writeFileSync(
+    join(tasksDir3, "T01-SUMMARY.md"),
+    "# T01: Build thing\n\nAdded computeScore function with full test coverage.\n",
+    "utf-8",
+  );
+  writeFileSync(
+    join(mhBase, ".kata", "STATE.md"),
+    "## Next Action\nExecute T02 for S02: next thing\n",
+    "utf-8",
+  );
+
+  const status = await inspectExecuteTaskDurability(mhBase, "M200/S02/T01");
+  assert(status !== null, "mh-partial: status exists");
+  assertEq(status!.mustHaveCount, 3, "mh-partial: mustHaveCount is 3");
+  assertEq(
+    status!.mustHavesMentionedInSummary,
+    1,
+    "mh-partial: only 1 must-have mentioned",
+  );
+  const diag = formatExecuteTaskRecoveryStatus(status!);
+  assert(
+    diag.includes("must-have gap"),
+    "mh-partial: diagnostic includes 'must-have gap'",
+  );
+  assert(diag.includes("1 of 3"), "mh-partial: diagnostic includes '1 of 3'");
+}
+
+console.log("\n=== must-haves: no task plan file ===");
+{
+  const tasksDir4 = join(
+    mhBase,
+    ".kata",
+    "milestones",
+    "M200",
+    "slices",
+    "S03",
+    "tasks",
+  );
+  mkdirSync(tasksDir4, { recursive: true });
+
+  writeFileSync(
+    join(mhBase, ".kata", "milestones", "M200", "slices", "S03", "S03-PLAN.md"),
+    "# S03: Test\n\n## Tasks\n\n- [x] **T01: Quick fix** `est:5m`\n  Fix.\n",
+    "utf-8",
+  );
+  // No T01-PLAN.md — only summary
+  writeFileSync(
+    join(tasksDir4, "T01-SUMMARY.md"),
+    "# T01: Quick fix\n\nFixed the thing.\n",
+    "utf-8",
+  );
+  writeFileSync(
+    join(mhBase, ".kata", "STATE.md"),
+    "## Next Action\nExecute T02 for S03: next thing\n",
+    "utf-8",
+  );
+
+  const status = await inspectExecuteTaskDurability(mhBase, "M200/S03/T01");
+  assert(status !== null, "mh-noplan: status exists");
+  assertEq(
+    status!.mustHaveCount,
+    0,
+    "mh-noplan: mustHaveCount is 0 when no task plan",
+  );
+  assertEq(
+    status!.mustHavesMentionedInSummary,
+    0,
+    "mh-noplan: mustHavesMentionedInSummary is 0",
+  );
+}
+
+console.log("\n=== must-haves: present but no summary file ===");
+{
+  const tasksDir5 = join(
+    mhBase,
+    ".kata",
+    "milestones",
+    "M200",
+    "slices",
+    "S04",
+    "tasks",
+  );
+  mkdirSync(tasksDir5, { recursive: true });
+
+  writeFileSync(
+    join(mhBase, ".kata", "milestones", "M200", "slices", "S04", "S04-PLAN.md"),
+    "# S04: Test\n\n## Tasks\n\n- [ ] **T01: Build parser** `est:10m`\n  Build.\n",
+    "utf-8",
+  );
+  // Task plan with must-haves but NO summary file
+  writeFileSync(
+    join(tasksDir5, "T01-PLAN.md"),
+    "# T01: Build parser\n\n## Must-Haves\n\n- [ ] `parseData` function exported\n- [ ] Error handling covers edge cases\n\n## Steps\n\n1. Do stuff\n",
+    "utf-8",
+  );
+  writeFileSync(
+    join(mhBase, ".kata", "STATE.md"),
+    "## Next Action\nExecute T01 for S04: build parser\n",
+    "utf-8",
+  );
+
+  const status = await inspectExecuteTaskDurability(mhBase, "M200/S04/T01");
+  assert(status !== null, "mh-nosummary: status exists");
+  assertEq(status!.mustHaveCount, 2, "mh-nosummary: mustHaveCount is 2");
+  assertEq(
+    status!.mustHavesMentionedInSummary,
+    0,
+    "mh-nosummary: mustHavesMentionedInSummary is 0 with no summary",
+  );
+  assertEq(status!.summaryExists, false, "mh-nosummary: summary doesn't exist");
+}
+
+console.log("\n=== must-haves: substring matching (no backtick tokens) ===");
+{
+  const tasksDir6 = join(
+    mhBase,
+    ".kata",
+    "milestones",
+    "M200",
+    "slices",
+    "S05",
+    "tasks",
+  );
+  mkdirSync(tasksDir6, { recursive: true });
+
+  writeFileSync(
+    join(mhBase, ".kata", "milestones", "M200", "slices", "S05", "S05-PLAN.md"),
+    "# S05: Test\n\n## Tasks\n\n- [x] **T01: Add diagnostics** `est:10m`\n  Add.\n",
+    "utf-8",
+  );
+  // Must-haves with no backtick tokens — falls back to substring matching
+  writeFileSync(
+    join(tasksDir6, "T01-PLAN.md"),
+    "# T01: Add diagnostics\n\n## Must-Haves\n\n- [ ] Heuristic matching prioritizes backtick-enclosed code tokens\n- [ ] Recovery diagnostic string shows gap count\n- [ ] All assertions pass\n\n## Steps\n\n1. Do stuff\n",
+    "utf-8",
+  );
+  // Summary mentions "heuristic" and "diagnostic" but not "assertions"
+  writeFileSync(
+    join(tasksDir6, "T01-SUMMARY.md"),
+    "# T01: Add diagnostics\n\nImplemented heuristic matching for must-have items. Recovery diagnostic string now includes gap counts.\n",
+    "utf-8",
+  );
+  writeFileSync(
+    join(mhBase, ".kata", "STATE.md"),
+    "## Next Action\nExecute T02 for S05: next thing\n",
+    "utf-8",
+  );
+
+  const status = await inspectExecuteTaskDurability(mhBase, "M200/S05/T01");
+  assert(status !== null, "mh-substr: status exists");
+  assertEq(status!.mustHaveCount, 3, "mh-substr: mustHaveCount is 3");
+  // "heuristic" appears in summary for item 1, "diagnostic" for item 2,
+  // "assertions" appears in summary? No — let's check
+  // Item 3: "All assertions pass" — words: "assertions", "pass" (<4 chars excluded)
+  // summary doesn't contain "assertions" → not matched
+  assertEq(
+    status!.mustHavesMentionedInSummary,
+    2,
+    "mh-substr: 2 of 3 matched via substring",
+  );
+  const diag = formatExecuteTaskRecoveryStatus(status!);
+  assert(
+    diag.includes("must-have gap"),
+    "mh-substr: diagnostic includes gap info",
+  );
+  assert(diag.includes("2 of 3"), "mh-substr: diagnostic includes '2 of 3'");
+}
+
+rmSync(mhBase, { recursive: true, force: true });
+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/workspace-index.test.ts

@@ -0,0 +1,118 @@
+import { mkdtempSync, mkdirSync, rmSync, writeFileSync } from "node:fs";
+import { join } from "node:path";
+import { tmpdir } from "node:os";
+
+import {
+  getSuggestedNextCommands,
+  indexWorkspace,
+  listDoctorScopeSuggestions,
+} from "../workspace-index.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)}`,
+    );
+  }
+}
+
+const base = mkdtempSync(join(tmpdir(), "kata-workspace-index-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(mDir, "M001-ROADMAP.md"),
+  `# M001: Demo Milestone
+
+## Slices
+- [ ] **S01: Demo Slice** \`risk:low\` \`depends:[]\`
+  > After this: demo works
+`,
+);
+
+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.
+`,
+);
+
+writeFileSync(
+  join(tDir, "T01-PLAN.md"),
+  `# T01: Implement thing
+
+## Steps
+- do it
+`,
+);
+
+async function main(): Promise<void> {
+  console.log("\n=== workspace index ===");
+  {
+    const index = await indexWorkspace(base);
+    assertEq(index.active.milestoneId, "M001", "active milestone indexed");
+    assertEq(index.active.sliceId, "S01", "active slice indexed");
+    assertEq(index.active.taskId, "T01", "active task indexed");
+    assert(
+      index.scopes.some((scope) => scope.scope === "M001/S01"),
+      "slice scope listed",
+    );
+    assert(
+      index.scopes.some((scope) => scope.scope === "M001/S01/T01"),
+      "task scope listed",
+    );
+  }
+
+  console.log("\n=== doctor scope suggestions ===");
+  {
+    const suggestions = await listDoctorScopeSuggestions(base);
+    assertEq(suggestions[0].value, "M001/S01", "active slice suggested first");
+    assert(
+      suggestions.some((item) => item.value === "M001/S01/T01"),
+      "task scope suggested",
+    );
+  }
+
+  console.log("\n=== next command suggestions ===");
+  {
+    const commands = await getSuggestedNextCommands(base);
+    assert(commands.includes("/kata auto"), "suggests auto during execution");
+    assert(commands.includes("/kata doctor M001/S01"), "suggests scoped doctor");
+    assert(commands.includes("/kata status"), "suggests status");
+  }
+
+  rmSync(base, { recursive: true, force: true });
+  console.log(`\nResults: ${passed} passed, ${failed} failed`);
+  if (failed > 0) process.exit(1);
+  console.log("All tests passed ✓");
+}
+
+main().catch((error) => {
+  console.error(error);
+  process.exit(1);
+});