@giovannijecha/jecode 0.2.0 → 0.2.2

package/dist/providers/openai.js

@@ -5,21 +5,38 @@
 import { postSse } from "./http.js";
 import { listModels } from "./catalog.js";
 import { keyFor } from "../credentials.js";
+import { EFFORTS, requireSupportedEffort } from "../effort.js";
 import { assembleOpenAI } from "./openai-stream.js";
-import { fromWireResponse, normalizeEffort, stopNotice, toWireItems, toWireTool, } from "./openai-wire.js";
+import { fromWireResponse, stopNotice, toWireItems, toWireTool, } from "./openai-wire.js";
 const ENDPOINT = "https://api.openai.com/v1/responses";
 const MODELS = "https://api.openai.com/v1/models";
 const KEY = "OPENAI_API_KEY";
-/**
- * What this account can reach that is not a chat model.
- *
- * The list is an exclusion rather than an allow-list on purpose: an unknown
- * `gpt-`something is far more likely to be a model worth offering than one
- * worth hiding, and an allow-list would quietly bury every family shipped
- * after this line was written.
- */
-const NOT_CHAT = /^(text-|tts-|whisper|dall-e|sora|gpt-image|omni-moderation|davinci|babbage)/;
-const NON_TEXT_MODE = /(?:^|[-_])(audio|realtime|transcribe|tts)(?:[-_]|$)/;
+const RESPONSES_REASONING_MODEL = /^(?:gpt-5(?:[.-]|$)|o(?:1|3|4)(?:[.-]|$)|codex-mini(?:[.-]|$))/;
+// Jecode's transport always streams and always declares local tools. Hide
+// catalog entries that cannot satisfy either half of that contract.
+const INCOMPATIBLE_MODEL = /^(?:gpt-5(?:\.[1-3])?-chat-latest|gpt-5\.5-pro|o1-mini|o(?:1|3)-pro|o3-deep-research|o4-mini-deep-research)(?:-|$)/;
+const STANDARD_EFFORTS = ["low", "medium", "high"];
+const XHIGH_EFFORTS = ["low", "medium", "high", "xhigh"];
+const PRO_EFFORTS = ["medium", "high", "xhigh"];
+const HIGH_ONLY_EFFORT = ["high"];
+export function supportsOpenAIModel(model) {
+    return RESPONSES_REASONING_MODEL.test(model) && !INCOMPATIBLE_MODEL.test(model);
+}
+export function openAIEfforts(model) {
+    if (!supportsOpenAIModel(model))
+        return [];
+    if (/^gpt-5-pro(?:-|$)/.test(model))
+        return HIGH_ONLY_EFFORT;
+    if (/^gpt-5\.[2-5]-pro(?:-|$)/.test(model))
+        return PRO_EFFORTS;
+    if (/^gpt-5\.6(?:[.-]|$)/.test(model))
+        return EFFORTS;
+    if (/^gpt-5\.[2-5](?:[.-]|$)/.test(model))
+        return XHIGH_EFFORTS;
+    if (/^(?:o(?:1|3|4)|codex-mini)(?:[.-]|$)/.test(model))
+        return STANDARD_EFFORTS;
+    return STANDARD_EFFORTS;
+}
 export const openai = {
     id: "openai",
     defaultModel: "gpt-5",
@@ -32,19 +49,23 @@ export const openai = {
     async models(signal, onStatus) {
         const ids = await listModels(MODELS, headers(requireKey()), signal, onStatus);
         return ids
-            .filter((id) => !NOT_CHAT.test(id) && !NON_TEXT_MODE.test(id))
+            .filter(supportsOpenAIModel)
             .sort((a, b) => b.localeCompare(a));
     },
+    async efforts(model) {
+        return openAIEfforts(model);
+    },
     location: () => "cloud",
     async send(req) {
         const key = requireKey();
+        const effort = requireSupportedEffort(req.model, req.effort, openAIEfforts(req.model));
         const events = await postSse(ENDPOINT, headers(key), {
             model: req.model,
             instructions: req.system,
             input: req.messages.flatMap((message) => toWireItems(message)),
             tools: req.tools.map(toWireTool),
             max_output_tokens: req.maxTokens,
-            reasoning: { effort: normalizeEffort(req.effort), summary: "auto" },
+            reasoning: { effort, summary: "auto" },
             store: false,
             include: ["reasoning.encrypted_content"],
             stream: true,

package/dist/settings-command.js

@@ -3,6 +3,7 @@
 import { modelsCommand, providersCommand } from "./provider-commands.js";
 import { credentialsCommand } from "./credential-commands.js";
 import { EFFORTS, readSettings, settingsLabel, updateSettings } from "./settings.js";
+import { providerFailure } from "./provider-errors.js";
 import { ollamaConnectionHint, ollamaConnectionSetting, } from "./ollama-settings-command.js";
 import { of } from "./tui/editor.js";
 import { heading } from "./tui/picker.js";
@@ -109,6 +110,7 @@ async function providerSetting(session, host) {
         model: session.model,
         providerId: session.config.providerId,
         configModel: session.config.model,
+        effort: session.config.effort,
     };
     if (!(await providersCommand(session, host, { announce: false, save: false })))
         return;
@@ -116,40 +118,85 @@ async function providerSetting(session, host) {
     const models = { ...current.models };
     if (session.model !== "")
         models[session.provider.id] = session.model;
-    if (await persist(host, { provider: session.provider.id, models }))
+    const patch = {
+        provider: session.provider.id,
+        models,
+        ...(session.config.effort === before.effort ? {} : { effort: session.config.effort }),
+    };
+    if (await persist(host, patch))
         return;
     session.provider = before.provider;
     session.model = before.model;
     session.config.providerId = before.providerId;
     session.config.model = before.configModel;
+    session.config.effort = before.effort;
 }
 async function modelSetting(session, host) {
-    const before = { model: session.model, configModel: session.config.model };
+    const before = {
+        model: session.model,
+        configModel: session.config.model,
+        effort: session.config.effort,
+    };
     if (!(await modelsCommand(session, host, { announce: false, save: false })))
         return;
     const current = readSettings();
     const models = { ...current.models, [session.provider.id]: session.model };
-    if (await persist(host, { models }))
+    const patch = {
+        models,
+        ...(session.config.effort === before.effort ? {} : { effort: session.config.effort }),
+    };
+    if (await persist(host, patch))
         return;
     session.model = before.model;
     session.config.model = before.configModel;
+    session.config.effort = before.effort;
 }
 async function effortSetting(session, host) {
     const choose = chooser(host);
     if (choose === undefined)
         return;
+    const efforts = await availableEfforts(session, host);
+    if (efforts === undefined)
+        return;
+    if (efforts.length === 0) {
+        host.emit({
+            kind: "notice",
+            text: `${session.model || session.provider.id} controls its own reasoning depth`,
+            tone: "info",
+        });
+        return;
+    }
     const current = session.config.effort;
     const index = await choose({
         title: heading("effort", "saved default", session.palette),
-        options: EFFORTS.map((value) => ({ label: value })),
-        index: Math.max(0, EFFORTS.findIndex((value) => value === current)),
+        options: efforts.map((value) => ({ label: value })),
+        index: Math.max(0, efforts.findIndex((value) => value === current)),
     });
-    const value = index === undefined ? undefined : EFFORTS[index];
+    const value = index === undefined ? undefined : efforts[index];
     if (value === undefined || !(await persist(host, { effort: value })))
         return;
     session.config.effort = value;
     return value;
 }
+async function availableEfforts(session, host) {
+    if (session.provider.efforts === undefined)
+        return EFFORTS;
+    host.status?.(`Asking ${session.provider.id}`);
+    try {
+        return await session.provider.efforts(session.model, host.signal, (status) => host.status?.(status));
+    }
+    catch (error) {
+        host.emit({
+            kind: "notice",
+            text: providerFailure(session.provider, error, true),
+            tone: "error",
+        });
+        return undefined;
+    }
+    finally {
+        host.status?.(undefined);
+    }
+}
 async function motionSetting(session, host) {
     const choose = chooser(host);
     if (choose === undefined)

package/dist/settings.js

@@ -3,10 +3,11 @@ import { readFileSync } from "node:fs";
 import { chmod, mkdir } from "node:fs/promises";
 import * as path from "node:path";
 import { atomicWrite } from "./atomic.js";
+import { EFFORTS } from "./effort.js";
 import { providerNames } from "./providers/index.js";
 import { parseOllamaEndpoint } from "./providers/ollama-endpoint.js";
 import { userDataLabel, userDataPath } from "./user-data.js";
-export const EFFORTS = ["low", "medium", "high", "xhigh", "max"];
+export { EFFORTS } from "./effort.js";
 let saved;
 export function readSettings() {
     if (saved === undefined)

package/dist/tools/args.js

@@ -3,10 +3,11 @@
 //
 // Every throw here becomes an is_error tool result the model can read and
 // correct on the next step, so the messages are written for that reader.
-export function requireString(args, name) {
+export function requireString(args, name, allowEmpty = false) {
     const value = args[name];
-    if (typeof value !== "string" || value === "") {
-        throw new Error(`"${name}" is required and must be a non-empty string`);
+    if (typeof value !== "string" || (!allowEmpty && value === "")) {
+        const kind = allowEmpty ? "a string" : "a non-empty string";
+        throw new Error(`"${name}" is required and must be ${kind}`);
     }
     return value;
 }

package/dist/tools/fs.js

@@ -101,7 +101,7 @@ export const writeFile = {
     async preview(args, ctx) {
         const root = await resolveExistingInRoot(ctx.root, ".");
         const target = await resolveDirectWritableInRoot(root, requireString(args, "path"));
-        const content = requireString(args, "content");
+        const content = requireString(args, "content", true);
         assertEditableText(content);
         // A write against a file that is already there is a replacement, and the
         // user is owed the difference rather than a wall of green.
@@ -110,7 +110,7 @@ export const writeFile = {
     async run(args, ctx) {
         const root = await resolveExistingInRoot(ctx.root, ".");
         const target = await resolveDirectWritableInRoot(root, requireString(args, "path"));
-        const content = requireString(args, "content");
+        const content = requireString(args, "content", true);
         assertEditableText(content);
         await fs.mkdir(path.dirname(target), { recursive: true });
         const validate = () => assertDirectWritableInRoot(root, target);
@@ -248,7 +248,10 @@ function applied(before, args) {
     }
     const made = replaceAll ? occurrences : 1;
     assertReplacementFits(before, oldText, newText, made);
-    const after = replaceAll ? before.replaceAll(oldText, newText) : before.replace(oldText, newText);
+    const replacement = () => newText;
+    const after = replaceAll
+        ? before.replaceAll(oldText, replacement)
+        : before.replace(oldText, replacement);
     assertEditableText(after, "edited content");
     return { after, made };
 }
@@ -270,6 +273,8 @@ async function unchangedSinceApproval(target, approved) {
     }
 }
 function count(text, noun) {
+    if (text === "")
+        return "empty";
     return plural(text.split("\n").length, noun, `${noun}s`);
 }
 function plural(n, one, many) {

package/dist/tools/index.js

@@ -20,8 +20,8 @@ export function toolSpecs(tools) {
 // and gets another turn to fix its call. Only an aborted turn propagates.
 export async function runTool(tool, call, ctx) {
     try {
-        const { output, summary } = await tool.run(call.input, ctx);
-        return { result: { kind: "tool_result", id: call.id, output, isError: false }, summary };
+        const { output, summary, isError = false } = await tool.run(call.input, ctx);
+        return { result: { kind: "tool_result", id: call.id, output, isError }, summary };
     }
     catch (error) {
         if (ctx.signal?.aborted === true)

package/dist/tools/search.js

@@ -8,6 +8,7 @@ const MAX_RESULTS = 500;
 const MAX_VISITED = 20_000;
 const MAX_FILE_BYTES = 1_000_000;
 const MAX_MATCH_LINE = 500;
+const MAX_GLOB_CHARS = 512;
 const SKIP = new Set([".git", ".hg", ".svn", "node_modules"]);
 export const findFiles = {
     name: "find_files",
@@ -17,7 +18,10 @@ export const findFiles = {
     input: {
         type: "object",
         properties: {
-            pattern: { type: "string", description: "Glob matched against workspace-relative paths." },
+            pattern: {
+                type: "string",
+                description: "Glob matched against workspace-relative paths. Maximum 512 characters.",
+            },
             path: { type: "string", description: "Directory to search, relative to the workspace root." },
             max_results: { type: "integer", description: "Maximum paths returned. Defaults to 100, caps at 500." },
         },
@@ -52,7 +56,10 @@ export const searchText = {
         properties: {
             query: { type: "string", description: "Literal text to find." },
             path: { type: "string", description: "Directory to search, relative to the workspace root." },
-            pattern: { type: "string", description: "Optional file glob, for example **/*.ts." },
+            pattern: {
+                type: "string",
+                description: "Optional file glob, for example **/*.ts. Maximum 512 characters.",
+            },
             case_sensitive: { type: "boolean", description: "Defaults to false." },
             max_results: { type: "integer", description: "Maximum matching lines. Defaults to 100, caps at 500." },
         },
@@ -166,29 +173,107 @@ function resultLimit(args) {
 }
 function glob(pattern) {
     const normalized = pattern.replace(/\\/g, "/");
-    let source = "";
-    for (let index = 0; index < normalized.length; index++) {
-        const char = normalized[index];
-        if (char === "*" && normalized[index + 1] === "*") {
-            if (normalized[index + 2] === "/") {
-                source += "(?:.*/)?";
-                index += 2;
+    if (normalized.length > MAX_GLOB_CHARS) {
+        throw new Error(`"pattern" must be at most ${MAX_GLOB_CHARS} characters`);
+    }
+    const tokens = tokenizeGlob(normalized.toLowerCase());
+    const basenameOnly = !normalized.includes("/");
+    return (relative) => {
+        const candidate = relative.replace(/\\/g, "/");
+        const target = (basenameOnly ? path.posix.basename(candidate) : candidate).toLowerCase();
+        return matchGlob(tokens, Array.from(target));
+    };
+}
+function tokenizeGlob(pattern) {
+    const chars = Array.from(pattern);
+    const tokens = [];
+    let index = 0;
+    while (index < chars.length) {
+        const char = chars[index];
+        if (char === "*") {
+            let end = index + 1;
+            while (chars[end] === "*")
+                end++;
+            if (end - index >= 2) {
+                if (chars[end] === "/") {
+                    tokens.push({ kind: "globdir-start" }, { kind: "globdir-body" });
+                    index = end + 1;
+                }
+                else {
+                    tokens.push({ kind: "globstar" });
+                    index = end;
+                }
             }
             else {
-                source += ".*";
-                index++;
+                tokens.push({ kind: "star" });
+                index = end;
             }
+            continue;
         }
-        else if (char === "*")
-            source += "[^/]*";
-        else if (char === "?")
-            source += "[^/]";
-        else
-            source += char.replace(/[|\\{}()[\]^$+?.]/g, "\\$&");
+        tokens.push(char === "?" ? { kind: "one" } : { kind: "literal", value: char });
+        index++;
     }
-    const expression = new RegExp(`^${source}$`, "i");
-    const basenameOnly = !normalized.includes("/");
-    return (relative) => expression.test(basenameOnly ? path.posix.basename(relative) : relative);
+    return tokens;
+}
+/** Thompson-style wildcard matching: O(pattern × path), with no regex backtracking. */
+function matchGlob(tokens, text) {
+    let states = epsilonClosure(new Set([0]), tokens);
+    for (const char of text) {
+        const next = new Set();
+        for (const state of states) {
+            const token = tokens[state];
+            if (token === undefined)
+                continue;
+            switch (token.kind) {
+                case "literal":
+                    if (token.value === char)
+                        next.add(state + 1);
+                    break;
+                case "one":
+                    if (char !== "/")
+                        next.add(state + 1);
+                    break;
+                case "star":
+                    if (char !== "/")
+                        next.add(state);
+                    break;
+                case "globstar":
+                    next.add(state);
+                    break;
+                case "globdir-body":
+                    next.add(state);
+                    if (char === "/")
+                        next.add(state + 1);
+                    break;
+                case "globdir-start":
+                    break;
+            }
+        }
+        states = epsilonClosure(next, tokens);
+        if (states.size === 0)
+            return false;
+    }
+    return epsilonClosure(states, tokens).has(tokens.length);
+}
+function epsilonClosure(seed, tokens) {
+    const states = new Set(seed);
+    const pending = [...seed];
+    while (pending.length > 0) {
+        const state = pending.pop();
+        const token = tokens[state];
+        const targets = token?.kind === "globdir-start"
+            ? [state + 1, state + 2]
+            : token?.kind === "star" || token?.kind === "globstar"
+                ? [state + 1]
+                : [];
+        for (const target of targets) {
+            if (states.has(target))
+                continue;
+            states.add(target);
+            pending.push(target);
+        }
+    }
+    return states;
 }
 function summary(count, limit, capped, one, many) {
     const noun = count === 1 ? one : many;

package/dist/tools/shell.js

@@ -4,7 +4,9 @@ import { spawn } from "node:child_process";
 import { optionalInt, requireString } from "./args.js";
 import { credentialRedactor, redactCredentials, shellEnvironment } from "../credential-safety.js";
 const DEFAULT_TIMEOUT_MS = 120_000;
+const MAX_TIMEOUT_MS = 2_147_483_647;
 const MAX_OUTPUT_CHARS = 30_000;
+const PIPE_DRAIN_MS = 100;
 export const runCommand = {
     name: "run_command",
     description: "Run a shell command starting in the workspace root and return its combined stdout " +
@@ -24,6 +26,9 @@ export const runCommand = {
         const timeoutMs = optionalInt(args, "timeout_ms") ?? DEFAULT_TIMEOUT_MS;
         if (timeoutMs <= 0)
             throw new Error('"timeout_ms" must be a positive integer');
+        if (timeoutMs > MAX_TIMEOUT_MS) {
+            throw new Error(`"timeout_ms" must be at most ${MAX_TIMEOUT_MS}ms`);
+        }
         const result = await execute(command, ctx.root, timeoutMs, ctx.signal, ctx.onOutput);
         const output = redactCredentials(result.output);
         const summary = result.timedOut
@@ -32,6 +37,7 @@ export const runCommand = {
         return {
             output: output === "" ? `[${summary}]` : `${output}\n[${summary}]`,
             summary,
+            isError: result.timedOut || result.code !== 0,
         };
     },
 };
@@ -45,12 +51,14 @@ function execute(command, cwd, timeoutMs, signal, onOutput) {
             shell: true,
             windowsHide: true,
             detached: process.platform !== "win32",
+            stdio: ["ignore", "pipe", "pipe"],
         });
         const output = capture(onOutput);
         let timedOut = false;
         let aborted;
         let settled = false;
         let forceTimer;
+        let drainTimer;
         const timer = setTimeout(() => {
             timedOut = true;
             stopTree(child.pid, false);
@@ -66,8 +74,20 @@ function execute(command, cwd, timeoutMs, signal, onOutput) {
             clearTimeout(timer);
             if (forceTimer !== undefined)
                 clearTimeout(forceTimer);
+            if (drainTimer !== undefined)
+                clearTimeout(drainTimer);
             signal?.removeEventListener("abort", onAbort);
         };
+        const finish = (code) => {
+            if (settled)
+                return;
+            settled = true;
+            cleanup();
+            if (aborted !== undefined)
+                reject(aborted);
+            else
+                resolve({ output: output.value().trimEnd(), code, timedOut });
+        };
         child.stdout.setEncoding("utf8");
         child.stderr.setEncoding("utf8");
         child.stdout.on("data", output.append);
@@ -79,16 +99,17 @@ function execute(command, cwd, timeoutMs, signal, onOutput) {
             cleanup();
             reject(error);
         });
-        child.on("close", (code) => {
-            if (settled)
-                return;
-            settled = true;
-            cleanup();
-            if (aborted !== undefined)
-                reject(aborted);
-            else
-                resolve({ output: output.value().trimEnd(), code, timedOut });
+        child.on("exit", (code) => {
+            // `close` normally follows once both pipes drain. A detached descendant
+            // can inherit those descriptors after the command itself has exited,
+            // though, so bound that final drain instead of hanging the tool on it.
+            drainTimer = setTimeout(() => {
+                child.stdout.destroy();
+                child.stderr.destroy();
+                finish(code);
+            }, PIPE_DRAIN_MS);
         });
+        child.on("close", finish);
     });
 }
 function capture(onOutput) {

package/dist/tui/app.js

@@ -34,6 +34,7 @@ export async function runApp(session, transcriptRoot, environment = {}) {
     let closed;
     let frameTimer;
     let spinTimer;
+    let escapeTimer;
     let stopResize = () => { };
     let stopInput = () => { };
     // Timers outlive the teardown they were scheduled before. Painting after the
@@ -118,6 +119,8 @@ export async function runApp(session, transcriptRoot, environment = {}) {
             clearInterval(spinTimer);
         if (frameTimer !== undefined)
             clearTimeout(frameTimer);
+        if (escapeTimer !== undefined)
+            clearTimeout(escapeTimer);
         feedback.close();
         terminal.leave();
         closed?.();
@@ -204,12 +207,23 @@ export async function runApp(session, transcriptRoot, environment = {}) {
         draw();
     });
     stopInput = terminal.onInput((chunk) => {
-        for (const key of keys.push(chunk))
+        if (escapeTimer !== undefined)
+            clearTimeout(escapeTimer);
+        for (const key of keys.push(chunk)) {
+            if (!live)
+                break;
             input.handle(key);
-        setTimeout(() => {
+        }
+        if (!live)
+            return;
+        escapeTimer = setTimeout(() => {
+            escapeTimer = undefined;
+            if (!live)
+                return;
             for (const key of keys.flush())
                 input.handle(key);
-            render();
+            if (live)
+                render();
         }, ESCAPE_MS);
         render();
     });

package/dist/tui/components/messages.js

@@ -2,6 +2,8 @@ import { blank, row } from "../../ui/render.js";
 import { markdown } from "../../ui/markdown.js";
 const PAD = 1;
 export const REASONING_PREVIEW_ROWS = 3;
+const MIN_REASONING_PREVIEW_CHARS = 4_096;
+const REASONING_PREVIEW_OVERSCAN = 12;
 export function renderUser(block, width, pal) {
     const inner = Math.max(8, width - PAD * 2);
     const content = markdown(block.text, inner, pal, inner);
@@ -21,14 +23,21 @@ export function renderAnswer(block, width, pal) {
 }
 export function renderReasoning(block, width, pal) {
     const inner = Math.max(8, width - PAD * 2);
-    const content = markdown(block.text, inner, pal, inner);
-    const expanded = block.expanded === true;
+    // Expanding a live stream is deferred until it is sealed. Re-parsing an
+    // ever-growing full thought on every token makes the whole TUI stall.
+    const expanded = block.expanded === true && block.live !== true;
+    const source = !expanded
+        ? reasoningPreviewSource(block.text, inner)
+        : { text: block.text, truncated: false };
+    const content = markdown(source.text, inner, pal, inner);
     const visible = expanded ? content : content.slice(-REASONING_PREVIEW_ROWS);
     const action = expanded
         ? "ctrl+o compact"
-        : content.length > REASONING_PREVIEW_ROWS
-            ? "ctrl+o full"
-            : undefined;
+        : block.live === true && block.expanded === true
+            ? "full when done"
+            : source.truncated || content.length > REASONING_PREVIEW_ROWS
+                ? "ctrl+o full"
+                : undefined;
     return [
         "",
         row(width, [
@@ -41,3 +50,15 @@ export function renderReasoning(block, width, pal) {
         ...visible.map((line) => row(width, line.segs.map((seg) => ({ ...seg, fg: pal.ink.muted, italic: true })), [], undefined, PAD)),
     ];
 }
+export function reasoningPreviewSource(text, width) {
+    const limit = Math.max(MIN_REASONING_PREVIEW_CHARS, width * REASONING_PREVIEW_ROWS * REASONING_PREVIEW_OVERSCAN);
+    if (text.length <= limit)
+        return { text, truncated: false };
+    // A compact view only needs its visible tail. The complete text remains on
+    // the block for expansion after the reasoning stream is sealed.
+    let start = text.length - limit;
+    const code = text.charCodeAt(start);
+    if (code >= 0xdc00 && code <= 0xdfff)
+        start--;
+    return { text: text.slice(start), truncated: true };
+}