@mainahq/core 1.0.0 → 1.0.2

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,14 +31,24 @@ 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;
+	/** package.json scripts (e.g. { test: "vitest", build: "tsc" }) */
+	scripts: Record<string, string>;
+	/** Build tool detected (e.g. "vite", "webpack", "tsup", "bunup", "esbuild") */
+	buildTool: string;
+	/** Whether this is a monorepo (workspaces detected) */
+	monorepo: boolean;
+	/** Inferred conventions from project context */
+	conventions: string[];
 }
 
 // ── Project Detection ───────────────────────────────────────────────────────
@@ -40,89 +57,282 @@ function detectStack(repoRoot: string): DetectedStack {
 	const stack: DetectedStack = {
 		runtime: "unknown",
 		language: "unknown",
+		languages: [],
 		testRunner: "unknown",
 		linter: "unknown",
 		framework: "none",
+		scripts: {},
+		buildTool: "unknown",
+		monorepo: false,
+		conventions: [],
 	};
 
-	// Try reading package.json
-	const pkgPath = join(repoRoot, "package.json");
-	if (!existsSync(pkgPath)) return stack;
+	// ── Multi-language detection (file-marker based) ─────────────────────
+	const languages: string[] = [];
+
+	// Go
+	if (existsSync(join(repoRoot, "go.mod"))) {
+		languages.push("go");
+	}
+
+	// Rust
+	if (existsSync(join(repoRoot, "Cargo.toml"))) {
+		languages.push("rust");
+	}
+
+	// Python
+	if (
+		existsSync(join(repoRoot, "pyproject.toml")) ||
+		existsSync(join(repoRoot, "requirements.txt")) ||
+		existsSync(join(repoRoot, "setup.py"))
+	) {
+		languages.push("python");
+	}
+
+	// Java
+	if (
+		existsSync(join(repoRoot, "pom.xml")) ||
+		existsSync(join(repoRoot, "build.gradle")) ||
+		existsSync(join(repoRoot, "build.gradle.kts"))
+	) {
+		languages.push("java");
+	}
 
-	let pkg: Record<string, unknown>;
+	// .NET (C#/F#) — check for .csproj, .fsproj, .sln files
 	try {
-		pkg = JSON.parse(readFileSync(pkgPath, "utf-8"));
+		const entries = readdirSync(repoRoot);
+		if (
+			entries.some(
+				(e: string) =>
+					e.endsWith(".csproj") || e.endsWith(".sln") || e.endsWith(".fsproj"),
+			)
+		) {
+			languages.push("dotnet");
+		}
 	} catch {
-		return stack;
+		// Directory not readable — skip
 	}
 
-	const allDeps = {
-		...(pkg.dependencies as Record<string, string> | undefined),
-		...(pkg.devDependencies as Record<string, string> | undefined),
-		...(pkg.peerDependencies as Record<string, string> | undefined),
-	};
+	// ── 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),
+			};
+
+			// Extract scripts
+			if (pkg.scripts && typeof pkg.scripts === "object") {
+				stack.scripts = pkg.scripts as Record<string, string>;
+			}
+
+			// Detect monorepo (workspaces)
+			if (pkg.workspaces) {
+				stack.monorepo = true;
+			}
+		} catch {
+			// Malformed package.json — skip
+		}
+	}
+
+	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";
+		}
+
+		// Build tool detection
+		if (allDeps.bunup) {
+			stack.buildTool = "bunup";
+		} else if (allDeps.tsup) {
+			stack.buildTool = "tsup";
+		} else if (allDeps.vite) {
+			stack.buildTool = "vite";
+		} else if (allDeps.webpack) {
+			stack.buildTool = "webpack";
+		} else if (allDeps.esbuild) {
+			stack.buildTool = "esbuild";
+		} else if (allDeps.rollup) {
+			stack.buildTool = "rollup";
+		} else if (allDeps.turbo) {
+			stack.buildTool = "turborepo";
+		}
+
+		// Also check for monorepo tools
+		if (
+			allDeps.turbo ||
+			allDeps.nx ||
+			allDeps.lerna ||
+			existsSync(join(repoRoot, "pnpm-workspace.yaml"))
+		) {
+			stack.monorepo = true;
+		}
+	}
 
-	// Runtime detection
+	// ── Infer conventions from project context ───────────────────────────
+	const conventions: string[] = [];
+
+	// Check for conventional commits
 	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"))
+		existsSync(join(repoRoot, "commitlint.config.js")) ||
+		existsSync(join(repoRoot, "commitlint.config.ts")) ||
+		existsSync(join(repoRoot, ".commitlintrc.json")) ||
+		existsSync(join(repoRoot, ".commitlintrc.yml"))
 	) {
-		stack.runtime = "deno";
-	} else {
-		stack.runtime = "node";
+		conventions.push("Conventional commits enforced via commitlint");
+	}
+
+	// Check for git hooks
+	if (existsSync(join(repoRoot, "lefthook.yml"))) {
+		conventions.push("Git hooks via lefthook");
+	} else if (existsSync(join(repoRoot, ".husky"))) {
+		conventions.push("Git hooks via husky");
 	}
 
-	// Language detection
-	if (existsSync(join(repoRoot, "tsconfig.json")) || allDeps.typescript) {
-		stack.language = "typescript";
-	} else {
-		stack.language = "javascript";
+	// Check for strict TypeScript
+	if (existsSync(join(repoRoot, "tsconfig.json"))) {
+		try {
+			const tsconfig = readFileSync(join(repoRoot, "tsconfig.json"), "utf-8");
+			if (tsconfig.includes('"strict"') && tsconfig.includes("true")) {
+				conventions.push("TypeScript strict mode enabled");
+			}
+		} catch {
+			// ignore
+		}
 	}
 
-	// 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";
+	// Check for Docker
+	if (
+		existsSync(join(repoRoot, "Dockerfile")) ||
+		existsSync(join(repoRoot, "docker-compose.yml")) ||
+		existsSync(join(repoRoot, "docker-compose.yaml"))
+	) {
+		conventions.push("Docker containerization");
 	}
 
-	// Linter detection
-	if (allDeps["@biomejs/biome"]) {
-		stack.linter = "biome";
-	} else if (allDeps.eslint) {
-		stack.linter = "eslint";
-	} else if (allDeps.prettier) {
-		stack.linter = "prettier";
+	// Check for CI
+	if (existsSync(join(repoRoot, ".github/workflows"))) {
+		conventions.push("GitHub Actions CI/CD");
+	} else if (existsSync(join(repoRoot, ".gitlab-ci.yml"))) {
+		conventions.push("GitLab CI/CD");
+	} else if (existsSync(join(repoRoot, ".circleci"))) {
+		conventions.push("CircleCI");
 	}
 
-	// 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";
+	// Check for env management
+	if (existsSync(join(repoRoot, ".env.example"))) {
+		conventions.push("Environment variables documented in .env.example");
 	}
 
+	// Infer from package.json scripts
+	if (stack.scripts.lint || stack.scripts["lint:fix"]) {
+		conventions.push(
+			`Lint command: \`${stack.runtime === "bun" ? "bun" : "npm"} run lint\``,
+		);
+	}
+	if (stack.scripts.test) {
+		conventions.push(`Test command: \`${stack.scripts.test}\``);
+	}
+	if (stack.scripts.build) {
+		conventions.push(`Build command: \`${stack.scripts.build}\``);
+	}
+	if (stack.scripts.typecheck || stack.scripts["type-check"]) {
+		conventions.push("Type checking enforced");
+	}
+
+	stack.conventions = conventions;
+
+	// 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 {
@@ -149,6 +359,53 @@ function buildConstitution(stack: DetectedStack): string {
 	const frameworkLine =
 		stack.framework !== "none" ? `- Framework: ${stack.framework}\n` : "";
 
+	const buildLine =
+		stack.buildTool !== "unknown" ? `- Build: ${stack.buildTool}\n` : "";
+
+	const monorepoLine = stack.monorepo ? "- Monorepo: yes (workspaces)\n" : "";
+
+	// Build architecture section from context
+	const archLines: string[] = [];
+	if (stack.monorepo) {
+		archLines.push("- Monorepo with shared packages");
+	}
+	if (stack.framework !== "none") {
+		archLines.push(`- ${stack.framework} application`);
+	}
+	if (stack.languages.length > 1) {
+		archLines.push(`- Multi-language: ${stack.languages.join(", ")}`);
+	}
+	const archSection =
+		archLines.length > 0
+			? archLines.join("\n")
+			: "- [NEEDS CLARIFICATION] Define architectural constraints.";
+
+	// Build verification section from scripts
+	const verifyLines: string[] = [];
+	const runCmd = stack.runtime === "bun" ? "bun" : "npm";
+	if (stack.scripts.lint || stack.linter !== "unknown") {
+		verifyLines.push(
+			`- Lint: \`${stack.scripts.lint ?? `${runCmd} run lint`}\``,
+		);
+	}
+	if (stack.language === "typescript") {
+		verifyLines.push(
+			`- Typecheck: \`${stack.scripts.typecheck ?? stack.scripts["type-check"] ?? `${runCmd} run typecheck`}\``,
+		);
+	}
+	if (stack.scripts.test) {
+		verifyLines.push(`- Test: \`${stack.scripts.test}\``);
+	} else if (stack.testRunner !== "unknown") {
+		verifyLines.push(`- Test: \`${runCmd} test\``);
+	}
+	verifyLines.push("- Diff-only: only report findings on changed lines");
+
+	// Build conventions section from detected conventions
+	const conventionLines =
+		stack.conventions.length > 0
+			? stack.conventions.map((c) => `- ${c}`).join("\n")
+			: "- [NEEDS CLARIFICATION] Add project-specific conventions.";
+
 	return `# Project Constitution
 
 Non-negotiable rules. Injected into every AI call.
@@ -158,16 +415,15 @@ ${runtimeLine}
 ${langLine}
 ${lintLine}
 ${testLine}
-${frameworkLine}
+${frameworkLine}${buildLine}${monorepoLine}
 ## Architecture
-- [NEEDS CLARIFICATION] Define architectural constraints.
+${archSection}
 
 ## Verification
-- All commits pass: lint + typecheck + test
-- Diff-only: only report findings on changed lines
+${verifyLines.join("\n")}
 
 ## Conventions
-- [NEEDS CLARIFICATION] Add project-specific conventions.
+${conventionLines}
 `;
 }
 
@@ -179,6 +435,11 @@ function buildAgentsMd(stack: DetectedStack): string {
 
 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
 ${installCmd}
@@ -199,6 +460,10 @@ 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 |
 |------|---------|-----------|
@@ -206,6 +471,9 @@ maina commit    # verify + commit
 | \`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
@@ -220,7 +488,12 @@ function buildCopilotInstructions(stack: DetectedStack): string {
 
 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
+## 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
@@ -230,14 +503,7 @@ You are working on a codebase verified by [Maina](https://mainahq.com), the veri
 
 ## Available MCP Tools
 
-| 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 |
+${MCP_TOOLS_TABLE}
 
 ## Conventions
 
@@ -253,6 +519,242 @@ Issues labeled \`audit\` come from maina's daily verification. Fix the specific
 `;
 }
 
+// ── .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:
@@ -306,11 +808,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",
@@ -332,6 +837,22 @@ function getFileManifest(stack: DetectedStack): FileEntry[] {
 			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),
+		},
 	];
 }
 
@@ -385,6 +906,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[] = [];
@@ -393,8 +915,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 });
@@ -404,8 +926,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, "..");
@@ -440,6 +976,7 @@ export async function bootstrap(
 				directory: mainaDir,
 				detectedStack,
 				detectedTools: detectedToolsList,
+				aiGenerated,
 			},
 		};
 	} catch (e) {