@mainahq/core 0.2.0

package/src/feedback/__tests__/preferences.test.ts

@@ -0,0 +1,169 @@
+import { afterEach, beforeEach, describe, expect, test } from "bun:test";
+import { mkdirSync, readFileSync } from "node:fs";
+import { join } from "node:path";
+import {
+	acknowledgeFinding,
+	dismissFinding,
+	getNoisyRules,
+	loadPreferences,
+	type Preferences,
+	savePreferences,
+} from "../preferences";
+
+let tmpDir: string;
+
+beforeEach(() => {
+	tmpDir = join(
+		import.meta.dir,
+		`tmp-prefs-${Date.now()}-${Math.random().toString(36).slice(2)}`,
+	);
+	mkdirSync(tmpDir, { recursive: true });
+});
+
+afterEach(() => {
+	try {
+		const { rmSync } = require("node:fs");
+		rmSync(tmpDir, { recursive: true, force: true });
+	} catch {
+		// ignore
+	}
+});
+
+describe("loadPreferences", () => {
+	test("returns defaults when no file exists", () => {
+		const prefs = loadPreferences(tmpDir);
+
+		expect(prefs.rules).toEqual({});
+		expect(prefs.updatedAt).toBeTruthy();
+	});
+});
+
+describe("dismissFinding", () => {
+	test("increments dismiss count", () => {
+		dismissFinding(tmpDir, "no-console-log");
+		dismissFinding(tmpDir, "no-console-log");
+
+		const prefs = loadPreferences(tmpDir);
+		const rule = prefs.rules["no-console-log"];
+
+		expect(rule).toBeDefined();
+		expect(rule?.dismissCount).toBe(2);
+		expect(rule?.totalCount).toBe(2);
+		expect(rule?.falsePositiveRate).toBeCloseTo(1.0, 5);
+	});
+});
+
+describe("acknowledgeFinding", () => {
+	test("increments total count without incrementing dismiss count", () => {
+		acknowledgeFinding(tmpDir, "no-unused-vars");
+		acknowledgeFinding(tmpDir, "no-unused-vars");
+
+		const prefs = loadPreferences(tmpDir);
+		const rule = prefs.rules["no-unused-vars"];
+
+		expect(rule).toBeDefined();
+		expect(rule?.dismissCount).toBe(0);
+		expect(rule?.totalCount).toBe(2);
+		expect(rule?.falsePositiveRate).toBe(0);
+	});
+});
+
+describe("getNoisyRules", () => {
+	test("returns rules with >50% false positive rate and >= 5 samples", () => {
+		// noisy rule: 5 dismissed out of 6 total (83%) — meets MIN_RULE_SAMPLES
+		dismissFinding(tmpDir, "noisy-rule");
+		dismissFinding(tmpDir, "noisy-rule");
+		dismissFinding(tmpDir, "noisy-rule");
+		dismissFinding(tmpDir, "noisy-rule");
+		dismissFinding(tmpDir, "noisy-rule");
+		acknowledgeFinding(tmpDir, "noisy-rule");
+
+		// good rule: 1 dismissed out of 6 total (17%) — not noisy
+		dismissFinding(tmpDir, "good-rule");
+		acknowledgeFinding(tmpDir, "good-rule");
+		acknowledgeFinding(tmpDir, "good-rule");
+		acknowledgeFinding(tmpDir, "good-rule");
+		acknowledgeFinding(tmpDir, "good-rule");
+		acknowledgeFinding(tmpDir, "good-rule");
+
+		// borderline rule: exactly 50% — should NOT be included (>50% required)
+		dismissFinding(tmpDir, "borderline-rule");
+		acknowledgeFinding(tmpDir, "borderline-rule");
+		dismissFinding(tmpDir, "borderline-rule");
+		acknowledgeFinding(tmpDir, "borderline-rule");
+		dismissFinding(tmpDir, "borderline-rule");
+		acknowledgeFinding(tmpDir, "borderline-rule");
+
+		const noisy = getNoisyRules(tmpDir);
+
+		expect(noisy.length).toBe(1);
+		expect(noisy[0]?.ruleId).toBe("noisy-rule");
+		expect(noisy[0]?.falsePositiveRate).toBeCloseTo(5 / 6, 5);
+	});
+
+	test("excludes rules with fewer than 5 samples even if false positive rate is 100%", () => {
+		// Only 1 sample — 100% false positive rate but below MIN_RULE_SAMPLES
+		dismissFinding(tmpDir, "low-sample-rule");
+
+		const noisy = getNoisyRules(tmpDir);
+
+		expect(noisy.length).toBe(0);
+	});
+});
+
+describe("savePreferences", () => {
+	test("writes JSON file", () => {
+		const prefs: Preferences = {
+			rules: {
+				"test-rule": {
+					ruleId: "test-rule",
+					dismissCount: 5,
+					totalCount: 10,
+					falsePositiveRate: 0.5,
+				},
+			},
+			updatedAt: new Date().toISOString(),
+		};
+
+		savePreferences(tmpDir, prefs);
+
+		const filePath = join(tmpDir, "preferences.json");
+		const raw = readFileSync(filePath, "utf-8");
+		const parsed = JSON.parse(raw);
+
+		expect(parsed.rules["test-rule"].dismissCount).toBe(5);
+		expect(parsed.rules["test-rule"].totalCount).toBe(10);
+	});
+});
+
+describe("round-trip", () => {
+	test("preferences survive save then load", () => {
+		const prefs: Preferences = {
+			rules: {
+				"rule-a": {
+					ruleId: "rule-a",
+					dismissCount: 3,
+					totalCount: 7,
+					falsePositiveRate: 3 / 7,
+				},
+				"rule-b": {
+					ruleId: "rule-b",
+					dismissCount: 0,
+					totalCount: 5,
+					falsePositiveRate: 0,
+				},
+			},
+			updatedAt: "2026-04-03T00:00:00.000Z",
+		};
+
+		savePreferences(tmpDir, prefs);
+		const loaded = loadPreferences(tmpDir);
+
+		expect(loaded.rules["rule-a"]?.dismissCount).toBe(3);
+		expect(loaded.rules["rule-a"]?.totalCount).toBe(7);
+		expect(loaded.rules["rule-a"]?.falsePositiveRate).toBeCloseTo(3 / 7, 5);
+		expect(loaded.rules["rule-b"]?.dismissCount).toBe(0);
+		expect(loaded.rules["rule-b"]?.totalCount).toBe(5);
+		expect(loaded.updatedAt).toBe("2026-04-03T00:00:00.000Z");
+	});
+});

package/src/feedback/collector.ts

@@ -0,0 +1,135 @@
+import { hashContent } from "../cache/keys";
+import { getFeedbackDb } from "../db/index";
+import { recordOutcome } from "../prompts/engine";
+import { compressReview, storeCompressedReview } from "./compress";
+
+export interface FeedbackRecord {
+	promptHash: string;
+	task: string;
+	accepted: boolean;
+	modification?: string;
+	timestamp: string;
+}
+
+/**
+ * Record feedback for an AI interaction.
+ * Appends to feedback.db using existing recordOutcome from prompts/engine.
+ */
+export function recordFeedback(mainaDir: string, record: FeedbackRecord): void {
+	recordOutcome(mainaDir, record.promptHash, {
+		accepted: record.accepted,
+		command: record.task,
+		context: record.modification ?? undefined,
+	});
+}
+
+/**
+ * Get feedback summary for a task.
+ */
+export function getFeedbackSummary(
+	mainaDir: string,
+	task: string,
+): {
+	total: number;
+	accepted: number;
+	rejected: number;
+	acceptRate: number;
+} {
+	const dbResult = getFeedbackDb(mainaDir);
+	if (!dbResult.ok) {
+		return { total: 0, accepted: 0, rejected: 0, acceptRate: 0 };
+	}
+
+	const { db } = dbResult.value;
+
+	const row = db
+		.query(
+			`SELECT
+				COUNT(*) as total,
+				SUM(CASE WHEN accepted = 1 THEN 1 ELSE 0 END) as accepted_count
+			 FROM feedback WHERE command = ?`,
+		)
+		.get(task) as { total: number; accepted_count: number } | null;
+
+	if (!row || row.total === 0) {
+		return { total: 0, accepted: 0, rejected: 0, acceptRate: 0 };
+	}
+
+	const total = row.total;
+	const accepted = row.accepted_count;
+	const rejected = total - accepted;
+
+	return {
+		total,
+		accepted,
+		rejected,
+		acceptRate: total > 0 ? accepted / total : 0,
+	};
+}
+
+/**
+ * Record feedback and, if the review was accepted, compress and store
+ * it as an episodic entry for future context.
+ */
+export function recordFeedbackWithCompression(
+	mainaDir: string,
+	record: FeedbackRecord & { aiOutput?: string; diff?: string },
+): void {
+	// Record the feedback
+	recordFeedback(mainaDir, record);
+
+	// If accepted review, compress and store as episodic
+	if (record.accepted && record.task === "review" && record.aiOutput) {
+		const compressed = compressReview({
+			diff: record.diff ?? "",
+			aiOutput: record.aiOutput,
+			task: record.task,
+			accepted: true,
+		});
+		if (compressed) {
+			storeCompressedReview(mainaDir, compressed, record.task);
+		}
+	}
+}
+
+/**
+ * Record feedback asynchronously — never blocks the calling command.
+ * Uses queueMicrotask for zero-latency fire-and-forget.
+ */
+export function recordFeedbackAsync(
+	mainaDir: string,
+	record: FeedbackRecord & {
+		workflowStep?: string;
+		workflowId?: string;
+	},
+): void {
+	queueMicrotask(() => {
+		try {
+			// Use existing recordFeedback for the base record
+			recordFeedback(mainaDir, record);
+
+			// Write workflow columns directly if provided
+			if (record.workflowStep || record.workflowId) {
+				const dbResult = getFeedbackDb(mainaDir);
+				if (!dbResult.ok) return;
+				const { db } = dbResult.value;
+
+				// Update the most recent row for this prompt hash
+				db.prepare(
+					`UPDATE feedback SET workflow_step = ?, workflow_id = ?
+           WHERE id = (SELECT id FROM feedback ORDER BY created_at DESC LIMIT 1)`,
+				).run(record.workflowStep ?? null, record.workflowId ?? null);
+			}
+		} catch {
+			// Never throw from background feedback
+		}
+	});
+}
+
+/**
+ * Generate a workflow ID from a branch name.
+ * All commands on the same branch share the same workflow ID.
+ */
+export function getWorkflowId(branchName: string): string {
+	return hashContent(`workflow:${branchName}`).slice(0, 12);
+}

package/src/feedback/compress.ts

@@ -0,0 +1,92 @@
+import { addEntry } from "../context/episodic";
+
+/** Maximum character length for compressed review (approx 500 tokens) */
+const MAX_COMPRESSED_CHARS = 2000;
+
+/**
+ * Compress an accepted AI review into a short episodic entry
+ * suitable as a few-shot example for future context.
+ *
+ * Target: under 500 tokens per compressed entry.
+ */
+export function compressReview(review: {
+	diff: string;
+	aiOutput: string;
+	task: string;
+	accepted: boolean;
+}): string | null {
+	if (!review.accepted) return null;
+
+	// Extract file names from diff headers (+++ b/path)
+	const fileRegex = /^\+\+\+ b\/(.+)$/gm;
+	const files: string[] = [];
+	let match: RegExpExecArray | null = null;
+	match = fileRegex.exec(review.diff);
+	while (match !== null) {
+		files.push(match[1] as string);
+		match = fileRegex.exec(review.diff);
+	}
+	const uniqueFiles = [...new Set(files)];
+
+	// Extract key findings from AI output (lines with issue/fix/error/warning keywords)
+	const findingKeywords = /\b(issue|fix|error|warning|bug|problem|critical)\b/i;
+	const aiLines = review.aiOutput.split("\n");
+	const findings = aiLines.filter((line) => findingKeywords.test(line));
+
+	// Extract verdict/summary (look for lines starting with "Overall", "Summary", "Verdict", or last non-empty line)
+	const verdictRegex = /^(overall|summary|verdict|conclusion)\b/i;
+	let verdict = aiLines.find((line) => verdictRegex.test(line.trim()));
+	if (!verdict) {
+		// Fall back to last non-empty, non-finding line
+		const nonEmpty = aiLines.filter(
+			(line) => line.trim().length > 0 && !findingKeywords.test(line),
+		);
+		verdict = nonEmpty[nonEmpty.length - 1] ?? "";
+	}
+
+	// Build the compressed entry
+	const parts: string[] = [];
+
+	parts.push(`[${review.task}] Accepted review`);
+
+	if (uniqueFiles.length > 0) {
+		parts.push(`Files: ${uniqueFiles.join(", ")}`);
+	}
+
+	if (findings.length > 0) {
+		// Limit findings to keep under budget
+		const limitedFindings = findings.slice(0, 10);
+		parts.push("Findings:");
+		for (const f of limitedFindings) {
+			parts.push(`  - ${f.trim()}`);
+		}
+	}
+
+	if (verdict) {
+		parts.push(`Verdict: ${verdict.trim()}`);
+	}
+
+	let compressed = parts.join("\n");
+
+	// Trim to MAX_COMPRESSED_CHARS
+	if (compressed.length > MAX_COMPRESSED_CHARS) {
+		compressed = `${compressed.slice(0, MAX_COMPRESSED_CHARS - 3)}...`;
+	}
+
+	return compressed;
+}
+
+/**
+ * Store a compressed review as an episodic entry.
+ */
+export function storeCompressedReview(
+	mainaDir: string,
+	compressed: string,
+	task: string,
+): void {
+	addEntry(mainaDir, {
+		content: compressed,
+		summary: task === "review" ? "Accepted review" : `Accepted ${task} review`,
+		type: "review",
+	});
+}

package/src/feedback/preferences.ts

@@ -0,0 +1,108 @@
+import { existsSync, readFileSync, writeFileSync } from "node:fs";
+import { join } from "node:path";
+
+export interface RulePreference {
+	ruleId: string;
+	dismissCount: number;
+	totalCount: number;
+	falsePositiveRate: number;
+}
+
+export interface Preferences {
+	rules: Record<string, RulePreference>;
+	updatedAt: string;
+}
+
+const MIN_RULE_SAMPLES = 5;
+
+const PREFS_FILE = "preferences.json";
+
+function prefsPath(mainaDir: string): string {
+	return join(mainaDir, PREFS_FILE);
+}
+
+/**
+ * Load preferences from .maina/preferences.json.
+ * Returns defaults when no file exists.
+ */
+export function loadPreferences(mainaDir: string): Preferences {
+	const path = prefsPath(mainaDir);
+	if (!existsSync(path)) {
+		return {
+			rules: {},
+			updatedAt: new Date().toISOString(),
+		};
+	}
+
+	try {
+		const raw = readFileSync(path, "utf-8");
+		return JSON.parse(raw) as Preferences;
+	} catch {
+		return {
+			rules: {},
+			updatedAt: new Date().toISOString(),
+		};
+	}
+}
+
+/**
+ * Save preferences to .maina/preferences.json.
+ */
+export function savePreferences(mainaDir: string, prefs: Preferences): void {
+	const path = prefsPath(mainaDir);
+	writeFileSync(path, JSON.stringify(prefs, null, 2), "utf-8");
+}
+
+function ensureRule(prefs: Preferences, ruleId: string): RulePreference {
+	if (!prefs.rules[ruleId]) {
+		prefs.rules[ruleId] = {
+			ruleId,
+			dismissCount: 0,
+			totalCount: 0,
+			falsePositiveRate: 0,
+		};
+	}
+	return prefs.rules[ruleId];
+}
+
+function updateRate(rule: RulePreference): void {
+	rule.falsePositiveRate =
+		rule.totalCount > 0 ? rule.dismissCount / rule.totalCount : 0;
+}
+
+/**
+ * Record a finding dismissal (user saw it and chose to ignore it).
+ */
+export function dismissFinding(mainaDir: string, ruleId: string): void {
+	const prefs = loadPreferences(mainaDir);
+	const rule = ensureRule(prefs, ruleId);
+	rule.dismissCount += 1;
+	rule.totalCount += 1;
+	updateRate(rule);
+	prefs.updatedAt = new Date().toISOString();
+	savePreferences(mainaDir, prefs);
+}
+
+/**
+ * Record a finding acknowledgment (user saw it and it was valid).
+ */
+export function acknowledgeFinding(mainaDir: string, ruleId: string): void {
+	const prefs = loadPreferences(mainaDir);
+	const rule = ensureRule(prefs, ruleId);
+	rule.totalCount += 1;
+	updateRate(rule);
+	prefs.updatedAt = new Date().toISOString();
+	savePreferences(mainaDir, prefs);
+}
+
+/**
+ * Get rules with high false positive rates (>50% dismissed).
+ * These should be downgraded in severity or suppressed.
+ */
+export function getNoisyRules(mainaDir: string): RulePreference[] {
+	const prefs = loadPreferences(mainaDir);
+	return Object.values(prefs.rules).filter(
+		(rule) =>
+			rule.falsePositiveRate > 0.5 && rule.totalCount >= MIN_RULE_SAMPLES,
+	);
+}

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

@@ -0,0 +1,62 @@
+import { describe, expect, test } from "bun:test";
+import {
+	getBranchName,
+	getChangedFiles,
+	getCurrentBranch,
+	getDiff,
+	getRecentCommits,
+	getRepoRoot,
+	getStagedFiles,
+} from "../index";
+
+describe("git operations", () => {
+	test("getCurrentBranch() returns a non-empty string", async () => {
+		const branch = await getCurrentBranch();
+		expect(typeof branch).toBe("string");
+		expect(branch.length).toBeGreaterThan(0);
+	});
+
+	test("getBranchName() is an alias for getCurrentBranch()", async () => {
+		const branch = await getBranchName();
+		expect(typeof branch).toBe("string");
+		expect(branch.length).toBeGreaterThan(0);
+	});
+
+	test("getRepoRoot() returns a path that contains 'maina'", async () => {
+		const root = await getRepoRoot();
+		expect(typeof root).toBe("string");
+		expect(root).toContain("maina");
+	});
+
+	test("getRecentCommits(5) returns an array (may be empty for new repo)", async () => {
+		const commits = await getRecentCommits(5);
+		expect(Array.isArray(commits)).toBe(true);
+		for (const commit of commits) {
+			expect(typeof commit.hash).toBe("string");
+			expect(typeof commit.message).toBe("string");
+			expect(typeof commit.author).toBe("string");
+			expect(typeof commit.date).toBe("string");
+		}
+	});
+
+	test("getChangedFiles() returns an array of strings", async () => {
+		const files = await getChangedFiles();
+		expect(Array.isArray(files)).toBe(true);
+		for (const file of files) {
+			expect(typeof file).toBe("string");
+		}
+	});
+
+	test("getStagedFiles() returns an array", async () => {
+		const files = await getStagedFiles();
+		expect(Array.isArray(files)).toBe(true);
+		for (const file of files) {
+			expect(typeof file).toBe("string");
+		}
+	});
+
+	test("getDiff() returns a string", async () => {
+		const diff = await getDiff();
+		expect(typeof diff).toBe("string");
+	});
+});

package/src/git/index.ts

@@ -0,0 +1,110 @@
+export interface Commit {
+	hash: string;
+	message: string;
+	author: string;
+	date: string;
+}
+
+async function exec(
+	args: string[],
+	cwd: string = process.cwd(),
+): Promise<string> {
+	try {
+		const proc = Bun.spawn(["git", ...args], {
+			cwd,
+			stdout: "pipe",
+			stderr: "pipe",
+		});
+		const output = await new Response(proc.stdout).text();
+		const exitCode = await proc.exited;
+		if (exitCode !== 0) return "";
+		return output.trim();
+	} catch {
+		return "";
+	}
+}
+
+export async function getCurrentBranch(cwd?: string): Promise<string> {
+	const branch = await exec(["rev-parse", "--abbrev-ref", "HEAD"], cwd);
+	return branch;
+}
+
+export async function getBranchName(cwd?: string): Promise<string> {
+	return getCurrentBranch(cwd);
+}
+
+export async function getRepoRoot(cwd?: string): Promise<string> {
+	const root = await exec(["rev-parse", "--show-toplevel"], cwd);
+	return root;
+}
+
+export async function getRecentCommits(
+	n: number,
+	cwd?: string,
+): Promise<Commit[]> {
+	const separator = "|||";
+	const format = `%H${separator}%s${separator}%an${separator}%ai`;
+	const output = await exec(["log", `-${n}`, `--pretty=format:${format}`], cwd);
+	if (!output) return [];
+	return output
+		.split("\n")
+		.filter((line) => line.trim().length > 0)
+		.map((line) => {
+			const parts = line.split(separator);
+			return {
+				hash: parts[0]?.trim() ?? "",
+				message: parts[1]?.trim() ?? "",
+				author: parts[2]?.trim() ?? "",
+				date: parts[3]?.trim() ?? "",
+			};
+		});
+}
+
+export async function getChangedFiles(
+	since?: string,
+	cwd?: string,
+): Promise<string[]> {
+	let output: string;
+	if (since) {
+		output = await exec(["diff", "--name-only", since], cwd);
+	} else {
+		output = await exec(["status", "--porcelain"], cwd);
+		if (!output) return [];
+		return output
+			.split("\n")
+			.filter((line) => line.trim().length > 0)
+			.map((line) => line.slice(3).trim());
+	}
+	if (!output) return [];
+	return output.split("\n").filter((line) => line.trim().length > 0);
+}
+
+export async function getDiff(
+	ref1?: string,
+	ref2?: string,
+	cwd?: string,
+): Promise<string> {
+	const args: string[] = ["diff"];
+	if (ref1 && ref2) {
+		args.push(ref1, ref2);
+	} else if (ref1) {
+		args.push(ref1);
+	}
+	const output = await exec(args, cwd);
+	return output;
+}
+
+export async function getStagedFiles(cwd?: string): Promise<string[]> {
+	const output = await exec(["diff", "--cached", "--name-only"], cwd);
+	if (!output) return [];
+	return output.split("\n").filter((line) => line.trim().length > 0);
+}
+
+export async function getTrackedFiles(cwd?: string): Promise<string[]> {
+	const output = await exec(
+		["ls-files", "--cached", "--exclude-standard"],
+		cwd,
+	);
+	if (!output) return [];
+	return output.split("\n").filter((line) => line.trim().length > 0);
+}