@link-assistant/agent 0.0.9 → 0.0.12

package/src/json-standard/index.ts

@@ -6,65 +6,76 @@
  * - claude: Claude CLI stream-json format - NDJSON (newline-delimited JSON)
  */
 
-import { EOL } from 'os'
+import { EOL } from 'os';
 
-export type JsonStandard = 'opencode' | 'claude'
+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>
+  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
+  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 {
+export function serializeOutput(
+  event: OpenCodeEvent | ClaudeEvent,
+  standard: JsonStandard
+): string {
   if (standard === 'claude') {
     // NDJSON format - compact, one line
-    return JSON.stringify(event) + EOL
+    return JSON.stringify(event) + EOL;
   }
   // OpenCode format - pretty-printed
-  return JSON.stringify(event, null, 2) + EOL
+  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
+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
-      }
+        session_id,
+      };
 
     case 'text':
       if (event.part && typeof event.part.text === 'string') {
@@ -73,28 +84,30 @@ export function convertOpenCodeToClaude(event: OpenCodeEvent, startTime: number)
           timestamp,
           session_id,
           role: 'assistant',
-          content: [{
-            type: 'text',
-            text: event.part.text
-          }]
-        }
+          content: [
+            {
+              type: 'text',
+              text: event.part.text,
+            },
+          ],
+        };
       }
-      return null
+      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
+        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
-        }
+          tool_use_id: event.part.id as string,
+        };
       }
-      return null
+      return null;
 
     case 'step_finish':
       return {
@@ -102,8 +115,8 @@ export function convertOpenCodeToClaude(event: OpenCodeEvent, startTime: number)
         timestamp,
         session_id,
         status: 'success',
-        duration_ms: event.timestamp - startTime
-      }
+        duration_ms: event.timestamp - startTime,
+      };
 
     case 'error':
       return {
@@ -111,11 +124,14 @@ export function convertOpenCodeToClaude(event: OpenCodeEvent, startTime: number)
         timestamp,
         session_id,
         status: 'error',
-        output: typeof event.error === 'string' ? event.error : JSON.stringify(event.error)
-      }
+        output:
+          typeof event.error === 'string'
+            ? event.error
+            : JSON.stringify(event.error),
+      };
 
     default:
-      return null
+      return null;
   }
 }
 
@@ -123,7 +139,7 @@ export function convertOpenCodeToClaude(event: OpenCodeEvent, startTime: number)
  * Create an event output handler based on the selected standard
  */
 export function createEventHandler(standard: JsonStandard, sessionID: string) {
-  const startTime = Date.now()
+  const startTime = Date.now();
 
   return {
     /**
@@ -131,12 +147,12 @@ export function createEventHandler(standard: JsonStandard, sessionID: string) {
      */
     output(event: OpenCodeEvent): void {
       if (standard === 'claude') {
-        const claudeEvent = convertOpenCodeToClaude(event, startTime)
+        const claudeEvent = convertOpenCodeToClaude(event, startTime);
         if (claudeEvent) {
-          process.stdout.write(serializeOutput(claudeEvent, standard))
+          process.stdout.write(serializeOutput(claudeEvent, standard));
         }
       } else {
-        process.stdout.write(serializeOutput(event, standard))
+        process.stdout.write(serializeOutput(event, standard));
       }
     },
 
@@ -144,14 +160,14 @@ export function createEventHandler(standard: JsonStandard, sessionID: string) {
      * Get the start time for duration calculations
      */
     getStartTime(): number {
-      return startTime
-    }
-  }
+      return startTime;
+    },
+  };
 }
 
 /**
  * Validate JSON standard option
  */
 export function isValidJsonStandard(value: string): value is JsonStandard {
-  return value === 'opencode' || value === 'claude'
+  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;
   }
 }