@giovannijecha/jecode 0.7.2 → 0.7.4

package/dist/ui/diff.js

@@ -8,24 +8,37 @@
  * Above this many cells the table stops being worth building.
  *
  * The diff is quadratic in the two line counts, and it is drawn between two
- * keystrokes. Past the ceiling the honest answer is the coarse one — all of
- * the old, then all of the new — rather than a frame the user waits for.
+ * keystrokes. Common edges are removed before this limit is applied, so a
+ * local edit in a large file stays local. If the changed middle itself crosses
+ * the ceiling, the honest answer is the coarse one rather than a frame the
+ * user waits for.
  */
 const CEILING = 250_000;
 export function diff(before, after) {
     const a = lines(before);
     const b = lines(after);
-    if (a.length * b.length > CEILING) {
-        return [...a.map(del), ...b.map(add)];
+    const prefix = commonPrefix(a, b);
+    const suffix = commonSuffix(a, b, prefix);
+    const aEnd = a.length - suffix;
+    const bEnd = b.length - suffix;
+    const middleA = a.slice(prefix, aEnd);
+    const middleB = b.slice(prefix, bEnd);
+    const rows = a.slice(0, prefix).map(keep);
+    if (middleA.length * middleB.length > CEILING) {
+        for (const line of middleA)
+            rows.push(del(line));
+        for (const line of middleB)
+            rows.push(add(line));
+        appendSuffix(rows, a, aEnd);
+        return rows;
     }
-    const table = common(a, b);
-    const rows = [];
+    const table = common(middleA, middleB);
     let i = 0;
     let j = 0;
-    const width = b.length + 1;
-    while (i < a.length && j < b.length) {
-        if (a[i] === b[j]) {
-            rows.push({ kind: "keep", text: a[i] });
+    const width = middleB.length + 1;
+    while (i < middleA.length && j < middleB.length) {
+        if (middleA[i] === middleB[j]) {
+            rows.push(keep(middleA[i]));
             i++;
             j++;
             continue;
@@ -33,20 +46,39 @@ export function diff(before, after) {
         // Deletions first on a tie, so a replaced line reads old-then-new — the
         // order the eye expects, and the order every other diff prints.
         if (table[(i + 1) * width + j] >= table[i * width + j + 1]) {
-            rows.push(del(a[i]));
+            rows.push(del(middleA[i]));
             i++;
         }
         else {
-            rows.push(add(b[j]));
+            rows.push(add(middleB[j]));
             j++;
         }
     }
-    while (i < a.length)
-        rows.push(del(a[i++]));
-    while (j < b.length)
-        rows.push(add(b[j++]));
+    while (i < middleA.length)
+        rows.push(del(middleA[i++]));
+    while (j < middleB.length)
+        rows.push(add(middleB[j++]));
+    appendSuffix(rows, a, aEnd);
     return rows;
 }
+function commonPrefix(a, b) {
+    const limit = Math.min(a.length, b.length);
+    let length = 0;
+    while (length < limit && a[length] === b[length])
+        length++;
+    return length;
+}
+function commonSuffix(a, b, prefix) {
+    const limit = Math.min(a.length, b.length) - prefix;
+    let length = 0;
+    while (length < limit && a[a.length - length - 1] === b[b.length - length - 1])
+        length++;
+    return length;
+}
+function appendSuffix(rows, source, start) {
+    for (let index = start; index < source.length; index++)
+        rows.push(keep(source[index]));
+}
 /**
  * Drop the unchanged stretches, keeping `context` rows either side.
  *
@@ -109,3 +141,6 @@ function add(text) {
 function del(text) {
     return { kind: "del", text };
 }
+function keep(text) {
+    return { kind: "keep", text };
+}

package/dist/ui/render.js

@@ -1,7 +1,7 @@
 // Composing a terminal row out of styled segments. Pure: every function here
 // returns a string or rows of segments, none of them write anywhere.
 import { terminalText } from "./terminal-text.js";
-import { elide, textWidth, wrapText } from "./width.js";
+import { elide, splitByCells, textWidth, wrapText } from "./width.js";
 // Built rather than written literally: a raw escape byte in the source is
 // invisible in a diff and in a code review, which is how they survive.
 const ESC = String.fromCharCode(27);
@@ -166,13 +166,13 @@ export function flow(segs, max, continuation = []) {
     let used = 0;
     let pending;
     const room = () => Math.max(1, max - (rows.length === 0 ? 0 : lead));
-    const add = (tok) => {
+    const add = (tok, width = textWidth(tok.text)) => {
         const last = current[current.length - 1];
         if (last !== undefined && sameStyle(last, tok.seg))
             last.text += tok.text;
         else
             current.push({ ...tok.seg, text: tok.text });
-        used += textWidth(tok.text);
+        used += width;
     };
     const flush = () => {
         rows.push(rows.length === 0 ? current : [...continuation.map(copy), ...current]);
@@ -191,39 +191,31 @@ export function flow(segs, max, continuation = []) {
             continue;
         }
         const space = pending === undefined ? 0 : textWidth(pending.text);
-        let word = tok.text;
-        if (used + space + textWidth(word) > room() && current.length > 0)
+        const wordWidth = textWidth(tok.text);
+        if (used + space + wordWidth > room() && current.length > 0)
             flush();
         else if (pending !== undefined) {
-            add(pending);
+            add(pending, space);
             pending = undefined;
         }
         // A word wider than any row is spent across rows: with autowrap off, what
         // overflows is not ugly, it is gone.
-        while (textWidth(word) > room() - used) {
-            const head = clipTo(word, room() - used);
-            if (head === "")
-                break;
-            add({ ...tok, text: head });
-            word = word.slice(head.length);
-            flush();
+        if (wordWidth > room() - used) {
+            const chunks = splitByCells(tok.text, room() - used, Math.max(1, max - lead));
+            for (const [index, chunk] of chunks.entries()) {
+                add({ ...tok, text: chunk.text }, chunk.width);
+                if (index + 1 < chunks.length)
+                    flush();
+            }
+            continue;
         }
-        if (word !== "")
-            add({ ...tok, text: word });
+        if (tok.text !== "")
+            add(tok, wordWidth);
     }
     if (current.length > 0 || rows.length === 0)
         flush();
     return rows;
 }
-function clipTo(text, cols) {
-    let out = "";
-    for (const char of text) {
-        if (textWidth(out + char) > cols)
-            break;
-        out += char;
-    }
-    return out;
-}
 function copy(seg) {
     return { ...seg };
 }

package/dist/ui/width.js

@@ -6,6 +6,8 @@
 // cell at all. Every alignment in the UI depends on this file being right:
 // the right-hand column, a ground band, the cursor. Nothing measures with
 // `.length`.
+import { graphemes, segmentGraphemes } from "../text-boundary.js";
+export { graphemes } from "../text-boundary.js";
 /** Ranges the terminal draws two cells wide (East Asian Wide and Fullwidth). */
 const WIDE = [
     [0x1100, 0x115f],
@@ -93,16 +95,6 @@ function inRanges(code, ranges) {
 // in source is a byte nobody reviews.
 const VS15 = String.fromCodePoint(0xfe0e);
 const VS16 = String.fromCodePoint(0xfe0f);
-// Grapheme segmentation is in the standard library, so a family emoji built
-// out of five code points and three joiners counts as the one thing the
-// terminal actually draws.
-const SEGMENTER = new Intl.Segmenter(undefined, { granularity: "grapheme" });
-export function graphemes(text) {
-    const out = [];
-    for (const { segment } of SEGMENTER.segment(text))
-        out.push(segment);
-    return out;
-}
 /**
  * Cells taken by one grapheme cluster.
  *
@@ -126,17 +118,38 @@ export function charWidth(cluster) {
 }
 export function textWidth(text) {
     let total = 0;
-    for (const cluster of SEGMENTER.segment(text))
+    for (const cluster of segmentGraphemes(text))
         total += charWidth(cluster.segment);
     return total;
 }
+/** Split text into grapheme-safe chunks without rescanning any suffix. */
+export function splitByCells(text, firstCols, followingCols = firstCols) {
+    if (text === "")
+        return [{ text, width: 0 }];
+    const chunks = [];
+    let start = 0;
+    let used = 0;
+    let room = Math.max(1, firstCols);
+    for (const { index, segment } of segmentGraphemes(text)) {
+        const width = charWidth(segment);
+        if (index > start && used + width > room) {
+            chunks.push({ text: text.slice(start, index), width: used });
+            start = index;
+            used = 0;
+            room = Math.max(1, followingCols);
+        }
+        used += width;
+    }
+    chunks.push({ text: text.slice(start), width: used });
+    return chunks;
+}
 /** The longest prefix of `text` that fits in `cols` cells. */
 export function clip(text, cols) {
     if (cols <= 0)
         return "";
     let out = "";
     let used = 0;
-    for (const { segment } of SEGMENTER.segment(text)) {
+    for (const { segment } of segmentGraphemes(text)) {
         const w = charWidth(segment);
         if (used + w > cols)
             break;
@@ -214,17 +227,13 @@ export function wrapText(text, max, continuation = "") {
                 flush();
             if (w > room()) {
                 // Too long for any row: spend whole rows on it until it fits.
-                let rest = word;
-                while (textWidth(rest) > room()) {
-                    const head = clip(rest, room() - (line === "" ? 0 : width + 1));
-                    if (head === "")
-                        break;
-                    line = line === "" ? head : `${line} ${head}`;
-                    rest = rest.slice(head.length);
-                    flush();
+                const chunks = splitByCells(word, room(), Math.max(1, max - lead));
+                for (const [index, chunk] of chunks.entries()) {
+                    line = chunk.text;
+                    width = chunk.width;
+                    if (index + 1 < chunks.length)
+                        flush();
                 }
-                line = rest;
-                width = textWidth(rest);
                 continue;
             }
             line = line === "" ? word : `${line} ${word}`;

package/dist/usage.js

@@ -12,9 +12,12 @@ export function emptyUsage() {
 }
 export function recordUsage(total, next) {
     total.requests += 1;
-    total.lastInputTokens = next.inputTokens;
     addUsage(total, next);
 }
+/** Replace context pressure without inventing provider-reported usage. */
+export function recordRequestInput(total, inputTokens) {
+    total.lastInputTokens = inputTokens;
+}
 /** Account for an internal request without replacing the main context signal. */
 export function recordAuxiliaryUsage(total, next) {
     total.requests += 1;
@@ -32,6 +35,7 @@ export function usageFromHistory(messages) {
     for (const message of messages) {
         if (message.role === "assistant" && message.usage !== undefined) {
             recordUsage(total, message.usage);
+            recordRequestInput(total, message.usage.inputTokens);
         }
     }
     return total;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@giovannijecha/jecode",
-  "version": "0.7.2",
+  "version": "0.7.4",
   "description": "An owned coding agent with zero external runtime dependencies.",
   "license": "MIT",
   "repository": {
@@ -45,6 +45,7 @@
     "start": "node src/main.ts",
     "tui:lab": "node dev/tui-lab.ts",
     "bench:transcript": "node dev/benchmark-transcript.ts",
+    "bench:search": "node dev/benchmark-search.ts",
     "typecheck": "tsc --noEmit",
     "test": "npm run build:release && node --test",
     "coverage": "npm run build:release && node --test --experimental-test-coverage --test-coverage-include=\"src/**/*.ts\" --test-coverage-lines=80 --test-coverage-branches=75 --test-coverage-functions=75",