@giovannijecha/jecode 0.8.5 → 0.8.6

package/dist/tui/turn-workflow.js

@@ -0,0 +1,264 @@
+// 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 { steeringInbox } from "../steering.js";
+import { recordAuxiliaryUsage, recordRequestInput, recordUsage } from "../usage.js";
+import { toolSpecs } from "../tools/index.js";
+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 { transcribe } from "./turn.js";
+const WAITING = "Waiting";
+export function turnWorkflow(options, automaticCompaction) {
+    const { session, state, permissions, feedback } = options;
+    let activeSteering;
+    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 { 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;
+}

package/dist/tui/turn.js

@@ -3,17 +3,14 @@
 // The controller speaks in stream events and tool results; the screen speaks in
 // blocks. This is the whole of the translation, kept out of the shell so that
 // neither has to know how the other is built.
-import { graphemes } from "../text-boundary.js";
-import { condense, diff } from "../ui/diff.js";
 import { promptFor } from "./approve.js";
+import { toolTarget, previewDetails, producedDetails, outputDetails } from "./tool-details.js";
 // Semantic activity labels feed the footer's compact state and timer while
 // reasoning and tools keep the detailed work visible in the transcript.
 const WAITING = "Waiting";
 const THINKING = "Thinking";
 const RESPONDING = "Responding";
 const ASKING = "Waiting for you";
-/** Unchanged rows kept either side of a change. */
-const CONTEXT = 2;
 export function transcribe(stage) {
     // The block the stream is currently filling. A change of kind starts a new
     // one, which is what keeps reasoning and answer from running together.
@@ -104,10 +101,10 @@ export function transcribe(stage) {
             const block = {
                 kind: "tool",
                 name: call.name,
-                target: target(call.input),
+                target: toolTarget(call.input),
                 right: "ready",
                 tone: "pending",
-                body: preview(call, look),
+                body: previewDetails(call, look),
             };
             tools.set(call.id, block);
             stage.emit(block);
@@ -117,7 +114,7 @@ export function transcribe(stage) {
             const block = tools.get(call.id);
             if (block === undefined || block.kind !== "tool" || block.tone !== "pending")
                 return;
-            block.body = details(output, "out");
+            block.body = outputDetails(output, "out");
             stage.render(block);
         },
         onToolResult(call, result, summary) {
@@ -138,8 +135,8 @@ export function transcribe(stage) {
             // A failure replaces the preview: what the call was going to do stops
             // being the interesting part the moment it did not do it.
             const outcome = result.isError
-                ? details(result.output, "out")
-                : produced(call, result.output);
+                ? outputDetails(result.output, "out")
+                : producedDetails(call, result.output);
             if (outcome !== undefined)
                 block.body = outcome;
             stage.render(block);
@@ -158,7 +155,7 @@ export function transcribe(stage) {
                 stage.render(block);
             }
             return new Promise((resolve) => {
-                stage.ask(promptFor(call, target(call.input), stage.palette), (answer) => {
+                stage.ask(promptFor(call, toolTarget(call.input), stage.palette), (answer) => {
                     if (answer === "always")
                         stage.remember(call);
                     const approved = answer !== "no";
@@ -204,133 +201,3 @@ function settleDuration(block) {
     }
     block.startedAt = undefined;
 }
-/** The argument worth showing: the thing the call acts on. */
-function target(input) {
-    const { path, command } = input;
-    if (typeof command === "string")
-        return command;
-    if (typeof path === "string")
-        return path;
-    const rest = JSON.stringify(input);
-    return rest === "{}" ? "" : rest;
-}
-/**
- * What the call is about to do, drawn before it is allowed to do it.
- *
- * The tool is asked first, because only it knows what is already on disk: a
- * write against an existing file is a replacement, and showing it as a page of
- * additions hides exactly the part worth approving. The fallback diffs what is
- * in the arguments, which is all there is when a tool has nothing to say.
- */
-function preview(call, look) {
-    if (look !== undefined)
-        return changes(look.before, look.after);
-    const input = call.input;
-    if (call.name === "write_file" && typeof input.content === "string") {
-        return changes("", input.content);
-    }
-    if (call.name === "edit_file" && typeof input.old_text === "string") {
-        return changes(input.old_text, typeof input.new_text === "string" ? input.new_text : "");
-    }
-    return undefined;
-}
-/** Two texts as the rows of their difference, unchanged runs summed up. */
-function changes(before, after) {
-    let oldLine = 1;
-    let newLine = 1;
-    const rows = [];
-    for (const changed of condense(diff(before, after), CONTEXT)) {
-        if (changed.kind === "gap") {
-            rows.push({ kind: "gap", text: `… ${changed.skipped} unchanged` });
-            oldLine += changed.skipped;
-            newLine += changed.skipped;
-            continue;
-        }
-        if (changed.kind === "keep") {
-            rows.push({ kind: "keep", text: tabs(changed.text), oldLine, newLine });
-            oldLine++;
-            newLine++;
-            continue;
-        }
-        if (changed.kind === "del") {
-            rows.push({ kind: "del", text: tabs(changed.text), oldLine });
-            oldLine++;
-            continue;
-        }
-        rows.push({ kind: "add", text: tabs(changed.text), newLine });
-        newLine++;
-    }
-    emphasizePairs(rows);
-    return rows.length === 0 ? undefined : rows;
-}
-function emphasizePairs(rows) {
-    for (let index = 0; index < rows.length - 1; index++) {
-        const removed = rows[index];
-        const added = rows[index + 1];
-        if (removed?.kind !== "del" || added?.kind !== "add")
-            continue;
-        if (rows[index - 1]?.kind === "del" || rows[index + 2]?.kind === "add")
-            continue;
-        const removedClusters = graphemes(removed.text);
-        const addedClusters = graphemes(added.text);
-        let prefix = 0;
-        let start = 0;
-        while (prefix < removedClusters.length &&
-            prefix < addedClusters.length &&
-            removedClusters[prefix] === addedClusters[prefix]) {
-            start += removedClusters[prefix].length;
-            prefix++;
-        }
-        let suffix = 0;
-        let removedSuffix = 0;
-        let addedSuffix = 0;
-        while (suffix < removedClusters.length - prefix &&
-            suffix < addedClusters.length - prefix &&
-            removedClusters[removedClusters.length - 1 - suffix] ===
-                addedClusters[addedClusters.length - 1 - suffix]) {
-            removedSuffix += removedClusters[removedClusters.length - 1 - suffix].length;
-            addedSuffix += addedClusters[addedClusters.length - 1 - suffix].length;
-            suffix++;
-        }
-        while (suffix > 0 &&
-            (!wordBoundary(removed.text, removedSuffix) || !wordBoundary(added.text, addedSuffix))) {
-            removedSuffix -= removedClusters[removedClusters.length - suffix].length;
-            addedSuffix -= addedClusters[addedClusters.length - suffix].length;
-            suffix--;
-        }
-        const removedLength = removed.text.length - start - removedSuffix;
-        const addedLength = added.text.length - start - addedSuffix;
-        if (removedLength > 0)
-            removed.emphasis = { start, length: removedLength };
-        if (addedLength > 0)
-            added.emphasis = { start, length: addedLength };
-    }
-}
-function wordBoundary(text, suffix) {
-    const at = text.length - suffix;
-    if (at <= 0 || at >= text.length)
-        return true;
-    return /\w/.test(text[at - 1]) !== /\w/.test(text[at]);
-}
-/** What the call left behind, for the calls whose output is worth a look. */
-function produced(call, output) {
-    if (call.name === "run_command")
-        return details(output, "out");
-    // A read or a listing is already summed up on the right of its own row, and
-    // the model is about to say what was in it. Printing it twice helps nobody.
-    return undefined;
-}
-function details(text, kind) {
-    const rows = split(text).map((line) => ({ kind, text: tabs(line) }));
-    return rows.length === 0 ? undefined : rows;
-}
-function split(text) {
-    const lines = text.replace(/\r\n?/g, "\n").split("\n");
-    while (lines.length > 0 && lines[lines.length - 1] === "")
-        lines.pop();
-    return lines.map(tabs);
-}
-// A tab is a width the terminal decides and the row measurement cannot see.
-function tabs(line) {
-    return line.replace(/\t/g, "  ");
-}

package/dist/tui/workflow-types.js

@@ -0,0 +1,2 @@
+// Host capabilities shared by foreground command and turn workflows.
+export {};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@giovannijecha/jecode",
-  "version": "0.8.5",
+  "version": "0.8.6",
   "description": "An owned coding agent with zero external runtime dependencies.",
   "license": "MIT",
   "repository": {
@@ -41,22 +41,22 @@
     "registry": "https://registry.npmjs.org/"
   },
   "scripts": {
-    "build:release": "node dev/build-release.ts",
+    "build:release": "node scripts/build-release.ts",
     "pack:release": "npm run build:release && npm pack --ignore-scripts",
     "start": "node src/main.ts",
-    "tui:lab": "node dev/tui-lab.ts",
-    "bench:context": "node dev/benchmark-context.ts",
-    "bench:redaction": "node dev/benchmark-redaction.ts",
-    "bench:search": "node dev/benchmark-search.ts",
-    "bench:session": "node dev/benchmark-session.ts",
-    "bench:transcript": "node dev/benchmark-transcript.ts",
+    "tui:lab": "node dev/tui/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",
     "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",
-    "check:source-tree": "node dev/check-source-tree.ts",
-    "check:release-tag": "node dev/check-release-tag.ts",
-    "check:package": "npm run build:release -- --quiet && node dev/check-package.ts",
-    "check:install": "npm run build:release -- --quiet && node dev/check-installed-cli.ts",
+    "check:source-tree": "node scripts/check-source-tree.ts",
+    "check:release-tag": "node scripts/check-release-tag.ts",
+    "check:package": "npm run build:release -- --quiet && node scripts/check-package.ts",
+    "check:install": "npm run build:release -- --quiet && node scripts/check-installed-cli.ts",
     "check": "npm run check:source-tree && npm run typecheck && npm run coverage && npm run check:package && npm run check:install"
   },
   "devDependencies": {

package/dist/ollama-settings-command.js

@@ -1,74 +0,0 @@
-// Ollama connection choices inside the persistent settings hub.
-import { askForKey } from "./credential-commands.js";
-import { keyFor } from "./credentials.js";
-import { of } from "./tui/editor.js";
-import { heading } from "./tui/picker.js";
-import { OLLAMA_CLOUD_HOST, OLLAMA_LOCAL_HOST, parseOllamaEndpoint, } from "./providers/ollama-endpoint.js";
-import { configureOllama, ollamaConnection } from "./providers/ollama.js";
-const KEY = "OLLAMA_API_KEY";
-export function ollamaConnectionHint() {
-    const connection = ollamaConnection();
-    const origin = new URL(connection.baseUrl).host;
-    const automatic = connection.inferred ? " · automatic" : "";
-    if (connection.kind === "local")
-        return `local · this computer${automatic}`;
-    return `${connection.kind} · ${origin}${automatic}`;
-}
-export async function ollamaConnectionSetting(session, host, persist) {
-    if (host.choose === undefined)
-        return;
-    const current = ollamaConnection();
-    const index = await host.choose({
-        title: heading("Ollama connection", "where Ollama requests run", session.palette),
-        options: [
-            { label: "cloud", hint: "ollama.com · API key" },
-            { label: "local", hint: "this computer · no API key" },
-            { label: "custom", hint: "HTTPS or loopback endpoint" },
-        ],
-        index: current.kind === "cloud" ? 0 : current.kind === "local" ? 1 : 2,
-    });
-    if (index === undefined)
-        return;
-    let nextHost;
-    if (index === 0)
-        nextHost = OLLAMA_CLOUD_HOST;
-    else if (index === 1)
-        nextHost = OLLAMA_LOCAL_HOST;
-    else {
-        const custom = await customEndpoint(session, host, current.kind === "custom" ? current.baseUrl : "https://");
-        if (custom === undefined)
-            return;
-        nextHost = custom;
-    }
-    const endpoint = parseOllamaEndpoint(nextHost);
-    if (!endpoint.loopback && keyFor(KEY) === undefined) {
-        const accepted = await askForKey(KEY, host, session.palette);
-        if (!accepted)
-            return;
-    }
-    if (!(await persist({ ollamaHost: endpoint.baseUrl })))
-        return;
-    configureOllama(endpoint.baseUrl);
-    session.config.ollamaHost = endpoint.baseUrl;
-}
-async function customEndpoint(session, host, initial) {
-    if (host.type === undefined)
-        return undefined;
-    const field = {
-        title: heading("Ollama endpoint", "HTTPS or exact loopback URL", session.palette),
-        right: "enter save · esc back",
-        editor: of(initial),
-        secret: false,
-        note: "Remote endpoints must use HTTPS. API keys are stored separately.",
-    };
-    const value = await host.type(field);
-    if (value === undefined)
-        return undefined;
-    try {
-        return parseOllamaEndpoint(value).baseUrl;
-    }
-    catch (error) {
-        host.emit({ kind: "notice", text: error.message, tone: "error" });
-        return undefined;
-    }
-}

package/dist/tui/motion.js

@@ -1,32 +0,0 @@
-// Small deterministic motion primitives for terminal cells.
-export const TOOL_BIRTH_MS = 300;
-export const TOOL_SETTLE_MS = 700;
-export const TOOL_ROW_ARRIVAL_MS = 420;
-export const TOOL_LEADER_MAX_MS = 1_500;
-export function interval(now, start, duration) {
-    if (start === undefined)
-        return 1;
-    if (duration <= 0)
-        return 1;
-    return Math.max(0, Math.min(1, (now - start) / duration));
-}
-export function easeOut(value) {
-    const rest = 1 - Math.max(0, Math.min(1, value));
-    return 1 - rest * rest * rest;
-}
-export function easeInOut(value) {
-    const at = Math.max(0, Math.min(1, value));
-    return at < 0.5 ? 4 * at * at * at : 1 - Math.pow(-2 * at + 2, 3) / 2;
-}
-export function mix(from, to, amount) {
-    const at = Math.max(0, Math.min(1, amount));
-    return [
-        Math.round(from[0] + (to[0] - from[0]) * at),
-        Math.round(from[1] + (to[1] - from[1]) * at),
-        Math.round(from[2] + (to[2] - from[2]) * at),
-    ];
-}
-/** A restrained pulse that never reaches either endpoint. */
-export function breathe(now, period = 1_400) {
-    return 0.2 + ((Math.sin((now / period) * Math.PI * 2) + 1) / 2) * 0.6;
-}