@ipul-labs/forge 1.13.0

package/bin/cli/apply.js

@@ -0,0 +1,264 @@
+import path from "node:path";
+import React, { useEffect, useState } from "react";
+import Spinner from "ink-spinner";
+import { h, Box, Text, useApp, runApp, Confirm } from "./ink.js";
+import { canonicalRepoId, getFlag, projectRoot } from "./utils.js";
+import {
+	PHASES,
+	appendEvent,
+	readAnalysis,
+	readState,
+	resolveSessionTarget,
+	updateState,
+} from "./sessionStore.js";
+
+function changesByRepo(changes) {
+	const map = new Map();
+	for (const c of changes ?? []) {
+		const key = c.repo ?? "(unknown)";
+		if (!map.has(key)) map.set(key, []);
+		map.get(key).push(c);
+	}
+	return map;
+}
+
+function Summary({ analysis }) {
+	const grouped = changesByRepo(analysis.changes);
+	const total = analysis.changes?.length ?? 0;
+	return h`<${Box} flexDirection="column">
+		<${Text} dimColor>${"────────── apply plan ──────────"}</>
+		<${Box}>
+			<${Text} color="yellow">Issue:  </>
+			<${Text}>#${analysis.issue?.iid}: ${analysis.issue?.title ?? ""}</>
+		</>
+		${analysis.mrTitle
+			? h`<${Box}>
+				<${Text} color="yellow">MR:     </>
+				<${Text}>${analysis.mrTitle}</>
+			</>`
+			: null}
+		<${Box}>
+			<${Text} color="yellow">Total:  </>
+			<${Text}>${`${total} change(s) across ${grouped.size} repo(s)`}</>
+		</>
+		<${Box} marginTop=${1}>
+			<${Text} dimColor>${"Per repo:"}</>
+		</>
+		${[...grouped.entries()].map(([repo, changes], i) =>
+			h`<${Box} flexDirection="column" key=${i} marginLeft=${2}>
+				<${Text} bold>${repo} (${changes.length})</>
+				${changes.map((c, j) =>
+					h`<${Text} key=${j} dimColor>${`  ${c.action.padEnd(7)} ${c.file}`}</>`,
+				)}
+			</>`,
+		)}
+	</>`;
+}
+
+function ApplyView({ analysis, primary, secondaries, bypassYes, onDone }) {
+	const { exit } = useApp();
+	const [phase, setPhase] = useState("review"); // review → confirm → applying → done | aborted | error
+	const [applications, setApplications] = useState([]);
+	const [error, setError] = useState(null);
+	const [running, setRunning] = useState(null); // current repo being applied
+
+	useEffect(() => {
+		if (phase !== "applying") return;
+		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,
+				});
+				// applyFix doesn't currently emit per-step events on its own —
+				// fall back to a coarse "applying repo X" indicator by inspecting
+				// the analysis.changes grouping ahead of the call.
+				const grouped = changesByRepo(analysis.changes);
+				const ordered = [primary, ...secondaries].filter((r) => grouped.has(r));
+				if (ordered.length === 0) {
+					// Fallback to whatever the analysis says
+					ordered.push(...grouped.keys());
+				}
+				setRunning(ordered[0] ?? null);
+				const result = await agent.applyFix(analysis);
+				if (cancelled) return;
+				setApplications(result.applications ?? []);
+				setRunning(null);
+				setPhase("done");
+			} catch (err) {
+				if (cancelled) return;
+				setError(err);
+				setRunning(null);
+				setPhase("error");
+			}
+		})();
+		return () => {
+			cancelled = true;
+		};
+	}, [phase]);
+
+	useEffect(() => {
+		if (phase === "done" || phase === "aborted" || phase === "error") {
+			onDone({
+				phase,
+				applications,
+				error,
+			});
+			exit();
+		}
+	}, [phase]);
+
+	if (phase === "review" || phase === "confirm") {
+		return h`<${Box} flexDirection="column">
+			<${Summary} analysis=${analysis} />
+			<${Confirm}
+				message="Apply these changes (creates branch + opens MR per repo)?"
+				bypassYes=${bypassYes}
+				onSelect=${(yes) => setPhase(yes ? "applying" : "aborted")} />
+		</>`;
+	}
+
+	if (phase === "applying") {
+		return h`<${Box} flexDirection="column">
+			<${Summary} analysis=${analysis} />
+			<${Box} marginTop=${1}>
+				<${Text} color="cyan"><${Spinner} type="dots"/></>
+				<${Text}>${` Applying${running ? ` to ${running}` : "…"}`}</>
+			</>
+		</>`;
+	}
+
+	if (phase === "done") {
+		return h`<${Box} flexDirection="column">
+			<${Summary} analysis=${analysis} />
+			<${Box} flexDirection="column" marginTop=${1}>
+				<${Text} color="green">${`✓ Applied across ${applications.length} repo(s)`}</>
+				${applications.map((a, i) =>
+					h`<${Box} key=${i} flexDirection="column" marginLeft=${2} marginTop=${1}>
+						<${Text} bold>${a.repo}</>
+						<${Text}>${`  branch: ${a.branchName}`}</>
+						${a.mr?.web_url
+							? h`<${Text}>${`  MR:     ${a.mr.web_url}`}</>`
+							: a.mr?.iid
+								? h`<${Text}>${`  MR:     !${a.mr.iid}`}</>`
+								: h`<${Text} dimColor>${"  MR:     (not opened)"}</>`}
+						${a.pipelineUrl
+							? h`<${Text} dimColor>${`  pipe:   ${a.pipelineUrl}`}</>`
+							: null}
+					</>`,
+				)}
+			</>
+		</>`;
+	}
+
+	if (phase === "aborted") {
+		return h`<${Box} flexDirection="column">
+			<${Summary} analysis=${analysis} />
+			<${Box} marginTop=${1}>
+				<${Text} dimColor>${"Aborted — no changes applied."}</>
+			</>
+		</>`;
+	}
+
+	return h`<${Box} flexDirection="column">
+		<${Summary} analysis=${analysis} />
+		<${Box} marginTop=${1}>
+			<${Text} color="red">${`✘ ${error?.message ?? String(error)}`}</>
+		</>
+	</>`;
+}
+
+export async function cmdApply(argv) {
+	const explicitIid = Number(argv[1]);
+	const explicitRepo = getFlag(argv, "--repo");
+	const target = await resolveSessionTarget({
+		explicitIid: Number.isInteger(explicitIid) && explicitIid > 0 ? explicitIid : null,
+		explicitRepo,
+	});
+	if (!target?.repo || !target?.iid) {
+		console.error(
+			"No session target. Pass an <iid>, set --repo, or run analyze first.",
+		);
+		process.exit(1);
+	}
+	const analysis = await readAnalysis(target.repo, target.iid);
+	if (!analysis) {
+		console.error(
+			`No cached analysis at ${target.repo}#${target.iid}. Run: forge-agent analyze ${target.iid}`,
+		);
+		process.exit(1);
+	}
+
+	const state = (await readState(target.repo, target.iid)) ?? {};
+	const primary = state.primary ?? target.repo;
+	const secondaries = state.secondaries ?? [];
+
+	const bypassYes = argv.includes("--yes") || process.env.FORGE_YES === "1";
+	const wantValidate = argv.includes("--validate");
+
+	if (wantValidate) {
+		const { cmdValidate } = await import("./validate.js");
+		// Re-enter validate using the same session target. cmdValidate exits
+		// with code 2 on red — we trust that gating.
+		await cmdValidate(["validate", String(target.iid), "--repo", target.repo]);
+		// If validate failed it would have exited; we reach here only on green.
+	}
+
+	let outcome = { phase: null };
+	await runApp(
+		h`<${ApplyView}
+			analysis=${analysis}
+			primary=${primary}
+			secondaries=${secondaries}
+			bypassYes=${bypassYes}
+			onDone=${(o) => (outcome = o)} />`,
+	);
+
+	if (outcome.phase === "aborted") {
+		await updateState(target.repo, target.iid, {
+			phase: "apply-aborted",
+		});
+		await appendEvent(target.repo, target.iid, { type: "session:apply-aborted" });
+		process.exit(0);
+	}
+	if (outcome.phase === "error") {
+		await updateState(target.repo, target.iid, {
+			phase: "apply-failed",
+			lastError: outcome.error?.message ?? null,
+		});
+		await appendEvent(target.repo, target.iid, {
+			type: "session:apply-failed",
+			error: outcome.error?.message,
+		});
+		process.exit(2);
+	}
+
+	// Done — record per-repo branch + MR. ApplyFix returns one ApplicationResult
+	// per repo; the primary's MR is the canonical session reference.
+	const primaryApp =
+		outcome.applications?.find(
+			(a) => canonicalRepoId(a.repo) === canonicalRepoId(primary),
+		) ?? outcome.applications?.[0];
+	await updateState(target.repo, target.iid, {
+		phase: PHASES.APPLIED,
+		branch: primaryApp?.branchName ?? null,
+		mrIid: primaryApp?.mr?.iid ?? null,
+		mrUrl: primaryApp?.mr?.web_url ?? null,
+		pipelineUrl: primaryApp?.pipelineUrl ?? null,
+		applications: outcome.applications ?? [],
+		lastError: null,
+	});
+	await appendEvent(target.repo, target.iid, {
+		type: "session:apply-done",
+		applications: (outcome.applications ?? []).map((a) => ({
+			repo: a.repo,
+			branchName: a.branchName,
+			mrIid: a.mr?.iid ?? null,
+			mrUrl: a.mr?.web_url ?? null,
+		})),
+	});
+}

package/bin/cli/cifix.js

@@ -0,0 +1,300 @@
+import path from "node:path";
+import React, { useEffect, useState } from "react";
+import Spinner from "ink-spinner";
+import { h, Box, Text, useApp, runApp } from "./ink.js";
+import { getFlag, projectRoot } from "./utils.js";
+import {
+	PHASES,
+	appendEvent,
+	readAnalysis,
+	readState,
+	resolveSessionTarget,
+	updateState,
+	writeAnalysis,
+} from "./sessionStore.js";
+
+const TRACE_TAIL_LINES = 150; // matches the existing CI refinement pattern
+
+async function fetchFailedJobTraces(provider, mrIid) {
+	const pipelines = await provider.getMRPipelines(mrIid);
+	if (!pipelines?.length) throw new Error(`No pipelines found for MR !${mrIid}`);
+	const latest = pipelines[0];
+	const jobs = await provider.getPipelineJobs(latest.id);
+	const failed = jobs.filter((j) => j.status === "failed");
+	if (!failed.length) {
+		throw new Error(
+			`Latest pipeline #${latest.id} has no failed jobs (status: ${latest.status}). Nothing to fix.`,
+		);
+	}
+	const traces = await Promise.all(
+		failed.map(async (j) => {
+			const text = await provider.getJobTrace(j.id).catch(() => "(trace fetch failed)");
+			const tail = text.split("\n").slice(-TRACE_TAIL_LINES).join("\n");
+			return { name: j.name, stage: j.stage, tail };
+		}),
+	);
+	return { pipeline: latest, traces };
+}
+
+function formatCiContext(traces) {
+	return traces
+		.map(
+			(t) =>
+				`### Failed job: ${t.name} (stage: ${t.stage})\n\n\`\`\`\n${t.tail}\n\`\`\``,
+		)
+		.join("\n\n");
+}
+
+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 CiFixView({
+	repo,
+	iid,
+	primary,
+	secondaries,
+	branch,
+	mrIid,
+	model,
+	eventSink,
+	onDone,
+}) {
+	const { exit } = useApp();
+	const [phase, setPhase] = useState("fetching"); // fetching → analyzing → committing → done | error
+	const [items, setItems] = useState([]);
+	const [traces, setTraces] = useState([]);
+	const [pipeline, setPipeline] = useState(null);
+	const [result, setResult] = useState(null);
+	const [error, setError] = useState(null);
+
+	useEffect(() => {
+		if (phase === "done" || phase === "error") {
+			onDone({ phase, result, pipeline, error });
+			exit();
+		}
+	}, [phase]);
+
+	useEffect(() => {
+		let cancelled = false;
+		(async () => {
+			try {
+				const { createProvider } = await import(
+					path.join(projectRoot, "server/forge/core/providers/index.js")
+				);
+				const provider = createProvider(repo);
+				const { pipeline: pipe, traces: tr } = await fetchFailedJobTraces(
+					provider,
+					mrIid,
+				);
+				if (cancelled) return;
+				setTraces(tr);
+				setPipeline(pipe);
+				setPhase("analyzing");
+
+				const ciContext = formatCiContext(tr);
+
+				const { ForgeAgent } = await import(
+					path.join(projectRoot, "server/forge/core/ForgeAgent.js")
+				);
+				const agent = new ForgeAgent({
+					project: primary,
+					secondaryProjects: secondaries,
+				});
+				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 "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.ciFixIssue(iid, ciContext, onEvent, model);
+				if (cancelled) return;
+				setItems((prev) =>
+					prev.map((it) =>
+						it.kind === "step" && it.status === "running"
+							? { ...it, status: "done" }
+							: it,
+					),
+				);
+				if (!final) {
+					setError(new Error("CI fix produced no result."));
+					setPhase("error");
+					return;
+				}
+				setResult(final);
+				setPhase("committing");
+
+				await agent.commitToBranch(branch, final, primary);
+				if (cancelled) return;
+				setPhase("done");
+			} catch (err) {
+				if (cancelled) return;
+				setError(err);
+				setPhase("error");
+			}
+		})();
+		return () => {
+			cancelled = true;
+		};
+	}, []);
+
+	return h`<${Box} flexDirection="column">
+		<${Box}>
+			<${Text} color="yellow">CI fix </>
+			<${Text}>${repo} #${iid} → ${branch}</>
+		</>
+		${phase === "fetching"
+			? h`<${Box} marginTop=${1}>
+				<${Text} color="cyan"><${Spinner} type="dots"/></>
+				<${Text}>${` Fetching failed job traces from MR !${mrIid}…`}</>
+			</>`
+			: null}
+		${traces.length
+			? h`<${Box} flexDirection="column" marginTop=${1}>
+				<${Text} dimColor>${`Pipeline #${pipeline?.id} failed on:`}</>
+				${traces.map((t, i) =>
+					h`<${Text} key=${i} dimColor>${`  • ${t.stage}/${t.name} (${t.tail.split("\n").length} log lines)`}</>`,
+				)}
+			</>`
+			: null}
+		${items.length
+			? h`<${Box} flexDirection="column" marginTop=${1}>
+				${items.map((it, i) => {
+					if (it.kind === "step")
+						return h`<${StepRow} key=${i} step=${it.step} message=${it.message} status=${it.status} />`;
+					if (it.kind === "log")
+						return h`<${Box} key=${i}><${Text} dimColor>  ${it.text}</></>`;
+					return h`<${Box} key=${i}>
+						<${Text} color="red">ERROR</>
+						<${Text}>: ${it.message}</>
+					</>`;
+				})}
+			</>`
+			: null}
+		${phase === "committing"
+			? h`<${Box} marginTop=${1}>
+				<${Text} color="cyan"><${Spinner} type="dots"/></>
+				<${Text}>${` Pushing fix commit to ${branch}…`}</>
+			</>`
+			: null}
+		${phase === "done"
+			? h`<${Box} marginTop=${1}>
+				<${Text} color="green">${`✓ CI fix pushed to ${branch}. Re-run watch to follow the new pipeline.`}</>
+			</>`
+			: null}
+		${phase === "error"
+			? h`<${Box} marginTop=${1}>
+				<${Text} color="red">${`✘ ${error?.message ?? String(error)}`}</>
+			</>`
+			: null}
+	</>`;
+}
+
+export async function cmdCiFix(argv) {
+	const explicitIid = Number(argv[1]);
+	const explicitRepo = getFlag(argv, "--repo");
+	const target = await resolveSessionTarget({
+		explicitIid: Number.isInteger(explicitIid) && explicitIid > 0 ? explicitIid : null,
+		explicitRepo,
+	});
+	if (!target?.repo || !target?.iid) {
+		console.error(
+			"No session target. Pass an <iid>, set --repo, or run analyze + apply first.",
+		);
+		process.exit(1);
+	}
+	const state = await readState(target.repo, target.iid);
+	if (!state?.branch || !state?.mrIid) {
+		console.error(
+			`Session ${target.repo}#${target.iid} has no branch/MR yet. Run: forge-agent apply ${target.iid}`,
+		);
+		process.exit(1);
+	}
+	const primary = state.primary ?? target.repo;
+	const secondaries = state.secondaries ?? [];
+	const model = getFlag(argv, "--model") || undefined;
+
+	let outcome = { phase: null };
+	const events = [];
+	await runApp(
+		h`<${CiFixView}
+			repo=${primary}
+			iid=${target.iid}
+			primary=${primary}
+			secondaries=${secondaries}
+			branch=${state.branch}
+			mrIid=${state.mrIid}
+			model=${model}
+			eventSink=${(e) => events.push(e)}
+			onDone=${(o) => (outcome = o)} />`,
+	);
+
+	if (outcome.phase === "done" && outcome.result) {
+		await writeAnalysis(target.repo, target.iid, outcome.result);
+		await updateState(target.repo, target.iid, {
+			phase: PHASES.APPLIED, // stays applied after a refresh commit
+			lastError: null,
+		});
+		await appendEvent(target.repo, target.iid, {
+			type: "session:cifix-done",
+			pipelineId: outcome.pipeline?.id,
+		});
+		return;
+	}
+	await updateState(target.repo, target.iid, {
+		phase: "cifix-failed",
+		lastError: outcome.error?.message ?? null,
+	}).catch(() => {});
+	await appendEvent(target.repo, target.iid, {
+		type: "session:cifix-failed",
+		error: outcome.error?.message,
+	}).catch(() => {});
+	process.exit(2);
+}

package/bin/cli/close.js

@@ -0,0 +1,125 @@
+import path from "node:path";
+import React, { useEffect, useState } from "react";
+import Spinner from "ink-spinner";
+import { h, Box, Text, useApp, runApp, Confirm } from "./ink.js";
+import { getFlag, projectRoot } from "./utils.js";
+import {
+	PHASES,
+	appendEvent,
+	readState,
+	resolveSessionTarget,
+	updateState,
+} from "./sessionStore.js";
+
+function CloseView({ repo, iid, bypassYes, onDone }) {
+	const { exit } = useApp();
+	const [phase, setPhase] = useState("review");
+	const [error, setError] = useState(null);
+
+	useEffect(() => {
+		if (phase === "done" || phase === "aborted" || phase === "error") {
+			onDone({ phase, error });
+			exit();
+		}
+	}, [phase]);
+
+	useEffect(() => {
+		if (phase !== "closing") return;
+		let cancelled = false;
+		(async () => {
+			try {
+				const { createProvider } = await import(
+					path.join(projectRoot, "server/forge/core/providers/index.js")
+				);
+				const provider = createProvider(repo);
+				if (typeof provider.closeIssue !== "function") {
+					throw new Error(
+						`${provider.name ?? "provider"} does not support closeIssue.`,
+					);
+				}
+				await provider.closeIssue(iid);
+				if (cancelled) return;
+				setPhase("done");
+			} catch (err) {
+				if (cancelled) return;
+				setError(err);
+				setPhase("error");
+			}
+		})();
+		return () => {
+			cancelled = true;
+		};
+	}, [phase]);
+
+	if (phase === "review" || phase === "confirm") {
+		return h`<${Box} flexDirection="column">
+			<${Box}>
+				<${Text} color="yellow">Issue </>
+				<${Text}>${repo} #${iid}</>
+			</>
+			<${Confirm}
+				message="Close this issue?"
+				bypassYes=${bypassYes}
+				onSelect=${(yes) => setPhase(yes ? "closing" : "aborted")} />
+		</>`;
+	}
+
+	if (phase === "closing") {
+		return h`<${Box}>
+			<${Text} color="cyan"><${Spinner} type="dots"/></>
+			<${Text}> Closing issue…</>
+		</>`;
+	}
+
+	if (phase === "done") {
+		return h`<${Text} color="green">${`✓ Closed #${iid}`}</>`;
+	}
+
+	if (phase === "aborted") {
+		return h`<${Text} dimColor>Aborted — issue still open.</>`;
+	}
+
+	return h`<${Box}>
+		<${Text} color="red">${`✘ ${error?.message ?? String(error)}`}</>
+	</>`;
+}
+
+export async function cmdClose(argv) {
+	const explicitIid = Number(argv[1]);
+	const explicitRepo = getFlag(argv, "--repo");
+	const bypassYes = argv.includes("--yes") || process.env.FORGE_YES === "1";
+
+	const target = await resolveSessionTarget({
+		explicitIid: Number.isInteger(explicitIid) && explicitIid > 0 ? explicitIid : null,
+		explicitRepo,
+	});
+	if (!target?.repo || !target?.iid) {
+		console.error(
+			"No session target. Pass an <iid>, set --repo, or run analyze first.",
+		);
+		process.exit(1);
+	}
+	const state = await readState(target.repo, target.iid);
+	const repo = state?.primary ?? target.repo;
+
+	let outcome = { phase: null };
+	await runApp(
+		h`<${CloseView}
+			repo=${repo}
+			iid=${target.iid}
+			bypassYes=${bypassYes}
+			onDone=${(o) => (outcome = o)} />`,
+	);
+
+	if (outcome.phase === "done") {
+		await updateState(target.repo, target.iid, {
+			phase: PHASES.CLOSED,
+			closedAt: new Date().toISOString(),
+		}).catch(() => {});
+		await appendEvent(target.repo, target.iid, { type: "session:closed" }).catch(
+			() => {},
+		);
+		return;
+	}
+	if (outcome.phase === "error") process.exit(2);
+}