@link-assistant/agent 0.5.3 → 0.6.1

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();

package/src/file/watcher.ts

@@ -36,7 +36,7 @@ export namespace FileWatcher {
   const state = Instance.state(
     async () => {
       if (Instance.project.vcs !== 'git') return {};
-      log.info('init');
+      log.info(() => ({ message: 'init' }));
       const cfg = await Config.get();
       const backend = (() => {
         if (process.platform === 'win32') return 'windows';
@@ -44,18 +44,23 @@ export namespace FileWatcher {
         if (process.platform === 'linux') return 'inotify';
       })();
       if (!backend) {
-        log.error('watcher backend not supported', {
+        log.error(() => ({
+          message: 'watcher backend not supported',
           platform: process.platform,
-        });
+        }));
         return {};
       }
-      log.info('watcher backend', { platform: process.platform, backend });
+      log.info(() => ({
+        message: 'watcher backend',
+        platform: process.platform,
+        backend,
+      }));
       const sub = await watcher().subscribe(
         Instance.directory,
         (err, evts) => {
           if (err) return;
           for (const evt of evts) {
-            log.info('event', evt);
+            log.info(() => ({ message: 'event', ...evt }));
             if (evt.type === 'create')
               Bus.publish(Event.Updated, { file: evt.path, event: 'add' });
             if (evt.type === 'update')

package/src/format/index.ts

@@ -29,7 +29,7 @@ export namespace Format {
 
     const formatters: Record<string, Formatter.Info> = {};
     if (cfg.formatter === false) {
-      log.info('all formatters are disabled');
+      log.info(() => ({ message: 'all formatters are disabled' }));
       return {
         enabled,
         formatters,
@@ -77,10 +77,10 @@ export namespace Format {
     const formatters = await state().then((x) => x.formatters);
     const result = [];
     for (const item of Object.values(formatters)) {
-      log.info('checking', { name: item.name, ext });
+      log.info(() => ({ message: 'checking', name: item.name, ext }));
       if (!item.extensions.includes(ext)) continue;
       if (!(await isEnabled(item))) continue;
-      log.info('enabled', { name: item.name, ext });
+      log.info(() => ({ message: 'enabled', name: item.name, ext }));
       result.push(item);
     }
     return result;
@@ -101,14 +101,14 @@ export namespace Format {
   }
 
   export function init() {
-    log.info('init');
+    log.info(() => ({ message: 'init' }));
     Bus.subscribe(File.Event.Edited, async (payload) => {
       const file = payload.properties.file;
-      log.info('formatting', { file });
+      log.info(() => ({ message: 'formatting', file }));
       const ext = path.extname(file);
 
       for (const item of await getFormatter(ext)) {
-        log.info('running', { command: item.command });
+        log.info(() => ({ message: 'running', command: item.command }));
         try {
           const proc = Bun.spawn({
             cmd: item.command.map((x) => x.replace('$FILE', file)),
@@ -119,17 +119,19 @@ export namespace Format {
           });
           const exit = await proc.exited;
           if (exit !== 0)
-            log.error('failed', {
+            log.error(() => ({
+              message: 'failed',
               command: item.command,
               ...item.environment,
-            });
+            }));
         } catch (error) {
-          log.error('failed to format file', {
+          log.error(() => ({
+            message: 'failed to format file',
             error,
             command: item.command,
             ...item.environment,
             file,
-          });
+          }));
         }
       }
     });

package/src/index.js

@@ -246,22 +246,19 @@ async function readSystemMessages(argv) {
 }
 
 async function runAgentMode(argv, request) {
-  // Note: verbose flag and logging are now initialized in middleware
-  // See main() function for the middleware that sets up Flag and Log.init()
-
-  // Log version and command info in verbose mode
-  if (Flag.OPENCODE_VERBOSE) {
-    console.error(`Agent version: ${pkg.version}`);
-    console.error(`Command: ${process.argv.join(' ')}`);
-    console.error(`Working directory: ${process.cwd()}`);
-    console.error(`Script path: ${import.meta.path}`);
-  }
-
-  // Log dry-run mode if enabled
+  // Log version and command info in verbose mode using lazy logging
+  Log.Default.lazy.info(() => ({
+    message: 'Agent started',
+    version: pkg.version,
+    command: process.argv.join(' '),
+    workingDirectory: process.cwd(),
+    scriptPath: import.meta.path,
+  }));
   if (Flag.OPENCODE_DRY_RUN) {
-    console.error(
-      `[DRY RUN MODE] No actual API calls or package installations will be made`
-    );
+    Log.Default.lazy.info(() => ({
+      message: 'Dry run mode enabled',
+      mode: 'dry-run',
+    }));
   }
 
   const { providerID, modelID } = await parseModelConfig(argv);
@@ -269,9 +266,11 @@ async function runAgentMode(argv, request) {
   // Validate and get JSON standard
   const jsonStandard = argv['json-standard'];
   if (!isValidJsonStandard(jsonStandard)) {
-    console.error(
-      `Invalid JSON standard: ${jsonStandard}. Use "opencode" or "claude".`
-    );
+    outputStatus({
+      type: 'error',
+      errorType: 'ValidationError',
+      message: `Invalid JSON standard: ${jsonStandard}. Use "opencode" or "claude".`,
+    });
     process.exit(1);
   }
 
@@ -317,24 +316,20 @@ async function runAgentMode(argv, request) {
  * @param {object} argv - Command line arguments
  */
 async function runContinuousAgentMode(argv) {
-  // Note: verbose flag and logging are now initialized in middleware
-  // See main() function for the middleware that sets up Flag and Log.init()
-
   const compactJson = argv['compact-json'] === true;
-
-  // Log version and command info in verbose mode
-  if (Flag.OPENCODE_VERBOSE) {
-    console.error(`Agent version: ${pkg.version}`);
-    console.error(`Command: ${process.argv.join(' ')}`);
-    console.error(`Working directory: ${process.cwd()}`);
-    console.error(`Script path: ${import.meta.path}`);
-  }
-
-  // Log dry-run mode if enabled
+  // Log version and command info in verbose mode using lazy logging
+  Log.Default.lazy.info(() => ({
+    message: 'Agent started (continuous mode)',
+    version: pkg.version,
+    command: process.argv.join(' '),
+    workingDirectory: process.cwd(),
+    scriptPath: import.meta.path,
+  }));
   if (Flag.OPENCODE_DRY_RUN) {
-    console.error(
-      `[DRY RUN MODE] No actual API calls or package installations will be made`
-    );
+    Log.Default.lazy.info(() => ({
+      message: 'Dry run mode enabled',
+      mode: 'dry-run',
+    }));
   }
 
   const { providerID, modelID } = await parseModelConfig(argv);
@@ -935,7 +930,7 @@ async function main() {
         }
 
         // Initialize logging system
-        // - If verbose: print logs to stderr for debugging
+        // - If verbose: print logs to stderr for debugging in JSON format
         // - Otherwise: write logs to file to keep CLI output clean
         await Log.init({
           print: Flag.OPENCODE_VERBOSE,

package/src/mcp/index.ts

@@ -81,9 +81,10 @@ export namespace MCP {
       await Promise.all(
         Object.values(state.clients).map((client) =>
           client.close().catch((error) => {
-            log.error('Failed to close MCP client', {
+            log.error(() => ({
+              message: 'Failed to close MCP client',
               error,
-            });
+            }));
           })
         )
       );
@@ -119,10 +120,10 @@ export namespace MCP {
 
   async function create(key: string, mcp: Config.Mcp) {
     if (mcp.enabled === false) {
-      log.info('mcp server disabled', { key });
+      log.info(() => ({ message: 'mcp server disabled', key }));
       return;
     }
-    log.info('found', { key, type: mcp.type });
+    log.info(() => ({ message: 'found', key, type: mcp.type }));
     let mcpClient: MCPClient | undefined;
     let status: Status | undefined = undefined;
 
@@ -152,7 +153,11 @@ export namespace MCP {
           transport,
         })
           .then((client) => {
-            log.info('connected', { key, transport: name });
+            log.info(() => ({
+              message: 'connected',
+              key,
+              transport: name,
+            }));
             mcpClient = client;
             status = { status: 'connected' };
             return true;
@@ -160,12 +165,13 @@ export namespace MCP {
           .catch((error) => {
             lastError =
               error instanceof Error ? error : new Error(String(error));
-            log.debug('transport connection failed', {
+            log.debug(() => ({
+              message: 'transport connection failed',
               key,
               transport: name,
               url: mcp.url,
               error: lastError.message,
-            });
+            }));
             status = {
               status: 'failed' as const,
               error: lastError.message,
@@ -198,11 +204,12 @@ export namespace MCP {
           };
         })
         .catch((error) => {
-          log.error('local mcp startup failed', {
+          log.error(() => ({
+            message: 'local mcp startup failed',
             key,
             command: mcp.command,
             error: error instanceof Error ? error.message : String(error),
-          });
+          }));
           status = {
             status: 'failed' as const,
             error: error instanceof Error ? error.message : String(error),
@@ -228,14 +235,19 @@ export namespace MCP {
       mcpClient.tools(),
       mcp.timeout ?? 5000
     ).catch((err) => {
-      log.error('failed to get tools from client', { key, error: err });
+      log.error(() => ({
+        message: 'failed to get tools from client',
+        key,
+        error: err,
+      }));
       return undefined;
     });
     if (!result) {
       await mcpClient.close().catch((error) => {
-        log.error('Failed to close MCP client', {
+        log.error(() => ({
+          message: 'Failed to close MCP client',
           error,
-        });
+        }));
       });
       status = {
         status: 'failed',
@@ -250,10 +262,11 @@ export namespace MCP {
       };
     }
 
-    log.info('create() successfully created client', {
+    log.info(() => ({
+      message: 'create() successfully created client',
       key,
       toolCount: Object.keys(result).length,
-    });
+    }));
     return {
       mcpClient,
       status,
@@ -274,7 +287,11 @@ export namespace MCP {
     const clientsSnapshot = await clients();
     for (const [clientName, client] of Object.entries(clientsSnapshot)) {
       const tools = await client.tools().catch((e) => {
-        log.error('failed to get tools', { clientName, error: e.message });
+        log.error(() => ({
+          message: 'failed to get tools',
+          clientName,
+          error: e.message,
+        }));
         const failedStatus = {
           status: 'failed' as const,
           error: e instanceof Error ? e.message : String(e),

package/src/patch/index.ts

@@ -532,13 +532,13 @@ export namespace Patch {
 
           await fs.writeFile(hunk.path, hunk.contents, 'utf-8');
           added.push(hunk.path);
-          log.info(`Added file: ${hunk.path}`);
+          log.info(() => ({ message: 'Added file', path: hunk.path }));
           break;
 
         case 'delete':
           await fs.unlink(hunk.path);
           deleted.push(hunk.path);
-          log.info(`Deleted file: ${hunk.path}`);
+          log.info(() => ({ message: 'Deleted file', path: hunk.path }));
           break;
 
         case 'update':
@@ -557,12 +557,16 @@ export namespace Patch {
             await fs.writeFile(hunk.move_path, fileUpdate.content, 'utf-8');
             await fs.unlink(hunk.path);
             modified.push(hunk.move_path);
-            log.info(`Moved file: ${hunk.path} -> ${hunk.move_path}`);
+            log.info(() => ({
+              message: 'Moved file',
+              from: hunk.path,
+              to: hunk.move_path,
+            }));
           } else {
             // Regular update
             await fs.writeFile(hunk.path, fileUpdate.content, 'utf-8');
             modified.push(hunk.path);
-            log.info(`Updated file: ${hunk.path}`);
+            log.info(() => ({ message: 'Updated file', path: hunk.path }));
           }
           break;
       }

package/src/project/project.ts

@@ -24,7 +24,7 @@ export namespace Project {
   export type Info = z.infer<typeof Info>;
 
   export async function fromDirectory(directory: string) {
-    log.info('fromDirectory', { directory });
+    log.info(() => ({ message: 'fromDirectory', directory }));
     const matches = Filesystem.up({ targets: ['.git'], start: directory });
     const git = await matches.next().then((x) => x.value);
     await matches.return();