@ipul-labs/forge 1.13.0

package/bin/cli/utils.js

@@ -0,0 +1,145 @@
+import fs from "node:fs/promises";
+import path from "node:path";
+import { fileURLToPath } from "node:url";
+
+const __dirname = path.dirname(fileURLToPath(import.meta.url));
+export const projectRoot = path.dirname(path.dirname(__dirname));
+
+export async function readPkg() {
+	const raw = await fs.readFile(path.join(projectRoot, "package.json"), "utf8");
+	return JSON.parse(raw);
+}
+
+export function getFlag(argv, name) {
+	const idx = argv.indexOf(name);
+	if (idx !== -1 && argv[idx + 1] && !argv[idx + 1].startsWith("-")) return argv[idx + 1];
+	const eq = argv.find((a) => a.startsWith(`${name}=`));
+	return eq ? eq.slice(name.length + 1) : null;
+}
+
+/**
+ * Collect every value of a repeatable flag: --secondary a --secondary b → ["a", "b"].
+ */
+export function getFlagAll(argv, name) {
+	const out = [];
+	for (let i = 0; i < argv.length; i++) {
+		if (argv[i] === name && argv[i + 1] && !argv[i + 1].startsWith("-")) {
+			out.push(argv[i + 1]);
+			i += 1;
+		} else if (argv[i].startsWith(`${name}=`)) {
+			out.push(argv[i].slice(name.length + 1));
+		}
+	}
+	return out;
+}
+
+export function parsePort(argv) {
+	let raw;
+	const i = argv.indexOf("-p");
+	const j = argv.indexOf("--port");
+	if (i !== -1 && argv[i + 1]) raw = argv[i + 1];
+	else if (j !== -1 && argv[j + 1]) raw = argv[j + 1];
+	else {
+		const eq = argv.find((a) => a.startsWith("--port="));
+		if (eq) raw = eq.slice("--port=".length);
+	}
+	if (raw == null) return null;
+	const n = Number(raw);
+	if (!Number.isInteger(n) || n < 1 || n > 65535) {
+		console.error(`Invalid port: ${raw} (must be 1–65535)`);
+		process.exit(1);
+	}
+	return n;
+}
+
+export function relativeAge(iso) {
+	if (!iso) return "";
+	const ms = Date.now() - new Date(iso).getTime();
+	if (Number.isNaN(ms) || ms < 0) return "";
+	const s = Math.floor(ms / 1000);
+	if (s < 60) return `${s}s`;
+	const m = Math.floor(s / 60);
+	if (m < 60) return `${m}m`;
+	const h = Math.floor(m / 60);
+	if (h < 24) return `${h}h`;
+	const d = Math.floor(h / 24);
+	if (d < 30) return `${d}d`;
+	const mo = Math.floor(d / 30);
+	if (mo < 12) return `${mo}mo`;
+	return `${Math.floor(mo / 12)}y`;
+}
+
+export async function resolvePrimaryRepo(argv) {
+	const repoFlag = getFlag(argv, "--repo");
+	let primary = repoFlag || process.env.FORGE_GITLAB_PROJECT;
+	if (!primary) {
+		const { get } = await import(
+			path.join(projectRoot, "server/forge/core/configStore.js")
+		);
+		primary = get().repos?.[0]?.id;
+	}
+	return primary;
+}
+
+/**
+ * Strip a "gitlab:" / "github:" / "azuredevops:" prefix so two repo strings
+ * that point at the same project compare equal regardless of where they came
+ * from (env vars are usually unprefixed; configStore entries are prefixed).
+ */
+export function canonicalRepoId(id) {
+	if (!id) return id;
+	return id.replace(/^(gitlab|github|azuredevops):/, "");
+}
+
+/**
+ * Resolve { primary, secondaries } from argv. Honours:
+ *  - --repo <id>            primary repo (overrides default)
+ *  - --secondary <id>       additional repo (repeatable)
+ *  - --all-repos            all configured repos except primary become secondaries
+ *
+ * Dedup is prefix-insensitive so an env-provided primary doesn't double up
+ * with its configStore-prefixed twin.
+ */
+export async function resolveRepoSet(argv) {
+	const primary = await resolvePrimaryRepo(argv);
+	const explicit = getFlagAll(argv, "--secondary");
+	const allRepos = argv.includes("--all-repos");
+
+	const primaryCanon = canonicalRepoId(primary);
+	let secondaries = explicit.filter((id) => canonicalRepoId(id) !== primaryCanon);
+
+	if (allRepos) {
+		const { get } = await import(
+			path.join(projectRoot, "server/forge/core/configStore.js")
+		);
+		const configured = (get().repos ?? []).map((r) => r.id);
+		const fromConfig = configured.filter(
+			(id) => canonicalRepoId(id) !== primaryCanon,
+		);
+		const merged = [...secondaries, ...fromConfig];
+		// Dedup secondaries against each other (prefix-insensitive, keep first).
+		const seen = new Set();
+		secondaries = merged.filter((id) => {
+			const key = canonicalRepoId(id);
+			if (seen.has(key)) return false;
+			seen.add(key);
+			return true;
+		});
+	}
+	return { primary, secondaries };
+}
+
+/**
+ * Compare a conventional-commits prefix on two titles. Returns null if both
+ * prefixes match or either is missing; otherwise returns { issue, mr } so the
+ * caller can warn (e.g. issue is "feat:" but mrTitle starts "fix:").
+ */
+export function prefixDivergence(issueTitle, mrTitle) {
+	if (!issueTitle || !mrTitle) return null;
+	const re = /^([a-zA-Z]+)(?:\([^)]*\))?!?:/;
+	const ip = issueTitle.match(re)?.[1]?.toLowerCase();
+	const mp = mrTitle.match(re)?.[1]?.toLowerCase();
+	if (!ip || !mp) return null;
+	if (ip === mp) return null;
+	return { issue: ip, mr: mp };
+}

package/bin/cli/validate.js

@@ -0,0 +1,280 @@
+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,
+} from "./sessionStore.js";
+
+function StepRow({ step, status }) {
+	let glyph;
+	let color;
+	if (status === "running") {
+		glyph = h`<${Spinner} type="dots"/>`;
+		color = "cyan";
+	} else if (status === "passed") {
+		glyph = h`<${Text}>✓</>`;
+		color = "green";
+	} else if (status === "failed") {
+		glyph = h`<${Text}>✘</>`;
+		color = "red";
+	} else {
+		glyph = h`<${Text}>○</>`;
+		color = "gray";
+	}
+	return h`<${Box} marginLeft=${4}>
+		<${Text} color=${color}>${glyph}</>
+		<${Text}> ${step}</>
+	</>`;
+}
+
+function RepoBlock({ repo, projectType, steps, status, allPassed }) {
+	const headerColor = status === "done" ? (allPassed ? "green" : "red") : "yellow";
+	const headerText =
+		status === "done"
+			? allPassed
+				? `✓ ${repo} (${projectType ?? "?"}) — all checks passed`
+				: `✘ ${repo} (${projectType ?? "?"}) — failed`
+			: `▸ ${repo} (${projectType ?? "?"})`;
+	return h`<${Box} flexDirection="column" marginTop=${1}>
+		<${Text} color=${headerColor}>${headerText}</>
+		${steps.map((s, i) => h`<${StepRow} key=${i} ...${s} />`)}
+	</>`;
+}
+
+function LogLine({ message, repo }) {
+	return h`<${Box} marginLeft=${4}>
+		<${Text} dimColor>${repo ? `[${repo}] ` : ""}${message}</>
+	</>`;
+}
+
+function ValidateView({ analysis, eventSink, onDone }) {
+	const { exit } = useApp();
+	const [repos, setRepos] = useState({});
+	const [logs, setLogs] = useState([]);
+	const [finished, setFinished] = useState(null);
+
+	useEffect(() => {
+		if (!finished) return;
+		onDone(finished);
+		exit();
+	}, [finished]);
+
+	useEffect(() => {
+		let cancelled = false;
+		(async () => {
+			try {
+				const { validate } = await import(
+					path.join(projectRoot, "server/forge/core/validator.js")
+				);
+				let allOk = true;
+
+				const onEvent = (evt) => {
+					if (cancelled) return;
+					eventSink?.(evt);
+					const repo = evt.repo;
+
+					if (evt.type === "repo_started" && repo) {
+						setRepos((prev) => ({
+							...prev,
+							[repo]: {
+								projectType: evt.projectType,
+								stepOrder: evt.stepOrder ?? [],
+								steps: (evt.stepOrder ?? []).map((s) => ({
+									step: s,
+									status: "pending",
+								})),
+								status: "running",
+								allPassed: null,
+							},
+						}));
+						return;
+					}
+
+					if (evt.type === "progress" && repo && evt.step) {
+						setRepos((prev) => {
+							const cur = prev[repo];
+							if (!cur) return prev;
+							return {
+								...prev,
+								[repo]: {
+									...cur,
+									steps: cur.steps.map((s) =>
+										s.step === evt.step ? { ...s, status: "running" } : s,
+									),
+								},
+							};
+						});
+						return;
+					}
+
+					if (evt.type === "step_result" && repo && evt.step) {
+						setRepos((prev) => {
+							const cur = prev[repo];
+							if (!cur) return prev;
+							return {
+								...prev,
+								[repo]: {
+									...cur,
+									steps: cur.steps.map((s) =>
+										s.step === evt.step
+											? { ...s, status: evt.passed ? "passed" : "failed" }
+											: s,
+									),
+								},
+							};
+						});
+						if (!evt.passed) allOk = false;
+						return;
+					}
+
+					if (evt.type === "repo_result" && repo) {
+						setRepos((prev) => {
+							const cur = prev[repo];
+							if (!cur) return prev;
+							return {
+								...prev,
+								[repo]: { ...cur, status: "done", allPassed: evt.allPassed },
+							};
+						});
+						if (!evt.allPassed) allOk = false;
+						return;
+					}
+
+					if (evt.type === "log") {
+						setLogs((prev) => [
+							...prev,
+							{ message: evt.message, repo: evt.repo },
+						]);
+					}
+				};
+
+				const result = await validate(analysis, onEvent);
+				if (cancelled) return;
+				setFinished({ ok: true, allPassed: allOk && result.allPassed, result });
+			} catch (err) {
+				if (cancelled) return;
+				setLogs((prev) => [
+					...prev,
+					{ message: `ERROR: ${err.message ?? String(err)}` },
+				]);
+				setFinished({ ok: false, error: err });
+			}
+		})();
+		return () => {
+			cancelled = true;
+		};
+	}, []);
+
+	return h`<${Box} flexDirection="column">
+		<${Text}>${`Validating ${analysis.changes?.length ?? 0} change(s)…`}</>
+		${Object.entries(repos).map(([repo, r], i) =>
+			h`<${RepoBlock} key=${i} repo=${repo} ...${r} />`,
+		)}
+		${logs.length > 0
+			? h`<${Box} flexDirection="column" marginTop=${1}>
+				<${Text} dimColor>${"─── log ───"}</>
+				${logs.slice(-12).map((l, i) => h`<${LogLine} key=${i} ...${l} />`)}
+			</>`
+			: null}
+		${finished
+			? h`<${Box} marginTop=${1}>
+				<${Text} color=${finished.ok && finished.allPassed ? "green" : "red"}>
+					${finished.ok && finished.allPassed ? "✓ All checks passed." : "✘ Validation failed."}
+				</>
+			</>`
+			: null}
+	</>`;
+}
+
+export async function cmdValidate(argv) {
+	const json = argv.includes("--json");
+	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);
+	}
+
+	if (json) {
+		const { validate } = await import(
+			path.join(projectRoot, "server/forge/core/validator.js")
+		);
+		const events = [];
+		const onEvent = (evt) => {
+			events.push(evt);
+			process.stdout.write(`${JSON.stringify(evt)}\n`);
+		};
+		try {
+			const result = await validate(analysis, onEvent);
+			await persistValidateOutcome(target.repo, target.iid, events, result.allPassed, null);
+			if (!result.allPassed) process.exit(2);
+		} catch (err) {
+			process.stdout.write(
+				`${JSON.stringify({ type: "error", message: err.message })}\n`,
+			);
+			await persistValidateOutcome(target.repo, target.iid, events, false, err);
+			process.exit(2);
+		}
+		return;
+	}
+
+	let outcome = { ok: false };
+	const events = [];
+	await runApp(
+		h`<${ValidateView}
+			analysis=${analysis}
+			eventSink=${(e) => events.push(e)}
+			onDone=${(o) => (outcome = o)} />`,
+	);
+	await persistValidateOutcome(
+		target.repo,
+		target.iid,
+		events,
+		outcome.ok && outcome.allPassed,
+		outcome.error,
+	);
+	if (!outcome.ok || !outcome.allPassed) process.exit(2);
+}
+
+async function persistValidateOutcome(repo, iid, events, passed, error) {
+	try {
+		await updateState(repo, iid, {
+			validation: {
+				passed: !!passed,
+				checkedAt: new Date().toISOString(),
+				error: error?.message ?? null,
+			},
+			phase: passed ? PHASES.VALIDATED : "validate-failed",
+			lastError: error?.message ?? null,
+		});
+		await appendEvent(repo, iid, { type: "session:validate-start" });
+		for (const e of events) await appendEvent(repo, iid, e);
+		await appendEvent(repo, iid, {
+			type: "session:validate-end",
+			passed: !!passed,
+			error: error?.message,
+		});
+	} catch (err) {
+		process.stderr.write(`forge: failed to persist session: ${err.message}\n`);
+	}
+}

package/bin/cli/watch.js

@@ -0,0 +1,274 @@
+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,
+	readState,
+	resolveSessionTarget,
+	updateState,
+} from "./sessionStore.js";
+
+const POLL_MS = 5000;
+const TERMINAL_PIPELINE = new Set([
+	"success",
+	"failed",
+	"canceled",
+	"skipped",
+	"manual",
+]);
+const TERMINAL_JOB = new Set([
+	"success",
+	"failed",
+	"canceled",
+	"skipped",
+	"manual",
+]);
+
+function jobStatusIcon(status) {
+	if (status === "success") return { glyph: "✓", color: "green" };
+	if (status === "failed") return { glyph: "✘", color: "red" };
+	if (status === "canceled" || status === "skipped") return { glyph: "○", color: "gray" };
+	if (status === "manual") return { glyph: "▶", color: "yellow" };
+	if (status === "running") return { glyph: "●", color: "cyan" };
+	if (status === "pending" || status === "created" || status === "scheduled")
+		return { glyph: "·", color: "yellow" };
+	return { glyph: "?", color: undefined };
+}
+
+function pipelineStatusColor(status) {
+	if (status === "success") return "green";
+	if (status === "failed") return "red";
+	if (status === "running" || status === "pending") return "cyan";
+	if (status === "canceled" || status === "skipped") return "gray";
+	return undefined;
+}
+
+function fmtDuration(s) {
+	if (s == null) return "";
+	if (s < 60) return `${Math.round(s)}s`;
+	const m = Math.floor(s / 60);
+	const r = Math.round(s - m * 60);
+	return `${m}m${r > 0 ? `${r}s` : ""}`;
+}
+
+function PipelineRow({ pipeline }) {
+	if (!pipeline) {
+		return h`<${Box}>
+			<${Text} color="cyan"><${Spinner} type="dots"/></>
+			<${Text}> Waiting for pipeline to start…</>
+		</>`;
+	}
+	const color = pipelineStatusColor(pipeline.status);
+	return h`<${Box}>
+		<${Text}>Pipeline </>
+		<${Text} dimColor>#${pipeline.id} </>
+		<${Text} color=${color} bold>${pipeline.status.padEnd(8)}</>
+		${pipeline.web_url ? h`<${Text} dimColor>  ${pipeline.web_url}</>` : null}
+	</>`;
+}
+
+function JobsTable({ jobs }) {
+	if (!jobs?.length) return null;
+	const stages = [...new Set(jobs.map((j) => j.stage ?? "(no-stage)"))];
+	return h`<${Box} flexDirection="column" marginTop=${1}>
+		${stages.map((stage, si) =>
+			h`<${Box} flexDirection="column" key=${si}>
+				<${Text} dimColor>${stage}</>
+				${jobs
+					.filter((j) => (j.stage ?? "(no-stage)") === stage)
+					.map((j, ji) => {
+						const { glyph, color } = jobStatusIcon(j.status);
+						return h`<${Box} key=${ji} marginLeft=${2}>
+							<${Text} color=${color}>${glyph}</>
+							<${Text}> ${j.name.padEnd(28)}</>
+							<${Text} color=${color}>${j.status.padEnd(10)}</>
+							<${Text} dimColor>${fmtDuration(j.duration)}</>
+						</>`;
+					})}
+			</>`,
+		)}
+	</>`;
+}
+
+function WatchView({ repo, mrIid, onDone }) {
+	const { exit } = useApp();
+	const [pipeline, setPipeline] = useState(null);
+	const [jobs, setJobs] = useState([]);
+	const [error, setError] = useState(null);
+	const [tick, setTick] = useState(0);
+	const [done, setDone] = useState(null);
+
+	useEffect(() => {
+		if (!done) return;
+		onDone(done);
+		exit();
+	}, [done]);
+
+	useEffect(() => {
+		let cancelled = false;
+		let timer;
+
+		(async () => {
+			try {
+				const { createProvider } = await import(
+					path.join(projectRoot, "server/forge/core/providers/index.js")
+				);
+				const provider = createProvider(repo);
+
+				const poll = async () => {
+					if (cancelled) return;
+					try {
+						const pipelines = await provider.getMRPipelines(mrIid);
+						if (!pipelines?.length) {
+							setPipeline(null);
+							setJobs([]);
+						} else {
+							const latest = pipelines[0];
+							const [pipe, list] = await Promise.all([
+								provider.getPipeline(latest.id),
+								provider.getPipelineJobs(latest.id),
+							]);
+							if (cancelled) return;
+							setPipeline(pipe);
+							setJobs(list);
+							if (TERMINAL_PIPELINE.has(pipe.status)) {
+								setDone({ ok: true, pipeline: pipe, jobs: list });
+								return;
+							}
+						}
+					} catch (err) {
+						if (cancelled) return;
+						setError(err.message ?? String(err));
+					}
+					setTick((t) => t + 1);
+					timer = setTimeout(poll, POLL_MS);
+				};
+
+				await poll();
+			} catch (err) {
+				if (cancelled) return;
+				setDone({ ok: false, error: err });
+			}
+		})();
+
+		return () => {
+			cancelled = true;
+			if (timer) clearTimeout(timer);
+		};
+	}, []);
+
+	return h`<${Box} flexDirection="column">
+		<${Box}>
+			<${Text} color="yellow">Watching </>
+			<${Text}>${repo} !${mrIid}</>
+			<${Text} dimColor>${`  (poll #${tick + 1}, every ${POLL_MS / 1000}s)`}</>
+		</>
+		<${Box} marginTop=${1}><${PipelineRow} pipeline=${pipeline} /></>
+		<${JobsTable} jobs=${jobs} />
+		${error ? h`<${Box} marginTop=${1}><${Text} color="red">${error}</></>` : null}
+		${done?.ok
+			? h`<${Box} marginTop=${1}>
+				<${Text} color=${pipelineStatusColor(done.pipeline.status)}>
+					${`Pipeline finished: ${done.pipeline.status}`}
+				</>
+			</>`
+			: null}
+	</>`;
+}
+
+export async function cmdWatch(argv) {
+	const json = argv.includes("--json");
+	const explicitIid = Number(argv[1]);
+	const explicitRepo = getFlag(argv, "--repo");
+	const explicitMr = Number(getFlag(argv, "--mr"));
+
+	let repo;
+	let mrIid;
+
+	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 yet. Run: forge-agent apply ${target.iid}`,
+			);
+			process.exit(1);
+		}
+		repo = state.primary ?? target.repo;
+		mrIid = state.mrIid;
+	}
+
+	if (!repo) {
+		console.error("Repo is required: pass --repo <id>");
+		process.exit(1);
+	}
+
+	if (json) {
+		const { createProvider } = await import(
+			path.join(projectRoot, "server/forge/core/providers/index.js")
+		);
+		const provider = createProvider(repo);
+		while (true) {
+			const pipelines = await provider.getMRPipelines(mrIid).catch((err) => {
+				process.stdout.write(JSON.stringify({ type: "error", message: err.message }) + "\n");
+				return null;
+			});
+			if (!pipelines?.length) {
+				process.stdout.write(JSON.stringify({ type: "tick", pipeline: null }) + "\n");
+			} else {
+				const latest = pipelines[0];
+				const [pipe, list] = await Promise.all([
+					provider.getPipeline(latest.id),
+					provider.getPipelineJobs(latest.id),
+				]);
+				process.stdout.write(
+					JSON.stringify({ type: "tick", pipeline: pipe, jobs: list }) + "\n",
+				);
+				if (TERMINAL_PIPELINE.has(pipe.status)) {
+					process.exit(pipe.status === "success" ? 0 : 2);
+				}
+			}
+			await new Promise((r) => setTimeout(r, POLL_MS));
+		}
+	}
+
+	let outcome = { ok: false };
+	await runApp(
+		h`<${WatchView}
+			repo=${repo}
+			mrIid=${mrIid}
+			onDone=${(o) => (outcome = o)} />`,
+	);
+
+	// Persist last pipeline state if we have a session
+	if (Number.isInteger(explicitIid) && explicitIid > 0 && explicitRepo) {
+		await updateState(explicitRepo, explicitIid, {
+			lastPipelineStatus: outcome.pipeline?.status ?? null,
+			lastPipelineUrl: outcome.pipeline?.web_url ?? null,
+		}).catch(() => {});
+		await appendEvent(explicitRepo, explicitIid, {
+			type: "session:watch-end",
+			status: outcome.pipeline?.status,
+		}).catch(() => {});
+	}
+
+	if (!outcome.ok || outcome.pipeline?.status !== "success") process.exit(2);
+}
+
+export { TERMINAL_PIPELINE, TERMINAL_JOB };