@gugacoder/agentic-sdk 0.2.0

package/dist/tools/index.js

@@ -0,0 +1,46 @@
+import { readTool } from "./read.js";
+import { writeTool } from "./write.js";
+import { editTool } from "./edit.js";
+import { bashTool } from "./bash.js";
+import { globTool } from "./glob.js";
+import { grepTool } from "./grep.js";
+import { listDirTool } from "./list-dir.js";
+import { multiEditTool } from "./multi-edit.js";
+import { todoWriteTool, todoReadTool } from "./todo.js";
+import { diagnosticsTool } from "./diagnostics.js";
+import { createAskUserTool } from "./ask-user.js";
+import { webFetchTool } from "./web-fetch.js";
+import { createWebSearchTool } from "./web-search.js";
+import { createTaskTool } from "./task.js";
+import { createBatchTool } from "./batch.js";
+import { applyPatchTool } from "./apply-patch.js";
+import { createCodeSearchTool } from "./code-search.js";
+import { httpRequestTool } from "./http-request.js";
+import { apiSpecTool } from "./api-spec.js";
+export { createBashTool } from "./bash.js";
+export { createWriteTool } from "./write.js";
+export { createEditTool } from "./edit.js";
+export { createMultiEditTool } from "./multi-edit.js";
+export { createApplyPatchTool } from "./apply-patch.js";
+export const codingTools = {
+    Read: readTool,
+    Write: writeTool,
+    Edit: editTool,
+    Bash: bashTool,
+    Glob: globTool,
+    Grep: grepTool,
+    ListDir: listDirTool,
+    MultiEdit: multiEditTool,
+    TodoWrite: todoWriteTool,
+    TodoRead: todoReadTool,
+    Diagnostics: diagnosticsTool,
+    AskUser: createAskUserTool(),
+    WebFetch: webFetchTool,
+    WebSearch: createWebSearchTool(),
+    Task: createTaskTool(),
+    Batch: createBatchTool({}),
+    ApplyPatch: applyPatchTool,
+    CodeSearch: createCodeSearchTool(),
+    HttpRequest: httpRequestTool,
+    ApiSpec: apiSpecTool,
+};

package/dist/tools/job-tools.d.ts

@@ -0,0 +1,24 @@
+export interface JobToolCallbacks {
+    submitJob: (opts: {
+        agentId: string;
+        command: string;
+        timeout?: number;
+    }) => unknown;
+    listJobs: (agentId?: string) => unknown[];
+    getJob: (jobId: string) => unknown | undefined;
+    killJob: (jobId: string) => boolean;
+    getAgentId: () => string | undefined;
+}
+export declare function createJobTools(callbacks: JobToolCallbacks): {
+    submit_job: import("ai").Tool<{
+        command: string;
+        timeout?: number | undefined;
+    }, string>;
+    list_jobs: import("ai").Tool<{}, string>;
+    get_job: import("ai").Tool<{
+        jobId: string;
+    }, string>;
+    kill_job: import("ai").Tool<{
+        jobId: string;
+    }, "Job killed successfully" | "Job not found or already finished">;
+};

package/dist/tools/job-tools.js

@@ -0,0 +1,67 @@
+/**
+ * Vercel AI SDK tool wrappers for job management.
+ * Uses callbacks to avoid coupling to a specific job engine implementation.
+ */
+import { tool } from "ai";
+import { z } from "zod";
+export function createJobTools(callbacks) {
+    return {
+        submit_job: tool({
+            description: "Submit a long-running process for backbone supervision. The backbone captures output, applies timeout, and wakes you up when the job finishes.",
+            inputSchema: z.object({
+                command: z
+                    .string()
+                    .describe("Shell command to execute (e.g. 'sleep 30')"),
+                timeout: z
+                    .number()
+                    .optional()
+                    .describe("Timeout in seconds. Default: 1800 (30min)"),
+            }),
+            execute: async ({ command, timeout }) => {
+                const agentId = callbacks.getAgentId();
+                if (!agentId)
+                    return "Error: AGENT_ID not available";
+                try {
+                    const summary = callbacks.submitJob({
+                        agentId,
+                        command,
+                        timeout,
+                    });
+                    return JSON.stringify(summary);
+                }
+                catch (err) {
+                    return `Error: ${err instanceof Error ? err.message : String(err)}`;
+                }
+            },
+        }),
+        list_jobs: tool({
+            description: "List all jobs for this agent. Returns an array of job summaries.",
+            inputSchema: z.object({}),
+            execute: async () => {
+                const agentId = callbacks.getAgentId();
+                return JSON.stringify(callbacks.listJobs(agentId ?? undefined));
+            },
+        }),
+        get_job: tool({
+            description: "Get full details of a specific job including output tail, status, exit code, and duration.",
+            inputSchema: z.object({
+                jobId: z.string().describe("Job ID to query"),
+            }),
+            execute: async ({ jobId }) => {
+                const job = callbacks.getJob(jobId);
+                return job ? JSON.stringify(job) : "Job not found";
+            },
+        }),
+        kill_job: tool({
+            description: "Kill a running job with SIGKILL.",
+            inputSchema: z.object({
+                jobId: z.string().describe("Job ID to kill"),
+            }),
+            execute: async ({ jobId }) => {
+                return callbacks.killJob(jobId)
+                    ? "Job killed successfully"
+                    : "Job not found or already finished";
+            },
+        }),
+    };
+}

package/dist/tools/list-dir.d.ts

@@ -0,0 +1,5 @@
+export declare const listDirTool: import("ai").Tool<{
+    path: string;
+    depth: number;
+    ignore: string[];
+}, string>;

package/dist/tools/list-dir.js

@@ -0,0 +1,79 @@
+import { tool } from "ai";
+import { z } from "zod";
+import { readdir, stat } from "node:fs/promises";
+import { join, basename } from "node:path";
+const DEFAULT_IGNORE = ["node_modules", ".git", "dist", "build"];
+async function buildTree(dirPath, depth, maxDepth, ignore, prefix) {
+    if (depth >= maxDepth)
+        return [];
+    let entries;
+    try {
+        entries = await readdir(dirPath, { withFileTypes: true });
+    }
+    catch {
+        return [];
+    }
+    // Filter ignored entries
+    entries = entries.filter((e) => !ignore.includes(e.name));
+    // Sort: directories first, then files, alphabetically within each group
+    entries.sort((a, b) => {
+        if (a.isDirectory() && !b.isDirectory())
+            return -1;
+        if (!a.isDirectory() && b.isDirectory())
+            return 1;
+        return a.name.localeCompare(b.name);
+    });
+    const lines = [];
+    for (let i = 0; i < entries.length; i++) {
+        const entry = entries[i];
+        const isLast = i === entries.length - 1;
+        const connector = isLast ? "└── " : "├── ";
+        const childPrefix = isLast ? "    " : "│   ";
+        if (entry.isDirectory()) {
+            lines.push(`${prefix}${connector}${entry.name}/`);
+            const children = await buildTree(join(dirPath, entry.name), depth + 1, maxDepth, ignore, prefix + childPrefix);
+            lines.push(...children);
+        }
+        else {
+            lines.push(`${prefix}${connector}${entry.name}`);
+        }
+    }
+    return lines;
+}
+export const listDirTool = tool({
+    description: "Lists files and directories as an indented tree. Use this to understand project structure.",
+    inputSchema: z.object({
+        path: z.string().describe("Absolute path of the directory to list"),
+        depth: z
+            .number()
+            .optional()
+            .default(3)
+            .describe("Maximum depth to traverse (default: 3)"),
+        ignore: z
+            .array(z.string())
+            .optional()
+            .default(DEFAULT_IGNORE)
+            .describe("Directory/file names to ignore (default: node_modules, .git, dist, build)"),
+    }),
+    execute: async ({ path, depth, ignore }) => {
+        try {
+            const s = await stat(path);
+            if (!s.isDirectory()) {
+                return `Error: ${path} is not a directory`;
+            }
+            const rootName = basename(path) || path;
+            const lines = [`${rootName}/`];
+            const children = await buildTree(path, 0, depth, ignore, "");
+            lines.push(...children);
+            const result = lines.join("\n");
+            // Respect 50KB output limit
+            if (result.length > 50_000) {
+                return result.slice(0, 50_000) + "\n... (truncated at 50KB)";
+            }
+            return result;
+        }
+        catch (err) {
+            return `Error: ${err.message}`;
+        }
+    },
+});