agentool 1.0.0 → 1.1.1

package/dist/{chunk-SUSAPI5W.cjs → chunk-CXBWF5ON.cjs}

@@ -1,4 +1,8 @@
-"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
+"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 _chunkKONXT2SFcjs = require('./chunk-KONXT2SF.cjs');
+
+// src/bash/index.ts
 var _ai = require('ai');
 var _zod = require('zod');
 
@@ -103,12 +107,54 @@ async function executeShell(command, options) {
   });
 }
 
+// src/bash/prompt.ts
+function getPrompt(config = {}) {
+  const timeout = _nullishCoalesce(config.timeout, () => ( 12e4));
+  const timeoutMin = timeout / 6e4;
+  const shell = _nullishCoalesce(config.shell, () => ( "$SHELL or /bin/bash"));
+  return `Execute a shell command and return its output (stdout, stderr, exit code).
+
+Runs the command in ${shell} with \`-c\`. The working directory persists between calls.
+
+## When to Use
+- Build commands, git operations, system administration, installing packages
+- Running scripts, compiling code, process management
+- Any shell task that doesn't have a dedicated tool available
+
+## When NOT to Use
+- Reading file contents \u2014 use the dedicated file reading tool instead
+- Searching file contents \u2014 use the dedicated content search tool instead
+- Finding files by name/pattern \u2014 use the dedicated file search tool instead
+- Editing files \u2014 use the dedicated file editing tool instead
+- Writing new files \u2014 use the dedicated file writing tool instead
+Prefer dedicated tools over shell equivalents (e.g., don't use cat, head, tail, sed, awk, grep, find, or echo when a dedicated tool exists). Dedicated tools provide better output formatting and permission handling.
+
+## Usage Guidelines
+- Default timeout: ${timeout}ms (${timeoutMin} minutes). Override with the timeout parameter.
+- Timeout escalation: SIGTERM first, then SIGKILL after 5-second grace period.
+- Output is capped at 10 MB per stream (stdout/stderr).
+- Always quote file paths containing spaces with double quotes.
+- When issuing multiple commands:
+  - Independent commands: make separate tool calls in parallel.
+  - Sequential with dependency: chain with \`&&\`.
+  - Sequential ignoring failures: chain with \`;\`.
+  - Do NOT use newlines to separate commands.
+- Avoid unnecessary \`sleep\` commands:
+  - Don't sleep between commands that can run immediately.
+  - Don't retry failing commands in a sleep loop \u2014 diagnose the root cause.
+  - If you must sleep, keep it short (1-5 seconds).
+- For git commands:
+  - Prefer creating new commits rather than amending existing ones.
+  - Never skip hooks (--no-verify) unless the user explicitly requests it.
+  - Before destructive operations (reset --hard, push --force), consider safer alternatives.`;
+}
+
 // 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.",
+    description: _nullishCoalesce(config.description, () => ( getPrompt(config))),
     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)"),
@@ -128,7 +174,7 @@ ${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);
+        const msg = _chunkKONXT2SFcjs.extractErrorMessage.call(void 0, error);
         return `Error [bash]: Failed to execute command: ${msg}`;
       }
     }
@@ -139,4 +185,5 @@ var bash = createBash();
 
 
 
-exports.createBash = createBash; exports.bash = bash;
+
+exports.getPrompt = getPrompt; exports.createBash = createBash; exports.bash = bash;

package/dist/{chunk-U2YMJM25.cjs → chunk-G6ZVJA4V.cjs}

@@ -1,4 +1,8 @@
-"use strict";Object.defineProperty(exports, "__esModule", {value: true}); function _interopRequireWildcard(obj) { if (obj && obj.__esModule) { return obj; } else { var newObj = {}; if (obj != null) { for (var key in obj) { if (Object.prototype.hasOwnProperty.call(obj, key)) { newObj[key] = obj[key]; } } } newObj.default = obj; return newObj; } } 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/web-fetch/index.ts
+"use strict";Object.defineProperty(exports, "__esModule", {value: true}); function _interopRequireWildcard(obj) { if (obj && obj.__esModule) { return obj; } else { var newObj = {}; if (obj != null) { for (var key in obj) { if (Object.prototype.hasOwnProperty.call(obj, key)) { newObj[key] = obj[key]; } } } newObj.default = obj; return newObj; } } 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 _chunkKONXT2SFcjs = require('./chunk-KONXT2SF.cjs');
+
+// src/web-fetch/index.ts
 var _ai = require('ai');
 var _zod = require('zod');
 
@@ -73,15 +77,33 @@ async function fetchUrl(url, options) {
   };
 }
 
+// src/web-fetch/prompt.ts
+function getPrompt(config = {}) {
+  const timeout = _nullishCoalesce(config.timeout, () => ( 3e4));
+  return `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.
+
+## When to Use
+- To retrieve and read web page content, documentation, or articles
+- To fetch API responses, JSON data, or raw text from URLs
+- To check what a web page contains
+
+## When NOT to Use
+- For API interactions that need custom HTTP methods (POST, PUT, DELETE) \u2014 use the dedicated HTTP request tool instead
+- For searching the web \u2014 use the dedicated web search tool instead
+
+## Usage Guidelines
+- Content is truncated at 100,000 characters to manage context size
+- The URL must be a fully-formed valid URL (e.g., https://example.com)
+- Timeout: ${timeout}ms
+- This tool is read-only \u2014 it does not modify any files or state`;
+}
+
 // src/web-fetch/index.ts
 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.",
+    description: _nullishCoalesce(config.description, () => ( getPrompt(config))),
     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 {
@@ -101,7 +123,7 @@ function createWebFetch(config = {}) {
         parts.push(result.content);
         return parts.join("\n");
       } catch (error) {
-        const msg = error instanceof Error ? error.message : String(error);
+        const msg = _chunkKONXT2SFcjs.extractErrorMessage.call(void 0, error);
         return `Error [web-fetch]: Failed to fetch ${url}: ${msg}`;
       }
     }
@@ -112,4 +134,5 @@ var webFetch = createWebFetch();
 
 
 
-exports.createWebFetch = createWebFetch; exports.webFetch = webFetch;
+
+exports.getPrompt = getPrompt; exports.createWebFetch = createWebFetch; exports.webFetch = webFetch;

package/dist/chunk-GPHCXS2S.js

@@ -0,0 +1,99 @@
+import {
+  applyEditToFile,
+  countOccurrences,
+  findActualString,
+  preserveQuoteStyle
+} from "./chunk-4MXDQEPA.js";
+import {
+  readTextContent,
+  writeTextContent
+} from "./chunk-PWBVB6MN.js";
+import {
+  expandPath
+} from "./chunk-I3ONDY7P.js";
+import {
+  extractErrorMessage
+} from "./chunk-X6ZY2KFU.js";
+
+// src/edit/index.ts
+import { tool } from "ai";
+import { z } from "zod";
+
+// src/edit/prompt.ts
+function getPrompt() {
+  return `Perform an exact string replacement in a file. Locates old_string and replaces it with new_string.
+
+Supports absolute paths, relative paths, and tilde (~) expansion. Includes curly-quote fallback matching and quote-style preservation.
+
+## When to Use
+- To make targeted changes to existing files
+- To rename variables, update configuration values, or fix bugs
+- Prefer this over the file writing tool for modifying existing files \u2014 it only changes what you specify
+
+## When NOT to Use
+- To create a new file from scratch \u2014 use the file writing tool instead
+- To make many changes at once \u2014 consider the multi-edit tool for batch operations
+
+## Usage Guidelines
+- The edit will fail if \`old_string\` is not found in the file
+- When \`replace_all\` is false (default), \`old_string\` must appear exactly once in the file. If it appears multiple times, provide more surrounding context to make it unique, or set \`replace_all: true\`
+- Use \`replace_all: true\` for renaming a variable or string across the entire file
+- Preserve exact indentation (tabs/spaces) from the original file in both old_string and new_string
+- old_string and new_string must be different`;
+}
+
+// src/edit/index.ts
+function createEdit(config = {}) {
+  return tool({
+    description: config.description ?? getPrompt(),
+    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 readTextContent(resolved);
+        } catch (err) {
+          const msg = extractErrorMessage(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) {
+          const count = countOccurrences(content, actualOld);
+          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 writeTextContent(resolved, updated);
+        const snippet = styledNew.length > 0 ? styledNew.slice(0, 200) : "(deletion)";
+        return `Successfully edited "${resolved}". Replacement snippet:
+${snippet}`;
+      } catch (error) {
+        const msg = extractErrorMessage(error);
+        return `Error [edit]: ${msg}`;
+      }
+    }
+  });
+}
+var edit = createEdit();
+
+export {
+  getPrompt,
+  createEdit,
+  edit
+};

package/dist/chunk-HG5T47NA.cjs

@@ -0,0 +1,77 @@
+"use strict";Object.defineProperty(exports, "__esModule", {value: true}); function _nullishCoalesce(lhs, rhsFn) { if (lhs != null) { return lhs; } else { return rhsFn(); } }
+
+
+var _chunkBIAODQ2Pcjs = require('./chunk-BIAODQ2P.cjs');
+
+
+var _chunkQZ5GS6HWcjs = require('./chunk-QZ5GS6HW.cjs');
+
+
+var _chunkKONXT2SFcjs = require('./chunk-KONXT2SF.cjs');
+
+// src/read/index.ts
+var _ai = require('ai');
+var _zod = require('zod');
+
+// src/read/prompt.ts
+function getPrompt(config = {}) {
+  const maxLines = _nullishCoalesce(config.maxLines, () => ( 2e3));
+  return `Read a file 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.
+
+## When to Use
+- To examine source code, configuration files, or any text file
+- Before editing a file \u2014 read it first to understand its current content
+- To check specific sections of large files using offset and limit
+
+## When NOT to Use
+- To list directory contents \u2014 use a shell command instead
+- To search across many files \u2014 use the dedicated content search tool instead
+- To find files by name \u2014 use the dedicated file search tool instead
+
+## Usage Guidelines
+- By default, reads up to ${maxLines} lines from the start of the file
+- Use \`offset\` and \`limit\` to read specific ranges of large files rather than reading the entire file
+- When you already know which part of the file you need, read only that part to save context
+- Results use cat -n style line numbering starting at 1`;
+}
+
+// src/read/index.ts
+function createRead(config = {}) {
+  const cwd = _nullishCoalesce(config.cwd, () => ( process.cwd()));
+  const defaultMaxLines = _nullishCoalesce(config.maxLines, () => ( 2e3));
+  return _ai.tool.call(void 0, {
+    description: _nullishCoalesce(config.description, () => ( getPrompt(config))),
+    inputSchema: _zod.z.object({
+      file_path: _zod.z.string().describe("The absolute path to the file to read"),
+      offset: _zod.z.number().int().nonnegative().optional().describe("The line number to start reading from (default: 0)"),
+      limit: _zod.z.number().int().positive().optional().describe("The number of lines to read (default: 2000)")
+    }),
+    execute: async ({ file_path, offset, limit }) => {
+      try {
+        const absolutePath = _chunkQZ5GS6HWcjs.expandPath.call(void 0, file_path, cwd);
+        const result = await _chunkBIAODQ2Pcjs.readFileInRange.call(void 0, 
+          absolutePath,
+          _nullishCoalesce(offset, () => ( 0)),
+          _nullishCoalesce(limit, () => ( defaultMaxLines))
+        );
+        const numbered = _chunkBIAODQ2Pcjs.addLineNumbers.call(void 0, {
+          content: result.content,
+          startLine: (_nullishCoalesce(offset, () => ( 0))) + 1
+        });
+        return numbered;
+      } catch (error) {
+        const msg = _chunkKONXT2SFcjs.extractErrorMessage.call(void 0, error);
+        return `Error [read]: ${msg}`;
+      }
+    }
+  });
+}
+var read = createRead();
+
+
+
+
+
+exports.getPrompt = getPrompt; exports.createRead = createRead; exports.read = read;

package/dist/chunk-HO4NIRU5.js

@@ -0,0 +1,65 @@
+import {
+  formatTaskSummary,
+  loadTasks
+} from "./chunk-VHLY7LQE.js";
+import {
+  extractErrorMessage
+} from "./chunk-X6ZY2KFU.js";
+
+// src/task-list/index.ts
+import { tool } from "ai";
+import { z } from "zod";
+import { join } from "path";
+
+// src/task-list/prompt.ts
+function getPrompt() {
+  return `List all tasks with their status, owner, and dependencies.
+
+## When to Use
+- To see what tasks are available to work on (status: pending, not blocked)
+- To check overall progress on the current work
+- To find tasks that are blocked and need dependencies resolved
+- After completing a task \u2014 check for newly unblocked work
+- Before creating new tasks \u2014 check for duplicates
+
+## Output Format
+Returns a summary of each non-deleted task:
+- **id**: Task identifier (use with task-get or task-update)
+- **status**: pending, in_progress, or completed
+- **subject**: Brief description of the task
+- **owner**: Who is assigned (if set)
+- **blockedBy**: Tasks that must complete before this one can start
+
+## Tips
+- Tasks with non-empty \`blockedBy\` lists cannot be started until their dependencies are resolved
+- Use task-get with a specific ID to see full details including description and metadata
+- After marking a task completed, call this tool to find the next available task`;
+}
+
+// src/task-list/index.ts
+function createTaskList(config = {}) {
+  const cwd = config.cwd ?? process.cwd();
+  const tasksFile = config.tasksFile ?? join(cwd, ".agentool", "tasks.json");
+  return tool({
+    description: config.description ?? getPrompt(),
+    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 = extractErrorMessage(error);
+        return `Error [task-list]: ${msg}`;
+      }
+    }
+  });
+}
+var taskList = createTaskList();
+
+export {
+  getPrompt,
+  createTaskList,
+  taskList
+};

package/dist/{chunk-HZAQRHBT.js → chunk-IBC4QCGR.js}

@@ -4,6 +4,9 @@ import {
 import {
   expandPath
 } from "./chunk-I3ONDY7P.js";
+import {
+  extractErrorMessage
+} from "./chunk-X6ZY2KFU.js";
 
 // src/glob/index.ts
 import { tool } from "ai";
@@ -65,11 +68,32 @@ async function glob(pattern, cwd, options) {
   return { files, truncated };
 }
 
+// src/glob/prompt.ts
+function getPrompt() {
+  return `Find files matching a glob pattern. Returns absolute file paths sorted by modification time (newest first).
+
+Fast file pattern matching powered by ripgrep. Supports patterns like "**/*.ts", "src/**/*.js", or "*.json".
+
+## When to Use
+- To find files by name or extension across a codebase
+- To locate configuration files, test files, or specific file types
+- To discover project structure and file organization
+
+## When NOT to Use
+- To search file *contents* \u2014 use the dedicated content search tool instead
+- To read a specific file whose path you already know \u2014 use the file reading tool directly
+
+## Usage Guidelines
+- Results are sorted by modification time (most recently modified first)
+- The optional \`path\` parameter lets you narrow the search to a specific directory
+- Results may be truncated for very large result sets`;
+}
+
 // src/glob/index.ts
 function createGlob(config = {}) {
   const cwd = config.cwd ?? process.cwd();
   return tool({
-    description: 'Find files matching a glob pattern. Returns absolute file paths sorted by modification time (newest first). Supports patterns like "**/*.ts", "src/**/*.js", or "*.json".',
+    description: config.description ?? getPrompt(),
     inputSchema: z.object({
       pattern: z.string().describe("Glob pattern to match files against"),
       path: z.string().optional().describe("Directory to search in. Defaults to the working directory.")
@@ -85,7 +109,7 @@ function createGlob(config = {}) {
         return `${header}
 ${files.join("\n")}`;
       } catch (error) {
-        const message = error instanceof Error ? error.message : String(error);
+        const message = extractErrorMessage(error);
         return `Error [glob]: Failed to search for files: ${message}`;
       }
     }
@@ -94,6 +118,7 @@ ${files.join("\n")}`;
 var glob2 = createGlob();
 
 export {
+  getPrompt,
   createGlob,
   glob2 as glob
 };

package/dist/chunk-JYTOARJV.cjs

@@ -0,0 +1,69 @@
+"use strict";Object.defineProperty(exports, "__esModule", {value: true}); function _nullishCoalesce(lhs, rhsFn) { if (lhs != null) { return lhs; } else { return rhsFn(); } }
+
+var _chunkKONXT2SFcjs = require('./chunk-KONXT2SF.cjs');
+
+// src/sleep/index.ts
+var _ai = require('ai');
+var _zod = require('zod');
+
+// src/sleep/prompt.ts
+function getPrompt(config = {}) {
+  const maxDuration = _nullishCoalesce(config.maxDuration, () => ( 3e5));
+  const maxSec = maxDuration / 1e3;
+  return `Pause execution for a specified duration. Maximum duration: ${maxSec} seconds (${maxDuration}ms).
+
+## When to Use
+- When rate-limited by an external API and need to wait before retrying
+- When waiting for an external process to complete
+- Prefer this over shell sleep commands \u2014 it doesn't hold a shell process
+
+## When NOT to Use
+- Don't sleep between commands that can run immediately \u2014 just run them
+- Don't retry failing commands in a sleep loop \u2014 diagnose the root cause first
+- Avoid long sleeps that block the user \u2014 keep durations short when possible
+
+## Usage Guidelines
+- Durations exceeding the maximum are automatically clamped to ${maxDuration}ms
+- Provide a \`reason\` parameter to document why the sleep is needed
+- Each sleep costs an API turn \u2014 use judiciously`;
+}
+
+// src/sleep/index.ts
+function createSleep(config = {}) {
+  const maxDuration = _nullishCoalesce(config.maxDuration, () => ( 3e5));
+  return _ai.tool.call(void 0, {
+    description: _nullishCoalesce(config.description, () => ( getPrompt(config))),
+    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 = _chunkKONXT2SFcjs.extractErrorMessage.call(void 0, error);
+        return `Sleep failed: ${message}`;
+      }
+    }
+  });
+}
+var sleep = createSleep();
+
+
+
+
+
+exports.getPrompt = getPrompt; exports.createSleep = createSleep; exports.sleep = sleep;

package/dist/chunk-KONXT2SF.cjs

@@ -0,0 +1,8 @@
+"use strict";Object.defineProperty(exports, "__esModule", {value: true});// src/shared/errors.ts
+function extractErrorMessage(error) {
+  return error instanceof Error ? error.message : String(error);
+}
+
+
+
+exports.extractErrorMessage = extractErrorMessage;

package/dist/chunk-KUFZFNPT.cjs

@@ -0,0 +1,61 @@
+"use strict";Object.defineProperty(exports, "__esModule", {value: true}); function _nullishCoalesce(lhs, rhsFn) { if (lhs != null) { return lhs; } else { return rhsFn(); } }
+
+var _chunkKONXT2SFcjs = require('./chunk-KONXT2SF.cjs');
+
+// src/ask-user/index.ts
+var _ai = require('ai');
+var _zod = require('zod');
+
+// src/ask-user/prompt.ts
+function getPrompt() {
+  return `Ask the user a question and wait for their response. Pauses execution until the user replies.
+
+Requires an onQuestion callback to be configured \u2014 the application provides the user interaction mechanism.
+
+## When to Use
+- When you need clarification about ambiguous requirements before proceeding
+- When you need the user to choose between multiple valid approaches
+- When you need confirmation before taking a potentially destructive action
+- When missing critical information that cannot be reasonably inferred
+
+## When NOT to Use
+- When you can make a reasonable decision autonomously
+- For trivial confirmations that slow down workflow
+- When the answer is clearly implied by the user's request
+
+## Usage Guidelines
+- Ask clear, specific questions \u2014 avoid vague or overly broad queries
+- Provide options when there are a small number of valid choices
+- Batch related questions together rather than asking one at a time
+- Prefer making progress autonomously when the right course of action is clear`;
+}
+
+// src/ask-user/index.ts
+function createAskUser(config = {}) {
+  return _ai.tool.call(void 0, {
+    description: _nullishCoalesce(config.description, () => ( getPrompt())),
+    inputSchema: _zod.z.object({
+      question: _zod.z.string().describe("The question to ask the user"),
+      options: _zod.z.array(_zod.z.string()).optional().describe("Optional list of suggested response options")
+    }),
+    execute: async ({ question, options }) => {
+      if (!config.onQuestion) {
+        return "Error [ask-user]: No onQuestion callback configured. Provide an onQuestion function in the tool config to enable user interaction.";
+      }
+      try {
+        const response = await config.onQuestion(question, options);
+        return response;
+      } catch (error) {
+        const msg = _chunkKONXT2SFcjs.extractErrorMessage.call(void 0, error);
+        return `Error [ask-user]: Failed to get user response: ${msg}`;
+      }
+    }
+  });
+}
+var askUser = createAskUser();
+
+
+
+
+
+exports.getPrompt = getPrompt; exports.createAskUser = createAskUser; exports.askUser = askUser;

package/dist/chunk-L7R4UZSK.js

@@ -0,0 +1,61 @@
+import {
+  extractErrorMessage
+} from "./chunk-X6ZY2KFU.js";
+
+// src/ask-user/index.ts
+import { tool } from "ai";
+import { z } from "zod";
+
+// src/ask-user/prompt.ts
+function getPrompt() {
+  return `Ask the user a question and wait for their response. Pauses execution until the user replies.
+
+Requires an onQuestion callback to be configured \u2014 the application provides the user interaction mechanism.
+
+## When to Use
+- When you need clarification about ambiguous requirements before proceeding
+- When you need the user to choose between multiple valid approaches
+- When you need confirmation before taking a potentially destructive action
+- When missing critical information that cannot be reasonably inferred
+
+## When NOT to Use
+- When you can make a reasonable decision autonomously
+- For trivial confirmations that slow down workflow
+- When the answer is clearly implied by the user's request
+
+## Usage Guidelines
+- Ask clear, specific questions \u2014 avoid vague or overly broad queries
+- Provide options when there are a small number of valid choices
+- Batch related questions together rather than asking one at a time
+- Prefer making progress autonomously when the right course of action is clear`;
+}
+
+// src/ask-user/index.ts
+function createAskUser(config = {}) {
+  return tool({
+    description: config.description ?? getPrompt(),
+    inputSchema: z.object({
+      question: z.string().describe("The question to ask the user"),
+      options: z.array(z.string()).optional().describe("Optional list of suggested response options")
+    }),
+    execute: async ({ question, options }) => {
+      if (!config.onQuestion) {
+        return "Error [ask-user]: No onQuestion callback configured. Provide an onQuestion function in the tool config to enable user interaction.";
+      }
+      try {
+        const response = await config.onQuestion(question, options);
+        return response;
+      } catch (error) {
+        const msg = extractErrorMessage(error);
+        return `Error [ask-user]: Failed to get user response: ${msg}`;
+      }
+    }
+  });
+}
+var askUser = createAskUser();
+
+export {
+  getPrompt,
+  createAskUser,
+  askUser
+};