@link-assistant/agent 0.0.8 → 0.0.11

package/src/util/error.ts

@@ -1,10 +1,13 @@
-import z from "zod"
+import z from 'zod';
 
 export abstract class NamedError extends Error {
-  abstract schema(): z.core.$ZodType
-  abstract toObject(): { name: string; data: any }
+  abstract schema(): z.core.$ZodType;
+  abstract toObject(): { name: string; data: any };
 
-  static create<Name extends string, Data extends z.core.$ZodType>(name: Name, data: Data) {
+  static create<Name extends string, Data extends z.core.$ZodType>(
+    name: Name,
+    data: Data
+  ) {
     const schema = z
       .object({
         name: z.literal(name),
@@ -12,43 +15,45 @@ export abstract class NamedError extends Error {
       })
       .meta({
         ref: name,
-      })
+      });
     const result = class extends NamedError {
-      public static readonly Schema = schema
+      public static readonly Schema = schema;
 
-      public override readonly name = name as Name
+      public override readonly name = name as Name;
 
       constructor(
         public readonly data: z.input<Data>,
-        options?: ErrorOptions,
+        options?: ErrorOptions
       ) {
-        super(name, options)
-        this.name = name
+        super(name, options);
+        this.name = name;
       }
 
       static isInstance(input: any): input is InstanceType<typeof result> {
-        return typeof input === "object" && "name" in input && input.name === name
+        return (
+          typeof input === 'object' && 'name' in input && input.name === name
+        );
       }
 
       schema() {
-        return schema
+        return schema;
       }
 
       toObject() {
         return {
           name: name,
           data: this.data,
-        }
+        };
       }
-    }
-    Object.defineProperty(result, "name", { value: name })
-    return result
+    };
+    Object.defineProperty(result, 'name', { value: name });
+    return result;
   }
 
   public static readonly Unknown = NamedError.create(
-    "UnknownError",
+    'UnknownError',
     z.object({
       message: z.string(),
-    }),
-  )
+    })
+  );
 }

package/src/util/eventloop.ts

@@ -1,20 +1,26 @@
-import { Log } from "./log"
+import { Log } from './log';
 
 export namespace EventLoop {
   export async function wait() {
     return new Promise<void>((resolve) => {
       const check = () => {
-        const active = [...(process as any)._getActiveHandles(), ...(process as any)._getActiveRequests()]
-        Log.Default.info("eventloop", {
+        const active = [
+          ...(process as any)._getActiveHandles(),
+          ...(process as any)._getActiveRequests(),
+        ];
+        Log.Default.info('eventloop', {
           active,
-        })
-        if ((process as any)._getActiveHandles().length === 0 && (process as any)._getActiveRequests().length === 0) {
-          resolve()
+        });
+        if (
+          (process as any)._getActiveHandles().length === 0 &&
+          (process as any)._getActiveRequests().length === 0
+        ) {
+          resolve();
         } else {
-          setImmediate(check)
+          setImmediate(check);
         }
-      }
-      check()
-    })
+      };
+      check();
+    });
   }
 }

package/src/util/filesystem.ts

@@ -1,52 +1,56 @@
-import { exists } from "fs/promises"
-import { dirname, join, relative } from "path"
+import { exists } from 'fs/promises';
+import { dirname, join, relative } from 'path';
 
 export namespace Filesystem {
   export function overlaps(a: string, b: string) {
-    const relA = relative(a, b)
-    const relB = relative(b, a)
-    return !relA || !relA.startsWith("..") || !relB || !relB.startsWith("..")
+    const relA = relative(a, b);
+    const relB = relative(b, a);
+    return !relA || !relA.startsWith('..') || !relB || !relB.startsWith('..');
   }
 
   export function contains(parent: string, child: string) {
-    return !relative(parent, child).startsWith("..")
+    return !relative(parent, child).startsWith('..');
   }
 
   export async function findUp(target: string, start: string, stop?: string) {
-    let current = start
-    const result = []
+    let current = start;
+    const result = [];
     while (true) {
-      const search = join(current, target)
-      if (await exists(search)) result.push(search)
-      if (stop === current) break
-      const parent = dirname(current)
-      if (parent === current) break
-      current = parent
+      const search = join(current, target);
+      if (await exists(search)) result.push(search);
+      if (stop === current) break;
+      const parent = dirname(current);
+      if (parent === current) break;
+      current = parent;
     }
-    return result
+    return result;
   }
 
-  export async function* up(options: { targets: string[]; start: string; stop?: string }) {
-    const { targets, start, stop } = options
-    let current = start
+  export async function* up(options: {
+    targets: string[];
+    start: string;
+    stop?: string;
+  }) {
+    const { targets, start, stop } = options;
+    let current = start;
     while (true) {
       for (const target of targets) {
-        const search = join(current, target)
-        if (await exists(search)) yield search
+        const search = join(current, target);
+        if (await exists(search)) yield search;
       }
-      if (stop === current) break
-      const parent = dirname(current)
-      if (parent === current) break
-      current = parent
+      if (stop === current) break;
+      const parent = dirname(current);
+      if (parent === current) break;
+      current = parent;
     }
   }
 
   export async function globUp(pattern: string, start: string, stop?: string) {
-    let current = start
-    const result = []
+    let current = start;
+    const result = [];
     while (true) {
       try {
-        const glob = new Bun.Glob(pattern)
+        const glob = new Bun.Glob(pattern);
         for await (const match of glob.scan({
           cwd: current,
           absolute: true,
@@ -54,16 +58,16 @@ export namespace Filesystem {
           followSymlinks: true,
           dot: true,
         })) {
-          result.push(match)
+          result.push(match);
         }
       } catch {
         // Skip invalid glob patterns
       }
-      if (stop === current) break
-      const parent = dirname(current)
-      if (parent === current) break
-      current = parent
+      if (stop === current) break;
+      const parent = dirname(current);
+      if (parent === current) break;
+      current = parent;
     }
-    return result
+    return result;
   }
 }

package/src/util/fn.ts

@@ -1,11 +1,14 @@
-import { z } from "zod"
+import { z } from 'zod';
 
-export function fn<T extends z.ZodType, Result>(schema: T, cb: (input: z.infer<T>) => Result) {
+export function fn<T extends z.ZodType, Result>(
+  schema: T,
+  cb: (input: z.infer<T>) => Result
+) {
   const result = (input: z.infer<T>) => {
-    const parsed = schema.parse(input)
-    return cb(parsed)
-  }
-  result.force = (input: z.infer<T>) => cb(input)
-  result.schema = schema
-  return result
+    const parsed = schema.parse(input);
+    return cb(parsed);
+  };
+  result.force = (input: z.infer<T>) => cb(input);
+  result.schema = schema;
+  return result;
 }

package/src/util/iife.ts

@@ -1,3 +1,3 @@
 export function iife<T>(fn: () => T) {
-  return fn()
+  return fn();
 }

package/src/util/keybind.ts

@@ -1,79 +1,79 @@
-import { isDeepEqual } from "remeda"
+import { isDeepEqual } from 'remeda';
 
 export namespace Keybind {
   export type Info = {
-    ctrl: boolean
-    meta: boolean
-    shift: boolean
-    leader: boolean
-    name: string
-  }
+    ctrl: boolean;
+    meta: boolean;
+    shift: boolean;
+    leader: boolean;
+    name: string;
+  };
 
   export function match(a: Info, b: Info): boolean {
-    return isDeepEqual(a, b)
+    return isDeepEqual(a, b);
   }
 
   export function toString(info: Info): string {
-    const parts: string[] = []
+    const parts: string[] = [];
 
-    if (info.ctrl) parts.push("ctrl")
-    if (info.meta) parts.push("alt")
-    if (info.shift) parts.push("shift")
+    if (info.ctrl) parts.push('ctrl');
+    if (info.meta) parts.push('alt');
+    if (info.shift) parts.push('shift');
     if (info.name) {
-      if (info.name === "delete") parts.push("del")
-      else parts.push(info.name)
+      if (info.name === 'delete') parts.push('del');
+      else parts.push(info.name);
     }
 
-    let result = parts.join("+")
+    let result = parts.join('+');
 
     if (info.leader) {
-      result = result ? `<leader> ${result}` : `<leader>`
+      result = result ? `<leader> ${result}` : `<leader>`;
     }
 
-    return result
+    return result;
   }
 
   export function parse(key: string): Info[] {
-    if (key === "none") return []
+    if (key === 'none') return [];
 
-    return key.split(",").map((combo) => {
+    return key.split(',').map((combo) => {
       // Handle <leader> syntax by replacing with leader+
-      const normalized = combo.replace(/<leader>/g, "leader+")
-      const parts = normalized.toLowerCase().split("+")
+      const normalized = combo.replace(/<leader>/g, 'leader+');
+      const parts = normalized.toLowerCase().split('+');
       const info: Info = {
         ctrl: false,
         meta: false,
         shift: false,
         leader: false,
-        name: "",
-      }
+        name: '',
+      };
 
       for (const part of parts) {
         switch (part) {
-          case "ctrl":
-            info.ctrl = true
-            break
-          case "alt":
-          case "meta":
-          case "option":
-            info.meta = true
-            break
-          case "shift":
-            info.shift = true
-            break
-          case "leader":
-            info.leader = true
-            break
-          case "esc":
-            info.name = "escape"
-            break
+          case 'ctrl':
+            info.ctrl = true;
+            break;
+          case 'alt':
+          case 'meta':
+          case 'option':
+            info.meta = true;
+            break;
+          case 'shift':
+            info.shift = true;
+            break;
+          case 'leader':
+            info.leader = true;
+            break;
+          case 'esc':
+            info.name = 'escape';
+            break;
           default:
-            info.name = part
-            break
+            info.name = part;
+            break;
         }
       }
 
-      return info
-    })
+      return info;
+    });
   }
 }

package/src/util/lazy.ts

@@ -1,11 +1,11 @@
 export function lazy<T>(fn: () => T) {
-  let value: T | undefined
-  let loaded = false
+  let value: T | undefined;
+  let loaded = false;
 
   return (): T => {
-    if (loaded) return value as T
-    loaded = true
-    value = fn()
-    return value as T
-  }
+    if (loaded) return value as T;
+    loaded = true;
+    value = fn();
+    return value as T;
+  };
 }

package/src/util/locale.ts

@@ -1,39 +1,43 @@
 export namespace Locale {
   export function titlecase(str: string) {
-    return str.replace(/\b\w/g, (c) => c.toUpperCase())
+    return str.replace(/\b\w/g, (c) => c.toUpperCase());
   }
 
   export function time(input: number) {
-    const date = new Date(input)
-    return date.toLocaleTimeString()
+    const date = new Date(input);
+    return date.toLocaleTimeString();
   }
 
   export function number(num: number): string {
     if (num >= 1000000) {
-      return (num / 1000000).toFixed(1) + "M"
+      return (num / 1000000).toFixed(1) + 'M';
     } else if (num >= 1000) {
-      return (num / 1000).toFixed(1) + "K"
+      return (num / 1000).toFixed(1) + 'K';
     }
-    return num.toString()
+    return num.toString();
   }
 
   export function truncate(str: string, len: number): string {
-    if (str.length <= len) return str
-    return str.slice(0, len - 1) + "…"
+    if (str.length <= len) return str;
+    return str.slice(0, len - 1) + '…';
   }
 
   export function truncateMiddle(str: string, maxLength: number = 35): string {
-    if (str.length <= maxLength) return str
+    if (str.length <= maxLength) return str;
 
-    const ellipsis = "…"
-    const keepStart = Math.ceil((maxLength - ellipsis.length) / 2)
-    const keepEnd = Math.floor((maxLength - ellipsis.length) / 2)
+    const ellipsis = '…';
+    const keepStart = Math.ceil((maxLength - ellipsis.length) / 2);
+    const keepEnd = Math.floor((maxLength - ellipsis.length) / 2);
 
-    return str.slice(0, keepStart) + ellipsis + str.slice(-keepEnd)
+    return str.slice(0, keepStart) + ellipsis + str.slice(-keepEnd);
   }
 
-  export function pluralize(count: number, singular: string, plural: string): string {
-    const template = count === 1 ? singular : plural
-    return template.replace("{}", count.toString())
+  export function pluralize(
+    count: number,
+    singular: string,
+    plural: string
+  ): string {
+    const template = count === 1 ? singular : plural;
+    return template.replace('{}', count.toString());
   }
 }

package/src/util/lock.ts

@@ -2,12 +2,12 @@ export namespace Lock {
   const locks = new Map<
     string,
     {
-      readers: number
-      writer: boolean
-      waitingReaders: (() => void)[]
-      waitingWriters: (() => void)[]
+      readers: number;
+      writer: boolean;
+      waitingReaders: (() => void)[];
+      waitingWriters: (() => void)[];
     }
-  >()
+  >();
 
   function get(key: string) {
     if (!locks.has(key)) {
@@ -16,83 +16,88 @@ export namespace Lock {
         writer: false,
         waitingReaders: [],
         waitingWriters: [],
-      })
+      });
     }
-    return locks.get(key)!
+    return locks.get(key)!;
   }
 
   function process(key: string) {
-    const lock = locks.get(key)
-    if (!lock || lock.writer || lock.readers > 0) return
+    const lock = locks.get(key);
+    if (!lock || lock.writer || lock.readers > 0) return;
 
     // Prioritize writers to prevent starvation
     if (lock.waitingWriters.length > 0) {
-      const nextWriter = lock.waitingWriters.shift()!
-      nextWriter()
-      return
+      const nextWriter = lock.waitingWriters.shift()!;
+      nextWriter();
+      return;
     }
 
     // Wake up all waiting readers
     while (lock.waitingReaders.length > 0) {
-      const nextReader = lock.waitingReaders.shift()!
-      nextReader()
+      const nextReader = lock.waitingReaders.shift()!;
+      nextReader();
     }
 
     // Clean up empty locks
-    if (lock.readers === 0 && !lock.writer && lock.waitingReaders.length === 0 && lock.waitingWriters.length === 0) {
-      locks.delete(key)
+    if (
+      lock.readers === 0 &&
+      !lock.writer &&
+      lock.waitingReaders.length === 0 &&
+      lock.waitingWriters.length === 0
+    ) {
+      locks.delete(key);
     }
   }
 
   export async function read(key: string): Promise<Disposable> {
-    const lock = get(key)
+    const lock = get(key);
 
     return new Promise((resolve) => {
       if (!lock.writer && lock.waitingWriters.length === 0) {
-        lock.readers++
+        lock.readers++;
         resolve({
           [Symbol.dispose]: () => {
-            lock.readers--
-            process(key)
+            lock.readers--;
+            process(key);
           },
-        })
+        });
       } else {
         lock.waitingReaders.push(() => {
-          lock.readers++
+          lock.readers++;
           resolve({
             [Symbol.dispose]: () => {
-              lock.readers--
-              process(key)
+              lock.readers--;
+              process(key);
             },
-          })
-        })
+          });
+        });
       }
-    })
+    });
   }
 
   export async function write(key: string): Promise<Disposable> {
-    const lock = get(key)
+    const lock = get(key);
 
     return new Promise((resolve) => {
       if (!lock.writer && lock.readers === 0) {
-        lock.writer = true
+        lock.writer = true;
         resolve({
           [Symbol.dispose]: () => {
-            lock.writer = false
-            process(key)
+            lock.writer = false;
+            process(key);
           },
-        })
+        });
       } else {
         lock.waitingWriters.push(() => {
-          lock.writer = true
+          lock.writer = true;
           resolve({
             [Symbol.dispose]: () => {
-              lock.writer = false
-              process(key)
+              lock.writer = false;
+              process(key);
             },
-          })
-        })
+          });
+        });
       }
-    })
+    });
   }
 }