@link-assistant/agent 0.0.9 → 0.0.12

package/src/tool/bash.ts

@@ -1,67 +1,75 @@
-import z from "zod"
-import { spawn } from "child_process"
-import { Tool } from "./tool"
-import DESCRIPTION from "./bash.txt"
-import { Log } from "../util/log"
-import { Instance } from "../project/instance"
-import { lazy } from "../util/lazy"
-import { Language } from "web-tree-sitter"
-import { $ } from "bun"
-import { Filesystem } from "../util/filesystem"
-import { fileURLToPath } from "url"
-
-const MAX_OUTPUT_LENGTH = 30_000
-const DEFAULT_TIMEOUT = 1 * 60 * 1000
-const MAX_TIMEOUT = 10 * 60 * 1000
-const SIGKILL_TIMEOUT_MS = 200
-
-export const log = Log.create({ service: "bash-tool" })
+import z from 'zod';
+import { spawn } from 'child_process';
+import { Tool } from './tool';
+import DESCRIPTION from './bash.txt';
+import { Log } from '../util/log';
+import { Instance } from '../project/instance';
+import { lazy } from '../util/lazy';
+import { Language } from 'web-tree-sitter';
+import { $ } from 'bun';
+import { Filesystem } from '../util/filesystem';
+import { fileURLToPath } from 'url';
+
+const MAX_OUTPUT_LENGTH = 30_000;
+const DEFAULT_TIMEOUT = 1 * 60 * 1000;
+const MAX_TIMEOUT = 10 * 60 * 1000;
+const SIGKILL_TIMEOUT_MS = 200;
+
+export const log = Log.create({ service: 'bash-tool' });
 
 const resolveWasm = (asset: string) => {
-  if (asset.startsWith("file://")) return fileURLToPath(asset)
-  if (asset.startsWith("/") || /^[a-z]:/i.test(asset)) return asset
-  const url = new URL(asset, import.meta.url)
-  return fileURLToPath(url)
-}
+  if (asset.startsWith('file://')) return fileURLToPath(asset);
+  if (asset.startsWith('/') || /^[a-z]:/i.test(asset)) return asset;
+  const url = new URL(asset, import.meta.url);
+  return fileURLToPath(url);
+};
 
 const parser = lazy(async () => {
-  const { Parser } = await import("web-tree-sitter")
-  const { default: treeWasm } = await import("web-tree-sitter/tree-sitter.wasm" as string, {
-    with: { type: "wasm" },
-  })
-  const treePath = resolveWasm(treeWasm)
+  const { Parser } = await import('web-tree-sitter');
+  const { default: treeWasm } = await import(
+    'web-tree-sitter/tree-sitter.wasm' as string,
+    {
+      with: { type: 'wasm' },
+    }
+  );
+  const treePath = resolveWasm(treeWasm);
   await Parser.init({
     locateFile() {
-      return treePath
+      return treePath;
     },
-  })
-  const { default: bashWasm } = await import("tree-sitter-bash/tree-sitter-bash.wasm" as string, {
-    with: { type: "wasm" },
-  })
-  const bashPath = resolveWasm(bashWasm)
-  const bashLanguage = await Language.load(bashPath)
-  const p = new Parser()
-  p.setLanguage(bashLanguage)
-  return p
-})
-
-export const BashTool = Tool.define("bash", {
+  });
+  const { default: bashWasm } = await import(
+    'tree-sitter-bash/tree-sitter-bash.wasm' as string,
+    {
+      with: { type: 'wasm' },
+    }
+  );
+  const bashPath = resolveWasm(bashWasm);
+  const bashLanguage = await Language.load(bashPath);
+  const p = new Parser();
+  p.setLanguage(bashLanguage);
+  return p;
+});
+
+export const BashTool = Tool.define('bash', {
   description: DESCRIPTION,
   parameters: z.object({
-    command: z.string().describe("The command to execute"),
-    timeout: z.number().describe("Optional timeout in milliseconds").optional(),
+    command: z.string().describe('The command to execute'),
+    timeout: z.number().describe('Optional timeout in milliseconds').optional(),
     description: z
       .string()
       .describe(
-        "Clear, concise description of what this command does in 5-10 words. Examples:\nInput: ls\nOutput: Lists files in current directory\n\nInput: git status\nOutput: Shows working tree status\n\nInput: npm install\nOutput: Installs package dependencies\n\nInput: mkdir foo\nOutput: Creates directory 'foo'",
+        "Clear, concise description of what this command does in 5-10 words. Examples:\nInput: ls\nOutput: Lists files in current directory\n\nInput: git status\nOutput: Shows working tree status\n\nInput: npm install\nOutput: Installs package dependencies\n\nInput: mkdir foo\nOutput: Creates directory 'foo'"
       )
       .optional(),
   }),
   async execute(params, ctx) {
     if (params.timeout !== undefined && params.timeout < 0) {
-      throw new Error(`Invalid timeout value: ${params.timeout}. Timeout must be a positive number.`)
+      throw new Error(
+        `Invalid timeout value: ${params.timeout}. Timeout must be a positive number.`
+      );
     }
-    const timeout = Math.min(params.timeout ?? DEFAULT_TIMEOUT, MAX_TIMEOUT)
+    const timeout = Math.min(params.timeout ?? DEFAULT_TIMEOUT, MAX_TIMEOUT);
 
     // No restrictions - unrestricted command execution
     const proc = spawn(params.command, {
@@ -70,114 +78,116 @@ export const BashTool = Tool.define("bash", {
       env: {
         ...process.env,
       },
-      stdio: ["ignore", "pipe", "pipe"],
-      detached: process.platform !== "win32",
-    })
+      stdio: ['ignore', 'pipe', 'pipe'],
+      detached: process.platform !== 'win32',
+    });
 
-    let output = ""
+    let output = '';
 
     // Initialize metadata with empty output
     ctx.metadata({
       metadata: {
-        output: "",
+        output: '',
         description: params.description,
       },
-    })
+    });
 
     const append = (chunk: Buffer) => {
-      output += chunk.toString()
+      output += chunk.toString();
       ctx.metadata({
         metadata: {
           output,
           description: params.description,
         },
-      })
-    }
+      });
+    };
 
-    proc.stdout?.on("data", append)
-    proc.stderr?.on("data", append)
+    proc.stdout?.on('data', append);
+    proc.stderr?.on('data', append);
 
-    let timedOut = false
-    let aborted = false
-    let exited = false
+    let timedOut = false;
+    let aborted = false;
+    let exited = false;
 
     const killTree = async () => {
-      const pid = proc.pid
+      const pid = proc.pid;
       if (!pid || exited) {
-        return
+        return;
       }
 
-      if (process.platform === "win32") {
+      if (process.platform === 'win32') {
         await new Promise<void>((resolve) => {
-          const killer = spawn("taskkill", ["/pid", String(pid), "/f", "/t"], { stdio: "ignore" })
-          killer.once("exit", resolve)
-          killer.once("error", resolve)
-        })
-        return
+          const killer = spawn('taskkill', ['/pid', String(pid), '/f', '/t'], {
+            stdio: 'ignore',
+          });
+          killer.once('exit', resolve);
+          killer.once('error', resolve);
+        });
+        return;
       }
 
       try {
-        process.kill(-pid, "SIGTERM")
-        await Bun.sleep(SIGKILL_TIMEOUT_MS)
+        process.kill(-pid, 'SIGTERM');
+        await Bun.sleep(SIGKILL_TIMEOUT_MS);
         if (!exited) {
-          process.kill(-pid, "SIGKILL")
+          process.kill(-pid, 'SIGKILL');
         }
       } catch (_e) {
-        proc.kill("SIGTERM")
-        await Bun.sleep(SIGKILL_TIMEOUT_MS)
+        proc.kill('SIGTERM');
+        await Bun.sleep(SIGKILL_TIMEOUT_MS);
         if (!exited) {
-          proc.kill("SIGKILL")
+          proc.kill('SIGKILL');
         }
       }
-    }
+    };
 
     if (ctx.abort.aborted) {
-      aborted = true
-      await killTree()
+      aborted = true;
+      await killTree();
     }
 
     const abortHandler = () => {
-      aborted = true
-      void killTree()
-    }
+      aborted = true;
+      void killTree();
+    };
 
-    ctx.abort.addEventListener("abort", abortHandler, { once: true })
+    ctx.abort.addEventListener('abort', abortHandler, { once: true });
 
     const timeoutTimer = setTimeout(() => {
-      timedOut = true
-      void killTree()
-    }, timeout)
+      timedOut = true;
+      void killTree();
+    }, timeout);
 
     await new Promise<void>((resolve, reject) => {
       const cleanup = () => {
-        clearTimeout(timeoutTimer)
-        ctx.abort.removeEventListener("abort", abortHandler)
-      }
-
-      proc.once("exit", () => {
-        exited = true
-        cleanup()
-        resolve()
-      })
-
-      proc.once("error", (error) => {
-        exited = true
-        cleanup()
-        reject(error)
-      })
-    })
+        clearTimeout(timeoutTimer);
+        ctx.abort.removeEventListener('abort', abortHandler);
+      };
+
+      proc.once('exit', () => {
+        exited = true;
+        cleanup();
+        resolve();
+      });
+
+      proc.once('error', (error) => {
+        exited = true;
+        cleanup();
+        reject(error);
+      });
+    });
 
     if (output.length > MAX_OUTPUT_LENGTH) {
-      output = output.slice(0, MAX_OUTPUT_LENGTH)
-      output += "\n\n(Output was truncated due to length limit)"
+      output = output.slice(0, MAX_OUTPUT_LENGTH);
+      output += '\n\n(Output was truncated due to length limit)';
     }
 
     if (timedOut) {
-      output += `\n\n(Command timed out after ${timeout} ms)`
+      output += `\n\n(Command timed out after ${timeout} ms)`;
     }
 
     if (aborted) {
-      output += "\n\n(Command was aborted)"
+      output += '\n\n(Command was aborted)';
     }
 
     return {
@@ -188,6 +198,6 @@ export const BashTool = Tool.define("bash", {
         description: params.description,
       },
       output,
-    }
+    };
   },
-})
+});

package/src/tool/batch.ts

@@ -1,90 +1,100 @@
-import z from "zod"
-import { Tool } from "./tool"
-import DESCRIPTION from "./batch.txt"
+import z from 'zod';
+import { Tool } from './tool';
+import DESCRIPTION from './batch.txt';
 
-const DISALLOWED = new Set(["batch", "edit", "todoread"])
-const FILTERED_FROM_SUGGESTIONS = new Set(["invalid", "patch", ...DISALLOWED])
+const DISALLOWED = new Set(['batch', 'edit', 'todoread']);
+const FILTERED_FROM_SUGGESTIONS = new Set(['invalid', 'patch', ...DISALLOWED]);
 
-export const BatchTool = Tool.define("batch", async () => {
+export const BatchTool = Tool.define('batch', async () => {
   return {
     description: DESCRIPTION,
     parameters: z.object({
       tool_calls: z
         .array(
           z.object({
-            tool: z.string().describe("The name of the tool to execute"),
-            parameters: z.object({}).loose().describe("Parameters for the tool"),
-          }),
+            tool: z.string().describe('The name of the tool to execute'),
+            parameters: z
+              .object({})
+              .loose()
+              .describe('Parameters for the tool'),
+          })
         )
-        .min(1, "Provide at least one tool call")
-        .describe("Array of tool calls to execute in parallel"),
+        .min(1, 'Provide at least one tool call')
+        .describe('Array of tool calls to execute in parallel'),
     }),
     formatValidationError(error) {
       const formattedErrors = error.issues
         .map((issue) => {
-          const path = issue.path.length > 0 ? issue.path.join(".") : "root"
-          return `  - ${path}: ${issue.message}`
+          const path = issue.path.length > 0 ? issue.path.join('.') : 'root';
+          return `  - ${path}: ${issue.message}`;
         })
-        .join("\n")
+        .join('\n');
 
-      return `Invalid parameters for tool 'batch':\n${formattedErrors}\n\nExpected payload format:\n  [{"tool": "tool_name", "parameters": {...}}, {...}]`
+      return `Invalid parameters for tool 'batch':\n${formattedErrors}\n\nExpected payload format:\n  [{"tool": "tool_name", "parameters": {...}}, {...}]`;
     },
     async execute(params, ctx) {
-      const { Session } = await import("../session")
-      const { Identifier } = await import("../id/id")
+      const { Session } = await import('../session');
+      const { Identifier } = await import('../id/id');
 
-      const toolCalls = params.tool_calls.slice(0, 10)
-      const discardedCalls = params.tool_calls.slice(10)
+      const toolCalls = params.tool_calls.slice(0, 10);
+      const discardedCalls = params.tool_calls.slice(10);
 
-      const { ToolRegistry } = await import("./registry")
-      const availableTools = await ToolRegistry.tools("", "")
-      const toolMap = new Map(availableTools.map((t) => [t.id, t]))
+      const { ToolRegistry } = await import('./registry');
+      const availableTools = await ToolRegistry.tools('', '');
+      const toolMap = new Map(availableTools.map((t) => [t.id, t]));
 
       const executeCall = async (call: (typeof toolCalls)[0]) => {
-        const callStartTime = Date.now()
-        const partID = Identifier.ascending("part")
+        const callStartTime = Date.now();
+        const partID = Identifier.ascending('part');
 
         try {
           if (DISALLOWED.has(call.tool)) {
             throw new Error(
-              `Tool '${call.tool}' is not allowed in batch. Disallowed tools: ${Array.from(DISALLOWED).join(", ")}`,
-            )
+              `Tool '${call.tool}' is not allowed in batch. Disallowed tools: ${Array.from(DISALLOWED).join(', ')}`
+            );
           }
 
-          const tool = toolMap.get(call.tool)
+          const tool = toolMap.get(call.tool);
           if (!tool) {
-            const availableToolsList = Array.from(toolMap.keys()).filter((name) => !FILTERED_FROM_SUGGESTIONS.has(name))
-            throw new Error(`Tool '${call.tool}' not found. Available tools: ${availableToolsList.join(", ")}`)
+            const availableToolsList = Array.from(toolMap.keys()).filter(
+              (name) => !FILTERED_FROM_SUGGESTIONS.has(name)
+            );
+            throw new Error(
+              `Tool '${call.tool}' not found. Available tools: ${availableToolsList.join(', ')}`
+            );
           }
-          const validatedParams = tool.parameters.parse(call.parameters)
+          const validatedParams = tool.parameters.parse(call.parameters);
 
           await Session.updatePart({
             id: partID,
             messageID: ctx.messageID,
             sessionID: ctx.sessionID,
-            type: "tool",
+            type: 'tool',
             tool: call.tool,
             callID: partID,
             state: {
-              status: "running",
+              status: 'running',
               input: call.parameters,
               time: {
                 start: callStartTime,
               },
             },
-          })
+          });
 
-          const result = await tool.execute(validatedParams, { ...ctx, callID: partID })
+          const result = await tool.execute(validatedParams, {
+            ...ctx,
+            callID: partID,
+          });
 
           await Session.updatePart({
             id: partID,
             messageID: ctx.messageID,
             sessionID: ctx.sessionID,
-            type: "tool",
+            type: 'tool',
             tool: call.tool,
             callID: partID,
             state: {
-              status: "completed",
+              status: 'completed',
               input: call.parameters,
               output: result.output,
               title: result.title,
@@ -95,19 +105,19 @@ export const BatchTool = Tool.define("batch", async () => {
                 end: Date.now(),
               },
             },
-          })
+          });
 
-          return { success: true as const, tool: call.tool, result }
+          return { success: true as const, tool: call.tool, result };
         } catch (error) {
           await Session.updatePart({
             id: partID,
             messageID: ctx.messageID,
             sessionID: ctx.sessionID,
-            type: "tool",
+            type: 'tool',
             tool: call.tool,
             callID: partID,
             state: {
-              status: "error",
+              status: 'error',
               input: call.parameters,
               error: error instanceof Error ? error.message : String(error),
               time: {
@@ -115,51 +125,55 @@ export const BatchTool = Tool.define("batch", async () => {
                 end: Date.now(),
               },
             },
-          })
+          });
 
-          return { success: false as const, tool: call.tool, error }
+          return { success: false as const, tool: call.tool, error };
         }
-      }
+      };
 
-      const results = await Promise.all(toolCalls.map((call) => executeCall(call)))
+      const results = await Promise.all(
+        toolCalls.map((call) => executeCall(call))
+      );
 
       // Add discarded calls as errors
-      const now = Date.now()
+      const now = Date.now();
       for (const call of discardedCalls) {
-        const partID = Identifier.ascending("part")
+        const partID = Identifier.ascending('part');
         await Session.updatePart({
           id: partID,
           messageID: ctx.messageID,
           sessionID: ctx.sessionID,
-          type: "tool",
+          type: 'tool',
           tool: call.tool,
           callID: partID,
           state: {
-            status: "error",
+            status: 'error',
             input: call.parameters,
-            error: "Maximum of 10 tools allowed in batch",
+            error: 'Maximum of 10 tools allowed in batch',
             time: { start: now, end: now },
           },
-        })
+        });
         results.push({
           success: false as const,
           tool: call.tool,
-          error: new Error("Maximum of 10 tools allowed in batch"),
-        })
+          error: new Error('Maximum of 10 tools allowed in batch'),
+        });
       }
 
-      const successfulCalls = results.filter((r) => r.success).length
-      const failedCalls = results.length - successfulCalls
+      const successfulCalls = results.filter((r) => r.success).length;
+      const failedCalls = results.length - successfulCalls;
 
       const outputMessage =
         failedCalls > 0
           ? `Executed ${successfulCalls}/${results.length} tools successfully. ${failedCalls} failed.`
-          : `All ${successfulCalls} tools executed successfully.\n\nKeep using the batch tool for optimal performance in your next response!`
+          : `All ${successfulCalls} tools executed successfully.\n\nKeep using the batch tool for optimal performance in your next response!`;
 
       return {
         title: `Batch execution (${successfulCalls}/${results.length} successful)`,
         output: outputMessage,
-        attachments: results.filter((result) => result.success).flatMap((r) => r.result.attachments ?? []),
+        attachments: results
+          .filter((result) => result.success)
+          .flatMap((r) => r.result.attachments ?? []),
         metadata: {
           totalCalls: results.length,
           successful: successfulCalls,
@@ -167,7 +181,7 @@ export const BatchTool = Tool.define("batch", async () => {
           tools: params.tool_calls.map((c) => c.tool),
           details: results.map((r) => ({ tool: r.tool, success: r.success })),
         },
-      }
+      };
     },
-  }
-})
+  };
+});