@giovannijecha/jecode 0.8.5 → 0.8.6

package/dist/settings.js

@@ -5,7 +5,7 @@ import { assertDirectoryAnchor, captureDirectDirectorySync, preparePrivateDirect
 import { MAX_COMPACTION_PERCENT, MIN_COMPACTION_PERCENT } from "./context/policy.js";
 import { EFFORTS } from "./effort.js";
 import { providerNames } from "./providers/index.js";
-import { parseOllamaEndpoint } from "./providers/ollama-endpoint.js";
+import { isLegacyOllamaCloudHost, OLLAMA_CLOUD_HOST } from "./providers/ollama-endpoint.js";
 import { withStoreLock } from "./store-lock.js";
 import { userDataLabel, userDataPath } from "./user-data.js";
 import { assertStoreText, readBoundedJsonForMutationSync, readBoundedJsonSync, USER_STORE_LIMITS, } from "./user-store.js";
@@ -17,12 +17,14 @@ export function readSettings() {
     return copy(saved);
 }
 export async function updateSettings(patch) {
+    assertRetiredOllamaHost(patch);
     const file = settingsPath();
     const directory = path.dirname(file);
     const anchor = await preparePrivateDirectory(directory, "settings store directory");
     const anchoredFile = path.join(anchor.path, path.basename(file));
     return withStoreLock(anchoredFile, async () => {
         const next = normalize({ ...readStoreForMutation(anchoredFile, anchor), ...patch });
+        delete next.ollamaHost;
         const text = `${JSON.stringify(next, null, 2)}\n`;
         assertStoreText(text, USER_STORE_LIMITS.settingsBytes);
         await atomicWrite(anchoredFile, text, {
@@ -50,8 +52,8 @@ function readStore(file = settingsPath()) {
         return normalize(readBoundedJsonSync(anchoredFile, USER_STORE_LIMITS.settingsBytes, directory));
     }
     catch {
-        // Missing, unreadable, and malformed stores all fall back safely. A bad
-        // preference must never prevent the agent from starting.
+        // Missing, unreadable, and malformed stores fall back safely. Parsed
+        // retired endpoint markers survive normalization for startup validation.
         return {};
     }
 }
@@ -88,9 +90,7 @@ function assertMutableSettings(value) {
             Object.values(models).some((model) => !boundedNonempty(model, USER_STORE_LIMITS.model)))
             throw new Error("settings store has invalid models");
     }
-    if ("ollamaHost" in value && endpoint(value["ollamaHost"]) === undefined) {
-        throw new Error("settings store has an invalid Ollama endpoint");
-    }
+    assertRetiredOllamaHost(value);
     if ("effort" in value && member(value["effort"], EFFORTS) === undefined) {
         throw new Error("settings store has an invalid reasoning effort");
     }
@@ -109,7 +109,7 @@ function normalize(value) {
     const providers = providerNames();
     const provider = member(value["provider"], providers);
     const models = modelsOf(value["models"], providers);
-    const ollamaHost = endpoint(value["ollamaHost"]);
+    const ollamaHost = "ollamaHost" in value ? legacyOllamaHost(value["ollamaHost"]) : undefined;
     const effort = member(value["effort"], EFFORTS);
     const reducedMotion = typeof value["reducedMotion"] === "boolean" ? value["reducedMotion"] : undefined;
     const maxTokens = positiveInteger(value["maxTokens"]);
@@ -133,14 +133,15 @@ function modelsOf(value, providers) {
 function member(value, values) {
     return typeof value === "string" && values.includes(value) ? value : undefined;
 }
-function endpoint(value) {
-    if (!boundedNonempty(value, USER_STORE_LIMITS.endpoint))
-        return undefined;
-    try {
-        return parseOllamaEndpoint(value).baseUrl;
-    }
-    catch {
-        return undefined;
+function legacyOllamaHost(value) {
+    if (isLegacyOllamaCloudHost(value))
+        return OLLAMA_CLOUD_HOST;
+    // Even an invalid retired value must not disappear and enable cloud use.
+    return boundedNonempty(value, USER_STORE_LIMITS.endpoint) ? value : "unsupported legacy Ollama endpoint";
+}
+function assertRetiredOllamaHost(value) {
+    if ("ollamaHost" in value && !isLegacyOllamaCloudHost(value.ollamaHost)) {
+        throw new Error("settings store has a retired Ollama endpoint; remove ollamaHost from settings.json to use Ollama API");
     }
 }
 function boundedNonempty(value, max) {

package/dist/start.js

@@ -6,7 +6,7 @@ import { loadConfig } from "./config.js";
 import { ConversationTree } from "./conversation.js";
 import { parseLaunch } from "./launch.js";
 import { systemPrompt } from "./prompt.js";
-import { configureProviders, selectProvider } from "./providers/index.js";
+import { selectProvider } from "./providers/index.js";
 import { SessionPersistence } from "./sessions/runtime.js";
 import { DurableSessionStore } from "./sessions/store.js";
 import { builtinTools } from "./tools/index.js";
@@ -23,7 +23,6 @@ export async function start(args = process.argv.slice(2), environment = {}) {
         return;
     const launch = parseLaunch(args);
     const config = loadConfig(launch.configArgs);
-    configureProviders(config);
     const provider = selectProvider(config.providerId);
     const hasScreen = environment.interactive?.() ?? interactive();
     if (launch.kind === "resume" && !hasScreen) {

package/dist/tools/file-read.js

@@ -0,0 +1,192 @@
+// Bounded workspace file reads and stable directory listings.
+import * as path from "node:path";
+import { withStableFile } from "../bounded-file.js";
+import { readStableDirectory } from "../stable-directory.js";
+import { optionalInt, optionalString, requireString } from "./args.js";
+import { resolveExistingInRoot } from "./paths.js";
+import { leadingText } from "./text-boundary.js";
+import { count, plural } from "./file-summary.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;
+const MAX_READ_SCAN_BYTES = 16 * 1024 * 1024;
+export const readFile = {
+    name: "read_file",
+    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,
+    concurrency: "shared",
+    input: {
+        type: "object",
+        properties: {
+            path: { type: "string", description: "Path relative to the workspace root." },
+            offset: { type: "integer", description: "First line to return, 1-based." },
+            limit: { type: "integer", description: "How many lines to return." },
+        },
+        required: ["path"],
+    },
+    async run(args, ctx) {
+        return runReadFile(args, ctx);
+    },
+};
+export async function runReadFile(args, ctx, dependencies = {}) {
+    const root = await resolveExistingInRoot(ctx.root, ".");
+    const target = await resolveExistingInRoot(root, requireString(args, "path"));
+    const offset = optionalInt(args, "offset");
+    const limit = optionalInt(args, "limit");
+    const { text, truncated, scanCapped } = await readRange(root, target, offset, limit, ctx.signal, dependencies);
+    if (truncated) {
+        return {
+            output: `${text}\n\n[truncated at ${MAX_READ_CHARS} characters — read a narrower range]`,
+            summary: `truncated at ${MAX_READ_CHARS} characters`,
+        };
+    }
+    if (scanCapped) {
+        const notice = `[read stopped after scanning ${MAX_READ_SCAN_BYTES} bytes — use a smaller offset or search_text]`;
+        return {
+            output: text === "" ? notice : `${text}\n\n${notice}`,
+            summary: `scan capped at ${MAX_READ_SCAN_BYTES} bytes`,
+        };
+    }
+    if (text === "")
+        return { output: "[file is empty]", summary: "empty" };
+    return { output: text, summary: `${count(text, "line")}` };
+}
+export const listDir = {
+    name: "list_dir",
+    description: "List the entries of a directory inside the workspace. Directories end with a slash.",
+    dangerous: false,
+    concurrency: "shared",
+    input: {
+        type: "object",
+        properties: {
+            path: { type: "string", description: "Directory relative to the workspace root. Defaults to the root." },
+        },
+        required: [],
+    },
+    async run(args, ctx) {
+        return runListDir(args, ctx);
+    },
+};
+export async function runListDir(args, ctx, dependencies = {}) {
+    const root = await resolveExistingInRoot(ctx.root, ".");
+    const requested = optionalString(args, "path");
+    const relative = requested === undefined || requested.trim() === "" ? "." : requested;
+    const target = await resolveExistingInRoot(root, relative);
+    const inspected = await readStableDirectory(root, target, {
+        maxEntries: MAX_LIST_ENTRIES + 1,
+        signal: ctx.signal,
+        beforeOpen: dependencies.beforeOpen,
+    });
+    const entries = [];
+    let chars = 0;
+    let truncated = inspected.capped;
+    for (const entry of inspected.entries) {
+        const label = entry.kind === "directory" ? `${entry.name}/` : entry.name;
+        const separator = entries.length === 0 ? 0 : 1;
+        if (entries.length >= MAX_LIST_ENTRIES ||
+            chars + separator + label.length > MAX_LIST_CHARS) {
+            truncated = true;
+            break;
+        }
+        entries.push(label);
+        chars += separator + label.length;
+    }
+    if (entries.length === 0)
+        return { output: "[empty directory]", summary: "empty" };
+    const listing = entries.join("\n");
+    if (truncated) {
+        return {
+            output: `${listing}\n\n[truncated after ${entries.length} entries]`,
+            summary: `${entries.length}+ entries`,
+        };
+    }
+    return { output: listing, summary: plural(entries.length, "entry", "entries") };
+}
+async function readRange(root, target, offset, limit, signal, dependencies) {
+    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, scanCapped: false };
+    const result = await withStableFile(target, {
+        label: "read file",
+        signal,
+        beforeOpen: dependencies.beforeOpen,
+    }, async (handle, opened) => {
+        const decoder = new TextDecoder();
+        let text = "";
+        let line = 1;
+        let stopped = false;
+        let truncated = false;
+        let reachedEnd = false;
+        const selected = (at) => at >= firstLine && at < endLine;
+        const append = (fragment) => {
+            if (fragment === "")
+                return;
+            const room = MAX_READ_CHARS - text.length;
+            if (fragment.length > room) {
+                text += leadingText(fragment, room);
+                truncated = true;
+                stopped = true;
+                return;
+            }
+            text += fragment;
+        };
+        const consume = (chunk) => {
+            let start = 0;
+            while (!stopped && start < chunk.length) {
+                const newline = chunk.indexOf("\n", start);
+                const end = newline === -1 ? chunk.length : newline;
+                if (selected(line))
+                    append(chunk.slice(start, end));
+                if (stopped || newline === -1)
+                    return;
+                const nextLine = line + 1;
+                if (selected(line) && selected(nextLine))
+                    append("\n");
+                line = nextLine;
+                if (line >= endLine) {
+                    stopped = true;
+                    return;
+                }
+                start = newline + 1;
+            }
+        };
+        let position = 0;
+        const buffer = Buffer.allocUnsafe(READ_CHUNK_BYTES);
+        while (!stopped && position < MAX_READ_SCAN_BYTES) {
+            throwIfAborted(signal);
+            const length = Math.min(buffer.length, MAX_READ_SCAN_BYTES - position);
+            const { bytesRead } = await handle.read(buffer, 0, length, position);
+            throwIfAborted(signal);
+            if (bytesRead === 0) {
+                reachedEnd = true;
+                break;
+            }
+            position += bytesRead;
+            consume(decoder.decode(buffer.subarray(0, bytesRead), { stream: true }));
+        }
+        if (!stopped && BigInt(position) >= opened.size)
+            reachedEnd = true;
+        if (!stopped && reachedEnd)
+            consume(decoder.decode());
+        return {
+            text,
+            truncated,
+            scanCapped: !stopped && !reachedEnd && position >= MAX_READ_SCAN_BYTES,
+        };
+    });
+    const confirmed = await resolveExistingInRoot(root, target);
+    if (path.relative(target, confirmed) !== "") {
+        throw new Error("read file changed while it was being read");
+    }
+    return result;
+}
+function throwIfAborted(signal) {
+    if (signal?.aborted !== true)
+        return;
+    throw signal.reason instanceof Error ? signal.reason : new Error("interrupted");
+}

package/dist/tools/file-summary.js

@@ -0,0 +1,9 @@
+// Shared line and entry counts in filesystem tool summaries.
+export function count(text, noun) {
+    if (text === "")
+        return "empty";
+    return plural(text.split("\n").length, noun, `${noun}s`);
+}
+export function plural(n, one, many) {
+    return `${n} ${n === 1 ? one : many}`;
+}

package/dist/tools/{fs.js → file-write.js}

@@ -1,111 +1,12 @@
-// Filesystem tools: read, list, write, edit.
+// Atomic file mutations share preview validation and exact replacement rules.
 import * as fs from "node:fs/promises";
 import * as path from "node:path";
-import { withStableFile } from "../bounded-file.js";
-import { readStableDirectory } from "../stable-directory.js";
-import { optionalBool, optionalInt, optionalString, requireString } from "./args.js";
-import { assertDirectWritableInRoot, displayPath, resolveDirectWritableInRoot, resolveExistingInRoot, } from "./paths.js";
-import { assertEditableText, assertReplacementFits, leadingText, MAX_EDITABLE_CHARS, MAX_EDITABLE_LINES, readEditableText, } from "./text-boundary.js";
 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;
-const MAX_READ_SCAN_BYTES = 16 * 1024 * 1024;
+import { optionalBool, requireString } from "./args.js";
+import { assertDirectWritableInRoot, displayPath, resolveDirectWritableInRoot, resolveExistingInRoot, } from "./paths.js";
+import { assertEditableText, assertReplacementFits, MAX_EDITABLE_CHARS, MAX_EDITABLE_LINES, readEditableText, } from "./text-boundary.js";
+import { count, plural } from "./file-summary.js";
 const DEFAULT_MUTATION_DEPENDENCIES = { atomicWrite };
-export const readFile = {
-    name: "read_file",
-    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,
-    concurrency: "shared",
-    input: {
-        type: "object",
-        properties: {
-            path: { type: "string", description: "Path relative to the workspace root." },
-            offset: { type: "integer", description: "First line to return, 1-based." },
-            limit: { type: "integer", description: "How many lines to return." },
-        },
-        required: ["path"],
-    },
-    async run(args, ctx) {
-        return runReadFile(args, ctx);
-    },
-};
-export async function runReadFile(args, ctx, dependencies = {}) {
-    const root = await resolveExistingInRoot(ctx.root, ".");
-    const target = await resolveExistingInRoot(root, requireString(args, "path"));
-    const offset = optionalInt(args, "offset");
-    const limit = optionalInt(args, "limit");
-    const { text, truncated, scanCapped } = await readRange(root, target, offset, limit, ctx.signal, dependencies);
-    if (truncated) {
-        return {
-            output: `${text}\n\n[truncated at ${MAX_READ_CHARS} characters — read a narrower range]`,
-            summary: `truncated at ${MAX_READ_CHARS} characters`,
-        };
-    }
-    if (scanCapped) {
-        const notice = `[read stopped after scanning ${MAX_READ_SCAN_BYTES} bytes — use a smaller offset or search_text]`;
-        return {
-            output: text === "" ? notice : `${text}\n\n${notice}`,
-            summary: `scan capped at ${MAX_READ_SCAN_BYTES} bytes`,
-        };
-    }
-    if (text === "")
-        return { output: "[file is empty]", summary: "empty" };
-    return { output: text, summary: `${count(text, "line")}` };
-}
-export const listDir = {
-    name: "list_dir",
-    description: "List the entries of a directory inside the workspace. Directories end with a slash.",
-    dangerous: false,
-    concurrency: "shared",
-    input: {
-        type: "object",
-        properties: {
-            path: { type: "string", description: "Directory relative to the workspace root. Defaults to the root." },
-        },
-        required: [],
-    },
-    async run(args, ctx) {
-        return runListDir(args, ctx);
-    },
-};
-export async function runListDir(args, ctx, dependencies = {}) {
-    const root = await resolveExistingInRoot(ctx.root, ".");
-    const requested = optionalString(args, "path");
-    const relative = requested === undefined || requested.trim() === "" ? "." : requested;
-    const target = await resolveExistingInRoot(root, relative);
-    const inspected = await readStableDirectory(root, target, {
-        maxEntries: MAX_LIST_ENTRIES + 1,
-        signal: ctx.signal,
-        beforeOpen: dependencies.beforeOpen,
-    });
-    const entries = [];
-    let chars = 0;
-    let truncated = inspected.capped;
-    for (const entry of inspected.entries) {
-        const label = entry.kind === "directory" ? `${entry.name}/` : entry.name;
-        const separator = entries.length === 0 ? 0 : 1;
-        if (entries.length >= MAX_LIST_ENTRIES ||
-            chars + separator + label.length > MAX_LIST_CHARS) {
-            truncated = true;
-            break;
-        }
-        entries.push(label);
-        chars += separator + label.length;
-    }
-    if (entries.length === 0)
-        return { output: "[empty directory]", summary: "empty" };
-    const listing = entries.join("\n");
-    if (truncated) {
-        return {
-            output: `${listing}\n\n[truncated after ${entries.length} entries]`,
-            summary: `${entries.length}+ entries`,
-        };
-    }
-    return { output: listing, summary: plural(entries.length, "entry", "entries") };
-}
 export const writeFile = {
     name: "write_file",
     description: "Create a file, or replace its entire contents. Parent directories are " +
@@ -221,87 +122,6 @@ export async function runEditFile(args, ctx, dependencies = DEFAULT_MUTATION_DEP
         summary: plural(made, "replacement", "replacements"),
     };
 }
-async function readRange(root, target, offset, limit, signal, dependencies) {
-    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, scanCapped: false };
-    const result = await withStableFile(target, {
-        label: "read file",
-        signal,
-        beforeOpen: dependencies.beforeOpen,
-    }, async (handle, opened) => {
-        const decoder = new TextDecoder();
-        let text = "";
-        let line = 1;
-        let stopped = false;
-        let truncated = false;
-        let reachedEnd = false;
-        const selected = (at) => at >= firstLine && at < endLine;
-        const append = (fragment) => {
-            if (fragment === "")
-                return;
-            const room = MAX_READ_CHARS - text.length;
-            if (fragment.length > room) {
-                text += leadingText(fragment, room);
-                truncated = true;
-                stopped = true;
-                return;
-            }
-            text += fragment;
-        };
-        const consume = (chunk) => {
-            let start = 0;
-            while (!stopped && start < chunk.length) {
-                const newline = chunk.indexOf("\n", start);
-                const end = newline === -1 ? chunk.length : newline;
-                if (selected(line))
-                    append(chunk.slice(start, end));
-                if (stopped || newline === -1)
-                    return;
-                const nextLine = line + 1;
-                if (selected(line) && selected(nextLine))
-                    append("\n");
-                line = nextLine;
-                if (line >= endLine) {
-                    stopped = true;
-                    return;
-                }
-                start = newline + 1;
-            }
-        };
-        let position = 0;
-        const buffer = Buffer.allocUnsafe(READ_CHUNK_BYTES);
-        while (!stopped && position < MAX_READ_SCAN_BYTES) {
-            throwIfAborted(signal);
-            const length = Math.min(buffer.length, MAX_READ_SCAN_BYTES - position);
-            const { bytesRead } = await handle.read(buffer, 0, length, position);
-            throwIfAborted(signal);
-            if (bytesRead === 0) {
-                reachedEnd = true;
-                break;
-            }
-            position += bytesRead;
-            consume(decoder.decode(buffer.subarray(0, bytesRead), { stream: true }));
-        }
-        if (!stopped && BigInt(position) >= opened.size)
-            reachedEnd = true;
-        if (!stopped && reachedEnd)
-            consume(decoder.decode());
-        return {
-            text,
-            truncated,
-            scanCapped: !stopped && !reachedEnd && position >= MAX_READ_SCAN_BYTES,
-        };
-    });
-    const confirmed = await resolveExistingInRoot(root, target);
-    if (path.relative(target, confirmed) !== "") {
-        throw new Error("read file changed while it was being read");
-    }
-    return result;
-}
 function throwIfAborted(signal) {
     if (signal?.aborted !== true)
         return;
@@ -370,11 +190,3 @@ function changedFile(operation, previewed) {
     const when = previewed ? "after the preview" : "while preparing the change";
     return new Error(`file changed ${when} — inspect it and retry the ${operation}`);
 }
-function count(text, noun) {
-    if (text === "")
-        return "empty";
-    return plural(text.split("\n").length, noun, `${noun}s`);
-}
-function plural(n, one, many) {
-    return `${n} ${n === 1 ? one : many}`;
-}

package/dist/tools/glob.js

@@ -0,0 +1,107 @@
+// Bounded workspace glob matching without regular-expression backtracking.
+import * as path from "node:path";
+const MAX_GLOB_CHARS = 512;
+export function glob(pattern) {
+    const normalized = pattern.replace(/\\/g, "/");
+    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 {
+                tokens.push({ kind: "star" });
+                index = end;
+            }
+            continue;
+        }
+        tokens.push(char === "?" ? { kind: "one" } : { kind: "literal", value: char });
+        index++;
+    }
+    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;
+}

package/dist/tools/index.js

@@ -1,5 +1,6 @@
 // The tool registry, and the one place a tool actually gets run.
-import { editFile, listDir, readFile, writeFile } from "./fs.js";
+import { listDir, readFile } from "./file-read.js";
+import { editFile, writeFile } from "./file-write.js";
 import { runCommand } from "./shell.js";
 import { findFiles, searchText } from "./search.js";
 export function builtinTools() {