@mainahq/core 0.7.0 → 1.0.1

package/src/feedback/sync.ts

@@ -1,12 +1,14 @@
 /**
- * Feedback sync — exports local feedback records for cloud upload.
+ * Feedback sync — exports local feedback records and workflow stats for cloud upload.
  *
  * Reads from the local SQLite feedback.db and maps records to the
  * cloud-compatible FeedbackEvent format for batch upload.
+ * Also exports workflow step counts for analytics.
  */
 
-import type { FeedbackEvent } from "../cloud/types";
-import { getFeedbackDb } from "../db/index";
+import type { EpisodicCloudEntry, FeedbackEvent } from "../cloud/types";
+import { getEntries } from "../context/episodic";
+import { getFeedbackDb, getStatsDb } from "../db/index";
 
 /** Raw row shape from the feedback table. */
 interface FeedbackRow {
@@ -52,3 +54,90 @@ export function exportFeedbackForCloud(mainaDir: string): FeedbackEvent[] {
 		return event;
 	});
 }
+
+/** Workflow stats summary for cloud analytics. */
+export interface WorkflowStats {
+	totalCommits: number;
+	totalVerifyTimeMs: number;
+	avgVerifyTimeMs: number;
+	totalFindings: number;
+	totalContextTokens: number;
+	cacheHitRate: number;
+	passRate: number;
+}
+
+/**
+ * Export workflow stats from the local stats.db for cloud analytics.
+ * Returns aggregated numbers the dashboard can display.
+ */
+export function exportWorkflowStats(mainaDir: string): WorkflowStats | null {
+	const dbResult = getStatsDb(mainaDir);
+	if (!dbResult.ok) return null;
+
+	const { db } = dbResult.value;
+	try {
+		const row = db
+			.query(
+				`SELECT
+				COUNT(*) as total_commits,
+				COALESCE(SUM(verify_duration_ms), 0) as total_verify_ms,
+				COALESCE(AVG(verify_duration_ms), 0) as avg_verify_ms,
+				COALESCE(SUM(findings_total), 0) as total_findings,
+				COALESCE(SUM(context_tokens), 0) as total_context_tokens,
+				COALESCE(SUM(cache_hits), 0) as total_cache_hits,
+				COALESCE(SUM(cache_misses), 0) as total_cache_misses,
+				COALESCE(SUM(CASE WHEN pipeline_passed = 1 THEN 1 ELSE 0 END), 0) as passed_count
+			FROM commit_snapshots`,
+			)
+			.get() as {
+			total_commits: number;
+			total_verify_ms: number;
+			avg_verify_ms: number;
+			total_findings: number;
+			total_context_tokens: number;
+			total_cache_hits: number;
+			total_cache_misses: number;
+			passed_count: number;
+		} | null;
+
+		if (!row || row.total_commits === 0) return null;
+
+		const totalCacheOps = row.total_cache_hits + row.total_cache_misses;
+
+		return {
+			totalCommits: row.total_commits,
+			totalVerifyTimeMs: row.total_verify_ms,
+			avgVerifyTimeMs: Math.round(row.avg_verify_ms),
+			totalFindings: row.total_findings,
+			totalContextTokens: row.total_context_tokens,
+			cacheHitRate:
+				totalCacheOps > 0 ? row.total_cache_hits / totalCacheOps : 0,
+			passRate: row.passed_count / row.total_commits,
+		};
+	} catch {
+		return null;
+	}
+}
+
+/**
+ * Export local episodic entries for cloud upload.
+ *
+ * Reads from the episodic_entries table in the context DB and maps
+ * each entry to the cloud-compatible EpisodicCloudEntry format.
+ *
+ * @param repo - Repository identifier (e.g. "owner/repo") to tag entries with.
+ */
+export function exportEpisodicForCloud(
+	mainaDir: string,
+	repo: string,
+): EpisodicCloudEntry[] {
+	const entries = getEntries(mainaDir);
+
+	return entries.map((entry) => ({
+		repo,
+		entryType: entry.type,
+		title: entry.summary || entry.type,
+		summary: entry.content,
+		relevanceScore: entry.relevance,
+	}));
+}

package/src/git/__tests__/git.test.ts

@@ -6,6 +6,7 @@ import {
 	getDiff,
 	getRecentCommits,
 	getRepoRoot,
+	getRepoSlug,
 	getStagedFiles,
 } from "../index";
 
@@ -59,4 +60,18 @@ describe("git operations", () => {
 		const diff = await getDiff();
 		expect(typeof diff).toBe("string");
 	});
+
+	test("getRepoSlug() returns owner/repo format", async () => {
+		const slug = await getRepoSlug();
+		expect(typeof slug).toBe("string");
+		// Should contain a slash (owner/repo) or at minimum be non-empty
+		expect(slug.length).toBeGreaterThan(0);
+		// If remote exists, should be owner/repo format
+		if (slug !== "unknown" && slug.includes("/")) {
+			const parts = slug.split("/");
+			expect(parts).toHaveLength(2);
+			expect(parts[0]?.length).toBeGreaterThan(0);
+			expect(parts[1]?.length).toBeGreaterThan(0);
+		}
+	});
 });

package/src/git/index.ts

@@ -108,3 +108,28 @@ export async function getTrackedFiles(cwd?: string): Promise<string[]> {
 	if (!output) return [];
 	return output.split("\n").filter((line) => line.trim().length > 0);
 }
+
+/**
+ * Extract the "owner/repo" slug from the git remote origin URL.
+ * Handles HTTPS (https://github.com/owner/repo.git) and
+ * SSH (git@github.com:owner/repo.git) formats.
+ * Returns the directory basename as fallback if parsing fails.
+ */
+export async function getRepoSlug(cwd?: string): Promise<string> {
+	const url = await exec(["remote", "get-url", "origin"], cwd);
+	if (url) {
+		// SSH: git@github.com:owner/repo.git
+		const sshMatch = url.match(/:([^/]+\/[^/]+?)(?:\.git)?$/);
+		if (sshMatch?.[1]) return sshMatch[1];
+		// HTTPS: https://github.com/owner/repo.git
+		const httpsMatch = url.match(/\/([^/]+\/[^/]+?)(?:\.git)?$/);
+		if (httpsMatch?.[1]) return httpsMatch[1];
+	}
+	// Fallback: use directory name
+	const root = await exec(["rev-parse", "--show-toplevel"], cwd);
+	if (root) {
+		const parts = root.split("/");
+		return parts[parts.length - 1] ?? "unknown";
+	}
+	return "unknown";
+}

package/src/index.ts

@@ -63,9 +63,11 @@ export { type CloudClient, createCloudClient } from "./cloud/client";
 export type {
 	ApiResponse,
 	CloudConfig,
+	CloudEpisodicEntry,
 	CloudFeedbackPayload,
 	CloudPromptImprovement,
 	DeviceCodeResponse,
+	EpisodicCloudEntry,
 	FeedbackBatchPayload,
 	FeedbackEvent,
 	FeedbackImprovementsResponse,
@@ -172,7 +174,12 @@ export {
 	type RulePreference,
 	savePreferences,
 } from "./feedback/preferences";
-export { exportFeedbackForCloud } from "./feedback/sync";
+export {
+	exportEpisodicForCloud,
+	exportFeedbackForCloud,
+	exportWorkflowStats,
+	type WorkflowStats,
+} from "./feedback/sync";
 export {
 	analyzeWorkflowTrace,
 	type PromptImprovement,
@@ -188,6 +195,7 @@ export {
 	getDiff,
 	getRecentCommits,
 	getRepoRoot,
+	getRepoSlug,
 	getStagedFiles,
 	getTrackedFiles,
 } from "./git/index";
@@ -317,8 +325,11 @@ export {
 export {
 	detectTool,
 	detectTools,
+	getToolsForLanguages,
 	isToolAvailable,
 	TOOL_REGISTRY,
+	type ToolRegistryEntry,
+	type ToolTier,
 } from "./verify/detect";
 export {
 	filterByDiff,

package/src/init/__tests__/detect-stack.test.ts

@@ -0,0 +1,237 @@
+import { afterEach, beforeEach, describe, expect, test } from "bun:test";
+import { mkdirSync, rmSync, writeFileSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import { bootstrap } from "../index";
+
+function makeTmpDir(): string {
+	const dir = join(
+		tmpdir(),
+		`maina-detect-stack-test-${Date.now()}-${Math.random().toString(36).slice(2)}`,
+	);
+	mkdirSync(dir, { recursive: true });
+	return dir;
+}
+
+describe("detectStack — languages field", () => {
+	let tmpDir: string;
+
+	beforeEach(() => {
+		tmpDir = makeTmpDir();
+	});
+
+	afterEach(() => {
+		rmSync(tmpDir, { recursive: true, force: true });
+	});
+
+	test("empty directory returns languages with 'unknown'", async () => {
+		const result = await bootstrap(tmpDir);
+		expect(result.ok).toBe(true);
+		if (result.ok) {
+			expect(result.value.detectedStack.languages).toBeDefined();
+			expect(Array.isArray(result.value.detectedStack.languages)).toBe(true);
+			expect(result.value.detectedStack.languages).toContain("unknown");
+		}
+	});
+
+	test("TypeScript project includes 'typescript' in languages", async () => {
+		writeFileSync(
+			join(tmpDir, "package.json"),
+			JSON.stringify({ devDependencies: { typescript: "^5.0.0" } }),
+		);
+		writeFileSync(join(tmpDir, "tsconfig.json"), "{}");
+
+		const result = await bootstrap(tmpDir);
+		expect(result.ok).toBe(true);
+		if (result.ok) {
+			expect(result.value.detectedStack.languages).toContain("typescript");
+			expect(result.value.detectedStack.languages).not.toContain("unknown");
+		}
+	});
+
+	test("JavaScript project includes 'javascript' in languages", async () => {
+		writeFileSync(
+			join(tmpDir, "package.json"),
+			JSON.stringify({ dependencies: { express: "^4.0.0" } }),
+		);
+
+		const result = await bootstrap(tmpDir);
+		expect(result.ok).toBe(true);
+		if (result.ok) {
+			expect(result.value.detectedStack.languages).toContain("javascript");
+			expect(result.value.detectedStack.languages).not.toContain("unknown");
+		}
+	});
+
+	test("go.mod detected as 'go' language", async () => {
+		writeFileSync(
+			join(tmpDir, "go.mod"),
+			"module example.com/foo\n\ngo 1.21\n",
+		);
+
+		const result = await bootstrap(tmpDir);
+		expect(result.ok).toBe(true);
+		if (result.ok) {
+			expect(result.value.detectedStack.languages).toContain("go");
+		}
+	});
+
+	test("Cargo.toml detected as 'rust' language", async () => {
+		writeFileSync(
+			join(tmpDir, "Cargo.toml"),
+			'[package]\nname = "test"\nversion = "0.1.0"\n',
+		);
+
+		const result = await bootstrap(tmpDir);
+		expect(result.ok).toBe(true);
+		if (result.ok) {
+			expect(result.value.detectedStack.languages).toContain("rust");
+		}
+	});
+
+	test("pyproject.toml detected as 'python' language", async () => {
+		writeFileSync(join(tmpDir, "pyproject.toml"), "[project]\nname = 'test'\n");
+
+		const result = await bootstrap(tmpDir);
+		expect(result.ok).toBe(true);
+		if (result.ok) {
+			expect(result.value.detectedStack.languages).toContain("python");
+		}
+	});
+
+	test("requirements.txt detected as 'python' language", async () => {
+		writeFileSync(join(tmpDir, "requirements.txt"), "flask==2.0.0\n");
+
+		const result = await bootstrap(tmpDir);
+		expect(result.ok).toBe(true);
+		if (result.ok) {
+			expect(result.value.detectedStack.languages).toContain("python");
+		}
+	});
+
+	test("setup.py detected as 'python' language", async () => {
+		writeFileSync(join(tmpDir, "setup.py"), "from setuptools import setup\n");
+
+		const result = await bootstrap(tmpDir);
+		expect(result.ok).toBe(true);
+		if (result.ok) {
+			expect(result.value.detectedStack.languages).toContain("python");
+		}
+	});
+
+	test("pom.xml detected as 'java' language", async () => {
+		writeFileSync(join(tmpDir, "pom.xml"), "<project></project>\n");
+
+		const result = await bootstrap(tmpDir);
+		expect(result.ok).toBe(true);
+		if (result.ok) {
+			expect(result.value.detectedStack.languages).toContain("java");
+		}
+	});
+
+	test("build.gradle detected as 'java' language", async () => {
+		writeFileSync(join(tmpDir, "build.gradle"), "apply plugin: 'java'\n");
+
+		const result = await bootstrap(tmpDir);
+		expect(result.ok).toBe(true);
+		if (result.ok) {
+			expect(result.value.detectedStack.languages).toContain("java");
+		}
+	});
+
+	test("build.gradle.kts detected as 'java' language", async () => {
+		writeFileSync(join(tmpDir, "build.gradle.kts"), 'plugins { id("java") }\n');
+
+		const result = await bootstrap(tmpDir);
+		expect(result.ok).toBe(true);
+		if (result.ok) {
+			expect(result.value.detectedStack.languages).toContain("java");
+		}
+	});
+
+	test(".csproj file detected as 'dotnet' language", async () => {
+		writeFileSync(join(tmpDir, "MyApp.csproj"), "<Project></Project>\n");
+
+		const result = await bootstrap(tmpDir);
+		expect(result.ok).toBe(true);
+		if (result.ok) {
+			expect(result.value.detectedStack.languages).toContain("dotnet");
+		}
+	});
+
+	test(".sln file detected as 'dotnet' language", async () => {
+		writeFileSync(join(tmpDir, "MyApp.sln"), "Microsoft Visual Studio\n");
+
+		const result = await bootstrap(tmpDir);
+		expect(result.ok).toBe(true);
+		if (result.ok) {
+			expect(result.value.detectedStack.languages).toContain("dotnet");
+		}
+	});
+
+	test(".fsproj file detected as 'dotnet' language", async () => {
+		writeFileSync(join(tmpDir, "MyApp.fsproj"), "<Project></Project>\n");
+
+		const result = await bootstrap(tmpDir);
+		expect(result.ok).toBe(true);
+		if (result.ok) {
+			expect(result.value.detectedStack.languages).toContain("dotnet");
+		}
+	});
+
+	test("multi-language project detects all languages", async () => {
+		// TypeScript + Python
+		writeFileSync(
+			join(tmpDir, "package.json"),
+			JSON.stringify({ devDependencies: { typescript: "^5.0.0" } }),
+		);
+		writeFileSync(join(tmpDir, "tsconfig.json"), "{}");
+		writeFileSync(join(tmpDir, "requirements.txt"), "flask==2.0.0\n");
+
+		const result = await bootstrap(tmpDir);
+		expect(result.ok).toBe(true);
+		if (result.ok) {
+			expect(result.value.detectedStack.languages).toContain("typescript");
+			expect(result.value.detectedStack.languages).toContain("python");
+			expect(
+				result.value.detectedStack.languages.length,
+			).toBeGreaterThanOrEqual(2);
+		}
+	});
+
+	test("TypeScript + Go + Rust multi-language detection", async () => {
+		writeFileSync(
+			join(tmpDir, "package.json"),
+			JSON.stringify({ devDependencies: { typescript: "^5.0.0" } }),
+		);
+		writeFileSync(join(tmpDir, "tsconfig.json"), "{}");
+		writeFileSync(join(tmpDir, "go.mod"), "module test\n\ngo 1.21\n");
+		writeFileSync(join(tmpDir, "Cargo.toml"), '[package]\nname = "test"\n');
+
+		const result = await bootstrap(tmpDir);
+		expect(result.ok).toBe(true);
+		if (result.ok) {
+			const langs = result.value.detectedStack.languages;
+			expect(langs).toContain("typescript");
+			expect(langs).toContain("go");
+			expect(langs).toContain("rust");
+			expect(langs.length).toBeGreaterThanOrEqual(3);
+		}
+	});
+
+	test("languages does not contain duplicates", async () => {
+		writeFileSync(
+			join(tmpDir, "package.json"),
+			JSON.stringify({ devDependencies: { typescript: "^5.0.0" } }),
+		);
+		writeFileSync(join(tmpDir, "tsconfig.json"), "{}");
+
+		const result = await bootstrap(tmpDir);
+		expect(result.ok).toBe(true);
+		if (result.ok) {
+			const langs = result.value.detectedStack.languages;
+			const unique = [...new Set(langs)];
+			expect(langs.length).toBe(unique.length);
+		}
+	});
+});

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

@@ -276,4 +276,188 @@ describe("bootstrap", () => {
 			expect(result.value.detectedStack.linter).toBe("eslint");
 		}
 	});
+
+	// ── .mcp.json generation ──────────────────────────────────────────────
+
+	test("creates .mcp.json at repo root", async () => {
+		const result = await bootstrap(tmpDir);
+		expect(result.ok).toBe(true);
+
+		const mcpPath = join(tmpDir, ".mcp.json");
+		expect(existsSync(mcpPath)).toBe(true);
+
+		const content = JSON.parse(readFileSync(mcpPath, "utf-8"));
+		expect(content.mcpServers).toBeDefined();
+		expect(content.mcpServers.maina).toBeDefined();
+		expect(content.mcpServers.maina.command).toBe("maina");
+		expect(content.mcpServers.maina.args).toEqual(["--mcp"]);
+	});
+
+	test("does not overwrite existing .mcp.json", async () => {
+		writeFileSync(join(tmpDir, ".mcp.json"), '{"custom": true}');
+
+		const result = await bootstrap(tmpDir);
+		expect(result.ok).toBe(true);
+		if (result.ok) {
+			expect(result.value.skipped).toContain(".mcp.json");
+		}
+
+		const content = readFileSync(join(tmpDir, ".mcp.json"), "utf-8");
+		expect(JSON.parse(content)).toEqual({ custom: true });
+	});
+
+	// ── Agent instruction files ───────────────────────────────────────────
+
+	test("creates CLAUDE.md at repo root", async () => {
+		const result = await bootstrap(tmpDir);
+		expect(result.ok).toBe(true);
+
+		const claudePath = join(tmpDir, "CLAUDE.md");
+		expect(existsSync(claudePath)).toBe(true);
+
+		const content = readFileSync(claudePath, "utf-8");
+		expect(content).toContain("# CLAUDE.md");
+		expect(content).toContain("constitution.md");
+		expect(content).toContain("brainstorm");
+		expect(content).toContain("getContext");
+		expect(content).toContain("maina verify");
+	});
+
+	test("creates GEMINI.md at repo root", async () => {
+		const result = await bootstrap(tmpDir);
+		expect(result.ok).toBe(true);
+
+		const geminiPath = join(tmpDir, "GEMINI.md");
+		expect(existsSync(geminiPath)).toBe(true);
+
+		const content = readFileSync(geminiPath, "utf-8");
+		expect(content).toContain("# GEMINI.md");
+		expect(content).toContain("constitution.md");
+		expect(content).toContain("brainstorm");
+		expect(content).toContain("getContext");
+	});
+
+	test("creates .cursorrules at repo root", async () => {
+		const result = await bootstrap(tmpDir);
+		expect(result.ok).toBe(true);
+
+		const cursorPath = join(tmpDir, ".cursorrules");
+		expect(existsSync(cursorPath)).toBe(true);
+
+		const content = readFileSync(cursorPath, "utf-8");
+		expect(content).toContain("Cursor Rules");
+		expect(content).toContain("constitution.md");
+		expect(content).toContain("brainstorm");
+		expect(content).toContain("maina verify");
+	});
+
+	test("does not overwrite existing agent files", async () => {
+		writeFileSync(join(tmpDir, "CLAUDE.md"), "# My Custom CLAUDE.md\n");
+		writeFileSync(join(tmpDir, "GEMINI.md"), "# My Custom GEMINI.md\n");
+		writeFileSync(join(tmpDir, ".cursorrules"), "# My Custom Rules\n");
+
+		const result = await bootstrap(tmpDir);
+		expect(result.ok).toBe(true);
+		if (result.ok) {
+			expect(result.value.skipped).toContain("CLAUDE.md");
+			expect(result.value.skipped).toContain("GEMINI.md");
+			expect(result.value.skipped).toContain(".cursorrules");
+		}
+
+		expect(readFileSync(join(tmpDir, "CLAUDE.md"), "utf-8")).toBe(
+			"# My Custom CLAUDE.md\n",
+		);
+	});
+
+	// ── Workflow order in agent files ─────────────────────────────────────
+
+	test("AGENTS.md includes workflow order", async () => {
+		const result = await bootstrap(tmpDir);
+		expect(result.ok).toBe(true);
+
+		const content = readFileSync(join(tmpDir, "AGENTS.md"), "utf-8");
+		expect(content).toContain("Workflow Order");
+		expect(content).toContain("brainstorm");
+		expect(content).toContain("ticket");
+		expect(content).toContain("implement");
+		expect(content).toContain("verify");
+	});
+
+	test("copilot instructions include workflow order", async () => {
+		const result = await bootstrap(tmpDir);
+		expect(result.ok).toBe(true);
+
+		const content = readFileSync(
+			join(tmpDir, ".github", "copilot-instructions.md"),
+			"utf-8",
+		);
+		expect(content).toContain("Workflow Order");
+		expect(content).toContain("brainstorm");
+	});
+
+	// ── MCP tools in agent files ──────────────────────────────────────────
+
+	test("AGENTS.md includes MCP tools table", async () => {
+		const result = await bootstrap(tmpDir);
+		expect(result.ok).toBe(true);
+
+		const content = readFileSync(join(tmpDir, "AGENTS.md"), "utf-8");
+		expect(content).toContain("MCP Tools");
+		expect(content).toContain("getContext");
+		expect(content).toContain("checkSlop");
+		expect(content).toContain("reviewCode");
+		expect(content).toContain("suggestTests");
+		expect(content).toContain("explainModule");
+		expect(content).toContain("analyzeFeature");
+	});
+
+	// ── aiGenerate option ─────────────────────────────────────────────────
+
+	test("aiGenerate defaults to false (backward compatible)", async () => {
+		const result = await bootstrap(tmpDir);
+		expect(result.ok).toBe(true);
+		if (result.ok) {
+			// Without aiGenerate, should not have AI-generated constitution
+			expect(result.value.aiGenerated).toBeFalsy();
+		}
+	});
+
+	test("aiGenerate falls back to static template when AI unavailable", async () => {
+		// No API key in env, AI will fail
+		const result = await bootstrap(tmpDir, { aiGenerate: true });
+		expect(result.ok).toBe(true);
+		if (result.ok) {
+			// Constitution should still be created (fallback to static)
+			expect(result.value.created).toContain(".maina/constitution.md");
+			const content = readFileSync(
+				join(tmpDir, ".maina", "constitution.md"),
+				"utf-8",
+			);
+			expect(content).toContain("# Project Constitution");
+		}
+	});
+
+	// ── Complete file manifest ────────────────────────────────────────────
+
+	test("creates all expected files in fresh directory", async () => {
+		const result = await bootstrap(tmpDir);
+		expect(result.ok).toBe(true);
+		if (result.ok) {
+			const expectedFiles = [
+				".maina/constitution.md",
+				".maina/prompts/review.md",
+				".maina/prompts/commit.md",
+				"AGENTS.md",
+				".github/workflows/maina-ci.yml",
+				".github/copilot-instructions.md",
+				".mcp.json",
+				"CLAUDE.md",
+				"GEMINI.md",
+				".cursorrules",
+			];
+			for (const f of expectedFiles) {
+				expect(result.value.created).toContain(f);
+			}
+		}
+	});
 });