@giovannijecha/jecode 0.7.1 → 0.7.3

package/dist/tui/app.js

@@ -21,7 +21,7 @@ import { appWorkflows } from "./app-workflows.js";
 import { sessionPermissions } from "../permissions.js";
 import { resumePicker } from "./resume.js";
 const FRAME_MS = 16;
-const SPIN_MS = 80;
+const ACTIVITY_REFRESH_MS = 1_000;
 /** How long a lone escape waits to prove it is not the start of a sequence. */
 const ESCAPE_MS = 25;
 export async function runApp(session, transcriptRoot, environment = {}) {
@@ -36,11 +36,12 @@ export async function runApp(session, transcriptRoot, environment = {}) {
     const permissions = sessionPermissions(session.tools, session.config.autoApprove);
     let closed;
     let frameTimer;
-    let spinTimer;
+    let activityTimer;
     let escapeTimer;
     let stopResize = () => { };
     let stopInput = () => { };
     let failure;
+    let activeWorkflow;
     // Timers outlive the teardown they were scheduled before. Painting after the
     // terminal has been handed back would write escapes into the user's shell.
     let live = true;
@@ -69,8 +70,6 @@ export async function runApp(session, transcriptRoot, environment = {}) {
                 : activityStatus(state.activity, state.status ?? state.activity.label, now),
             feedback: state.feedback,
             readiness: turnBlocker(session),
-            spin: state.spin,
-            reducedMotion: session.config.reducedMotion,
             now,
             modal: overlay.shown(state.open),
             menu: completionOptions(state.completing),
@@ -97,6 +96,8 @@ export async function runApp(session, transcriptRoot, environment = {}) {
         }
         state.lastMaxScroll = frame.maxScroll;
         paint.paint(frame.rows, frame.cursor);
+        if (frame.transcriptPending)
+            render();
     };
     // Streaming produces a token at a time; painting at that rate is wasted
     // work, so repaints coalesce onto one frame.
@@ -141,22 +142,42 @@ export async function runApp(session, transcriptRoot, environment = {}) {
         if (!live)
             return;
         live = false;
-        stopInput();
-        stopResize();
-        if (spinTimer !== undefined)
-            clearInterval(spinTimer);
+        safely(stopInput);
+        safely(stopResize);
+        if (activityTimer !== undefined)
+            clearInterval(activityTimer);
         if (frameTimer !== undefined)
             clearTimeout(frameTimer);
         if (escapeTimer !== undefined)
             clearTimeout(escapeTimer);
-        feedback.close();
-        terminal.leave();
+        safely(() => feedback.close());
+        safely(() => terminal.leave());
         closed?.();
     }
+    function safely(action) {
+        try {
+            action();
+        }
+        catch (error) {
+            failure ??= { error };
+        }
+    }
     function fail(error) {
         failure ??= { error };
+        state.open = overlay.cancel(state.open);
+        state.activity?.control.abort(error);
         quit();
     }
+    function track(work) {
+        const tracked = work
+            .catch((error) => fail(error))
+            .finally(() => {
+            if (activeWorkflow === tracked)
+                activeWorkflow = undefined;
+        });
+        activeWorkflow = tracked;
+        return tracked;
+    }
     function requestQuit() {
         const activity = state.activity;
         if (activity === undefined) {
@@ -173,9 +194,7 @@ export async function runApp(session, transcriptRoot, environment = {}) {
         const activity = begin(kind, label);
         state.activity = activity;
         state.status = label;
-        spinTimer = setInterval(() => guard(() => {
-            if (!session.config.reducedMotion)
-                state.spin++;
+        activityTimer = setInterval(() => guard(() => {
             let activeTool;
             for (let index = state.blocks.length - 1; index >= 0; index--) {
                 const block = state.blocks[index];
@@ -185,16 +204,16 @@ export async function runApp(session, transcriptRoot, environment = {}) {
                 break;
             }
             render(activeTool);
-        }), session.config.reducedMotion ? 1_000 : SPIN_MS);
+        }), ACTIVITY_REFRESH_MS);
         render();
         return activity;
     }
     function finishActivity(activity) {
         if (state.activity !== activity)
             return;
-        if (spinTimer !== undefined)
-            clearInterval(spinTimer);
-        spinTimer = undefined;
+        if (activityTimer !== undefined)
+            clearInterval(activityTimer);
+        activityTimer = undefined;
         state.activity = undefined;
         state.status = undefined;
         state.open = overlay.cancel(state.open);
@@ -226,7 +245,10 @@ export async function runApp(session, transcriptRoot, environment = {}) {
         session,
         state,
         feedback,
-        actions,
+        actions: {
+            command: (text) => track(actions.command(text)),
+            turn: (text) => track(actions.turn(text)),
+        },
         live: () => live,
         quit,
         requestQuit,
@@ -236,7 +258,7 @@ export async function runApp(session, transcriptRoot, environment = {}) {
     });
     const resumeAtLaunch = session.resume === undefined
         ? undefined
-        : openResumedSession(session.resume);
+        : track(openResumedSession(session.resume));
     async function openResumedSession(launch) {
         while (live) {
             const index = await new Promise((resolve) => {
@@ -271,7 +293,7 @@ export async function runApp(session, transcriptRoot, environment = {}) {
         terminal.enter(session.config.reducedMotion);
         stopResize = terminal.onResize(() => guard(() => {
             paint.invalidate();
-            draw();
+            render();
         }));
         stopInput = terminal.onInput((chunk) => guard(() => {
             if (escapeTimer !== undefined)
@@ -305,6 +327,7 @@ export async function runApp(session, transcriptRoot, environment = {}) {
     finally {
         try {
             quit();
+            await activeWorkflow;
         }
         finally {
             await session.persistence?.close();

package/dist/tui/blocks.js

@@ -13,8 +13,6 @@ export function render(block, width, pal, context = {}) {
         case "tool":
             return renderTool(block, width, pal, {
                 continues: context.previous?.kind === "tool",
-                spin: context.spin,
-                reducedMotion: context.reducedMotion,
                 now: context.now,
             });
         case "notice":

package/dist/tui/components/tool.js

@@ -10,7 +10,7 @@ export function renderTool(block, width, pal, context = {}) {
         ...(context.continues === true ? [] : [""]),
         row(width, [
             { text: " " },
-            { text: `${stateGlyph(block, context)} `, fg: statusInk(block.tone, pal), bold: true },
+            { text: `${stateGlyph(block)} `, fg: statusInk(block.tone, pal), bold: true },
             { text: block.name, fg: pal.ink.bright, bold: true },
             ...(block.target === "" ? [] : [{ text: `  ${block.target}`, fg: pal.technical }]),
         ], right === "" ? [] : [{ text: right, fg: statusInk(block.tone, pal) }]),
@@ -81,13 +81,9 @@ function emphasized(text, emphasis, fg) {
         ...(end === text.length ? [] : [{ text: text.slice(end), fg }]),
     ];
 }
-function stateGlyph(block, context) {
-    if (block.tone === "pending") {
-        if (block.startedAt === undefined || context.reducedMotion === true)
-            return "◌";
-        const frames = ["◐", "◓", "◑", "◒"];
-        return frames[Math.floor((context.spin ?? 0) / 2) % frames.length];
-    }
+function stateGlyph(block) {
+    if (block.tone === "pending")
+        return "◌";
     if (block.tone === "fail")
         return hasColor() ? "●" : "×";
     if (block.tone === "deny")

package/dist/tui/session-view.js

@@ -1,13 +1,14 @@
 // Small projections of the live session used by the shell and footer.
 import { credentialSource } from "../credentials.js";
 import { providerFailure } from "../provider-errors.js";
-export function controllerOptions(session, tools = session.tools) {
+export function controllerOptions(session, contextPolicy, tools = session.tools) {
     return {
         provider: session.provider,
         tools,
         model: session.model,
         system: session.system,
         maxTokens: session.config.maxTokens,
+        contextPolicy,
         effort: session.config.effort,
         maxSteps: session.config.maxSteps,
         toolContext: { root: session.config.root },

package/dist/tui/transcript-view.js

@@ -1,138 +1,210 @@
 // Incremental transcript layout for long-running sessions.
 import { render } from "./blocks.js";
+const MAX_LAYOUTS = 2;
+const REFLOW_BLOCKS_PER_FRAME = 128;
 /**
- * Keep block rows and cumulative row ends between frames.
+ * Keep recent widths and reflow a bounded working set on each frame.
  *
- * The app mutates semantic blocks while streaming, so it marks that one block
- * dirty. Appends then cost one render, stable frames cost no block renders,
- * and viewport selection starts with a binary search instead of flattening or
- * scanning the complete transcript.
+ * The visible window is always rendered before it is returned. Older rows use
+ * their last known height only to guide scrolling while the remaining blocks
+ * are refreshed over later frames. This keeps resize responsive without a
+ * worker, hidden loop, or unbounded multi-width cache.
  */
 export function transcriptRenderer(draw = render) {
-    let source;
-    let layoutWidth = -1;
-    let layoutPalette;
-    let entries = [];
-    let ends = [];
-    let positions = new WeakMap();
-    const dirty = new Set();
+    let layouts = [];
     return {
         viewport(blocks, width, height, scroll, palette, state = {}) {
-            sync(blocks, width, palette, state);
-            const visibleHeight = Math.max(0, height);
-            const totalRows = ends.at(-1) ?? 0;
-            const maxScroll = Math.max(0, totalRows - visibleHeight);
-            const offset = Math.min(Math.max(0, scroll), maxScroll);
-            const start = Math.max(0, totalRows - visibleHeight - offset);
-            const end = start + visibleHeight;
-            const rows = [];
-            let index = firstEndingAfter(start);
-            let at = index === 0 ? 0 : (ends[index - 1] ?? 0);
-            while (index < entries.length && at < end) {
-                const blockRows = entries[index]?.rows ?? [];
-                rows.push(...blockRows.slice(Math.max(0, start - at), Math.min(blockRows.length, end - at)));
-                at = ends[index] ?? at;
-                index++;
-            }
-            while (rows.length < visibleHeight)
-                rows.unshift("");
-            return { rows, maxScroll };
+            const layout = layoutFor(blocks, width, palette);
+            // 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.
+            if (scroll === 0)
+                reflowBatch(layout, state);
+            const window = reflowWindow(layout, Math.max(0, height), scroll, state);
+            return {
+                rows: visibleRows(layout, window, Math.max(0, height)),
+                maxScroll: window.maxScroll,
+                pending: scroll === 0 && layout.pending > 0,
+            };
         },
         invalidate(block) {
-            if (block !== undefined) {
-                dirty.add(block);
+            if (block === undefined) {
+                layouts = [];
                 return;
             }
-            source = undefined;
-            entries = [];
-            ends = [];
-            positions = new WeakMap();
-            dirty.clear();
+            for (const layout of layouts) {
+                const index = layout.positions.get(block);
+                if (index === undefined)
+                    continue;
+                const entry = layout.entries[index];
+                if (entry?.rows !== undefined) {
+                    entry.rows = undefined;
+                    layout.pending++;
+                }
+                layout.next = Math.max(layout.next, index);
+            }
         },
     };
-    function sync(blocks, width, palette, state) {
-        if (source !== blocks ||
-            layoutWidth !== width ||
-            layoutPalette !== palette ||
-            blocks.length < entries.length ||
-            edgeChanged(blocks)) {
-            rebuild(blocks, width, palette, state);
-            return;
+    function layoutFor(blocks, width, palette) {
+        const cachedAt = layouts.findIndex((layout) => layout.width === width && layout.palette === palette);
+        if (cachedAt !== -1) {
+            const cached = layouts[cachedAt];
+            layouts.splice(cachedAt, 1);
+            if (compatible(cached, blocks)) {
+                append(cached, blocks);
+                layouts.push(cached);
+                return cached;
+            }
         }
-        append(blocks, width, palette, state);
-        refreshDirty(width, palette, state);
+        const seed = [...layouts].reverse().find((layout) => compatiblePrefix(layout, blocks));
+        const created = createLayout(blocks, width, palette, seed);
+        layouts.push(created);
+        if (layouts.length > MAX_LAYOUTS)
+            layouts.shift();
+        return created;
     }
-    function rebuild(blocks, width, palette, state) {
-        source = blocks;
-        layoutWidth = width;
-        layoutPalette = palette;
-        entries = [];
-        ends = [];
-        positions = new WeakMap();
-        dirty.clear();
-        append(blocks, width, palette, state);
+    function createLayout(blocks, width, palette, seed) {
+        const layout = {
+            source: blocks,
+            width,
+            palette,
+            entries: [],
+            ends: [],
+            positions: new WeakMap(),
+            pending: 0,
+            next: -1,
+        };
+        append(layout, blocks, seed);
+        return layout;
     }
-    function append(blocks, width, palette, state) {
-        let total = ends.at(-1) ?? 0;
-        for (let index = entries.length; index < blocks.length; index++) {
+    function append(layout, blocks, seed) {
+        const firstAdded = layout.entries.length;
+        let total = layout.ends.at(-1) ?? 0;
+        for (let index = firstAdded; index < blocks.length; index++) {
             const block = blocks[index];
             if (block === undefined)
                 continue;
-            const rows = draw(block, width, palette, { ...state, previous: blocks[index - 1] });
-            entries.push({ block, rows });
-            positions.set(block, index);
-            dirty.delete(block);
-            total += rows.length;
-            ends.push(total);
+            const seeded = seed?.entries[index];
+            const rowCount = seeded?.block === block ? seeded.rowCount : estimatedRows(block);
+            layout.entries.push({ block, rowCount });
+            layout.positions.set(block, index);
+            layout.pending++;
+            total += rowCount;
+            layout.ends.push(total);
+        }
+        if (layout.entries.length > firstAdded) {
+            layout.next = Math.max(layout.next, layout.entries.length - 1);
         }
     }
-    function refreshDirty(width, palette, state) {
-        if (dirty.size === 0)
-            return;
-        const changed = [...dirty]
-            .map((block) => positions.get(block))
-            .filter((index) => index !== undefined)
-            .sort((left, right) => left - right);
-        dirty.clear();
-        if (changed.length === 0)
-            return;
-        const first = changed[0];
-        for (const index of changed) {
-            const entry = entries[index];
-            if (entry !== undefined) {
-                entry.rows = draw(entry.block, width, palette, {
-                    ...state,
-                    previous: entries[index - 1]?.block,
-                });
+    function reflowBatch(layout, state) {
+        let remaining = REFLOW_BLOCKS_PER_FRAME;
+        let firstChanged = layout.entries.length;
+        let index = layout.next;
+        while (index >= 0 && remaining > 0 && layout.pending > 0) {
+            if (renderEntry(layout, index, state)) {
+                firstChanged = Math.min(firstChanged, index);
+                remaining--;
             }
+            index--;
         }
-        recomputeEnds(first);
+        layout.next = index;
+        if (firstChanged < layout.entries.length)
+            recomputeEnds(layout, firstChanged);
     }
-    function recomputeEnds(from) {
-        let total = from === 0 ? 0 : (ends[from - 1] ?? 0);
-        for (let index = from; index < entries.length; index++) {
-            total += entries[index]?.rows.length ?? 0;
-            ends[index] = total;
+    function reflowWindow(layout, height, scroll, state) {
+        while (true) {
+            const window = visibleWindow(layout, height, scroll);
+            let firstChanged = layout.entries.length;
+            for (let index = window.first; index <= window.last; index++) {
+                if (renderEntry(layout, index, state))
+                    firstChanged = Math.min(firstChanged, index);
+            }
+            if (firstChanged === layout.entries.length)
+                return window;
+            recomputeEnds(layout, firstChanged);
         }
     }
-    function edgeChanged(blocks) {
-        if (entries.length === 0)
+    function renderEntry(layout, index, state) {
+        const entry = layout.entries[index];
+        if (entry === undefined || entry.rows !== undefined)
             return false;
-        const lastShared = Math.min(blocks.length, entries.length) - 1;
-        return lastShared < 0 ||
-            entries[0]?.block !== blocks[0] ||
-            entries[lastShared]?.block !== blocks[lastShared];
+        entry.rows = draw(entry.block, layout.width, layout.palette, {
+            ...state,
+            previous: layout.entries[index - 1]?.block,
+        });
+        entry.rowCount = entry.rows.length;
+        layout.pending--;
+        return true;
+    }
+    function recomputeEnds(layout, from) {
+        let total = from === 0 ? 0 : (layout.ends[from - 1] ?? 0);
+        for (let index = from; index < layout.entries.length; index++) {
+            total += layout.entries[index]?.rowCount ?? 0;
+            layout.ends[index] = total;
+        }
     }
-    function firstEndingAfter(row) {
-        let low = 0;
-        let high = ends.length;
-        while (low < high) {
-            const middle = Math.floor((low + high) / 2);
-            if ((ends[middle] ?? 0) <= row)
-                low = middle + 1;
-            else
-                high = middle;
+    function visibleWindow(layout, height, scroll) {
+        const totalRows = layout.ends.at(-1) ?? 0;
+        const maxScroll = Math.max(0, totalRows - height);
+        const offset = Math.min(Math.max(0, scroll), maxScroll);
+        const start = Math.max(0, totalRows - height - offset);
+        const end = start + height;
+        const first = firstEndingAfter(layout.ends, start);
+        let last = first - 1;
+        let at = first === 0 ? 0 : (layout.ends[first - 1] ?? 0);
+        while (last + 1 < layout.entries.length && at < end) {
+            last++;
+            at = layout.ends[last] ?? at;
         }
-        return low;
+        return { first, last, start, end, maxScroll };
+    }
+    function visibleRows(layout, window, height) {
+        const rows = [];
+        let index = window.first;
+        let at = index === 0 ? 0 : (layout.ends[index - 1] ?? 0);
+        while (index <= window.last && at < window.end) {
+            const blockRows = layout.entries[index]?.rows ?? [];
+            rows.push(...blockRows.slice(Math.max(0, window.start - at), Math.min(blockRows.length, window.end - at)));
+            at = layout.ends[index] ?? at;
+            index++;
+        }
+        while (rows.length < height)
+            rows.unshift("");
+        return rows;
+    }
+}
+function compatible(layout, blocks) {
+    return layout.source === blocks &&
+        blocks.length >= layout.entries.length &&
+        !edgeChanged(layout, blocks);
+}
+function compatiblePrefix(layout, blocks) {
+    if (layout.entries.length === 0 || blocks.length === 0)
+        return true;
+    const shared = Math.min(layout.entries.length, blocks.length);
+    return layout.entries[0]?.block === blocks[0] &&
+        layout.entries[shared - 1]?.block === blocks[shared - 1];
+}
+function edgeChanged(layout, blocks) {
+    if (layout.entries.length === 0)
+        return false;
+    const lastShared = Math.min(blocks.length, layout.entries.length) - 1;
+    return lastShared < 0 ||
+        layout.entries[0]?.block !== blocks[0] ||
+        layout.entries[lastShared]?.block !== blocks[lastShared];
+}
+function estimatedRows(block) {
+    return block.kind === "user" ? 4 : 2;
+}
+function firstEndingAfter(ends, row) {
+    let low = 0;
+    let high = ends.length;
+    while (low < high) {
+        const middle = Math.floor((low + high) / 2);
+        if ((ends[middle] ?? 0) <= row)
+            low = middle + 1;
+        else
+            high = middle;
     }
+    return low;
 }

package/dist/tui/view.js

@@ -25,11 +25,16 @@ 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, { spin: view.spin, reducedMotion: view.reducedMotion, now: view.now });
+    const viewport = transcript.viewport(view.blocks, width, transcriptHeight, view.scroll, view.pal, { now: view.now });
     const cursor = dock.cursor === undefined
         ? undefined
         : { row: transcriptHeight + dock.cursor.row, col: dock.cursor.col };
-    return { rows: [...viewport.rows, ...dock.rows], cursor, maxScroll: viewport.maxScroll };
+    return {
+        rows: [...viewport.rows, ...dock.rows],
+        cursor,
+        maxScroll: viewport.maxScroll,
+        transcriptPending: viewport.pending,
+    };
 }
 function dockRows(view, width, height) {
     const status = renderStatus({
@@ -82,5 +87,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 };
+    return { rows, maxScroll: 0, transcriptPending: false };
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@giovannijecha/jecode",
-  "version": "0.7.1",
+  "version": "0.7.3",
   "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",