@mainahq/core 0.2.0

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

@@ -0,0 +1,366 @@
+import { afterAll, beforeAll, describe, expect, it } from "bun:test";
+import { mkdirSync, rmSync, writeFileSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import { getProfile } from "../../language/profile";
+import {
+	detectCommentedCode,
+	detectConsoleLogs,
+	detectEmptyBodies,
+	detectHallucinatedImports,
+	detectSlop,
+	detectTodosWithoutTickets,
+} from "../slop";
+
+// ─── Fixtures ──────────────────────────────────────────────────────────────
+
+const TMP_DIR = join(tmpdir(), `maina-slop-test-${Date.now()}`);
+
+beforeAll(() => {
+	mkdirSync(TMP_DIR, { recursive: true });
+});
+
+afterAll(() => {
+	rmSync(TMP_DIR, { recursive: true, force: true });
+});
+
+function writeFixture(name: string, content: string): string {
+	const filePath = join(TMP_DIR, name);
+	writeFileSync(filePath, content, "utf-8");
+	return filePath;
+}
+
+// ─── Empty Bodies ────────────────────────────────────────────────────────────
+
+describe("SlopDetector", () => {
+	describe("detectEmptyBodies", () => {
+		it("should detect empty function bodies via AST", () => {
+			const content = `function doNothing() {}
+
+function hasBody() {
+	return 42;
+}
+
+const arrow = () => {};
+
+class Foo {
+	method() {}
+}`;
+			const findings = detectEmptyBodies(content, "src/foo.ts");
+			expect(findings.length).toBe(3);
+			expect(findings.every((f) => f.ruleId === "slop/empty-body")).toBe(true);
+			expect(findings.every((f) => f.tool === "slop")).toBe(true);
+			expect(findings.every((f) => f.severity === "warning")).toBe(true);
+		});
+
+		it("should not flag function bodies with comments", () => {
+			const content = `function placeholder() {
+	// TODO(#123): implement later
+}`;
+			const findings = detectEmptyBodies(content, "src/foo.ts");
+			expect(findings.length).toBe(0);
+		});
+
+		it("should not flag empty object literals or arrays", () => {
+			const content = `const obj = {};
+const arr: string[] = [];
+const map = new Map();`;
+			const findings = detectEmptyBodies(content, "src/foo.ts");
+			expect(findings.length).toBe(0);
+		});
+	});
+
+	// ─── Hallucinated Imports ────────────────────────────────────────────────
+
+	describe("detectHallucinatedImports", () => {
+		it("should detect hallucinated imports", () => {
+			const content = `import { foo } from "./nonexistent-module";
+import { bar } from "../does-not-exist";`;
+			const findings = detectHallucinatedImports(
+				content,
+				join(TMP_DIR, "test.ts"),
+				TMP_DIR,
+			);
+			expect(findings.length).toBe(2);
+			expect(
+				findings.every((f) => f.ruleId === "slop/hallucinated-import"),
+			).toBe(true);
+			expect(findings.every((f) => f.severity === "error")).toBe(true);
+		});
+
+		it("should not flag node_modules imports", () => {
+			const content = `import { describe } from "bun:test";
+import path from "node:path";
+import React from "react";
+import { z } from "zod";`;
+			const findings = detectHallucinatedImports(
+				content,
+				join(TMP_DIR, "test.ts"),
+				TMP_DIR,
+			);
+			expect(findings.length).toBe(0);
+		});
+
+		it("should not flag existing relative imports", () => {
+			// Create the imported file
+			writeFixture("real-module.ts", "export const x = 1;\n");
+			const content = `import { x } from "./real-module";`;
+			const findings = detectHallucinatedImports(
+				content,
+				join(TMP_DIR, "importer.ts"),
+				TMP_DIR,
+			);
+			expect(findings.length).toBe(0);
+		});
+	});
+
+	// ─── Console Logs ────────────────────────────────────────────────────────
+
+	describe("detectConsoleLogs", () => {
+		it("should detect console.log in production code", () => {
+			const content = `function greet(name: string): void {
+	console.log("Hello", name);
+	console.warn("deprecated");
+	console.error("something broke");
+	console.debug("trace info");
+	console.info("status update");
+}`;
+			const findings = detectConsoleLogs(content, "src/app.ts");
+			expect(findings.length).toBe(5);
+			expect(findings.every((f) => f.ruleId === "slop/console-log")).toBe(true);
+			expect(findings.every((f) => f.severity === "warning")).toBe(true);
+		});
+
+		it("should not flag console.log in test files", () => {
+			const content = `console.log("debugging test");`;
+			const findingsTest = detectConsoleLogs(content, "src/app.test.ts");
+			const findingsSpec = detectConsoleLogs(content, "src/app.spec.ts");
+			expect(findingsTest.length).toBe(0);
+			expect(findingsSpec.length).toBe(0);
+		});
+
+		it("should not flag files without console usage", () => {
+			const content = `function add(a: number, b: number): number {
+	return a + b;
+}`;
+			const findings = detectConsoleLogs(content, "src/math.ts");
+			expect(findings.length).toBe(0);
+		});
+	});
+
+	// ─── Bare TODOs missing ticket ──────────────────────────────────────────
+
+	describe("detectTodosWithoutTickets", () => {
+		it("should detect TODO without ticket reference", () => {
+			const content = `// TODO: fix this later
+/* TODO implement error handling */
+// TODO add caching`;
+			const findings = detectTodosWithoutTickets(content, "src/app.ts");
+			expect(findings.length).toBe(3);
+			expect(
+				findings.every((f) => f.ruleId === "slop/todo-without-ticket"),
+			).toBe(true);
+			expect(findings.every((f) => f.severity === "info")).toBe(true);
+		});
+
+		it("should not flag TODO with ticket references", () => {
+			const content = `// TODO(#123): fix this later
+/* TODO PROJ-456: implement error handling */
+// TODO [#789] add caching
+// TODO(MAINA-42): refactor`;
+			const findings = detectTodosWithoutTickets(content, "src/app.ts");
+			expect(findings.length).toBe(0);
+		});
+	});
+
+	// ─── Commented-out code ──────────────────────────────────────────────────
+
+	describe("detectCommentedCode", () => {
+		it("should detect commented-out code blocks > 3 lines", () => {
+			const content = `function active() {
+	return 1;
+}
+
+// const old = require("old-module");
+// function deprecated() {
+//   return old.doStuff();
+// }
+
+function alsoActive() {
+	return 2;
+}`;
+			const findings = detectCommentedCode(content, "src/app.ts");
+			expect(findings.length).toBe(1);
+			expect(findings[0]?.ruleId).toBe("slop/commented-code");
+			expect(findings[0]?.severity).toBe("warning");
+		});
+
+		it("should not flag short comment blocks", () => {
+			const content = `// This is a normal comment
+// that spans two lines
+function foo() {
+	return 1;
+}`;
+			const findings = detectCommentedCode(content, "src/app.ts");
+			expect(findings.length).toBe(0);
+		});
+
+		it("should not flag documentation comments", () => {
+			const content = `/**
+ * This function does something important.
+ * It takes a number and returns it doubled.
+ * @param n - the number to double
+ * @returns the doubled number
+ */
+function double(n: number): number {
+	return n * 2;
+}`;
+			const findings = detectCommentedCode(content, "src/app.ts");
+			expect(findings.length).toBe(0);
+		});
+	});
+
+	// ─── Cache integration ───────────────────────────────────────────────────
+
+	describe("cache integration", () => {
+		it("should cache results for unchanged files", async () => {
+			const filePath = writeFixture(
+				"cached.ts",
+				`function empty() {}\nconsole.log("hello");\n`,
+			);
+
+			// Create a mock cache manager
+			const store = new Map<string, { value: string }>();
+			const mockCache = {
+				get(key: string) {
+					const entry = store.get(key);
+					if (!entry) return null;
+					return {
+						key,
+						value: entry.value,
+						createdAt: Date.now(),
+						ttl: 0,
+					};
+				},
+				set(key: string, value: string) {
+					store.set(key, { value });
+				},
+				has(key: string) {
+					return store.has(key);
+				},
+				invalidate(key: string) {
+					store.delete(key);
+				},
+				clear() {
+					store.clear();
+				},
+				stats() {
+					return {
+						l1Hits: 0,
+						l2Hits: 0,
+						misses: 0,
+						totalQueries: 0,
+						entriesL1: 0,
+						entriesL2: 0,
+					};
+				},
+			};
+
+			// First call — should not be cached
+			const result1 = await detectSlop([filePath], {
+				cache: mockCache,
+				cwd: TMP_DIR,
+			});
+			expect(result1.cached).toBe(false);
+			expect(result1.findings.length).toBeGreaterThan(0);
+
+			// Second call — same file, should be cached
+			const result2 = await detectSlop([filePath], {
+				cache: mockCache,
+				cwd: TMP_DIR,
+			});
+			expect(result2.cached).toBe(true);
+			expect(result2.findings.length).toBe(result1.findings.length);
+		});
+	});
+
+	// ─── Integration: detectSlop ─────────────────────────────────────────────
+
+	describe("detectSlop integration", () => {
+		it("should detect console.log in a file", async () => {
+			const filePath = writeFixture(
+				"with-console.ts",
+				`export function greet(): void {\n\tconsole.log("hello");\n}\n`,
+			);
+			const result = await detectSlop([filePath], { cwd: TMP_DIR });
+			expect(result.findings.length).toBeGreaterThan(0);
+			expect(result.findings.some((f) => f.ruleId === "slop/console-log")).toBe(
+				true,
+			);
+		});
+
+		it("should return clean for a file without slop", async () => {
+			const filePath = writeFixture(
+				"clean.ts",
+				`export function add(a: number, b: number): number {\n\treturn a + b;\n}\n`,
+			);
+			const result = await detectSlop([filePath], { cwd: TMP_DIR });
+			expect(result.findings.length).toBe(0);
+		});
+	});
+
+	// ─── Language-aware slop detection ──────────────────────────────────────
+
+	describe("language-aware slop detection", () => {
+		it("should detect print() in Python files", () => {
+			const findings = detectConsoleLogs(
+				"x = 1\nprint('debug')\ny = 2",
+				"app.py",
+				getProfile("python"),
+			);
+			expect(findings).toHaveLength(1);
+			expect(findings[0]?.ruleId).toBe("slop/console-log");
+		});
+
+		it("should detect fmt.Println in Go files", () => {
+			const findings = detectConsoleLogs(
+				"package main\nfmt.Println(x)\n",
+				"main.go",
+				getProfile("go"),
+			);
+			expect(findings).toHaveLength(1);
+		});
+
+		it("should detect println! in Rust files", () => {
+			const findings = detectConsoleLogs(
+				'fn main() {\n  println!("debug");\n}',
+				"main.rs",
+				getProfile("rust"),
+			);
+			expect(findings).toHaveLength(1);
+		});
+
+		it("should skip Python test files", () => {
+			const findings = detectConsoleLogs(
+				"print('ok')",
+				"test_app.py",
+				getProfile("python"),
+			);
+			expect(findings).toHaveLength(0);
+		});
+
+		it("should skip Go test files", () => {
+			const findings = detectConsoleLogs(
+				"fmt.Println(x)",
+				"app_test.go",
+				getProfile("go"),
+			);
+			expect(findings).toHaveLength(0);
+		});
+
+		it("should still work without profile (backward compatible)", () => {
+			const findings = detectConsoleLogs("console.log('test')", "app.ts");
+			expect(findings).toHaveLength(1);
+		});
+	});
+});

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

@@ -0,0 +1,113 @@
+import { describe, expect, it } from "bun:test";
+import { parseSonarReport, runSonar } from "../sonar";
+
+describe("SonarQube Integration", () => {
+	describe("parseSonarReport", () => {
+		it("should parse SonarQube JSON issues into findings", () => {
+			const json = JSON.stringify({
+				issues: [
+					{
+						rule: "typescript:S1854",
+						severity: "MAJOR",
+						component: "src/app.ts",
+						line: 42,
+						message: 'Remove this useless assignment to local variable "x".',
+					},
+					{
+						rule: "typescript:S3776",
+						severity: "CRITICAL",
+						component: "src/utils.ts",
+						line: 10,
+						message:
+							"Refactor this function to reduce its Cognitive Complexity.",
+					},
+				],
+			});
+
+			const findings = parseSonarReport(json);
+
+			expect(findings).toHaveLength(2);
+			expect(findings[0]?.tool).toBe("sonarqube");
+			expect(findings[0]?.file).toBe("src/app.ts");
+			expect(findings[0]?.line).toBe(42);
+			expect(findings[0]?.severity).toBe("warning");
+			expect(findings[0]?.ruleId).toBe("typescript:S1854");
+			expect(findings[1]?.severity).toBe("error");
+		});
+
+		it("should handle empty issues array", () => {
+			const json = JSON.stringify({ issues: [] });
+			expect(parseSonarReport(json)).toHaveLength(0);
+		});
+
+		it("should handle malformed JSON", () => {
+			expect(parseSonarReport("not json")).toHaveLength(0);
+		});
+
+		it("should handle missing fields gracefully", () => {
+			const json = JSON.stringify({
+				issues: [{ rule: "test:rule" }],
+			});
+			const findings = parseSonarReport(json);
+			expect(findings).toHaveLength(1);
+			expect(findings[0]?.file).toBe("");
+			expect(findings[0]?.line).toBe(0);
+		});
+
+		it("should map SonarQube severities correctly", () => {
+			const json = JSON.stringify({
+				issues: [
+					{
+						rule: "r1",
+						severity: "BLOCKER",
+						component: "a.ts",
+						line: 1,
+						message: "blocker",
+					},
+					{
+						rule: "r2",
+						severity: "CRITICAL",
+						component: "a.ts",
+						line: 2,
+						message: "critical",
+					},
+					{
+						rule: "r3",
+						severity: "MAJOR",
+						component: "a.ts",
+						line: 3,
+						message: "major",
+					},
+					{
+						rule: "r4",
+						severity: "MINOR",
+						component: "a.ts",
+						line: 4,
+						message: "minor",
+					},
+					{
+						rule: "r5",
+						severity: "INFO",
+						component: "a.ts",
+						line: 5,
+						message: "info",
+					},
+				],
+			});
+			const findings = parseSonarReport(json);
+			expect(findings[0]?.severity).toBe("error"); // BLOCKER
+			expect(findings[1]?.severity).toBe("error"); // CRITICAL
+			expect(findings[2]?.severity).toBe("warning"); // MAJOR
+			expect(findings[3]?.severity).toBe("warning"); // MINOR
+			expect(findings[4]?.severity).toBe("info"); // INFO
+		});
+	});
+
+	describe("runSonar", () => {
+		it("should skip when sonarqube is not available", async () => {
+			const result = await runSonar({ available: false });
+			expect(result.skipped).toBe(true);
+			expect(result.findings).toHaveLength(0);
+		});
+	});
+});

package/src/verify/__tests__/syntax-guard.test.ts

@@ -0,0 +1,227 @@
+import { afterAll, beforeAll, describe, expect, it } from "bun:test";
+import { mkdirSync, rmSync, writeFileSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import { getProfile } from "../../language/profile";
+import { parseBiomeOutput, syntaxGuard } from "../syntax-guard";
+
+// ─── Fixtures ──────────────────────────────────────────────────────────────
+
+const TMP_DIR = join(tmpdir(), `maina-syntax-guard-test-${Date.now()}`);
+
+const VALID_TS = `export const greeting = "hello";\n`;
+
+const INVALID_TS_MISSING_BRACKET = `export function broken( {
+	return 1;
+}\n`;
+
+const INVALID_TS_PARSE_ERROR = `export function bad(): number {
+	const x = [1, 2, 3
+	return x.length;
+}\n`;
+
+beforeAll(() => {
+	mkdirSync(TMP_DIR, { recursive: true });
+});
+
+afterAll(() => {
+	rmSync(TMP_DIR, { recursive: true, force: true });
+});
+
+function writeFixture(name: string, content: string): string {
+	const filePath = join(TMP_DIR, name);
+	writeFileSync(filePath, content, "utf-8");
+	return filePath;
+}
+
+// ─── SyntaxGuard ───────────────────────────────────────────────────────────
+
+describe("SyntaxGuard", () => {
+	it("should pass valid TypeScript files", async () => {
+		const file = writeFixture("valid.ts", VALID_TS);
+		const result = await syntaxGuard([file]);
+		expect(result.ok).toBe(true);
+	});
+
+	it("should reject files with syntax errors", async () => {
+		const file = writeFixture("broken.ts", INVALID_TS_MISSING_BRACKET);
+		const result = await syntaxGuard([file]);
+		expect(result.ok).toBe(false);
+		if (!result.ok) {
+			expect(result.error.length).toBeGreaterThan(0);
+			const hasError = result.error.some((e) => e.severity === "error");
+			expect(hasError).toBe(true);
+		}
+	});
+
+	it("should complete in < 500ms for 10 files", async () => {
+		const files: string[] = [];
+		for (let i = 0; i < 10; i++) {
+			files.push(
+				writeFixture(`perf_${i}.ts`, `export const val${i} = ${i};\n`),
+			);
+		}
+		const start = performance.now();
+		const result = await syntaxGuard(files);
+		const elapsed = performance.now() - start;
+		expect(result.ok).toBe(true);
+		expect(elapsed).toBeLessThan(500);
+	});
+
+	it("should return structured error with file + line + message", async () => {
+		const file = writeFixture("structured.ts", INVALID_TS_PARSE_ERROR);
+		const result = await syntaxGuard([file]);
+		expect(result.ok).toBe(false);
+		if (!result.ok) {
+			expect(result.error.length).toBeGreaterThan(0);
+			const first = result.error[0] as NonNullable<(typeof result.error)[0]>;
+			expect(typeof first.file).toBe("string");
+			expect(first.file).toContain("structured.ts");
+			expect(typeof first.line).toBe("number");
+			expect(first.line).toBeGreaterThan(0);
+			expect(typeof first.column).toBe("number");
+			expect(typeof first.message).toBe("string");
+			expect(first.message.length).toBeGreaterThan(0);
+			expect(["error", "warning"]).toContain(first.severity);
+		}
+	});
+
+	it("should return Ok immediately for empty file list", async () => {
+		const result = await syntaxGuard([]);
+		expect(result.ok).toBe(true);
+	});
+
+	it("should include warnings in output but only reject on errors", async () => {
+		// A file with only a warning (unused variable) but no parse errors
+		const file = writeFixture(
+			"warn_only.ts",
+			`const used = 1;\nexport const result = used + 1;\n`,
+		);
+		const result = await syntaxGuard([file]);
+		// This should pass because there are no errors (only possible warnings)
+		expect(result.ok).toBe(true);
+	});
+});
+
+// ─── syntaxGuard with language profile ────────────────────────────────────
+
+describe("syntaxGuard with language profile", () => {
+	it("should accept a language profile parameter", async () => {
+		const profile = getProfile("typescript");
+		const result = await syntaxGuard([], undefined, profile);
+		expect(result.ok).toBe(true);
+	});
+
+	it("should use biome for typescript profile (default behavior)", async () => {
+		const result = await syntaxGuard(["nonexistent.ts"]);
+		expect(result).toBeDefined();
+	});
+
+	it("should attempt ruff for python profile", async () => {
+		const profile = getProfile("python");
+		// ruff likely not installed — should fail gracefully
+		const result = await syntaxGuard(["test.py"], undefined, profile);
+		expect(result).toBeDefined();
+		// Either ok (if ruff found nothing) or error (if ruff not installed)
+	});
+
+	it("should attempt go vet for go profile", async () => {
+		const profile = getProfile("go");
+		const result = await syntaxGuard(["test.go"], undefined, profile);
+		expect(result).toBeDefined();
+	});
+
+	it("should attempt clippy for rust profile", async () => {
+		const profile = getProfile("rust");
+		const result = await syntaxGuard(["test.rs"], undefined, profile);
+		expect(result).toBeDefined();
+	});
+});
+
+// ─── parseBiomeOutput ──────────────────────────────────────────────────────
+
+describe("parseBiomeOutput", () => {
+	it("should return empty array for empty diagnostics", () => {
+		const json = JSON.stringify({
+			summary: { errors: 0, warnings: 0 },
+			diagnostics: [],
+			command: "check",
+		});
+		const errors = parseBiomeOutput(json);
+		expect(errors).toEqual([]);
+	});
+
+	it("should parse diagnostics from biome JSON output", () => {
+		const json = JSON.stringify({
+			summary: { errors: 1, warnings: 0 },
+			diagnostics: [
+				{
+					severity: "error",
+					message: "expected `:` but instead found `x`",
+					category: "parse",
+					location: {
+						path: "/tmp/test.ts",
+						start: { line: 3, column: 10 },
+						end: { line: 3, column: 11 },
+					},
+					advices: [],
+				},
+			],
+			command: "check",
+		});
+
+		const errors = parseBiomeOutput(json);
+		expect(errors.length).toBe(1);
+		const first = errors[0] as NonNullable<(typeof errors)[0]>;
+		expect(first.file).toBe("/tmp/test.ts");
+		expect(first.line).toBe(3);
+		expect(first.column).toBe(10);
+		expect(first.message).toContain("expected `:`");
+		expect(first.severity).toBe("error");
+	});
+
+	it("should handle multiple diagnostics", () => {
+		const json = JSON.stringify({
+			summary: { errors: 2, warnings: 1 },
+			diagnostics: [
+				{
+					severity: "warning",
+					message: "Unused variable",
+					category: "lint/correctness/noUnusedVariables",
+					location: {
+						path: "/tmp/a.ts",
+						start: { line: 1, column: 5 },
+						end: { line: 1, column: 6 },
+					},
+					advices: [],
+				},
+				{
+					severity: "error",
+					message: "Parse error",
+					category: "parse",
+					location: {
+						path: "/tmp/a.ts",
+						start: { line: 5, column: 1 },
+						end: { line: 5, column: 1 },
+					},
+					advices: [],
+				},
+			],
+			command: "check",
+		});
+
+		const errors = parseBiomeOutput(json);
+		expect(errors.length).toBe(2);
+		expect((errors[0] as NonNullable<(typeof errors)[0]>).severity).toBe(
+			"warning",
+		);
+		expect((errors[1] as NonNullable<(typeof errors)[0]>).severity).toBe(
+			"error",
+		);
+	});
+
+	it("should return empty array for invalid JSON", () => {
+		const errors = parseBiomeOutput("not json at all");
+		expect(errors).toEqual([]);
+	});
+});