@mainahq/core 0.2.0 → 0.3.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@mainahq/core",
-  "version": "0.2.0",
+  "version": "0.3.0",
   "type": "module",
   "license": "Apache-2.0",
   "description": "Maina core engines — Context, Prompt, and Verify for verification-first development",

package/src/ai/__tests__/delegation.test.ts

@@ -0,0 +1,105 @@
+import { describe, expect, it } from "bun:test";
+import {
+	type DelegationRequest,
+	formatDelegationRequest,
+	parseDelegationRequest,
+} from "../delegation";
+
+describe("formatDelegationRequest", () => {
+	it("should format a request with all fields", () => {
+		const req: DelegationRequest = {
+			task: "ai-review",
+			context: "Reviewing diff for cross-function consistency",
+			prompt: "Review this diff:\n+const x = 1;",
+			expectedFormat: "json",
+			schema: '{"findings":[]}',
+		};
+
+		const formatted = formatDelegationRequest(req);
+
+		expect(formatted).toContain("---MAINA_AI_REQUEST---");
+		expect(formatted).toContain("---END_MAINA_AI_REQUEST---");
+		expect(formatted).toContain("task: ai-review");
+		expect(formatted).toContain("context: Reviewing diff");
+		expect(formatted).toContain("expected_format: json");
+		expect(formatted).toContain("schema: ");
+		expect(formatted).toContain("prompt: |");
+		expect(formatted).toContain("  Review this diff:");
+	});
+
+	it("should format without optional schema", () => {
+		const req: DelegationRequest = {
+			task: "commit-msg",
+			context: "Generate commit message",
+			prompt: "Generate a commit message for these changes",
+			expectedFormat: "text",
+		};
+
+		const formatted = formatDelegationRequest(req);
+		expect(formatted).not.toContain("schema:");
+	});
+});
+
+describe("parseDelegationRequest", () => {
+	it("should parse a formatted request back", () => {
+		const original: DelegationRequest = {
+			task: "ai-review",
+			context: "Reviewing diff",
+			prompt: "Review this diff:\n+const x = 1;",
+			expectedFormat: "json",
+			schema: '{"findings":[]}',
+		};
+
+		const formatted = formatDelegationRequest(original);
+		const parsed = parseDelegationRequest(formatted);
+
+		expect(parsed).not.toBeNull();
+		expect(parsed?.task).toBe("ai-review");
+		expect(parsed?.context).toBe("Reviewing diff");
+		expect(parsed?.expectedFormat).toBe("json");
+		expect(parsed?.schema).toBe('{"findings":[]}');
+		expect(parsed?.prompt).toContain("Review this diff:");
+		expect(parsed?.prompt).toContain("+const x = 1;");
+	});
+
+	it("should return null for text without markers", () => {
+		expect(parseDelegationRequest("no markers here")).toBeNull();
+	});
+
+	it("should return null for empty task", () => {
+		const text =
+			"---MAINA_AI_REQUEST---\ncontext: test\n---END_MAINA_AI_REQUEST---";
+		expect(parseDelegationRequest(text)).toBeNull();
+	});
+
+	it("should handle multiline prompts", () => {
+		const req: DelegationRequest = {
+			task: "review",
+			context: "Code review",
+			prompt: "Line 1\nLine 2\nLine 3",
+			expectedFormat: "markdown",
+		};
+
+		const formatted = formatDelegationRequest(req);
+		const parsed = parseDelegationRequest(formatted);
+
+		expect(parsed?.prompt).toContain("Line 1");
+		expect(parsed?.prompt).toContain("Line 2");
+		expect(parsed?.prompt).toContain("Line 3");
+	});
+
+	it("should parse request embedded in other text", () => {
+		const text = `Some output before
+---MAINA_AI_REQUEST---
+task: test
+context: testing
+prompt: |
+  hello
+---END_MAINA_AI_REQUEST---
+Some output after`;
+
+		const parsed = parseDelegationRequest(text);
+		expect(parsed?.task).toBe("test");
+		expect(parsed?.prompt).toBe("hello");
+	});
+});

package/src/ai/delegation.ts

@@ -0,0 +1,111 @@
+/**
+ * AI Delegation Protocol — structured stdout protocol for host agents.
+ *
+ * When maina runs inside Claude Code/Codex/OpenCode without an API key,
+ * AI-dependent steps output request blocks that the host agent can
+ * parse and process with its own AI.
+ */
+
+// ─── Types ────────────────────────────────────────────────────────────────
+
+export interface DelegationRequest {
+	task: string;
+	context: string;
+	prompt: string;
+	expectedFormat: "json" | "markdown" | "text";
+	schema?: string;
+}
+
+// ─── Constants ────────────────────────────────────────────────────────────
+
+const START_MARKER = "---MAINA_AI_REQUEST---";
+const END_MARKER = "---END_MAINA_AI_REQUEST---";
+
+// ─── Format ───────────────────────────────────────────────────────────────
+
+/**
+ * Format a delegation request as a structured text block.
+ * This block is output to stdout for host agents to parse.
+ */
+export function formatDelegationRequest(req: DelegationRequest): string {
+	const lines: string[] = [START_MARKER];
+	lines.push(`task: ${req.task}`);
+	lines.push(`context: ${req.context}`);
+	lines.push(`expected_format: ${req.expectedFormat}`);
+	if (req.schema) {
+		lines.push(`schema: ${req.schema}`);
+	}
+	lines.push("prompt: |");
+	// Indent prompt lines by 2 spaces (YAML-style block scalar)
+	for (const line of req.prompt.split("\n")) {
+		lines.push(`  ${line}`);
+	}
+	lines.push(END_MARKER);
+	return lines.join("\n");
+}
+
+// ─── Parse ────────────────────────────────────────────────────────────────
+
+/**
+ * Parse a delegation request block from text.
+ * Returns null if the text doesn't contain a valid request block.
+ */
+export function parseDelegationRequest(text: string): DelegationRequest | null {
+	const startIdx = text.indexOf(START_MARKER);
+	const endIdx = text.indexOf(END_MARKER);
+	if (startIdx === -1 || endIdx === -1 || endIdx <= startIdx) {
+		return null;
+	}
+
+	const block = text.slice(startIdx + START_MARKER.length, endIdx).trim();
+	const lines = block.split("\n");
+
+	let task = "";
+	let context = "";
+	let expectedFormat: DelegationRequest["expectedFormat"] = "text";
+	let schema: string | undefined;
+	const promptLines: string[] = [];
+	let inPrompt = false;
+
+	for (const line of lines) {
+		if (inPrompt) {
+			// Prompt lines are indented by 2 spaces
+			promptLines.push(line.startsWith("  ") ? line.slice(2) : line);
+			continue;
+		}
+
+		if (line.startsWith("task: ")) {
+			task = line.slice(6).trim();
+		} else if (line.startsWith("context: ")) {
+			context = line.slice(9).trim();
+		} else if (line.startsWith("expected_format: ")) {
+			const fmt = line.slice(17).trim();
+			if (fmt === "json" || fmt === "markdown" || fmt === "text") {
+				expectedFormat = fmt;
+			}
+		} else if (line.startsWith("schema: ")) {
+			schema = line.slice(8).trim();
+		} else if (line.startsWith("prompt: |")) {
+			inPrompt = true;
+		}
+	}
+
+	if (!task) return null;
+
+	return {
+		task,
+		context,
+		prompt: promptLines.join("\n").trim(),
+		expectedFormat,
+		schema,
+	};
+}
+
+/**
+ * Output a delegation request to stdout.
+ * Used by tryAIGenerate when in host mode.
+ */
+export function outputDelegationRequest(req: DelegationRequest): void {
+	const formatted = formatDelegationRequest(req);
+	process.stdout.write(`\n${formatted}\n`);
+}

package/src/ai/try-generate.ts

@@ -1,4 +1,5 @@
 import { getApiKey, isHostMode } from "../config/index";
+import { outputDelegationRequest } from "./delegation";
 
 export interface DelegationPrompt {
 	task: string;
@@ -69,6 +70,22 @@ export async function tryAIGenerate(
 			}
 		}
 
+		// Output structured request for host agent to process
+		outputDelegationRequest({
+			task,
+			context: `AI ${task} requested — process with host AI`,
+			prompt: userPrompt,
+			expectedFormat:
+				task === "commit"
+					? "text"
+					: task.includes("review")
+						? "json"
+						: "markdown",
+			schema: task.includes("review")
+				? '{"findings":[{"file":"path","line":42,"message":"desc","severity":"warning"}]}'
+				: undefined,
+		});
+
 		// Host mode — return structured delegation for host agent to process
 		return {
 			text: null,

package/src/context/relevance.ts

@@ -47,6 +47,11 @@ function resolveImportPath(
 		// Rust
 		`${base}.rs`,
 		`${base}/mod.rs`,
+		// C#
+		`${base}.cs`,
+		// Java
+		`${base}.java`,
+		`${base}.kt`,
 	];
 
 	for (const candidate of candidates) {

package/src/context/retrieval.ts

@@ -236,6 +236,9 @@ export async function searchWithGrep(
 				"--include=*.py",
 				"--include=*.go",
 				"--include=*.rs",
+				"--include=*.cs",
+				"--include=*.java",
+				"--include=*.kt",
 				"--exclude-dir=node_modules",
 				"--exclude-dir=dist",
 				"--exclude-dir=.git",

package/src/context/semantic.ts

@@ -31,6 +31,9 @@ const SOURCE_EXTENSIONS = new Set([
 	".pyi",
 	".go",
 	".rs",
+	".cs",
+	".java",
+	".kt",
 ]);
 
 /**

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,
@@ -171,9 +178,11 @@ export {
 	getPrimaryLanguage,
 } from "./language/detect";
 export {
+	CSHARP_PROFILE,
 	GO_PROFILE,
 	getProfile,
 	getSupportedLanguages,
+	JAVA_PROFILE,
 	type LanguageId,
 	type LanguageProfile,
 	PYTHON_PROFILE,

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

@@ -35,6 +35,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);

package/src/language/detect.ts

@@ -2,7 +2,7 @@
  * Language Detection — detects project languages from marker files.
  */
 
-import { existsSync, readFileSync } from "node:fs";
+import { existsSync, readdirSync, readFileSync } from "node:fs";
 import { join } from "node:path";
 import type { LanguageId } from "./profile";
 
@@ -17,6 +17,8 @@ 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"],
 };
 
 /**
@@ -39,6 +41,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");

package/src/language/profile.ts

@@ -3,7 +3,13 @@
  * file patterns, and slop detection rules.
  */
 
-export type LanguageId = "typescript" | "python" | "go" | "rust";
+export type LanguageId =
+	| "typescript"
+	| "python"
+	| "go"
+	| "rust"
+	| "csharp"
+	| "java";
 
 export interface LanguageProfile {
 	id: LanguageId;
@@ -94,11 +100,48 @@ export const RUST_PROFILE: LanguageProfile = {
 	fileGlobs: ["*.rs"],
 };
 
+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"],
+};
+
 const PROFILES: Record<LanguageId, LanguageProfile> = {
 	typescript: TYPESCRIPT_PROFILE,
 	python: PYTHON_PROFILE,
 	go: GO_PROFILE,
 	rust: RUST_PROFILE,
+	csharp: CSHARP_PROFILE,
+	java: JAVA_PROFILE,
 };
 
 export function getProfile(id: LanguageId): LanguageProfile {

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/detect.ts

@@ -22,7 +22,11 @@ export type ToolName =
 	| "golangci-lint"
 	| "cargo-clippy"
 	| "cargo-audit"
-	| "playwright";
+	| "playwright"
+	| "dotnet-format"
+	| "checkstyle"
+	| "spotbugs"
+	| "pmd";
 
 export interface DetectedTool {
 	name: string;
@@ -47,6 +51,10 @@ export const TOOL_REGISTRY: Record<
 	"cargo-clippy": { command: "cargo", versionFlag: "clippy --version" },
 	"cargo-audit": { command: "cargo-audit", versionFlag: "--version" },
 	playwright: { command: "npx", versionFlag: "playwright --version" },
+	"dotnet-format": { command: "dotnet", versionFlag: "format --version" },
+	checkstyle: { command: "checkstyle", versionFlag: "--version" },
+	spotbugs: { command: "spotbugs", versionFlag: "-version" },
+	pmd: { command: "pmd", versionFlag: "--version" },
 };
 
 /**

package/src/verify/linters/checkstyle.ts

@@ -0,0 +1,41 @@
+/**
+ * Checkstyle output parser for Java linting.
+ * Parses Checkstyle XML output.
+ */
+
+import type { SyntaxDiagnostic } from "../syntax-guard";
+
+/**
+ * Parse Checkstyle XML output into SyntaxDiagnostic[].
+ */
+export function parseCheckstyleOutput(xml: string): SyntaxDiagnostic[] {
+	const diagnostics: SyntaxDiagnostic[] = [];
+
+	// Simple XML parsing — extract <error> elements
+	// Format: <file name="path"><error line="10" column="5" severity="error" message="desc" source="rule"/></file>
+	const filePattern = /<file\s+name="([^"]+)">([\s\S]*?)<\/file>/g;
+	const errorPattern =
+		/<error\s+line="(\d+)"\s+(?:column="(\d+)"\s+)?severity="(\w+)"\s+message="([^"]+)"/g;
+
+	for (const fileMatch of xml.matchAll(filePattern)) {
+		const filePath = fileMatch[1] ?? "";
+		const fileContent = fileMatch[2] ?? "";
+
+		for (const errorMatch of fileContent.matchAll(errorPattern)) {
+			const line = Number.parseInt(errorMatch[1] ?? "0", 10);
+			const column = Number.parseInt(errorMatch[2] ?? "0", 10);
+			const severity = errorMatch[3] ?? "warning";
+			const message = errorMatch[4] ?? "";
+
+			diagnostics.push({
+				file: filePath,
+				line,
+				column,
+				message,
+				severity: severity === "error" ? "error" : "warning",
+			});
+		}
+	}
+
+	return diagnostics;
+}

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

@@ -0,0 +1,37 @@
+/**
+ * dotnet format output parser for C# linting.
+ * Parses `dotnet format --verify-no-changes` output.
+ */
+
+import type { SyntaxDiagnostic } from "../syntax-guard";
+
+/**
+ * Parse dotnet format text output into SyntaxDiagnostic[].
+ * dotnet format outputs: "path/file.cs(line,col): severity CODE: message"
+ */
+export function parseDotnetFormatOutput(output: string): SyntaxDiagnostic[] {
+	const diagnostics: SyntaxDiagnostic[] = [];
+	const lines = output.split("\n");
+
+	for (const line of lines) {
+		if (!line.trim()) continue;
+		// Format: file.cs(line,col): warning CS1234: message
+		const match = line.match(
+			/^(.+?)\((\d+),(\d+)\):\s*(error|warning)\s+(\w+):\s*(.+)$/,
+		);
+		if (!match) continue;
+
+		const [, file, lineStr, colStr, severity, _code, message] = match;
+		if (!file || !lineStr || !message) continue;
+
+		diagnostics.push({
+			file,
+			line: Number.parseInt(lineStr, 10),
+			column: Number.parseInt(colStr ?? "0", 10),
+			message,
+			severity: severity === "error" ? "error" : "warning",
+		});
+	}
+
+	return diagnostics;
+}

package/src/verify/syntax-guard.ts

@@ -13,7 +13,9 @@ import { join } from "node:path";
 import type { Result } from "../db/index";
 import type { LanguageProfile } from "../language/profile";
 import { TYPESCRIPT_PROFILE } from "../language/profile";
+import { parseCheckstyleOutput } from "./linters/checkstyle";
 import { parseClippyOutput } from "./linters/clippy";
+import { parseDotnetFormatOutput } from "./linters/dotnet-format";
 import { parseGoVetOutput } from "./linters/go-vet";
 import { parseRuffOutput } from "./linters/ruff";
 
@@ -225,6 +227,12 @@ async function runLanguageLinter(
 			case "rust":
 				diagnostics = parseClippyOutput(stdout);
 				break;
+			case "csharp":
+				diagnostics = parseDotnetFormatOutput(stdout);
+				break;
+			case "java":
+				diagnostics = parseCheckstyleOutput(stdout);
+				break;
 		}
 
 		const errors = diagnostics.filter((d) => d.severity === "error");