@happy-nut/monacori 0.1.9 → 0.1.10

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,10 @@ function launchReviewApp(args) {
     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()}`);
     if (args.includes("--foreground")) {
         const result = spawnSync(electronBinary, appArgs, { stdio: "inherit" });
         process.exit(result.status ?? 0);

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/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@happy-nut/monacori",
-  "version": "0.1.9",
+  "version": "0.1.10",
   "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": {