@link-assistant/agent 0.0.8 → 0.0.11

package/src/util/log.ts

@@ -1,105 +1,111 @@
-import path from "path"
-import fs from "fs/promises"
-import { Global } from "../global"
-import z from "zod"
+import path from 'path';
+import fs from 'fs/promises';
+import { Global } from '../global';
+import z from 'zod';
 
 export namespace Log {
-  export const Level = z.enum(["DEBUG", "INFO", "WARN", "ERROR"]).meta({ ref: "LogLevel", description: "Log level" })
-  export type Level = z.infer<typeof Level>
+  export const Level = z
+    .enum(['DEBUG', 'INFO', 'WARN', 'ERROR'])
+    .meta({ ref: 'LogLevel', description: 'Log level' });
+  export type Level = z.infer<typeof Level>;
 
   const levelPriority: Record<Level, number> = {
     DEBUG: 0,
     INFO: 1,
     WARN: 2,
     ERROR: 3,
-  }
+  };
 
-  let level: Level = "INFO"
+  let level: Level = 'INFO';
 
   function shouldLog(input: Level): boolean {
-    return levelPriority[input] >= levelPriority[level]
+    return levelPriority[input] >= levelPriority[level];
   }
 
   export type Logger = {
-    debug(message?: any, extra?: Record<string, any>): void
-    info(message?: any, extra?: Record<string, any>): void
-    error(message?: any, extra?: Record<string, any>): void
-    warn(message?: any, extra?: Record<string, any>): void
-    tag(key: string, value: string): Logger
-    clone(): Logger
+    debug(message?: any, extra?: Record<string, any>): void;
+    info(message?: any, extra?: Record<string, any>): void;
+    error(message?: any, extra?: Record<string, any>): void;
+    warn(message?: any, extra?: Record<string, any>): void;
+    tag(key: string, value: string): Logger;
+    clone(): Logger;
     time(
       message: string,
-      extra?: Record<string, any>,
+      extra?: Record<string, any>
     ): {
-      stop(): void
-      [Symbol.dispose](): void
-    }
-  }
+      stop(): void;
+      [Symbol.dispose](): void;
+    };
+  };
 
-  const loggers = new Map<string, Logger>()
+  const loggers = new Map<string, Logger>();
 
-  export const Default = create({ service: "default" })
+  export const Default = create({ service: 'default' });
 
   export interface Options {
-    print: boolean
-    dev?: boolean
-    level?: Level
+    print: boolean;
+    dev?: boolean;
+    level?: Level;
   }
 
-  let logpath = ""
+  let logpath = '';
   export function file() {
-    return logpath
+    return logpath;
   }
-  let write = (msg: any) => Bun.stderr.write(msg)
+  let write = (msg: any) => Bun.stderr.write(msg);
 
   export async function init(options: Options) {
-    if (options.level) level = options.level
-    cleanup(Global.Path.log)
-    if (options.print) return
+    if (options.level) level = options.level;
+    cleanup(Global.Path.log);
+    if (options.print) return;
     logpath = path.join(
       Global.Path.log,
-      options.dev ? "dev.log" : new Date().toISOString().split(".")[0].replace(/:/g, "") + ".log",
-    )
-    const logfile = Bun.file(logpath)
-    await fs.truncate(logpath).catch(() => {})
-    const writer = logfile.writer()
+      options.dev
+        ? 'dev.log'
+        : new Date().toISOString().split('.')[0].replace(/:/g, '') + '.log'
+    );
+    const logfile = Bun.file(logpath);
+    await fs.truncate(logpath).catch(() => {});
+    const writer = logfile.writer();
     write = async (msg: any) => {
-      const num = writer.write(msg)
-      writer.flush()
-      return num
-    }
+      const num = writer.write(msg);
+      writer.flush();
+      return num;
+    };
   }
 
   async function cleanup(dir: string) {
-    const glob = new Bun.Glob("????-??-??T??????.log")
+    const glob = new Bun.Glob('????-??-??T??????.log');
     const files = await Array.fromAsync(
       glob.scan({
         cwd: dir,
         absolute: true,
-      }),
-    )
-    if (files.length <= 5) return
+      })
+    );
+    if (files.length <= 5) return;
 
-    const filesToDelete = files.slice(0, -10)
-    await Promise.all(filesToDelete.map((file) => fs.unlink(file).catch(() => {})))
+    const filesToDelete = files.slice(0, -10);
+    await Promise.all(
+      filesToDelete.map((file) => fs.unlink(file).catch(() => {}))
+    );
   }
 
   function formatError(error: Error, depth = 0): string {
-    const result = error.message
+    const result = error.message;
     return error.cause instanceof Error && depth < 10
-      ? result + " Caused by: " + formatError(error.cause, depth + 1)
-      : result
+      ? result + ' Caused by: ' + formatError(error.cause, depth + 1)
+      : result;
   }
 
-  let last = Date.now()
+  let last = Date.now();
   export function create(tags?: Record<string, any>) {
-    tags = tags || {}
+    tags = tags || {};
 
-    const service = tags["service"]
-    if (service && typeof service === "string") {
-      const cached = loggers.get(service)
+    const service = tags['service'];
+    if (service && typeof service === 'string') {
+      const cached = loggers.get(service);
       if (cached) {
-        return cached
+        return cached;
       }
     }
 
@@ -110,68 +116,72 @@ export namespace Log {
       })
         .filter(([_, value]) => value !== undefined && value !== null)
         .map(([key, value]) => {
-          const prefix = `${key}=`
-          if (value instanceof Error) return prefix + formatError(value)
-          if (typeof value === "object") return prefix + JSON.stringify(value)
-          return prefix + value
+          const prefix = `${key}=`;
+          if (value instanceof Error) return prefix + formatError(value);
+          if (typeof value === 'object') return prefix + JSON.stringify(value);
+          return prefix + value;
         })
-        .join(" ")
-      const next = new Date()
-      const diff = next.getTime() - last
-      last = next.getTime()
-      return [next.toISOString().split(".")[0], "+" + diff + "ms", prefix, message].filter(Boolean).join(" ") + "\n"
+        .join(' ');
+      const next = new Date();
+      const diff = next.getTime() - last;
+      last = next.getTime();
+      return (
+        [next.toISOString().split('.')[0], '+' + diff + 'ms', prefix, message]
+          .filter(Boolean)
+          .join(' ') + '\n'
+      );
     }
     const result: Logger = {
       debug(message?: any, extra?: Record<string, any>) {
-        if (shouldLog("DEBUG")) {
-          write("DEBUG " + build(message, extra))
+        if (shouldLog('DEBUG')) {
+          write('DEBUG ' + build(message, extra));
         }
       },
       info(message?: any, extra?: Record<string, any>) {
-        if (shouldLog("INFO")) {
-          write("INFO  " + build(message, extra))
+        if (shouldLog('INFO')) {
+          write('INFO  ' + build(message, extra));
         }
       },
       error(message?: any, extra?: Record<string, any>) {
-        if (shouldLog("ERROR")) {
-          write("ERROR " + build(message, extra))
+        if (shouldLog('ERROR')) {
+          write('ERROR ' + build(message, extra));
         }
       },
       warn(message?: any, extra?: Record<string, any>) {
-        if (shouldLog("WARN")) {
-          write("WARN  " + build(message, extra))
+        if (shouldLog('WARN')) {
+          write('WARN  ' + build(message, extra));
         }
       },
       tag(key: string, value: string) {
-        if (tags) tags[key] = value
-        return result
+        if (tags) tags[key] = value;
+        return result;
       },
       clone() {
-        return Log.create({ ...tags })
+        return Log.create({ ...tags });
       },
       time(message: string, extra?: Record<string, any>) {
-        const now = Date.now()
-        result.info(message, { status: "started", ...extra })
+        const now = Date.now();
+        result.info(message, { status: 'started', ...extra });
         function stop() {
           result.info(message, {
-            status: "completed",
+            status: 'completed',
             duration: Date.now() - now,
             ...extra,
-          })
+          });
         }
         return {
           stop,
           [Symbol.dispose]() {
-            stop()
+            stop();
           },
-        }
+        };
       },
-    }
+    };
 
-    if (service && typeof service === "string") {
-      loggers.set(service, result)
+    if (service && typeof service === 'string') {
+      loggers.set(service, result);
     }
 
-    return result
+    return result;
   }
 }

package/src/util/queue.ts

@@ -1,19 +1,19 @@
 export class AsyncQueue<T> implements AsyncIterable<T> {
-  private queue: T[] = []
-  private resolvers: ((value: T) => void)[] = []
+  private queue: T[] = [];
+  private resolvers: ((value: T) => void)[] = [];
 
   push(item: T) {
-    const resolve = this.resolvers.shift()
-    if (resolve) resolve(item)
-    else this.queue.push(item)
+    const resolve = this.resolvers.shift();
+    if (resolve) resolve(item);
+    else this.queue.push(item);
   }
 
   async next(): Promise<T> {
-    if (this.queue.length > 0) return this.queue.shift()!
-    return new Promise((resolve) => this.resolvers.push(resolve))
+    if (this.queue.length > 0) return this.queue.shift()!;
+    return new Promise((resolve) => this.resolvers.push(resolve));
   }
 
   async *[Symbol.asyncIterator]() {
-    while (true) yield await this.next()
+    while (true) yield await this.next();
   }
 }

package/src/util/rpc.ts

@@ -1,42 +1,54 @@
 export namespace Rpc {
   type Definition = {
-    [method: string]: (input: any) => any
-  }
+    [method: string]: (input: any) => any;
+  };
 
   export function listen(rpc: Definition) {
     onmessage = async (evt) => {
-      const parsed = JSON.parse(evt.data)
-      if (parsed.type === "rpc.request") {
-        const result = await rpc[parsed.method](parsed.input)
-        postMessage(JSON.stringify({ type: "rpc.result", result, id: parsed.id }))
+      const parsed = JSON.parse(evt.data);
+      if (parsed.type === 'rpc.request') {
+        const result = await rpc[parsed.method](parsed.input);
+        postMessage(
+          JSON.stringify({ type: 'rpc.result', result, id: parsed.id })
+        );
       }
-    }
+    };
   }
 
   export function client<T extends Definition>(target: {
-    postMessage: (data: string) => void | null
-    onmessage: ((this: Worker, ev: MessageEvent<any>) => any) | null
+    postMessage: (data: string) => void | null;
+    onmessage: ((this: Worker, ev: MessageEvent<any>) => any) | null;
   }) {
-    const pending = new Map<number, (result: any) => void>()
-    let id = 0
+    const pending = new Map<number, (result: any) => void>();
+    let id = 0;
     target.onmessage = async (evt) => {
-      const parsed = JSON.parse(evt.data)
-      if (parsed.type === "rpc.result") {
-        const resolve = pending.get(parsed.id)
+      const parsed = JSON.parse(evt.data);
+      if (parsed.type === 'rpc.result') {
+        const resolve = pending.get(parsed.id);
         if (resolve) {
-          resolve(parsed.result)
-          pending.delete(parsed.id)
+          resolve(parsed.result);
+          pending.delete(parsed.id);
         }
       }
-    }
+    };
     return {
-      call<Method extends keyof T>(method: Method, input: Parameters<T[Method]>[0]): Promise<ReturnType<T[Method]>> {
-        const requestId = id++
+      call<Method extends keyof T>(
+        method: Method,
+        input: Parameters<T[Method]>[0]
+      ): Promise<ReturnType<T[Method]>> {
+        const requestId = id++;
         return new Promise((resolve) => {
-          pending.set(requestId, resolve)
-          target.postMessage(JSON.stringify({ type: "rpc.request", method, input, id: requestId }))
-        })
+          pending.set(requestId, resolve);
+          target.postMessage(
+            JSON.stringify({
+              type: 'rpc.request',
+              method,
+              input,
+              id: requestId,
+            })
+          );
+        });
       },
-    }
+    };
   }
 }

package/src/util/scrap.ts

@@ -1,10 +1,10 @@
-export const foo: string = "42"
-export const bar: number = 123
+export const foo: string = '42';
+export const bar: number = 123;
 
 export function dummyFunction(): void {
-  console.log("This is a dummy function")
+  console.log('This is a dummy function');
 }
 
 export function randomHelper(): boolean {
-  return Math.random() > 0.5
+  return Math.random() > 0.5;
 }

package/src/util/signal.ts

@@ -1,12 +1,12 @@
 export function signal() {
-  let resolve: any
-  const promise = new Promise((r) => (resolve = r))
+  let resolve: any;
+  const promise = new Promise((r) => (resolve = r));
   return {
     trigger() {
-      return resolve()
+      return resolve();
     },
     wait() {
-      return promise
+      return promise;
     },
-  }
+  };
 }

package/src/util/timeout.ts

@@ -1,14 +1,14 @@
 export function withTimeout<T>(promise: Promise<T>, ms: number): Promise<T> {
-  let timeout: NodeJS.Timeout
+  let timeout: NodeJS.Timeout;
   return Promise.race([
     promise.then((result) => {
-      clearTimeout(timeout)
-      return result
+      clearTimeout(timeout);
+      return result;
     }),
     new Promise<never>((_, reject) => {
       timeout = setTimeout(() => {
-        reject(new Error(`Operation timed out after ${ms}ms`))
-      }, ms)
+        reject(new Error(`Operation timed out after ${ms}ms`));
+      }, ms);
     }),
-  ])
+  ]);
 }

package/src/util/token.ts

@@ -1,7 +1,7 @@
 export namespace Token {
-  const CHARS_PER_TOKEN = 4
+  const CHARS_PER_TOKEN = 4;
 
   export function estimate(input: string) {
-    return Math.max(0, Math.round((input || "").length / CHARS_PER_TOKEN))
+    return Math.max(0, Math.round((input || '').length / CHARS_PER_TOKEN));
   }
 }

package/src/util/wildcard.ts

@@ -1,54 +1,65 @@
-import { sortBy, pipe } from "remeda"
+import { sortBy, pipe } from 'remeda';
 
 export namespace Wildcard {
   export function match(str: string, pattern: string) {
     const regex = new RegExp(
-      "^" +
+      '^' +
         pattern
-          .replace(/[.+^${}()|[\]\\]/g, "\\$&") // escape special regex chars
-          .replace(/\*/g, ".*") // * becomes .*
-          .replace(/\?/g, ".") + // ? becomes .
-        "$",
-      "s", // s flag enables multiline matching
-    )
-    return regex.test(str)
+          .replace(/[.+^${}()|[\]\\]/g, '\\$&') // escape special regex chars
+          .replace(/\*/g, '.*') // * becomes .*
+          .replace(/\?/g, '.') + // ? becomes .
+        '$',
+      's' // s flag enables multiline matching
+    );
+    return regex.test(str);
   }
 
   export function all(input: string, patterns: Record<string, any>) {
-    const sorted = pipe(patterns, Object.entries, sortBy([([key]) => key.length, "asc"], [([key]) => key, "asc"]))
-    let result = undefined
+    const sorted = pipe(
+      patterns,
+      Object.entries,
+      sortBy([([key]) => key.length, 'asc'], [([key]) => key, 'asc'])
+    );
+    let result = undefined;
     for (const [pattern, value] of sorted) {
       if (match(input, pattern)) {
-        result = value
-        continue
+        result = value;
+        continue;
       }
     }
-    return result
+    return result;
   }
 
-  export function allStructured(input: { head: string; tail: string[] }, patterns: Record<string, any>) {
-    const sorted = pipe(patterns, Object.entries, sortBy([([key]) => key.length, "asc"], [([key]) => key, "asc"]))
-    let result = undefined
+  export function allStructured(
+    input: { head: string; tail: string[] },
+    patterns: Record<string, any>
+  ) {
+    const sorted = pipe(
+      patterns,
+      Object.entries,
+      sortBy([([key]) => key.length, 'asc'], [([key]) => key, 'asc'])
+    );
+    let result = undefined;
     for (const [pattern, value] of sorted) {
-      const parts = pattern.split(/\s+/)
-      if (!match(input.head, parts[0])) continue
+      const parts = pattern.split(/\s+/);
+      if (!match(input.head, parts[0])) continue;
       if (parts.length === 1 || matchSequence(input.tail, parts.slice(1))) {
-        result = value
-        continue
+        result = value;
+        continue;
       }
     }
-    return result
+    return result;
   }
 
   function matchSequence(items: string[], patterns: string[]): boolean {
-    if (patterns.length === 0) return true
-    const [pattern, ...rest] = patterns
-    if (pattern === "*") return matchSequence(items, rest)
+    if (patterns.length === 0) return true;
+    const [pattern, ...rest] = patterns;
+    if (pattern === '*') return matchSequence(items, rest);
     for (let i = 0; i < items.length; i++) {
       if (match(items[i], pattern) && matchSequence(items.slice(i + 1), rest)) {
-        return true
+        return true;
       }
     }
-    return false
+    return false;
   }
 }