@link-assistant/agent 0.0.8 → 0.0.11

package/src/tool/patch.ts

@@ -1,188 +1,215 @@
-import z from "zod"
-import * as path from "path"
-import * as fs from "fs/promises"
-import { Tool } from "./tool"
-import { FileTime } from "../file/time"
-import { Bus } from "../bus"
-import { FileWatcher } from "../file/watcher"
-import { Instance } from "../project/instance"
-import { Patch } from "../patch"
-import { Filesystem } from "../util/filesystem"
-import { createTwoFilesPatch } from "diff"
+import z from 'zod';
+import * as path from 'path';
+import * as fs from 'fs/promises';
+import { Tool } from './tool';
+import { FileTime } from '../file/time';
+import { Bus } from '../bus';
+import { FileWatcher } from '../file/watcher';
+import { Instance } from '../project/instance';
+import { Patch } from '../patch';
+import { Filesystem } from '../util/filesystem';
+import { createTwoFilesPatch } from 'diff';
 
 const PatchParams = z.object({
-  patchText: z.string().describe("The full patch text that describes all changes to be made"),
-})
+  patchText: z
+    .string()
+    .describe('The full patch text that describes all changes to be made'),
+});
 
-export const PatchTool = Tool.define("patch", {
+export const PatchTool = Tool.define('patch', {
   description:
-    "Apply a patch to modify multiple files. Supports adding, updating, and deleting files with context-aware changes.",
+    'Apply a patch to modify multiple files. Supports adding, updating, and deleting files with context-aware changes.',
   parameters: PatchParams,
   async execute(params, ctx) {
     if (!params.patchText) {
-      throw new Error("patchText is required")
+      throw new Error('patchText is required');
     }
 
     // Parse the patch to get hunks
-    let hunks: Patch.Hunk[]
+    let hunks: Patch.Hunk[];
     try {
-      const parseResult = Patch.parsePatch(params.patchText)
-      hunks = parseResult.hunks
+      const parseResult = Patch.parsePatch(params.patchText);
+      hunks = parseResult.hunks;
     } catch (error) {
-      throw new Error(`Failed to parse patch: ${error}`)
+      throw new Error(`Failed to parse patch: ${error}`);
     }
 
     if (hunks.length === 0) {
-      throw new Error("No file changes found in patch")
+      throw new Error('No file changes found in patch');
     }
 
     // No restrictions - unrestricted patching
     const fileChanges: Array<{
-      filePath: string
-      oldContent: string
-      newContent: string
-      type: "add" | "update" | "delete" | "move"
-      movePath?: string
-    }> = []
+      filePath: string;
+      oldContent: string;
+      newContent: string;
+      type: 'add' | 'update' | 'delete' | 'move';
+      movePath?: string;
+    }> = [];
 
-    let totalDiff = ""
+    let totalDiff = '';
 
     for (const hunk of hunks) {
-      const filePath = path.resolve(Instance.directory, hunk.path)
+      const filePath = path.resolve(Instance.directory, hunk.path);
 
       switch (hunk.type) {
-        case "add":
-          if (hunk.type === "add") {
-            const oldContent = ""
-            const newContent = hunk.contents
-            const diff = createTwoFilesPatch(filePath, filePath, oldContent, newContent)
+        case 'add':
+          if (hunk.type === 'add') {
+            const oldContent = '';
+            const newContent = hunk.contents;
+            const diff = createTwoFilesPatch(
+              filePath,
+              filePath,
+              oldContent,
+              newContent
+            );
 
             fileChanges.push({
               filePath,
               oldContent,
               newContent,
-              type: "add",
-            })
+              type: 'add',
+            });
 
-            totalDiff += diff + "\n"
+            totalDiff += diff + '\n';
           }
-          break
+          break;
 
-        case "update":
+        case 'update':
           // Check if file exists for update
-          const stats = await fs.stat(filePath).catch(() => null)
+          const stats = await fs.stat(filePath).catch(() => null);
           if (!stats || stats.isDirectory()) {
-            throw new Error(`File not found or is directory: ${filePath}`)
+            throw new Error(`File not found or is directory: ${filePath}`);
           }
 
           // Read file and update time tracking (like edit tool does)
-          await FileTime.assert(ctx.sessionID, filePath)
-          const oldContent = await fs.readFile(filePath, "utf-8")
-          let newContent = oldContent
+          await FileTime.assert(ctx.sessionID, filePath);
+          const oldContent = await fs.readFile(filePath, 'utf-8');
+          let newContent = oldContent;
 
           // Apply the update chunks to get new content
           try {
-            const fileUpdate = Patch.deriveNewContentsFromChunks(filePath, hunk.chunks)
-            newContent = fileUpdate.content
+            const fileUpdate = Patch.deriveNewContentsFromChunks(
+              filePath,
+              hunk.chunks
+            );
+            newContent = fileUpdate.content;
           } catch (error) {
-            throw new Error(`Failed to apply update to ${filePath}: ${error}`)
+            throw new Error(`Failed to apply update to ${filePath}: ${error}`);
           }
 
-          const diff = createTwoFilesPatch(filePath, filePath, oldContent, newContent)
+          const diff = createTwoFilesPatch(
+            filePath,
+            filePath,
+            oldContent,
+            newContent
+          );
 
           fileChanges.push({
             filePath,
             oldContent,
             newContent,
-            type: hunk.move_path ? "move" : "update",
-            movePath: hunk.move_path ? path.resolve(Instance.directory, hunk.move_path) : undefined,
-          })
+            type: hunk.move_path ? 'move' : 'update',
+            movePath: hunk.move_path
+              ? path.resolve(Instance.directory, hunk.move_path)
+              : undefined,
+          });
 
-          totalDiff += diff + "\n"
-          break
+          totalDiff += diff + '\n';
+          break;
 
-        case "delete":
+        case 'delete':
           // Check if file exists for deletion
-          await FileTime.assert(ctx.sessionID, filePath)
-          const contentToDelete = await fs.readFile(filePath, "utf-8")
-          const deleteDiff = createTwoFilesPatch(filePath, filePath, contentToDelete, "")
+          await FileTime.assert(ctx.sessionID, filePath);
+          const contentToDelete = await fs.readFile(filePath, 'utf-8');
+          const deleteDiff = createTwoFilesPatch(
+            filePath,
+            filePath,
+            contentToDelete,
+            ''
+          );
 
           fileChanges.push({
             filePath,
             oldContent: contentToDelete,
-            newContent: "",
-            type: "delete",
-          })
+            newContent: '',
+            type: 'delete',
+          });
 
-          totalDiff += deleteDiff + "\n"
-          break
+          totalDiff += deleteDiff + '\n';
+          break;
       }
     }
 
     // No restrictions - apply changes directly
     // Apply the changes
-    const changedFiles: string[] = []
+    const changedFiles: string[] = [];
 
     for (const change of fileChanges) {
       switch (change.type) {
-        case "add":
+        case 'add':
           // Create parent directories
-          const addDir = path.dirname(change.filePath)
-          if (addDir !== "." && addDir !== "/") {
-            await fs.mkdir(addDir, { recursive: true })
+          const addDir = path.dirname(change.filePath);
+          if (addDir !== '.' && addDir !== '/') {
+            await fs.mkdir(addDir, { recursive: true });
           }
-          await fs.writeFile(change.filePath, change.newContent, "utf-8")
-          changedFiles.push(change.filePath)
-          break
+          await fs.writeFile(change.filePath, change.newContent, 'utf-8');
+          changedFiles.push(change.filePath);
+          break;
 
-        case "update":
-          await fs.writeFile(change.filePath, change.newContent, "utf-8")
-          changedFiles.push(change.filePath)
-          break
+        case 'update':
+          await fs.writeFile(change.filePath, change.newContent, 'utf-8');
+          changedFiles.push(change.filePath);
+          break;
 
-        case "move":
+        case 'move':
           if (change.movePath) {
             // Create parent directories for destination
-            const moveDir = path.dirname(change.movePath)
-            if (moveDir !== "." && moveDir !== "/") {
-              await fs.mkdir(moveDir, { recursive: true })
+            const moveDir = path.dirname(change.movePath);
+            if (moveDir !== '.' && moveDir !== '/') {
+              await fs.mkdir(moveDir, { recursive: true });
             }
             // Write to new location
-            await fs.writeFile(change.movePath, change.newContent, "utf-8")
+            await fs.writeFile(change.movePath, change.newContent, 'utf-8');
             // Remove original
-            await fs.unlink(change.filePath)
-            changedFiles.push(change.movePath)
+            await fs.unlink(change.filePath);
+            changedFiles.push(change.movePath);
           }
-          break
+          break;
 
-        case "delete":
-          await fs.unlink(change.filePath)
-          changedFiles.push(change.filePath)
-          break
+        case 'delete':
+          await fs.unlink(change.filePath);
+          changedFiles.push(change.filePath);
+          break;
       }
 
       // Update file time tracking
-      FileTime.read(ctx.sessionID, change.filePath)
+      FileTime.read(ctx.sessionID, change.filePath);
       if (change.movePath) {
-        FileTime.read(ctx.sessionID, change.movePath)
+        FileTime.read(ctx.sessionID, change.movePath);
       }
     }
 
     // Publish file change events
     for (const filePath of changedFiles) {
-      await Bus.publish(FileWatcher.Event.Updated, { file: filePath, event: "change" })
+      await Bus.publish(FileWatcher.Event.Updated, {
+        file: filePath,
+        event: 'change',
+      });
     }
 
     // Generate output summary
-    const relativePaths = changedFiles.map((filePath) => path.relative(Instance.worktree, filePath))
-    const summary = `${fileChanges.length} files changed`
+    const relativePaths = changedFiles.map((filePath) =>
+      path.relative(Instance.worktree, filePath)
+    );
+    const summary = `${fileChanges.length} files changed`;
 
     return {
       title: summary,
       metadata: {
         diff: totalDiff,
       },
-      output: `Patch applied successfully. ${summary}:\n${relativePaths.map((p) => `  ${p}`).join("\n")}`,
-    }
+      output: `Patch applied successfully. ${summary}:\n${relativePaths.map((p) => `  ${p}`).join('\n')}`,
+    };
   },
-})
+});

package/src/tool/read.ts

@@ -1,69 +1,82 @@
-import z from "zod"
-import * as fs from "fs"
-import * as path from "path"
-import { Tool } from "./tool"
-import { FileTime } from "../file/time"
-import DESCRIPTION from "./read.txt"
-import { Filesystem } from "../util/filesystem"
-import { Instance } from "../project/instance"
-import { Provider } from "../provider/provider"
-import { Identifier } from "../id/id"
-import { iife } from "../util/iife"
-
-const DEFAULT_READ_LIMIT = 2000
-const MAX_LINE_LENGTH = 2000
-
-export const ReadTool = Tool.define("read", {
+import z from 'zod';
+import * as fs from 'fs';
+import * as path from 'path';
+import { Tool } from './tool';
+import { FileTime } from '../file/time';
+import DESCRIPTION from './read.txt';
+import { Filesystem } from '../util/filesystem';
+import { Instance } from '../project/instance';
+import { Provider } from '../provider/provider';
+import { Identifier } from '../id/id';
+import { iife } from '../util/iife';
+
+const DEFAULT_READ_LIMIT = 2000;
+const MAX_LINE_LENGTH = 2000;
+
+export const ReadTool = Tool.define('read', {
   description: DESCRIPTION,
   parameters: z.object({
-    filePath: z.string().describe("The path to the file to read"),
-    offset: z.coerce.number().describe("The line number to start reading from (0-based)").optional(),
-    limit: z.coerce.number().describe("The number of lines to read (defaults to 2000)").optional(),
+    filePath: z.string().describe('The path to the file to read'),
+    offset: z.coerce
+      .number()
+      .describe('The line number to start reading from (0-based)')
+      .optional(),
+    limit: z.coerce
+      .number()
+      .describe('The number of lines to read (defaults to 2000)')
+      .optional(),
   }),
   async execute(params, ctx) {
-    let filepath = params.filePath
+    let filepath = params.filePath;
     if (!path.isAbsolute(filepath)) {
-      filepath = path.join(process.cwd(), filepath)
+      filepath = path.join(process.cwd(), filepath);
     }
-    const title = path.relative(Instance.worktree, filepath)
+    const title = path.relative(Instance.worktree, filepath);
 
     // No restrictions - unrestricted file read
-    const file = Bun.file(filepath)
+    const file = Bun.file(filepath);
     if (!(await file.exists())) {
-      const dir = path.dirname(filepath)
-      const base = path.basename(filepath)
+      const dir = path.dirname(filepath);
+      const base = path.basename(filepath);
 
-      const dirEntries = fs.readdirSync(dir)
+      const dirEntries = fs.readdirSync(dir);
       const suggestions = dirEntries
         .filter(
           (entry) =>
-            entry.toLowerCase().includes(base.toLowerCase()) || base.toLowerCase().includes(entry.toLowerCase()),
+            entry.toLowerCase().includes(base.toLowerCase()) ||
+            base.toLowerCase().includes(entry.toLowerCase())
         )
         .map((entry) => path.join(dir, entry))
-        .slice(0, 3)
+        .slice(0, 3);
 
       if (suggestions.length > 0) {
-        throw new Error(`File not found: ${filepath}\n\nDid you mean one of these?\n${suggestions.join("\n")}`)
+        throw new Error(
+          `File not found: ${filepath}\n\nDid you mean one of these?\n${suggestions.join('\n')}`
+        );
       }
 
-      throw new Error(`File not found: ${filepath}`)
+      throw new Error(`File not found: ${filepath}`);
     }
 
-    const isImage = isImageFile(filepath)
+    const isImage = isImageFile(filepath);
     const supportsImages = await (async () => {
-      if (!ctx.extra?.["providerID"] || !ctx.extra?.["modelID"]) return false
-      const providerID = ctx.extra["providerID"] as string
-      const modelID = ctx.extra["modelID"] as string
-      const model = await Provider.getModel(providerID, modelID).catch(() => undefined)
-      if (!model) return false
-      return model.info.modalities?.input?.includes("image") ?? false
-    })()
+      if (!ctx.extra?.['providerID'] || !ctx.extra?.['modelID']) return false;
+      const providerID = ctx.extra['providerID'] as string;
+      const modelID = ctx.extra['modelID'] as string;
+      const model = await Provider.getModel(providerID, modelID).catch(
+        () => undefined
+      );
+      if (!model) return false;
+      return model.info.modalities?.input?.includes('image') ?? false;
+    })();
     if (isImage) {
       if (!supportsImages) {
-        throw new Error(`Failed to read image: ${filepath}, model may not be able to read images`)
+        throw new Error(
+          `Failed to read image: ${filepath}, model may not be able to read images`
+        );
       }
-      const mime = file.type
-      const msg = "Image read successfully"
+      const mime = file.type;
+      const msg = 'Image read successfully';
       return {
         title,
         output: msg,
@@ -72,47 +85,49 @@ export const ReadTool = Tool.define("read", {
         },
         attachments: [
           {
-            id: Identifier.ascending("part"),
+            id: Identifier.ascending('part'),
             sessionID: ctx.sessionID,
             messageID: ctx.messageID,
-            type: "file",
+            type: 'file',
             mime,
-            url: `data:${mime};base64,${Buffer.from(await file.bytes()).toString("base64")}`,
+            url: `data:${mime};base64,${Buffer.from(await file.bytes()).toString('base64')}`,
           },
         ],
-      }
+      };
     }
 
-    const isBinary = await isBinaryFile(filepath, file)
-    if (isBinary) throw new Error(`Cannot read binary file: ${filepath}`)
+    const isBinary = await isBinaryFile(filepath, file);
+    if (isBinary) throw new Error(`Cannot read binary file: ${filepath}`);
 
-    const limit = params.limit ?? DEFAULT_READ_LIMIT
-    const offset = params.offset || 0
-    const lines = await file.text().then((text) => text.split("\n"))
+    const limit = params.limit ?? DEFAULT_READ_LIMIT;
+    const offset = params.offset || 0;
+    const lines = await file.text().then((text) => text.split('\n'));
     const raw = lines.slice(offset, offset + limit).map((line) => {
-      return line.length > MAX_LINE_LENGTH ? line.substring(0, MAX_LINE_LENGTH) + "..." : line
-    })
+      return line.length > MAX_LINE_LENGTH
+        ? line.substring(0, MAX_LINE_LENGTH) + '...'
+        : line;
+    });
     const content = raw.map((line, index) => {
-      return `${(index + offset + 1).toString().padStart(5, "0")}| ${line}`
-    })
-    const preview = raw.slice(0, 20).join("\n")
+      return `${(index + offset + 1).toString().padStart(5, '0')}| ${line}`;
+    });
+    const preview = raw.slice(0, 20).join('\n');
 
-    let output = "<file>\n"
-    output += content.join("\n")
+    let output = '<file>\n';
+    output += content.join('\n');
 
-    const totalLines = lines.length
-    const lastReadLine = offset + content.length
-    const hasMoreLines = totalLines > lastReadLine
+    const totalLines = lines.length;
+    const lastReadLine = offset + content.length;
+    const hasMoreLines = totalLines > lastReadLine;
 
     if (hasMoreLines) {
-      output += `\n\n(File has more lines. Use 'offset' parameter to read beyond line ${lastReadLine})`
+      output += `\n\n(File has more lines. Use 'offset' parameter to read beyond line ${lastReadLine})`;
     } else {
-      output += `\n\n(End of file - total ${totalLines} lines)`
+      output += `\n\n(End of file - total ${totalLines} lines)`;
     }
-    output += "\n</file>"
+    output += '\n</file>';
 
     // just warms the lsp client
-    FileTime.read(ctx.sessionID, filepath)
+    FileTime.read(ctx.sessionID, filepath);
 
     return {
       title,
@@ -120,82 +135,85 @@ export const ReadTool = Tool.define("read", {
       metadata: {
         preview,
       },
-    }
+    };
   },
-})
+});
 
 function isImageFile(filePath: string): string | false {
-  const ext = path.extname(filePath).toLowerCase()
+  const ext = path.extname(filePath).toLowerCase();
   switch (ext) {
-    case ".jpg":
-    case ".jpeg":
-      return "JPEG"
-    case ".png":
-      return "PNG"
-    case ".gif":
-      return "GIF"
-    case ".bmp":
-      return "BMP"
-    case ".webp":
-      return "WebP"
+    case '.jpg':
+    case '.jpeg':
+      return 'JPEG';
+    case '.png':
+      return 'PNG';
+    case '.gif':
+      return 'GIF';
+    case '.bmp':
+      return 'BMP';
+    case '.webp':
+      return 'WebP';
     default:
-      return false
+      return false;
   }
 }
 
-async function isBinaryFile(filepath: string, file: Bun.BunFile): Promise<boolean> {
-  const ext = path.extname(filepath).toLowerCase()
+async function isBinaryFile(
+  filepath: string,
+  file: Bun.BunFile
+): Promise<boolean> {
+  const ext = path.extname(filepath).toLowerCase();
   // binary check for common non-text extensions
   switch (ext) {
-    case ".zip":
-    case ".tar":
-    case ".gz":
-    case ".exe":
-    case ".dll":
-    case ".so":
-    case ".class":
-    case ".jar":
-    case ".war":
-    case ".7z":
-    case ".doc":
-    case ".docx":
-    case ".xls":
-    case ".xlsx":
-    case ".ppt":
-    case ".pptx":
-    case ".odt":
-    case ".ods":
-    case ".odp":
-    case ".bin":
-    case ".dat":
-    case ".obj":
-    case ".o":
-    case ".a":
-    case ".lib":
-    case ".wasm":
-    case ".pyc":
-    case ".pyo":
-      return true
+    case '.zip':
+    case '.tar':
+    case '.gz':
+    case '.exe':
+    case '.dll':
+    case '.so':
+    case '.class':
+    case '.jar':
+    case '.war':
+    case '.7z':
+    case '.doc':
+    case '.docx':
+    case '.xls':
+    case '.xlsx':
+    case '.ppt':
+    case '.pptx':
+    case '.odt':
+    case '.ods':
+    case '.odp':
+    case '.bin':
+    case '.dat':
+    case '.obj':
+    case '.o':
+    case '.a':
+    case '.lib':
+    case '.wasm':
+    case '.pyc':
+    case '.pyo':
+      return true;
     default:
-      break
+      break;
   }
 
-  const stat = await file.stat()
-  const fileSize = stat.size
-  if (fileSize === 0) return false
+  const stat = await file.stat();
+  const fileSize = stat.size;
+  if (fileSize === 0) return false;
 
-  const bufferSize = Math.min(4096, fileSize)
-  const buffer = await file.arrayBuffer()
-  if (buffer.byteLength === 0) return false
-  const bytes = new Uint8Array(buffer.slice(0, bufferSize))
+  const bufferSize = Math.min(4096, fileSize);
+  const buffer = await file.arrayBuffer();
+  if (buffer.byteLength === 0) return false;
+  const bytes = new Uint8Array(buffer.slice(0, bufferSize));
 
-  let nonPrintableCount = 0
+  let nonPrintableCount = 0;
   for (let i = 0; i < bytes.length; i++) {
-    if (bytes[i] === 0) return true
+    if (bytes[i] === 0) return true;
     if (bytes[i] < 9 || (bytes[i] > 13 && bytes[i] < 32)) {
-      nonPrintableCount++
+      nonPrintableCount++;
     }
   }
   // If >30% non-printable characters, consider it binary
-  return nonPrintableCount / bytes.length > 0.3
+  return nonPrintableCount / bytes.length > 0.3;
 }