@link-assistant/agent 0.0.8 → 0.0.11

package/src/config/markdown.ts

@@ -1,41 +1,41 @@
-import { NamedError } from "../util/error"
-import matter from "gray-matter"
-import { z } from "zod"
+import { NamedError } from '../util/error';
+import matter from 'gray-matter';
+import { z } from 'zod';
 
 export namespace ConfigMarkdown {
-  export const FILE_REGEX = /(?<![\w`])@(\.?[^\s`,.]*(?:\.[^\s`,.]+)*)/g
-  export const SHELL_REGEX = /!`([^`]+)`/g
+  export const FILE_REGEX = /(?<![\w`])@(\.?[^\s`,.]*(?:\.[^\s`,.]+)*)/g;
+  export const SHELL_REGEX = /!`([^`]+)`/g;
 
   export function files(template: string) {
-    return Array.from(template.matchAll(FILE_REGEX))
+    return Array.from(template.matchAll(FILE_REGEX));
   }
 
   export function shell(template: string) {
-    return Array.from(template.matchAll(SHELL_REGEX))
+    return Array.from(template.matchAll(SHELL_REGEX));
   }
 
   export async function parse(filePath: string) {
-    const template = await Bun.file(filePath).text()
+    const template = await Bun.file(filePath).text();
 
     try {
-      const md = matter(template)
-      return md
+      const md = matter(template);
+      return md;
     } catch (err) {
       throw new FrontmatterError(
         {
           path: filePath,
           message: `Failed to parse YAML frontmatter: ${err instanceof Error ? err.message : String(err)}`,
         },
-        { cause: err },
-      )
+        { cause: err }
+      );
     }
   }
 
   export const FrontmatterError = NamedError.create(
-    "ConfigFrontmatterError",
+    'ConfigFrontmatterError',
     z.object({
       path: z.string(),
       message: z.string(),
-    }),
-  )
+    })
+  );
 }

package/src/file/ripgrep.ts

@@ -1,17 +1,17 @@
 // Ripgrep utility functions
-import path from "path"
-import { Global } from "../global"
-import fs from "fs/promises"
-import z from "zod"
-import { NamedError } from "../util/error"
-import { lazy } from "../util/lazy"
-import { $ } from "bun"
+import path from 'path';
+import { Global } from '../global';
+import fs from 'fs/promises';
+import z from 'zod';
+import { NamedError } from '../util/error';
+import { lazy } from '../util/lazy';
+import { $ } from 'bun';
 
-import { ZipReader, BlobReader, BlobWriter } from "@zip.js/zip.js"
-import { Log } from "../util/log"
+import { ZipReader, BlobReader, BlobWriter } from '@zip.js/zip.js';
+import { Log } from '../util/log';
 
 export namespace Ripgrep {
-  const log = Log.create({ service: "ripgrep" })
+  const log = Log.create({ service: 'ripgrep' });
   const Stats = z.object({
     elapsed: z.object({
       secs: z.number(),
@@ -24,19 +24,19 @@ export namespace Ripgrep {
     bytes_printed: z.number(),
     matched_lines: z.number(),
     matches: z.number(),
-  })
+  });
 
   const Begin = z.object({
-    type: z.literal("begin"),
+    type: z.literal('begin'),
     data: z.object({
       path: z.object({
         text: z.string(),
       }),
     }),
-  })
+  });
 
   export const Match = z.object({
-    type: z.literal("match"),
+    type: z.literal('match'),
     data: z.object({
       path: z.object({
         text: z.string(),
@@ -53,13 +53,13 @@ export namespace Ripgrep {
           }),
           start: z.number(),
           end: z.number(),
-        }),
+        })
       ),
     }),
-  })
+  });
 
   const End = z.object({
-    type: z.literal("end"),
+    type: z.literal('end'),
     data: z.object({
       path: z.object({
         text: z.string(),
@@ -67,10 +67,10 @@ export namespace Ripgrep {
       binary_offset: z.number().nullable(),
       stats: Stats,
     }),
-  })
+  });
 
   const Summary = z.object({
-    type: z.literal("summary"),
+    type: z.literal('summary'),
     data: z.object({
       elapsed_total: z.object({
         human: z.string(),
@@ -79,313 +79,345 @@ export namespace Ripgrep {
       }),
       stats: Stats,
     }),
-  })
+  });
 
-  const Result = z.union([Begin, Match, End, Summary])
+  const Result = z.union([Begin, Match, End, Summary]);
 
-  export type Result = z.infer<typeof Result>
-  export type Match = z.infer<typeof Match>
-  export type Begin = z.infer<typeof Begin>
-  export type End = z.infer<typeof End>
-  export type Summary = z.infer<typeof Summary>
+  export type Result = z.infer<typeof Result>;
+  export type Match = z.infer<typeof Match>;
+  export type Begin = z.infer<typeof Begin>;
+  export type End = z.infer<typeof End>;
+  export type Summary = z.infer<typeof Summary>;
   const PLATFORM = {
-    "arm64-darwin": { platform: "aarch64-apple-darwin", extension: "tar.gz" },
-    "arm64-linux": {
-      platform: "aarch64-unknown-linux-gnu",
-      extension: "tar.gz",
+    'arm64-darwin': { platform: 'aarch64-apple-darwin', extension: 'tar.gz' },
+    'arm64-linux': {
+      platform: 'aarch64-unknown-linux-gnu',
+      extension: 'tar.gz',
     },
-    "x64-darwin": { platform: "x86_64-apple-darwin", extension: "tar.gz" },
-    "x64-linux": { platform: "x86_64-unknown-linux-musl", extension: "tar.gz" },
-    "x64-win32": { platform: "x86_64-pc-windows-msvc", extension: "zip" },
-  } as const
+    'x64-darwin': { platform: 'x86_64-apple-darwin', extension: 'tar.gz' },
+    'x64-linux': { platform: 'x86_64-unknown-linux-musl', extension: 'tar.gz' },
+    'x64-win32': { platform: 'x86_64-pc-windows-msvc', extension: 'zip' },
+  } as const;
 
   export const ExtractionFailedError = NamedError.create(
-    "RipgrepExtractionFailedError",
+    'RipgrepExtractionFailedError',
     z.object({
       filepath: z.string(),
       stderr: z.string(),
-    }),
-  )
+    })
+  );
 
   export const UnsupportedPlatformError = NamedError.create(
-    "RipgrepUnsupportedPlatformError",
+    'RipgrepUnsupportedPlatformError',
     z.object({
       platform: z.string(),
-    }),
-  )
+    })
+  );
 
   export const DownloadFailedError = NamedError.create(
-    "RipgrepDownloadFailedError",
+    'RipgrepDownloadFailedError',
     z.object({
       url: z.string(),
       status: z.number(),
-    }),
-  )
+    })
+  );
 
   const state = lazy(async () => {
-    let filepath = Bun.which("rg")
-    if (filepath) return { filepath }
-    filepath = path.join(Global.Path.bin, "rg" + (process.platform === "win32" ? ".exe" : ""))
-
-    const file = Bun.file(filepath)
+    let filepath = Bun.which('rg');
+    if (filepath) return { filepath };
+    filepath = path.join(
+      Global.Path.bin,
+      'rg' + (process.platform === 'win32' ? '.exe' : '')
+    );
+
+    const file = Bun.file(filepath);
     if (!(await file.exists())) {
-      const platformKey = `${process.arch}-${process.platform}` as keyof typeof PLATFORM
-      const config = PLATFORM[platformKey]
-      if (!config) throw new UnsupportedPlatformError({ platform: platformKey })
+      const platformKey =
+        `${process.arch}-${process.platform}` as keyof typeof PLATFORM;
+      const config = PLATFORM[platformKey];
+      if (!config)
+        throw new UnsupportedPlatformError({ platform: platformKey });
 
-      const version = "14.1.1"
-      const filename = `ripgrep-${version}-${config.platform}.${config.extension}`
-      const url = `https://github.com/BurntSushi/ripgrep/releases/download/${version}/${filename}`
+      const version = '14.1.1';
+      const filename = `ripgrep-${version}-${config.platform}.${config.extension}`;
+      const url = `https://github.com/BurntSushi/ripgrep/releases/download/${version}/${filename}`;
 
-      const response = await fetch(url)
-      if (!response.ok) throw new DownloadFailedError({ url, status: response.status })
+      const response = await fetch(url);
+      if (!response.ok)
+        throw new DownloadFailedError({ url, status: response.status });
 
-      const buffer = await response.arrayBuffer()
-      const archivePath = path.join(Global.Path.bin, filename)
-      await Bun.write(archivePath, buffer)
-      if (config.extension === "tar.gz") {
-        const args = ["tar", "-xzf", archivePath, "--strip-components=1"]
+      const buffer = await response.arrayBuffer();
+      const archivePath = path.join(Global.Path.bin, filename);
+      await Bun.write(archivePath, buffer);
+      if (config.extension === 'tar.gz') {
+        const args = ['tar', '-xzf', archivePath, '--strip-components=1'];
 
-        if (platformKey.endsWith("-darwin")) args.push("--include=*/rg")
-        if (platformKey.endsWith("-linux")) args.push("--wildcards", "*/rg")
+        if (platformKey.endsWith('-darwin')) args.push('--include=*/rg');
+        if (platformKey.endsWith('-linux')) args.push('--wildcards', '*/rg');
 
         const proc = Bun.spawn(args, {
           cwd: Global.Path.bin,
-          stderr: "pipe",
-          stdout: "pipe",
-        })
-        await proc.exited
+          stderr: 'pipe',
+          stdout: 'pipe',
+        });
+        await proc.exited;
         if (proc.exitCode !== 0)
           throw new ExtractionFailedError({
             filepath,
             stderr: await Bun.readableStreamToText(proc.stderr),
-          })
+          });
       }
-      if (config.extension === "zip") {
-        if (config.extension === "zip") {
-          const zipFileReader = new ZipReader(new BlobReader(new Blob([await Bun.file(archivePath).arrayBuffer()])))
-          const entries = await zipFileReader.getEntries()
-          let rgEntry: any
+      if (config.extension === 'zip') {
+        if (config.extension === 'zip') {
+          const zipFileReader = new ZipReader(
+            new BlobReader(
+              new Blob([await Bun.file(archivePath).arrayBuffer()])
+            )
+          );
+          const entries = await zipFileReader.getEntries();
+          let rgEntry: any;
           for (const entry of entries) {
-            if (entry.filename.endsWith("rg.exe")) {
-              rgEntry = entry
-              break
+            if (entry.filename.endsWith('rg.exe')) {
+              rgEntry = entry;
+              break;
             }
           }
 
           if (!rgEntry) {
             throw new ExtractionFailedError({
               filepath: archivePath,
-              stderr: "rg.exe not found in zip archive",
-            })
+              stderr: 'rg.exe not found in zip archive',
+            });
           }
 
-          const rgBlob = await rgEntry.getData(new BlobWriter())
+          const rgBlob = await rgEntry.getData(new BlobWriter());
           if (!rgBlob) {
             throw new ExtractionFailedError({
               filepath: archivePath,
-              stderr: "Failed to extract rg.exe from zip archive",
-            })
+              stderr: 'Failed to extract rg.exe from zip archive',
+            });
           }
-          await Bun.write(filepath, await rgBlob.arrayBuffer())
-          await zipFileReader.close()
+          await Bun.write(filepath, await rgBlob.arrayBuffer());
+          await zipFileReader.close();
         }
       }
-      await fs.unlink(archivePath)
-      if (!platformKey.endsWith("-win32")) await fs.chmod(filepath, 0o755)
+      await fs.unlink(archivePath);
+      if (!platformKey.endsWith('-win32')) await fs.chmod(filepath, 0o755);
     }
 
     return {
       filepath,
-    }
-  })
+    };
+  });
 
   export async function filepath() {
-    const { filepath } = await state()
-    return filepath
+    const { filepath } = await state();
+    return filepath;
   }
 
   export async function* files(input: { cwd: string; glob?: string[] }) {
-    const args = [await filepath(), "--files", "--follow", "--hidden", "--glob=!.git/*"]
+    const args = [
+      await filepath(),
+      '--files',
+      '--follow',
+      '--hidden',
+      '--glob=!.git/*',
+    ];
     if (input.glob) {
       for (const g of input.glob) {
-        args.push(`--glob=${g}`)
+        args.push(`--glob=${g}`);
       }
     }
 
     // Bun.spawn should throw this, but it incorrectly reports that the executable does not exist.
     // See https://github.com/oven-sh/bun/issues/24012
     if (!(await fs.stat(input.cwd).catch(() => undefined))?.isDirectory()) {
-      throw Object.assign(new Error(`No such file or directory: '${input.cwd}'`), {
-        code: "ENOENT",
-        errno: -2,
-        path: input.cwd,
-      })
+      throw Object.assign(
+        new Error(`No such file or directory: '${input.cwd}'`),
+        {
+          code: 'ENOENT',
+          errno: -2,
+          path: input.cwd,
+        }
+      );
     }
 
     const proc = Bun.spawn(args, {
       cwd: input.cwd,
-      stdout: "pipe",
-      stderr: "ignore",
+      stdout: 'pipe',
+      stderr: 'ignore',
       maxBuffer: 1024 * 1024 * 20,
-    })
+    });
 
-    const reader = proc.stdout.getReader()
-    const decoder = new TextDecoder()
-    let buffer = ""
+    const reader = proc.stdout.getReader();
+    const decoder = new TextDecoder();
+    let buffer = '';
 
     try {
       while (true) {
-        const { done, value } = await reader.read()
-        if (done) break
+        const { done, value } = await reader.read();
+        if (done) break;
 
-        buffer += decoder.decode(value, { stream: true })
-        const lines = buffer.split("\n")
-        buffer = lines.pop() || ""
+        buffer += decoder.decode(value, { stream: true });
+        const lines = buffer.split('\n');
+        buffer = lines.pop() || '';
 
         for (const line of lines) {
-          if (line) yield line
+          if (line) yield line;
         }
       }
 
-      if (buffer) yield buffer
+      if (buffer) yield buffer;
     } finally {
-      reader.releaseLock()
-      await proc.exited
+      reader.releaseLock();
+      await proc.exited;
     }
   }
 
   export async function tree(input: { cwd: string; limit?: number }) {
-    log.info("tree", input)
-    const files = await Array.fromAsync(Ripgrep.files({ cwd: input.cwd }))
+    log.info('tree', input);
+    const files = await Array.fromAsync(Ripgrep.files({ cwd: input.cwd }));
     interface Node {
-      path: string[]
-      children: Node[]
+      path: string[];
+      children: Node[];
     }
 
     function getPath(node: Node, parts: string[], create: boolean) {
-      if (parts.length === 0) return node
-      let current = node
+      if (parts.length === 0) return node;
+      let current = node;
       for (const part of parts) {
-        let existing = current.children.find((x) => x.path.at(-1) === part)
+        let existing = current.children.find((x) => x.path.at(-1) === part);
         if (!existing) {
-          if (!create) return
+          if (!create) return;
           existing = {
             path: current.path.concat(part),
             children: [],
-          }
-          current.children.push(existing)
+          };
+          current.children.push(existing);
         }
-        current = existing
+        current = existing;
       }
-      return current
+      return current;
     }
 
     const root: Node = {
       path: [],
       children: [],
-    }
+    };
     for (const file of files) {
-      if (file.includes(".opencode")) continue
-      const parts = file.split(path.sep)
-      getPath(root, parts, true)
+      if (file.includes('.opencode')) continue;
+      const parts = file.split(path.sep);
+      getPath(root, parts, true);
     }
 
     function sort(node: Node) {
       node.children.sort((a, b) => {
-        if (!a.children.length && b.children.length) return 1
-        if (!b.children.length && a.children.length) return -1
-        return a.path.at(-1)!.localeCompare(b.path.at(-1)!)
-      })
+        if (!a.children.length && b.children.length) return 1;
+        if (!b.children.length && a.children.length) return -1;
+        return a.path.at(-1)!.localeCompare(b.path.at(-1)!);
+      });
       for (const child of node.children) {
-        sort(child)
+        sort(child);
       }
     }
-    sort(root)
+    sort(root);
 
-    let current = [root]
+    let current = [root];
     const result: Node = {
       path: [],
       children: [],
-    }
+    };
 
-    let processed = 0
-    const limit = input.limit ?? 50
+    let processed = 0;
+    const limit = input.limit ?? 50;
     while (current.length > 0) {
-      const next = []
+      const next = [];
       for (const node of current) {
-        if (node.children.length) next.push(...node.children)
+        if (node.children.length) next.push(...node.children);
       }
-      const max = Math.max(...current.map((x) => x.children.length))
+      const max = Math.max(...current.map((x) => x.children.length));
       for (let i = 0; i < max && processed < limit; i++) {
         for (const node of current) {
-          const child = node.children[i]
-          if (!child) continue
-          getPath(result, child.path, true)
-          processed++
-          if (processed >= limit) break
+          const child = node.children[i];
+          if (!child) continue;
+          getPath(result, child.path, true);
+          processed++;
+          if (processed >= limit) break;
         }
       }
       if (processed >= limit) {
         for (const node of [...current, ...next]) {
-          const compare = getPath(result, node.path, false)
-          if (!compare) continue
+          const compare = getPath(result, node.path, false);
+          if (!compare) continue;
           if (compare?.children.length !== node.children.length) {
-            const diff = node.children.length - compare.children.length
+            const diff = node.children.length - compare.children.length;
             compare.children.push({
               path: compare.path.concat(`[${diff} truncated]`),
               children: [],
-            })
+            });
           }
         }
-        break
+        break;
       }
-      current = next
+      current = next;
     }
 
-    const lines: string[] = []
+    const lines: string[] = [];
 
     function render(node: Node, depth: number) {
-      const indent = "\t".repeat(depth)
-      lines.push(indent + node.path.at(-1) + (node.children.length ? "/" : ""))
+      const indent = '\t'.repeat(depth);
+      lines.push(indent + node.path.at(-1) + (node.children.length ? '/' : ''));
       for (const child of node.children) {
-        render(child, depth + 1)
+        render(child, depth + 1);
       }
     }
-    result.children.map((x) => render(x, 0))
+    result.children.map((x) => render(x, 0));
 
-    return lines.join("\n")
+    return lines.join('\n');
   }
 
-  export async function search(input: { cwd: string; pattern: string; glob?: string[]; limit?: number }) {
-    const args = [`${await filepath()}`, "--json", "--hidden", "--glob='!.git/*'"]
+  export async function search(input: {
+    cwd: string;
+    pattern: string;
+    glob?: string[];
+    limit?: number;
+  }) {
+    const args = [
+      `${await filepath()}`,
+      '--json',
+      '--hidden',
+      "--glob='!.git/*'",
+    ];
 
     if (input.glob) {
       for (const g of input.glob) {
-        args.push(`--glob=${g}`)
+        args.push(`--glob=${g}`);
       }
     }
 
     if (input.limit) {
-      args.push(`--max-count=${input.limit}`)
+      args.push(`--max-count=${input.limit}`);
     }
 
-    args.push("--")
-    args.push(input.pattern)
+    args.push('--');
+    args.push(input.pattern);
 
-    const command = args.join(" ")
-    const result = await $`${{ raw: command }}`.cwd(input.cwd).quiet().nothrow()
+    const command = args.join(' ');
+    const result = await $`${{ raw: command }}`
+      .cwd(input.cwd)
+      .quiet()
+      .nothrow();
     if (result.exitCode !== 0) {
-      return []
+      return [];
     }
 
-    const lines = result.text().trim().split("\n").filter(Boolean)
+    const lines = result.text().trim().split('\n').filter(Boolean);
     // Parse JSON lines from ripgrep output
 
     return lines
       .map((line) => JSON.parse(line))
       .map((parsed) => Result.parse(parsed))
-      .filter((r) => r.type === "match")
-      .map((r) => r.data)
+      .filter((r) => r.type === 'match')
+      .map((r) => r.data);
   }
 }