@katyella/legio 0.1.3 → 0.2.2

package/src/server/routes.ts

@@ -11,7 +11,6 @@ import { randomUUID } from "node:crypto";
 import { constants } from "node:fs";
 import { access, readFile, writeFile } from "node:fs/promises";
 import { join } from "node:path";
-import { createBeadsClient } from "../beads/client.ts";
 import { gatherInspectData } from "../commands/inspect.ts";
 import { gatherStatus } from "../commands/status.ts";
 import { loadConfig } from "../config.ts";
@@ -21,6 +20,7 @@ import { createMergeQueue } from "../merge/queue.ts";
 import { createMetricsStore } from "../metrics/store.ts";
 import { openSessionStore } from "../sessions/compat.ts";
 import { createRunStore, createSessionStore } from "../sessions/store.ts";
+import { createTrackerClient } from "../tracker/factory.ts";
 import type {
 	EventLevel,
 	HeadlessCoordinatorConfig,
@@ -635,7 +635,7 @@ export async function handleApiRequest(
 				const idea = data.ideas.find((i) => i.id === id);
 				if (!idea) return errorResponse(`Idea not found: ${id}`, 404);
 
-				const client = createBeadsClient(projectRoot);
+				const client = createTrackerClient("auto", projectRoot);
 				const issueId = await client.create(idea.title, { description: idea.body });
 
 				idea.status = "backlog";
@@ -703,7 +703,7 @@ export async function handleApiRequest(
 		}
 
 		const args = ["coordinator", "start", "--no-attach", "--json"];
-		if (parsed.watchdog === true) args.push("--watchdog");
+		if (parsed.watchdog === true) args.push("--watchman");
 		if (parsed.monitor === true) args.push("--monitor");
 		const result = await runLegio(args, projectRoot);
 		if (result.ok) {
@@ -1106,7 +1106,7 @@ export async function handleApiRequest(
 			const { id } = params;
 			if (!id) return errorResponse("Missing issue ID", 400);
 			try {
-				const client = createBeadsClient(projectRoot);
+				const client = createTrackerClient("auto", projectRoot);
 				const issue = await client.show(id);
 				const body = issue.description ? `${issue.title}\n\n${issue.description}` : issue.title;
 				const store = createMailStore(join(legioDir, "mail.db"));
@@ -1143,7 +1143,7 @@ export async function handleApiRequest(
 			try {
 				const body = (await request.json().catch(() => ({}))) as { reason?: string };
 				const reason = typeof body.reason === "string" ? body.reason : "Closed from dashboard";
-				const client = createBeadsClient(projectRoot);
+				const client = createTrackerClient("auto", projectRoot);
 				await client.close(id, reason);
 				return jsonResponse({ success: true, id });
 			} catch (err) {
@@ -1245,7 +1245,20 @@ export async function handleApiRequest(
 		}
 		const { store } = openSessionStore(legioDir);
 		try {
-			return jsonResponse(store.getAll());
+			// Scope to current run if one exists, otherwise show only active agents
+			// (avoids flooding the dashboard with completed agents from old runs)
+			const runIdPath = join(legioDir, "current-run.txt");
+			let runId: string | null = null;
+			try {
+				const text = await readFile(runIdPath, "utf-8");
+				runId = text.trim() || null;
+			} catch {
+				// No current run file
+			}
+			if (runId) {
+				return jsonResponse(store.getByRunIncludeOrphans(runId));
+			}
+			return jsonResponse(store.getActive());
 		} finally {
 			store.close();
 		}
@@ -1711,7 +1724,7 @@ export async function handleApiRequest(
 		}
 
 		try {
-			const client = createBeadsClient(projectRoot);
+			const client = createTrackerClient("auto", projectRoot);
 			const issues = await client.list({ status: statusParam, limit, all });
 			if (isDefaultRequest) {
 				issuesCacheData = issues;
@@ -1725,7 +1738,7 @@ export async function handleApiRequest(
 
 	if (path === "/api/issues/ready") {
 		try {
-			const client = createBeadsClient(projectRoot);
+			const client = createTrackerClient("auto", projectRoot);
 			const issues = await client.ready();
 			return jsonResponse(issues);
 		} catch {
@@ -1740,7 +1753,7 @@ export async function handleApiRequest(
 			const { id } = params;
 			if (!id) return errorResponse("Missing issue ID", 400);
 			try {
-				const client = createBeadsClient(projectRoot);
+				const client = createTrackerClient("auto", projectRoot);
 				const issue = await client.show(id);
 				return jsonResponse(issue);
 			} catch {
@@ -1771,29 +1784,28 @@ export async function handleApiRequest(
 			});
 		}
 
-		// Try terminal log file first (pipe-pane streaming)
+		// Try capture-pane first (clean rendered output)
 		let output: string | null = null;
-		const { store: captureStore } = openSessionStore(legioDir);
-		try {
-			const agentSession = captureStore.getByName(agentName);
-			if (agentSession?.terminalLogPath) {
-				output = await readTerminalLog(agentSession.terminalLogPath, lines);
-			}
-		} finally {
-			captureStore.close();
+		const tmuxSession = await resolveTerminalSession(legioDir, projectRoot, agentName);
+		if (tmuxSession) {
+			output = await captureTmuxPane(tmuxSession, lines);
 		}
 
-		// Fall back to capture-pane if no terminal log available
+		// Fall back to pipe-pane log file if capture-pane fails (session dead)
 		if (output === null) {
-			const tmuxSession = await resolveTerminalSession(legioDir, projectRoot, agentName);
-			if (!tmuxSession) {
-				return errorResponse(`Cannot resolve tmux session for agent "${agentName}"`, 404);
+			const { store: captureStore } = openSessionStore(legioDir);
+			try {
+				const agentSession = captureStore.getByName(agentName);
+				if (agentSession?.terminalLogPath) {
+					output = await readTerminalLog(agentSession.terminalLogPath, lines);
+				}
+			} finally {
+				captureStore.close();
 			}
+		}
 
-			output = await captureTmuxPane(tmuxSession, lines);
-			if (output === null) {
-				return errorResponse(`Failed to capture tmux pane for session "${tmuxSession}"`);
-			}
+		if (output === null) {
+			return errorResponse(`Cannot resolve tmux session for agent "${agentName}"`, 404);
 		}
 
 		return jsonResponse({

package/src/test-helpers.ts

@@ -30,6 +30,10 @@ async function getTemplateRepo(): Promise<string> {
 
 	const dir = await mkdtemp(join(tmpdir(), "legio-template-"));
 	await runGitInDir(dir, ["init", "-b", "main"]);
+	// Bake identity into the template so clones inherit it without extra
+	// per-repo `git config` subprocess calls.
+	await runGitInDir(dir, ["config", "user.name", "Legio Test"]);
+	await runGitInDir(dir, ["config", "user.email", "test@legio.dev"]);
 	await writeFile(join(dir, ".gitkeep"), "");
 	await runGitInDir(dir, ["add", ".gitkeep"]);
 	await runGitInDir(dir, ["commit", "-m", "initial commit"]);
@@ -52,9 +56,7 @@ export async function createTempGitRepo(): Promise<string> {
 	const dir = await mkdtemp(join(tmpdir(), "legio-test-"));
 	// Clone into the empty dir. Avoid --local (hardlinks trigger EFAULT in Bun's rm).
 	await runGitInDir(".", ["clone", template, dir]);
-	// Set git identity at repo level so code that doesn't use GIT_TEST_ENV
-	// (e.g., resolver's runGit) can still commit. Locally this is covered by
-	// ~/.gitconfig, but CI runners have no global git identity.
+	// git clone does not copy local config — set identity so merge commits work on CI
 	await runGitInDir(dir, ["config", "user.name", "Legio Test"]);
 	await runGitInDir(dir, ["config", "user.email", "test@legio.dev"]);
 	return dir;
@@ -74,6 +76,7 @@ export async function cloneFixtureRepo(): Promise<string> {
 	const dir = await mkdtemp(join(tmpdir(), "legio-test-"));
 	// Avoid --local (hardlinks trigger EFAULT in Bun's rm).
 	await runGitInDir(".", ["clone", fixturePath, dir]);
+	// git clone does not copy local config — set identity so merge commits work on CI
 	await runGitInDir(dir, ["config", "user.name", "Legio Test"]);
 	await runGitInDir(dir, ["config", "user.email", "test@legio.dev"]);
 	return dir;

package/src/tracker/beads.ts

@@ -0,0 +1,159 @@
+/**
+ * Beads adapter for the tracker abstraction layer.
+ *
+ * Wraps the bd CLI to implement TrackerClient. Reuses the same
+ * normalizeIssue/parseJsonOutput patterns as seeds.ts for consistency.
+ */
+
+import { AgentError } from "../errors.ts";
+import { runTrackerCommand } from "./exec.ts";
+import type { TrackerClient, TrackerIssue } from "./types.ts";
+
+/**
+ * Parse JSON output from a bd command.
+ */
+function parseJsonOutput<T>(stdout: string, context: string): T {
+	const trimmed = stdout.trim();
+	if (trimmed === "") {
+		throw new AgentError(`Empty output from bd ${context}`);
+	}
+	try {
+		return JSON.parse(trimmed) as T;
+	} catch {
+		throw new AgentError(
+			`Failed to parse JSON output from bd ${context}: ${trimmed.slice(0, 200)}`,
+		);
+	}
+}
+
+/**
+ * Raw issue shape from the bd CLI (snake_case fields).
+ */
+interface RawBeadIssue {
+	id: string;
+	title: string;
+	status: string;
+	priority: number;
+	issue_type?: string;
+	type?: string;
+	owner?: string;
+	assignee?: string;
+	description?: string;
+	blocks?: string[];
+	blocked_by?: string[];
+	blockedBy?: string[];
+	closed_at?: string;
+	close_reason?: string;
+	created_at?: string;
+}
+
+/**
+ * Normalize a raw bd issue into a TrackerIssue (camelCase).
+ */
+function normalizeIssue(raw: RawBeadIssue): TrackerIssue {
+	return {
+		id: raw.id,
+		title: raw.title,
+		status: raw.status,
+		priority: raw.priority,
+		type: raw.issue_type ?? raw.type ?? "unknown",
+		assignee: raw.owner ?? raw.assignee,
+		description: raw.description,
+		blocks: raw.blocks,
+		blockedBy: raw.blocked_by ?? raw.blockedBy,
+		closedAt: raw.closed_at,
+		closeReason: raw.close_reason,
+		createdAt: raw.created_at,
+	};
+}
+
+/**
+ * Create a TrackerClient backed by the beads (bd) CLI.
+ *
+ * @param cwd - Working directory where bd commands should run
+ */
+export function createBeadsTrackerClient(cwd: string): TrackerClient {
+	async function runBd(
+		args: string[],
+		context: string,
+	): Promise<{ stdout: string; stderr: string }> {
+		const { stdout, stderr, exitCode } = await runTrackerCommand(["bd", ...args], cwd);
+		if (exitCode !== 0) {
+			throw new AgentError(`bd ${context} failed (exit ${exitCode}): ${stderr.trim()}`);
+		}
+		return { stdout, stderr };
+	}
+
+	return {
+		async ready(options): Promise<TrackerIssue[]> {
+			const args = ["ready", "--json"];
+			if (options?.mol) {
+				args.push("--mol", options.mol);
+			}
+			const { stdout } = await runBd(args, "ready");
+			const raw = parseJsonOutput<RawBeadIssue[]>(stdout, "ready");
+			return raw.map(normalizeIssue);
+		},
+
+		async show(id): Promise<TrackerIssue> {
+			const { stdout } = await runBd(["show", id, "--json"], `show ${id}`);
+			const raw = parseJsonOutput<RawBeadIssue[]>(stdout, `show ${id}`);
+			const first = raw[0];
+			if (!first) {
+				throw new AgentError(`bd show ${id} returned empty array`);
+			}
+			return normalizeIssue(first);
+		},
+
+		async create(title, options): Promise<string> {
+			const args = ["create", title, "--json"];
+			if (options?.type) {
+				args.push("--type", options.type);
+			}
+			if (options?.priority !== undefined) {
+				args.push("--priority", String(options.priority));
+			}
+			if (options?.description) {
+				args.push("--description", options.description);
+			}
+			const { stdout } = await runBd(args, "create");
+			const result = parseJsonOutput<{ id: string }>(stdout, "create");
+			return result.id;
+		},
+
+		async claim(id): Promise<void> {
+			await runBd(["update", id, "--status", "in_progress"], `claim ${id}`);
+		},
+
+		async close(id, reason): Promise<void> {
+			const args = ["close", id];
+			if (reason) {
+				args.push("--reason", reason);
+			}
+			await runBd(args, `close ${id}`);
+		},
+
+		async list(options): Promise<TrackerIssue[]> {
+			const args = ["list", "--json"];
+			if (options?.status) {
+				args.push("--status", options.status);
+			}
+			if (options?.limit !== undefined) {
+				args.push("--limit", String(options.limit));
+			}
+			if (options?.all) {
+				args.push("--all");
+			}
+			const { stdout } = await runBd(args, "list");
+			const raw = parseJsonOutput<RawBeadIssue[]>(stdout, "list");
+			return raw.map(normalizeIssue);
+		},
+
+		async sync(): Promise<void> {
+			const { exitCode, stderr } = await runTrackerCommand(["bd", "sync"], cwd);
+			if (exitCode !== 0) {
+				throw new AgentError(`bd sync failed (exit ${exitCode}): ${stderr.trim()}`);
+			}
+		},
+	};
+}

package/src/tracker/exec.ts

@@ -0,0 +1,44 @@
+/**
+ * Shared subprocess execution for tracker adapters.
+ */
+
+import { spawn } from "node:child_process";
+import { AgentError } from "../errors.ts";
+
+/**
+ * Run a CLI command and capture its output.
+ *
+ * @param cmd - Command and arguments array (e.g., ["bd", "sync"])
+ * @param cwd - Working directory for the subprocess
+ * @param context - Human-readable context for error messages (e.g., "bd sync")
+ */
+export async function runTrackerCommand(
+	cmd: string[],
+	cwd: string,
+): Promise<{ stdout: string; stderr: string; exitCode: number }> {
+	const [command, ...args] = cmd;
+	if (!command) throw new Error("Empty command");
+	return new Promise((resolve, reject) => {
+		const proc = spawn(command, args, {
+			cwd,
+			stdio: ["ignore", "pipe", "pipe"],
+		});
+		const chunks: { stdout: Buffer[]; stderr: Buffer[] } = { stdout: [], stderr: [] };
+		proc.stdout.on("data", (data: Buffer) => chunks.stdout.push(data));
+		proc.stderr.on("data", (data: Buffer) => chunks.stderr.push(data));
+		proc.on("error", (err: NodeJS.ErrnoException) => {
+			if (err.code === "ENOENT") {
+				reject(new AgentError(`CLI tool "${command}" not found. Is it installed and on PATH?`));
+			} else {
+				reject(err);
+			}
+		});
+		proc.on("close", (code) => {
+			resolve({
+				stdout: Buffer.concat(chunks.stdout).toString(),
+				stderr: Buffer.concat(chunks.stderr).toString(),
+				exitCode: code ?? 1,
+			});
+		});
+	});
+}

package/src/tracker/factory.test.ts

@@ -0,0 +1,283 @@
+/**
+ * Tests for the tracker factory, adapters, and normalizeIssue logic.
+ *
+ * Uses real temp directories (createTempGitRepo pattern).
+ * Does NOT test the seeds/beads adapters with real CLIs (they may not be installed).
+ * DOES test normalizeIssue which is pure logic requiring no CLI.
+ */
+
+import { mkdir } from "node:fs/promises";
+import { join } from "node:path";
+import { afterEach, beforeEach, describe, expect, it } from "vitest";
+import { cleanupTempDir, createTempGitRepo } from "../test-helpers.ts";
+import { createBeadsTrackerClient } from "./beads.ts";
+import { createTrackerClient, resolveBackend } from "./factory.ts";
+import { normalizeIssue } from "./seeds.ts";
+
+describe("resolveBackend", () => {
+	let tmpDir: string;
+
+	beforeEach(async () => {
+		tmpDir = await createTempGitRepo();
+	});
+
+	afterEach(async () => {
+		await cleanupTempDir(tmpDir);
+	});
+
+	it("returns 'seeds' when .seeds/ directory exists", async () => {
+		await mkdir(join(tmpDir, ".seeds"), { recursive: true });
+		expect(resolveBackend(tmpDir)).toBe("seeds");
+	});
+
+	it("returns 'beads' when .beads/ directory exists (no .seeds/)", async () => {
+		await mkdir(join(tmpDir, ".beads"), { recursive: true });
+		expect(resolveBackend(tmpDir)).toBe("beads");
+	});
+
+	it("prefers .seeds/ over .beads/ when both exist", async () => {
+		await mkdir(join(tmpDir, ".seeds"), { recursive: true });
+		await mkdir(join(tmpDir, ".beads"), { recursive: true });
+		expect(resolveBackend(tmpDir)).toBe("seeds");
+	});
+
+	it("defaults to 'seeds' when neither directory exists", () => {
+		expect(resolveBackend(tmpDir)).toBe("seeds");
+	});
+});
+
+describe("createTrackerClient", () => {
+	let tmpDir: string;
+
+	beforeEach(async () => {
+		tmpDir = await createTempGitRepo();
+	});
+
+	afterEach(async () => {
+		await cleanupTempDir(tmpDir);
+	});
+
+	it("returns a TrackerClient object for 'beads' backend", () => {
+		const client = createTrackerClient("beads", tmpDir);
+		expect(typeof client.ready).toBe("function");
+		expect(typeof client.show).toBe("function");
+		expect(typeof client.create).toBe("function");
+		expect(typeof client.claim).toBe("function");
+		expect(typeof client.close).toBe("function");
+		expect(typeof client.list).toBe("function");
+		expect(typeof client.sync).toBe("function");
+	});
+
+	it("returns a TrackerClient object for 'seeds' backend", () => {
+		const client = createTrackerClient("seeds", tmpDir);
+		expect(typeof client.ready).toBe("function");
+		expect(typeof client.show).toBe("function");
+		expect(typeof client.create).toBe("function");
+		expect(typeof client.claim).toBe("function");
+		expect(typeof client.close).toBe("function");
+		expect(typeof client.list).toBe("function");
+		expect(typeof client.sync).toBe("function");
+	});
+
+	it("returns a TrackerClient object for 'auto' backend (no marker dirs)", () => {
+		const client = createTrackerClient("auto", tmpDir);
+		expect(typeof client.ready).toBe("function");
+	});
+
+	it("auto-detects beads when .beads/ exists", async () => {
+		await mkdir(join(tmpDir, ".beads"), { recursive: true });
+		const client = createTrackerClient("auto", tmpDir);
+		expect(typeof client.ready).toBe("function");
+	});
+
+	it("auto-detects seeds when .seeds/ exists", async () => {
+		await mkdir(join(tmpDir, ".seeds"), { recursive: true });
+		const client = createTrackerClient("auto", tmpDir);
+		expect(typeof client.ready).toBe("function");
+	});
+});
+
+describe("normalizeIssue", () => {
+	it("maps snake_case fields to camelCase", () => {
+		const result = normalizeIssue({
+			id: "test-1",
+			title: "Test issue",
+			status: "open",
+			priority: 2,
+			issue_type: "task",
+			owner: "alice",
+			blocked_by: ["test-0"],
+			closed_at: "2026-01-01T00:00:00Z",
+			close_reason: "done",
+			created_at: "2025-12-01T00:00:00Z",
+		});
+
+		expect(result.id).toBe("test-1");
+		expect(result.title).toBe("Test issue");
+		expect(result.status).toBe("open");
+		expect(result.priority).toBe(2);
+		expect(result.type).toBe("task");
+		expect(result.assignee).toBe("alice");
+		expect(result.blockedBy).toEqual(["test-0"]);
+		expect(result.closedAt).toBe("2026-01-01T00:00:00Z");
+		expect(result.closeReason).toBe("done");
+		expect(result.createdAt).toBe("2025-12-01T00:00:00Z");
+	});
+
+	it("prefers issue_type over type", () => {
+		const result = normalizeIssue({
+			id: "t-1",
+			title: "T",
+			status: "open",
+			priority: 1,
+			issue_type: "bug",
+			type: "task",
+		});
+		expect(result.type).toBe("bug");
+	});
+
+	it("falls back to type when issue_type is absent", () => {
+		const result = normalizeIssue({
+			id: "t-1",
+			title: "T",
+			status: "open",
+			priority: 1,
+			type: "feature",
+		});
+		expect(result.type).toBe("feature");
+	});
+
+	it("defaults type to 'unknown' when both are absent", () => {
+		const result = normalizeIssue({
+			id: "t-1",
+			title: "T",
+			status: "open",
+			priority: 1,
+		});
+		expect(result.type).toBe("unknown");
+	});
+
+	it("prefers owner over assignee", () => {
+		const result = normalizeIssue({
+			id: "t-1",
+			title: "T",
+			status: "open",
+			priority: 1,
+			owner: "bob",
+			assignee: "alice",
+		});
+		expect(result.assignee).toBe("bob");
+	});
+
+	it("falls back to assignee when owner is absent", () => {
+		const result = normalizeIssue({
+			id: "t-1",
+			title: "T",
+			status: "open",
+			priority: 1,
+			assignee: "alice",
+		});
+		expect(result.assignee).toBe("alice");
+	});
+
+	it("prefers blocked_by over blockedBy", () => {
+		const result = normalizeIssue({
+			id: "t-1",
+			title: "T",
+			status: "open",
+			priority: 1,
+			blocked_by: ["a"],
+			blockedBy: ["b"],
+		});
+		expect(result.blockedBy).toEqual(["a"]);
+	});
+
+	it("handles minimal input with only required fields", () => {
+		const result = normalizeIssue({
+			id: "t-1",
+			title: "Minimal",
+			status: "open",
+			priority: 3,
+		});
+		expect(result.id).toBe("t-1");
+		expect(result.type).toBe("unknown");
+		expect(result.assignee).toBeUndefined();
+		expect(result.blockedBy).toBeUndefined();
+		expect(result.closedAt).toBeUndefined();
+		expect(result.closeReason).toBeUndefined();
+		expect(result.createdAt).toBeUndefined();
+		expect(result.description).toBeUndefined();
+		expect(result.blocks).toBeUndefined();
+	});
+});
+
+describe("createBeadsTrackerClient", () => {
+	let tmpDir: string;
+
+	beforeEach(async () => {
+		tmpDir = await createTempGitRepo();
+	});
+
+	afterEach(async () => {
+		await cleanupTempDir(tmpDir);
+	});
+
+	it("returns an object implementing TrackerClient interface", () => {
+		const client = createBeadsTrackerClient(tmpDir);
+		expect(typeof client.ready).toBe("function");
+		expect(typeof client.show).toBe("function");
+		expect(typeof client.create).toBe("function");
+		expect(typeof client.claim).toBe("function");
+		expect(typeof client.close).toBe("function");
+		expect(typeof client.list).toBe("function");
+		expect(typeof client.sync).toBe("function");
+	});
+
+	it("ready() throws when bd is not available", async () => {
+		const client = createBeadsTrackerClient(tmpDir);
+		await expect(client.ready()).rejects.toThrow();
+	});
+
+	it("sync() throws when bd is not available", async () => {
+		const client = createBeadsTrackerClient(tmpDir);
+		await expect(client.sync()).rejects.toThrow();
+	});
+
+	it("show() throws when bd is not available", async () => {
+		const client = createBeadsTrackerClient(tmpDir);
+		await expect(client.show("test-id")).rejects.toThrow();
+	});
+
+	it("list() throws when bd is not available", async () => {
+		const client = createBeadsTrackerClient(tmpDir);
+		await expect(client.list()).rejects.toThrow();
+	});
+});
+
+describe("tracker module exports", () => {
+	it("types.ts exports TrackerIssue, TrackerBackend, TrackerClient", async () => {
+		const mod = await import("./types.ts");
+		expect(mod).toBeDefined();
+	});
+
+	it("factory.ts exports resolveBackend and createTrackerClient", async () => {
+		const mod = await import("./factory.ts");
+		expect(typeof mod.resolveBackend).toBe("function");
+		expect(typeof mod.createTrackerClient).toBe("function");
+	});
+
+	it("beads.ts exports createBeadsTrackerClient", async () => {
+		const mod = await import("./beads.ts");
+		expect(typeof mod.createBeadsTrackerClient).toBe("function");
+	});
+
+	it("seeds.ts exports createSeedsTrackerClient", async () => {
+		const mod = await import("./seeds.ts");
+		expect(typeof mod.createSeedsTrackerClient).toBe("function");
+	});
+
+	it("exec.ts exports runTrackerCommand", async () => {
+		const mod = await import("./exec.ts");
+		expect(typeof mod.runTrackerCommand).toBe("function");
+	});
+});