@giovannijecha/jecode 0.8.5 → 0.8.6

package/dist/tools/search.js

@@ -6,12 +6,12 @@ import { readStableDirectory, StableDirectoryError, } from "../stable-directory.
 import { optionalBool, optionalInt, optionalString, requireString } from "./args.js";
 import { displayPath, resolveExistingInRoot } from "./paths.js";
 import { leadingText } from "./text-boundary.js";
+import { glob } from "./glob.js";
 const DEFAULT_RESULTS = 100;
 const MAX_RESULTS = 500;
 const MAX_VISITED = 20_000;
 const MAX_FILE_BYTES = 1_000_000;
 const MAX_MATCH_LINE = 500;
-const MAX_GLOB_CHARS = 512;
 const PORTABLE_SEARCH_CONCURRENCY = 8;
 const SKIP = new Set([".git", ".hg", ".svn", "node_modules"]);
 export const findFiles = {
@@ -255,110 +255,6 @@ function resultLimit(args) {
         throw new Error('"max_results" must be a positive integer');
     return Math.min(requested, MAX_RESULTS);
 }
-function glob(pattern) {
-    const normalized = pattern.replace(/\\/g, "/");
-    if (normalized.length > MAX_GLOB_CHARS) {
-        throw new Error(`"pattern" must be at most ${MAX_GLOB_CHARS} characters`);
-    }
-    const tokens = tokenizeGlob(normalized.toLowerCase());
-    const basenameOnly = !normalized.includes("/");
-    return (relative) => {
-        const candidate = relative.replace(/\\/g, "/");
-        const target = (basenameOnly ? path.posix.basename(candidate) : candidate).toLowerCase();
-        return matchGlob(tokens, Array.from(target));
-    };
-}
-function tokenizeGlob(pattern) {
-    const chars = Array.from(pattern);
-    const tokens = [];
-    let index = 0;
-    while (index < chars.length) {
-        const char = chars[index];
-        if (char === "*") {
-            let end = index + 1;
-            while (chars[end] === "*")
-                end++;
-            if (end - index >= 2) {
-                if (chars[end] === "/") {
-                    tokens.push({ kind: "globdir-start" }, { kind: "globdir-body" });
-                    index = end + 1;
-                }
-                else {
-                    tokens.push({ kind: "globstar" });
-                    index = end;
-                }
-            }
-            else {
-                tokens.push({ kind: "star" });
-                index = end;
-            }
-            continue;
-        }
-        tokens.push(char === "?" ? { kind: "one" } : { kind: "literal", value: char });
-        index++;
-    }
-    return tokens;
-}
-/** Thompson-style wildcard matching: O(pattern × path), with no regex backtracking. */
-function matchGlob(tokens, text) {
-    let states = epsilonClosure(new Set([0]), tokens);
-    for (const char of text) {
-        const next = new Set();
-        for (const state of states) {
-            const token = tokens[state];
-            if (token === undefined)
-                continue;
-            switch (token.kind) {
-                case "literal":
-                    if (token.value === char)
-                        next.add(state + 1);
-                    break;
-                case "one":
-                    if (char !== "/")
-                        next.add(state + 1);
-                    break;
-                case "star":
-                    if (char !== "/")
-                        next.add(state);
-                    break;
-                case "globstar":
-                    next.add(state);
-                    break;
-                case "globdir-body":
-                    next.add(state);
-                    if (char === "/")
-                        next.add(state + 1);
-                    break;
-                case "globdir-start":
-                    break;
-            }
-        }
-        states = epsilonClosure(next, tokens);
-        if (states.size === 0)
-            return false;
-    }
-    return epsilonClosure(states, tokens).has(tokens.length);
-}
-function epsilonClosure(seed, tokens) {
-    const states = new Set(seed);
-    const pending = [...seed];
-    while (pending.length > 0) {
-        const state = pending.pop();
-        const token = tokens[state];
-        const targets = token?.kind === "globdir-start"
-            ? [state + 1, state + 2]
-            : token?.kind === "star" || token?.kind === "globstar"
-                ? [state + 1]
-                : [];
-        for (const target of targets) {
-            if (states.has(target))
-                continue;
-            states.add(target);
-            pending.push(target);
-        }
-    }
-    return states;
-}
 function summary(count, limit, capped, one, many) {
     const noun = count === 1 ? one : many;
     if (count >= limit)

package/dist/tui/app-workflows.js

@@ -1,364 +1,11 @@
-// 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 { 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;
+    return {
+        command: commandWorkflow(options, () => automaticCompaction.reset()),
+        ...turnWorkflow(options, automaticCompaction),
+    };
 }

package/dist/tui/approve.js

@@ -16,13 +16,15 @@ export { scopeFor };
 export function promptFor(call, target, pal) {
     const scope = scopeFor(call);
     const options = [
-        { label: "Yes, once", hint: "enter", key: "y" },
-        { label: `Yes, ${scopeNoun(scope)} for the session`, hint: "a", key: "a" },
-        { label: "No, and say why", hint: "esc", key: "n" },
+        { label: "Yes, once", hint: "y", key: "y", description: "Approve only this call. Ask again next time." },
+        { label: `Yes, ${scopeNoun(scope)} for the session`, hint: "a", key: "a",
+            description: `Reuse approval for ${scopeNoun(scope)} in this session.` },
+        { label: "No, and say why", hint: "n", key: "n", description: "Do not run this call. Return feedback to the model." },
     ];
     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

@@ -2,23 +2,24 @@
 import { renderAnswer, renderReasoning, renderUser } from "./components/messages.js";
 import { renderNotice } from "./components/misc.js";
 import { renderTool } from "./components/tool.js";
+import { insetTranscript, modelTranscriptWidth } from "./transcript-grammar.js";
 export function render(block, width, pal, context = {}) {
+    const inner = modelTranscriptWidth(width);
     switch (block.kind) {
         case "user":
             return renderUser(block, width, pal);
         case "answer":
-            return renderAnswer(block, width, pal);
+            return insetTranscript(renderAnswer(block, inner, pal));
         case "reasoning":
-            return renderReasoning(block, width, pal, {
+            return insetTranscript(renderReasoning(block, inner, pal, {
                 continues: context.previous?.kind === "reasoning",
-            });
+            }));
         case "tool":
-            return renderTool(block, width, pal, {
-                continues: context.previous?.kind === "tool",
+            return insetTranscript(renderTool(block, inner, pal, {
+                continues: context.previous?.kind === "reasoning",
                 now: context.now,
-                motion: context.motion,
                 reducedMotion: context.reducedMotion,
-            });
+            }));
         case "notice":
             return renderNotice(block, width, pal);
     }

package/dist/tui/command-workflow.js

@@ -0,0 +1,106 @@
+// Foreground slash-command interactions and their session updates.
+import { 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) {
+    const { session, state, permissions, feedback } = options;
+    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);
+                    resetCompaction();
+                    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")
+                        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 {
+            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}`, description: command.blurb, 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() {