@mainahq/core 0.2.0

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

@@ -0,0 +1,478 @@
+import { afterAll, beforeEach, describe, expect, it, mock } from "bun:test";
+import type { Finding } from "../diff-filter";
+
+// ─── Mock setup ──────────────────────────────────────────────────────────
+
+// Mock the AI generate function
+const mockGenerate = mock(() =>
+	Promise.resolve({
+		text: "",
+		cached: false,
+		model: "test-model",
+		tokens: { input: 100, output: 50 },
+	}),
+);
+
+// Mock the Prompt Engine
+const mockBuildSystemPrompt = mock(() =>
+	Promise.resolve({
+		prompt: "You are a fix generator. Fix the issues.",
+		hash: "prompt-hash-abc",
+	}),
+);
+
+// Mock the cache manager
+const mockCacheGet = mock(
+	() =>
+		null as {
+			key: string;
+			value: string;
+			createdAt: number;
+			ttl: number;
+		} | null,
+);
+const mockCacheSet = mock(() => {});
+const mockCacheHas = mock(() => false);
+const mockCreateCacheManager = mock(() => ({
+	get: mockCacheGet,
+	set: mockCacheSet,
+	has: mockCacheHas,
+	invalidate: mock(() => {}),
+	clear: mock(() => {}),
+	stats: mock(() => ({
+		l1Hits: 0,
+		l2Hits: 0,
+		misses: 0,
+		totalQueries: 0,
+		entriesL1: 0,
+		entriesL2: 0,
+	})),
+}));
+
+// Apply mocks before importing the module under test
+mock.module("../../ai/index", () => ({
+	generate: mockGenerate,
+}));
+
+mock.module("../../prompts/engine", () => ({
+	buildSystemPrompt: mockBuildSystemPrompt,
+}));
+
+mock.module("../../cache/manager", () => ({
+	createCacheManager: mockCreateCacheManager,
+}));
+
+afterAll(() => {
+	mock.restore();
+});
+
+// Now import the module under test
+import {
+	type FixOptions,
+	type FixResult,
+	type FixSuggestion,
+	generateFixes,
+	hashFinding,
+	parseFixResponse,
+} from "../fix";
+
+// ─── Test data ───────────────────────────────────────────────────────────
+
+const sampleFinding: Finding = {
+	tool: "biome",
+	file: "src/utils.ts",
+	line: 42,
+	column: 5,
+	message: "Use const instead of let",
+	severity: "warning",
+	ruleId: "lint/style/useConst",
+};
+
+const sampleFinding2: Finding = {
+	tool: "semgrep",
+	file: "src/api.ts",
+	line: 10,
+	message: "Potential SQL injection",
+	severity: "error",
+	ruleId: "security/sql-injection",
+};
+
+const sampleAiResponse = `### Fix for finding: biome/lint/style/useConst at src/utils.ts:42
+
+**Explanation:** The variable is never reassigned, so it should be declared with const instead of let for better immutability guarantees.
+
+**Confidence:** high
+
+\`\`\`diff
+--- a/src/utils.ts
++++ b/src/utils.ts
+@@ -42,1 +42,1 @@
+-  let result = computeValue();
++  const result = computeValue();
+\`\`\`
+`;
+
+const multiFixAiResponse = `### Fix for finding: biome/lint/style/useConst at src/utils.ts:42
+
+**Explanation:** The variable is never reassigned, so it should be declared with const instead of let.
+
+**Confidence:** high
+
+\`\`\`diff
+--- a/src/utils.ts
++++ b/src/utils.ts
+@@ -42,1 +42,1 @@
+-  let result = computeValue();
++  const result = computeValue();
+\`\`\`
+
+### Fix for finding: semgrep/security/sql-injection at src/api.ts:10
+
+**Explanation:** Use parameterized queries to prevent SQL injection attacks.
+
+**Confidence:** medium
+
+\`\`\`diff
+--- a/src/api.ts
++++ b/src/api.ts
+@@ -10,1 +10,1 @@
+-  const rows = db.query("SELECT * FROM users WHERE id = " + userId);
++  const rows = db.query("SELECT * FROM users WHERE id = ?", [userId]);
+\`\`\`
+`;
+
+// ─── hashFinding ─────────────────────────────────────────────────────────
+
+describe("hashFinding", () => {
+	it("should return a deterministic hash for the same finding", () => {
+		const hash1 = hashFinding(sampleFinding);
+		const hash2 = hashFinding(sampleFinding);
+		expect(hash1).toBe(hash2);
+	});
+
+	it("should return different hashes for different findings", () => {
+		const hash1 = hashFinding(sampleFinding);
+		const hash2 = hashFinding(sampleFinding2);
+		expect(hash1).not.toBe(hash2);
+	});
+
+	it("should return a hex string", () => {
+		const hash = hashFinding(sampleFinding);
+		expect(hash).toMatch(/^[0-9a-f]+$/);
+	});
+
+	it("should include tool, file, line, message, and ruleId in the hash input", () => {
+		// Same finding but different line → different hash
+		const altered = { ...sampleFinding, line: 99 };
+		expect(hashFinding(sampleFinding)).not.toBe(hashFinding(altered));
+
+		// Same finding but different message → different hash
+		const alteredMsg = { ...sampleFinding, message: "Different message" };
+		expect(hashFinding(sampleFinding)).not.toBe(hashFinding(alteredMsg));
+	});
+});
+
+// ─── parseFixResponse ────────────────────────────────────────────────────
+
+describe("parseFixResponse", () => {
+	it("should parse a single fix from AI response", () => {
+		const findings = [sampleFinding];
+		const suggestions = parseFixResponse(sampleAiResponse, findings);
+
+		expect(suggestions.length).toBe(1);
+		expect(suggestions[0]?.finding).toBe(sampleFinding);
+		expect(suggestions[0]?.confidence).toBe("high");
+		expect(suggestions[0]?.explanation).toContain("never reassigned");
+		expect(suggestions[0]?.diff).toContain("-  let result");
+		expect(suggestions[0]?.diff).toContain("+  const result");
+	});
+
+	it("should parse multiple fixes from AI response", () => {
+		const findings = [sampleFinding, sampleFinding2];
+		const suggestions = parseFixResponse(multiFixAiResponse, findings);
+
+		expect(suggestions.length).toBe(2);
+
+		// First fix
+		expect(suggestions[0]?.finding).toBe(sampleFinding);
+		expect(suggestions[0]?.confidence).toBe("high");
+
+		// Second fix
+		expect(suggestions[1]?.finding).toBe(sampleFinding2);
+		expect(suggestions[1]?.confidence).toBe("medium");
+		expect(suggestions[1]?.explanation).toContain("parameterized queries");
+	});
+
+	it("should default confidence to low when not parseable", () => {
+		const badResponse = `### Fix for finding: biome/lint/style/useConst at src/utils.ts:42
+
+**Explanation:** Just fix it.
+
+\`\`\`diff
+--- a/src/utils.ts
++++ b/src/utils.ts
+@@ -42,1 +42,1 @@
+-  let result = computeValue();
++  const result = computeValue();
+\`\`\`
+`;
+		const findings = [sampleFinding];
+		const suggestions = parseFixResponse(badResponse, findings);
+
+		expect(suggestions.length).toBe(1);
+		expect(suggestions[0]?.confidence).toBe("low");
+	});
+
+	it("should return empty array for empty response", () => {
+		const suggestions = parseFixResponse("", [sampleFinding]);
+		expect(suggestions.length).toBe(0);
+	});
+
+	it("should return empty array for unparseable response", () => {
+		const suggestions = parseFixResponse("I cannot fix this issue.", [
+			sampleFinding,
+		]);
+		expect(suggestions.length).toBe(0);
+	});
+});
+
+// ─── generateFixes ───────────────────────────────────────────────────────
+
+describe("generateFixes", () => {
+	const defaultOptions: FixOptions = {
+		mainaDir: ".maina",
+		cwd: "/project",
+		contextText: "const computeValue = () => 42;",
+	};
+
+	beforeEach(() => {
+		mockGenerate.mockClear();
+		mockBuildSystemPrompt.mockClear();
+		mockCacheGet.mockClear();
+		mockCacheSet.mockClear();
+		mockCacheHas.mockClear();
+		mockCreateCacheManager.mockClear();
+
+		// Reset default implementations
+		mockCacheGet.mockImplementation(() => null);
+		mockGenerate.mockImplementation(() =>
+			Promise.resolve({
+				text: sampleAiResponse,
+				cached: false,
+				model: "test-model",
+				tokens: { input: 100, output: 50 },
+			}),
+		);
+	});
+
+	it("should return empty suggestions for empty findings", async () => {
+		const result = await generateFixes([], defaultOptions);
+
+		expect(result.suggestions.length).toBe(0);
+		expect(result.cached).toBe(false);
+		expect(mockGenerate).not.toHaveBeenCalled();
+	});
+
+	it("should call buildSystemPrompt with 'fix' task", async () => {
+		await generateFixes([sampleFinding], defaultOptions);
+
+		expect(mockBuildSystemPrompt).toHaveBeenCalledWith(
+			"fix",
+			".maina",
+			expect.objectContaining({
+				findings: expect.any(String),
+				source: expect.any(String),
+			}),
+		);
+	});
+
+	it("should call generate with assembled prompt", async () => {
+		await generateFixes([sampleFinding], defaultOptions);
+
+		expect(mockGenerate).toHaveBeenCalledTimes(1);
+		expect(mockGenerate).toHaveBeenCalledWith(
+			expect.objectContaining({
+				task: "fix",
+				systemPrompt: expect.any(String),
+				userPrompt: expect.any(String),
+				mainaDir: ".maina",
+			}),
+		);
+	});
+
+	it("should return parsed suggestions from AI response", async () => {
+		const result = await generateFixes([sampleFinding], defaultOptions);
+
+		expect(result.suggestions.length).toBe(1);
+		expect(result.suggestions[0]?.finding).toBe(sampleFinding);
+		expect(result.suggestions[0]?.confidence).toBe("high");
+		expect(result.cached).toBe(false);
+		expect(result.model).toBe("test-model");
+	});
+
+	it("should check cache before calling AI", async () => {
+		// Simulate cache hit
+		const cachedResult: FixResult = {
+			suggestions: [
+				{
+					finding: sampleFinding,
+					diff: "cached diff",
+					explanation: "cached explanation",
+					confidence: "high",
+				},
+			],
+			cached: true,
+			model: "cached-model",
+		};
+
+		mockCacheGet.mockImplementation(() => ({
+			key: "test-key",
+			value: JSON.stringify(cachedResult),
+			createdAt: Date.now(),
+			ttl: 0,
+		}));
+
+		const result = await generateFixes([sampleFinding], defaultOptions);
+
+		expect(result.cached).toBe(true);
+		expect(result.suggestions.length).toBe(1);
+		expect(result.suggestions[0]?.diff).toBe("cached diff");
+		// AI generate should NOT have been called
+		expect(mockGenerate).not.toHaveBeenCalled();
+	});
+
+	it("should cache the result after AI call", async () => {
+		await generateFixes([sampleFinding], defaultOptions);
+
+		expect(mockCacheSet).toHaveBeenCalledTimes(1);
+		expect(mockCacheSet).toHaveBeenCalledWith(
+			expect.any(String), // cache key
+			expect.any(String), // JSON stringified result
+			expect.objectContaining({
+				ttl: expect.any(Number),
+			}),
+		);
+	});
+
+	it("should return same fix on second call via cache", async () => {
+		// First call: AI generates
+		const result1 = await generateFixes([sampleFinding], defaultOptions);
+		expect(result1.cached).toBe(false);
+		expect(mockGenerate).toHaveBeenCalledTimes(1);
+
+		// Set up cache to return what was stored
+		const calls = mockCacheSet.mock.calls as unknown[][];
+		const storedValue = (calls[0]?.[1] ?? "") as string;
+		mockCacheGet.mockImplementation(() => ({
+			key: "test-key",
+			value: storedValue,
+			createdAt: Date.now(),
+			ttl: 0,
+		}));
+
+		// Second call: should hit cache
+		const result2 = await generateFixes([sampleFinding], defaultOptions);
+		expect(result2.cached).toBe(true);
+		// AI should not be called a second time
+		expect(mockGenerate).toHaveBeenCalledTimes(1);
+	});
+
+	it("should batch multiple findings into a single AI call", async () => {
+		mockGenerate.mockImplementation(() =>
+			Promise.resolve({
+				text: multiFixAiResponse,
+				cached: false,
+				model: "test-model",
+				tokens: { input: 200, output: 100 },
+			}),
+		);
+
+		const result = await generateFixes(
+			[sampleFinding, sampleFinding2],
+			defaultOptions,
+		);
+
+		// Only one AI call for multiple findings
+		expect(mockGenerate).toHaveBeenCalledTimes(1);
+		expect(result.suggestions.length).toBe(2);
+	});
+
+	it("should handle AI call returning empty/unparseable response", async () => {
+		mockGenerate.mockImplementation(() =>
+			Promise.resolve({
+				text: "Sorry, I cannot fix these issues.",
+				cached: false,
+				model: "test-model",
+				tokens: { input: 100, output: 10 },
+			}),
+		);
+
+		const result = await generateFixes([sampleFinding], defaultOptions);
+
+		expect(result.suggestions.length).toBe(0);
+		expect(result.cached).toBe(false);
+	});
+
+	it("should use contextText in the prompt when provided", async () => {
+		await generateFixes([sampleFinding], {
+			...defaultOptions,
+			contextText: "function computeValue() { return 42; }",
+		});
+
+		expect(mockBuildSystemPrompt).toHaveBeenCalledWith(
+			"fix",
+			".maina",
+			expect.objectContaining({
+				source: expect.stringContaining("computeValue"),
+			}),
+		);
+	});
+
+	it("should handle missing contextText gracefully", async () => {
+		await generateFixes([sampleFinding], {
+			mainaDir: ".maina",
+		});
+
+		expect(mockBuildSystemPrompt).toHaveBeenCalledWith(
+			"fix",
+			".maina",
+			expect.objectContaining({
+				source: expect.any(String),
+			}),
+		);
+	});
+});
+
+// ─── FixSuggestion type ──────────────────────────────────────────────────
+
+describe("FixSuggestion type", () => {
+	it("should have all required fields", () => {
+		const suggestion: FixSuggestion = {
+			finding: sampleFinding,
+			diff: "--- a/file\n+++ b/file",
+			explanation: "Fix explanation",
+			confidence: "high",
+		};
+
+		expect(suggestion.finding).toBe(sampleFinding);
+		expect(suggestion.diff).toBeTruthy();
+		expect(suggestion.explanation).toBeTruthy();
+		expect(suggestion.confidence).toBe("high");
+	});
+});
+
+// ─── FixResult type ──────────────────────────────────────────────────────
+
+describe("FixResult type", () => {
+	it("should have suggestions, cached flag, and optional model", () => {
+		const result: FixResult = {
+			suggestions: [],
+			cached: false,
+			model: "gpt-4",
+		};
+
+		expect(Array.isArray(result.suggestions)).toBe(true);
+		expect(typeof result.cached).toBe("boolean");
+		expect(result.model).toBe("gpt-4");
+	});
+});

package/src/verify/__tests__/linters/clippy.test.ts

@@ -0,0 +1,45 @@
+import { describe, expect, it } from "bun:test";
+import { parseClippyOutput } from "../../linters/clippy";
+
+describe("parseClippyOutput", () => {
+	it("should parse clippy JSON messages", () => {
+		const lines = [
+			JSON.stringify({
+				reason: "compiler-message",
+				message: {
+					code: { code: "clippy::unwrap_used" },
+					level: "warning",
+					message: "used `unwrap()` on a `Result` value",
+					spans: [
+						{ file_name: "src/main.rs", line_start: 10, column_start: 5 },
+					],
+				},
+			}),
+			JSON.stringify({ reason: "build-finished", success: true }),
+		].join("\n");
+
+		const diagnostics = parseClippyOutput(lines);
+		expect(diagnostics).toHaveLength(1);
+		expect(diagnostics[0]?.file).toBe("src/main.rs");
+		expect(diagnostics[0]?.line).toBe(10);
+		expect(diagnostics[0]?.severity).toBe("warning");
+	});
+
+	it("should handle empty output", () => {
+		expect(parseClippyOutput("")).toHaveLength(0);
+	});
+
+	it("should map error level correctly", () => {
+		const line = JSON.stringify({
+			reason: "compiler-message",
+			message: {
+				code: { code: "E0308" },
+				level: "error",
+				message: "mismatched types",
+				spans: [{ file_name: "src/lib.rs", line_start: 5, column_start: 1 }],
+			},
+		});
+		const diagnostics = parseClippyOutput(line);
+		expect(diagnostics[0]?.severity).toBe("error");
+	});
+});

package/src/verify/__tests__/linters/go-vet.test.ts

@@ -0,0 +1,27 @@
+import { describe, expect, it } from "bun:test";
+import { parseGoVetOutput } from "../../linters/go-vet";
+
+describe("parseGoVetOutput", () => {
+	it("should parse go vet text output", () => {
+		const output = `# example.com/pkg
+./main.go:15:2: unreachable code
+./utils.go:8:4: loop variable captured by func literal`;
+
+		const diagnostics = parseGoVetOutput(output);
+		expect(diagnostics).toHaveLength(2);
+		expect(diagnostics[0]?.file).toBe("./main.go");
+		expect(diagnostics[0]?.line).toBe(15);
+		expect(diagnostics[0]?.severity).toBe("error");
+		expect(diagnostics[0]?.message).toContain("unreachable code");
+	});
+
+	it("should handle empty output", () => {
+		expect(parseGoVetOutput("")).toHaveLength(0);
+	});
+
+	it("should skip package header lines", () => {
+		const output = `# example.com/pkg
+vet: checking...`;
+		expect(parseGoVetOutput(output)).toHaveLength(0);
+	});
+});

package/src/verify/__tests__/linters/ruff.test.ts

@@ -0,0 +1,64 @@
+import { describe, expect, it } from "bun:test";
+import { parseRuffOutput } from "../../linters/ruff";
+
+describe("parseRuffOutput", () => {
+	it("should parse ruff JSON output into SyntaxDiagnostic[]", () => {
+		const json = JSON.stringify([
+			{
+				code: "E501",
+				message: "Line too long (120 > 88)",
+				filename: "src/app.py",
+				location: { row: 10, column: 1 },
+				end_location: { row: 10, column: 120 },
+				fix: null,
+				noqa_row: 10,
+			},
+			{
+				code: "F401",
+				message: "os imported but unused",
+				filename: "src/utils.py",
+				location: { row: 3, column: 1 },
+				end_location: { row: 3, column: 10 },
+				fix: { applicability: "safe" },
+				noqa_row: 3,
+			},
+		]);
+
+		const diagnostics = parseRuffOutput(json);
+		expect(diagnostics).toHaveLength(2);
+		expect(diagnostics[0]?.file).toBe("src/app.py");
+		expect(diagnostics[0]?.line).toBe(10);
+		expect(diagnostics[0]?.severity).toBe("warning");
+		expect(diagnostics[1]?.file).toBe("src/utils.py");
+	});
+
+	it("should map E-codes to warning and F-codes to error", () => {
+		const json = JSON.stringify([
+			{
+				code: "E501",
+				message: "style",
+				filename: "a.py",
+				location: { row: 1, column: 1 },
+				end_location: { row: 1, column: 1 },
+			},
+			{
+				code: "F811",
+				message: "redefined",
+				filename: "a.py",
+				location: { row: 2, column: 1 },
+				end_location: { row: 2, column: 1 },
+			},
+		]);
+		const diagnostics = parseRuffOutput(json);
+		expect(diagnostics[0]?.severity).toBe("warning");
+		expect(diagnostics[1]?.severity).toBe("error");
+	});
+
+	it("should handle empty array", () => {
+		expect(parseRuffOutput("[]")).toHaveLength(0);
+	});
+
+	it("should handle malformed JSON", () => {
+		expect(parseRuffOutput("not json")).toHaveLength(0);
+	});
+});