@giovannijecha/jecode 0.8.4 → 0.8.6

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 &&

package/dist/tui/turn-workflow.js

@@ -0,0 +1,264 @@
+// One model turn, including steering, compaction, durable settlement, and recovery.
+import { runTurn } from "../controller.js";
+import { resolveContextPolicy } from "../context/capacity.js";
+import { automaticCompactionKey } from "../context/automatic.js";
+import { compactContext } from "../context/compactor.js";
+import { isContextOverflow } from "../context/policy.js";
+import { steeringInbox } from "../steering.js";
+import { recordAuxiliaryUsage, recordRequestInput, recordUsage } from "../usage.js";
+import { toolSpecs } from "../tools/index.js";
+import { requestIdentityForSession } from "../request-identity.js";
+import { transition } from "./activity.js";
+import { answerAt } from "./approve.js";
+import * as edit from "./editor.js";
+import { controllerOptions, turnFailure } from "./session-view.js";
+import { transcribe } from "./turn.js";
+const WAITING = "Waiting";
+export function turnWorkflow(options, automaticCompaction) {
+    const { session, state, permissions, feedback } = options;
+    let activeSteering;
+    async function turn(text) {
+        const activity = options.startActivity("turn", WAITING);
+        if (activity === undefined)
+            return;
+        const inbox = steeringInbox((pending, accepting) => {
+            if (activeSteering !== inbox)
+                return;
+            state.steering = accepting ? pending : undefined;
+            options.render();
+        });
+        activeSteering = inbox;
+        state.steering = 0;
+        const status = (label) => transition(activity, label);
+        const parentId = session.conversation.activeNodeId;
+        const history = session.conversation.history;
+        const modelHistory = session.conversation.contextHistory;
+        const historyStart = history.length;
+        const blockStart = state.blocks.length;
+        const createdAt = new Date().toISOString();
+        const prospectiveNodeId = session.conversation.nodes.length + 1;
+        let nodeId;
+        let context;
+        const unpersistedSteering = [];
+        const turnTools = permissions.availableTools();
+        const specs = toolSpecs(turnTools);
+        let firstPolicy = true;
+        const policy = () => {
+            let visible = firstPolicy;
+            firstPolicy = false;
+            if (visible) {
+                status("Checking context");
+                options.render();
+            }
+            return resolveContextPolicy({
+                provider: session.provider,
+                model: session.model,
+                compactionPercent: session.config.compactionPercent,
+                signal: activity.control.signal,
+                onStatus: (said) => {
+                    visible = true;
+                    status(said);
+                    options.render();
+                },
+            }).finally(() => {
+                if (visible) {
+                    status(WAITING);
+                    options.render();
+                }
+            });
+        };
+        options.emit({ kind: "user", text });
+        const user = { role: "user", content: [{ kind: "text", text }] };
+        history.push(user);
+        modelHistory.push(structuredClone(user));
+        const events = transcribe({
+            emit: options.emit,
+            render: options.render,
+            palette: session.palette,
+            approved: (call) => permissions.approved(call),
+            remember: (call) => permissions.remember(call),
+            ask: (prompt, settle) => {
+                state.open = { picker: prompt, settle: (index) => settle(answerAt(index)) };
+                options.render();
+            },
+            status: (text) => {
+                status(text);
+            },
+            usage: (usage) => recordUsage(session.usage, usage),
+            requestInput: (inputTokens) => recordRequestInput(session.usage, inputTokens),
+        });
+        const persist = async (checkpoint, settlement, failure) => {
+            const next = session.conversation.commit({
+                ...(nodeId === undefined ? {} : { nodeId }),
+                parentId,
+                createdAt,
+                identity: {
+                    providerId: session.provider.id,
+                    model: session.model,
+                    effort: session.config.effort,
+                },
+                messages: checkpoint.slice(historyStart),
+                blocks: state.blocks.slice(blockStart),
+                ...(context === undefined ? {} : { context }),
+                ...(failure === undefined ? {} : { failure }),
+            }, settlement);
+            await session.persistence?.checkpoint(next);
+            session.conversation = next;
+            nodeId = next.activeNodeId;
+            state.committedNodeId = next.activeNodeId;
+            unpersistedSteering.length = 0;
+        };
+        const compact = async (checkpoint, projected, request) => {
+            if (request.reason === "overflow" &&
+                (request.error === undefined || !isContextOverflow(request.error))) {
+                return undefined;
+            }
+            const force = request.reason === "overflow" || request.projectionSaturated;
+            const key = automaticCompactionKey(session.provider.id, session.model, nodeId ?? prospectiveNodeId, checkpoint.length);
+            const attempt = { key, reason: request.reason };
+            if (!automaticCompaction.allows(attempt))
+                return undefined;
+            let attempted = false;
+            const result = await compactContext({
+                provider: session.provider,
+                model: session.model,
+                effort: session.config.effort,
+                context: projected,
+                turn: checkpoint.slice(historyStart),
+                nodeId: nodeId ?? prospectiveNodeId,
+                coveredMessages: context?.messageCount ?? 0,
+                lastInputTokens: Math.max(session.usage.lastInputTokens, request.inputTokens),
+                estimatedInputTokens: request.inputTokens,
+                signal: activity.control.signal,
+                force,
+                policy: request.policy,
+                requestEnvelope: {
+                    system: session.system,
+                    tools: specs,
+                    maxOutputTokens: session.config.maxTokens,
+                },
+                requestIdentity: requestIdentityForSession(session),
+                onBegin: () => {
+                    attempted = true;
+                    status("Compacting");
+                    options.render();
+                },
+                onEnd: () => {
+                    status(WAITING);
+                    options.render();
+                },
+            });
+            if (result === undefined) {
+                if (attempted && !activity.control.signal.aborted)
+                    automaticCompaction.failed(attempt);
+                return undefined;
+            }
+            automaticCompaction.succeeded(attempt);
+            context = result.anchor;
+            if (result.usage !== undefined)
+                recordAuxiliaryUsage(session.usage, result.usage);
+            return result.messages;
+        };
+        events.onContext = compact;
+        events.onSteering = (guidance) => {
+            unpersistedSteering.push(guidance);
+            options.emit({ kind: "user", text: guidance });
+            options.render();
+        };
+        events.onCheckpoint = async (checkpoint, settlement, projected) => {
+            await persist(checkpoint, settlement);
+            const compacted = await compact(checkpoint, projected, {
+                reason: "budget",
+                policy: await policy(),
+                inputTokens: session.usage.lastInputTokens,
+                projectionSaturated: false,
+            });
+            if (compacted !== undefined)
+                await persist(checkpoint, settlement);
+            return compacted;
+        };
+        let finishReason;
+        let failed;
+        try {
+            await runTurn(history, controllerOptions(session, policy, turnTools, inbox), events, activity.control.signal, modelHistory);
+        }
+        catch (error) {
+            const interrupted = activity.control.signal.aborted;
+            const completed = nodeId !== undefined && session.conversation.activeNodeId === nodeId &&
+                session.conversation.activeNode?.settlement === "completed";
+            if (completed) {
+                const notice = turnFailure(session, error, interrupted);
+                feedback.show({ text: notice.text, tone: notice.tone, timeoutMs: 6_000 });
+            }
+            else {
+                finishReason = interrupted ? "interrupted" : "failed";
+                failed = { error: error, interrupted };
+            }
+        }
+        finally {
+            let pendingSteering = inbox.close();
+            if (activeSteering === inbox)
+                activeSteering = undefined;
+            state.steering = undefined;
+            try {
+                events.finish(finishReason);
+                if (failed !== undefined) {
+                    const notice = turnFailure(session, failed.error, failed.interrupted);
+                    const settlement = failed.interrupted ? "interrupted" : "failed";
+                    const failure = {
+                        text: notice.text,
+                        tone: failed.interrupted ? "warn" : "error",
+                    };
+                    options.emit(notice);
+                    try {
+                        await persist(closeFailedTurn(history, settlement), settlement, failure);
+                    }
+                    catch (error) {
+                        // A failed persistence boundary cannot remain visible as if it had
+                        // been saved. Revert to the last durable path and return the input
+                        // to the composer so the user can retry without losing it.
+                        options.replaceTranscript();
+                        state.editor = edit.of([
+                            ...(nodeId === undefined ? [text] : []),
+                            ...unpersistedSteering,
+                            ...pendingSteering,
+                            state.editor.text,
+                        ].filter((part) => part !== "").join("\n\n"));
+                        state.completing = undefined;
+                        pendingSteering = [];
+                        feedback.show({
+                            text: error.message,
+                            tone: "error",
+                            timeoutMs: 6_000,
+                        });
+                    }
+                }
+            }
+            finally {
+                restorePendingSteering(state, pendingSteering);
+                options.finishActivity(activity);
+            }
+        }
+    }
+    function steer(text) {
+        return activeSteering?.offer(text) ?? "unavailable";
+    }
+    return { turn, steer };
+}
+function restorePendingSteering(state, messages) {
+    if (messages.length === 0)
+        return;
+    const pending = messages.join("\n\n");
+    state.editor = edit.of(state.editor.text === "" ? pending : `${pending}\n\n${state.editor.text}`);
+    state.completing = undefined;
+}
+function closeFailedTurn(history, settlement) {
+    const closed = [...history];
+    if (closed.at(-1)?.role === "assistant")
+        return closed;
+    const text = settlement === "interrupted"
+        ? "The previous attempt was interrupted by the user before completion."
+        : "The previous attempt failed before completion.";
+    closed.push({ role: "assistant", content: [{ kind: "text", text }] });
+    return closed;
+}