@supyagent/sdk 0.2.1 → 0.3.0

package/dist/index.js

@@ -810,7 +810,7 @@ function createBashTool(options) {
         };
       }
       const start = Date.now();
-      return new Promise((resolve) => {
+      return new Promise((resolve6) => {
         const child = exec(
           command,
           {
@@ -824,7 +824,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,
@@ -834,7 +834,7 @@ function createBashTool(options) {
           }
         );
         child.on("error", () => {
-          resolve({
+          resolve6({
             stdout: "",
             stderr: "Failed to start process",
             exitCode: 127,
@@ -877,11 +877,503 @@ function createViewImageTool(options) {
     }
   });
 }
+
+// src/tools/edit-file.ts
+import { tool as tool5, jsonSchema as jsonSchema5 } from "ai";
+import { readFile, writeFile } from "fs/promises";
+import { resolve } from "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 tool5({
+    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: jsonSchema5(schema),
+    execute: async (args) => {
+      const { path: filePath, edits } = args;
+      const fullPath = resolve(cwd, filePath);
+      let content;
+      try {
+        const buf = await 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 writeFile(fullPath, content, "utf-8");
+      return { path: filePath, replacements };
+    }
+  });
+}
+
+// src/tools/grep.ts
+import { tool as tool6, jsonSchema as jsonSchema6 } from "ai";
+import { exec as exec2 } from "child_process";
+import { resolve as resolve2 } from "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 tool6({
+    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: jsonSchema6(schema),
+    execute: async (args) => {
+      const {
+        pattern,
+        path: searchPath,
+        include,
+        ignoreCase,
+        maxResults
+      } = args;
+      const target = resolve2(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) => {
+        exec2(
+          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
+import { tool as tool7, jsonSchema as jsonSchema7 } from "ai";
+import { exec as exec3 } from "child_process";
+import { resolve as resolve3 } from "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 tool7({
+    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: jsonSchema7(schema),
+    execute: async (args) => {
+      const {
+        pattern,
+        path: searchPath,
+        type: fileType,
+        maxDepth,
+        maxResults
+      } = args;
+      const target = resolve3(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) => {
+        exec3(
+          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
+import { tool as tool8, jsonSchema as jsonSchema8 } from "ai";
+import { open } from "fs/promises";
+import { resolve as resolve4 } from "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 tool8({
+    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: jsonSchema8(schema),
+    execute: async (args) => {
+      const { path: filePath, startLine, endLine } = args;
+      const fullPath = resolve4(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 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
+import { tool as tool9, jsonSchema as jsonSchema9 } from "ai";
+import { appendFile as fsAppendFile } from "fs/promises";
+import { resolve as resolve5 } from "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 tool9({
+    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: jsonSchema9(schema),
+    execute: async (args) => {
+      const { path: filePath, content } = args;
+      const fullPath = resolve5(cwd, filePath);
+      try {
+        await fsAppendFile(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
+import { tool as tool10, jsonSchema as jsonSchema10 } from "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 tool10({
+    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: jsonSchema10(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}` };
+      }
+    }
+  });
+}
 export {
   buildSkillsSystemPrompt,
   createApiCallTool,
+  createAppendFileTool,
   createBashTool,
+  createEditFileTool,
+  createFindTool,
+  createGrepTool,
+  createHttpRequestTool,
   createLoadSkillTool,
+  createReadFileRangeTool,
   createViewImageTool,
   findSkill,
   parseSkillsMarkdown,