pi-legion 3.0.3 → 4.0.0

package/src/backends/legacy/cursor-chat.ts

@@ -1,348 +0,0 @@
-/**
- * Structured collection for cursor-kind children.
- *
- * cursor-agent persists every chat under `~/.cursor/chats/<projectHash>/<chatId>/`
- * as a SQLite store (`store.db`, WAL mode) whose `blobs(id, data)` rows hold the
- * conversation: user and assistant messages as JSON, tool traffic as protobuf
- * blobs. herdr reports the chat id as `agent_session.value` (`source:
- * "herdr:cursor"`), so locating the store is deterministic — no screen scraping.
- * Why this beats reading the pane (measured 2026-09-20, v2026.09.18-9a7762b):
- *   - the assistant reply is stored verbatim — the TUI word-wraps long lines,
- *     which corrupted streamed verdict JSON enough to break JSON.parse;
- *   - a message is written atomically on turn completion: across every live
- *     chat, the last row is a complete assistant message, never a half-stream.
- *     "last message is assistant with text" IS the turn-settled signal;
- *   - F7's "non-pi kinds can only report unknown" no longer holds: the store
- *     carries the reply, so outcome/verdict derivation can use it directly.
- *
- * Schema notes (`meta.json` sits beside `store.db`):
- *   {"schemaVersion": 1, "cwd": "...", "title": "...", "createdAtMs": ...}
- * `schemaVersion` is checked on read; a bump means the shape below changed and
- * the parser should refuse rather than mis-parse.
- */
-
-import * as fs from "node:fs";
-import * as os from "node:os";
-import * as path from "node:path";
-// `node:module` is implemented by both Bun and Node, so this static import is
-// safe — unlike node:sqlite, which Bun lacks entirely.
-import { createRequire } from "node:module";
-import type { ParsedSession, TurnRecord } from "../../shared/types.ts";
-import { emptyParsedSession } from "../../shared/session.ts";
-
-/**
- * Minimal structural type both runtimes' SQLite drivers satisfy.
- *
- * IMPORTANT: sqlite is loaded LAZILY via createRequire at call time — pi
- * ships as a Bun-compiled binary, Bun has no `node:sqlite`, and a static
- * import would fail at module-resolution time, killing the whole extension
- * on load even when no cursor child ever runs. Runtime branch: Bun →
- * `bun:sqlite` (readonly: true), Node ≥22.5 → `node:sqlite`
- * (readOnly: true).
- */
-interface MinimalSqliteDb {
-	prepare(sql: string): { iterate(): IterableIterator<{ data: unknown }> };
-	close(): void;
-}
-
-/**
- * Per-driver opener recipe: the module id and its own read-only option
- * spelling (bun uses `readonly`, node uses `readOnly` — each driver gets only
- * its own key, so no cross-runtime assumption about unknown-key tolerance).
- */
-const SQLITE_DRIVERS: ReadonlyArray<{
-	id: string;
-	readonlyKey: "readonly" | "readOnly";
-	ctor: "Database" | "DatabaseSync";
-}> = [
-	{ id: "bun:sqlite", readonlyKey: "readonly", ctor: "Database" },
-	{ id: "node:sqlite", readonlyKey: "readOnly", ctor: "DatabaseSync" },
-];
-
-/** Opens a SQLite file read-only (per-runtime driver, resolved lazily). */
-type SqliteOpener = (dbPath: string) => MinimalSqliteDb;
-
-/** Cached CommonJS require; created lazily so a hostile import.meta.url in a
- * compiled binary cannot crash module load (the very bug this guards). */
-let cachedRequire: ((id: string) => unknown) | null | undefined;
-
-/** Cached opener; null once both drivers are known to be unavailable. */
-let cachedOpener: SqliteOpener | null | undefined;
-
-/** Get a CommonJS require for built-ins; null when unobtainable. */
-function requireForBuiltins(): ((id: string) => unknown) | null {
-	if (cachedRequire !== undefined) return cachedRequire;
-	try {
-		// Deferred (not module-top-level) so even a weird virtual
-		// import.meta.url (Bun compiled binaries) only degrades cursor
-		// collection via the catch below, never extension loading.
-		cachedRequire = createRequire(import.meta.url);
-	} catch {
-		cachedRequire = null;
-	}
-	return cachedRequire;
-}
-
-/** Constructor shape shared by Bun's `Database` and Node's `DatabaseSync`. */
-type SqliteDbCtor = new (
-	dbPath: string,
-	opts: Record<string, boolean>,
-) => MinimalSqliteDb;
-/** Pick the driver constructor out of a required module namespace. */
-function ctorOf(
-	mod: unknown,
-	name: "Database" | "DatabaseSync",
-): SqliteDbCtor | null {
-	if (typeof mod !== "object" || mod === null) return null;
-	// SAFETY: structural narrowing of an untyped module namespace — the
-	// typeof-function guard is the whole invariant; the constructor signature
-	// is then checked by TypeScript at the `new` site below.
-	const ctor = (mod as Record<string, unknown>)[name];
-	if (typeof ctor !== "function") return null;
-	return ctor as SqliteDbCtor;
-}
-
-/** Resolve the current runtime's SQLite driver lazily; null when unavailable. */
-function sqliteOpener(): SqliteOpener | null {
-	if (cachedOpener !== undefined) return cachedOpener;
-	const req = requireForBuiltins();
-	if (req) {
-		for (const driver of SQLITE_DRIVERS) {
-			let mod: unknown;
-			try {
-				mod = req(driver.id);
-			} catch {
-				continue; // this runtime lacks the builtin
-			}
-			const Ctor = ctorOf(mod, driver.ctor);
-			if (Ctor) {
-				const opts: Record<string, boolean> = {};
-				opts[driver.readonlyKey] = true;
-				cachedOpener = (dbPath) => new Ctor(dbPath, opts);
-				return cachedOpener;
-			}
-		}
-	}
-	cachedOpener = null;
-	return null;
-}
-
-/** The only schemaVersion observed in the wild so far. */
-const SUPPORTED_SCHEMA_VERSION = 1;
-
-interface ChatMessage {
-	role: "user" | "assistant";
-	content: unknown;
-}
-
-/**
- * Locate the chat directory for a herdr cursor session id.
- *
- * The id is the directory name; the project hash parent is found by scanning
- * `~/.cursor/chats/<project>/<id>/` and matching `meta.json`'s `cwd` when the
- * child's cwd is known (a worktree child must not bind to the parent
- * checkout's chat).
- */
-export function findCursorChatDir(
-	chatId: string,
-	opts: { cwd?: string; chatsRoot?: string } = {},
-): string | null {
-	if (!chatId) return null;
-	const root = opts.chatsRoot ?? path.join(os.homedir(), ".cursor", "chats");
-	let entries: string[];
-	try {
-		entries = fs.readdirSync(root);
-	} catch {
-		return null;
-	}
-	const candidates: string[] = [];
-	for (const project of entries) {
-		const dir = path.join(root, project, chatId);
-		if (fs.existsSync(dir)) candidates.push(dir);
-	}
-	if (candidates.length === 0) return null;
-	if (candidates.length === 1) return candidates[0] ?? null;
-	// Several projects share the id (cursor reused it): prefer the one whose
-	// meta cwd matches the child's, else the newest.
-	if (opts.cwd) {
-		for (const dir of candidates) {
-			const meta = readMeta(path.join(dir, "meta.json"));
-			if (meta?.cwd && sameDir(meta.cwd, opts.cwd)) return dir;
-		}
-	}
-	return candidates.sort(
-		(a, b) => fs.statSync(b).mtimeMs - fs.statSync(a).mtimeMs,
-	)[0] ?? null;
-}
-
-function sameDir(a: string, b: string): boolean {
-	return path.resolve(a) === path.resolve(b);
-}
-
-function readMeta(file: string): {
-	schemaVersion?: number;
-	cwd?: string;
-	title?: string;
-} | null {
-	try {
-		return JSON.parse(fs.readFileSync(file, "utf-8"));
-	} catch {
-		return null;
-	}
-}
-
-/**
- * Parse a cursor chat store into the same `ParsedSession` shape the pi jsonl
- * parser produces, so `collect()`'s main verdict/acceptance path applies
- * unchanged.
- *
- * Empty session (unreadable/unsupported/turn not started) → `turns: []`, which
- * the caller treats as "keep waiting", never as failure.
- */
-export function parseCursorChat(chatDir: string): ParsedSession {
-	const dbPath = path.join(chatDir, "store.db");
-	if (!fs.existsSync(dbPath)) return emptyParsedSession();
-
-	const meta = readMeta(path.join(chatDir, "meta.json"));
-	if (
-		meta?.schemaVersion !== undefined &&
-		meta.schemaVersion !== SUPPORTED_SCHEMA_VERSION
-	) {
-		// Unknown future schema: refuse rather than mis-parse.
-		return emptyParsedSession();
-	}
-
-	const messages = readMessages(dbPath);
-	if (messages.length === 0) return emptyParsedSession();
-	return sessionFromMessages(messages);
-}
-
-/** Open the store read-only and pull the ordered user/assistant messages. */
-function readMessages(dbPath: string): ChatMessage[] {
-	// readOnly keeps the child's WAL untouched; a missing db is an empty turn.
-	const open = sqliteOpener();
-	if (!open) return [];
-	let db: MinimalSqliteDb;
-	try {
-		db = open(dbPath);
-	} catch {
-		return [];
-	}
-	try {
-		const out: ChatMessage[] = [];
-		for (const row of db
-			.prepare("SELECT data FROM blobs ORDER BY rowid")
-			.iterate() as IterableIterator<{ data: unknown }>) {
-			const msg = parseMessageBlob(row.data);
-			if (msg) out.push(msg);
-		}
-		return out;
-	} catch {
-		return [];
-	} finally {
-		db.close();
-	}
-}
-
-function parseMessageBlob(data: unknown): ChatMessage | null {
-	if (typeof data !== "string" && !(data instanceof Uint8Array)) return null;
-	const text =
-		typeof data === "string" ? data : new TextDecoder().decode(data);
-	const trimmed = text.trimStart();
-	if (!trimmed.startsWith("{")) return null;
-	let parsed: unknown;
-	try {
-		parsed = JSON.parse(trimmed);
-	} catch {
-		return null;
-	}
-	if (typeof parsed !== "object" || parsed === null) return null;
-	const role = (parsed as { role?: unknown }).role;
-	if (role !== "user" && role !== "assistant") return null;
-	return { role, content: (parsed as { content?: unknown }).content };
-}
-
-function sessionFromMessages(messages: ChatMessage[]): ParsedSession {
-	const turns: TurnRecord[] = [];
-	let current: TurnRecord | null = null;
-	for (const msg of messages) {
-		if (msg.role === "user") {
-			// A user message starts a new turn. Skip injected non-task rows
-			// (cursor prepends <user_info>/<environment_context> payloads).
-			const text = textOf(msg.content);
-			if (turns.length === 0 && isInjectedUserRow(text)) continue;
-			const turn: TurnRecord = {
-				userText: text ?? "",
-				assistants: [],
-				toolResults: 0,
-				toolErrors: 0,
-			};
-			turns.push(turn);
-			current = turn;
-			continue;
-		}
-		// Assistant message: attach to the current turn, or an implicit turn
-		// when cursor wrote a reply without a task user row in the store.
-		if (!current) {
-			const turn: TurnRecord = {
-				userText: "",
-				assistants: [],
-				toolResults: 0,
-				toolErrors: 0,
-			};
-			turns.push(turn);
-			current = turn;
-		}
-		current.assistants.push({
-			stopReason: "stop",
-			text: textOf(msg.content),
-			errorMessage: null,
-			tools: [],
-		});
-	}
-	const last = turns.at(-1);
-	return {
-		...emptyParsedSession(),
-		turns,
-		output: last?.assistants.at(-1)?.text ?? "",
-		lastTurnOutput: last?.assistants.at(-1)?.text ?? null,
-		model: null,
-	};
-}
-
-function textOf(content: unknown): string | null {
-	if (typeof content === "string") return content;
-	if (!Array.isArray(content)) return null;
-	const texts: string[] = [];
-	for (const blk of content) {
-		if (
-			typeof blk === "object" &&
-			blk !== null &&
-			(blk as { type?: unknown }).type === "text"
-		) {
-			const t = (blk as { text?: unknown }).text;
-			if (typeof t === "string") texts.push(t);
-		}
-	}
-	return texts.length > 0 ? texts.join("\n\n") : null;
-}
-
-/**
- * Injected context rows cursor writes before the task. They carry no user
- * text and must not open a phantom turn.
- */
-function isInjectedUserRow(text: string | null): boolean {
-	if (!text) return true;
-	return /^\s*<(?:user_info|environment_context|timestamp)\b/.test(text);
-}
-
-/**
- * The turn-settled signal: the store's last message is an assistant reply with
- * text. Measured across every live chat: rows are written atomically on turn
- * completion, so a half-streamed answer never appears as a final row.
- */
-export function cursorTurnSettled(parsed: ParsedSession): boolean {
-	const last = parsed.turns.at(-1);
-	if (!last || last.assistants.length === 0) return false;
-	return Boolean(last.assistants.at(-1)?.text);
-}

package/src/backends/legacy/runner.ts

@@ -1,101 +0,0 @@
-/**
- * Command runner: spawns the `herdr` binary and captures stdout/stderr.
- *
- * Measured constraint (F21): herdr prints SUCCESS payloads on stdout but
- * ERROR payloads on STDERR. Both must be parsed, or errors look like
- * empty responses.
- */
-
-import { spawn } from "node:child_process";
-import { createCappedOutput, resolveMaxOutputBytes } from "../../shared/output-cap.ts";
-import type { CommandRunner } from "./types.ts";
-
-const HERDR_BIN_ENV = "HERDR_BIN";
-const HERDR_BIN_PATH_ENV = "HERDR_BIN_PATH";
-
-export function resolveHerdrBin(env: NodeJS.ProcessEnv = process.env): string {
-	return env[HERDR_BIN_ENV] || env[HERDR_BIN_PATH_ENV] || "herdr";
-}
-
-export interface RunnerOptions {
-	bin?: string;
-	env?: NodeJS.ProcessEnv;
-	/** Default timeout applied when a call does not specify one. */
-	defaultTimeoutMs?: number;
-}
-
-/**
- * Create the default runner that shells out to herdr.
- * Errors are surfaced as a non-zero `code` plus whatever text was produced;
- * the caller (parseHerdrResponse) turns that into a structured HerdrError.
- */
-export function createCommandRunner(
-	options: RunnerOptions = {},
-): CommandRunner {
-	const bin = options.bin ?? resolveHerdrBin();
-	const baseEnv = options.env ?? process.env;
-
-	return (args, opts = {}) =>
-		new Promise((resolve) => {
-			let child: ReturnType<typeof spawn>;
-			try {
-				child = spawn(bin, args, {
-					shell: false,
-					windowsHide: true,
-					env: { ...baseEnv, ...(opts.env ?? {}) },
-				});
-			} catch (cause) {
-				resolve({ stdout: "", stderr: String(cause), code: -1 });
-				return;
-			}
-
-			const cap = resolveMaxOutputBytes(baseEnv);
-			const killOnOverflow = () => {
-				child.stdout?.destroy();
-				child.stderr?.destroy();
-				try {
-					child.kill("SIGKILL");
-				} catch {
-					/* already gone */
-				}
-			};
-			const out = createCappedOutput(cap, killOnOverflow);
-			const err = createCappedOutput(cap, killOnOverflow);
-			let extraStderr = "";
-			let settled = false;
-			const finish = (code: number) => {
-				if (settled) return;
-				settled = true;
-				if (timer) clearTimeout(timer);
-				const overflowed = out.truncated || err.truncated;
-				resolve({ stdout: out.text(), stderr: `${err.text()}${extraStderr}`, code: overflowed && code === 0 ? -3 : code });
-			};
-
-			let timer: ReturnType<typeof setTimeout> | undefined;
-			const timeoutMs = opts.timeoutMs ?? options.defaultTimeoutMs;
-			if (timeoutMs && timeoutMs > 0) {
-				timer = setTimeout(() => {
-					try {
-						child.kill("SIGKILL");
-					} catch {
-						/* already gone */
-					}
-					extraStderr += `\n[timeout after ${timeoutMs}ms]`;
-					finish(-2);
-				}, timeoutMs);
-				timer.unref?.();
-			}
-
-			child.stdout?.on("data", (chunk) => {
-				out.push(chunk);
-			});
-			child.stderr?.on("data", (chunk) => {
-				err.push(chunk);
-			});
-			child.on("error", (e) => {
-				extraStderr += String(e);
-				finish(-1);
-			});
-			child.on("close", (code) => finish(code ?? 0));
-		});
-}

package/src/backends/legacy/types.ts

@@ -1,138 +0,0 @@
-import type { AgentKind } from "../../shared/types.ts";
-
-/** @legacy Error envelope returned by the archived herdr CLI backend. */
-export interface HerdrError {
-	code: string;
-	message: string;
-	details?: unknown;
-}
-
-/** @legacy Result envelope returned by the archived herdr CLI backend. */
-export type HerdrResult<T> =
-	| { ok: true; value: T }
-	| { ok: false; error: HerdrError };
-
-/** @legacy Herdr pane payload; RPC v2 does not create panes. */
-export interface PaneInfo {
-	pane_id: string;
-	tab_id: string;
-	workspace_id: string;
-	agent_status?: string;
-	cwd?: string | null;
-	terminal_title_stripped?: string;
-}
-
-/** @legacy Herdr agent payload retained for archived clients. */
-export interface AgentInfo {
-	name?: string | null;
-	pane_id: string;
-	tab_id: string;
-	workspace_id: string;
-	agent: string | null;
-	agent_status: string;
-	cwd?: string | null;
-	agent_session?: { kind: string; source: string; value: string } | null;
-	state_labels?: Record<string, string>;
-	tokens?: unknown;
-}
-
-/** @legacy Herdr tab payload retained for archived clients. */
-export interface TabInfo {
-	tab_id: string;
-	workspace_id: string;
-	label?: string | null;
-	pane_count: number;
-}
-
-/** @legacy Herdr launch payload retained for archived clients. */
-export interface AgentStartResult {
-	name: string;
-	paneId: string;
-	argv: string[];
-	sessionPath?: string;
-	agentStatus: string;
-}
-
-/** @legacy Herdr process-info payload retained for archived clients. */
-export interface ProcessInfo {
-	foregroundProcesses: Array<{
-		argv: string[];
-		cmdline: string;
-		pid: number;
-		name: string;
-		cwd?: string;
-	}>;
-	shellPid?: number;
-}
-
-/** @legacy Injectable runner for the archived herdr CLI client. */
-export type CommandRunner = (
-	args: string[],
-	opts?: { timeoutMs?: number; env?: Record<string, string | undefined> },
-) => Promise<{ stdout: string; stderr: string; code: number }>;
-
-/** @deprecated Archived v0.16.x backend contract; RPC v2 uses LegionSupervisor. */
-export interface HerdrClient {
-	paneSplit(opts: {
-		target?: string;
-		current?: boolean;
-		direction: "right" | "down";
-		cwd?: string;
-		env?: Record<string, string>;
-		focus?: boolean;
-	}): Promise<HerdrResult<PaneInfo>>;
-	paneClose(paneId: string): Promise<HerdrResult<void>>;
-	paneRead(
-		paneId: string,
-		opts?: { source?: ReadSource; lines?: number },
-	): Promise<HerdrResult<string>>;
-	paneList(): Promise<HerdrResult<PaneInfo[]>>;
-	paneGet(paneId: string): Promise<HerdrResult<PaneInfo>>;
-	paneReportMetadata(opts: {
-		paneId: string;
-		source: string;
-		displayAgent?: string;
-		title?: string;
-		tokens?: Record<string, string>;
-		stateLabel?: { status: string; text: string };
-		ttlMs?: number;
-		clearStateLabels?: boolean;
-	}): Promise<HerdrResult<void>>;
-	tabCreate(opts: {
-		cwd?: string;
-		label?: string;
-		focus?: boolean;
-		env?: Record<string, string>;
-		workspaceId?: string;
-	}): Promise<HerdrResult<{ tab: TabInfo; rootPaneId: string }>>;
-	tabClose(tabId: string): Promise<HerdrResult<void>>;
-	tabList(workspaceId?: string): Promise<HerdrResult<TabInfo[]>>;
-	agentStart(opts: {
-		name: string;
-		kind: AgentKind;
-		paneId: string;
-		args?: string[];
-		timeoutMs?: number;
-	}): Promise<HerdrResult<AgentStartResult>>;
-	agentPrompt(
-		target: string,
-		text: string,
-		opts?: { wait?: boolean; timeoutMs?: number },
-	): Promise<HerdrResult<AgentInfo>>;
-	agentGet(target: string): Promise<HerdrResult<AgentInfo>>;
-	agentList(): Promise<HerdrResult<AgentInfo[]>>;
-	agentSendKeys(target: string, ...keys: string[]): Promise<HerdrResult<void>>;
-	agentWait(
-		target: string,
-		opts?: { until?: string[]; timeoutMs?: number },
-	): Promise<HerdrResult<void>>;
-	available(): Promise<boolean>;
-	integrationStatus(target: string): Promise<HerdrResult<string | null>>;
-	integrationInstall(target: string): Promise<HerdrResult<string>>;
-}
-
-export type ReadSource =
-	| "visible"
-	| "recent"
-	| "recent-unwrapped"
-	| "detection";