@ipul-labs/forge 1.13.0

package/bin/cli/issues.js

@@ -0,0 +1,155 @@
+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 { projectRoot, getFlag, relativeAge, resolvePrimaryRepo } from "./utils.js";
+
+function applyFilters(list, { label, mine, currentUser }) {
+	let out = list;
+	if (label) {
+		const want = label.toLowerCase();
+		out = out.filter((i) => (i.labels ?? []).some((l) => l.toLowerCase() === want));
+	}
+	if (mine && currentUser) {
+		const want = currentUser.toLowerCase();
+		out = out.filter((i) => (i.author?.name ?? "").toLowerCase() === want);
+	}
+	return out;
+}
+
+function IssuesView({ primary, limit, label, mine, onError }) {
+	const { exit } = useApp();
+	const [phase, setPhase] = useState("loading");
+	const [issues, setIssues] = useState([]);
+	const [error, setError] = useState(null);
+
+	useEffect(() => {
+		let cancelled = false;
+		(async () => {
+			try {
+				const { createProvider } = await import(
+					path.join(projectRoot, "server/forge/core/providers/index.js")
+				);
+				const provider = createProvider(primary);
+				let list = await provider.listOpenIssues();
+				if (cancelled) return;
+				list = applyFilters(list, {
+					label,
+					mine,
+					currentUser: process.env.FORGE_USER ?? process.env.USER ?? null,
+				});
+				if (Number.isInteger(limit) && limit > 0) list = list.slice(0, limit);
+				setIssues(list);
+				setPhase("done");
+			} catch (err) {
+				if (cancelled) return;
+				setError(err.message || String(err));
+				setPhase("error");
+				onError(err);
+			}
+		})();
+		return () => {
+			cancelled = true;
+		};
+	}, []);
+
+	useEffect(() => {
+		if (phase === "done" || phase === "error") exit();
+	}, [phase]);
+
+	if (phase === "loading") {
+		return h`<${Box}>
+			<${Text} color="cyan"><${Spinner} type="dots"/></>
+			<${Text}> Fetching issues from </>
+			<${Text} dimColor>${primary}</>
+		</>`;
+	}
+
+	if (phase === "error") {
+		return h`<${Box}>
+			<${Text} color="red">✘</>
+			<${Text}> Failed to fetch issues: ${error}</>
+		</>`;
+	}
+
+	const count = issues.length;
+	const header = h`<${Box} marginBottom=${1}>
+		<${Text} color="green">✓</>
+		<${Text}> ${count} open issue${count === 1 ? "" : "s"} in </>
+		<${Text} dimColor>${primary}</>
+	</>`;
+
+	if (count === 0) return header;
+
+	const rows = issues.map((i) => ({
+		age: relativeAge(i.created_at),
+		iid: `#${i.iid}`,
+		title: i.title.length > 60 ? `${i.title.slice(0, 57)}…` : i.title,
+		labels: (i.labels ?? []).slice(0, 3).join(","),
+	}));
+	const wAge = Math.max(3, ...rows.map((r) => r.age.length));
+	const wIid = Math.max(3, ...rows.map((r) => r.iid.length));
+
+	return h`<${Box} flexDirection="column">
+		${header}
+		${rows.map((r, i) =>
+			h`<${Box} key=${i}>
+				<${Box} width=${wAge + 2}><${Text} dimColor>${r.age}</></>
+				<${Box} width=${wIid + 2}><${Text} color="yellow">${r.iid}</></>
+				<${Box} flexGrow=${1}><${Text}>${r.title}</></>
+				<${Text} dimColor>  ${r.labels}</>
+			</>`,
+		)}
+		<${Box} marginTop=${1}>
+			<${Text} dimColor>${"Analyze: forge-agent analyze <iid>"}</>
+		</>
+	</>`;
+}
+
+export async function cmdIssues(argv) {
+	const primary = await resolvePrimaryRepo(argv);
+	if (!primary) {
+		console.error(
+			"No repo. Pass --repo <group/repo>, set FORGE_GITLAB_PROJECT, or run `forge-agent init`.",
+		);
+		process.exit(1);
+	}
+
+	const json = argv.includes("--json");
+	const limitStr = getFlag(argv, "--limit");
+	const limit = limitStr ? parseInt(limitStr, 10) : null;
+	const label = getFlag(argv, "--label");
+	const mine = argv.includes("--mine");
+
+	if (json) {
+		const { createProvider } = await import(
+			path.join(projectRoot, "server/forge/core/providers/index.js")
+		);
+		const provider = createProvider(primary);
+		try {
+			let issues = await provider.listOpenIssues();
+			issues = applyFilters(issues, {
+				label,
+				mine,
+				currentUser: process.env.FORGE_USER ?? process.env.USER ?? null,
+			});
+			if (Number.isInteger(limit) && limit > 0) issues = issues.slice(0, limit);
+			process.stdout.write(`${JSON.stringify(issues, null, 2)}\n`);
+		} catch (err) {
+			process.stdout.write(`${JSON.stringify({ error: err.message })}\n`);
+			process.exit(2);
+		}
+		return;
+	}
+
+	let failed = false;
+	await runApp(
+		h`<${IssuesView}
+			primary=${primary}
+			limit=${limit}
+			label=${label}
+			mine=${mine}
+			onError=${() => (failed = true)} />`,
+	);
+	if (failed) process.exit(2);
+}

package/bin/cli/merge.js

@@ -0,0 +1,175 @@
+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 MergeView({ repo, mrIid, autoMerge, bypassYes, onDone }) {
+	const { exit } = useApp();
+	const [phase, setPhase] = useState("review"); // review → merging → done | aborted | error
+	const [error, setError] = useState(null);
+
+	useEffect(() => {
+		if (phase === "done" || phase === "aborted" || phase === "error") {
+			onDone({ phase, error });
+			exit();
+		}
+	}, [phase]);
+
+	useEffect(() => {
+		if (phase !== "merging") return;
+		let cancelled = false;
+		(async () => {
+			try {
+				const { createProvider } = await import(
+					path.join(projectRoot, "server/forge/core/providers/index.js")
+				);
+				const provider = createProvider(repo);
+				if (autoMerge) {
+					if (typeof provider.setAutoMergeMR !== "function") {
+						throw new Error(
+							`${provider.name ?? "provider"} does not support arming auto-merge.`,
+						);
+					}
+					await provider.setAutoMergeMR(mrIid);
+				} else {
+					await provider.mergeMR(mrIid);
+				}
+				if (cancelled) return;
+				setPhase("done");
+			} catch (err) {
+				if (cancelled) return;
+				setError(err);
+				setPhase("error");
+			}
+		})();
+		return () => {
+			cancelled = true;
+		};
+	}, [phase]);
+
+	const action = autoMerge
+		? "Arm auto-merge for this MR (will merge once CI is green)?"
+		: "Merge this MR now?";
+
+	if (phase === "review" || phase === "confirm") {
+		return h`<${Box} flexDirection="column">
+			<${Box}>
+				<${Text} color="yellow">MR </>
+				<${Text}>${repo} !${mrIid}</>
+			</>
+			<${Confirm}
+				message=${action}
+				bypassYes=${bypassYes}
+				onSelect=${(yes) => setPhase(yes ? "merging" : "aborted")} />
+		</>`;
+	}
+
+	if (phase === "merging") {
+		return h`<${Box}>
+			<${Text} color="cyan"><${Spinner} type="dots"/></>
+			<${Text}>${autoMerge ? " Arming auto-merge…" : " Merging…"}</>
+		</>`;
+	}
+
+	if (phase === "done") {
+		return h`<${Box}>
+			<${Text} color="green">${autoMerge ? "✓ Auto-merge armed." : "✓ Merged."}</>
+		</>`;
+	}
+
+	if (phase === "aborted") {
+		return h`<${Text} dimColor>Aborted — no merge.</>`;
+	}
+
+	return h`<${Box}>
+		<${Text} color="red">${`✘ ${error?.message ?? String(error)}`}</>
+	</>`;
+}
+
+export async function cmdMerge(argv) {
+	const explicitIid = Number(argv[1]);
+	const explicitRepo = getFlag(argv, "--repo");
+	const explicitMr = Number(getFlag(argv, "--mr"));
+	const autoMerge = argv.includes("--auto");
+	const bypassYes = argv.includes("--yes") || process.env.FORGE_YES === "1";
+
+	let repo;
+	let mrIid;
+	let sessionRef = null;
+
+	if (Number.isInteger(explicitMr) && explicitMr > 0) {
+		repo = explicitRepo;
+		mrIid = explicitMr;
+	} else {
+		const target = await resolveSessionTarget({
+			explicitIid:
+				Number.isInteger(explicitIid) && explicitIid > 0 ? explicitIid : null,
+			explicitRepo,
+		});
+		if (!target?.repo || !target?.iid) {
+			console.error(
+				"No session target. Pass --mr <iid> --repo <repo>, or run analyze + apply first.",
+			);
+			process.exit(1);
+		}
+		const state = await readState(target.repo, target.iid);
+		if (!state?.mrIid) {
+			console.error(
+				`Session ${target.repo}#${target.iid} has no MR. Run: forge-agent apply ${target.iid}`,
+			);
+			process.exit(1);
+		}
+		repo = state.primary ?? target.repo;
+		mrIid = state.mrIid;
+		sessionRef = target;
+	}
+
+	if (!repo) {
+		console.error("Repo is required: pass --repo <id>");
+		process.exit(1);
+	}
+
+	let outcome = { phase: null };
+	await runApp(
+		h`<${MergeView}
+			repo=${repo}
+			mrIid=${mrIid}
+			autoMerge=${autoMerge}
+			bypassYes=${bypassYes}
+			onDone=${(o) => (outcome = o)} />`,
+	);
+
+	if (sessionRef) {
+		if (outcome.phase === "done") {
+			await updateState(sessionRef.repo, sessionRef.iid, {
+				phase: PHASES.MERGED,
+				mergedAt: new Date().toISOString(),
+				autoMergeArmed: !!autoMerge,
+				lastError: null,
+			}).catch(() => {});
+			await appendEvent(sessionRef.repo, sessionRef.iid, {
+				type: "session:merge-done",
+				autoMerge: !!autoMerge,
+			}).catch(() => {});
+		} else if (outcome.phase === "error") {
+			await updateState(sessionRef.repo, sessionRef.iid, {
+				lastError: outcome.error?.message ?? null,
+			}).catch(() => {});
+			await appendEvent(sessionRef.repo, sessionRef.iid, {
+				type: "session:merge-failed",
+				error: outcome.error?.message,
+			}).catch(() => {});
+		}
+	}
+
+	if (outcome.phase === "error") process.exit(2);
+	if (outcome.phase === "aborted") process.exit(0);
+}

package/bin/cli/refine.js

@@ -0,0 +1,253 @@
+import path from "node:path";
+import React, { useEffect, useState } from "react";
+import Spinner from "ink-spinner";
+import TextInput from "ink-text-input";
+import { h, Box, Text, useApp, useInput, runApp } from "./ink.js";
+import { getFlag, projectRoot } from "./utils.js";
+import {
+	PHASES,
+	appendEvent,
+	readAnalysis,
+	readState,
+	resolveSessionTarget,
+	updateState,
+	writeAnalysis,
+} from "./sessionStore.js";
+
+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 FeedbackPrompt({ onSubmit }) {
+	const { exit } = useApp();
+	const [input, setInput] = useState("");
+	return h`<${Box} flexDirection="column">
+		<${Box}>
+			<${Text} color="cyan">? </>
+			<${Text}>What feedback should the model address?</>
+		</>
+		<${Box} marginLeft=${2}>
+			<${TextInput}
+				value=${input}
+				onChange=${setInput}
+				onSubmit=${(v) => {
+					const trimmed = v.trim();
+					if (!trimmed) return; // require non-empty
+					onSubmit(trimmed);
+					exit();
+				}} />
+		</>
+	</>`;
+}
+
+function RefineView({ analysis, primary, secondaries, feedback, model, 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,
+				});
+				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.refineIssue(
+					analysis.issue.iid,
+					analysis.changes,
+					feedback,
+					onEvent,
+					model,
+					undefined, // ciContext
+					undefined, // validationState
+					undefined, // claudeSessionId — TODO: persist in session for multi-turn
+				);
+				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">
+		<${Box}>
+			<${Text} dimColor>Feedback: </>
+			<${Text}>${feedback}</>
+		</>
+		${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}</>
+			</>`;
+		})}
+		${result
+			? h`<${Box} marginTop=${1}>
+				<${Text} color="green">${`✓ Refined ${result.changes?.length ?? 0} change(s) — view with: forge-agent show`}</>
+			</>`
+			: null}
+	</>`;
+}
+
+export async function cmdRefine(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 model = getFlag(argv, "--model") || undefined;
+
+	let feedback = getFlag(argv, "--feedback");
+	if (!feedback) {
+		// Interactive prompt
+		await runApp(
+			h`<${FeedbackPrompt} onSubmit=${(v) => (feedback = v)} />`,
+		);
+		if (!feedback) {
+			console.error("Feedback is required. Use --feedback \"...\" or enter it interactively.");
+			process.exit(1);
+		}
+	}
+
+	let outcome = { ok: false };
+	const events = [];
+	await runApp(
+		h`<${RefineView}
+			analysis=${analysis}
+			primary=${primary}
+			secondaries=${secondaries}
+			feedback=${feedback}
+			model=${model}
+			eventSink=${(e) => events.push(e)}
+			onDone=${(o) => (outcome = o)} />`,
+	);
+
+	if (outcome.ok && outcome.result) {
+		await writeAnalysis(target.repo, target.iid, outcome.result);
+		await updateState(target.repo, target.iid, {
+			phase: PHASES.REFINED,
+			lastError: null,
+			lastFeedback: feedback,
+		});
+		await appendEvent(target.repo, target.iid, {
+			type: "session:refine-done",
+			feedback,
+		});
+	} else {
+		await updateState(target.repo, target.iid, {
+			phase: "refine-failed",
+			lastError: outcome.error?.message ?? null,
+		});
+		await appendEvent(target.repo, target.iid, {
+			type: "session:refine-failed",
+			feedback,
+			error: outcome.error?.message,
+		});
+		process.exit(2);
+	}
+}

package/bin/cli/repos.js

@@ -0,0 +1,91 @@
+import path from "node:path";
+import React from "react";
+import { h, Box, Text, runApp } from "./ink.js";
+import { projectRoot } from "./utils.js";
+
+function ReposList({ repos }) {
+	if (repos.length === 0) {
+		return h`<${Box} flexDirection="column">
+			<${Text} dimColor>No repos configured.</>
+			<${Text}>${"Add one: forge-agent repos add <group/repo>"}</>
+		</>`;
+	}
+	return h`<${Box} flexDirection="column" marginTop=${1}>
+		${repos.map((r, i) =>
+			h`<${Box} key=${i}>
+				${i === 0
+					? h`<${Text} color="green">  *</>`
+					: h`<${Text}>   </>`}
+				<${Text}> ${r.id}</>
+			</>`,
+		)}
+		<${Box} marginTop=${1}>
+			<${Text} dimColor>${"* default — override per-call with --repo <group/repo>"}</>
+		</>
+	</>`;
+}
+
+export async function cmdRepos(argv) {
+	const { get, patch } = await import(
+		path.join(projectRoot, "server/forge/core/configStore.js")
+	);
+	const sub = argv[1] ?? "list";
+
+	if (sub === "list") {
+		const json = argv.includes("--json");
+		const repos = get().repos ?? [];
+		if (json) {
+			process.stdout.write(`${JSON.stringify(repos, null, 2)}\n`);
+			return;
+		}
+		await runApp(h`<${ReposList} repos=${repos} />`);
+		return;
+	}
+
+	const repoArg = argv[2];
+	if (!repoArg) {
+		console.error(`Usage: forge-agent repos ${sub} <group/repo>`);
+		process.exit(1);
+	}
+
+	const repos = get().repos ?? [];
+
+	if (sub === "add") {
+		if (repos.some((r) => r.id === repoArg)) {
+			console.error(`Already configured: ${repoArg}`);
+			process.exit(1);
+		}
+		await patch({ repos: [...repos, { id: repoArg, label: repoArg }] });
+		process.stderr.write(`✓ Added ${repoArg}\n`);
+		if (repos.length === 0) {
+			process.stderr.write(`  (set as default)\n`);
+		}
+		return;
+	}
+
+	if (sub === "remove" || sub === "rm") {
+		if (!repos.some((r) => r.id === repoArg)) {
+			console.error(`Not configured: ${repoArg}`);
+			process.exit(1);
+		}
+		await patch({ repos: repos.filter((r) => r.id !== repoArg) });
+		process.stderr.write(`✓ Removed ${repoArg}\n`);
+		return;
+	}
+
+	if (sub === "set-default" || sub === "default") {
+		const target = repos.find((r) => r.id === repoArg);
+		if (!target) {
+			console.error(`Not configured. Add it first: forge-agent repos add ${repoArg}`);
+			process.exit(1);
+		}
+		const rest = repos.filter((r) => r.id !== repoArg);
+		await patch({ repos: [target, ...rest] });
+		process.stderr.write(`✓ Default: ${repoArg}\n`);
+		return;
+	}
+
+	console.error(`Unknown subcommand: ${sub}`);
+	console.error("Subcommands: list, add, set-default, remove");
+	process.exit(1);
+}