@link-assistant/agent 0.0.9 → 0.0.12

package/src/tool/webfetch.ts

@@ -1,171 +1,194 @@
-import z from "zod"
-import { Tool } from "./tool"
-import TurndownService from "turndown"
-import DESCRIPTION from "./webfetch.txt"
+import z from 'zod';
+import { Tool } from './tool';
+import TurndownService from 'turndown';
+import DESCRIPTION from './webfetch.txt';
 
-const MAX_RESPONSE_SIZE = 5 * 1024 * 1024 // 5MB
-const DEFAULT_TIMEOUT = 30 * 1000 // 30 seconds
-const MAX_TIMEOUT = 120 * 1000 // 2 minutes
+const MAX_RESPONSE_SIZE = 5 * 1024 * 1024; // 5MB
+const DEFAULT_TIMEOUT = 30 * 1000; // 30 seconds
+const MAX_TIMEOUT = 120 * 1000; // 2 minutes
 
-export const WebFetchTool = Tool.define("webfetch", {
+export const WebFetchTool = Tool.define('webfetch', {
   description: DESCRIPTION,
   parameters: z.object({
-    url: z.string().describe("The URL to fetch content from"),
+    url: z.string().describe('The URL to fetch content from'),
     format: z
-      .enum(["text", "markdown", "html"])
-      .describe("The format to return the content in (text, markdown, or html)"),
-    timeout: z.number().describe("Optional timeout in seconds (max 120)").optional(),
+      .enum(['text', 'markdown', 'html'])
+      .describe(
+        'The format to return the content in (text, markdown, or html)'
+      ),
+    timeout: z
+      .number()
+      .describe('Optional timeout in seconds (max 120)')
+      .optional(),
   }),
   async execute(params, ctx) {
     // Validate URL
-    if (!params.url.startsWith("http://") && !params.url.startsWith("https://")) {
-      throw new Error("URL must start with http:// or https://")
+    if (
+      !params.url.startsWith('http://') &&
+      !params.url.startsWith('https://')
+    ) {
+      throw new Error('URL must start with http:// or https://');
     }
 
     // No restrictions - unrestricted web fetch
-    const timeout = Math.min((params.timeout ?? DEFAULT_TIMEOUT / 1000) * 1000, MAX_TIMEOUT)
+    const timeout = Math.min(
+      (params.timeout ?? DEFAULT_TIMEOUT / 1000) * 1000,
+      MAX_TIMEOUT
+    );
 
-    const controller = new AbortController()
-    const timeoutId = setTimeout(() => controller.abort(), timeout)
+    const controller = new AbortController();
+    const timeoutId = setTimeout(() => controller.abort(), timeout);
 
     // Build Accept header based on requested format with q parameters for fallbacks
-    let acceptHeader = "*/*"
+    let acceptHeader = '*/*';
     switch (params.format) {
-      case "markdown":
-        acceptHeader = "text/markdown;q=1.0, text/x-markdown;q=0.9, text/plain;q=0.8, text/html;q=0.7, */*;q=0.1"
-        break
-      case "text":
-        acceptHeader = "text/plain;q=1.0, text/markdown;q=0.9, text/html;q=0.8, */*;q=0.1"
-        break
-      case "html":
-        acceptHeader = "text/html;q=1.0, application/xhtml+xml;q=0.9, text/plain;q=0.8, text/markdown;q=0.7, */*;q=0.1"
-        break
+      case 'markdown':
+        acceptHeader =
+          'text/markdown;q=1.0, text/x-markdown;q=0.9, text/plain;q=0.8, text/html;q=0.7, */*;q=0.1';
+        break;
+      case 'text':
+        acceptHeader =
+          'text/plain;q=1.0, text/markdown;q=0.9, text/html;q=0.8, */*;q=0.1';
+        break;
+      case 'html':
+        acceptHeader =
+          'text/html;q=1.0, application/xhtml+xml;q=0.9, text/plain;q=0.8, text/markdown;q=0.7, */*;q=0.1';
+        break;
       default:
         acceptHeader =
-          "text/html,application/xhtml+xml,application/xml;q=0.9,image/avif,image/webp,image/apng,*/*;q=0.8"
+          'text/html,application/xhtml+xml,application/xml;q=0.9,image/avif,image/webp,image/apng,*/*;q=0.8';
     }
 
     const response = await fetch(params.url, {
       signal: AbortSignal.any([controller.signal, ctx.abort]),
       headers: {
-        "User-Agent":
-          "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/120.0.0.0 Safari/537.36",
+        'User-Agent':
+          'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/120.0.0.0 Safari/537.36',
         Accept: acceptHeader,
-        "Accept-Language": "en-US,en;q=0.9",
+        'Accept-Language': 'en-US,en;q=0.9',
       },
-    })
+    });
 
-    clearTimeout(timeoutId)
+    clearTimeout(timeoutId);
 
     if (!response.ok) {
-      throw new Error(`Request failed with status code: ${response.status}`)
+      throw new Error(`Request failed with status code: ${response.status}`);
     }
 
     // Check content length
-    const contentLength = response.headers.get("content-length")
+    const contentLength = response.headers.get('content-length');
     if (contentLength && parseInt(contentLength) > MAX_RESPONSE_SIZE) {
-      throw new Error("Response too large (exceeds 5MB limit)")
+      throw new Error('Response too large (exceeds 5MB limit)');
     }
 
-    const arrayBuffer = await response.arrayBuffer()
+    const arrayBuffer = await response.arrayBuffer();
     if (arrayBuffer.byteLength > MAX_RESPONSE_SIZE) {
-      throw new Error("Response too large (exceeds 5MB limit)")
+      throw new Error('Response too large (exceeds 5MB limit)');
     }
 
-    const content = new TextDecoder().decode(arrayBuffer)
-    const contentType = response.headers.get("content-type") || ""
+    const content = new TextDecoder().decode(arrayBuffer);
+    const contentType = response.headers.get('content-type') || '';
 
-    const title = `${params.url} (${contentType})`
+    const title = `${params.url} (${contentType})`;
 
     // Handle content based on requested format and actual content type
     switch (params.format) {
-      case "markdown":
-        if (contentType.includes("text/html")) {
-          const markdown = convertHTMLToMarkdown(content)
+      case 'markdown':
+        if (contentType.includes('text/html')) {
+          const markdown = convertHTMLToMarkdown(content);
           return {
             output: markdown,
             title,
             metadata: {},
-          }
+          };
         }
         return {
           output: content,
           title,
           metadata: {},
-        }
+        };
 
-      case "text":
-        if (contentType.includes("text/html")) {
-          const text = await extractTextFromHTML(content)
+      case 'text':
+        if (contentType.includes('text/html')) {
+          const text = await extractTextFromHTML(content);
           return {
             output: text,
             title,
             metadata: {},
-          }
+          };
         }
         return {
           output: content,
           title,
           metadata: {},
-        }
+        };
 
-      case "html":
+      case 'html':
         return {
           output: content,
           title,
           metadata: {},
-        }
+        };
 
       default:
         return {
           output: content,
           title,
           metadata: {},
-        }
+        };
     }
   },
-})
+});
 
 async function extractTextFromHTML(html: string) {
-  let text = ""
-  let skipContent = false
+  let text = '';
+  let skipContent = false;
 
   const rewriter = new HTMLRewriter()
-    .on("script, style, noscript, iframe, object, embed", {
+    .on('script, style, noscript, iframe, object, embed', {
       element() {
-        skipContent = true
+        skipContent = true;
       },
       text() {
         // Skip text content inside these elements
       },
     })
-    .on("*", {
+    .on('*', {
       element(element) {
         // Reset skip flag when entering other elements
-        if (!["script", "style", "noscript", "iframe", "object", "embed"].includes(element.tagName)) {
-          skipContent = false
+        if (
+          ![
+            'script',
+            'style',
+            'noscript',
+            'iframe',
+            'object',
+            'embed',
+          ].includes(element.tagName)
+        ) {
+          skipContent = false;
         }
       },
       text(input) {
         if (!skipContent) {
-          text += input.text
+          text += input.text;
         }
       },
     })
-    .transform(new Response(html))
+    .transform(new Response(html));
 
-  await rewriter.text()
-  return text.trim()
+  await rewriter.text();
+  return text.trim();
 }
 
 function convertHTMLToMarkdown(html: string): string {
   const turndownService = new TurndownService({
-    headingStyle: "atx",
-    hr: "---",
-    bulletListMarker: "-",
-    codeBlockStyle: "fenced",
-    emDelimiter: "*",
-  })
-  turndownService.remove(["script", "style", "meta", "link"])
-  return turndownService.turndown(html)
+    headingStyle: 'atx',
+    hr: '---',
+    bulletListMarker: '-',
+    codeBlockStyle: 'fenced',
+    emDelimiter: '*',
+  });
+  turndownService.remove(['script', 'style', 'meta', 'link']);
+  return turndownService.turndown(html);
 }

package/src/tool/websearch.ts

@@ -1,133 +1,147 @@
-import z from "zod"
-import { Tool } from "./tool"
-import DESCRIPTION from "./websearch.txt"
-import { Config } from "../config/config"
+import z from 'zod';
+import { Tool } from './tool';
+import DESCRIPTION from './websearch.txt';
+import { Config } from '../config/config';
 
 const API_CONFIG = {
-  BASE_URL: "https://mcp.exa.ai",
+  BASE_URL: 'https://mcp.exa.ai',
   ENDPOINTS: {
-    SEARCH: "/mcp",
+    SEARCH: '/mcp',
   },
   DEFAULT_NUM_RESULTS: 8,
-} as const
+} as const;
 
 interface McpSearchRequest {
-  jsonrpc: string
-  id: number
-  method: string
+  jsonrpc: string;
+  id: number;
+  method: string;
   params: {
-    name: string
+    name: string;
     arguments: {
-      query: string
-      numResults?: number
-      livecrawl?: "fallback" | "preferred"
-      type?: "auto" | "fast" | "deep"
-      contextMaxCharacters?: number
-    }
-  }
+      query: string;
+      numResults?: number;
+      livecrawl?: 'fallback' | 'preferred';
+      type?: 'auto' | 'fast' | 'deep';
+      contextMaxCharacters?: number;
+    };
+  };
 }
 
 interface McpSearchResponse {
-  jsonrpc: string
+  jsonrpc: string;
   result: {
     content: Array<{
-      type: string
-      text: string
-    }>
-  }
+      type: string;
+      text: string;
+    }>;
+  };
 }
 
-export const WebSearchTool = Tool.define("websearch", {
+export const WebSearchTool = Tool.define('websearch', {
   description: DESCRIPTION,
   parameters: z.object({
-    query: z.string().describe("Websearch query"),
-    numResults: z.number().optional().describe("Number of search results to return (default: 8)"),
+    query: z.string().describe('Websearch query'),
+    numResults: z
+      .number()
+      .optional()
+      .describe('Number of search results to return (default: 8)'),
     livecrawl: z
-      .enum(["fallback", "preferred"])
+      .enum(['fallback', 'preferred'])
       .optional()
       .describe(
-        "Live crawl mode - 'fallback': use live crawling as backup if cached content unavailable, 'preferred': prioritize live crawling (default: 'fallback')",
+        "Live crawl mode - 'fallback': use live crawling as backup if cached content unavailable, 'preferred': prioritize live crawling (default: 'fallback')"
       ),
     type: z
-      .enum(["auto", "fast", "deep"])
+      .enum(['auto', 'fast', 'deep'])
       .optional()
-      .describe("Search type - 'auto': balanced search (default), 'fast': quick results, 'deep': comprehensive search"),
+      .describe(
+        "Search type - 'auto': balanced search (default), 'fast': quick results, 'deep': comprehensive search"
+      ),
     contextMaxCharacters: z
       .number()
       .optional()
-      .describe("Maximum characters for context string optimized for LLMs (default: 10000)"),
+      .describe(
+        'Maximum characters for context string optimized for LLMs (default: 10000)'
+      ),
   }),
   async execute(params, ctx) {
     // No restrictions - unrestricted web search
     const searchRequest: McpSearchRequest = {
-      jsonrpc: "2.0",
+      jsonrpc: '2.0',
       id: 1,
-      method: "tools/call",
+      method: 'tools/call',
       params: {
-        name: "web_search_exa",
+        name: 'web_search_exa',
         arguments: {
           query: params.query,
-          type: params.type || "auto",
+          type: params.type || 'auto',
           numResults: params.numResults || API_CONFIG.DEFAULT_NUM_RESULTS,
-          livecrawl: params.livecrawl || "fallback",
+          livecrawl: params.livecrawl || 'fallback',
           contextMaxCharacters: params.contextMaxCharacters,
         },
       },
-    }
+    };
 
-    const controller = new AbortController()
-    const timeoutId = setTimeout(() => controller.abort(), 25000)
+    const controller = new AbortController();
+    const timeoutId = setTimeout(() => controller.abort(), 25000);
 
     try {
       const headers: Record<string, string> = {
-        accept: "application/json, text/event-stream",
-        "content-type": "application/json",
-      }
+        accept: 'application/json, text/event-stream',
+        'content-type': 'application/json',
+      };
 
-      const response = await fetch(`${API_CONFIG.BASE_URL}${API_CONFIG.ENDPOINTS.SEARCH}`, {
-        method: "POST",
-        headers,
-        body: JSON.stringify(searchRequest),
-        signal: AbortSignal.any([controller.signal, ctx.abort]),
-      })
+      const response = await fetch(
+        `${API_CONFIG.BASE_URL}${API_CONFIG.ENDPOINTS.SEARCH}`,
+        {
+          method: 'POST',
+          headers,
+          body: JSON.stringify(searchRequest),
+          signal: AbortSignal.any([controller.signal, ctx.abort]),
+        }
+      );
 
-      clearTimeout(timeoutId)
+      clearTimeout(timeoutId);
 
       if (!response.ok) {
-        const errorText = await response.text()
-        throw new Error(`Search error (${response.status}): ${errorText}`)
+        const errorText = await response.text();
+        throw new Error(`Search error (${response.status}): ${errorText}`);
       }
 
-      const responseText = await response.text()
+      const responseText = await response.text();
 
       // Parse SSE response
-      const lines = responseText.split("\n")
+      const lines = responseText.split('\n');
       for (const line of lines) {
-        if (line.startsWith("data: ")) {
-          const data: McpSearchResponse = JSON.parse(line.substring(6))
-          if (data.result && data.result.content && data.result.content.length > 0) {
+        if (line.startsWith('data: ')) {
+          const data: McpSearchResponse = JSON.parse(line.substring(6));
+          if (
+            data.result &&
+            data.result.content &&
+            data.result.content.length > 0
+          ) {
             return {
               output: data.result.content[0].text,
               title: `Web search: ${params.query}`,
               metadata: {},
-            }
+            };
           }
         }
       }
 
       return {
-        output: "No search results found. Please try a different query.",
+        output: 'No search results found. Please try a different query.',
         title: `Web search: ${params.query}`,
         metadata: {},
-      }
+      };
     } catch (error) {
-      clearTimeout(timeoutId)
+      clearTimeout(timeoutId);
 
-      if (error instanceof Error && error.name === "AbortError") {
-        throw new Error("Search request timed out")
+      if (error instanceof Error && error.name === 'AbortError') {
+        throw new Error('Search request timed out');
       }
 
-      throw error
+      throw error;
     }
   },
-})
+});

package/src/tool/write.ts

@@ -1,24 +1,30 @@
-import z from "zod"
-import * as path from "path"
-import { Tool } from "./tool"
-import DESCRIPTION from "./write.txt"
-import { Instance } from "../project/instance"
+import z from 'zod';
+import * as path from 'path';
+import { Tool } from './tool';
+import DESCRIPTION from './write.txt';
+import { Instance } from '../project/instance';
 
-export const WriteTool = Tool.define("write", {
+export const WriteTool = Tool.define('write', {
   description: DESCRIPTION,
   parameters: z.object({
-    content: z.string().describe("The content to write to the file"),
-    filePath: z.string().describe("The absolute path to the file to write (must be absolute, not relative)"),
+    content: z.string().describe('The content to write to the file'),
+    filePath: z
+      .string()
+      .describe(
+        'The absolute path to the file to write (must be absolute, not relative)'
+      ),
   }),
   async execute(params, ctx) {
     // No restrictions - unrestricted file system access
-    const filepath = path.isAbsolute(params.filePath) ? params.filePath : path.join(Instance.directory, params.filePath)
+    const filepath = path.isAbsolute(params.filePath)
+      ? params.filePath
+      : path.join(Instance.directory, params.filePath);
 
-    const file = Bun.file(filepath)
-    const exists = await file.exists()
+    const file = Bun.file(filepath);
+    const exists = await file.exists();
 
     // Write the file without permission checks
-    await Bun.write(filepath, params.content)
+    await Bun.write(filepath, params.content);
 
     return {
       title: path.relative(Instance.worktree, filepath),
@@ -27,7 +33,7 @@ export const WriteTool = Tool.define("write", {
         filepath,
         exists: exists,
       },
-      output: "",
-    }
+      output: '',
+    };
   },
-})
+});

package/src/util/binary.ts

@@ -1,41 +1,49 @@
 export namespace Binary {
-  export function search<T>(array: T[], id: string, compare: (item: T) => string): { found: boolean; index: number } {
-    let left = 0
-    let right = array.length - 1
+  export function search<T>(
+    array: T[],
+    id: string,
+    compare: (item: T) => string
+  ): { found: boolean; index: number } {
+    let left = 0;
+    let right = array.length - 1;
 
     while (left <= right) {
-      const mid = Math.floor((left + right) / 2)
-      const midId = compare(array[mid])
+      const mid = Math.floor((left + right) / 2);
+      const midId = compare(array[mid]);
 
       if (midId === id) {
-        return { found: true, index: mid }
+        return { found: true, index: mid };
       } else if (midId < id) {
-        left = mid + 1
+        left = mid + 1;
       } else {
-        right = mid - 1
+        right = mid - 1;
       }
     }
 
-    return { found: false, index: left }
+    return { found: false, index: left };
   }
 
-  export function insert<T>(array: T[], item: T, compare: (item: T) => string): T[] {
-    const id = compare(item)
-    let left = 0
-    let right = array.length
+  export function insert<T>(
+    array: T[],
+    item: T,
+    compare: (item: T) => string
+  ): T[] {
+    const id = compare(item);
+    let left = 0;
+    let right = array.length;
 
     while (left < right) {
-      const mid = Math.floor((left + right) / 2)
-      const midId = compare(array[mid])
+      const mid = Math.floor((left + right) / 2);
+      const midId = compare(array[mid]);
 
       if (midId < id) {
-        left = mid + 1
+        left = mid + 1;
       } else {
-        right = mid
+        right = mid;
       }
     }
 
-    array.splice(left, 0, item)
-    return array
+    array.splice(left, 0, item);
+    return array;
   }
 }

package/src/util/context.ts

@@ -1,25 +1,25 @@
-import { AsyncLocalStorage } from "async_hooks"
+import { AsyncLocalStorage } from 'async_hooks';
 
 export namespace Context {
   export class NotFound extends Error {
     constructor(public override readonly name: string) {
-      super(`No context found for ${name}`)
+      super(`No context found for ${name}`);
     }
   }
 
   export function create<T>(name: string) {
-    const storage = new AsyncLocalStorage<T>()
+    const storage = new AsyncLocalStorage<T>();
     return {
       use() {
-        const result = storage.getStore()
+        const result = storage.getStore();
         if (!result) {
-          throw new NotFound(name)
+          throw new NotFound(name);
         }
-        return result
+        return result;
       },
       provide<R>(value: T, fn: () => R) {
-        return storage.run(value, fn)
+        return storage.run(value, fn);
       },
-    }
+    };
   }
 }

package/src/util/defer.ts

@@ -1,12 +1,14 @@
 export function defer<T extends () => void | Promise<void>>(
-  fn: T,
-): T extends () => Promise<void> ? { [Symbol.asyncDispose]: () => Promise<void> } : { [Symbol.dispose]: () => void } {
+  fn: T
+): T extends () => Promise<void>
+  ? { [Symbol.asyncDispose]: () => Promise<void> }
+  : { [Symbol.dispose]: () => void } {
   return {
     [Symbol.dispose]() {
-      fn()
+      fn();
     },
     [Symbol.asyncDispose]() {
-      return Promise.resolve(fn())
+      return Promise.resolve(fn());
     },
-  } as any
+  } as any;
 }