agentool 0.0.1 → 1.1.0

package/dist/chunk-IRRNYFI5.js

@@ -0,0 +1,48 @@
+// src/tool-search/index.ts
+import { tool } from "ai";
+import { z } from "zod";
+function createToolSearch(config = {}) {
+  return tool({
+    description: "Search for available tools by name or keyword. Returns matching tool names and descriptions.",
+    inputSchema: z.object({
+      query: z.string().describe("Query to find tools by name or keyword"),
+      max_results: z.number().optional().default(5).describe("Max results to return")
+    }),
+    execute: async ({ query, max_results }) => {
+      try {
+        const registry = 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();
+
+export {
+  createToolSearch,
+  toolSearch
+};

package/dist/chunk-K77GC2QI.js

@@ -0,0 +1,59 @@
+// src/context-compaction/index.ts
+import { tool, zodSchema } from "ai";
+import { z } from "zod";
+var parametersSchema = z.object({
+  messages: z.array(
+    z.object({
+      role: z.string().describe("Message role (system, user, assistant)"),
+      content: z.string().describe("Message content")
+    })
+  ).describe("The conversation messages to compact"),
+  maxTokens: z.number().optional().describe(
+    "Target maximum tokens (default: config.maxTokens or 4096)"
+  )
+});
+function createContextCompaction(config = {}) {
+  return tool({
+    description: "Compact conversation history by summarizing older messages to reduce context size. Requires a summarize function in config. Returns compacted messages where total chars < maxTokens * 4.",
+    inputSchema: zodSchema(parametersSchema),
+    execute: async ({
+      messages,
+      maxTokens: inputMaxTokens
+    }) => {
+      const maxTokens = inputMaxTokens ?? config.maxTokens ?? 4096;
+      const charBudget = maxTokens * 4;
+      const totalChars = messages.reduce(
+        (sum, m) => sum + m.content.length,
+        0
+      );
+      if (totalChars <= charBudget) {
+        return JSON.stringify({
+          compacted: false,
+          messages,
+          reason: "Already within token budget"
+        });
+      }
+      if (!config.summarize) {
+        return "Error [context-compaction]: No summarize function configured. Provide a summarize callback in the tool config.";
+      }
+      try {
+        const summary = await config.summarize(messages);
+        const compactedMessages = [{ role: "system", content: summary }];
+        return JSON.stringify({
+          compacted: true,
+          messages: compactedMessages,
+          originalCount: messages.length
+        });
+      } catch (error) {
+        const msg = error instanceof Error ? error.message : String(error);
+        return `Error [context-compaction]: Summarization failed: ${msg}`;
+      }
+    }
+  });
+}
+var contextCompaction = createContextCompaction();
+
+export {
+  createContextCompaction,
+  contextCompaction
+};

package/dist/chunk-L5JH4I77.cjs

@@ -0,0 +1,51 @@
+"use strict";Object.defineProperty(exports, "__esModule", {value: true});// src/shared/task-store.ts
+var _promises = require('fs/promises');
+var _path = require('path');
+var _crypto = require('crypto');
+function generateId() {
+  return _crypto.randomBytes.call(void 0, 4).toString("hex");
+}
+async function loadTasks(filePath) {
+  try {
+    const data = await _promises.readFile.call(void 0, filePath, "utf-8");
+    return JSON.parse(data);
+  } catch (e) {
+    return [];
+  }
+}
+async function saveTasks(filePath, tasks) {
+  await _promises.mkdir.call(void 0, _path.dirname.call(void 0, filePath), { recursive: true });
+  await _promises.writeFile.call(void 0, 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(" ");
+}
+
+
+
+
+
+
+
+exports.generateId = generateId; exports.loadTasks = loadTasks; exports.saveTasks = saveTasks; exports.formatTask = formatTask; exports.formatTaskSummary = formatTaskSummary;

package/dist/chunk-LK6SQH2G.cjs

@@ -0,0 +1,30 @@
+"use strict";Object.defineProperty(exports, "__esModule", {value: true});// src/web-search/index.ts
+var _ai = require('ai');
+var _zod = require('zod');
+function createWebSearch(config = {}) {
+  return _ai.tool.call(void 0, {
+    description: "Search the web for information using a search query. Results can be filtered by allowed or blocked domains.",
+    inputSchema: _zod.z.object({
+      query: _zod.z.string().min(2).describe("The search query to use"),
+      allowed_domains: _zod.z.array(_zod.z.string()).optional().describe("Only include search results from these domains"),
+      blocked_domains: _zod.z.array(_zod.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();
+
+
+
+
+exports.createWebSearch = createWebSearch; exports.webSearch = webSearch;

package/dist/chunk-LPV5CN2K.js

@@ -0,0 +1,58 @@
+// src/http-request/index.ts
+import { tool } from "ai";
+import { z } from "zod";
+function createHttpRequest(config = {}) {
+  return tool({
+    description: "Make an HTTP request to a URL. Returns the response status, headers, and body. Use this for API interactions, webhook calls, and service health checks. Unlike web-fetch, this returns raw response data without markdown conversion.",
+    inputSchema: z.object({
+      method: z.enum(["GET", "POST", "PUT", "PATCH", "DELETE", "HEAD"]).describe("HTTP method"),
+      url: z.string().describe("The URL to send the request to"),
+      headers: z.record(z.string()).optional().describe("Request headers as key-value pairs"),
+      body: z.string().optional().describe("Request body (for POST, PUT, PATCH)"),
+      timeout: z.number().optional().describe("Request timeout in milliseconds (default: 30000)")
+    }),
+    execute: async ({ method, url, headers, body, timeout }) => {
+      try {
+        const timeoutMs = timeout ?? config.timeout ?? 3e4;
+        const controller = new AbortController();
+        const timeoutId = setTimeout(() => controller.abort(), timeoutMs);
+        const mergedHeaders = { ...config.defaultHeaders, ...headers };
+        const response = await fetch(url, {
+          method,
+          headers: mergedHeaders,
+          body: ["POST", "PUT", "PATCH"].includes(method) ? body : void 0,
+          signal: controller.signal
+        });
+        clearTimeout(timeoutId);
+        const responseBody = await response.text();
+        const responseHeaders = {};
+        response.headers.forEach((value, key) => {
+          responseHeaders[key] = value;
+        });
+        return JSON.stringify(
+          {
+            status: response.status,
+            statusText: response.statusText,
+            headers: responseHeaders,
+            body: responseBody
+          },
+          null,
+          2
+        );
+      } catch (error) {
+        const effectiveTimeout = timeout ?? config.timeout ?? 3e4;
+        if (error instanceof Error && error.name === "AbortError") {
+          return `Error [http-request]: Request timed out after ${effectiveTimeout}ms for ${method} ${url}. Try increasing the timeout or verify the server is responsive.`;
+        }
+        const msg = error instanceof Error ? error.message : String(error);
+        return `Error [http-request]: ${method} ${url} failed: ${msg}. Verify the URL is correct and the server is reachable.`;
+      }
+    }
+  });
+}
+var httpRequest = createHttpRequest();
+
+export {
+  createHttpRequest,
+  httpRequest
+};

package/dist/chunk-LTE5NG4D.js

@@ -0,0 +1,53 @@
+import {
+  formatTask,
+  generateId,
+  loadTasks,
+  saveTasks
+} from "./chunk-E6NBEYZD.js";
+
+// src/task-create/index.ts
+import { tool } from "ai";
+import { z } from "zod";
+import { join } from "path";
+function createTaskCreate(config = {}) {
+  const cwd = config.cwd ?? process.cwd();
+  const tasksFile = config.tasksFile ?? join(cwd, ".agentool", "tasks.json");
+  return tool({
+    description: 'Create a new task to track work. Each task gets a unique ID, starts with "pending" status, and can include optional metadata.',
+    inputSchema: z.object({
+      subject: z.string().describe("A brief title for the task"),
+      description: z.string().describe("What needs to be done"),
+      metadata: z.record(z.string(), z.unknown()).optional().describe("Arbitrary metadata to attach to the task")
+    }),
+    execute: async ({ subject, description, metadata }) => {
+      try {
+        const tasks = await loadTasks(tasksFile);
+        const now = (/* @__PURE__ */ new Date()).toISOString();
+        const entry = {
+          id: generateId(),
+          subject,
+          description,
+          status: "pending",
+          blocks: [],
+          blockedBy: [],
+          metadata,
+          createdAt: now,
+          updatedAt: now
+        };
+        tasks.push(entry);
+        await saveTasks(tasksFile, tasks);
+        return `Created task ${entry.id}.
+${formatTask(entry)}`;
+      } catch (error) {
+        const msg = error instanceof Error ? error.message : String(error);
+        return `Error [task-create]: ${msg}`;
+      }
+    }
+  });
+}
+var taskCreate = createTaskCreate();
+
+export {
+  createTaskCreate,
+  taskCreate
+};

package/dist/chunk-MF7CJVIZ.js

@@ -0,0 +1,40 @@
+// src/sleep/index.ts
+import { tool, zodSchema } from "ai";
+import { z } from "zod";
+function createSleep(config = {}) {
+  const maxDuration = config.maxDuration ?? 3e5;
+  return tool({
+    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: zodSchema(
+      z.object({
+        durationMs: z.number().describe("Duration to sleep in milliseconds"),
+        reason: 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();
+
+export {
+  createSleep,
+  sleep
+};

package/dist/chunk-MIYA7TNR.cjs

@@ -0,0 +1,123 @@
+"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/shared/ripgrep.ts
+var _child_process = require('child_process');
+var MAX_BUFFER_SIZE = 2e7;
+var DEFAULT_TIMEOUT = 2e4;
+var INSTALL_URL = "https://github.com/BurntSushi/ripgrep#installation";
+var RipgrepNotFoundError = class extends Error {
+  constructor(message) {
+    super(
+      _nullishCoalesce(message, () => ( `ripgrep (rg) not found on PATH. Install it from: ${INSTALL_URL}`))
+    );
+    this.name = "RipgrepNotFoundError";
+  }
+};
+var RipgrepTimeoutError = class extends Error {
+  /**
+   * Lines captured from stdout before the process was killed.
+   * May be empty if no output arrived before the timeout.
+   */
+  
+  constructor(message, partialResults) {
+    super(message);
+    this.name = "RipgrepTimeoutError";
+    this.partialResults = partialResults;
+  }
+};
+function findRg() {
+  try {
+    const result = _child_process.execFileSync.call(void 0, "which", ["rg"], {
+      encoding: "utf-8",
+      timeout: 5e3
+    });
+    const rgPath = result.trim();
+    if (!rgPath) {
+      throw new RipgrepNotFoundError();
+    }
+    return rgPath;
+  } catch (error) {
+    if (error instanceof RipgrepNotFoundError) {
+      throw error;
+    }
+    throw new RipgrepNotFoundError();
+  }
+}
+function isEagainError(stderr) {
+  return stderr.includes("os error 11") || stderr.includes("Resource temporarily unavailable");
+}
+function parseStdout(stdout) {
+  return stdout.trim().split("\n").map((line) => line.replace(/\r$/, "")).filter(Boolean);
+}
+async function executeRipgrep(args, target, options) {
+  const rgPath = findRg();
+  const timeout = _nullishCoalesce(_optionalChain([options, 'optionalAccess', _ => _.timeout]), () => ( DEFAULT_TIMEOUT));
+  return new Promise((resolve, reject) => {
+    const handleResult = (error, stdout, stderr, isRetry) => {
+      if (!error) {
+        resolve(parseStdout(stdout));
+        return;
+      }
+      if (error.code === 1) {
+        resolve([]);
+        return;
+      }
+      const CRITICAL_CODES = ["ENOENT", "EACCES", "EPERM"];
+      if (CRITICAL_CODES.includes(error.code)) {
+        reject(error);
+        return;
+      }
+      if (!isRetry && isEagainError(stderr)) {
+        _child_process.execFile.call(void 0, 
+          rgPath,
+          ["-j", "1", ...args, target],
+          {
+            maxBuffer: MAX_BUFFER_SIZE,
+            signal: _optionalChain([options, 'optionalAccess', _2 => _2.signal]),
+            timeout,
+            killSignal: "SIGKILL"
+          },
+          (retryErr, retryStdout, retryStderr) => {
+            handleResult(retryErr, retryStdout, retryStderr, true);
+          }
+        );
+        return;
+      }
+      const hasOutput = stdout && stdout.trim().length > 0;
+      const isTimeout = error.signal === "SIGTERM" || error.signal === "SIGKILL" || error.code === "ABORT_ERR";
+      const isBufferOverflow = error.code === "ERR_CHILD_PROCESS_STDIO_MAXBUFFER";
+      let lines = [];
+      if (hasOutput) {
+        lines = parseStdout(stdout);
+        if (lines.length > 0 && (isTimeout || isBufferOverflow)) {
+          lines = lines.slice(0, -1);
+        }
+      }
+      if (isTimeout && lines.length === 0) {
+        reject(
+          new RipgrepTimeoutError(
+            `Ripgrep search timed out after ${timeout / 1e3} seconds. Try a more specific path or pattern.`,
+            lines
+          )
+        );
+        return;
+      }
+      resolve(lines);
+    };
+    _child_process.execFile.call(void 0, 
+      rgPath,
+      [...args, target],
+      {
+        maxBuffer: MAX_BUFFER_SIZE,
+        signal: _optionalChain([options, 'optionalAccess', _3 => _3.signal]),
+        timeout,
+        killSignal: "SIGKILL"
+      },
+      (error, stdout, stderr) => {
+        handleResult(error, stdout, stderr, false);
+      }
+    );
+  });
+}
+
+
+
+exports.executeRipgrep = executeRipgrep;

package/dist/chunk-MJCAXASI.js

@@ -0,0 +1,123 @@
+// src/shared/ripgrep.ts
+import { execFile, execFileSync } from "child_process";
+var MAX_BUFFER_SIZE = 2e7;
+var DEFAULT_TIMEOUT = 2e4;
+var INSTALL_URL = "https://github.com/BurntSushi/ripgrep#installation";
+var RipgrepNotFoundError = class extends Error {
+  constructor(message) {
+    super(
+      message ?? `ripgrep (rg) not found on PATH. Install it from: ${INSTALL_URL}`
+    );
+    this.name = "RipgrepNotFoundError";
+  }
+};
+var RipgrepTimeoutError = class extends Error {
+  /**
+   * Lines captured from stdout before the process was killed.
+   * May be empty if no output arrived before the timeout.
+   */
+  partialResults;
+  constructor(message, partialResults) {
+    super(message);
+    this.name = "RipgrepTimeoutError";
+    this.partialResults = partialResults;
+  }
+};
+function findRg() {
+  try {
+    const result = execFileSync("which", ["rg"], {
+      encoding: "utf-8",
+      timeout: 5e3
+    });
+    const rgPath = result.trim();
+    if (!rgPath) {
+      throw new RipgrepNotFoundError();
+    }
+    return rgPath;
+  } catch (error) {
+    if (error instanceof RipgrepNotFoundError) {
+      throw error;
+    }
+    throw new RipgrepNotFoundError();
+  }
+}
+function isEagainError(stderr) {
+  return stderr.includes("os error 11") || stderr.includes("Resource temporarily unavailable");
+}
+function parseStdout(stdout) {
+  return stdout.trim().split("\n").map((line) => line.replace(/\r$/, "")).filter(Boolean);
+}
+async function executeRipgrep(args, target, options) {
+  const rgPath = findRg();
+  const timeout = options?.timeout ?? DEFAULT_TIMEOUT;
+  return new Promise((resolve, reject) => {
+    const handleResult = (error, stdout, stderr, isRetry) => {
+      if (!error) {
+        resolve(parseStdout(stdout));
+        return;
+      }
+      if (error.code === 1) {
+        resolve([]);
+        return;
+      }
+      const CRITICAL_CODES = ["ENOENT", "EACCES", "EPERM"];
+      if (CRITICAL_CODES.includes(error.code)) {
+        reject(error);
+        return;
+      }
+      if (!isRetry && isEagainError(stderr)) {
+        execFile(
+          rgPath,
+          ["-j", "1", ...args, target],
+          {
+            maxBuffer: MAX_BUFFER_SIZE,
+            signal: options?.signal,
+            timeout,
+            killSignal: "SIGKILL"
+          },
+          (retryErr, retryStdout, retryStderr) => {
+            handleResult(retryErr, retryStdout, retryStderr, true);
+          }
+        );
+        return;
+      }
+      const hasOutput = stdout && stdout.trim().length > 0;
+      const isTimeout = error.signal === "SIGTERM" || error.signal === "SIGKILL" || error.code === "ABORT_ERR";
+      const isBufferOverflow = error.code === "ERR_CHILD_PROCESS_STDIO_MAXBUFFER";
+      let lines = [];
+      if (hasOutput) {
+        lines = parseStdout(stdout);
+        if (lines.length > 0 && (isTimeout || isBufferOverflow)) {
+          lines = lines.slice(0, -1);
+        }
+      }
+      if (isTimeout && lines.length === 0) {
+        reject(
+          new RipgrepTimeoutError(
+            `Ripgrep search timed out after ${timeout / 1e3} seconds. Try a more specific path or pattern.`,
+            lines
+          )
+        );
+        return;
+      }
+      resolve(lines);
+    };
+    execFile(
+      rgPath,
+      [...args, target],
+      {
+        maxBuffer: MAX_BUFFER_SIZE,
+        signal: options?.signal,
+        timeout,
+        killSignal: "SIGKILL"
+      },
+      (error, stdout, stderr) => {
+        handleResult(error, stdout, stderr, false);
+      }
+    );
+  });
+}
+
+export {
+  executeRipgrep
+};

package/dist/chunk-OM2UFTGS.cjs

@@ -0,0 +1,47 @@
+"use strict";Object.defineProperty(exports, "__esModule", {value: true}); function _nullishCoalesce(lhs, rhsFn) { if (lhs != null) { return lhs; } else { return rhsFn(); } }
+
+
+var _chunkCAEVLIQBcjs = require('./chunk-CAEVLIQB.cjs');
+
+
+var _chunkQZ5GS6HWcjs = require('./chunk-QZ5GS6HW.cjs');
+
+// src/read/index.ts
+var _ai = require('ai');
+var _zod = require('zod');
+function createRead(config = {}) {
+  const cwd = _nullishCoalesce(config.cwd, () => ( process.cwd()));
+  const defaultMaxLines = _nullishCoalesce(config.maxLines, () => ( 2e3));
+  return _ai.tool.call(void 0, {
+    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: _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 _chunkCAEVLIQBcjs.readFileInRange.call(void 0, 
+          absolutePath,
+          _nullishCoalesce(offset, () => ( 0)),
+          _nullishCoalesce(limit, () => ( defaultMaxLines))
+        );
+        const numbered = _chunkCAEVLIQBcjs.addLineNumbers.call(void 0, {
+          content: result.content,
+          startLine: (_nullishCoalesce(offset, () => ( 0))) + 1
+        });
+        return numbered;
+      } catch (error) {
+        const msg = error instanceof Error ? error.message : String(error);
+        return `Error [read]: ${msg}`;
+      }
+    }
+  });
+}
+var read = createRead();
+
+
+
+
+exports.createRead = createRead; exports.read = read;