agentool 0.0.1 → 1.1.0

package/dist/chunk-4YI2H55A.js

@@ -0,0 +1,142 @@
+// src/bash/index.ts
+import { tool } from "ai";
+import { z } from "zod";
+
+// src/shared/shell.ts
+import { spawn } from "child_process";
+var MAX_BUFFER_BYTES = 10 * 1024 * 1024;
+var DEFAULT_TIMEOUT_MS = 12e4;
+var SIGKILL_GRACE_MS = 5e3;
+async function executeShell(command, options) {
+  const shellBin = options?.shell ?? process.env.SHELL ?? "/bin/bash";
+  const timeout = options?.timeout ?? DEFAULT_TIMEOUT_MS;
+  return new Promise((resolve, reject) => {
+    const child = spawn(shellBin, ["-c", command], {
+      cwd: options?.cwd,
+      stdio: ["pipe", "pipe", "pipe"],
+      // Prevent visible console window on Windows (no-op elsewhere)
+      windowsHide: true
+    });
+    let stdout = "";
+    let stderr = "";
+    let stdoutBytes = 0;
+    let stderrBytes = 0;
+    let settled = false;
+    let timeoutId;
+    let graceId;
+    function cleanup() {
+      if (timeoutId !== void 0) {
+        clearTimeout(timeoutId);
+        timeoutId = void 0;
+      }
+      if (graceId !== void 0) {
+        clearTimeout(graceId);
+        graceId = void 0;
+      }
+      if (abortHandler && options?.signal) {
+        options.signal.removeEventListener("abort", abortHandler);
+      }
+    }
+    function settle(result) {
+      if (settled) return;
+      settled = true;
+      cleanup();
+      resolve(result);
+    }
+    child.stdout.on("data", (chunk) => {
+      if (stdoutBytes >= MAX_BUFFER_BYTES) return;
+      const str = chunk.toString();
+      const remaining = MAX_BUFFER_BYTES - stdoutBytes;
+      if (chunk.length > remaining) {
+        stdout += str.slice(0, remaining);
+        stdoutBytes = MAX_BUFFER_BYTES;
+      } else {
+        stdout += str;
+        stdoutBytes += chunk.length;
+      }
+    });
+    child.stderr.on("data", (chunk) => {
+      if (stderrBytes >= MAX_BUFFER_BYTES) return;
+      const str = chunk.toString();
+      const remaining = MAX_BUFFER_BYTES - stderrBytes;
+      if (chunk.length > remaining) {
+        stderr += str.slice(0, remaining);
+        stderrBytes = MAX_BUFFER_BYTES;
+      } else {
+        stderr += str;
+        stderrBytes += chunk.length;
+      }
+    });
+    child.on("exit", (code, signal) => {
+      const exitCode = code !== null ? code : signal === "SIGKILL" ? 137 : signal === "SIGTERM" ? 143 : 1;
+      settle({ stdout, stderr, exitCode });
+    });
+    child.on("error", (err) => {
+      if (settled) return;
+      settled = true;
+      cleanup();
+      reject(err);
+    });
+    if (timeout > 0) {
+      timeoutId = setTimeout(() => {
+        timeoutId = void 0;
+        if (settled) return;
+        child.kill("SIGTERM");
+        graceId = setTimeout(() => {
+          graceId = void 0;
+          if (settled) return;
+          child.kill("SIGKILL");
+        }, SIGKILL_GRACE_MS);
+      }, timeout);
+    }
+    const abortHandler = options?.signal ? () => {
+      if (settled) return;
+      child.kill("SIGTERM");
+    } : void 0;
+    if (abortHandler && options?.signal) {
+      if (options.signal.aborted) {
+        child.kill("SIGTERM");
+      } else {
+        options.signal.addEventListener("abort", abortHandler, { once: true });
+      }
+    }
+  });
+}
+
+// src/bash/index.ts
+function createBash(config = {}) {
+  const cwd = config.cwd ?? process.cwd();
+  const timeout = config.timeout ?? 12e4;
+  return tool({
+    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.",
+    inputSchema: z.object({
+      command: z.string().describe("The shell command to execute"),
+      timeout: z.number().optional().describe("Timeout in milliseconds (default: 120000)"),
+      description: z.string().optional().describe("Human-readable description of what the command does")
+    }),
+    execute: async ({ command, timeout: cmdTimeout }) => {
+      try {
+        const result = await executeShell(command, {
+          cwd,
+          timeout: cmdTimeout ?? timeout,
+          shell: config.shell
+        });
+        const parts = [];
+        if (result.stdout) parts.push(result.stdout);
+        if (result.stderr) parts.push(`STDERR:
+${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);
+        return `Error [bash]: Failed to execute command: ${msg}`;
+      }
+    }
+  });
+}
+var bash = createBash();
+
+export {
+  createBash,
+  bash
+};

package/dist/chunk-56CL4JCW.cjs

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

package/dist/chunk-5NW4OGRI.cjs

@@ -0,0 +1,99 @@
+"use strict";Object.defineProperty(exports, "__esModule", {value: true});// src/shared/edit-helpers.ts
+var LEFT_SINGLE_CURLY_QUOTE = "\u2018";
+var RIGHT_SINGLE_CURLY_QUOTE = "\u2019";
+var LEFT_DOUBLE_CURLY_QUOTE = "\u201C";
+var RIGHT_DOUBLE_CURLY_QUOTE = "\u201D";
+function normalizeQuotes(str) {
+  return str.replaceAll(LEFT_SINGLE_CURLY_QUOTE, "'").replaceAll(RIGHT_SINGLE_CURLY_QUOTE, "'").replaceAll(LEFT_DOUBLE_CURLY_QUOTE, '"').replaceAll(RIGHT_DOUBLE_CURLY_QUOTE, '"');
+}
+function findActualString(fileContent, searchString) {
+  if (fileContent.includes(searchString)) {
+    return searchString;
+  }
+  const normalizedSearch = normalizeQuotes(searchString);
+  const normalizedFile = normalizeQuotes(fileContent);
+  const searchIndex = normalizedFile.indexOf(normalizedSearch);
+  if (searchIndex !== -1) {
+    return fileContent.substring(
+      searchIndex,
+      searchIndex + searchString.length
+    );
+  }
+  return null;
+}
+function preserveQuoteStyle(oldString, actualOldString, newString) {
+  if (oldString === actualOldString) {
+    return newString;
+  }
+  const hasDoubleQuotes = actualOldString.includes(LEFT_DOUBLE_CURLY_QUOTE) || actualOldString.includes(RIGHT_DOUBLE_CURLY_QUOTE);
+  const hasSingleQuotes = actualOldString.includes(LEFT_SINGLE_CURLY_QUOTE) || actualOldString.includes(RIGHT_SINGLE_CURLY_QUOTE);
+  if (!hasDoubleQuotes && !hasSingleQuotes) {
+    return newString;
+  }
+  let result = newString;
+  if (hasDoubleQuotes) {
+    result = applyCurlyDoubleQuotes(result);
+  }
+  if (hasSingleQuotes) {
+    result = applyCurlySingleQuotes(result);
+  }
+  return result;
+}
+function applyEditToFile(originalContent, oldString, newString, replaceAll = false) {
+  const f = replaceAll ? (content, search, replace) => content.replaceAll(search, () => replace) : (content, search, replace) => content.replace(search, () => replace);
+  if (newString !== "") {
+    return f(originalContent, oldString, newString);
+  }
+  const stripTrailingNewline = !oldString.endsWith("\n") && originalContent.includes(oldString + "\n");
+  return stripTrailingNewline ? f(originalContent, oldString + "\n", newString) : f(originalContent, oldString, newString);
+}
+function isOpeningContext(chars, index) {
+  if (index === 0) {
+    return true;
+  }
+  const prev = chars[index - 1];
+  return prev === " " || prev === "	" || prev === "\n" || prev === "\r" || prev === "(" || prev === "[" || prev === "{" || prev === "\u2014" || // em dash
+  prev === "\u2013";
+}
+function applyCurlyDoubleQuotes(str) {
+  const chars = [...str];
+  const result = [];
+  for (let i = 0; i < chars.length; i++) {
+    if (chars[i] === '"') {
+      result.push(
+        isOpeningContext(chars, i) ? LEFT_DOUBLE_CURLY_QUOTE : RIGHT_DOUBLE_CURLY_QUOTE
+      );
+    } else {
+      result.push(chars[i]);
+    }
+  }
+  return result.join("");
+}
+function applyCurlySingleQuotes(str) {
+  const chars = [...str];
+  const result = [];
+  for (let i = 0; i < chars.length; i++) {
+    if (chars[i] === "'") {
+      const prev = i > 0 ? chars[i - 1] : void 0;
+      const next = i < chars.length - 1 ? chars[i + 1] : void 0;
+      const prevIsLetter = prev !== void 0 && new RegExp("\\p{L}", "u").test(prev);
+      const nextIsLetter = next !== void 0 && new RegExp("\\p{L}", "u").test(next);
+      if (prevIsLetter && nextIsLetter) {
+        result.push(RIGHT_SINGLE_CURLY_QUOTE);
+      } else {
+        result.push(
+          isOpeningContext(chars, i) ? LEFT_SINGLE_CURLY_QUOTE : RIGHT_SINGLE_CURLY_QUOTE
+        );
+      }
+    } else {
+      result.push(chars[i]);
+    }
+  }
+  return result.join("");
+}
+
+
+
+
+
+exports.findActualString = findActualString; exports.preserveQuoteStyle = preserveQuoteStyle; exports.applyEditToFile = applyEditToFile;

package/dist/chunk-5O55DKOB.cjs

@@ -0,0 +1,112 @@
+"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
+var _ai = require('ai');
+var _zod = require('zod');
+
+// src/shared/fetch.ts
+var MAX_MARKDOWN_LENGTH = 1e5;
+var DEFAULT_TIMEOUT_MS = 3e4;
+var DEFAULT_MAX_CONTENT_LENGTH = 10 * 1024 * 1024;
+var turndownPromise;
+function getTurndownService() {
+  return turndownPromise ??= Promise.resolve().then(() => _interopRequireWildcard(require("turndown"))).then((m) => {
+    const Turndown = m.default;
+    return new Turndown();
+  });
+}
+function composeSignal(timeoutMs, userSignal) {
+  const timeoutSignal = AbortSignal.timeout(timeoutMs);
+  if (!userSignal) {
+    return timeoutSignal;
+  }
+  return AbortSignal.any([timeoutSignal, userSignal]);
+}
+async function fetchUrl(url, options) {
+  const timeoutMs = _nullishCoalesce(_optionalChain([options, 'optionalAccess', _ => _.timeout]), () => ( DEFAULT_TIMEOUT_MS));
+  const maxBytes = _nullishCoalesce(_optionalChain([options, 'optionalAccess', _2 => _2.maxContentLength]), () => ( DEFAULT_MAX_CONTENT_LENGTH));
+  const signal = composeSignal(timeoutMs, _optionalChain([options, 'optionalAccess', _3 => _3.signal]));
+  const headers = {
+    Accept: "text/markdown, text/html, */*"
+  };
+  if (_optionalChain([options, 'optionalAccess', _4 => _4.userAgent])) {
+    headers["User-Agent"] = options.userAgent;
+  }
+  const response = await fetch(url, { signal, headers });
+  const chunks = [];
+  let totalBytes = 0;
+  if (response.body) {
+    const reader = response.body.getReader();
+    for (; ; ) {
+      const { done, value } = await reader.read();
+      if (done) break;
+      totalBytes += value.byteLength;
+      if (totalBytes > maxBytes) {
+        await reader.cancel();
+        throw new Error(
+          `Response body exceeds maxContentLength (${maxBytes} bytes)`
+        );
+      }
+      chunks.push(value);
+    }
+  }
+  const rawBuffer = Buffer.concat(chunks);
+  const byteLength = rawBuffer.length;
+  const contentType = _nullishCoalesce(response.headers.get("content-type"), () => ( ""));
+  const textContent = rawBuffer.toString("utf-8");
+  let content;
+  if (contentType.includes("text/html")) {
+    const td = await getTurndownService();
+    content = td.turndown(textContent);
+  } else {
+    content = textContent;
+  }
+  let truncated = false;
+  if (content.length > MAX_MARKDOWN_LENGTH) {
+    content = content.slice(0, MAX_MARKDOWN_LENGTH);
+    truncated = true;
+  }
+  return {
+    content,
+    contentType,
+    statusCode: response.status,
+    byteLength,
+    truncated
+  };
+}
+
+// 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.",
+    inputSchema: _zod.z.object({
+      url: _zod.z.string().url().describe("The URL to fetch")
+    }),
+    execute: async ({ url }) => {
+      try {
+        const result = await fetchUrl(url, {
+          timeout: _nullishCoalesce(config.timeout, () => ( 3e4)),
+          maxContentLength: config.maxContentLength,
+          userAgent: config.userAgent
+        });
+        const parts = [];
+        parts.push(`URL: ${url}`);
+        parts.push(`Status: ${result.statusCode}`);
+        parts.push(`Content-Type: ${result.contentType}`);
+        if (result.truncated) {
+          parts.push("(Content truncated to 100,000 characters)");
+        }
+        parts.push("");
+        parts.push(result.content);
+        return parts.join("\n");
+      } catch (error) {
+        const msg = error instanceof Error ? error.message : String(error);
+        return `Error [web-fetch]: Failed to fetch ${url}: ${msg}`;
+      }
+    }
+  });
+}
+var webFetch = createWebFetch();
+
+
+
+
+exports.createWebFetch = createWebFetch; exports.webFetch = webFetch;

package/dist/chunk-5TDZF4IM.cjs

@@ -0,0 +1,197 @@
+"use strict";Object.defineProperty(exports, "__esModule", {value: true}); function _nullishCoalesce(lhs, rhsFn) { if (lhs != null) { return lhs; } else { return rhsFn(); } }// src/lsp/index.ts
+var _ai = require('ai');
+var _zod = require('zod');
+var _child_process = require('child_process');
+var _promises = require('fs/promises');
+var _url = require('url');
+var _path = require('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 (e2) {
+    }
+    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 _nullishCoalesce(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 (e3) {
+  } finally {
+    proc.kill();
+  }
+}
+async function executeLspOperation(serverConfig, params, timeoutMs) {
+  const absolutePath = _path.resolve.call(void 0, params.cwd, params.filePath);
+  const uri = _url.pathToFileURL.call(void 0, absolutePath).href;
+  const proc = _child_process.spawn.call(void 0, serverConfig.command, _nullishCoalesce(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: _url.pathToFileURL.call(void 0, params.cwd).href
+    });
+    const rpc = (id) => Promise.race([waitForResponse(proc, id, timeoutMs), spawnError]);
+    await rpc(initId);
+    sendNotification(proc, "initialized", {});
+    const content = await _promises.readFile.call(void 0, absolutePath, "utf-8");
+    const langId = _path.extname.call(void 0, 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, _nullishCoalesce(params.line, () => ( 0)), _nullishCoalesce(params.character, () => ( 0)));
+    let response = await rpc(sendRequest(proc, method, reqParams));
+    if (response.error) return `Error [lsp]: Server error: ${response.error.message} (code ${response.error.code})`;
+    if ((params.operation === "incomingCalls" || params.operation === "outgoingCalls") && Array.isArray(response.result) && response.result.length > 0) {
+      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 _nullishCoalesce(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 = _nullishCoalesce(config.timeout, () => ( 3e4));
+  return _ai.tool.call(void 0, {
+    description: "Perform language server operations like go-to-definition, find-references, and hover. Requires LSP server configuration. Supports 9 operations: goToDefinition, findReferences, hover, documentSymbol, workspaceSymbol, goToImplementation, prepareCallHierarchy, incomingCalls, outgoingCalls.",
+    inputSchema: _zod.z.object({
+      operation: _zod.z.enum(LSP_OPERATIONS).describe("The LSP operation to perform"),
+      filePath: _zod.z.string().describe("Path to the file"),
+      line: _zod.z.number().int().positive().describe("The line number (1-based, as shown in editors)"),
+      character: _zod.z.number().int().positive().describe("The character offset (1-based, as shown in editors)")
+    }),
+    execute: async ({ operation, filePath, line, character }) => {
+      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 = _path.extname.call(void 0, 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: _nullishCoalesce(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();
+
+
+
+
+
+exports.executeLspOperation = executeLspOperation; exports.createLsp = createLsp; exports.lsp = lsp;

package/dist/chunk-6DJSWTWQ.cjs

@@ -0,0 +1,40 @@
+"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/write/index.ts
+var _ai = require('ai');
+var _zod = require('zod');
+function createWrite(config = {}) {
+  const cwd = _nullishCoalesce(config.cwd, () => ( process.cwd()));
+  return _ai.tool.call(void 0, {
+    description: "Write text content to a file, creating parent directories as needed. If the file exists it is overwritten. Use this to create new files or replace existing file contents.",
+    inputSchema: _zod.z.object({
+      file_path: _zod.z.string().describe("The absolute path to the file to write (must be absolute, not relative)"),
+      content: _zod.z.string().describe("Text content to write to the file")
+    }),
+    execute: async ({ file_path, content }) => {
+      try {
+        const absolutePath = _chunkQZ5GS6HWcjs.expandPath.call(void 0, file_path, cwd);
+        const existed = await _chunkCAEVLIQBcjs.pathExists.call(void 0, absolutePath);
+        await _chunkCAEVLIQBcjs.writeTextContent.call(void 0, 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();
+
+
+
+
+exports.createWrite = createWrite; exports.write = write;