@ipul-labs/forge 1.16.8 → 1.17.0

package/bin/cli/apply.js

@@ -1,264 +0,0 @@
-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 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

@@ -1,300 +0,0 @@
-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 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

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