@katyella/legio 0.1.3 → 0.2.0

package/src/tracker/factory.ts

@@ -0,0 +1,59 @@
+/**
+ * Tracker factory with auto-detection.
+ *
+ * Detects which tracker backend is present in the project root and
+ * returns the appropriate TrackerClient.
+ */
+
+import { existsSync } from "node:fs";
+import { join } from "node:path";
+import { createBeadsTrackerClient } from "./beads.ts";
+import { createSeedsTrackerClient } from "./seeds.ts";
+import type { TrackerBackend, TrackerClient } from "./types.ts";
+
+// Re-export types for convenience
+export type { TrackerBackend, TrackerClient, TrackerIssue } from "./types.ts";
+
+/**
+ * Auto-detect which tracker backend to use.
+ * Checks .seeds/ first, then .beads/. Defaults to seeds.
+ *
+ * @param cwd - Directory to search for tracker markers
+ */
+export function resolveBackend(cwd: string): "seeds" | "beads" {
+	if (existsSync(join(cwd, ".seeds"))) return "seeds";
+	if (existsSync(join(cwd, ".beads"))) return "beads";
+	return "seeds"; // default
+}
+
+/**
+ * Create a TrackerClient for the given backend.
+ *
+ * @param backend - The backend to use ("auto" detects from filesystem)
+ * @param cwd - Working directory for CLI commands and backend detection
+ */
+export function createTrackerClient(backend: TrackerBackend, cwd: string): TrackerClient {
+	const resolved = backend === "auto" ? resolveBackend(cwd) : backend;
+	switch (resolved) {
+		case "seeds":
+			return createSeedsTrackerClient(cwd);
+		case "beads":
+			return createBeadsTrackerClient(cwd);
+	}
+}
+
+/**
+ * Return the CLI tool name for a resolved backend.
+ * Used by the overlay generator to inject {{TRACKER_CLI}} into agent definitions.
+ */
+export function trackerCliName(backend: "seeds" | "beads"): string {
+	return backend === "seeds" ? "sd" : "bd";
+}
+
+/**
+ * Return the human-readable tracker name for a resolved backend.
+ * Used by the overlay generator to inject {{TRACKER_NAME}} into agent definitions.
+ */
+export function trackerDisplayName(backend: "seeds" | "beads"): string {
+	return backend === "seeds" ? "seeds" : "beads";
+}

package/src/tracker/seeds.ts

@@ -0,0 +1,156 @@
+/**
+ * Seeds adapter for the tracker abstraction layer.
+ *
+ * Wraps the `sd` CLI to implement TrackerClient using the seeds backend.
+ * Follows the same patterns as the beads adapter.
+ */
+
+import { AgentError } from "../errors.ts";
+import { runTrackerCommand } from "./exec.ts";
+import type { TrackerClient, TrackerIssue } from "./types.ts";
+
+/**
+ * Parse JSON output from an sd command.
+ */
+function parseJsonOutput<T>(stdout: string, context: string): T {
+	const trimmed = stdout.trim();
+	if (trimmed === "") {
+		throw new AgentError(`Empty output from sd ${context}`);
+	}
+	try {
+		return JSON.parse(trimmed) as T;
+	} catch {
+		throw new AgentError(
+			`Failed to parse JSON output from sd ${context}: ${trimmed.slice(0, 200)}`,
+		);
+	}
+}
+
+/**
+ * Raw issue shape from the sd CLI (snake_case fields).
+ */
+interface RawSeedIssue {
+	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 sd issue into a TrackerIssue (camelCase).
+ */
+export function normalizeIssue(raw: RawSeedIssue): 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 seeds (sd) CLI.
+ *
+ * @param cwd - Working directory where sd commands should run
+ */
+export function createSeedsTrackerClient(cwd: string): TrackerClient {
+	async function runSd(
+		args: string[],
+		context: string,
+	): Promise<{ stdout: string; stderr: string }> {
+		const { stdout, stderr, exitCode } = await runTrackerCommand(["sd", ...args], cwd);
+		if (exitCode !== 0) {
+			throw new AgentError(`sd ${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 runSd(args, "ready");
+			const raw = parseJsonOutput<RawSeedIssue[]>(stdout, "ready");
+			return raw.map(normalizeIssue);
+		},
+
+		async show(id): Promise<TrackerIssue> {
+			const { stdout } = await runSd(["show", id, "--json"], `show ${id}`);
+			const raw = parseJsonOutput<RawSeedIssue[]>(stdout, `show ${id}`);
+			const first = raw[0];
+			if (!first) {
+				throw new AgentError(`sd 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 runSd(args, "create");
+			const result = parseJsonOutput<{ id: string }>(stdout, "create");
+			return result.id;
+		},
+
+		async claim(id): Promise<void> {
+			await runSd(["update", id, "--status", "in_progress"], `claim ${id}`);
+		},
+
+		async close(id, reason): Promise<void> {
+			const args = ["close", id];
+			if (reason) {
+				args.push("--reason", reason);
+			}
+			await runSd(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 runSd(args, "list");
+			const raw = parseJsonOutput<RawSeedIssue[]>(stdout, "list");
+			return raw.map(normalizeIssue);
+		},
+
+		async sync(): Promise<void> {
+			await runSd(["sync"], "sync");
+		},
+	};
+}

package/src/tracker/types.ts

@@ -0,0 +1,46 @@
+/**
+ * Tracker abstraction layer types.
+ *
+ * Defines a pluggable TrackerClient interface that works with any backend
+ * (beads via bd CLI, or seeds via sd CLI).
+ */
+
+/** A tracker issue as returned by any backend. */
+export interface TrackerIssue {
+	id: string;
+	title: string;
+	status: string;
+	priority: number;
+	type: string;
+	assignee?: string;
+	description?: string;
+	blocks?: string[];
+	blockedBy?: string[];
+	closedAt?: string;
+	closeReason?: string;
+	createdAt?: string;
+}
+
+/** Supported tracker backends. */
+export type TrackerBackend = "auto" | "seeds" | "beads";
+
+/** Pluggable tracker client interface. */
+export interface TrackerClient {
+	/** List issues that are ready for work (open, unblocked). */
+	ready(options?: { mol?: string }): Promise<TrackerIssue[]>;
+	/** Show details for a specific issue. */
+	show(id: string): Promise<TrackerIssue>;
+	/** Create a new issue. Returns the new issue ID. */
+	create(
+		title: string,
+		options?: { type?: string; priority?: number; description?: string },
+	): Promise<string>;
+	/** Claim an issue (mark as in_progress). */
+	claim(id: string): Promise<void>;
+	/** Close an issue with an optional reason. */
+	close(id: string, reason?: string): Promise<void>;
+	/** List issues with optional filters. */
+	list(options?: { status?: string; limit?: number; all?: boolean }): Promise<TrackerIssue[]>;
+	/** Sync tracker state (e.g., bd sync or sd sync). */
+	sync(): Promise<void>;
+}

package/src/types.ts

@@ -33,7 +33,12 @@ export interface LegioConfig {
 	worktrees: {
 		baseDir: string; // Where worktrees live
 	};
-	beads: {
+	/** @deprecated Use taskTracker instead. Kept for backward compatibility with inline fixtures. */
+	beads?: {
+		enabled: boolean;
+	};
+	taskTracker: {
+		backend: "auto" | "seeds" | "beads";
 		enabled: boolean;
 	};
 	mulch: {
@@ -46,13 +51,17 @@ export interface LegioConfig {
 		aiResolveEnabled: boolean;
 		reimagineEnabled: boolean;
 	};
-	watchdog: {
+	watchman: {
 		tier0Enabled: boolean; // Tier 0: Mechanical daemon (heartbeat, tmux/pid liveness)
 		tier0IntervalMs: number; // Default 30_000
 		tier1Enabled: boolean; // Tier 1: Triage agent (ephemeral AI analysis)
 		tier2Enabled: boolean; // Tier 2: Monitor agent (continuous patrol — not yet implemented)
 		zombieThresholdMs: number; // When to kill
 		nudgeIntervalMs: number; // Time between progressive nudge stages (default 60_000)
+		mailIntervalMs: number; // Mail polling interval (default 5_000)
+		reNudgeIntervalMs: number; // Time between re-nudges for the same agent (default 10_000)
+		warnAfterMs: number; // Warn after unread mail sits this long (default 60_000)
+		beaconNudgeMs: number; // Time before sending follow-up Enter to stuck beacon (default 20_000)
 	};
 	models: Partial<Record<string, ModelAlias>>;
 	logging: {