@link-assistant/agent 0.0.9 → 0.0.12

package/src/bun/index.ts

@@ -1,74 +1,84 @@
-import z from "zod"
-import { Global } from "../global"
-import { Log } from "../util/log"
-import path from "path"
-import { NamedError } from "../util/error"
-import { readableStreamToText } from "bun"
+import z from 'zod';
+import { Global } from '../global';
+import { Log } from '../util/log';
+import path from 'path';
+import { NamedError } from '../util/error';
+import { readableStreamToText } from 'bun';
 
 export namespace BunProc {
-  const log = Log.create({ service: "bun" })
+  const log = Log.create({ service: 'bun' });
 
-  export async function run(cmd: string[], options?: Bun.SpawnOptions.OptionsObject<any, any, any>) {
-    log.info("running", {
+  export async function run(
+    cmd: string[],
+    options?: Bun.SpawnOptions.OptionsObject<any, any, any>
+  ) {
+    log.info('running', {
       cmd: [which(), ...cmd],
       ...options,
-    })
+    });
     const result = Bun.spawn([which(), ...cmd], {
       ...options,
-      stdout: "pipe",
-      stderr: "pipe",
+      stdout: 'pipe',
+      stderr: 'pipe',
       env: {
         ...process.env,
         ...options?.env,
-        BUN_BE_BUN: "1",
+        BUN_BE_BUN: '1',
       },
-    })
-    const code = await result.exited
+    });
+    const code = await result.exited;
     const stdout = result.stdout
-      ? typeof result.stdout === "number"
+      ? typeof result.stdout === 'number'
         ? result.stdout
         : await readableStreamToText(result.stdout)
-      : undefined
+      : undefined;
     const stderr = result.stderr
-      ? typeof result.stderr === "number"
+      ? typeof result.stderr === 'number'
         ? result.stderr
         : await readableStreamToText(result.stderr)
-      : undefined
-    log.info("done", {
+      : undefined;
+    log.info('done', {
       code,
       stdout,
       stderr,
-    })
+    });
     if (code !== 0) {
-      throw new Error(`Command failed with exit code ${result.exitCode}`)
+      throw new Error(`Command failed with exit code ${result.exitCode}`);
     }
-    return result
+    return result;
   }
 
   export function which() {
-    return process.execPath
+    return process.execPath;
   }
 
   export const InstallFailedError = NamedError.create(
-    "BunInstallFailedError",
+    'BunInstallFailedError',
     z.object({
       pkg: z.string(),
       version: z.string(),
-    }),
-  )
+    })
+  );
 
-  export async function install(pkg: string, version = "latest") {
-    const mod = path.join(Global.Path.cache, "node_modules", pkg)
-    const pkgjson = Bun.file(path.join(Global.Path.cache, "package.json"))
+  export async function install(pkg: string, version = 'latest') {
+    const mod = path.join(Global.Path.cache, 'node_modules', pkg);
+    const pkgjson = Bun.file(path.join(Global.Path.cache, 'package.json'));
     const parsed = await pkgjson.json().catch(async () => {
-      const result = { dependencies: {} }
-      await Bun.write(pkgjson.name!, JSON.stringify(result, null, 2))
-      return result
-    })
-    if (parsed.dependencies[pkg] === version) return mod
+      const result = { dependencies: {} };
+      await Bun.write(pkgjson.name!, JSON.stringify(result, null, 2));
+      return result;
+    });
+    if (parsed.dependencies[pkg] === version) return mod;
 
     // Build command arguments
-    const args = ["add", "--force", "--exact", "--cwd", Global.Path.cache, pkg + "@" + version]
+    const args = [
+      'add',
+      '--force',
+      '--exact',
+      '--cwd',
+      Global.Path.cache,
+      pkg + '@' + version,
+    ];
 
     // Let Bun handle registry resolution:
     // - If .npmrc files exist, Bun will use them automatically
@@ -77,7 +87,7 @@ export namespace BunProc {
     log.info("installing package using Bun's default registry resolution", {
       pkg,
       version,
-    })
+    });
 
     await BunProc.run(args, {
       cwd: Global.Path.cache,
@@ -86,11 +96,11 @@ export namespace BunProc {
         { pkg, version },
         {
           cause: e,
-        },
-      )
-    })
-    parsed.dependencies[pkg] = version
-    await Bun.write(pkgjson.name!, JSON.stringify(parsed, null, 2))
-    return mod
+        }
+      );
+    });
+    parsed.dependencies[pkg] = version;
+    await Bun.write(pkgjson.name!, JSON.stringify(parsed, null, 2));
+    return mod;
   }
 }

package/src/bus/global.ts

@@ -1,10 +1,10 @@
-import { EventEmitter } from "events"
+import { EventEmitter } from 'events';
 
 export const GlobalBus = new EventEmitter<{
   event: [
     {
-      directory: string
-      payload: any
+      directory: string;
+      payload: any;
     },
-  ]
-}>()
+  ];
+}>();

package/src/bus/index.ts

@@ -1,38 +1,41 @@
-import z from "zod"
-import type { ZodType } from "zod"
-import { Log } from "../util/log"
-import { Instance } from "../project/instance"
-import { GlobalBus } from "./global"
+import z from 'zod';
+import type { ZodType } from 'zod';
+import { Log } from '../util/log';
+import { Instance } from '../project/instance';
+import { GlobalBus } from './global';
 
 export namespace Bus {
-  const log = Log.create({ service: "bus" })
-  type Subscription = (event: any) => void
+  const log = Log.create({ service: 'bus' });
+  type Subscription = (event: any) => void;
 
   const state = Instance.state(() => {
-    const subscriptions = new Map<any, Subscription[]>()
+    const subscriptions = new Map<any, Subscription[]>();
 
     return {
       subscriptions,
-    }
-  })
+    };
+  });
 
-  export type EventDefinition = ReturnType<typeof event>
+  export type EventDefinition = ReturnType<typeof event>;
 
-  const registry = new Map<string, EventDefinition>()
+  const registry = new Map<string, EventDefinition>();
 
-  export function event<Type extends string, Properties extends ZodType>(type: Type, properties: Properties) {
+  export function event<Type extends string, Properties extends ZodType>(
+    type: Type,
+    properties: Properties
+  ) {
     const result = {
       type,
       properties,
-    }
-    registry.set(type, result)
-    return result
+    };
+    registry.set(type, result);
+    return result;
   }
 
   export function payloads() {
     return z
       .discriminatedUnion(
-        "type",
+        'type',
         registry
           .entries()
           .map(([type, def]) => {
@@ -42,78 +45,81 @@ export namespace Bus {
                 properties: def.properties,
               })
               .meta({
-                ref: "Event" + "." + def.type,
-              })
+                ref: 'Event' + '.' + def.type,
+              });
           })
-          .toArray() as any,
+          .toArray() as any
       )
       .meta({
-        ref: "Event",
-      })
+        ref: 'Event',
+      });
   }
 
   export async function publish<Definition extends EventDefinition>(
     def: Definition,
-    properties: z.output<Definition["properties"]>,
+    properties: z.output<Definition['properties']>
   ) {
     const payload = {
       type: def.type,
       properties,
-    }
-    log.info("publishing", {
+    };
+    log.info('publishing', {
       type: def.type,
-    })
-    const pending = []
-    for (const key of [def.type, "*"]) {
-      const match = state().subscriptions.get(key)
+    });
+    const pending = [];
+    for (const key of [def.type, '*']) {
+      const match = state().subscriptions.get(key);
       for (const sub of match ?? []) {
-        pending.push(sub(payload))
+        pending.push(sub(payload));
       }
     }
-    GlobalBus.emit("event", {
+    GlobalBus.emit('event', {
       directory: Instance.directory,
       payload,
-    })
-    return Promise.all(pending)
+    });
+    return Promise.all(pending);
   }
 
   export function subscribe<Definition extends EventDefinition>(
     def: Definition,
-    callback: (event: { type: Definition["type"]; properties: z.infer<Definition["properties"]> }) => void,
+    callback: (event: {
+      type: Definition['type'];
+      properties: z.infer<Definition['properties']>;
+    }) => void
   ) {
-    return raw(def.type, callback)
+    return raw(def.type, callback);
   }
 
   export function once<Definition extends EventDefinition>(
     def: Definition,
     callback: (event: {
-      type: Definition["type"]
-      properties: z.infer<Definition["properties"]>
-    }) => "done" | undefined,
+      type: Definition['type'];
+      properties: z.infer<Definition['properties']>;
+    }) => 'done' | undefined
   ) {
     const unsub = subscribe(def, (event) => {
-      if (callback(event)) unsub()
-    })
+      if (callback(event)) unsub();
+    });
   }
 
   export function subscribeAll(callback: (event: any) => void) {
-    return raw("*", callback)
+    return raw('*', callback);
   }
 
   function raw(type: string, callback: (event: any) => void) {
-    log.info("subscribing", { type })
-    const subscriptions = state().subscriptions
-    let match = subscriptions.get(type) ?? []
-    match.push(callback)
-    subscriptions.set(type, match)
+    log.info('subscribing', { type });
+    const subscriptions = state().subscriptions;
+    let match = subscriptions.get(type) ?? [];
+    match.push(callback);
+    subscriptions.set(type, match);
 
     return () => {
-      log.info("unsubscribing", { type })
-      const match = subscriptions.get(type)
-      if (!match) return
-      const index = match.indexOf(callback)
-      if (index === -1) return
-      match.splice(index, 1)
-    }
+      log.info('unsubscribing', { type });
+      const match = subscriptions.get(type);
+      if (!match) return;
+      const index = match.indexOf(callback);
+      if (index === -1) return;
+      match.splice(index, 1);
+    };
   }
 }

package/src/cli/bootstrap.js

@@ -2,16 +2,16 @@
 // Permalink: https://github.com/sst/opencode/blob/main/packages/opencode/src/project/instance.ts
 // Permalink: https://github.com/sst/opencode/blob/main/packages/opencode/src/project/bootstrap.ts
 
-import { createOpencode } from '@opencode-ai/sdk'
+// createOpencode is available from @opencode-ai/sdk but not used directly
 
 class Instance {
-  static directory = process.cwd()
-  static worktree = process.cwd()
+  static directory = process.cwd();
+  static worktree = process.cwd();
 
   static provide(options) {
-    this.directory = options.directory
-    this.worktree = options.directory
-    return options.fn()
+    this.directory = options.directory;
+    this.worktree = options.directory;
+    return options.fn();
   }
 
   static dispose() {
@@ -25,17 +25,17 @@ class InstanceBootstrap {
   }
 }
 
-export async function bootstrap(directory, cb) {
+export function bootstrap(directory, cb) {
   return Instance.provide({
     directory,
     init: InstanceBootstrap,
     fn: async () => {
       try {
-        const result = await cb()
-        return result
+        const result = await cb();
+        return result;
       } finally {
-        await Instance.dispose()
+        await Instance.dispose();
       }
     },
-  })
-}
+  });
+}

package/src/cli/bootstrap.ts

@@ -1,5 +1,5 @@
-import { InstanceBootstrap } from "../project/bootstrap"
-import { Instance } from "../project/instance"
+import { InstanceBootstrap } from '../project/bootstrap';
+import { Instance } from '../project/instance';
 
 export async function bootstrap<T>(directory: string, cb: () => Promise<T>) {
   return Instance.provide({
@@ -7,11 +7,11 @@ export async function bootstrap<T>(directory: string, cb: () => Promise<T>) {
     init: InstanceBootstrap,
     fn: async () => {
       try {
-        const result = await cb()
-        return result
+        const result = await cb();
+        return result;
       } finally {
-        await Instance.dispose()
+        await Instance.dispose();
       }
     },
-  })
+  });
 }