@assemblyline-agents/runtime 1.0.0 → 3.0.0

package/dist/code-mode.js

@@ -1,658 +0,0 @@
-import { approvalNever } from "@openeve/core";
-export const READ_TOOL_NAME = "read";
-export const WRITE_TOOL_NAME = "write";
-export const EDIT_TOOL_NAME = "edit";
-export const DELETE_TOOL_NAME = "delete";
-export const LIST_TOOL_NAME = "list";
-export const GREP_TOOL_NAME = "grep";
-export const BASH_TOOL_NAME = "bash";
-export const ASK_QUESTION_TOOL_NAME = "ask_question";
-export const SPAWN_SUBAGENT_TOOL_NAME = "spawn_subagent";
-export const LOAD_SKILL_TOOL_NAME = "load_skill";
-export const TOOL_SEARCH_TOOL_NAME = "tool_search";
-export const TOOL_DESCRIBE_TOOL_NAME = "tool_describe";
-export const TOOL_CALL_TOOL_NAME = "tool_call";
-export const CORE_HARNESS_TOOL_NAMES = [
-    READ_TOOL_NAME,
-    WRITE_TOOL_NAME,
-    EDIT_TOOL_NAME,
-    DELETE_TOOL_NAME,
-    LIST_TOOL_NAME,
-    GREP_TOOL_NAME,
-    BASH_TOOL_NAME,
-    ASK_QUESTION_TOOL_NAME,
-    SPAWN_SUBAGENT_TOOL_NAME,
-    LOAD_SKILL_TOOL_NAME,
-    TOOL_SEARCH_TOOL_NAME,
-    TOOL_DESCRIBE_TOOL_NAME,
-    TOOL_CALL_TOOL_NAME
-];
-const CORE_HARNESS_TOOL_NAME_SET = new Set(CORE_HARNESS_TOOL_NAMES);
-const BUILTIN_SOURCE = {
-    path: "__builtin__/harness",
-    sha256: "builtin-harness"
-};
-const PATH_SCHEMA = {
-    type: "string",
-    description: "Absolute sandbox path, such as /memory/notes.md, /skills/name/SKILL.md, /runtime/report.txt, or /workspace/app.ts."
-};
-const READ_COMPILED_TOOL = {
-    name: READ_TOOL_NAME,
-    description: "Read a file from the sandbox filesystem. Lazily hydrates logical OpenEve paths before reading.",
-    inputSchema: {
-        type: "object",
-        additionalProperties: false,
-        properties: {
-            path: PATH_SCHEMA,
-            maxBytes: { type: "number", description: "Maximum bytes to return. Defaults to 65536." }
-        },
-        required: ["path"]
-    },
-    needsApproval: approvalNever(),
-    defaultEnabled: true,
-    visibility: "always",
-    execution: "sandbox",
-    tags: ["filesystem", "sandbox", "read"],
-    aliases: ["read_file", "cat"],
-    hasToModelOutput: true,
-    source: BUILTIN_SOURCE
-};
-const WRITE_COMPILED_TOOL = {
-    name: WRITE_TOOL_NAME,
-    description: "Write a file in the sandbox filesystem. Mutations are durably queued for async sync before the write.",
-    inputSchema: {
-        type: "object",
-        additionalProperties: false,
-        properties: {
-            path: PATH_SCHEMA,
-            content: { type: "string", description: "File contents to write." },
-            contents: { type: "string", description: "Alias for content." },
-            encoding: { type: "string", enum: ["utf8", "base64"], description: "Input encoding. Defaults to utf8." }
-        },
-        required: ["path"]
-    },
-    needsApproval: approvalNever(),
-    defaultEnabled: true,
-    visibility: "always",
-    execution: "sandbox",
-    tags: ["filesystem", "sandbox", "write"],
-    aliases: ["write_file"],
-    hasToModelOutput: true,
-    source: BUILTIN_SOURCE
-};
-const EDIT_COMPILED_TOOL = {
-    name: EDIT_TOOL_NAME,
-    description: "Edit a sandbox file by replacing exact text. Hydrates the path first when it is a logical OpenEve resource.",
-    inputSchema: {
-        type: "object",
-        additionalProperties: false,
-        properties: {
-            path: PATH_SCHEMA,
-            search: { type: "string", description: "Exact text to replace." },
-            replace: { type: "string", description: "Replacement text." },
-            expectedOccurrences: { type: "number", description: "Optional exact occurrence count guard." },
-            all: { type: "boolean", description: "Replace all occurrences. Defaults to true." }
-        },
-        required: ["path", "search", "replace"]
-    },
-    needsApproval: approvalNever(),
-    defaultEnabled: true,
-    visibility: "always",
-    execution: "sandbox",
-    tags: ["filesystem", "sandbox", "edit"],
-    aliases: ["patch", "replace"],
-    hasToModelOutput: true,
-    source: BUILTIN_SOURCE
-};
-const DELETE_COMPILED_TOOL = {
-    name: DELETE_TOOL_NAME,
-    description: "Delete a writable sandbox file or directory and record a tombstone for durable async sync.",
-    inputSchema: {
-        type: "object",
-        additionalProperties: false,
-        properties: {
-            path: PATH_SCHEMA,
-            recursive: { type: "boolean", description: "Allow deleting directories recursively. Defaults to true." }
-        },
-        required: ["path"]
-    },
-    needsApproval: approvalNever(),
-    defaultEnabled: true,
-    visibility: "always",
-    execution: "sandbox",
-    tags: ["filesystem", "sandbox", "delete"],
-    aliases: ["rm", "remove"],
-    hasToModelOutput: true,
-    source: BUILTIN_SOURCE
-};
-const LIST_COMPILED_TOOL = {
-    name: LIST_TOOL_NAME,
-    description: "List files under a sandbox path. Lazily hydrates bounded logical OpenEve roots before listing.",
-    inputSchema: {
-        type: "object",
-        additionalProperties: false,
-        properties: {
-            path: PATH_SCHEMA,
-            limit: { type: "number", description: "Maximum entries. Defaults to 200." }
-        },
-        required: ["path"]
-    },
-    needsApproval: approvalNever(),
-    defaultEnabled: true,
-    visibility: "always",
-    execution: "sandbox",
-    tags: ["filesystem", "sandbox", "list"],
-    aliases: ["ls"],
-    hasToModelOutput: true,
-    source: BUILTIN_SOURCE
-};
-const GREP_COMPILED_TOOL = {
-    name: GREP_TOOL_NAME,
-    description: "Search files under a sandbox path with a regular expression or literal pattern.",
-    inputSchema: {
-        type: "object",
-        additionalProperties: false,
-        properties: {
-            pattern: { type: "string" },
-            path: PATH_SCHEMA,
-            literal: { type: "boolean", description: "Treat pattern as literal text. Defaults to false." },
-            limit: { type: "number", description: "Maximum matches. Defaults to 100." }
-        },
-        required: ["pattern"]
-    },
-    needsApproval: approvalNever(),
-    defaultEnabled: true,
-    visibility: "always",
-    execution: "sandbox",
-    tags: ["filesystem", "sandbox", "search"],
-    aliases: ["search", "rg"],
-    hasToModelOutput: true,
-    source: BUILTIN_SOURCE
-};
-const BASH_COMPILED_TOOL = {
-    name: BASH_TOOL_NAME,
-    description: "Run a Bash command in the sandbox. The sandbox is marked dirty and queued for async sync before execution.",
-    inputSchema: {
-        type: "object",
-        additionalProperties: false,
-        properties: {
-            command: { type: "string" },
-            cwd: { type: "string" },
-            timeoutMs: { type: "number" }
-        },
-        required: ["command"]
-    },
-    needsApproval: approvalNever(),
-    defaultEnabled: true,
-    visibility: "always",
-    execution: "sandbox",
-    tags: ["sandbox", "bash", "shell"],
-    aliases: ["shell", "terminal"],
-    hasToModelOutput: true,
-    source: BUILTIN_SOURCE
-};
-const ASK_QUESTION_COMPILED_TOOL = {
-    name: ASK_QUESTION_TOOL_NAME,
-    description: "Ask the user a concise clarifying question and pause the run until the answer is available.",
-    inputSchema: {
-        type: "object",
-        additionalProperties: false,
-        properties: {
-            question: { type: "string" },
-            choices: { type: "array", items: { type: "string" } },
-            allowFreeform: { type: "boolean" },
-            metadata: { type: "object", additionalProperties: true }
-        },
-        required: ["question"]
-    },
-    needsApproval: approvalNever(),
-    defaultEnabled: true,
-    visibility: "always",
-    execution: "direct",
-    tags: ["human", "question"],
-    aliases: ["clarify"],
-    hasToModelOutput: true,
-    source: BUILTIN_SOURCE
-};
-const SPAWN_SUBAGENT_COMPILED_TOOL = {
-    name: SPAWN_SUBAGENT_TOOL_NAME,
-    description: "Spawn a configured subagent by name for delegated work.",
-    inputSchema: {
-        type: "object",
-        additionalProperties: true,
-        properties: {
-            name: { type: "string", description: "Subagent name." },
-            task: { type: "string" },
-            expectedOutput: { type: "string" },
-            constraints: { type: "array", items: { type: "string" } }
-        },
-        required: ["name", "task"]
-    },
-    needsApproval: approvalNever(),
-    defaultEnabled: true,
-    visibility: "always",
-    execution: "direct",
-    tags: ["subagent", "delegate"],
-    aliases: ["delegate", "agent"],
-    hasToModelOutput: true,
-    source: BUILTIN_SOURCE
-};
-const LOAD_SKILL_COMPILED_TOOL = {
-    name: LOAD_SKILL_TOOL_NAME,
-    description: "Load a skill's full instructions by name from the durable skill store. Loading a skill does not reveal additional tools.",
-    inputSchema: {
-        type: "object",
-        additionalProperties: false,
-        properties: {
-            name: { type: "string", description: "Skill name, such as skill-creator." },
-            skillName: { type: "string", description: "Alias for name." }
-        }
-    },
-    needsApproval: approvalNever(),
-    defaultEnabled: true,
-    visibility: "always",
-    execution: "direct",
-    tags: ["skills", "instructions", "progressive-disclosure"],
-    aliases: ["skill_view", "load_instructions"],
-    hasToModelOutput: true,
-    source: BUILTIN_SOURCE
-};
-const TOOL_SEARCH_COMPILED_TOOL = {
-    name: TOOL_SEARCH_TOOL_NAME,
-    description: "Search deferred non-core tools by name, description, tags, aliases, or connection. Returns compact metadata only.",
-    inputSchema: {
-        type: "object",
-        additionalProperties: false,
-        properties: {
-            query: { type: "string" },
-            limit: { type: "number" },
-            kind: { type: "string" },
-            connection: { type: "string" }
-        },
-        required: ["query"]
-    },
-    needsApproval: approvalNever(),
-    defaultEnabled: true,
-    visibility: "always",
-    execution: "direct",
-    tags: ["tools", "deferred", "search"],
-    aliases: ["tools"],
-    hasToModelOutput: true,
-    source: BUILTIN_SOURCE
-};
-const TOOL_DESCRIBE_COMPILED_TOOL = {
-    name: TOOL_DESCRIBE_TOOL_NAME,
-    description: "Return the full schema for one deferred tool previously found with tool_search.",
-    inputSchema: {
-        type: "object",
-        additionalProperties: false,
-        properties: {
-            name: { type: "string" }
-        },
-        required: ["name"]
-    },
-    needsApproval: approvalNever(),
-    defaultEnabled: true,
-    visibility: "always",
-    execution: "direct",
-    tags: ["tools", "deferred", "describe"],
-    aliases: ["schema"],
-    hasToModelOutput: true,
-    source: BUILTIN_SOURCE
-};
-const TOOL_CALL_COMPILED_TOOL = {
-    name: TOOL_CALL_TOOL_NAME,
-    description: "Call a deferred non-core tool by name with JSON arguments. The underlying tool is logged and policy-checked directly.",
-    inputSchema: {
-        type: "object",
-        additionalProperties: false,
-        properties: {
-            name: { type: "string" },
-            arguments: { type: "object", additionalProperties: true },
-            input: { type: "object", additionalProperties: true }
-        },
-        required: ["name"]
-    },
-    needsApproval: approvalNever(),
-    defaultEnabled: true,
-    visibility: "always",
-    execution: "direct",
-    tags: ["tools", "deferred", "call"],
-    aliases: ["invoke"],
-    hasToModelOutput: true,
-    source: BUILTIN_SOURCE
-};
-const BUILT_IN_COMPILED_TOOLS = [
-    READ_COMPILED_TOOL,
-    WRITE_COMPILED_TOOL,
-    EDIT_COMPILED_TOOL,
-    DELETE_COMPILED_TOOL,
-    LIST_COMPILED_TOOL,
-    GREP_COMPILED_TOOL,
-    BASH_COMPILED_TOOL,
-    ASK_QUESTION_COMPILED_TOOL,
-    SPAWN_SUBAGENT_COMPILED_TOOL,
-    LOAD_SKILL_COMPILED_TOOL,
-    TOOL_SEARCH_COMPILED_TOOL,
-    TOOL_DESCRIBE_COMPILED_TOOL,
-    TOOL_CALL_COMPILED_TOOL
-];
-export function runtimeToolsForManifest(manifest) {
-    return [
-        ...manifest.tools.filter((tool) => !CORE_HARNESS_TOOL_NAME_SET.has(tool.name)),
-        ...BUILT_IN_COMPILED_TOOLS
-    ];
-}
-export function builtInToolDefinition(name) {
-    if (name === READ_TOOL_NAME)
-        return readToolDefinition;
-    if (name === WRITE_TOOL_NAME)
-        return writeToolDefinition;
-    if (name === EDIT_TOOL_NAME)
-        return editToolDefinition;
-    if (name === DELETE_TOOL_NAME)
-        return deleteToolDefinition;
-    if (name === LIST_TOOL_NAME)
-        return listToolDefinition;
-    if (name === GREP_TOOL_NAME)
-        return grepToolDefinition;
-    if (name === BASH_TOOL_NAME)
-        return bashToolDefinition;
-    if (name === ASK_QUESTION_TOOL_NAME)
-        return askQuestionToolDefinition;
-    if (name === SPAWN_SUBAGENT_TOOL_NAME)
-        return spawnSubagentToolDefinition;
-    if (name === LOAD_SKILL_TOOL_NAME)
-        return runtimeHandledToolDefinition(LOAD_SKILL_COMPILED_TOOL);
-    if (name === TOOL_SEARCH_TOOL_NAME)
-        return runtimeHandledToolDefinition(TOOL_SEARCH_COMPILED_TOOL);
-    if (name === TOOL_DESCRIBE_TOOL_NAME)
-        return runtimeHandledToolDefinition(TOOL_DESCRIBE_COMPILED_TOOL);
-    if (name === TOOL_CALL_TOOL_NAME)
-        return runtimeHandledToolDefinition(TOOL_CALL_COMPILED_TOOL);
-    return undefined;
-}
-export function isBuiltInToolName(name) {
-    return CORE_HARNESS_TOOL_NAME_SET.has(name);
-}
-const readToolDefinition = {
-    ...toolDefinitionBase(READ_COMPILED_TOOL),
-    async execute(input, ctx) {
-        const raw = recordInput(input);
-        const path = requiredPath(raw.path);
-        const maxBytes = boundedNumber(raw.maxBytes, 65_536, 1, 10 * 1024 * 1024);
-        await ctx.hydrateSandboxPath?.(path);
-        const sandbox = await ctx.getSandbox();
-        const contents = await sandbox.readFile(path);
-        const bytes = Buffer.from(contents);
-        const truncated = bytes.byteLength > maxBytes;
-        return {
-            path,
-            content: bytes.subarray(0, maxBytes).toString("utf8"),
-            bytes: bytes.byteLength,
-            truncated
-        };
-    }
-};
-const writeToolDefinition = {
-    ...toolDefinitionBase(WRITE_COMPILED_TOOL),
-    async execute(input, ctx) {
-        const raw = recordInput(input);
-        const path = requiredWritablePath(raw.path);
-        const content = typeof raw.content === "string" ? raw.content : typeof raw.contents === "string" ? raw.contents : "";
-        const encoding = raw.encoding === "base64" ? "base64" : "utf8";
-        const bytes = encoding === "base64" ? Buffer.from(content, "base64") : content;
-        const sandbox = await ctx.getSandbox();
-        await sandbox.writeFile(path, bytes);
-        return {
-            path,
-            bytes: typeof bytes === "string" ? Buffer.byteLength(bytes) : bytes.byteLength,
-            encoding
-        };
-    }
-};
-const editToolDefinition = {
-    ...toolDefinitionBase(EDIT_COMPILED_TOOL),
-    async execute(input, ctx) {
-        const raw = recordInput(input);
-        const path = requiredWritablePath(raw.path);
-        const search = typeof raw.search === "string" ? raw.search : "";
-        const replace = typeof raw.replace === "string" ? raw.replace : "";
-        if (!search)
-            throw new Error("edit requires a non-empty search string.");
-        await ctx.hydrateSandboxPath?.(path);
-        const sandbox = await ctx.getSandbox();
-        const original = await sandbox.readFile(path);
-        const occurrences = countOccurrences(original, search);
-        if (typeof raw.expectedOccurrences === "number" && occurrences !== raw.expectedOccurrences) {
-            throw new Error(`edit expected ${raw.expectedOccurrences} occurrences but found ${occurrences}.`);
-        }
-        if (occurrences === 0)
-            throw new Error(`edit found no occurrences in ${path}.`);
-        const all = raw.all !== false;
-        const updated = all ? original.split(search).join(replace) : original.replace(search, replace);
-        await sandbox.writeFile(path, updated);
-        return {
-            path,
-            occurrences,
-            replaced: all ? occurrences : 1,
-            bytes: Buffer.byteLength(updated)
-        };
-    }
-};
-const deleteToolDefinition = {
-    ...toolDefinitionBase(DELETE_COMPILED_TOOL),
-    async execute(input, ctx) {
-        const raw = recordInput(input);
-        const path = requiredWritablePath(raw.path);
-        const sandbox = await ctx.getSandbox();
-        await ctx.recordSandboxTombstone?.(path);
-        const flag = raw.recursive === false ? "" : "-r";
-        const result = await sandbox.shell(`rm ${flag} -f -- ${shellQuote(path)}`.replace(/\s+/g, " ").trim());
-        if (result.exitCode !== 0)
-            throw new Error(result.stderr || `delete failed for ${path}`);
-        return { path, deleted: true };
-    }
-};
-const listToolDefinition = {
-    ...toolDefinitionBase(LIST_COMPILED_TOOL),
-    async execute(input, ctx) {
-        const raw = recordInput(input);
-        const path = requiredPath(raw.path);
-        const limit = boundedNumber(raw.limit, 200, 1, 2000);
-        await ctx.hydrateSandboxPath?.(path, { list: true, limit });
-        const sandbox = await ctx.getSandbox();
-        const entries = await listSandboxEntries(sandbox, path, limit);
-        return { path, entries, count: entries.length, truncated: entries.length >= limit };
-    }
-};
-const grepToolDefinition = {
-    ...toolDefinitionBase(GREP_COMPILED_TOOL),
-    async execute(input, ctx) {
-        const raw = recordInput(input);
-        const pattern = typeof raw.pattern === "string" ? raw.pattern : "";
-        if (!pattern)
-            throw new Error("grep requires a non-empty pattern.");
-        const path = typeof raw.path === "string" ? normalizeSandboxPath(raw.path) : "/workspace";
-        const limit = boundedNumber(raw.limit, 100, 1, 2000);
-        await ctx.hydrateSandboxPath?.(path, { list: true, limit });
-        const sandbox = await ctx.getSandbox();
-        const matches = await grepSandbox(sandbox, path, pattern, raw.literal === true, limit);
-        return { pattern, path, matches, count: matches.length, truncated: matches.length >= limit };
-    }
-};
-const bashToolDefinition = {
-    ...toolDefinitionBase(BASH_COMPILED_TOOL),
-    async execute(input, ctx) {
-        const raw = recordInput(input);
-        const command = typeof raw.command === "string" ? raw.command : "";
-        if (!command.trim())
-            throw new Error("bash requires a non-empty command.");
-        const sandbox = await ctx.getSandbox();
-        const options = {};
-        if (typeof raw.cwd === "string")
-            options.cwd = raw.cwd;
-        if (typeof raw.timeoutMs === "number" && Number.isFinite(raw.timeoutMs))
-            options.timeoutMs = raw.timeoutMs;
-        return sandbox.shell(command, options);
-    }
-};
-const askQuestionToolDefinition = {
-    ...toolDefinitionBase(ASK_QUESTION_COMPILED_TOOL),
-    async execute(input, ctx) {
-        const raw = recordInput(input);
-        const question = typeof raw.question === "string" ? raw.question.trim() : "";
-        if (!question)
-            throw new Error("ask_question requires a non-empty question.");
-        const options = {};
-        if (Array.isArray(raw.choices))
-            options.choices = raw.choices.map(String).filter(Boolean);
-        if (typeof raw.allowFreeform === "boolean")
-            options.allowFreeform = raw.allowFreeform;
-        if (raw.metadata && typeof raw.metadata === "object" && !Array.isArray(raw.metadata)) {
-            options.metadata = raw.metadata;
-        }
-        return ctx.askQuestion(question, options);
-    }
-};
-const spawnSubagentToolDefinition = {
-    ...toolDefinitionBase(SPAWN_SUBAGENT_COMPILED_TOOL),
-    async execute(input, ctx) {
-        if (!ctx.spawnSubagent)
-            throw new Error("Subagent spawning is not available in this runtime.");
-        const raw = recordInput(input);
-        const name = typeof raw.name === "string" ? raw.name.trim() : "";
-        const task = typeof raw.task === "string" ? raw.task.trim() : "";
-        if (!name || !task)
-            throw new Error("spawn_subagent requires name and task.");
-        return ctx.spawnSubagent({
-            name,
-            task,
-            ...(typeof raw.expectedOutput === "string" ? { expectedOutput: raw.expectedOutput } : {}),
-            ...(Array.isArray(raw.constraints) ? { constraints: raw.constraints.map(String) } : {})
-        });
-    }
-};
-function toolDefinitionBase(tool) {
-    const definition = {
-        description: tool.description,
-        inputSchema: tool.inputSchema,
-        needsApproval: false,
-        defaultEnabled: tool.defaultEnabled,
-        capability: {
-            visibility: tool.visibility,
-            execution: tool.execution,
-            tags: tool.tags,
-            aliases: tool.aliases
-        },
-        toModelOutput(output) {
-            return output;
-        }
-    };
-    if (tool.outputSchema)
-        definition.outputSchema = tool.outputSchema;
-    return definition;
-}
-function runtimeHandledToolDefinition(tool) {
-    return {
-        ...toolDefinitionBase(tool),
-        async execute() {
-            throw new Error(`${tool.name} is handled by the OpenEve runtime dispatcher.`);
-        }
-    };
-}
-function recordInput(input) {
-    if (input && typeof input === "object" && !Array.isArray(input))
-        return input;
-    return {};
-}
-function requiredPath(value) {
-    if (typeof value !== "string" || value.trim().length === 0)
-        throw new Error("path is required.");
-    return normalizeSandboxPath(value);
-}
-function requiredWritablePath(value) {
-    const path = requiredPath(value);
-    if (path === "/history" || path.startsWith("/history/") || path === "/files" || path.startsWith("/files/")) {
-        throw new Error(`${path} is read-only.`);
-    }
-    return path;
-}
-function normalizeSandboxPath(path) {
-    const normalized = path.replace(/\\/g, "/").replace(/\/+/g, "/").trim();
-    const absolute = normalized.startsWith("/") ? normalized : `/${normalized}`;
-    if (absolute.split("/").some((part) => part === ".."))
-        throw new Error(`Invalid sandbox path: ${path}`);
-    return absolute === "/" ? "/" : absolute.replace(/\/$/u, "");
-}
-function boundedNumber(value, fallback, min, max) {
-    if (typeof value !== "number" || !Number.isFinite(value))
-        return fallback;
-    return Math.max(min, Math.min(max, Math.floor(value)));
-}
-async function listSandboxEntries(sandbox, path, limit) {
-    if (!sandbox.listFiles)
-        throw new Error("This sandbox adapter does not support file listing.");
-    const entries = await sandbox.listFiles(path);
-    return entries.slice(0, limit).map((entry) => {
-        const out = { path: entry.path };
-        if (entry.size !== undefined)
-            out.size = entry.size;
-        return out;
-    });
-}
-async function grepSandbox(sandbox, path, pattern, literal, limit) {
-    if (!sandbox.listFiles)
-        throw new Error("This sandbox adapter does not support grep without file listing.");
-    const entries = await sandbox.listFiles(path);
-    const matches = [];
-    const regexp = literal ? undefined : new RegExp(pattern, "u");
-    for (const entry of entries) {
-        if (matches.length >= limit)
-            break;
-        const contents = entryContents(entry);
-        if (contents === undefined)
-            continue;
-        const lines = contents.split(/\r?\n/u);
-        for (let index = 0; index < lines.length; index += 1) {
-            const text = lines[index] ?? "";
-            const matched = literal ? text.includes(pattern) : regexp?.test(text);
-            if (!matched)
-                continue;
-            matches.push({ path: entry.path, line: index + 1, text });
-            if (matches.length >= limit)
-                break;
-        }
-    }
-    return matches;
-}
-function entryContents(entry) {
-    if (typeof entry.contents === "string")
-        return entry.contents;
-    if (entry.contents instanceof Uint8Array)
-        return Buffer.from(entry.contents).toString("utf8");
-    return undefined;
-}
-function countOccurrences(value, search) {
-    if (!search)
-        return 0;
-    let count = 0;
-    let index = value.indexOf(search);
-    while (index >= 0) {
-        count += 1;
-        index = value.indexOf(search, index + search.length);
-    }
-    return count;
-}
-function shellQuote(value) {
-    return `'${value.replace(/'/gu, "'\\''")}'`;
-}
-export function builtInToolContext(tool) {
-    if (!isBuiltInToolName(tool.name))
-        return undefined;
-    return {
-        builtin: true,
-        source: tool.source.path
-    };
-}
-//# sourceMappingURL=code-mode.js.map