agentool 0.0.1 → 1.0.0

package/dist/chunk-IMZQ7ELK.cjs

@@ -0,0 +1,196 @@
+"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",
+    incomingCalls: "textDocument/prepareCallHierarchy",
+    outgoingCalls: "textDocument/prepareCallHierarchy"
+  };
+  return _nullishCoalesce(map[operation], () => ( operation));
+}
+function buildRequestParams(op, uri, line, char, query) {
+  if (op === "workspaceSymbol") return { query: _nullishCoalesce(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)), 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 _nullishCoalesce(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 = _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 8 operations: goToDefinition, findReferences, hover, documentSymbol, workspaceSymbol, goToImplementation, 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().optional().describe("Line number (0-indexed)"),
+      character: _zod.z.number().optional().describe("Character offset (0-indexed)"),
+      query: _zod.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 = _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, character, query, 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-JCTBB7H2.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("Path to the file to write"),
+      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;

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-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-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
+};