@happy-nut/monacori 0.1.0 → 0.1.3

package/README.md

@@ -1,177 +1,89 @@
 # monacori
 
-Validation control plane for AI-generated code changes.
+**Validation control plane for AI-generated code changes.** After an AI edits your repository, `monacori` produces verification evidence a human can actually trust.
 
-`monacori` is not an agent orchestrator. It does not manage panes, sessions, worktrees, or model adapters. Its job is narrower: after an AI edits a repository, produce verification evidence that a human can trust.
-
-It gives you:
-
-- detected verification commands in `.monacori/config.json`
-- repeatable verification logs under `.monacori/logs/`
-- a local desktop review app for live diff inspection
-- diff2html review pages under `.monacori/diffs/`
-- searchable source previews, including unchanged indexed files
-- compact validation reports under `.monacori/reports/`
+It is *not* an agent orchestrator. It does not manage panes, sessions, worktrees, or model adapters. Its job is narrow on purpose: validate what the AI just did.
 
 ## Why
 
-AI coding output is hard to trust when review depends on chat memory or vague "done" claims. `monacori` keeps the review artifacts in the repository so the state can be inspected, rerun, and discussed.
+AI coding output is hard to trust when review depends on chat memory or a vague "done" claim. `monacori` keeps the review artifacts inside the repository, so the state of a change can be inspected, rerun, and discussed instead of taken on faith.
 
-The intended loop is simple:
+The loop is simple:
 
 ```text
 AI edits code.
 monacori runs verification.
 monacori creates a reviewable diff artifact.
-You inspect evidence before accepting the change.
+You inspect the evidence before accepting the change.
 ```
 
+![Diff review](assets/screenshots/diff-review.png)
+*Local desktop review app: side-by-side diff with changed lines highlighted and IntelliJ-style git status colors in the sidebar.*
+
 ## Install
 
 ```bash
 npm install -g @happy-nut/monacori
 ```
 
-After installation, the short command is:
-
-```bash
-dg
-```
-
-Homebrew tap distribution is prepared through `Formula/monacori.rb`. Once the scoped npm package is published and the formula is copied to the `happy-nut/homebrew-monacori` tap, the intended install path is:
+After install, the short command is `mo`. A Homebrew tap (`happy-nut/monacori/monacori`) is also available.
 
-```bash
-brew install happy-nut/monacori/monacori
-```
+## What you get
 
-For local development:
+- **Local desktop review app** — diff review with changed-line highlighting and an IntelliJ-style sidebar that colors files by git status. Reads the repo directly, refreshes on change, no HTTP server.
+- **Integrated terminal** — run AI CLIs like `claude` or `codex` inside the app, and send a "merged prompt" (your question or fix request bundled with the relevant code context) straight to the session.
+- **Inline comments** — annotate the diff while you review.
+- **Verification logs & reports** — repeatable verification under `.monacori/logs/` and compact validation reports under `.monacori/reports/`.
 
-```bash
-git clone https://github.com/happy-nut/monacori.git
-cd monacori
-npm install
-npm run build
-npm link
-```
+![Integrated terminal](assets/screenshots/terminal.png)
+*Run your AI CLI inside the review app, next to the diff it just produced.*
 
-## Quick Start
+## Quick start
 
 Inside the repository you want to validate:
 
 ```bash
-dg
-monacori check --include-untracked
-```
-
-`dg` opens the local desktop review app for the current directory. On first run it creates `.monacori/`, updates Git ignore rules for `.monacori/`, and includes untracked files so new AI-created files show up immediately.
-
-`check` runs configured verification commands, writes a log, creates a browser diff review, and records a compact report.
-
-For a one-off command:
-
-```bash
-monacori check -- npm test
-```
-
-For live diff review while an AI is still editing:
-
-```bash
-dg
+mo                              # open the desktop review app for the current dir
+monacori check --include-untracked   # run verification, write a log, diff, and report
 ```
 
-## Diff Review
-
-The desktop review app is powered by Electron and diff2html. It reads Git diff and source files directly from the local repository, writes a local `.monacori/app-review.html` file, and refreshes when the working tree changes. It does not start an HTTP server.
-
-- `F7`: show the next changed hunk, starting from the current source file when possible
-- `Shift+F7`: previous changed hunk
-- `]` / `[`: fallback keys if the browser captures function keys
-- `Shift Shift`: search indexed files, including unchanged files
-- `Cmd/Ctrl+E`: open recent files
-- `Cmd/Ctrl+Down`: jump from the source cursor to a declaration-like match for the symbol under it
-
-The app opens as a read-only source viewer by default. The `Files` tab opens indexed files even when they are unchanged, and `F7` switches into the diff view when you want to inspect changes. Drag-copying source text adds `path:line-range` plus a fenced code block to the clipboard so the snippet can be pasted into an AI prompt with context. Viewed marks are stored with file signatures, so a file becomes unviewed again when it changes.
-
-The browser artifact path is still available through `monacori diff`. Add `--watch` there only when you specifically want a browser-served live review.
+On first run, `mo` creates `.monacori/`, adds it to `.gitignore`, and includes untracked files so new AI-created files show up immediately.
 
 ## Commands
 
-```bash
-monacori open [--base HEAD] [--staged] [--tracked-only] [--context 12] [--no-watch]
-```
-
-Opens the local desktop review app for the current directory. `dg` and bare `monacori` are aliases for this default flow. It auto-initializes local state when needed and includes untracked files by default; pass `--tracked-only` to inspect tracked changes only.
+| Command | What it does |
+| --- | --- |
+| `mo` | Open the desktop review app (alias for `monacori open`). |
+| `monacori check` | Run verification, then create a diff and a validation report. `-- <cmd>` overrides commands for one run. |
+| `monacori verify` | Run configured verification commands and store the log. Exits non-zero on failure. |
+| `monacori diff` | Generate a browser-based side-by-side diff page. `--watch` serves a live-reloading review. |
+| `monacori app` | Launch the desktop review app (same as `mo`). |
+| `monacori report` | Store a manual report under `.monacori/reports/`. |
+| `monacori status` | Print branch, git status, diff stat, verification commands, and recent reports/logs. |
 
-```bash
-monacori check [--include-untracked] [--staged] [--base HEAD] [--context 12] [--open] [--no-verify] [--no-diff] [-- <command>]
-```
+## Repository state
 
-Runs verification and creates a validation report. By default it uses commands from `.monacori/config.json`; pass `-- <command>` to override for one run.
-
-```bash
-monacori init [--force]
-```
-
-Creates `.monacori/` with config, state, decisions, reports, logs, and diff directories. Because these are local validation artifacts, monacori also adds `.monacori/` to `.gitignore` inside Git worktrees.
-
-```bash
-monacori install [--force] [--apply-agent-docs]
-```
-
-Writes `.monacori/agent-snippet.md`, a short instruction block telling AI agents to run validation before claiming completion. With `--apply-agent-docs`, it updates `AGENTS.md` and `CLAUDE.md` marker blocks where available.
-
-```bash
-monacori verify [-- <command>]
-```
-
-Runs configured verification commands and stores the log in `.monacori/logs/`. Exits non-zero on failure.
-
-```bash
-monacori app [--base HEAD] [--staged] [--include-untracked] [--context 12] [--no-watch]
-```
-
-Launches the local desktop review app. `dg`, `monacori open`, and `monacori review` are aliases. Prefer `dg` for normal use.
-
-```bash
-monacori diff [--base HEAD] [--staged] [--include-untracked] [--context 12] [--output review.html] [--open] [--watch] [--port 0]
-```
-
-Generates a browser-based side-by-side diff review. Add `--watch` to serve a live review that reloads when the working tree changes.
-
-```bash
-monacori status
-```
-
-Prints current branch, git status, diff stat, configured verification commands, recent reports, and recent logs.
-
-```bash
-monacori report [--label manual] [--file report.md]
-```
-
-Stores a manual report under `.monacori/reports/` and appends a compact summary to `.monacori/state.md`.
-
-## Repository State
-
-`monacori init` creates:
+`monacori init` (run automatically by `mo`) creates:
 
 ```text
 .monacori/
-  config.json       verification commands and diff defaults
-  state.md          compact validation history
-  decisions.md      durable validation decisions
-  diffs/            generated browser diff reviews
-  reports/          validation reports
-  logs/             verification logs
+  config.json   verification commands and diff defaults
+  state.md      compact validation history
+  diffs/        generated browser diff reviews
+  reports/      validation reports
+  logs/         verification logs
 ```
 
-`monacori install` also writes `.monacori/agent-snippet.md` for projects that want to paste or apply agent-facing validation instructions.
-
 Keep `.monacori/` ignored unless your team explicitly wants to commit validation state.
 
-## Design Principles
+## Design principles
 
 - Verification evidence beats chat memory.
-- Generated artifacts should be plain Markdown, JSON, logs, or static HTML.
-- The tool should not require a specific AI agent, terminal multiplexer, editor, or worktree strategy.
+- Generated artifacts are plain Markdown, JSON, logs, or static HTML.
+- No required AI agent, terminal multiplexer, editor, or worktree strategy.
 - The default command should be useful after any AI-generated edit.
-- A change is not accepted until verification evidence is clear or the gap is explicitly documented.
+- A change is not accepted until the evidence is clear or the gap is documented.
+
+## License
+
+MIT

package/dist/app-main.js

@@ -1,13 +1,131 @@
-import { existsSync, mkdirSync, writeFileSync } from "node:fs";
+import { existsSync, mkdirSync, readFileSync, writeFileSync } from "node:fs";
+import { spawnSync } from "node:child_process";
 import { dirname, join, resolve } from "node:path";
 import { fileURLToPath } from "node:url";
-import { app, BrowserWindow, Menu, nativeImage } from "electron";
-import { buildDiffReview } from "./cli.js";
+import { app, BrowserWindow, ipcMain, Menu, nativeImage } from "electron";
+import { buildDiffReview, performHttpRequest } from "./cli.js";
+import { spawn as spawnPty } from "node-pty";
 const FLOW_DIR = ".monacori";
 const REVIEW_FILE = "app-review.html";
 const WATCH_INTERVAL_MS = 1000;
+// Painted immediately while the first review build + HTML render run, so startup shows a spinner instead
+// of a blank window. Inlined as a data: URL so it needs no file on disk and appears before any review work.
+const LOADING_HTML = `<!doctype html><html><head><meta charset="utf-8"><style>
+  html,body{margin:0;height:100vh;background:#2b2b2b;color:#9aa4af;display:flex;flex-direction:column;
+    align-items:center;justify-content:center;gap:18px;
+    font:13px -apple-system,BlinkMacSystemFont,"Segoe UI",sans-serif}
+  .s{width:34px;height:34px;border:3px solid #3a3a3a;border-top-color:#4a9eff;border-radius:50%;
+    animation:spin .8s linear infinite}
+  @keyframes spin{to{transform:rotate(360deg)}}
+</style></head><body><div class="s"></div><div>monacori</div></body></html>`;
 app.setName("monacori");
+ipcMain.handle("monacori:http-send", (_event, request) => performHttpRequest(request));
+// Phase 2 lazy-LOAD: serve a single file's diff body to the renderer on demand. Retained from the
+// most recent writeReviewFile() build so navigation/scroll can materialize bodies without embedding.
+let currentBodies = [];
+let currentSourceData = "[]";
+ipcMain.handle("monacori:get-file", (_event, request) => {
+    const i = Number(request?.index);
+    return Number.isInteger(i) && i >= 0 && i < currentBodies.length ? currentBodies[i] : "";
+});
+// Phase 2b lazy-LOAD: serve the full source files JSON (with content) on demand.
+ipcMain.handle("monacori:get-source-data", () => currentSourceData);
+// Self-update: install the latest published package globally, then relaunch so the updated code loads.
+// Runs in the main process because the sandboxed renderer can't spawn npm. Returns {ok:true} (and
+// relaunches shortly after) or {ok:false,error} so the renderer can fall back to the manual command.
+ipcMain.handle("monacori:self-update", () => {
+    const result = spawnSync("npm", ["install", "-g", "@happy-nut/monacori@latest"], {
+        encoding: "utf8",
+        shell: true,
+        env: process.env,
+        timeout: 5 * 60 * 1000,
+    });
+    if ((result.status ?? 1) === 0) {
+        // Let the renderer paint "Restarting…" before we relaunch with the new code.
+        setTimeout(() => { app.relaunch(); app.exit(0); }, 500);
+        return { ok: true };
+    }
+    const detail = (result.stderr || result.stdout || (result.error && result.error.message) || "npm install failed").trim();
+    return { ok: false, error: detail.slice(-600) };
+});
+// Integrated terminal: own node-pty sessions in the main process (the sandboxed renderer can't spawn
+// them) and relay bytes to the renderer's xterm panes. Each split pane gets its own pty, keyed by id, so
+// the renderer can route data/resize/kill per pane.
+const terms = new Map();
+let nextPtyId = 0;
+ipcMain.handle("monacori:pty-spawn", (_event, size) => {
+    const id = ++nextPtyId;
+    const shell = process.env.SHELL || (process.platform === "win32" ? "powershell.exe" : "/bin/zsh");
+    const t = spawnPty(shell, [], {
+        name: "xterm-color",
+        cols: size?.cols ?? 80,
+        rows: size?.rows ?? 24,
+        cwd: options.root,
+        env: process.env,
+    });
+    terms.set(id, t);
+    // mainWindow?. only guards null, NOT a *destroyed* window — sending to a closed window's webContents
+    // throws "Object has been destroyed". The pty can outlive the window (close races pty teardown), so
+    // guard every relay with isDestroyed().
+    const deliver = (channel, payload) => {
+        if (mainWindow && !mainWindow.isDestroyed())
+            mainWindow.webContents.send(channel, payload);
+    };
+    t.onData((data) => deliver("monacori:pty-data", { id, data }));
+    t.onExit(() => { terms.delete(id); deliver("monacori:pty-exit", { id }); });
+    return { ok: true, id };
+});
+ipcMain.on("monacori:pty-write", (_event, msg) => { terms.get(msg?.id)?.write(msg.data); });
+ipcMain.on("monacori:pty-resize", (_event, msg) => {
+    try {
+        terms.get(msg?.id)?.resize(msg.cols, msg.rows);
+    }
+    catch { /* resize can race the pty teardown — ignore */ }
+});
+ipcMain.on("monacori:pty-kill", (_event, msg) => {
+    const t = terms.get(msg?.id);
+    if (t) {
+        try {
+            t.kill();
+        }
+        catch { /* already exited */ }
+        terms.delete(msg.id);
+    }
+});
+// Persisted global settings (locale, …) live in a JSON file under userData and reach the renderer
+// via preload + the two handlers below. The renderer's file:// localStorage is NOT reliably persisted
+// across app restarts, so settings that must survive a reopen round-trip through the main process.
+function settingsFile() {
+    return join(app.getPath("userData"), "monacori-settings.json");
+}
+function readSettings() {
+    try {
+        return JSON.parse(readFileSync(settingsFile(), "utf8"));
+    }
+    catch {
+        return {};
+    }
+}
+function writeSettings(settings) {
+    try {
+        writeFileSync(settingsFile(), JSON.stringify(settings, null, 2));
+    }
+    catch {
+        /* best-effort: a failed write just means the setting isn't persisted */
+    }
+}
+ipcMain.on("monacori:get-settings", (event) => {
+    event.returnValue = readSettings();
+});
+ipcMain.on("monacori:set-setting", (_event, msg) => {
+    if (!msg || typeof msg.key !== "string")
+        return;
+    const settings = readSettings();
+    settings[msg.key] = msg.value;
+    writeSettings(settings);
+});
 const iconPath = join(dirname(fileURLToPath(import.meta.url)), "..", "assets", "icon.png");
+const preloadPath = join(dirname(fileURLToPath(import.meta.url)), "preload.cjs");
 const options = parseArgs(process.argv.slice(2));
 let mainWindow;
 let currentSignature = "";
@@ -19,13 +137,67 @@ if (!existsSync(options.root)) {
 app.whenReady().then(async () => {
     process.chdir(options.root);
     mkdirSync(FLOW_DIR, { recursive: true });
-    Menu.setApplicationMenu(null);
+    // Keep the standard Edit/Window roles so Cmd+C/V/X/A (copy comments into prompts) and Cmd+Q work.
+    // The in-window menu bar stays hidden on Windows/Linux via autoHideMenuBar; macOS shows it in the top bar.
+    const sendMerged = (kind) => mainWindow?.webContents.send("monacori:merged-view", kind);
+    const menuTemplate = [];
+    if (process.platform === "darwin")
+        menuTemplate.push({ role: "appMenu" });
+    menuTemplate.push({ role: "editMenu" });
+    // Ctrl+Cmd+Shift+/ ("?") and Ctrl+Cmd+Shift+. (">") open the merged question / change-request views.
+    // ? and > are Shift+/ and Shift+. so Shift is part of the combo; Ctrl+Cmd avoids macOS's Cmd+? Help grab.
+    menuTemplate.push({
+        label: "Review",
+        submenu: [
+            { label: "All questions", accelerator: "Control+Command+Shift+/", click: () => sendMerged("q") },
+            { label: "All change requests", accelerator: "Control+Command+Shift+.", click: () => sendMerged("c") },
+            { type: "separator" },
+            // Whitespace-ignore re-runs git diff with --ignore-all-space and reloads (main-process action,
+            // so a menu checkbox is simpler than a renderer IPC round-trip).
+            {
+                label: "Ignore whitespace",
+                type: "checkbox",
+                checked: options.ignoreWhitespace,
+                accelerator: "CommandOrControl+Shift+W",
+                click: (item) => {
+                    options.ignoreWhitespace = item.checked;
+                    currentSignature = writeReviewFile(options).signature;
+                    mainWindow?.webContents.reloadIgnoringCache();
+                },
+            },
+        ],
+    });
+    // Cmd/Ctrl+W closes the active Files-mode tab (routed to the renderer) instead of the window, matching
+    // editor/browser tab behavior. Closing the window stays available via the menu item and Cmd/Ctrl+Q.
+    menuTemplate.push({
+        label: "Window",
+        submenu: [
+            { role: "minimize" },
+            { role: "zoom" },
+            { type: "separator" },
+            { label: "Close Tab", accelerator: "CommandOrControl+W", click: () => mainWindow?.webContents.send("monacori:close-tab") },
+            { label: "Close Window", click: () => mainWindow?.close() },
+        ],
+    });
+    // Terminal toggle/split as menu accelerators: Chromium swallows Cmd+D before it reaches the renderer
+    // (Cmd+A and friends arrive fine), so route the split — and the toggles — through the menu instead.
+    menuTemplate.push({
+        label: "Terminal",
+        submenu: [
+            { label: "Toggle Terminal", accelerator: "Control+`", click: () => mainWindow?.webContents.send("monacori:terminal-toggle") },
+            { label: "Toggle Terminal (F12)", accelerator: "Alt+F12", click: () => mainWindow?.webContents.send("monacori:terminal-toggle") },
+            { label: "Split Terminal", accelerator: "CommandOrControl+D", click: () => mainWindow?.webContents.send("monacori:terminal-split") },
+            { type: "separator" },
+            { label: "Focus Previous Pane", accelerator: "CommandOrControl+Alt+[", click: () => mainWindow?.webContents.send("monacori:terminal-pane-focus", -1) },
+            { label: "Focus Next Pane", accelerator: "CommandOrControl+Alt+]", click: () => mainWindow?.webContents.send("monacori:terminal-pane-focus", 1) },
+            { label: "Rename Pane", accelerator: "F2", click: () => mainWindow?.webContents.send("monacori:terminal-pane-rename") },
+        ],
+    });
+    Menu.setApplicationMenu(Menu.buildFromTemplate(menuTemplate));
     const appIcon = nativeImage.createFromPath(iconPath);
     if (process.platform === "darwin" && app.dock && !appIcon.isEmpty()) {
         app.dock.setIcon(appIcon);
     }
-    const firstBuild = writeReviewFile(options);
-    currentSignature = firstBuild.signature;
     mainWindow = new BrowserWindow({
         width: 1440,
         height: 960,
@@ -37,6 +209,7 @@ app.whenReady().then(async () => {
         backgroundColor: "#2b2b2b",
         autoHideMenuBar: true,
         webPreferences: {
+            preload: preloadPath,
             contextIsolation: true,
             nodeIntegration: false,
             sandbox: true,
@@ -45,10 +218,24 @@ app.whenReady().then(async () => {
     });
     mainWindow.webContents.setWindowOpenHandler(() => ({ action: "deny" }));
     mainWindow.once("ready-to-show", () => mainWindow?.show());
-    await mainWindow.loadFile(reviewPath());
-    if (options.watch) {
-        refreshTimer = setInterval(refreshIfChanged, WATCH_INTERVAL_MS);
-    }
+    // Paint the window with a spinner immediately, then build the (potentially heavy) review off the first
+    // paint and swap it in. The first build used to run synchronously *before* the window existed, so the
+    // screen stayed blank for the first few seconds of startup; now the user sees a loading screen instead.
+    await mainWindow.loadURL("data:text/html;charset=utf-8," + encodeURIComponent(LOADING_HTML));
+    setImmediate(() => {
+        try {
+            const firstBuild = writeReviewFile(options);
+            currentSignature = firstBuild.signature;
+            if (mainWindow && !mainWindow.isDestroyed())
+                void mainWindow.loadFile(reviewPath());
+            if (options.watch)
+                refreshTimer = setInterval(refreshIfChanged, WATCH_INTERVAL_MS);
+        }
+        catch (error) {
+            console.error(error instanceof Error ? error.message : String(error));
+            app.quit();
+        }
+    });
 }).catch((error) => {
     console.error(error instanceof Error ? error.message : String(error));
     app.quit();
@@ -56,6 +243,13 @@ app.whenReady().then(async () => {
 app.on("window-all-closed", () => {
     if (refreshTimer)
         clearInterval(refreshTimer);
+    for (const t of terms.values()) {
+        try {
+            t.kill();
+        }
+        catch { /* already exited */ }
+    }
+    terms.clear();
     app.quit();
 });
 async function refreshIfChanged() {
@@ -83,8 +277,13 @@ function writeReviewFile(input) {
         includeUntracked: input.includeUntracked,
         context: input.context,
         title: "monacori",
+        ignoreWhitespace: input.ignoreWhitespace,
+        lazyLoad: true, // Electron streams per-file bodies/source over IPC (monacori:get-file / get-source)
+        app: true, // gate the integrated terminal (xterm) into the HTML — Electron only
     });
     writeFileSync(reviewPath(), build.html);
+    currentBodies = build.lazyBodies ?? [];
+    currentSourceData = build.lazySourceData ?? "[]";
     return { signature: build.signature };
 }
 function reviewPath() {
@@ -100,6 +299,7 @@ function parseArgs(args) {
         includeUntracked: args.includes("--include-untracked"),
         context: contextValue ? parsePositiveInteger(contextValue, "--context") : 12,
         watch: !args.includes("--no-watch"),
+        ignoreWhitespace: args.includes("--ignore-whitespace"),
     };
 }
 function readOption(args, name) {

package/dist/assets.d.ts

@@ -0,0 +1,6 @@
+export declare function readViewerAsset(name: string): string;
+export declare function diff2HtmlCss(): string;
+export declare function diffCss(): string;
+export declare function diffScript(): string;
+export declare function xtermCss(): string;
+export declare function xtermScript(): string;

package/dist/assets.js

@@ -0,0 +1,51 @@
+import { readFileSync } from "node:fs";
+import { dirname, join } from "node:path";
+import { fileURLToPath } from "node:url";
+import { createRequire } from "node:module";
+const nodeRequire = createRequire(import.meta.url);
+const viewerAssetCache = new Map();
+// Client viewer script/stylesheet live in sibling files (copied to dist/ at build) so this
+// module stays small and the client code can use template literals freely (no String.raw).
+export function readViewerAsset(name) {
+    let cached = viewerAssetCache.get(name);
+    if (cached === undefined) {
+        cached = readFileSync(join(dirname(fileURLToPath(import.meta.url)), name), "utf8");
+        viewerAssetCache.set(name, cached);
+    }
+    return cached;
+}
+export function diff2HtmlCss() {
+    try {
+        return readFileSync(nodeRequire.resolve("diff2html/bundles/css/diff2html.min.css"), "utf8");
+    }
+    catch {
+        return "";
+    }
+}
+export function diffCss() {
+    return readViewerAsset("viewer.css");
+}
+export function diffScript() {
+    return readViewerAsset("viewer.client.js");
+}
+// xterm.js (terminal renderer) for the integrated terminal panel. UMD bundles that expose
+// window.Terminal + window.FitAddon when inlined. Resolved from node_modules like diff2HtmlCss();
+// pure JS, no native binding — the pty itself lives in the main process via node-pty.
+export function xtermCss() {
+    try {
+        return readFileSync(nodeRequire.resolve("@xterm/xterm/css/xterm.css"), "utf8");
+    }
+    catch {
+        return "";
+    }
+}
+export function xtermScript() {
+    try {
+        const core = readFileSync(nodeRequire.resolve("@xterm/xterm/lib/xterm.js"), "utf8");
+        const fit = readFileSync(nodeRequire.resolve("@xterm/addon-fit/lib/addon-fit.js"), "utf8");
+        return core + "\n" + fit;
+    }
+    catch {
+        return "";
+    }
+}

package/dist/build.d.ts

@@ -0,0 +1,13 @@
+import type { DiffReviewBuild } from "./types.js";
+export declare function buildDiffReview(input: {
+    base?: string;
+    staged: boolean;
+    includeUntracked: boolean;
+    context: number;
+    title: string;
+    watch?: boolean;
+    ignoreWhitespace?: boolean;
+    lazy?: boolean;
+    lazyLoad?: boolean;
+    app?: boolean;
+}): DiffReviewBuild;

package/dist/build.js

@@ -0,0 +1,77 @@
+import { createHash } from "node:crypto";
+import { basename } from "node:path";
+import { isGitRepository } from "./git.js";
+import { collectHttpEnvironments, collectReviewFileStates, collectSourceFiles, parseUnifiedDiff, readUnifiedDiff } from "./diff.js";
+import { renderDiff2Html } from "./highlight.js";
+import { diffSubtitle, renderDiffHtml, renderNotGitRepoHtml, shouldLazyRender, splitDiffForLazy } from "./render.js";
+export function buildDiffReview(input) {
+    if (!isGitRepository(process.cwd())) {
+        return {
+            html: renderNotGitRepoHtml(process.cwd()),
+            files: 0,
+            hunks: 0,
+            signature: "not-a-git-repo",
+            generatedAt: new Date().toISOString(),
+        };
+    }
+    const diffText = readUnifiedDiff({
+        base: input.base,
+        staged: input.staged,
+        context: input.context,
+        includeUntracked: input.includeUntracked,
+        ignoreWhitespace: input.ignoreWhitespace,
+    });
+    const files = parseUnifiedDiff(diffText);
+    const sourceFiles = collectSourceFiles(files);
+    const fileStates = collectReviewFileStates(files, sourceFiles);
+    const httpEnvironments = collectHttpEnvironments(process.cwd());
+    const hunks = files.reduce((sum, file) => sum + file.hunks.length, 0);
+    const generatedAt = new Date().toISOString();
+    const diffHtml = renderDiff2Html(diffText);
+    const totalLines = files.reduce((sum, file) => sum + file.hunks.reduce((t, h) => t + h.lines.length, 0), 0);
+    // lazy-LOAD (Phase 2) serves each file body + source on demand instead of embedding them; it implies
+    // lazy (shells). The transport opts in (serve/Electron pass lazyLoad:true) and we honor it regardless
+    // of size: it used to be gated by `&& big`, but a mid-size repo (dozens of files, just under the
+    // threshold) then embedded a 600KB+ source blob + every diff body inline, forcing the renderer to
+    // parse + lay out a huge document before the first click — the startup "freeze". Standalone (no
+    // transport) has no server, so it auto-decides by size and lazy-materializes from embedded islands.
+    const big = shouldLazyRender(files.length, totalLines);
+    const lazyLoad = input.lazyLoad ?? false;
+    const lazy = lazyLoad || (input.lazy ?? big);
+    const diffSplit = lazy ? splitDiffForLazy(diffHtml, files) : { container: diffHtml, islands: "", bodies: [] };
+    const signature = createHash("sha1")
+        .update(diffText)
+        .update("\n")
+        .update(sourceFiles.map((file) => `${file.path}\0${file.size}\0${file.embedded ? file.content : file.skippedReason ?? ""}`).join("\n"))
+        .update("\n")
+        .update(JSON.stringify(httpEnvironments))
+        .digest("hex");
+    const html = renderDiffHtml({
+        files,
+        diffHtml: diffSplit.container,
+        diffIslands: lazyLoad ? "" : diffSplit.islands,
+        lazy,
+        lazyLoad,
+        sourceFiles,
+        fileStates,
+        httpEnvironments,
+        title: input.title,
+        subtitle: diffSubtitle(input),
+        projectName: basename(process.cwd()),
+        projectPath: process.cwd(),
+        watch: Boolean(input.watch),
+        ignoreWhitespace: Boolean(input.ignoreWhitespace),
+        app: Boolean(input.app),
+        signature,
+        generatedAt,
+    });
+    return {
+        html,
+        files: files.length,
+        hunks,
+        signature,
+        generatedAt,
+        lazyBodies: diffSplit.bodies,
+        lazySourceData: lazyLoad ? JSON.stringify(sourceFiles) : undefined,
+    };
+}