npm - @happy-nut/monacori - Versions diffs - 0.1.10 → 0.1.12 - Mend

@happy-nut/monacori 0.1.10 → 0.1.12

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (13) hide show

package/README.md CHANGED Viewed

@@ -52,25 +52,6 @@ On first run, `mo` creates `.monacori/`, adds it to `.gitignore`, and includes u
 - **Source navigation**: jump between changed files, search indexed files, preview source, and move through hunks from the keyboard.
 - **Plain local artifacts**: generated review files and state are Markdown, JSON, and static HTML under `.monacori/`.
-## Commands
-| Command | What it does |
-| --- | --- |
-| `mo` | Open the desktop diff-review app for the current repository. Alias for `monacori open`. |
-| `monacori open` | Launch the review app, auto-initialize `.monacori/`, and include untracked files by default. |
-| `monacori app` | Launch the same desktop app explicitly. |
-| `monacori init` | Initialize `.monacori/` in the current directory. |
-| `monacori install` | Initialize and write agent instruction snippets. Use `--apply-agent-docs` to patch `AGENTS.md` or `CLAUDE.md`. |
-Useful review options:
-```bash
-mo --staged              # review only staged changes
-mo --tracked-only        # exclude untracked files
-mo --base main           # compare against a specific base
-mo --context 20          # show more context around each hunk
-```
 ## Development
 Working on monacori itself? The globally-installed `mo` runs the **published** package, not your
@@ -82,10 +63,10 @@ Run your checkout directly (builds, then launches in the foreground with DevTool
 npm run dev
 ```
-This reviews the monacori repo itself. To point a local build at another project:
+This reviews the monacori repo itself. To review **another repo** with your local build, pass `--cwd`:
 ```bash
-MONACORI_DEV=1 node /path/to/monacori/bin/monacori.js --foreground
+npm run dev -- --cwd /path/to/other-repo
 ```
 **Which build is running?** A dev build titles its window `monacori (dev)` and opens DevTools, and
@@ -120,7 +101,7 @@ suite gates every release.
 ## Local State
-`monacori init` creates a git-ignored `.monacori/` directory for generated diff reviews, local config, comments, logs, and validation notes. Keep it ignored unless your team intentionally wants to version review artifacts.
+Running `mo` creates a git-ignored `.monacori/` directory for generated diff reviews, local config, comments, logs, and validation notes. Keep it ignored unless your team intentionally wants to version review artifacts.
 ## Design Principles

package/dist/app-main.js CHANGED Viewed

@@ -1,10 +1,12 @@
 import { existsSync, mkdirSync, readFileSync, writeFileSync } from "node:fs";
-import { spawnSync } from "node:child_process";
+import { spawnSync, spawn } from "node:child_process";
 import { dirname, join, resolve } from "node:path";
 import { fileURLToPath } from "node:url";
 import { app, BrowserWindow, ipcMain, Menu, nativeImage } from "electron";
 import { buildDiffReview, performHttpRequest } from "./cli.js";
 import { sanitizeTerminalEnv } from "./util.js";
+import { readUnifiedDiff } from "./diff.js";
+import { createHash } from "node:crypto";
 import { spawn as spawnPty } from "node-pty";
 // `npm run dev` sets MONACORI_DEV=1 so a locally-built app announces itself — a window-title suffix
 // plus a boot log with its on-disk path — making it obvious whether `mo` launched THIS checkout or
@@ -15,15 +17,32 @@ 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;
+// of a blank window. Inlined as a data: URL so it needs no file on disk and appears before any review
+// work. Theme-aware so a light-theme user doesn't get a dark flash before the renderer applies the theme.
+function loadingHtml(light) {
+    const bg = light ? "#ffffff" : "#2b2b2b";
+    const fg = light ? "#6e7781" : "#9aa4af";
+    const ring = light ? "#d0d7de" : "#3a3a3a";
+    const accent = light ? "#0969da" : "#4a9eff";
+    return `<!doctype html><html><head><meta charset="utf-8"><style>
+  html,body{margin:0;height:100vh;background:${bg};color:${fg};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%;
+  .s{width:34px;height:34px;border:3px solid ${ring};border-top-color:${accent};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>`;
+}
+// The persisted theme (set by the renderer via monacoriSettings). Read at startup so the native window
+// chrome + loading screen match before the renderer boots. Defaults to dark.
+function isLightTheme() {
+    try {
+        return readSettings()["monacori-theme"] === "light";
+    }
+    catch {
+        return false;
+    }
+}
 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
@@ -47,8 +66,27 @@ ipcMain.handle("monacori:self-update", () => {
         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);
+        // Let the renderer paint "Restarting…", then start the freshly-installed CLI as a NEW detached
+        // process and exit. app.relaunch() re-runs THIS process, but the global install just replaced our
+        // on-disk dist (and possibly the bundled Electron), so the current process is stale — relaunching
+        // it can boot the old code or fail outright. Spawning `mo` loads the new code; a sanitized env
+        // keeps this update run's npm_* vars out of the fresh process. Falls back to relaunch if spawn fails.
+        setTimeout(() => {
+            try {
+                const child = spawn("mo", [], {
+                    cwd: options.root,
+                    detached: true,
+                    stdio: "ignore",
+                    env: sanitizeTerminalEnv(process.env),
+                    shell: true,
+                });
+                child.unref();
+            }
+            catch {
+                app.relaunch();
+            }
+            app.exit(0);
+        }, 400);
         return { ok: true };
     }
     const detail = (result.stderr || result.stdout || (result.error && result.error.message) || "npm install failed").trim();
@@ -211,6 +249,7 @@ app.whenReady().then(async () => {
     if (process.platform === "darwin" && app.dock && !appIcon.isEmpty()) {
         app.dock.setIcon(appIcon);
     }
+    const themeLight = isLightTheme();
     mainWindow = new BrowserWindow({
         width: 1440,
         height: 960,
@@ -219,7 +258,7 @@ app.whenReady().then(async () => {
         show: false,
         title: APP_TITLE,
         icon: iconPath,
-        backgroundColor: "#2b2b2b",
+        backgroundColor: themeLight ? "#ffffff" : "#2b2b2b",
         autoHideMenuBar: true,
         webPreferences: {
             preload: preloadPath,
@@ -238,7 +277,7 @@ app.whenReady().then(async () => {
     // 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));
+    await mainWindow.loadURL("data:text/html;charset=utf-8," + encodeURIComponent(loadingHtml(themeLight)));
     // Give the loading spinner a few frames to actually paint before the (synchronous) first build blocks
     // the main process — otherwise the spinner looks frozen until the build finishes. The boot overlay in
     // the review HTML then takes over, so there's no blank gap when loadFile swaps the page in.
@@ -272,11 +311,27 @@ app.on("window-all-closed", () => {
     terms.clear();
     app.quit();
 });
+let lastDiffSig = "";
 async function refreshIfChanged() {
     if (refreshing || !mainWindow || mainWindow.isDestroyed())
         return;
     refreshing = true;
     try {
+        // Fast path: hash only the git diff (~120ms) before the full build (~1s). The vast majority of
+        // watch ticks see no change, so skip the heavy buildDiffReview entirely then — keeping the main
+        // process free for IPC/pty so the UI never stalls on an unchanged tree.
+        const diffSig = createHash("sha1")
+            .update(readUnifiedDiff({
+            base: options.base,
+            staged: options.staged,
+            context: options.context,
+            includeUntracked: options.includeUntracked,
+            ignoreWhitespace: options.ignoreWhitespace,
+        }))
+            .digest("hex");
+        if (diffSig === lastDiffSig)
+            return;
+        lastDiffSig = diffSig;
         const next = writeReviewFile(options);
         if (next.signature !== currentSignature) {
             currentSignature = next.signature;
@@ -320,8 +375,9 @@ function parseArgs(args) {
     const contextValue = readOption(args, "--context");
     return {
         root: resolve(root),
-        base: readOption(args, "--base"),
-        staged: args.includes("--staged"),
+        // staged review and custom --base were removed from the CLI; always diff the working tree against
+        // HEAD (base omitted → defaults to HEAD downstream).
+        staged: false,
         includeUntracked: args.includes("--include-untracked"),
         context: contextValue ? parsePositiveInteger(contextValue, "--context") : 12,
         watch: !args.includes("--no-watch"),

package/dist/commands.js CHANGED Viewed

@@ -1,46 +1,23 @@
 import { existsSync, mkdirSync, readFileSync, writeFileSync } from "node:fs";
-import { basename, dirname, join } from "node:path";
+import { basename, dirname, join, resolve } from "node:path";
 import { spawn, spawnSync } from "node:child_process";
 import { fileURLToPath } from "node:url";
 import { createRequire } from "node:module";
-import { AGENT_SNIPPET_FILE, CONFIG_FILE, DECISIONS_FILE, FLOW_DIR, GITIGNORE_FILE, STATE_FILE } from "./constants.js";
-import { parsePositiveInteger, readOption } from "./util.js";
+import { CONFIG_FILE, DECISIONS_FILE, FLOW_DIR, GITIGNORE_FILE, STATE_FILE } from "./constants.js";
+import { readOption } from "./util.js";
 import { git } from "./git.js";
 const nodeRequire = createRequire(import.meta.url);
+// monacori is a single command: open the desktop review app for the current repository. `mo` and
+// `monacori` (with or without flags) all do the same thing. `--cwd <path>` reviews another repo (used by
+// `npm run dev -- --cwd <path>`); `--no-watch` / `--foreground` are dev/internal knobs. `--help` prints help.
 export function main() {
     const rawArgs = process.argv.slice(2);
-    const [command, ...args] = rawArgs;
     try {
-        if (!command) {
-            openCurrentRepository([]);
+        if (rawArgs.includes("--help") || rawArgs.includes("-h")) {
+            printHelp();
             return;
         }
-        if (command !== "--help" && command !== "-h" && command.startsWith("-")) {
-            openCurrentRepository(rawArgs);
-            return;
-        }
-        switch (command) {
-            case "init":
-                initFlow(args);
-                break;
-            case "install":
-                installFlow(args);
-                break;
-            case "app":
-            case "review":
-                launchReviewApp(args);
-                break;
-            case "open":
-                openCurrentRepository(args);
-                break;
-            case "--help":
-            case "-h":
-            case "help":
-                printHelp();
-                break;
-            default:
-                throw new Error(`Unknown command: ${command}`);
-        }
+        launchReviewApp(rawArgs);
     }
     catch (error) {
         const message = error instanceof Error ? error.message : String(error);
@@ -48,108 +25,42 @@ export function main() {
         process.exit(1);
     }
 }
-function initFlow(args) {
-    const force = args.includes("--force");
-    const quiet = args.includes("--quiet");
-    const root = process.cwd();
-    const flowPath = join(root, FLOW_DIR);
-    mkdirSync(flowPath, { recursive: true });
-    mkdirSync(join(flowPath, "reports"), { recursive: true });
-    mkdirSync(join(flowPath, "logs"), { recursive: true });
-    mkdirSync(join(flowPath, "diffs"), { recursive: true });
-    const config = {
-        version: 1,
-        projectName: basename(root),
-        verification: {
-            commands: detectVerificationCommands(root),
-        },
-        diff: {
-            context: 12,
-            includeUntracked: false,
-        },
-    };
-    writeIfMissing(join(flowPath, CONFIG_FILE), `${JSON.stringify(config, null, 2)}\n`, force);
-    writeIfMissing(join(flowPath, STATE_FILE), initialState(config), force);
-    writeIfMissing(join(flowPath, DECISIONS_FILE), initialDecisions(), force);
-    const ignored = ensureMonacoriGitignore(root);
-    if (!quiet) {
-        console.log(`Initialized ${FLOW_DIR}/ in ${root}`);
-        if (ignored) {
-            console.log(`Updated ${GITIGNORE_FILE} to ignore ${FLOW_DIR}/ validation artifacts.`);
-        }
-        console.log("Next: run `mo` to open the diff review app.");
-    }
-}
-function installFlow(args) {
-    const force = args.includes("--force");
-    const applyAgentDocs = args.includes("--apply-agent-docs");
-    initFlow(["--quiet"]);
-    writeIfMissing(join(process.cwd(), FLOW_DIR, AGENT_SNIPPET_FILE), agentSnippet(), force);
-    if (applyAgentDocs) {
-        applyAgentDocSnippet("AGENTS.md");
-        applyAgentDocSnippet("CLAUDE.md");
-    }
-    console.log("Installed monacori validation instructions.");
-    console.log(`- ${FLOW_DIR}/${AGENT_SNIPPET_FILE}`);
-    if (applyAgentDocs) {
-        console.log("- Updated AGENTS.md / CLAUDE.md validation snippets where available.");
-    }
-    else {
-        console.log(`Next: add ${FLOW_DIR}/${AGENT_SNIPPET_FILE} to your agent instructions if desired.`);
-    }
-}
+// "Show everything" diff context: large enough that `git diff -U<n>` emits entire files as context, so the
+// diff never folds away unchanged regions. Reviewers skip with F7/Shift+F7 instead of relying on gaps.
+const FULL_DIFF_CONTEXT = 100000;
 function launchReviewApp(args) {
-    if (args.includes("--help") || args.includes("-h")) {
-        printAppHelp();
-        return;
+    // Review the directory given by --cwd (defaults to the current one), so `npm run dev -- --cwd <path>` can
+    // open ANY repo from anywhere. chdir up front so the flow state and the launched app resolve to one repo.
+    const targetCwd = resolve(readOption(args, "--cwd") ?? process.cwd());
+    if (!existsSync(targetCwd)) {
+        throw new Error(`Directory does not exist: ${targetCwd}`);
     }
+    process.chdir(targetCwd);
     ensureWritableFlowState();
-    const config = loadConfig();
-    const contextValue = readOption(args, "--context");
-    const context = contextValue ? parsePositiveInteger(contextValue, "--context") : config.diff.context;
     const appArgs = [
         appMainPath(),
         "--cwd",
         process.cwd(),
         "--context",
-        String(context),
+        String(FULL_DIFF_CONTEXT),
+        "--include-untracked", // new AI-created files are visible by default
     ];
-    const base = readOption(args, "--base");
-    if (base)
-        appArgs.push("--base", base);
-    if (args.includes("--staged"))
-        appArgs.push("--staged");
-    if (args.includes("--include-untracked") || config.diff.includeUntracked)
-        appArgs.push("--include-untracked");
     if (args.includes("--no-watch"))
         appArgs.push("--no-watch");
     const electronBinary = resolveElectronBinary();
-    // Tell the user which build is about to run. The app-main path disambiguates a local checkout from
-    // the installed package (their versions can match); printed on the shell that ran `mo`, even when
-    // the app itself is spawned detached.
-    console.error(`monacori: launching ${appMainPath()}`);
+    // In dev only (`npm run dev` sets MONACORI_DEV=1) announce which build is launching, so a local checkout
+    // is distinguishable from the installed package. Normal `mo` runs stay silent.
+    if (process.env.MONACORI_DEV === "1") {
+        console.error(`monacori: launching ${appMainPath()}`);
+    }
     if (args.includes("--foreground")) {
         const result = spawnSync(electronBinary, appArgs, { stdio: "inherit" });
         process.exit(result.status ?? 0);
     }
-    const child = spawn(electronBinary, appArgs, {
-        detached: true,
-        stdio: "ignore",
-    });
+    const child = spawn(electronBinary, appArgs, { detached: true, stdio: "ignore" });
     child.unref();
     console.log("Opened monacori review app.");
 }
-function openCurrentRepository(args) {
-    if (args.includes("--help") || args.includes("-h")) {
-        printOpenHelp();
-        return;
-    }
-    const appArgs = args.filter((arg) => arg !== "--tracked-only");
-    if (!args.includes("--tracked-only") && !args.includes("--staged") && !args.includes("--include-untracked")) {
-        appArgs.push("--include-untracked");
-    }
-    launchReviewApp(appArgs);
-}
 function resolveElectronBinary() {
     const electronModule = nodeRequire("electron");
     if (typeof electronModule === "string") {
@@ -166,12 +77,30 @@ function resolveElectronBinary() {
 function appMainPath() {
     return join(dirname(fileURLToPath(import.meta.url)), "app-main.js");
 }
+// Create .monacori/ on first run (the app auto-initializes; there is no separate `init` command).
+function initFlow() {
+    const root = process.cwd();
+    const flowPath = join(root, FLOW_DIR);
+    mkdirSync(flowPath, { recursive: true });
+    mkdirSync(join(flowPath, "reports"), { recursive: true });
+    mkdirSync(join(flowPath, "logs"), { recursive: true });
+    mkdirSync(join(flowPath, "diffs"), { recursive: true });
+    const config = {
+        version: 1,
+        projectName: basename(root),
+        verification: { commands: detectVerificationCommands(root) },
+        diff: { context: 12, includeUntracked: false },
+    };
+    writeIfMissing(join(flowPath, CONFIG_FILE), `${JSON.stringify(config, null, 2)}\n`);
+    writeIfMissing(join(flowPath, STATE_FILE), initialState(config));
+    writeIfMissing(join(flowPath, DECISIONS_FILE), initialDecisions());
+    ensureMonacoriGitignore(root);
+}
 function initialState(config) {
     return [
         "# Monacori Validation State",
         "",
         `Project: ${config.projectName}`,
-        `Initialized: ${new Date().toISOString()}`,
         "",
         "## Goal",
         "- Keep AI-generated changes reviewable, test-backed, and easy to inspect.",
@@ -190,74 +119,22 @@ function initialDecisions() {
         "",
     ].join("\n");
 }
-function agentSnippet() {
-    return [
-        "<!-- MONACORI:START -->",
-        "## monacori Diff Review",
-        "",
-        "This repository uses monacori to help humans review AI-generated code changes side-by-side.",
-        "",
-        "After making code changes:",
-        "",
-        "- The user can run `mo` to open the diff review app and inspect your changes.",
-        "- Inspect changed hunks with F7 / Shift+F7.",
-        "- Use Shift Shift in the diff review to search indexed files, including unchanged files.",
-        "- In source previews, use Cmd/Ctrl+Down to jump to the declaration-like match under the cursor.",
-        "- Inline comments left in the review are bundled into a prompt and sent back to the session.",
-        "<!-- MONACORI:END -->",
-        "",
-    ].join("\n");
-}
-function applyAgentDocSnippet(fileName) {
-    const path = join(process.cwd(), fileName);
-    const snippet = agentSnippet();
-    if (!existsSync(path)) {
-        writeFileSync(path, `# ${fileName}\n\n${snippet}`);
-        return;
-    }
-    const current = readFileSync(path, "utf8");
-    const markerPattern = /<!-- MONACORI:START -->[\s\S]*?<!-- MONACORI:END -->\n?/;
-    const next = markerPattern.test(current)
-        ? current.replace(markerPattern, snippet)
-        : `${current.trimEnd()}\n\n${snippet}`;
-    writeFileSync(path, next);
-}
-function ensureInitialized() {
-    if (!existsSync(join(process.cwd(), FLOW_DIR, CONFIG_FILE))) {
-        throw new Error(`Missing ${FLOW_DIR}/. Run \`monacori init\` first.`);
-    }
-}
 function ensureWritableFlowState() {
     if (!existsSync(join(process.cwd(), FLOW_DIR, CONFIG_FILE))) {
-        initFlow(["--quiet"]);
+        initFlow();
         return;
     }
     ensureMonacoriGitignore(process.cwd());
 }
-function loadConfig() {
-    ensureInitialized();
-    const raw = JSON.parse(readFileSync(join(process.cwd(), FLOW_DIR, CONFIG_FILE), "utf8"));
-    return {
-        version: 1,
-        projectName: raw.projectName ?? basename(process.cwd()),
-        verification: {
-            commands: Array.isArray(raw.verification?.commands) ? raw.verification.commands : [],
-        },
-        diff: {
-            context: typeof raw.diff?.context === "number" ? raw.diff.context : 12,
-            includeUntracked: typeof raw.diff?.includeUntracked === "boolean" ? raw.diff.includeUntracked : false,
-        },
-    };
-}
-function writeIfMissing(path, content, force) {
-    if (!force && existsSync(path)) {
+function writeIfMissing(path, content) {
+    if (existsSync(path)) {
         return;
     }
     writeFileSync(path, content);
 }
 function ensureMonacoriGitignore(root) {
     if (git(root, ["rev-parse", "--is-inside-work-tree"]) !== "true") {
-        return false;
+        return;
     }
     const path = join(root, GITIGNORE_FILE);
     const content = existsSync(path) ? readFileSync(path, "utf8") : "";
@@ -266,11 +143,10 @@ function ensureMonacoriGitignore(root) {
         .map((line) => line.trim())
         .some((line) => line === FLOW_DIR || line === `${FLOW_DIR}/`);
     if (hasEntry) {
-        return false;
+        return;
     }
     const prefix = content.length === 0 ? "" : content.endsWith("\n") ? "\n" : "\n\n";
     writeFileSync(path, `${content}${prefix}# monacori local validation artifacts\n${FLOW_DIR}/\n`);
-    return true;
 }
 function detectVerificationCommands(root) {
     const commands = new Set();
@@ -318,51 +194,16 @@ function packageScriptCommand(manager, script) {
     return `pnpm ${script}`;
 }
 function printHelp() {
-    console.log(`monacori
-Desktop review app for AI-generated code changes.
+    console.log(`monacori — desktop review app for AI-generated code changes.
 Usage:
-  mo
-  monacori open [--base HEAD] [--staged] [--tracked-only]
-  monacori app [--base HEAD] [--staged] [--include-untracked]
-  monacori init [--force]
-  monacori install [--force] [--apply-agent-docs]
+  mo            open the review app for the current repository
 Diff review keys:
-  F7         next changed hunk
-  Shift+F7  previous changed hunk
-  Shift Shift file search across indexed files
-  Cmd/Ctrl+E recent files
-  Cmd/Ctrl+Down jump to symbol under cursor
-`);
-}
-function printOpenHelp() {
-    console.log(`monacori open
-Open the local desktop review app for the current directory. This is the default command behind \`mo\` and \`monacori\` with no arguments.
-It auto-initializes .monacori/ when needed, makes sure .monacori/ is ignored in Git worktrees, and includes untracked files by default so new AI-created files are visible.
-Usage:
-  mo
-  monacori open [--base HEAD] [--staged] [--tracked-only] [--context 12] [--no-watch] [--foreground]
-Options:
-  --tracked-only  inspect tracked changes only
-`);
-}
-function printAppHelp() {
-    console.log(`monacori app
-Launch the local desktop review app. The app reads Git diff and source files directly from this repository, writes a local review file under .monacori/, and refreshes when the working tree changes. It does not start an HTTP server.
-Usage:
-  monacori app [--base HEAD] [--staged] [--include-untracked] [--context 12] [--no-watch] [--foreground]
-Aliases:
-  mo
-  monacori open
-  monacori review
+  F7 / Shift+F7     next / previous changed hunk
+  Cmd/Ctrl+0 / +1   focus the Changes / Files panel (arrows + Enter to open a file)
+  Shift Shift       file search across indexed files
+  Cmd/Ctrl+E        recent files
+  Cmd/Ctrl+Down     jump to symbol under cursor
 `);
 }

package/dist/diff.js CHANGED Viewed

@@ -3,8 +3,14 @@ import { existsSync, readFileSync, statSync } from "node:fs";
 import { basename, join } from "node:path";
 import { FLOW_DIR, IMAGE_MAX_BYTES, SOURCE_MAX_FILE_BYTES, SOURCE_MAX_FILES, SOURCE_MAX_TOTAL_BYTES } from "./constants.js";
 import { formatBytes, hashText, isLikelyBinary, languageForPath, stripDiffPath } from "./util.js";
-import { git } from "./git.js";
+import { git, repoRoot } from "./git.js";
+// File content + signature cache, keyed by path and validated on (mtime, size). Under `watch` the app
+// rebuilds every second; without this, collectSourceFiles re-reads + re-hashes EVERY tracked source
+// file each tick (~1.3s for ~6k files on a large repo), pinning the Electron main process and starving
+// IPC/pty. With it an unchanged file costs a single statSync — the per-tick cost collapses to stat-only.
+const sourceContentCache = new Map();
 export function readUnifiedDiff(options) {
+    const root = repoRoot();
     const args = ["diff", "--no-ext-diff", "--find-renames", `--unified=${options.context}`];
     if (options.ignoreWhitespace)
         args.push("--ignore-all-space");
@@ -16,7 +22,7 @@ export function readUnifiedDiff(options) {
     }
     args.push("--");
     const result = spawnSync("git", args, {
-        cwd: process.cwd(),
+        cwd: root,
         encoding: "utf8",
         maxBuffer: 1024 * 1024 * 100,
     });
@@ -25,18 +31,18 @@ export function readUnifiedDiff(options) {
     }
     const chunks = [result.stdout ?? ""];
     if (options.includeUntracked && !options.staged) {
-        chunks.push(readUntrackedDiff(options.context));
+        chunks.push(readUntrackedDiff(options.context, root));
     }
     return chunks.filter(Boolean).join("\n");
 }
-function readUntrackedDiff(context) {
-    const files = git(process.cwd(), ["ls-files", "--others", "--exclude-standard"])
+function readUntrackedDiff(context, root) {
+    const files = git(root, ["ls-files", "--others", "--exclude-standard"])
         .split(/\r?\n/)
         .map((line) => line.trim())
         .filter((line) => line && !line.startsWith(`${FLOW_DIR}/`));
     const chunks = [];
     for (const file of files) {
-        const absolute = join(process.cwd(), file);
+        const absolute = join(root, file);
         if (!existsSync(absolute) || !statSync(absolute).isFile()) {
             continue;
         }
@@ -225,14 +231,15 @@ export function collectSourceFiles(diffFiles) {
         }
         changedLinesByPath.set(file.displayPath, nums);
     }
-    const vcsByPath = gitStatusMap(process.cwd());
+    const root = repoRoot();
+    const vcsByPath = gitStatusMap(root);
     for (const file of diffFiles) {
         const kind = vcsByPath.get(file.displayPath);
         if (kind)
             file.vcs = kind; // color the Changes list from the same status map
     }
     const paths = new Set();
-    const gitFiles = git(process.cwd(), ["ls-files", "--cached", "--others", "--exclude-standard"]);
+    const gitFiles = git(root, ["ls-files", "--cached", "--others", "--exclude-standard"]);
     for (const file of gitFiles.split(/\r?\n/)) {
         const path = file.trim();
         if (path && isSourceCandidate(path)) {
@@ -248,7 +255,7 @@ export function collectSourceFiles(diffFiles) {
     let embeddedFiles = 0;
     let embeddedBytes = 0;
     for (const path of Array.from(paths).sort((a, b) => a.localeCompare(b))) {
-        const absolute = join(process.cwd(), path);
+        const absolute = join(root, path);
         const base = {
             path,
             name: basename(path),
@@ -282,7 +289,11 @@ export function collectSourceFiles(diffFiles) {
             }
             continue;
         }
-        if (isLikelyBinary(absolute)) {
+        // A file we already cached as text (same mtime+size) can't have turned binary — skip the binary
+        // sniff (an open+read per file, ~635ms across this repo) on the hot watch path.
+        const cached = sourceContentCache.get(path);
+        const fresh = Boolean(cached && cached.mtimeMs === stats.mtimeMs && cached.size === stats.size);
+        if (!fresh && isLikelyBinary(absolute)) {
             const skippedReason = "binary file";
             sourceFiles.push({ ...base, size: stats.size, signature: hashText(`${path}\0binary\0${stats.size}`), skippedReason });
             continue;
@@ -297,14 +308,18 @@ export function collectSourceFiles(diffFiles) {
             sourceFiles.push({ ...base, size: stats.size, signature: hashText(`${path}\0budget\0${stats.size}`), skippedReason });
             continue;
         }
-        const content = readFileSync(absolute, "utf8");
-        sourceFiles.push({
-            ...base,
-            content,
-            size: stats.size,
-            embedded: true,
-            signature: hashText(`${path}\0${content}`),
-        });
+        let content;
+        let signature;
+        if (fresh) {
+            content = cached.content; // unchanged since last build — skip the read + hash
+            signature = cached.signature;
+        }
+        else {
+            content = readFileSync(absolute, "utf8");
+            signature = hashText(`${path}\0${content}`);
+            sourceContentCache.set(path, { mtimeMs: stats.mtimeMs, size: stats.size, content, signature });
+        }
+        sourceFiles.push({ ...base, content, size: stats.size, embedded: true, signature });
         embeddedFiles += 1;
         embeddedBytes += stats.size;
     }