@happy-nut/monacori 0.1.5 → 0.1.7

package/README.md

@@ -1,10 +1,30 @@
 # monacori
 
-**A local desktop diff-review app for AI-generated code changes.** After an AI edits your repo, run `mo` to open a side-by-side diff — read it, comment on it, and send your comments straight to an AI CLI running in the built-in terminal.
+**A local desktop review workspace for AI-generated code changes.**
 
-## Why
+Run `mo` after an AI edits your repository. monacori opens a side-by-side diff, lets you attach line-level questions or change requests, and bundles that feedback back into the AI CLI (command-line interface) session running in the built-in terminal.
 
-A chat log or a "done" claim is a poor way to review what an AI changed. monacori puts the change in front of you as a real diff you can read and annotate — then turns your comments into a prompt you hand right back to `claude` or `codex`, without leaving the app or copy-pasting between windows.
+![monacori reviewing a diff, adding a change request, and targeting the built-in terminal](assets/monacori-demo.gif)
+
+## Why monacori
+
+AI coding tools are fast, but their "done" message is not a review. monacori gives the human reviewer a dedicated control surface for the gap between generated code and trusted code:
+
+- See every changed, added, and untracked file in an IntelliJ-style review sidebar.
+- Review side-by-side diffs with syntax highlighting, changed-line emphasis, and keyboard navigation.
+- Leave questions or change requests directly on the relevant line.
+- Send all reviewer comments, with file paths and code context, into `claude`, `codex`, or another terminal session without copy-paste.
+- Keep all generated review state local, plain, and inspectable under `.monacori/`.
+
+## Workflow
+
+1. Let an AI coding tool make changes in your repository.
+2. Run `mo` from that repository.
+3. Inspect the diff, mark files as viewed, and attach line comments where needed.
+4. Open the built-in terminal and keep your AI CLI session beside the review.
+5. Send the merged questions or change requests back to the session as a focused follow-up prompt.
+
+The result is a tighter review loop: the AI produces changes, the human reviews the actual diff, and the next prompt is grounded in exact file and line context.
 
 ## Install
 
@@ -12,43 +32,55 @@ A chat log or a "done" claim is a poor way to review what an AI changed. monacor
 npm install -g @happy-nut/monacori
 ```
 
-After install, the short command is `mo`. A Homebrew tap (`happy-nut/monacori/monacori`) is also available.
-
-## What you get
+The short command is `mo`.
 
-- **Desktop diff review** — side-by-side diff 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` right inside the app, split into panes.
-- **Comments → session** — annotate any line, then send your comments (bundled with their code context) into a terminal pane as one merged prompt: pick the target pane visually and press Enter.
+## Quick Start
 
-## Quick start
-
-Inside the repository you want to review:
+Inside any Git repository:
 
 ```bash
 mo
 ```
 
-On first run, `mo` creates `.monacori/`, adds it to `.gitignore`, and includes untracked files so new AI-created files show up immediately.
+On first run, `mo` creates `.monacori/`, adds it to `.gitignore`, and includes untracked files so new AI-created files appear immediately.
+
+## Highlights
+
+- **Desktop diff review**: reads the repository directly, refreshes from local Git state, and does not require a web server.
+- **AI handoff comments**: questions and change requests are stored with their file, line, and code context.
+- **Integrated terminal**: keep `claude`, `codex`, or a shell open inside the same window, with split panes when needed.
+- **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 (alias for `monacori open`). |
-| `monacori app` | Launch the desktop review app (same as `mo`). |
+| `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. `--apply-agent-docs` patches `AGENTS.md` / `CLAUDE.md`. |
+| `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
+```
 
-## Repository state
+## Local State
 
-`monacori init` (run automatically by `mo`) creates a git-ignored `.monacori/` directory holding generated diff reviews and local config. Keep it ignored unless your team explicitly wants to commit review 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.
 
-## Design principles
+## Design Principles
 
-- A real diff beats a chat log or a "done" claim.
-- Review, comment, and hand-off live in one window — no copy-paste loop.
-- Generated artifacts are plain static HTML and JSON.
-- No required AI agent, terminal multiplexer, editor, or worktree strategy.
+- Real diffs beat chat summaries.
+- Human review should stay close to the code and the running AI session.
+- The core should be local, inspectable, and agent-agnostic.
+- No required terminal multiplexer, editor plugin, hosted service, or worktree strategy.
 
 ## License
 

package/dist/app-main.js

@@ -71,37 +71,10 @@ ipcMain.handle("monacori:pty-spawn", (_event, size) => {
         if (mainWindow && !mainWindow.isDestroyed())
             mainWindow.webContents.send(channel, payload);
     };
-    // pty output can arrive as many tiny chunks (thousands/sec under fast output). One IPC per chunk floods
-    // the renderer, so coalesce: buffer chunks and flush on a short timer, or immediately once the buffer is
-    // large — bounding both IPC traffic and added latency.
-    let outBuf = "";
-    let flushTimer;
-    const flushOut = () => {
-        flushTimer = undefined;
-        if (!outBuf)
-            return;
-        const data = outBuf;
-        outBuf = "";
-        deliver("monacori:pty-data", { id, data });
-    };
-    t.onData((data) => {
-        outBuf += data;
-        if (outBuf.length >= 64 * 1024) {
-            if (flushTimer)
-                clearTimeout(flushTimer);
-            flushOut();
-        }
-        else if (!flushTimer) {
-            flushTimer = setTimeout(flushOut, 12);
-        }
-    });
-    t.onExit(() => {
-        if (flushTimer)
-            clearTimeout(flushTimer);
-        flushOut(); // deliver any buffered tail before signaling exit
-        terms.delete(id);
-        deliver("monacori:pty-exit", { id });
-    });
+    // Relay pty output to the renderer immediately, one IPC per chunk. (A coalescing buffer was tried as an
+    // optimization but it broke terminal I/O — the shell prompt and echo stopped appearing — so it's removed.)
+    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); });

package/dist/viewer.client.js

@@ -455,6 +455,20 @@ function scheduleDiffScroll(row) {
   });
 }
 
+// Coalesced scrollIntoView for caret/focus moves. Holding an arrow key fires key-repeat faster than a
+// reflow-forcing scrollIntoView can run, so collapse them to one (latest element) per animation frame and
+// use block:nearest (no per-row center-jump). Shared by the tree, source caret, and diff caret.
+var pendingScrollEl = null, scrollElRaf = 0;
+function scheduleScrollIntoView(el) {
+  pendingScrollEl = el || null;
+  if (scrollElRaf) return;
+  scrollElRaf = requestAnimationFrame(function () {
+    scrollElRaf = 0;
+    var e = pendingScrollEl; pendingScrollEl = null;
+    if (e && e.scrollIntoView) { try { e.scrollIntoView({ block: 'nearest', inline: 'nearest' }); } catch (x) {} }
+  });
+}
+
 var setActiveRaf = 0, setActiveScrollPending = true;
 function setActive(index, shouldScroll = true) {
   if (hunkTotal() === 0) return;
@@ -814,10 +828,11 @@ function treeRows() {
 function focusTree(index) {
   const rows = treeRows();
   if (rows.length === 0) return;
+  // Incremental: drop the old focus class and add the new one — no full forEach over every row per keystroke.
+  if (treeFocusIndex >= 0 && treeFocusIndex < rows.length) rows[treeFocusIndex]?.classList.remove('tree-focus');
   treeFocusIndex = Math.max(0, Math.min(rows.length - 1, index));
-  rows.forEach((row, i) => row.classList.toggle('tree-focus', i === treeFocusIndex));
   const el = rows[treeFocusIndex];
-  if (el) el.scrollIntoView({ block: 'nearest' });
+  if (el) { el.classList.add('tree-focus'); scheduleScrollIntoView(el); }
 }
 
 function clearTreeFocus() {
@@ -1454,10 +1469,7 @@ function setDiffCursor(path, side, rowIndex, column, reveal) {
   diffSelectionAnchor = null; // any direct caret placement (click/F7/Cmd-arrow) drops the selection; Shift+Arrow re-sets it
   renderDiffCaret();
   applyDiffSelection();
-  if (reveal) {
-    var r = diffRowAt(wrapper, side, ri);
-    if (r && r.scrollIntoView) requestAnimationFrame(function () { try { r.scrollIntoView({ block: 'nearest' }); } catch (e) {} });
-  }
+  if (reveal) scheduleScrollIntoView(diffRowAt(wrapper, side, ri));
   recordNav(navEntryOf('diff'));
 }
 function navEntryOf(kind) {
@@ -2138,7 +2150,12 @@ refreshComments();
       // 2+ panes: dim every pane but the active one (no border, just a clean focus cue). A lone pane stays full.
       q.el.classList.toggle('is-inactive', panes.length > 1 && q !== p);
     });
-    if (p) requestAnimationFrame(function () { try { p.term.focus(); } catch (e) {} });
+    if (p) requestAnimationFrame(function () {
+      try {
+        if (p.labelEl && p.labelEl.getAttribute('contenteditable') === 'true') return;
+        p.term.focus();
+      } catch (e) {}
+    });
   }
 
   function makePane() {
@@ -2918,11 +2935,7 @@ function setSourceCursor(path, lineIndex, column, shouldReveal = false, targetLi
     const shouldSwitch = !viewer || viewer.dataset.openPath !== path || viewer.classList.contains('hidden');
     openSourceFile(path, shouldSwitch);
   }
-  if (shouldReveal) {
-    requestAnimationFrame(() => {
-      document.querySelector('.source-row.cursor-line')?.scrollIntoView({ block: 'center' });
-    });
-  }
+  if (shouldReveal) scheduleScrollIntoView(document.querySelector('.source-row.cursor-line'));
   recordNav(navEntryOf('source'));
 }
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@happy-nut/monacori",
-  "version": "0.1.5",
+  "version": "0.1.7",
   "description": "Validation control plane for AI-generated code changes.",
   "type": "module",
   "repository": {