@ipul-labs/forge 1.16.7 → 1.17.0

package/README.md

@@ -252,11 +252,30 @@ FORGE_REPOS=gitlab:ipul/web-app,github:my-org/mobile
 
 ---
 
+## Security
+
+Forge is designed for self-hosted deployment on trusted infrastructure. Security measures in place:
+
+- **Timing-safe auth** — token comparison uses `crypto.timingSafeEqual` to prevent timing attacks
+- **Rate limiting** — API endpoints are rate-limited (60 req/min per IP) to prevent brute-force
+- **Security headers** — Helmet middleware sets X-Frame-Options, HSTS, X-Content-Type-Options, and CSP (production)
+- **Request size limits** — JSON body capped at 1MB to prevent memory exhaustion
+- **Secret redaction** — error logs and API responses scrub tokens (`glpat-*`, `ghp_*`, `oauth2:*@`) before output
+- **File permissions** — config files (`~/.forge/config.json`) written with `0600`, session directories with `0700`
+- **Git credential isolation** — SCM tokens passed via `GIT_ASKPASS` helper, never embedded in clone URLs
+- **Path traversal protection** — symlink-aware `realpath` checks prevent file writes outside clone directories
+- **No shell injection** — all subprocess calls use `spawn()` with argument arrays, never shell strings
+- **Atomic config writes** — config updates use temp file + rename to prevent corruption
+
+`FORGE_TOKEN` is a standalone dashboard password — never reuse an SCM token for this value.
+
+---
+
 ## Production deployment
 
 ```bash
 npm run build:app      # builds Vite SPA to dist/
-NODE_ENV=production node server.js
+NODE_ENV=production tsx server.ts
 ```
 
 Or with Docker:
@@ -270,31 +289,38 @@ docker run -p 5001:5001 --env-file .env forge
 
 ## Architecture
 
+Full-stack TypeScript. The backend runs via `tsx` (no build step); the frontend compiles through Vite.
+
 ```
 bin/
-  forge-agent.js        # CLI entry point (forge command)
+  forge-agent.ts        # CLI entry point (forge command)
   cli/
-    ship.js             # End-to-end orchestrator (Ink UI)
-    analyze.js          # Two-pass issue analysis
-    resolution.js       # Post-merge resolution check
-    sessionStore.js     # ~/.forge/sessions/ persistence
+    ship.ts             # End-to-end orchestrator (Ink UI)
+    analyze.ts          # Two-pass issue analysis
+    repl.ts             # Interactive terminal (Ink-based)
+    serverClient.ts     # CLI → Server API client (server/local mode)
+    sessionStore.ts     # ~/.forge/sessions/ persistence
     ...
 
+shared/
+  events.ts             # FORGE_EVENTS constants (server + client)
+
 server/
   forge/
-    routes.js           # Express router — all /api/forge/* endpoints
+    routes.ts           # Express router — all /api/forge/* endpoints
     core/
-      ForgeAgent.js     # Orchestrates the full pipeline (analyze -> apply -> refine)
-      claudeClient.js   # Shells out to the claude CLI for structured output
-      openclawClient.js # OpenClaw Gateway HTTP client
-      agentClient.js    # Dispatcher: routes to claudeClient or openclawClient
-      k8s.js            # Kubernetes client for rollout monitoring
+      ForgeAgent.ts     # Orchestrates the full pipeline (analyze -> apply -> refine)
+      claudeClient.ts   # Shells out to the claude CLI for structured output
+      openclawClient.ts # OpenClaw Gateway HTTP client
+      agentClient.ts    # Dispatcher: routes to claudeClient or openclawClient
+      k8s.ts            # Kubernetes client for rollout monitoring
+      jobs.ts           # Job store with SSE event buffering + replay
       providers/
-        base.js         # Abstract ScmProvider — normalized shapes + interface
-        gitlab.js       # GitLab REST API v4
-        github.js       # GitHub REST API v3 + Git Data API
-        azuredevops.js  # Azure DevOps REST API
-        index.js        # createProvider() factory
+        base.ts         # Abstract ScmProvider — normalized shapes + interface
+        gitlab.ts       # GitLab REST API v4
+        github.ts       # GitHub REST API v3 + Git Data API
+        azuredevops.ts  # Azure DevOps REST API
+        index.ts        # createProvider() factory
 
 src/
   views/Forge/
@@ -305,6 +331,7 @@ src/
     components/             # Analysis progress, pipeline status, diff viewer
     hooks/
       useForgeDashboard.ts  # All state, phase transitions, and API calls
+      useForgeEvents.ts     # SSE event bus subscription
 ```
 
 ### Two-pass analysis
@@ -321,7 +348,7 @@ When a pipeline fails, Forge fetches the last 150 lines of each failed job's tra
 
 ### Provider abstraction
 
-All three SCM providers implement `ScmProvider` from `providers/base.js`. The contract is:
+All three SCM providers implement `ScmProvider` from `providers/base.ts`. The contract is:
 - **Normalized return types** — all methods return `NormalIssue`, `NormalMR`, `NormalPipeline`, etc., regardless of provider
 - **Instance-scoped** — each provider is instantiated with a repo string; no global state
 - **`supportsRebase`** — providers that don't support server-side rebase return `false`; the UI and API layer check this before showing the rebase button
@@ -330,20 +357,30 @@ All three SCM providers implement `ScmProvider` from `providers/base.js`. The co
 
 ## Programmatic usage
 
-Mount the Forge Express router or use the core classes directly:
+The npm package ships compiled JavaScript with TypeScript declarations — no `tsx` or TypeScript runtime needed by consumers.
 
-```js
+```ts
 import forgeRouter from "@ipul-labs/forge";             // Express router
 import { ForgeAgent } from "@ipul-labs/forge/agent";    // Core pipeline class
 import { createProvider } from "@ipul-labs/forge/providers"; // SCM factory
 ```
 
-```js
+```ts
 const agent = new ForgeAgent({ project: "group/repo" });
 const result = await agent.analyzeIssue(42, (event) => console.log(event));
 const { branchName, mr } = await agent.applyFix(result);
 ```
 
+### Development
+
+Source is TypeScript (`.ts`). The dev server runs via `tsx` (no build step). For the npm package, `tsc` compiles to `lib/` with declarations during `prepack`.
+
+```bash
+npm run dev              # tsx watch + vite (dev)
+npm run build:server     # compile server/bin/shared → lib/
+npm run typecheck        # check both frontend + server configs
+```
+
 ---
 
 ## License

package/lib/bin/cli/analyze.d.ts

@@ -0,0 +1,9 @@
+import type { AnalysisResult } from "../../server/forge/core/types.ts";
+/**
+ * Render a cached analysis (read from session) through the same ResultBlock
+ * the live analyze view uses. No streaming, no progress — just the final
+ * payload. Used by `forge show`.
+ */
+export declare function renderCachedResult(result: AnalysisResult): Promise<void>;
+export declare function cmdAnalyze(argv: string[]): Promise<void>;
+//# sourceMappingURL=analyze.d.ts.map

package/lib/bin/cli/analyze.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"analyze.d.ts","sourceRoot":"","sources":["../../../bin/cli/analyze.ts"],"names":[],"mappings":"AA2BA,OAAO,KAAK,EAAE,cAAc,EAA2B,MAAM,kCAAkC,CAAC;AAsQhG;;;;GAIG;AACH,wBAAsB,kBAAkB,CAAC,MAAM,EAAE,cAAc,iBAM9D;AAiJD,wBAAsB,UAAU,CAAC,IAAI,EAAE,MAAM,EAAE,iBAsH9C"}

package/lib/bin/cli/analyze.js

@@ -0,0 +1,491 @@
+var __rewriteRelativeImportExtension = (this && this.__rewriteRelativeImportExtension) || function (path, preserveJsx) {
+    if (typeof path === "string" && /^\.\.?\//.test(path)) {
+        return path.replace(/\.(tsx)$|((?:\.d)?)((?:\.[^./]+?)?)\.([cm]?)ts$/i, function (m, tsx, d, ext, cm) {
+            return tsx ? preserveJsx ? ".jsx" : ".js" : d && (!ext || !cm) ? m : (d + ext + "." + cm.toLowerCase() + "js");
+        });
+    }
+    return path;
+};
+import fs from "node:fs/promises";
+import path from "node:path";
+import { useEffect, useState } from "react";
+import Spinner from "ink-spinner";
+import { createPatch } from "diff";
+import { h, Box, Text, useApp, runApp } from "./ink.js";
+import { isServerAvailable, streamJob, SERVER_MODE, LOCAL_MODE, } from "./serverClient.js";
+import { projectRoot, getFlag, notifyServer, resolveRepoSet, prefixDivergence, } from "./utils.js";
+import { PHASES, appendEvent, setHead, updateState, writeAnalysis, } from "./sessionStore.js";
+const DIFF_MAX_LINES = 60;
+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} marginLeft=${2}>
+		${glyph}
+		<${Text} dimColor> [${step}]</>
+		<${Text}> ${message}</>
+	</>`;
+}
+function ItemRow({ item }) {
+    if (item.kind === "step")
+        return h `<${StepRow} ...${item} />`;
+    if (item.kind === "log")
+        return h `<${Box} marginLeft=${4}><${Text} dimColor>${item.text}</></>`;
+    if (item.kind === "usage") {
+        const cost = typeof item.cost === "number" ? `$${item.cost.toFixed(4)}` : "$?";
+        return h `<${Box} marginLeft=${4}>
+			<${Text} dimColor>${item.inputTokens}in / ${item.outputTokens}out tokens, ${cost}</>
+		</>`;
+    }
+    if (item.kind === "error")
+        return h `<${Box} marginLeft=${2}><${Text} color="red">ERROR</><${Text}>: ${item.message}</></>`;
+    return null;
+}
+function colorForDiffLine(line) {
+    if (line.startsWith("+++") || line.startsWith("---"))
+        return "white";
+    if (line.startsWith("@@"))
+        return "cyan";
+    if (line.startsWith("+"))
+        return "green";
+    if (line.startsWith("-"))
+        return "red";
+    return undefined;
+}
+function DiffBlock({ original, proposed, file }) {
+    const patch = createPatch(file, original ?? "", proposed ?? "", "current", "proposed");
+    const lines = patch.split("\n").slice(2);
+    const truncated = lines.length > DIFF_MAX_LINES;
+    const shown = truncated ? lines.slice(0, DIFF_MAX_LINES) : lines;
+    return h `<${Box} flexDirection="column" marginLeft=${4}>
+		${shown.map((line, i) => {
+        const color = colorForDiffLine(line);
+        return h `<${Text} key=${i} color=${color} dimColor=${color === undefined}>${line || " "}</>`;
+    })}
+		${truncated
+        ? h `<${Text} dimColor>${`    … ${lines.length - DIFF_MAX_LINES} more diff lines (use --json to see full payload)`}</>`
+        : null}
+	</>`;
+}
+function ChangeBlock({ change, index }) {
+    const isCreate = change.action === "create";
+    const isDelete = change.action === "delete";
+    const showDiff = !isDelete; // create: diff vs empty; delete: skip
+    const header = `${index + 1}. ${change.action.toUpperCase()}  ${change.repo}:${change.file}`;
+    return h `<${Box} flexDirection="column" marginTop=${1} marginLeft=${2}>
+		<${Text} color="yellow">${header}</>
+		${change.summary
+        ? h `<${Box} marginLeft=${3}><${Text} dimColor>${change.summary}</></>`
+        : null}
+		${showDiff
+        ? h `<${DiffBlock} file=${change.file} original=${isCreate ? "" : change.original ?? ""} proposed=${change.proposed ?? ""} />`
+        : null}
+	</>`;
+}
+function DivergenceWarning({ divergence }) {
+    if (!divergence)
+        return null;
+    const text = `⚠  Issue prefix "${divergence.issue}:" but proposed MR prefix "${divergence.mr}:" — model may have misinterpreted the issue.`;
+    return h `<${Box} marginTop=${1}>
+		<${Text} color="yellow">${text}</>
+	</>`;
+}
+function ResultBlock({ result }) {
+    const changes = result.changes ?? [];
+    const issueTitle = result.issue?.title ?? "";
+    const divergence = prefixDivergence(issueTitle, result.mrTitle);
+    return h `<${Box} flexDirection="column" marginTop=${1} marginLeft=${2}>
+		<${Text} dimColor>${"─── result ───"}</>
+		<${Box} marginTop=${1}>
+			<${Text} color="yellow">Issue  </>
+			<${Text}>#${result.issue?.iid}: ${issueTitle}</>
+		</>
+		${result.mrTitle
+        ? h `<${Box}>
+				<${Text} color="yellow">MR     </>
+				<${Text}>${result.mrTitle}</>
+			</>`
+        : null}
+		${result.repos?.length
+        ? h `<${Box}>
+				<${Text} color="yellow">Repos  </>
+				<${Text}>${result.repos.join(", ")}</>
+			</>`
+        : null}
+		<${DivergenceWarning} divergence=${divergence} />
+		${result.explanation
+        ? h `<${Box} flexDirection="column" marginTop=${1}>
+				<${Text} dimColor>Explanation</>
+				<${Box} marginLeft=${2}><${Text}>${result.explanation}</></>
+			</>`
+        : null}
+		<${Box} marginTop=${1}>
+			<${Text} dimColor>${`Changes (${changes.length}):`}</>
+		</>
+		${changes.length === 0
+        ? h `<${Box} marginLeft=${2}><${Text} dimColor>(none — model proposed no changes)</></>`
+        : changes.map((c, i) => h `<${ChangeBlock} key=${i} change=${c} index=${i} />`)}
+	</>`;
+}
+function AnalyzeView({ iid, primary, secondaries, model, agentKind, userPrompt, eventSink, onDone, }) {
+    const { exit } = useApp();
+    const [items, setItems] = useState([]);
+    const [mode, setMode] = useState(null);
+    const [result, setResult] = useState(null);
+    const [finished, setFinished] = useState(null);
+    useEffect(() => {
+        if (!finished)
+            return;
+        onDone(finished);
+        exit();
+    }, [finished]);
+    const handleEvent = (evt, cancelled) => {
+        if (cancelled?.current)
+            return;
+        eventSink?.(evt);
+        if (evt.type === "result")
+            return evt.data;
+        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 "usage":
+                    return [
+                        ...prev,
+                        { kind: "usage", inputTokens: evt.inputTokens, outputTokens: evt.outputTokens, cost: evt.cost },
+                    ];
+                case "error":
+                    return [
+                        ...prev.map((it) => it.kind === "step" && it.status === "running" ? { ...it, status: "failed" } : it),
+                        { kind: "error", message: evt.message },
+                    ];
+                default:
+                    return prev;
+            }
+        });
+        return null;
+    };
+    const finalize = (final) => {
+        setItems((prev) => prev.map((it) => it.kind === "step" && it.status === "running" ? { ...it, status: "done" } : it));
+        if (final)
+            setResult(final);
+        setFinished({ ok: true, result: final });
+    };
+    useEffect(() => {
+        const cancelRef = { current: false };
+        (async () => {
+            try {
+                const serverUp = await isServerAvailable();
+                setMode(serverUp ? SERVER_MODE : LOCAL_MODE);
+                let final = null;
+                if (serverUp) {
+                    const { events } = streamJob(`/issues/${iid}/analyze`, {
+                        repo: primary,
+                        secondaryRepos: secondaries,
+                        agent: agentKind,
+                        model,
+                        prompt: userPrompt,
+                        kind: "fresh",
+                    });
+                    for await (const evt of events) {
+                        if (cancelRef.current)
+                            return;
+                        const data = handleEvent(evt, cancelRef);
+                        if (data)
+                            final = data;
+                    }
+                }
+                else {
+                    const { ForgeAgent } = await import(__rewriteRelativeImportExtension(path.join(projectRoot, "server/forge/core/ForgeAgent.ts")));
+                    const agent = new ForgeAgent({
+                        project: primary,
+                        secondaryProjects: secondaries,
+                        agent: agentKind,
+                    });
+                    const { FORGE_EVENTS: FE } = await import("../../shared/events.js");
+                    await notifyServer({ type: FE.ANALYSIS_STARTED, iid });
+                    await agent.analyzeIssue(iid, (evt) => {
+                        const data = handleEvent(evt, cancelRef);
+                        if (data)
+                            final = data;
+                    }, model, undefined, userPrompt, "fresh");
+                }
+                if (cancelRef.current)
+                    return;
+                finalize(final);
+            }
+            catch (err) {
+                if (cancelRef.current)
+                    return;
+                const errObj = err instanceof Error ? err : new Error(String(err));
+                setItems((prev) => [
+                    ...prev.map((it) => it.kind === "step" && it.status === "running" ? { ...it, status: "failed" } : it),
+                    { kind: "error", message: errObj.message },
+                ]);
+                setFinished({ ok: false, error: errObj });
+            }
+        })();
+        return () => { cancelRef.current = true; };
+    }, []);
+    return h `<${Box} flexDirection="column">
+		${mode ? h `<${Box} marginLeft=${2} marginBottom=${1}><${Text}>${mode}</></>` : null}
+		${items.map((it, i) => h `<${ItemRow} key=${i} item=${it} />`)}
+		${result ? h `<${ResultBlock} result=${result} />` : null}
+	</>`;
+}
+/**
+ * Render a cached analysis (read from session) through the same ResultBlock
+ * the live analyze view uses. No streaming, no progress — just the final
+ * payload. Used by `forge show`.
+ */
+export async function renderCachedResult(result) {
+    await runApp(h `<${Box} flexDirection="column">
+			<${ResultBlock} result=${result} />
+		</>`);
+}
+async function persistAnalyzeOutcome({ repo, iid, primary, secondaries, result, events, error }) {
+    if (!repo || !iid)
+        return;
+    try {
+        if (result)
+            await writeAnalysis(repo, iid, result);
+        await updateState(repo, iid, {
+            repo,
+            iid: Number(iid),
+            primary,
+            secondaries,
+            phase: result ? PHASES.ANALYZED : "analyze-failed",
+            lastError: error?.message ?? null,
+        });
+        await appendEvent(repo, iid, { type: "session:analyze-start" });
+        for (const evt of events)
+            await appendEvent(repo, iid, evt);
+        await appendEvent(repo, iid, {
+            type: "session:analyze-end",
+            ok: !error,
+            error: error?.message,
+        });
+        await setHead(repo, iid);
+        if (result) {
+            const { FORGE_EVENTS } = await import("../../shared/events.js");
+            await notifyServer({ type: FORGE_EVENTS.ANALYSIS_DONE, iid: Number(iid) });
+        }
+    }
+    catch (err) {
+        process.stderr.write(`forge: failed to persist session: ${err instanceof Error ? err.message : String(err)}\n`);
+    }
+}
+/**
+ * Render a saved NDJSON event stream through the same Ink view, without
+ * re-running the agent. Useful for verifying renderer changes against a
+ * known-good payload, and for users who want to re-inspect a prior result.
+ */
+async function cmdAnalyzeReplay(replayPath) {
+    const raw = await fs.readFile(replayPath, "utf8");
+    const events = raw
+        .split("\n")
+        .filter(Boolean)
+        .map((line) => {
+        try {
+            return JSON.parse(line);
+        }
+        catch {
+            return null;
+        }
+    })
+        .filter(Boolean);
+    let outcome = { ok: true };
+    await runApp(h `<${ReplayView} events=${events} onDone=${(o) => (outcome = o)} />`);
+    if (!outcome.ok)
+        process.exit(2);
+}
+function ReplayView({ events, 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 final = null;
+        const next = [];
+        const closeRunning = (list) => list.map((it) => it.kind === "step" && it.status === "running" ? { ...it, status: "done" } : it);
+        for (const evt of events) {
+            if (evt.type === "result") {
+                final = evt.data ?? null;
+                continue;
+            }
+            switch (evt.type) {
+                case "progress": {
+                    const closed = closeRunning(next);
+                    next.length = 0;
+                    next.push(...closed, {
+                        kind: "step",
+                        step: evt.step,
+                        message: evt.message,
+                        status: "running",
+                    });
+                    break;
+                }
+                case "log":
+                    next.push({ kind: "log", text: evt.message });
+                    break;
+                case "usage":
+                    next.push({
+                        kind: "usage",
+                        inputTokens: evt.inputTokens,
+                        outputTokens: evt.outputTokens,
+                        cost: evt.cost,
+                    });
+                    break;
+                case "error": {
+                    const closed = next.map((it) => it.kind === "step" && it.status === "running"
+                        ? { ...it, status: "failed" }
+                        : it);
+                    next.length = 0;
+                    next.push(...closed, { kind: "error", message: evt.message });
+                    break;
+                }
+                default:
+            }
+        }
+        setItems(closeRunning(next));
+        if (final)
+            setResult(final);
+        setFinished({ ok: true });
+    }, []);
+    return h `<${Box} flexDirection="column">
+		${items.map((it, i) => h `<${ItemRow} key=${i} item=${it} />`)}
+		${result ? h `<${ResultBlock} result=${result} />` : null}
+	</>`;
+}
+export async function cmdAnalyze(argv) {
+    const replayPath = getFlag(argv, "--replay");
+    if (replayPath)
+        return cmdAnalyzeReplay(replayPath);
+    const iid = Number(argv[1]);
+    if (!Number.isInteger(iid) || iid <= 0) {
+        console.error("Usage: forge analyze <iid> [options]");
+        process.exit(1);
+    }
+    const { primary, secondaries } = await resolveRepoSet(argv);
+    if (!primary) {
+        console.error("No repo. Pass --repo <group/repo>, set FORGE_GITLAB_PROJECT, or run `forge init`.");
+        process.exit(1);
+    }
+    const model = getFlag(argv, "--model") || undefined;
+    const agentKind = getFlag(argv, "--agent") || "claude";
+    const userPrompt = getFlag(argv, "--prompt") || undefined;
+    const json = argv.includes("--json");
+    const quiet = argv.includes("--quiet");
+    const { ForgeAgent } = await import(__rewriteRelativeImportExtension(path.join(projectRoot, "server/forge/core/ForgeAgent.ts")));
+    if (json || quiet) {
+        const agent = new ForgeAgent({
+            project: primary,
+            secondaryProjects: secondaries,
+            agent: agentKind,
+        });
+        let finalResult = null;
+        const events = [];
+        const onEvent = (evt) => {
+            if (evt.type === "result")
+                finalResult = evt.data;
+            events.push(evt);
+            if (json)
+                process.stdout.write(`${JSON.stringify(evt)}\n`);
+        };
+        try {
+            const { FORGE_EVENTS: FE } = await import("../../shared/events.js");
+            await notifyServer({ type: FE.ANALYSIS_STARTED, iid });
+            await agent.analyzeIssue(iid, onEvent, model, undefined, userPrompt, "fresh");
+        }
+        catch (err) {
+            const errObj = err instanceof Error ? err : new Error(String(err));
+            if (json) {
+                process.stdout.write(`${JSON.stringify({ type: "error", message: errObj.message })}\n`);
+            }
+            else {
+                process.stderr.write(`ERROR: ${errObj.message}\n`);
+            }
+            await persistAnalyzeOutcome({
+                repo: primary,
+                iid,
+                primary,
+                secondaries,
+                result: null,
+                events,
+                error: errObj,
+            });
+            process.exit(2);
+        }
+        if (!finalResult) {
+            if (!json)
+                console.error("Analysis produced no result.");
+            await persistAnalyzeOutcome({
+                repo: primary,
+                iid,
+                primary,
+                secondaries,
+                result: null,
+                events,
+                error: new Error("no result"),
+            });
+            process.exit(2);
+        }
+        await persistAnalyzeOutcome({
+            repo: primary,
+            iid,
+            primary,
+            secondaries,
+            result: finalResult,
+            events,
+            error: null,
+        });
+        if (quiet && !json)
+            console.log(JSON.stringify(finalResult, null, 2));
+        return;
+    }
+    let outcome = { ok: true };
+    const events = [];
+    await runApp(h `<${AnalyzeView}
+			iid=${iid}
+			primary=${primary}
+			secondaries=${secondaries}
+			model=${model}
+			agentKind=${agentKind}
+			userPrompt=${userPrompt}
+			eventSink=${(e) => events.push(e)}
+			onDone=${(o) => (outcome = o)} />`);
+    await persistAnalyzeOutcome({
+        repo: primary,
+        iid,
+        primary,
+        secondaries,
+        result: outcome.result ?? null,
+        events,
+        error: outcome.error ?? null,
+    });
+    if (!outcome.ok)
+        process.exit(2);
+    if (!outcome.result) {
+        console.error("Analysis produced no result.");
+        process.exit(2);
+    }
+}
+//# sourceMappingURL=analyze.js.map