@giovannijecha/jecode 0.7.3 → 0.8.0

package/dist/tui/turn.js

@@ -3,13 +3,14 @@
 // The controller speaks in stream events and tool results; the screen speaks in
 // blocks. This is the whole of the translation, kept out of the shell so that
 // neither has to know how the other is built.
+import { graphemes } from "../text-boundary.js";
 import { condense, diff } from "../ui/diff.js";
 import { promptFor } from "./approve.js";
 // Semantic activity labels feed the footer's compact state and timer while
 // reasoning and tools keep the detailed work visible in the transcript.
 const WAITING = "Waiting";
 const THINKING = "Thinking";
-const WRITING = "Writing";
+const RESPONDING = "Responding";
 const ASKING = "Waiting for you";
 /** Unchanged rows kept either side of a change. */
 const CONTEXT = 2;
@@ -18,10 +19,7 @@ export function transcribe(stage) {
     // one, which is what keeps reasoning and answer from running together.
     let open;
     const tools = new Map();
-    let step = 1;
-    let steps = 1;
-    let tool = 1;
-    let toolTotal = 1;
+    const progress = new Map();
     const close = () => {
         const block = open?.block;
         const changed = block?.kind === "reasoning" && block.live === true;
@@ -40,30 +38,50 @@ export function transcribe(stage) {
                     continue;
                 block.tone = "fail";
                 block.right = reason ?? "failed";
-                block.startedAt = undefined;
+                settleDuration(block);
                 stage.render(block);
             }
         },
-        onStep(current, total) {
-            step = current;
-            steps = total;
-            stage.status(waiting(step, steps));
+        onToolPreparing(call, current, total) {
+            progress.set(call.id, { current, total });
+            const changed = close();
+            if (changed !== undefined)
+                stage.render(changed);
+            stage.status(toolStatus("Preparing", call, progress));
             stage.render();
         },
-        onToolProgress(current, total) {
-            tool = current;
-            toolTotal = total;
+        onToolStart(call, current, total) {
+            progress.set(call.id, { current, total });
+            stage.status(toolStatus("Running", call, progress));
+            const block = tools.get(call.id);
+            if (block !== undefined && block.kind === "tool") {
+                block.right = "running";
+                block.startedAt = Date.now();
+                block.durationMs = undefined;
+            }
+            stage.render(block);
         },
         onUsage(usage) {
             stage.usage?.(usage);
         },
+        onRequestInput(inputTokens) {
+            stage.requestInput?.(inputTokens);
+        },
         onStatus(status) {
             stage.status(status);
             stage.render();
         },
         onStream(event) {
+            if (event.kind === "tool") {
+                const changed = close();
+                if (changed !== undefined)
+                    stage.render(changed);
+                stage.status(`Preparing ${event.name ?? "tool"}`);
+                stage.render();
+                return;
+            }
             const kind = event.kind === "thinking" ? "reasoning" : "answer";
-            stage.status(kind === "reasoning" ? THINKING : WRITING);
+            stage.status(kind === "reasoning" ? THINKING : RESPONDING);
             if (open === undefined || open.kind !== kind) {
                 const changed = close();
                 if (changed !== undefined)
@@ -83,15 +101,13 @@ export function transcribe(stage) {
             const changed = close();
             if (changed !== undefined)
                 stage.render(changed);
-            stage.status(`Running ${call.name}${toolTotal > 1 ? ` · tool ${tool}/${toolTotal}` : ""}${step > 1 ? ` · step ${step}/${steps}` : ""}`);
             const block = {
                 kind: "tool",
                 name: call.name,
                 target: target(call.input),
-                right: "running",
+                right: "ready",
                 tone: "pending",
                 body: preview(call, look),
-                startedAt: Date.now(),
             };
             tools.set(call.id, block);
             stage.emit(block);
@@ -105,7 +121,7 @@ export function transcribe(stage) {
             stage.render(block);
         },
         onToolResult(call, result, summary) {
-            stage.status(waiting(step, steps));
+            stage.status(WAITING);
             const block = tools.get(call.id);
             if (block === undefined || block.kind !== "tool")
                 return;
@@ -118,7 +134,7 @@ export function transcribe(stage) {
             }
             block.tone = result.isError ? "fail" : "ok";
             block.right = summary ?? "";
-            block.startedAt = undefined;
+            settleDuration(block);
             // A failure replaces the preview: what the call was going to do stops
             // being the interesting part the moment it did not do it.
             const outcome = result.isError
@@ -130,14 +146,8 @@ export function transcribe(stage) {
         },
         approve(call) {
             const block = tools.get(call.id);
-            if (stage.approved(call)) {
-                if (block !== undefined && block.kind === "tool") {
-                    block.right = "running";
-                    block.startedAt ??= Date.now();
-                    stage.render(block);
-                }
+            if (stage.approved(call))
                 return Promise.resolve(true);
-            }
             const changed = close();
             if (changed !== undefined)
                 stage.render(changed);
@@ -156,8 +166,8 @@ export function transcribe(stage) {
                     if (settled !== undefined && settled.kind === "tool") {
                         if (approved) {
                             settled.tone = "pending";
-                            settled.right = "running";
-                            settled.startedAt = Date.now();
+                            settled.right = "ready";
+                            settled.startedAt = undefined;
                         }
                         else {
                             settled.tone = "deny";
@@ -165,7 +175,9 @@ export function transcribe(stage) {
                             settled.startedAt = undefined;
                         }
                     }
-                    stage.status(approved ? `Running ${call.name}` : waiting(step, steps));
+                    stage.status(approved
+                        ? toolStatus("Preparing", call, progress)
+                        : WAITING);
                     stage.render(settled);
                     resolve(approved);
                 });
@@ -173,14 +185,24 @@ export function transcribe(stage) {
         },
     };
 }
+function toolStatus(phase, call, progress) {
+    const position = progress.get(call.id);
+    const tool = position !== undefined && position.total > 1
+        ? ` · tool ${position.current}/${position.total}`
+        : "";
+    return `${phase} ${call.name}${tool}`;
+}
 function pendingApproval(body) {
     const added = body?.filter((detail) => detail.kind === "add").length ?? 0;
     const removed = body?.filter((detail) => detail.kind === "del").length ?? 0;
     const summary = added + removed === 0 ? "" : `+${added} −${removed} · `;
     return `${summary}pending approval`;
 }
-function waiting(step, total) {
-    return step === 1 ? WAITING : `${WAITING} · step ${step}/${total}`;
+function settleDuration(block) {
+    if (block.startedAt !== undefined) {
+        block.durationMs = Math.max(0, Date.now() - block.startedAt);
+    }
+    block.startedAt = undefined;
 }
 /** The argument worth showing: the thing the call acts on. */
 function target(input) {
@@ -249,18 +271,35 @@ function emphasizePairs(rows) {
             continue;
         if (rows[index - 1]?.kind === "del" || rows[index + 2]?.kind === "add")
             continue;
+        const removedClusters = graphemes(removed.text);
+        const addedClusters = graphemes(added.text);
+        let prefix = 0;
         let start = 0;
-        while (start < removed.text.length && start < added.text.length && removed.text[start] === added.text[start])
-            start++;
+        while (prefix < removedClusters.length &&
+            prefix < addedClusters.length &&
+            removedClusters[prefix] === addedClusters[prefix]) {
+            start += removedClusters[prefix].length;
+            prefix++;
+        }
         let suffix = 0;
-        while (suffix < removed.text.length - start &&
-            suffix < added.text.length - start &&
-            removed.text[removed.text.length - 1 - suffix] === added.text[added.text.length - 1 - suffix])
+        let removedSuffix = 0;
+        let addedSuffix = 0;
+        while (suffix < removedClusters.length - prefix &&
+            suffix < addedClusters.length - prefix &&
+            removedClusters[removedClusters.length - 1 - suffix] ===
+                addedClusters[addedClusters.length - 1 - suffix]) {
+            removedSuffix += removedClusters[removedClusters.length - 1 - suffix].length;
+            addedSuffix += addedClusters[addedClusters.length - 1 - suffix].length;
             suffix++;
-        while (suffix > 0 && (!wordBoundary(removed.text, suffix) || !wordBoundary(added.text, suffix)))
+        }
+        while (suffix > 0 &&
+            (!wordBoundary(removed.text, removedSuffix) || !wordBoundary(added.text, addedSuffix))) {
+            removedSuffix -= removedClusters[removedClusters.length - suffix].length;
+            addedSuffix -= addedClusters[addedClusters.length - suffix].length;
             suffix--;
-        const removedLength = removed.text.length - start - suffix;
-        const addedLength = added.text.length - start - suffix;
+        }
+        const removedLength = removed.text.length - start - removedSuffix;
+        const addedLength = added.text.length - start - addedSuffix;
         if (removedLength > 0)
             removed.emphasis = { start, length: removedLength };
         if (addedLength > 0)

package/dist/tui/view.js

@@ -25,7 +25,7 @@ export function compose(view, size, transcript = transcriptRenderer()) {
     // Any spare height belongs above the conversation, so short sessions grow
     // upward from the fixed dock rhythm instead of leaving a changing hole
     // beneath the latest reply.
-    const viewport = transcript.viewport(view.blocks, width, transcriptHeight, view.scroll, view.pal, { now: view.now });
+    const viewport = transcript.viewport(view.blocks, width, transcriptHeight, view.scroll, view.pal, { now: view.now, reducedMotion: view.reducedMotion });
     const cursor = dock.cursor === undefined
         ? undefined
         : { row: transcriptHeight + dock.cursor.row, col: dock.cursor.col };
@@ -34,6 +34,7 @@ export function compose(view, size, transcript = transcriptRenderer()) {
         cursor,
         maxScroll: viewport.maxScroll,
         transcriptPending: viewport.pending,
+        transcriptAnimating: viewport.animating,
     };
 }
 function dockRows(view, width, height) {
@@ -42,6 +43,7 @@ function dockRows(view, width, height) {
         // use the footer while that interaction is open instead of repeating a
         // generic "Running /…" label beside it.
         status: view.modal === undefined ? view.status : undefined,
+        steering: view.modal === undefined ? view.steering : undefined,
         feedback: view.feedback,
         readiness: view.readiness,
         unseen: view.unseen ?? 0,
@@ -87,5 +89,5 @@ function tooSmall(height, width, view) {
             { text: elide(`need ${MIN_COLS}×${MIN_ROWS}`, Math.max(1, width)), fg: view.pal.ink.dim },
         ]);
     }
-    return { rows, maxScroll: 0, transcriptPending: false };
+    return { rows, maxScroll: 0, transcriptPending: false, transcriptAnimating: false };
 }

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);
@@ -125,9 +125,7 @@ export function blank(width, ground) {
 /**
  * A full-width divider.
  *
- * Edge to edge, because the other thing that spans a whole row is the ground
- * behind a user's message: two elements that stop at different columns read as
- * two grids, and the eye finds the discrepancy before it finds the text.
+ * Edge to edge so the composer and dock keep one exact terminal boundary.
  */
 export function rule(width, color) {
     return paint({ text: "─".repeat(Math.max(0, width)), fg: color });
@@ -166,13 +164,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 +189,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/theme.js

@@ -1,26 +1,27 @@
 // Jecode's fixed terminal identity. Components depend on semantic tokens, not
-// literal colours, while the product exposes one deliberate dark Steel look.
-// Jecode's fixed dark Steel baseline. Structural blues, semantic outcomes,
-// and slate surfaces keep the transcript vivid without turning it decorative.
+// literal colours, while the product exposes one deliberate dark Slate look.
+// Jecode's fixed dark Slate baseline. The exported name stays stable while
+// cooler, quieter values leave the transcript bright enough to read and let
+// live state carry the colour.
 // Components depend on these roles rather than embedding presentation values.
 export const STEEL = {
-    accent: [102, 155, 210],
-    technical: [78, 201, 232],
-    focus: [102, 155, 210],
-    rule: [53, 80, 110],
+    accent: [124, 164, 222],
+    technical: [126, 186, 208],
+    focus: [124, 164, 222],
+    rule: [44, 60, 78],
     ink: {
-        fg: [220, 224, 229],
-        bright: [235, 239, 244],
-        muted: [156, 169, 183],
-        dim: [112, 124, 137],
-        attention: [230, 191, 95],
-        added: [134, 203, 146],
-        removed: [232, 112, 112],
+        fg: [214, 219, 226],
+        bright: [241, 244, 248],
+        muted: [149, 160, 174],
+        dim: [99, 111, 125],
+        attention: [226, 188, 112],
+        added: [138, 190, 150],
+        removed: [223, 120, 120],
     },
     surface: {
-        subtle: [31, 38, 47],
-        added: [22, 55, 34],
-        removed: [62, 24, 27],
-        attention: [62, 50, 19],
+        subtle: [23, 29, 37],
+        added: [21, 52, 33],
+        removed: [58, 24, 27],
+        attention: [58, 47, 20],
     },
 };

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.3",
+  "version": "0.8.0",
   "description": "An owned coding agent with zero external runtime dependencies.",
   "license": "MIT",
   "repository": {