@giovannijecha/jecode 0.2.2 → 0.2.4

package/dist/accounts.js

@@ -11,8 +11,18 @@ export function openAICodexAccount() {
     return account === undefined ? undefined : { ...account };
 }
 export function accountValues() {
-    const account = store().accounts["openai-codex"];
-    return account === undefined ? [] : [account.accessToken, account.refreshToken];
+    // Keep both snapshots. Another Jecode process may rotate the refresh token
+    // after this process populated its account cache; shell-output redaction
+    // must recognize the newly persisted values without forgetting the old ones.
+    const values = new Set();
+    for (const source of [store(), readStore(accountsPath())]) {
+        const account = source.accounts["openai-codex"];
+        if (account === undefined)
+            continue;
+        values.add(account.accessToken);
+        values.add(account.refreshToken);
+    }
+    return [...values];
 }
 export function accountsPath() {
     return userDataPath("accounts.json");

package/dist/controller.js

@@ -37,6 +37,7 @@ export async function runTurn(history, options, events, signal) {
         if (calls.length > MAX_TOOL_CALLS_PER_STEP) {
             throw new Error(`provider returned ${calls.length} tool calls in one step (maximum ${MAX_TOOL_CALLS_PER_STEP})`);
         }
+        assertToolCallIds(calls);
         history.push(assistant);
         if (calls.length === 0) {
             if (assistant.usage !== undefined)
@@ -95,6 +96,17 @@ export async function runTurn(history, options, events, signal) {
     }
     throw new Error(`gave up after ${options.maxSteps} steps without finishing (raise --max-steps)`);
 }
+function assertToolCallIds(calls) {
+    const seen = new Set();
+    for (const call of calls) {
+        if (call.id.trim() === "")
+            throw new Error("provider returned a tool call without an id");
+        if (seen.has(call.id)) {
+            throw new Error("provider returned duplicate tool call ids in one step");
+        }
+        seen.add(call.id);
+    }
+}
 async function settle(call, options, events, signal, preview) {
     const tool = findTool(options.tools, call.name);
     if (tool === undefined) {

package/dist/credentials.js

@@ -31,8 +31,20 @@ export function credentialSource(name) {
 /** Values that must never survive in shell output, regardless of their source. */
 export function credentialValues() {
     const stored = fromDisk();
-    const names = new Set([...held.keys(), ...Object.keys(stored)]);
-    const values = new Set([...held.values(), ...Object.values(stored)]);
+    // A second process can replace the saved store after this session cached it.
+    // Redact both snapshots so neither a stale nor a newly persisted key can
+    // cross the shell boundary.
+    const current = readSavedStore();
+    const names = new Set([
+        ...held.keys(),
+        ...Object.keys(stored),
+        ...Object.keys(current),
+    ]);
+    const values = new Set([
+        ...held.values(),
+        ...Object.values(stored),
+        ...Object.values(current),
+    ]);
     for (const name of names) {
         const environment = use(process.env[name]);
         if (environment !== undefined)
@@ -94,10 +106,13 @@ export function reload() {
 function fromDisk() {
     if (saved !== undefined)
         return saved;
+    saved = readSavedStore();
+    return saved;
+}
+function readSavedStore() {
     const current = readStore(storePath());
     const legacy = legacyUserDataPath("credentials.json");
-    saved = current ?? (legacy === undefined ? undefined : readStore(legacy)) ?? {};
-    return saved;
+    return current ?? (legacy === undefined ? undefined : readStore(legacy)) ?? {};
 }
 function readStore(file) {
     try {

package/dist/prompt.js

@@ -2,8 +2,6 @@
 // gets rewritten far more often than the loop that carries it.
 export function systemPrompt(config) {
     return [
-        "You are jecode, a coding agent working in a terminal alongside the user.",
-        "",
         `Workspace root: ${config.root}`,
         `Platform: ${process.platform}`,
         "",

package/dist/providers/ollama-stream.js

@@ -8,6 +8,7 @@ export async function assembleOllama(events, onStream) {
     const calls = new Map();
     let toolArgumentChars = 0;
     let content = "";
+    let reasoning = "";
     let finishReason;
     let usage;
     for await (const raw of events) {
@@ -28,9 +29,12 @@ export async function assembleOllama(events, onStream) {
             continue;
         // Reasoning has no standardized field name across the models Ollama
         // serves, so both spellings in circulation are accepted.
-        const reasoning = delta.reasoning ?? delta.reasoning_content;
-        if (typeof reasoning === "string" && reasoning !== "") {
-            onStream?.({ kind: "thinking", text: reasoning });
+        const reasoningDelta = delta.reasoning ?? delta.reasoning_content;
+        if (typeof reasoningDelta === "string" && reasoningDelta !== "") {
+            // Keep the authoritative copy as well as the display event. Ollama
+            // expects reasoning to accompany an assistant tool call on continuation.
+            reasoning += reasoningDelta;
+            onStream?.({ kind: "thinking", text: reasoningDelta });
         }
         if (typeof delta.content === "string" && delta.content !== "") {
             content += delta.content;
@@ -59,5 +63,5 @@ export async function assembleOllama(events, onStream) {
         // Not every server sends an id, and the loop needs one to pair the result
         // back to its call.
         .map(([index, call]) => (call.id === "" ? { ...call, id: `call_${index}` } : call));
-    return { content, toolCalls, finishReason, usage };
+    return { content, reasoning, toolCalls, finishReason, usage };
 }

package/dist/providers/ollama-wire.js

@@ -40,6 +40,9 @@ export function toWireMessages(system, messages) {
             if (texts.length === 0 && toolCalls.length === 0)
                 continue;
             const turn = { role: "assistant", content: texts.join("\n") };
+            const reasoning = ollamaReasoning(message);
+            if (reasoning !== undefined)
+                turn["reasoning"] = reasoning;
             // An empty tool_calls array is not the same as no tool_calls to every
             // server, so the key is omitted rather than sent empty.
             if (toolCalls.length > 0)
@@ -59,9 +62,22 @@ export function fromWireReply(reply) {
     for (const call of reply.toolCalls) {
         content.push({ kind: "tool_call", id: call.id, name: call.name, input: parseArgs(call.args) });
     }
-    // No `raw`: unlike the other two providers, nothing in this shape has to be
-    // echoed back verbatim, so the normalized blocks are the whole message.
-    return { role: "assistant", content, usage: normalizeUsage(reply) };
+    const raw = reply.reasoning === "" ? undefined : { reasoning: reply.reasoning };
+    return {
+        role: "assistant",
+        content,
+        ...(raw === undefined ? {} : { raw, rawFrom: "ollama" }),
+        usage: normalizeUsage(reply),
+    };
+}
+function ollamaReasoning(message) {
+    if (message.rawFrom !== "ollama" ||
+        typeof message.raw !== "object" ||
+        message.raw === null ||
+        Array.isArray(message.raw))
+        return undefined;
+    const reasoning = message.raw["reasoning"];
+    return typeof reasoning === "string" && reasoning !== "" ? reasoning : undefined;
 }
 function normalizeUsage(reply) {
     if (reply.usage === undefined)

package/dist/tools/fs.js

@@ -1,5 +1,5 @@
 // Filesystem tools: read, list, write, edit.
-import { createReadStream } from "node:fs";
+import { constants } from "node:fs";
 import * as fs from "node:fs/promises";
 import * as path from "node:path";
 import { optionalBool, optionalInt, requireString } from "./args.js";
@@ -9,9 +9,10 @@ import { atomicWrite } from "../atomic.js";
 const MAX_READ_CHARS = 60_000;
 const MAX_LIST_CHARS = 60_000;
 const MAX_LIST_ENTRIES = 2_000;
+const READ_CHUNK_BYTES = 64 * 1024;
 export const readFile = {
     name: "read_file",
-    description: "Read a UTF-8 text file inside the workspace. Optionally start at a line " +
+    description: "Read a regular UTF-8 text file inside the workspace. Optionally start at a line " +
         "(1-based) and cap how many lines come back. Large files are truncated.",
     dangerous: false,
     input: {
@@ -28,7 +29,7 @@ export const readFile = {
         const target = await resolveExistingInRoot(root, requireString(args, "path"));
         const offset = optionalInt(args, "offset");
         const limit = optionalInt(args, "limit");
-        const { text, truncated } = await readRange(target, offset, limit);
+        const { text, truncated } = await readRange(target, offset, limit, ctx.signal);
         if (truncated) {
             return {
                 output: `${text}\n\n[truncated at ${MAX_READ_CHARS} characters — read a narrower range]`,
@@ -169,13 +170,22 @@ export const editFile = {
         };
     },
 };
-async function readRange(target, offset, limit) {
+async function readRange(target, offset, limit, signal) {
+    throwIfAborted(signal);
     const firstLine = Math.max(1, offset ?? 1);
     const lineCount = limit === undefined ? undefined : Math.max(0, limit);
     const endLine = lineCount === undefined ? Number.POSITIVE_INFINITY : firstLine + lineCount;
     if (lineCount === 0)
         return { text: "", truncated: false };
-    const source = createReadStream(target);
+    if (!(await fs.lstat(target)).isFile())
+        throw new Error("path must be a regular file");
+    // O_NONBLOCK prevents a path swapped to a FIFO between lstat and open from
+    // waiting forever for a writer. The handle stat closes that race before any
+    // content is accepted.
+    const flags = process.platform === "win32"
+        ? "r"
+        : constants.O_RDONLY | (constants.O_NONBLOCK ?? 0);
+    const handle = await fs.open(target, flags);
     const decoder = new TextDecoder();
     let text = "";
     let line = 1;
@@ -216,19 +226,32 @@ async function readRange(target, offset, limit) {
         }
     };
     try {
-        for await (const chunk of source) {
-            consume(decoder.decode(chunk, { stream: true }));
-            if (stopped)
+        if (!(await handle.stat()).isFile())
+            throw new Error("path must be a regular file");
+        let position = 0;
+        const buffer = Buffer.allocUnsafe(READ_CHUNK_BYTES);
+        while (!stopped) {
+            throwIfAborted(signal);
+            const { bytesRead } = await handle.read(buffer, 0, buffer.length, position);
+            throwIfAborted(signal);
+            if (bytesRead === 0)
                 break;
+            position += bytesRead;
+            consume(decoder.decode(buffer.subarray(0, bytesRead), { stream: true }));
         }
         if (!stopped)
             consume(decoder.decode());
     }
     finally {
-        source.destroy();
+        await handle.close();
     }
     return { text, truncated };
 }
+function throwIfAborted(signal) {
+    if (signal?.aborted !== true)
+        return;
+    throw signal.reason instanceof Error ? signal.reason : new Error("interrupted");
+}
 /**
  * The edit worked out against a given text — the one place its rules live.
  *

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@giovannijecha/jecode",
-  "version": "0.2.2",
+  "version": "0.2.4",
   "description": "An owned coding agent with zero external runtime dependencies.",
   "license": "MIT",
   "repository": {