@happy-nut/monacori 0.1.0 → 0.1.2

package/README.md

@@ -35,7 +35,7 @@ npm install -g @happy-nut/monacori
 After installation, the short command is:
 
 ```bash
-dg
+mo
 ```
 
 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:
@@ -59,11 +59,11 @@ npm link
 Inside the repository you want to validate:
 
 ```bash
-dg
+mo
 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.
+`mo` 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.
 
@@ -76,7 +76,7 @@ monacori check -- npm test
 For live diff review while an AI is still editing:
 
 ```bash
-dg
+mo
 ```
 
 ## Diff Review
@@ -100,7 +100,7 @@ The browser artifact path is still available through `monacori diff`. Add `--wat
 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.
+Opens the local desktop review app for the current directory. `mo` 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.
 
 ```bash
 monacori check [--include-untracked] [--staged] [--base HEAD] [--context 12] [--open] [--no-verify] [--no-diff] [-- <command>]
@@ -130,7 +130,7 @@ Runs configured verification commands and stores the log in `.monacori/logs/`. E
 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.
+Launches the local desktop review app. `mo`, `monacori open`, and `monacori review` are aliases. Prefer `mo` for normal use.
 
 ```bash
 monacori diff [--base HEAD] [--staged] [--include-untracked] [--context 12] [--output review.html] [--open] [--watch] [--port 0]

package/dist/app-main.js

@@ -1,13 +1,25 @@
 import { existsSync, mkdirSync, writeFileSync } from "node:fs";
 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";
 const FLOW_DIR = ".monacori";
 const REVIEW_FILE = "app-review.html";
 const WATCH_INTERVAL_MS = 1000;
 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);
 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,7 +31,38 @@ 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" });
+    // Claim Cmd/Ctrl+Shift+/ ("?") and Cmd/Ctrl+Shift+. (">") as menu accelerators so macOS does not
+    // swallow Cmd+? for its Help search; clicking routes to the renderer's merged comment views.
+    menuTemplate.push({
+        label: "Review",
+        submenu: [
+            { label: "All questions", accelerator: "CommandOrControl+Shift+/", click: () => sendMerged("q") },
+            { label: "All change requests", accelerator: "CommandOrControl+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();
+                },
+            },
+        ],
+    });
+    menuTemplate.push({ role: "windowMenu" });
+    Menu.setApplicationMenu(Menu.buildFromTemplate(menuTemplate));
     const appIcon = nativeImage.createFromPath(iconPath);
     if (process.platform === "darwin" && app.dock && !appIcon.isEmpty()) {
         app.dock.setIcon(appIcon);
@@ -37,6 +80,7 @@ app.whenReady().then(async () => {
         backgroundColor: "#2b2b2b",
         autoHideMenuBar: true,
         webPreferences: {
+            preload: preloadPath,
             contextIsolation: true,
             nodeIntegration: false,
             sandbox: true,
@@ -83,8 +127,12 @@ 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)
     });
     writeFileSync(reviewPath(), build.html);
+    currentBodies = build.lazyBodies ?? [];
+    currentSourceData = build.lazySourceData ?? "[]";
     return { signature: build.signature };
 }
 function reviewPath() {
@@ -100,6 +148,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,4 @@
+export declare function readViewerAsset(name: string): string;
+export declare function diff2HtmlCss(): string;
+export declare function diffCss(): string;
+export declare function diffScript(): string;

package/dist/assets.js

@@ -0,0 +1,30 @@
+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");
+}

package/dist/build.d.ts

@@ -0,0 +1,12 @@
+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;
+}): DiffReviewBuild;

package/dist/build.js

@@ -0,0 +1,74 @@
+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). Gated by size: only big reviews lazy-LOAD — small ones embed (no IPC round-trips, no
+    // "Loading source…" flash). The transport opts in (serve/Electron pass lazyLoad:true); standalone has
+    // no server. A big standalone review still lazy-materializes from embedded islands (Phase 1).
+    const big = shouldLazyRender(files.length, totalLines);
+    const lazyLoad = (input.lazyLoad ?? false) && big;
+    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),
+        signature,
+        generatedAt,
+    });
+    return {
+        html,
+        files: files.length,
+        hunks,
+        signature,
+        generatedAt,
+        lazyBodies: diffSplit.bodies,
+        lazySourceData: lazyLoad ? JSON.stringify(sourceFiles) : undefined,
+    };
+}

package/dist/cli.d.ts

@@ -1,34 +1,6 @@
 #!/usr/bin/env node
-export type HttpSendRequest = {
-    method: string;
-    url: string;
-    headers: Record<string, string>;
-    body?: string;
-};
-export type HttpSendResult = {
-    ok: boolean;
-    status?: number;
-    statusText?: string;
-    headers?: Record<string, string>;
-    body?: string;
-    error?: string;
-    durationMs: number;
-};
-type DiffReviewBuild = {
-    html: string;
-    files: number;
-    hunks: number;
-    signature: string;
-    generatedAt: string;
-};
-export declare function main(): void;
-export declare function buildDiffReview(input: {
-    base?: string;
-    staged: boolean;
-    includeUntracked: boolean;
-    context: number;
-    title: string;
-    watch?: boolean;
-}): DiffReviewBuild;
-export declare function performHttpRequest(request: HttpSendRequest): Promise<HttpSendResult>;
-export {};
+import { main } from "./commands.js";
+export { main };
+export { buildDiffReview } from "./build.js";
+export { performHttpRequest } from "./server.js";
+export type { HttpSendRequest, HttpSendResult } from "./types.js";