@link-assistant/agent 0.0.9 → 0.0.12

package/src/project/bootstrap.ts

@@ -1,22 +1,22 @@
-import { Format } from "../format"
-import { FileWatcher } from "../file/watcher"
-import { File } from "../file"
-import { Flag } from "../flag/flag"
-import { Project } from "./project"
-import { Bus } from "../bus"
-import { Command } from "../command"
-import { Instance } from "./instance"
-import { Log } from "../util/log"
+import { Format } from '../format';
+import { FileWatcher } from '../file/watcher';
+import { File } from '../file';
+import { Flag } from '../flag/flag';
+import { Project } from './project';
+import { Bus } from '../bus';
+import { Command } from '../command';
+import { Instance } from './instance';
+import { Log } from '../util/log';
 
 export async function InstanceBootstrap() {
-  Log.Default.info("bootstrapping", { directory: Instance.directory })
-  Format.init()
-  FileWatcher.init()
-  File.init()
+  Log.Default.info('bootstrapping', { directory: Instance.directory });
+  Format.init();
+  FileWatcher.init();
+  File.init();
 
   Bus.subscribe(Command.Event.Executed, async (payload) => {
     if (payload.properties.name === Command.Default.INIT) {
-      await Project.setInitialized(Instance.project.id)
+      await Project.setInitialized(Instance.project.id);
     }
-  })
+  });
 }

package/src/project/instance.ts

@@ -1,67 +1,74 @@
-import { Log } from "../util/log"
-import { Context } from "../util/context"
-import { Project } from "./project"
-import { State } from "./state"
-import { iife } from "../util/iife"
+import { Log } from '../util/log';
+import { Context } from '../util/context';
+import { Project } from './project';
+import { State } from './state';
+import { iife } from '../util/iife';
 
 interface Context {
-  directory: string
-  worktree: string
-  project: Project.Info
+  directory: string;
+  worktree: string;
+  project: Project.Info;
 }
-const context = Context.create<Context>("instance")
-const cache = new Map<string, Promise<Context>>()
+const context = Context.create<Context>('instance');
+const cache = new Map<string, Promise<Context>>();
 
 export const Instance = {
-  async provide<R>(input: { directory: string; init?: () => Promise<any>; fn: () => R }): Promise<R> {
-    let existing = cache.get(input.directory)
+  async provide<R>(input: {
+    directory: string;
+    init?: () => Promise<any>;
+    fn: () => R;
+  }): Promise<R> {
+    let existing = cache.get(input.directory);
     if (!existing) {
-      Log.Default.info("creating instance", { directory: input.directory })
+      Log.Default.info('creating instance', { directory: input.directory });
       existing = iife(async () => {
-        const project = await Project.fromDirectory(input.directory)
+        const project = await Project.fromDirectory(input.directory);
         const ctx = {
           directory: input.directory,
           worktree: project.worktree,
           project,
-        }
+        };
         await context.provide(ctx, async () => {
-          await input.init?.()
-        })
-        return ctx
-      })
-      cache.set(input.directory, existing)
+          await input.init?.();
+        });
+        return ctx;
+      });
+      cache.set(input.directory, existing);
     }
-    const ctx = await existing
+    const ctx = await existing;
     return context.provide(ctx, async () => {
-      return input.fn()
-    })
+      return input.fn();
+    });
   },
   get directory() {
-    return context.use().directory
+    return context.use().directory;
   },
   get worktree() {
-    return context.use().worktree
+    return context.use().worktree;
   },
   get project() {
-    return context.use().project
+    return context.use().project;
   },
-  state<S>(init: () => S, dispose?: (state: Awaited<S>) => Promise<void>): () => S {
-    return State.create(() => Instance.directory, init, dispose)
+  state<S>(
+    init: () => S,
+    dispose?: (state: Awaited<S>) => Promise<void>
+  ): () => S {
+    return State.create(() => Instance.directory, init, dispose);
   },
   async dispose() {
-    Log.Default.info("disposing instance", { directory: Instance.directory })
-    await State.dispose(Instance.directory)
+    Log.Default.info('disposing instance', { directory: Instance.directory });
+    await State.dispose(Instance.directory);
   },
   async disposeAll() {
-    Log.Default.info("disposing all instances")
+    Log.Default.info('disposing all instances');
     for (const [_key, value] of cache) {
-      const awaited = await value.catch(() => {})
+      const awaited = await value.catch(() => {});
       if (awaited) {
         await context.provide(await value, async () => {
-          await Instance.dispose()
-        })
+          await Instance.dispose();
+        });
       }
     }
-    cache.clear()
+    cache.clear();
   },
-}
+};

package/src/project/project.ts

@@ -1,51 +1,51 @@
-import z from "zod"
-import { Filesystem } from "../util/filesystem"
-import path from "path"
-import { $ } from "bun"
-import { Storage } from "../storage/storage"
-import { Log } from "../util/log"
-import { Flag } from "../flag/flag"
+import z from 'zod';
+import { Filesystem } from '../util/filesystem';
+import path from 'path';
+import { $ } from 'bun';
+import { Storage } from '../storage/storage';
+import { Log } from '../util/log';
+import { Flag } from '../flag/flag';
 
 export namespace Project {
-  const log = Log.create({ service: "project" })
+  const log = Log.create({ service: 'project' });
   export const Info = z
     .object({
       id: z.string(),
       worktree: z.string(),
-      vcs: z.literal("git").optional(),
+      vcs: z.literal('git').optional(),
       time: z.object({
         created: z.number(),
         initialized: z.number().optional(),
       }),
     })
     .meta({
-      ref: "Project",
-    })
-  export type Info = z.infer<typeof Info>
+      ref: 'Project',
+    });
+  export type Info = z.infer<typeof Info>;
 
   export async function fromDirectory(directory: string) {
-    log.info("fromDirectory", { directory })
-    const matches = Filesystem.up({ targets: [".git"], start: directory })
-    const git = await matches.next().then((x) => x.value)
-    await matches.return()
+    log.info('fromDirectory', { directory });
+    const matches = Filesystem.up({ targets: ['.git'], start: directory });
+    const git = await matches.next().then((x) => x.value);
+    await matches.return();
     if (!git) {
       const project: Info = {
-        id: "global",
-        worktree: "/",
-        vcs: "none", // No VCS
+        id: 'global',
+        worktree: '/',
+        vcs: 'none', // No VCS
         time: {
           created: Date.now(),
         },
-      }
-      await Storage.write<Info>(["project", "global"], project)
-      return project
+      };
+      await Storage.write<Info>(['project', 'global'], project);
+      return project;
     }
-    let worktree = path.dirname(git)
-    const timer = log.time("git.rev-parse")
-    let id = await Bun.file(path.join(git, "opencode"))
+    let worktree = path.dirname(git);
+    const timer = log.time('git.rev-parse');
+    let id = await Bun.file(path.join(git, 'opencode'))
       .text()
       .then((x) => x.trim())
-      .catch(() => {})
+      .catch(() => {});
     if (!id) {
       const roots = await $`git rev-list --max-parents=0 --all`
         .quiet()
@@ -54,52 +54,52 @@ export namespace Project {
         .text()
         .then((x) =>
           x
-            .split("\n")
+            .split('\n')
             .filter(Boolean)
             .map((x) => x.trim())
-            .toSorted(),
-        )
-      id = roots[0]
-      if (id) Bun.file(path.join(git, "opencode")).write(id)
+            .toSorted()
+        );
+      id = roots[0];
+      if (id) Bun.file(path.join(git, 'opencode')).write(id);
     }
-    timer.stop()
+    timer.stop();
     if (!id) {
       const project: Info = {
-        id: "global",
-        worktree: "/",
+        id: 'global',
+        worktree: '/',
         time: {
           created: Date.now(),
         },
-      }
-      await Storage.write<Info>(["project", "global"], project)
-      return project
+      };
+      await Storage.write<Info>(['project', 'global'], project);
+      return project;
     }
     worktree = await $`git rev-parse --path-format=absolute --show-toplevel`
       .quiet()
       .nothrow()
       .cwd(worktree)
       .text()
-      .then((x) => x.trim())
+      .then((x) => x.trim());
     const project: Info = {
       id,
       worktree,
-      vcs: "git",
+      vcs: 'git',
       time: {
         created: Date.now(),
       },
-    }
-    await Storage.write<Info>(["project", id], project)
-    return project
+    };
+    await Storage.write<Info>(['project', id], project);
+    return project;
   }
 
   export async function setInitialized(projectID: string) {
-    await Storage.update<Info>(["project", projectID], (draft) => {
-      draft.time.initialized = Date.now()
-    })
+    await Storage.update<Info>(['project', projectID], (draft) => {
+      draft.time.initialized = Date.now();
+    });
   }
 
   export async function list() {
-    const keys = await Storage.list(["project"])
-    return await Promise.all(keys.map((x) => Storage.read<Info>(x)))
+    const keys = await Storage.list(['project']);
+    return await Promise.all(keys.map((x) => Storage.read<Info>(x)));
   }
 }

package/src/project/state.ts

@@ -1,65 +1,69 @@
-import { Log } from "../util/log"
+import { Log } from '../util/log';
 
 export namespace State {
   interface Entry {
-    state: any
-    dispose?: (state: any) => Promise<void>
+    state: any;
+    dispose?: (state: any) => Promise<void>;
   }
 
-  const log = Log.create({ service: "state" })
-  const recordsByKey = new Map<string, Map<any, Entry>>()
+  const log = Log.create({ service: 'state' });
+  const recordsByKey = new Map<string, Map<any, Entry>>();
 
-  export function create<S>(root: () => string, init: () => S, dispose?: (state: Awaited<S>) => Promise<void>) {
+  export function create<S>(
+    root: () => string,
+    init: () => S,
+    dispose?: (state: Awaited<S>) => Promise<void>
+  ) {
     return () => {
-      const key = root()
-      let entries = recordsByKey.get(key)
+      const key = root();
+      let entries = recordsByKey.get(key);
       if (!entries) {
-        entries = new Map<string, Entry>()
-        recordsByKey.set(key, entries)
+        entries = new Map<string, Entry>();
+        recordsByKey.set(key, entries);
       }
-      const exists = entries.get(init)
-      if (exists) return exists.state as S
-      const state = init()
+      const exists = entries.get(init);
+      if (exists) return exists.state as S;
+      const state = init();
       entries.set(init, {
         state,
         dispose,
-      })
-      return state
-    }
+      });
+      return state;
+    };
   }
 
   export async function dispose(key: string) {
-    const entries = recordsByKey.get(key)
-    if (!entries) return
+    const entries = recordsByKey.get(key);
+    if (!entries) return;
 
-    log.info("waiting for state disposal to complete", { key })
+    log.info('waiting for state disposal to complete', { key });
 
-    let disposalFinished = false
+    let disposalFinished = false;
 
     setTimeout(() => {
       if (!disposalFinished) {
         log.warn(
-          "state disposal is taking an unusually long time - if it does not complete in a reasonable time, please report this as a bug",
-          { key },
-        )
+          'state disposal is taking an unusually long time - if it does not complete in a reasonable time, please report this as a bug',
+          { key }
+        );
       }
-    }, 10000).unref()
+    }, 10000).unref();
 
-    const tasks: Promise<void>[] = []
+    const tasks: Promise<void>[] = [];
     for (const entry of entries.values()) {
-      if (!entry.dispose) continue
+      if (!entry.dispose) continue;
 
       const task = Promise.resolve(entry.state)
         .then((state) => entry.dispose!(state))
         .catch((error) => {
-          log.error("Error while disposing state:", { error, key })
-        })
+          log.error('Error while disposing state:', { error, key });
+        });
 
-      tasks.push(task)
+      tasks.push(task);
     }
-    await Promise.all(tasks)
-    recordsByKey.delete(key)
-    disposalFinished = true
-    log.info("state disposal completed", { key })
+    await Promise.all(tasks);
+    recordsByKey.delete(key);
+    disposalFinished = true;
+    log.info('state disposal completed', { key });
   }
 }

package/src/provider/models-macro.ts

@@ -1,11 +1,11 @@
 export async function data() {
-  const path = Bun.env.MODELS_DEV_API_JSON
+  const path = Bun.env.MODELS_DEV_API_JSON;
   if (path) {
-    const file = Bun.file(path)
+    const file = Bun.file(path);
     if (await file.exists()) {
-      return await file.text()
+      return await file.text();
     }
   }
-  const json = await fetch("https://models.dev/api.json").then((x) => x.text())
-  return json
+  const json = await fetch('https://models.dev/api.json').then((x) => x.text());
+  return json;
 }

package/src/provider/models.ts

@@ -1,12 +1,12 @@
-import { Global } from "../global"
-import { Log } from "../util/log"
-import path from "path"
-import z from "zod"
-import { data } from "./models-macro"
+import { Global } from '../global';
+import { Log } from '../util/log';
+import path from 'path';
+import z from 'zod';
+import { data } from './models-macro';
 
 export namespace ModelsDev {
-  const log = Log.create({ service: "models.dev" })
-  const filepath = path.join(Global.Path.cache, "models.json")
+  const log = Log.create({ service: 'models.dev' });
+  const filepath = path.join(Global.Path.cache, 'models.json');
 
   export const Model = z
     .object({
@@ -37,20 +37,20 @@ export namespace ModelsDev {
       }),
       modalities: z
         .object({
-          input: z.array(z.enum(["text", "audio", "image", "video", "pdf"])),
-          output: z.array(z.enum(["text", "audio", "image", "video", "pdf"])),
+          input: z.array(z.enum(['text', 'audio', 'image', 'video', 'pdf'])),
+          output: z.array(z.enum(['text', 'audio', 'image', 'video', 'pdf'])),
         })
         .optional(),
       experimental: z.boolean().optional(),
-      status: z.enum(["alpha", "beta", "deprecated"]).optional(),
+      status: z.enum(['alpha', 'beta', 'deprecated']).optional(),
       options: z.record(z.string(), z.any()),
       headers: z.record(z.string(), z.string()).optional(),
       provider: z.object({ npm: z.string() }).optional(),
     })
     .meta({
-      ref: "Model",
-    })
-  export type Model = z.infer<typeof Model>
+      ref: 'Model',
+    });
+  export type Model = z.infer<typeof Model>;
 
   export const Provider = z
     .object({
@@ -62,37 +62,37 @@ export namespace ModelsDev {
       models: z.record(z.string(), Model),
     })
     .meta({
-      ref: "Provider",
-    })
+      ref: 'Provider',
+    });
 
-  export type Provider = z.infer<typeof Provider>
+  export type Provider = z.infer<typeof Provider>;
 
   export async function get() {
-    refresh()
-    const file = Bun.file(filepath)
-    const result = await file.json().catch(() => {})
-    if (result) return result as Record<string, Provider>
-    const json = await data()
-    return JSON.parse(json) as Record<string, Provider>
+    refresh();
+    const file = Bun.file(filepath);
+    const result = await file.json().catch(() => {});
+    if (result) return result as Record<string, Provider>;
+    const json = await data();
+    return JSON.parse(json) as Record<string, Provider>;
   }
 
   export async function refresh() {
-    const file = Bun.file(filepath)
-    log.info("refreshing", {
+    const file = Bun.file(filepath);
+    log.info('refreshing', {
       file,
-    })
-    const result = await fetch("https://models.dev/api.json", {
+    });
+    const result = await fetch('https://models.dev/api.json', {
       headers: {
-        "User-Agent": "agent-cli/1.0.0",
+        'User-Agent': 'agent-cli/1.0.0',
       },
       signal: AbortSignal.timeout(10 * 1000),
     }).catch((e) => {
-      log.error("Failed to fetch models.dev", {
+      log.error('Failed to fetch models.dev', {
         error: e,
-      })
-    })
-    if (result && result.ok) await Bun.write(file, await result.text())
+      });
+    });
+    if (result && result.ok) await Bun.write(file, await result.text());
   }
 }
 
-setInterval(() => ModelsDev.refresh(), 60 * 1000 * 60).unref()
+setInterval(() => ModelsDev.refresh(), 60 * 1000 * 60).unref();

package/src/provider/opencode.js

@@ -1,13 +1,13 @@
 // Permalink: https://github.com/sst/opencode/blob/main/packages/opencode/src/provider/provider.ts
 
-import { createOpenCode } from '@opencode-ai/sdk'
+import { createOpenCode } from '@opencode-ai/sdk';
 
 class OpenCodeProvider {
   constructor() {
-    this.name = 'opencode'
+    this.name = 'opencode';
   }
 
-  async getModel(modelId) {
+  getModel(modelId) {
     // For grok-code, return a model that uses the opencode API
     if (modelId === 'grok-code') {
       return {
@@ -15,33 +15,33 @@ class OpenCodeProvider {
         provider: this,
         generateText: async (options) => {
           // Use opencode API
-          const opencode = await createOpenCode()
-          const { client } = opencode
+          const opencode = await createOpenCode();
+          const { client } = opencode;
 
-          const sessionResult = await client.session.create()
-          const sessionId = sessionResult.data?.id
+          const sessionResult = await client.session.create();
+          const sessionId = sessionResult.data?.id;
 
           await client.session.prompt({
             path: { id: sessionId },
             body: {
-              agent: "build",
-              model: { providerID: "opencode", modelID: "grok-code" },
-              parts: [{ type: "text", text: options.prompt }]
-            }
-          })
+              agent: 'build',
+              model: { providerID: 'opencode', modelID: 'grok-code' },
+              parts: [{ type: 'text', text: options.prompt }],
+            },
+          });
 
           // For simplicity, return a mock response
           return {
             text: 'Hello from Grok Code!',
-            usage: { promptTokens: 10, completionTokens: 5 }
-          }
-        }
-      }
+            usage: { promptTokens: 10, completionTokens: 5 },
+          };
+        },
+      };
     }
-    throw new Error(`Model ${modelId} not found`)
+    throw new Error(`Model ${modelId} not found`);
   }
 }
 
-const opencodeProvider = new OpenCodeProvider()
+const opencodeProvider = new OpenCodeProvider();
 
-export { opencodeProvider }
+export { opencodeProvider };