@mainahq/core 0.2.0

package/src/verify/__tests__/ai-review.test.ts

@@ -0,0 +1,242 @@
+import { afterAll, beforeEach, describe, expect, it, mock } from "bun:test";
+
+// Mock tryAIGenerate
+let mockAIResult: {
+	text: string | null;
+	fromAI: boolean;
+	hostDelegation: boolean;
+} = {
+	text: null,
+	fromAI: false,
+	hostDelegation: false,
+};
+
+mock.module("../../ai/try-generate", () => ({
+	tryAIGenerate: async () => mockAIResult,
+}));
+
+mock.module("../../cache/keys", () => ({
+	hashContent: (s: string) => `hash-${s.length}`,
+	buildCacheKey: async () => "test-cache-key",
+}));
+
+mock.module("../../cache/manager", () => ({
+	createCacheManager: () => ({
+		get: () => null,
+		set: () => {},
+		stats: () => ({ l1Hits: 0, l2Hits: 0, misses: 0 }),
+	}),
+}));
+
+afterAll(() => mock.restore());
+
+import { resolveReferencedFunctions } from "../ai-review";
+
+describe("resolveReferencedFunctions", () => {
+	it("should extract function calls from added lines in diff", () => {
+		const diff = `--- a/src/app.ts
++++ b/src/app.ts
+@@ -10,3 +10,5 @@ function existing() {
++  const result = validateInput(data);
++  processResult(result);
+   return true;`;
+
+		const entities = [
+			{
+				name: "validateInput",
+				kind: "function" as const,
+				startLine: 1,
+				endLine: 5,
+				filePath: "src/utils.ts",
+				body: "function validateInput(data: unknown) {\n  if (!data) return null;\n  return data;\n}",
+			},
+			{
+				name: "processResult",
+				kind: "function" as const,
+				startLine: 10,
+				endLine: 15,
+				filePath: "src/utils.ts",
+				body: "function processResult(result: unknown) {\n  console.log(result);\n}",
+			},
+			{
+				name: "unusedFunction",
+				kind: "function" as const,
+				startLine: 20,
+				endLine: 25,
+				filePath: "src/other.ts",
+				body: "function unusedFunction() { return 1; }",
+			},
+		];
+
+		const result = resolveReferencedFunctions(diff, entities);
+
+		expect(result).toHaveLength(2);
+		expect(result[0]?.name).toBe("validateInput");
+		expect(result[1]?.name).toBe("processResult");
+	});
+
+	it("should cap at 3 referenced functions per file", () => {
+		const diff = `--- a/src/app.ts
++++ b/src/app.ts
+@@ -1,3 +1,7 @@
++  fn1();
++  fn2();
++  fn3();
++  fn4();`;
+
+		const entities = [
+			{
+				name: "fn1",
+				kind: "function" as const,
+				startLine: 1,
+				endLine: 3,
+				filePath: "src/a.ts",
+				body: "function fn1() {}",
+			},
+			{
+				name: "fn2",
+				kind: "function" as const,
+				startLine: 1,
+				endLine: 3,
+				filePath: "src/b.ts",
+				body: "function fn2() {}",
+			},
+			{
+				name: "fn3",
+				kind: "function" as const,
+				startLine: 1,
+				endLine: 3,
+				filePath: "src/c.ts",
+				body: "function fn3() {}",
+			},
+			{
+				name: "fn4",
+				kind: "function" as const,
+				startLine: 1,
+				endLine: 3,
+				filePath: "src/d.ts",
+				body: "function fn4() {}",
+			},
+		];
+
+		const result = resolveReferencedFunctions(diff, entities);
+		expect(result).toHaveLength(3);
+	});
+
+	it("should return empty array when no functions match", () => {
+		const diff = `+++ b/src/app.ts
+@@ -1,1 +1,2 @@
++  const x = 42;`;
+
+		const result = resolveReferencedFunctions(diff, []);
+		expect(result).toHaveLength(0);
+	});
+});
+
+// Import AFTER mocking
+const { runAIReview } = await import("../ai-review");
+
+describe("runAIReview", () => {
+	const baseOptions = {
+		diff: "+  const x = validateInput(data);",
+		entities: [],
+		mainaDir: ".maina",
+	};
+
+	beforeEach(() => {
+		mockAIResult = { text: null, fromAI: false, hostDelegation: false };
+	});
+
+	it("should return findings from AI response (mechanical tier)", async () => {
+		mockAIResult = {
+			text: JSON.stringify({
+				findings: [
+					{
+						file: "src/app.ts",
+						line: 10,
+						message: "validateInput may return null but caller doesn't check",
+						severity: "warning",
+						ruleId: "ai-review/edge-case",
+					},
+				],
+			}),
+			fromAI: true,
+			hostDelegation: false,
+		};
+
+		const result = await runAIReview(baseOptions);
+
+		expect(result.findings).toHaveLength(1);
+		expect(result.findings[0]?.tool).toBe("ai-review");
+		expect(result.findings[0]?.severity).toBe("warning");
+		expect(result.tier).toBe("mechanical");
+		expect(result.skipped).toBe(false);
+	});
+
+	it("should cap severity to warning in mechanical mode", async () => {
+		mockAIResult = {
+			text: JSON.stringify({
+				findings: [
+					{
+						file: "src/app.ts",
+						line: 5,
+						message: "bad",
+						severity: "error",
+						ruleId: "ai-review/contract",
+					},
+				],
+			}),
+			fromAI: true,
+			hostDelegation: false,
+		};
+
+		const result = await runAIReview(baseOptions);
+		expect(result.findings[0]?.severity).toBe("warning");
+	});
+
+	it("should allow error severity in deep mode", async () => {
+		mockAIResult = {
+			text: JSON.stringify({
+				findings: [
+					{
+						file: "src/app.ts",
+						line: 5,
+						message: "spec violation",
+						severity: "error",
+						ruleId: "ai-review/spec-compliance",
+					},
+				],
+			}),
+			fromAI: true,
+			hostDelegation: false,
+		};
+
+		const result = await runAIReview({ ...baseOptions, deep: true });
+		expect(result.findings[0]?.severity).toBe("error");
+		expect(result.tier).toBe("standard");
+	});
+
+	it("should skip gracefully when AI is unavailable", async () => {
+		mockAIResult = { text: null, fromAI: false, hostDelegation: false };
+		const result = await runAIReview(baseOptions);
+		expect(result.findings).toHaveLength(0);
+		expect(result.skipped).toBe(true);
+	});
+
+	it("should skip gracefully on malformed AI response", async () => {
+		mockAIResult = { text: "not json", fromAI: true, hostDelegation: false };
+		const result = await runAIReview(baseOptions);
+		expect(result.findings).toHaveLength(0);
+		expect(result.skipped).toBe(true);
+	});
+
+	it("should handle host delegation by skipping", async () => {
+		mockAIResult = {
+			text: "[HOST_DELEGATION] prompt here",
+			fromAI: false,
+			hostDelegation: true,
+		};
+		const result = await runAIReview(baseOptions);
+		expect(result.skipped).toBe(true);
+	});
+});

package/src/verify/__tests__/coverage.test.ts

@@ -0,0 +1,83 @@
+import { describe, expect, it } from "bun:test";
+import { parseDiffCoverJson, runCoverage } from "../coverage";
+
+describe("diff-cover Coverage Integration", () => {
+	describe("parseDiffCoverJson", () => {
+		it("should parse diff-cover JSON into findings", () => {
+			const json = JSON.stringify({
+				report_name: "Diff Coverage",
+				diff_name: "master...HEAD",
+				src_stats: {
+					"src/app.ts": {
+						covered_lines: [10, 11, 12],
+						violation_lines: [15, 16],
+						percent_covered: 60.0,
+					},
+					"src/utils.ts": {
+						covered_lines: [1, 2, 3, 4, 5],
+						violation_lines: [],
+						percent_covered: 100.0,
+					},
+				},
+				total_num_lines: 10,
+				total_num_violations: 2,
+				total_percent_covered: 80.0,
+			});
+
+			const findings = parseDiffCoverJson(json);
+
+			// Only files with violations should produce findings
+			expect(findings).toHaveLength(2);
+			expect(findings[0]?.tool).toBe("diff-cover");
+			expect(findings[0]?.file).toBe("src/app.ts");
+			expect(findings[0]?.line).toBe(15);
+			expect(findings[0]?.severity).toBe("warning");
+			expect(findings[0]?.ruleId).toBe("diff-cover/uncovered-line");
+			expect(findings[1]?.line).toBe(16);
+		});
+
+		it("should handle empty src_stats", () => {
+			const json = JSON.stringify({ src_stats: {} });
+			expect(parseDiffCoverJson(json)).toHaveLength(0);
+		});
+
+		it("should handle malformed JSON", () => {
+			expect(parseDiffCoverJson("not json")).toHaveLength(0);
+		});
+
+		it("should handle files with no violations", () => {
+			const json = JSON.stringify({
+				src_stats: {
+					"src/clean.ts": {
+						covered_lines: [1, 2, 3],
+						violation_lines: [],
+						percent_covered: 100.0,
+					},
+				},
+			});
+			expect(parseDiffCoverJson(json)).toHaveLength(0);
+		});
+
+		it("should include coverage percentage in message", () => {
+			const json = JSON.stringify({
+				src_stats: {
+					"src/app.ts": {
+						covered_lines: [1],
+						violation_lines: [2],
+						percent_covered: 50.0,
+					},
+				},
+			});
+			const findings = parseDiffCoverJson(json);
+			expect(findings[0]?.message).toContain("50%");
+		});
+	});
+
+	describe("runCoverage", () => {
+		it("should skip when diff-cover is not available", async () => {
+			const result = await runCoverage({ available: false });
+			expect(result.skipped).toBe(true);
+			expect(result.findings).toHaveLength(0);
+		});
+	});
+});

package/src/verify/__tests__/detect.test.ts

@@ -0,0 +1,175 @@
+import { describe, expect, it, test } from "bun:test";
+import {
+	detectTool,
+	detectTools,
+	isToolAvailable,
+	TOOL_REGISTRY,
+	type ToolName,
+} from "../detect";
+
+// ─── Type checks ────────────────────────────────────────────────────────────
+
+describe("detect types", () => {
+	test("TOOL_REGISTRY has all expected tools", () => {
+		const expectedTools: ToolName[] = [
+			"biome",
+			"semgrep",
+			"trivy",
+			"secretlint",
+			"sonarqube",
+			"stryker",
+		];
+		for (const tool of expectedTools) {
+			expect(TOOL_REGISTRY[tool]).toBeDefined();
+			expect(typeof TOOL_REGISTRY[tool].command).toBe("string");
+			expect(typeof TOOL_REGISTRY[tool].versionFlag).toBe("string");
+		}
+	});
+
+	test("TOOL_REGISTRY maps sonarqube to sonar-scanner command", () => {
+		expect(TOOL_REGISTRY.sonarqube.command).toBe("sonar-scanner");
+	});
+});
+
+// ─── detectTool ─────────────────────────────────────────────────────────────
+
+describe("detectTool", () => {
+	test("returns a DetectedTool shape", async () => {
+		const result = await detectTool("biome");
+		expect(result).toHaveProperty("name");
+		expect(result).toHaveProperty("command");
+		expect(result).toHaveProperty("version");
+		expect(result).toHaveProperty("available");
+		expect(typeof result.name).toBe("string");
+		expect(typeof result.command).toBe("string");
+		expect(typeof result.available).toBe("boolean");
+	});
+
+	test("detects biome as available (installed in project)", async () => {
+		const result = await detectTool("biome");
+		expect(result.name).toBe("biome");
+		// command may be "biome" (global) or a local node_modules/.bin path
+		expect(result.command).toContain("biome");
+		expect(result.available).toBe(true);
+		expect(result.version).not.toBeNull();
+		expect(typeof result.version).toBe("string");
+	});
+
+	test("detects sonarqube status correctly", async () => {
+		const result = await detectTool("sonarqube");
+		expect(result.name).toBe("sonarqube");
+		expect(result.command).toBe("sonar-scanner");
+		// sonarqube may or may not be installed — just verify shape
+		expect(typeof result.available).toBe("boolean");
+	});
+});
+
+// ─── detectTools ────────────────────────────────────────────────────────────
+
+describe("detectTools", () => {
+	test("returns an array of DetectedTool for all registered tools", async () => {
+		const results = await detectTools();
+		expect(Array.isArray(results)).toBe(true);
+		expect(results.length).toBe(Object.keys(TOOL_REGISTRY).length);
+	});
+
+	test("each result has the correct shape", async () => {
+		const results = await detectTools();
+		for (const tool of results) {
+			expect(typeof tool.name).toBe("string");
+			expect(typeof tool.command).toBe("string");
+			expect(typeof tool.available).toBe("boolean");
+			// version is string or null
+			if (tool.available) {
+				expect(typeof tool.version).toBe("string");
+			} else {
+				expect(tool.version).toBeNull();
+			}
+		}
+	});
+
+	test("should auto-detect installed tools", async () => {
+		const results = await detectTools();
+		const biome = results.find((t) => t.name === "biome");
+		expect(biome).toBeDefined();
+		expect(biome?.available).toBe(true);
+		expect(biome?.version).not.toBeNull();
+	});
+
+	test("detects sonarqube status in detectTools", async () => {
+		const results = await detectTools();
+		const sonarqube = results.find((t) => t.name === "sonarqube");
+		expect(sonarqube).toBeDefined();
+		expect(typeof sonarqube?.available).toBe("boolean");
+	});
+
+	test("detects tools in parallel (all results returned)", async () => {
+		const results = await detectTools();
+		const names = results.map((t) => t.name);
+		expect(names).toContain("biome");
+		expect(names).toContain("semgrep");
+		expect(names).toContain("trivy");
+		expect(names).toContain("secretlint");
+		expect(names).toContain("sonarqube");
+		expect(names).toContain("stryker");
+	});
+});
+
+// ─── isToolAvailable ────────────────────────────────────────────────────────
+
+describe("isToolAvailable", () => {
+	test("returns true for biome", async () => {
+		const available = await isToolAvailable("biome");
+		expect(available).toBe(true);
+	});
+
+	test("returns boolean for sonarqube", async () => {
+		const available = await isToolAvailable("sonarqube");
+		expect(typeof available).toBe("boolean");
+	});
+});
+
+// ─── Language-specific linter tools ─────────────────────────────────────────
+
+describe("language-specific linter tools", () => {
+	it("should have ruff in tool registry", () => {
+		expect(TOOL_REGISTRY.ruff).toBeDefined();
+		expect(TOOL_REGISTRY.ruff.command).toBe("ruff");
+	});
+
+	it("should have golangci-lint in tool registry", () => {
+		expect(TOOL_REGISTRY["golangci-lint"]).toBeDefined();
+	});
+
+	it("should have cargo-clippy in tool registry", () => {
+		expect(TOOL_REGISTRY["cargo-clippy"]).toBeDefined();
+	});
+
+	it("should have cargo-audit in tool registry", () => {
+		expect(TOOL_REGISTRY["cargo-audit"]).toBeDefined();
+	});
+});
+
+// ─── VerifyPipeline (TDD contract from Sprint 3) ───────────────────────────
+
+describe("VerifyPipeline", () => {
+	it("should auto-detect installed tools", async () => {
+		const results = await detectTools();
+		const installed = results.filter((t) => t.available);
+		expect(installed.length).toBeGreaterThan(0);
+		// biome is always installed in this project
+		const biome = installed.find((t) => t.name === "biome");
+		expect(biome).toBeDefined();
+		expect(biome?.version).not.toBeNull();
+	});
+
+	it("should skip missing tools with info note", async () => {
+		const results = await detectTools();
+		const missing = results.filter((t) => !t.available);
+		expect(missing.length).toBeGreaterThan(0);
+		for (const tool of missing) {
+			expect(tool.available).toBe(false);
+			expect(tool.version).toBeNull();
+		}
+	});
+});