@kata-sh/cli 0.1.0 → 0.1.2

package/src/resources/extensions/kata/tests/complete-milestone.test.ts

@@ -0,0 +1,317 @@
+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";
+
+// loadPrompt reads from ~/.kata-cli/agent/extensions/kata/prompts/ (main checkout).
+// In a worktree the file may not exist there yet, so we resolve prompts
+// relative to this test file's location (the worktree copy).
+const __dirname = dirname(fileURLToPath(import.meta.url));
+const worktreePromptsDir = join(__dirname, "..", "prompts");
+
+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)}`,
+    );
+  }
+}
+
+/**
+ * Load a prompt template from the worktree prompts directory
+ * and apply variable substitution (mirrors loadPrompt logic).
+ */
+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();
+}
+
+// ─── Fixture Helpers ───────────────────────────────────────────────────────
+
+function createFixtureBase(): string {
+  const base = mkdtempSync(join(tmpdir(), "kata-complete-ms-test-"));
+  mkdirSync(join(base, ".kata", "milestones"), { recursive: true });
+  return base;
+}
+
+function writeRoadmap(base: string, mid: string, content: string): void {
+  const dir = join(base, ".kata", "milestones", mid);
+  mkdirSync(dir, { recursive: true });
+  writeFileSync(join(dir, `${mid}-ROADMAP.md`), content);
+}
+
+function writeMilestoneSummary(
+  base: string,
+  mid: string,
+  content: string,
+): void {
+  const dir = join(base, ".kata", "milestones", mid);
+  mkdirSync(dir, { recursive: true });
+  writeFileSync(join(dir, `${mid}-SUMMARY.md`), content);
+}
+
+function cleanup(base: string): void {
+  rmSync(base, { recursive: true, force: true });
+}
+
+// ═══════════════════════════════════════════════════════════════════════════
+// Tests
+// ═══════════════════════════════════════════════════════════════════════════
+
+async function main(): Promise<void> {
+  // ─── Prompt Template Loading ───────────────────────────────────────────
+  console.log("\n=== complete-milestone prompt template exists ===");
+  {
+    let result: string;
+    let threw = false;
+    try {
+      result = loadPromptFromWorktree("complete-milestone", {
+        milestoneId: "M001",
+        milestoneTitle: "Test Milestone",
+        roadmapPath: ".kata/milestones/M001/M001-ROADMAP.md",
+        inlinedContext: "test context block",
+      });
+    } catch (err) {
+      threw = true;
+      result = "";
+      console.error(`  ERROR: loadPrompt threw: ${err}`);
+    }
+
+    assert(!threw, "loadPrompt does not throw for complete-milestone");
+    assert(
+      typeof result === "string" && result.length > 0,
+      "loadPrompt returns a non-empty string",
+    );
+  }
+
+  // ─── Variable Substitution ─────────────────────────────────────────────
+  console.log("\n=== prompt variable substitution ===");
+  {
+    const prompt = loadPromptFromWorktree("complete-milestone", {
+      milestoneId: "M001",
+      milestoneTitle: "Integration Feature",
+      roadmapPath: ".kata/milestones/M001/M001-ROADMAP.md",
+      inlinedContext: "--- inlined slice summaries and context ---",
+    });
+
+    assert(prompt.includes("M001"), "prompt contains milestoneId 'M001'");
+    assert(
+      prompt.includes("Integration Feature"),
+      "prompt contains milestoneTitle",
+    );
+    assert(
+      prompt.includes(".kata/milestones/M001/M001-ROADMAP.md"),
+      "prompt contains roadmapPath",
+    );
+    assert(
+      prompt.includes("--- inlined slice summaries and context ---"),
+      "prompt contains inlinedContext",
+    );
+    assert(
+      !prompt.includes("{{milestoneId}}"),
+      "no un-substituted {{milestoneId}}",
+    );
+    assert(
+      !prompt.includes("{{milestoneTitle}}"),
+      "no un-substituted {{milestoneTitle}}",
+    );
+    assert(
+      !prompt.includes("{{roadmapPath}}"),
+      "no un-substituted {{roadmapPath}}",
+    );
+    assert(
+      !prompt.includes("{{inlinedContext}}"),
+      "no un-substituted {{inlinedContext}}",
+    );
+  }
+
+  // ─── Prompt Content Integrity ──────────────────────────────────────────
+  console.log("\n=== prompt content integrity ===");
+  {
+    const prompt = loadPromptFromWorktree("complete-milestone", {
+      milestoneId: "M002",
+      milestoneTitle: "Completion Workflow",
+      roadmapPath: ".kata/milestones/M002/M002-ROADMAP.md",
+      inlinedContext: "context",
+    });
+
+    assert(
+      prompt.includes("Complete Milestone"),
+      "prompt contains 'Complete Milestone' heading",
+    );
+    assert(
+      prompt.includes("success criter") || prompt.includes("success criteria"),
+      "prompt mentions success criteria verification",
+    );
+    assert(
+      prompt.includes("milestone-summary") ||
+        prompt.includes("milestoneSummary"),
+      "prompt references milestone summary artifact",
+    );
+    assert(
+      prompt.includes("Milestone M002 complete"),
+      "prompt contains completion sentinel for M002",
+    );
+  }
+
+  // ─── diagnoseExpectedArtifact behavior ─────────────────────────────────
+  // Since diagnoseExpectedArtifact is not exported from auto.ts, we test
+  // the same logic by reimplementing the switch case for complete-milestone
+  // and verifying against known path patterns.
+  console.log(
+    "\n=== diagnoseExpectedArtifact logic for complete-milestone ===",
+  );
+  {
+    // Import the path helpers used by diagnoseExpectedArtifact
+    const { relMilestoneFile } = await import("../paths.ts");
+
+    // Simulate diagnoseExpectedArtifact("complete-milestone", "M001", base) logic
+    const base = createFixtureBase();
+    try {
+      writeRoadmap(
+        base,
+        "M001",
+        `# M001\n\n## Slices\n- [x] **S01: Done** \`risk:low\` \`depends:[]\`\n  > After this: done\n`,
+      );
+
+      const unitType = "complete-milestone";
+      const unitId = "M001";
+      const parts = unitId.split("/");
+      const mid = parts[0]!;
+
+      // This is the exact logic from diagnoseExpectedArtifact for "complete-milestone"
+      const result = `${relMilestoneFile(base, mid, "SUMMARY")} (milestone summary)`;
+
+      assert(typeof result === "string", "diagnose returns a string");
+      assert(result.includes("SUMMARY"), "diagnose result mentions SUMMARY");
+      assert(
+        result.includes("milestone"),
+        "diagnose result mentions milestone",
+      );
+      assert(
+        result.includes("M001"),
+        "diagnose result includes the milestone ID",
+      );
+    } finally {
+      cleanup(base);
+    }
+  }
+
+  // ─── deriveState integration: completing-milestone dispatches correctly ─
+  console.log("\n=== deriveState completing-milestone integration ===");
+  {
+    const { deriveState, isMilestoneComplete } = await import("../state.ts");
+    const { parseRoadmap } = await import("../files.ts");
+
+    const base = createFixtureBase();
+    try {
+      writeRoadmap(
+        base,
+        "M001",
+        `# M001: Integration Test
+
+**Vision:** Test completing-milestone flow.
+
+## Slices
+
+- [x] **S01: Slice One** \`risk:low\` \`depends:[]\`
+  > After this: done.
+
+- [x] **S02: Slice Two** \`risk:low\` \`depends:[S01]\`
+  > After this: done.
+`,
+      );
+
+      // Verify isMilestoneComplete returns true
+      const { loadFile } = await import("../files.ts");
+      const roadmapPath = join(
+        base,
+        ".kata",
+        "milestones",
+        "M001",
+        "M001-ROADMAP.md",
+      );
+      const roadmapContent = await loadFile(roadmapPath);
+      const roadmap = parseRoadmap(roadmapContent!);
+      assert(
+        isMilestoneComplete(roadmap),
+        "isMilestoneComplete returns true when all slices are [x]",
+      );
+
+      // Verify deriveState returns completing-milestone phase
+      const state = await deriveState(base);
+      assertEq(
+        state.phase,
+        "completing-milestone",
+        "deriveState returns completing-milestone when all slices done, no summary",
+      );
+      assertEq(state.activeMilestone?.id, "M001", "active milestone is M001");
+      assertEq(
+        state.activeSlice,
+        null,
+        "no active slice in completing-milestone",
+      );
+
+      // Now add the summary and verify it transitions to complete
+      writeMilestoneSummary(base, "M001", "# M001 Summary\n\nDone.");
+      const stateAfter = await deriveState(base);
+      assertEq(
+        stateAfter.phase,
+        "complete",
+        "deriveState returns complete after summary exists",
+      );
+      assertEq(
+        stateAfter.registry[0]?.status,
+        "complete",
+        "registry shows complete status",
+      );
+    } 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);
+});

package/src/resources/extensions/kata/tests/cost-projection.test.ts

@@ -0,0 +1,160 @@
+/**
+ * Contract tests for `formatCostProjection`.
+ * Tests the pure function — no file I/O, no extension context.
+ *
+ * This test intentionally fails at import time (or on first assertion)
+ * because `formatCostProjection` does not yet exist in metrics.ts.
+ * That failure confirms the test runs against real code. (T01 state)
+ */
+
+import {
+  type SliceAggregate,
+  formatCostProjection,
+} from "../metrics.js";
+
+// ─── Test helpers ─────────────────────────────────────────────────────────────
+
+function makeSliceAggregate(sliceId: string, cost: number): SliceAggregate {
+  return {
+    sliceId,
+    units: 1,
+    tokens: { input: 0, output: 0, cacheRead: 0, cacheWrite: 0, total: 0 },
+    cost,
+    duration: 1000,
+  };
+}
+
+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 (actual === expected) {
+    passed++;
+  } else {
+    failed++;
+    console.error(`  FAIL: ${message} — expected ${JSON.stringify(expected)}, got ${JSON.stringify(actual)}`);
+  }
+}
+
+// ─── formatCostProjection ─────────────────────────────────────────────────────
+
+console.log("\n=== formatCostProjection ===");
+
+// 1. Zero completed slices → empty result
+{
+  const result = formatCostProjection([], 3);
+  assertEq(result.length, 0, "zero slices → empty array");
+}
+
+// 2. One slice → suppressed (need ≥2 to project reliably)
+{
+  const result = formatCostProjection([makeSliceAggregate("M001/S01", 0.10)], 3);
+  assertEq(result.length, 0, "one slice → suppressed (no projection shown)");
+}
+
+// 3. Two slices → projection shown (result.length > 0)
+{
+  const slices = [
+    makeSliceAggregate("M001/S01", 0.10),
+    makeSliceAggregate("M001/S02", 0.10),
+  ];
+  const result = formatCostProjection(slices, 5);
+  assert(result.length > 0, "two slices → projection shown");
+}
+
+// 4. Two-slice result: result[0] contains "$" (cost is formatted)
+{
+  const slices = [
+    makeSliceAggregate("M001/S01", 0.10),
+    makeSliceAggregate("M001/S02", 0.10),
+  ];
+  const result = formatCostProjection(slices, 5);
+  assert(result.length > 0 && result[0].includes("$"), "projection line contains \"$\"");
+}
+
+// 5. Budget ceiling hit: total $0.20 >= ceiling $0.05 → line contains "ceiling"
+{
+  const slices = [
+    makeSliceAggregate("M001/S01", 0.10),
+    makeSliceAggregate("M001/S02", 0.10),
+  ];
+  const result = formatCostProjection(slices, 5, 0.05);
+  const hasCeilingLine = result.some(
+    line => line.toLowerCase().includes("ceiling")
+  );
+  assert(hasCeilingLine, "ceiling warning appears when total ($0.20) >= ceiling ($0.05)");
+}
+
+// 6. Budget ceiling not hit: total $0.20 < ceiling $100.00 → no ceiling line
+{
+  const slices = [
+    makeSliceAggregate("M001/S01", 0.10),
+    makeSliceAggregate("M001/S02", 0.10),
+  ];
+  const result = formatCostProjection(slices, 5, 100.00);
+  const hasCeilingLine = result.some(
+    line => line.toLowerCase().includes("ceiling")
+  );
+  assert(!hasCeilingLine, "no ceiling warning when total ($0.20) < ceiling ($100.00)");
+}
+
+// 7. No ceiling arg → no ceiling line
+{
+  const slices = [
+    makeSliceAggregate("M001/S01", 0.10),
+    makeSliceAggregate("M001/S02", 0.10),
+  ];
+  const result = formatCostProjection(slices, 5);
+  const hasCeilingLine = result.some(
+    line => line.toLowerCase().includes("ceiling")
+  );
+  assert(!hasCeilingLine, "no ceiling warning when no ceiling is set");
+}
+
+// 8. Rounding: avg $0.10 × 5 remaining = $0.50 → result[0] contains "$0.50"
+{
+  const slices = [
+    makeSliceAggregate("M001/S01", 0.10),
+    makeSliceAggregate("M001/S02", 0.10),
+  ];
+  const result = formatCostProjection(slices, 5);
+  const hasRoundedCost = result.some(line => line.includes("$0.50"));
+  assert(hasRoundedCost, "projected cost $0.50 (avg $0.10 × 5 remaining) appears in output");
+}
+
+// 9. Bare milestone entries excluded from average:
+//    makeSliceAggregate('M001', 5.00) has no "/" in sliceId → excluded from avg calc.
+//    Only M001/S01 ($0.10) and M001/S02 ($0.10) count → avg $0.10 × 3 remaining = $0.30
+{
+  const slices = [
+    makeSliceAggregate("M001", 5.00),        // bare milestone — must be excluded
+    makeSliceAggregate("M001/S01", 0.10),
+    makeSliceAggregate("M001/S02", 0.10),
+  ];
+  const result = formatCostProjection(slices, 3);
+  const hasCorrectProjection = result.some(line => line.includes("$0.30"));
+  assert(
+    hasCorrectProjection,
+    "bare milestone entry excluded from avg: projection shows $0.30 (avg $0.10 × 3), not $1.83 (including $5.00 entry)"
+  );
+}
+
+// ─── Summary ──────────────────────────────────────────────────────────────────
+
+console.log(`\n${"=".repeat(40)}`);
+console.log(`Results: ${passed} passed, ${failed} failed`);
+if (failed > 0) {
+  console.error(`${failed} test(s) failed`);
+  process.exit(1);
+} else {
+  console.log("All tests passed ✓");
+}