@giovannijecha/jecode 0.8.5 → 0.8.6

package/dist/tui/picker.js

@@ -1,9 +1,7 @@
 // One interaction model for every terminal selector.
-import { row } from "../ui/render.js";
-import { elide, graphemes } from "../ui/width.js";
+import { graphemes } from "../ui/width.js";
 import { assertPromptAppend } from "../input-boundary.js";
-import { menuWindow, renderMenuRows } from "./components/menu.js";
-import { promptCursor, promptLine } from "./components/prompt.js";
+import { layoutPicker } from "./picker-layout.js";
 const WINDOW = 6;
 export function move(picker, step) {
     const shown = matches(picker);
@@ -53,74 +51,12 @@ export function byKey(picker, text) {
     const found = picker.options.findIndex((option) => option.key === typed);
     return found === -1 ? undefined : found;
 }
-export function panel(picker, width, pal, maxRows = (picker.visible ?? WINDOW) + 3) {
-    return layout(picker, width, pal, maxRows).rows;
+export function panel(picker, width, pal, maxRows = (picker.visible ?? WINDOW) + 6) {
+    return layoutPicker(picker, matches(picker), width, pal, maxRows).rows;
 }
 /** Caret for the shared query row, relative to the unframed picker body. */
-export function caret(picker, width, maxRows = (picker.visible ?? WINDOW) + 3) {
-    return layout(picker, width, undefined, maxRows).cursor;
-}
-function layout(picker, width, pal, maxRows) {
-    const found = matches(picker);
-    const note = picker.description ?? picker.footer;
-    const hasTitle = picker.title.length > 0;
-    const fixed = (hasTitle ? 1 : 0) +
-        (note === undefined ? 0 : 1) +
-        (picker.searchable === true ? 1 : 0);
-    const optionRoom = Math.max(1, Math.min(picker.visible ?? WINDOW, maxRows - fixed));
-    const selectedAt = Math.max(0, found.findIndex((entry) => entry.index === picker.index));
-    const { first, last } = menuWindow(found.length, selectedAt, optionRoom);
-    const shown = found.slice(first, last);
-    const colors = pal;
-    const options = colors === undefined
-        ? []
-        : shown.length === 0
-            ? [row(width, [{ text: "no matches", fg: colors.ink.muted }])]
-            : renderMenuRows(shown.map(({ option, index }) => ({
-                label: option.label,
-                description: option.description,
-                hint: option.hint,
-                value: option.value,
-                adjustable: option.adjustable,
-                selected: index === picker.index,
-            })), width, colors);
-    const progress = found.length > shown.length || picker.searchable === true
-        ? `${found.length === 0 ? "0" : `${first + 1}–${first + shown.length}`} / ${found.length}` +
-            (found.length === picker.options.length ? "" : ` · ${picker.options.length} total`)
-        : "";
-    const titleRight = hasTitle
-        ? picker.right ?? (picker.searchable === true ? undefined : progress)
-        : undefined;
-    const visibleTitleRight = titleRight === undefined
-        ? undefined
-        : elide(titleRight, Math.max(1, Math.floor(width * 0.55)));
-    const queryRow = picker.searchable === true && colors !== undefined
-        ? promptLine(picker.query ?? "", (picker.query ?? "").length, width, colors, {
-            placeholder: "type to filter",
-            right: progress,
-        })
-        : undefined;
-    const queryCursor = picker.searchable === true
-        ? promptCursor(picker.query ?? "", (picker.query ?? "").length, width, { right: progress })
-        : undefined;
-    const queryOffset = (hasTitle ? 1 : 0) + (note === undefined ? 0 : 1);
-    return {
-        rows: colors === undefined
-            ? []
-            : [
-                ...(hasTitle
-                    ? [row(width, picker.title, visibleTitleRight === undefined || visibleTitleRight === ""
-                            ? []
-                            : [{ text: visibleTitleRight, fg: colors.ink.dim }])]
-                    : []),
-                ...(note === undefined ? [] : [row(width, [{ text: note, fg: colors.ink.muted }])]),
-                ...(queryRow === undefined ? [] : [queryRow.row]),
-                ...options,
-            ],
-        cursor: picker.searchable === true
-            ? { row: queryOffset, col: queryCursor?.col ?? 0 }
-            : undefined,
-    };
+export function caret(picker, width, maxRows = (picker.visible ?? WINDOW) + 6) {
+    return layoutPicker(picker, matches(picker), width, undefined, maxRows).cursor;
 }
 export function heading(label, about, pal) {
     return [
@@ -128,7 +64,7 @@ export function heading(label, about, pal) {
         { text: about, fg: pal.ink.fg },
     ];
 }
-function matches(picker) {
+export function matches(picker) {
     const query = (picker.query ?? "").trim().toLocaleLowerCase();
     return picker.options.flatMap((option, index) => {
         const haystack = `${option.label} ${option.hint ?? ""} ${option.value ?? ""}`.toLocaleLowerCase();

package/dist/tui/tool-details.js

@@ -0,0 +1,135 @@
+// Semantic tool evidence built from arguments, previews, and results.
+import { graphemes } from "../text-boundary.js";
+import { condense, diff } from "../ui/diff.js";
+/** Unchanged rows kept either side of a change. */
+const CONTEXT = 2;
+/** The argument worth showing: the thing the call acts on. */
+export function toolTarget(input) {
+    const { path, command } = input;
+    if (typeof command === "string")
+        return command;
+    if (typeof path === "string")
+        return path;
+    const rest = JSON.stringify(input);
+    return rest === "{}" ? "" : rest;
+}
+/**
+ * What the call is about to do, drawn before it is allowed to do it.
+ *
+ * The tool is asked first, because only it knows what is already on disk: a
+ * write against an existing file is a replacement, and showing it as a page of
+ * additions hides exactly the part worth approving. The fallback diffs what is
+ * in the arguments, which is all there is when a tool has nothing to say.
+ */
+export function previewDetails(call, look) {
+    if (look !== undefined)
+        return changes(look.before, look.after);
+    const input = call.input;
+    if (call.name === "write_file" && typeof input.content === "string") {
+        return changes("", input.content);
+    }
+    if (call.name === "edit_file" && typeof input.old_text === "string") {
+        return changes(input.old_text, typeof input.new_text === "string" ? input.new_text : "");
+    }
+    return undefined;
+}
+/** Two texts as the rows of their difference, unchanged runs summed up. */
+function changes(before, after) {
+    let oldLine = 1;
+    let newLine = 1;
+    const rows = [];
+    for (const changed of condense(diff(before, after), CONTEXT)) {
+        if (changed.kind === "gap") {
+            rows.push({ kind: "gap", text: `… ${changed.skipped} unchanged` });
+            oldLine += changed.skipped;
+            newLine += changed.skipped;
+            continue;
+        }
+        if (changed.kind === "keep") {
+            rows.push({ kind: "keep", text: tabs(changed.text), oldLine, newLine });
+            oldLine++;
+            newLine++;
+            continue;
+        }
+        if (changed.kind === "del") {
+            rows.push({ kind: "del", text: tabs(changed.text), oldLine });
+            oldLine++;
+            continue;
+        }
+        rows.push({ kind: "add", text: tabs(changed.text), newLine });
+        newLine++;
+    }
+    emphasizePairs(rows);
+    return rows.length === 0 ? undefined : rows;
+}
+function emphasizePairs(rows) {
+    for (let index = 0; index < rows.length - 1; index++) {
+        const removed = rows[index];
+        const added = rows[index + 1];
+        if (removed?.kind !== "del" || added?.kind !== "add")
+            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 (prefix < removedClusters.length &&
+            prefix < addedClusters.length &&
+            removedClusters[prefix] === addedClusters[prefix]) {
+            start += removedClusters[prefix].length;
+            prefix++;
+        }
+        let suffix = 0;
+        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, removedSuffix) || !wordBoundary(added.text, addedSuffix))) {
+            removedSuffix -= removedClusters[removedClusters.length - suffix].length;
+            addedSuffix -= addedClusters[addedClusters.length - suffix].length;
+            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)
+            added.emphasis = { start, length: addedLength };
+    }
+}
+function wordBoundary(text, suffix) {
+    const at = text.length - suffix;
+    if (at <= 0 || at >= text.length)
+        return true;
+    return /\w/.test(text[at - 1]) !== /\w/.test(text[at]);
+}
+/** What the call left behind, for the calls whose output is worth a look. */
+export function producedDetails(call, output) {
+    if (call.name === "run_command")
+        return outputDetails(output, "out");
+    // A read or a listing is already summed up on the right of its own row, and
+    // the model is about to say what was in it. Printing it twice helps nobody.
+    return undefined;
+}
+export function outputDetails(text, kind) {
+    const rows = split(text).map((line) => ({ kind, text: tabs(line) }));
+    return rows.length === 0 ? undefined : rows;
+}
+function split(text) {
+    const lines = text.replace(/\r\n?/g, "\n").split("\n");
+    while (lines.length > 0 && lines[lines.length - 1] === "")
+        lines.pop();
+    return lines.map(tabs);
+}
+// A tab is a width the terminal decides and the row measurement cannot see.
+function tabs(line) {
+    return line.replace(/\t/g, "  ");
+}

package/dist/tui/transcript-grammar.js

@@ -1,5 +1,12 @@
-// One semantic margin shared by the user cue and executable tool evidence.
+// Shared transcript inset and a bounded measure for model prose and tool records.
 const GUTTER = 2;
+const MODEL_MEASURE = 86;
+export function modelTranscriptWidth(width) {
+    return Math.max(8, Math.min(width - GUTTER * 2, MODEL_MEASURE));
+}
+export function insetTranscript(rows) {
+    return rows.map((line) => line === "" ? "" : `${" ".repeat(GUTTER)}${line}`);
+}
 export function transcriptGutter(_width) {
     return GUTTER;
 }

package/dist/tui/transcript-view.js

@@ -1,6 +1,7 @@
 // Incremental transcript layout for long-running sessions.
+import { hasColor } from "../ui/render.js";
+import { runningTool } from "./components/tool-motion.js";
 import { render } from "./blocks.js";
-import { TOOL_BIRTH_MS, TOOL_LEADER_MAX_MS, TOOL_ROW_ARRIVAL_MS, TOOL_SETTLE_MS, } from "./motion.js";
 const MAX_LAYOUTS = 2;
 const REFLOW_BLOCKS_PER_FRAME = 128;
 /**
@@ -13,18 +14,13 @@ const REFLOW_BLOCKS_PER_FRAME = 128;
  */
 export function transcriptRenderer(draw = render, clock = Date.now) {
     let layouts = [];
-    const motions = new WeakMap();
-    const activeMotion = new Set();
+    const activeTools = new Set();
     return {
         viewport(blocks, width, height, scroll, palette, state = {}) {
             const layout = layoutFor(blocks, width, palette);
-            const now = state.now ?? clock();
-            if (state.reducedMotion === true) {
-                discardSuppressedMotion(layout);
-            }
-            else if (scroll === 0) {
-                invalidateMovingEntries(layout, now);
-            }
+            state = { ...state, now: state.now ?? clock() };
+            if (scroll === 0)
+                invalidateRunningEntries(layout);
             // Reflowing rows below a scroll-locked viewport would move the content
             // being read as estimates become exact. Visible rows still resolve on
             // demand; background work resumes when the user follows the tail again.
@@ -35,15 +31,19 @@ export function transcriptRenderer(draw = render, clock = Date.now) {
                 rows: visibleRows(layout, window, Math.max(0, height)),
                 maxScroll: window.maxScroll,
                 pending: scroll === 0 && layout.pending > 0,
-                animating: scroll === 0 && state.reducedMotion !== true && hasMovingEntry(layout, now),
+                animating: scroll === 0 && state.reducedMotion !== true && hasColor() && hasRunningEntry(layout, window),
             };
         },
         invalidate(block) {
             if (block === undefined) {
                 layouts = [];
+                activeTools.clear();
                 return;
             }
-            observeMotion(block, clock());
+            if (runningTool(block))
+                activeTools.add(block);
+            else
+                activeTools.delete(block);
             for (const layout of layouts) {
                 const index = layout.positions.get(block);
                 if (index === undefined)
@@ -95,6 +95,8 @@ export function transcriptRenderer(draw = render, clock = Date.now) {
             const rowCount = seeded?.block === block ? seeded.rowCount : estimatedRows(block);
             layout.entries.push({ block, rowCount });
             layout.positions.set(block, index);
+            if (runningTool(block))
+                activeTools.add(block);
             layout.pending++;
             total += rowCount;
             layout.ends.push(total);
@@ -138,7 +140,6 @@ export function transcriptRenderer(draw = render, clock = Date.now) {
         entry.rows = draw(entry.block, layout.width, layout.palette, {
             ...state,
             previous: layout.entries[index - 1]?.block,
-            motion: motions.get(entry.block),
         });
         entry.rowCount = entry.rows.length;
         layout.pending--;
@@ -188,115 +189,28 @@ export function transcriptRenderer(draw = render, clock = Date.now) {
         }
         layout.next = Math.max(layout.next, index);
     }
-    function observeMotion(block, now) {
-        if (block.kind !== "tool")
-            return;
-        let motion = motions.get(block);
-        // A settled historical block may be invalidated by Ctrl+O. It should not
-        // replay its original arrival animation after resume.
-        if (motion === undefined) {
-            if (block.tone !== "pending")
-                return;
-            motion = {
-                bornAt: now,
-                rowsAt: (block.body ?? []).map(() => now),
-                rowKeys: (block.body ?? []).map(detailKey),
-                tone: block.tone,
-            };
-            motions.set(block, motion);
-            activeMotion.add(block);
-            return;
-        }
-        if (motion.tone === "pending" && block.tone !== "pending")
-            motion.settledAt = now;
-        motion.tone = block.tone;
-        reconcileRows(motion, block.body ?? [], now);
-        activeMotion.add(block);
-    }
-    function invalidateMovingEntries(layout, now) {
-        for (const block of activeMotion) {
+    function invalidateRunningEntries(layout) {
+        for (const block of activeTools) {
             const index = layout.positions.get(block);
-            if (index === undefined) {
-                activeMotion.delete(block);
-                continue;
-            }
-            const motion = motions.get(block);
-            if (motion === undefined || !moving(block, motion, now)) {
-                // Paint the resting state once before leaving the motion registry;
-                // otherwise the cache could retain the final in-between frame.
-                dirty(layout, index);
-                activeMotion.delete(block);
+            if (index === undefined || !runningTool(block)) {
+                activeTools.delete(block);
+                if (index !== undefined)
+                    dirty(layout, index);
                 continue;
             }
+            // Clock-driven repaints keep elapsed time current even without motion.
             dirty(layout, index);
         }
     }
-    function hasMovingEntry(layout, now) {
-        for (const block of activeMotion) {
-            if (layout.positions.get(block) === undefined)
-                continue;
-            const motion = motions.get(block);
-            if (motion !== undefined && moving(block, motion, now))
+    function hasRunningEntry(layout, window) {
+        for (const block of activeTools) {
+            const index = layout.positions.get(block);
+            if (index !== undefined && index >= window.first && index <= window.last &&
+                runningTool(block) && block.expanded !== true)
                 return true;
         }
         return false;
     }
-    function discardSuppressedMotion(layout) {
-        for (const block of activeMotion) {
-            if (layout.positions.get(block) !== undefined && block.kind === "tool" && block.tone === "pending") {
-                continue;
-            }
-            activeMotion.delete(block);
-            motions.delete(block);
-        }
-    }
-}
-function reconcileRows(motion, details, now) {
-    const available = new Map();
-    for (let index = 0; index < motion.rowKeys.length; index++) {
-        const key = motion.rowKeys[index];
-        if (key === undefined)
-            continue;
-        const bucket = available.get(key) ?? { values: [], next: 0 };
-        bucket.values.push(motion.rowsAt[index] ?? motion.bornAt);
-        available.set(key, bucket);
-    }
-    const rowKeys = details.map(detailKey);
-    const rowsAt = rowKeys.map((key) => {
-        const bucket = available.get(key);
-        if (bucket === undefined || bucket.next >= bucket.values.length)
-            return now;
-        const value = bucket.values[bucket.next] ?? now;
-        bucket.next++;
-        return value;
-    });
-    motion.rowKeys = rowKeys;
-    motion.rowsAt = rowsAt;
-}
-function detailKey(detail) {
-    if (detail.kind === "out" || detail.kind === "gap") {
-        return JSON.stringify([detail.kind, detail.text]);
-    }
-    return JSON.stringify([
-        detail.kind,
-        detail.oldLine ?? "",
-        detail.newLine ?? "",
-        detail.emphasis?.start ?? "",
-        detail.emphasis?.length ?? "",
-        detail.text,
-    ]);
-}
-function moving(block, motion, now) {
-    if (block.kind === "tool" && block.tone === "pending" &&
-        block.startedAt !== undefined && block.right === "running")
-        return true;
-    let until = motion.bornAt + Math.max(TOOL_BIRTH_MS, TOOL_LEADER_MAX_MS);
-    if (motion.settledAt !== undefined)
-        until = Math.max(until, motion.settledAt + TOOL_SETTLE_MS);
-    for (const arrivedAt of motion.rowsAt) {
-        until = Math.max(until, arrivedAt + TOOL_ROW_ARRIVAL_MS);
-    }
-    return now < until;
 }
 function compatible(layout, blocks) {
     return layout.source === blocks &&