@mainahq/core 0.2.0

package/src/ticket/__tests__/ticket.test.ts

@@ -0,0 +1,273 @@
+import { afterAll, beforeAll, describe, expect, test } from "bun:test";
+import { mkdirSync, rmSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import { getContextDb } from "../../db/index.ts";
+import { buildIssueBody, createTicket, detectModules } from "../index.ts";
+
+const TEST_DIR = join(tmpdir(), `maina-ticket-test-${Date.now()}`);
+
+beforeAll(() => {
+	mkdirSync(TEST_DIR, { recursive: true });
+});
+
+afterAll(() => {
+	rmSync(TEST_DIR, { recursive: true, force: true });
+});
+
+// ── detectModules ───────────────────────────────────────────────────────────
+
+describe("detectModules", () => {
+	test("returns empty array when DB does not exist", async () => {
+		const nonExistent = join(TEST_DIR, "no-such-dir");
+		const result = detectModules(nonExistent, "some title", "some body");
+		expect(result).toEqual([]);
+	});
+
+	test("returns empty array when no entities match keywords", () => {
+		const mainaDir = join(TEST_DIR, "no-match");
+		mkdirSync(mainaDir, { recursive: true });
+
+		// Create DB with entities that don't match
+		const dbResult = getContextDb(mainaDir);
+		expect(dbResult.ok).toBe(true);
+		if (!dbResult.ok) return;
+		const { db } = dbResult.value;
+
+		// Insert a semantic entity in the "auth" module
+		db.exec(`
+			INSERT INTO semantic_entities (id, file_path, name, kind, start_line, end_line, updated_at)
+			VALUES ('e1', 'src/auth/login.ts', 'login', 'function', 1, 10, '2026-01-01')
+		`);
+
+		const modules = detectModules(
+			mainaDir,
+			"fix database query",
+			"slow query in cache layer",
+		);
+		// "auth" should not match "database query" or "cache layer"
+		// but "cache" is not in the DB, so result should be empty
+		expect(modules).toEqual([]);
+		db.close();
+	});
+
+	test("returns matching module names from semantic entities", () => {
+		const mainaDir = join(TEST_DIR, "match-modules");
+		mkdirSync(mainaDir, { recursive: true });
+
+		const dbResult = getContextDb(mainaDir);
+		expect(dbResult.ok).toBe(true);
+		if (!dbResult.ok) return;
+		const { db } = dbResult.value;
+
+		// Insert entities in different modules
+		db.exec(`
+			INSERT INTO semantic_entities (id, file_path, name, kind, start_line, end_line, updated_at)
+			VALUES
+				('e1', 'src/context/engine.ts', 'assembleContext', 'function', 1, 50, '2026-01-01'),
+				('e2', 'src/verify/pipeline.ts', 'runPipeline', 'function', 1, 30, '2026-01-01'),
+				('e3', 'src/verify/slop.ts', 'detectSlop', 'function', 1, 20, '2026-01-01'),
+				('e4', 'src/cli/commands/commit.ts', 'commitAction', 'function', 1, 40, '2026-01-01')
+		`);
+
+		const modules = detectModules(
+			mainaDir,
+			"Fix context engine budget",
+			"The context assembly is exceeding token budget",
+		);
+
+		expect(modules).toContain("context");
+		expect(modules).not.toContain("cli");
+		db.close();
+	});
+
+	test("deduplicates module names", () => {
+		const mainaDir = join(TEST_DIR, "dedup-modules");
+		mkdirSync(mainaDir, { recursive: true });
+
+		const dbResult = getContextDb(mainaDir);
+		expect(dbResult.ok).toBe(true);
+		if (!dbResult.ok) return;
+		const { db } = dbResult.value;
+
+		// Multiple entities in the same module
+		db.exec(`
+			INSERT INTO semantic_entities (id, file_path, name, kind, start_line, end_line, updated_at)
+			VALUES
+				('e1', 'src/verify/pipeline.ts', 'runPipeline', 'function', 1, 30, '2026-01-01'),
+				('e2', 'src/verify/slop.ts', 'detectSlop', 'function', 1, 20, '2026-01-01'),
+				('e3', 'src/verify/diff-filter.ts', 'filterByDiff', 'function', 1, 15, '2026-01-01')
+		`);
+
+		const modules = detectModules(
+			mainaDir,
+			"Fix verify pipeline",
+			"The verify slop detector has a bug in diff filter",
+		);
+
+		// Should have "verify" only once
+		const verifyCount = modules.filter((m) => m === "verify").length;
+		expect(verifyCount).toBeLessThanOrEqual(1);
+		expect(modules).toContain("verify");
+		db.close();
+	});
+});
+
+// ── buildIssueBody ──────────────────────────────────────────────────────────
+
+describe("buildIssueBody", () => {
+	test("appends Modules section when modules are found", () => {
+		const body = "Fix the context engine budget calculation.";
+		const modules = ["context", "verify", "cli"];
+
+		const result = buildIssueBody(body, modules);
+
+		expect(result).toContain(body);
+		expect(result).toContain("**Modules:** context, verify, cli");
+	});
+
+	test("returns body unchanged when no modules", () => {
+		const body = "Fix the context engine budget calculation.";
+
+		const result = buildIssueBody(body, []);
+
+		expect(result).toBe(body);
+	});
+
+	test("handles empty body with modules", () => {
+		const result = buildIssueBody("", ["core"]);
+
+		expect(result).toContain("**Modules:** core");
+	});
+});
+
+// ── createTicket ────────────────────────────────────────────────────────────
+
+describe("createTicket", () => {
+	test("returns success with url and number on successful gh call", async () => {
+		const mockSpawn = async (_args: string[], _opts?: { cwd?: string }) => ({
+			exitCode: 0,
+			stdout: "https://github.com/owner/repo/issues/42\n",
+			stderr: "",
+		});
+
+		const result = await createTicket(
+			{
+				title: "Test issue",
+				body: "Test body",
+				labels: ["bug"],
+			},
+			{ spawn: mockSpawn },
+		);
+
+		expect(result.ok).toBe(true);
+		if (!result.ok) return;
+		expect(result.value.url).toBe("https://github.com/owner/repo/issues/42");
+		expect(result.value.number).toBe(42);
+	});
+
+	test("passes labels to gh issue create", async () => {
+		let capturedArgs: string[] = [];
+		const mockSpawn = async (args: string[], _opts?: { cwd?: string }) => {
+			capturedArgs = args;
+			return {
+				exitCode: 0,
+				stdout: "https://github.com/owner/repo/issues/1\n",
+				stderr: "",
+			};
+		};
+
+		await createTicket(
+			{
+				title: "Test",
+				body: "Body",
+				labels: ["bug", "context"],
+			},
+			{ spawn: mockSpawn },
+		);
+
+		expect(capturedArgs).toContain("--label");
+		expect(capturedArgs).toContain("bug,context");
+	});
+
+	test("returns error when gh fails", async () => {
+		const mockSpawn = async (_args: string[], _opts?: { cwd?: string }) => ({
+			exitCode: 1,
+			stdout: "",
+			stderr: "gh: not logged in",
+		});
+
+		const result = await createTicket(
+			{
+				title: "Test",
+				body: "Body",
+			},
+			{ spawn: mockSpawn },
+		);
+
+		expect(result.ok).toBe(false);
+		if (result.ok) return;
+		expect(result.error).toContain("gh: not logged in");
+	});
+
+	test("returns error when gh is not installed (spawn throws)", async () => {
+		const mockSpawn = async (_args: string[], _opts?: { cwd?: string }) => {
+			throw new Error("spawn: command not found: gh");
+		};
+
+		const result = await createTicket(
+			{
+				title: "Test",
+				body: "Body",
+			},
+			{ spawn: mockSpawn },
+		);
+
+		expect(result.ok).toBe(false);
+		if (result.ok) return;
+		expect(result.error).toContain("gh");
+	});
+
+	test("extracts issue number from URL", async () => {
+		const mockSpawn = async (_args: string[], _opts?: { cwd?: string }) => ({
+			exitCode: 0,
+			stdout: "https://github.com/bikash/maina/issues/123\n",
+			stderr: "",
+		});
+
+		const result = await createTicket(
+			{
+				title: "Test",
+				body: "Body",
+			},
+			{ spawn: mockSpawn },
+		);
+
+		expect(result.ok).toBe(true);
+		if (!result.ok) return;
+		expect(result.value.number).toBe(123);
+	});
+
+	test("passes cwd to spawn", async () => {
+		let capturedOpts: { cwd?: string } | undefined;
+		const mockSpawn = async (_args: string[], opts?: { cwd?: string }) => {
+			capturedOpts = opts;
+			return {
+				exitCode: 0,
+				stdout: "https://github.com/owner/repo/issues/1\n",
+				stderr: "",
+			};
+		};
+
+		await createTicket(
+			{
+				title: "Test",
+				body: "Body",
+				cwd: "/some/path",
+			},
+			{ spawn: mockSpawn },
+		);
+
+		expect(capturedOpts?.cwd).toBe("/some/path");
+	});
+});

package/src/ticket/index.ts

@@ -0,0 +1,185 @@
+/**
+ * Ticket Module — Create GitHub Issues with automatic module tagging.
+ *
+ * Uses the semantic entity index from the Context Engine DB to detect
+ * which modules are relevant to an issue's title and body, then calls
+ * `gh issue create` to create the issue on GitHub.
+ */
+
+import type { Result } from "../db/index.ts";
+import { getContextDb } from "../db/index.ts";
+
+// ── Types ────────────────────────────────────────────────────────────────────
+
+export interface TicketOptions {
+	title: string;
+	body: string;
+	labels?: string[];
+	cwd?: string;
+}
+
+export interface TicketResult {
+	url: string;
+	number: number;
+}
+
+/** Dependency injection for spawn, enabling testability. */
+export interface SpawnDeps {
+	spawn: (
+		args: string[],
+		opts?: { cwd?: string },
+	) => Promise<{ exitCode: number; stdout: string; stderr: string }>;
+}
+
+// ── Default spawn via Bun.spawn ──────────────────────────────────────────────
+
+async function defaultSpawn(
+	args: string[],
+	opts?: { cwd?: string },
+): Promise<{ exitCode: number; stdout: string; stderr: string }> {
+	const proc = Bun.spawn(args, {
+		cwd: opts?.cwd,
+		stdout: "pipe",
+		stderr: "pipe",
+	});
+
+	const stdout = await new Response(proc.stdout).text();
+	const stderr = await new Response(proc.stderr).text();
+	const exitCode = await proc.exited;
+
+	return { exitCode, stdout, stderr };
+}
+
+const defaultDeps: SpawnDeps = { spawn: defaultSpawn };
+
+// ── detectModules ────────────────────────────────────────────────────────────
+
+/**
+ * Extract module/directory names from the semantic entity index that are
+ * relevant to the given title and body keywords.
+ *
+ * Looks at `file_path` in `semantic_entities` table, extracts the first
+ * directory component after `src/`, and matches against keywords from
+ * the title and body.
+ *
+ * Returns a deduplicated list of module names (e.g., ["context", "verify"]).
+ * If no DB or no matches, returns empty array (graceful).
+ */
+export function detectModules(
+	mainaDir: string,
+	title: string,
+	body: string,
+): string[] {
+	try {
+		const dbResult = getContextDb(mainaDir);
+		if (!dbResult.ok) return [];
+
+		const db = dbResult.value.db;
+		try {
+			// Get all unique module names from semantic entities
+			const rows = db
+				.prepare("SELECT DISTINCT file_path FROM semantic_entities")
+				.all() as Array<{ file_path: string }>;
+
+			if (rows.length === 0) {
+				return [];
+			}
+
+			// Extract module names from file paths (first dir after src/)
+			const moduleSet = new Set<string>();
+			for (const row of rows) {
+				const match = row.file_path.match(/(?:^|\/)?src\/([^/]+)\//);
+				if (match?.[1]) {
+					moduleSet.add(match[1]);
+				}
+			}
+
+			// Build keywords from title + body (lowercase, split by non-alpha)
+			const text = `${title} ${body}`.toLowerCase();
+			const keywords = text.split(/[^a-z0-9]+/).filter((w) => w.length > 2);
+
+			// Match modules against keywords
+			const matched: string[] = [];
+			for (const mod of moduleSet) {
+				const modLower = mod.toLowerCase();
+				if (
+					keywords.some((kw) => modLower.includes(kw) || kw.includes(modLower))
+				) {
+					matched.push(mod);
+				}
+			}
+
+			return [...new Set(matched)];
+		} finally {
+			db.close();
+		}
+	} catch {
+		return [];
+	}
+}
+
+// ── buildIssueBody ──────────────────────────────────────────────────────────
+
+/**
+ * Format the issue body with a module tags section appended.
+ * If modules found: adds `\n\n**Modules:** context, verify, cli`
+ * If no modules: returns body unchanged.
+ */
+export function buildIssueBody(body: string, modules: string[]): string {
+	if (modules.length === 0) return body;
+	return `${body}\n\n**Modules:** ${modules.join(", ")}`;
+}
+
+// ── createTicket ────────────────────────────────────────────────────────────
+
+/**
+ * Create a GitHub Issue via `gh issue create`.
+ * Returns the issue URL and number on success, or an error on failure.
+ * Never throws — all errors are returned as Result Err values.
+ */
+export async function createTicket(
+	options: TicketOptions,
+	deps: SpawnDeps = defaultDeps,
+): Promise<Result<TicketResult>> {
+	try {
+		const args = [
+			"gh",
+			"issue",
+			"create",
+			"--title",
+			options.title,
+			"--body",
+			options.body,
+		];
+
+		if (options.labels && options.labels.length > 0) {
+			args.push("--label", options.labels.join(","));
+		}
+
+		const { exitCode, stdout, stderr } = await deps.spawn(args, {
+			cwd: options.cwd,
+		});
+
+		if (exitCode !== 0) {
+			const message =
+				stderr.trim() || stdout.trim() || "gh issue create failed";
+			return { ok: false, error: message };
+		}
+
+		const url = stdout.trim();
+		const numberMatch = url.match(/\/issues\/(\d+)/);
+		const issueNumber = numberMatch?.[1]
+			? Number.parseInt(numberMatch[1], 10)
+			: 0;
+
+		return {
+			ok: true,
+			value: { url, number: issueNumber },
+		};
+	} catch (e) {
+		return {
+			ok: false,
+			error: e instanceof Error ? e.message : String(e),
+		};
+	}
+}

package/src/utils.ts

@@ -0,0 +1,87 @@
+/**
+ * Shared utility functions used across core modules.
+ */
+
+/**
+ * Convert a string to kebab-case.
+ * Handles: spaces, camelCase, PascalCase, underscores.
+ */
+export function toKebabCase(input: string): string {
+	return (
+		input
+			// Insert hyphen before uppercase letters in camelCase/PascalCase
+			.replace(/([a-z0-9])([A-Z])/g, "$1-$2")
+			// Replace spaces, underscores, and multiple hyphens with single hyphen
+			.replace(/[\s_]+/g, "-")
+			// Remove non-alphanumeric characters except hyphens
+			.replace(/[^a-z0-9-]/gi, "")
+			// Collapse multiple hyphens
+			.replace(/-+/g, "-")
+			// Trim leading/trailing hyphens
+			.replace(/^-|-$/g, "")
+			.toLowerCase()
+	);
+}
+
+/**
+ * Common stop words filtered out during keyword matching.
+ */
+export const STOP_WORDS = new Set([
+	"the",
+	"and",
+	"for",
+	"are",
+	"but",
+	"not",
+	"you",
+	"all",
+	"can",
+	"has",
+	"her",
+	"was",
+	"one",
+	"our",
+	"out",
+	"with",
+	"that",
+	"this",
+	"from",
+	"have",
+	"will",
+	"should",
+]);
+
+/**
+ * Extract the content under `## Acceptance criteria` from a spec file.
+ * Returns individual criterion lines (trimmed, without leading `- ` or `- [ ] `).
+ */
+export function extractAcceptanceCriteria(specContent: string): string[] {
+	const lines = specContent.split("\n");
+	const criteria: string[] = [];
+	let inSection = false;
+
+	for (const line of lines) {
+		const trimmed = line.trim();
+
+		// Detect start of acceptance criteria section (case-insensitive)
+		if (/^##\s+acceptance\s+criteria/i.test(trimmed)) {
+			inSection = true;
+			continue;
+		}
+
+		// Stop at next heading
+		if (inSection && /^##\s/.test(trimmed)) {
+			break;
+		}
+
+		if (inSection && trimmed.startsWith("-")) {
+			// Strip leading `- `, `- [ ] `, `- [x] `
+			const content = trimmed.replace(/^-\s*(\[.\]\s*)?/, "").trim();
+			if (content.length > 0) {
+				criteria.push(content);
+			}
+		}
+	}
+
+	return criteria;
+}