@link-assistant/agent 0.5.2 → 0.6.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@link-assistant/agent",
-  "version": "0.5.2",
+  "version": "0.6.0",
   "description": "A minimal, public domain AI CLI agent compatible with OpenCode's JSON interface. Bun-only runtime.",
   "main": "src/index.js",
   "type": "module",
@@ -68,6 +68,8 @@
     "@opentui/solid": "^0.1.46",
     "@parcel/watcher": "^2.5.1",
     "@solid-primitives/event-bus": "^1.1.2",
+    "@standard-community/standard-json": "^0.3.5",
+    "@standard-community/standard-openapi": "^0.2.9",
     "@zip.js/zip.js": "^2.8.10",
     "ai": "6.0.0-beta.99",
     "chokidar": "^4.0.3",
@@ -82,9 +84,9 @@
     "hono-openapi": "^1.1.1",
     "ignore": "^7.0.5",
     "jsonc-parser": "^3.3.1",
+    "lino-objects-codec": "^0.1.1",
+    "log-lazy": "^1.0.4",
     "minimatch": "^10.1.1",
-    "open": "^11.0.0",
-    "partial-json": "^0.1.7",
     "remeda": "^2.32.0",
     "solid-js": "^1.9.10",
     "strip-ansi": "^7.1.2",

package/src/auth/claude-oauth.ts

@@ -147,9 +147,10 @@ export namespace ClaudeOAuth {
    */
   export async function saveState(state: OAuthState): Promise<void> {
     await Bun.write(statePath, JSON.stringify(state, null, 2));
-    log.info('saved oauth state', {
+    log.info(() => ({
+      message: 'saved oauth state',
       expiresAt: new Date(state.expiresAt).toISOString(),
-    });
+    }));
   }
 
   /**
@@ -165,14 +166,14 @@ export namespace ClaudeOAuth {
       const parsed = OAuthState.parse(content);
 
       if (parsed.expiresAt < Date.now()) {
-        log.warn('oauth state expired');
+        log.warn(() => ({ message: 'oauth state expired' }));
         await clearState();
         return undefined;
       }
 
       return parsed;
     } catch (error) {
-      log.error('failed to load oauth state', { error });
+      log.error(() => ({ message: 'failed to load oauth state', error }));
       return undefined;
     }
   }
@@ -190,7 +191,7 @@ export namespace ClaudeOAuth {
         await fs.unlink(statePath).catch(() => {});
       }
     } catch (error) {
-      log.error('failed to clear oauth state', { error });
+      log.error(() => ({ message: 'failed to clear oauth state', error }));
     }
   }
 
@@ -213,7 +214,9 @@ export namespace ClaudeOAuth {
       code_verifier: codeVerifier,
     });
 
-    log.info('exchanging authorization code for tokens');
+    log.info(() => ({
+      message: 'exchanging authorization code for tokens',
+    }));
 
     const response = await fetch(Config.tokenUrl, {
       method: 'POST',
@@ -225,7 +228,11 @@ export namespace ClaudeOAuth {
 
     if (!response.ok) {
       const error = await response.text();
-      log.error('token exchange failed', { status: response.status, error });
+      log.error(() => ({
+        message: 'token exchange failed',
+        status: response.status,
+        error,
+      }));
       throw new Error(`Token exchange failed: ${response.status} ${error}`);
     }
 
@@ -267,9 +274,10 @@ export namespace ClaudeOAuth {
     };
 
     await Bun.write(credentialsPath, JSON.stringify(credentials, null, 2));
-    log.info('saved credentials', {
+    log.info(() => ({
+      message: 'saved credentials',
       expiresAt: new Date(credentials.claudeAiOauth!.expiresAt).toISOString(),
-    });
+    }));
   }
 
   /**
@@ -283,7 +291,10 @@ export namespace ClaudeOAuth {
     try {
       const file = Bun.file(credentialsPath);
       if (!(await file.exists())) {
-        log.info('credentials file not found', { path: credentialsPath });
+        log.info(() => ({
+          message: 'credentials file not found',
+          path: credentialsPath,
+        }));
         return undefined;
       }
 
@@ -291,27 +302,31 @@ export namespace ClaudeOAuth {
       const parsed = Credentials.parse(content);
 
       if (!parsed.claudeAiOauth) {
-        log.info('no claudeAiOauth credentials found');
+        log.info(() => ({
+          message: 'no claudeAiOauth credentials found',
+        }));
         return undefined;
       }
 
       // Check if token is expired
       if (parsed.claudeAiOauth.expiresAt < Date.now()) {
-        log.warn('token expired', {
+        log.warn(() => ({
+          message: 'token expired',
           expiresAt: new Date(parsed.claudeAiOauth.expiresAt).toISOString(),
-        });
+        }));
         // TODO: Implement token refresh using refreshToken
         // For now, user needs to re-authenticate
       }
 
-      log.info('loaded oauth credentials', {
+      log.info(() => ({
+        message: 'loaded oauth credentials',
         subscriptionType: parsed.claudeAiOauth.subscriptionType,
         scopes: parsed.claudeAiOauth.scopes,
-      });
+      }));
 
       return parsed.claudeAiOauth;
     } catch (error) {
-      log.error('failed to read credentials', { error });
+      log.error(() => ({ message: 'failed to read credentials', error }));
       return undefined;
     }
   }
@@ -344,7 +359,9 @@ export namespace ClaudeOAuth {
   export async function completeAuth(code: string): Promise<boolean> {
     const state = await loadState();
     if (!state) {
-      log.error('no oauth state found - please start login flow first');
+      log.error(() => ({
+        message: 'no oauth state found - please start login flow first',
+      }));
       return false;
     }
 
@@ -352,10 +369,15 @@ export namespace ClaudeOAuth {
       const tokens = await exchangeCode(code, state.codeVerifier);
       await saveCredentials(tokens);
       await clearState();
-      log.info('authentication completed successfully');
+      log.info(() => ({
+        message: 'authentication completed successfully',
+      }));
       return true;
     } catch (error) {
-      log.error('failed to complete authentication', { error });
+      log.error(() => ({
+        message: 'failed to complete authentication',
+        error,
+      }));
       await clearState();
       return false;
     }
@@ -367,7 +389,7 @@ export namespace ClaudeOAuth {
   export async function refreshToken(): Promise<boolean> {
     const creds = await getCredentials();
     if (!creds?.refreshToken) {
-      log.error('no refresh token available');
+      log.error(() => ({ message: 'no refresh token available' }));
       return false;
     }
 
@@ -377,7 +399,7 @@ export namespace ClaudeOAuth {
       refresh_token: creds.refreshToken,
     });
 
-    log.info('refreshing access token');
+    log.info(() => ({ message: 'refreshing access token' }));
 
     try {
       const response = await fetch(Config.tokenUrl, {
@@ -390,16 +412,20 @@ export namespace ClaudeOAuth {
 
       if (!response.ok) {
         const error = await response.text();
-        log.error('token refresh failed', { status: response.status, error });
+        log.error(() => ({
+          message: 'token refresh failed',
+          status: response.status,
+          error,
+        }));
         return false;
       }
 
       const tokens = TokenResponse.parse(await response.json());
       await saveCredentials(tokens);
-      log.info('token refreshed successfully');
+      log.info(() => ({ message: 'token refreshed successfully' }));
       return true;
     } catch (error) {
-      log.error('failed to refresh token', { error });
+      log.error(() => ({ message: 'failed to refresh token', error }));
       return false;
     }
   }

package/src/auth/plugins.ts

@@ -162,9 +162,10 @@ const AnthropicPlugin: AuthPlugin = {
             );
 
             if (!result.ok) {
-              log.error('anthropic oauth token exchange failed', {
+              log.error(() => ({
+                message: 'anthropic oauth token exchange failed',
                 status: result.status,
-              });
+              }));
               return { type: 'failed' };
             }
 
@@ -229,9 +230,10 @@ const AnthropicPlugin: AuthPlugin = {
             );
 
             if (!tokenResult.ok) {
-              log.error('anthropic oauth token exchange failed', {
+              log.error(() => ({
+                message: 'anthropic oauth token exchange failed',
                 status: tokenResult.status,
-              });
+              }));
               return { type: 'failed' };
             }
 
@@ -286,7 +288,9 @@ const AnthropicPlugin: AuthPlugin = {
 
         // Refresh token if expired
         if (!currentAuth.access || currentAuth.expires < Date.now()) {
-          log.info('refreshing anthropic oauth token');
+          log.info(() => ({
+            message: 'refreshing anthropic oauth token',
+          }));
           const response = await fetch(
             'https://console.anthropic.com/v1/oauth/token',
             {
@@ -566,7 +570,7 @@ const GitHubCopilotPlugin: AuthPlugin = {
             : 'github.com';
           const urls = getCopilotUrls(domain);
 
-          log.info('refreshing github copilot token');
+          log.info(() => ({ message: 'refreshing github copilot token' }));
           const response = await fetch(urls.COPILOT_API_KEY_URL, {
             headers: {
               Accept: 'application/json',
@@ -720,7 +724,9 @@ const OpenAIPlugin: AuthPlugin = {
             }
 
             if (!code) {
-              log.error('openai oauth no code provided');
+              log.error(() => ({
+                message: 'openai oauth no code provided',
+              }));
               return { type: 'failed' };
             }
 
@@ -740,9 +746,10 @@ const OpenAIPlugin: AuthPlugin = {
             });
 
             if (!tokenResult.ok) {
-              log.error('openai oauth token exchange failed', {
+              log.error(() => ({
+                message: 'openai oauth token exchange failed',
                 status: tokenResult.status,
-              });
+              }));
               return { type: 'failed' };
             }
 
@@ -752,7 +759,9 @@ const OpenAIPlugin: AuthPlugin = {
               !json.refresh_token ||
               typeof json.expires_in !== 'number'
             ) {
-              log.error('openai oauth token response missing fields');
+              log.error(() => ({
+                message: 'openai oauth token response missing fields',
+              }));
               return { type: 'failed' };
             }
 
@@ -787,7 +796,7 @@ const OpenAIPlugin: AuthPlugin = {
 
         // Refresh token if expired
         if (!currentAuth.access || currentAuth.expires < Date.now()) {
-          log.info('refreshing openai oauth token');
+          log.info(() => ({ message: 'refreshing openai oauth token' }));
           const response = await fetch(OPENAI_TOKEN_URL, {
             method: 'POST',
             headers: {
@@ -992,9 +1001,10 @@ const GooglePlugin: AuthPlugin = {
               });
 
               if (!tokenResult.ok) {
-                log.error('google oauth token exchange failed', {
+                log.error(() => ({
+                  message: 'google oauth token exchange failed',
                   status: tokenResult.status,
-                });
+                }));
                 return { type: 'failed' };
               }
 
@@ -1004,7 +1014,9 @@ const GooglePlugin: AuthPlugin = {
                 !json.refresh_token ||
                 typeof json.expires_in !== 'number'
               ) {
-                log.error('google oauth token response missing fields');
+                log.error(() => ({
+                  message: 'google oauth token response missing fields',
+                }));
                 return { type: 'failed' };
               }
 
@@ -1015,7 +1027,7 @@ const GooglePlugin: AuthPlugin = {
                 expires: Date.now() + json.expires_in * 1000,
               };
             } catch (error) {
-              log.error('google oauth failed', { error });
+              log.error(() => ({ message: 'google oauth failed', error }));
               return { type: 'failed' };
             }
           },
@@ -1058,7 +1070,7 @@ const GooglePlugin: AuthPlugin = {
           !currentAuth.access ||
           currentAuth.expires < Date.now() + FIVE_MIN_MS
         ) {
-          log.info('refreshing google oauth token');
+          log.info(() => ({ message: 'refreshing google oauth token' }));
           const response = await fetch(GOOGLE_TOKEN_URL, {
             method: 'POST',
             headers: {

package/src/bun/index.ts

@@ -17,10 +17,11 @@ export namespace BunProc {
     cmd: string[],
     options?: Bun.SpawnOptions.OptionsObject<any, any, any>
   ) {
-    log.info('running', {
+    log.info(() => ({
+      message: 'running',
       cmd: [which(), ...cmd],
       ...options,
-    });
+    }));
     const result = Bun.spawn([which(), ...cmd], {
       ...options,
       stdout: 'pipe',
@@ -42,11 +43,7 @@ export namespace BunProc {
         ? result.stderr
         : await readableStreamToText(result.stderr)
       : undefined;
-    log.info('done', {
-      code,
-      stdout,
-      stderr,
-    });
+    log.info(() => ({ message: 'done', code, stdout, stderr }));
     if (code !== 0) {
       const parts = [`Command failed with exit code ${result.exitCode}`];
       if (stderr) parts.push(`stderr: ${stderr}`);
@@ -111,14 +108,13 @@ export namespace BunProc {
 
     // Check for dry-run mode
     if (Flag.OPENCODE_DRY_RUN) {
-      log.info(
-        '[DRY RUN] Would install package (skipping actual installation)',
-        {
-          pkg,
-          version,
-          targetPath: mod,
-        }
-      );
+      log.info(() => ({
+        message:
+          '[DRY RUN] Would install package (skipping actual installation)',
+        pkg,
+        version,
+        targetPath: mod,
+      }));
       // In dry-run mode, pretend the package is installed
       return mod;
     }
@@ -137,10 +133,11 @@ export namespace BunProc {
     // - If .npmrc files exist, Bun will use them automatically
     // - If no .npmrc files exist, Bun will default to https://registry.npmjs.org
     // - No need to pass --registry flag
-    log.info("installing package using Bun's default registry resolution", {
+    log.info(() => ({
+      message: "installing package using Bun's default registry resolution",
       pkg,
       version,
-    });
+    }));
 
     // Retry logic for cache-related errors
     let lastError: Error | undefined;
@@ -150,7 +147,12 @@ export namespace BunProc {
           cwd: Global.Path.cache,
         });
 
-        log.info('package installed successfully', { pkg, version, attempt });
+        log.info(() => ({
+          message: 'package installed successfully',
+          pkg,
+          version,
+          attempt,
+        }));
         parsed.dependencies[pkg] = version;
         await Bun.write(pkgjson.name!, JSON.stringify(parsed, null, 2));
         return mod;
@@ -158,43 +160,47 @@ export namespace BunProc {
         const errorMsg = e instanceof Error ? e.message : String(e);
         const isCacheError = isCacheRelatedError(errorMsg);
 
-        log.warn('package installation attempt failed', {
+        log.warn(() => ({
+          message: 'package installation attempt failed',
           pkg,
           version,
           attempt,
           maxRetries: MAX_RETRIES,
           error: errorMsg,
           isCacheError,
-        });
+        }));
 
         if (isCacheError && attempt < MAX_RETRIES) {
-          log.info('retrying installation after cache-related error', {
+          log.info(() => ({
+            message: 'retrying installation after cache-related error',
             pkg,
             version,
             attempt,
             nextAttempt: attempt + 1,
             delayMs: RETRY_DELAY_MS,
-          });
+          }));
           await delay(RETRY_DELAY_MS);
           lastError = e instanceof Error ? e : new Error(errorMsg);
           continue;
         }
 
         // Non-cache error or final attempt - log and throw
-        log.error('package installation failed', {
+        log.error(() => ({
+          message: 'package installation failed',
           pkg,
           version,
           error: errorMsg,
           stack: e instanceof Error ? e.stack : undefined,
           possibleCacheCorruption: isCacheError,
           attempts: attempt,
-        });
+        }));
 
         // Provide helpful recovery instructions for cache-related errors
         if (isCacheError) {
-          log.error(
-            'Bun package cache may be corrupted. Try clearing the cache with: bun pm cache rm'
-          );
+          log.error(() => ({
+            message:
+              'Bun package cache may be corrupted. Try clearing the cache with: bun pm cache rm',
+          }));
         }
 
         throw new InstallFailedError(

package/src/bus/index.ts

@@ -63,9 +63,7 @@ export namespace Bus {
       type: def.type,
       properties,
     };
-    log.info('publishing', {
-      type: def.type,
-    });
+    log.info(() => ({ message: 'publishing', type: def.type }));
     const pending = [];
     for (const key of [def.type, '*']) {
       const match = state().subscriptions.get(key);
@@ -107,14 +105,14 @@ export namespace Bus {
   }
 
   function raw(type: string, callback: (event: any) => void) {
-    log.info('subscribing', { type });
+    log.info(() => ({ message: 'subscribing', type }));
     const subscriptions = state().subscriptions;
     let match = subscriptions.get(type) ?? [];
     match.push(callback);
     subscriptions.set(type, match);
 
     return () => {
-      log.info('unsubscribing', { type });
+      log.info(() => ({ message: 'unsubscribing', type }));
       const match = subscriptions.get(type);
       if (!match) return;
       const index = match.indexOf(callback);

package/src/config/config.ts

@@ -53,16 +53,21 @@ export namespace Config {
       if (!newDirExists) {
         try {
           // Perform migration by copying the entire directory
-          log.info(
-            `Migrating config from ${oldDir} to ${newDir} for smooth transition`
-          );
+          log.info(() => ({
+            message: `Migrating config from ${oldDir} to ${newDir} for smooth transition`,
+          }));
 
           // Use fs-extra style recursive copy
           await copyDirectory(oldDir, newDir);
 
-          log.info(`Successfully migrated config to ${newDir}`);
+          log.info(() => ({
+            message: `Successfully migrated config to ${newDir}`,
+          }));
         } catch (error) {
-          log.error(`Failed to migrate config from ${oldDir}:`, error);
+          log.error(() => ({
+            message: `Failed to migrate config from ${oldDir}:`,
+            error,
+          }));
           // Don't throw - allow the app to continue with the old config
         }
       }
@@ -83,14 +88,19 @@ export namespace Config {
         .catch(() => false);
 
       if (oldGlobalExists && !newGlobalExists) {
-        log.info(
-          `Migrating global config from ${oldGlobalPath} to ${newGlobalPath}`
-        );
+        log.info(() => ({
+          message: `Migrating global config from ${oldGlobalPath} to ${newGlobalPath}`,
+        }));
         await copyDirectory(oldGlobalPath, newGlobalPath);
-        log.info(`Successfully migrated global config to ${newGlobalPath}`);
+        log.info(() => ({
+          message: `Successfully migrated global config to ${newGlobalPath}`,
+        }));
       }
     } catch (error) {
-      log.error('Failed to migrate global config:', error);
+      log.error(() => ({
+        message: 'Failed to migrate global config:',
+        error,
+      }));
       // Don't throw - allow the app to continue
     }
   }
@@ -126,7 +136,10 @@ export namespace Config {
     // Override with custom config if provided
     if (Flag.OPENCODE_CONFIG) {
       result = mergeDeep(result, await loadFile(Flag.OPENCODE_CONFIG));
-      log.debug('loaded custom config', { path: Flag.OPENCODE_CONFIG });
+      log.debug(() => ({
+        message: 'loaded custom config',
+        path: Flag.OPENCODE_CONFIG,
+      }));
     }
 
     for (const file of ['opencode.jsonc', 'opencode.json']) {
@@ -142,7 +155,9 @@ export namespace Config {
 
     if (Flag.OPENCODE_CONFIG_CONTENT) {
       result = mergeDeep(result, JSON.parse(Flag.OPENCODE_CONFIG_CONTENT));
-      log.debug('loaded custom config from OPENCODE_CONFIG_CONTENT');
+      log.debug(() => ({
+        message: 'loaded custom config from OPENCODE_CONFIG_CONTENT',
+      }));
     }
 
     for (const [key, value] of Object.entries(auth)) {
@@ -182,12 +197,11 @@ export namespace Config {
     const filteredDirs = foundDirs.filter((dir) => {
       // If .link-assistant-agent exists, exclude .opencode directories
       if (hasNewConfig && dir.endsWith('.opencode')) {
-        log.debug(
-          'Skipping .opencode directory (using .link-assistant-agent):',
-          {
-            path: dir,
-          }
-        );
+        log.debug(() => ({
+          message:
+            'Skipping .opencode directory (using .link-assistant-agent):',
+          path: dir,
+        }));
         return false;
       }
       return true;
@@ -197,9 +211,10 @@ export namespace Config {
 
     if (Flag.OPENCODE_CONFIG_DIR) {
       directories.push(Flag.OPENCODE_CONFIG_DIR);
-      log.debug('loading config from LINK_ASSISTANT_AGENT_CONFIG_DIR', {
+      log.debug(() => ({
+        message: 'loading config from LINK_ASSISTANT_AGENT_CONFIG_DIR',
         path: Flag.OPENCODE_CONFIG_DIR,
-      });
+      }));
     }
 
     const promises: Promise<void>[] = [];
@@ -212,7 +227,9 @@ export namespace Config {
         dir === Flag.OPENCODE_CONFIG_DIR
       ) {
         for (const file of ['opencode.jsonc', 'opencode.json']) {
-          log.debug(`loading config from ${path.join(dir, file)}`);
+          log.debug(() => ({
+            message: `loading config from ${path.join(dir, file)}`,
+          }));
           result = mergeDeep(result, await loadFile(path.join(dir, file)));
           // to satisy the type checker
           result.agent ??= {};
@@ -932,7 +949,7 @@ export namespace Config {
   });
 
   async function loadFile(filepath: string): Promise<Info> {
-    log.info('loading', { path: filepath });
+    log.info(() => ({ message: 'loading', path: filepath }));
     let text = await Bun.file(filepath)
       .text()
       .catch((err) => {

package/src/file/ripgrep.ts

@@ -275,7 +275,7 @@ export namespace Ripgrep {
   }
 
   export async function tree(input: { cwd: string; limit?: number }) {
-    log.info('tree', input);
+    log.info(() => ({ message: 'tree', ...input }));
     const files = await Array.fromAsync(Ripgrep.files({ cwd: input.cwd }));
     interface Node {
       path: string[];

package/src/file/time.ts

@@ -15,7 +15,7 @@ export namespace FileTime {
   });
 
   export function read(sessionID: string, file: string) {
-    log.info('read', { sessionID, file });
+    log.info(() => ({ message: 'read', sessionID, file }));
     const { read } = state();
     read[sessionID] = read[sessionID] || {};
     read[sessionID][file] = new Date();