@giovannijecha/jecode 0.8.5 → 0.8.7

package/dist/tui/app-workflows.js

@@ -1,364 +1,16 @@
-// Foreground command and model-turn workflows for the TUI shell.
-import { handleCommand } from "../commands.js";
-import { runTurn } from "../controller.js";
-import { resolveContextPolicy } from "../context/capacity.js";
-import { automaticCompactionGate, automaticCompactionKey, } from "../context/automatic.js";
-import { compactContext } from "../context/compactor.js";
-import { compactSession } from "../context/manual.js";
-import { isContextOverflow } from "../context/policy.js";
-import { updateSettings } from "../settings.js";
-import { steeringInbox } from "../steering.js";
-import { saveTranscript } from "../transcript-export.js";
-import { recordAuxiliaryUsage, recordRequestInput, recordUsage } from "../usage.js";
-import { selectTimeline } from "../timeline.js";
-import { toolSpecs } from "../tools/index.js";
-import { resetRequestIdentity, requestIdentityForSession } from "../request-identity.js";
-import { transition } from "./activity.js";
-import { answerAt } from "./approve.js";
-import * as edit from "./editor.js";
-import { cancel as cancelOpen } from "./overlay.js";
-import { controllerOptions, turnFailure } from "./session-view.js";
-import { transcribe } from "./turn.js";
-const WAITING = "Waiting";
+// Wire foreground workflows to the shell and their shared compaction lifetime.
+import { automaticCompactionGate } from "../context/automatic.js";
+import { inputLifetime } from "../context/lifetime.js";
+import { commandWorkflow } from "./command-workflow.js";
+import { turnWorkflow } from "./turn-workflow.js";
 export function appWorkflows(options) {
-    const { session, state, permissions, feedback } = options;
-    let activeSteering;
     const automaticCompaction = automaticCompactionGate();
-    const choose = (picker) => new Promise((resolve) => {
-        state.open = { picker, settle: resolve };
-        options.render();
-    });
-    async function command(text) {
-        const activity = options.startActivity("command", `Running ${text.split(/\s+/)[0]}`);
-        if (activity === undefined)
-            return;
-        const status = (label) => transition(activity, label);
-        try {
-            const outcome = await handleCommand(text, session, {
-                emit: options.commandNotice,
-                signal: activity.control.signal,
-                showHelp: () => new Promise((resolve) => {
-                    state.open = { help: true, settle: resolve };
-                    options.render();
-                }),
-                choose,
-                dismiss: () => {
-                    state.open = state.open === undefined ? undefined : cancelOpen(state.open);
-                    options.render();
-                },
-                type: (field) => new Promise((resolve) => {
-                    state.open = { field, settle: resolve };
-                    options.render();
-                }),
-                status: (said) => {
-                    status(said ?? activity.label);
-                    options.render();
-                },
-                reset: async () => {
-                    await session.persistence?.reset();
-                    resetRequestIdentity(session);
-                    automaticCompaction.reset();
-                    state.blocks.splice(0);
-                    state.past.length = 0;
-                    permissions.reset();
-                    state.scroll = 0;
-                    state.follow = true;
-                    state.unseen = 0;
-                    state.lastMaxScroll = 0;
-                    state.committedNodeId = 0;
-                },
-                permissions,
-                exportTranscript: () => saveTranscript(options.transcriptRoot, state.blocks),
-                saveSettings: async (patch) => {
-                    await updateSettings(patch);
-                },
-                refreshSettings: options.refreshSettings,
-                timeline: async () => {
-                    const selected = await selectTimeline(session, choose);
-                    if (!selected)
-                        return "unchanged";
-                    options.replaceTranscript();
-                    return session.conversation.activeNodeId === state.committedNodeId
-                        ? "unchanged"
-                        : "selected";
-                },
-                compact: async () => {
-                    if (session.conversation.activeNodeId !== state.committedNodeId) {
-                        return "branch-pending";
-                    }
-                    const result = await compactSession(session, {
-                        signal: activity.control.signal,
-                        onStatus: (said) => {
-                            status(said ?? activity.label);
-                            options.render();
-                        },
-                    });
-                    if (result === "compacted")
-                        automaticCompaction.reset();
-                    return result;
-                },
-            });
-            if (outcome === "exit")
-                state.closeWhenIdle = true;
-        }
-        catch (error) {
-            // Command cancellation is already visible through the dock closing and
-            // the activity ending. Keep it silent instead of replacing the footer
-            // with a redundant warning.
-            if (!activity.control.signal.aborted) {
-                feedback.show({
-                    text: error.message,
-                    tone: "error",
-                    timeoutMs: 6_000,
-                });
-            }
-        }
-        finally {
-            options.finishActivity(activity);
-        }
-    }
-    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 { command, 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;
+    const inputs = inputLifetime();
+    return {
+        command: commandWorkflow(options, () => {
+            automaticCompaction.reset();
+            inputs.reset();
+        }, () => inputs.reset()),
+        ...turnWorkflow(options, automaticCompaction, inputs),
+    };
 }

package/dist/tui/app.js

@@ -34,7 +34,7 @@ export async function runApp(session, transcriptRoot, environment = {}) {
     const state = appState();
     state.blocks.push(...session.conversation.transcript);
     state.committedNodeId = session.conversation.activeNodeId;
-    const permissions = sessionPermissions(session.tools, session.config.autoApprove);
+    const permissions = sessionPermissions(session.tools);
     let closed;
     let frameTimer;
     let motionTimer;
@@ -42,9 +42,10 @@ export async function runApp(session, transcriptRoot, environment = {}) {
     let escapeTimer;
     let stopResize = () => { };
     let stopInput = () => { };
+    let stopOutput = () => { };
     let stopShutdown = () => { };
     let failure;
-    let activeWorkflow;
+    const activeWorkflows = new Set();
     // 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;
@@ -61,22 +62,25 @@ export async function runApp(session, transcriptRoot, environment = {}) {
     };
     const view = () => {
         const now = Date.now();
+        const activity = state.command !== undefined && state.open === undefined && state.approval === undefined
+            ? state.command : state.activity ?? state.command;
         return {
             blocks: state.blocks,
             editor: state.editor,
             scroll: state.scroll,
             unseen: state.unseen,
             pal: session.palette,
-            footer: footerInfo(session, workspace),
-            status: state.activity === undefined
+            footer: state.turnFooter === undefined ? footerInfo(session, workspace) : { ...state.turnFooter, workspace },
+            status: activity === undefined
                 ? undefined
-                : activityStatus(state.activity, now),
-            steering: state.steering,
+                : activityStatus(activity, now),
+            turnActive: state.activity !== undefined,
+            steering: state.command === undefined ? state.steering : undefined,
             feedback: state.feedback,
             readiness: turnBlocker(session),
             now,
             reducedMotion: session.config.reducedMotion,
-            modal: overlay.shown(state.open),
+            modal: overlay.shown(state.approval ?? state.open),
             menu: completionOptions(state.completing),
             menuIndex: state.completing?.index,
         };
@@ -143,8 +147,8 @@ export async function runApp(session, transcriptRoot, environment = {}) {
         if (state.follow)
             state.unseen = 0;
     };
-    const replaceTranscript = () => {
-        state.blocks.splice(0, state.blocks.length, ...session.conversation.transcript);
+    const replaceTranscript = (blocks = session.conversation.transcript) => {
+        state.blocks.splice(0, state.blocks.length, ...blocks);
         state.scroll = 0;
         state.follow = true;
         state.unseen = 0;
@@ -158,6 +162,7 @@ export async function runApp(session, transcriptRoot, environment = {}) {
             return;
         live = false;
         safely(stopInput);
+        safely(stopOutput);
         safely(stopResize);
         safely(stopShutdown);
         if (activityTimer !== undefined)
@@ -183,35 +188,42 @@ export async function runApp(session, transcriptRoot, environment = {}) {
     function fail(error) {
         failure ??= { error };
         state.open = overlay.cancel(state.open);
+        state.approval = overlay.cancel(state.approval);
         state.activity?.control.abort(error);
+        state.command?.control.abort(error);
         quit();
     }
     function track(work) {
         const tracked = work
             .catch((error) => fail(error))
             .finally(() => {
-            if (activeWorkflow === tracked)
-                activeWorkflow = undefined;
+            activeWorkflows.delete(tracked);
         });
-        activeWorkflow = tracked;
+        activeWorkflows.add(tracked);
         return tracked;
     }
     function requestQuit(reason = new Error("interrupted")) {
         state.open = overlay.cancel(state.open);
-        const activity = state.activity;
-        if (activity === undefined) {
+        state.approval = overlay.cancel(state.approval);
+        if (state.activity === undefined && state.command === undefined) {
             quit();
             return;
         }
         state.closeWhenIdle = true;
-        activity.control.abort(reason);
+        state.activity?.control.abort(reason);
+        state.command?.control.abort(reason);
     }
     function startActivity(kind, label) {
-        if (state.activity !== undefined)
+        if (state.closeWhenIdle)
+            return undefined;
+        if (state.command !== undefined || (kind === "turn" && state.activity !== undefined))
             return undefined;
         const activity = begin(kind, label);
-        state.activity = activity;
-        activityTimer = setInterval(() => guard(() => {
+        if (kind === "turn")
+            state.activity = activity;
+        else
+            state.command = activity;
+        activityTimer ??= setInterval(() => guard(() => {
             let activeTool;
             for (let index = state.blocks.length - 1; index >= 0; index--) {
                 const block = state.blocks[index];
@@ -226,14 +238,23 @@ export async function runApp(session, transcriptRoot, environment = {}) {
         return activity;
     }
     function finishActivity(activity) {
-        if (state.activity !== activity)
+        if (state.activity === activity) {
+            state.activity = undefined;
+            state.turnFooter = undefined;
+            state.approval = overlay.cancel(state.approval);
+        }
+        else if (state.command === activity) {
+            state.command = undefined;
+            state.open = overlay.cancel(state.open);
+        }
+        else
             return;
-        if (activityTimer !== undefined)
+        const idle = state.activity === undefined && state.command === undefined;
+        if (idle && activityTimer !== undefined) {
             clearInterval(activityTimer);
-        activityTimer = undefined;
-        state.activity = undefined;
-        state.open = overlay.cancel(state.open);
-        if (state.closeWhenIdle)
+            activityTimer = undefined;
+        }
+        if (state.closeWhenIdle && idle)
             quit();
         else
             render();
@@ -273,9 +294,6 @@ export async function runApp(session, transcriptRoot, environment = {}) {
         invalidate: () => paint.invalidate(),
         transcriptChanged: (block) => transcript.invalidate(block),
     });
-    const resumeAtLaunch = session.resume === undefined
-        ? undefined
-        : track(openResumedSession(session.resume));
     async function openResumedSession(launch) {
         while (live) {
             const index = await new Promise((resolve) => {
@@ -314,6 +332,7 @@ export async function runApp(session, transcriptRoot, environment = {}) {
         shutdownSignal?.addEventListener("abort", onShutdown, { once: true });
         stopShutdown = () => shutdownSignal?.removeEventListener("abort", onShutdown);
         terminal.enter(session.config.reducedMotion);
+        stopOutput = paint.onReady?.(() => guard(() => render())) ?? (() => { });
         stopResize = terminal.onResize(() => guard(() => {
             paint.invalidate();
             render();
@@ -339,6 +358,9 @@ export async function runApp(session, transcriptRoot, environment = {}) {
             }), ESCAPE_MS);
             render();
         }));
+        const resumeAtLaunch = session.resume === undefined
+            ? undefined
+            : track(openResumedSession(session.resume));
         draw();
         if (resumeAtLaunch !== undefined)
             await Promise.race([resumeAtLaunch, done]);
@@ -347,10 +369,15 @@ export async function runApp(session, transcriptRoot, environment = {}) {
         if (failure !== undefined)
             throw failure.error;
     }
+    catch (error) {
+        // Startup failures must settle pending menus before teardown waits for work.
+        fail(error);
+        throw error;
+    }
     finally {
         try {
             quit();
-            await activeWorkflow;
+            await Promise.allSettled([...activeWorkflows]);
         }
         finally {
             await session.persistence?.close();

package/dist/tui/approve.js

@@ -16,13 +16,14 @@ export { scopeFor };
 export function promptFor(call, target, pal) {
     const scope = scopeFor(call);
     const options = [
-        { label: "Yes, once", hint: "enter", key: "y" },
+        { label: "Yes, once", hint: "y", key: "y" },
         { label: `Yes, ${scopeNoun(scope)} for the session`, hint: "a", key: "a" },
-        { label: "No, and say why", hint: "esc", key: "n" },
+        { label: "No, and say why", hint: "n", key: "n" },
     ];
     return {
         title: [{ text: question(call.name), fg: pal.ink.attention, bold: true }],
         right: `${call.name}${target === "" ? "" : ` · ${target}`}`,
+        controls: "↑↓ choose · enter confirm · esc deny",
         options,
         index: 0,
     };

package/dist/tui/blocks.js

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