@giovannijecha/jecode 0.8.5 → 0.8.7

package/dist/tui/command-workflow.js

@@ -0,0 +1,112 @@
+// Foreground slash-command interactions and their session updates.
+import { commandNeedsIdle, handleCommand } from "../commands.js";
+import { compactSession } from "../context/manual.js";
+import { resetRequestIdentity } from "../request-identity.js";
+import { updateSettings } from "../settings.js";
+import { selectTimeline } from "../timeline.js";
+import { saveTranscript } from "../transcript-export.js";
+import { transition } from "./activity.js";
+import { cancel as cancelOpen } from "./overlay.js";
+export function commandWorkflow(options, resetCompaction, resetInput) {
+    const { session, state, permissions, feedback } = options;
+    const choose = (picker) => new Promise((resolve) => {
+        state.command?.control.signal.throwIfAborted();
+        state.open = { picker, settle: resolve };
+        options.render();
+    });
+    async function command(text) {
+        if (state.activity !== undefined && commandNeedsIdle(text))
+            return;
+        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) => {
+                    activity.control.signal.throwIfAborted();
+                    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) => {
+                    activity.control.signal.throwIfAborted();
+                    state.open = { field, settle: resolve };
+                    options.render();
+                }),
+                status: (said) => {
+                    status(said ?? activity.label);
+                    options.render();
+                },
+                reset: async () => {
+                    await session.persistence?.reset();
+                    resetRequestIdentity(session);
+                    resetCompaction();
+                    state.past.length = 0;
+                    permissions.reset();
+                    options.replaceTranscript([]);
+                    state.committedNodeId = 0;
+                },
+                permissions,
+                exportTranscript: () => saveTranscript(options.transcriptRoot, structuredClone(state.blocks)),
+                saveSettings: async (patch) => {
+                    await updateSettings(patch);
+                },
+                refreshSettings: options.refreshSettings,
+                timeline: async () => {
+                    const selected = await selectTimeline(session, choose);
+                    if (!selected)
+                        return "unchanged";
+                    resetCompaction();
+                    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")
+                        resetCompaction();
+                    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 {
+            // Access can change while a turn is running. Discard even an observation
+            // from an in-flight response that used the previous connection.
+            if (text.trim().split(/\s+/)[0] === "/providers")
+                resetInput();
+            options.finishActivity(activity);
+        }
+    }
+    return command;
+}

package/dist/tui/components/command-menu.js

@@ -1,18 +1,15 @@
-import { menuWindow, renderMenuRows } from "./menu.js";
+import { renderMenu } from "./menu.js";
 const MAX_ROWS = 4;
 export function renderCommandMenu(commands, selected, width, pal) {
     const selectedIndex = selected === undefined ? 0 : Math.max(0, Math.min(commands.length - 1, selected));
-    const { first, last } = menuWindow(commands.length, selectedIndex, MAX_ROWS);
-    const shown = commands.slice(first, last);
-    if (shown.length === 0)
+    if (commands.length === 0)
         return { rows: [], right: "" };
+    const menu = renderMenu(commands.map((command, index) => ({
+        label: `/${command.name}`, selected: selectedIndex === index,
+    })), width, pal, { maxRows: MAX_ROWS + 2, visible: MAX_ROWS });
     return {
-        rows: renderMenuRows(shown.map((command, index) => ({
-            label: `/${command.name}`,
-            description: command.blurb,
-            selected: selectedIndex === first + index,
-        })), width, pal),
-        right: commands.length > shown.length ? `${first + 1}–${last} / ${commands.length}` : "",
+        rows: menu.rows,
+        right: commands.length > menu.last - menu.first ? `${menu.first + 1}–${menu.last} / ${commands.length}` : "",
     };
 }
 export function commandMenuLimit() {

package/dist/tui/components/menu.js

@@ -1,12 +1,54 @@
-// One visual row grammar for autocomplete and every interactive selector.
-import { hasColor, plainLen, row } from "../../ui/render.js";
-import { elide } from "../../ui/width.js";
+// Ribbon rows and bounded overflow recovery shared by completion and selectors.
+import { row } from "../../ui/render.js";
+import { terminalText } from "../../ui/terminal-text.js";
+import { elide, textWidth, wrapText } from "../../ui/width.js";
 export function renderMenuRows(entries, width, pal) {
+    return entries.map((entry) => {
+        const right = summary(entry, width);
+        return row(width, [
+            { text: entry.selected ? "● " : "  ", fg: pal.focus },
+            { text: entry.label, fg: entry.selected ? pal.ink.bright : pal.ink.muted, bold: entry.selected },
+        ], right === "" ? [] : [{ text: right, fg: entry.selected ? pal.focus : pal.ink.dim }], entry.selected ? pal.surface.subtle : undefined);
+    });
+}
+/** A missing palette measures the window without producing styled rows. */
+export function renderMenu(entries, width, pal, options) {
+    const room = Math.max(0, options.maxRows);
+    if (room === 0)
+        return { rows: [], first: 0, last: 0 };
+    const detailLimit = options.overflow === "truncate" ? 0 : Math.min(2, room - 1);
+    let detailRows = 0;
+    // Measure every possible selection so revealing clipped identity and values
+    // does not move the dock when the selected row changes.
+    for (const entry of entries) {
+        detailRows = Math.max(detailRows, detailLines(entry, width, detailLimit).length);
+        if (detailRows === detailLimit)
+            break;
+    }
+    const visible = Math.min(options.visible ?? 6, room - detailRows);
+    const at = Math.max(0, entries.findIndex((entry) => entry.selected));
+    const { first, last } = menuWindow(entries.length, at, visible);
+    if (pal === undefined)
+        return { rows: [], first, last };
     if (entries.length === 0)
+        return {
+            rows: [row(width, [{ text: "No matches. Change the filter.", fg: pal.ink.muted }])], first, last,
+        };
+    const active = entries.find((entry) => entry.selected);
+    const lines = detailLines(active, width, detailRows);
+    return {
+        rows: [
+            ...renderMenuRows(entries.slice(first, last), width, pal),
+            ...Array.from({ length: detailRows }, (_, index) => lines[index] === undefined ? ""
+                : row(width, [{ text: "  " + lines[index], fg: pal.ink.muted }])),
+        ], first, last,
+    };
+}
+function detailLines(entry, width, maxRows) {
+    if (entry === undefined || maxRows <= 0)
         return [];
-    const widest = Math.max(...entries.map(primaryWidth));
-    const labelWidth = Math.min(42, Math.max(12, widest + 2));
-    return entries.map((entry) => renderEntry(entry, labelWidth, width, pal));
+    const room = Math.max(1, width - 2);
+    return menuText(clippedParts(entry, width).join(" · "), room, maxRows);
 }
 export function menuWindow(length, selected, visible) {
     const count = Math.max(0, length);
@@ -15,42 +57,39 @@ export function menuWindow(length, selected, visible) {
     const first = Math.max(0, Math.min(at - Math.floor(room / 2), count - room));
     return { first, last: Math.min(count, first + room) };
 }
-function renderEntry(entry, labelWidth, width, pal) {
-    // Colour terminals spend focus on the active label instead of painting a
-    // full-width band. Monochrome has no colour, so it alone reserves a fixed
-    // arrow column to keep selection visible without shifting peer rows.
-    const monochrome = !hasColor();
-    const selectedMark = monochrome ? (entry.selected ? "→ " : "  ") : "";
-    const fg = entry.selected ? pal.focus : pal.ink.fg;
-    const primary = [
-        { text: selectedMark, fg },
-        { text: entry.label, fg, bold: entry.selected || undefined },
+/** Wrap untrusted menu copy, marking a bounded final row when it omits text. */
+export function menuText(text, width, maxRows) {
+    if (text === "" || maxRows <= 0)
+        return [];
+    const lines = wrapText(terminalText(text), Math.max(1, width));
+    return lines.slice(0, maxRows).map((line, index) => index === maxRows - 1 && lines.length > maxRows ? elide(line + " …", width) : line);
+}
+function fullSummary(entry) {
+    return [entry.hint, displayedValue(entry)].filter(Boolean).join(" · ");
+}
+function summary(entry, width) {
+    const room = Math.max(1, Math.floor(width * 0.42));
+    const value = terminalText(displayedValue(entry));
+    const hint = terminalText(entry.hint ?? "");
+    if (value === "" || hint === "")
+        return elide(value || hint, room);
+    // Keep the current policy visible even when its remembered-scope hint is long.
+    const hintRoom = room - textWidth(value) - 3;
+    return hintRoom <= 0 ? elide(value, room) : `${elide(hint, hintRoom)} · ${value}`;
+}
+function displayedValue(entry) {
+    if (entry.value === undefined)
+        return "";
+    return entry.selected && entry.adjustable ? `‹ ${entry.value} ›` : entry.value;
+}
+function clippedParts(entry, width) {
+    // Reserve the stepper's width for every peer, so moving selection cannot
+    // make the shared detail area appear or disappear.
+    const stable = entry.adjustable ? { ...entry, selected: true } : entry;
+    const right = summary(stable, width);
+    const leftRoom = Math.max(0, width - 2 - (right === "" ? 0 : textWidth(right) + 1));
+    return [
+        ...(textWidth(terminalText(entry.label)) > leftRoom ? [entry.label] : []),
+        ...(right !== terminalText(fullSummary(stable)) ? [fullSummary(stable)] : []),
     ];
-    if (width > 40 && entry.description !== undefined) {
-        const gap = Math.max(2, labelWidth - primaryWidth(entry));
-        primary.push({
-            text: `${" ".repeat(gap)}${entry.description}`,
-            fg: entry.selected ? pal.ink.bright : pal.ink.muted,
-        });
-    }
-    const value = entry.value === undefined
-        ? undefined
-        : entry.selected && entry.adjustable === true
-            ? `‹ ${entry.value} ›`
-            : entry.value;
-    const summary = [entry.hint, value]
-        .filter((part) => part !== undefined)
-        .join(" · ");
-    const rightColor = entry.selected ? pal.focus : pal.ink.muted;
-    const right = summary === "" || (width <= 40 && entry.value === undefined)
-        ? []
-        : [{
-                text: elide(summary, Math.max(1, Math.floor(entry.value === undefined ? width / 4 : width * 0.45))),
-                fg: rightColor,
-                bold: entry.selected || undefined,
-            }];
-    return row(width, primary, right);
-}
-function primaryWidth(entry) {
-    return plainLen([{ text: entry.label }]);
 }

package/dist/tui/components/messages.js

@@ -1,25 +1,32 @@
 import { trailingText } from "../../text-boundary.js";
-import { blank, row } from "../../ui/render.js";
+import { blank, hasColor, row } from "../../ui/render.js";
 import { markdown } from "../../ui/markdown.js";
+import { terminalText } from "../../ui/terminal-text.js";
+import { splitByCells } from "../../ui/width.js";
 import { transcriptLead, transcriptWidth } from "../transcript-grammar.js";
 export const REASONING_PREVIEW_ROWS = 3;
 const MIN_REASONING_PREVIEW_CHARS = 4_096;
 const REASONING_PREVIEW_OVERSCAN = 12;
 export function renderUser(block, width, pal) {
     const inner = transcriptWidth(width);
-    const content = markdown(block.text, inner, pal, inner);
+    const content = terminalText(block.text, { multiline: true }).split("\n")
+        .flatMap((line) => splitByCells(line, inner));
     return [
         "",
-        blank(width, pal.surface.subtle),
-        ...content.map((line, index) => row(width, [
-            ...transcriptLead(width, index === 0
-                ? { text: "❯", fg: pal.accent, bold: true }
-                : undefined),
-            ...line.segs,
+        userEdge(width, pal, "▄"),
+        ...content.map((line) => row(width, [
+            ...transcriptLead(width),
+            { text: line.text, fg: pal.ink.fg },
         ], [], pal.surface.subtle)),
-        blank(width, pal.surface.subtle),
+        userEdge(width, pal, "▀"),
     ];
 }
+/** Half-cell colour keeps the surface light without moving surrounding text. */
+function userEdge(width, pal, half) {
+    if (!hasColor())
+        return blank(width, pal.surface.subtle);
+    return row(width, [{ text: half.repeat(width), fg: pal.surface.subtle }]);
+}
 export function renderAnswer(block, width, pal) {
     return [
         "",

package/dist/tui/components/status.js

@@ -19,7 +19,7 @@ export function renderStatus(info, pal) {
             ];
         return withUnseen([
             ...active,
-            { text: " · esc to interrupt", fg: pal.ink.dim, optional: true },
+            ...(info.interruptible === false ? [] : [{ text: " · esc to interrupt", fg: pal.ink.dim, optional: true }]),
         ], info.unseen, pal);
     }
     if (info.feedback !== undefined) {

package/dist/tui/components/tool-evidence.js

@@ -0,0 +1,107 @@
+// Selection and rendering of retained tool evidence. Never mutates its source.
+import { row } from "../../ui/render.js";
+import { graphemeCeiling, graphemeFloor } from "../../text-boundary.js";
+import { transcriptLead } from "../transcript-grammar.js";
+// Native exception headings may include a Node error code before the message.
+const ERROR_DIAGNOSTIC = /^\s*\w*Error(?:\s+\[[^\]]+\])?\s*:|\berror\b\s*:|AssertionError/i;
+export function toolEvidence(block) {
+    const all = block.body ?? [];
+    const changed = [];
+    let added = 0, removed = 0, regions = 0, context = 3;
+    for (const detail of all) {
+        if (detail.kind === "keep") {
+            context++;
+            continue;
+        }
+        if (detail.kind !== "add" && detail.kind !== "del") {
+            context = 3;
+            continue;
+        }
+        if (context >= 3)
+            regions++;
+        context = 0;
+        if (detail.kind === "add")
+            added++;
+        else
+            removed++;
+        changed.push(detail);
+    }
+    const counts = changed.length === 0 ? "" : `+${added} −${removed}`;
+    const summary = counts === "" ? "" : `${counts} · ${regions} ${regions === 1 ? "region" : "regions"}`;
+    if (all.length === 0)
+        return { details: [], counts, summary, note: "" };
+    if (block.expanded)
+        return { details: all, counts, summary, note: "ctrl+o collapse" };
+    if (changed.length > 0)
+        return {
+            details: changed.length <= 6 ? changed : [
+                ...changed.slice(0, 3),
+                { kind: "gap", text: `… ${changed.length - 6} more changed ${changed.length === 7 ? "line" : "lines"}` },
+                ...changed.slice(-3),
+            ], counts, summary, note: "ctrl+o full source",
+        };
+    const diagnostic = block.tone === "fail"
+        ? all.find((detail) => ERROR_DIAGNOSTIC.test(detail.text))
+            ?? all.find((detail) => /^not ok\b|^\s*[×✖]/i.test(detail.text)) : undefined;
+    let details = all.slice(-4);
+    if (diagnostic !== undefined && !details.includes(diagnostic))
+        details = [diagnostic, ...all.slice(-3)];
+    const hidden = all.length - details.length;
+    return {
+        details, counts, summary,
+        note: hidden > 0 ? `${hidden} ${diagnostic === undefined ? "earlier" : "other"} ${hidden === 1 ? "line" : "lines"} · ctrl+o`
+            : `${all.length} ${all.length === 1 ? "line" : "lines"}`,
+    };
+}
+export function renderDetail(detail, tone, width, pal, railInk = pal.rule) {
+    const rail = transcriptLead(width, { text: "│", fg: railInk });
+    if (detail.kind === "out") {
+        const base = tone === "fail" || failureLine(detail.text) ? pal.ink.removed : pal.ink.muted;
+        return row(width, [
+            ...rail,
+            { text: detail.text === "" ? " " : detail.text, fg: base },
+        ]);
+    }
+    if (detail.kind === "gap") {
+        return row(width, [
+            ...rail,
+            { text: detail.text, fg: pal.ink.dim, italic: true },
+        ]);
+    }
+    const number = detail.kind === "add" ? detail.newLine : detail.oldLine;
+    const sign = detail.kind === "add" ? "+" : detail.kind === "del" ? "-" : " ";
+    const fg = detail.kind === "add"
+        ? pal.ink.added
+        : detail.kind === "del"
+            ? pal.ink.removed
+            : pal.ink.dim;
+    const tint = detail.kind === "add"
+        ? pal.surface.added
+        : detail.kind === "del"
+            ? pal.surface.removed
+            : undefined;
+    return row(width, [
+        ...rail,
+        { text: sign, fg, bold: detail.kind !== "keep" },
+        { text: `${String(number ?? "").padStart(4)} `, fg: pal.ink.dim },
+        ...emphasized(detail.text, detail.emphasis, fg, tint),
+    ]);
+}
+function emphasized(text, emphasis, fg, bg) {
+    if (emphasis === undefined || emphasis.length <= 0)
+        return [{ text, fg }];
+    const requestedStart = Math.max(0, Math.min(text.length, emphasis.start));
+    const requestedEnd = Math.max(requestedStart, Math.min(text.length, requestedStart + emphasis.length));
+    const start = graphemeFloor(text, requestedStart);
+    const end = graphemeCeiling(text, requestedEnd);
+    if (start === end)
+        return [{ text, fg }];
+    return [
+        ...(start === 0 ? [] : [{ text: text.slice(0, start), fg }]),
+        { text: text.slice(start, end), fg, bg, bold: true },
+        ...(end === text.length ? [] : [{ text: text.slice(end), fg }]),
+    ];
+}
+function failureLine(line) {
+    return line.startsWith("✖") || line.startsWith("×") || line.includes("AssertionError") || /\bfailed\b/i.test(line);
+}

package/dist/tui/components/tool-motion.js

@@ -0,0 +1,32 @@
+// One travelling light on the execution connector; evidence never animates.
+import { hasColor } from "../../ui/render.js";
+export function runningTool(block) {
+    return block.kind === "tool" && block.tone === "pending" &&
+        block.startedAt !== undefined && block.right === "running";
+}
+export function stateInk(block, pal) {
+    if (block.tone === "fail")
+        return pal.ink.removed;
+    if (block.tone === "deny")
+        return pal.ink.attention;
+    if (block.tone === "ok")
+        return pal.ink.added;
+    return runningTool(block) ? pal.accent : pal.ink.dim;
+}
+export function stateMark(block) {
+    return block.tone === "ok" ? "✓" : block.tone === "fail" ? "×" : block.tone === "deny" ? "!" : "○";
+}
+export function connectorInk(block, pal, context, position, length) {
+    if (context.reducedMotion === true || block.expanded === true || !hasColor() || !runningTool(block))
+        return pal.rule;
+    const elapsed = Math.max(0, (context.now ?? Date.now()) - block.startedAt);
+    const head = (elapsed % 2000) / 2000 * (length + 3) - 1.5;
+    const amount = Math.max(0, 1 - Math.abs(position - head) / 1.8);
+    const channel = (index) => Math.round(pal.rule[index] + (pal.accent[index] - pal.rule[index]) * amount);
+    return [channel(0), channel(1), channel(2)];
+}
+export function connector(text, block, pal, context, position, length) {
+    return Array.from(text, (char, index) => ({
+        text: char, fg: connectorInk(block, pal, context, position + index / 3, length),
+    }));
+}