@mainahq/core 0.2.0

package/src/features/__tests__/checklist.test.ts

@@ -0,0 +1,454 @@
+import { afterEach, beforeEach, describe, expect, test } from "bun:test";
+import { mkdirSync, rmSync, writeFileSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import { verifyPlan } from "../checklist";
+
+function makeTmpDir(): string {
+	const dir = join(
+		tmpdir(),
+		`maina-checklist-test-${Date.now()}-${Math.random().toString(36).slice(2)}`,
+	);
+	mkdirSync(dir, { recursive: true });
+	return dir;
+}
+
+const VALID_SPEC = `# Feature: User Auth
+
+## User stories
+- As a user, I want to log in with email/password
+
+## Acceptance criteria
+- Login form validates email format
+- Failed login shows specific error message
+- Password reset sends email within 30 seconds
+
+## [NEEDS CLARIFICATION]
+- Should we support OAuth?
+`;
+
+const VALID_PLAN = `# Implementation Plan
+
+## Architecture
+- JWT with RS256 signing
+
+## Tasks
+- T001: Write tests for email validation and login form
+- T002: Implement login endpoint with email format validation
+- T003: Implement error messages for failed login attempts
+- T004: Write tests for password reset flow
+- T005: Implement password reset with email sending within 30 seconds
+`;
+
+describe("verifyPlan", () => {
+	let tmpDir: string;
+
+	beforeEach(() => {
+		tmpDir = makeTmpDir();
+	});
+
+	afterEach(() => {
+		rmSync(tmpDir, { recursive: true, force: true });
+	});
+
+	// --- Missing spec file ---
+	test("missing spec file returns error Result", () => {
+		const planPath = join(tmpDir, "plan.md");
+		const specPath = join(tmpDir, "spec.md");
+		writeFileSync(planPath, VALID_PLAN);
+
+		const result = verifyPlan(planPath, specPath);
+		expect(result.ok).toBe(false);
+		if (!result.ok) {
+			expect(result.error).toContain("spec");
+		}
+	});
+
+	// --- Missing plan file ---
+	test("missing plan file returns error Result", () => {
+		const planPath = join(tmpDir, "plan.md");
+		const specPath = join(tmpDir, "spec.md");
+		writeFileSync(specPath, VALID_SPEC);
+
+		const result = verifyPlan(planPath, specPath);
+		expect(result.ok).toBe(false);
+		if (!result.ok) {
+			expect(result.error).toContain("plan");
+		}
+	});
+
+	// --- Spec criterion coverage ---
+	test("plan missing a spec criterion fails with specific message", () => {
+		const specPath = join(tmpDir, "spec.md");
+		const planPath = join(tmpDir, "plan.md");
+
+		writeFileSync(specPath, VALID_SPEC);
+		// Plan only covers email validation — missing "error message" and "password reset"
+		writeFileSync(
+			planPath,
+			`# Implementation Plan
+
+## Architecture
+- Simple approach
+
+## Tasks
+- T001: Implement email format validation for login form
+`,
+		);
+
+		const result = verifyPlan(planPath, specPath);
+		expect(result.ok).toBe(true);
+		if (!result.ok) return;
+
+		const coverage = result.value.checks.find(
+			(c) => c.name === "spec-coverage",
+		);
+		expect(coverage).toBeDefined();
+		expect(coverage?.passed).toBe(false);
+		// Should mention the missing criteria
+		expect(
+			coverage?.details.some((d) => d.toLowerCase().includes("error message")),
+		).toBe(true);
+		expect(
+			coverage?.details.some((d) => d.toLowerCase().includes("password reset")),
+		).toBe(true);
+	});
+
+	test("plan covering all spec criteria passes", () => {
+		const specPath = join(tmpDir, "spec.md");
+		const planPath = join(tmpDir, "plan.md");
+		writeFileSync(specPath, VALID_SPEC);
+		writeFileSync(planPath, VALID_PLAN);
+
+		const result = verifyPlan(planPath, specPath);
+		expect(result.ok).toBe(true);
+		if (!result.ok) return;
+
+		const coverage = result.value.checks.find(
+			(c) => c.name === "spec-coverage",
+		);
+		expect(coverage).toBeDefined();
+		expect(coverage?.passed).toBe(true);
+		expect(coverage?.details).toHaveLength(0);
+	});
+
+	// --- No TODO/TBD/PLACEHOLDER markers ---
+	test("plan with TODO marker fails and reports the line", () => {
+		const specPath = join(tmpDir, "spec.md");
+		const planPath = join(tmpDir, "plan.md");
+		writeFileSync(specPath, VALID_SPEC);
+		writeFileSync(
+			planPath,
+			`# Implementation Plan
+
+## Architecture
+- JWT with RS256 signing
+
+## Tasks
+- T001: Write tests for email validation and login form
+- T002: Implement login endpoint with email format validation
+- T003: TODO: Implement error messages for failed login attempts
+- T004: Write tests for password reset flow
+- T005: Implement password reset with email sending within 30 seconds
+`,
+		);
+
+		const result = verifyPlan(planPath, specPath);
+		expect(result.ok).toBe(true);
+		if (!result.ok) return;
+
+		const placeholders = result.value.checks.find(
+			(c) => c.name === "no-placeholders",
+		);
+		expect(placeholders).toBeDefined();
+		expect(placeholders?.passed).toBe(false);
+		expect(placeholders?.details.some((d) => d.includes("TODO"))).toBe(true);
+		// Should report the line number
+		expect(placeholders?.details.some((d) => /line \d+/i.test(d))).toBe(true);
+	});
+
+	test("plan with TBD marker fails", () => {
+		const specPath = join(tmpDir, "spec.md");
+		const planPath = join(tmpDir, "plan.md");
+		writeFileSync(specPath, VALID_SPEC);
+		writeFileSync(
+			planPath,
+			`# Implementation Plan
+
+## Architecture
+- TBD architecture decisions
+
+## Tasks
+- T001: Write tests for email validation and login form
+- T002: Implement login endpoint with email format validation
+- T003: Implement error messages for failed login attempts
+- T004: Write tests for password reset flow
+- T005: Implement password reset with email sending within 30 seconds
+`,
+		);
+
+		const result = verifyPlan(planPath, specPath);
+		expect(result.ok).toBe(true);
+		if (!result.ok) return;
+
+		const placeholders = result.value.checks.find(
+			(c) => c.name === "no-placeholders",
+		);
+		expect(placeholders).toBeDefined();
+		expect(placeholders?.passed).toBe(false);
+		expect(placeholders?.details.some((d) => d.includes("TBD"))).toBe(true);
+	});
+
+	test("plan with PLACEHOLDER marker fails", () => {
+		const specPath = join(tmpDir, "spec.md");
+		const planPath = join(tmpDir, "plan.md");
+		writeFileSync(specPath, VALID_SPEC);
+		writeFileSync(
+			planPath,
+			`# Implementation Plan
+
+## Architecture
+- JWT with RS256 signing
+
+## Tasks
+- T001: Write tests for email validation and login form
+- T002: Implement login endpoint with email format validation
+- T003: Implement error messages for failed login attempts
+- T004: Write tests for password reset flow
+- T005: Implement password reset with email sending within 30 seconds
+- T006: PLACEHOLDER for future work
+`,
+		);
+
+		const result = verifyPlan(planPath, specPath);
+		expect(result.ok).toBe(true);
+		if (!result.ok) return;
+
+		const placeholders = result.value.checks.find(
+			(c) => c.name === "no-placeholders",
+		);
+		expect(placeholders).toBeDefined();
+		expect(placeholders?.passed).toBe(false);
+		expect(placeholders?.details.some((d) => d.includes("PLACEHOLDER"))).toBe(
+			true,
+		);
+	});
+
+	test("plan with FIXME marker fails", () => {
+		const specPath = join(tmpDir, "spec.md");
+		const planPath = join(tmpDir, "plan.md");
+		writeFileSync(specPath, VALID_SPEC);
+		writeFileSync(
+			planPath,
+			`# Implementation Plan
+
+## Architecture
+- JWT with RS256 signing
+
+## Tasks
+- T001: Write tests for email validation and login form
+- T002: Implement login endpoint with email format validation
+- T003: Implement error messages for failed login attempts FIXME
+- T004: Write tests for password reset flow
+- T005: Implement password reset with email sending within 30 seconds
+`,
+		);
+
+		const result = verifyPlan(planPath, specPath);
+		expect(result.ok).toBe(true);
+		if (!result.ok) return;
+
+		const placeholders = result.value.checks.find(
+			(c) => c.name === "no-placeholders",
+		);
+		expect(placeholders).toBeDefined();
+		expect(placeholders?.passed).toBe(false);
+		expect(placeholders?.details.some((d) => d.includes("FIXME"))).toBe(true);
+	});
+
+	test("plan with [NEEDS CLARIFICATION] passes (allowed marker)", () => {
+		const specPath = join(tmpDir, "spec.md");
+		const planPath = join(tmpDir, "plan.md");
+		writeFileSync(specPath, VALID_SPEC);
+		writeFileSync(
+			planPath,
+			`# Implementation Plan
+
+## Architecture
+- JWT with RS256 signing
+- [NEEDS CLARIFICATION] OAuth support decision pending
+
+## Tasks
+- T001: Write tests for email validation and login form
+- T002: Implement login endpoint with email format validation
+- T003: Implement error messages for failed login attempts
+- T004: Write tests for password reset flow
+- T005: Implement password reset with email sending within 30 seconds
+`,
+		);
+
+		const result = verifyPlan(planPath, specPath);
+		expect(result.ok).toBe(true);
+		if (!result.ok) return;
+
+		const placeholders = result.value.checks.find(
+			(c) => c.name === "no-placeholders",
+		);
+		expect(placeholders).toBeDefined();
+		expect(placeholders?.passed).toBe(true);
+		expect(placeholders?.details).toHaveLength(0);
+	});
+
+	// --- Function/type name consistency ---
+	test("consistent function names across tasks passes", () => {
+		const specPath = join(tmpDir, "spec.md");
+		const planPath = join(tmpDir, "plan.md");
+		writeFileSync(
+			specPath,
+			`# Feature: API
+
+## Acceptance criteria
+- User creation works
+`,
+		);
+		writeFileSync(
+			planPath,
+			`# Implementation Plan
+
+## Tasks
+- T001: Write tests for \`createUser\` function
+- T002: Implement \`createUser\` in user service
+- T003: Wire \`createUser\` to the API route
+`,
+		);
+
+		const result = verifyPlan(planPath, specPath);
+		expect(result.ok).toBe(true);
+		if (!result.ok) return;
+
+		const nameCheck = result.value.checks.find(
+			(c) => c.name === "name-consistency",
+		);
+		expect(nameCheck).toBeDefined();
+		expect(nameCheck?.passed).toBe(true);
+		expect(nameCheck?.details).toHaveLength(0);
+	});
+
+	test("identifiers used only once are tracked without issues", () => {
+		const specPath = join(tmpDir, "spec.md");
+		const planPath = join(tmpDir, "plan.md");
+		writeFileSync(
+			specPath,
+			`# Feature: API
+
+## Acceptance criteria
+- User creation works
+- User deletion works
+`,
+		);
+		writeFileSync(
+			planPath,
+			`# Implementation Plan
+
+## Tasks
+- T001: Implement \`createUser\` in user service
+- T002: Implement \`deleteUser\` in user service
+`,
+		);
+
+		const result = verifyPlan(planPath, specPath);
+		expect(result.ok).toBe(true);
+		if (!result.ok) return;
+
+		const nameCheck = result.value.checks.find(
+			(c) => c.name === "name-consistency",
+		);
+		expect(nameCheck).toBeDefined();
+		// Single-use names are fine — no inconsistency to detect
+		expect(nameCheck?.passed).toBe(true);
+	});
+
+	// --- Test-first ordering ---
+	test("test task before implementation passes", () => {
+		const specPath = join(tmpDir, "spec.md");
+		const planPath = join(tmpDir, "plan.md");
+		writeFileSync(
+			specPath,
+			`# Feature: Auth
+
+## Acceptance criteria
+- Login works
+`,
+		);
+		writeFileSync(
+			planPath,
+			`# Implementation Plan
+
+## Tasks
+- T001: Write tests for login endpoint
+- T002: Implement login endpoint
+`,
+		);
+
+		const result = verifyPlan(planPath, specPath);
+		expect(result.ok).toBe(true);
+		if (!result.ok) return;
+
+		const testFirst = result.value.checks.find((c) => c.name === "test-first");
+		expect(testFirst).toBeDefined();
+		expect(testFirst?.passed).toBe(true);
+		expect(testFirst?.details).toHaveLength(0);
+	});
+
+	test("implementation task before test task fails with warning", () => {
+		const specPath = join(tmpDir, "spec.md");
+		const planPath = join(tmpDir, "plan.md");
+		writeFileSync(
+			specPath,
+			`# Feature: Auth
+
+## Acceptance criteria
+- Login works
+`,
+		);
+		writeFileSync(
+			planPath,
+			`# Implementation Plan
+
+## Tasks
+- T001: Implement login endpoint
+- T002: Write tests for login endpoint
+`,
+		);
+
+		const result = verifyPlan(planPath, specPath);
+		expect(result.ok).toBe(true);
+		if (!result.ok) return;
+
+		const testFirst = result.value.checks.find((c) => c.name === "test-first");
+		expect(testFirst).toBeDefined();
+		expect(testFirst?.passed).toBe(false);
+		expect(testFirst?.details.length).toBeGreaterThan(0);
+		// Should mention which test task comes after implementation
+		expect(testFirst?.details.some((d) => d.includes("login"))).toBe(true);
+	});
+
+	// --- Fully valid plan ---
+	test("fully valid plan passes all checks", () => {
+		const specPath = join(tmpDir, "spec.md");
+		const planPath = join(tmpDir, "plan.md");
+		writeFileSync(specPath, VALID_SPEC);
+		writeFileSync(planPath, VALID_PLAN);
+
+		const result = verifyPlan(planPath, specPath);
+		expect(result.ok).toBe(true);
+		if (!result.ok) return;
+
+		expect(result.value.passed).toBe(true);
+		for (const check of result.value.checks) {
+			expect(check.passed).toBe(true);
+			expect(check.details).toHaveLength(0);
+		}
+		expect(result.value.checks).toHaveLength(4);
+	});
+});