@mainahq/core 0.3.0 → 0.5.0

package/src/init/index.ts

@@ -291,6 +291,38 @@ function getFileManifest(stack: DetectedStack): FileEntry[] {
 	];
 }
 
+/**
+ * Build a sensible default biome.json for projects without a linter.
+ * Ensures every maina-initialized project has at least one real linter.
+ */
+function buildBiomeConfig(): string {
+	return JSON.stringify(
+		{
+			$schema: "https://biomejs.dev/schemas/2.0.0/schema.json",
+			linter: {
+				enabled: true,
+				rules: {
+					recommended: true,
+					correctness: {
+						noUnusedVariables: "warn",
+						noUnusedImports: "warn",
+					},
+					style: {
+						useConst: "error",
+					},
+				},
+			},
+			formatter: {
+				enabled: true,
+				indentStyle: "tab",
+				lineWidth: 100,
+			},
+		},
+		null,
+		2,
+	);
+}
+
 /** Directories to create even if they have no files */
 const EXTRA_DIRS = [".maina/hooks"];
 
@@ -345,6 +377,17 @@ export async function bootstrap(
 			}
 		}
 
+		// ── Auto-configure Biome if no linter detected ──────────────────
+		if (detectedStack.linter === "unknown") {
+			const biomePath = join(repoRoot, "biome.json");
+			if (!existsSync(biomePath) || force) {
+				const biomeConfig = buildBiomeConfig();
+				writeFileSync(biomePath, biomeConfig, "utf-8");
+				created.push("biome.json");
+				detectedStack.linter = "biome";
+			}
+		}
+
 		return {
 			ok: true,
 			value: {

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

@@ -1,7 +1,7 @@
 import { describe, expect, it } from "bun:test";
 import { existsSync, mkdirSync, rmSync, writeFileSync } from "node:fs";
 import { join } from "node:path";
-import { detectLanguages } from "../detect";
+import { detectFileLanguage, detectLanguages } from "../detect";
 
 describe("detectLanguages", () => {
 	const testDir = join(import.meta.dir, "__fixtures__/detect");
@@ -74,4 +74,64 @@ describe("detectLanguages", () => {
 		expect(result).toContain("python");
 		cleanup();
 	});
+
+	it("should detect PHP from composer.json", () => {
+		setup({ "composer.json": '{"require": {"php": ">=8.1"}}' });
+		const result = detectLanguages(testDir);
+		expect(result).toContain("php");
+		cleanup();
+	});
+
+	it("should detect PHP from composer.lock", () => {
+		setup({ "composer.lock": '{"packages": []}' });
+		const result = detectLanguages(testDir);
+		expect(result).toContain("php");
+		cleanup();
+	});
+});
+
+describe("detectFileLanguage", () => {
+	it("should detect TypeScript from .ts extension", () => {
+		expect(detectFileLanguage("src/index.ts")).toBe("typescript");
+	});
+
+	it("should detect TypeScript from .tsx extension", () => {
+		expect(detectFileLanguage("components/App.tsx")).toBe("typescript");
+	});
+
+	it("should detect Python from .py extension", () => {
+		expect(detectFileLanguage("app/main.py")).toBe("python");
+	});
+
+	it("should detect Go from .go extension", () => {
+		expect(detectFileLanguage("cmd/server.go")).toBe("go");
+	});
+
+	it("should detect Rust from .rs extension", () => {
+		expect(detectFileLanguage("src/lib.rs")).toBe("rust");
+	});
+
+	it("should detect C# from .cs extension", () => {
+		expect(detectFileLanguage("Controllers/HomeController.cs")).toBe("csharp");
+	});
+
+	it("should detect Java from .java extension", () => {
+		expect(detectFileLanguage("src/Main.java")).toBe("java");
+	});
+
+	it("should detect PHP from .php extension", () => {
+		expect(detectFileLanguage("src/Controller.php")).toBe("php");
+	});
+
+	it("should return null for unknown extensions", () => {
+		expect(detectFileLanguage("data.csv")).toBeNull();
+		expect(detectFileLanguage("README.md")).toBeNull();
+		expect(detectFileLanguage("Dockerfile")).toBeNull();
+	});
+
+	it("should handle case-insensitive extensions", () => {
+		expect(detectFileLanguage("script.PY")).toBe("python");
+		expect(detectFileLanguage("main.Go")).toBe("go");
+		expect(detectFileLanguage("index.PHP")).toBe("php");
+	});
 });

package/src/language/__tests__/profile.test.ts

@@ -1,5 +1,9 @@
 import { describe, expect, it } from "bun:test";
-import { getProfile, TYPESCRIPT_PROFILE } from "../profile";
+import {
+	getProfile,
+	getSupportedLanguages,
+	TYPESCRIPT_PROFILE,
+} from "../profile";
 
 describe("LanguageProfile", () => {
 	it("should return TypeScript profile by default", () => {
@@ -63,4 +67,52 @@ describe("LanguageProfile", () => {
 		expect(getProfile("go").printPattern.test("fmt.Println(x)")).toBe(true);
 		expect(getProfile("rust").printPattern.test("println!(x)")).toBe(true);
 	});
+
+	it("should return PHP profile", () => {
+		const profile = getProfile("php");
+		expect(profile.id).toBe("php");
+		expect(profile.displayName).toBe("PHP");
+		expect(profile.extensions).toContain(".php");
+		expect(profile.syntaxTool).toBe("phpstan");
+		expect(profile.commentPrefixes).toContain("//");
+		expect(profile.commentPrefixes).toContain("#");
+		expect(profile.commentPrefixes).toContain("/*");
+	});
+
+	it("should have PHP test file pattern", () => {
+		const profile = getProfile("php");
+		expect(profile.testFilePattern.test("UserTest.php")).toBe(true);
+		expect(profile.testFilePattern.test("tests/UserTest.php")).toBe(true);
+		expect(profile.testFilePattern.test("src/User.php")).toBe(false);
+	});
+
+	it("should have PHP print/debug patterns", () => {
+		const profile = getProfile("php");
+		expect(profile.printPattern.test("echo('hello')")).toBe(true);
+		expect(profile.printPattern.test("print('hello')")).toBe(true);
+		expect(profile.printPattern.test("var_dump($x)")).toBe(true);
+		expect(profile.printPattern.test("print_r($arr)")).toBe(true);
+		expect(profile.printPattern.test("error_log('msg')")).toBe(true);
+	});
+
+	it("should have PHP lint ignore patterns", () => {
+		const profile = getProfile("php");
+		expect(profile.lintIgnorePattern.test("@phpstan-ignore")).toBe(true);
+		expect(profile.lintIgnorePattern.test("@psalm-suppress")).toBe(true);
+		expect(profile.lintIgnorePattern.test("phpcs:ignore")).toBe(true);
+	});
+
+	it("should have PHP import pattern", () => {
+		const profile = getProfile("php");
+		expect(profile.importPattern.test("use App\\Models\\User;")).toBe(true);
+		expect(profile.importPattern.test("require 'vendor/autoload.php';")).toBe(
+			true,
+		);
+		expect(profile.importPattern.test("include 'config.php';")).toBe(true);
+	});
+
+	it("should include php in supported languages", () => {
+		const languages = getSupportedLanguages();
+		expect(languages).toContain("php");
+	});
 });

package/src/language/detect.ts

@@ -3,8 +3,8 @@
  */
 
 import { existsSync, readdirSync, readFileSync } from "node:fs";
-import { join } from "node:path";
-import type { LanguageId } from "./profile";
+import { extname, join } from "node:path";
+import { type LanguageId, PROFILES } from "./profile";
 
 const LANGUAGE_MARKERS: Record<LanguageId, string[]> = {
 	typescript: ["tsconfig.json", "tsconfig.build.json"],
@@ -19,6 +19,7 @@ const LANGUAGE_MARKERS: Record<LanguageId, string[]> = {
 	rust: ["Cargo.toml", "Cargo.lock"],
 	csharp: ["global.json", "Directory.Build.props"],
 	java: ["pom.xml", "build.gradle", "build.gradle.kts", "settings.gradle"],
+	php: ["composer.json", "composer.lock"],
 };
 
 /**
@@ -82,3 +83,18 @@ export function getPrimaryLanguage(cwd: string): LanguageId {
 	const languages = detectLanguages(cwd);
 	return languages[0] ?? "typescript";
 }
+
+/**
+ * Detect language for a single file based on its extension.
+ * Returns the LanguageId if matched, or null if unknown.
+ */
+export function detectFileLanguage(filePath: string): LanguageId | null {
+	const ext = extname(filePath).toLowerCase();
+	if (!ext) return null;
+	for (const profile of Object.values(PROFILES)) {
+		if (profile.extensions.includes(ext)) {
+			return profile.id;
+		}
+	}
+	return null;
+}

package/src/language/profile.ts

@@ -9,7 +9,8 @@ export type LanguageId =
 	| "go"
 	| "rust"
 	| "csharp"
-	| "java";
+	| "java"
+	| "php";
 
 export interface LanguageProfile {
 	id: LanguageId;
@@ -135,13 +136,34 @@ export const JAVA_PROFILE: LanguageProfile = {
 	fileGlobs: ["*.java", "*.kt"],
 };
 
-const PROFILES: Record<LanguageId, LanguageProfile> = {
+export const PHP_PROFILE: LanguageProfile = {
+	id: "php",
+	displayName: "PHP",
+	extensions: [".php"],
+	syntaxTool: "phpstan",
+	syntaxArgs: (files, _cwd) => [
+		"phpstan",
+		"analyse",
+		"--error-format=json",
+		"--no-progress",
+		...files,
+	],
+	commentPrefixes: ["//", "/*", "#"],
+	testFilePattern: /(?:Test\.php$|tests\/)/,
+	printPattern: /\b(?:echo|print|var_dump|print_r|error_log)\s*\(/,
+	lintIgnorePattern: /@phpstan-ignore|@psalm-suppress|phpcs:ignore/,
+	importPattern: /^(?:use|require|include)\s+/,
+	fileGlobs: ["*.php"],
+};
+
+export const PROFILES: Record<LanguageId, LanguageProfile> = {
 	typescript: TYPESCRIPT_PROFILE,
 	python: PYTHON_PROFILE,
 	go: GO_PROFILE,
 	rust: RUST_PROFILE,
 	csharp: CSHARP_PROFILE,
 	java: JAVA_PROFILE,
+	php: PHP_PROFILE,
 };
 
 export function getProfile(id: LanguageId): LanguageProfile {

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__/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);
 	});