@mainahq/core 0.2.0

package/src/review/__tests__/review.test.ts

@@ -0,0 +1,288 @@
+import { describe, expect, test } from "bun:test";
+import {
+	reviewCodeQuality,
+	reviewSpecCompliance,
+	runTwoStageReview,
+} from "../index";
+
+// ── reviewSpecCompliance ────────────────────────────────────────────────────
+
+describe("reviewSpecCompliance", () => {
+	test("no plan → passed", () => {
+		const result = reviewSpecCompliance("+ some code change", null);
+
+		expect(result.stage).toBe("spec-compliance");
+		expect(result.passed).toBe(true);
+		expect(result.findings).toHaveLength(0);
+	});
+
+	test("plan with tasks, diff covers all → passed", () => {
+		const plan = `## Tasks
+- [ ] Add user authentication to auth.ts
+- [ ] Update database schema in db/schema.ts`;
+
+		const diff = `diff --git a/src/auth.ts b/src/auth.ts
+--- a/src/auth.ts
++++ b/src/auth.ts
+@@ -1,3 +1,5 @@
++export function authenticate() { return true; }
+diff --git a/src/db/schema.ts b/src/db/schema.ts
+--- a/src/db/schema.ts
++++ b/src/db/schema.ts
+@@ -1,3 +1,5 @@
++export const usersTable = {};`;
+
+		const result = reviewSpecCompliance(diff, plan);
+
+		expect(result.stage).toBe("spec-compliance");
+		expect(result.passed).toBe(true);
+		expect(result.findings).toHaveLength(0);
+	});
+
+	test("plan with task not in diff → warning (missing implementation)", () => {
+		const plan = `## Tasks
+- [ ] Add user authentication to auth.ts
+- [ ] Update database schema in db/schema.ts`;
+
+		// Only touches auth.ts, not db/schema.ts
+		const diff = `diff --git a/src/auth.ts b/src/auth.ts
+--- a/src/auth.ts
++++ b/src/auth.ts
+@@ -1,3 +1,5 @@
++export function authenticate() { return true; }`;
+
+		const result = reviewSpecCompliance(diff, plan);
+
+		expect(result.stage).toBe("spec-compliance");
+		expect(result.passed).toBe(false);
+		expect(result.findings.length).toBeGreaterThan(0);
+
+		const missing = result.findings.find((f) =>
+			f.message.toLowerCase().includes("missing"),
+		);
+		expect(missing).toBeDefined();
+		expect(missing?.severity).toBe("warning");
+	});
+
+	test("diff changes not in plan → info (over-building)", () => {
+		const plan = `## Tasks
+- [ ] Add user authentication to auth.ts`;
+
+		// Touches auth.ts (in plan) AND unrelated.ts (not in plan)
+		const diff = `diff --git a/src/auth.ts b/src/auth.ts
+--- a/src/auth.ts
++++ b/src/auth.ts
+@@ -1,3 +1,5 @@
++export function authenticate() { return true; }
+diff --git a/src/unrelated.ts b/src/unrelated.ts
+--- a/src/unrelated.ts
++++ b/src/unrelated.ts
+@@ -1,3 +1,5 @@
++export function unrelated() {}`;
+
+		const result = reviewSpecCompliance(diff, plan);
+
+		const overBuilding = result.findings.find((f) =>
+			f.message.toLowerCase().includes("over-building"),
+		);
+		expect(overBuilding).toBeDefined();
+		expect(overBuilding?.severity).toBe("info");
+	});
+});
+
+// ── reviewCodeQuality ───────────────────────────────────────────────────────
+
+describe("reviewCodeQuality", () => {
+	test("clean diff → passed", () => {
+		const diff = `diff --git a/src/index.ts b/src/index.ts
+--- a/src/index.ts
++++ b/src/index.ts
+@@ -1,3 +1,5 @@
++export function greet(name: string): string {
++  return name;
++}`;
+
+		const result = reviewCodeQuality(diff, null);
+
+		expect(result.stage).toBe("code-quality");
+		expect(result.passed).toBe(true);
+		expect(result.findings).toHaveLength(0);
+	});
+
+	test("diff with console.log → finding", () => {
+		const diff = `diff --git a/src/index.ts b/src/index.ts
+--- a/src/index.ts
++++ b/src/index.ts
+@@ -1,3 +1,5 @@
++export function greet(name: string): string {
++  console.log("hello");
++  return name;
++}`;
+
+		const result = reviewCodeQuality(diff, null);
+
+		expect(result.passed).toBe(false);
+		const consoleFinding = result.findings.find((f) =>
+			f.message.toLowerCase().includes("console.log"),
+		);
+		expect(consoleFinding).toBeDefined();
+		expect(consoleFinding?.severity).toBe("warning");
+	});
+
+	test("diff with TODO no ticket → finding", () => {
+		const diff = `diff --git a/src/index.ts b/src/index.ts
+--- a/src/index.ts
++++ b/src/index.ts
+@@ -1,3 +1,5 @@
++// TODO fix this later
++export function greet() { return "hi"; }`;
+
+		const result = reviewCodeQuality(diff, null);
+
+		expect(result.passed).toBe(false);
+		const todoFinding = result.findings.find((f) =>
+			f.message.toLowerCase().includes("todo"),
+		);
+		expect(todoFinding).toBeDefined();
+		expect(todoFinding?.severity).toBe("warning");
+	});
+
+	test("diff with empty function body → finding", () => {
+		const diff = `diff --git a/src/index.ts b/src/index.ts
+--- a/src/index.ts
++++ b/src/index.ts
+@@ -1,3 +1,5 @@
++export function greet() {}`;
+
+		const result = reviewCodeQuality(diff, null);
+
+		expect(result.passed).toBe(false);
+		const emptyFinding = result.findings.find((f) =>
+			f.message.toLowerCase().includes("empty"),
+		);
+		expect(emptyFinding).toBeDefined();
+		expect(emptyFinding?.severity).toBe("warning");
+	});
+
+	test("diff with very long line → finding", () => {
+		const longLine = `+export const x = "${"a".repeat(130)}";`;
+		const diff = `diff --git a/src/index.ts b/src/index.ts
+--- a/src/index.ts
++++ b/src/index.ts
+@@ -1,3 +1,5 @@
+${longLine}`;
+
+		const result = reviewCodeQuality(diff, null);
+
+		const longFinding = result.findings.find((f) =>
+			f.message.toLowerCase().includes("long"),
+		);
+		expect(longFinding).toBeDefined();
+		expect(longFinding?.severity).toBe("info");
+	});
+
+	test("TODO with ticket reference is allowed", () => {
+		const diff = `diff --git a/src/index.ts b/src/index.ts
+--- a/src/index.ts
++++ b/src/index.ts
+@@ -1,3 +1,5 @@
++// TODO(#123) fix this later
++export function greet() { return "hi"; }`;
+
+		const result = reviewCodeQuality(diff, null);
+
+		const todoFinding = result.findings.find((f) =>
+			f.message.toLowerCase().includes("todo"),
+		);
+		expect(todoFinding).toBeUndefined();
+	});
+});
+
+// ── runTwoStageReview ───────────────────────────────────────────────────────
+
+describe("runTwoStageReview", () => {
+	test("both pass → passed", async () => {
+		const diff = `diff --git a/src/auth.ts b/src/auth.ts
+--- a/src/auth.ts
++++ b/src/auth.ts
+@@ -1,3 +1,5 @@
++export function authenticate() { return true; }`;
+
+		const plan = `## Tasks
+- [ ] Add user authentication to auth.ts`;
+
+		const result = await runTwoStageReview({
+			diff,
+			planContent: plan,
+		});
+
+		expect(result.passed).toBe(true);
+		expect(result.stage1.passed).toBe(true);
+		expect(result.stage2).not.toBeNull();
+		expect(result.stage2?.passed).toBe(true);
+	});
+
+	test("stage 1 fails → stage 2 is null", async () => {
+		const plan = `## Tasks
+- [ ] Add user authentication to auth.ts
+- [ ] Update database schema in db/schema.ts`;
+
+		// Only touches unrelated file
+		const diff = `diff --git a/src/unrelated.ts b/src/unrelated.ts
+--- a/src/unrelated.ts
++++ b/src/unrelated.ts
+@@ -1,3 +1,5 @@
++export function unrelated() { return true; }`;
+
+		const result = await runTwoStageReview({
+			diff,
+			planContent: plan,
+		});
+
+		expect(result.passed).toBe(false);
+		expect(result.stage1.passed).toBe(false);
+		expect(result.stage2).toBeNull();
+	});
+
+	test("stage 1 passes but stage 2 fails → passed is false", async () => {
+		const diff = `diff --git a/src/auth.ts b/src/auth.ts
+--- a/src/auth.ts
++++ b/src/auth.ts
+@@ -1,3 +1,5 @@
++export function authenticate() {
++  console.log("authenticating");
++  return true;
++}`;
+
+		const plan = `## Tasks
+- [ ] Add user authentication to auth.ts`;
+
+		const result = await runTwoStageReview({
+			diff,
+			planContent: plan,
+		});
+
+		expect(result.passed).toBe(false);
+		expect(result.stage1.passed).toBe(true);
+		expect(result.stage2).not.toBeNull();
+		expect(result.stage2?.passed).toBe(false);
+	});
+
+	test("no plan → stage 1 passes automatically", async () => {
+		const diff = `diff --git a/src/index.ts b/src/index.ts
+--- a/src/index.ts
++++ b/src/index.ts
+@@ -1,3 +1,5 @@
++export function greet(name: string): string {
++  return name;
++}`;
+
+		const result = await runTwoStageReview({
+			diff,
+			planContent: null,
+		});
+
+		expect(result.stage1.passed).toBe(true);
+		expect(result.stage2).not.toBeNull();
+	});
+});

package/src/review/comprehensive.ts

@@ -0,0 +1,362 @@
+import { relative } from "node:path";
+import type { Finding } from "../verify/diff-filter";
+
+// ── Types ────────────────────────────────────────────────────────────────────
+
+export type ReviewSeverity = "critical" | "important" | "minor";
+
+export interface ComprehensiveReviewFinding {
+	severity: ReviewSeverity;
+	category:
+		| "quality"
+		| "architecture"
+		| "testing"
+		| "requirements"
+		| "security";
+	file?: string;
+	line?: number;
+	issue: string;
+	why: string;
+	fix?: string;
+}
+
+export interface ComprehensiveReviewResult {
+	strengths: string[];
+	findings: ComprehensiveReviewFinding[];
+	planAlignment: {
+		tasksInPlan: number;
+		tasksWithChanges: number;
+		overBuilding: string[];
+		missingImpl: string[];
+	};
+	architecture: {
+		separationOfConcerns: boolean;
+		errorHandling: boolean;
+		typeSafety: boolean;
+		notes: string[];
+	};
+	testing: {
+		testFiles: number;
+		implFiles: number;
+		ratio: string;
+		gaps: string[];
+	};
+	verdict: "ready" | "with-fixes" | "not-ready";
+	verdictReason: string;
+}
+
+export interface ComprehensiveReviewOptions {
+	diff: string;
+	files: string[];
+	repoRoot: string;
+	planContent?: string | null;
+	pipelineFindings?: Finding[];
+}
+
+// ── Helpers ──────────────────────────────────────────────────────────────────
+
+function extractAddedLines(
+	diff: string,
+): Array<{ file: string; line: number; content: string }> {
+	const lines: Array<{ file: string; line: number; content: string }> = [];
+	let currentFile = "";
+	let lineNum = 0;
+
+	for (const raw of diff.split("\n")) {
+		if (raw.startsWith("+++ b/")) {
+			currentFile = raw.slice(6);
+			continue;
+		}
+		if (raw.startsWith("@@ ")) {
+			const match = /@@ -\d+(?:,\d+)? \+(\d+)/.exec(raw);
+			lineNum = match ? Number.parseInt(match[1] ?? "0", 10) - 1 : 0;
+			continue;
+		}
+		if (raw.startsWith("+") && !raw.startsWith("+++")) {
+			lineNum++;
+			lines.push({ file: currentFile, line: lineNum, content: raw.slice(1) });
+		} else if (!raw.startsWith("-")) {
+			lineNum++;
+		}
+	}
+	return lines;
+}
+
+function extractTasksFromPlan(
+	planContent: string,
+): Array<{ id: string; description: string }> {
+	const tasks: Array<{ id: string; description: string }> = [];
+	const taskPattern = /- \[[ x]\]\s*(T\d+)[:\s]+(.*)/gi;
+	let match: RegExpExecArray | null;
+	match = taskPattern.exec(planContent);
+	while (match !== null) {
+		tasks.push({ id: match[1] ?? "", description: match[2] ?? "" });
+		match = taskPattern.exec(planContent);
+	}
+	return tasks;
+}
+
+// ── Main Review ──────────────────────────────────────────────────────────────
+
+export function comprehensiveReview(
+	options: ComprehensiveReviewOptions,
+): ComprehensiveReviewResult {
+	const { diff, files, repoRoot, planContent, pipelineFindings } = options;
+	const addedLines = extractAddedLines(diff);
+
+	const strengths: string[] = [];
+	const findings: ComprehensiveReviewFinding[] = [];
+
+	// ── Quality checks ──────────────────────────────────────────────────
+
+	// Check for Result<T,E> pattern usage (strength if present)
+	const usesResult = addedLines.some(
+		(l) => l.content.includes("Result<") || l.content.includes(": Result"),
+	);
+	if (usesResult) {
+		strengths.push("Uses Result<T,E> error handling pattern (no throwing)");
+	}
+
+	// Check for console.log in production code
+	for (const line of addedLines) {
+		if (
+			/console\.(log|warn|error|debug|info)\s*\(/.test(line.content) &&
+			!line.file.includes(".test.") &&
+			!line.file.includes("__tests__")
+		) {
+			findings.push({
+				severity: "important",
+				category: "quality",
+				file: line.file,
+				line: line.line,
+				issue: `console.${/console\.(\w+)/.exec(line.content)?.[1]} in production code`,
+				why: "Constitution forbids console.log in production. Breaks structured logging.",
+				fix: "Remove or replace with proper logging/Result error handling",
+			});
+		}
+	}
+
+	// Check for bare TODO missing ticket reference
+	for (const line of addedLines) {
+		if (
+			/\/\/\s*(?:TO)(?:DO)(?!\s*[(#[])/.test(line.content) &&
+			!line.file.includes(".test.")
+		) {
+			findings.push({
+				severity: "minor",
+				category: "quality",
+				file: line.file,
+				line: line.line,
+				issue: "TODO without ticket reference",
+				why: "Untracked TODOs get forgotten. Link to a ticket for accountability.",
+				fix: "Add ticket reference: // TODO(#123): description",
+			});
+		}
+	}
+
+	// Check for `any` type usage
+	for (const line of addedLines) {
+		if (/:\s*any\b|as\s+any\b/.test(line.content)) {
+			findings.push({
+				severity: "important",
+				category: "quality",
+				file: line.file,
+				line: line.line,
+				issue: "Usage of `any` type",
+				why: "TypeScript strict mode is required. `any` bypasses all type checking.",
+				fix: "Replace with proper type or `unknown`",
+			});
+		}
+	}
+
+	// Check for empty catch blocks
+	for (const line of addedLines) {
+		if (/catch\s*\{?\s*$/.test(line.content.trim())) {
+			findings.push({
+				severity: "minor",
+				category: "quality",
+				file: line.file,
+				line: line.line,
+				issue: "Empty catch block",
+				why: "Swallowed errors hide bugs. At minimum, log or use Result pattern.",
+			});
+		}
+	}
+
+	// ── Pipeline findings (from maina verify) ───────────────────────────
+
+	if (pipelineFindings && pipelineFindings.length > 0) {
+		for (const f of pipelineFindings) {
+			findings.push({
+				severity: f.severity === "error" ? "critical" : "minor",
+				category: "quality",
+				file: f.file,
+				line: f.line,
+				issue: `[${f.tool}] ${f.message}`,
+				why: `Caught by ${f.tool} verification tool`,
+				fix: f.ruleId ? `Fix rule: ${f.ruleId}` : undefined,
+			});
+		}
+	}
+
+	// ── Architecture checks ─────────────────────────────────────────────
+
+	const archNotes: string[] = [];
+	let separationOk = true;
+	let errorHandlingOk = true;
+	const typeSafetyOk = true;
+
+	// Check for cross-package imports
+	for (const line of addedLines) {
+		if (
+			line.file.includes("packages/mcp/") &&
+			line.content.includes("packages/cli/")
+		) {
+			separationOk = false;
+			findings.push({
+				severity: "important",
+				category: "architecture",
+				file: line.file,
+				line: line.line,
+				issue: "MCP package imports directly from CLI package",
+				why: "Violates dependency direction. Both should depend on core, not on each other.",
+				fix: "Move shared code to packages/core/",
+			});
+		}
+	}
+
+	// Check for throw statements (should use Result)
+	const throwCount = addedLines.filter(
+		(l) => /\bthrow\s/.test(l.content) && !l.file.includes(".test."),
+	).length;
+	if (throwCount > 0) {
+		errorHandlingOk = false;
+		archNotes.push(
+			`${throwCount} throw statement(s) found — consider Result<T,E> pattern`,
+		);
+	}
+
+	if (separationOk) {
+		strengths.push("Clean separation of concerns across packages");
+	}
+	if (errorHandlingOk) {
+		strengths.push("Consistent error handling (no throws in production)");
+	}
+
+	// ── Testing assessment ──────────────────────────────────────────────
+
+	const testFiles = files.filter(
+		(f) => f.includes(".test.") || f.includes("__tests__"),
+	);
+	const implFiles = files.filter(
+		(f) =>
+			!f.includes(".test.") &&
+			!f.includes("__tests__") &&
+			(f.endsWith(".ts") || f.endsWith(".tsx")),
+	);
+	const testGaps: string[] = [];
+
+	// Check if impl files have corresponding test files
+	for (const impl of implFiles) {
+		const baseName = impl.replace(/\.tsx?$/, "");
+		const hasTest = testFiles.some(
+			(t) =>
+				t.includes(baseName.split("/").pop() ?? "") || t.includes("__tests__"),
+		);
+		if (!hasTest) {
+			testGaps.push(relative(repoRoot, impl));
+		}
+	}
+
+	if (testFiles.length > 0) {
+		strengths.push(`${testFiles.length} test file(s) with TDD approach`);
+	}
+
+	// ── Plan alignment ──────────────────────────────────────────────────
+
+	let tasksInPlan = 0;
+	let tasksWithChanges = 0;
+	const overBuilding: string[] = [];
+	const missingImpl: string[] = [];
+
+	if (planContent) {
+		const tasks = extractTasksFromPlan(planContent);
+		tasksInPlan = tasks.length;
+
+		const changedFileNames = files.map(
+			(f) =>
+				f
+					.split("/")
+					.pop()
+					?.replace(/\.tsx?$/, "")
+					.toLowerCase() ?? "",
+		);
+
+		for (const task of tasks) {
+			const keywords = task.description.toLowerCase().split(/\s+/);
+			const hasChange = keywords.some(
+				(kw) => kw.length > 3 && changedFileNames.some((f) => f.includes(kw)),
+			);
+			if (hasChange) {
+				tasksWithChanges++;
+			} else {
+				missingImpl.push(`${task.id}: ${task.description}`);
+			}
+		}
+
+		if (tasksInPlan > 0 && tasksWithChanges === tasksInPlan) {
+			strengths.push("All plan tasks have corresponding code changes");
+		}
+	}
+
+	// ── Verdict ──────────────────────────────────────────────────────────
+
+	const criticalCount = findings.filter(
+		(f) => f.severity === "critical",
+	).length;
+	const importantCount = findings.filter(
+		(f) => f.severity === "important",
+	).length;
+
+	let verdict: "ready" | "with-fixes" | "not-ready";
+	let verdictReason: string;
+
+	if (criticalCount > 0) {
+		verdict = "not-ready";
+		verdictReason = `${criticalCount} critical issue(s) must be fixed before merge`;
+	} else if (importantCount > 0) {
+		verdict = "with-fixes";
+		verdictReason = `${importantCount} important issue(s) should be addressed`;
+	} else {
+		verdict = "ready";
+		verdictReason = "No critical or important issues found";
+	}
+
+	return {
+		strengths,
+		findings,
+		planAlignment: {
+			tasksInPlan,
+			tasksWithChanges,
+			overBuilding,
+			missingImpl,
+		},
+		architecture: {
+			separationOfConcerns: separationOk,
+			errorHandling: errorHandlingOk,
+			typeSafety: typeSafetyOk,
+			notes: archNotes,
+		},
+		testing: {
+			testFiles: testFiles.length,
+			implFiles: implFiles.length,
+			ratio:
+				implFiles.length > 0
+					? `${((testFiles.length / implFiles.length) * 100).toFixed(0)}%`
+					: "N/A",
+			gaps: testGaps,
+		},
+		verdict,
+		verdictReason,
+	};
+}