@mainahq/core 0.2.0 → 0.4.0

package/src/ticket/index.ts

@@ -16,6 +16,7 @@ export interface TicketOptions {
 	body: string;
 	labels?: string[];
 	cwd?: string;
+	repo?: string; // Cross-repo: "owner/name" for gh --repo flag
 }
 
 export interface TicketResult {
@@ -156,6 +157,10 @@ export async function createTicket(
 			args.push("--label", options.labels.join(","));
 		}
 
+		if (options.repo) {
+			args.push("--repo", options.repo);
+		}
+
 		const { exitCode, stdout, stderr } = await deps.spawn(args, {
 			cwd: options.cwd,
 		});

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

@@ -0,0 +1,98 @@
+/**
+ * Tests for cross-function consistency checking.
+ *
+ * Verifies that checkConsistency() catches cases where related functions
+ * use inconsistent patterns (e.g., calling isURL but not isIP).
+ */
+
+import { afterEach, beforeEach, describe, expect, it } from "bun:test";
+import { mkdirSync, rmSync, writeFileSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+
+describe("checkConsistency", () => {
+	let testDir: string;
+	let mainaDir: string;
+
+	beforeEach(() => {
+		testDir = join(tmpdir(), `maina-consistency-test-${Date.now()}`);
+		mainaDir = join(testDir, ".maina");
+		mkdirSync(mainaDir, { recursive: true });
+	});
+
+	afterEach(() => {
+		rmSync(testDir, { recursive: true, force: true });
+	});
+
+	it("should detect inconsistent validator usage from spec constraints", async () => {
+		// Spec says "use isIP for IP hosts"
+		writeFileSync(
+			join(mainaDir, "constitution.md"),
+			"## Rules\n- Always validate IP addresses with isIP when checking hosts\n",
+		);
+
+		const code = [
+			"function processUrl(host: string) {",
+			"  if (isURL(host)) {",
+			"    // should also call isIP but doesn't",
+			"    return fetch(host);",
+			"  }",
+			"}",
+		].join("\n");
+
+		writeFileSync(join(testDir, "handler.ts"), code);
+
+		const { checkConsistency } = await import("../consistency");
+		const result = await checkConsistency(["handler.ts"], testDir, mainaDir);
+
+		expect(result.rulesChecked).toBeGreaterThan(0);
+	});
+
+	it("should return empty findings when no spec exists", async () => {
+		writeFileSync(join(testDir, "clean.ts"), "const x = 1;\n");
+
+		const { checkConsistency } = await import("../consistency");
+		const result = await checkConsistency(
+			["clean.ts"],
+			testDir,
+			join(testDir, "nonexistent-maina"),
+		);
+
+		expect(result.findings).toEqual([]);
+	});
+
+	it("should detect heuristic pattern: validator used on one path but not another", async () => {
+		const code = [
+			'import { isValid } from "./validators";',
+			"",
+			"function handleA(input: string) {",
+			"  if (isValid(input)) return process(input);",
+			"}",
+			"",
+			"function handleB(input: string) {",
+			"  // Missing isValid check — inconsistent with handleA",
+			"  return process(input);",
+			"}",
+		].join("\n");
+
+		writeFileSync(join(testDir, "handlers.ts"), code);
+
+		const { checkConsistency } = await import("../consistency");
+		const result = await checkConsistency(["handlers.ts"], testDir, mainaDir);
+
+		// Heuristic mode should at least check for patterns
+		expect(result.rulesChecked).toBeGreaterThanOrEqual(0);
+	});
+
+	it("should return ConsistencyResult with correct shape", async () => {
+		writeFileSync(join(testDir, "simple.ts"), "const x = 1;\n");
+
+		const { checkConsistency } = await import("../consistency");
+		const result = await checkConsistency(["simple.ts"], testDir, mainaDir);
+
+		expect(result).toHaveProperty("findings");
+		expect(result).toHaveProperty("rulesChecked");
+		expect(Array.isArray(result.findings)).toBe(true);
+		expect(typeof result.rulesChecked).toBe("number");
+	});
+});

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

@@ -0,0 +1,215 @@
+import { describe, expect, it } from "bun:test";
+import { parseLighthouseJson, runLighthouse } from "../lighthouse";
+
+// ─── parseLighthouseJson ──────────────────────────────────────────────────
+
+describe("parseLighthouseJson", () => {
+	it("should return empty findings when all scores are above thresholds", () => {
+		const json = JSON.stringify({
+			categories: {
+				performance: { score: 0.95 },
+				accessibility: { score: 0.92 },
+				seo: { score: 0.98 },
+			},
+		});
+
+		const result = parseLighthouseJson(json);
+		expect(result.findings).toEqual([]);
+		expect(result.scores).toEqual({
+			performance: 95,
+			accessibility: 92,
+			seo: 98,
+		});
+	});
+
+	it("should generate findings when scores fall below default thresholds", () => {
+		const json = JSON.stringify({
+			categories: {
+				performance: { score: 0.72 },
+				accessibility: { score: 0.85 },
+				seo: { score: 0.6 },
+			},
+		});
+
+		const result = parseLighthouseJson(json);
+		expect(result.findings.length).toBe(3);
+
+		const perfFinding = result.findings.find((f) =>
+			f.message.includes("performance"),
+		);
+		expect(perfFinding?.tool).toBe("lighthouse");
+		expect(perfFinding?.severity).toBe("warning");
+		expect(perfFinding?.message).toContain("72");
+		expect(perfFinding?.message).toContain("90");
+
+		const a11yFinding = result.findings.find((f) =>
+			f.message.includes("accessibility"),
+		);
+		expect(a11yFinding?.severity).toBe("warning");
+
+		const seoFinding = result.findings.find((f) => f.message.includes("seo"));
+		expect(seoFinding?.severity).toBe("warning");
+	});
+
+	it("should use custom thresholds when provided", () => {
+		const json = JSON.stringify({
+			categories: {
+				performance: { score: 0.72 },
+				accessibility: { score: 0.85 },
+				seo: { score: 0.6 },
+			},
+		});
+
+		const result = parseLighthouseJson(json, {
+			performance: 70,
+			accessibility: 80,
+			seo: 50,
+		});
+
+		// All scores are above custom thresholds
+		expect(result.findings).toEqual([]);
+	});
+
+	it("should generate error severity for very low scores", () => {
+		const json = JSON.stringify({
+			categories: {
+				performance: { score: 0.3 },
+				accessibility: { score: 0.4 },
+				seo: { score: 0.25 },
+			},
+		});
+
+		const result = parseLighthouseJson(json);
+		for (const finding of result.findings) {
+			expect(finding.severity).toBe("error");
+		}
+	});
+
+	it("should handle missing categories gracefully", () => {
+		const json = JSON.stringify({
+			categories: {
+				performance: { score: 0.95 },
+			},
+		});
+
+		const result = parseLighthouseJson(json);
+		expect(result.findings).toEqual([]);
+		expect(result.scores).toEqual({ performance: 95 });
+	});
+
+	it("should return empty findings for invalid JSON", () => {
+		const result = parseLighthouseJson("not valid json {{{");
+		expect(result.findings).toEqual([]);
+		expect(result.scores).toEqual({});
+	});
+
+	it("should return empty findings for malformed structure", () => {
+		const result = parseLighthouseJson(JSON.stringify({ unexpected: true }));
+		expect(result.findings).toEqual([]);
+		expect(result.scores).toEqual({});
+	});
+
+	it("should handle categories with null scores", () => {
+		const json = JSON.stringify({
+			categories: {
+				performance: { score: null },
+				accessibility: { score: 0.95 },
+			},
+		});
+
+		const result = parseLighthouseJson(json);
+		expect(result.scores).toEqual({ accessibility: 95 });
+	});
+
+	it("should include the URL in findings when provided", () => {
+		const json = JSON.stringify({
+			requestedUrl: "https://example.com",
+			categories: {
+				performance: { score: 0.5 },
+			},
+		});
+
+		const result = parseLighthouseJson(json);
+		expect(result.findings.length).toBe(1);
+		expect(result.findings[0]?.file).toBe("https://example.com");
+	});
+
+	it("should handle best-practices category", () => {
+		const json = JSON.stringify({
+			categories: {
+				"best-practices": { score: 0.7 },
+			},
+		});
+
+		const result = parseLighthouseJson(json);
+		// best-practices is not in default thresholds, so no findings
+		expect(result.findings).toEqual([]);
+		expect(result.scores).toEqual({ "best-practices": 70 });
+	});
+
+	it("should generate findings for best-practices when threshold set", () => {
+		const json = JSON.stringify({
+			categories: {
+				"best-practices": { score: 0.7 },
+			},
+		});
+
+		const result = parseLighthouseJson(json, {
+			"best-practices": 90,
+		});
+		expect(result.findings.length).toBe(1);
+		expect(result.findings[0]?.message).toContain("best-practices");
+	});
+});
+
+// ─── runLighthouse ────────────────────────────────────────────────────────
+
+describe("runLighthouse", () => {
+	it("should skip when lighthouse is not available", async () => {
+		const result = await runLighthouse({
+			url: "https://example.com",
+			cwd: "/tmp",
+			available: false,
+		});
+		expect(result.findings).toEqual([]);
+		expect(result.skipped).toBe(true);
+		expect(result.scores).toEqual({});
+	});
+
+	it("should skip when no URL is provided", async () => {
+		const result = await runLighthouse({
+			url: "",
+			cwd: "/tmp",
+			available: true,
+		});
+		expect(result.findings).toEqual([]);
+		expect(result.skipped).toBe(true);
+		expect(result.scores).toEqual({});
+	});
+
+	it("should return correct result shape", async () => {
+		const result = await runLighthouse({
+			url: "https://example.com",
+			cwd: "/tmp",
+			available: false,
+		});
+		expect(result).toHaveProperty("findings");
+		expect(result).toHaveProperty("skipped");
+		expect(result).toHaveProperty("scores");
+		expect(Array.isArray(result.findings)).toBe(true);
+		expect(typeof result.skipped).toBe("boolean");
+		expect(typeof result.scores).toBe("object");
+	});
+
+	it("should accept custom thresholds without crashing", async () => {
+		const result = await runLighthouse({
+			url: "https://example.com",
+			cwd: "/tmp",
+			available: false,
+			thresholds: { performance: 80, accessibility: 85 },
+		});
+		expect(result).toHaveProperty("findings");
+		expect(result).toHaveProperty("skipped");
+		expect(result).toHaveProperty("scores");
+	});
+});

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

@@ -0,0 +1,23 @@
+import { describe, expect, it } from "bun:test";
+import { parseCheckstyleOutput } from "../../linters/checkstyle";
+
+describe("parseCheckstyleOutput", () => {
+	it("should parse checkstyle XML", () => {
+		const xml = `<?xml version="1.0" encoding="UTF-8"?>
+<checkstyle>
+<file name="src/Main.java">
+<error line="10" column="5" severity="error" message="Missing Javadoc comment" source="com.puppycrawl.tools.checkstyle.checks.javadoc"/>
+<error line="20" severity="warning" message="Line is longer than 120 characters" source="com.puppycrawl.tools.checkstyle.checks.sizes"/>
+</file>
+</checkstyle>`;
+		const diagnostics = parseCheckstyleOutput(xml);
+		expect(diagnostics).toHaveLength(2);
+		expect(diagnostics[0]?.file).toBe("src/Main.java");
+		expect(diagnostics[0]?.severity).toBe("error");
+		expect(diagnostics[1]?.severity).toBe("warning");
+	});
+
+	it("should handle empty XML", () => {
+		expect(parseCheckstyleOutput("")).toHaveLength(0);
+	});
+});

package/src/verify/__tests__/linters/dotnet-format.test.ts

@@ -0,0 +1,18 @@
+import { describe, expect, it } from "bun:test";
+import { parseDotnetFormatOutput } from "../../linters/dotnet-format";
+
+describe("parseDotnetFormatOutput", () => {
+	it("should parse dotnet format diagnostics", () => {
+		const output = `Program.cs(10,5): warning CS1234: Unused variable 'x'
+Service.cs(20,1): error CS0246: The type or namespace name 'Foo' could not be found`;
+		const diagnostics = parseDotnetFormatOutput(output);
+		expect(diagnostics).toHaveLength(2);
+		expect(diagnostics[0]?.file).toBe("Program.cs");
+		expect(diagnostics[0]?.severity).toBe("warning");
+		expect(diagnostics[1]?.severity).toBe("error");
+	});
+
+	it("should handle empty output", () => {
+		expect(parseDotnetFormatOutput("")).toHaveLength(0);
+	});
+});

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

@@ -33,6 +33,11 @@ let mockStagedFiles: string[] = ["src/app.ts"];
 let callOrder: string[] = [];
 
 // Mock the modules
+// NOTE: These mocks are intentionally minimal — they only export what pipeline.ts
+// needs. Tests MUST be run via `bun run test` (scripts/test-isolated.ts) which
+// runs each test file in its own subprocess, preventing mock.module() bleed.
+// Running `bun test` directly (single process) will cause cross-file mock leaks.
+
 mock.module("../syntax-guard", () => ({
 	syntaxGuard: async (..._args: unknown[]) => {
 		callOrder.push("syntaxGuard");
@@ -140,6 +145,20 @@ mock.module("../ai-review", () => ({
 	},
 }));
 
+mock.module("../typecheck", () => ({
+	runTypecheck: async (..._args: unknown[]) => {
+		callOrder.push("runTypecheck");
+		return { findings: [], duration: 0, tool: "tsc", skipped: true };
+	},
+}));
+
+mock.module("../consistency", () => ({
+	checkConsistency: async (..._args: unknown[]) => {
+		callOrder.push("checkConsistency");
+		return { findings: [], rulesChecked: 0 };
+	},
+}));
+
 mock.module("../../language/detect", () => ({
 	detectLanguages: (..._args: unknown[]) => ["typescript"],
 }));
@@ -253,8 +272,8 @@ describe("VerifyPipeline", () => {
 		expect(callOrder).toContain("runTrivy");
 		expect(callOrder).toContain("runSecretlint");
 
-		// 5 tool reports (slop + semgrep + trivy + secretlint + ai-review)
-		expect(result.tools).toHaveLength(8);
+		// 10 tool reports (slop + semgrep + trivy + secretlint + sonarqube + stryker + diff-cover + typecheck + consistency + ai-review)
+		expect(result.tools).toHaveLength(10);
 		expect(result.findings).toHaveLength(3);
 	});
 

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

@@ -0,0 +1,160 @@
+/**
+ * Tests for built-in type checking in the verify pipeline.
+ *
+ * Verifies that runTypecheck() spawns the correct language-specific
+ * type checker and parses its output into Finding[].
+ */
+
+import { afterEach, beforeEach, describe, expect, it } from "bun:test";
+import { mkdirSync, rmSync, writeFileSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+
+describe("runTypecheck", () => {
+	let testDir: string;
+
+	beforeEach(() => {
+		testDir = join(tmpdir(), `maina-typecheck-test-${Date.now()}`);
+		mkdirSync(testDir, { recursive: true });
+	});
+
+	afterEach(() => {
+		rmSync(testDir, { recursive: true, force: true });
+	});
+
+	it("should parse tsc --noEmit output into Finding[]", async () => {
+		// Create a tsconfig.json and install typescript locally
+		writeFileSync(
+			join(testDir, "tsconfig.json"),
+			JSON.stringify({
+				compilerOptions: { strict: true, noEmit: true },
+				include: ["*.ts"],
+			}),
+		);
+		// Install typescript locally so tsc is in node_modules/.bin
+		const install = Bun.spawnSync(["bun", "add", "typescript"], {
+			cwd: testDir,
+		});
+		if (install.exitCode !== 0) {
+			// Skip if we can't install (CI without network, etc.)
+			return;
+		}
+
+		// Create a file with a type error
+		writeFileSync(
+			join(testDir, "bad.ts"),
+			'const x: number = "not a number";\n',
+		);
+
+		const { runTypecheck } = await import("../typecheck");
+		const result = await runTypecheck(["bad.ts"], testDir);
+
+		expect(result.findings.length).toBeGreaterThan(0);
+		const first = result.findings[0];
+		if (!first) throw new Error("Expected at least one finding");
+		expect(first.tool).toBe("tsc");
+		expect(first.severity).toBe("error");
+		expect(first.file).toContain("bad.ts");
+		expect(first.line).toBeGreaterThan(0);
+		expect(result.duration).toBeGreaterThanOrEqual(0);
+	});
+
+	it("should return empty findings for clean file", async () => {
+		writeFileSync(
+			join(testDir, "tsconfig.json"),
+			JSON.stringify({
+				compilerOptions: { strict: true, noEmit: true },
+				include: ["*.ts"],
+			}),
+		);
+		Bun.spawnSync(["bun", "add", "typescript"], { cwd: testDir });
+
+		writeFileSync(join(testDir, "good.ts"), "const x: number = 42;\n");
+
+		const { runTypecheck } = await import("../typecheck");
+		const result = await runTypecheck(["good.ts"], testDir);
+
+		expect(result.findings).toEqual([]);
+		expect(result.tool).toBe("tsc");
+	});
+
+	it("should skip with info when tsc is not found", async () => {
+		// Use a non-existent tool path
+		const { runTypecheck } = await import("../typecheck");
+		const result = await runTypecheck(["file.ts"], testDir, {
+			command: "nonexistent-tsc-binary",
+		});
+
+		expect(result.findings).toEqual([]);
+		expect(result.skipped).toBe(true);
+	});
+
+	it("should detect language and use appropriate checker", async () => {
+		const { getTypecheckCommand } = await import("../typecheck");
+
+		expect(getTypecheckCommand("typescript")).toEqual(
+			expect.objectContaining({ tool: "tsc" }),
+		);
+		expect(getTypecheckCommand("python")).toEqual(
+			expect.objectContaining({ tool: "mypy" }),
+		);
+		expect(getTypecheckCommand("go")).toEqual(
+			expect.objectContaining({ tool: "go-vet" }),
+		);
+		expect(getTypecheckCommand("rust")).toEqual(
+			expect.objectContaining({ tool: "cargo-check" }),
+		);
+		expect(getTypecheckCommand("csharp")).toEqual(
+			expect.objectContaining({ tool: "dotnet-build" }),
+		);
+		expect(getTypecheckCommand("java")).toEqual(
+			expect.objectContaining({ tool: "javac" }),
+		);
+	});
+
+	it("should parse multiple errors from tsc output", async () => {
+		const { parseTscOutput } = await import("../typecheck");
+
+		const tscOutput = [
+			"src/foo.ts(10,5): error TS2322: Type 'string' is not assignable to type 'number'.",
+			"src/bar.ts(3,1): error TS2304: Cannot find name 'x'.",
+		].join("\n");
+
+		const findings = parseTscOutput(tscOutput);
+
+		expect(findings).toHaveLength(2);
+		expect(findings[0]).toEqual({
+			tool: "tsc",
+			file: "src/foo.ts",
+			line: 10,
+			column: 5,
+			message: "TS2322: Type 'string' is not assignable to type 'number'.",
+			severity: "error",
+			ruleId: "TS2322",
+		});
+		expect(findings[1]).toEqual({
+			tool: "tsc",
+			file: "src/bar.ts",
+			line: 3,
+			column: 1,
+			message: "TS2304: Cannot find name 'x'.",
+			severity: "error",
+			ruleId: "TS2304",
+		});
+	});
+
+	it("should return empty for empty tsc output", async () => {
+		const { parseTscOutput } = await import("../typecheck");
+		const findings = parseTscOutput("");
+		expect(findings).toEqual([]);
+	});
+
+	it("should handle no tsconfig.json gracefully", async () => {
+		// No tsconfig.json in testDir
+		const { runTypecheck } = await import("../typecheck");
+		const result = await runTypecheck(["file.ts"], testDir);
+
+		// Should not crash, should skip or return empty
+		expect(result.skipped).toBe(true);
+	});
+});