@chengchenccc/oh-my-agent 0.1.1-rc.1

package/dist/core/tools/agent-fs-like.d.ts

@@ -0,0 +1,15 @@
+/** Virtual filesystem interface for agent tools. */
+export interface AgentFsLike {
+    read(path: string): Promise<string | null>;
+    write(path: string, content: string): Promise<void>;
+    list(path: string): Promise<string[]>;
+    stat(path: string): Promise<{
+        mtimeMs: number;
+        size: number;
+    } | null>;
+    exists(path: string): Promise<boolean>;
+    mkdirp(path: string): Promise<void>;
+}
+/** Join path segments with "/", collapsing duplicate slashes. */
+export declare function pjoin(...segments: string[]): string;
+//# sourceMappingURL=agent-fs-like.d.ts.map

package/dist/core/tools/agent-fs-like.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"agent-fs-like.d.ts","sourceRoot":"","sources":["../../../src/core/tools/agent-fs-like.ts"],"names":[],"mappings":"AAAA,oDAAoD;AACpD,MAAM,WAAW,WAAW;IAC1B,IAAI,CAAC,IAAI,EAAE,MAAM,GAAG,OAAO,CAAC,MAAM,GAAG,IAAI,CAAC,CAAC;IAC3C,KAAK,CAAC,IAAI,EAAE,MAAM,EAAE,OAAO,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC,CAAC;IACpD,IAAI,CAAC,IAAI,EAAE,MAAM,GAAG,OAAO,CAAC,MAAM,EAAE,CAAC,CAAC;IACtC,IAAI,CAAC,IAAI,EAAE,MAAM,GAAG,OAAO,CAAC;QAAE,OAAO,EAAE,MAAM,CAAC;QAAC,IAAI,EAAE,MAAM,CAAA;KAAE,GAAG,IAAI,CAAC,CAAC;IACtE,MAAM,CAAC,IAAI,EAAE,MAAM,GAAG,OAAO,CAAC,OAAO,CAAC,CAAC;IACvC,MAAM,CAAC,IAAI,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC,CAAC;CACrC;AAED,iEAAiE;AACjE,wBAAgB,KAAK,CAAC,GAAG,QAAQ,EAAE,MAAM,EAAE,GAAG,MAAM,CAEnD"}

package/dist/core/tools/agent-fs-like.js

@@ -0,0 +1,4 @@
+/** Join path segments with "/", collapsing duplicate slashes. */
+export function pjoin(...segments) {
+    return segments.join("/").replace(/\/+/g, "/").replace(/\/$/, "") || "/";
+}

package/dist/core/tools/ask-question.d.ts

@@ -0,0 +1,5 @@
+import type { PluginTool } from "../agent-runtime.js";
+/** Native ask_question tool (oh-my-pi style). Executes through the HITL ask
+ *  pipeline (`options.ask`); absent pipeline = fail closed. */
+export declare function createAskQuestionTool(): PluginTool;
+//# sourceMappingURL=ask-question.d.ts.map

package/dist/core/tools/ask-question.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ask-question.d.ts","sourceRoot":"","sources":["../../../src/core/tools/ask-question.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,qBAAqB,CAAC;AAyBtD;+DAC+D;AAC/D,wBAAgB,qBAAqB,IAAI,UAAU,CA8BlD"}

package/dist/core/tools/ask-question.js

@@ -0,0 +1,51 @@
+function normalizeInput(args) {
+    const raw = args.questions;
+    if (!Array.isArray(raw) || raw.length === 0)
+        return { error: "questions must be a non-empty array" };
+    const questions = [];
+    for (const q of raw) {
+        if (typeof q !== "object" || q === null)
+            return { error: "each question must be an object" };
+        const item = q;
+        if (typeof item.id !== "string" || typeof item.question !== "string") {
+            return { error: "each question needs string id and question" };
+        }
+        const kind = item.kind === "text" ? "text" : "select";
+        if (kind === "select") {
+            const options = Array.isArray(item.options) ? item.options : [];
+            if (options.length === 0)
+                return { error: `question ${item.id}: select needs options` };
+        }
+        questions.push(item);
+    }
+    return { questions };
+}
+/** Native ask_question tool (oh-my-pi style). Executes through the HITL ask
+ *  pipeline (`options.ask`); absent pipeline = fail closed. */
+export function createAskQuestionTool() {
+    return {
+        name: "ask_question",
+        description: "Ask the user structured questions and wait for answers. Questions are select (options, optional multi/recommended/other) or text (free input). Returns {answers:[{id,selectedValues,freeText}]}.",
+        inputSchema: {
+            type: "object",
+            properties: {
+                questions: {
+                    type: "array",
+                    items: { type: "object" },
+                },
+            },
+            required: ["questions"],
+        },
+        async execute(args, _signal, options) {
+            const normalized = normalizeInput(args);
+            if ("error" in normalized)
+                return normalized;
+            if (!options?.ask)
+                return { error: "no ask pipeline configured" };
+            const result = await options.ask(normalized);
+            if (!result)
+                return { error: "ask pipeline returned no answer" };
+            return result;
+        },
+    };
+}

package/dist/core/tools/bash.d.ts

@@ -0,0 +1,5 @@
+import type { Tool } from "@chengchenccc/message";
+export declare function createBashTool(opts: {
+    workspaceRoot: string;
+}): Tool;
+//# sourceMappingURL=bash.d.ts.map

package/dist/core/tools/bash.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"bash.d.ts","sourceRoot":"","sources":["../../../src/core/tools/bash.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,IAAI,EAAE,MAAM,uBAAuB,CAAC;AAwBlD,wBAAgB,cAAc,CAAC,IAAI,EAAE;IAAE,aAAa,EAAE,MAAM,CAAA;CAAE,GAAG,IAAI,CAqGpE"}

package/dist/core/tools/bash.js

@@ -0,0 +1,109 @@
+import { WorkspaceSandbox } from "./workspace-sandbox.js";
+const descriptionParam = {
+    type: "string",
+    description: "Must be the first parameter. A short human-readable summary explaining why this command is being run.",
+};
+function envMs(name, fallback) {
+    const raw = process.env[name];
+    if (raw === undefined)
+        return fallback;
+    const n = Number(raw);
+    return Number.isFinite(n) ? n : fallback;
+}
+function defaultBashTimeoutMs() {
+    return envMs("OMA_BASH_TIMEOUT_MS", 30_000);
+}
+function maxToolTimeoutMs() {
+    return envMs("OMA_MAX_TOOL_TIMEOUT_MS", 0);
+}
+export function createBashTool(opts) {
+    const sandbox = new WorkspaceSandbox(opts.workspaceRoot);
+    return {
+        name: "bash",
+        description: "Execute a bash shell command. Returns exit code, stdout, and stderr. Default timeout 30s, max 600s.",
+        inputSchema: {
+            type: "object",
+            properties: {
+                description: descriptionParam,
+                command: {
+                    type: "string",
+                    description: "The shell command to execute",
+                },
+                timeout: {
+                    type: "number",
+                    description: "Timeout in milliseconds (default 30000, max 600000)",
+                },
+                cwd: {
+                    type: "string",
+                    description: "Working directory (relative to workspace root)",
+                },
+            },
+            required: ["description", "command"],
+        },
+        async execute(input, signal, options) {
+            const { command, timeout = defaultBashTimeoutMs(), cwd, } = input;
+            // Validate cwd against the fixed workspace sandbox. Out-of-bounds cwd
+            // is a tool error, never a silent fallback to process cwd.
+            let validatedCwd = opts.workspaceRoot;
+            if (cwd) {
+                try {
+                    validatedCwd = sandbox.validateCwd(cwd);
+                }
+                catch {
+                    return {
+                        content: `Error: cwd escapes workspace root: ${String(cwd)}`,
+                        isError: true,
+                    };
+                }
+            }
+            const upper = maxToolTimeoutMs();
+            const cap = upper > 0 ? Math.min(upper, 600_000) : 600_000;
+            const clamped = Math.min(Math.max(timeout, 1), cap);
+            const hasSetsid = Bun.which("setsid") !== null;
+            const proc = Bun.spawn(hasSetsid ? ["setsid", "bash", "-c", command] : ["bash", "-c", command], { stdout: "pipe", stderr: "pipe", cwd: validatedCwd });
+            // Kill the process group on timeout OR abort signal.
+            const killGroup = () => {
+                proc.kill();
+                try {
+                    process.kill(-proc.pid, "SIGKILL");
+                }
+                catch {
+                    /* */
+                }
+            };
+            const timer = setTimeout(killGroup, clamped);
+            const onAbort = () => killGroup();
+            if (signal?.aborted)
+                killGroup();
+            signal?.addEventListener("abort", onAbort, { once: true });
+            try {
+                const stderrPromise = new Response(proc.stderr).text();
+                let stdout = "";
+                if (options?.onOutput) {
+                    const reader = proc.stdout.getReader();
+                    for (;;) {
+                        const { done, value } = await reader.read();
+                        if (done)
+                            break;
+                        const chunk = new TextDecoder().decode(value);
+                        stdout += chunk;
+                        options.onOutput(chunk);
+                    }
+                }
+                else {
+                    stdout = await new Response(proc.stdout).text();
+                }
+                const stderr = await stderrPromise;
+                const exitCode = await proc.exited;
+                return {
+                    content: `${stdout}\n[exit: ${exitCode}]${stderr ? `\n${stderr}` : ""}`,
+                    isError: exitCode !== 0,
+                };
+            }
+            finally {
+                clearTimeout(timer);
+                signal?.removeEventListener("abort", onAbort);
+            }
+        },
+    };
+}

package/dist/core/tools/eval.d.ts

@@ -0,0 +1,10 @@
+import type { Tool } from "@chengchenccc/message";
+/** eval: run a TS/JS snippet in a process sandbox (spawned bun subprocess,
+ *  minimal env, hard timeout). The snippet must `export default (ctx) => out`
+ *  where ctx is the JSON `input` object. Output is the returned value; stdout
+ *  and stderr are reported alongside. Files written next to the script live
+ *  only for the run unless keepWorkspace is set (cwd = workspace eval dir). */
+export declare function createEvalTool(_opts: {
+    workspaceRoot: string;
+}): Tool;
+//# sourceMappingURL=eval.d.ts.map

package/dist/core/tools/eval.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"eval.d.ts","sourceRoot":"","sources":["../../../src/core/tools/eval.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,IAAI,EAAE,MAAM,uBAAuB,CAAC;AAgBlD;;;;+EAI+E;AAC/E,wBAAgB,cAAc,CAAC,KAAK,EAAE;IAAE,aAAa,EAAE,MAAM,CAAA;CAAE,GAAG,IAAI,CAuErE"}

package/dist/core/tools/eval.js

@@ -0,0 +1,83 @@
+import { runInSandbox } from "@chengchenccc/sandbox";
+const descriptionParam = {
+    type: "string",
+    description: "Must be the first parameter. A short human-readable summary explaining what this code evaluates.",
+};
+function envMs(name, fallback) {
+    const raw = process.env[name];
+    if (raw === undefined)
+        return fallback;
+    const n = Number(raw);
+    return Number.isFinite(n) ? n : fallback;
+}
+/** eval: run a TS/JS snippet in a process sandbox (spawned bun subprocess,
+ *  minimal env, hard timeout). The snippet must `export default (ctx) => out`
+ *  where ctx is the JSON `input` object. Output is the returned value; stdout
+ *  and stderr are reported alongside. Files written next to the script live
+ *  only for the run unless keepWorkspace is set (cwd = workspace eval dir). */
+export function createEvalTool(_opts) {
+    return {
+        name: "eval",
+        description: "Evaluate a TypeScript/JavaScript snippet in an isolated sandbox process. The code must `export default async (ctx) => result` — ctx is the provided input object and result must be JSON-serializable. Use for computations, data shaping, and quick experiments instead of bash one-liners.",
+        inputSchema: {
+            type: "object",
+            properties: {
+                description: descriptionParam,
+                code: {
+                    type: "string",
+                    description: "TS/JS module source. Must `export default async (ctx) => result`.",
+                },
+                input: {
+                    type: "object",
+                    description: "JSON object passed to the snippet as ctx",
+                    additionalProperties: true,
+                },
+                timeout: {
+                    type: "number",
+                    description: "Timeout in milliseconds (default 30000)",
+                },
+                keepWorkspace: {
+                    type: "boolean",
+                    description: "Keep the sandbox working dir across this session (default false)",
+                },
+            },
+            required: ["description", "code"],
+        },
+        async execute(input, signal) {
+            const { code, input: ctxInput, timeout = envMs("OMA_EVAL_TIMEOUT_MS", 30_000), keepWorkspace = false, } = input;
+            if (typeof code !== "string" || code.trim() === "") {
+                return { content: "eval requires non-empty code", isError: true };
+            }
+            if (signal?.aborted)
+                return { content: "aborted", isError: true };
+            try {
+                const r = await runInSandbox({
+                    code,
+                    input: ctxInput ?? {},
+                    timeoutMs: timeout,
+                    keepCwd: keepWorkspace,
+                });
+                const parts = [];
+                if (r.output !== null)
+                    parts.push(JSON.stringify(r.output, null, 2));
+                if (r.stdout.trim())
+                    parts.push(`stdout:\n${r.stdout.trim()}`);
+                if (r.stderr.trim())
+                    parts.push(`stderr:\n${r.stderr.trim()}`);
+                const ok = r.exitCode === 0;
+                return {
+                    content: ok
+                        ? parts.join("\n\n") || "(no output)"
+                        : `eval failed (exit ${r.exitCode}):\n${parts.join("\n\n")}`,
+                    isError: !ok,
+                };
+            }
+            catch (err) {
+                return {
+                    content: `eval error: ${err instanceof Error ? err.message : String(err)}`,
+                    isError: true,
+                };
+            }
+        },
+    };
+}

package/dist/core/tools/file-tools.d.ts

@@ -0,0 +1,18 @@
+import type { Tool } from "@chengchenccc/message";
+/** Simple cwd-based default - tools resolve relative paths against this. */
+export declare function withDefaultCwd(tool: Tool, cwd: string): Tool;
+/** Resolve a path against a fixed workspace root using realpath containment. */
+export declare function resolveWorkspacePath(root: string, userPath: string): string | null;
+/** Create a read-file tool scoped to a cwd. */
+export declare function createReadTool(opts: {
+    cwd: string;
+}): Tool;
+/** Create a write-file tool scoped to a cwd. */
+export declare function createWriteTool(opts: {
+    cwd: string;
+}): Tool;
+/** Create an edit-file tool scoped to a cwd. */
+export declare function createEditTool(opts: {
+    cwd: string;
+}): Tool;
+//# sourceMappingURL=file-tools.d.ts.map

package/dist/core/tools/file-tools.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"file-tools.d.ts","sourceRoot":"","sources":["../../../src/core/tools/file-tools.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,IAAI,EAAE,MAAM,uBAAuB,CAAC;AAKlD,4EAA4E;AAC5E,wBAAgB,cAAc,CAAC,IAAI,EAAE,IAAI,EAAE,GAAG,EAAE,MAAM,GAAG,IAAI,CAQ5D;AAkBD,gFAAgF;AAChF,wBAAgB,oBAAoB,CAAC,IAAI,EAAE,MAAM,EAAE,QAAQ,EAAE,MAAM,GAAG,MAAM,GAAG,IAAI,CAMlF;AAuBD,+CAA+C;AAC/C,wBAAgB,cAAc,CAAC,IAAI,EAAE;IAAE,GAAG,EAAE,MAAM,CAAA;CAAE,GAAG,IAAI,CAyE1D;AAID,gDAAgD;AAChD,wBAAgB,eAAe,CAAC,IAAI,EAAE;IAAE,GAAG,EAAE,MAAM,CAAA;CAAE,GAAG,IAAI,CAsC3D;AAID,gDAAgD;AAChD,wBAAgB,cAAc,CAAC,IAAI,EAAE;IAAE,GAAG,EAAE,MAAM,CAAA;CAAE,GAAG,IAAI,CA4E1D"}

package/dist/core/tools/file-tools.js

@@ -0,0 +1,249 @@
+import { existsSync, mkdirSync, readFileSync, statSync, writeFileSync } from "node:fs";
+import { extname, resolve } from "node:path";
+import { WorkspaceSandbox } from "./workspace-sandbox.js";
+/** Simple cwd-based default - tools resolve relative paths against this. */
+export function withDefaultCwd(tool, cwd) {
+    return {
+        ...tool,
+        execute: async (input, signal) => {
+            const rec = input;
+            return tool.execute({ ...rec, cwd: rec.cwd ?? cwd }, signal);
+        },
+    };
+}
+function safePath(cwd, userPath) {
+    try {
+        const sandbox = new WorkspaceSandbox(cwd);
+        return sandbox.validate(userPath);
+    }
+    catch {
+        return null;
+    }
+}
+function safePathNew(cwd, userPath) {
+    try {
+        const sandbox = new WorkspaceSandbox(cwd);
+        return sandbox.validateNew(userPath);
+    }
+    catch {
+        return null;
+    }
+}
+/** Resolve a path against a fixed workspace root using realpath containment. */
+export function resolveWorkspacePath(root, userPath) {
+    try {
+        return new WorkspaceSandbox(root).validate(userPath);
+    }
+    catch {
+        return null;
+    }
+}
+const IMAGE_EXTENSIONS = new Set([
+    ".png",
+    ".jpg",
+    ".jpeg",
+    ".gif",
+    ".webp",
+    ".bmp",
+    ".svg",
+    ".ico",
+]);
+const READ_MAX_SIZE_BYTES = 256 * 1024;
+/** Shared "description" parameter - forces the model to explain its intent before each tool call. */
+const descriptionParam = {
+    type: "string",
+    description: "Must be the first parameter. A short human-readable summary explaining why this tool is being called.",
+};
+// ─── read ──────────────────────────────────────────────────────
+/** Create a read-file tool scoped to a cwd. */
+export function createReadTool(opts) {
+    const { cwd } = opts;
+    return {
+        name: "read",
+        description: "Read a file from the workspace. Returns file contents with line numbers (line\\tcontent). " +
+            "For images, returns a placeholder with file size. Output capped at 256KB; use offset/limit for large files.",
+        inputSchema: {
+            type: "object",
+            properties: {
+                description: descriptionParam,
+                path: {
+                    type: "string",
+                    description: "Path to the file to read, relative to workspace root",
+                },
+                offset: {
+                    type: "number",
+                    description: "1-based line number to start reading from. Defaults to 1.",
+                },
+                limit: {
+                    type: "number",
+                    description: "Maximum number of lines to read from offset.",
+                },
+            },
+            required: ["path"],
+        },
+        async execute(input) {
+            const rec = input;
+            const full = safePath(cwd, String(rec.path ?? ""));
+            if (!full)
+                return { content: "Error: path escapes workspace", isError: true };
+            try {
+                const stat = statSync(full);
+                if (stat.isDirectory()) {
+                    return { content: `Error: ${rec.path} is a directory, not a file.`, isError: true };
+                }
+                if (IMAGE_EXTENSIONS.has(extname(full).toLowerCase())) {
+                    return { content: `[image file: ${rec.path} (${stat.size} bytes)]` };
+                }
+                const content = readFileSync(full, "utf-8");
+                const lines = content.split("\n");
+                const offset = typeof rec.offset === "number" ? rec.offset : undefined;
+                const limit = typeof rec.limit === "number" ? rec.limit : undefined;
+                const start = offset && offset > 1 ? offset - 1 : 0;
+                const end = limit !== undefined ? start + Math.max(0, limit) : lines.length;
+                const selected = lines.slice(start, Math.max(start, end));
+                const out = [];
+                let bytes = 0;
+                let truncated = false;
+                for (let i = 0; i < selected.length; i++) {
+                    const rendered = `${start + i + 1}\t${selected[i]}`;
+                    const size = Buffer.byteLength(rendered, "utf8") + 1;
+                    if (out.length > 0 && bytes + size > READ_MAX_SIZE_BYTES) {
+                        truncated = true;
+                        break;
+                    }
+                    bytes += size;
+                    out.push(rendered);
+                }
+                let result = out.join("\n");
+                if (truncated) {
+                    result += `\n... [truncated at ${READ_MAX_SIZE_BYTES} bytes; pass offset/limit to read a specific range]`;
+                }
+                return { content: result };
+            }
+            catch (err) {
+                return {
+                    content: `Error reading file: ${err instanceof Error ? err.message : err}`,
+                    isError: true,
+                };
+            }
+        },
+    };
+}
+// ─── write ─────────────────────────────────────────────────────
+/** Create a write-file tool scoped to a cwd. */
+export function createWriteTool(opts) {
+    const { cwd } = opts;
+    return {
+        name: "write",
+        description: "Write content to a file in the workspace. Creates parent directories if needed. Overwrites if file exists.",
+        inputSchema: {
+            type: "object",
+            properties: {
+                description: descriptionParam,
+                path: {
+                    type: "string",
+                    description: "Path to the file to write, relative to workspace root",
+                },
+                content: {
+                    type: "string",
+                    description: "Content to write to the file",
+                },
+            },
+            required: ["path", "content"],
+        },
+        async execute(input) {
+            const rec = input;
+            const full = safePathNew(cwd, String(rec.path ?? ""));
+            if (!full)
+                return { content: "Error: path escapes workspace", isError: true };
+            try {
+                mkdirSync(resolve(full, ".."), { recursive: true });
+                const content = String(rec.content ?? "");
+                writeFileSync(full, content, "utf-8");
+                return { content: `Wrote ${Buffer.byteLength(content, "utf8")} bytes to ${rec.path}` };
+            }
+            catch (err) {
+                return {
+                    content: `Error writing file: ${err instanceof Error ? err.message : err}`,
+                    isError: true,
+                };
+            }
+        },
+    };
+}
+// ─── edit ──────────────────────────────────────────────────────
+/** Create an edit-file tool scoped to a cwd. */
+export function createEditTool(opts) {
+    const { cwd } = opts;
+    return {
+        name: "edit",
+        description: "Perform exact string replacement in a file. old_string must match exactly and be unique " +
+            "unless replace_all is set. Use for surgical edits; prefer write for full replacement.",
+        inputSchema: {
+            type: "object",
+            properties: {
+                description: descriptionParam,
+                path: {
+                    type: "string",
+                    description: "Path to the file to edit, relative to workspace root",
+                },
+                old_string: {
+                    type: "string",
+                    description: "The exact text to replace (must be unique unless replace_all is true)",
+                },
+                new_string: {
+                    type: "string",
+                    description: "The replacement text (must differ from old_string)",
+                },
+                replace_all: {
+                    type: "boolean",
+                    description: "Replace all occurrences. Defaults to false (first match only).",
+                },
+            },
+            required: ["path", "old_string", "new_string"],
+        },
+        async execute(input) {
+            const rec = input;
+            const full = safePath(cwd, String(rec.path ?? ""));
+            if (!full)
+                return { content: "Error: path escapes workspace", isError: true };
+            try {
+                if (!existsSync(full)) {
+                    return { content: `Error: file not found: ${rec.path}`, isError: true };
+                }
+                const oldStr = String(rec.old_string ?? "");
+                const newStr = String(rec.new_string ?? "");
+                const replaceAll = rec.replace_all === true;
+                if (oldStr === newStr) {
+                    return { content: "Error: new_string must differ from old_string.", isError: true };
+                }
+                const content = readFileSync(full, "utf-8");
+                const occurrences = content.split(oldStr).length - 1;
+                if (occurrences === 0) {
+                    return {
+                        content: "Error: old_string not found in file. The file may have changed since you last read it.",
+                        isError: true,
+                    };
+                }
+                if (!replaceAll && occurrences > 1) {
+                    return {
+                        content: `Error: old_string is not unique (${occurrences} matches). Provide a larger unique string or set replace_all.`,
+                        isError: true,
+                    };
+                }
+                const newContent = replaceAll
+                    ? content.split(oldStr).join(newStr)
+                    : content.replace(oldStr, newStr);
+                writeFileSync(full, newContent, "utf-8");
+                const count = replaceAll ? occurrences : 1;
+                return { content: `Replaced ${count} occurrence${count === 1 ? "" : "s"} in ${rec.path}` };
+            }
+            catch (err) {
+                return {
+                    content: `Error editing file: ${err instanceof Error ? err.message : err}`,
+                    isError: true,
+                };
+            }
+        },
+    };
+}

package/dist/core/tools/glob.d.ts

@@ -0,0 +1,5 @@
+import type { Tool } from "@chengchenccc/message";
+export declare function createGlobTool(opts: {
+    workspaceRoot: string;
+}): Tool;
+//# sourceMappingURL=glob.d.ts.map

package/dist/core/tools/glob.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"glob.d.ts","sourceRoot":"","sources":["../../../src/core/tools/glob.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,IAAI,EAAE,MAAM,uBAAuB,CAAC;AASlD,wBAAgB,cAAc,CAAC,IAAI,EAAE;IAAE,aAAa,EAAE,MAAM,CAAA;CAAE,GAAG,IAAI,CAkDpE"}

package/dist/core/tools/glob.js

@@ -0,0 +1,54 @@
+import { WorkspaceSandbox } from "./workspace-sandbox.js";
+const descriptionParam = {
+    type: "string",
+    description: "Must be the first parameter. A short human-readable summary explaining why this search is being performed.",
+};
+export function createGlobTool(opts) {
+    const sandbox = new WorkspaceSandbox(opts.workspaceRoot);
+    return {
+        name: "glob",
+        description: "Find files matching a glob pattern. Returns newline-separated paths. Results are capped at 500.",
+        inputSchema: {
+            type: "object",
+            properties: {
+                description: descriptionParam,
+                pattern: { type: "string", description: "The glob pattern to match (e.g. '**/*.ts')" },
+                cwd: {
+                    type: "string",
+                    description: "Subdirectory to search from (relative to workspace root)",
+                },
+            },
+            required: ["pattern"],
+        },
+        async execute(input) {
+            const { pattern, cwd } = input;
+            let validatedCwd = opts.workspaceRoot;
+            if (cwd) {
+                try {
+                    validatedCwd = sandbox.validateCwd(cwd);
+                }
+                catch {
+                    return {
+                        content: `Error: cwd escapes workspace root: ${String(cwd)}`,
+                        isError: true,
+                    };
+                }
+            }
+            const LIMIT = 500;
+            const glob = new Bun.Glob(pattern);
+            const matches = [];
+            let truncated = false;
+            for await (const m of glob.scan({ cwd: validatedCwd, absolute: false, onlyFiles: true })) {
+                if (matches.length >= LIMIT) {
+                    truncated = true;
+                    break;
+                }
+                matches.push(m);
+            }
+            if (matches.length === 0)
+                return { content: "(no matches)" };
+            const body = matches.join("\n");
+            return { content: truncated ? `${body}\n... (truncated at ${LIMIT})` : body };
+        },
+    };
+}

package/dist/core/tools/grep.d.ts

@@ -0,0 +1,5 @@
+import type { Tool } from "@chengchenccc/message";
+export declare function createGrepTool(opts: {
+    workspaceRoot: string;
+}): Tool;
+//# sourceMappingURL=grep.d.ts.map

package/dist/core/tools/grep.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"grep.d.ts","sourceRoot":"","sources":["../../../src/core/tools/grep.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,IAAI,EAAE,MAAM,uBAAuB,CAAC;AASlD,wBAAgB,cAAc,CAAC,IAAI,EAAE;IAAE,aAAa,EAAE,MAAM,CAAA;CAAE,GAAG,IAAI,CAkEpE"}