@mainahq/core 0.2.0

package/src/context/__tests__/retrieval.test.ts

@@ -0,0 +1,143 @@
+import { describe, expect, test } from "bun:test";
+import type { SearchResult } from "../retrieval";
+import {
+	assembleRetrievalText,
+	isToolAvailable,
+	parseZoektOutput,
+	search,
+} from "../retrieval";
+
+describe("isToolAvailable", () => {
+	test("returns true for 'git' (always available)", async () => {
+		const result = await isToolAvailable("git");
+		expect(result).toBe(true);
+	});
+
+	test("returns false for 'nonexistent-tool-xyz'", async () => {
+		const result = await isToolAvailable("nonexistent-tool-xyz");
+		expect(result).toBe(false);
+	});
+});
+
+describe("search", () => {
+	test("finds known symbol in codebase", async () => {
+		const results = await search("getCurrentBranch", {
+			cwd: process.cwd(),
+		});
+		expect(results.length).toBeGreaterThan(0);
+		// At least one result should contain the search term
+		const hasMatch = results.some((r) =>
+			r.content.includes("getCurrentBranch"),
+		);
+		expect(hasMatch).toBe(true);
+	});
+
+	test("respects maxResults limit", async () => {
+		// Search for something that appears many times (e.g. 'export')
+		const results = await search("export", {
+			cwd: process.cwd(),
+			maxResults: 3,
+		});
+		expect(results.length).toBeLessThanOrEqual(3);
+	});
+
+	test("returns empty array for nonsense query", async () => {
+		// Use a pattern that cannot appear in real source code
+		const needle = ["ZZZZ", "QQQQ", "NOSUCHSYMBOL", "9999"].join("__");
+		const results = await search(needle, {
+			cwd: process.cwd(),
+		});
+		expect(results).toEqual([]);
+	});
+
+	test("returns an array (never throws)", async () => {
+		// Even with a bad cwd, should not throw
+		const results = await search("anything", {
+			cwd: "/nonexistent/path/xyz",
+		});
+		expect(Array.isArray(results)).toBe(true);
+	});
+});
+
+describe("parseZoektOutput", () => {
+	test("parses zoekt text output into SearchResult[]", () => {
+		const output = `src/app.ts:10:export function main() {
+src/app.ts:11:  return true;
+src/utils.ts:5:export const helper = () => {};`;
+
+		const results = parseZoektOutput(output);
+		expect(results).toHaveLength(3);
+		expect(results[0]?.filePath).toBe("src/app.ts");
+		expect(results[0]?.line).toBe(10);
+		expect(results[0]?.content).toBe("export function main() {");
+	});
+
+	test("handles empty output", () => {
+		expect(parseZoektOutput("")).toHaveLength(0);
+	});
+
+	test("skips malformed lines", () => {
+		const output = `src/app.ts:10:valid line
+not a valid line
+another:bad
+src/utils.ts:5:also valid`;
+		const results = parseZoektOutput(output);
+		expect(results).toHaveLength(2);
+	});
+
+	test("handles zoekt header lines gracefully", () => {
+		const output = `Repository: maina
+src/app.ts:10:export function main() {
+src/app.ts:11:  return true;`;
+		const results = parseZoektOutput(output);
+		// Should skip the Repository: line
+		expect(results).toHaveLength(2);
+	});
+});
+
+describe("searchWithZoekt", () => {
+	test("should skip when zoekt is not available", async () => {
+		// zoekt is almost certainly not installed in test environment
+		const { searchWithZoekt } = await import("../retrieval");
+		const results = await searchWithZoekt("testquery", { cwd: process.cwd() });
+		// Either returns results (if zoekt installed) or empty array (not installed)
+		expect(Array.isArray(results)).toBe(true);
+	});
+});
+
+describe("assembleRetrievalText", () => {
+	test("formats results as 'filePath:line: content'", () => {
+		const results: SearchResult[] = [
+			{
+				filePath: "src/foo.ts",
+				line: 10,
+				content: "export function foo() {}",
+				matchLength: 3,
+			},
+			{
+				filePath: "src/bar.ts",
+				line: 42,
+				content: "const bar = 1;",
+				matchLength: 3,
+			},
+		];
+		const text = assembleRetrievalText(results);
+		expect(text).toContain("src/foo.ts:10: export function foo() {}");
+		expect(text).toContain("src/bar.ts:42: const bar = 1;");
+	});
+
+	test("returns empty string for empty results", () => {
+		const text = assembleRetrievalText([]);
+		expect(text).toBe("");
+	});
+
+	test("separates results with newlines", () => {
+		const results: SearchResult[] = [
+			{ filePath: "a.ts", line: 1, content: "line one", matchLength: 4 },
+			{ filePath: "b.ts", line: 2, content: "line two", matchLength: 4 },
+		];
+		const text = assembleRetrievalText(results);
+		const lines = text.split("\n");
+		expect(lines.length).toBe(2);
+	});
+});

package/src/context/__tests__/selector.test.ts

@@ -0,0 +1,174 @@
+import { describe, expect, it } from "bun:test";
+import type { BudgetMode } from "../budget.ts";
+import { getBudgetMode, getContextNeeds, needsLayer } from "../selector.ts";
+
+describe("getContextNeeds", () => {
+	it("commit needs only working + conventions", () => {
+		const needs = getContextNeeds("commit");
+		expect(needs.working).toBe(true);
+		expect(needs.episodic).toBe(false);
+		expect(needs.semantic).toEqual(["conventions"]);
+		expect(needs.retrieval).toBe(false);
+	});
+
+	it("context command needs all 4 layers", () => {
+		const needs = getContextNeeds("context");
+		expect(needs.working).toBe(true);
+		expect(needs.episodic).toBe(true);
+		expect(needs.semantic).toBe(true);
+		expect(needs.retrieval).toBe(true);
+	});
+
+	it("verify needs working + recent-reviews + adrs + conventions", () => {
+		const needs = getContextNeeds("verify");
+		expect(needs.working).toBe(true);
+		expect(needs.episodic).toEqual(["recent-reviews"]);
+		expect(needs.semantic).toEqual(["adrs", "conventions"]);
+		expect(needs.retrieval).toBe(false);
+	});
+
+	it("review returns correct context needs", () => {
+		const needs = getContextNeeds("review");
+		expect(needs.working).toBe(true);
+		expect(needs.episodic).toEqual(["past-reviews"]);
+		expect(needs.semantic).toEqual(["adrs"]);
+		expect(needs.retrieval).toBe(false);
+	});
+
+	it("plan returns correct context needs", () => {
+		const needs = getContextNeeds("plan");
+		expect(needs.working).toBe(true);
+		expect(needs.semantic).toEqual(["adrs", "conventions"]);
+		expect(needs.episodic).toBe(false);
+		expect(needs.retrieval).toBe(false);
+	});
+
+	it("explain returns correct context needs", () => {
+		const needs = getContextNeeds("explain");
+		expect(needs.working).toBe(true);
+		expect(needs.episodic).toBe(false);
+		expect(needs.semantic).toBe(true);
+		expect(needs.retrieval).toBe(true);
+	});
+
+	it("design returns correct context needs", () => {
+		const needs = getContextNeeds("design");
+		expect(needs.working).toBe(true);
+		expect(needs.episodic).toBe(false);
+		expect(needs.semantic).toEqual(["adrs"]);
+		expect(needs.retrieval).toBe(false);
+	});
+
+	it("ticket returns correct context needs", () => {
+		const needs = getContextNeeds("ticket");
+		expect(needs.working).toBe(false);
+		expect(needs.episodic).toBe(false);
+		expect(needs.semantic).toEqual(["modules"]);
+		expect(needs.retrieval).toBe(false);
+	});
+
+	it("analyze returns correct context needs", () => {
+		const needs = getContextNeeds("analyze");
+		expect(needs.working).toBe(true);
+		expect(needs.episodic).toBe(true);
+		expect(needs.semantic).toBe(true);
+		expect(needs.retrieval).toBe(false);
+	});
+
+	it("pr returns correct context needs", () => {
+		const needs = getContextNeeds("pr");
+		expect(needs.working).toBe(true);
+		expect(needs.episodic).toEqual(["past-reviews"]);
+		expect(needs.semantic).toBe(true);
+		expect(needs.retrieval).toBe(true);
+	});
+});
+
+describe("needsLayer", () => {
+	it("correctly identifies when working layer is needed", () => {
+		const needs = getContextNeeds("commit");
+		expect(needsLayer(needs, "working")).toBe(true);
+	});
+
+	it("correctly identifies when working layer is not needed", () => {
+		const needs = getContextNeeds("ticket");
+		expect(needsLayer(needs, "working")).toBe(false);
+	});
+
+	it("correctly identifies when episodic layer is needed (true)", () => {
+		const needs = getContextNeeds("context");
+		expect(needsLayer(needs, "episodic")).toBe(true);
+	});
+
+	it("correctly identifies when episodic layer is needed (string[])", () => {
+		const needs = getContextNeeds("verify");
+		expect(needsLayer(needs, "episodic")).toBe(true);
+	});
+
+	it("correctly identifies when episodic layer is not needed", () => {
+		const needs = getContextNeeds("commit");
+		expect(needsLayer(needs, "episodic")).toBe(false);
+	});
+
+	it("correctly identifies when semantic layer is needed (true)", () => {
+		const needs = getContextNeeds("context");
+		expect(needsLayer(needs, "semantic")).toBe(true);
+	});
+
+	it("correctly identifies when semantic layer is needed (string[])", () => {
+		const needs = getContextNeeds("commit");
+		expect(needsLayer(needs, "semantic")).toBe(true);
+	});
+
+	it("correctly identifies when retrieval layer is needed", () => {
+		const needs = getContextNeeds("context");
+		expect(needsLayer(needs, "retrieval")).toBe(true);
+	});
+
+	it("correctly identifies when retrieval layer is not needed", () => {
+		const needs = getContextNeeds("commit");
+		expect(needsLayer(needs, "retrieval")).toBe(false);
+	});
+});
+
+describe("getBudgetMode", () => {
+	it("commit uses focused budget mode", () => {
+		expect(getBudgetMode("commit")).toBe("focused" satisfies BudgetMode);
+	});
+
+	it("context uses explore budget mode", () => {
+		expect(getBudgetMode("context")).toBe("explore" satisfies BudgetMode);
+	});
+
+	it("explain uses explore budget mode", () => {
+		expect(getBudgetMode("explain")).toBe("explore" satisfies BudgetMode);
+	});
+
+	it("review uses default budget mode", () => {
+		expect(getBudgetMode("review")).toBe("default" satisfies BudgetMode);
+	});
+
+	it("verify uses default budget mode", () => {
+		expect(getBudgetMode("verify")).toBe("default" satisfies BudgetMode);
+	});
+
+	it("plan uses default budget mode", () => {
+		expect(getBudgetMode("plan")).toBe("default" satisfies BudgetMode);
+	});
+
+	it("design uses default budget mode", () => {
+		expect(getBudgetMode("design")).toBe("default" satisfies BudgetMode);
+	});
+
+	it("ticket uses default budget mode", () => {
+		expect(getBudgetMode("ticket")).toBe("default" satisfies BudgetMode);
+	});
+
+	it("analyze uses default budget mode", () => {
+		expect(getBudgetMode("analyze")).toBe("default" satisfies BudgetMode);
+	});
+
+	it("pr uses default budget mode", () => {
+		expect(getBudgetMode("pr")).toBe("default" satisfies BudgetMode);
+	});
+});

package/src/context/__tests__/semantic.test.ts

@@ -0,0 +1,252 @@
+import { afterAll, beforeAll, describe, expect, test } from "bun:test";
+import { mkdirSync, rmSync, writeFileSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import type { DependencyGraph } from "../relevance";
+import {
+	assembleSemanticText,
+	getTopEntities,
+	loadConstitution,
+	loadCustomContext,
+	type SemanticContext,
+} from "../semantic";
+
+const TEST_DIR = join(tmpdir(), `maina-semantic-test-${Date.now()}`);
+const MAINA_DIR = join(TEST_DIR, ".maina");
+
+beforeAll(() => {
+	mkdirSync(TEST_DIR, { recursive: true });
+	mkdirSync(MAINA_DIR, { recursive: true });
+});
+
+afterAll(() => {
+	rmSync(TEST_DIR, { recursive: true, force: true });
+});
+
+describe("loadConstitution", () => {
+	test("returns null when constitution.md does not exist", async () => {
+		const result = await loadConstitution(MAINA_DIR);
+		expect(result).toBeNull();
+	});
+
+	test("reads content when constitution.md exists", async () => {
+		const constitutionPath = join(MAINA_DIR, "constitution.md");
+		const content = "# Project Constitution\n\nUse TypeScript everywhere.\n";
+		writeFileSync(constitutionPath, content);
+
+		const result = await loadConstitution(MAINA_DIR);
+		expect(result).toBe(content);
+	});
+});
+
+describe("loadCustomContext", () => {
+	test("returns empty array when custom directory does not exist", async () => {
+		const freshMainaDir = join(TEST_DIR, ".maina-fresh");
+		mkdirSync(freshMainaDir, { recursive: true });
+
+		const result = await loadCustomContext(freshMainaDir);
+		expect(result).toEqual([]);
+	});
+
+	test("reads files from the custom directory", async () => {
+		const customDir = join(MAINA_DIR, "context", "semantic", "custom");
+		mkdirSync(customDir, { recursive: true });
+
+		writeFileSync(
+			join(customDir, "conventions.md"),
+			"# Conventions\n\nUse tabs.\n",
+		);
+		writeFileSync(
+			join(customDir, "adrs.md"),
+			"# ADRs\n\nADR-001: Use SQLite.\n",
+		);
+
+		const result = await loadCustomContext(MAINA_DIR);
+		expect(result.length).toBe(2);
+
+		// Should contain the file contents (order may vary)
+		const combined = result.join("\n");
+		expect(combined).toContain("Conventions");
+		expect(combined).toContain("ADRs");
+	});
+
+	test("returns empty array for empty custom directory", async () => {
+		const emptyMainaDir = join(TEST_DIR, ".maina-empty");
+		const emptyCustomDir = join(emptyMainaDir, "context", "semantic", "custom");
+		mkdirSync(emptyCustomDir, { recursive: true });
+
+		const result = await loadCustomContext(emptyMainaDir);
+		expect(result).toEqual([]);
+	});
+});
+
+// Helper to build a minimal SemanticContext for testing
+function makeContext(
+	overrides: Partial<SemanticContext> = {},
+): SemanticContext {
+	const graph: DependencyGraph = {
+		nodes: new Set(["fileA.ts", "fileB.ts"]),
+		edges: new Map(),
+	};
+
+	return {
+		entities: [
+			{
+				filePath: "fileA.ts",
+				name: "doSomething",
+				kind: "function",
+				relevance: 0.8,
+			},
+			{ filePath: "fileA.ts", name: "MyClass", kind: "class", relevance: 0.6 },
+			{
+				filePath: "fileB.ts",
+				name: "helper",
+				kind: "function",
+				relevance: 0.3,
+			},
+			{
+				filePath: "fileB.ts",
+				name: "IConfig",
+				kind: "interface",
+				relevance: 0.2,
+			},
+			{
+				filePath: "fileA.ts",
+				name: "lowRelevance",
+				kind: "variable",
+				relevance: 0.1,
+			},
+		],
+		graph,
+		scores: new Map([
+			["fileA.ts", 0.7],
+			["fileB.ts", 0.3],
+		]),
+		constitution: null,
+		customContext: [],
+		...overrides,
+	};
+}
+
+describe("getTopEntities", () => {
+	test("returns top N entities by relevance score", () => {
+		const context = makeContext();
+		const top3 = getTopEntities(context, 3);
+
+		expect(top3).toHaveLength(3);
+		expect(top3[0]?.name).toBe("doSomething");
+		expect(top3[1]?.name).toBe("MyClass");
+		expect(top3[2]?.name).toBe("helper");
+	});
+
+	test("returns top 20 by default", () => {
+		// Create context with fewer than 20 entities
+		const context = makeContext();
+		const result = getTopEntities(context);
+
+		// Since we only have 5 entities, all should be returned
+		expect(result.length).toBeLessThanOrEqual(20);
+		expect(result.length).toBe(5);
+	});
+
+	test("returns limited results when n is smaller than total", () => {
+		const context = makeContext();
+		const top1 = getTopEntities(context, 1);
+
+		expect(top1).toHaveLength(1);
+		expect(top1[0]?.name).toBe("doSomething");
+	});
+
+	test("returns all entities when n is larger than total", () => {
+		const context = makeContext();
+		const result = getTopEntities(context, 100);
+
+		expect(result).toHaveLength(5);
+	});
+
+	test("entities are sorted by relevance descending", () => {
+		const context = makeContext();
+		const result = getTopEntities(context);
+
+		for (let i = 1; i < result.length; i++) {
+			const prev = result[i - 1]?.relevance ?? 0;
+			const curr = result[i]?.relevance ?? 0;
+			expect(prev).toBeGreaterThanOrEqual(curr);
+		}
+	});
+});
+
+describe("assembleSemanticText", () => {
+	test("includes constitution when present", () => {
+		const context = makeContext({
+			constitution: "# My Constitution\n\nAlways write tests first.\n",
+		});
+
+		const text = assembleSemanticText(context);
+		expect(text).toContain("Constitution");
+		expect(text).toContain("Always write tests first");
+	});
+
+	test("does not include constitution section when null", () => {
+		const context = makeContext({ constitution: null });
+
+		const text = assembleSemanticText(context);
+		// Should not have an empty constitution block
+		expect(text).not.toContain("Always write tests first");
+	});
+
+	test("includes custom context when present", () => {
+		const context = makeContext({
+			customContext: [
+				"# Conventions\n\nUse tabs.",
+				"# ADRs\n\nADR-001: SQLite.",
+			],
+		});
+
+		const text = assembleSemanticText(context);
+		expect(text).toContain("Conventions");
+		expect(text).toContain("ADRs");
+	});
+
+	test("includes top entities section", () => {
+		const context = makeContext();
+		const text = assembleSemanticText(context);
+
+		expect(text).toContain("doSomething");
+		expect(text).toContain("MyClass");
+	});
+
+	test("with filter 'conventions' only includes relevant parts", () => {
+		const context = makeContext({
+			constitution: "# My Constitution\n\nAlways write tests first.\n",
+			customContext: [
+				"# Conventions\n\nUse tabs.",
+				"# ADRs\n\nADR-001: SQLite.",
+			],
+		});
+
+		const text = assembleSemanticText(context, ["conventions"]);
+		expect(text).toContain("Conventions");
+		// When filtered, might not include all sections — at minimum includes conventions
+	});
+
+	test("with filter 'adrs' only includes ADR content", () => {
+		const context = makeContext({
+			constitution: "# My Constitution\n\nAlways write tests first.\n",
+			customContext: [
+				"# Conventions\n\nUse tabs.",
+				"# ADRs\n\nADR-001: SQLite.",
+			],
+		});
+
+		const text = assembleSemanticText(context, ["adrs"]);
+		expect(text).toContain("ADR");
+	});
+
+	test("returns non-empty string for minimal context", () => {
+		const context = makeContext();
+		const text = assembleSemanticText(context);
+
+		expect(text.length).toBeGreaterThan(0);
+	});
+});