@link-assistant/agent 0.5.3 → 0.6.0

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

package/src/project/state.ts

@@ -36,16 +36,20 @@ export namespace State {
     const entries = recordsByKey.get(key);
     if (!entries) return;
 
-    log.info('waiting for state disposal to complete', { key });
+    log.info(() => ({
+      message: 'waiting for state disposal to complete',
+      key,
+    }));
 
     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 }
-        );
+        log.warn(() => ({
+          message:
+            '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();
 
@@ -56,7 +60,11 @@ export namespace State {
       const task = Promise.resolve(entry.state)
         .then((state) => entry.dispose!(state))
         .catch((error) => {
-          log.error('Error while disposing state:', { error, key });
+          log.error(() => ({
+            message: 'Error while disposing state',
+            error,
+            key,
+          }));
         });
 
       tasks.push(task);
@@ -64,6 +72,6 @@ export namespace State {
     await Promise.all(tasks);
     recordsByKey.delete(key);
     disposalFinished = true;
-    log.info('state disposal completed', { key });
+    log.info(() => ({ message: 'state disposal completed', key }));
   }
 }

package/src/provider/models.ts

@@ -78,18 +78,17 @@ export namespace ModelsDev {
 
   export async function refresh() {
     const file = Bun.file(filepath);
-    log.info('refreshing', {
-      file,
-    });
+    log.info(() => ({ message: 'refreshing', file }));
     const result = await fetch('https://models.dev/api.json', {
       headers: {
         'User-Agent': 'agent-cli/1.0.0',
       },
       signal: AbortSignal.timeout(10 * 1000),
     }).catch((e) => {
-      log.error('Failed to fetch models.dev', {
+      log.error(() => ({
+        message: 'Failed to fetch models.dev',
         error: e,
-      });
+      }));
     });
     if (result && result.ok) await Bun.write(file, await result.text());
   }

package/src/provider/provider.ts

@@ -37,7 +37,7 @@ export namespace Provider {
       // Check if OAuth credentials are available via the auth plugin
       const auth = await Auth.get('anthropic');
       if (auth?.type === 'oauth') {
-        log.info('using anthropic oauth credentials');
+        log.info(() => ({ message: 'using anthropic oauth credentials' }));
         const loaderFn = await AuthPlugins.getLoader('anthropic');
         if (loaderFn) {
           const result = await loaderFn(() => Auth.get('anthropic'), input);
@@ -330,7 +330,7 @@ export namespace Provider {
     google: async (input) => {
       const auth = await Auth.get('google');
       if (auth?.type === 'oauth') {
-        log.info('using google oauth credentials');
+        log.info(() => ({ message: 'using google oauth credentials' }));
         const loaderFn = await AuthPlugins.getLoader('google');
         if (loaderFn) {
           const result = await loaderFn(() => Auth.get('google'), input);
@@ -355,7 +355,9 @@ export namespace Provider {
     'github-copilot': async (input) => {
       const auth = await Auth.get('github-copilot');
       if (auth?.type === 'oauth') {
-        log.info('using github copilot oauth credentials');
+        log.info(() => ({
+          message: 'using github copilot oauth credentials',
+        }));
         const loaderFn = await AuthPlugins.getLoader('github-copilot');
         if (loaderFn) {
           const result = await loaderFn(
@@ -383,7 +385,9 @@ export namespace Provider {
     'github-copilot-enterprise': async (input) => {
       const auth = await Auth.get('github-copilot-enterprise');
       if (auth?.type === 'oauth') {
-        log.info('using github copilot enterprise oauth credentials');
+        log.info(() => ({
+          message: 'using github copilot enterprise oauth credentials',
+        }));
         const loaderFn = await AuthPlugins.getLoader('github-copilot');
         if (loaderFn) {
           const result = await loaderFn(
@@ -435,7 +439,10 @@ export namespace Provider {
         return { autoload: false };
       }
 
-      log.info('using claude oauth credentials', { source: tokenSource });
+      log.info(() => ({
+        message: 'using claude oauth credentials',
+        source: tokenSource,
+      }));
 
       // Create authenticated fetch with Bearer token and OAuth beta header
       const customFetch = ClaudeOAuth.createAuthenticatedFetch(oauthToken);
@@ -537,7 +544,7 @@ export namespace Provider {
     // Maps `${provider}/${key}` to the provider’s actual model ID for custom aliases.
     const realIdByKey = new Map<string, string>();
 
-    log.info('init');
+    log.info(() => ({ message: 'init' }));
 
     function mergeProvider(
       id: string,
@@ -783,7 +790,7 @@ export namespace Provider {
         delete providers[providerID];
         continue;
       }
-      log.info('found', { providerID });
+      log.info(() => ({ message: 'found', providerID }));
     }
 
     return {
@@ -818,19 +825,21 @@ export namespace Provider {
 
       let installedPath: string;
       if (!pkg.startsWith('file://')) {
-        log.info('installing provider package', {
+        log.info(() => ({
+          message: 'installing provider package',
           providerID: provider.id,
           pkg,
           version: 'latest',
-        });
+        }));
         installedPath = await BunProc.install(pkg, 'latest');
-        log.info('provider package installed successfully', {
+        log.info(() => ({
+          message: 'provider package installed successfully',
           providerID: provider.id,
           pkg,
           installedPath,
-        });
+        }));
       } else {
-        log.info('loading local provider', { pkg });
+        log.info(() => ({ message: 'loading local provider', pkg }));
         installedPath = pkg;
       }
 
@@ -876,13 +885,14 @@ export namespace Provider {
       s.sdk.set(key, loaded);
       return loaded as SDK;
     })().catch((e) => {
-      log.error('provider initialization failed', {
+      log.error(() => ({
+        message: 'provider initialization failed',
         providerID: provider.id,
         pkg: model.provider?.npm ?? provider.npm ?? provider.id,
         error: e instanceof Error ? e.message : String(e),
         stack: e instanceof Error ? e.stack : undefined,
         cause: e instanceof Error && e.cause ? String(e.cause) : undefined,
-      });
+      }));
       throw new InitError({ providerID: provider.id }, { cause: e });
     });
   }
@@ -896,10 +906,7 @@ export namespace Provider {
     const s = await state();
     if (s.models.has(key)) return s.models.get(key)!;
 
-    log.info('getModel', {
-      providerID,
-      modelID,
-    });
+    log.info(() => ({ message: 'getModel', providerID, modelID }));
 
     const provider = s.providers[providerID];
     if (!provider) throw new ModelNotFoundError({ providerID, modelID });
@@ -929,7 +936,7 @@ export namespace Provider {
           ? await provider.getModel(sdk, realID, provider.options)
           : sdk.languageModel(realID);
       }
-      log.info('found', { providerID, modelID });
+      log.info(() => ({ message: 'found', providerID, modelID }));
       s.models.set(key, {
         providerID,
         modelID,
@@ -1032,10 +1039,11 @@ export namespace Provider {
     if (opencodeProvider) {
       const [model] = sort(Object.values(opencodeProvider.info.models));
       if (model) {
-        log.info('using opencode provider as default', {
+        log.info(() => ({
+          message: 'using opencode provider as default',
           provider: opencodeProvider.info.id,
           model: model.id,
-        });
+        }));
         return {
           providerID: opencodeProvider.info.id,
           modelID: model.id,

package/src/server/server.ts

@@ -55,9 +55,7 @@ export namespace Server {
   export const App = lazy(() =>
     app
       .onError((err, c) => {
-        log.error('failed', {
-          error: err,
-        });
+        log.error(() => ({ message: 'failed', error: err }));
         if (err instanceof NamedError) {
           let status: ContentfulStatusCode;
           if (err instanceof Storage.NotFoundError) status = 404;
@@ -71,10 +69,11 @@ export namespace Server {
         });
       })
       .use(async (c, next) => {
-        log.info('request', {
+        log.info(() => ({
+          message: 'request',
           method: c.req.method,
           path: c.req.path,
-        });
+        }));
         const timer = log.time('request', {
           method: c.req.method,
           path: c.req.path,

package/src/session/agent.js

@@ -96,8 +96,22 @@ export class Agent {
             const errorTime = Date.now();
             const callID = `call_${Math.floor(Math.random() * 100000000)}`;
 
-            // Log full error to stderr for debugging
-            console.error('Tool execution error:', error);
+            // Log full error to stderr for debugging in JSON format
+            console.error(
+              JSON.stringify({
+                log: {
+                  level: 'error',
+                  timestamp: new Date().toISOString(),
+                  message: 'Tool execution error',
+                  tool: tool.name,
+                  error: {
+                    name: error.name,
+                    message: error.message,
+                    stack: error.stack,
+                  },
+                },
+              })
+            );
 
             // Emit tool_use event with error
             this.emitEvent('tool_use', {

package/src/session/compaction.ts

@@ -52,7 +52,7 @@ export namespace SessionCompaction {
   // tool calls that are no longer relevant.
   export async function prune(input: { sessionID: string }) {
     if (Flag.OPENCODE_DISABLE_PRUNE) return;
-    log.info('pruning');
+    log.info(() => ({ message: 'pruning' }));
     const msgs = await Session.messages({ sessionID: input.sessionID });
     let total = 0;
     let pruned = 0;
@@ -78,7 +78,7 @@ export namespace SessionCompaction {
           }
       }
     }
-    log.info('found', { pruned, total });
+    log.info(() => ({ message: 'found', pruned, total }));
     if (pruned > PRUNE_MINIMUM) {
       for (const part of toPrune) {
         if (part.state.status === 'completed') {
@@ -86,7 +86,7 @@ export namespace SessionCompaction {
           await Session.updatePart(part);
         }
       }
-      log.info('pruned', { count: toPrune.length });
+      log.info(() => ({ message: 'pruned', count: toPrune.length }));
     }
   }
 
@@ -139,9 +139,7 @@ export namespace SessionCompaction {
     const result = await processor.process(() =>
       streamText({
         onError(error) {
-          log.error('stream error', {
-            error,
-          });
+          log.error(() => ({ message: 'stream error', error }));
         },
         // set to 0, we handle loop
         maxRetries: 0,