@ipul-labs/forge 1.16.8 → 1.17.1

package/bin/cli/session.js

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

@@ -1,211 +0,0 @@
-/**
- * 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, mode: 0o700 });
-}
-
-export async function writeAnalysis(repo, iid, analysis) {
-	const dir = sessionDir(repo, iid);
-	await ensureDir(dir);
-	const file = path.join(dir, "analysis.json");
-	await fs.writeFile(file, JSON.stringify(analysis, null, 2), { encoding: "utf8", mode: 0o600 });
-}
-
-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), { encoding: "utf8", mode: 0o600 });
-	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 show              → HEAD
- *   forge show 42           → primary repo + iid 42
- *   forge 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();
-}