@link-assistant/agent 0.5.2 → 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/cache.ts

@@ -0,0 +1,259 @@
+/**
+ * Cache Provider - A synthetic provider for caching API responses
+ *
+ * This provider caches API responses to enable deterministic testing.
+ * When a response is not cached, it falls back to the echo provider behavior.
+ * Cached responses are stored using Links Notation format (.lino files).
+ *
+ * Usage:
+ *   agent --model link-assistant/cache/opencode -p "hello"  # Uses cached responses
+ *
+ * Cache location: ./data/api-cache/{provider}/{model}/
+ * Format: Links Notation files with .lino extension
+ *
+ * @see https://github.com/link-assistant/agent/issues/89
+ * @see https://github.com/link-foundation/lino-objects-codec
+ */
+
+import type { LanguageModelV2, LanguageModelV2CallOptions } from 'ai';
+import { Log } from '../util/log';
+import { createEchoModel } from './echo';
+import { readFileSync, writeFileSync, existsSync, mkdirSync } from 'fs';
+import { dirname, join } from 'path';
+import { fileURLToPath } from 'url';
+// @ts-ignore - lino-objects-codec is a JavaScript library
+import { encode, decode } from 'lino-objects-codec';
+
+const log = Log.create({ service: 'provider.cache' });
+
+const __dirname = dirname(fileURLToPath(import.meta.url));
+const CACHE_ROOT = join(__dirname, '../../data/api-cache');
+
+/**
+ * Generate a cache key from the prompt
+ */
+function generateCacheKey(
+  prompt: LanguageModelV2CallOptions['prompt']
+): string {
+  // Simple hash of the prompt content
+  const content = JSON.stringify(prompt);
+  let hash = 0;
+  for (let i = 0; i < content.length; i++) {
+    const char = content.charCodeAt(i);
+    hash = (hash << 5) - hash + char;
+    hash = hash & hash; // Convert to 32-bit integer
+  }
+  return Math.abs(hash).toString(36);
+}
+
+/**
+ * Get cache file path for a provider/model combination
+ * Uses .lino extension for Links Notation format
+ */
+function getCachePath(provider: string, model: string, key: string): string {
+  return join(CACHE_ROOT, provider, model, `${key}.lino`);
+}
+
+/**
+ * Generate a unique ID for streaming parts
+ */
+function generatePartId(): string {
+  return `cache_${Date.now()}_${Math.random().toString(36).substring(2, 8)}`;
+}
+
+/**
+ * Load cached response from file using Links Notation format
+ */
+function loadCachedResponse(filePath: string): any | null {
+  try {
+    if (!existsSync(filePath)) {
+      return null;
+    }
+    const content = readFileSync(filePath, 'utf8');
+    // Decode from Links Notation format
+    return decode({ notation: content });
+  } catch (error: any) {
+    log.warn('Failed to load cached response', {
+      filePath,
+      error: error.message,
+    });
+    return null;
+  }
+}
+
+/**
+ * Save response to cache file using Links Notation format
+ */
+function saveCachedResponse(filePath: string, response: any): void {
+  try {
+    const dir = dirname(filePath);
+    if (!existsSync(dir)) {
+      mkdirSync(dir, { recursive: true });
+    }
+    // Encode to Links Notation format
+    const encoded = encode({ obj: response });
+    writeFileSync(filePath, encoded, 'utf8');
+    log.info('Saved cached response', { filePath });
+  } catch (error: any) {
+    log.warn('Failed to save cached response', {
+      filePath,
+      error: error.message,
+    });
+  }
+}
+
+/**
+ * Creates a cache language model that stores/retrieves responses
+ * Implements LanguageModelV2 interface for AI SDK 6.x compatibility
+ */
+export function createCacheModel(
+  providerId: string,
+  modelId: string
+): LanguageModelV2 {
+  const model: LanguageModelV2 = {
+    specificationVersion: 'v2',
+    provider: 'link-assistant',
+    modelId: `${providerId}/${modelId}`,
+
+    // No external URLs are supported by this synthetic provider
+    supportedUrls: {},
+
+    async doGenerate(options: LanguageModelV2CallOptions) {
+      const cacheKey = generateCacheKey(options.prompt);
+      const cachePath = getCachePath(providerId, modelId, cacheKey);
+
+      // Try to load from cache first
+      const cached = loadCachedResponse(cachePath);
+      if (cached) {
+        log.info('Using cached response', { providerId, modelId, cacheKey });
+        return cached;
+      }
+
+      // Fall back to echo behavior
+      log.info('No cached response, using echo fallback', {
+        providerId,
+        modelId,
+        cacheKey,
+      });
+      const echoModel = createEchoModel(`${providerId}/${modelId}`);
+      const response = await echoModel.doGenerate(options);
+
+      // Save to cache for future use
+      saveCachedResponse(cachePath, response);
+
+      return response;
+    },
+
+    async doStream(options: LanguageModelV2CallOptions) {
+      const cacheKey = generateCacheKey(options.prompt);
+      const cachePath = getCachePath(providerId, modelId, cacheKey);
+
+      // Try to load from cache first
+      const cached = loadCachedResponse(cachePath);
+      if (cached) {
+        log.info('Using cached streaming response', {
+          providerId,
+          modelId,
+          cacheKey,
+        });
+
+        // For cached responses, we need to simulate streaming
+        // Extract the text from the cached response
+        const echoText =
+          cached.content?.[0]?.text || cached.text || 'Cached response';
+        const textPartId = generatePartId();
+
+        // Create a ReadableStream with LanguageModelV2StreamPart format
+        const stream = new ReadableStream({
+          async start(controller) {
+            // Emit text-start
+            controller.enqueue({
+              type: 'text-start',
+              id: textPartId,
+              providerMetadata: undefined,
+            });
+
+            // Emit the text in chunks for realistic streaming behavior
+            const chunkSize = 10;
+            for (let i = 0; i < echoText.length; i += chunkSize) {
+              const chunk = echoText.slice(i, i + chunkSize);
+              controller.enqueue({
+                type: 'text-delta',
+                id: textPartId,
+                delta: chunk,
+                providerMetadata: undefined,
+              });
+            }
+
+            // Emit text-end
+            controller.enqueue({
+              type: 'text-end',
+              id: textPartId,
+              providerMetadata: undefined,
+            });
+
+            // Emit finish event
+            controller.enqueue({
+              type: 'finish',
+              finishReason: 'stop',
+              usage: cached.usage || {
+                promptTokens: Math.ceil(echoText.length / 4),
+                completionTokens: Math.ceil(echoText.length / 4),
+              },
+              providerMetadata: undefined,
+            });
+
+            controller.close();
+          },
+        });
+
+        return {
+          stream,
+          request: undefined,
+          response: undefined,
+          warnings: [],
+        };
+      }
+
+      // Fall back to echo streaming behavior
+      log.info('No cached streaming response, using echo fallback', {
+        providerId,
+        modelId,
+        cacheKey,
+      });
+      const echoModel = createEchoModel(`${providerId}/${modelId}`);
+      const response = await echoModel.doStream(options);
+
+      // Note: We don't cache streaming responses as they're consumed immediately
+      return response;
+    },
+  };
+
+  return model;
+}
+
+/**
+ * Cache provider factory function
+ */
+export function createCacheProvider(options?: { name?: string }) {
+  return {
+    languageModel(modelId: string): LanguageModelV2 {
+      // Parse provider/model from modelId like "opencode/grok-code"
+      const parts = modelId.split('/');
+      if (parts.length < 2) {
+        throw new Error(
+          `Invalid cache model ID: ${modelId}. Expected format: provider/model`
+        );
+      }
+      const [providerId, ...modelParts] = parts;
+      const actualModelId = modelParts.join('/');
+
+      return createCacheModel(providerId, actualModelId);
+    },
+    textEmbeddingModel() {
+      throw new Error('Cache provider does not support text embeddings');
+    },
+  };
+}
+
+export const cacheProvider = createCacheProvider();