@link-assistant/agent 0.0.8 → 0.0.11

package/src/json-standard/index.ts

@@ -0,0 +1,173 @@
+/**
+ * JSON Standard Format Handlers
+ *
+ * Provides adapters for different JSON output formats:
+ * - opencode: OpenCode format (default) - pretty-printed JSON events
+ * - claude: Claude CLI stream-json format - NDJSON (newline-delimited JSON)
+ */
+
+import { EOL } from 'os';
+
+export type JsonStandard = 'opencode' | 'claude';
+
+/**
+ * OpenCode JSON event types
+ */
+export interface OpenCodeEvent {
+  type: 'step_start' | 'step_finish' | 'text' | 'tool_use' | 'error';
+  timestamp: number;
+  sessionID: string;
+  part?: Record<string, unknown>;
+  error?: string | Record<string, unknown>;
+}
+
+/**
+ * Claude JSON event types (stream-json format)
+ */
+export interface ClaudeEvent {
+  type: 'init' | 'message' | 'tool_use' | 'tool_result' | 'result';
+  timestamp?: string;
+  session_id?: string;
+  role?: 'assistant' | 'user';
+  content?: Array<{
+    type: 'text' | 'tool_use';
+    text?: string;
+    name?: string;
+    input?: unknown;
+  }>;
+  output?: string;
+  name?: string;
+  input?: unknown;
+  tool_use_id?: string;
+  status?: 'success' | 'error';
+  duration_ms?: number;
+  model?: string;
+}
+
+/**
+ * Serialize JSON output based on the selected standard
+ */
+export function serializeOutput(
+  event: OpenCodeEvent | ClaudeEvent,
+  standard: JsonStandard
+): string {
+  if (standard === 'claude') {
+    // NDJSON format - compact, one line
+    return JSON.stringify(event) + EOL;
+  }
+  // OpenCode format - pretty-printed
+  return JSON.stringify(event, null, 2) + EOL;
+}
+
+/**
+ * Convert OpenCode event to Claude event format
+ */
+export function convertOpenCodeToClaude(
+  event: OpenCodeEvent,
+  startTime: number
+): ClaudeEvent | null {
+  const timestamp = new Date(event.timestamp).toISOString();
+  const session_id = event.sessionID;
+
+  switch (event.type) {
+    case 'step_start':
+      return {
+        type: 'init',
+        timestamp,
+        session_id,
+      };
+
+    case 'text':
+      if (event.part && typeof event.part.text === 'string') {
+        return {
+          type: 'message',
+          timestamp,
+          session_id,
+          role: 'assistant',
+          content: [
+            {
+              type: 'text',
+              text: event.part.text,
+            },
+          ],
+        };
+      }
+      return null;
+
+    case 'tool_use':
+      if (event.part && event.part.state) {
+        const state = event.part.state as Record<string, unknown>;
+        const tool = state.tool as Record<string, unknown> | undefined;
+        return {
+          type: 'tool_use',
+          timestamp,
+          session_id,
+          name: (tool?.name as string) || 'unknown',
+          input: tool?.parameters || {},
+          tool_use_id: event.part.id as string,
+        };
+      }
+      return null;
+
+    case 'step_finish':
+      return {
+        type: 'result',
+        timestamp,
+        session_id,
+        status: 'success',
+        duration_ms: event.timestamp - startTime,
+      };
+
+    case 'error':
+      return {
+        type: 'result',
+        timestamp,
+        session_id,
+        status: 'error',
+        output:
+          typeof event.error === 'string'
+            ? event.error
+            : JSON.stringify(event.error),
+      };
+
+    default:
+      return null;
+  }
+}
+
+/**
+ * Create an event output handler based on the selected standard
+ */
+export function createEventHandler(standard: JsonStandard, sessionID: string) {
+  const startTime = Date.now();
+
+  return {
+    /**
+     * Format and output an event
+     */
+    output(event: OpenCodeEvent): void {
+      if (standard === 'claude') {
+        const claudeEvent = convertOpenCodeToClaude(event, startTime);
+        if (claudeEvent) {
+          process.stdout.write(serializeOutput(claudeEvent, standard));
+        }
+      } else {
+        process.stdout.write(serializeOutput(event, standard));
+      }
+    },
+
+    /**
+     * Get the start time for duration calculations
+     */
+    getStartTime(): number {
+      return startTime;
+    },
+  };
+}
+
+/**
+ * Validate JSON standard option
+ */
+export function isValidJsonStandard(value: string): value is JsonStandard {
+  return value === 'opencode' || value === 'claude';
+}

package/src/mcp/index.ts

@@ -1,135 +1,135 @@
-import { experimental_createMCPClient } from "@ai-sdk/mcp"
-import { type Tool } from "ai"
-import { StreamableHTTPClientTransport } from "@modelcontextprotocol/sdk/client/streamableHttp.js"
-import { SSEClientTransport } from "@modelcontextprotocol/sdk/client/sse.js"
-import { StdioClientTransport } from "@modelcontextprotocol/sdk/client/stdio.js"
-import { Config } from "../config/config"
-import { Log } from "../util/log"
-import { NamedError } from "../util/error"
-import z from "zod/v4"
-import { Instance } from "../project/instance"
-import { withTimeout } from "../util/timeout"
+import { experimental_createMCPClient } from '@ai-sdk/mcp';
+import { type Tool } from 'ai';
+import { StreamableHTTPClientTransport } from '@modelcontextprotocol/sdk/client/streamableHttp.js';
+import { SSEClientTransport } from '@modelcontextprotocol/sdk/client/sse.js';
+import { StdioClientTransport } from '@modelcontextprotocol/sdk/client/stdio.js';
+import { Config } from '../config/config';
+import { Log } from '../util/log';
+import { NamedError } from '../util/error';
+import z from 'zod/v4';
+import { Instance } from '../project/instance';
+import { withTimeout } from '../util/timeout';
 
 export namespace MCP {
-  const log = Log.create({ service: "mcp" })
+  const log = Log.create({ service: 'mcp' });
 
   export const Failed = NamedError.create(
-    "MCPFailed",
+    'MCPFailed',
     z.object({
       name: z.string(),
-    }),
-  )
+    })
+  );
 
-  type Client = Awaited<ReturnType<typeof experimental_createMCPClient>>
+  type Client = Awaited<ReturnType<typeof experimental_createMCPClient>>;
 
   export const Status = z
-    .discriminatedUnion("status", [
+    .discriminatedUnion('status', [
       z
         .object({
-          status: z.literal("connected"),
+          status: z.literal('connected'),
         })
         .meta({
-          ref: "MCPStatusConnected",
+          ref: 'MCPStatusConnected',
         }),
       z
         .object({
-          status: z.literal("disabled"),
+          status: z.literal('disabled'),
         })
         .meta({
-          ref: "MCPStatusDisabled",
+          ref: 'MCPStatusDisabled',
         }),
       z
         .object({
-          status: z.literal("failed"),
+          status: z.literal('failed'),
           error: z.string(),
         })
         .meta({
-          ref: "MCPStatusFailed",
+          ref: 'MCPStatusFailed',
         }),
     ])
     .meta({
-      ref: "MCPStatus",
-    })
-  export type Status = z.infer<typeof Status>
-  type MCPClient = Awaited<ReturnType<typeof experimental_createMCPClient>>
+      ref: 'MCPStatus',
+    });
+  export type Status = z.infer<typeof Status>;
+  type MCPClient = Awaited<ReturnType<typeof experimental_createMCPClient>>;
 
   const state = Instance.state(
     async () => {
-      const cfg = await Config.get()
-      const config = cfg.mcp ?? {}
-      const clients: Record<string, Client> = {}
-      const status: Record<string, Status> = {}
+      const cfg = await Config.get();
+      const config = cfg.mcp ?? {};
+      const clients: Record<string, Client> = {};
+      const status: Record<string, Status> = {};
 
       await Promise.all(
         Object.entries(config).map(async ([key, mcp]) => {
-          const result = await create(key, mcp).catch(() => undefined)
-          if (!result) return
+          const result = await create(key, mcp).catch(() => undefined);
+          if (!result) return;
 
-          status[key] = result.status
+          status[key] = result.status;
 
           if (result.mcpClient) {
-            clients[key] = result.mcpClient
+            clients[key] = result.mcpClient;
           }
-        }),
-      )
+        })
+      );
       return {
         status,
         clients,
-      }
+      };
     },
     async (state) => {
       await Promise.all(
         Object.values(state.clients).map((client) =>
           client.close().catch((error) => {
-            log.error("Failed to close MCP client", {
+            log.error('Failed to close MCP client', {
               error,
-            })
-          }),
-        ),
-      )
-    },
-  )
+            });
+          })
+        )
+      );
+    }
+  );
 
   export async function add(name: string, mcp: Config.Mcp) {
-    const s = await state()
-    const result = await create(name, mcp)
+    const s = await state();
+    const result = await create(name, mcp);
     if (!result) {
       const status = {
-        status: "failed" as const,
-        error: "unknown error",
-      }
-      s.status[name] = status
+        status: 'failed' as const,
+        error: 'unknown error',
+      };
+      s.status[name] = status;
       return {
         status,
-      }
+      };
     }
     if (!result.mcpClient) {
-      s.status[name] = result.status
+      s.status[name] = result.status;
       return {
         status: s.status,
-      }
+      };
     }
-    s.clients[name] = result.mcpClient
-    s.status[name] = result.status
+    s.clients[name] = result.mcpClient;
+    s.status[name] = result.status;
 
     return {
       status: s.status,
-    }
+    };
   }
 
   async function create(key: string, mcp: Config.Mcp) {
     if (mcp.enabled === false) {
-      log.info("mcp server disabled", { key })
-      return
+      log.info('mcp server disabled', { key });
+      return;
     }
-    log.info("found", { key, type: mcp.type })
-    let mcpClient: MCPClient | undefined
-    let status: Status | undefined = undefined
+    log.info('found', { key, type: mcp.type });
+    let mcpClient: MCPClient | undefined;
+    let status: Status | undefined = undefined;
 
-    if (mcp.type === "remote") {
+    if (mcp.type === 'remote') {
       const transports = [
         {
-          name: "StreamableHTTP",
+          name: 'StreamableHTTP',
           transport: new StreamableHTTPClientTransport(new URL(mcp.url), {
             requestInit: {
               headers: mcp.headers,
@@ -137,153 +137,160 @@ export namespace MCP {
           }),
         },
         {
-          name: "SSE",
+          name: 'SSE',
           transport: new SSEClientTransport(new URL(mcp.url), {
             requestInit: {
               headers: mcp.headers,
             },
           }),
         },
-      ]
-      let lastError: Error | undefined
+      ];
+      let lastError: Error | undefined;
       for (const { name, transport } of transports) {
         const result = await experimental_createMCPClient({
-          name: "opencode",
+          name: 'opencode',
           transport,
         })
           .then((client) => {
-            log.info("connected", { key, transport: name })
-            mcpClient = client
-            status = { status: "connected" }
-            return true
+            log.info('connected', { key, transport: name });
+            mcpClient = client;
+            status = { status: 'connected' };
+            return true;
           })
           .catch((error) => {
-            lastError = error instanceof Error ? error : new Error(String(error))
-            log.debug("transport connection failed", {
+            lastError =
+              error instanceof Error ? error : new Error(String(error));
+            log.debug('transport connection failed', {
               key,
               transport: name,
               url: mcp.url,
               error: lastError.message,
-            })
+            });
             status = {
-              status: "failed" as const,
+              status: 'failed' as const,
               error: lastError.message,
-            }
-            return false
-          })
-        if (result) break
+            };
+            return false;
+          });
+        if (result) break;
       }
     }
 
-    if (mcp.type === "local") {
-      const [cmd, ...args] = mcp.command
+    if (mcp.type === 'local') {
+      const [cmd, ...args] = mcp.command;
       await experimental_createMCPClient({
-        name: "opencode",
+        name: 'opencode',
         transport: new StdioClientTransport({
-          stderr: "ignore",
+          stderr: 'ignore',
           command: cmd,
           args,
           env: {
             ...process.env,
-            ...(cmd === "opencode" ? { BUN_BE_BUN: "1" } : {}),
+            ...(cmd === 'opencode' ? { BUN_BE_BUN: '1' } : {}),
             ...mcp.environment,
           },
         }),
       })
         .then((client) => {
-          mcpClient = client
+          mcpClient = client;
           status = {
-            status: "connected",
-          }
+            status: 'connected',
+          };
         })
         .catch((error) => {
-          log.error("local mcp startup failed", {
+          log.error('local mcp startup failed', {
             key,
             command: mcp.command,
             error: error instanceof Error ? error.message : String(error),
-          })
+          });
           status = {
-            status: "failed" as const,
+            status: 'failed' as const,
             error: error instanceof Error ? error.message : String(error),
-          }
-        })
+          };
+        });
     }
 
     if (!status) {
       status = {
-        status: "failed" as const,
-        error: "Unknown error",
-      }
+        status: 'failed' as const,
+        error: 'Unknown error',
+      };
     }
 
     if (!mcpClient) {
       return {
         mcpClient: undefined,
         status,
-      }
+      };
     }
 
-    const result = await withTimeout(mcpClient.tools(), mcp.timeout ?? 5000).catch((err) => {
-      log.error("failed to get tools from client", { key, error: err })
-      return undefined
-    })
+    const result = await withTimeout(
+      mcpClient.tools(),
+      mcp.timeout ?? 5000
+    ).catch((err) => {
+      log.error('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('Failed to close MCP client', {
           error,
-        })
-      })
+        });
+      });
       status = {
-        status: "failed",
-        error: "Failed to get tools",
-      }
+        status: 'failed',
+        error: 'Failed to get tools',
+      };
       return {
         mcpClient: undefined,
         status: {
-          status: "failed" as const,
-          error: "Failed to get tools",
+          status: 'failed' as const,
+          error: 'Failed to get tools',
         },
-      }
+      };
     }
 
-    log.info("create() successfully created client", { key, toolCount: Object.keys(result).length })
+    log.info('create() successfully created client', {
+      key,
+      toolCount: Object.keys(result).length,
+    });
     return {
       mcpClient,
       status,
-    }
+    };
   }
 
   export async function status() {
-    return state().then((state) => state.status)
+    return state().then((state) => state.status);
   }
 
   export async function clients() {
-    return state().then((state) => state.clients)
+    return state().then((state) => state.clients);
   }
 
   export async function tools() {
-    const result: Record<string, Tool> = {}
-    const s = await state()
-    const clientsSnapshot = await clients()
+    const result: Record<string, Tool> = {};
+    const s = await state();
+    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('failed to get tools', { clientName, error: e.message });
         const failedStatus = {
-          status: "failed" as const,
+          status: 'failed' as const,
           error: e instanceof Error ? e.message : String(e),
-        }
-        s.status[clientName] = failedStatus
-        delete s.clients[clientName]
-      })
+        };
+        s.status[clientName] = failedStatus;
+        delete s.clients[clientName];
+      });
       if (!tools) {
-        continue
+        continue;
       }
       for (const [toolName, tool] of Object.entries(tools)) {
-        const sanitizedClientName = clientName.replace(/[^a-zA-Z0-9_-]/g, "_")
-        const sanitizedToolName = toolName.replace(/[^a-zA-Z0-9_-]/g, "_")
-        result[sanitizedClientName + "_" + sanitizedToolName] = tool
+        const sanitizedClientName = clientName.replace(/[^a-zA-Z0-9_-]/g, '_');
+        const sanitizedToolName = toolName.replace(/[^a-zA-Z0-9_-]/g, '_');
+        result[sanitizedClientName + '_' + sanitizedToolName] = tool;
       }
     }
-    return result
+    return result;
   }
 }