@gugacoder/agentic-sdk 0.2.0

package/dist/tools/edit.js

@@ -0,0 +1,47 @@
+import { tool } from "ai";
+import { z } from "zod";
+import { readFile, writeFile } from "node:fs/promises";
+export function createEditTool(opts) {
+    const baseTool = tool({
+        description: "Performs exact string replacement in a file. The old_string must be unique in the file unless replace_all is true.",
+        inputSchema: z.object({
+            file_path: z.string().describe("Absolute path to the file to edit"),
+            old_string: z.string().describe("The exact text to find and replace"),
+            new_string: z.string().describe("The replacement text"),
+            replace_all: z
+                .boolean()
+                .optional()
+                .default(false)
+                .describe("Replace all occurrences instead of just the first"),
+        }),
+        execute: async ({ file_path, old_string, new_string, replace_all }) => {
+            try {
+                const content = await readFile(file_path, "utf-8");
+                if (!content.includes(old_string)) {
+                    return `Error: old_string not found in ${file_path}`;
+                }
+                if (!replace_all) {
+                    const count = content.split(old_string).length - 1;
+                    if (count > 1) {
+                        return `Error: old_string appears ${count} times in the file. Provide more context to make it unique, or set replace_all to true.`;
+                    }
+                }
+                const updated = replace_all
+                    ? content.replaceAll(old_string, new_string)
+                    : content.replace(old_string, new_string);
+                await writeFile(file_path, updated, "utf-8");
+                return `File edited successfully: ${file_path}`;
+            }
+            catch (err) {
+                return `Error editing file: ${err.message}`;
+            }
+        },
+    });
+    if (opts?.autoApprove === false) {
+        return Object.assign(baseTool, {
+            needsApproval: async () => true,
+        });
+    }
+    return baseTool;
+}
+export const editTool = createEditTool();

package/dist/tools/glob.d.ts

@@ -0,0 +1,4 @@
+export declare const globTool: import("ai").Tool<{
+    pattern: string;
+    path?: string | undefined;
+}, string>;

package/dist/tools/glob.js

@@ -0,0 +1,42 @@
+import { tool } from "ai";
+import { z } from "zod";
+import fg from "fast-glob";
+import { stat } from "node:fs/promises";
+export const globTool = tool({
+    description: "Fast file pattern matching. Supports glob patterns like '**/*.ts'. Returns matching file paths sorted by modification time.",
+    inputSchema: z.object({
+        pattern: z.string().describe("Glob pattern to match files against"),
+        path: z
+            .string()
+            .optional()
+            .describe("Directory to search in. Defaults to cwd."),
+    }),
+    execute: async ({ pattern, path }) => {
+        try {
+            const cwd = path ?? process.cwd();
+            const files = await fg(pattern, {
+                cwd,
+                absolute: true,
+                dot: false,
+                onlyFiles: true,
+            });
+            // Sort by mtime (most recent first)
+            const withStats = await Promise.all(files.map(async (f) => {
+                try {
+                    const s = await stat(f);
+                    return { file: f, mtime: s.mtimeMs };
+                }
+                catch {
+                    return { file: f, mtime: 0 };
+                }
+            }));
+            withStats.sort((a, b) => b.mtime - a.mtime);
+            if (withStats.length === 0)
+                return "No files matched the pattern.";
+            return withStats.map((w) => w.file).join("\n");
+        }
+        catch (err) {
+            return `Error: ${err.message}`;
+        }
+    },
+});

package/dist/tools/grep.d.ts

@@ -0,0 +1,6 @@
+export declare const grepTool: import("ai").Tool<{
+    pattern: string;
+    output_mode: "content" | "files_with_matches" | "count";
+    path?: string | undefined;
+    glob?: string | undefined;
+}, string>;

package/dist/tools/grep.js

@@ -0,0 +1,69 @@
+import { tool } from "ai";
+import { z } from "zod";
+import { execFile } from "node:child_process";
+const MAX_OUTPUT = 30_000;
+export const grepTool = tool({
+    description: "Searches file contents using ripgrep (rg) with regex support. Falls back to grep if rg is unavailable.",
+    inputSchema: z.object({
+        pattern: z.string().describe("Regex pattern to search for"),
+        path: z
+            .string()
+            .optional()
+            .describe("File or directory to search in. Defaults to cwd."),
+        glob: z
+            .string()
+            .optional()
+            .describe("Glob pattern to filter files (e.g. '*.ts')"),
+        output_mode: z
+            .enum(["content", "files_with_matches", "count"])
+            .optional()
+            .default("files_with_matches")
+            .describe("Output mode"),
+    }),
+    execute: async ({ pattern, path, glob: globFilter, output_mode }) => {
+        const searchPath = path ?? ".";
+        // Build rg args array (no shell quoting needed with execFile)
+        const args = [];
+        if (output_mode === "files_with_matches")
+            args.push("-l");
+        else if (output_mode === "count")
+            args.push("-c");
+        else
+            args.push("-n"); // content mode: show line numbers
+        if (globFilter)
+            args.push("--glob", globFilter);
+        args.push(pattern, searchPath);
+        return new Promise((resolve) => {
+            execFile("rg", args, { timeout: 30_000, maxBuffer: 10 * 1024 * 1024 }, (err, stdout) => {
+                if (stdout) {
+                    const output = stdout.length > MAX_OUTPUT
+                        ? stdout.slice(0, MAX_OUTPUT) + "\n...[truncated]"
+                        : stdout;
+                    resolve(output.trim());
+                }
+                else if (err) {
+                    // rg returns exit code 1 for no matches
+                    if (err.code === 1) {
+                        resolve("No matches found.");
+                    }
+                    else {
+                        // Try grep fallback
+                        const grepArgs = ["-rn"];
+                        if (globFilter)
+                            grepArgs.push(`--include=${globFilter}`);
+                        grepArgs.push(pattern, searchPath);
+                        execFile("grep", grepArgs, { timeout: 30_000 }, (gErr, gOut) => {
+                            if (gOut)
+                                resolve(gOut.trim());
+                            else
+                                resolve("No matches found.");
+                        });
+                    }
+                }
+                else {
+                    resolve("No matches found.");
+                }
+            });
+        });
+    },
+});

package/dist/tools/http-request.d.ts

@@ -0,0 +1,7 @@
+export declare const httpRequestTool: import("ai").Tool<{
+    timeout: number;
+    url: string;
+    method: "GET" | "POST" | "PUT" | "PATCH" | "DELETE" | "HEAD" | "OPTIONS";
+    headers?: Record<string, string> | undefined;
+    body?: string | undefined;
+}, string>;

package/dist/tools/http-request.js

@@ -0,0 +1,98 @@
+import { tool } from "ai";
+import { z } from "zod";
+const MAX_RESPONSE_SIZE = 50 * 1024; // 50KB
+const MAX_TIMEOUT = 60_000;
+export const httpRequestTool = tool({
+    description: "Sends an HTTP request to a URL. Supports all methods, custom headers, and JSON/text bodies. Use for REST API interactions.",
+    inputSchema: z.object({
+        method: z
+            .enum(["GET", "POST", "PUT", "PATCH", "DELETE", "HEAD", "OPTIONS"])
+            .describe("HTTP method"),
+        url: z.string().url().describe("Target URL"),
+        headers: z
+            .record(z.string())
+            .optional()
+            .describe("Custom headers (e.g. Authorization, Content-Type)"),
+        body: z
+            .string()
+            .optional()
+            .describe("Request body (JSON string or plain text)"),
+        timeout: z
+            .number()
+            .optional()
+            .default(30_000)
+            .describe("Timeout in ms (max 60000)"),
+    }),
+    execute: async ({ method, url, headers, body, timeout }) => {
+        const effectiveTimeout = Math.min(timeout ?? 30_000, MAX_TIMEOUT);
+        const controller = new AbortController();
+        const timer = setTimeout(() => controller.abort(), effectiveTimeout);
+        try {
+            const fetchHeaders = { ...headers };
+            // Auto-set Content-Type for JSON bodies if not specified
+            if (body && !fetchHeaders["Content-Type"] && !fetchHeaders["content-type"]) {
+                try {
+                    JSON.parse(body);
+                    fetchHeaders["Content-Type"] = "application/json";
+                }
+                catch {
+                    // Not JSON — leave Content-Type unset
+                }
+            }
+            const response = await fetch(url, {
+                method,
+                headers: fetchHeaders,
+                body: method !== "GET" && method !== "HEAD" ? body : undefined,
+                signal: controller.signal,
+            });
+            // Collect response headers (subset)
+            const responseHeaders = {};
+            for (const key of ["content-type", "location", "x-request-id", "retry-after"]) {
+                const val = response.headers.get(key);
+                if (val)
+                    responseHeaders[key] = val;
+            }
+            // Read response body
+            const contentType = response.headers.get("content-type") ?? "";
+            let responseBody;
+            if (method === "HEAD") {
+                responseBody = null;
+            }
+            else {
+                const text = await response.text();
+                const truncated = text.length > MAX_RESPONSE_SIZE;
+                const bodyText = truncated ? text.slice(0, MAX_RESPONSE_SIZE) : text;
+                // Try JSON parse if content-type indicates JSON
+                if (contentType.includes("json")) {
+                    try {
+                        responseBody = JSON.parse(bodyText);
+                    }
+                    catch {
+                        responseBody = bodyText;
+                    }
+                }
+                else {
+                    responseBody = bodyText;
+                }
+                if (truncated) {
+                    responseHeaders["x-truncated"] = `true (${text.length} bytes, showing first ${MAX_RESPONSE_SIZE})`;
+                }
+            }
+            return JSON.stringify({
+                status: response.status,
+                statusText: response.statusText,
+                headers: responseHeaders,
+                body: responseBody,
+            });
+        }
+        catch (err) {
+            if (err.name === "AbortError") {
+                return `Error: Request timed out after ${effectiveTimeout}ms`;
+            }
+            return `Error: ${err.message}`;
+        }
+        finally {
+            clearTimeout(timer);
+        }
+    },
+});