@vincemakes/kiso-code 0.1.14 → 0.1.16

package/dist/diff.js

@@ -0,0 +1,122 @@
+/**
+ * v2e — the diff renderer: edit/write changes as inline ± lines, zero
+ * dependencies, no syntax highlighting (the spec's scope line). Shown at
+ * the approval moment ONLY — the frozen summary stays one line (v2d's
+ * anti-leak principle), /last has the full data.
+ *
+ * edit_file diffs IN PLACE (the search→replace windows are known — no
+ * general engine needed); write_file does a row-level LCS over the old
+ * file (small files are the target). Context: 2 rows each side. The
+ * RENDERER truncates (18 head + 18 tail + "… N lines"); the stats come
+ * from the full diff.
+ */
+/** A line-level LCS diff — the classic two-row DP, ~small inputs. */
+function lcsDiff(oldLines, newLines) {
+    const n = oldLines.length;
+    const m = newLines.length;
+    const dp = Array.from({ length: n + 1 }, () => new Array(m + 1).fill(0));
+    for (let i = n - 1; i >= 0; i -= 1) {
+        for (let j = m - 1; j >= 0; j -= 1) {
+            dp[i][j] = oldLines[i] === newLines[j] ? dp[i + 1][j + 1] + 1 : Math.max(dp[i + 1][j], dp[i][j + 1]);
+        }
+    }
+    const out = [];
+    let i = 0;
+    let j = 0;
+    while (i < n && j < m) {
+        if (oldLines[i] === newLines[j]) {
+            out.push({ kind: " ", text: oldLines[i] });
+            i += 1;
+            j += 1;
+        }
+        else if (dp[i + 1][j] >= dp[i][j + 1]) {
+            out.push({ kind: "-", text: oldLines[i] });
+            i += 1;
+        }
+        else {
+            out.push({ kind: "+", text: newLines[j] });
+            j += 1;
+        }
+    }
+    while (i < n) {
+        out.push({ kind: "-", text: oldLines[i] });
+        i += 1;
+    }
+    while (j < m) {
+        out.push({ kind: "+", text: newLines[j] });
+        j += 1;
+    }
+    return out;
+}
+/** Keep 2 context rows around each change — the unified-style window. */
+function withContext(diff) {
+    const out = [];
+    let lastAdded = -10;
+    for (let k = 0; k < diff.length; k += 1) {
+        if (diff[k].kind === " ")
+            continue;
+        const from = Math.max(0, k - 2);
+        const to = Math.min(diff.length - 1, k + 2);
+        for (let c = from; c <= to; c += 1) {
+            if (c > lastAdded) {
+                out.push(diff[c]);
+                lastAdded = c;
+            }
+        }
+        lastAdded = to;
+    }
+    return out;
+}
+const MAX_DIFF_LINES = 40; // the RENDERED cap
+const TRUNCATE_KEEP = 18;
+/** The RENDERER's truncation: head + "… N lines (/last for full)" + tail. */
+export function truncateDiff(diff) {
+    if (diff.length <= MAX_DIFF_LINES)
+        return diff;
+    const omitted = diff.length - 2 * TRUNCATE_KEEP;
+    return [
+        ...diff.slice(0, TRUNCATE_KEEP),
+        { kind: " ", text: `… ${omitted} lines (/last for full)` },
+        ...diff.slice(diff.length - TRUNCATE_KEEP),
+    ];
+}
+function stats(diff) {
+    let added = 0;
+    let removed = 0;
+    for (const d of diff) {
+        if (d.kind === "+")
+            added += 1;
+        else if (d.kind === "-")
+            removed += 1;
+    }
+    return { added, removed };
+}
+/** edit_file: the search→replace windows replace in place — the changed
+ *  region is KNOWN, so the diff is the old window vs the new window,
+ *  context from the surrounding file. */
+export function editFileDiff(oldContent, search, replace) {
+    const oldLines = oldContent.split("\n");
+    const searchLines = search.split("\n");
+    const replaceLines = replace.split("\n");
+    // Locate the search window (the first occurrence — the edit tool's own
+    // semantics); no occurrence → the whole file is the old side.
+    let at = -1;
+    for (let i = 0; i + searchLines.length <= oldLines.length; i += 1) {
+        if (oldLines.slice(i, i + searchLines.length).join("\n") === search) {
+            at = i;
+            break;
+        }
+    }
+    const lines = at < 0 ? withContext(lcsDiff(oldLines, replaceLines)) : withContext(lcsDiff(oldLines, [...oldLines.slice(0, at), ...replaceLines, ...oldLines.slice(at + searchLines.length)]));
+    return { lines, ...stats(lines) };
+}
+/** write_file: a new file is all +; an existing file diffs row-level
+ *  against its old content. */
+export function writeFileDiff(oldContent, newContent) {
+    if (oldContent === null) {
+        const lines = newContent.split("\n").map((text) => ({ kind: "+", text }));
+        return { lines, added: lines.length, removed: 0 };
+    }
+    const lines = withContext(lcsDiff(oldContent.split("\n"), newContent.split("\n")));
+    return { lines, ...stats(lines) };
+}

package/dist/dock.d.ts

@@ -27,7 +27,11 @@ export declare class Dock {
         line: string;
         cursor: number;
     }, prompt: string): void;
-    /** Enter docked mode: DECSTBM the scroll region, draw the chrome. A
+    /** Enter docked mode: draw the chrome. #13 (P1): the DECSTBM scroll
+     *  region is GONE — v2d-B (ADR-0040): the body uses plain LF scrolling
+     *  so frozen lines enter the native scrollback deterministically
+     *  (region-scrolled lines are terminal-dependent — some terminals drop
+     *  them). The dock rows are redrawn by the body after every scroll. A
      *  TTY without a real window size (rows < 4) stays in the v2a line
      *  mode — the bottom three rows need room to exist. */
     enter(): void;
@@ -36,21 +40,15 @@ export declare class Dock {
      *  from main's finally on EVERY exit path (kill -9 excepted — README:
      *  `reset` saves it). */
     exit(): void;
-    /** SIGWINCH: recompute the region, redraw the chrome. */
+    /** SIGWINCH: recompute the size, redraw the chrome. */
     onResize(): void;
-    /** Body output: position the cursor inside the scroll region at the
-     *  body's tracked position, write, and hand the cursor back to the
-     *  input line's EDIT position. The row/col tracking is approximate for
-     *  width-wrapped and wide-char lines (documented) — the region clamp
-     *  keeps the bottom rows safe regardless.
-     *
-     *  The edit-position return is a correctness requirement, not
-     *  cosmetics: readline tracks its cursor internally and NEVER
-     *  re-syncs after an external move — a body write that left the
-     *  cursor at column 1 made the next keystroke overwrite the prompt
-     *  (probe-confirmed; the dock's redraw self-repaired ~200ms later,
-     *  which read the user as cursor drift). */
-    writeBody(text: string): void;
+    /** The input line's edit column — prompt width + cursor + 1. The
+     *  dock's redraw and the body's cursor return both end here, so the
+     *  ACTUAL cursor always equals what the editor tracks. The width is
+     *  DISPLAY width (the editor's cursor column is already width-based —
+     *  the CJK drift root cause, editor.ts). v2d: public — the Body's
+     *  render loop ends at this column. */
+    editCol(): number;
     /** The status bar's base text (usage, ctx, session, …). */
     setStatus(text: string): void;
     /** The live tail — the spinner glyph or "running <tool> Ns". */

package/dist/dock.js

@@ -41,7 +41,11 @@ export class Dock {
         this.#inputState = state;
         this.#inputPrompt = prompt;
     }
-    /** Enter docked mode: DECSTBM the scroll region, draw the chrome. A
+    /** Enter docked mode: draw the chrome. #13 (P1): the DECSTBM scroll
+     *  region is GONE — v2d-B (ADR-0040): the body uses plain LF scrolling
+     *  so frozen lines enter the native scrollback deterministically
+     *  (region-scrolled lines are terminal-dependent — some terminals drop
+     *  them). The dock rows are redrawn by the body after every scroll. A
      *  TTY without a real window size (rows < 4) stays in the v2a line
      *  mode — the bottom three rows need room to exist. */
     enter() {
@@ -53,7 +57,6 @@ export class Dock {
         this.#width = process.stdout.columns ?? 80;
         this.#bodyRow = 1;
         this.#bodyCol = 1;
-        process.stdout.write(`\x1b[1;${this.#height - 3}r`); // scroll region: top .. H-3
         this.redraw();
         this.#resizeHandler = () => this.onResize();
         process.stdout.on("resize", this.#resizeHandler);
@@ -77,52 +80,23 @@ export class Dock {
         }
         process.stdout.write(`\x1b[${H};1H`);
     }
-    /** SIGWINCH: recompute the region, redraw the chrome. */
+    /** SIGWINCH: recompute the size, redraw the chrome. */
     onResize() {
         if (!this.#active)
             return;
         this.#height = process.stdout.rows ?? this.#height;
         this.#width = process.stdout.columns ?? this.#width;
-        process.stdout.write(`\x1b[1;${this.#height - 3}r`);
         this.redraw();
     }
-    /** Body output: position the cursor inside the scroll region at the
-     *  body's tracked position, write, and hand the cursor back to the
-     *  input line's EDIT position. The row/col tracking is approximate for
-     *  width-wrapped and wide-char lines (documented) — the region clamp
-     *  keeps the bottom rows safe regardless.
-     *
-     *  The edit-position return is a correctness requirement, not
-     *  cosmetics: readline tracks its cursor internally and NEVER
-     *  re-syncs after an external move — a body write that left the
-     *  cursor at column 1 made the next keystroke overwrite the prompt
-     *  (probe-confirmed; the dock's redraw self-repaired ~200ms later,
-     *  which read the user as cursor drift). */
-    writeBody(text) {
-        if (!this.#active) {
-            process.stdout.write(text);
-            return;
-        }
-        const row = Math.min(this.#bodyRow, this.#height - 3);
-        const col = this.#bodyCol > this.#width ? this.#width : this.#bodyCol;
-        process.stdout.write(`\x1b[${row};${col}H`);
-        process.stdout.write(text);
-        for (const ch of text) {
-            if (ch === "\n") {
-                this.#bodyRow += 1;
-                this.#bodyCol = 1;
-            }
-            else {
-                this.#bodyCol += 1;
-            }
-        }
-        process.stdout.write(`\x1b[${this.#height};${this.#inputCol()}H`); // back to the edit position
-    }
     /** The input line's edit column — prompt width + cursor + 1. The
      *  dock's redraw and the body's cursor return both end here, so the
      *  ACTUAL cursor always equals what the editor tracks. The width is
      *  DISPLAY width (the editor's cursor column is already width-based —
-     *  the CJK drift root cause, editor.ts). */
+     *  the CJK drift root cause, editor.ts). v2d: public — the Body's
+     *  render loop ends at this column. */
+    editCol() {
+        return this.#inputCol();
+    }
     #inputCol() {
         const inp = this.#inputState();
         const promptWidth = displayWidth(this.#inputPrompt.replace(/\x1b\[[0-9;]*m/g, ""));