@giovannijecha/jecode 0.8.5 → 0.8.7

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@giovannijecha/jecode",
-  "version": "0.8.5",
+  "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"
   ],
@@ -41,22 +43,24 @@
     "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",
+    "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",
-    "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/batch-view.js

@@ -1,17 +0,0 @@
-// Project semantic blocks into a compact transcript for pipes.
-import { render } from "./tui/blocks.js";
-export function renderBatch(block, width, pal) {
-    const rows = [];
-    let lastWasBlank = false;
-    for (const rendered of render(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;
-}

package/dist/batch.js

@@ -1,267 +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,
-                });
-            };
-            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,
-                    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);
-        },
-    };
-}

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;
-}