@giovannijecha/jecode 0.8.4 → 0.8.5

package/dist/tui/app-workflows.js

@@ -2,6 +2,7 @@
 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";
@@ -10,6 +11,8 @@ 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";
@@ -20,6 +23,7 @@ const WAITING = "Waiting";
 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();
@@ -52,6 +56,8 @@ export function appWorkflows(options) {
                 },
                 reset: async () => {
                     await session.persistence?.reset();
+                    resetRequestIdentity(session);
+                    automaticCompaction.reset();
                     state.blocks.splice(0);
                     state.past.length = 0;
                     permissions.reset();
@@ -80,13 +86,16 @@ export function appWorkflows(options) {
                     if (session.conversation.activeNodeId !== state.committedNodeId) {
                         return "branch-pending";
                     }
-                    return compactSession(session, {
+                    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")
@@ -131,6 +140,8 @@ export function appWorkflows(options) {
         let nodeId;
         let context;
         const unpersistedSteering = [];
+        const turnTools = permissions.availableTools();
+        const specs = toolSpecs(turnTools);
         let firstPolicy = true;
         const policy = () => {
             let visible = firstPolicy;
@@ -202,7 +213,12 @@ export function appWorkflows(options) {
                 (request.error === undefined || !isContextOverflow(request.error))) {
                 return undefined;
             }
-            const force = request.reason === "overflow";
+            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,
@@ -216,7 +232,14 @@ export function appWorkflows(options) {
                 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();
                 },
@@ -225,8 +248,12 @@ export function appWorkflows(options) {
                     options.render();
                 },
             });
-            if (result === undefined)
+            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);
@@ -244,6 +271,7 @@ export function appWorkflows(options) {
                 reason: "budget",
                 policy: await policy(),
                 inputTokens: session.usage.lastInputTokens,
+                projectionSaturated: false,
             });
             if (compacted !== undefined)
                 await persist(checkpoint, settlement);
@@ -252,7 +280,7 @@ export function appWorkflows(options) {
         let finishReason;
         let failed;
         try {
-            await runTurn(history, controllerOptions(session, policy, permissions.availableTools(), inbox), events, activity.control.signal, modelHistory);
+            await runTurn(history, controllerOptions(session, policy, turnTools, inbox), events, activity.control.signal, modelHistory);
         }
         catch (error) {
             const interrupted = activity.control.signal.aborted;

package/dist/tui/components/footer.js

@@ -10,7 +10,7 @@ export function renderFooter(info, status, width, pal) {
 function identity(info, cols) {
     if (cols <= 0)
         return "";
-    const core = `${info.model || "no model"} · ${info.effort}`;
+    const core = `${info.provider || "Provider"} · ${info.model || "no model"} · ${info.effort}`;
     if (textWidth(core) >= cols || info.workspace === "")
         return elide(core, cols);
     const divider = " · ";

package/dist/tui/feedback.js

@@ -1,4 +1,5 @@
 // Operational feedback belongs in the footer, not in the conversation.
+import { CONVERSATION_LIMITS } from "../conversation.js";
 import { providerLabel } from "../provider-label.js";
 const INFO_MS = 2_200;
 const WARN_MS = 4_200;
@@ -53,6 +54,9 @@ export function turnBlocker(session) {
     if (session.persistence?.failure !== undefined) {
         return { text: "session could not be saved · /new to retry", tone: "error" };
     }
+    if (session.conversation.nodes.length >= CONVERSATION_LIMITS.nodes) {
+        return { text: "conversation reached its session limit · /new to continue", tone: "warn" };
+    }
     const blocked = session.provider.blocked();
     const auth = session.provider.auth;
     const expected = auth.kind === "api-key"

package/dist/tui/session-view.js

@@ -1,6 +1,9 @@
 // Small projections of the live session used by the shell and footer.
 import { credentialSource } from "../credentials.js";
 import { providerFailure } from "../provider-errors.js";
+import { providerRouteLabel } from "../provider-label.js";
+import { providerFailureDetails } from "../providers/failure.js";
+import { requestIdentityForSession } from "../request-identity.js";
 export function controllerOptions(session, contextPolicy, tools = session.tools, steering) {
     return {
         provider: session.provider,
@@ -10,6 +13,7 @@ export function controllerOptions(session, contextPolicy, tools = session.tools,
         maxTokens: session.config.maxTokens,
         contextPolicy,
         effort: session.config.effort,
+        requestIdentity: requestIdentityForSession(session),
         maxModelRequests: session.config.maxModelRequests,
         toolContext: { root: session.config.root },
         ...(steering === undefined ? {} : { steering }),
@@ -18,6 +22,7 @@ export function controllerOptions(session, contextPolicy, tools = session.tools,
 export function footerInfo(session, workspace = session.config.root) {
     return {
         workspace,
+        provider: providerRouteLabel(session.provider),
         model: session.model || "no model",
         effort: session.config.effort,
     };
@@ -26,8 +31,8 @@ export function footerInfo(session, workspace = session.config.root) {
 export function turnFailure(session, error, aborted) {
     if (aborted)
         return { kind: "notice", text: "[interrupted]", tone: "warn" };
-    let text = providerFailure(session.provider, error);
-    if (/\b401\b/.test(text)) {
+    let text = providerFailure(session.provider, error, true);
+    if (providerFailureDetails(session.provider.id, error).kind === "authentication") {
         const auth = session.provider.auth;
         if (auth.kind === "oauth") {
             text += ` · reconnect ${auth.label} in /providers`;

package/dist/tui/workspace.js

@@ -1,7 +1,10 @@
 // Compact workspace identity for the persistent footer.
-import { readFile, stat } from "node:fs/promises";
+import { lstat } from "node:fs/promises";
 import { homedir } from "node:os";
 import * as path from "node:path";
+import { readBoundedText, stableFileExpectation } from "../bounded-file.js";
+import { assertDirectoryAnchor, captureDirectDirectory, } from "../directory-anchor.js";
+const MAX_GIT_POINTER_BYTES = 4_096;
 export async function workspaceLabel(root) {
     const shown = displayRoot(root);
     const branch = await findBranch(root);
@@ -30,16 +33,24 @@ async function findBranch(root) {
 async function branchAt(directory) {
     const marker = path.join(directory, ".git");
     try {
-        const info = await stat(marker);
-        if (info.isDirectory())
-            return readHead(marker);
+        const info = await lstat(marker, { bigint: true });
+        if (info.isSymbolicLink())
+            return undefined;
+        if (info.isDirectory()) {
+            const gitDirectory = await captureDirectDirectory(marker, "Git directory");
+            return readHead(gitDirectory);
+        }
         if (!info.isFile())
             return undefined;
-        const pointer = await readFile(marker, "utf8");
+        const pointer = await readBoundedText(marker, MAX_GIT_POINTER_BYTES, {
+            label: "Git directory pointer",
+            expected: stableFileExpectation(info),
+        });
         const match = /^gitdir:\s*(.+)\s*$/im.exec(pointer);
         if (match === null)
             return undefined;
-        return readHead(path.resolve(directory, match[1]));
+        const gitDirectory = await captureDirectDirectory(path.resolve(directory, match[1]), "Git directory");
+        return readHead(gitDirectory);
     }
     catch {
         return undefined;
@@ -47,7 +58,10 @@ async function branchAt(directory) {
 }
 async function readHead(gitDirectory) {
     try {
-        const head = (await readFile(path.join(gitDirectory, "HEAD"), "utf8")).trim();
+        const head = (await readBoundedText(path.join(gitDirectory.path, "HEAD"), MAX_GIT_POINTER_BYTES, {
+            label: "Git HEAD",
+            validate: async () => assertDirectoryAnchor(gitDirectory),
+        })).trim();
         const prefix = "ref: refs/heads/";
         if (head.startsWith(prefix))
             return head.slice(prefix.length);

package/dist/user-store.js

@@ -1,6 +1,7 @@
 // Bounded synchronous reads for the tiny JSON stores under ~/.jecode.
 import { Buffer } from "node:buffer";
-import { closeSync, constants, fstatSync, openSync, readSync } from "node:fs";
+import { readBoundedFileSync } from "./bounded-file.js";
+import { assertDirectoryAnchorSync } from "./directory-anchor.js";
 export const USER_STORE_LIMITS = Object.freeze({
     settingsBytes: 64 * 1_024,
     credentialsBytes: 256 * 1_024,
@@ -13,38 +14,29 @@ export const USER_STORE_LIMITS = Object.freeze({
     accountToken: 32_768,
     accountLabel: 1_024,
 });
-export function readBoundedJsonSync(file, maxBytes) {
-    // Non-blocking open keeps a replaced FIFO or device from stalling startup;
-    // fstat below then accepts only regular files before any content is read.
-    const flags = process.platform === "win32"
-        ? "r"
-        : constants.O_RDONLY | (constants.O_NONBLOCK ?? 0);
-    const descriptor = openSync(file, flags);
+export function readBoundedJsonSync(file, maxBytes, directory) {
+    const validate = directory === undefined
+        ? undefined
+        : () => assertDirectoryAnchorSync(directory);
+    return JSON.parse(readBoundedFileSync(file, maxBytes, {
+        label: "user store",
+        validate,
+    }).toString("utf8"));
+}
+export function readBoundedJsonForMutationSync(file, maxBytes, label, directory) {
     try {
-        const details = fstatSync(descriptor);
-        if (!details.isFile())
-            throw new Error("user store must be a regular file");
-        if (!Number.isSafeInteger(details.size) || details.size > maxBytes) {
-            throw new Error(`user store exceeds ${maxBytes} bytes`);
-        }
-        // One extra byte detects an in-place growth after fstat without allowing
-        // the read allocation to follow the file's new size.
-        const capacity = Math.min(maxBytes + 1, Math.max(1, details.size + 1));
-        const bytes = Buffer.allocUnsafe(capacity);
-        let offset = 0;
-        while (offset < capacity) {
-            const count = readSync(descriptor, bytes, offset, capacity - offset, null);
-            if (count === 0)
-                break;
-            offset += count;
-        }
-        if (offset > maxBytes || offset > details.size) {
-            throw new Error("user store changed while it was being read");
-        }
-        return JSON.parse(bytes.toString("utf8", 0, offset));
+        const validate = directory === undefined
+            ? undefined
+            : () => assertDirectoryAnchorSync(directory);
+        return JSON.parse(readBoundedFileSync(file, maxBytes, {
+            label: "user store",
+            validate,
+        }).toString("utf8"));
     }
-    finally {
-        closeSync(descriptor);
+    catch (error) {
+        if (error.code === "ENOENT")
+            return undefined;
+        throw new Error(`${label} is invalid, unsafe, or too large`, { cause: error });
     }
 }
 export function assertStoreText(text, maxBytes) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@giovannijecha/jecode",
-  "version": "0.8.4",
+  "version": "0.8.5",
   "description": "An owned coding agent with zero external runtime dependencies.",
   "license": "MIT",
   "repository": {
@@ -59,9 +59,8 @@
     "check:install": "npm run build:release -- --quiet && node dev/check-installed-cli.ts",
     "check": "npm run check:source-tree && npm run typecheck && npm run coverage && npm run check:package && npm run check:install"
   },
-  "dependencies": {},
   "devDependencies": {
-    "@types/node": "^26.4.0",
-    "typescript": "^5.9.3"
+    "@types/node": "^26.4.1",
+    "typescript": "^7.0.2"
   }
 }

package/dist/tools/ripgrep.js

@@ -1,230 +0,0 @@
-// Optional native acceleration for bounded literal search.
-import { spawn } from "node:child_process";
-import * as path from "node:path";
-import { shellEnvironment } from "../credential-safety.js";
-import { resolveExecutable } from "../executable.js";
-const MAX_BATCH_FILES = 256;
-const MAX_BATCH_BYTES = 16_000_000;
-const MAX_COMMAND_CHARS = 12_000;
-const MAX_QUERY_CHARS = 4_000;
-const MAX_EVENT_CHARS = 8_000_000;
-const MAX_STDERR_CHARS = 16_000;
-/** Return undefined when ripgrep is unavailable or cannot preserve the contract. */
-export async function trySearchWithRipgrep(options) {
-    if (options.files.length === 0)
-        return { matches: [], binaryPaths: [] };
-    if (options.query.length > MAX_QUERY_CHARS || options.query.includes("\0"))
-        return undefined;
-    const executable = resolveExecutable("rg", { rejectUnder: options.root });
-    if (executable === undefined)
-        return undefined;
-    const matches = [];
-    const binaryPaths = new Set();
-    try {
-        for (const batch of batches(options.files, options.query.length)) {
-            throwIfAborted(options.signal);
-            const searched = await searchBatch(executable, batch, options);
-            if (searched === undefined)
-                return undefined;
-            for (const match of searched.matches) {
-                if (matches.length >= options.limit)
-                    break;
-                matches.push(match);
-            }
-            for (const file of searched.binaryPaths)
-                binaryPaths.add(file);
-            if (matches.length >= options.limit)
-                break;
-        }
-    }
-    catch (error) {
-        if (options.signal?.aborted === true)
-            throw abortReason(options.signal);
-        return undefined;
-    }
-    return { matches, binaryPaths: [...binaryPaths] };
-}
-function batches(files, queryChars) {
-    const groups = [];
-    let group = [];
-    let bytes = 0;
-    let chars = queryChars;
-    for (const file of files) {
-        const nextChars = chars + file.path.length + 1;
-        if (group.length > 0 &&
-            (group.length >= MAX_BATCH_FILES ||
-                bytes + file.bytes > MAX_BATCH_BYTES ||
-                nextChars > MAX_COMMAND_CHARS)) {
-            groups.push(group);
-            group = [];
-            bytes = 0;
-            chars = queryChars;
-        }
-        group.push(file);
-        bytes += file.bytes;
-        chars += file.path.length + 1;
-    }
-    if (group.length > 0)
-        groups.push(group);
-    return groups;
-}
-function searchBatch(executable, files, options) {
-    throwIfAborted(options.signal);
-    const args = [
-        "--json",
-        "--no-config",
-        "--fixed-strings",
-        "--max-filesize",
-        "1000000",
-        "--max-count",
-        String(options.limit),
-        ...(options.caseSensitive ? [] : ["--ignore-case"]),
-        "--",
-        options.query,
-        ...files.map((file) => file.path),
-    ];
-    return new Promise((resolve, reject) => {
-        let child;
-        try {
-            child = spawn(executable, args, {
-                cwd: path.dirname(executable),
-                env: shellEnvironment(),
-                windowsHide: true,
-                stdio: ["ignore", "pipe", "pipe"],
-            });
-        }
-        catch {
-            resolve(undefined);
-            return;
-        }
-        const matches = [];
-        const binaryPaths = new Set();
-        let buffered = "";
-        let stderr = "";
-        let invalid = false;
-        let overLimit = false;
-        let settled = false;
-        const onAbort = () => child.kill();
-        options.signal?.addEventListener("abort", onAbort, { once: true });
-        if (options.signal?.aborted === true)
-            onAbort();
-        const finish = (value, error) => {
-            if (settled)
-                return;
-            settled = true;
-            options.signal?.removeEventListener("abort", onAbort);
-            if (error !== undefined)
-                reject(error);
-            else
-                resolve(value);
-        };
-        const consume = (line) => {
-            if (line === "" || invalid || overLimit)
-                return;
-            try {
-                const event = JSON.parse(line);
-                const parsed = ripgrepEvent(event);
-                if (parsed?.kind === "match") {
-                    // `rg --max-count` is per file, not global. Once the raw stream
-                    // exceeds the requested result count, stop the accelerator and let
-                    // the portable scanner produce the exact bounded answer. Returning
-                    // early here would lose the later binary-file end marker.
-                    if (matches.length >= options.limit) {
-                        overLimit = true;
-                        child.kill();
-                        return;
-                    }
-                    matches.push(parsed.match);
-                }
-                if (parsed?.kind === "binary")
-                    binaryPaths.add(parsed.path);
-            }
-            catch {
-                invalid = true;
-                child.kill();
-            }
-        };
-        child.stdout.setEncoding("utf8");
-        child.stderr.setEncoding("utf8");
-        child.stdout.on("data", (chunk) => {
-            buffered += chunk;
-            if (buffered.length > MAX_EVENT_CHARS) {
-                invalid = true;
-                child.kill();
-                return;
-            }
-            let newline = buffered.indexOf("\n");
-            while (newline !== -1) {
-                consume(buffered.slice(0, newline));
-                buffered = buffered.slice(newline + 1);
-                newline = buffered.indexOf("\n");
-            }
-        });
-        child.stderr.on("data", (chunk) => {
-            stderr = `${stderr}${chunk}`.slice(-MAX_STDERR_CHARS);
-        });
-        child.on("error", (error) => {
-            if (options.signal?.aborted === true)
-                finish(undefined, abortReason(options.signal));
-            else if (error.code === "ENOENT")
-                finish(undefined);
-            else
-                finish(undefined);
-        });
-        child.on("close", (code) => {
-            if (options.signal?.aborted === true) {
-                finish(undefined, abortReason(options.signal));
-                return;
-            }
-            consume(buffered);
-            if (invalid || overLimit || (code !== 0 && code !== 1) || stderr.trim() !== "") {
-                finish(undefined);
-                return;
-            }
-            const order = new Map(files.map((file, index) => [file.path, index]));
-            finish({
-                matches: matches
-                    .filter((match) => !binaryPaths.has(match.path))
-                    .sort((a, b) => ((order.get(a.path) ?? Number.MAX_SAFE_INTEGER) -
-                    (order.get(b.path) ?? Number.MAX_SAFE_INTEGER) ||
-                    a.line - b.line)),
-                binaryPaths: [...binaryPaths],
-            });
-        });
-    });
-}
-function ripgrepEvent(value) {
-    if (!record(value) || !record(value["data"]))
-        return undefined;
-    const data = value["data"];
-    const file = textField(data["path"]);
-    if (file === undefined)
-        return undefined;
-    if (value["type"] === "match") {
-        const line = data["line_number"];
-        const text = textField(data["lines"]);
-        if (typeof line !== "number" || !Number.isInteger(line) || text === undefined)
-            return undefined;
-        return {
-            kind: "match",
-            match: { path: file, line, text: text.replace(/\r?\n$/, "") },
-        };
-    }
-    if (value["type"] === "end" && typeof data["binary_offset"] === "number") {
-        return { kind: "binary", path: file };
-    }
-    return undefined;
-}
-function textField(value) {
-    return record(value) && typeof value["text"] === "string" ? value["text"] : undefined;
-}
-function record(value) {
-    return typeof value === "object" && value !== null && !Array.isArray(value);
-}
-function throwIfAborted(signal) {
-    if (signal?.aborted === true)
-        throw abortReason(signal);
-}
-function abortReason(signal) {
-    return signal.reason instanceof Error ? signal.reason : new Error("interrupted");
-}