@link-assistant/agent 0.0.9 → 0.0.12

package/src/tool/glob.ts

@@ -1,55 +1,59 @@
-import z from "zod"
-import path from "path"
-import { Tool } from "./tool"
-import DESCRIPTION from "./glob.txt"
-import { Ripgrep } from "../file/ripgrep"
-import { Instance } from "../project/instance"
+import z from 'zod';
+import path from 'path';
+import { Tool } from './tool';
+import DESCRIPTION from './glob.txt';
+import { Ripgrep } from '../file/ripgrep';
+import { Instance } from '../project/instance';
 
-export const GlobTool = Tool.define("glob", {
+export const GlobTool = Tool.define('glob', {
   description: DESCRIPTION,
   parameters: z.object({
-    pattern: z.string().describe("The glob pattern to match files against"),
+    pattern: z.string().describe('The glob pattern to match files against'),
     path: z
       .string()
       .optional()
       .describe(
-        `The directory to search in. If not specified, the current working directory will be used. IMPORTANT: Omit this field to use the default directory. DO NOT enter "undefined" or "null" - simply omit it for the default behavior. Must be a valid directory path if provided.`,
+        `The directory to search in. If not specified, the current working directory will be used. IMPORTANT: Omit this field to use the default directory. DO NOT enter "undefined" or "null" - simply omit it for the default behavior. Must be a valid directory path if provided.`
       ),
   }),
   async execute(params) {
-    let search = params.path ?? Instance.directory
-    search = path.isAbsolute(search) ? search : path.resolve(Instance.directory, search)
+    let search = params.path ?? Instance.directory;
+    search = path.isAbsolute(search)
+      ? search
+      : path.resolve(Instance.directory, search);
 
-    const limit = 100
-    const files = []
-    let truncated = false
+    const limit = 100;
+    const files = [];
+    let truncated = false;
     for await (const file of Ripgrep.files({
       cwd: search,
       glob: [params.pattern],
     })) {
       if (files.length >= limit) {
-        truncated = true
-        break
+        truncated = true;
+        break;
       }
-      const full = path.resolve(search, file)
+      const full = path.resolve(search, file);
       const stats = await Bun.file(full)
         .stat()
         .then((x) => x.mtime.getTime())
-        .catch(() => 0)
+        .catch(() => 0);
       files.push({
         path: full,
         mtime: stats,
-      })
+      });
     }
-    files.sort((a, b) => b.mtime - a.mtime)
+    files.sort((a, b) => b.mtime - a.mtime);
 
-    const output = []
-    if (files.length === 0) output.push("No files found")
+    const output = [];
+    if (files.length === 0) output.push('No files found');
     if (files.length > 0) {
-      output.push(...files.map((f) => f.path))
+      output.push(...files.map((f) => f.path));
       if (truncated) {
-        output.push("")
-        output.push("(Results are truncated. Consider using a more specific path or pattern.)")
+        output.push('');
+        output.push(
+          '(Results are truncated. Consider using a more specific path or pattern.)'
+        );
       }
     }
 
@@ -59,7 +63,7 @@ export const GlobTool = Tool.define("glob", {
         count: files.length,
         truncated,
       },
-      output: output.join("\n"),
-    }
+      output: output.join('\n'),
+    };
   },
-})
+});

package/src/tool/grep.ts

@@ -1,107 +1,126 @@
-import z from "zod"
-import { Tool } from "./tool"
-import { Ripgrep } from "../file/ripgrep"
+import z from 'zod';
+import { Tool } from './tool';
+import { Ripgrep } from '../file/ripgrep';
 
-import DESCRIPTION from "./grep.txt"
-import { Instance } from "../project/instance"
+import DESCRIPTION from './grep.txt';
+import { Instance } from '../project/instance';
 
-export const GrepTool = Tool.define("grep", {
+export const GrepTool = Tool.define('grep', {
   description: DESCRIPTION,
   parameters: z.object({
-    pattern: z.string().describe("The regex pattern to search for in file contents"),
-    path: z.string().optional().describe("The directory to search in. Defaults to the current working directory."),
-    include: z.string().optional().describe('File pattern to include in the search (e.g. "*.js", "*.{ts,tsx}")'),
+    pattern: z
+      .string()
+      .describe('The regex pattern to search for in file contents'),
+    path: z
+      .string()
+      .optional()
+      .describe(
+        'The directory to search in. Defaults to the current working directory.'
+      ),
+    include: z
+      .string()
+      .optional()
+      .describe(
+        'File pattern to include in the search (e.g. "*.js", "*.{ts,tsx}")'
+      ),
   }),
   async execute(params) {
     if (!params.pattern) {
-      throw new Error("pattern is required")
+      throw new Error('pattern is required');
     }
 
-    const searchPath = params.path || Instance.directory
+    const searchPath = params.path || Instance.directory;
 
-    const rgPath = await Ripgrep.filepath()
-    const args = ["-nH", "--field-match-separator=|", "--regexp", params.pattern]
+    const rgPath = await Ripgrep.filepath();
+    const args = [
+      '-nH',
+      '--field-match-separator=|',
+      '--regexp',
+      params.pattern,
+    ];
     if (params.include) {
-      args.push("--glob", params.include)
+      args.push('--glob', params.include);
     }
-    args.push(searchPath)
+    args.push(searchPath);
 
     const proc = Bun.spawn([rgPath, ...args], {
-      stdout: "pipe",
-      stderr: "pipe",
-    })
+      stdout: 'pipe',
+      stderr: 'pipe',
+    });
 
-    const output = await new Response(proc.stdout).text()
-    const errorOutput = await new Response(proc.stderr).text()
-    const exitCode = await proc.exited
+    const output = await new Response(proc.stdout).text();
+    const errorOutput = await new Response(proc.stderr).text();
+    const exitCode = await proc.exited;
 
     if (exitCode === 1) {
       return {
         title: params.pattern,
         metadata: { matches: 0, truncated: false },
-        output: "No files found",
-      }
+        output: 'No files found',
+      };
     }
 
     if (exitCode !== 0) {
-      throw new Error(`ripgrep failed: ${errorOutput}`)
+      throw new Error(`ripgrep failed: ${errorOutput}`);
     }
 
-    const lines = output.trim().split("\n")
-    const matches = []
+    const lines = output.trim().split('\n');
+    const matches = [];
 
     for (const line of lines) {
-      if (!line) continue
+      if (!line) continue;
 
-      const [filePath, lineNumStr, ...lineTextParts] = line.split("|")
-      if (!filePath || !lineNumStr || lineTextParts.length === 0) continue
+      const [filePath, lineNumStr, ...lineTextParts] = line.split('|');
+      if (!filePath || !lineNumStr || lineTextParts.length === 0) continue;
 
-      const lineNum = parseInt(lineNumStr, 10)
-      const lineText = lineTextParts.join("|")
+      const lineNum = parseInt(lineNumStr, 10);
+      const lineText = lineTextParts.join('|');
 
-      const file = Bun.file(filePath)
-      const stats = await file.stat().catch(() => null)
-      if (!stats) continue
+      const file = Bun.file(filePath);
+      const stats = await file.stat().catch(() => null);
+      if (!stats) continue;
 
       matches.push({
         path: filePath,
         modTime: stats.mtime.getTime(),
         lineNum,
         lineText,
-      })
+      });
     }
 
-    matches.sort((a, b) => b.modTime - a.modTime)
+    matches.sort((a, b) => b.modTime - a.modTime);
 
-    const limit = 100
-    const truncated = matches.length > limit
-    const finalMatches = truncated ? matches.slice(0, limit) : matches
+    const limit = 100;
+    const truncated = matches.length > limit;
+    const finalMatches = truncated ? matches.slice(0, limit) : matches;
 
     if (finalMatches.length === 0) {
       return {
         title: params.pattern,
         metadata: { matches: 0, truncated: false },
-        output: "No files found",
-      }
+        output: 'No files found',
+      };
     }
 
-    const outputLines = [`Found ${finalMatches.length} matches`]
+    const outputLines = [`Found ${finalMatches.length} matches`];
 
-    let currentFile = ""
+    let currentFile = '';
     for (const match of finalMatches) {
       if (currentFile !== match.path) {
-        if (currentFile !== "") {
-          outputLines.push("")
+        if (currentFile !== '') {
+          outputLines.push('');
         }
-        currentFile = match.path
-        outputLines.push(`${match.path}:`)
+        currentFile = match.path;
+        outputLines.push(`${match.path}:`);
       }
-      outputLines.push(`  Line ${match.lineNum}: ${match.lineText}`)
+      outputLines.push(`  Line ${match.lineNum}: ${match.lineText}`);
     }
 
     if (truncated) {
-      outputLines.push("")
-      outputLines.push("(Results are truncated. Consider using a more specific path or pattern.)")
+      outputLines.push('');
+      outputLines.push(
+        '(Results are truncated. Consider using a more specific path or pattern.)'
+      );
     }
 
     return {
@@ -110,7 +129,7 @@ export const GrepTool = Tool.define("grep", {
         matches: finalMatches.length,
         truncated,
       },
-      output: outputLines.join("\n"),
-    }
+      output: outputLines.join('\n'),
+    };
   },
-})
+});

package/src/tool/invalid.ts

@@ -1,17 +1,17 @@
-import z from "zod"
-import { Tool } from "./tool"
+import z from 'zod';
+import { Tool } from './tool';
 
-export const InvalidTool = Tool.define("invalid", {
-  description: "Do not use",
+export const InvalidTool = Tool.define('invalid', {
+  description: 'Do not use',
   parameters: z.object({
     tool: z.string(),
     error: z.string(),
   }),
   async execute(params) {
     return {
-      title: "Invalid Tool",
+      title: 'Invalid Tool',
       output: `The arguments provided to the tool are invalid: ${params.error}`,
       metadata: {},
-    }
+    };
   },
-})
+});

package/src/tool/ls.ts

@@ -1,102 +1,115 @@
-import z from "zod"
-import { Tool } from "./tool"
-import * as path from "path"
-import DESCRIPTION from "./ls.txt"
-import { Instance } from "../project/instance"
-import { Ripgrep } from "../file/ripgrep"
+import z from 'zod';
+import { Tool } from './tool';
+import * as path from 'path';
+import DESCRIPTION from './ls.txt';
+import { Instance } from '../project/instance';
+import { Ripgrep } from '../file/ripgrep';
 
 export const IGNORE_PATTERNS = [
-  "node_modules/",
-  "__pycache__/",
-  ".git/",
-  "dist/",
-  "build/",
-  "target/",
-  "vendor/",
-  "bin/",
-  "obj/",
-  ".idea/",
-  ".vscode/",
-  ".zig-cache/",
-  "zig-out",
-  ".coverage",
-  "coverage/",
-  "vendor/",
-  "tmp/",
-  "temp/",
-  ".cache/",
-  "cache/",
-  "logs/",
-  ".venv/",
-  "venv/",
-  "env/",
-]
-
-const LIMIT = 100
-
-export const ListTool = Tool.define("list", {
+  'node_modules/',
+  '__pycache__/',
+  '.git/',
+  'dist/',
+  'build/',
+  'target/',
+  'vendor/',
+  'bin/',
+  'obj/',
+  '.idea/',
+  '.vscode/',
+  '.zig-cache/',
+  'zig-out',
+  '.coverage',
+  'coverage/',
+  'vendor/',
+  'tmp/',
+  'temp/',
+  '.cache/',
+  'cache/',
+  'logs/',
+  '.venv/',
+  'venv/',
+  'env/',
+];
+
+const LIMIT = 100;
+
+export const ListTool = Tool.define('list', {
   description: DESCRIPTION,
   parameters: z.object({
-    path: z.string().describe("The absolute path to the directory to list (must be absolute, not relative)").optional(),
-    ignore: z.array(z.string()).describe("List of glob patterns to ignore").optional(),
+    path: z
+      .string()
+      .describe(
+        'The absolute path to the directory to list (must be absolute, not relative)'
+      )
+      .optional(),
+    ignore: z
+      .array(z.string())
+      .describe('List of glob patterns to ignore')
+      .optional(),
   }),
   async execute(params) {
-    const searchPath = path.resolve(Instance.directory, params.path || ".")
-
-    const ignoreGlobs = IGNORE_PATTERNS.map((p) => `!${p}*`).concat(params.ignore?.map((p) => `!${p}`) || [])
-    const files = []
-    for await (const file of Ripgrep.files({ cwd: searchPath, glob: ignoreGlobs })) {
-      files.push(file)
-      if (files.length >= LIMIT) break
+    const searchPath = path.resolve(Instance.directory, params.path || '.');
+
+    const ignoreGlobs = IGNORE_PATTERNS.map((p) => `!${p}*`).concat(
+      params.ignore?.map((p) => `!${p}`) || []
+    );
+    const files = [];
+    for await (const file of Ripgrep.files({
+      cwd: searchPath,
+      glob: ignoreGlobs,
+    })) {
+      files.push(file);
+      if (files.length >= LIMIT) break;
     }
 
     // Build directory structure
-    const dirs = new Set<string>()
-    const filesByDir = new Map<string, string[]>()
+    const dirs = new Set<string>();
+    const filesByDir = new Map<string, string[]>();
 
     for (const file of files) {
-      const dir = path.dirname(file)
-      const parts = dir === "." ? [] : dir.split("/")
+      const dir = path.dirname(file);
+      const parts = dir === '.' ? [] : dir.split('/');
 
       // Add all parent directories
       for (let i = 0; i <= parts.length; i++) {
-        const dirPath = i === 0 ? "." : parts.slice(0, i).join("/")
-        dirs.add(dirPath)
+        const dirPath = i === 0 ? '.' : parts.slice(0, i).join('/');
+        dirs.add(dirPath);
       }
 
       // Add file to its directory
-      if (!filesByDir.has(dir)) filesByDir.set(dir, [])
-      filesByDir.get(dir)!.push(path.basename(file))
+      if (!filesByDir.has(dir)) filesByDir.set(dir, []);
+      filesByDir.get(dir)!.push(path.basename(file));
     }
 
     function renderDir(dirPath: string, depth: number): string {
-      const indent = "  ".repeat(depth)
-      let output = ""
+      const indent = '  '.repeat(depth);
+      let output = '';
 
       if (depth > 0) {
-        output += `${indent}${path.basename(dirPath)}/\n`
+        output += `${indent}${path.basename(dirPath)}/\n`;
       }
 
-      const childIndent = "  ".repeat(depth + 1)
+      const childIndent = '  '.repeat(depth + 1);
       const children = Array.from(dirs)
         .filter((d) => path.dirname(d) === dirPath && d !== dirPath)
-        .sort()
+        .sort();
 
       // Render subdirectories first
       for (const child of children) {
-        output += renderDir(child, depth + 1)
+        output += renderDir(child, depth + 1);
       }
 
       // Render files
-      const files = filesByDir.get(dirPath) || []
+      const files = filesByDir.get(dirPath) || [];
       for (const file of files.sort()) {
-        output += `${childIndent}${file}\n`
+        output += `${childIndent}${file}\n`;
       }
 
-      return output
+      return output;
     }
 
-    const output = `${searchPath}/\n` + renderDir(".", 0)
+    const output = `${searchPath}/\n` + renderDir('.', 0);
 
     return {
       title: path.relative(Instance.worktree, searchPath),
@@ -105,6 +118,6 @@ export const ListTool = Tool.define("list", {
         truncated: files.length >= LIMIT,
       },
       output,
-    }
+    };
   },
-})
+});

package/src/tool/multiedit.ts

@@ -1,28 +1,37 @@
-import z from "zod"
-import { Tool } from "./tool"
-import { EditTool } from "./edit"
-import DESCRIPTION from "./multiedit.txt"
-import path from "path"
-import { Instance } from "../project/instance"
+import z from 'zod';
+import { Tool } from './tool';
+import { EditTool } from './edit';
+import DESCRIPTION from './multiedit.txt';
+import path from 'path';
+import { Instance } from '../project/instance';
 
-export const MultiEditTool = Tool.define("multiedit", {
+export const MultiEditTool = Tool.define('multiedit', {
   description: DESCRIPTION,
   parameters: z.object({
-    filePath: z.string().describe("The absolute path to the file to modify"),
+    filePath: z.string().describe('The absolute path to the file to modify'),
     edits: z
       .array(
         z.object({
-          filePath: z.string().describe("The absolute path to the file to modify"),
-          oldString: z.string().describe("The text to replace"),
-          newString: z.string().describe("The text to replace it with (must be different from oldString)"),
-          replaceAll: z.boolean().optional().describe("Replace all occurrences of oldString (default false)"),
-        }),
+          filePath: z
+            .string()
+            .describe('The absolute path to the file to modify'),
+          oldString: z.string().describe('The text to replace'),
+          newString: z
+            .string()
+            .describe(
+              'The text to replace it with (must be different from oldString)'
+            ),
+          replaceAll: z
+            .boolean()
+            .optional()
+            .describe('Replace all occurrences of oldString (default false)'),
+        })
       )
-      .describe("Array of edit operations to perform sequentially on the file"),
+      .describe('Array of edit operations to perform sequentially on the file'),
   }),
   async execute(params, ctx) {
-    const tool = await EditTool.init()
-    const results = []
+    const tool = await EditTool.init();
+    const results = [];
     for (const [, edit] of params.edits.entries()) {
       const result = await tool.execute(
         {
@@ -31,9 +40,9 @@ export const MultiEditTool = Tool.define("multiedit", {
           newString: edit.newString,
           replaceAll: edit.replaceAll,
         },
-        ctx,
-      )
-      results.push(result)
+        ctx
+      );
+      results.push(result);
     }
     return {
       title: path.relative(Instance.worktree, params.filePath),
@@ -41,6 +50,6 @@ export const MultiEditTool = Tool.define("multiedit", {
         results: results.map((r) => r.metadata),
       },
       output: results.at(-1)!.output,
-    }
+    };
   },
-})
+});