@ipul-labs/forge 1.16.8 → 1.17.1

package/bin/cli/update.js

@@ -1,95 +0,0 @@
-import { execSync } from "node:child_process";
-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, readPkg } from "./utils.js";
-
-function UpdateView({ onDone }) {
-	const { exit } = useApp();
-	const [phase, setPhase] = useState("checking");
-	const [info, setInfo] = useState({});
-	const [error, setError] = useState(null);
-
-	useEffect(() => {
-		if (phase === "done" || phase === "error") {
-			onDone({ phase, info, error });
-			exit();
-		}
-	}, [phase]);
-
-	useEffect(() => {
-		(async () => {
-			try {
-				const before = (await readPkg()).version;
-				setInfo((prev) => ({ ...prev, before }));
-
-				setPhase("pulling");
-				execSync("git pull --rebase", { cwd: projectRoot, stdio: "pipe" });
-
-				setPhase("installing");
-				execSync("npm install --no-audit --no-fund", {
-					cwd: projectRoot,
-					stdio: "pipe",
-				});
-
-				const after = (await readPkg()).version;
-				setInfo({ before, after, updated: before !== after });
-				setPhase("done");
-			} catch (err) {
-				setError(err);
-				setPhase("error");
-			}
-		})();
-	}, []);
-
-	if (phase === "checking") {
-		return h`<${Box}>
-			<${Text} color="cyan"><${Spinner} type="dots"/></>
-			<${Text}> Checking for updates…</>
-		</>`;
-	}
-	if (phase === "pulling") {
-		return h`<${Box}>
-			<${Text} color="cyan"><${Spinner} type="dots"/></>
-			<${Text}> Pulling latest changes…</>
-		</>`;
-	}
-	if (phase === "installing") {
-		return h`<${Box}>
-			<${Text} color="cyan"><${Spinner} type="dots"/></>
-			<${Text}> Installing dependencies…</>
-		</>`;
-	}
-	if (phase === "done") {
-		if (info.updated) {
-			return h`<${Box} flexDirection="column">
-				<${Box}>
-					<${Text} color="green">✓ </>
-					<${Text}>Updated </>
-					<${Text} dimColor>${info.before}</>
-					<${Text}> → </>
-					<${Text} color="green">${info.after}</>
-				</>
-				<${Box}><${Text} dimColor>Restart forge to use the new version.</>
-				</>
-			</>`;
-		}
-		return h`<${Box}>
-			<${Text} color="green">✓ </>
-			<${Text}>Already up to date </>
-			<${Text} dimColor>(v${info.after})</>
-		</>`;
-	}
-	return h`<${Box}>
-		<${Text} color="red">${`✘ Update failed: ${error?.message ?? String(error)}`}</>
-	</>`;
-}
-
-export async function cmdUpdate() {
-	let outcome = { phase: null };
-	await runApp(
-		h`<${UpdateView} onDone=${(o) => (outcome = o)} />`,
-	);
-	if (outcome.phase === "error") process.exit(2);
-}

package/bin/cli/utils.js

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

@@ -1,280 +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,
-} 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 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`);
-	}
-}