@giovannijecha/jecode 0.8.6 → 0.8.7

package/dist/tui/turn-workflow.js

@@ -1,9 +1,7 @@
 // One model turn, including steering, compaction, durable settlement, and recovery.
 import { runTurn } from "../controller.js";
 import { resolveContextPolicy } from "../context/capacity.js";
-import { automaticCompactionKey } from "../context/automatic.js";
-import { compactContext } from "../context/compactor.js";
-import { isContextOverflow } from "../context/policy.js";
+import { contextManager } from "../context/manager.js";
 import { steeringInbox } from "../steering.js";
 import { recordAuxiliaryUsage, recordRequestInput, recordUsage } from "../usage.js";
 import { toolSpecs } from "../tools/index.js";
@@ -11,16 +9,21 @@ import { requestIdentityForSession } from "../request-identity.js";
 import { transition } from "./activity.js";
 import { answerAt } from "./approve.js";
 import * as edit from "./editor.js";
-import { controllerOptions, turnFailure } from "./session-view.js";
+import { controllerOptions, footerInfo, turnFailure } from "./session-view.js";
 import { transcribe } from "./turn.js";
 const WAITING = "Waiting";
-export function turnWorkflow(options, automaticCompaction) {
+export function turnWorkflow(options, automaticCompaction, inputs) {
     const { session, state, permissions, feedback } = options;
     let activeSteering;
     async function turn(text) {
         const activity = options.startActivity("turn", WAITING);
         if (activity === undefined)
             return;
+        // Settings menus remain live, but every request, compaction, and checkpoint
+        // in this turn must retain the selection with which the turn started.
+        const runtime = { ...session, config: { ...session.config } };
+        const requestIdentity = requestIdentityForSession(session);
+        state.turnFooter = footerInfo(runtime);
         const inbox = steeringInbox((pending, accepting) => {
             if (activeSteering !== inbox)
                 return;
@@ -51,9 +54,9 @@ export function turnWorkflow(options, automaticCompaction) {
                 options.render();
             }
             return resolveContextPolicy({
-                provider: session.provider,
-                model: session.model,
-                compactionPercent: session.config.compactionPercent,
+                provider: runtime.provider,
+                model: runtime.model,
+                compactionPercent: runtime.config.compactionPercent,
                 signal: activity.control.signal,
                 onStatus: (said) => {
                     visible = true;
@@ -67,6 +70,11 @@ export function turnWorkflow(options, automaticCompaction) {
                 }
             });
         };
+        const requestOptions = {
+            ...controllerOptions(session, policy, turnTools, inbox),
+            inputMeter: inputs.forTurn(runtime.provider, requestIdentity.conversationId),
+            toolAllowed: (call) => permissions.allowed(call),
+        };
         options.emit({ kind: "user", text });
         const user = { role: "user", content: [{ kind: "text", text }] };
         history.push(user);
@@ -78,7 +86,7 @@ export function turnWorkflow(options, automaticCompaction) {
             approved: (call) => permissions.approved(call),
             remember: (call) => permissions.remember(call),
             ask: (prompt, settle) => {
-                state.open = { picker: prompt, settle: (index) => settle(answerAt(index)) };
+                state.approval = { picker: prompt, settle: (index) => settle(answerAt(index)) };
                 options.render();
             },
             status: (text) => {
@@ -93,9 +101,9 @@ export function turnWorkflow(options, automaticCompaction) {
                 parentId,
                 createdAt,
                 identity: {
-                    providerId: session.provider.id,
-                    model: session.model,
-                    effort: session.config.effort,
+                    providerId: runtime.provider.id,
+                    model: runtime.model,
+                    effort: runtime.config.effort,
                 },
                 messages: checkpoint.slice(historyStart),
                 blocks: state.blocks.slice(blockStart),
@@ -108,86 +116,49 @@ export function turnWorkflow(options, automaticCompaction) {
             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;
+        const manager = contextManager({
+            provider: runtime.provider,
+            model: runtime.model,
+            effort: runtime.config.effort,
+            system: runtime.system,
+            tools: specs,
+            maxOutputTokens: runtime.config.maxTokens,
+            historyStart,
+            nodeId: () => nodeId ?? prospectiveNodeId,
+            gate: automaticCompaction,
+            identity: requestIdentity,
+            signal: activity.control.signal,
+            onStatus(active) {
+                status(active ? "Compacting" : WAITING);
+                options.render();
+            },
+            onUsage: (usage) => recordAuxiliaryUsage(session.usage, usage),
+        });
+        events.onContext = async (checkpoint, projected, request) => {
+            const result = await manager.compact(checkpoint, projected, request);
+            context = manager.anchor;
+            return result;
         };
-        events.onContext = compact;
         events.onSteering = (guidance) => {
             unpersistedSteering.push(guidance);
             options.emit({ kind: "user", text: guidance });
             options.render();
         };
-        events.onCheckpoint = async (checkpoint, settlement, projected) => {
+        events.onCheckpoint = async (checkpoint, settlement) => {
             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);
+            await runTurn(history, requestOptions, events, activity.control.signal, modelHistory);
         }
         catch (error) {
+            inputs.reset();
             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);
+                const notice = turnFailure(runtime, error, interrupted);
                 feedback.show({ text: notice.text, tone: notice.tone, timeoutMs: 6_000 });
             }
             else {
@@ -203,7 +174,7 @@ export function turnWorkflow(options, automaticCompaction) {
             try {
                 events.finish(finishReason);
                 if (failed !== undefined) {
-                    const notice = turnFailure(session, failed.error, failed.interrupted);
+                    const notice = turnFailure(runtime, failed.error, failed.interrupted);
                     const settlement = failed.interrupted ? "interrupted" : "failed";
                     const failure = {
                         text: notice.text,

package/dist/tui/view.js

@@ -39,10 +39,10 @@ export function compose(view, size, transcript = transcriptRenderer()) {
 }
 function dockRows(view, width, height) {
     const status = renderStatus({
-        // A modal already names the interaction in progress. Let command feedback
-        // use the footer while that interaction is open instead of repeating a
-        // generic "Running /…" label beside it.
-        status: view.modal === undefined ? view.status : undefined,
+        // A modal names its command; background model work still needs visible
+        // status. Its interruption/steering keys are suspended while a menu owns input.
+        status: view.modal === undefined || view.turnActive ? view.status : undefined,
+        interruptible: view.modal === undefined,
         steering: view.modal === undefined ? view.steering : undefined,
         feedback: view.feedback,
         readiness: view.readiness,

package/dist/ui/render.js

@@ -45,10 +45,6 @@ export function paint(seg) {
 export function plainLen(segs) {
     return segs.reduce((n, seg) => n + textWidth(terminalText(seg.text)), 0);
 }
-export function columns() {
-    const width = process.stdout.columns;
-    return typeof width === "number" && width >= 40 ? width : 80;
-}
 /**
  * The margin every row keeps from the edges of the terminal: none.
  *

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@giovannijecha/jecode",
-  "version": "0.8.6",
+  "version": "0.8.7",
   "description": "An owned coding agent with zero external runtime dependencies.",
   "license": "MIT",
   "repository": {
@@ -27,6 +27,8 @@
     "dist/",
     "assets/jeco-256.png",
     "assets/wordmark-steel.svg",
+    "assets/tokenizers/o200k-base.tiktoken.gz",
+    "assets/tokenizers/LICENSE",
     "LICENSE",
     "README.md"
   ],
@@ -45,11 +47,13 @@
     "pack:release": "npm run build:release && npm pack --ignore-scripts",
     "start": "node src/main.ts",
     "tui:lab": "node dev/tui/main.ts",
+    "web:preview": "node dev/web/main.ts",
     "bench:context": "node dev/benchmarks/context.ts",
     "bench:redaction": "node dev/benchmarks/redaction.ts",
     "bench:search": "node dev/benchmarks/search.ts",
     "bench:session": "node dev/benchmarks/session.ts",
     "bench:transcript": "node dev/benchmarks/transcript.ts",
+    "bench:tui": "node --expose-gc dev/benchmarks/tui.ts",
     "typecheck": "tsc --noEmit",
     "test": "npm run build:release && node --test",
     "coverage": "npm run build:release && node --test --experimental-test-coverage --test-coverage-include=\"src/**/*.ts\" --test-coverage-lines=80 --test-coverage-branches=75 --test-coverage-functions=75",

package/dist/batch-view.js

@@ -1,42 +0,0 @@
-// Project semantic blocks into a compact transcript for pipes.
-import { renderAnswer, renderReasoning, renderUser } from "./tui/components/messages.js";
-import { renderNotice } from "./tui/components/misc.js";
-import { renderDetail } from "./tui/components/tool-evidence.js";
-import { stateInk, stateMark } from "./tui/components/tool-motion.js";
-import { toolDuration } from "./duration.js";
-import { row } from "./ui/render.js";
-export function renderBatch(block, width, pal) {
-    const rows = [];
-    let lastWasBlank = false;
-    for (const rendered of batchRows(block, width, pal)) {
-        const line = rendered.trimEnd();
-        const blank = line === "";
-        if (blank && lastWasBlank)
-            continue;
-        rows.push(line);
-        lastWasBlank = blank;
-    }
-    while (rows.at(-1) === "")
-        rows.pop();
-    return rows;
-}
-function batchRows(block, width, pal) {
-    switch (block.kind) {
-        case "answer": return renderAnswer(block, width, pal);
-        case "reasoning": return renderReasoning(block, width, pal);
-        case "user": return renderUser(block, width, pal);
-        case "notice": return renderNotice(block, width, pal);
-        case "tool": {
-            // Pipes cannot expand records or repaint a running connector.
-            const mark = stateMark(block);
-            const result = [block.right, block.durationMs === undefined ? "" : toolDuration(block.durationMs)]
-                .filter(Boolean).join(" · ");
-            return ["", row(width, [
-                    { text: `${mark} `, fg: stateInk(block, pal) },
-                    { text: block.name, fg: pal.ink.bright },
-                    { text: block.target === "" ? "" : `  ${block.target}`, fg: pal.technical },
-                ], [{ text: result, fg: pal.ink.muted }]),
-                ...(block.body ?? []).map((detail) => renderDetail(detail, block.tone, width, pal))];
-        }
-    }
-}

package/dist/batch.js

@@ -1,269 +0,0 @@
-// The non-interactive path: stdin is a pipe, so there is no screen to own.
-//
-// It exists so the agent can be scripted and tested. It shares the controller,
-// the tools and the block renderer with the TUI — only the surface differs.
-import { stdin, stdout } from "node:process";
-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 { handleCommand } from "./commands.js";
-import { renderBatch } from "./batch-view.js";
-import { columns } from "./ui/render.js";
-import { terminalText } from "./ui/terminal-text.js";
-import { recordAuxiliaryUsage, recordRequestInput, recordUsage } from "./usage.js";
-import { assertPromptLength, boundedInputLines } from "./input-boundary.js";
-import { providerFailure } from "./provider-errors.js";
-import { toolSpecs } from "./tools/index.js";
-import { requestIdentityForSession } from "./request-identity.js";
-export async function runBatch(session, environment = {}) {
-    const write = environment.write ?? ((text) => stdout.write(text));
-    const width = environment.width ?? columns();
-    const signal = environment.signal;
-    const source = environment.lines ?? boundedInputLines(stdin);
-    const lines = abortableLines(source, signal);
-    const automaticCompaction = automaticCompactionGate();
-    const emit = (block) => {
-        for (const line of renderBatch(block, width, session.palette))
-            write(`${line}\n`);
-    };
-    try {
-        throwIfAborted(signal);
-        for await (const raw of lines) {
-            throwIfAborted(signal);
-            assertPromptLength(raw.length);
-            const line = raw.trim();
-            if (line === "")
-                continue;
-            if (line.startsWith("/")) {
-                if ((await handleCommand(line, session, {
-                    emit,
-                    signal,
-                    reset: () => {
-                        automaticCompaction.reset();
-                    },
-                    compact: async () => {
-                        const result = await compactSession(session, { signal });
-                        if (result === "compacted")
-                            automaticCompaction.reset();
-                        return result;
-                    },
-                })) === "exit")
-                    break;
-                continue;
-            }
-            write(`> ${terminalText(line)}\n`);
-            const parentId = session.conversation.activeNodeId;
-            const createdAt = new Date().toISOString();
-            const history = session.conversation.history;
-            const modelHistory = session.conversation.contextHistory;
-            const before = history.length;
-            const prospectiveNodeId = session.conversation.nodes.length + 1;
-            let nodeId;
-            let context;
-            const policy = () => {
-                return resolveContextPolicy({
-                    provider: session.provider,
-                    model: session.model,
-                    compactionPercent: session.config.compactionPercent,
-                    signal,
-                });
-            };
-            const user = { role: "user", content: [{ kind: "text", text: line }] };
-            history.push(user);
-            modelHistory.push(structuredClone(user));
-            const turn = events(emit, session);
-            const specs = toolSpecs(session.tools);
-            const commit = (checkpoint, settlement) => {
-                session.conversation = session.conversation.commit({
-                    ...(nodeId === undefined ? {} : { nodeId }),
-                    parentId,
-                    createdAt,
-                    identity: {
-                        providerId: session.provider.id,
-                        model: session.model,
-                        effort: session.config.effort,
-                    },
-                    messages: checkpoint.slice(before),
-                    blocks: [],
-                    ...(context === undefined ? {} : { context }),
-                }, settlement);
-                nodeId = session.conversation.activeNodeId;
-            };
-            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,
-                    signal,
-                    context: projected,
-                    turn: checkpoint.slice(before),
-                    nodeId: nodeId ?? prospectiveNodeId,
-                    coveredMessages: context?.messageCount ?? 0,
-                    lastInputTokens: Math.max(session.usage.lastInputTokens, request.inputTokens),
-                    estimatedInputTokens: request.inputTokens,
-                    force,
-                    policy: request.policy,
-                    requestEnvelope: {
-                        system: session.system,
-                        tools: specs,
-                        maxOutputTokens: session.config.maxTokens,
-                    },
-                    requestIdentity: requestIdentityForSession(session),
-                    onBegin: () => {
-                        attempted = true;
-                    },
-                });
-                if (result === undefined) {
-                    if (attempted && signal?.aborted !== true)
-                        automaticCompaction.failed(attempt);
-                    return undefined;
-                }
-                automaticCompaction.succeeded(attempt);
-                context = result.anchor;
-                if (result.usage !== undefined)
-                    recordAuxiliaryUsage(session.usage, result.usage);
-                return result.messages;
-            };
-            turn.onContext = compact;
-            turn.onCheckpoint = async (checkpoint, settlement, projected) => {
-                commit(checkpoint, settlement);
-                const compacted = await compact(checkpoint, projected, {
-                    reason: "budget",
-                    policy: await policy(),
-                    inputTokens: session.usage.lastInputTokens,
-                    projectionSaturated: false,
-                });
-                if (compacted !== undefined)
-                    commit(checkpoint, settlement);
-                return compacted;
-            };
-            try {
-                await runTurn(history, options(session, policy), turn, signal, modelHistory);
-            }
-            catch (error) {
-                throwIfAborted(signal);
-                if (!(error instanceof Error))
-                    throw error;
-                const message = providerFailure(session.provider, error, true);
-                if (message === error.message)
-                    throw error;
-                throw new Error(message, { cause: error });
-            }
-            turn.flush();
-        }
-        throwIfAborted(signal);
-    }
-    finally {
-        if (environment.lines === undefined)
-            stdin.pause();
-    }
-}
-function throwIfAborted(signal) {
-    if (signal?.aborted === true)
-        throw signal.reason;
-}
-async function* abortableLines(source, signal) {
-    const iterator = source[Symbol.asyncIterator]();
-    let exhausted = false;
-    try {
-        while (true) {
-            throwIfAborted(signal);
-            const next = signal === undefined
-                ? await iterator.next()
-                : await new Promise((resolve, reject) => {
-                    const abort = () => reject(signal.reason);
-                    signal.addEventListener("abort", abort, { once: true });
-                    iterator.next().then((result) => {
-                        signal.removeEventListener("abort", abort);
-                        resolve(result);
-                    }, (error) => {
-                        signal.removeEventListener("abort", abort);
-                        reject(error);
-                    });
-                });
-            if (next.done === true) {
-                exhausted = true;
-                return;
-            }
-            yield next.value;
-        }
-    }
-    finally {
-        if (!exhausted && iterator.return !== undefined) {
-            const closing = iterator.return();
-            if (signal?.aborted === true)
-                void closing.catch(() => { });
-            else
-                await closing;
-        }
-    }
-}
-function options(session, contextPolicy) {
-    return {
-        provider: session.provider,
-        tools: session.tools,
-        model: session.model,
-        system: session.system,
-        maxTokens: session.config.maxTokens,
-        contextPolicy,
-        effort: session.config.effort,
-        requestIdentity: requestIdentityForSession(session),
-        maxModelRequests: session.config.maxModelRequests,
-        toolContext: { root: session.config.root },
-    };
-}
-// Prose is buffered rather than streamed: without a screen to repaint there is
-// nothing to gain from partial lines, and plenty to lose in readability.
-function events(emit, session) {
-    let answer = "";
-    const flush = () => {
-        if (answer === "")
-            return;
-        emit({ kind: "answer", text: answer });
-        answer = "";
-    };
-    return {
-        flush,
-        onStream(event) {
-            if (event.kind === "text")
-                answer += event.text;
-        },
-        onToolCall() {
-            flush();
-        },
-        onToolResult(call, result, summary) {
-            emit({
-                kind: "tool",
-                name: call.name,
-                target: "",
-                right: summary ?? "",
-                tone: result.isError ? "fail" : "ok",
-            });
-        },
-        approve() {
-            flush();
-            // Nobody is watching a pipe. Approval has to be granted up front with
-            // --auto-approve, never inferred from silence.
-            return Promise.resolve(session.config.autoApprove);
-        },
-        onUsage(usage) {
-            recordUsage(session.usage, usage);
-        },
-        onRequestInput(inputTokens) {
-            recordRequestInput(session.usage, inputTokens);
-        },
-    };
-}