@ipul-labs/forge 1.16.8 → 1.17.0

package/bin/cli/analyze.js

@@ -1,516 +0,0 @@
-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 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 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 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);
-	}
-}