@giovannijecha/jecode 0.7.0 → 0.7.2

package/dist/timeline.js

@@ -7,7 +7,7 @@ import { usageFromHistory } from "./usage.js";
 import { heading } from "./tui/picker.js";
 export function timelinePicker(conversation, palette) {
     const entries = timelineEntries(conversation);
-    const selectedId = conversation.latestCompleted()?.activeNodeId ?? 0;
+    const selectedId = conversation.latestResumable()?.activeNodeId ?? 0;
     const index = Math.max(0, entries.findIndex((entry) => entry.node.id === selectedId));
     return Object.freeze({
         picker: {
@@ -18,7 +18,7 @@ export function timelinePicker(conversation, palette) {
             options: entries.map((entry) => ({
                 label: `${entry.prefix}${preview(entry.node)}`,
                 hint: stamp(entry.node.createdAt),
-                ...(entry.node.id === selectedId ? { value: "active" } : {}),
+                ...timelineValue(entry.node, selectedId),
             })),
             index,
         },
@@ -38,12 +38,12 @@ export async function selectTimeline(session, choose) {
     return true;
 }
 function timelineEntries(conversation) {
-    const completed = conversation.nodes.filter((node) => node.settlement === "completed");
-    const completedIds = new Set(completed.map((node) => node.id));
+    const resumable = conversation.nodes.filter((node) => node.settlement !== "checkpointed");
+    const resumableIds = new Set(resumable.map((node) => node.id));
     const children = new Map();
-    for (const node of completed) {
+    for (const node of resumable) {
         let parentId = node.parentId;
-        while (parentId !== 0 && !completedIds.has(parentId)) {
+        while (parentId !== 0 && !resumableIds.has(parentId)) {
             parentId = conversation.node(parentId)?.parentId ?? 0;
         }
         const siblings = children.get(parentId) ?? [];
@@ -70,6 +70,12 @@ function timelineEntries(conversation) {
     visit(0, []);
     return entries;
 }
+function timelineValue(node, selectedId) {
+    const state = node.settlement === "completed" ? undefined : node.settlement;
+    const active = node.id === selectedId ? "active" : undefined;
+    const value = [state, active].filter((part) => part !== undefined).join(" · ");
+    return value === "" ? {} : { value };
+}
 function preview(node) {
     for (const message of node.messages) {
         if (message.role !== "user")

package/dist/tui/app-workflows.js

@@ -10,6 +10,7 @@ import { saveTranscript } from "../transcript-export.js";
 import { recordAuxiliaryUsage, recordUsage } from "../usage.js";
 import { selectTimeline } from "../timeline.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";
@@ -136,7 +137,7 @@ export function appWorkflows(options) {
             },
             usage: (usage) => recordUsage(session.usage, usage),
         });
-        const persist = async (checkpoint, settlement) => {
+        const persist = async (checkpoint, settlement, failure) => {
             const next = session.conversation.commit({
                 ...(nodeId === undefined ? {} : { nodeId }),
                 parentId,
@@ -149,6 +150,7 @@ export function appWorkflows(options) {
                 messages: checkpoint.slice(historyStart),
                 blocks: state.blocks.slice(blockStart),
                 ...(context === undefined ? {} : { context }),
+                ...(failure === undefined ? {} : { failure }),
             }, settlement);
             await session.persistence?.checkpoint(next);
             session.conversation = next;
@@ -217,18 +219,65 @@ export function appWorkflows(options) {
             return compacted;
         };
         let finishReason;
+        let failed;
         try {
             await runTurn(history, controllerOptions(session, permissions.availableTools()), events, activity.control.signal, modelHistory);
         }
         catch (error) {
             const interrupted = activity.control.signal.aborted;
-            finishReason = interrupted ? "interrupted" : "failed";
-            options.emit(turnFailure(session, error, interrupted));
+            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 {
-            events.finish(finishReason);
-            options.finishActivity(activity);
+            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(text);
+                        feedback.show({
+                            text: error.message,
+                            tone: "error",
+                            timeoutMs: 6_000,
+                        });
+                    }
+                }
+            }
+            finally {
+                options.finishActivity(activity);
+            }
         }
     }
     return { command, turn };
 }
+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;
+}

package/dist/tui/app.js

@@ -40,12 +40,22 @@ export async function runApp(session, transcriptRoot, environment = {}) {
     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;
     const done = new Promise((resolve) => {
         closed = resolve;
     });
+    const guard = (action) => {
+        try {
+            action();
+        }
+        catch (error) {
+            fail(error);
+        }
+    };
     const view = () => {
         const now = Date.now();
         return {
@@ -94,8 +104,9 @@ export async function runApp(session, transcriptRoot, environment = {}) {
     const render = (block) => {
         if (block !== undefined)
             transcript.invalidate(block);
-        if (live && frameTimer === undefined)
-            frameTimer = setTimeout(draw, FRAME_MS);
+        if (live && frameTimer === undefined) {
+            frameTimer = setTimeout(() => guard(draw), FRAME_MS);
+        }
     };
     const feedback = feedbackController((next) => {
         state.feedback = next;
@@ -131,18 +142,42 @@ export async function runApp(session, transcriptRoot, environment = {}) {
         if (!live)
             return;
         live = false;
-        stopInput();
-        stopResize();
+        safely(stopInput);
+        safely(stopResize);
         if (spinTimer !== undefined)
             clearInterval(spinTimer);
         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) {
@@ -159,7 +194,7 @@ export async function runApp(session, transcriptRoot, environment = {}) {
         const activity = begin(kind, label);
         state.activity = activity;
         state.status = label;
-        spinTimer = setInterval(() => {
+        spinTimer = setInterval(() => guard(() => {
             if (!session.config.reducedMotion)
                 state.spin++;
             let activeTool;
@@ -171,7 +206,7 @@ export async function runApp(session, transcriptRoot, environment = {}) {
                 break;
             }
             render(activeTool);
-        }, session.config.reducedMotion ? 1_000 : SPIN_MS);
+        }), session.config.reducedMotion ? 1_000 : SPIN_MS);
         render();
         return activity;
     }
@@ -212,7 +247,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,
@@ -222,7 +260,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) => {
@@ -253,39 +291,48 @@ export async function runApp(session, transcriptRoot, environment = {}) {
             }
         }
     }
-    terminal.enter(session.config.reducedMotion);
-    stopResize = terminal.onResize(() => {
-        paint.invalidate();
-        draw();
-    });
-    stopInput = terminal.onInput((chunk) => {
-        if (escapeTimer !== undefined)
-            clearTimeout(escapeTimer);
-        for (const key of keys.push(chunk)) {
-            if (!live)
-                break;
-            input.handle(key);
-        }
-        if (!live)
-            return;
-        escapeTimer = setTimeout(() => {
-            escapeTimer = undefined;
+    try {
+        terminal.enter(session.config.reducedMotion);
+        stopResize = terminal.onResize(() => guard(() => {
+            paint.invalidate();
+            draw();
+        }));
+        stopInput = terminal.onInput((chunk) => guard(() => {
+            if (escapeTimer !== undefined)
+                clearTimeout(escapeTimer);
+            for (const key of keys.push(chunk)) {
+                if (!live)
+                    break;
+                input.handle(key);
+            }
             if (!live)
                 return;
-            for (const key of keys.flush())
-                input.handle(key);
-            if (live)
-                render();
-        }, ESCAPE_MS);
-        render();
-    });
-    draw();
-    try {
-        await resumeAtLaunch;
+            escapeTimer = setTimeout(() => guard(() => {
+                escapeTimer = undefined;
+                if (!live)
+                    return;
+                for (const key of keys.flush())
+                    input.handle(key);
+                if (live)
+                    render();
+            }), ESCAPE_MS);
+            render();
+        }));
+        draw();
+        if (resumeAtLaunch !== undefined)
+            await Promise.race([resumeAtLaunch, done]);
         if (live)
             await done;
+        if (failure !== undefined)
+            throw failure.error;
     }
     finally {
-        await session.persistence?.close();
+        try {
+            quit();
+            await activeWorkflow;
+        }
+        finally {
+            await session.persistence?.close();
+        }
     }
 }

package/dist/tui/picker.js

@@ -1,6 +1,6 @@
 // One interaction model for every terminal selector.
 import { row } from "../ui/render.js";
-import { elide } from "../ui/width.js";
+import { elide, graphemes } from "../ui/width.js";
 import { menuWindow, renderMenuRows } from "./components/menu.js";
 import { promptCursor, promptLine } from "./components/prompt.js";
 const WINDOW = 6;
@@ -33,7 +33,7 @@ export function type(picker, text) {
 export function backspace(picker) {
     if (picker.searchable !== true || (picker.query ?? "") === "")
         return picker;
-    return withQuery(picker, Array.from(picker.query ?? "").slice(0, -1).join(""));
+    return withQuery(picker, graphemes(picker.query ?? "").slice(0, -1).join(""));
 }
 export function clear(picker) {
     return withQuery(picker, "");

package/dist/ui/terminal-text.js

@@ -38,5 +38,8 @@ export function terminalText(text, options = {}) {
     return safe;
 }
 function isBidiControl(code) {
-    return (code >= 0x202a && code <= 0x202e) || (code >= 0x2066 && code <= 0x2069);
+    return code === 0x061c ||
+        (code >= 0x200e && code <= 0x200f) ||
+        (code >= 0x202a && code <= 0x202e) ||
+        (code >= 0x2066 && code <= 0x2069);
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@giovannijecha/jecode",
-  "version": "0.7.0",
+  "version": "0.7.2",
   "description": "An owned coding agent with zero external runtime dependencies.",
   "license": "MIT",
   "repository": {