@kata-sh/cli 0.1.0 → 0.1.1

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

@@ -0,0 +1,185 @@
+// Tests for inlinePriorMilestoneSummary — the cross-milestone context bridging helper.
+//
+// Scenarios covered:
+//   (A) M002 with M001-SUMMARY.md present → returns string containing "Prior Milestone Summary" and summary content
+//   (B) M001 (no prior milestone in dir) → returns null
+//   (C) M002 with no M001-SUMMARY.md written → returns null
+//   (D) M003 with M002 dir present but no M002-SUMMARY.md → returns null
+
+import { mkdtempSync, mkdirSync, rmSync, writeFileSync } from "node:fs";
+import { join, dirname } from "node:path";
+import { tmpdir } from "node:os";
+import { fileURLToPath } from "node:url";
+
+import { inlinePriorMilestoneSummary } from "../files.ts";
+
+// ─── Worktree-aware prompt loader ──────────────────────────────────────────
+const __dirname = dirname(fileURLToPath(import.meta.url));
+
+// ─── 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-plan-ms-test-"));
+  mkdirSync(join(base, ".kata", "milestones"), { recursive: true });
+  return base;
+}
+
+function writeMilestoneDir(base: string, mid: string): void {
+  mkdirSync(join(base, ".kata", "milestones", mid), { recursive: true });
+}
+
+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> {
+  // ─── (A) M002 with M001-SUMMARY.md present ────────────────────────────────
+  console.log(
+    '\n── (A) M002 with M001-SUMMARY.md present → string containing "Prior Milestone Summary"',
+  );
+  {
+    const base = createFixtureBase();
+    try {
+      writeMilestoneDir(base, "M001");
+      writeMilestoneDir(base, "M002");
+      writeMilestoneSummary(
+        base,
+        "M001",
+        "# M001 Summary\n\nKey decisions: used TypeScript throughout.\n",
+      );
+
+      const result = await inlinePriorMilestoneSummary("M002", base);
+
+      assert(
+        result !== null,
+        "(A) result is not null when prior milestone has SUMMARY",
+      );
+      assert(
+        typeof result === "string" &&
+          result.includes("Prior Milestone Summary"),
+        '(A) result contains "Prior Milestone Summary" label',
+      );
+      assert(
+        typeof result === "string" &&
+          result.includes("Key decisions: used TypeScript throughout."),
+        "(A) result contains the summary file content",
+      );
+    } finally {
+      cleanup(base);
+    }
+  }
+
+  // ─── (B) M001 (no prior milestone in dir) ─────────────────────────────────
+  console.log("\n── (B) M001 — first milestone, no prior → null");
+  {
+    const base = createFixtureBase();
+    try {
+      writeMilestoneDir(base, "M001");
+
+      const result = await inlinePriorMilestoneSummary("M001", base);
+
+      assertEq(result, null, "(B) M001 with no prior milestone → null");
+    } finally {
+      cleanup(base);
+    }
+  }
+
+  // ─── (C) M002 with no M001-SUMMARY.md ────────────────────────────────────
+  console.log("\n── (C) M002 with M001 dir but no M001-SUMMARY.md → null");
+  {
+    const base = createFixtureBase();
+    try {
+      writeMilestoneDir(base, "M001");
+      writeMilestoneDir(base, "M002");
+      // Intentionally do NOT write M001-SUMMARY.md
+
+      const result = await inlinePriorMilestoneSummary("M002", base);
+
+      assertEq(result, null, "(C) M002 when M001 has no SUMMARY file → null");
+    } finally {
+      cleanup(base);
+    }
+  }
+
+  // ─── (D) M003 with M002 dir but no M002-SUMMARY.md ───────────────────────
+  console.log(
+    "\n── (D) M003, M002 is immediately prior but has no SUMMARY → null",
+  );
+  {
+    const base = createFixtureBase();
+    try {
+      writeMilestoneDir(base, "M001");
+      writeMilestoneDir(base, "M002");
+      writeMilestoneDir(base, "M003");
+      // M001 has a summary — but M002 (the immediately prior to M003) does NOT
+      writeMilestoneSummary(base, "M001", "# M001 Summary\n\nOld context.\n");
+      // Intentionally do NOT write M002-SUMMARY.md
+
+      const result = await inlinePriorMilestoneSummary("M003", base);
+
+      assertEq(
+        result,
+        null,
+        "(D) M003 when M002 (immediately prior) has no SUMMARY → null",
+      );
+    } 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/plan-quality-validator.test.ts

@@ -0,0 +1,386 @@
+import { validateTaskPlanContent, validateSlicePlanContent } from '../observability-validator.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)}`);
+  }
+}
+
+// ═══════════════════════════════════════════════════════════════════════════
+// validateTaskPlanContent — empty/missing Steps section
+// ═══════════════════════════════════════════════════════════════════════════
+
+console.log('\n=== validateTaskPlanContent: empty Steps section ===');
+{
+  const content = `# T01: Some Task
+
+## Description
+
+Do something useful.
+
+## Steps
+
+## Verification
+
+- Run the tests and confirm output.
+`;
+
+  const issues = validateTaskPlanContent('T01-PLAN.md', content);
+  const stepsIssues = issues.filter(i => i.ruleId === 'empty_steps_section');
+  assert(stepsIssues.length >= 1, 'empty Steps section produces empty_steps_section issue');
+  if (stepsIssues.length > 0) {
+    assertEq(stepsIssues[0].severity, 'warning', 'empty_steps_section severity is warning');
+    assertEq(stepsIssues[0].scope, 'task-plan', 'empty_steps_section scope is task-plan');
+  }
+}
+
+console.log('\n=== validateTaskPlanContent: missing Steps section entirely ===');
+{
+  const content = `# T01: Some Task
+
+## Description
+
+Do something useful.
+
+## Verification
+
+- Run the tests.
+`;
+
+  const issues = validateTaskPlanContent('T01-PLAN.md', content);
+  const stepsIssues = issues.filter(i => i.ruleId === 'empty_steps_section');
+  assert(stepsIssues.length >= 1, 'missing Steps section produces empty_steps_section issue');
+}
+
+// ═══════════════════════════════════════════════════════════════════════════
+// validateTaskPlanContent — placeholder-only Verification
+// ═══════════════════════════════════════════════════════════════════════════
+
+console.log('\n=== validateTaskPlanContent: placeholder-only Verification ===');
+{
+  const content = `# T01: Some Task
+
+## Steps
+
+1. Do the thing.
+2. Do the other thing.
+
+## Verification
+
+- {{placeholder verification step}}
+- {{another placeholder}}
+`;
+
+  const issues = validateTaskPlanContent('T01-PLAN.md', content);
+  const verifyIssues = issues.filter(i => i.ruleId === 'placeholder_verification');
+  assert(verifyIssues.length >= 1, 'placeholder-only Verification produces placeholder_verification issue');
+  if (verifyIssues.length > 0) {
+    assertEq(verifyIssues[0].severity, 'warning', 'placeholder_verification severity is warning');
+    assertEq(verifyIssues[0].scope, 'task-plan', 'placeholder_verification scope is task-plan');
+  }
+}
+
+console.log('\n=== validateTaskPlanContent: Verification with only template text ===');
+{
+  const content = `# T01: Some Task
+
+## Steps
+
+1. Do the thing.
+
+## Verification
+
+{{whatWasVerifiedAndHow — commands run, tests passed, behavior confirmed}}
+`;
+
+  const issues = validateTaskPlanContent('T01-PLAN.md', content);
+  const verifyIssues = issues.filter(i => i.ruleId === 'placeholder_verification');
+  assert(verifyIssues.length >= 1, 'template-text-only Verification produces placeholder_verification issue');
+}
+
+// ═══════════════════════════════════════════════════════════════════════════
+// validateSlicePlanContent — empty inline task entries
+// ═══════════════════════════════════════════════════════════════════════════
+
+console.log('\n=== validateSlicePlanContent: empty inline task entries ===');
+{
+  const content = `# S01: Some Slice
+
+**Goal:** Build the thing.
+**Demo:** It works.
+
+## Tasks
+
+- [ ] **T01: First Task** \`est:20m\`
+
+- [ ] **T02: Second Task** \`est:15m\`
+
+## Verification
+
+- Run the tests.
+`;
+
+  const issues = validateSlicePlanContent('S01-PLAN.md', content);
+  const emptyTaskIssues = issues.filter(i => i.ruleId === 'empty_task_entry');
+  assert(emptyTaskIssues.length >= 1, 'task entries with no description produce empty_task_entry issue');
+  if (emptyTaskIssues.length > 0) {
+    assertEq(emptyTaskIssues[0].severity, 'warning', 'empty_task_entry severity is warning');
+    assertEq(emptyTaskIssues[0].scope, 'slice-plan', 'empty_task_entry scope is slice-plan');
+  }
+}
+
+console.log('\n=== validateSlicePlanContent: task entries with content are fine ===');
+{
+  const content = `# S01: Some Slice
+
+**Goal:** Build the thing.
+**Demo:** It works.
+
+## Tasks
+
+- [ ] **T01: First Task** \`est:20m\`
+  - Why: Because it matters.
+  - Files: \`src/index.ts\`
+  - Do: Implement the feature.
+
+- [ ] **T02: Second Task** \`est:15m\`
+  - Why: Also important.
+  - Do: Add tests.
+
+## Verification
+
+- Run the tests.
+`;
+
+  const issues = validateSlicePlanContent('S01-PLAN.md', content);
+  const emptyTaskIssues = issues.filter(i => i.ruleId === 'empty_task_entry');
+  assertEq(emptyTaskIssues.length, 0, 'task entries with description content produce no empty_task_entry issues');
+}
+
+// ═══════════════════════════════════════════════════════════════════════════
+// validateTaskPlanContent — scope_estimate over threshold
+// ═══════════════════════════════════════════════════════════════════════════
+
+console.log('\n=== validateTaskPlanContent: scope_estimate over threshold ===');
+{
+  const content = `---
+estimated_steps: 12
+estimated_files: 15
+---
+
+# T01: Big Task
+
+## Steps
+
+1. Step one.
+2. Step two.
+3. Step three.
+
+## Verification
+
+- Check it works.
+`;
+
+  const issues = validateTaskPlanContent('T01-PLAN.md', content);
+  const stepsOverIssues = issues.filter(i => i.ruleId === 'scope_estimate_steps_high');
+  const filesOverIssues = issues.filter(i => i.ruleId === 'scope_estimate_files_high');
+  assert(stepsOverIssues.length >= 1, 'estimated_steps=12 (>=10) produces scope_estimate_steps_high issue');
+  assert(filesOverIssues.length >= 1, 'estimated_files=15 (>=12) produces scope_estimate_files_high issue');
+  if (stepsOverIssues.length > 0) {
+    assertEq(stepsOverIssues[0].severity, 'warning', 'scope_estimate_steps_high severity is warning');
+    assertEq(stepsOverIssues[0].scope, 'task-plan', 'scope_estimate_steps_high scope is task-plan');
+  }
+  if (filesOverIssues.length > 0) {
+    assertEq(filesOverIssues[0].severity, 'warning', 'scope_estimate_files_high severity is warning');
+  }
+}
+
+// ═══════════════════════════════════════════════════════════════════════════
+// validateTaskPlanContent — scope_estimate within limits
+// ═══════════════════════════════════════════════════════════════════════════
+
+console.log('\n=== validateTaskPlanContent: scope_estimate within limits ===');
+{
+  const content = `---
+estimated_steps: 4
+estimated_files: 6
+---
+
+# T01: Small Task
+
+## Steps
+
+1. Do the thing.
+
+## Verification
+
+- Verify it works.
+`;
+
+  const issues = validateTaskPlanContent('T01-PLAN.md', content);
+  const scopeIssues = issues.filter(i =>
+    i.ruleId === 'scope_estimate_steps_high' || i.ruleId === 'scope_estimate_files_high'
+  );
+  assertEq(scopeIssues.length, 0, 'scope_estimate within limits produces no scope issues');
+}
+
+// ═══════════════════════════════════════════════════════════════════════════
+// validateTaskPlanContent — missing scope_estimate (no warning)
+// ═══════════════════════════════════════════════════════════════════════════
+
+console.log('\n=== validateTaskPlanContent: missing scope_estimate ===');
+{
+  const content = `# T01: No Frontmatter Task
+
+## Steps
+
+1. Do the thing.
+
+## Verification
+
+- Verify it works.
+`;
+
+  const issues = validateTaskPlanContent('T01-PLAN.md', content);
+  const scopeIssues = issues.filter(i =>
+    i.ruleId === 'scope_estimate_steps_high' || i.ruleId === 'scope_estimate_files_high'
+  );
+  assertEq(scopeIssues.length, 0, 'missing scope_estimate produces no scope issues');
+}
+
+console.log('\n=== validateTaskPlanContent: frontmatter without scope keys ===');
+{
+  const content = `---
+id: T01
+parent: S01
+---
+
+# T01: Task With Other Frontmatter
+
+## Steps
+
+1. Do the thing.
+
+## Verification
+
+- Verify it works.
+`;
+
+  const issues = validateTaskPlanContent('T01-PLAN.md', content);
+  const scopeIssues = issues.filter(i =>
+    i.ruleId === 'scope_estimate_steps_high' || i.ruleId === 'scope_estimate_files_high'
+  );
+  assertEq(scopeIssues.length, 0, 'frontmatter without scope keys produces no scope issues');
+}
+
+// ═══════════════════════════════════════════════════════════════════════════
+// Clean plans — no false positives
+// ═══════════════════════════════════════════════════════════════════════════
+
+console.log('\n=== Clean task plan: no plan-quality issues ===');
+{
+  const content = `---
+estimated_steps: 5
+estimated_files: 3
+---
+
+# T01: Well-Formed Task
+
+## Description
+
+A real task with real content.
+
+## Steps
+
+1. Read the input files.
+2. Parse the configuration.
+3. Transform the data.
+4. Write the output.
+5. Verify the results.
+
+## Must-Haves
+
+- [ ] Output file is valid JSON
+- [ ] All input records are processed
+
+## Verification
+
+- Run \`node --test tests/transform.test.ts\` — all assertions pass
+- Manually inspect output.json for correct structure
+
+## Observability Impact
+
+- Signals added/changed: structured error log on parse failure
+- How a future agent inspects this: check stderr for JSON parse errors
+- Failure state exposed: exit code 1 + error message on invalid input
+`;
+
+  const issues = validateTaskPlanContent('T01-PLAN.md', content);
+  const planQualityIssues = issues.filter(i =>
+    i.ruleId === 'empty_steps_section' ||
+    i.ruleId === 'placeholder_verification' ||
+    i.ruleId === 'scope_estimate_steps_high' ||
+    i.ruleId === 'scope_estimate_files_high'
+  );
+  assertEq(planQualityIssues.length, 0, 'clean task plan produces no plan-quality issues');
+}
+
+console.log('\n=== Clean slice plan: no plan-quality issues ===');
+{
+  const content = `# S01: Well-Formed Slice
+
+**Goal:** Build a complete feature.
+**Demo:** Run the test suite and see all green.
+
+## Tasks
+
+- [ ] **T01: Create tests** \`est:20m\`
+  - Why: Tests define the contract before implementation.
+  - Files: \`tests/feature.test.ts\`
+  - Do: Write comprehensive test assertions.
+  - Verify: Test file runs without syntax errors.
+
+- [ ] **T02: Implement feature** \`est:30m\`
+  - Why: Core implementation.
+  - Files: \`src/feature.ts\`
+  - Do: Build the feature to make tests pass.
+  - Verify: All tests pass.
+
+## Verification
+
+- \`node --test tests/feature.test.ts\` — all assertions pass
+- Check error output for diagnostic messages
+
+## Observability / Diagnostics
+
+- Runtime signals: structured error objects with error codes
+- Inspection surfaces: test output shows pass/fail counts
+- Failure visibility: exit code 1 on failure with descriptive message
+- Redaction constraints: none
+`;
+
+  const issues = validateSlicePlanContent('S01-PLAN.md', content);
+  const planQualityIssues = issues.filter(i => i.ruleId === 'empty_task_entry');
+  assertEq(planQualityIssues.length, 0, 'clean slice plan produces no empty_task_entry issues');
+}
+
+// ═══════════════════════════════════════════════════════════════════════════
+// Results
+// ═══════════════════════════════════════════════════════════════════════════
+
+console.log(`\nResults: ${passed} passed, ${failed} failed`);
+if (failed > 0) process.exit(1);
+console.log('All tests passed ✓');