agentool 0.0.1 → 1.0.0

package/dist/chunk-6MDPYALY.js

@@ -0,0 +1,196 @@
+// 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",
+    incomingCalls: "textDocument/prepareCallHierarchy",
+    outgoingCalls: "textDocument/prepareCallHierarchy"
+  };
+  return map[operation] ?? operation;
+}
+function buildRequestParams(op, uri, line, char, query) {
+  if (op === "workspaceSymbol") return { query: 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, params.query);
+    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",
+  "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 8 operations: goToDefinition, findReferences, hover, documentSymbol, workspaceSymbol, goToImplementation, 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().optional().describe("Line number (0-indexed)"),
+      character: z.number().optional().describe("Character offset (0-indexed)"),
+      query: z.string().optional().describe("Search query for workspaceSymbol")
+    }),
+    execute: async ({ operation, filePath, line, character, query }) => {
+      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, character, query, 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-6PQLFDGT.js

@@ -0,0 +1,117 @@
+// src/shared/file.ts
+import { createReadStream } from "fs";
+import { mkdir, readFile, stat, writeFile } from "fs/promises";
+import { dirname } from "path";
+var FAST_PATH_MAX_SIZE = 10 * 1024 * 1024;
+function addLineNumbers({
+  content,
+  startLine
+}) {
+  if (!content) {
+    return "";
+  }
+  const lines = content.split(/\r?\n/);
+  return lines.map((line, index) => `${index + startLine}	${line}`).join("\n");
+}
+async function writeTextContent(filePath, content) {
+  await mkdir(dirname(filePath), { recursive: true });
+  await writeFile(filePath, content, { encoding: "utf-8" });
+}
+async function pathExists(path) {
+  try {
+    await stat(path);
+    return true;
+  } catch {
+    return false;
+  }
+}
+async function readFileInRange(filePath, offset = 0, maxLines) {
+  const stats = await stat(filePath);
+  if (stats.isDirectory()) {
+    throw new Error(
+      `EISDIR: illegal operation on a directory, read '${filePath}'`
+    );
+  }
+  if (stats.isFile() && stats.size < FAST_PATH_MAX_SIZE) {
+    const raw = await readFile(filePath, { encoding: "utf-8" });
+    return readFileInRangeFast(raw, offset, maxLines);
+  }
+  return readFileInRangeStreaming(filePath, offset, maxLines);
+}
+function readFileInRangeFast(raw, offset, maxLines) {
+  const text = raw.charCodeAt(0) === 65279 ? raw.slice(1) : raw;
+  const allLines = text.replace(/\r/g, "").split("\n");
+  const totalLines = allLines.length;
+  const endLine = maxLines !== void 0 ? offset + maxLines : totalLines;
+  const selected = allLines.slice(offset, endLine);
+  return {
+    content: selected.join("\n"),
+    lineCount: selected.length,
+    totalLines
+  };
+}
+function readFileInRangeStreaming(filePath, offset, maxLines) {
+  return new Promise((resolve, reject) => {
+    const endLine = maxLines !== void 0 ? offset + maxLines : Infinity;
+    const selectedLines = [];
+    let currentLineIndex = 0;
+    let partial = "";
+    let isFirstChunk = true;
+    const stream = createReadStream(filePath, {
+      encoding: "utf8",
+      highWaterMark: 512 * 1024
+    });
+    stream.on("data", (raw) => {
+      let chunk = String(raw);
+      if (isFirstChunk) {
+        isFirstChunk = false;
+        if (chunk.charCodeAt(0) === 65279) {
+          chunk = chunk.slice(1);
+        }
+      }
+      const data = partial.length > 0 ? partial + chunk : chunk;
+      partial = "";
+      let startPos = 0;
+      let newlinePos;
+      while ((newlinePos = data.indexOf("\n", startPos)) !== -1) {
+        if (currentLineIndex >= offset && currentLineIndex < endLine) {
+          let line = data.slice(startPos, newlinePos);
+          if (line.endsWith("\r")) {
+            line = line.slice(0, -1);
+          }
+          selectedLines.push(line);
+        }
+        currentLineIndex++;
+        startPos = newlinePos + 1;
+      }
+      if (startPos < data.length) {
+        if (currentLineIndex >= offset && currentLineIndex < endLine) {
+          partial = data.slice(startPos);
+        }
+      }
+    });
+    stream.once("end", () => {
+      if (partial.length > 0 && currentLineIndex >= offset && currentLineIndex < endLine) {
+        let line = partial;
+        if (line.endsWith("\r")) {
+          line = line.slice(0, -1);
+        }
+        selectedLines.push(line);
+      }
+      currentLineIndex++;
+      resolve({
+        content: selectedLines.join("\n"),
+        lineCount: selectedLines.length,
+        totalLines: currentLineIndex
+      });
+    });
+    stream.once("error", reject);
+  });
+}
+
+export {
+  addLineNumbers,
+  writeTextContent,
+  pathExists,
+  readFileInRange
+};

package/dist/chunk-7QL4BQCH.js

@@ -0,0 +1,40 @@
+import {
+  pathExists,
+  writeTextContent
+} from "./chunk-6PQLFDGT.js";
+import {
+  expandPath
+} from "./chunk-I3ONDY7P.js";
+
+// src/write/index.ts
+import { tool } from "ai";
+import { z } from "zod";
+function createWrite(config = {}) {
+  const cwd = config.cwd ?? process.cwd();
+  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"),
+      content: z.string().describe("Text content to write to the file")
+    }),
+    execute: async ({ file_path, content }) => {
+      try {
+        const absolutePath = expandPath(file_path, cwd);
+        const existed = await pathExists(absolutePath);
+        await writeTextContent(absolutePath, content);
+        const bytes = Buffer.byteLength(content, "utf-8");
+        const verb = existed ? "Updated" : "Created";
+        return `${verb} file: ${absolutePath} (${bytes} bytes)`;
+      } catch (error) {
+        const message = error instanceof Error ? error.message : String(error);
+        return `Error [write]: Failed to write file: ${message}`;
+      }
+    }
+  });
+}
+var write = createWrite();
+
+export {
+  createWrite,
+  write
+};

package/dist/chunk-CAEVLIQB.cjs

@@ -0,0 +1,117 @@
+"use strict";Object.defineProperty(exports, "__esModule", {value: true});// src/shared/file.ts
+var _fs = require('fs');
+var _promises = require('fs/promises');
+var _path = require('path');
+var FAST_PATH_MAX_SIZE = 10 * 1024 * 1024;
+function addLineNumbers({
+  content,
+  startLine
+}) {
+  if (!content) {
+    return "";
+  }
+  const lines = content.split(/\r?\n/);
+  return lines.map((line, index) => `${index + startLine}	${line}`).join("\n");
+}
+async function writeTextContent(filePath, content) {
+  await _promises.mkdir.call(void 0, _path.dirname.call(void 0, filePath), { recursive: true });
+  await _promises.writeFile.call(void 0, filePath, content, { encoding: "utf-8" });
+}
+async function pathExists(path) {
+  try {
+    await _promises.stat.call(void 0, path);
+    return true;
+  } catch (e) {
+    return false;
+  }
+}
+async function readFileInRange(filePath, offset = 0, maxLines) {
+  const stats = await _promises.stat.call(void 0, filePath);
+  if (stats.isDirectory()) {
+    throw new Error(
+      `EISDIR: illegal operation on a directory, read '${filePath}'`
+    );
+  }
+  if (stats.isFile() && stats.size < FAST_PATH_MAX_SIZE) {
+    const raw = await _promises.readFile.call(void 0, filePath, { encoding: "utf-8" });
+    return readFileInRangeFast(raw, offset, maxLines);
+  }
+  return readFileInRangeStreaming(filePath, offset, maxLines);
+}
+function readFileInRangeFast(raw, offset, maxLines) {
+  const text = raw.charCodeAt(0) === 65279 ? raw.slice(1) : raw;
+  const allLines = text.replace(/\r/g, "").split("\n");
+  const totalLines = allLines.length;
+  const endLine = maxLines !== void 0 ? offset + maxLines : totalLines;
+  const selected = allLines.slice(offset, endLine);
+  return {
+    content: selected.join("\n"),
+    lineCount: selected.length,
+    totalLines
+  };
+}
+function readFileInRangeStreaming(filePath, offset, maxLines) {
+  return new Promise((resolve, reject) => {
+    const endLine = maxLines !== void 0 ? offset + maxLines : Infinity;
+    const selectedLines = [];
+    let currentLineIndex = 0;
+    let partial = "";
+    let isFirstChunk = true;
+    const stream = _fs.createReadStream.call(void 0, filePath, {
+      encoding: "utf8",
+      highWaterMark: 512 * 1024
+    });
+    stream.on("data", (raw) => {
+      let chunk = String(raw);
+      if (isFirstChunk) {
+        isFirstChunk = false;
+        if (chunk.charCodeAt(0) === 65279) {
+          chunk = chunk.slice(1);
+        }
+      }
+      const data = partial.length > 0 ? partial + chunk : chunk;
+      partial = "";
+      let startPos = 0;
+      let newlinePos;
+      while ((newlinePos = data.indexOf("\n", startPos)) !== -1) {
+        if (currentLineIndex >= offset && currentLineIndex < endLine) {
+          let line = data.slice(startPos, newlinePos);
+          if (line.endsWith("\r")) {
+            line = line.slice(0, -1);
+          }
+          selectedLines.push(line);
+        }
+        currentLineIndex++;
+        startPos = newlinePos + 1;
+      }
+      if (startPos < data.length) {
+        if (currentLineIndex >= offset && currentLineIndex < endLine) {
+          partial = data.slice(startPos);
+        }
+      }
+    });
+    stream.once("end", () => {
+      if (partial.length > 0 && currentLineIndex >= offset && currentLineIndex < endLine) {
+        let line = partial;
+        if (line.endsWith("\r")) {
+          line = line.slice(0, -1);
+        }
+        selectedLines.push(line);
+      }
+      currentLineIndex++;
+      resolve({
+        content: selectedLines.join("\n"),
+        lineCount: selectedLines.length,
+        totalLines: currentLineIndex
+      });
+    });
+    stream.once("error", reject);
+  });
+}
+
+
+
+
+
+
+exports.addLineNumbers = addLineNumbers; exports.writeTextContent = writeTextContent; exports.pathExists = pathExists; exports.readFileInRange = readFileInRange;

package/dist/chunk-CGTPF6IS.js

@@ -0,0 +1,90 @@
+import {
+  expandPath
+} from "./chunk-I3ONDY7P.js";
+
+// src/diff/index.ts
+import { readFile as readFile2 } from "fs/promises";
+import { tool } from "ai";
+import { z } from "zod";
+
+// src/shared/diff.ts
+import { readFile } from "fs/promises";
+import { createTwoFilesPatch } from "diff";
+function diffStrings(oldContent, newContent, options) {
+  if (oldContent === newContent) {
+    return "No differences found.";
+  }
+  const context = options?.context ?? 3;
+  const oldLabel = options?.oldLabel ?? "a";
+  const newLabel = options?.newLabel ?? "b";
+  return createTwoFilesPatch(
+    oldLabel,
+    newLabel,
+    oldContent,
+    newContent,
+    void 0,
+    void 0,
+    { context }
+  );
+}
+async function diffFiles(oldFilePath, newFilePath, options) {
+  const [oldContent, newContent] = await Promise.all([
+    readFile(oldFilePath, "utf-8"),
+    readFile(newFilePath, "utf-8")
+  ]);
+  return diffStrings(oldContent, newContent, {
+    ...options,
+    oldLabel: oldFilePath,
+    newLabel: newFilePath
+  });
+}
+
+// src/diff/index.ts
+function createDiff(config = {}) {
+  const cwd = config.cwd ?? process.cwd();
+  return tool({
+    description: "Generate a unified diff between two files or two strings. Provide file_path + other_file_path to compare files, or old_content + new_content to compare strings. You can also provide file_path with old_content or new_content to compare a file against provided content.",
+    inputSchema: z.object({
+      file_path: z.string().optional().describe("Path to the first file (absolute or relative to cwd)"),
+      other_file_path: z.string().optional().describe("Path to the second file (absolute or relative to cwd)"),
+      old_content: z.string().optional().describe("The original content string"),
+      new_content: z.string().optional().describe("The modified content string")
+    }),
+    execute: async ({ file_path, other_file_path, old_content, new_content }) => {
+      try {
+        if (file_path && other_file_path) {
+          const resolvedOld = expandPath(file_path, cwd);
+          const resolvedNew = expandPath(other_file_path, cwd);
+          return await diffFiles(resolvedOld, resolvedNew);
+        }
+        if (old_content !== void 0 && new_content !== void 0 && !file_path) {
+          return diffStrings(old_content, new_content);
+        }
+        if (file_path && (old_content !== void 0 || new_content !== void 0)) {
+          const resolvedPath = expandPath(file_path, cwd);
+          const fileContent = await readFile2(resolvedPath, "utf-8");
+          if (old_content !== void 0) {
+            return diffStrings(old_content, fileContent, {
+              oldLabel: "provided",
+              newLabel: resolvedPath
+            });
+          }
+          return diffStrings(fileContent, new_content, {
+            oldLabel: resolvedPath,
+            newLabel: "provided"
+          });
+        }
+        return "Error [diff]: Insufficient parameters. Provide either: (1) file_path + other_file_path, (2) old_content + new_content, or (3) file_path + old_content/new_content.";
+      } catch (error) {
+        const msg = error instanceof Error ? error.message : String(error);
+        return `Error [diff]: ${msg}`;
+      }
+    }
+  });
+}
+var diff = createDiff();
+
+export {
+  createDiff,
+  diff
+};

package/dist/chunk-EA3YV7ZG.js

@@ -0,0 +1,79 @@
+import {
+  applyEditToFile,
+  findActualString,
+  preserveQuoteStyle
+} from "./chunk-G3ITTPGX.js";
+import {
+  writeTextContent
+} from "./chunk-6PQLFDGT.js";
+import {
+  expandPath
+} from "./chunk-I3ONDY7P.js";
+
+// src/multi-edit/index.ts
+import { readFile } from "fs/promises";
+import { tool } from "ai";
+import { z } from "zod";
+function countOccurrences(text, search) {
+  if (search.length === 0) return 0;
+  let count = 0;
+  let pos = 0;
+  while ((pos = text.indexOf(search, pos)) !== -1) {
+    count++;
+    pos += search.length;
+  }
+  return count;
+}
+function createMultiEdit(config = {}) {
+  const cwd = config.cwd ?? process.cwd();
+  return tool({
+    description: "Atomically apply multiple text edits to a single file. All edits succeed together or none are applied (rollback on failure). Each edit replaces one occurrence of old_string with new_string. Edits are applied sequentially in the order provided.",
+    inputSchema: z.object({
+      file_path: z.string().describe("Path to the file to edit (absolute or relative to cwd)"),
+      edits: z.array(
+        z.object({
+          old_string: z.string().describe("The exact string to find and replace"),
+          new_string: z.string().describe("The replacement string")
+        })
+      ).describe("Ordered list of edits to apply atomically")
+    }),
+    execute: async ({ file_path, edits }) => {
+      try {
+        if (edits.length === 0) {
+          return "No edits provided. File unchanged.";
+        }
+        const resolvedPath = expandPath(file_path, cwd);
+        const originalContent = await readFile(resolvedPath, "utf-8");
+        let content = originalContent;
+        for (let i = 0; i < edits.length; i++) {
+          const edit = edits[i];
+          const actualOldString = findActualString(content, edit.old_string);
+          if (actualOldString === null) {
+            return `Error [multi-edit]: Edit ${i + 1}/${edits.length} failed \u2014 old_string not found in file. No edits were applied. File: ${resolvedPath}`;
+          }
+          const occurrences = countOccurrences(content, actualOldString);
+          if (occurrences > 1) {
+            return `Error [multi-edit]: Edit ${i + 1}/${edits.length} failed \u2014 old_string matches ${occurrences} locations (must be unique). No edits were applied. File: ${resolvedPath}`;
+          }
+          const styledNewString = preserveQuoteStyle(
+            edit.old_string,
+            actualOldString,
+            edit.new_string
+          );
+          content = applyEditToFile(content, actualOldString, styledNewString);
+        }
+        await writeTextContent(resolvedPath, content);
+        return `Successfully applied ${edits.length} edit${edits.length === 1 ? "" : "s"} to ${resolvedPath}`;
+      } catch (error) {
+        const msg = error instanceof Error ? error.message : String(error);
+        return `Error [multi-edit]: ${msg}`;
+      }
+    }
+  });
+}
+var multiEdit = createMultiEdit();
+
+export {
+  createMultiEdit,
+  multiEdit
+};