agentool 0.0.1 → 1.1.0

package/dist/chunk-VLNDEVKS.js

@@ -0,0 +1,102 @@
+import {
+  containsPathTraversal
+} from "./chunk-I3ONDY7P.js";
+
+// src/memory/index.ts
+import { tool } from "ai";
+import { z } from "zod";
+import { mkdir, readFile, readdir, unlink, writeFile } from "fs/promises";
+import { join } from "path";
+function sanitizeKey(key) {
+  if (!key || key.trim() === "") {
+    return { err: "Error [memory]: Key must not be empty." };
+  }
+  if (containsPathTraversal(key)) {
+    return { err: "Error [memory]: Key contains path traversal and was rejected." };
+  }
+  const cleaned = key.replace(/^\.+/, "");
+  if (cleaned === "") {
+    return { err: "Error [memory]: Key must not be empty after stripping leading dots." };
+  }
+  return { ok: cleaned };
+}
+function createMemory(config = {}) {
+  const cwd = config.cwd ?? process.cwd();
+  const memoryDir = config.memoryDir ?? join(cwd, ".agentool", "memory");
+  return tool({
+    description: "File-based key-value memory store. Use this to persist notes, context, or any text data across conversations. Supports write, read, list, and delete operations.",
+    inputSchema: z.object({
+      action: z.enum(["read", "write", "list", "delete"]).describe(
+        "The operation to perform: read, write, list, or delete"
+      ),
+      key: z.string().optional().describe(
+        "The memory key (required for read, write, delete)"
+      ),
+      content: z.string().optional().describe(
+        "The content to store (required for write)"
+      )
+    }),
+    execute: async ({ action, key, content }) => {
+      try {
+        if (action === "list") {
+          return await listKeys(memoryDir);
+        }
+        const result = sanitizeKey(key);
+        if ("err" in result) return result.err;
+        const safeKey = result.ok;
+        switch (action) {
+          case "write":
+            return await writeEntry(memoryDir, safeKey, content);
+          case "read":
+            return await readEntry(memoryDir, safeKey);
+          case "delete":
+            return await deleteEntry(memoryDir, safeKey);
+          default:
+            return `Error [memory]: Unknown action "${String(action)}".`;
+        }
+      } catch (error) {
+        const msg = error instanceof Error ? error.message : String(error);
+        return `Error [memory]: ${msg}`;
+      }
+    }
+  });
+}
+async function writeEntry(dir, key, content) {
+  if (!content && content !== "") {
+    return "Error [memory]: Content is required for write action.";
+  }
+  await mkdir(dir, { recursive: true });
+  await writeFile(join(dir, `${key}.md`), content, "utf-8");
+  return `Saved memory "${key}".`;
+}
+async function readEntry(dir, key) {
+  try {
+    return await readFile(join(dir, `${key}.md`), "utf-8");
+  } catch {
+    return `Error [memory]: Key "${key}" not found.`;
+  }
+}
+async function listKeys(dir) {
+  try {
+    const files = await readdir(dir);
+    const keys = files.filter((f) => f.endsWith(".md")).map((f) => f.slice(0, -3));
+    if (keys.length === 0) return "No memory entries found.";
+    return keys.join("\n");
+  } catch {
+    return "No memory entries found.";
+  }
+}
+async function deleteEntry(dir, key) {
+  try {
+    await unlink(join(dir, `${key}.md`));
+    return `Deleted memory "${key}".`;
+  } catch {
+    return `Error [memory]: Key "${key}" not found.`;
+  }
+}
+var memory = createMemory();
+
+export {
+  createMemory,
+  memory
+};

package/dist/chunk-VXZ4RKJI.js

@@ -0,0 +1,36 @@
+import {
+  formatTask,
+  loadTasks
+} from "./chunk-E6NBEYZD.js";
+
+// src/task-get/index.ts
+import { tool } from "ai";
+import { z } from "zod";
+import { join } from "path";
+function createTaskGet(config = {}) {
+  const cwd = config.cwd ?? process.cwd();
+  const tasksFile = config.tasksFile ?? join(cwd, ".agentool", "tasks.json");
+  return tool({
+    description: "Retrieve a task by its ID to see full details.",
+    inputSchema: z.object({
+      taskId: z.string().describe("The ID of the task to retrieve")
+    }),
+    execute: async ({ taskId }) => {
+      try {
+        const tasks = await loadTasks(tasksFile);
+        const found = tasks.find((t) => t.id === taskId);
+        if (!found) return `Error [task-get]: Task "${taskId}" not found.`;
+        return formatTask(found);
+      } catch (error) {
+        const msg = error instanceof Error ? error.message : String(error);
+        return `Error [task-get]: ${msg}`;
+      }
+    }
+  });
+}
+var taskGet = createTaskGet();
+
+export {
+  createTaskGet,
+  taskGet
+};

package/dist/chunk-XAQGZ374.js

@@ -0,0 +1,197 @@
+// src/lsp/index.ts
+import { tool } from "ai";
+import { z } from "zod";
+import { spawn } from "child_process";
+import { readFile } from "fs/promises";
+import { pathToFileURL } from "url";
+import { resolve, extname } from "path";
+var nextId = 1;
+function encodeJsonRpc(msg) {
+  const body = JSON.stringify(msg);
+  return Buffer.from(`Content-Length: ${Buffer.byteLength(body)}\r
+\r
+${body}`);
+}
+function parseJsonRpcResponses(buffer) {
+  const parsed = [];
+  let offset = 0;
+  while (offset < buffer.length) {
+    const headerEnd = buffer.indexOf("\r\n\r\n", offset);
+    if (headerEnd === -1) break;
+    const match = /Content-Length:\s*(\d+)/i.exec(buffer.subarray(offset, headerEnd).toString());
+    if (!match) break;
+    const bodyStart = headerEnd + 4;
+    const contentLength = parseInt(match[1], 10);
+    if (bodyStart + contentLength > buffer.length) break;
+    try {
+      parsed.push(JSON.parse(buffer.subarray(bodyStart, bodyStart + contentLength).toString()));
+    } catch {
+    }
+    offset = bodyStart + contentLength;
+  }
+  return parsed;
+}
+function operationToMethod(operation) {
+  const map = {
+    goToDefinition: "textDocument/definition",
+    findReferences: "textDocument/references",
+    hover: "textDocument/hover",
+    documentSymbol: "textDocument/documentSymbol",
+    workspaceSymbol: "workspace/symbol",
+    goToImplementation: "textDocument/implementation",
+    prepareCallHierarchy: "textDocument/prepareCallHierarchy",
+    incomingCalls: "textDocument/prepareCallHierarchy",
+    outgoingCalls: "textDocument/prepareCallHierarchy"
+  };
+  return map[operation] ?? operation;
+}
+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 };
+  if (op === "findReferences") return { textDocument: td, position: pos, context: { includeDeclaration: true } };
+  return { textDocument: td, position: pos };
+}
+function sendRequest(proc, method, params) {
+  const id = nextId++;
+  const msg = { jsonrpc: "2.0", id, method, params };
+  proc.stdin.write(encodeJsonRpc(msg));
+  return id;
+}
+function sendNotification(proc, method, params) {
+  const msg = { jsonrpc: "2.0", method, params };
+  proc.stdin.write(encodeJsonRpc(msg));
+}
+function waitForResponse(proc, id, timeoutMs) {
+  return new Promise((resolveP, reject) => {
+    let buf = Buffer.alloc(0);
+    const timer = setTimeout(() => {
+      cleanup();
+      reject(new Error(`LSP request timed out after ${timeoutMs}ms`));
+    }, timeoutMs);
+    const cleanup = () => {
+      clearTimeout(timer);
+      proc.stdout.off("data", onData);
+      proc.stdout.off("error", onErr);
+    };
+    function onData(chunk) {
+      buf = Buffer.concat([buf, chunk]);
+      for (const msg of parseJsonRpcResponses(buf)) {
+        const rpc = msg;
+        if (rpc.id === id) {
+          cleanup();
+          resolveP(rpc.error ? { error: rpc.error } : { result: rpc.result });
+          return;
+        }
+      }
+    }
+    function onErr(e) {
+      cleanup();
+      reject(e);
+    }
+    proc.stdout.on("data", onData);
+    proc.stdout.on("error", onErr);
+  });
+}
+async function shutdownServer(proc, ms) {
+  try {
+    const id = sendRequest(proc, "shutdown", {});
+    await waitForResponse(proc, id, Math.min(ms, 5e3));
+    sendNotification(proc, "exit", {});
+  } catch {
+  } finally {
+    proc.kill();
+  }
+}
+async function executeLspOperation(serverConfig, params, timeoutMs) {
+  const absolutePath = resolve(params.cwd, params.filePath);
+  const uri = pathToFileURL(absolutePath).href;
+  const proc = spawn(serverConfig.command, serverConfig.args ?? [], {
+    cwd: params.cwd,
+    stdio: ["pipe", "pipe", "pipe"]
+  });
+  const spawnError = new Promise((_, reject) => {
+    proc.on("error", (err) => reject(err));
+  });
+  try {
+    const initId = sendRequest(proc, "initialize", {
+      processId: process.pid,
+      capabilities: {},
+      rootUri: pathToFileURL(params.cwd).href
+    });
+    const rpc = (id) => Promise.race([waitForResponse(proc, id, timeoutMs), spawnError]);
+    await rpc(initId);
+    sendNotification(proc, "initialized", {});
+    const content = await readFile(absolutePath, "utf-8");
+    const langId = extname(absolutePath).replace(".", "") || "plaintext";
+    sendNotification(proc, "textDocument/didOpen", {
+      textDocument: { uri, languageId: langId, version: 1, text: content }
+    });
+    const method = operationToMethod(params.operation);
+    const reqParams = buildRequestParams(params.operation, uri, params.line ?? 0, 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) {
+      const cm = params.operation === "incomingCalls" ? "callHierarchy/incomingCalls" : "callHierarchy/outgoingCalls";
+      response = await rpc(sendRequest(proc, cm, { item: response.result[0] }));
+      if (response.error) return `Error [lsp]: Server error: ${response.error.message} (code ${response.error.code})`;
+    }
+    await shutdownServer(proc, timeoutMs);
+    return JSON.stringify(response.result, null, 2) ?? "null";
+  } catch (error) {
+    proc.kill();
+    throw error;
+  }
+}
+var LSP_OPERATIONS = [
+  "goToDefinition",
+  "findReferences",
+  "hover",
+  "documentSymbol",
+  "workspaceSymbol",
+  "goToImplementation",
+  "prepareCallHierarchy",
+  "incomingCalls",
+  "outgoingCalls"
+];
+function createLsp(config = {}) {
+  const timeoutMs = config.timeout ?? 3e4;
+  return tool({
+    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: z.object({
+      operation: z.enum(LSP_OPERATIONS).describe("The LSP operation to perform"),
+      filePath: z.string().describe("Path to the file"),
+      line: z.number().int().positive().describe("The line number (1-based, as shown in editors)"),
+      character: z.number().int().positive().describe("The character offset (1-based, as shown in editors)")
+    }),
+    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"] } } })';
+      }
+      const ext = extname(filePath) || "." + filePath.split(".").pop();
+      const serverConfig = config.servers[ext];
+      if (!serverConfig) {
+        const available = Object.keys(config.servers).join(", ");
+        return `Error [lsp]: No LSP server configured for ${ext} files. Available: ${available}`;
+      }
+      try {
+        return await executeLspOperation(
+          serverConfig,
+          { operation, filePath, line: line - 1, character: character - 1, cwd: config.cwd ?? process.cwd() },
+          timeoutMs
+        );
+      } catch (error) {
+        const msg = error instanceof Error ? error.message : String(error);
+        return `Error [lsp]: ${operation} failed for ${filePath}: ${msg}`;
+      }
+    }
+  });
+}
+var lsp = createLsp();
+
+export {
+  executeLspOperation,
+  createLsp,
+  lsp
+};

package/dist/chunk-YPPPGGLA.cjs

@@ -0,0 +1,99 @@
+"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 _chunkMIYA7TNRcjs = require('./chunk-MIYA7TNR.cjs');
+
+
+var _chunkQZ5GS6HWcjs = require('./chunk-QZ5GS6HW.cjs');
+
+// src/glob/index.ts
+var _ai = require('ai');
+var _zod = require('zod');
+
+// src/shared/glob.ts
+var _path = require('path');
+function extractGlobBaseDirectory(pattern) {
+  const globChars = /[*?[{]/;
+  const match = pattern.match(globChars);
+  if (!match || match.index === void 0) {
+    const dir = _path.dirname.call(void 0, pattern);
+    const file = _path.basename.call(void 0, pattern);
+    return { baseDir: dir, relativePattern: file };
+  }
+  const staticPrefix = pattern.slice(0, match.index);
+  const lastSepIndex = Math.max(
+    staticPrefix.lastIndexOf("/"),
+    staticPrefix.lastIndexOf(_path.sep)
+  );
+  if (lastSepIndex === -1) {
+    return { baseDir: "", relativePattern: pattern };
+  }
+  let baseDir = staticPrefix.slice(0, lastSepIndex);
+  const relativePattern = pattern.slice(lastSepIndex + 1);
+  if (baseDir === "" && lastSepIndex === 0) {
+    baseDir = "/";
+  }
+  return { baseDir, relativePattern };
+}
+async function glob(pattern, cwd, options) {
+  const limit = _nullishCoalesce(_optionalChain([options, 'optionalAccess', _ => _.limit]), () => ( 100));
+  const offset = _nullishCoalesce(_optionalChain([options, 'optionalAccess', _2 => _2.offset]), () => ( 0));
+  let searchDir = cwd;
+  let searchPattern = pattern;
+  if (_path.isAbsolute.call(void 0, pattern)) {
+    const { baseDir, relativePattern } = extractGlobBaseDirectory(pattern);
+    if (baseDir) {
+      searchDir = baseDir;
+      searchPattern = relativePattern;
+    }
+  }
+  const args = [
+    "--files",
+    "--glob",
+    searchPattern,
+    "--sort=modified",
+    "--hidden",
+    "--no-ignore"
+  ];
+  const allPaths = await _chunkMIYA7TNRcjs.executeRipgrep.call(void 0, args, searchDir, {
+    signal: _optionalChain([options, 'optionalAccess', _3 => _3.signal])
+  });
+  const absolutePaths = allPaths.map(
+    (p) => _path.isAbsolute.call(void 0, p) ? p : _path.join.call(void 0, searchDir, p)
+  );
+  const truncated = absolutePaths.length > offset + limit;
+  const files = absolutePaths.slice(offset, offset + limit);
+  return { files, truncated };
+}
+
+// src/glob/index.ts
+function createGlob(config = {}) {
+  const cwd = _nullishCoalesce(config.cwd, () => ( process.cwd()));
+  return _ai.tool.call(void 0, {
+    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".',
+    inputSchema: _zod.z.object({
+      pattern: _zod.z.string().describe("Glob pattern to match files against"),
+      path: _zod.z.string().optional().describe("Directory to search in. Defaults to the working directory.")
+    }),
+    execute: async ({ pattern, path }) => {
+      try {
+        const searchDir = path ? _chunkQZ5GS6HWcjs.expandPath.call(void 0, path, cwd) : cwd;
+        const { files, truncated } = await glob(pattern, searchDir);
+        if (files.length === 0) {
+          return "No files found";
+        }
+        const header = truncated ? `Found ${files.length}+ files (results truncated)` : `Found ${files.length} files`;
+        return `${header}
+${files.join("\n")}`;
+      } catch (error) {
+        const message = error instanceof Error ? error.message : String(error);
+        return `Error [glob]: Failed to search for files: ${message}`;
+      }
+    }
+  });
+}
+var glob2 = createGlob();
+
+
+
+
+exports.createGlob = createGlob; exports.glob = glob2;

package/dist/chunk-ZBLQV6UO.cjs

@@ -0,0 +1,73 @@
+"use strict";Object.defineProperty(exports, "__esModule", {value: true});
+
+
+
+var _chunk5NW4OGRIcjs = require('./chunk-5NW4OGRI.cjs');
+
+
+var _chunkQZ5GS6HWcjs = require('./chunk-QZ5GS6HW.cjs');
+
+// src/edit/index.ts
+var _promises = require('fs/promises');
+var _ai = require('ai');
+var _zod = require('zod');
+function createEdit(config = {}) {
+  return _ai.tool.call(void 0, {
+    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: _zod.z.object({
+      file_path: _zod.z.string().describe("The absolute path to the file to modify"),
+      old_string: _zod.z.string().describe("The exact string to find and replace"),
+      new_string: _zod.z.string().describe("The replacement string"),
+      replace_all: _zod.z.boolean().default(false).optional().describe("Replace all occurrences (default: false)")
+    }),
+    execute: async ({ file_path, old_string, new_string, replace_all }) => {
+      try {
+        const resolved = _chunkQZ5GS6HWcjs.expandPath.call(void 0, file_path, config.cwd);
+        let content;
+        try {
+          content = await _promises.readFile.call(void 0, 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 = _chunk5NW4OGRIcjs.findActualString.call(void 0, 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 = _chunk5NW4OGRIcjs.preserveQuoteStyle.call(void 0, old_string, actualOld, new_string);
+        const updated = _chunk5NW4OGRIcjs.applyEditToFile.call(void 0, content, actualOld, styledNew, replace_all);
+        await _promises.writeFile.call(void 0, 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();
+
+
+
+
+exports.createEdit = createEdit; exports.edit = edit;

package/dist/chunk-ZFQZWXOI.cjs

@@ -0,0 +1,75 @@
+"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-update/index.ts
+var _ai = require('ai');
+var _zod = require('zod');
+var _path = require('path');
+function createTaskUpdate(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: "Update a task by its ID. Can change status, subject, description, owner, metadata, and dependency relationships.",
+    inputSchema: _zod.z.object({
+      taskId: _zod.z.string().describe("The ID of the task to update"),
+      subject: _zod.z.string().optional().describe("New subject for the task"),
+      description: _zod.z.string().optional().describe("New description"),
+      status: _zod.z.enum(["pending", "in_progress", "completed", "deleted"]).optional().describe("New status for the task"),
+      owner: _zod.z.string().optional().describe("New owner for the task"),
+      activeForm: _zod.z.string().optional().describe("Present continuous form shown in spinner when in_progress"),
+      addBlocks: _zod.z.array(_zod.z.string()).optional().describe("Task IDs that this task blocks"),
+      addBlockedBy: _zod.z.array(_zod.z.string()).optional().describe("Task IDs that block this task"),
+      metadata: _zod.z.record(_zod.z.string(), _zod.z.unknown()).optional().describe("Metadata keys to merge. Set key to null to delete.")
+    }),
+    execute: async (input) => {
+      try {
+        const tasks = await _chunkL5JH4I77cjs.loadTasks.call(void 0, 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 _chunkL5JH4I77cjs.saveTasks.call(void 0, tasksFile, tasks);
+        return `Updated task ${input.taskId}.
+${_chunkL5JH4I77cjs.formatTask.call(void 0, entry)}`;
+      } catch (error) {
+        const msg = error instanceof Error ? error.message : String(error);
+        return `Error [task-update]: ${msg}`;
+      }
+    }
+  });
+}
+var taskUpdate = createTaskUpdate();
+
+
+
+
+exports.createTaskUpdate = createTaskUpdate; exports.taskUpdate = taskUpdate;

package/dist/context-compaction/index.cjs

@@ -0,0 +1,8 @@
+"use strict";Object.defineProperty(exports, "__esModule", {value: true});
+
+
+var _chunkFW3UJ622cjs = require('../chunk-FW3UJ622.cjs');
+
+
+
+exports.contextCompaction = _chunkFW3UJ622cjs.contextCompaction; exports.createContextCompaction = _chunkFW3UJ622cjs.createContextCompaction;

package/dist/context-compaction/index.d.cts

@@ -0,0 +1,77 @@
+import * as ai from 'ai';
+import { B as BaseToolConfig } from '../types-3QPDuCXN.cjs';
+
+/**
+ * Configuration for the context compaction tool.
+ * Extends {@link BaseToolConfig} with summarization options.
+ *
+ * @example
+ * ```typescript
+ * import { createContextCompaction } from 'agentool/context-compaction';
+ *
+ * const compactor = createContextCompaction({
+ *   summarize: async (msgs) => `Summary of ${msgs.length} messages`,
+ *   maxTokens: 2048,
+ * });
+ * ```
+ */
+interface ContextCompactionConfig extends BaseToolConfig {
+    /**
+     * Function that summarizes messages into a shorter form.
+     * Consumer must provide this for compaction to work.
+     */
+    summarize?: (messages: Array<{
+        role: string;
+        content: string;
+    }>) => Promise<string>;
+    /** Maximum tokens target. Defaults to 4096. */
+    maxTokens?: number;
+}
+/**
+ * Create a context compaction tool with the given configuration.
+ * Summarizes conversation history to reduce context size when it
+ * exceeds the token budget (estimated as maxTokens * 4 characters).
+ *
+ * @param config - Configuration including the summarize callback and token budget
+ * @returns An AI SDK tool that compacts conversation messages
+ *
+ * @example
+ * ```typescript
+ * import { createContextCompaction } from 'agentool/context-compaction';
+ *
+ * const compactor = createContextCompaction({
+ *   summarize: async (msgs) => {
+ *     // Call your LLM to summarize
+ *     return 'Condensed summary of the conversation';
+ *   },
+ *   maxTokens: 4096,
+ * });
+ * ```
+ */
+declare function createContextCompaction(config?: ContextCompactionConfig): ai.Tool<{
+    messages: {
+        content: string;
+        role: string;
+    }[];
+    maxTokens?: number | undefined;
+}, string>;
+/**
+ * Default context compaction tool instance with no summarize function.
+ * Configure with {@link createContextCompaction} for full functionality.
+ *
+ * @example
+ * ```typescript
+ * import { contextCompaction } from 'agentool/context-compaction';
+ * // Use directly — will return error if messages exceed budget
+ * // since no summarize function is configured.
+ * ```
+ */
+declare const contextCompaction: ai.Tool<{
+    messages: {
+        content: string;
+        role: string;
+    }[];
+    maxTokens?: number | undefined;
+}, string>;
+
+export { type ContextCompactionConfig, contextCompaction, createContextCompaction };