@orbit-intelligence/orbit-agent 0.3.12

package/dist/src/core/skill-loader.js

@@ -0,0 +1,31 @@
+import { toolError, okToolOk } from './tools/types.js';
+/**
+ * load_project_skill — exposes the bodies of user-authored skills from
+ * `.orbit/skills/` (or `.agents/skills/`) so the model can load instructions
+ * on demand instead of them inflating every single prompt.
+ */
+export function createSkillLoaderTool(project) {
+    return {
+        name: 'load_project_skill',
+        description: 'Load the full instructions of a named project skill (from .orbit/skills/*.md). Returns the skill body verbatim. Skills documented in your system prompt — load them before starting matching work.',
+        parameters: {
+            type: 'object',
+            properties: {
+                name: { type: 'string', description: 'Skill name (markdown filename without the .md suffix).' },
+            },
+            required: ['name'],
+        },
+        async run(args, ctx) {
+            void ctx;
+            const name = String(args.name ?? '').trim();
+            if (!name)
+                return toolError('load_project_skill requires a skill name.');
+            const body = project.skillBodies[name];
+            if (body === undefined) {
+                const available = project.skills.map((s) => s.name).join(', ') || '(none found)';
+                return toolError(`unknown skill "${name}". Available: ${available}`);
+            }
+            return okToolOk(body);
+        },
+    };
+}

package/dist/src/core/tools/edit.js

@@ -0,0 +1,142 @@
+import { readFile, writeFile, mkdir } from 'node:fs/promises';
+import { resolve, relative, basename } from 'node:path';
+import { homedir } from 'node:os';
+import { toolError } from './types.js';
+function resolvePath(p, cwd) {
+    if (p === '~')
+        return homedir();
+    if (p.startsWith('~/'))
+        return joinPath(homedir(), p.slice(2));
+    return resolve(cwd, p);
+}
+function joinPath(a, b) {
+    return `${a.replace(/\/$/, '')}/${b}`;
+}
+function countOccurrences(haystack, needle) {
+    let count = 0;
+    let idx = 0;
+    while ((idx = haystack.indexOf(needle, idx)) !== -1) {
+        count++;
+        idx += needle.length;
+        if (count > 1)
+            return count;
+    }
+    return count;
+}
+/**
+ * edit_file — a surgical alternative to write_file. Prefers exact string
+ * replacement over full rewrites: the model only sends the changed fragment,
+ * so it preserves style and reduces the chance of clobbering unrelated code.
+ *
+ * Two modes:
+ *  1. old_string/new_string  — replace the single unique occurrence of a substring.
+ *  2. from_line/to_line/new_string — replace an inclusive line range.
+ */
+export const editFileTool = {
+    name: 'edit_file',
+    description: 'Apply a targeted edit to an existing text file. Use this instead of write_file for small changes: it preserves the rest of the file. Provide old_string + new_string (unique substring) to make an exact replacement, or from_line/to_line + new_string to replace a line range. Returns a compact diff of what changed.',
+    parameters: {
+        type: 'object',
+        properties: {
+            path: { type: 'string', description: 'Path to the file to edit (relative or absolute).' },
+            old_string: { type: 'string', description: 'Exact text to find. Must appear exactly once. Omit when using line ranges.' },
+            new_string: { type: 'string', description: 'Replacement text.' },
+            from_line: { type: 'number', description: '1-based first line to replace (requires to_line).' },
+            to_line: { type: 'number', description: '1-based last line to replace (inclusive, requires from_line).' },
+        },
+        required: ['path'],
+    },
+    async run(args, ctx) {
+        if (!ctx.canWrite)
+            return toolError('filesystem is read-only in this context.');
+        const p = resolvePath(String(args.path ?? ''), ctx.cwd);
+        const newString = String(args.new_string ?? '');
+        const oldString = typeof args.old_string === 'string' ? args.old_string : '';
+        const fromLine = typeof args.from_line === 'number' ? args.from_line : undefined;
+        const toLine = typeof args.to_line === 'number' ? args.to_line : undefined;
+        if (oldString && (fromLine !== undefined || toLine !== undefined)) {
+            return toolError('provide either old_string OR a line range, not both.');
+        }
+        if (!oldString && (fromLine === undefined || toLine === undefined)) {
+            return toolError('provide old_string (with new_string) or a from_line/to_line range.');
+        }
+        let content;
+        try {
+            content = await readFile(p, 'utf8');
+        }
+        catch (err) {
+            return toolError(`cannot read ${p}: ${err.message}`);
+        }
+        let before;
+        let after;
+        let changed = null;
+        if (oldString) {
+            const occurrences = countOccurrences(content, oldString);
+            if (occurrences === 0)
+                return toolError(`old_string not found in ${relativePathFor(p, ctx.cwd)}.`);
+            if (occurrences > 1)
+                return toolError(`old_string matched ${occurrences} times — include more surrounding context to make it unique.`);
+            const idx = content.indexOf(oldString);
+            before = content.slice(0, idx);
+            after = content.slice(idx + oldString.length);
+            changed = {
+                start: content.slice(0, idx).split('\n').length,
+                end: content.slice(0, idx + oldString.length).split('\n').length,
+            };
+        }
+        else {
+            const lines = content.split('\n');
+            const n = lines.length;
+            const from = Math.max(1, fromLine);
+            const to = Math.min(n, toLine ?? from);
+            if (fromLine > toLine) {
+                return toolError('from_line must be <= to_line.');
+            }
+            before = lines.slice(0, from - 1).join('\n');
+            after = lines.slice(to).join('\n');
+            changed = { start: from, end: to };
+        }
+        const next = (before.length === 0 ? '' : before) + newString + after;
+        // Preserve a single trailing newline if the original had one.
+        const final = content.endsWith('\n') && !next.endsWith('\n') ? next + '\n' : next;
+        try {
+            const parent = p.split('/').slice(0, -1).join('/') || '.';
+            await mkdir(parent, { recursive: true });
+            await writeFile(p, final, 'utf8');
+        }
+        catch (err) {
+            return toolError(`write failed: ${err.message}`);
+        }
+        const rel = relativePathFor(p, ctx.cwd);
+        const removedLines = changed.end - changed.start + 1;
+        const addedLines = newString.split('\n').length;
+        // Compact diff window: show up to 3 lines context before/after.
+        const ctxBefore = lastN(before, 3);
+        const ctxAfter = firstN(after, 3);
+        const diffLines = [
+            `Edited ${rel} (lines ${changed.start}–${changed.end}, ${removedLines}→${addedLines} lines):`,
+        ];
+        for (const l of ctxBefore)
+            diffLines.push(`  ${l}`);
+        for (const l of oldString.split('\n'))
+            diffLines.push(`- ${l}`);
+        for (const l of newString.split('\n'))
+            diffLines.push(`+ ${l}`);
+        for (const l of ctxAfter)
+            diffLines.push(`  ${l}`);
+        if (diffLines.length > 40) {
+            diffLines.push(`  … (${diffLines.length - 40} diff rows elided)`);
+        }
+        return { content: diffLines.join('\n'), isError: false };
+    },
+};
+// --- helpers ---
+function relativePathFor(p, cwd) {
+    return relative(cwd, p) || basename(p);
+}
+function lastN(s, n) {
+    return s.split('\n').slice(-n);
+}
+function firstN(s, n) {
+    return s.split('\n').slice(0, n);
+}

package/dist/src/core/tools/filesystem.js

@@ -0,0 +1,203 @@
+import { readFile, writeFile, mkdir } from 'node:fs/promises';
+import { readdir } from 'node:fs/promises';
+import { join, relative, resolve, basename, extname } from 'node:path';
+import { homedir } from 'node:os';
+import { okToolOk, toolError } from './types.js';
+function resolvePath(p, cwd) {
+    if (p === '~')
+        return homedir();
+    if (p.startsWith('~/'))
+        return join(homedir(), p.slice(2));
+    return resolve(cwd, p);
+}
+export const readFileTool = {
+    name: 'read_file',
+    description: 'Read the full contents of a text file. Returns raw bytes as text; truncates very large files.',
+    parameters: {
+        type: 'object',
+        properties: {
+            path: { type: 'string', description: 'Absolute or relative path to read.' },
+        },
+        required: ['path'],
+    },
+    async run(args, ctx) {
+        const p = resolvePath(String(args.path ?? ''), ctx.cwd);
+        try {
+            const content = await readFile(p, 'utf8');
+            const maxLen = 200_000;
+            const out = content.length > maxLen ? `${content.slice(0, maxLen)}\n… [truncated ${content.length - maxLen} bytes]` : content;
+            return okToolOk(out);
+        }
+        catch (err) {
+            return toolError(err.message);
+        }
+    },
+};
+export const writeFileTool = {
+    name: 'write_file',
+    description: 'Write content to a file, creating parent directories as needed.',
+    parameters: {
+        type: 'object',
+        properties: {
+            path: { type: 'string', description: 'Path to write to.' },
+            content: { type: 'string', description: 'Full file content to write.' },
+        },
+        required: ['path', 'content'],
+    },
+    async run(args, ctx) {
+        if (!ctx.canWrite) {
+            return toolError('filesystem is read-only in this context.');
+        }
+        const p = resolvePath(String(args.path ?? ''), ctx.cwd);
+        try {
+            const parent = p.split('/').slice(0, -1).join('/') || '.';
+            await mkdir(parent, { recursive: true });
+            await writeFile(p, String(args.content ?? ''), 'utf8');
+            const rel = relative(ctx.cwd, p) || basename(p);
+            return okToolOk(`Wrote ${rel} (${Buffer.byteLength(String(args.content ?? ''))} bytes).`);
+        }
+        catch (err) {
+            return toolError(err.message);
+        }
+    },
+};
+export const listDirTool = {
+    name: 'list_dir',
+    description: 'List the contents of a directory (recursive only up to depth 1 by default).',
+    parameters: {
+        type: 'object',
+        properties: {
+            path: { type: 'string', description: 'Directory to list. Defaults to the working directory.' },
+            depth: { type: 'number', description: 'Recurse up to this depth (default 0).', default: 0 },
+        },
+        required: [],
+    },
+    async run(args, ctx) {
+        const p = resolvePath(String(args.path ?? '.'), ctx.cwd);
+        const depth = Math.min(Math.max(Number(args.depth ?? 0), 0), 2);
+        try {
+            const lines = await walk(p, depth, ctx.cwd);
+            if (lines.length === 0)
+                return okToolOk(`(empty directory: ${relative(ctx.cwd, p) || '.'})`);
+            return okToolOk(lines.join('\n'));
+        }
+        catch (err) {
+            return toolError(err.message);
+        }
+    },
+};
+async function walk(dir, depth, cwd) {
+    let entries;
+    try {
+        entries = await readdir(dir, { withFileTypes: true });
+    }
+    catch {
+        return [`(unreadable: ${dir})`];
+    }
+    entries.sort((a, b) => a.isDirectory() === b.isDirectory() ? a.name.localeCompare(b.name) : a.isDirectory() ? 1 : -1);
+    const lines = [];
+    for (const e of entries) {
+        if (e.name === 'node_modules' || e.name === '.git' || e.name === 'dist')
+            continue;
+        const full = join(dir, e.name);
+        const rel = relative(cwd, full) || e.name;
+        if (e.isDirectory()) {
+            lines.push(`${rel}/`);
+            if (depth > 0) {
+                const sub = await walk(full, depth - 1, cwd);
+                for (const s of sub.slice(0, 100))
+                    lines.push(s);
+            }
+        }
+        else {
+            lines.push(rel);
+        }
+    }
+    return lines;
+}
+/** Simple glob: supports **, *, ? against the resolved path. */
+export const globTool = {
+    name: 'glob',
+    description: 'Find files matching a glob pattern (e.g. "src/**/*.ts").',
+    parameters: {
+        type: 'object',
+        properties: {
+            pattern: { type: 'string', description: 'Glob pattern to match.' },
+            path: { type: 'string', description: 'Base directory.' },
+        },
+        required: ['pattern'],
+    },
+    async run(args, ctx) {
+        const base = resolvePath(String(args.path ?? '.'), ctx.cwd);
+        const pattern = String(args.pattern ?? '');
+        try {
+            const results = await globWalk(base, pattern, ctx.cwd);
+            return okToolOk(results.length ? results.join('\n') : `(no matches for "${pattern}")`);
+        }
+        catch (err) {
+            return toolError(err.message);
+        }
+    },
+};
+async function globWalk(base, pattern, cwd) {
+    const all = [];
+    const segments = pattern.split('/');
+    await walkMode(base, segments, cwd, all, 0);
+    return all;
+}
+async function walkMode(dir, pattern, cwd, out, depth) {
+    if (depth > 6)
+        return;
+    if (pattern.length === 0)
+        return;
+    const seg = pattern[0];
+    let entries;
+    try {
+        entries = await readdir(dir, { withFileTypes: true });
+    }
+    catch {
+        return;
+    }
+    for (const e of entries) {
+        if (e.name === 'node_modules' || e.name === '.git')
+            continue;
+        const full = join(dir, e.name);
+        const rel = relative(cwd, full) || e.name;
+        const rest = pattern.slice(1);
+        if (seg === '**') {
+            if (e.isDirectory()) {
+                // match zero or more directories
+                await walkMode(full, pattern, cwd, out, depth + 1);
+                if (rest.length === 0)
+                    continue;
+            }
+            if (matchSeg(seg, e.name)) {
+                if (rest.length === 0) {
+                    out.push(rel);
+                }
+                else if (e.isDirectory()) {
+                    await walkMode(full, rest, cwd, out, depth + 1);
+                }
+            }
+            continue;
+        }
+        if (!matchSeg(seg, e.name))
+            continue;
+        if (rest.length === 0) {
+            out.push(rel);
+        }
+        else if (e.isDirectory()) {
+            await walkMode(full, rest, cwd, out, depth + 1);
+        }
+    }
+}
+function matchSeg(pattern, str) {
+    if (pattern === '**')
+        return true;
+    const re = new RegExp('^' + pattern.replace(/[.+^${}()|[\]\\]/g, '\\$&').replace(/\*\*/g, '.*').replace(/\*/g, '[^/]*').replace(/\?/g, '.') + '$');
+    return re.test(str);
+}
+export function isBinaryish(p) {
+    const BIN_EXTS = new Set(['.png', '.jpg', '.jpeg', '.gif', '.webp', '.wasm', '.woff', '.woff2', '.ttf', '.o', '.a', '.so', '.dll', '.exe', '.pdf', '.zip', '.gz']);
+    return BIN_EXTS.has(extname(p).toLowerCase());
+}

package/dist/src/core/tools/git.js

@@ -0,0 +1,138 @@
+import { execFile } from 'node:child_process';
+import { okToolOk, toolError } from './types.js';
+export function runGit(cwd, args, timeoutMs = 15_000, signal) {
+    return new Promise((resolve) => {
+        const child = execFile('git', args, { cwd, timeout: timeoutMs, signal, maxBuffer: 2 * 1024 * 1024 }, (err, stdout, stderr) => {
+            if (err && err.code === 'ENOENT') {
+                resolve({ code: 127, stdout: '', stderr: 'git: command not found — install git on this device.' });
+                return;
+            }
+            const code = typeof err?.code === 'number'
+                ? err.code
+                : err ? 1 : 0;
+            resolve({ code, stdout, stderr });
+        });
+    });
+}
+const base = {
+    type: 'object',
+    properties: {
+        cwd: { type: 'string', description: 'Repository directory (default: current working directory).' },
+    },
+    required: [],
+};
+export const gitStatusTool = {
+    name: 'git_status',
+    description: 'Show the repository status: current branch and working-tree changes (short porcelain format). Read-only.',
+    parameters: { ...base },
+    async run(args, ctx) {
+        const cwd = String(args.cwd ?? ctx.cwd);
+        const { code, stdout, stderr } = await runGit(cwd, ['status', '--short', '--branch']);
+        if (code !== 0)
+            return toolError(`git status failed: ${stderr.trim() || stdout.trim()}`);
+        const out = stdout.trim() || '(clean working tree)';
+        return okToolOk(`git status:\n${out}\n\nRun git_diff for details.`);
+    },
+};
+export const gitDiffTool = {
+    name: 'git_diff',
+    description: 'Show the working-tree diff (or staged with staged=true). Optionally scoped to one path. Read-only.',
+    parameters: {
+        type: 'object',
+        properties: {
+            ...base.properties,
+            path: { type: 'string', description: 'Restrict diff to this path.' },
+            staged: { type: 'boolean', description: 'Show staged changes (git diff --staged).' },
+            stat: { type: 'boolean', description: 'Summary of changed files instead of full hunks.' },
+        },
+        required: [],
+    },
+    async run(args, ctx) {
+        const cwd = String(args.cwd ?? ctx.cwd);
+        const gitArgs = ['diff'];
+        if (args.staged)
+            gitArgs.push('--staged');
+        if (args.stat)
+            gitArgs.push('--stat');
+        if (args.path)
+            gitArgs.push('--', String(args.path));
+        const { code, stdout, stderr } = await runGit(cwd, gitArgs);
+        if (code !== 0)
+            return toolError(`git diff failed: ${stderr.trim() || stdout.trim()}`);
+        const out = stdout.trim();
+        if (!out)
+            return okToolOk('(no changes)');
+        const maxLen = 60_000;
+        const truncated = out.length > maxLen ? `${out.slice(0, maxLen)}\n… [truncated]` : out;
+        return okToolOk(truncated);
+    },
+};
+export const gitLogTool = {
+    name: 'git_log',
+    description: 'Show recent commit history (one line per commit). Read-only.',
+    parameters: {
+        type: 'object',
+        properties: {
+            ...base.properties,
+            count: { type: 'number', description: 'Number of commits to show (default 15).' },
+        },
+        required: [],
+    },
+    async run(args, ctx) {
+        const cwd = String(args.cwd ?? ctx.cwd);
+        const count = Math.min(Math.max(Number(args.count ?? 15), 1), 50);
+        const { code, stdout, stderr } = await runGit(cwd, ['log', `--max-count=${count}`, '--oneline']);
+        if (code !== 0)
+            return toolError(`git log failed: ${stderr.trim() || stdout.trim()}`);
+        return okToolOk(stdout.trim() || '(no commits yet)');
+    },
+};
+export const gitAddTool = {
+    name: 'git_add',
+    description: 'Stage files with `git add`. Mutates the index — permission-gated. Provide paths as a relative path/glob string or list.',
+    parameters: {
+        type: 'object',
+        properties: {
+            ...base.properties,
+            paths: { type: 'array', items: { type: 'string' }, description: 'Paths or globs to stage (default: ".")' },
+        },
+        required: [],
+    },
+    async run(args, ctx) {
+        const cwd = String(args.cwd ?? ctx.cwd);
+        const paths = Array.isArray(args.paths) && args.paths.length > 0 ? args.paths.map(String) : ['.'];
+        const { code, stdout, stderr } = await runGit(cwd, ['add', '--', ...paths]);
+        if (code !== 0)
+            return toolError(`git add failed: ${stderr.trim() || stdout.trim()}`);
+        return okToolOk(stdout.trim() ? `git add: ${stdout.trim()}` : `staged ${paths.join(', ')}`);
+    },
+};
+export const gitCommitTool = {
+    name: 'git_commit',
+    description: 'Create a commit with the given message. Staged changes are required first. Permission-gated.',
+    parameters: {
+        type: 'object',
+        properties: {
+            ...base.properties,
+            message: { type: 'string', description: 'Commit message.' },
+        },
+        required: ['message'],
+    },
+    async run(args, ctx) {
+        const cwd = String(args.cwd ?? ctx.cwd);
+        const message = String(args.message ?? '');
+        if (!message.trim())
+            return toolError('commit message is required.');
+        const { code, stdout, stderr } = await runGit(cwd, ['commit', '-m', message]);
+        if (code !== 0)
+            return toolError(`git commit failed: ${stderr.trim() || stdout.trim()}`);
+        return okToolOk(stdout.trim() || `committed: ${message}`);
+    },
+};
+export const gitTools = [
+    gitStatusTool,
+    gitDiffTool,
+    gitLogTool,
+    gitAddTool,
+    gitCommitTool,
+];

package/dist/src/core/tools/registry.js

@@ -0,0 +1,73 @@
+import { readFileTool, writeFileTool, listDirTool, globTool } from './filesystem.js';
+import { editFileTool } from './edit.js';
+import { createShellTool } from './shell.js';
+import { grepTool } from './search.js';
+import { gitTools } from './git.js';
+/**
+ * ToolRegistry — ordered, dependency-light tool container.
+ * Supports role-based restriction for delegated sub-agents:
+ * a restricted registry shares the same tool implementations but only
+ * exposes a whitelist of names (read-only roles drop shell mutations etc.).
+ */
+export class ToolRegistry {
+    tools = new Map();
+    names = [];
+    ctx;
+    constructor(init) {
+        this.ctx = { cwd: init.cwd, canWrite: init.canWrite ?? true };
+        this.register(readFileTool);
+        this.register(editFileTool);
+        this.register(writeFileTool);
+        this.register(listDirTool);
+        this.register(globTool);
+        this.register(grepTool);
+        if (init.withGit ?? true) {
+            for (const t of gitTools)
+                this.register(t);
+        }
+        if (init.shell ?? true) {
+            this.register(createShellTool({ shell: init.shellPath }));
+        }
+    }
+    register(tool) {
+        const exists = this.tools.has(tool.name);
+        this.tools.set(tool.name, tool);
+        if (!exists)
+            this.names.push(tool.name);
+    }
+    get(name) {
+        return this.tools.get(name);
+    }
+    all() {
+        return this.names.map((n) => this.tools.get(n)).filter(Boolean);
+    }
+    /** A new registry restricted to the given tool names, sharing implementations. */
+    restrict(allowed) {
+        const r = new ToolRegistry({ cwd: this.ctx.cwd, canWrite: this.ctx.canWrite, shell: false, withGit: false });
+        r.tools.clear();
+        r.names = [];
+        for (const name of allowed) {
+            const t = this.tools.get(name);
+            if (t)
+                r.register(t);
+        }
+        return r;
+    }
+    toToolDefs() {
+        return this.all().map((t) => ({
+            type: 'function',
+            function: { name: t.name, description: t.description, parameters: t.parameters },
+        }));
+    }
+    createToolContext() {
+        return { ...this.ctx, notify: () => { } };
+    }
+}
+export const READ_ONLY_TOOLS = [
+    'read_file', 'list_dir', 'glob', 'grep',
+    'git_status', 'git_diff', 'git_log',
+];
+export const CODER_TOOLS = [
+    'read_file', 'edit_file', 'write_file', 'list_dir', 'glob', 'grep',
+    'run_shell', 'git_status', 'git_diff', 'git_log', 'git_add', 'git_commit',
+];

package/dist/src/core/tools/search.js

@@ -0,0 +1,90 @@
+import { readdir, readFile, stat } from 'node:fs/promises';
+import { join, relative, resolve } from 'node:path';
+import { okToolOk, toolError } from './types.js';
+const SEARCH_DEPTH = 5;
+const FILE_LIMIT = 60_000;
+export const grepTool = {
+    name: 'grep',
+    description: 'Search file contents in a directory for a regex pattern. Returns matching lines.',
+    parameters: {
+        type: 'object',
+        properties: {
+            pattern: { type: 'string', description: 'Regex to search for.' },
+            path: { type: 'string', description: 'Directory to search.' },
+            include: { type: 'string', description: 'Optional filename glob filter, e.g. "*.ts".' },
+        },
+        required: ['pattern'],
+    },
+    async run(args, ctx) {
+        const dir = resolve(String(args.path ?? '.'), ctx.cwd);
+        const pattern = String(args.pattern ?? '');
+        let re;
+        try {
+            re = new RegExp(pattern, 'i');
+        }
+        catch (err) {
+            return toolError(`invalid regex: ${err.message}`);
+        }
+        const include = String(args.include ?? '');
+        try {
+            const matches = [];
+            await search(dir, dir, re, include, matches, 0, ctx.cwd);
+            if (matches.length === 0)
+                return okToolOk(`(no matches for /${pattern}/)`);
+            const truncated = matches.slice(0, 200);
+            const more = matches.length > 200 ? `… ${matches.length - 200} more` : '';
+            return okToolOk(truncated.join('\n') + (more ? `\n${more}` : ''));
+        }
+        catch (err) {
+            return toolError(err.message);
+        }
+    },
+};
+async function search(root, dir, re, include, out, depth, cwd) {
+    if (depth > SEARCH_DEPTH || out.length >= FILE_LIMIT)
+        return;
+    let entries;
+    try {
+        entries = await readdir(dir, { withFileTypes: true });
+    }
+    catch {
+        return;
+    }
+    for (const e of entries) {
+        if (e.name === 'node_modules' || e.name === '.git' || e.name === 'dist')
+            continue;
+        const full = join(dir, e.name);
+        if (e.isDirectory()) {
+            await search(root, full, re, include, out, depth + 1, cwd);
+            continue;
+        }
+        if (include && !matchGlob(include, e.name))
+            continue;
+        try {
+            const st = await stat(full);
+            if (st.size > 500_000)
+                continue;
+            const content = await readFile(full, 'utf8');
+            const rel = relative(cwd, full) || e.name;
+            const lines = content.split('\n');
+            for (let i = 0; i < lines.length; i++) {
+                if (re.test(lines[i])) {
+                    out.push(`${rel}:${i + 1}: ${lines[i].slice(0, 180)}`);
+                    if (out.length >= FILE_LIMIT)
+                        return;
+                }
+            }
+        }
+        catch {
+            /* skip unreadable */
+        }
+    }
+}
+function matchGlob(pattern, name) {
+    const re = new RegExp('^' + pattern.replace(/[.+^${}()|[\]\\]/g, '\\$&').replace(/\*/g, '[^/]*').replace(/\?/g, '.') + '$');
+    return re.test(name);
+}
+export function isText(buf) {
+    const sample = buf.subarray(0, 8000);
+    return !sample.includes(0);
+}