@ipul-labs/forge 1.13.0

package/bin/cli/resolution.js

@@ -0,0 +1,126 @@
+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";
+
+function ResolutionView({ repo, secondaries, iid, mrIid, onDone }) {
+	const { exit } = useApp();
+	const [phase, setPhase] = useState("checking"); // checking → done | error
+	const [verdict, setVerdict] = useState(null);
+	const [error, setError] = useState(null);
+
+	useEffect(() => {
+		if (phase === "done" || phase === "error") {
+			onDone({ phase, verdict, error });
+			exit();
+		}
+	}, [phase]);
+
+	useEffect(() => {
+		let cancelled = false;
+		(async () => {
+			try {
+				const { ForgeAgent } = await import(
+					path.join(projectRoot, "server/forge/core/ForgeAgent.js")
+				);
+				const agent = new ForgeAgent({
+					project: repo,
+					secondaryProjects: secondaries,
+				});
+				const result = await agent.checkResolution(iid, mrIid, repo);
+				if (cancelled) return;
+				setVerdict(result);
+				setPhase("done");
+			} catch (err) {
+				if (cancelled) return;
+				setError(err);
+				setPhase("error");
+			}
+		})();
+		return () => {
+			cancelled = true;
+		};
+	}, []);
+
+	if (phase === "checking") {
+		return h`<${Box}>
+			<${Text} color="cyan"><${Spinner} type="dots"/></>
+			<${Text}>${` Checking whether MR !${mrIid} resolves issue #${iid}…`}</>
+		</>`;
+	}
+
+	if (phase === "error") {
+		return h`<${Box}>
+			<${Text} color="red">${`✘ ${error?.message ?? String(error)}`}</>
+		</>`;
+	}
+
+	const ok = verdict?.resolved === true || verdict?.ok === true;
+	const reasoning = verdict?.reasoning ?? verdict?.explanation ?? "";
+	return h`<${Box} flexDirection="column">
+		<${Text} color=${ok ? "green" : "red"}>${ok ? "✓ Resolved" : "✘ Not resolved"}</>
+		${reasoning
+			? h`<${Box} marginTop=${1}>
+				<${Text} dimColor>Model reasoning: </>
+				<${Text}>${reasoning}</>
+			</>`
+			: null}
+	</>`;
+}
+
+export async function cmdResolutionCheck(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?.mrIid) {
+		console.error(
+			`Session ${target.repo}#${target.iid} has no MR. Run: forge-agent apply ${target.iid}`,
+		);
+		process.exit(1);
+	}
+	const repo = state.primary ?? target.repo;
+	const secondaries = state.secondaries ?? [];
+
+	let outcome = { phase: null };
+	await runApp(
+		h`<${ResolutionView}
+			repo=${repo}
+			secondaries=${secondaries}
+			iid=${target.iid}
+			mrIid=${state.mrIid}
+			onDone=${(o) => (outcome = o)} />`,
+	);
+
+	if (outcome.phase === "done") {
+		const ok = outcome.verdict?.resolved === true || outcome.verdict?.ok === true;
+		await updateState(target.repo, target.iid, {
+			phase: ok ? PHASES.RESOLVED : "resolution-rejected",
+			resolution: outcome.verdict ?? null,
+		}).catch(() => {});
+		await appendEvent(target.repo, target.iid, {
+			type: "session:resolution-check",
+			resolved: ok,
+		}).catch(() => {});
+		if (!ok) process.exit(2);
+		return;
+	}
+	process.exit(2);
+}

package/bin/cli/session.js

@@ -0,0 +1,230 @@
+import path from "node:path";
+import React from "react";
+import { h, Box, Text, runApp } from "./ink.js";
+import { getFlag, projectRoot } from "./utils.js";
+import {
+	cleanAll,
+	cleanSession,
+	getHead,
+	listSessions,
+	readAnalysis,
+	readState,
+	resolveSessionTarget,
+	sessionDir,
+} from "./sessionStore.js";
+
+function relTime(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 ago`;
+	const m = Math.floor(s / 60);
+	if (m < 60) return `${m}m ago`;
+	const h = Math.floor(m / 60);
+	if (h < 24) return `${h}h ago`;
+	return `${Math.floor(h / 24)}d ago`;
+}
+
+function SessionsTable({ sessions, head }) {
+	if (sessions.length === 0) {
+		return h`<${Box} flexDirection="column">
+			<${Text} dimColor>No sessions yet.</>
+			<${Text}>${"Run: forge-agent analyze <iid>"}</>
+		</>`;
+	}
+	const rows = sessions.map((s) => {
+		const isHead = head && head.repo === s.repo && head.iid === s.iid;
+		return {
+			marker: isHead ? "*" : " ",
+			ref: `${s.repo}#${s.iid}`,
+			phase: s.phase ?? "?",
+			when: relTime(s.updatedAt),
+		};
+	});
+	const wRef = Math.max(3, ...rows.map((r) => r.ref.length));
+	const wPhase = Math.max(5, ...rows.map((r) => r.phase.length));
+	return h`<${Box} flexDirection="column" marginTop=${1}>
+		${rows.map((r, i) =>
+			h`<${Box} key=${i}>
+				<${Text} color=${r.marker === "*" ? "green" : undefined}>  ${r.marker}</>
+				<${Box} width=${wRef + 2}><${Text}> ${r.ref}</></>
+				<${Box} width=${wPhase + 2}><${Text} color="yellow">${r.phase}</></>
+				<${Text} dimColor>${r.when}</>
+			</>`,
+		)}
+		<${Box} marginTop=${1}>
+			<${Text} dimColor>${"* HEAD — commands without <iid> resume here"}</>
+		</>
+	</>`;
+}
+
+function SessionDetail({ state, analysisSummary }) {
+	return h`<${Box} flexDirection="column">
+		<${Box}>
+			<${Text} color="yellow">Session  </>
+			<${Text}>${state.repo}#${state.iid}</>
+		</>
+		<${Box}>
+			<${Text} color="yellow">Phase    </>
+			<${Text}>${state.phase ?? "?"}</>
+		</>
+		${state.primary
+			? h`<${Box}>
+				<${Text} color="yellow">Primary  </>
+				<${Text}>${state.primary}</>
+			</>`
+			: null}
+		${state.secondaries?.length
+			? h`<${Box}>
+				<${Text} color="yellow">Secondary</>
+				<${Text}> ${state.secondaries.join(", ")}</>
+			</>`
+			: null}
+		${state.branch
+			? h`<${Box}>
+				<${Text} color="yellow">Branch   </>
+				<${Text}>${state.branch}</>
+			</>`
+			: null}
+		${state.mrIid
+			? h`<${Box}>
+				<${Text} color="yellow">MR       </>
+				<${Text}>!${state.mrIid}</>
+			</>`
+			: null}
+		${state.lastError
+			? h`<${Box}>
+				<${Text} color="red">Error    </>
+				<${Text}>${state.lastError}</>
+			</>`
+			: null}
+		<${Box} marginTop=${1}>
+			<${Text} dimColor>${`Created ${relTime(state.createdAt)} · Updated ${relTime(state.updatedAt)}`}</>
+		</>
+		${analysisSummary
+			? h`<${Box} flexDirection="column" marginTop=${1}>
+				<${Text} dimColor>${"Cached analysis:"}</>
+				<${Text}>${`  ${analysisSummary.changes} change(s) · ${analysisSummary.repos} repo(s) · ${analysisSummary.mrTitle ?? "(no proposed title)"}`}</>
+			</>`
+			: h`<${Box} marginTop=${1}>
+				<${Text} dimColor>${"No cached analysis on disk."}</>
+			</>`}
+	</>`;
+}
+
+async function listCommand(argv) {
+	const json = argv.includes("--json");
+	const sessions = await listSessions();
+	if (json) {
+		process.stdout.write(`${JSON.stringify(sessions, null, 2)}\n`);
+		return;
+	}
+	const head = await getHead();
+	await runApp(h`<${SessionsTable} sessions=${sessions} head=${head} />`);
+}
+
+async function showCommand(argv) {
+	const json = argv.includes("--json");
+	const explicitIid = Number(argv[2]);
+	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 state = await readState(target.repo, target.iid);
+	if (!state) {
+		console.error(`No session at ${sessionDir(target.repo, target.iid)}`);
+		process.exit(1);
+	}
+	const analysis = await readAnalysis(target.repo, target.iid);
+	if (json) {
+		process.stdout.write(`${JSON.stringify({ state, analysis }, null, 2)}\n`);
+		return;
+	}
+	const summary = analysis
+		? {
+			changes: analysis.changes?.length ?? 0,
+			repos: analysis.repos?.length ?? 0,
+			mrTitle: analysis.mrTitle ?? null,
+		}
+		: null;
+	await runApp(h`<${SessionDetail} state=${state} analysisSummary=${summary} />`);
+}
+
+async function cleanCommand(argv) {
+	if (argv.includes("--all")) {
+		await cleanAll();
+		process.stderr.write(`✓ Removed all sessions\n`);
+		return;
+	}
+	const explicitIid = Number(argv[2]);
+	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 use --all to wipe everything.",
+		);
+		process.exit(1);
+	}
+	const removed = await cleanSession(target.repo, target.iid);
+	if (removed) process.stderr.write(`✓ Removed ${target.repo}#${target.iid}\n`);
+	else process.stderr.write(`Nothing to remove at ${target.repo}#${target.iid}\n`);
+}
+
+export async function cmdSession(argv) {
+	const sub = argv[1] ?? "list";
+	if (sub === "list" || sub === "ls") return listCommand(argv);
+	if (sub === "show") return showCommand(argv);
+	if (sub === "clean" || sub === "rm") return cleanCommand(argv);
+	console.error(`Unknown subcommand: ${sub}`);
+	console.error("Subcommands: list, show, clean");
+	process.exit(1);
+}
+
+/**
+ * Top-level `forge-agent show [<iid>]` — re-renders the cached analysis from
+ * the session through the same Ink view as live analyze. Resolves <iid> via
+ * positional arg or HEAD pointer.
+ */
+export async function cmdShow(argv) {
+	const explicitIid = Number(argv[1]);
+	const explicitRepo = getFlag(argv, "--repo");
+	const json = argv.includes("--json");
+	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>, or run analyze first to seed HEAD.",
+		);
+		process.exit(1);
+	}
+	const analysis = await readAnalysis(target.repo, target.iid);
+	if (!analysis) {
+		console.error(
+			`No cached analysis at ${sessionDir(target.repo, target.iid)}.\n` +
+				`Run: forge-agent analyze ${target.iid}`,
+		);
+		process.exit(1);
+	}
+	if (json) {
+		process.stdout.write(`${JSON.stringify(analysis, null, 2)}\n`);
+		return;
+	}
+	// Reuse analyze.js's ResultBlock by importing it lazily — keeps the
+	// dependency cycle simple (session.js depends on the analyze view, but
+	// analyze.js doesn't depend on session.js's UI).
+	const { renderCachedResult } = await import("./analyze.js");
+	await renderCachedResult(analysis);
+}

package/bin/cli/sessionStore.js

@@ -0,0 +1,214 @@
+/**
+ * Session store for the ship workflow.
+ *
+ *   ~/.forge/sessions/<canonical-repo>/<iid>/
+ *     analysis.json   — last cached ForgeAgent.analyzeIssue result
+ *     state.json      — { phase, primary, secondaries, branch?, mrIid?, ... }
+ *     events.ndjson   — append-only log of every event we received
+ *
+ *   ~/.forge/sessions/HEAD
+ *     — single line: "<canonical-repo>/<iid>" of the most recently touched
+ *       session. Used so subsequent commands without an explicit <iid> can
+ *       resume the current unit of work, in the spirit of git's HEAD.
+ *
+ * Override the root with FORGE_SESSIONS_PATH (test isolation).
+ */
+
+import { existsSync } from "node:fs";
+import fs from "node:fs/promises";
+import os from "node:os";
+import path from "node:path";
+import { canonicalRepoId } from "./utils.js";
+
+export const PHASES = Object.freeze({
+	ANALYZED: "analyzed",
+	REFINED: "refined",
+	VALIDATED: "validated",
+	APPLIED: "applied",
+	WATCHING: "watching",
+	MERGED: "merged",
+	RESOLVED: "resolved",
+	CLOSED: "closed",
+});
+
+function rootDir() {
+	return (
+		process.env.FORGE_SESSIONS_PATH ??
+		path.join(os.homedir(), ".forge", "sessions")
+	);
+}
+
+/**
+ * Resolve the on-disk directory for a session. Repo is canonicalised so
+ * "iplayulisten/web-app" and "gitlab:iplayulisten/web-app" map to the
+ * same folder.
+ */
+export function sessionDir(repo, iid) {
+	return path.join(rootDir(), canonicalRepoId(String(repo)), String(iid));
+}
+
+async function ensureDir(dir) {
+	await fs.mkdir(dir, { recursive: true });
+}
+
+export async function writeAnalysis(repo, iid, analysis) {
+	const dir = sessionDir(repo, iid);
+	await ensureDir(dir);
+	await fs.writeFile(
+		path.join(dir, "analysis.json"),
+		JSON.stringify(analysis, null, 2),
+		"utf8",
+	);
+}
+
+export async function readAnalysis(repo, iid) {
+	const file = path.join(sessionDir(repo, iid), "analysis.json");
+	if (!existsSync(file)) return null;
+	return JSON.parse(await fs.readFile(file, "utf8"));
+}
+
+export async function readState(repo, iid) {
+	const file = path.join(sessionDir(repo, iid), "state.json");
+	if (!existsSync(file)) return null;
+	return JSON.parse(await fs.readFile(file, "utf8"));
+}
+
+export async function updateState(repo, iid, partial) {
+	const dir = sessionDir(repo, iid);
+	await ensureDir(dir);
+	const file = path.join(dir, "state.json");
+	const now = new Date().toISOString();
+	const prev = (await readState(repo, iid)) ?? {
+		repo: canonicalRepoId(String(repo)),
+		iid: Number(iid),
+		createdAt: now,
+	};
+	const next = { ...prev, ...partial, updatedAt: now };
+	await fs.writeFile(file, JSON.stringify(next, null, 2), "utf8");
+	return next;
+}
+
+export async function appendEvent(repo, iid, evt) {
+	const dir = sessionDir(repo, iid);
+	await ensureDir(dir);
+	await fs.appendFile(
+		path.join(dir, "events.ndjson"),
+		`${JSON.stringify({ ts: new Date().toISOString(), ...evt })}\n`,
+		"utf8",
+	);
+}
+
+export async function setHead(repo, iid) {
+	const root = rootDir();
+	await fs.mkdir(root, { recursive: true });
+	await fs.writeFile(
+		path.join(root, "HEAD"),
+		`${canonicalRepoId(String(repo))}/${iid}\n`,
+		"utf8",
+	);
+}
+
+/**
+ * Return { repo, iid } of the HEAD session, or null.
+ */
+export async function getHead() {
+	const file = path.join(rootDir(), "HEAD");
+	if (!existsSync(file)) return null;
+	const raw = (await fs.readFile(file, "utf8")).trim();
+	const lastSlash = raw.lastIndexOf("/");
+	if (lastSlash <= 0) return null;
+	const repo = raw.slice(0, lastSlash);
+	const iid = Number(raw.slice(lastSlash + 1));
+	if (!Number.isInteger(iid) || iid <= 0) return null;
+	return { repo, iid };
+}
+
+/**
+ * Walk the on-disk tree and return every session it finds. Sorted by
+ * updatedAt descending (most recent first).
+ */
+export async function listSessions() {
+	const root = rootDir();
+	if (!existsSync(root)) return [];
+
+	const out = [];
+	const repoDirs = await safeReadDir(root);
+	for (const repoEntry of repoDirs) {
+		if (!repoEntry.isDirectory()) continue;
+		// Repos may be nested one level (e.g. "iplayulisten/web-app").
+		const repoLevel1 = path.join(root, repoEntry.name);
+		const repoSubdirs = await safeReadDir(repoLevel1);
+		for (const sub of repoSubdirs) {
+			if (!sub.isDirectory()) continue;
+			const candidatePath = path.join(repoLevel1, sub.name);
+
+			// Two layouts:
+			//  a) repoLevel1/<iid>/state.json     (single-segment repo)
+			//  b) repoLevel1/<sub>/<iid>/state.json (two-segment repo)
+			if (existsSync(path.join(candidatePath, "state.json"))) {
+				const state = JSON.parse(
+					await fs.readFile(path.join(candidatePath, "state.json"), "utf8"),
+				);
+				out.push(state);
+				continue;
+			}
+			const iidEntries = await safeReadDir(candidatePath);
+			for (const iidEntry of iidEntries) {
+				if (!iidEntry.isDirectory()) continue;
+				const stateFile = path.join(candidatePath, iidEntry.name, "state.json");
+				if (!existsSync(stateFile)) continue;
+				const state = JSON.parse(await fs.readFile(stateFile, "utf8"));
+				out.push(state);
+			}
+		}
+	}
+
+	out.sort((a, b) => (b.updatedAt ?? "").localeCompare(a.updatedAt ?? ""));
+	return out;
+}
+
+async function safeReadDir(dir) {
+	try {
+		return await fs.readdir(dir, { withFileTypes: true });
+	} catch {
+		return [];
+	}
+}
+
+export async function cleanSession(repo, iid) {
+	const dir = sessionDir(repo, iid);
+	if (!existsSync(dir)) return false;
+	await fs.rm(dir, { recursive: true, force: true });
+	const head = await getHead();
+	if (head && canonicalRepoId(head.repo) === canonicalRepoId(String(repo)) && head.iid === Number(iid)) {
+		await fs.rm(path.join(rootDir(), "HEAD"), { force: true });
+	}
+	return true;
+}
+
+export async function cleanAll() {
+	const root = rootDir();
+	if (!existsSync(root)) return;
+	await fs.rm(root, { recursive: true, force: true });
+}
+
+/**
+ * Resolve a session target from CLI argv. Honours an explicit positional iid
+ * or HEAD as fallback. Returns { repo, iid } or null.
+ *
+ *   forge-agent show              → HEAD
+ *   forge-agent show 42           → primary repo + iid 42
+ *   forge-agent show 42 --repo X  → repo X + iid 42
+ */
+export async function resolveSessionTarget({ explicitIid, explicitRepo }) {
+	if (Number.isInteger(explicitIid) && explicitIid > 0) {
+		// repo defaults to HEAD's repo if available, else explicitRepo, else
+		// the configStore primary. Keeps `show 42` working when there's a
+		// prior HEAD that was on the same repo.
+		if (explicitRepo) return { repo: explicitRepo, iid: explicitIid };
+		const head = await getHead();
+		if (head) return { repo: head.repo, iid: explicitIid };
+		return { repo: null, iid: explicitIid };
+	}
+	return await getHead();
+}