@supyagent/sdk 0.2.1 → 0.3.0

package/dist/index.cjs

@@ -22,8 +22,14 @@ var src_exports = {};
 __export(src_exports, {
   buildSkillsSystemPrompt: () => buildSkillsSystemPrompt,
   createApiCallTool: () => createApiCallTool,
+  createAppendFileTool: () => createAppendFileTool,
   createBashTool: () => createBashTool,
+  createEditFileTool: () => createEditFileTool,
+  createFindTool: () => createFindTool,
+  createGrepTool: () => createGrepTool,
+  createHttpRequestTool: () => createHttpRequestTool,
   createLoadSkillTool: () => createLoadSkillTool,
+  createReadFileRangeTool: () => createReadFileRangeTool,
   createViewImageTool: () => createViewImageTool,
   findSkill: () => findSkill,
   parseSkillsMarkdown: () => parseSkillsMarkdown,
@@ -843,7 +849,7 @@ function createBashTool(options) {
         };
       }
       const start = Date.now();
-      return new Promise((resolve) => {
+      return new Promise((resolve6) => {
         const child = (0, import_node_child_process.exec)(
           command,
           {
@@ -857,7 +863,7 @@ function createBashTool(options) {
             const durationMs = Date.now() - start;
             const timedOut = error?.killed === true;
             const exitCode = timedOut ? 124 : typeof error?.code === "number" ? error.code : error ? 1 : 0;
-            resolve({
+            resolve6({
               stdout: truncate(stdout, maxOutput),
               stderr: truncate(stderr, maxOutput),
               exitCode,
@@ -867,7 +873,7 @@ function createBashTool(options) {
           }
         );
         child.on("error", () => {
-          resolve({
+          resolve6({
             stdout: "",
             stderr: "Failed to start process",
             exitCode: 127,
@@ -910,12 +916,504 @@ function createViewImageTool(options) {
     }
   });
 }
+
+// src/tools/edit-file.ts
+var import_ai5 = require("ai");
+var import_promises = require("fs/promises");
+var import_node_path = require("path");
+function createEditFileTool(options) {
+  const cwd = options?.cwd ?? process.cwd();
+  const maxFileSize = options?.maxFileSize ?? 1048576;
+  const schema = {
+    type: "object",
+    properties: {
+      path: {
+        type: "string",
+        description: "File path to edit (absolute or relative to working directory)"
+      },
+      edits: {
+        type: "array",
+        description: "Array of search-and-replace operations applied sequentially. Each edit replaces the first occurrence of oldText with newText.",
+        items: {
+          type: "object",
+          properties: {
+            oldText: {
+              type: "string",
+              description: "The exact text to find in the file"
+            },
+            newText: {
+              type: "string",
+              description: "The replacement text"
+            }
+          },
+          required: ["oldText", "newText"]
+        }
+      }
+    },
+    required: ["path", "edits"]
+  };
+  return (0, import_ai5.tool)({
+    description: "Edit a file by applying one or more search-and-replace operations. Each edit replaces the first occurrence of oldText with newText. More efficient than rewriting entire files \u2014 only send the changed parts. Returns an error with the current file content if any oldText is not found.",
+    inputSchema: (0, import_ai5.jsonSchema)(schema),
+    execute: async (args) => {
+      const { path: filePath, edits } = args;
+      const fullPath = (0, import_node_path.resolve)(cwd, filePath);
+      let content;
+      try {
+        const buf = await (0, import_promises.readFile)(fullPath);
+        if (buf.length > maxFileSize) {
+          return { error: `File too large (${buf.length} bytes). Max: ${maxFileSize} bytes.` };
+        }
+        content = buf.toString("utf-8");
+      } catch (err) {
+        const code = err.code;
+        if (code === "ENOENT") {
+          return { error: `File not found: ${filePath}` };
+        }
+        return { error: `Failed to read file: ${err.message}` };
+      }
+      let replacements = 0;
+      for (const edit of edits) {
+        const idx = content.indexOf(edit.oldText);
+        if (idx === -1) {
+          return {
+            error: `oldText not found in file \u2014 it may have been modified. Re-read the file and retry.
+
+Searched for:
+${edit.oldText}`,
+            currentContent: content
+          };
+        }
+        content = content.slice(0, idx) + edit.newText + content.slice(idx + edit.oldText.length);
+        replacements++;
+      }
+      await (0, import_promises.writeFile)(fullPath, content, "utf-8");
+      return { path: filePath, replacements };
+    }
+  });
+}
+
+// src/tools/grep.ts
+var import_ai6 = require("ai");
+var import_node_child_process2 = require("child_process");
+var import_node_path2 = require("path");
+var MAX_OUTPUT2 = 3e4;
+var DEFAULT_TIMEOUT2 = 15e3;
+function createGrepTool(options) {
+  const cwd = options?.cwd ?? process.cwd();
+  const timeout = options?.timeout ?? DEFAULT_TIMEOUT2;
+  const maxOutput = options?.maxOutput ?? MAX_OUTPUT2;
+  const schema = {
+    type: "object",
+    properties: {
+      pattern: {
+        type: "string",
+        description: "Search pattern (regular expression)"
+      },
+      path: {
+        type: "string",
+        description: "File or directory to search in (relative to working directory). Defaults to current directory."
+      },
+      include: {
+        type: "string",
+        description: 'Glob pattern to filter files, e.g. "*.ts", "*.{js,jsx}". Only matching files are searched.'
+      },
+      ignoreCase: {
+        type: "boolean",
+        description: "Case-insensitive search. Defaults to false."
+      },
+      maxResults: {
+        type: "number",
+        description: "Maximum number of matching lines to return. Defaults to 100."
+      }
+    },
+    required: ["pattern"]
+  };
+  return (0, import_ai6.tool)({
+    description: "Search file contents for a pattern (regular expression). Returns matching lines with file paths and line numbers. Useful for finding function definitions, usages, imports, config values, and more.",
+    inputSchema: (0, import_ai6.jsonSchema)(schema),
+    execute: async (args) => {
+      const {
+        pattern,
+        path: searchPath,
+        include,
+        ignoreCase,
+        maxResults
+      } = args;
+      const target = (0, import_node_path2.resolve)(cwd, searchPath ?? ".");
+      const limit = maxResults ?? 100;
+      const rgArgs = [
+        "--no-heading",
+        "--line-number",
+        "--color=never",
+        `-m ${limit}`
+      ];
+      if (ignoreCase) rgArgs.push("-i");
+      if (include) rgArgs.push(`--glob '${include}'`);
+      const grepArgs = [
+        "-rn",
+        "--color=never",
+        `-m ${limit}`
+      ];
+      if (ignoreCase) grepArgs.push("-i");
+      if (include) grepArgs.push(`--include='${include}'`);
+      const escaped = pattern.replace(/'/g, "'\\''");
+      const command = `rg ${rgArgs.join(" ")} '${escaped}' '${target}' 2>/dev/null || grep ${grepArgs.join(" ")} '${escaped}' '${target}' 2>/dev/null`;
+      return new Promise((resolvePromise) => {
+        (0, import_node_child_process2.exec)(
+          command,
+          {
+            cwd,
+            timeout,
+            maxBuffer: 10 * 1024 * 1024,
+            env: { ...process.env, TERM: "dumb" }
+          },
+          (error, stdout) => {
+            if (error && error.code !== 1 && !error.killed) {
+              resolvePromise({ error: `Search failed: ${error.message}` });
+              return;
+            }
+            if (error?.killed) {
+              resolvePromise({ error: "Search timed out" });
+              return;
+            }
+            const output = stdout.trim();
+            if (!output) {
+              resolvePromise({ matches: "", matchCount: 0, truncated: false });
+              return;
+            }
+            const truncated = output.length > maxOutput;
+            const matches = truncated ? output.slice(0, maxOutput) + "\n... (truncated)" : output;
+            const matchCount = matches.split("\n").filter(Boolean).length;
+            resolvePromise({ matches, matchCount, truncated });
+          }
+        );
+      });
+    }
+  });
+}
+
+// src/tools/find.ts
+var import_ai7 = require("ai");
+var import_node_child_process3 = require("child_process");
+var import_node_path3 = require("path");
+var DEFAULT_TIMEOUT3 = 15e3;
+var MAX_OUTPUT3 = 3e4;
+function createFindTool(options) {
+  const cwd = options?.cwd ?? process.cwd();
+  const timeout = options?.timeout ?? DEFAULT_TIMEOUT3;
+  const maxOutput = options?.maxOutput ?? MAX_OUTPUT3;
+  const schema = {
+    type: "object",
+    properties: {
+      pattern: {
+        type: "string",
+        description: 'File name or glob pattern to search for, e.g. "*.ts", "config.json", "README*"'
+      },
+      path: {
+        type: "string",
+        description: "Directory to search in (relative to working directory). Defaults to current directory."
+      },
+      type: {
+        type: "string",
+        description: 'Filter by type: "f" for files only, "d" for directories only. Defaults to both.',
+        enum: ["f", "d"]
+      },
+      maxDepth: {
+        type: "number",
+        description: "Maximum directory depth to search. Defaults to no limit."
+      },
+      maxResults: {
+        type: "number",
+        description: "Maximum number of results to return. Defaults to 200."
+      }
+    },
+    required: ["pattern"]
+  };
+  const IGNORE_DIRS = [
+    "node_modules",
+    ".git",
+    "dist",
+    "build",
+    ".next",
+    "__pycache__",
+    ".venv",
+    "venv",
+    ".cache",
+    "coverage",
+    ".turbo"
+  ];
+  return (0, import_ai7.tool)({
+    description: "Find files and directories by name or glob pattern. Returns matching paths relative to the working directory. Automatically ignores common directories (node_modules, .git, dist, etc.).",
+    inputSchema: (0, import_ai7.jsonSchema)(schema),
+    execute: async (args) => {
+      const {
+        pattern,
+        path: searchPath,
+        type: fileType,
+        maxDepth,
+        maxResults
+      } = args;
+      const target = (0, import_node_path3.resolve)(cwd, searchPath ?? ".");
+      const limit = maxResults ?? 200;
+      const pruneExpr = IGNORE_DIRS.map((d) => `-name '${d}' -prune`).join(" -o ");
+      const parts = [
+        `find '${target}'`,
+        `\\( ${pruneExpr} \\)`,
+        `-o -name '${pattern.replace(/'/g, "'\\''")}'`
+      ];
+      if (fileType) parts.push(`-type ${fileType}`);
+      parts.push("-print");
+      parts.push(`| head -n ${limit}`);
+      if (maxDepth !== void 0) {
+        parts.splice(1, 0, `-maxdepth ${maxDepth}`);
+      }
+      const command = parts.join(" ");
+      return new Promise((resolvePromise) => {
+        (0, import_node_child_process3.exec)(
+          command,
+          {
+            cwd,
+            timeout,
+            maxBuffer: 10 * 1024 * 1024,
+            env: { ...process.env, TERM: "dumb" }
+          },
+          (error, stdout) => {
+            if (error?.killed) {
+              resolvePromise({ error: "Search timed out" });
+              return;
+            }
+            const output = stdout.trim();
+            if (!output) {
+              resolvePromise({ files: [], count: 0, truncated: false });
+              return;
+            }
+            const truncated = output.length > maxOutput;
+            const raw = truncated ? output.slice(0, maxOutput) : output;
+            const files = raw.split("\n").filter(Boolean);
+            resolvePromise({
+              files,
+              count: files.length,
+              truncated: truncated || files.length >= limit
+            });
+          }
+        );
+      });
+    }
+  });
+}
+
+// src/tools/read-file-range.ts
+var import_ai8 = require("ai");
+var import_promises2 = require("fs/promises");
+var import_node_path4 = require("path");
+var DEFAULT_MAX_LINES = 200;
+function createReadFileRangeTool(options) {
+  const cwd = options?.cwd ?? process.cwd();
+  const maxLines = options?.maxLines ?? DEFAULT_MAX_LINES;
+  const schema = {
+    type: "object",
+    properties: {
+      path: {
+        type: "string",
+        description: "File path to read (absolute or relative to working directory)"
+      },
+      startLine: {
+        type: "number",
+        description: "First line to read (1-based, inclusive). Defaults to 1."
+      },
+      endLine: {
+        type: "number",
+        description: "Last line to read (1-based, inclusive). Defaults to startLine + 200."
+      }
+    },
+    required: ["path"]
+  };
+  return (0, import_ai8.tool)({
+    description: "Read a specific range of lines from a file, with line numbers. More efficient than reading entire files \u2014 use this after grep to read context around matches, or to inspect specific sections of large files.",
+    inputSchema: (0, import_ai8.jsonSchema)(schema),
+    execute: async (args) => {
+      const { path: filePath, startLine, endLine } = args;
+      const fullPath = (0, import_node_path4.resolve)(cwd, filePath);
+      const start = Math.max(1, startLine ?? 1);
+      const requestedEnd = endLine ?? start + maxLines - 1;
+      const end = Math.min(requestedEnd, start + maxLines - 1);
+      let fh;
+      try {
+        fh = await (0, import_promises2.open)(fullPath, "r");
+      } catch (err) {
+        const code = err.code;
+        if (code === "ENOENT") {
+          return { error: `File not found: ${filePath}` };
+        }
+        return { error: `Failed to open file: ${err.message}` };
+      }
+      try {
+        const lines = [];
+        let lineNum = 0;
+        for await (const line of fh.readLines()) {
+          lineNum++;
+          if (lineNum > end) break;
+          if (lineNum >= start) {
+            lines.push(`${lineNum}	${line}`);
+          }
+        }
+        if (lines.length === 0 && start > 1) {
+          return {
+            error: `File only has ${lineNum} lines. Requested start line: ${start}.`
+          };
+        }
+        return {
+          path: filePath,
+          content: lines.join("\n"),
+          startLine: start,
+          endLine: Math.min(end, lineNum),
+          totalLines: lineNum
+        };
+      } finally {
+        await fh.close();
+      }
+    }
+  });
+}
+
+// src/tools/append-file.ts
+var import_ai9 = require("ai");
+var import_promises3 = require("fs/promises");
+var import_node_path5 = require("path");
+function createAppendFileTool(options) {
+  const cwd = options?.cwd ?? process.cwd();
+  const schema = {
+    type: "object",
+    properties: {
+      path: {
+        type: "string",
+        description: "File path to append to (absolute or relative to working directory). Created if it doesn't exist."
+      },
+      content: {
+        type: "string",
+        description: "Content to append to the end of the file. Include a leading newline if you want separation from existing content."
+      }
+    },
+    required: ["path", "content"]
+  };
+  return (0, import_ai9.tool)({
+    description: "Append content to the end of a file. Creates the file if it doesn't exist. More efficient than reading a file and rewriting it \u2014 use this for building up logs, CSVs, reports, or any file where you only need to add content.",
+    inputSchema: (0, import_ai9.jsonSchema)(schema),
+    execute: async (args) => {
+      const { path: filePath, content } = args;
+      const fullPath = (0, import_node_path5.resolve)(cwd, filePath);
+      try {
+        await (0, import_promises3.appendFile)(fullPath, content, "utf-8");
+        return {
+          path: filePath,
+          bytesAppended: Buffer.byteLength(content, "utf-8")
+        };
+      } catch (err) {
+        return { error: `Failed to append to file: ${err.message}` };
+      }
+    }
+  });
+}
+
+// src/tools/http-request.ts
+var import_ai10 = require("ai");
+var DEFAULT_TIMEOUT4 = 3e4;
+var MAX_RESPONSE_SIZE = 1e5;
+function createHttpRequestTool(options) {
+  const defaultTimeout = options?.timeout ?? DEFAULT_TIMEOUT4;
+  const maxResponseSize = options?.maxResponseSize ?? MAX_RESPONSE_SIZE;
+  const defaultHeaders = options?.defaultHeaders ?? {};
+  const schema = {
+    type: "object",
+    properties: {
+      url: {
+        type: "string",
+        description: "The URL to request (must include protocol, e.g. https://)"
+      },
+      method: {
+        type: "string",
+        description: "HTTP method. Defaults to GET.",
+        enum: ["GET", "POST", "PUT", "PATCH", "DELETE", "HEAD"]
+      },
+      headers: {
+        type: "object",
+        description: 'Request headers as key-value pairs, e.g. { "Content-Type": "application/json" }',
+        additionalProperties: { type: "string" }
+      },
+      body: {
+        type: "string",
+        description: "Request body as a string. For JSON, stringify the object first."
+      },
+      timeout: {
+        type: "number",
+        description: "Request timeout in milliseconds. Defaults to 30000."
+      }
+    },
+    required: ["url"]
+  };
+  return (0, import_ai10.tool)({
+    description: "Make an HTTP request to any URL. Supports GET, POST, PUT, PATCH, DELETE with custom headers and body. Returns status code, headers, and response body. Use this for calling APIs, checking endpoints, fetching data, or sending webhooks.",
+    inputSchema: (0, import_ai10.jsonSchema)(schema),
+    execute: async (args) => {
+      const {
+        url,
+        method,
+        headers,
+        body,
+        timeout: reqTimeout
+      } = args;
+      const effectiveTimeout = reqTimeout ?? defaultTimeout;
+      try {
+        const controller = new AbortController();
+        const timer = setTimeout(() => controller.abort(), effectiveTimeout);
+        const start = Date.now();
+        const response = await fetch(url, {
+          method: method ?? "GET",
+          headers: { ...defaultHeaders, ...headers },
+          body: body ?? void 0,
+          signal: controller.signal
+        });
+        const durationMs = Date.now() - start;
+        clearTimeout(timer);
+        const responseHeaders = {};
+        response.headers.forEach((value, key) => {
+          responseHeaders[key] = value;
+        });
+        let responseBody = await response.text();
+        const truncated = responseBody.length > maxResponseSize;
+        if (truncated) {
+          responseBody = responseBody.slice(0, maxResponseSize) + "\n... (truncated)";
+        }
+        return {
+          status: response.status,
+          statusText: response.statusText,
+          headers: responseHeaders,
+          body: responseBody,
+          durationMs,
+          truncated
+        };
+      } catch (err) {
+        if (err instanceof DOMException && err.name === "AbortError") {
+          return { error: `Request timed out after ${effectiveTimeout}ms` };
+        }
+        return { error: `Request failed: ${err.message}` };
+      }
+    }
+  });
+}
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
   buildSkillsSystemPrompt,
   createApiCallTool,
+  createAppendFileTool,
   createBashTool,
+  createEditFileTool,
+  createFindTool,
+  createGrepTool,
+  createHttpRequestTool,
   createLoadSkillTool,
+  createReadFileRangeTool,
   createViewImageTool,
   findSkill,
   parseSkillsMarkdown,