@mainahq/core 0.7.0 → 1.0.1

package/src/init/index.ts

@@ -6,7 +6,13 @@
  * Never overwrites existing files unless `force: true`.
  */
 
-import { existsSync, mkdirSync, readFileSync, writeFileSync } from "node:fs";
+import {
+	existsSync,
+	mkdirSync,
+	readdirSync,
+	readFileSync,
+	writeFileSync,
+} from "node:fs";
 import { join } from "node:path";
 import type { Result } from "../db/index";
 import type { DetectedTool } from "../verify/detect";
@@ -16,6 +22,7 @@ import { detectTools } from "../verify/detect";
 
 export interface InitOptions {
 	force?: boolean;
+	aiGenerate?: boolean;
 }
 
 export interface InitReport {
@@ -24,11 +31,13 @@ export interface InitReport {
 	directory: string;
 	detectedStack: DetectedStack;
 	detectedTools: DetectedTool[];
+	aiGenerated?: boolean;
 }
 
 export interface DetectedStack {
 	runtime: "bun" | "node" | "deno" | "unknown";
 	language: "typescript" | "javascript" | "unknown";
+	languages: string[];
 	testRunner: string;
 	linter: string;
 	framework: string;
@@ -40,89 +49,168 @@ function detectStack(repoRoot: string): DetectedStack {
 	const stack: DetectedStack = {
 		runtime: "unknown",
 		language: "unknown",
+		languages: [],
 		testRunner: "unknown",
 		linter: "unknown",
 		framework: "none",
 	};
 
-	// Try reading package.json
-	const pkgPath = join(repoRoot, "package.json");
-	if (!existsSync(pkgPath)) return stack;
+	// ── Multi-language detection (file-marker based) ─────────────────────
+	const languages: string[] = [];
 
-	let pkg: Record<string, unknown>;
-	try {
-		pkg = JSON.parse(readFileSync(pkgPath, "utf-8"));
-	} catch {
-		return stack;
+	// Go
+	if (existsSync(join(repoRoot, "go.mod"))) {
+		languages.push("go");
 	}
 
-	const allDeps = {
-		...(pkg.dependencies as Record<string, string> | undefined),
-		...(pkg.devDependencies as Record<string, string> | undefined),
-		...(pkg.peerDependencies as Record<string, string> | undefined),
-	};
+	// Rust
+	if (existsSync(join(repoRoot, "Cargo.toml"))) {
+		languages.push("rust");
+	}
 
-	// Runtime detection
+	// Python
 	if (
-		allDeps["@types/bun"] ||
-		allDeps["bun-types"] ||
-		existsSync(join(repoRoot, "bun.lock"))
+		existsSync(join(repoRoot, "pyproject.toml")) ||
+		existsSync(join(repoRoot, "requirements.txt")) ||
+		existsSync(join(repoRoot, "setup.py"))
 	) {
-		stack.runtime = "bun";
-	} else if (
-		existsSync(join(repoRoot, "deno.json")) ||
-		existsSync(join(repoRoot, "deno.jsonc"))
-	) {
-		stack.runtime = "deno";
-	} else {
-		stack.runtime = "node";
+		languages.push("python");
 	}
 
-	// Language detection
-	if (existsSync(join(repoRoot, "tsconfig.json")) || allDeps.typescript) {
-		stack.language = "typescript";
-	} else {
-		stack.language = "javascript";
+	// Java
+	if (
+		existsSync(join(repoRoot, "pom.xml")) ||
+		existsSync(join(repoRoot, "build.gradle")) ||
+		existsSync(join(repoRoot, "build.gradle.kts"))
+	) {
+		languages.push("java");
 	}
 
-	// Test runner detection
-	if (stack.runtime === "bun") {
-		stack.testRunner = "bun:test";
-	} else if (allDeps.vitest) {
-		stack.testRunner = "vitest";
-	} else if (allDeps.jest || allDeps["@jest/core"]) {
-		stack.testRunner = "jest";
-	} else if (allDeps.mocha) {
-		stack.testRunner = "mocha";
+	// .NET (C#/F#) — check for .csproj, .fsproj, .sln files
+	try {
+		const entries = readdirSync(repoRoot);
+		if (
+			entries.some(
+				(e: string) =>
+					e.endsWith(".csproj") || e.endsWith(".sln") || e.endsWith(".fsproj"),
+			)
+		) {
+			languages.push("dotnet");
+		}
+	} catch {
+		// Directory not readable — skip
 	}
 
-	// Linter detection
-	if (allDeps["@biomejs/biome"]) {
-		stack.linter = "biome";
-	} else if (allDeps.eslint) {
-		stack.linter = "eslint";
-	} else if (allDeps.prettier) {
-		stack.linter = "prettier";
+	// ── JS/TS detection from package.json ───────────────────────────────
+	const pkgPath = join(repoRoot, "package.json");
+	let hasPkgJson = false;
+	let allDeps: Record<string, string> = {};
+
+	if (existsSync(pkgPath)) {
+		try {
+			const pkg = JSON.parse(readFileSync(pkgPath, "utf-8")) as Record<
+				string,
+				unknown
+			>;
+			hasPkgJson = true;
+			allDeps = {
+				...(pkg.dependencies as Record<string, string> | undefined),
+				...(pkg.devDependencies as Record<string, string> | undefined),
+				...(pkg.peerDependencies as Record<string, string> | undefined),
+			};
+		} catch {
+			// Malformed package.json — skip
+		}
 	}
 
-	// Framework detection
-	if (allDeps.next) {
-		stack.framework = "next.js";
-	} else if (allDeps.express) {
-		stack.framework = "express";
-	} else if (allDeps.hono) {
-		stack.framework = "hono";
-	} else if (allDeps.react && !allDeps.next) {
-		stack.framework = "react";
-	} else if (allDeps.vue) {
-		stack.framework = "vue";
-	} else if (allDeps.svelte) {
-		stack.framework = "svelte";
+	if (hasPkgJson) {
+		// Runtime detection
+		if (
+			allDeps["@types/bun"] ||
+			allDeps["bun-types"] ||
+			existsSync(join(repoRoot, "bun.lock"))
+		) {
+			stack.runtime = "bun";
+		} else if (
+			existsSync(join(repoRoot, "deno.json")) ||
+			existsSync(join(repoRoot, "deno.jsonc"))
+		) {
+			stack.runtime = "deno";
+		} else {
+			stack.runtime = "node";
+		}
+
+		// Language detection (single primary)
+		if (existsSync(join(repoRoot, "tsconfig.json")) || allDeps.typescript) {
+			stack.language = "typescript";
+			if (!languages.includes("typescript")) {
+				languages.push("typescript");
+			}
+		} else {
+			stack.language = "javascript";
+			if (!languages.includes("javascript")) {
+				languages.push("javascript");
+			}
+		}
+
+		// Test runner detection
+		if (stack.runtime === "bun") {
+			stack.testRunner = "bun:test";
+		} else if (allDeps.vitest) {
+			stack.testRunner = "vitest";
+		} else if (allDeps.jest || allDeps["@jest/core"]) {
+			stack.testRunner = "jest";
+		} else if (allDeps.mocha) {
+			stack.testRunner = "mocha";
+		}
+
+		// Linter detection
+		if (allDeps["@biomejs/biome"]) {
+			stack.linter = "biome";
+		} else if (allDeps.eslint) {
+			stack.linter = "eslint";
+		} else if (allDeps.prettier) {
+			stack.linter = "prettier";
+		}
+
+		// Framework detection
+		if (allDeps.next) {
+			stack.framework = "next.js";
+		} else if (allDeps.express) {
+			stack.framework = "express";
+		} else if (allDeps.hono) {
+			stack.framework = "hono";
+		} else if (allDeps.react && !allDeps.next) {
+			stack.framework = "react";
+		} else if (allDeps.vue) {
+			stack.framework = "vue";
+		} else if (allDeps.svelte) {
+			stack.framework = "svelte";
+		}
 	}
 
+	// If no languages detected, mark as unknown
+	stack.languages = languages.length > 0 ? languages : ["unknown"];
+
 	return stack;
 }
 
+// ── Constants (shared across agent files) ───────────────────────────────────
+
+const WORKFLOW_ORDER =
+	"brainstorm -> ticket -> plan -> design -> spec -> implement -> verify -> review -> fix -> commit -> review -> pr";
+
+const MCP_TOOLS_TABLE = `| Tool | When to use |
+|------|-------------|
+| \`getContext\` | Before starting — understand branch state and verification status |
+| \`verify\` | After changes — run the full verification pipeline |
+| \`checkSlop\` | On changed files — detect AI-generated slop patterns |
+| \`reviewCode\` | On your diff — two-stage review (spec compliance + code quality) |
+| \`suggestTests\` | When implementing — generate TDD test stubs |
+| \`getConventions\` | Understand project coding conventions |
+| \`explainModule\` | Understand a module's purpose and dependencies |
+| \`analyzeFeature\` | Analyze a feature directory for consistency |`;
+
 // ── Templates ────────────────────────────────────────────────────────────────
 
 function buildConstitution(stack: DetectedStack): string {
@@ -177,7 +265,12 @@ function buildAgentsMd(stack: DetectedStack): string {
 
 	return `# AGENTS.md
 
-This repo uses [Maina](https://github.com/beeeku/maina) for verification-first development.
+This repo uses [Maina](https://github.com/mainahq/maina) for verification-first development.
+
+## Workflow Order
+
+Follow this order for every feature:
+\`${WORKFLOW_ORDER}\`
 
 ## Quick Start
 \`\`\`bash
@@ -199,12 +292,20 @@ maina commit    # verify + commit
 | \`maina stats\` | Show verification metrics |
 | \`maina doctor\` | Check tool health |
 
+## MCP Tools
+
+${MCP_TOOLS_TABLE}
+
 ## Config Files
 | File | Purpose | Who Edits |
 |------|---------|-----------|
 | \`.maina/constitution.md\` | Project DNA — stack, rules, gates | Team (stable, rarely changes) |
 | \`AGENTS.md\` | Agent instructions — commands, conventions | Team |
+| \`.github/copilot-instructions.md\` | Copilot agent instructions + MCP tools | Team |
 | \`CLAUDE.md\` | Claude Code specific instructions | Optional, Claude Code users |
+| \`GEMINI.md\` | Gemini CLI specific instructions | Optional, Gemini CLI users |
+| \`.cursorrules\` | Cursor specific instructions | Optional, Cursor users |
+| \`.mcp.json\` | MCP server configuration | Team |
 | \`.maina/prompts/*.md\` | Prompt overrides for review/commit/etc | Maina (via \`maina learn\`) |
 
 ## Runtime
@@ -213,6 +314,279 @@ maina commit    # verify + commit
 `;
 }
 
+function buildCopilotInstructions(stack: DetectedStack): string {
+	const runCmd = stack.runtime === "bun" ? "bun" : "npm";
+	return `# Copilot Instructions
+
+You are working on a codebase verified by [Maina](https://mainahq.com), the verification-first developer OS. Maina MCP tools are available — use them.
+
+## Workflow Order
+
+Follow this order for every feature:
+\`${WORKFLOW_ORDER}\`
+
+## Step-by-step
+
+1. **Get context** — call \`maina getContext\` to understand codebase state
+2. **Write tests first** — TDD always. Write failing tests, then implement
+3. **Verify your work** — call \`maina verify\` before requesting review
+4. **Check for slop** — call \`maina checkSlop\` on changed files
+5. **Review your code** — call \`maina reviewCode\` with your diff
+
+## Available MCP Tools
+
+${MCP_TOOLS_TABLE}
+
+## Conventions
+
+- Runtime: ${stack.runtime}
+- Test: \`${runCmd} test\`
+- Commits: conventional commits (feat, fix, refactor, test, docs, chore)
+- No \`console.log\` in production code
+- Diff-only: only fix issues on changed lines
+
+## When Working on Audit Issues
+
+Issues labeled \`audit\` come from maina's daily verification. Fix the specific findings listed — don't refactor unrelated code.
+`;
+}
+
+// ── .mcp.json ───────────────────────────────────────────────────────────────
+
+function buildMcpJson(): string {
+	return JSON.stringify(
+		{
+			mcpServers: {
+				maina: {
+					command: "maina",
+					args: ["--mcp"],
+				},
+			},
+		},
+		null,
+		2,
+	);
+}
+
+// ── Agent Instruction Files ─────────────────────────────────────────────────
+
+function buildClaudeMd(stack: DetectedStack): string {
+	const runCmd = stack.runtime === "bun" ? "bun" : "npm";
+	return `# CLAUDE.md
+
+This repo uses [Maina](https://mainahq.com) for verification-first development.
+Read \`.maina/constitution.md\` for project DNA — stack rules, conventions, and gates.
+
+## Maina Workflow
+
+Follow this order for every feature:
+\`${WORKFLOW_ORDER}\`
+
+## MCP Tools
+
+Maina exposes MCP tools — use them in every session:
+
+${MCP_TOOLS_TABLE}
+
+## Commands
+
+\`\`\`bash
+maina verify    # run full verification pipeline
+maina commit    # verify + commit
+maina review    # two-stage code review
+maina context   # generate focused codebase context
+maina doctor    # check tool health
+maina plan      # create feature with spec/plan/tasks
+maina stats     # show verification metrics
+\`\`\`
+
+## Conventions
+
+- Runtime: ${stack.runtime}
+- Test: \`${runCmd} test\`
+- Conventional commits (feat, fix, refactor, test, docs, chore)
+- No \`console.log\` in production code
+- Diff-only: only fix issues on changed lines
+- TDD always — write tests first
+`;
+}
+
+function buildGeminiMd(stack: DetectedStack): string {
+	const runCmd = stack.runtime === "bun" ? "bun" : "npm";
+	return `# GEMINI.md
+
+Instructions for Gemini CLI when working in this repository.
+
+This repo uses [Maina](https://mainahq.com) for verification-first development.
+Read \`.maina/constitution.md\` for project DNA — stack rules, conventions, and gates.
+
+## Maina Workflow
+
+Follow this order for every feature:
+\`${WORKFLOW_ORDER}\`
+
+## MCP Tools
+
+Maina exposes MCP tools via \`.mcp.json\`. Use them:
+
+${MCP_TOOLS_TABLE}
+
+## Key Commands
+
+- \`maina verify\` — run full verification pipeline
+- \`maina commit\` — verify + commit
+- \`maina review\` — two-stage code review
+- \`maina context\` — generate focused codebase context
+- \`maina doctor\` — check tool health
+
+## Rules
+
+- Runtime: ${stack.runtime}
+- Test: \`${runCmd} test\`
+- Conventional commits (feat, fix, refactor, test, docs, chore)
+- No \`console.log\` in production code
+- Diff-only: only report findings on changed lines
+- TDD always — write tests first
+`;
+}
+
+function buildCursorRules(stack: DetectedStack): string {
+	const runCmd = stack.runtime === "bun" ? "bun" : "npm";
+	return `# Cursor Rules
+
+This repo uses Maina for verification-first development.
+Read \`.maina/constitution.md\` for project DNA.
+
+## Workflow Order
+${WORKFLOW_ORDER}
+
+## MCP Tools (via .mcp.json)
+${MCP_TOOLS_TABLE}
+
+## Commands
+- maina verify — run full verification pipeline
+- maina commit — verify + commit
+- maina review — two-stage code review
+- maina context — generate focused codebase context
+
+## Conventions
+- Runtime: ${stack.runtime}
+- Test: ${runCmd} test
+- Conventional commits
+- No console.log in production
+- Diff-only: only report findings on changed lines
+- TDD: write tests first, then implement
+`;
+}
+
+// ── AI-Generated Constitution ───────────────────────────────────────────────
+
+function buildProjectSummary(repoRoot: string, stack: DetectedStack): string {
+	const parts: string[] = [];
+	parts.push("## Detected Project Stack");
+	parts.push(`- Runtime: ${stack.runtime}`);
+	parts.push(`- Primary language: ${stack.language}`);
+	parts.push(`- All languages: ${stack.languages.join(", ")}`);
+	parts.push(`- Test runner: ${stack.testRunner}`);
+	parts.push(`- Linter: ${stack.linter}`);
+	parts.push(`- Framework: ${stack.framework}`);
+
+	// Read package.json for extra context
+	const pkgPath = join(repoRoot, "package.json");
+	if (existsSync(pkgPath)) {
+		try {
+			const pkg = JSON.parse(readFileSync(pkgPath, "utf-8")) as Record<
+				string,
+				unknown
+			>;
+			const deps = Object.keys(
+				(pkg.dependencies as Record<string, string>) ?? {},
+			);
+			const devDeps = Object.keys(
+				(pkg.devDependencies as Record<string, string>) ?? {},
+			);
+			if (deps.length > 0) {
+				parts.push(`\n## Dependencies\n${deps.join(", ")}`);
+			}
+			if (devDeps.length > 0) {
+				parts.push(`\n## Dev Dependencies\n${devDeps.join(", ")}`);
+			}
+			if (pkg.description) {
+				parts.push(`\n## Project Description\n${pkg.description}`);
+			}
+		} catch {
+			// Ignore parse errors
+		}
+	}
+
+	// Check for common config files
+	const configFiles: string[] = [];
+	const checks = [
+		"tsconfig.json",
+		"biome.json",
+		".eslintrc.json",
+		"jest.config.ts",
+		"vitest.config.ts",
+		"Dockerfile",
+		"docker-compose.yml",
+		".env.example",
+		"Makefile",
+	];
+	for (const f of checks) {
+		if (existsSync(join(repoRoot, f))) {
+			configFiles.push(f);
+		}
+	}
+	if (configFiles.length > 0) {
+		parts.push(`\n## Config Files Found\n${configFiles.join(", ")}`);
+	}
+
+	return parts.join("\n");
+}
+
+async function tryGenerateConstitution(
+	repoRoot: string,
+	stack: DetectedStack,
+): Promise<string | null> {
+	try {
+		const { tryAIGenerate } = await import("../ai/try-generate");
+		const mainaDir = join(repoRoot, ".maina");
+		const summary = buildProjectSummary(repoRoot, stack);
+
+		const result = await tryAIGenerate(
+			"init-constitution",
+			mainaDir,
+			{
+				stack_runtime: stack.runtime,
+				stack_language: stack.language,
+				stack_languages: stack.languages.join(", "),
+				stack_testRunner: stack.testRunner,
+				stack_linter: stack.linter,
+				stack_framework: stack.framework,
+			},
+			`Generate a project constitution for this software project based on the detected stack information below.
+
+A constitution defines non-negotiable rules injected into every AI call. It should include:
+1. Stack section — runtime, language, linter, test runner, framework
+2. Architecture section — key architectural constraints (infer from the stack)
+3. Verification section — what must pass before code merges
+4. Conventions section — coding conventions (infer from the stack)
+
+Replace [NEEDS CLARIFICATION] placeholders with reasonable defaults based on the stack.
+Keep it concise (under 50 lines). Use markdown format starting with "# Project Constitution".
+
+${summary}`,
+		);
+
+		if (result.fromAI && result.text) {
+			return result.text;
+		}
+	} catch {
+		// AI unavailable — fall back to static template
+	}
+	return null;
+}
+
 const REVIEW_PROMPT_TEMPLATE = `# Review Prompt
 
 Review the following code changes for:
@@ -266,11 +640,14 @@ interface FileEntry {
 	content: string;
 }
 
-function getFileManifest(stack: DetectedStack): FileEntry[] {
+function getFileManifest(
+	stack: DetectedStack,
+	constitutionOverride?: string,
+): FileEntry[] {
 	return [
 		{
 			relativePath: ".maina/constitution.md",
-			content: buildConstitution(stack),
+			content: constitutionOverride ?? buildConstitution(stack),
 		},
 		{
 			relativePath: ".maina/prompts/review.md",
@@ -288,6 +665,26 @@ function getFileManifest(stack: DetectedStack): FileEntry[] {
 			relativePath: ".github/workflows/maina-ci.yml",
 			content: buildCiWorkflow(stack),
 		},
+		{
+			relativePath: ".github/copilot-instructions.md",
+			content: buildCopilotInstructions(stack),
+		},
+		{
+			relativePath: ".mcp.json",
+			content: buildMcpJson(),
+		},
+		{
+			relativePath: "CLAUDE.md",
+			content: buildClaudeMd(stack),
+		},
+		{
+			relativePath: "GEMINI.md",
+			content: buildGeminiMd(stack),
+		},
+		{
+			relativePath: ".cursorrules",
+			content: buildCursorRules(stack),
+		},
 	];
 }
 
@@ -341,6 +738,7 @@ export async function bootstrap(
 	options?: InitOptions,
 ): Promise<Result<InitReport>> {
 	const force = options?.force ?? false;
+	const aiGenerate = options?.aiGenerate ?? false;
 	const mainaDir = join(repoRoot, ".maina");
 	const created: string[] = [];
 	const skipped: string[] = [];
@@ -349,8 +747,8 @@ export async function bootstrap(
 		// Detect project stack from package.json
 		const detectedStack = detectStack(repoRoot);
 
-		// Detect available verification tools on PATH
-		const detectedToolsList = await detectTools();
+		// Detect available verification tools on PATH (filtered by project languages)
+		const detectedToolsList = await detectTools(detectedStack.languages);
 
 		// Ensure .maina/ exists
 		mkdirSync(mainaDir, { recursive: true });
@@ -360,8 +758,22 @@ export async function bootstrap(
 			mkdirSync(join(repoRoot, dir), { recursive: true });
 		}
 
+		// Try AI-generated constitution when requested
+		let constitutionOverride: string | undefined;
+		let aiGenerated = false;
+		if (aiGenerate) {
+			const aiConstitution = await tryGenerateConstitution(
+				repoRoot,
+				detectedStack,
+			);
+			if (aiConstitution) {
+				constitutionOverride = aiConstitution;
+				aiGenerated = true;
+			}
+		}
+
 		// Scaffold each file with stack-aware templates
-		const manifest = getFileManifest(detectedStack);
+		const manifest = getFileManifest(detectedStack, constitutionOverride);
 		for (const entry of manifest) {
 			const fullPath = join(repoRoot, entry.relativePath);
 			const dirPath = join(fullPath, "..");
@@ -396,6 +808,7 @@ export async function bootstrap(
 				directory: mainaDir,
 				detectedStack,
 				detectedTools: detectedToolsList,
+				aiGenerated,
 			},
 		};
 	} catch (e) {