@giovannijecha/jecode 0.8.4 → 0.8.6

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,94 +1,12 @@
-// Filesystem tools: read, list, write, edit.
-import { constants } from "node:fs";
+// Atomic file mutations share preview validation and exact replacement rules.
 import * as fs from "node:fs/promises";
 import * as path from "node:path";
-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;
+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) {
-        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 } = await readRange(target, offset, limit, ctx.signal);
-        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 (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) {
-        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 entries = [];
-        let chars = 0;
-        let truncated = false;
-        const directory = await fs.opendir(target);
-        for await (const entry of directory) {
-            const label = entry.isDirectory() ? `${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
-            .sort((a, b) => a.localeCompare(b))
-            .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 " +
@@ -204,82 +122,6 @@ export async function runEditFile(args, ctx, dependencies = DEFAULT_MUTATION_DEP
         summary: plural(made, "replacement", "replacements"),
     };
 }
-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 };
-    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;
-    let stopped = false;
-    let truncated = 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;
-        }
-    };
-    try {
-        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 {
-        await handle.close();
-    }
-    return { text, truncated };
-}
 function throwIfAborted(signal) {
     if (signal?.aborted !== true)
         return;
@@ -348,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() {