@giovannijecha/jecode 0.1.5-rc.2

package/dist/tools/args.js

@@ -0,0 +1,38 @@
+// Hand-written argument checks. A schema validator would be a dependency; a
+// tool takes three arguments and this is the whole job.
+//
+// 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) {
+    const value = args[name];
+    if (typeof value !== "string" || value === "") {
+        throw new Error(`"${name}" is required and must be a non-empty string`);
+    }
+    return value;
+}
+export function optionalString(args, name) {
+    const value = args[name];
+    if (value === undefined || value === null)
+        return undefined;
+    if (typeof value !== "string")
+        throw new Error(`"${name}" must be a string`);
+    return value;
+}
+export function optionalInt(args, name) {
+    const value = args[name];
+    if (value === undefined || value === null)
+        return undefined;
+    const n = typeof value === "string" ? Number(value) : value;
+    if (typeof n !== "number" || !Number.isInteger(n)) {
+        throw new Error(`"${name}" must be an integer`);
+    }
+    return n;
+}
+export function optionalBool(args, name) {
+    const value = args[name];
+    if (value === undefined || value === null)
+        return undefined;
+    if (typeof value !== "boolean")
+        throw new Error(`"${name}" must be a boolean`);
+    return value;
+}

package/dist/tools/fs.js

@@ -0,0 +1,277 @@
+// Filesystem tools: read, list, write, edit.
+import { createReadStream } from "node:fs";
+import * as fs from "node:fs/promises";
+import * as path from "node:path";
+import { optionalBool, optionalInt, 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 { atomicWrite } from "../atomic.js";
+const MAX_READ_CHARS = 60_000;
+const MAX_LIST_CHARS = 60_000;
+const MAX_LIST_ENTRIES = 2_000;
+export const readFile = {
+    name: "read_file",
+    description: "Read a 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: {
+        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);
+        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,
+    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 target = await resolveExistingInRoot(root, args.path === undefined ? "." : requireString(args, "path"));
+        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 " +
+        "created as needed. Whole-file changes are limited to " +
+        `${MAX_EDITABLE_CHARS} characters and ${MAX_EDITABLE_LINES} lines. ` +
+        "To change part of an existing file, prefer edit_file.",
+    dangerous: true,
+    input: {
+        type: "object",
+        properties: {
+            path: { type: "string", description: "Path relative to the workspace root." },
+            content: { type: "string", description: "The full new contents of the file." },
+        },
+        required: ["path", "content"],
+    },
+    async preview(args, ctx) {
+        const root = await resolveExistingInRoot(ctx.root, ".");
+        const target = await resolveDirectWritableInRoot(root, requireString(args, "path"));
+        const content = requireString(args, "content");
+        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.
+        return { before: await current(target), after: content };
+    },
+    async run(args, ctx) {
+        const root = await resolveExistingInRoot(ctx.root, ".");
+        const target = await resolveDirectWritableInRoot(root, requireString(args, "path"));
+        const content = requireString(args, "content");
+        assertEditableText(content);
+        await fs.mkdir(path.dirname(target), { recursive: true });
+        const validate = () => assertDirectWritableInRoot(root, target);
+        await validate();
+        await unchangedSinceApproval(target, ctx.preview?.before);
+        await atomicWrite(target, content, { validate });
+        return {
+            output: `wrote ${displayPath(root, target)} (${content.length} characters)`,
+            summary: count(content, "line"),
+        };
+    },
+};
+export const editFile = {
+    name: "edit_file",
+    description: "Replace an exact string in a file. The old text must appear exactly once " +
+        "unless replace_all is true — include enough surrounding context to make it unique. " +
+        `Whole-file changes are limited to ${MAX_EDITABLE_CHARS} characters and ` +
+        `${MAX_EDITABLE_LINES} lines.`,
+    dangerous: true,
+    input: {
+        type: "object",
+        properties: {
+            path: { type: "string", description: "Path relative to the workspace root." },
+            old_text: { type: "string", description: "Exact text to replace, including indentation." },
+            new_text: { type: "string", description: "Text to put in its place." },
+            replace_all: { type: "boolean", description: "Replace every occurrence instead of requiring one." },
+        },
+        required: ["path", "old_text", "new_text"],
+    },
+    async preview(args, ctx) {
+        const root = await resolveExistingInRoot(ctx.root, ".");
+        const target = await resolveDirectWritableInRoot(root, requireString(args, "path"), true);
+        const before = await current(target);
+        // An edit that will not apply gets no preview: the run is about to say so
+        // properly, and a diff of a match that does not exist would be a lie.
+        try {
+            return { before, after: applied(before, args).after };
+        }
+        catch {
+            return undefined;
+        }
+    },
+    async run(args, ctx) {
+        const root = await resolveExistingInRoot(ctx.root, ".");
+        const target = await resolveDirectWritableInRoot(root, requireString(args, "path"), true);
+        const before = await readEditableText(target);
+        if (ctx.preview !== undefined && before !== ctx.preview.before) {
+            throw new Error("file changed after the preview — inspect it and retry the edit");
+        }
+        const { after, made } = applied(before, args);
+        const validate = () => assertDirectWritableInRoot(root, target, true);
+        await atomicWrite(target, after, { validate });
+        return {
+            output: `edited ${displayPath(root, target)} (${made} replacement${made === 1 ? "" : "s"})`,
+            summary: plural(made, "replacement", "replacements"),
+        };
+    },
+};
+async function readRange(target, offset, limit) {
+    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);
+    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) {
+            if (room > 0)
+                text += fragment.slice(0, 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 {
+        for await (const chunk of source) {
+            consume(decoder.decode(chunk, { stream: true }));
+            if (stopped)
+                break;
+        }
+        if (!stopped)
+            consume(decoder.decode());
+    }
+    finally {
+        source.destroy();
+    }
+    return { text, truncated };
+}
+/**
+ * The edit worked out against a given text — the one place its rules live.
+ *
+ * Shared by `run` and `preview` on purpose: a preview computed by a second
+ * implementation of the same rules is a preview that can disagree with what
+ * the call then does, which is worse than showing nothing at all.
+ */
+function applied(before, args) {
+    const oldText = requireString(args, "old_text");
+    const newText = args.new_text === "" ? "" : requireString(args, "new_text");
+    const replaceAll = optionalBool(args, "replace_all") ?? false;
+    const occurrences = countOccurrences(before, oldText);
+    if (occurrences === 0)
+        throw new Error("old_text was not found in the file");
+    if (occurrences > 1 && !replaceAll) {
+        throw new Error(`old_text appears ${occurrences} times — add surrounding context, or pass replace_all`);
+    }
+    const made = replaceAll ? occurrences : 1;
+    assertReplacementFits(before, oldText, newText, made);
+    const after = replaceAll ? before.replaceAll(oldText, newText) : before.replace(oldText, newText);
+    assertEditableText(after, "edited content");
+    return { after, made };
+}
+/** What is on disk now, or nothing at all — a file that is not there yet. */
+async function current(target) {
+    return readEditableText(target, { missingAsEmpty: true });
+}
+function countOccurrences(haystack, needle) {
+    let occurrences = 0;
+    for (let index = haystack.indexOf(needle); index !== -1; index = haystack.indexOf(needle, index + needle.length)) {
+        occurrences += 1;
+    }
+    return occurrences;
+}
+async function unchangedSinceApproval(target, approved) {
+    const onDisk = await current(target);
+    if (approved !== undefined && onDisk !== approved) {
+        throw new Error("file changed after the preview — inspect it and retry the write");
+    }
+}
+function count(text, noun) {
+    return plural(text.split("\n").length, noun, `${noun}s`);
+}
+function plural(n, one, many) {
+    return `${n} ${n === 1 ? one : many}`;
+}

package/dist/tools/index.js

@@ -0,0 +1,39 @@
+// The tool registry, and the one place a tool actually gets run.
+import { editFile, listDir, readFile, writeFile } from "./fs.js";
+import { runCommand } from "./shell.js";
+import { findFiles, searchText } from "./search.js";
+export function builtinTools() {
+    return [readFile, listDir, findFiles, searchText, editFile, writeFile, runCommand];
+}
+export function findTool(tools, name) {
+    return tools.find((tool) => tool.name === name);
+}
+/** Strip the executable half — providers only ever see the declaration. */
+export function toolSpecs(tools) {
+    return tools.map((tool) => ({
+        name: tool.name,
+        description: tool.description,
+        input: tool.input,
+    }));
+}
+// A tool failure is a result, not an exception: the model reads the message
+// 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 };
+    }
+    catch (error) {
+        if (ctx.signal?.aborted === true)
+            throw error;
+        return {
+            result: {
+                kind: "tool_result",
+                id: call.id,
+                output: `${tool.name} failed: ${error.message}`,
+                isError: true,
+            },
+            summary: "failed",
+        };
+    }
+}

package/dist/tools/paths.js

@@ -0,0 +1,122 @@
+import * as path from "node:path";
+import { lstat, realpath } from "node:fs/promises";
+// Every filesystem tool resolves through here. The agent works inside one
+// root and cannot be talked into reaching outside it — including via "..",
+// an absolute path, or (on Windows) a different drive letter.
+export function resolveInRoot(root, candidate) {
+    const absoluteRoot = path.resolve(root);
+    const absolute = path.resolve(absoluteRoot, candidate);
+    if (!inside(absoluteRoot, absolute)) {
+        throw new Error(`path escapes the workspace root: ${candidate}`);
+    }
+    return absolute;
+}
+/** Resolve an existing path after following symlinks and Windows junctions. */
+export async function resolveExistingInRoot(root, candidate) {
+    const lexical = resolveInRoot(root, candidate);
+    const canonicalRoot = await realpath(root);
+    const canonical = await realpath(lexical);
+    if (!inside(canonicalRoot, canonical))
+        throw new Error(`path escapes the workspace root: ${candidate}`);
+    return canonical;
+}
+/** Resolve a path that may not exist, canonicalizing its nearest existing parent. */
+export async function resolveWritableInRoot(root, candidate) {
+    const lexical = resolveInRoot(root, candidate);
+    const canonicalRoot = await realpath(root);
+    try {
+        const canonical = await realpath(lexical);
+        if (!inside(canonicalRoot, canonical))
+            throw new Error(`path escapes the workspace root: ${candidate}`);
+        return canonical;
+    }
+    catch (error) {
+        if (!missing(error))
+            throw error;
+    }
+    const rest = [path.basename(lexical)];
+    let parent = path.dirname(lexical);
+    while (true) {
+        try {
+            const canonicalParent = await realpath(parent);
+            const target = path.join(canonicalParent, ...rest);
+            if (!inside(canonicalRoot, target))
+                throw new Error(`path escapes the workspace root: ${candidate}`);
+            return target;
+        }
+        catch (error) {
+            if (!missing(error))
+                throw error;
+            const next = path.dirname(parent);
+            if (next === parent)
+                throw error;
+            rest.unshift(path.basename(parent));
+            parent = next;
+        }
+    }
+}
+/**
+ * Resolve a write target without permitting a symlink or junction component.
+ *
+ * Reads may follow an in-workspace alias. Writes stay on the direct path so a
+ * later boundary check can detect a component replaced during the operation.
+ */
+export async function resolveDirectWritableInRoot(root, candidate, mustExist = false) {
+    const { canonicalRoot, target } = await directPath(root, candidate);
+    await assertDirectWritableInRoot(canonicalRoot, target, mustExist);
+    return target;
+}
+/** Revalidate a previously resolved direct write target. */
+export async function assertDirectWritableInRoot(root, target, mustExist = false) {
+    const { canonicalRoot, target: direct } = await directPath(root, target);
+    const relative = path.relative(canonicalRoot, direct);
+    let current = canonicalRoot;
+    for (const part of relative.split(path.sep).filter((value) => value !== "")) {
+        current = path.join(current, part);
+        try {
+            const details = await lstat(current);
+            if (details.isSymbolicLink())
+                throw writeLinkError();
+        }
+        catch (error) {
+            if (!missing(error))
+                throw error;
+            if (mustExist)
+                throw error;
+            break;
+        }
+    }
+    const resolved = mustExist
+        ? await realpath(direct)
+        : await resolveWritableInRoot(canonicalRoot, direct);
+    if (!samePath(direct, resolved))
+        throw writeLinkError();
+}
+async function directPath(root, candidate) {
+    const lexicalRoot = path.resolve(root);
+    const lexicalTarget = resolveInRoot(lexicalRoot, candidate);
+    const relative = path.relative(lexicalRoot, lexicalTarget);
+    const canonicalRoot = await realpath(lexicalRoot);
+    const target = path.resolve(canonicalRoot, relative);
+    if (!inside(canonicalRoot, target)) {
+        throw new Error(`path escapes the workspace root: ${candidate}`);
+    }
+    return { canonicalRoot, target };
+}
+export function displayPath(root, absolute) {
+    const relative = path.relative(root, absolute);
+    return relative === "" ? "." : relative.split(path.sep).join("/");
+}
+function inside(root, target) {
+    const relative = path.relative(root, target);
+    return relative === "" || (!path.isAbsolute(relative) && relative !== ".." && !relative.startsWith(`..${path.sep}`));
+}
+function samePath(left, right) {
+    return path.relative(left, right) === "";
+}
+function writeLinkError() {
+    return new Error("write path contains a symbolic link or junction — use a direct workspace path");
+}
+function missing(error) {
+    return error.code === "ENOENT";
+}

package/dist/tools/search.js

@@ -0,0 +1,213 @@
+// Bounded, read-only workspace discovery without borrowing a shell.
+import * as fs from "node:fs/promises";
+import * as path from "node:path";
+import { optionalBool, optionalInt, optionalString, requireString } from "./args.js";
+import { displayPath, resolveExistingInRoot } from "./paths.js";
+const DEFAULT_RESULTS = 100;
+const MAX_RESULTS = 500;
+const MAX_VISITED = 20_000;
+const MAX_FILE_BYTES = 1_000_000;
+const MAX_MATCH_LINE = 500;
+const SKIP = new Set([".git", ".hg", ".svn", "node_modules"]);
+export const findFiles = {
+    name: "find_files",
+    description: "Find files inside the workspace by glob (for example **/*.ts). Skips dependency and VCS " +
+        "directories, never follows symlinks, and returns a bounded list.",
+    dangerous: false,
+    input: {
+        type: "object",
+        properties: {
+            pattern: { type: "string", description: "Glob matched against workspace-relative paths." },
+            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." },
+        },
+        required: ["pattern"],
+    },
+    async run(args, ctx) {
+        const scoped = await canonicalContext(ctx);
+        const start = await startAt(args, scoped);
+        const match = glob(requireString(args, "pattern"));
+        const limit = resultLimit(args);
+        const found = [];
+        const walked = await walk(start, scoped, async (file) => {
+            const relative = displayPath(scoped.root, file);
+            if (match(relative))
+                found.push(relative);
+            return found.length >= limit;
+        });
+        found.sort((a, b) => a.localeCompare(b));
+        return {
+            output: found.length === 0 ? "[no matching files]" : found.join("\n"),
+            summary: summary(found.length, limit, walked.capped, "file", "files"),
+        };
+    },
+};
+export const searchText = {
+    name: "search_text",
+    description: "Search UTF-8 text files inside the workspace for a literal string. Skips dependencies, VCS " +
+        "directories, symlinks, binary files, and files over 1 MB; results are bounded.",
+    dangerous: false,
+    input: {
+        type: "object",
+        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." },
+            case_sensitive: { type: "boolean", description: "Defaults to false." },
+            max_results: { type: "integer", description: "Maximum matching lines. Defaults to 100, caps at 500." },
+        },
+        required: ["query"],
+    },
+    async run(args, ctx) {
+        const scoped = await canonicalContext(ctx);
+        const start = await startAt(args, scoped);
+        const query = requireString(args, "query");
+        const sensitive = optionalBool(args, "case_sensitive") ?? false;
+        const needle = sensitive ? query : query.toLocaleLowerCase();
+        const pattern = optionalString(args, "pattern");
+        const match = pattern === undefined || pattern === "" ? () => true : glob(pattern);
+        const limit = resultLimit(args);
+        const found = [];
+        let skipped = 0;
+        const walked = await walk(start, scoped, async (lexical) => {
+            const relative = displayPath(scoped.root, lexical);
+            if (!match(relative))
+                return false;
+            const file = await resolveExistingInRoot(scoped.root, lexical);
+            const info = await fs.stat(file);
+            if (info.size > MAX_FILE_BYTES) {
+                skipped++;
+                return false;
+            }
+            let text;
+            try {
+                const data = await fs.readFile(file);
+                if (data.includes(0)) {
+                    skipped++;
+                    return false;
+                }
+                text = data.toString("utf8");
+            }
+            catch (error) {
+                if (skippable(error)) {
+                    skipped++;
+                    return false;
+                }
+                throw error;
+            }
+            for (const [index, line] of text.replace(/\r\n?/g, "\n").split("\n").entries()) {
+                checkAbort(ctx.signal);
+                const haystack = sensitive ? line : line.toLocaleLowerCase();
+                if (!haystack.includes(needle))
+                    continue;
+                found.push(`${relative}:${index + 1}:${clip(line)}`);
+                if (found.length >= limit)
+                    return true;
+            }
+            return false;
+        });
+        const extra = skipped === 0 ? "" : ` · skipped ${skipped} binary/large/unreadable`;
+        return {
+            output: found.length === 0 ? "[no matches]" : found.join("\n"),
+            summary: `${summary(found.length, limit, walked.capped, "match", "matches")}${extra}`,
+        };
+    },
+};
+async function walk(start, ctx, visit) {
+    const pending = [start];
+    let seen = 0;
+    while (pending.length > 0) {
+        checkAbort(ctx.signal);
+        const lexical = pending.pop();
+        const directory = await resolveExistingInRoot(ctx.root, lexical);
+        let entries;
+        try {
+            entries = await fs.readdir(directory, { withFileTypes: true, encoding: "utf8" });
+        }
+        catch (error) {
+            if (skippable(error))
+                continue;
+            throw error;
+        }
+        entries.sort((a, b) => a.name.localeCompare(b.name));
+        for (const entry of entries) {
+            checkAbort(ctx.signal);
+            if (++seen > MAX_VISITED)
+                return { capped: true };
+            if (entry.isSymbolicLink())
+                continue;
+            const target = path.join(directory, entry.name);
+            if (entry.isDirectory()) {
+                if (!SKIP.has(entry.name))
+                    pending.push(target);
+            }
+            else if (entry.isFile() && (await visit(target))) {
+                return { capped: false };
+            }
+        }
+    }
+    return { capped: false };
+}
+async function startAt(args, ctx) {
+    const candidate = optionalString(args, "path") ?? ".";
+    const target = await resolveExistingInRoot(ctx.root, candidate);
+    if (!(await fs.stat(target)).isDirectory())
+        throw new Error(`"path" is not a directory: ${candidate}`);
+    return target;
+}
+async function canonicalContext(ctx) {
+    return { ...ctx, root: await resolveExistingInRoot(ctx.root, ".") };
+}
+function resultLimit(args) {
+    const requested = optionalInt(args, "max_results") ?? DEFAULT_RESULTS;
+    if (requested <= 0)
+        throw new Error('"max_results" must be a positive integer');
+    return Math.min(requested, MAX_RESULTS);
+}
+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;
+            }
+            else {
+                source += ".*";
+                index++;
+            }
+        }
+        else if (char === "*")
+            source += "[^/]*";
+        else if (char === "?")
+            source += "[^/]";
+        else
+            source += char.replace(/[|\\{}()[\]^$+?.]/g, "\\$&");
+    }
+    const expression = new RegExp(`^${source}$`, "i");
+    const basenameOnly = !normalized.includes("/");
+    return (relative) => expression.test(basenameOnly ? path.posix.basename(relative) : relative);
+}
+function summary(count, limit, capped, one, many) {
+    const noun = count === 1 ? one : many;
+    if (count >= limit)
+        return `${count} ${noun} · result limit`;
+    if (capped)
+        return `${count} ${noun} · scan limit`;
+    return `${count} ${noun}`;
+}
+function clip(line) {
+    if (line.length <= MAX_MATCH_LINE)
+        return line;
+    return `${line.slice(0, MAX_MATCH_LINE - 1)}…`;
+}
+function checkAbort(signal) {
+    if (signal?.aborted !== true)
+        return;
+    throw signal.reason instanceof Error ? signal.reason : new Error("aborted");
+}
+function skippable(error) {
+    return ["EACCES", "EPERM", "ENOENT"].includes(error.code ?? "");
+}