@mainahq/core 0.2.0 → 0.4.0

package/src/feedback/trace-analysis.ts

@@ -0,0 +1,153 @@
+/**
+ * Post-workflow RL Trace Analysis — analyzes completed workflow traces
+ * to propose prompt improvements.
+ *
+ * After a full workflow completes (brainstorm → ... → pr):
+ * 1. Collects the full trace from workflow context
+ * 2. Analyzes: which steps had issues? How did findings trend?
+ * 3. Proposes prompt improvements based on patterns
+ * 4. Feeds into maina learn automatically
+ */
+
+import { existsSync, readFileSync } from "node:fs";
+import { join } from "node:path";
+
+// ─── Types ────────────────────────────────────────────────────────────────
+
+export interface TraceStep {
+	command: string;
+	timestamp: string;
+	summary: string;
+	findingsCount?: number;
+}
+
+export interface PromptImprovement {
+	promptFile: string;
+	reason: string;
+	suggestion: string;
+	confidence: number;
+}
+
+export interface TraceResult {
+	steps: TraceStep[];
+	improvements: PromptImprovement[];
+	summary: string;
+}
+
+// ─── Trace Parsing ───────────────────────────────────────────────────────
+
+/**
+ * Parse the workflow context file into structured trace steps.
+ */
+function parseWorkflowContext(content: string): TraceStep[] {
+	const steps: TraceStep[] = [];
+	const stepPattern =
+		/^## (\w+) \((\d{4}-\d{2}-\d{2}T[\d:.]+Z)\)\s*\n([\s\S]*?)(?=\n## |\n*$)/gm;
+
+	for (const match of content.matchAll(stepPattern)) {
+		const command = match[1] ?? "";
+		const timestamp = match[2] ?? "";
+		const summary = (match[3] ?? "").trim();
+
+		// Extract findings count if present
+		const findingsMatch = summary.match(/(\d+)\s+findings?/);
+		const findingsCount = findingsMatch
+			? Number.parseInt(findingsMatch[1] ?? "0", 10)
+			: undefined;
+
+		steps.push({ command, timestamp, summary, findingsCount });
+	}
+
+	return steps;
+}
+
+// ─── Analysis ────────────────────────────────────────────────────────────
+
+/**
+ * Analyze trace steps for patterns that suggest prompt improvements.
+ */
+function analyzePatterns(steps: TraceStep[]): PromptImprovement[] {
+	const improvements: PromptImprovement[] = [];
+
+	// Pattern 1: Multiple commits with findings before a clean one
+	const commitSteps = steps.filter(
+		(s) => s.command === "commit" && s.findingsCount !== undefined,
+	);
+	const dirtyCommits = commitSteps.filter(
+		(s) => s.findingsCount !== undefined && s.findingsCount > 0,
+	);
+
+	if (dirtyCommits.length >= 2) {
+		improvements.push({
+			promptFile: "prompts/review.md",
+			reason: `${dirtyCommits.length} commits had verification findings before clean pass — review prompt may need to catch these patterns earlier.`,
+			suggestion:
+				"Add examples of common finding patterns to the review prompt so AI catches them in the first pass.",
+			confidence: 0.6,
+		});
+	}
+
+	// Pattern 2: Workflow has no review step
+	const hasReview = steps.some((s) => s.command === "review");
+	if (steps.length >= 3 && !hasReview) {
+		improvements.push({
+			promptFile: "prompts/commit.md",
+			reason:
+				"Workflow completed without a review step — commit prompt could remind about review.",
+			suggestion:
+				"Add a reminder to run maina review before committing when changes are substantial.",
+			confidence: 0.4,
+		});
+	}
+
+	return improvements;
+}
+
+/**
+ * Generate a human-readable summary of the trace analysis.
+ */
+function generateSummary(
+	steps: TraceStep[],
+	improvements: PromptImprovement[],
+): string {
+	if (steps.length === 0) return "No workflow trace found.";
+
+	const commands = steps.map((s) => s.command).join(" → ");
+	const totalFindings = steps
+		.filter((s) => s.findingsCount !== undefined)
+		.reduce((sum, s) => sum + (s.findingsCount ?? 0), 0);
+
+	let summary = `Workflow: ${commands} (${steps.length} steps, ${totalFindings} total findings)`;
+
+	if (improvements.length > 0) {
+		summary += `\n${improvements.length} improvement(s) suggested.`;
+	}
+
+	return summary;
+}
+
+// ─── Main ────────────────────────────────────────────────────────────────
+
+/**
+ * Analyze the current workflow trace and generate improvement proposals.
+ *
+ * This runs after maina pr completes. It reads the workflow context,
+ * correlates with feedback data, and proposes prompt improvements
+ * that are automatically fed into maina learn.
+ */
+export async function analyzeWorkflowTrace(
+	mainaDir: string,
+): Promise<TraceResult> {
+	const workflowFile = join(mainaDir, "workflow", "current.md");
+
+	if (!existsSync(workflowFile)) {
+		return { steps: [], improvements: [], summary: "No workflow trace found." };
+	}
+
+	const content = readFileSync(workflowFile, "utf-8");
+	const steps = parseWorkflowContext(content);
+	const improvements = analyzePatterns(steps);
+	const summary = generateSummary(steps, improvements);
+
+	return { steps, improvements, summary };
+}

package/src/index.ts

@@ -2,6 +2,13 @@ export const VERSION = "0.1.0";
 
 // AI
 export { generateCommitMessage } from "./ai/commit-msg";
+// AI — Delegation
+export {
+	type DelegationRequest,
+	formatDelegationRequest,
+	outputDelegationRequest,
+	parseDelegationRequest,
+} from "./ai/delegation";
 export {
 	type DesignApproach,
 	generateDesignApproaches,
@@ -43,6 +50,26 @@ export {
 	type CacheStats,
 	createCacheManager,
 } from "./cache/manager";
+// Cloud
+export {
+	type AuthConfig,
+	clearAuthConfig,
+	loadAuthConfig,
+	pollForToken,
+	saveAuthConfig,
+	startDeviceFlow,
+} from "./cloud/auth";
+export { type CloudClient, createCloudClient } from "./cloud/client";
+export type {
+	ApiResponse,
+	CloudConfig,
+	CloudFeedbackPayload,
+	DeviceCodeResponse,
+	PromptRecord,
+	TeamInfo,
+	TeamMember,
+	TokenResponse,
+} from "./cloud/types";
 // Config
 export { getApiKey, isHostMode, shouldDelegateToHost } from "./config/index";
 export { calculateTokens } from "./context/budget";
@@ -137,6 +164,12 @@ export {
 	type RulePreference,
 	savePreferences,
 } from "./feedback/preferences";
+export {
+	analyzeWorkflowTrace,
+	type PromptImprovement,
+	type TraceResult,
+	type TraceStep,
+} from "./feedback/trace-analysis";
 // Git
 export {
 	type Commit,
@@ -171,9 +204,11 @@ export {
 	getPrimaryLanguage,
 } from "./language/detect";
 export {
+	CSHARP_PROFILE,
 	GO_PROFILE,
 	getProfile,
 	getSupportedLanguages,
+	JAVA_PROFILE,
 	type LanguageId,
 	type LanguageProfile,
 	PYTHON_PROFILE,
@@ -259,6 +294,10 @@ export {
 	resolveReferencedFunctions,
 	runAIReview,
 } from "./verify/ai-review";
+export {
+	type ConsistencyResult,
+	checkConsistency,
+} from "./verify/consistency";
 // Verify — Coverage
 export {
 	type CoverageOptions,
@@ -289,6 +328,13 @@ export {
 	hashFinding,
 	parseFixResponse,
 } from "./verify/fix";
+// Verify — Lighthouse
+export {
+	type LighthouseOptions,
+	type LighthouseResult,
+	parseLighthouseJson,
+	runLighthouse,
+} from "./verify/lighthouse";
 // Verify — Mutation
 export {
 	type MutationOptions,
@@ -334,6 +380,8 @@ export {
 	type SyntaxGuardResult,
 	syntaxGuard,
 } from "./verify/syntax-guard";
+// Verify — Typecheck + Consistency (built-in checks)
+export { runTypecheck, type TypecheckResult } from "./verify/typecheck";
 // Verify — Visual
 export {
 	captureScreenshot,
@@ -348,6 +396,13 @@ export {
 	type VisualDiffResult,
 	type VisualVerifyResult,
 } from "./verify/visual";
+// Verify — ZAP DAST
+export {
+	parseZapJson,
+	runZap,
+	type ZapOptions,
+	type ZapResult,
+} from "./verify/zap";
 // Workflow
 export {
 	appendWorkflowStep,

package/src/init/__tests__/init.test.ts

@@ -225,4 +225,55 @@ describe("bootstrap", () => {
 			}
 		}
 	});
+
+	test("auto-configures biome.json when no linter detected", async () => {
+		// Project with no linter in dependencies
+		writeFileSync(
+			join(tmpDir, "package.json"),
+			JSON.stringify({ dependencies: {} }),
+		);
+
+		const result = await bootstrap(tmpDir);
+		expect(result.ok).toBe(true);
+		if (result.ok) {
+			const biomePath = join(tmpDir, "biome.json");
+			expect(existsSync(biomePath)).toBe(true);
+
+			const biomeConfig = JSON.parse(readFileSync(biomePath, "utf-8"));
+			expect(biomeConfig.linter.enabled).toBe(true);
+			expect(biomeConfig.linter.rules.recommended).toBe(true);
+			expect(biomeConfig.formatter.enabled).toBe(true);
+
+			expect(result.value.created).toContain("biome.json");
+			expect(result.value.detectedStack.linter).toBe("biome");
+		}
+	});
+
+	test("does not overwrite existing biome.json", async () => {
+		writeFileSync(
+			join(tmpDir, "package.json"),
+			JSON.stringify({ dependencies: {} }),
+		);
+		writeFileSync(join(tmpDir, "biome.json"), '{"custom": true}');
+
+		const result = await bootstrap(tmpDir);
+		expect(result.ok).toBe(true);
+
+		const content = readFileSync(join(tmpDir, "biome.json"), "utf-8");
+		expect(JSON.parse(content)).toEqual({ custom: true });
+	});
+
+	test("skips biome.json when linter already detected", async () => {
+		writeFileSync(
+			join(tmpDir, "package.json"),
+			JSON.stringify({ devDependencies: { eslint: "^9.0.0" } }),
+		);
+
+		const result = await bootstrap(tmpDir);
+		expect(result.ok).toBe(true);
+		if (result.ok) {
+			expect(existsSync(join(tmpDir, "biome.json"))).toBe(false);
+			expect(result.value.detectedStack.linter).toBe("eslint");
+		}
+	});
 });

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", () => {
@@ -35,6 +39,21 @@ describe("LanguageProfile", () => {
 		expect(profile.commentPrefixes).toContain("//");
 	});
 
+	it("should return C# profile", () => {
+		const profile = getProfile("csharp");
+		expect(profile.id).toBe("csharp");
+		expect(profile.extensions).toContain(".cs");
+		expect(profile.syntaxTool).toBe("dotnet-format");
+	});
+
+	it("should return Java profile", () => {
+		const profile = getProfile("java");
+		expect(profile.id).toBe("java");
+		expect(profile.extensions).toContain(".java");
+		expect(profile.extensions).toContain(".kt");
+		expect(profile.syntaxTool).toBe("checkstyle");
+	});
+
 	it("should have test file pattern for each language", () => {
 		expect(TYPESCRIPT_PROFILE.testFilePattern.test("app.test.ts")).toBe(true);
 		expect(getProfile("python").testFilePattern.test("test_app.py")).toBe(true);
@@ -48,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

@@ -2,9 +2,9 @@
  * Language Detection — detects project languages from marker files.
  */
 
-import { existsSync, readFileSync } from "node:fs";
-import { join } from "node:path";
-import type { LanguageId } from "./profile";
+import { existsSync, readdirSync, readFileSync } from "node:fs";
+import { extname, join } from "node:path";
+import { type LanguageId, PROFILES } from "./profile";
 
 const LANGUAGE_MARKERS: Record<LanguageId, string[]> = {
 	typescript: ["tsconfig.json", "tsconfig.build.json"],
@@ -17,6 +17,9 @@ const LANGUAGE_MARKERS: Record<LanguageId, string[]> = {
 	],
 	go: ["go.mod", "go.sum"],
 	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"],
 };
 
 /**
@@ -39,6 +42,18 @@ export function detectLanguages(cwd: string): LanguageId[] {
 		}
 	}
 
+	// C# — check for .sln or .csproj files (names vary)
+	if (!detected.includes("csharp")) {
+		try {
+			const entries = readdirSync(cwd);
+			if (
+				entries.some((e: string) => e.endsWith(".sln") || e.endsWith(".csproj"))
+			) {
+				detected.push("csharp");
+			}
+		} catch {}
+	}
+
 	// Also check package.json for TypeScript dependency
 	if (!detected.includes("typescript")) {
 		const pkgPath = join(cwd, "package.json");
@@ -68,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

@@ -3,7 +3,14 @@
  * file patterns, and slop detection rules.
  */
 
-export type LanguageId = "typescript" | "python" | "go" | "rust";
+export type LanguageId =
+	| "typescript"
+	| "python"
+	| "go"
+	| "rust"
+	| "csharp"
+	| "java"
+	| "php";
 
 export interface LanguageProfile {
 	id: LanguageId;
@@ -94,11 +101,69 @@ export const RUST_PROFILE: LanguageProfile = {
 	fileGlobs: ["*.rs"],
 };
 
-const PROFILES: Record<LanguageId, LanguageProfile> = {
+export const CSHARP_PROFILE: LanguageProfile = {
+	id: "csharp",
+	displayName: "C#",
+	extensions: [".cs"],
+	syntaxTool: "dotnet-format",
+	syntaxArgs: (files, _cwd) => [
+		"dotnet",
+		"format",
+		"--verify-no-changes",
+		"--include",
+		...files,
+	],
+	commentPrefixes: ["//", "/*"],
+	testFilePattern: /(?:Tests?\.cs$|\.Tests?\.|tests\/)/,
+	printPattern: /Console\.Write(?:Line)?\s*\(/,
+	lintIgnorePattern:
+		/#pragma\s+warning\s+disable|\/\/\s*noinspection|\[SuppressMessage/,
+	importPattern: /^using\s+(\S+)/,
+	fileGlobs: ["*.cs"],
+};
+
+export const JAVA_PROFILE: LanguageProfile = {
+	id: "java",
+	displayName: "Java",
+	extensions: [".java", ".kt"],
+	syntaxTool: "checkstyle",
+	syntaxArgs: (files, _cwd) => ["checkstyle", "-f", "xml", ...files],
+	commentPrefixes: ["//", "/*"],
+	testFilePattern: /(?:Test\.java$|Spec\.java$|src\/test\/)/,
+	printPattern: /System\.out\.print(?:ln)?\s*\(/,
+	lintIgnorePattern: /@SuppressWarnings|\/\/\s*NOPMD|\/\/\s*NOSONAR/,
+	importPattern: /^import\s+(\S+)/,
+	fileGlobs: ["*.java", "*.kt"],
+};
+
+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 {