pulls.review 0.2.1 → 0.3.1

package/dist/devframe-DH2vpasJ.mjs

@@ -0,0 +1,1124 @@
+import { mkdir, rm, writeFile } from "node:fs/promises";
+import process from "node:process";
+import { fileURLToPath } from "node:url";
+import { promisify } from "node:util";
+import { join, relative, resolve } from "node:path";
+import { AGENT_SESSION_LOST, LOCAL_AGENT_CHANNEL, LOCAL_DEVFRAME_ID, LOCAL_RPC, LocalAgentInfoSchema } from "@pulls.review/core/local-rpc";
+import { defineDevframe, defineRpcFunction } from "devframe";
+import { LOCAL_AGENT_NAMES } from "@pulls.review/core/analyze";
+import { LOCALES } from "@pulls.review/core/locales";
+import { AgentSessionRefSchema, DiffsPayloadSchema } from "@pulls.review/core/types";
+import * as v from "valibot";
+import { randomUUID } from "node:crypto";
+import { AnalysisSchema, CLI_AGENT_CHAT_SECTION, analysisJsonSchema, buildAnalysisPrompt, buildCliAgentSystemPrompt, describeCoverageIssues, findCoverageIssues, renderFilesAsText, toGroupedResult } from "@pulls.review/core/llm";
+import { execFile, spawn } from "node:child_process";
+import { createInterface } from "node:readline";
+import { createLocalSource, readRepoInfo } from "@pulls.review/core/local";
+import { githubTokenFromEnv } from "@pulls.review/core/env";
+import fsDriver from "unstorage/drivers/fs";
+//#region package.json
+var name = "pulls.review";
+var version = "0.3.1";
+//#endregion
+//#region src/agents/run.ts
+var AgentRunError = class extends Error {
+	code;
+	constructor(message, code) {
+		super(message);
+		this.code = code;
+	}
+};
+/** The system prompt an agent gets: the role, the patch's location, and the answer's shape. */
+function systemPromptFor(diff, patchPath, extra = "") {
+	return `${buildCliAgentSystemPrompt({
+		patchPath,
+		repository: diff.ref.kind === "local"
+	})}${extra}\n\n<schema>\nThe grouping JSON must match this JSON Schema:\n${JSON.stringify(analysisJsonSchema())}\n</schema>`;
+}
+/** The files an agent's tool call touches, for the "reading" progress line. */
+function pathsOf(message, cwd) {
+	if (message.role !== "assistant") return [];
+	const paths = [];
+	for (const part of message.content) {
+		if (part.type !== "toolCall") continue;
+		const args = part.arguments;
+		const value = args.file_path ?? args.filePath ?? args.path ?? args.pattern ?? args.command;
+		if (typeof value !== "string" || !value) continue;
+		const rel = relative(cwd, value);
+		paths.push(value.startsWith("/") && rel && !rel.startsWith("..") ? rel : value);
+	}
+	return paths;
+}
+/**
+* One subprocess of the agent: appends its messages to `transcript` (emitting the live
+* transcript and progress as it goes) and resolves with its final answer. Rejects with
+* `AgentRunError` when the CLI fails or has lost the session; a run the caller aborts
+* rejects too, and the caller reads its own signal.
+*/
+async function runTurn(cli, input, transcript, { emit, signal, cwd, model, step }) {
+	const progress = (next) => emit({
+		kind: "progress",
+		progress: next
+	});
+	const outcome = {};
+	let failure;
+	const onMessage = (message) => {
+		transcript.push(message);
+		emit({
+			kind: "messages",
+			messages: [...transcript]
+		});
+		const paths = pathsOf(message, cwd);
+		if (paths.length) progress({
+			step,
+			kind: "reading",
+			paths
+		});
+		else if (message.role === "assistant") progress({
+			step,
+			kind: "thinking"
+		});
+	};
+	const onExit = (exit) => {
+		if (signal.aborted) throw new AgentRunError("Aborted");
+		if (exit.sessionLost) throw new AgentRunError(`${cli.label} no longer has this conversation.`, AGENT_SESSION_LOST);
+		if (failure !== void 0 || exit.code !== 0 && !outcome.final) throw new AgentRunError(failure || exit.stderr || `${cli.label} exited with code ${exit.code}.`);
+	};
+	progress({
+		step,
+		kind: "thinking"
+	});
+	for await (const event of cli.run({
+		...input,
+		signal
+	})) switch (event.kind) {
+		case "session":
+			outcome.session = {
+				agent: cli.name,
+				id: event.id,
+				model: event.model ?? model
+			};
+			break;
+		case "message":
+			onMessage(event.message);
+			break;
+		case "final":
+			if (event.isError) failure = event.text ?? "";
+			else outcome.final = {
+				text: event.text,
+				structured: event.structured
+			};
+			break;
+		case "exit": onExit(event);
+	}
+	return outcome;
+}
+/** Writes the patch the agent reads; resolves with its path and a cleanup. */
+async function writePatch(patchDir, id, diff) {
+	await mkdir(patchDir, { recursive: true });
+	const patchPath = join(patchDir, `${id}.patch`);
+	await writeFile(patchPath, renderFilesAsText(diff.files));
+	return {
+		patchPath,
+		cleanup: () => rm(patchPath, { force: true })
+	};
+}
+const JSON_FENCE = /```(?:json)?\n([\s\S]*?)\n```/g;
+/** The last fenced ```json block in an answer, parsed; else the whole text when it is JSON. */
+function parseJsonAnswer(text) {
+	if (!text) return void 0;
+	const candidate = [...text.matchAll(JSON_FENCE)].at(-1)?.[1] ?? text;
+	try {
+		return JSON.parse(candidate);
+	} catch {
+		return;
+	}
+}
+/** The reply without the fenced grouping it carried - the browser path shows a tool call there, not JSON. */
+function withoutJsonFence(text) {
+	const last = [...text.matchAll(JSON_FENCE)].at(-1);
+	return last ? `${text.slice(0, last.index)}${text.slice(last.index + last[0].length)}`.trim() : text;
+}
+//#endregion
+//#region src/agents/analyze.ts
+const RETRY_FIX = "Fix these and answer again with the complete grouping as JSON.";
+/** The accepted grouping, or what to tell the agent to fix. */
+function checkAnswer(diff, answer) {
+	const parsed = v.safeParse(AnalysisSchema, answer);
+	if (!parsed.success) return { fix: `The answer is not a valid grouping: ${v.summarize(parsed.issues)}\n${RETRY_FIX}` };
+	const fix = describeCoverageIssues(findCoverageIssues(diff, parsed.output), RETRY_FIX);
+	return fix ? { fix } : { analysis: parsed.output };
+}
+/**
+* Analyzes a diff through an agent CLI the way `runAgent` does through a model: the same
+* prompt, the patch on disk instead of `read_diffs`, a JSON answer instead of
+* `submit_grouping`, and one retry when the grouping misses or invents paths.
+*/
+async function runAgentAnalysis({ cli, model, diff, locale, cwd, patchDir, emit, signal }) {
+	const { patchPath, cleanup } = await writePatch(patchDir, randomUUID(), diff);
+	try {
+		const system = systemPromptFor(diff, patchPath);
+		const prompt = buildAnalysisPrompt(diff, locale);
+		const transcript = [{
+			role: "system",
+			content: system,
+			timestamp: Date.now()
+		}, {
+			role: "user",
+			content: prompt,
+			timestamp: Date.now()
+		}];
+		emit({
+			kind: "messages",
+			messages: [...transcript]
+		});
+		const turn = {
+			emit,
+			signal,
+			cwd,
+			model
+		};
+		let outcome = await runTurn(cli, {
+			cwd,
+			system,
+			prompt,
+			model,
+			sessionDir: patchDir
+		}, transcript, {
+			...turn,
+			step: 1
+		});
+		let answer = checkAnswer(diff, outcome.final?.structured ?? parseJsonAnswer(outcome.final?.text));
+		if ("fix" in answer) {
+			if (!outcome.session) throw new AgentRunError(answer.fix);
+			transcript.push({
+				role: "user",
+				content: answer.fix,
+				timestamp: Date.now()
+			});
+			const retry = await runTurn(cli, {
+				cwd,
+				system,
+				prompt: answer.fix,
+				model,
+				resume: outcome.session.id,
+				sessionDir: patchDir
+			}, transcript, {
+				...turn,
+				step: 2
+			});
+			outcome = {
+				session: retry.session ?? outcome.session,
+				final: retry.final
+			};
+			answer = checkAnswer(diff, outcome.final?.structured ?? parseJsonAnswer(outcome.final?.text));
+			if ("fix" in answer) throw new AgentRunError(answer.fix);
+		}
+		emit({
+			kind: "progress",
+			progress: {
+				step: 2,
+				kind: "organizing"
+			}
+		});
+		const stamp = `${cli.name}/${outcome.session?.model ?? model ?? "default"}`;
+		emit({
+			kind: "result",
+			result: toGroupedResult(diff, answer.analysis, stamp, locale)
+		});
+		emit({
+			kind: "end",
+			stopReason: "done",
+			agent: outcome.session
+		});
+	} finally {
+		await cleanup();
+	}
+}
+//#endregion
+//#region src/agents/types.ts
+const ZERO_USAGE = {
+	input: 0,
+	output: 0,
+	cacheRead: 0,
+	cacheWrite: 0,
+	totalTokens: 0,
+	cost: {
+		input: 0,
+		output: 0,
+		cacheRead: 0,
+		cacheWrite: 0,
+		total: 0
+	}
+};
+/** An agent's turn as the pi message the app's transcript and chat render. */
+function assistantMessage(provider, model, content) {
+	return {
+		role: "assistant",
+		content,
+		api: "anthropic-messages",
+		provider,
+		model,
+		usage: ZERO_USAGE,
+		stopReason: content.some((part) => part.type === "toolCall") ? "toolUse" : "stop",
+		timestamp: Date.now()
+	};
+}
+function toolCall(id, name, args) {
+	return {
+		type: "toolCall",
+		id,
+		name,
+		arguments: args && typeof args === "object" && !Array.isArray(args) ? args : {}
+	};
+}
+function toolResultMessage(toolCallId, toolName, text, isError = false) {
+	return {
+		role: "toolResult",
+		toolCallId,
+		toolName,
+		content: [{
+			type: "text",
+			text
+		}],
+		isError,
+		timestamp: Date.now()
+	};
+}
+//#endregion
+//#region src/agents/chat.ts
+function lastUserText(messages) {
+	const last = messages.findLast((message) => message.role === "user");
+	if (!last || last.role !== "user") return void 0;
+	return typeof last.content === "string" ? last.content : last.content.map((part) => part.type === "text" ? part.text : "").join("");
+}
+/** Drops the fenced grouping from the reply as shown; the notice that follows says what it did. */
+function stripGrouping(transcript) {
+	const index = transcript.findLastIndex((message) => message.role === "assistant");
+	const reply = transcript[index];
+	if (!reply || reply.role !== "assistant") return;
+	const content = reply.content.map((part) => part.type === "text" ? {
+		...part,
+		text: withoutJsonFence(part.text)
+	} : part).filter((part) => part.type !== "text" || part.text);
+	transcript[index] = {
+		...reply,
+		content
+	};
+}
+/**
+* Continues an agent CLI session with the reviewer's question. A fenced JSON grouping in
+* the reply is applied like `update_grouping`: validated, emitted as `result`, and noted
+* in the transcript; one that fails validation is noted as a tool error instead.
+*/
+async function runAgentChat({ cli, model, diff, locale, cwd, patchDir, emit, signal, session, text }) {
+	const resume = session.agent;
+	if (!resume || resume.agent !== cli.name) throw new AgentRunError(`This conversation was not started with ${cli.label}. Re-analyze to chat with it.`);
+	const message = text ?? lastUserText(session.messages);
+	if (!message) throw new AgentRunError("Nothing to send.");
+	const { patchPath, cleanup } = await writePatch(patchDir, randomUUID(), diff);
+	try {
+		const system = systemPromptFor(diff, patchPath, `\n\n${CLI_AGENT_CHAT_SECTION}`);
+		const transcript = text === void 0 ? [...session.messages] : [...session.messages, {
+			role: "user",
+			content: text,
+			timestamp: Date.now()
+		}];
+		emit({
+			kind: "messages",
+			messages: [...transcript]
+		});
+		const outcome = await runTurn(cli, {
+			cwd,
+			system,
+			prompt: message,
+			model,
+			resume: resume.id,
+			sessionDir: patchDir
+		}, transcript, {
+			emit,
+			signal,
+			cwd,
+			model,
+			step: 1
+		});
+		const answer = parseJsonAnswer(outcome.final?.text);
+		if (answer !== void 0) {
+			stripGrouping(transcript);
+			const checked = checkAnswer(diff, answer);
+			if ("analysis" in checked) {
+				const stamp = `${cli.name}/${outcome.session?.model ?? resume.model ?? model ?? "default"}`;
+				emit({
+					kind: "result",
+					result: toGroupedResult(diff, checked.analysis, stamp, locale)
+				});
+				transcript.push(toolResultMessage("grouping", "update_grouping", `Grouping updated: ${checked.analysis.groups.length} groups.`));
+			} else transcript.push(toolResultMessage("grouping", "update_grouping", checked.fix, true));
+			emit({
+				kind: "messages",
+				messages: [...transcript]
+			});
+		}
+		emit({
+			kind: "end",
+			stopReason: "done",
+			agent: outcome.session ?? resume
+		});
+	} finally {
+		await cleanup();
+	}
+}
+//#endregion
+//#region src/agents/process.ts
+/**
+* Runs a CLI that reads its prompt from stdin and prints one JSON object per stdout line,
+* yielding each parsed line and,
+* last, how the process ended. Lines that are not JSON (banners, warnings) are skipped.
+* Aborting the signal kills the process.
+*/
+async function* spawnJsonLines(bin, args, { cwd, signal, stdin }) {
+	const child = spawn(bin, args, {
+		cwd,
+		stdio: [
+			"pipe",
+			"pipe",
+			"pipe"
+		],
+		signal
+	});
+	child.stdin.on("error", () => {});
+	child.stdin.end(stdin);
+	let stderr = "";
+	child.stderr.setEncoding("utf8");
+	child.stderr.on("data", (chunk) => stderr = (stderr + chunk).slice(-4e3));
+	const exited = new Promise((resolve, reject) => {
+		child.on("error", (error) => {
+			if (error.name === "AbortError") resolve(null);
+			else reject(error.code === "ENOENT" ? /* @__PURE__ */ new Error(`${bin} is not installed (not on PATH).`) : error);
+		});
+		child.on("close", resolve);
+	});
+	for await (const text of createInterface({
+		input: child.stdout,
+		crlfDelay: Infinity
+	})) try {
+		yield { line: JSON.parse(text) };
+	} catch {}
+	yield { exit: {
+		code: await exited,
+		stderr: stderr.trim()
+	} };
+}
+/** The version number in the CLI's `--version`, or `undefined` when it is not on `PATH` or fails to run. */
+function readVersion(bin, args = ["--version"]) {
+	return new Promise((resolve) => {
+		const child = spawn(bin, args, { stdio: [
+			"ignore",
+			"pipe",
+			"ignore"
+		] });
+		let stdout = "";
+		child.stdout.setEncoding("utf8");
+		child.stdout.on("data", (chunk) => stdout += chunk);
+		child.on("error", () => resolve(void 0));
+		child.on("close", (code) => resolve(code === 0 ? stdout.match(/\d+\.\d[\w.-]*/)?.[0] : void 0));
+	});
+}
+//#endregion
+//#region src/agents/claude.ts
+/** Claude Code aliases; any full model id can still be typed. */
+const MODELS = [
+	{
+		id: "sonnet",
+		name: "Sonnet (latest)"
+	},
+	{
+		id: "opus",
+		name: "Opus (latest)"
+	},
+	{
+		id: "haiku",
+		name: "Haiku (latest)"
+	}
+];
+const READ_ONLY_TOOLS$1 = [
+	"Read",
+	"Grep",
+	"Glob"
+];
+const WRITE_TOOLS = [
+	"Bash",
+	"Edit",
+	"Write",
+	"MultiEdit",
+	"NotebookEdit",
+	"WebFetch",
+	"WebSearch",
+	"Task"
+];
+/** `claude -p --output-format stream-json --verbose`: one JSON object per line, these shapes. */
+const Text = v.object({
+	type: v.literal("text"),
+	text: v.string()
+});
+const Content = v.variant("type", [
+	Text,
+	v.object({
+		type: v.literal("tool_use"),
+		id: v.string(),
+		name: v.string(),
+		input: v.unknown()
+	}),
+	v.object({
+		type: v.literal("tool_result"),
+		tool_use_id: v.string(),
+		content: v.optional(v.union([v.string(), v.array(v.union([Text, v.looseObject({ type: v.string() })]))])),
+		is_error: v.optional(v.boolean())
+	})
+]);
+const Line$1 = v.variant("type", [
+	v.object({
+		type: v.literal("system"),
+		subtype: v.string(),
+		session_id: v.string(),
+		model: v.optional(v.string())
+	}),
+	v.object({
+		type: v.literal("assistant"),
+		message: v.object({
+			content: v.array(Content),
+			model: v.optional(v.string())
+		})
+	}),
+	v.object({
+		type: v.literal("user"),
+		message: v.object({ content: v.union([v.string(), v.array(Content)]) })
+	}),
+	v.object({
+		type: v.literal("result"),
+		is_error: v.boolean(),
+		result: v.optional(v.string()),
+		structured_output: v.optional(v.unknown()),
+		session_id: v.string()
+	})
+]);
+function textOf$1(content) {
+	if (typeof content === "string") return content;
+	return (content ?? []).map((part) => typeof part.text === "string" ? part.text : "").join("");
+}
+/** Claude validates the answer itself against the grouping schema, so `final.structured` is already parsed. */
+function args$2({ system, model, resume }) {
+	const list = [
+		"-p",
+		"--output-format",
+		"stream-json",
+		"--verbose",
+		"--system-prompt",
+		system,
+		"--permission-mode",
+		"dontAsk",
+		"--allowedTools",
+		...READ_ONLY_TOOLS$1,
+		"--disallowedTools",
+		...WRITE_TOOLS,
+		"--json-schema",
+		JSON.stringify(analysisJsonSchema())
+	];
+	if (model) list.push("--model", model);
+	if (resume) list.push("--resume", resume);
+	return list;
+}
+/** Maps one stream line; `toolNames` remembers each call's tool for the result that follows. */
+function mapLine(line, model, toolNames) {
+	switch (line.type) {
+		case "system": return line.subtype === "init" ? [{
+			kind: "session",
+			id: line.session_id,
+			model: line.model
+		}] : [];
+		case "assistant": {
+			const content = [];
+			for (const part of line.message.content) if (part.type === "text") content.push({
+				type: "text",
+				text: part.text
+			});
+			else if (part.type === "tool_use") {
+				toolNames.set(part.id, part.name);
+				content.push(toolCall(part.id, part.name, part.input));
+			}
+			return content.length ? [{
+				kind: "message",
+				message: assistantMessage("claude", line.message.model ?? model, content)
+			}] : [];
+		}
+		case "user":
+			if (typeof line.message.content === "string") return [];
+			return line.message.content.flatMap((part) => part.type === "tool_result" ? [{
+				kind: "message",
+				message: toolResultMessage(part.tool_use_id, toolNames.get(part.tool_use_id) ?? "tool", textOf$1(part.content), part.is_error ?? false)
+			}] : []);
+		case "result": return [{
+			kind: "final",
+			text: line.result,
+			structured: line.structured_output,
+			isError: line.is_error
+		}];
+	}
+}
+const claude = {
+	name: "claude",
+	label: "Claude Code",
+	detect: () => readVersion("claude"),
+	models: async () => MODELS,
+	async *run(input) {
+		let model = input.model ?? "claude";
+		const toolNames = /* @__PURE__ */ new Map();
+		for await (const item of spawnJsonLines("claude", args$2(input), {
+			cwd: input.cwd,
+			signal: input.signal,
+			stdin: input.prompt
+		})) {
+			if ("exit" in item) {
+				yield {
+					kind: "exit",
+					...item.exit,
+					sessionLost: /No conversation found/i.test(item.exit.stderr)
+				};
+				return;
+			}
+			const parsed = v.safeParse(Line$1, item.line);
+			if (!parsed.success) continue;
+			for (const event of mapLine(parsed.output, model, toolNames)) {
+				if (event.kind === "session" && event.model) model = event.model;
+				yield event;
+			}
+		}
+	}
+};
+//#endregion
+//#region src/agents/opencode.ts
+/** `opencode run --format json`: one event per line, each a part of the assistant's message. */
+const Part = v.variant("type", [
+	v.object({
+		type: v.literal("text"),
+		text: v.string()
+	}),
+	v.object({
+		type: v.literal("tool"),
+		tool: v.string(),
+		callID: v.string(),
+		state: v.object({
+			status: v.string(),
+			input: v.optional(v.unknown()),
+			output: v.optional(v.string()),
+			error: v.optional(v.string())
+		})
+	}),
+	v.object({ type: v.literal("step-start") }),
+	v.object({ type: v.literal("step-finish") })
+]);
+const Line = v.object({
+	type: v.string(),
+	sessionID: v.optional(v.string()),
+	part: v.optional(Part)
+});
+/** `opencode models` prints one `provider/model` id per line; the signed-in providers only. */
+async function listModels() {
+	const { stdout } = await promisify(execFile)("opencode", ["models"], { maxBuffer: 1048576 });
+	return stdout.split("\n").map((line) => line.trim()).filter((line) => line && !line.startsWith("{")).map((id) => ({
+		id,
+		name: id
+	}));
+}
+function args$1({ model, resume }) {
+	const list = [
+		"run",
+		"--format",
+		"json",
+		"--agent",
+		"plan"
+	];
+	if (model) list.push("--model", model);
+	if (resume) list.push("--session", resume);
+	return list;
+}
+function mapPart(part, model) {
+	if (part.type === "text") return [{
+		kind: "message",
+		message: assistantMessage("opencode", model, [{
+			type: "text",
+			text: part.text
+		}])
+	}];
+	if (part.type !== "tool") return [];
+	const failed = part.state.status === "error";
+	return [{
+		kind: "message",
+		message: assistantMessage("opencode", model, [toolCall(part.callID, part.tool, part.state.input)])
+	}, {
+		kind: "message",
+		message: toolResultMessage(part.callID, part.tool, failed ? part.state.error ?? "failed" : part.state.output ?? "", failed)
+	}];
+}
+const opencode = {
+	name: "opencode",
+	label: "OpenCode",
+	detect: () => readVersion("opencode"),
+	models: () => listModels().catch(() => []),
+	async *run(input) {
+		const { cwd, system, prompt, model, signal } = input;
+		let session;
+		let lastText;
+		for await (const item of spawnJsonLines("opencode", args$1(input), {
+			cwd,
+			signal,
+			stdin: `${system}\n\n${prompt}`
+		})) {
+			if ("exit" in item) {
+				if (item.exit.code === 0) yield {
+					kind: "final",
+					text: lastText
+				};
+				yield {
+					kind: "exit",
+					...item.exit,
+					sessionLost: /Session not found/i.test(item.exit.stderr)
+				};
+				return;
+			}
+			const parsed = v.safeParse(Line, item.line);
+			if (!parsed.success) continue;
+			const { sessionID, part } = parsed.output;
+			if (sessionID && sessionID !== session) {
+				session = sessionID;
+				yield {
+					kind: "session",
+					id: sessionID
+				};
+			}
+			if (part?.type === "text") lastText = part.text;
+			if (part) yield* mapPart(part, model ?? "opencode");
+		}
+	}
+};
+//#endregion
+//#region src/agents/pi.ts
+const READ_ONLY_TOOLS = "read,grep,find,ls";
+function args(input, sessionId) {
+	const list = [
+		"--mode",
+		"json",
+		input.resume ? "--session" : "--session-id",
+		input.resume ?? sessionId,
+		"--name",
+		"pulls.review",
+		"--system-prompt",
+		input.system,
+		"--tools",
+		READ_ONLY_TOOLS,
+		"--no-skills",
+		"--no-prompt-templates",
+		"--no-context-files",
+		"--no-approve"
+	];
+	if (input.sessionDir) list.push("--session-dir", input.sessionDir);
+	if (input.model) list.push("--model", input.model);
+	else if (process.env.PI_PROVIDER && process.env.PI_MODEL) list.push("--provider", process.env.PI_PROVIDER, "--model", process.env.PI_MODEL);
+	return list;
+}
+function record(value) {
+	return value && typeof value === "object" && !Array.isArray(value) ? value : void 0;
+}
+function isAssistantMessage(value) {
+	const message = record(value);
+	return message?.role === "assistant" && Array.isArray(message.content);
+}
+function isToolResultMessage(value) {
+	const message = record(value);
+	return message?.role === "toolResult" && Array.isArray(message.content);
+}
+function textOf(message) {
+	return message.content.filter((part) => part.type === "text").map((part) => part.text).join("") || void 0;
+}
+function modelOf(message) {
+	return message.provider && message.model ? `${message.provider}/${message.model}` : message.model;
+}
+function finalEvent(state) {
+	return {
+		kind: "final",
+		text: state.finalError ?? state.finalText,
+		isError: state.finalError !== void 0
+	};
+}
+function isLostSession(stderr) {
+	return /session.*not found/i.test(stderr) || /no session found/i.test(stderr) || /session.*does not exist/i.test(stderr) || /session found in different project/i.test(stderr);
+}
+function messageEvents(value, state) {
+	if (isToolResultMessage(value)) return [{
+		kind: "message",
+		message: value
+	}];
+	if (!isAssistantMessage(value)) return [];
+	const events = [{
+		kind: "message",
+		message: value
+	}];
+	const model = modelOf(value);
+	if (state.session && model && model !== state.model) {
+		state.model = model;
+		events.push({
+			kind: "session",
+			id: state.session,
+			model
+		});
+	}
+	const text = textOf(value);
+	if (text) state.finalText = text;
+	if (value.stopReason === "error" || value.stopReason === "aborted") state.finalError = value.errorMessage ?? text ?? `Pi stopped: ${value.stopReason}`;
+	return events;
+}
+function lineEvents(value, state) {
+	const line = record(value);
+	if (!line || typeof line.type !== "string") return [];
+	if (line.type === "session" && typeof line.id === "string") {
+		state.session = line.id;
+		return [{
+			kind: "session",
+			id: line.id
+		}];
+	}
+	if (line.type === "message_end") return messageEvents(line.message, state);
+	if (line.type === "agent_settled" && !state.finalSent) {
+		state.finalSent = true;
+		return [finalEvent(state)];
+	}
+	return [];
+}
+//#endregion
+//#region src/agents/index.ts
+const agents = {
+	claude,
+	opencode,
+	pi: {
+		name: "pi",
+		label: "Pi",
+		detect: () => readVersion("pi"),
+		models: async () => [],
+		async *run(input) {
+			const state = {
+				session: input.resume,
+				finalSent: false
+			};
+			const sessionId = randomUUID();
+			for await (const item of spawnJsonLines("pi", args(input, sessionId), {
+				cwd: input.cwd,
+				signal: input.signal,
+				stdin: input.prompt
+			})) {
+				if ("line" in item) {
+					yield* lineEvents(item.line, state);
+					continue;
+				}
+				if (!state.finalSent && (state.finalText !== void 0 || state.finalError !== void 0)) yield finalEvent(state);
+				yield {
+					kind: "exit",
+					...item.exit,
+					sessionLost: isLostSession(item.exit.stderr)
+				};
+			}
+		}
+	}
+};
+/** The agent CLIs on `PATH`, with their versions and model catalogs. */
+async function detectAgents() {
+	return (await Promise.all(Object.values(agents).map(async (cli) => {
+		const version = await cli.detect();
+		return version ? [{
+			name: cli.name,
+			label: cli.label,
+			version,
+			models: await cli.models()
+		}] : [];
+	}))).flat();
+}
+//#endregion
+//#region src/agents/rpc.ts
+const agentName = v.picklist(LOCAL_AGENT_NAMES);
+const locale = v.picklist(LOCALES.map((entry) => entry.code));
+const AnalyzeArgs = v.object({
+	agent: agentName,
+	model: v.optional(v.string()),
+	diff: DiffsPayloadSchema,
+	locale
+});
+const ChatArgs = v.object({
+	...AnalyzeArgs.entries,
+	session: v.object({
+		messages: v.array(v.looseObject({ role: v.string() })),
+		chatStartIndex: v.number(),
+		agent: v.optional(AgentSessionRefSchema)
+	}),
+	text: v.optional(v.string())
+});
+/** `agent.*`: analysis and chat through a local agent CLI, streamed on `channel` (`plans/11-local-agents.md`). */
+function agentRpcFunctions({ cwd, patchDir, channel }) {
+	const running = /* @__PURE__ */ new Map();
+	let detected;
+	/** Starts `run` on a fresh stream and returns its id at once; the stream carries the outcome. */
+	function start(args, run) {
+		const sink = channel.start();
+		const controller = new AbortController();
+		running.set(sink.id, controller);
+		sink.signal.addEventListener("abort", () => controller.abort());
+		(async () => {
+			const scratch = args.diff.ref.kind === "local" ? void 0 : join(patchDir, "workspace");
+			if (scratch) await mkdir(scratch, { recursive: true });
+			try {
+				await run({
+					cli: agents[args.agent],
+					model: args.model || void 0,
+					diff: args.diff,
+					locale: args.locale,
+					cwd: scratch ?? cwd,
+					patchDir,
+					emit: (event) => sink.write(event),
+					signal: controller.signal
+				});
+			} catch (error) {
+				if (controller.signal.aborted) sink.write({
+					kind: "end",
+					stopReason: "aborted"
+				});
+				else if (error instanceof AgentRunError) sink.write({
+					kind: "end",
+					stopReason: "error",
+					error: error.message,
+					code: error.code === AGENT_SESSION_LOST ? error.code : void 0
+				});
+				else sink.write({
+					kind: "end",
+					stopReason: "error",
+					error: error instanceof Error ? error.message : String(error)
+				});
+			} finally {
+				running.delete(sink.id);
+				sink.close();
+			}
+		})();
+		return { streamId: sink.id };
+	}
+	return [
+		defineRpcFunction({
+			name: LOCAL_RPC.agentList,
+			type: "query",
+			args: [],
+			returns: v.array(LocalAgentInfoSchema),
+			handler: () => detected ??= detectAgents()
+		}),
+		defineRpcFunction({
+			name: LOCAL_RPC.agentAnalyze,
+			type: "query",
+			args: [AnalyzeArgs],
+			returns: v.object({ streamId: v.string() }),
+			handler: (args) => start(args, runAgentAnalysis)
+		}),
+		defineRpcFunction({
+			name: LOCAL_RPC.agentChat,
+			type: "query",
+			args: [ChatArgs],
+			returns: v.object({ streamId: v.string() }),
+			handler: ({ session, text, ...args }) => start(args, (options) => runAgentChat({
+				...options,
+				session,
+				text
+			}))
+		}),
+		defineRpcFunction({
+			name: LOCAL_RPC.agentAbort,
+			type: "action",
+			args: [v.object({ streamId: v.string() })],
+			returns: v.void(),
+			handler: ({ streamId }) => {
+				running.get(streamId)?.abort();
+			}
+		})
+	];
+}
+//#endregion
+//#region src/credentials.ts
+/** The environment first, then the GitHub CLI's login, if `gh` is installed and signed in. */
+async function resolveGithubToken(env) {
+	const fromEnv = githubTokenFromEnv(env);
+	if (fromEnv) return fromEnv;
+	try {
+		const { stdout } = await promisify(execFile)("gh", ["auth", "token"]);
+		return stdout.trim() || void 0;
+	} catch {
+		return;
+	}
+}
+//#endregion
+//#region src/rpc.ts
+const target = v.object({ target: v.string() });
+/**
+* Every function the `PR_LOCAL` SPA calls. Only a client devframe has trusted
+* reaches them; inputs are still validated, since they decide what `git` runs.
+*/
+function localRpcFunctions({ cwd, driver, env }) {
+	const source = (text) => createLocalSource({
+		cwd,
+		target: text
+	});
+	return [
+		defineRpcFunction({
+			name: LOCAL_RPC.repoInfo,
+			type: "query",
+			handler: () => readRepoInfo(cwd)
+		}),
+		defineRpcFunction({
+			name: LOCAL_RPC.sourceKey,
+			type: "query",
+			args: [target],
+			returns: v.string(),
+			handler: ({ target }) => source(target).key()
+		}),
+		defineRpcFunction({
+			name: LOCAL_RPC.sourceFetch,
+			type: "query",
+			args: [target],
+			returns: DiffsPayloadSchema,
+			handler: ({ target }) => source(target).fetch()
+		}),
+		defineRpcFunction({
+			name: LOCAL_RPC.sourceFingerprint,
+			type: "query",
+			args: [target],
+			returns: v.string(),
+			handler: ({ target }) => source(target).fingerprint()
+		}),
+		defineRpcFunction({
+			name: LOCAL_RPC.sourceLoadFile,
+			type: "query",
+			args: [v.object({
+				target: v.string(),
+				path: v.string(),
+				sha: v.string()
+			})],
+			returns: v.optional(v.string()),
+			handler: ({ target, path, sha }) => source(target).loadFile(path, sha)
+		}),
+		defineRpcFunction({
+			name: LOCAL_RPC.storageGetItem,
+			type: "query",
+			args: [v.object({ key: v.string() })],
+			returns: v.nullable(v.string()),
+			handler: async ({ key }) => {
+				const value = await driver.getItem(key, {});
+				return typeof value === "string" ? value : null;
+			}
+		}),
+		defineRpcFunction({
+			name: LOCAL_RPC.storageSetItem,
+			type: "action",
+			args: [v.object({
+				key: v.string(),
+				value: v.string()
+			})],
+			returns: v.void(),
+			handler: async ({ key, value }) => {
+				await driver.setItem?.(key, value, {});
+			}
+		}),
+		defineRpcFunction({
+			name: LOCAL_RPC.storageRemoveItem,
+			type: "action",
+			args: [v.object({ key: v.string() })],
+			returns: v.void(),
+			handler: async ({ key }) => {
+				await driver.removeItem?.(key, {});
+			}
+		}),
+		defineRpcFunction({
+			name: LOCAL_RPC.storageGetKeys,
+			type: "query",
+			args: [v.object({ base: v.string() })],
+			returns: v.array(v.string()),
+			handler: ({ base }) => driver.getKeys(base, {})
+		}),
+		defineRpcFunction({
+			name: LOCAL_RPC.githubToken,
+			type: "query",
+			handler: () => resolveGithubToken(env)
+		})
+	];
+}
+//#endregion
+//#region src/storage.ts
+/**
+* The fs driver maps every `:` of a key to a directory, so `a:b` (a file) and `a:b:c`
+* (needing `a/b/` as a directory) can't both exist. Keys stay one directory per
+* collection prefix (`pr-meta:`, `review:`, ...) with the rest escaped into one file name.
+*/
+function flatKeys(driver) {
+	const encode = (key) => {
+		const [head = "", ...rest] = key.split(":");
+		return rest.length ? `${head}:${encodeURIComponent(rest.join(":"))}` : head;
+	};
+	const decode = (key) => {
+		const [head = "", ...rest] = key.split(/[:/]/);
+		return rest.length ? `${head}:${decodeURIComponent(rest.join(":"))}` : head;
+	};
+	return {
+		...driver,
+		hasItem: (key, opts) => driver.hasItem(encode(key), opts),
+		getItem: (key, opts) => driver.getItem(encode(key), opts),
+		setItem: (key, value, opts) => driver.setItem?.(encode(key), value, opts),
+		removeItem: (key, opts) => driver.removeItem?.(encode(key), opts),
+		getKeys: async (base, opts) => (await driver.getKeys(encode(base.replace(/:$/, "")), opts)).map(decode)
+	};
+}
+/** `<git-common-dir>/pulls-review`: shared by every worktree of the repo, never committed. */
+async function repoCacheDir(cwd) {
+	const { stdout } = await promisify(execFile)("git", ["rev-parse", "--git-common-dir"], { cwd });
+	return resolve(cwd, stdout.trim(), "pulls-review");
+}
+async function createRepoCacheDriver(cwd) {
+	return flatKeys(fsDriver({ base: await repoCacheDir(cwd) }));
+}
+//#endregion
+//#region src/devframe.ts
+/**
+* The one definition every surface consumes: the `pulls.review` CLI (`index.ts`)
+* and, through `createPluginFromDevframe`, a devframe hub. The SPA is the app's
+* `PR_LOCAL` build, copied next to this file by the package build.
+*/
+var devframe_default = defineDevframe({
+	id: LOCAL_DEVFRAME_ID,
+	name: "pulls.review",
+	version,
+	packageName: name,
+	description: "Review local git changes, grouped and summarized.",
+	homepage: "https://pulls.review",
+	icon: "ph:git-diff-duotone",
+	clientAssets: fileURLToPath(new URL("./client", import.meta.url)),
+	importMetaUrl: import.meta.url,
+	cli: {
+		command: "pulls.review",
+		port: 7390
+	},
+	async setup(ctx) {
+		const scope = ctx.scope(LOCAL_DEVFRAME_ID);
+		const functions = [...localRpcFunctions({
+			cwd: ctx.cwd,
+			driver: await createRepoCacheDriver(ctx.cwd),
+			env: process.env
+		}), ...agentRpcFunctions({
+			cwd: ctx.cwd,
+			patchDir: join(await repoCacheDir(ctx.cwd), "agent"),
+			channel: scope.rpc.streaming.create(LOCAL_AGENT_CHANNEL, { replayWindow: 4096 })
+		})];
+		for (const fn of functions) scope.rpc.register(fn);
+	}
+});
+//#endregion
+export { devframe_default as t };