agentool 0.0.1 → 1.1.0

package/dist/chunk-ONBH74ZV.cjs

@@ -0,0 +1,90 @@
+"use strict";Object.defineProperty(exports, "__esModule", {value: true}); function _nullishCoalesce(lhs, rhsFn) { if (lhs != null) { return lhs; } else { return rhsFn(); } } function _optionalChain(ops) { let lastAccessLHS = undefined; let value = ops[0]; let i = 1; while (i < ops.length) { const op = ops[i]; const fn = ops[i + 1]; i += 2; if ((op === 'optionalAccess' || op === 'optionalCall') && value == null) { return undefined; } if (op === 'access' || op === 'optionalAccess') { lastAccessLHS = value; value = fn(value); } else if (op === 'call' || op === 'optionalCall') { value = fn((...args) => value.call(lastAccessLHS, ...args)); lastAccessLHS = undefined; } } return value; }
+
+var _chunkQZ5GS6HWcjs = require('./chunk-QZ5GS6HW.cjs');
+
+// src/diff/index.ts
+var _promises = require('fs/promises');
+var _ai = require('ai');
+var _zod = require('zod');
+
+// src/shared/diff.ts
+
+var _diff = require('diff');
+function diffStrings(oldContent, newContent, options) {
+  if (oldContent === newContent) {
+    return "No differences found.";
+  }
+  const context = _nullishCoalesce(_optionalChain([options, 'optionalAccess', _ => _.context]), () => ( 3));
+  const oldLabel = _nullishCoalesce(_optionalChain([options, 'optionalAccess', _2 => _2.oldLabel]), () => ( "a"));
+  const newLabel = _nullishCoalesce(_optionalChain([options, 'optionalAccess', _3 => _3.newLabel]), () => ( "b"));
+  return _diff.createTwoFilesPatch.call(void 0, 
+    oldLabel,
+    newLabel,
+    oldContent,
+    newContent,
+    void 0,
+    void 0,
+    { context }
+  );
+}
+async function diffFiles(oldFilePath, newFilePath, options) {
+  const [oldContent, newContent] = await Promise.all([
+    _promises.readFile.call(void 0, oldFilePath, "utf-8"),
+    _promises.readFile.call(void 0, newFilePath, "utf-8")
+  ]);
+  return diffStrings(oldContent, newContent, {
+    ...options,
+    oldLabel: oldFilePath,
+    newLabel: newFilePath
+  });
+}
+
+// src/diff/index.ts
+function createDiff(config = {}) {
+  const cwd = _nullishCoalesce(config.cwd, () => ( process.cwd()));
+  return _ai.tool.call(void 0, {
+    description: "Generate a unified diff between two files or two strings. Provide file_path + other_file_path to compare files, or old_content + new_content to compare strings. You can also provide file_path with old_content or new_content to compare a file against provided content.",
+    inputSchema: _zod.z.object({
+      file_path: _zod.z.string().optional().describe("Path to the first file (absolute or relative to cwd)"),
+      other_file_path: _zod.z.string().optional().describe("Path to the second file (absolute or relative to cwd)"),
+      old_content: _zod.z.string().optional().describe("The original content string"),
+      new_content: _zod.z.string().optional().describe("The modified content string")
+    }),
+    execute: async ({ file_path, other_file_path, old_content, new_content }) => {
+      try {
+        if (file_path && other_file_path) {
+          const resolvedOld = _chunkQZ5GS6HWcjs.expandPath.call(void 0, file_path, cwd);
+          const resolvedNew = _chunkQZ5GS6HWcjs.expandPath.call(void 0, other_file_path, cwd);
+          return await diffFiles(resolvedOld, resolvedNew);
+        }
+        if (old_content !== void 0 && new_content !== void 0 && !file_path) {
+          return diffStrings(old_content, new_content);
+        }
+        if (file_path && (old_content !== void 0 || new_content !== void 0)) {
+          const resolvedPath = _chunkQZ5GS6HWcjs.expandPath.call(void 0, file_path, cwd);
+          const fileContent = await _promises.readFile.call(void 0, resolvedPath, "utf-8");
+          if (old_content !== void 0) {
+            return diffStrings(old_content, fileContent, {
+              oldLabel: "provided",
+              newLabel: resolvedPath
+            });
+          }
+          return diffStrings(fileContent, new_content, {
+            oldLabel: resolvedPath,
+            newLabel: "provided"
+          });
+        }
+        return "Error [diff]: Insufficient parameters. Provide either: (1) file_path + other_file_path, (2) old_content + new_content, or (3) file_path + old_content/new_content.";
+      } catch (error) {
+        const msg = error instanceof Error ? error.message : String(error);
+        return `Error [diff]: ${msg}`;
+      }
+    }
+  });
+}
+var diff = createDiff();
+
+
+
+
+exports.createDiff = createDiff; exports.diff = diff;

package/dist/chunk-OXLQ7QVL.cjs

@@ -0,0 +1,40 @@
+"use strict";Object.defineProperty(exports, "__esModule", {value: true}); function _nullishCoalesce(lhs, rhsFn) { if (lhs != null) { return lhs; } else { return rhsFn(); } }// src/sleep/index.ts
+var _ai = require('ai');
+var _zod = require('zod');
+function createSleep(config = {}) {
+  const maxDuration = _nullishCoalesce(config.maxDuration, () => ( 3e5));
+  return _ai.tool.call(void 0, {
+    description: "Pause execution for a specified duration. Useful for rate limiting, polling intervals, or waiting for external processes. Maximum duration is 300 seconds (5 minutes).",
+    inputSchema: _ai.zodSchema.call(void 0, 
+      _zod.z.object({
+        durationMs: _zod.z.number().describe("Duration to sleep in milliseconds"),
+        reason: _zod.z.string().optional().describe("Optional reason for the sleep")
+      })
+    ),
+    execute: async ({ durationMs, reason }) => {
+      try {
+        const clamped = Math.max(0, Math.min(durationMs, maxDuration));
+        const start = Date.now();
+        await new Promise((resolve) => setTimeout(resolve, clamped));
+        const elapsed = Date.now() - start;
+        const parts = [`Slept for ${elapsed}ms`];
+        if (reason) parts.push(`Reason: ${reason}`);
+        if (clamped !== durationMs) {
+          parts.push(
+            `(clamped from ${durationMs}ms to ${clamped}ms, max: ${maxDuration}ms)`
+          );
+        }
+        return parts.join(". ");
+      } catch (error) {
+        const message = error instanceof Error ? error.message : String(error);
+        return `Sleep failed: ${message}`;
+      }
+    }
+  });
+}
+var sleep = createSleep();
+
+
+
+
+exports.createSleep = createSleep; exports.sleep = sleep;

package/dist/chunk-P6Z5XFDS.js

@@ -0,0 +1,73 @@
+import {
+  applyEditToFile,
+  findActualString,
+  preserveQuoteStyle
+} from "./chunk-G3ITTPGX.js";
+import {
+  expandPath
+} from "./chunk-I3ONDY7P.js";
+
+// src/edit/index.ts
+import { readFile, writeFile } from "fs/promises";
+import { tool } from "ai";
+import { z } from "zod";
+function createEdit(config = {}) {
+  return tool({
+    description: "Perform an exact string replacement in a file. Locates old_string in the file and replaces it with new_string. Supports curly-quote fallback matching. When replace_all is false (default), old_string must appear exactly once.",
+    inputSchema: z.object({
+      file_path: z.string().describe("The absolute path to the file to modify"),
+      old_string: z.string().describe("The exact string to find and replace"),
+      new_string: z.string().describe("The replacement string"),
+      replace_all: z.boolean().default(false).optional().describe("Replace all occurrences (default: false)")
+    }),
+    execute: async ({ file_path, old_string, new_string, replace_all }) => {
+      try {
+        const resolved = expandPath(file_path, config.cwd);
+        let content;
+        try {
+          content = await readFile(resolved, "utf-8");
+        } catch (err) {
+          const msg = err instanceof Error ? err.message : String(err);
+          return `Error [edit]: Cannot read file "${resolved}": ${msg}`;
+        }
+        if (old_string === new_string) {
+          return "Error [edit]: old_string and new_string are identical \u2014 nothing to change.";
+        }
+        const actualOld = findActualString(content, old_string);
+        if (actualOld === null) {
+          const preview = content.slice(0, 200);
+          return `Error [edit]: old_string not found in "${resolved}". File starts with:
+${preview}`;
+        }
+        if (!replace_all) {
+          let count = 0;
+          let pos = 0;
+          while (pos < content.length) {
+            const idx = content.indexOf(actualOld, pos);
+            if (idx === -1) break;
+            count++;
+            pos = idx + 1;
+          }
+          if (count > 1) {
+            return `Error [edit]: old_string appears ${count} times in "${resolved}". Use replace_all to replace every occurrence, or provide a more specific string.`;
+          }
+        }
+        const styledNew = preserveQuoteStyle(old_string, actualOld, new_string);
+        const updated = applyEditToFile(content, actualOld, styledNew, replace_all);
+        await writeFile(resolved, updated, "utf-8");
+        const snippet = styledNew.length > 0 ? styledNew.slice(0, 200) : "(deletion)";
+        return `Successfully edited "${resolved}". Replacement snippet:
+${snippet}`;
+      } catch (error) {
+        const msg = error instanceof Error ? error.message : String(error);
+        return `Error [edit]: ${msg}`;
+      }
+    }
+  });
+}
+var edit = createEdit();
+
+export {
+  createEdit,
+  edit
+};

package/dist/chunk-QZ5GS6HW.cjs

@@ -0,0 +1,46 @@
+"use strict";Object.defineProperty(exports, "__esModule", {value: true}); function _nullishCoalesce(lhs, rhsFn) { if (lhs != null) { return lhs; } else { return rhsFn(); } }// src/shared/path.ts
+var _os = require('os');
+var _path = require('path');
+function expandPath(inputPath, baseDir) {
+  const actualBaseDir = _nullishCoalesce(baseDir, () => ( process.cwd()));
+  if (typeof inputPath !== "string") {
+    throw new TypeError(
+      `Path must be a string, received ${typeof inputPath}`
+    );
+  }
+  if (typeof actualBaseDir !== "string") {
+    throw new TypeError(
+      `Base directory must be a string, received ${typeof actualBaseDir}`
+    );
+  }
+  if (inputPath.includes("\0") || actualBaseDir.includes("\0")) {
+    throw new Error("Path contains null bytes");
+  }
+  const trimmed = inputPath.trim();
+  if (!trimmed) {
+    return _path.normalize.call(void 0, actualBaseDir);
+  }
+  if (trimmed === "~") {
+    return _os.homedir.call(void 0, );
+  }
+  if (trimmed.startsWith("~/")) {
+    return _path.join.call(void 0, _os.homedir.call(void 0, ), trimmed.slice(2));
+  }
+  if (_path.isAbsolute.call(void 0, trimmed)) {
+    return _path.normalize.call(void 0, trimmed);
+  }
+  return _path.resolve.call(void 0, actualBaseDir, trimmed);
+}
+function toRelativePath(absolutePath, baseDir) {
+  const rel = _path.relative.call(void 0, _nullishCoalesce(baseDir, () => ( process.cwd())), absolutePath);
+  return rel.startsWith("..") ? absolutePath : rel;
+}
+function containsPathTraversal(inputPath) {
+  return /(?:^|[\\/])\.\.(?:[\\/]|$)/.test(inputPath);
+}
+
+
+
+
+
+exports.expandPath = expandPath; exports.toRelativePath = toRelativePath; exports.containsPathTraversal = containsPathTraversal;

package/dist/chunk-S7IVHOA6.js

@@ -0,0 +1,75 @@
+import {
+  formatTask,
+  loadTasks,
+  saveTasks
+} from "./chunk-E6NBEYZD.js";
+
+// src/task-update/index.ts
+import { tool } from "ai";
+import { z } from "zod";
+import { join } from "path";
+function createTaskUpdate(config = {}) {
+  const cwd = config.cwd ?? process.cwd();
+  const tasksFile = config.tasksFile ?? join(cwd, ".agentool", "tasks.json");
+  return tool({
+    description: "Update a task by its ID. Can change status, subject, description, owner, metadata, and dependency relationships.",
+    inputSchema: z.object({
+      taskId: z.string().describe("The ID of the task to update"),
+      subject: z.string().optional().describe("New subject for the task"),
+      description: z.string().optional().describe("New description"),
+      status: z.enum(["pending", "in_progress", "completed", "deleted"]).optional().describe("New status for the task"),
+      owner: z.string().optional().describe("New owner for the task"),
+      activeForm: z.string().optional().describe("Present continuous form shown in spinner when in_progress"),
+      addBlocks: z.array(z.string()).optional().describe("Task IDs that this task blocks"),
+      addBlockedBy: z.array(z.string()).optional().describe("Task IDs that block this task"),
+      metadata: z.record(z.string(), z.unknown()).optional().describe("Metadata keys to merge. Set key to null to delete.")
+    }),
+    execute: async (input) => {
+      try {
+        const tasks = await loadTasks(tasksFile);
+        const idx = tasks.findIndex((t) => t.id === input.taskId);
+        if (idx === -1) return `Error [task-update]: Task "${input.taskId}" not found.`;
+        const entry = tasks[idx];
+        if (input.subject !== void 0) entry.subject = input.subject;
+        if (input.description !== void 0) entry.description = input.description;
+        if (input.status !== void 0) entry.status = input.status;
+        if (input.owner !== void 0) entry.owner = input.owner;
+        if (input.activeForm !== void 0) entry.activeForm = input.activeForm;
+        if (input.addBlocks) {
+          for (const id of input.addBlocks) {
+            if (!entry.blocks.includes(id)) entry.blocks.push(id);
+          }
+        }
+        if (input.addBlockedBy) {
+          for (const id of input.addBlockedBy) {
+            if (!entry.blockedBy.includes(id)) entry.blockedBy.push(id);
+          }
+        }
+        if (input.metadata) {
+          if (!entry.metadata) entry.metadata = {};
+          for (const [key, value] of Object.entries(input.metadata)) {
+            if (value === null) {
+              delete entry.metadata[key];
+            } else {
+              entry.metadata[key] = value;
+            }
+          }
+        }
+        entry.updatedAt = (/* @__PURE__ */ new Date()).toISOString();
+        tasks[idx] = entry;
+        await saveTasks(tasksFile, tasks);
+        return `Updated task ${input.taskId}.
+${formatTask(entry)}`;
+      } catch (error) {
+        const msg = error instanceof Error ? error.message : String(error);
+        return `Error [task-update]: ${msg}`;
+      }
+    }
+  });
+}
+var taskUpdate = createTaskUpdate();
+
+export {
+  createTaskUpdate,
+  taskUpdate
+};

package/dist/chunk-SUSAPI5W.cjs

@@ -0,0 +1,142 @@
+"use strict";Object.defineProperty(exports, "__esModule", {value: true}); function _nullishCoalesce(lhs, rhsFn) { if (lhs != null) { return lhs; } else { return rhsFn(); } } function _optionalChain(ops) { let lastAccessLHS = undefined; let value = ops[0]; let i = 1; while (i < ops.length) { const op = ops[i]; const fn = ops[i + 1]; i += 2; if ((op === 'optionalAccess' || op === 'optionalCall') && value == null) { return undefined; } if (op === 'access' || op === 'optionalAccess') { lastAccessLHS = value; value = fn(value); } else if (op === 'call' || op === 'optionalCall') { value = fn((...args) => value.call(lastAccessLHS, ...args)); lastAccessLHS = undefined; } } return value; }// src/bash/index.ts
+var _ai = require('ai');
+var _zod = require('zod');
+
+// src/shared/shell.ts
+var _child_process = require('child_process');
+var MAX_BUFFER_BYTES = 10 * 1024 * 1024;
+var DEFAULT_TIMEOUT_MS = 12e4;
+var SIGKILL_GRACE_MS = 5e3;
+async function executeShell(command, options) {
+  const shellBin = _nullishCoalesce(_nullishCoalesce(_optionalChain([options, 'optionalAccess', _ => _.shell]), () => ( process.env.SHELL)), () => ( "/bin/bash"));
+  const timeout = _nullishCoalesce(_optionalChain([options, 'optionalAccess', _2 => _2.timeout]), () => ( DEFAULT_TIMEOUT_MS));
+  return new Promise((resolve, reject) => {
+    const child = _child_process.spawn.call(void 0, shellBin, ["-c", command], {
+      cwd: _optionalChain([options, 'optionalAccess', _3 => _3.cwd]),
+      stdio: ["pipe", "pipe", "pipe"],
+      // Prevent visible console window on Windows (no-op elsewhere)
+      windowsHide: true
+    });
+    let stdout = "";
+    let stderr = "";
+    let stdoutBytes = 0;
+    let stderrBytes = 0;
+    let settled = false;
+    let timeoutId;
+    let graceId;
+    function cleanup() {
+      if (timeoutId !== void 0) {
+        clearTimeout(timeoutId);
+        timeoutId = void 0;
+      }
+      if (graceId !== void 0) {
+        clearTimeout(graceId);
+        graceId = void 0;
+      }
+      if (abortHandler && _optionalChain([options, 'optionalAccess', _4 => _4.signal])) {
+        options.signal.removeEventListener("abort", abortHandler);
+      }
+    }
+    function settle(result) {
+      if (settled) return;
+      settled = true;
+      cleanup();
+      resolve(result);
+    }
+    child.stdout.on("data", (chunk) => {
+      if (stdoutBytes >= MAX_BUFFER_BYTES) return;
+      const str = chunk.toString();
+      const remaining = MAX_BUFFER_BYTES - stdoutBytes;
+      if (chunk.length > remaining) {
+        stdout += str.slice(0, remaining);
+        stdoutBytes = MAX_BUFFER_BYTES;
+      } else {
+        stdout += str;
+        stdoutBytes += chunk.length;
+      }
+    });
+    child.stderr.on("data", (chunk) => {
+      if (stderrBytes >= MAX_BUFFER_BYTES) return;
+      const str = chunk.toString();
+      const remaining = MAX_BUFFER_BYTES - stderrBytes;
+      if (chunk.length > remaining) {
+        stderr += str.slice(0, remaining);
+        stderrBytes = MAX_BUFFER_BYTES;
+      } else {
+        stderr += str;
+        stderrBytes += chunk.length;
+      }
+    });
+    child.on("exit", (code, signal) => {
+      const exitCode = code !== null ? code : signal === "SIGKILL" ? 137 : signal === "SIGTERM" ? 143 : 1;
+      settle({ stdout, stderr, exitCode });
+    });
+    child.on("error", (err) => {
+      if (settled) return;
+      settled = true;
+      cleanup();
+      reject(err);
+    });
+    if (timeout > 0) {
+      timeoutId = setTimeout(() => {
+        timeoutId = void 0;
+        if (settled) return;
+        child.kill("SIGTERM");
+        graceId = setTimeout(() => {
+          graceId = void 0;
+          if (settled) return;
+          child.kill("SIGKILL");
+        }, SIGKILL_GRACE_MS);
+      }, timeout);
+    }
+    const abortHandler = _optionalChain([options, 'optionalAccess', _5 => _5.signal]) ? () => {
+      if (settled) return;
+      child.kill("SIGTERM");
+    } : void 0;
+    if (abortHandler && _optionalChain([options, 'optionalAccess', _6 => _6.signal])) {
+      if (options.signal.aborted) {
+        child.kill("SIGTERM");
+      } else {
+        options.signal.addEventListener("abort", abortHandler, { once: true });
+      }
+    }
+  });
+}
+
+// src/bash/index.ts
+function createBash(config = {}) {
+  const cwd = _nullishCoalesce(config.cwd, () => ( process.cwd()));
+  const timeout = _nullishCoalesce(config.timeout, () => ( 12e4));
+  return _ai.tool.call(void 0, {
+    description: "Execute a shell command and return its output. Runs the command in a bash shell with the configured working directory. Returns stdout, stderr, and exit code. Use this for running build commands, git operations, system administration, and any other shell tasks.",
+    inputSchema: _zod.z.object({
+      command: _zod.z.string().describe("The shell command to execute"),
+      timeout: _zod.z.number().optional().describe("Timeout in milliseconds (default: 120000)"),
+      description: _zod.z.string().optional().describe("Human-readable description of what the command does")
+    }),
+    execute: async ({ command, timeout: cmdTimeout }) => {
+      try {
+        const result = await executeShell(command, {
+          cwd,
+          timeout: _nullishCoalesce(cmdTimeout, () => ( timeout)),
+          shell: config.shell
+        });
+        const parts = [];
+        if (result.stdout) parts.push(result.stdout);
+        if (result.stderr) parts.push(`STDERR:
+${result.stderr}`);
+        if (result.exitCode !== 0) parts.push(`Exit code: ${result.exitCode}`);
+        return parts.length > 0 ? parts.join("\n") : `Command completed with exit code ${result.exitCode}`;
+      } catch (error) {
+        const msg = error instanceof Error ? error.message : String(error);
+        return `Error [bash]: Failed to execute command: ${msg}`;
+      }
+    }
+  });
+}
+var bash = createBash();
+
+
+
+
+exports.createBash = createBash; exports.bash = bash;

package/dist/chunk-TMW3XKKJ.js

@@ -0,0 +1,34 @@
+import {
+  formatTaskSummary,
+  loadTasks
+} from "./chunk-E6NBEYZD.js";
+
+// src/task-list/index.ts
+import { tool } from "ai";
+import { z } from "zod";
+import { join } from "path";
+function createTaskList(config = {}) {
+  const cwd = config.cwd ?? process.cwd();
+  const tasksFile = config.tasksFile ?? join(cwd, ".agentool", "tasks.json");
+  return tool({
+    description: "List all tasks with their status, owner, and dependencies.",
+    inputSchema: z.object({}),
+    execute: async () => {
+      try {
+        const tasks = await loadTasks(tasksFile);
+        const visible = tasks.filter((t) => t.status !== "deleted");
+        if (visible.length === 0) return "No tasks found.";
+        return visible.map(formatTaskSummary).join("\n");
+      } catch (error) {
+        const msg = error instanceof Error ? error.message : String(error);
+        return `Error [task-list]: ${msg}`;
+      }
+    }
+  });
+}
+var taskList = createTaskList();
+
+export {
+  createTaskList,
+  taskList
+};

package/dist/chunk-UDIG7332.js

@@ -0,0 +1,159 @@
+import {
+  executeRipgrep
+} from "./chunk-MJCAXASI.js";
+import {
+  expandPath,
+  toRelativePath
+} from "./chunk-I3ONDY7P.js";
+
+// src/grep/index.ts
+import { stat } from "fs/promises";
+import { tool } from "ai";
+import { z } from "zod";
+var VCS_DIRS = [".git", ".svn", ".hg", ".bzr", ".jj", ".sl"];
+var DEFAULT_HEAD_LIMIT = 250;
+function applyHeadLimit(items, limit, offset = 0) {
+  if (limit === 0) return { items: items.slice(offset), appliedLimit: void 0 };
+  const cap = limit ?? DEFAULT_HEAD_LIMIT;
+  const sliced = items.slice(offset, offset + cap);
+  const truncated = items.length - offset > cap;
+  return { items: sliced, appliedLimit: truncated ? cap : void 0 };
+}
+function truncationSuffix(appliedLimit, offset) {
+  const parts = [];
+  if (appliedLimit !== void 0) parts.push(`limit: ${appliedLimit}`);
+  if (offset > 0) parts.push(`offset: ${offset}`);
+  return parts.length > 0 ? `
+
+[Results truncated. ${parts.join(", ")}]` : "";
+}
+function relativizeLine(line, baseCwd, last = false) {
+  const idx = last ? line.lastIndexOf(":") : line.indexOf(":");
+  if (idx > 0) {
+    return toRelativePath(line.substring(0, idx), baseCwd) + line.substring(idx);
+  }
+  return line;
+}
+function parseGlobPatterns(globFilter) {
+  const patterns = [];
+  for (const raw of globFilter.split(/\s+/)) {
+    if (raw.includes("{") && raw.includes("}")) {
+      patterns.push(raw);
+    } else {
+      patterns.push(...raw.split(",").filter(Boolean));
+    }
+  }
+  return patterns;
+}
+function createGrep(config = {}) {
+  const cwd = config.cwd ?? process.cwd();
+  return tool({
+    description: 'Search file contents using ripgrep. Supports regex patterns, context lines, and three output modes: "content" (matching lines), "files_with_matches" (file paths), and "count" (match counts).',
+    inputSchema: z.object({
+      pattern: z.string().describe("The regular expression pattern to search for in file contents"),
+      path: z.string().optional().describe("File or directory to search in (rg PATH). Defaults to current working directory."),
+      glob: z.string().optional().describe('Glob pattern to filter files (e.g. "*.js", "*.{ts,tsx}") - maps to rg --glob'),
+      output_mode: z.enum(["content", "files_with_matches", "count"]).optional().describe('Output mode: "content" shows matching lines (supports -A/-B/-C context, -n line numbers, head_limit), "files_with_matches" shows file paths (supports head_limit), "count" shows match counts (supports head_limit). Defaults to "files_with_matches".'),
+      "-B": z.number().optional().describe('Number of lines to show before each match (rg -B). Requires output_mode: "content", ignored otherwise.'),
+      "-A": z.number().optional().describe('Number of lines to show after each match (rg -A). Requires output_mode: "content", ignored otherwise.'),
+      "-C": z.number().optional().describe("Alias for context."),
+      context: z.number().optional().describe('Number of lines to show before and after each match (rg -C). Requires output_mode: "content", ignored otherwise.'),
+      "-n": z.boolean().optional().describe('Show line numbers in output (rg -n). Requires output_mode: "content", ignored otherwise. Defaults to true.'),
+      "-i": z.boolean().optional().describe("Case insensitive search (rg -i)"),
+      type: z.string().optional().describe("File type to search (rg --type). Common types: js, py, rust, go, java, etc. More efficient than include for standard file types."),
+      head_limit: z.number().optional().describe('Limit output to first N lines/entries, equivalent to "| head -N". Works across all output modes: content (limits output lines), files_with_matches (limits file paths), count (limits count entries). Defaults to 250 when unspecified. Pass 0 for unlimited (use sparingly \u2014 large result sets waste context).'),
+      offset: z.number().optional().describe('Skip first N lines/entries before applying head_limit, equivalent to "| tail -n +N | head -N". Works across all output modes. Defaults to 0.'),
+      multiline: z.boolean().optional().describe("Enable multiline mode where . matches newlines and patterns can span lines (rg -U --multiline-dotall). Default: false.")
+    }),
+    execute: async (input) => {
+      try {
+        const {
+          pattern,
+          path,
+          glob: globFilter,
+          type: typeFilter,
+          output_mode: outputMode = "files_with_matches",
+          "-B": ctxBefore,
+          "-A": ctxAfter,
+          "-C": ctxC,
+          context: ctxAlias,
+          "-n": showLineNumbers = true,
+          "-i": caseInsensitive = false,
+          head_limit: headLimit,
+          offset = 0,
+          multiline = false
+        } = input;
+        const absolutePath = path ? expandPath(path, cwd) : cwd;
+        const args = ["--hidden"];
+        for (const dir of VCS_DIRS) args.push("--glob", `!${dir}`);
+        args.push("--max-columns", "500");
+        if (multiline) args.push("-U", "--multiline-dotall");
+        if (caseInsensitive) args.push("-i");
+        if (outputMode === "files_with_matches") args.push("-l");
+        else if (outputMode === "count") args.push("-c");
+        if (showLineNumbers && outputMode === "content") args.push("-n");
+        if (outputMode === "content") {
+          if (ctxAlias !== void 0) args.push("-C", ctxAlias.toString());
+          else if (ctxC !== void 0) args.push("-C", ctxC.toString());
+          else {
+            if (ctxBefore !== void 0) args.push("-B", ctxBefore.toString());
+            if (ctxAfter !== void 0) args.push("-A", ctxAfter.toString());
+          }
+        }
+        if (pattern.startsWith("-")) args.push("-e", pattern);
+        else args.push(pattern);
+        if (typeFilter) args.push("--type", typeFilter);
+        if (globFilter) {
+          for (const gp of parseGlobPatterns(globFilter)) args.push("--glob", gp);
+        }
+        const results = await executeRipgrep(args, absolutePath);
+        if (results.length === 0) return "No matches found";
+        if (outputMode === "content") {
+          const { items: items2, appliedLimit: appliedLimit2 } = applyHeadLimit(results, headLimit, offset);
+          const lines = items2.map((l) => relativizeLine(l, cwd));
+          return lines.join("\n") + truncationSuffix(appliedLimit2, offset);
+        }
+        if (outputMode === "count") {
+          const { items: items2, appliedLimit: appliedLimit2 } = applyHeadLimit(results, headLimit, offset);
+          const lines = items2.map((l) => relativizeLine(l, cwd, true));
+          let totalMatches = 0;
+          let fileCount = 0;
+          for (const line of lines) {
+            const idx = line.lastIndexOf(":");
+            if (idx > 0) {
+              const n = parseInt(line.substring(idx + 1), 10);
+              if (!isNaN(n)) {
+                totalMatches += n;
+                fileCount += 1;
+              }
+            }
+          }
+          return lines.join("\n") + `
+
+Total: ${totalMatches} matches in ${fileCount} files` + truncationSuffix(appliedLimit2, offset);
+        }
+        const stats = await Promise.allSettled(results.map((f) => stat(f)));
+        const sorted = results.map((fp, i) => {
+          const r = stats[i];
+          const mt = r.status === "fulfilled" ? r.value.mtimeMs ?? 0 : 0;
+          return [fp, mt];
+        }).sort((a, b) => {
+          const d = b[1] - a[1];
+          return d !== 0 ? d : a[0].localeCompare(b[0]);
+        }).map((e) => e[0]);
+        const { items, appliedLimit } = applyHeadLimit(sorted, headLimit, offset);
+        const relative = items.map((f) => toRelativePath(f, cwd));
+        return relative.join("\n") + truncationSuffix(appliedLimit, offset);
+      } catch (error) {
+        const msg = error instanceof Error ? error.message : String(error);
+        return `Error [grep]: Failed to search: ${msg}`;
+      }
+    }
+  });
+}
+var grep = createGrep();
+
+export {
+  createGrep,
+  grep
+};