@happy-nut/monacori 0.1.9 → 0.1.11

package/README.md

@@ -71,6 +71,53 @@ 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
+checkout — local edits won't appear until you build and run locally.
+
+Run your checkout directly (builds, then launches in the foreground with DevTools open):
+
+```bash
+npm run dev
+```
+
+This reviews the monacori repo itself. To point a local build at another project:
+
+```bash
+MONACORI_DEV=1 node /path/to/monacori/bin/monacori.js --foreground
+```
+
+**Which build is running?** A dev build titles its window `monacori (dev)` and opens DevTools, and
+every launch prints its app path — so a local checkout is distinguishable from the installed package
+even when their version numbers match:
+
+```text
+monacori: launching /…/repos/monacori/dist/app-main.js                       # local checkout
+monacori: launching /…/lib/node_modules/@happy-nut/monacori/dist/app-main.js  # installed package
+```
+
+Prefer the `mo` command pointed at your checkout? `npm link` once, then rebuild after each change:
+
+```bash
+npm link                              # global `mo` now runs this checkout
+npm run build                         # rebuild dist/ after editing src/
+npm unlink -g @happy-nut/monacori     # restore the published `mo`
+```
+
+`src/viewer.client.js` and `src/viewer.css` are copied (not compiled) into `dist/` by the build, so
+re-run `npm run build` (or `npm run dev`) after editing them.
+
+### Tests
+
+```bash
+npm test
+```
+
+`npm test` builds, then runs the jsdom regression suite (`test/*.test.mjs`) against the built `dist/`.
+It guards the core user flows end to end — see [test/USER_FLOWS.md](test/USER_FLOWS.md) — and the same
+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.

package/dist/app-main.js

@@ -4,7 +4,13 @@ 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 { 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
+// the globally-installed package (their version numbers can be identical; the path is the tell).
+const DEV_BUILD = process.env.MONACORI_DEV === "1";
+const APP_TITLE = DEV_BUILD ? "monacori (dev)" : "monacori";
 const FLOW_DIR = ".monacori";
 const REVIEW_FILE = "app-review.html";
 const WATCH_INTERVAL_MS = 1000;
@@ -61,7 +67,7 @@ ipcMain.handle("monacori:pty-spawn", (_event, size) => {
         cols: size?.cols ?? 80,
         rows: size?.rows ?? 24,
         cwd: options.root,
-        env: process.env,
+        env: sanitizeTerminalEnv(process.env),
     });
     terms.set(id, t);
     // mainWindow?. only guards null, NOT a *destroyed* window — sending to a closed window's webContents
@@ -137,6 +143,9 @@ if (!existsSync(options.root)) {
     throw new Error(`Repository path does not exist: ${options.root}`);
 }
 app.whenReady().then(async () => {
+    // Foreground (`npm run dev` / `mo --foreground`) surfaces this in the terminal; detached `mo` drops
+    // it. Either way the path disambiguates a local checkout from the installed package.
+    console.error(`[monacori] ${DEV_BUILD ? "DEV build" : "build"} — ${app.getAppPath()} (electron ${process.versions.electron})`);
     process.chdir(options.root);
     mkdirSync(FLOW_DIR, { recursive: true });
     // Keep the standard Edit/Window roles so Cmd+C/V/X/A (copy comments into prompts) and Cmd+Q work.
@@ -208,7 +217,7 @@ app.whenReady().then(async () => {
         minWidth: 960,
         minHeight: 640,
         show: false,
-        title: "monacori",
+        title: APP_TITLE,
         icon: iconPath,
         backgroundColor: "#2b2b2b",
         autoHideMenuBar: true,
@@ -221,7 +230,11 @@ app.whenReady().then(async () => {
         },
     });
     mainWindow.webContents.setWindowOpenHandler(() => ({ action: "deny" }));
-    mainWindow.once("ready-to-show", () => mainWindow?.show());
+    mainWindow.once("ready-to-show", () => {
+        mainWindow?.show();
+        if (DEV_BUILD)
+            mainWindow?.webContents.openDevTools({ mode: "detach" });
+    });
     // 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.
@@ -289,7 +302,7 @@ function writeReviewFile(input) {
         staged: input.staged,
         includeUntracked: input.includeUntracked,
         context: input.context,
-        title: "monacori",
+        title: APP_TITLE,
         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

package/dist/commands.js

@@ -124,6 +124,12 @@ function launchReviewApp(args) {
     if (args.includes("--no-watch"))
         appArgs.push("--no-watch");
     const electronBinary = resolveElectronBinary();
+    // 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 — the shell
+    // should be clean, not littered with our internal path.
+    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);

package/dist/diff.js

@@ -3,8 +3,9 @@ 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";
 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 +17,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 +26,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 +226,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 +250,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),

package/dist/git.d.ts

@@ -1,4 +1,5 @@
 import type { GitSnapshot } from "./types.js";
 export declare function isGitRepository(root: string): boolean;
 export declare function git(root: string, args: string[]): string;
+export declare function repoRoot(cwd?: string): string;
 export declare function readGitSnapshot(root: string): GitSnapshot;

package/dist/git.js

@@ -13,6 +13,15 @@ export function git(root, args) {
     }
     return (result.stdout ?? "").trim();
 }
+// Resolve the repository root. `git diff` and `git ls-files` print paths relative to it, and the
+// desktop tree shows them as-is — so every filesystem read of those paths must resolve against the
+// SAME root, not process.cwd(). When `mo` runs from a monorepo subdirectory (cwd != root), joining a
+// repo-root-relative path onto cwd points at a file that doesn't exist, which surfaced as a diff with
+// no source preview ("file is not present in the working tree"). Falls back to cwd outside a repo.
+export function repoRoot(cwd = process.cwd()) {
+    const top = git(cwd, ["rev-parse", "--show-toplevel"]);
+    return top || cwd;
+}
 export function readGitSnapshot(root) {
     return {
         branch: git(root, ["branch", "--show-current"]),

package/dist/util.d.ts

@@ -16,3 +16,6 @@ export declare function jsonForScript(value: unknown): string;
 export declare function escapeAttr(value: string): string;
 export declare function formatBytes(bytes: number): string;
 export declare function listRecentFiles(dir: string, limit: number): string[];
+export declare function sanitizeTerminalEnv(env: NodeJS.ProcessEnv): {
+    [key: string]: string;
+};

package/dist/util.js

@@ -142,3 +142,21 @@ export function listRecentFiles(dir, limit) {
         .sort((a, b) => statSync(b).mtimeMs - statSync(a).mtimeMs)
         .slice(0, limit);
 }
+// The integrated terminal should behave like the user's own login shell — not like a child of however
+// monacori was launched. When started through npm (`npm run dev`, or a global install run via an npm
+// shim), npm injects npm_config_* / npm_lifecycle_* / npm_package_* vars into our process. Inheriting
+// them into the pty leaks our run's npm config into the user's shell and, with nvm, triggers:
+//   "nvm is not compatible with the npm_config_prefix environment variable …"
+// Strip every npm_*-injected var (npm_config_prefix is the one nvm rejects) and drop undefined holes,
+// so the shell starts clean. Returns a fresh object; the input is not mutated.
+export function sanitizeTerminalEnv(env) {
+    const out = {};
+    for (const [key, value] of Object.entries(env)) {
+        if (value === undefined)
+            continue;
+        if (key.startsWith("npm_"))
+            continue;
+        out[key] = value;
+    }
+    return out;
+}

package/dist/viewer.client.js

@@ -124,7 +124,16 @@ var I18N = JSON.parse(document.getElementById('i18n-data')?.textContent || '{}')
 // app restart; file:// localStorage doesn't); browser/serve falls back to localStorage. persistRead
 // returns the bridge value (native) if present, else undefined so callers parse localStorage themselves.
 function persistRead(key) {
-  try { if (window.monacoriSettings && window.monacoriSettings.all && key in window.monacoriSettings.all) return window.monacoriSettings.all[key]; } catch (e) {}
+  // window.monacoriSettings.all crosses Electron's contextBridge, which DEEP-FREEZES every value it
+  // exposes. Returning that frozen object/array directly breaks callers that mutate the result —
+  // reviewComments.push(...) and mergePrompts[kind]=... both throw "object is not extensible". Hand
+  // back a mutable deep copy so the persisted snapshot is a starting point, not a locked one.
+  try {
+    if (window.monacoriSettings && window.monacoriSettings.all && key in window.monacoriSettings.all) {
+      var v = window.monacoriSettings.all[key];
+      return v && typeof v === 'object' ? JSON.parse(JSON.stringify(v)) : v;
+    }
+  } catch (e) {}
   return undefined;
 }
 function persistSave(key, value) {
@@ -1847,7 +1856,7 @@ function refreshComments() {
   if (composerState) {
     var composerFocusTries = 0;
     var tryFocusComposer = function () {
-      var ta = document.querySelector('.mc-composer .mc-input');
+      var ta = activeComposerInput();
       if (!ta) return true;                            // composer gone — stop retrying
       if (document.activeElement === ta) return true;  // already focused — done
       try { ta.focus({ preventScroll: true }); } catch (e) { try { ta.focus(); } catch (e2) {} }
@@ -1879,9 +1888,24 @@ function closeComposer() {
   composerState = null;
   refreshComments();
 }
+// The composer is injected into BOTH the diff and source views (refreshComments renders comments in
+// each), but only one view is on screen at a time — the other lives inside a `.hidden` container with
+// its own, empty textarea. Pick the textarea in the *visible* view so save/auto-focus never grab the
+// off-screen duplicate. This was the "Comment doesn't save" bug: clicking Save ran
+// document.querySelector('.mc-composer .mc-input'), which returns the hidden diff-view textarea first
+// (it precedes #source-viewer in the DOM), so addComment got its empty value and bailed.
+function activeComposerInput() {
+  var inputs = document.querySelectorAll('.mc-composer .mc-input');
+  for (var i = 0; i < inputs.length; i++) {
+    if (inputs[i].closest('#diff-view') && !isDiffViewVisible()) continue;
+    if (inputs[i].closest('#source-viewer') && !isSourceViewerVisible()) continue;
+    return inputs[i];
+  }
+  return inputs[0] || null;
+}
 function saveComposer(ta) {
   if (!composerState) return;
-  var box = ta || document.querySelector('.mc-composer .mc-input');
+  var box = ta || activeComposerInput();
   if (!box) return;
   addComment(composerState.kind, composerState.path, composerState.line, composerState.code, box.value);
   composerState = null;

package/dist/viewer.css

@@ -532,6 +532,9 @@ summary.tree-focus { background: var(--bg); }
    file's diff body extends all the way down. */
 #diff-view:not(.hidden) { flex: 1 1 auto; display: flex; flex-direction: column; min-height: 0; }
 #diff-view .diff2html-container { flex: 1 1 auto; display: flex; flex-direction: column; min-height: 0; }
+/* Source view mirrors the diff view: fill the content column so the source-body (its last child, after
+   the tabs + toolbar) reaches the bottom even for short files, instead of floating at the top. */
+#source-viewer:not(.hidden) { flex: 1 1 auto; display: flex; flex-direction: column; min-height: 0; }
 .diff2html-container .d2h-wrapper { flex: 1 1 auto; display: flex; flex-direction: column; }
 .diff2html-container .d2h-file-wrapper:last-child { flex: 1 1 auto; }
 .diff2html-container .d2h-file-wrapper:last-child .d2h-files-diff { height: 100%; }
@@ -639,10 +642,13 @@ h1 { margin: 0; font-size: 18px; }
 .source-tab-close:hover { background: var(--line); color: var(--text); }
 .source-body {
   border: 1px solid var(--border);
-  border-radius: 8px;
   overflow: auto;
   background: var(--panel);
   user-select: text;
+  /* Square edges flush to the chrome (no rounded corners), and fill the content column so a short
+     file still reaches the bottom instead of floating at the top — IntelliJ-style. */
+  flex: 1 1 auto;
+  min-height: 0;
 }
 /* Extend the line-number gutter (and its divider) to the bottom of the panel so it never stops at the
    last line with an empty strip + cut-off border below it — one continuous gutter. The .num cell is 58px

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@happy-nut/monacori",
-  "version": "0.1.9",
+  "version": "0.1.11",
   "description": "Validation control plane for AI-generated code changes.",
   "type": "module",
   "repository": {
@@ -29,10 +29,13 @@
   },
   "scripts": {
     "build": "tsc -p tsconfig.json && node scripts/copy-viewer-assets.mjs",
+    "dev": "npm run build && MONACORI_DEV=1 node bin/monacori.js --foreground",
     "icon": "node scripts/gen-icon.mjs",
     "postinstall": "node scripts/patch-electron-name.mjs && node scripts/fix-pty-spawn-helper.mjs",
     "prepare": "npm run build",
-    "smoke": "npm run build && node dist/cli.js --help"
+    "smoke": "npm run build && node dist/cli.js --help",
+    "pretest": "npm run build",
+    "test": "node --test test/*.test.mjs"
   },
   "keywords": [
     "ai",
@@ -45,6 +48,7 @@
   "license": "MIT",
   "devDependencies": {
     "@types/node": "^22.15.21",
+    "jsdom": "^29.1.1",
     "typescript": "^5.8.3"
   },
   "engines": {