agentool 1.0.0 → 1.1.0

package/README.md

@@ -2,7 +2,7 @@
 
 # agentool
 
-**16 AI agent tools as standalone [Vercel AI SDK](https://sdk.vercel.ai/) modules.**
+**22 AI agent tools as standalone [Vercel AI SDK](https://sdk.vercel.ai/) modules.**
 
   <p>
   <a href="https://www.npmjs.com/package/agentool"><img src="https://img.shields.io/npm/v/agentool?style=flat-square&color=cb3837&logo=npm" alt="npm version" /></a>
@@ -27,13 +27,13 @@ File operations, shell execution, code search, web fetching, and more -- everyth
 
 ## Features
 
-- **16 production-ready tools** -- bash, grep, glob, read, edit, write, web-fetch, memory, multi-edit, diff, task, lsp, http-request, context-compaction, ask-user, sleep
+- **22 production-ready tools** -- bash, grep, glob, read, edit, write, web-fetch, web-search, tool-search, memory, multi-edit, diff, task-create, task-get, task-update, task-list, lsp, http-request, context-compaction, ask-user, sleep
 - **Vercel AI SDK compatible** -- works with `generateText()`, `streamText()`, and any AI SDK provider (OpenAI, Anthropic, Google, etc.)
 - **Factory + default pattern** -- `createBash({ cwd: '/my/project' })` for custom config, or just use `bash` with zero config
 - **Dual ESM/CJS** -- works everywhere with proper `exports` map
 - **TypeScript-first** -- full type declarations, strict mode, no `any`
 - **Never throws** -- every `execute()` returns a descriptive error string instead of throwing
-- **Tree-shakeable** -- 17 subpath exports, only import what you need
+- **Tree-shakeable** -- 22 subpath exports, only import what you need
 
 ## Installation
 
@@ -326,7 +326,58 @@ const result = await webFetch.execute(
 // Returns markdown content (HTML converted via Turndown, truncated at 100K chars)
 ```
 
-**Parameters:** `url` (string), `prompt?` (string)
+**Parameters:** `url` (string, must be valid URL)
+
+---
+
+### web-search
+
+Search the web with a callback-based implementation (bring your own search provider).
+
+```typescript
+import { createWebSearch } from 'agentool/web-search';
+
+const webSearch = createWebSearch({
+  onSearch: async (query, { allowed_domains, blocked_domains }) => {
+    // Use Tavily, SerpAPI, Google, or any search provider
+    const results = await mySearchProvider.search(query, { allowed_domains, blocked_domains });
+    return results.map(r => `${r.title}: ${r.url}\n${r.snippet}`).join('\n\n');
+  },
+});
+
+const result = await webSearch.execute(
+  { query: 'TypeScript best practices 2024', allowed_domains: ['typescript-eslint.io'] },
+  { toolCallId: 'id', messages: [] },
+);
+```
+
+**Parameters:** `query` (string, min 2 chars), `allowed_domains?` (string[]), `blocked_domains?` (string[])
+
+---
+
+### tool-search
+
+Search through a registry of available tools by name or keyword.
+
+```typescript
+import { createToolSearch } from 'agentool/tool-search';
+
+const toolSearch = createToolSearch({
+  tools: {
+    bash: { description: 'Execute shell commands' },
+    grep: { description: 'Search file contents with regex' },
+    read: { description: 'Read file contents' },
+  },
+});
+
+const result = await toolSearch.execute(
+  { query: 'file', max_results: 3 },
+  { toolCallId: 'id', messages: [] },
+);
+// Returns matching tools sorted by relevance
+```
+
+**Parameters:** `query` (string), `max_results?` (number, default 5)
 
 ---
 
@@ -390,33 +441,78 @@ await memory.execute(
 
 ---
 
-### task
+### task-create
 
-JSON file-based task tracker for agent workflows.
+Create a new task with subject, description, and optional metadata.
 
 ```typescript
-import { task } from 'agentool/task';
+import { taskCreate } from 'agentool/task-create';
 
-// Create
-const created = await task.execute(
-  { action: 'create', subject: 'Fix login bug', description: 'Auth fails on refresh' },
+const result = await taskCreate.execute(
+  { subject: 'Fix login bug', description: 'Auth fails on refresh', metadata: { priority: 'high' } },
   { toolCallId: 'id', messages: [] },
 );
+```
 
-// List all
-const list = await task.execute(
-  { action: 'list' },
+**Parameters:** `subject` (string), `description` (string), `metadata?` (Record<string, unknown>)
+
+---
+
+### task-get
+
+Retrieve a task by ID to see full details.
+
+```typescript
+import { taskGet } from 'agentool/task-get';
+
+const result = await taskGet.execute(
+  { taskId: 'abc123' },
   { toolCallId: 'id', messages: [] },
 );
+```
+
+**Parameters:** `taskId` (string)
+
+---
+
+### task-update
+
+Update a task's status, owner, metadata, and dependency relationships.
+
+```typescript
+import { taskUpdate } from 'agentool/task-update';
+
+// Update status and owner
+await taskUpdate.execute(
+  { taskId: 'abc123', status: 'in_progress', owner: 'agent-1' },
+  { toolCallId: 'id', messages: [] },
+);
+
+// Add dependencies and merge metadata (null deletes a key)
+await taskUpdate.execute(
+  { taskId: 'abc123', addBlockedBy: ['def456'], metadata: { priority: null, notes: 'reviewed' } },
+  { toolCallId: 'id', messages: [] },
+);
+```
+
+**Parameters:** `taskId` (string), `subject?` (string), `description?` (string), `status?` (`'pending'` | `'in_progress'` | `'completed'` | `'deleted'`), `owner?` (string), `activeForm?` (string), `addBlocks?` (string[]), `addBlockedBy?` (string[]), `metadata?` (Record<string, unknown>)
+
+---
+
+### task-list
+
+List all non-deleted tasks with status and dependencies.
+
+```typescript
+import { taskList } from 'agentool/task-list';
 
-// Update status
-await task.execute(
-  { action: 'update', id: 'abc123', status: 'completed' },
+const result = await taskList.execute(
+  {},
   { toolCallId: 'id', messages: [] },
 );
 ```
 
-**Parameters:** `action` (`'create'` | `'get'` | `'update'` | `'list'` | `'delete'`), `id?` (string), `subject?` (string), `description?` (string), `status?` (`'pending'` | `'in_progress'` | `'completed'`)
+**Parameters:** none
 
 ---
 
@@ -440,7 +536,7 @@ const result = await lsp.execute(
 );
 ```
 
-**Parameters:** `operation` (`'goToDefinition'` | `'findReferences'` | `'hover'` | `'documentSymbol'` | `'workspaceSymbol'` | `'goToImplementation'` | `'incomingCalls'` | `'outgoingCalls'`), `filePath` (string), `line?` (number), `character?` (number), `query?` (string)
+**Parameters:** `operation` (`'goToDefinition'` | `'findReferences'` | `'hover'` | `'documentSymbol'` | `'workspaceSymbol'` | `'goToImplementation'` | `'prepareCallHierarchy'` | `'incomingCalls'` | `'outgoingCalls'`), `filePath` (string), `line` (number, 1-based), `character` (number, 1-based)
 
 ---
 
@@ -552,7 +648,12 @@ Tools that support timeouts extend `TimeoutConfig`:
 | `bash` | `shell?: string` -- shell binary path |
 | `read` | `maxLines?: number` -- max lines to return (default: 2000) |
 | `memory` | `memoryDir?: string` -- storage directory |
-| `task` | `tasksFile?: string` -- JSON file path |
+| `task-create` | `tasksFile?: string` -- JSON file path |
+| `task-get` | `tasksFile?: string` -- JSON file path |
+| `task-update` | `tasksFile?: string` -- JSON file path |
+| `task-list` | `tasksFile?: string` -- JSON file path |
+| `web-search` | `onSearch?: (query, opts) => Promise<string>` -- search callback |
+| `tool-search` | `tools?: Record<string, { description }>` -- tool registry |
 | `lsp` | `servers?: Record<string, LspServerConfig>` -- LSP servers by file extension |
 | `http-request` | `defaultHeaders?: Record<string, string>` -- headers merged into every request |
 | `web-fetch` | `maxContentLength?: number`, `userAgent?: string` |
@@ -587,11 +688,16 @@ import {
   grep, createGrep,
   glob, createGlob,
   webFetch, createWebFetch,
+  webSearch, createWebSearch,
+  toolSearch, createToolSearch,
   httpRequest, createHttpRequest,
   memory, createMemory,
   multiEdit, createMultiEdit,
   diff, createDiff,
-  task, createTask,
+  taskCreate, createTaskCreate,
+  taskGet, createTaskGet,
+  taskUpdate, createTaskUpdate,
+  taskList, createTaskList,
   lsp, createLsp,
   contextCompaction, createContextCompaction,
   askUser, createAskUser,
@@ -613,7 +719,12 @@ import { httpRequest } from 'agentool/http-request';
 import { memory } from 'agentool/memory';
 import { multiEdit } from 'agentool/multi-edit';
 import { diff } from 'agentool/diff';
-import { task } from 'agentool/task';
+import { taskCreate } from 'agentool/task-create';
+import { taskGet } from 'agentool/task-get';
+import { taskUpdate } from 'agentool/task-update';
+import { taskList } from 'agentool/task-list';
+import { webSearch } from 'agentool/web-search';
+import { toolSearch } from 'agentool/tool-search';
 import { lsp } from 'agentool/lsp';
 import { contextCompaction } from 'agentool/context-compaction';
 import { askUser } from 'agentool/ask-user';

package/dist/chunk-44AFQ2B7.js

@@ -0,0 +1,30 @@
+// src/web-search/index.ts
+import { tool } from "ai";
+import { z } from "zod";
+function createWebSearch(config = {}) {
+  return tool({
+    description: "Search the web for information using a search query. Results can be filtered by allowed or blocked domains.",
+    inputSchema: z.object({
+      query: z.string().min(2).describe("The search query to use"),
+      allowed_domains: z.array(z.string()).optional().describe("Only include search results from these domains"),
+      blocked_domains: z.array(z.string()).optional().describe("Never include search results from these domains")
+    }),
+    execute: async ({ query, allowed_domains, blocked_domains }) => {
+      try {
+        if (!config.onSearch) {
+          return "Error [web-search]: No search callback configured. Provide onSearch via createWebSearch({ onSearch: async (query, opts) => ... })";
+        }
+        return await config.onSearch(query, { allowed_domains, blocked_domains });
+      } catch (error) {
+        const msg = error instanceof Error ? error.message : String(error);
+        return `Error [web-search]: ${msg}`;
+      }
+    }
+  });
+}
+var webSearch = createWebSearch();
+
+export {
+  createWebSearch,
+  webSearch
+};

package/dist/{chunk-Y7KOKDFP.js → chunk-4HIATLKI.js}

@@ -78,10 +78,7 @@ function createWebFetch(config = {}) {
   return tool({
     description: "Fetch a URL and return its content. HTML pages are automatically converted to markdown for easier reading. JSON and other text content is returned as-is. Content is truncated at 100,000 characters to manage context size.",
     inputSchema: z.object({
-      url: z.string().describe("The URL to fetch"),
-      prompt: z.string().optional().describe(
-        "Optional context about what to extract from the page"
-      )
+      url: z.string().url().describe("The URL to fetch")
     }),
     execute: async ({ url }) => {
       try {

package/dist/chunk-4HXAKPQH.cjs

@@ -0,0 +1,36 @@
+"use strict";Object.defineProperty(exports, "__esModule", {value: true}); function _nullishCoalesce(lhs, rhsFn) { if (lhs != null) { return lhs; } else { return rhsFn(); } }
+
+
+var _chunkL5JH4I77cjs = require('./chunk-L5JH4I77.cjs');
+
+// src/task-get/index.ts
+var _ai = require('ai');
+var _zod = require('zod');
+var _path = require('path');
+function createTaskGet(config = {}) {
+  const cwd = _nullishCoalesce(config.cwd, () => ( process.cwd()));
+  const tasksFile = _nullishCoalesce(config.tasksFile, () => ( _path.join.call(void 0, cwd, ".agentool", "tasks.json")));
+  return _ai.tool.call(void 0, {
+    description: "Retrieve a task by its ID to see full details.",
+    inputSchema: _zod.z.object({
+      taskId: _zod.z.string().describe("The ID of the task to retrieve")
+    }),
+    execute: async ({ taskId }) => {
+      try {
+        const tasks = await _chunkL5JH4I77cjs.loadTasks.call(void 0, tasksFile);
+        const found = tasks.find((t) => t.id === taskId);
+        if (!found) return `Error [task-get]: Task "${taskId}" not found.`;
+        return _chunkL5JH4I77cjs.formatTask.call(void 0, found);
+      } catch (error) {
+        const msg = error instanceof Error ? error.message : String(error);
+        return `Error [task-get]: ${msg}`;
+      }
+    }
+  });
+}
+var taskGet = createTaskGet();
+
+
+
+
+exports.createTaskGet = createTaskGet; exports.taskGet = taskGet;

package/dist/chunk-56CL4JCW.cjs

@@ -0,0 +1,53 @@
+"use strict";Object.defineProperty(exports, "__esModule", {value: true}); function _nullishCoalesce(lhs, rhsFn) { if (lhs != null) { return lhs; } else { return rhsFn(); } }
+
+
+
+
+var _chunkL5JH4I77cjs = require('./chunk-L5JH4I77.cjs');
+
+// src/task-create/index.ts
+var _ai = require('ai');
+var _zod = require('zod');
+var _path = require('path');
+function createTaskCreate(config = {}) {
+  const cwd = _nullishCoalesce(config.cwd, () => ( process.cwd()));
+  const tasksFile = _nullishCoalesce(config.tasksFile, () => ( _path.join.call(void 0, cwd, ".agentool", "tasks.json")));
+  return _ai.tool.call(void 0, {
+    description: 'Create a new task to track work. Each task gets a unique ID, starts with "pending" status, and can include optional metadata.',
+    inputSchema: _zod.z.object({
+      subject: _zod.z.string().describe("A brief title for the task"),
+      description: _zod.z.string().describe("What needs to be done"),
+      metadata: _zod.z.record(_zod.z.string(), _zod.z.unknown()).optional().describe("Arbitrary metadata to attach to the task")
+    }),
+    execute: async ({ subject, description, metadata }) => {
+      try {
+        const tasks = await _chunkL5JH4I77cjs.loadTasks.call(void 0, tasksFile);
+        const now = (/* @__PURE__ */ new Date()).toISOString();
+        const entry = {
+          id: _chunkL5JH4I77cjs.generateId.call(void 0, ),
+          subject,
+          description,
+          status: "pending",
+          blocks: [],
+          blockedBy: [],
+          metadata,
+          createdAt: now,
+          updatedAt: now
+        };
+        tasks.push(entry);
+        await _chunkL5JH4I77cjs.saveTasks.call(void 0, tasksFile, tasks);
+        return `Created task ${entry.id}.
+${_chunkL5JH4I77cjs.formatTask.call(void 0, entry)}`;
+      } catch (error) {
+        const msg = error instanceof Error ? error.message : String(error);
+        return `Error [task-create]: ${msg}`;
+      }
+    }
+  });
+}
+var taskCreate = createTaskCreate();
+
+
+
+
+exports.createTaskCreate = createTaskCreate; exports.taskCreate = taskCreate;

package/dist/{chunk-U2YMJM25.cjs → chunk-5O55DKOB.cjs}

@@ -78,10 +78,7 @@ function createWebFetch(config = {}) {
   return _ai.tool.call(void 0, {
     description: "Fetch a URL and return its content. HTML pages are automatically converted to markdown for easier reading. JSON and other text content is returned as-is. Content is truncated at 100,000 characters to manage context size.",
     inputSchema: _zod.z.object({
-      url: _zod.z.string().describe("The URL to fetch"),
-      prompt: _zod.z.string().optional().describe(
-        "Optional context about what to extract from the page"
-      )
+      url: _zod.z.string().url().describe("The URL to fetch")
     }),
     execute: async ({ url }) => {
       try {

package/dist/{chunk-IMZQ7ELK.cjs → chunk-5TDZF4IM.cjs}

@@ -39,13 +39,14 @@ function operationToMethod(operation) {
     documentSymbol: "textDocument/documentSymbol",
     workspaceSymbol: "workspace/symbol",
     goToImplementation: "textDocument/implementation",
+    prepareCallHierarchy: "textDocument/prepareCallHierarchy",
     incomingCalls: "textDocument/prepareCallHierarchy",
     outgoingCalls: "textDocument/prepareCallHierarchy"
   };
   return _nullishCoalesce(map[operation], () => ( operation));
 }
-function buildRequestParams(op, uri, line, char, query) {
-  if (op === "workspaceSymbol") return { query: _nullishCoalesce(query, () => ( "")) };
+function buildRequestParams(op, uri, line, char) {
+  if (op === "workspaceSymbol") return { query: "" };
   const td = { uri };
   if (op === "documentSymbol") return { textDocument: td };
   const pos = { line, character: char };
@@ -128,7 +129,7 @@ async function executeLspOperation(serverConfig, params, timeoutMs) {
       textDocument: { uri, languageId: langId, version: 1, text: content }
     });
     const method = operationToMethod(params.operation);
-    const reqParams = buildRequestParams(params.operation, uri, _nullishCoalesce(params.line, () => ( 0)), _nullishCoalesce(params.character, () => ( 0)), params.query);
+    const reqParams = buildRequestParams(params.operation, uri, _nullishCoalesce(params.line, () => ( 0)), _nullishCoalesce(params.character, () => ( 0)));
     let response = await rpc(sendRequest(proc, method, reqParams));
     if (response.error) return `Error [lsp]: Server error: ${response.error.message} (code ${response.error.code})`;
     if ((params.operation === "incomingCalls" || params.operation === "outgoingCalls") && Array.isArray(response.result) && response.result.length > 0) {
@@ -150,21 +151,21 @@ var LSP_OPERATIONS = [
   "documentSymbol",
   "workspaceSymbol",
   "goToImplementation",
+  "prepareCallHierarchy",
   "incomingCalls",
   "outgoingCalls"
 ];
 function createLsp(config = {}) {
   const timeoutMs = _nullishCoalesce(config.timeout, () => ( 3e4));
   return _ai.tool.call(void 0, {
-    description: "Perform language server operations like go-to-definition, find-references, and hover. Requires LSP server configuration. Supports 8 operations: goToDefinition, findReferences, hover, documentSymbol, workspaceSymbol, goToImplementation, incomingCalls, outgoingCalls.",
+    description: "Perform language server operations like go-to-definition, find-references, and hover. Requires LSP server configuration. Supports 9 operations: goToDefinition, findReferences, hover, documentSymbol, workspaceSymbol, goToImplementation, prepareCallHierarchy, incomingCalls, outgoingCalls.",
     inputSchema: _zod.z.object({
       operation: _zod.z.enum(LSP_OPERATIONS).describe("The LSP operation to perform"),
       filePath: _zod.z.string().describe("Path to the file"),
-      line: _zod.z.number().optional().describe("Line number (0-indexed)"),
-      character: _zod.z.number().optional().describe("Character offset (0-indexed)"),
-      query: _zod.z.string().optional().describe("Search query for workspaceSymbol")
+      line: _zod.z.number().int().positive().describe("The line number (1-based, as shown in editors)"),
+      character: _zod.z.number().int().positive().describe("The character offset (1-based, as shown in editors)")
     }),
-    execute: async ({ operation, filePath, line, character, query }) => {
+    execute: async ({ operation, filePath, line, character }) => {
       if (!config.servers || Object.keys(config.servers).length === 0) {
         return 'Error [lsp]: No LSP servers configured. Provide server configuration via createLsp({ servers: { ".ts": { command: "typescript-language-server", args: ["--stdio"] } } })';
       }
@@ -177,7 +178,7 @@ function createLsp(config = {}) {
       try {
         return await executeLspOperation(
           serverConfig,
-          { operation, filePath, line, character, query, cwd: _nullishCoalesce(config.cwd, () => ( process.cwd())) },
+          { operation, filePath, line: line - 1, character: character - 1, cwd: _nullishCoalesce(config.cwd, () => ( process.cwd())) },
           timeoutMs
         );
       } catch (error) {

package/dist/{chunk-JCTBB7H2.cjs → chunk-6DJSWTWQ.cjs}

@@ -14,7 +14,7 @@ function createWrite(config = {}) {
   return _ai.tool.call(void 0, {
     description: "Write text content to a file, creating parent directories as needed. If the file exists it is overwritten. Use this to create new files or replace existing file contents.",
     inputSchema: _zod.z.object({
-      file_path: _zod.z.string().describe("Path to the file to write"),
+      file_path: _zod.z.string().describe("The absolute path to the file to write (must be absolute, not relative)"),
       content: _zod.z.string().describe("Text content to write to the file")
     }),
     execute: async ({ file_path, content }) => {

package/dist/{chunk-ZHCMEQJJ.js → chunk-ACGW44YT.js}

@@ -15,9 +15,9 @@ function createRead(config = {}) {
   return tool({
     description: 'Read a file from the local filesystem and return its contents with line numbers. Supports absolute paths, relative paths (resolved against the working directory), and tilde (~) home directory expansion. Returns numbered lines in "lineNumber\\tcontent" format. Use offset and limit to read specific ranges of large files.',
     inputSchema: z.object({
-      file_path: z.string().describe("The path to the file to read (absolute, relative, or ~/...)"),
-      offset: z.number().optional().describe("0-indexed line number to start reading from (default: 0)"),
-      limit: z.number().optional().describe("Maximum number of lines to return (default: 2000)")
+      file_path: z.string().describe("The absolute path to the file to read"),
+      offset: z.number().int().nonnegative().optional().describe("The line number to start reading from (default: 0)"),
+      limit: z.number().int().positive().optional().describe("The number of lines to read (default: 2000)")
     }),
     execute: async ({ file_path, offset, limit }) => {
       try {

package/dist/chunk-E6NBEYZD.js

@@ -0,0 +1,51 @@
+// src/shared/task-store.ts
+import { mkdir, readFile, writeFile } from "fs/promises";
+import { dirname } from "path";
+import { randomBytes } from "crypto";
+function generateId() {
+  return randomBytes(4).toString("hex");
+}
+async function loadTasks(filePath) {
+  try {
+    const data = await readFile(filePath, "utf-8");
+    return JSON.parse(data);
+  } catch {
+    return [];
+  }
+}
+async function saveTasks(filePath, tasks) {
+  await mkdir(dirname(filePath), { recursive: true });
+  await writeFile(filePath, JSON.stringify(tasks, null, 2), "utf-8");
+}
+function formatTask(t) {
+  const lines = [
+    `ID: ${t.id}`,
+    `Subject: ${t.subject}`,
+    `Description: ${t.description}`,
+    `Status: ${t.status}`
+  ];
+  if (t.owner) lines.push(`Owner: ${t.owner}`);
+  if (t.activeForm) lines.push(`Active: ${t.activeForm}`);
+  if (t.blocks.length > 0) lines.push(`Blocks: ${t.blocks.join(", ")}`);
+  if (t.blockedBy.length > 0) lines.push(`Blocked by: ${t.blockedBy.join(", ")}`);
+  if (t.metadata && Object.keys(t.metadata).length > 0) {
+    lines.push(`Metadata: ${JSON.stringify(t.metadata)}`);
+  }
+  lines.push(`Created: ${t.createdAt}`);
+  lines.push(`Updated: ${t.updatedAt}`);
+  return lines.join("\n");
+}
+function formatTaskSummary(t) {
+  const parts = [`#${t.id} [${t.status}] ${t.subject}`];
+  if (t.owner) parts.push(`(owner: ${t.owner})`);
+  if (t.blockedBy.length > 0) parts.push(`[blocked by ${t.blockedBy.join(", ")}]`);
+  return parts.join(" ");
+}
+
+export {
+  generateId,
+  loadTasks,
+  saveTasks,
+  formatTask,
+  formatTaskSummary
+};

package/dist/{chunk-7QL4BQCH.js → chunk-ECYT46FP.js}

@@ -14,7 +14,7 @@ function createWrite(config = {}) {
   return tool({
     description: "Write text content to a file, creating parent directories as needed. If the file exists it is overwritten. Use this to create new files or replace existing file contents.",
     inputSchema: z.object({
-      file_path: z.string().describe("Path to the file to write"),
+      file_path: z.string().describe("The absolute path to the file to write (must be absolute, not relative)"),
       content: z.string().describe("Text content to write to the file")
     }),
     execute: async ({ file_path, content }) => {

package/dist/{chunk-QEJV2KZ4.cjs → chunk-HNP7JDQC.cjs}

@@ -50,20 +50,20 @@ function createGrep(config = {}) {
   return _ai.tool.call(void 0, {
     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: _zod.z.object({
-      pattern: _zod.z.string().describe("Regex pattern to search for"),
-      path: _zod.z.string().optional().describe("File or directory to search in"),
-      glob: _zod.z.string().optional().describe('Glob pattern to filter files (e.g. "*.js")'),
-      output_mode: _zod.z.enum(["content", "files_with_matches", "count"]).optional().describe('Output mode. Defaults to "files_with_matches".'),
-      "-B": _zod.z.number().optional().describe("Lines of context before each match"),
-      "-A": _zod.z.number().optional().describe("Lines of context after each match"),
-      "-C": _zod.z.number().optional().describe("Lines of context around each match"),
-      context: _zod.z.number().optional().describe("Context lines (alias for -C)"),
-      "-n": _zod.z.boolean().optional().describe("Show line numbers (content mode, default true)"),
-      "-i": _zod.z.boolean().optional().describe("Case insensitive search"),
-      type: _zod.z.string().optional().describe('File type filter (e.g. "js", "py")'),
-      head_limit: _zod.z.number().optional().describe("Max entries. Default 250, 0 = unlimited."),
-      offset: _zod.z.number().optional().describe("Skip first N entries. Default 0."),
-      multiline: _zod.z.boolean().optional().describe("Enable multiline matching")
+      pattern: _zod.z.string().describe("The regular expression pattern to search for in file contents"),
+      path: _zod.z.string().optional().describe("File or directory to search in (rg PATH). Defaults to current working directory."),
+      glob: _zod.z.string().optional().describe('Glob pattern to filter files (e.g. "*.js", "*.{ts,tsx}") - maps to rg --glob'),
+      output_mode: _zod.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": _zod.z.number().optional().describe('Number of lines to show before each match (rg -B). Requires output_mode: "content", ignored otherwise.'),
+      "-A": _zod.z.number().optional().describe('Number of lines to show after each match (rg -A). Requires output_mode: "content", ignored otherwise.'),
+      "-C": _zod.z.number().optional().describe("Alias for context."),
+      context: _zod.z.number().optional().describe('Number of lines to show before and after each match (rg -C). Requires output_mode: "content", ignored otherwise.'),
+      "-n": _zod.z.boolean().optional().describe('Show line numbers in output (rg -n). Requires output_mode: "content", ignored otherwise. Defaults to true.'),
+      "-i": _zod.z.boolean().optional().describe("Case insensitive search (rg -i)"),
+      type: _zod.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: _zod.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: _zod.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: _zod.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 {

package/dist/chunk-HNUL2CID.cjs

@@ -0,0 +1,34 @@
+"use strict";Object.defineProperty(exports, "__esModule", {value: true}); function _nullishCoalesce(lhs, rhsFn) { if (lhs != null) { return lhs; } else { return rhsFn(); } }
+
+
+var _chunkL5JH4I77cjs = require('./chunk-L5JH4I77.cjs');
+
+// src/task-list/index.ts
+var _ai = require('ai');
+var _zod = require('zod');
+var _path = require('path');
+function createTaskList(config = {}) {
+  const cwd = _nullishCoalesce(config.cwd, () => ( process.cwd()));
+  const tasksFile = _nullishCoalesce(config.tasksFile, () => ( _path.join.call(void 0, cwd, ".agentool", "tasks.json")));
+  return _ai.tool.call(void 0, {
+    description: "List all tasks with their status, owner, and dependencies.",
+    inputSchema: _zod.z.object({}),
+    execute: async () => {
+      try {
+        const tasks = await _chunkL5JH4I77cjs.loadTasks.call(void 0, tasksFile);
+        const visible = tasks.filter((t) => t.status !== "deleted");
+        if (visible.length === 0) return "No tasks found.";
+        return visible.map(_chunkL5JH4I77cjs.formatTaskSummary).join("\n");
+      } catch (error) {
+        const msg = error instanceof Error ? error.message : String(error);
+        return `Error [task-list]: ${msg}`;
+      }
+    }
+  });
+}
+var taskList = createTaskList();
+
+
+
+
+exports.createTaskList = createTaskList; exports.taskList = taskList;

package/dist/chunk-IEX4NOVN.cjs

@@ -0,0 +1,48 @@
+"use strict";Object.defineProperty(exports, "__esModule", {value: true}); function _nullishCoalesce(lhs, rhsFn) { if (lhs != null) { return lhs; } else { return rhsFn(); } }// src/tool-search/index.ts
+var _ai = require('ai');
+var _zod = require('zod');
+function createToolSearch(config = {}) {
+  return _ai.tool.call(void 0, {
+    description: "Search for available tools by name or keyword. Returns matching tool names and descriptions.",
+    inputSchema: _zod.z.object({
+      query: _zod.z.string().describe("Query to find tools by name or keyword"),
+      max_results: _zod.z.number().optional().default(5).describe("Max results to return")
+    }),
+    execute: async ({ query, max_results }) => {
+      try {
+        const registry = _nullishCoalesce(config.tools, () => ( {}));
+        const entries = Object.entries(registry);
+        if (entries.length === 0) {
+          return "No tools registered. Provide a tools registry via createToolSearch({ tools: { ... } })";
+        }
+        const lower = query.toLowerCase();
+        const scored = entries.map(([name, { description }]) => {
+          let score = 0;
+          const nameLower = name.toLowerCase();
+          const descLower = description.toLowerCase();
+          if (nameLower === lower) score += 10;
+          else if (nameLower.includes(lower)) score += 5;
+          if (descLower.includes(lower)) score += 3;
+          for (const word of lower.split(/\s+/)) {
+            if (nameLower.includes(word)) score += 2;
+            if (descLower.includes(word)) score += 1;
+          }
+          return { name, description, score };
+        }).filter((e) => e.score > 0).sort((a, b) => b.score - a.score).slice(0, max_results);
+        if (scored.length === 0) {
+          return `No tools matched query "${query}".`;
+        }
+        return scored.map((e) => `${e.name}: ${e.description}`).join("\n");
+      } catch (error) {
+        const msg = error instanceof Error ? error.message : String(error);
+        return `Error [tool-search]: ${msg}`;
+      }
+    }
+  });
+}
+var toolSearch = createToolSearch();
+
+
+
+
+exports.createToolSearch = createToolSearch; exports.toolSearch = toolSearch;