@ipul-labs/forge 1.13.0

package/bin/cli/analyze.js

@@ -0,0 +1,516 @@
+import fs from "node:fs/promises";
+import path from "node:path";
+import React, { useEffect, useState } from "react";
+import Spinner from "ink-spinner";
+import { createPatch } from "diff";
+import { h, Box, Text, useApp, runApp } from "./ink.js";
+import {
+	projectRoot,
+	getFlag,
+	resolveRepoSet,
+	prefixDivergence,
+} from "./utils.js";
+import {
+	PHASES,
+	appendEvent,
+	setHead,
+	updateState,
+	writeAnalysis,
+} from "./sessionStore.js";
+
+const DIFF_MAX_LINES = 60;
+
+function StepRow({ step, message, status }) {
+	let glyph;
+	if (status === "running")
+		glyph = h`<${Text} color="cyan"><${Spinner} type="dots"/></>`;
+	else if (status === "done") glyph = h`<${Text} color="green">✓</>`;
+	else glyph = h`<${Text} color="red">✘</>`;
+	return h`<${Box}>
+		${glyph}
+		<${Text} dimColor> [${step}]</>
+		<${Text}> ${message}</>
+	</>`;
+}
+
+function ItemRow({ item }) {
+	if (item.kind === "step") return h`<${StepRow} ...${item} />`;
+	if (item.kind === "log")
+		return h`<${Box}><${Text} dimColor>  ${item.text}</></>`;
+	if (item.kind === "usage") {
+		const cost = typeof item.cost === "number" ? `$${item.cost.toFixed(4)}` : "$?";
+		return h`<${Box}>
+			<${Text} dimColor>  ${item.inputTokens}in / ${item.outputTokens}out tokens, ${cost}</>
+		</>`;
+	}
+	if (item.kind === "error")
+		return h`<${Box}><${Text} color="red">ERROR</><${Text}>: ${item.message}</></>`;
+	return null;
+}
+
+function colorForDiffLine(line) {
+	if (line.startsWith("+++") || line.startsWith("---")) return "white";
+	if (line.startsWith("@@")) return "cyan";
+	if (line.startsWith("+")) return "green";
+	if (line.startsWith("-")) return "red";
+	return undefined;
+}
+
+function DiffBlock({ original, proposed, file }) {
+	const patch = createPatch(file, original ?? "", proposed ?? "", "current", "proposed");
+	const lines = patch.split("\n").slice(2);
+	const truncated = lines.length > DIFF_MAX_LINES;
+	const shown = truncated ? lines.slice(0, DIFF_MAX_LINES) : lines;
+	return h`<${Box} flexDirection="column" marginLeft=${4}>
+		${shown.map((line, i) => {
+			const color = colorForDiffLine(line);
+			return h`<${Text} key=${i} color=${color} dimColor=${color === undefined}>${line || " "}</>`;
+		})}
+		${truncated
+			? h`<${Text} dimColor>${`    … ${lines.length - DIFF_MAX_LINES} more diff lines (use --json to see full payload)`}</>`
+			: null}
+	</>`;
+}
+
+function ChangeBlock({ change, index }) {
+	const isCreate = change.action === "create";
+	const isDelete = change.action === "delete";
+	const showDiff = !isDelete; // create: diff vs empty; delete: skip
+	const header = `  ${index + 1}. ${change.action.toUpperCase()}  ${change.repo}:${change.file}`;
+	return h`<${Box} flexDirection="column" marginTop=${1}>
+		<${Text} color="yellow">${header}</>
+		${change.summary
+			? h`<${Box} marginLeft=${5}><${Text} dimColor>${change.summary}</></>`
+			: null}
+		${showDiff
+			? h`<${DiffBlock} file=${change.file} original=${isCreate ? "" : change.original ?? ""} proposed=${change.proposed ?? ""} />`
+			: null}
+	</>`;
+}
+
+function DivergenceWarning({ divergence }) {
+	if (!divergence) return null;
+	const text = `⚠  Issue prefix "${divergence.issue}:" but proposed MR prefix "${divergence.mr}:" — model may have misinterpreted the issue.`;
+	return h`<${Box} marginTop=${1}>
+		<${Text} color="yellow">${text}</>
+	</>`;
+}
+
+function ResultBlock({ result }) {
+	const changes = result.changes ?? [];
+	const issueTitle = result.issue?.title ?? "";
+	const divergence = prefixDivergence(issueTitle, result.mrTitle);
+	return h`<${Box} flexDirection="column" marginTop=${1}>
+		<${Text} dimColor>${"────────────── result ──────────────"}</>
+		<${Box}>
+			<${Text} color="yellow">Issue:  </>
+			<${Text}>#${result.issue?.iid}: ${issueTitle}</>
+		</>
+		${result.mrTitle
+			? h`<${Box}>
+				<${Text} color="yellow">MR:     </>
+				<${Text}>${result.mrTitle}</>
+			</>`
+			: null}
+		${result.repos?.length
+			? h`<${Box}>
+				<${Text} color="yellow">Repos:  </>
+				<${Text}>${result.repos.join(", ")}</>
+			</>`
+			: null}
+		<${DivergenceWarning} divergence=${divergence} />
+		${result.explanation
+			? h`<${Box} flexDirection="column" marginTop=${1}>
+				<${Text} dimColor>Explanation</>
+				<${Text}>${result.explanation}</>
+			</>`
+			: null}
+		<${Box} marginTop=${1}>
+			<${Text} dimColor>${`Changes (${changes.length}):`}</>
+		</>
+		${changes.length === 0
+			? h`<${Box} marginLeft=${2}><${Text} dimColor>(none — model proposed no changes)</></>`
+			: changes.map((c, i) => h`<${ChangeBlock} key=${i} change=${c} index=${i} />`)}
+	</>`;
+}
+
+function AnalyzeView({
+	iid,
+	primary,
+	secondaries,
+	model,
+	agentKind,
+	userPrompt,
+	eventSink,
+	onDone,
+}) {
+	const { exit } = useApp();
+	const [items, setItems] = useState([]);
+	const [result, setResult] = useState(null);
+	const [finished, setFinished] = useState(null);
+
+	useEffect(() => {
+		if (!finished) return;
+		onDone(finished);
+		exit();
+	}, [finished]);
+
+	useEffect(() => {
+		let cancelled = false;
+		(async () => {
+			try {
+				const { ForgeAgent } = await import(
+					path.join(projectRoot, "server/forge/core/ForgeAgent.js")
+				);
+				const agent = new ForgeAgent({
+					project: primary,
+					secondaryProjects: secondaries,
+					agent: agentKind,
+				});
+				let final = null;
+
+				const onEvent = (evt) => {
+					if (cancelled) return;
+					eventSink?.(evt);
+					if (evt.type === "result") {
+						final = evt.data;
+						return;
+					}
+					setItems((prev) => {
+						const closeRunning = (list) =>
+							list.map((it) =>
+								it.kind === "step" && it.status === "running"
+									? { ...it, status: "done" }
+									: it,
+							);
+						switch (evt.type) {
+							case "progress":
+								return [
+									...closeRunning(prev),
+									{
+										kind: "step",
+										step: evt.step,
+										message: evt.message,
+										status: "running",
+									},
+								];
+							case "log":
+								return [...prev, { kind: "log", text: evt.message }];
+							case "usage":
+								return [
+									...prev,
+									{
+										kind: "usage",
+										inputTokens: evt.inputTokens,
+										outputTokens: evt.outputTokens,
+										cost: evt.cost,
+									},
+								];
+							case "error":
+								return [
+									...prev.map((it) =>
+										it.kind === "step" && it.status === "running"
+											? { ...it, status: "failed" }
+											: it,
+									),
+									{ kind: "error", message: evt.message },
+								];
+							default:
+								return prev;
+						}
+					});
+				};
+
+				await agent.analyzeIssue(iid, onEvent, model, undefined, userPrompt, "fresh");
+				if (cancelled) return;
+
+				setItems((prev) =>
+					prev.map((it) =>
+						it.kind === "step" && it.status === "running"
+							? { ...it, status: "done" }
+							: it,
+					),
+				);
+				if (final) setResult(final);
+				setFinished({ ok: true, result: final });
+			} catch (err) {
+				if (cancelled) return;
+				setItems((prev) => [
+					...prev.map((it) =>
+						it.kind === "step" && it.status === "running"
+							? { ...it, status: "failed" }
+							: it,
+					),
+					{ kind: "error", message: err.message || String(err) },
+				]);
+				setFinished({ ok: false, error: err });
+			}
+		})();
+		return () => {
+			cancelled = true;
+		};
+	}, []);
+
+	return h`<${Box} flexDirection="column">
+		${items.map((it, i) => h`<${ItemRow} key=${i} item=${it} />`)}
+		${result ? h`<${ResultBlock} result=${result} />` : null}
+	</>`;
+}
+
+/**
+ * Render a cached analysis (read from session) through the same ResultBlock
+ * the live analyze view uses. No streaming, no progress — just the final
+ * payload. Used by `forge-agent show`.
+ */
+export async function renderCachedResult(result) {
+	await runApp(
+		h`<${Box} flexDirection="column">
+			<${ResultBlock} result=${result} />
+		</>`,
+	);
+}
+
+/**
+ * Persist analyze outcome to ~/.forge/sessions/<repo>/<iid>/. Writes
+ * analysis.json (if a result is present), state.json with the new phase,
+ * events.ndjson with the full event buffer, and bumps HEAD so the next
+ * <iid>-less command resumes here. Errors during persistence are
+ * surfaced on stderr but never abort the caller.
+ */
+async function persistAnalyzeOutcome({ repo, iid, primary, secondaries, result, events, error }) {
+	if (!repo || !iid) return;
+	try {
+		if (result) await writeAnalysis(repo, iid, result);
+		await updateState(repo, iid, {
+			repo,
+			iid: Number(iid),
+			primary,
+			secondaries,
+			phase: result ? PHASES.ANALYZED : "analyze-failed",
+			lastError: error?.message ?? null,
+		});
+		await appendEvent(repo, iid, { type: "session:analyze-start" });
+		for (const evt of events) await appendEvent(repo, iid, evt);
+		await appendEvent(repo, iid, {
+			type: "session:analyze-end",
+			ok: !error,
+			error: error?.message,
+		});
+		await setHead(repo, iid);
+	} catch (err) {
+		process.stderr.write(`forge: failed to persist session: ${err.message}\n`);
+	}
+}
+
+/**
+ * Render a saved NDJSON event stream through the same Ink view, without
+ * re-running the agent. Useful for verifying renderer changes against a
+ * known-good payload, and for users who want to re-inspect a prior result.
+ */
+async function cmdAnalyzeReplay(replayPath) {
+	const raw = await fs.readFile(replayPath, "utf8");
+	const events = raw
+		.split("\n")
+		.filter(Boolean)
+		.map((line) => {
+			try {
+				return JSON.parse(line);
+			} catch {
+				return null;
+			}
+		})
+		.filter(Boolean);
+
+	let outcome = { ok: true };
+	await runApp(
+		h`<${ReplayView} events=${events} onDone=${(o) => (outcome = o)} />`,
+	);
+	if (!outcome.ok) process.exit(2);
+}
+
+function ReplayView({ events, onDone }) {
+	const { exit } = useApp();
+	const [items, setItems] = useState([]);
+	const [result, setResult] = useState(null);
+	const [finished, setFinished] = useState(null);
+
+	useEffect(() => {
+		if (!finished) return;
+		onDone(finished);
+		exit();
+	}, [finished]);
+
+	useEffect(() => {
+		let final = null;
+		const next = [];
+		const closeRunning = (list) =>
+			list.map((it) =>
+				it.kind === "step" && it.status === "running" ? { ...it, status: "done" } : it,
+			);
+		for (const evt of events) {
+			if (evt.type === "result") {
+				final = evt.data;
+				continue;
+			}
+			switch (evt.type) {
+				case "progress": {
+					const closed = closeRunning(next);
+					next.length = 0;
+					next.push(...closed, {
+						kind: "step",
+						step: evt.step,
+						message: evt.message,
+						status: "running",
+					});
+					break;
+				}
+				case "log":
+					next.push({ kind: "log", text: evt.message });
+					break;
+				case "usage":
+					next.push({
+						kind: "usage",
+						inputTokens: evt.inputTokens,
+						outputTokens: evt.outputTokens,
+						cost: evt.cost,
+					});
+					break;
+				case "error": {
+					const closed = next.map((it) =>
+						it.kind === "step" && it.status === "running"
+							? { ...it, status: "failed" }
+							: it,
+					);
+					next.length = 0;
+					next.push(...closed, { kind: "error", message: evt.message });
+					break;
+				}
+				default:
+			}
+		}
+		setItems(closeRunning(next));
+		if (final) setResult(final);
+		setFinished({ ok: true });
+	}, []);
+
+	return h`<${Box} flexDirection="column">
+		${items.map((it, i) => h`<${ItemRow} key=${i} item=${it} />`)}
+		${result ? h`<${ResultBlock} result=${result} />` : null}
+	</>`;
+}
+
+export async function cmdAnalyze(argv) {
+	const replayPath = getFlag(argv, "--replay");
+	if (replayPath) return cmdAnalyzeReplay(replayPath);
+
+	const iid = Number(argv[1]);
+	if (!Number.isInteger(iid) || iid <= 0) {
+		console.error("Usage: forge-agent analyze <iid> [options]");
+		process.exit(1);
+	}
+
+	const { primary, secondaries } = await resolveRepoSet(argv);
+	if (!primary) {
+		console.error(
+			"No repo. Pass --repo <group/repo>, set FORGE_GITLAB_PROJECT, or run `forge-agent init`.",
+		);
+		process.exit(1);
+	}
+
+	const model = getFlag(argv, "--model") || undefined;
+	const agentKind = getFlag(argv, "--agent") || "claude";
+	const userPrompt = getFlag(argv, "--prompt") || undefined;
+	const json = argv.includes("--json");
+	const quiet = argv.includes("--quiet");
+
+	const { ForgeAgent } = await import(
+		path.join(projectRoot, "server/forge/core/ForgeAgent.js")
+	);
+
+	if (json || quiet) {
+		const agent = new ForgeAgent({
+			project: primary,
+			secondaryProjects: secondaries,
+			agent: agentKind,
+		});
+		let finalResult = null;
+		const events = [];
+		const onEvent = (evt) => {
+			if (evt.type === "result") finalResult = evt.data;
+			events.push(evt);
+			if (json) process.stdout.write(`${JSON.stringify(evt)}\n`);
+		};
+		try {
+			await agent.analyzeIssue(iid, onEvent, model, undefined, userPrompt, "fresh");
+		} catch (err) {
+			if (json) {
+				process.stdout.write(
+					`${JSON.stringify({ type: "error", message: err.message })}\n`,
+				);
+			} else {
+				process.stderr.write(`ERROR: ${err.message}\n`);
+			}
+			await persistAnalyzeOutcome({
+				repo: primary,
+				iid,
+				primary,
+				secondaries,
+				result: null,
+				events,
+				error: err,
+			});
+			process.exit(2);
+		}
+		if (!finalResult) {
+			if (!json) console.error("Analysis produced no result.");
+			await persistAnalyzeOutcome({
+				repo: primary,
+				iid,
+				primary,
+				secondaries,
+				result: null,
+				events,
+				error: new Error("no result"),
+			});
+			process.exit(2);
+		}
+		await persistAnalyzeOutcome({
+			repo: primary,
+			iid,
+			primary,
+			secondaries,
+			result: finalResult,
+			events,
+		});
+		if (quiet && !json) console.log(JSON.stringify(finalResult, null, 2));
+		return;
+	}
+
+	let outcome = { ok: true };
+	const events = [];
+	await runApp(
+		h`<${AnalyzeView}
+			iid=${iid}
+			primary=${primary}
+			secondaries=${secondaries}
+			model=${model}
+			agentKind=${agentKind}
+			userPrompt=${userPrompt}
+			eventSink=${(e) => events.push(e)}
+			onDone=${(o) => (outcome = o)} />`,
+	);
+	await persistAnalyzeOutcome({
+		repo: primary,
+		iid,
+		primary,
+		secondaries,
+		result: outcome.result ?? null,
+		events,
+		error: outcome.error,
+	});
+	if (!outcome.ok) process.exit(2);
+	if (!outcome.result) {
+		console.error("Analysis produced no result.");
+		process.exit(2);
+	}
+}