@link-assistant/agent 0.0.8 → 0.0.9

package/EXAMPLES.md

@@ -279,7 +279,28 @@ echo '{"message":"fetch url","tools":[{"name":"webfetch","params":{"url":"https:
 
 ## Output Format
 
-### JSON Event Streaming (Pretty-Printed)
+### JSON Standards
+
+@link-assistant/agent supports two JSON output format standards via the `--json-standard` option:
+
+#### OpenCode Standard (default)
+
+```bash
+# Default - same as --json-standard opencode
+echo "hi" | agent
+
+# Explicit opencode standard
+echo "hi" | agent --json-standard opencode
+```
+
+#### Claude Standard (experimental)
+
+```bash
+# Claude CLI compatible format (NDJSON)
+echo "hi" | agent --json-standard claude
+```
+
+### JSON Event Streaming (Pretty-Printed) - OpenCode Standard
 
 @link-assistant/agent outputs JSON events in pretty-printed streaming format for easy readability, 100% compatible with OpenCode's event structure:
 
@@ -327,6 +348,28 @@ This format is designed for:
 - **Compatibility**: 100% compatible with OpenCode's event structure
 - **Automation**: Can be parsed using standard JSON tools (see filtering examples below)
 
+### Claude Stream-JSON Output (NDJSON)
+
+When using `--json-standard claude`, output is in NDJSON (Newline-Delimited JSON) format, compatible with Claude CLI:
+
+```bash
+echo "hi" | agent --json-standard claude
+```
+
+Output (compact NDJSON):
+```json
+{"type":"init","timestamp":"2025-01-01T00:00:00.000Z","session_id":"ses_560236487ffe3ROK1ThWvPwTEF"}
+{"type":"message","timestamp":"2025-01-01T00:00:01.000Z","session_id":"ses_560236487ffe3ROK1ThWvPwTEF","role":"assistant","content":[{"type":"text","text":"Hi! How can I help with your coding tasks today?"}]}
+{"type":"result","timestamp":"2025-01-01T00:00:01.100Z","session_id":"ses_560236487ffe3ROK1ThWvPwTEF","status":"success","duration_ms":1100}
+```
+
+Key differences from OpenCode format:
+- **Compact**: One JSON per line (no pretty-printing)
+- **Event Types**: `init`, `message`, `tool_use`, `tool_result`, `result`
+- **Timestamps**: ISO 8601 strings instead of Unix milliseconds
+- **Session ID**: `session_id` (snake_case) instead of `sessionID` (camelCase)
+- **Content**: Message content in array format with `{type, text}` objects
+
 ### Filtering Output
 
 Extract specific event types using `jq`:

package/README.md

@@ -156,6 +156,8 @@ agent [options]
 Options:
   --model                        Model to use in format providerID/modelID
                                  Default: opencode/grok-code
+  --json-standard                JSON output format standard
+                                 Choices: "opencode" (default), "claude" (experimental)
   --system-message               Full override of the system message
   --system-message-file          Full override of the system message from file
   --append-system-message        Append to the default system message
@@ -164,6 +166,36 @@ Options:
   --version                      Show version number
 ```
 
+### JSON Output Standards
+
+The agent supports two JSON output format standards via the `--json-standard` option:
+
+#### OpenCode Standard (default)
+
+The OpenCode format is the default JSON output format, compatible with `opencode run --format json`:
+
+```bash
+echo "hi" | agent --json-standard opencode
+```
+
+- **Format**: Pretty-printed JSON (human-readable with indentation)
+- **Event Types**: `step_start`, `step_finish`, `text`, `tool_use`, `error`
+- **Timestamps**: Unix milliseconds (number)
+- **Session ID**: `sessionID` (camelCase)
+
+#### Claude Standard (experimental)
+
+The Claude format provides compatibility with Anthropic's Claude CLI `--output-format stream-json`:
+
+```bash
+echo "hi" | agent --json-standard claude
+```
+
+- **Format**: NDJSON (Newline-Delimited JSON - compact, one JSON per line)
+- **Event Types**: `init`, `message`, `tool_use`, `tool_result`, `result`
+- **Timestamps**: ISO 8601 strings
+- **Session ID**: `session_id` (snake_case)
+
 ### Input Formats
 
 **Plain Text (auto-converted):**
@@ -222,11 +254,14 @@ See [EXAMPLES.md](EXAMPLES.md) for detailed usage examples of each tool with bot
 bun test
 
 # Run specific test file
+bun test tests/mcp.test.js
 bun test tests/websearch.tools.test.js
 bun test tests/batch.tools.test.js
 bun test tests/plaintext.input.test.js
 ```
 
+For detailed testing information including how to run tests manually and trigger CI tests, see [TESTING.md](TESTING.md).
+
 ## Maintenance
 
 ### Development
@@ -255,6 +290,7 @@ Bun automatically discovers and runs all `*.test.js` files in the project.
 - ✅ 13 tool implementation tests
 - ✅ Plain text input support test
 - ✅ OpenCode compatibility tests for websearch/codesearch
+- ✅ JSON standard unit tests (opencode and claude formats)
 - ✅ All tests pass with 100% OpenCode JSON format compatibility
 
 ### Publishing

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@link-assistant/agent",
-  "version": "0.0.8",
+  "version": "0.0.9",
   "description": "A minimal, public domain AI CLI agent compatible with OpenCode's JSON interface. Bun-only runtime.",
   "main": "src/index.js",
   "type": "module",
@@ -43,6 +43,7 @@
     "@agentclientprotocol/sdk": "^0.5.1",
     "@ai-sdk/mcp": "^0.0.8",
     "@ai-sdk/xai": "^2.0.33",
+    "@clack/prompts": "^0.11.0",
     "@hono/standard-validator": "^0.2.0",
     "@hono/zod-validator": "^0.7.5",
     "@modelcontextprotocol/sdk": "^1.22.0",

package/src/cli/cmd/mcp.ts

@@ -1,19 +1,94 @@
+import type { Argv } from "yargs"
 import { cmd } from "./cmd"
 import { Client } from "@modelcontextprotocol/sdk/client/index.js"
 import { StreamableHTTPClientTransport } from "@modelcontextprotocol/sdk/client/streamableHttp.js"
 import * as prompts from "@clack/prompts"
 import { UI } from "../ui"
+import { Global } from "../../global"
+import { Config } from "../../config/config"
+import path from "path"
+import fs from "fs/promises"
 
 export const McpCommand = cmd({
   command: "mcp",
-  builder: (yargs) => yargs.command(McpAddCommand).demandCommand(),
+  builder: (yargs) => yargs.command(McpAddCommand).command(McpListCommand).demandCommand(),
   async handler() {},
 })
 
+async function loadGlobalConfig(): Promise<Config.Info> {
+  const configPath = path.join(Global.Path.config, "opencode.json")
+  try {
+    const content = await Bun.file(configPath).text()
+    return JSON.parse(content)
+  } catch {
+    return {
+      $schema: "https://opencode.ai/config.json",
+    }
+  }
+}
+
+async function saveGlobalConfig(config: Config.Info): Promise<void> {
+  const configPath = path.join(Global.Path.config, "opencode.json")
+  await fs.mkdir(Global.Path.config, { recursive: true })
+  await Bun.write(configPath, JSON.stringify(config, null, 2))
+}
+
 export const McpAddCommand = cmd({
-  command: "add",
+  command: "add [name] [command..]",
   describe: "add an MCP server",
-  async handler() {
+  builder: (yargs: Argv) => {
+    return yargs
+      .positional("name", {
+        describe: "name of the MCP server",
+        type: "string",
+      })
+      .positional("command", {
+        describe: "command and arguments to run the MCP server (e.g., npx @playwright/mcp@latest)",
+        type: "string",
+        array: true,
+      })
+      .option("url", {
+        describe: "URL for remote MCP server",
+        type: "string",
+      })
+      .option("enabled", {
+        describe: "enable the MCP server",
+        type: "boolean",
+        default: true,
+      })
+  },
+  async handler(args) {
+    // If name and command are provided as CLI arguments, use non-interactive mode
+    if (args.name && ((args.command && args.command.length > 0) || args.url)) {
+      // Non-interactive mode: CLI arguments provided
+      const config = await loadGlobalConfig()
+      config.mcp = config.mcp || {}
+
+      if (args.url) {
+        // Remote MCP server
+        config.mcp[args.name] = {
+          type: "remote",
+          url: args.url,
+          enabled: args.enabled,
+        }
+        UI.success(`Remote MCP server "${args.name}" added with URL: ${args.url}`)
+      } else if (args.command && args.command.length > 0) {
+        // Local MCP server
+        config.mcp[args.name] = {
+          type: "local",
+          command: args.command,
+          enabled: args.enabled,
+        }
+        UI.success(`Local MCP server "${args.name}" added with command: ${args.command.join(" ")}`)
+      }
+
+      await saveGlobalConfig(config)
+      const configPath = path.join(Global.Path.config, "opencode.json")
+      UI.info(`Configuration saved to: ${configPath}`)
+      return
+    }
+
+    // Interactive mode: prompt for input
     UI.empty()
     prompts.intro("Add MCP server")
 
@@ -40,17 +115,27 @@ export const McpAddCommand = cmd({
     })
     if (prompts.isCancel(type)) throw new UI.CancelledError()
 
+    const config = await loadGlobalConfig()
+    config.mcp = config.mcp || {}
+
     if (type === "local") {
       const command = await prompts.text({
         message: "Enter command to run",
-        placeholder: "e.g., opencode x @modelcontextprotocol/server-filesystem",
+        placeholder: "e.g., npx @playwright/mcp@latest",
         validate: (x) => (x && x.length > 0 ? undefined : "Required"),
       })
       if (prompts.isCancel(command)) throw new UI.CancelledError()
 
+      // Parse command into array
+      const commandParts = command.split(/\s+/)
+      config.mcp[name] = {
+        type: "local",
+        command: commandParts,
+        enabled: true,
+      }
+
+      await saveGlobalConfig(config)
       prompts.log.info(`Local MCP server "${name}" configured with command: ${command}`)
-      prompts.outro("MCP server added successfully")
-      return
     }
 
     if (type === "remote") {
@@ -66,15 +151,62 @@ export const McpAddCommand = cmd({
       })
       if (prompts.isCancel(url)) throw new UI.CancelledError()
 
-      const client = new Client({
-        name: "opencode",
-        version: "1.0.0",
-      })
-      const transport = new StreamableHTTPClientTransport(new URL(url))
-      await client.connect(transport)
+      // Test connection
+      try {
+        const client = new Client({
+          name: "opencode",
+          version: "1.0.0",
+        })
+        const transport = new StreamableHTTPClientTransport(new URL(url))
+        await client.connect(transport)
+        await client.close()
+      } catch (error) {
+        prompts.log.warn(`Could not verify connection to ${url}, but saving configuration anyway`)
+      }
+
+      config.mcp[name] = {
+        type: "remote",
+        url: url,
+        enabled: true,
+      }
+
+      await saveGlobalConfig(config)
       prompts.log.info(`Remote MCP server "${name}" configured with URL: ${url}`)
     }
 
+    const configPath = path.join(Global.Path.config, "opencode.json")
+    prompts.log.info(`Configuration saved to: ${configPath}`)
     prompts.outro("MCP server added successfully")
   },
 })
+
+export const McpListCommand = cmd({
+  command: "list",
+  describe: "list configured MCP servers",
+  async handler() {
+    const config = await loadGlobalConfig()
+    const mcpServers = config.mcp || {}
+
+    if (Object.keys(mcpServers).length === 0) {
+      UI.info("No MCP servers configured")
+      return
+    }
+
+    UI.println(UI.Style.TEXT_BOLD + "Configured MCP servers:" + UI.Style.TEXT_NORMAL)
+    UI.empty()
+
+    for (const [name, server] of Object.entries(mcpServers)) {
+      const enabledStatus = server.enabled !== false ? UI.Style.TEXT_SUCCESS_BOLD + "[enabled]" : UI.Style.TEXT_DIM + "[disabled]"
+      UI.println(UI.Style.TEXT_INFO_BOLD + `  ${name}` + UI.Style.TEXT_NORMAL + ` ${enabledStatus}` + UI.Style.TEXT_NORMAL)
+
+      if (server.type === "local") {
+        UI.println(UI.Style.TEXT_DIM + `    Type: local`)
+        UI.println(UI.Style.TEXT_DIM + `    Command: ${server.command.join(" ")}`)
+      } else if (server.type === "remote") {
+        UI.println(UI.Style.TEXT_DIM + `    Type: remote`)
+        UI.println(UI.Style.TEXT_DIM + `    URL: ${server.url}`)
+      }
+      UI.empty()
+    }
+  },
+})

package/src/cli/ui.ts

@@ -0,0 +1,63 @@
+import { NamedError } from "../util/error"
+import z from "zod"
+
+export namespace UI {
+  // ANSI color codes for terminal output
+  export const Style = {
+    TEXT_NORMAL: "\x1b[0m",
+    TEXT_BOLD: "\x1b[1m",
+    TEXT_DIM: "\x1b[2m",
+    TEXT_DANGER_BOLD: "\x1b[1;31m",
+    TEXT_SUCCESS_BOLD: "\x1b[1;32m",
+    TEXT_WARNING_BOLD: "\x1b[1;33m",
+    TEXT_INFO_BOLD: "\x1b[1;34m",
+    TEXT_HIGHLIGHT_BOLD: "\x1b[1;35m",
+    TEXT_DIM_BOLD: "\x1b[1;90m",
+  } as const
+
+  // Error for cancelled operations (e.g., Ctrl+C in prompts)
+  export const CancelledError = NamedError.create(
+    "CancelledError",
+    z.object({})
+  )
+
+  // Print an empty line
+  export function empty() {
+    process.stderr.write("\n")
+  }
+
+  // Print a line with optional formatting
+  export function println(...args: string[]) {
+    process.stderr.write(args.join("") + Style.TEXT_NORMAL + "\n")
+  }
+
+  // Print an error message
+  export function error(message: string) {
+    process.stderr.write(Style.TEXT_DANGER_BOLD + "Error: " + Style.TEXT_NORMAL + message + "\n")
+  }
+
+  // Print a success message
+  export function success(message: string) {
+    process.stderr.write(Style.TEXT_SUCCESS_BOLD + "Success: " + Style.TEXT_NORMAL + message + "\n")
+  }
+
+  // Print an info message
+  export function info(message: string) {
+    process.stderr.write(Style.TEXT_INFO_BOLD + "Info: " + Style.TEXT_NORMAL + message + "\n")
+  }
+
+  // Basic markdown rendering for terminal
+  export function markdown(text: string): string {
+    // Simple markdown to ANSI conversion
+    let result = text
+
+    // Bold text: **text** or __text__
+    result = result.replace(/\*\*(.+?)\*\*/g, Style.TEXT_BOLD + "$1" + Style.TEXT_NORMAL)
+    result = result.replace(/__(.+?)__/g, Style.TEXT_BOLD + "$1" + Style.TEXT_NORMAL)
+
+    // Code blocks: `code`
+    result = result.replace(/`([^`]+)`/g, Style.TEXT_DIM + "$1" + Style.TEXT_NORMAL)
+
+    return result
+  }
+}

package/src/index.js

@@ -9,6 +9,34 @@ import { SessionPrompt } from './session/prompt.ts'
 import { EOL } from 'os'
 import yargs from 'yargs'
 import { hideBin } from 'yargs/helpers'
+import { createEventHandler, isValidJsonStandard } from './json-standard/index.ts'
+import { McpCommand } from './cli/cmd/mcp.ts'
+
+// Track if any errors occurred during execution
+let hasError = false
+
+// Install global error handlers to ensure non-zero exit codes
+process.on('uncaughtException', (error) => {
+  hasError = true
+  console.error(JSON.stringify({
+    type: 'error',
+    errorType: error.name || 'UncaughtException',
+    message: error.message,
+    stack: error.stack
+  }, null, 2))
+  process.exit(1)
+})
+
+process.on('unhandledRejection', (reason, promise) => {
+  hasError = true
+  console.error(JSON.stringify({
+    type: 'error',
+    errorType: 'UnhandledRejection',
+    message: reason?.message || String(reason),
+    stack: reason?.stack
+  }, null, 2))
+  process.exit(1)
+})
 
 async function readStdin() {
   return new Promise((resolve, reject) => {
@@ -35,15 +63,341 @@ async function readStdin() {
   })
 }
 
+async function runAgentMode(argv) {
+  // Parse model argument
+  const modelParts = argv.model.split('/')
+  const providerID = modelParts[0] || 'opencode'
+  const modelID = modelParts[1] || 'grok-code'
+
+  // Validate and get JSON standard
+  const jsonStandard = argv['json-standard']
+  if (!isValidJsonStandard(jsonStandard)) {
+    console.error(`Invalid JSON standard: ${jsonStandard}. Use "opencode" or "claude".`)
+    process.exit(1)
+  }
+
+  // Read system message files
+  let systemMessage = argv['system-message']
+  let appendSystemMessage = argv['append-system-message']
+
+  if (argv['system-message-file']) {
+    const resolvedPath = require('path').resolve(process.cwd(), argv['system-message-file'])
+    const file = Bun.file(resolvedPath)
+    if (!(await file.exists())) {
+      console.error(`System message file not found: ${argv['system-message-file']}`)
+      process.exit(1)
+    }
+    systemMessage = await file.text()
+  }
+
+  if (argv['append-system-message-file']) {
+    const resolvedPath = require('path').resolve(process.cwd(), argv['append-system-message-file'])
+    const file = Bun.file(resolvedPath)
+    if (!(await file.exists())) {
+      console.error(`Append system message file not found: ${argv['append-system-message-file']}`)
+      process.exit(1)
+    }
+    appendSystemMessage = await file.text()
+  }
+
+  // Initialize logging to redirect to log file instead of stderr
+  // This prevents log messages from mixing with JSON output
+  await Log.init({
+    print: false,  // Don't print to stderr
+    level: 'INFO'
+  })
+
+  // Read input from stdin
+  const input = await readStdin()
+  const trimmedInput = input.trim()
+
+  // Try to parse as JSON, if it fails treat it as plain text message
+  let request
+  try {
+    request = JSON.parse(trimmedInput)
+  } catch (e) {
+    // Not JSON, treat as plain text message
+    request = {
+      message: trimmedInput
+    }
+  }
+
+  // Wrap in Instance.provide for OpenCode infrastructure
+  await Instance.provide({
+    directory: process.cwd(),
+    fn: async () => {
+      if (argv.server) {
+        // SERVER MODE: Start server and communicate via HTTP
+        await runServerMode(request, providerID, modelID, systemMessage, appendSystemMessage, jsonStandard)
+      } else {
+        // DIRECT MODE: Run everything in single process
+        await runDirectMode(request, providerID, modelID, systemMessage, appendSystemMessage, jsonStandard)
+      }
+    }
+  })
+
+  // Explicitly exit to ensure process terminates
+  process.exit(hasError ? 1 : 0)
+}
+
+async function runServerMode(request, providerID, modelID, systemMessage, appendSystemMessage, jsonStandard) {
+  // Start server like OpenCode does
+  const server = Server.listen({ port: 0, hostname: "127.0.0.1" })
+  let unsub = null
+
+  try {
+    // Create a session
+    const createRes = await fetch(`http://${server.hostname}:${server.port}/session`, {
+      method: 'POST',
+      headers: { 'Content-Type': 'application/json' },
+      body: JSON.stringify({})
+    })
+    const session = await createRes.json()
+    const sessionID = session.id
+
+    if (!sessionID) {
+      throw new Error("Failed to create session")
+    }
+
+    // Create event handler for the selected JSON standard
+    const eventHandler = createEventHandler(jsonStandard, sessionID)
+
+    // Subscribe to all bus events and output in selected format
+    const eventPromise = new Promise((resolve) => {
+      unsub = Bus.subscribeAll((event) => {
+        // Output events in selected JSON format
+        if (event.type === 'message.part.updated') {
+          const part = event.properties.part
+          if (part.sessionID !== sessionID) return
+
+          // Output different event types
+          if (part.type === 'step-start') {
+            eventHandler.output({
+              type: 'step_start',
+              timestamp: Date.now(),
+              sessionID,
+              part
+            })
+          }
+
+          if (part.type === 'step-finish') {
+            eventHandler.output({
+              type: 'step_finish',
+              timestamp: Date.now(),
+              sessionID,
+              part
+            })
+          }
+
+          if (part.type === 'text' && part.time?.end) {
+            eventHandler.output({
+              type: 'text',
+              timestamp: Date.now(),
+              sessionID,
+              part
+            })
+          }
+
+          if (part.type === 'tool' && part.state.status === 'completed') {
+            eventHandler.output({
+              type: 'tool_use',
+              timestamp: Date.now(),
+              sessionID,
+              part
+            })
+          }
+        }
+
+        // Handle session idle to know when to stop
+        if (event.type === 'session.idle' && event.properties.sessionID === sessionID) {
+          resolve()
+        }
+
+        // Handle errors
+        if (event.type === 'session.error') {
+          const props = event.properties
+          if (props.sessionID !== sessionID || !props.error) return
+          hasError = true
+          eventHandler.output({
+            type: 'error',
+            timestamp: Date.now(),
+            sessionID,
+            error: props.error
+          })
+        }
+      })
+    })
+
+    // Send message to session with specified model (default: opencode/grok-code)
+    const message = request.message || "hi"
+    const parts = [{ type: "text", text: message }]
+
+    // Start the prompt (don't wait for response, events come via Bus)
+    fetch(`http://${server.hostname}:${server.port}/session/${sessionID}/message`, {
+      method: 'POST',
+      headers: { 'Content-Type': 'application/json' },
+      body: JSON.stringify({
+        parts,
+        model: {
+          providerID,
+          modelID
+        },
+        system: systemMessage,
+        appendSystem: appendSystemMessage
+      })
+    }).catch((error) => {
+      hasError = true
+      eventHandler.output({
+        type: 'error',
+        timestamp: Date.now(),
+        sessionID,
+        error: error instanceof Error ? error.message : String(error)
+      })
+    })
+
+    // Wait for session to become idle
+    await eventPromise
+  } finally {
+    // Always clean up resources
+    if (unsub) unsub()
+    server.stop()
+    await Instance.dispose()
+  }
+}
+
+async function runDirectMode(request, providerID, modelID, systemMessage, appendSystemMessage, jsonStandard) {
+  // DIRECT MODE: Run in single process without server
+  let unsub = null
+
+  try {
+    // Create a session directly
+    const session = await Session.createNext({
+      directory: process.cwd()
+    })
+    const sessionID = session.id
+
+    // Create event handler for the selected JSON standard
+    const eventHandler = createEventHandler(jsonStandard, sessionID)
+
+    // Subscribe to all bus events and output in selected format
+    const eventPromise = new Promise((resolve) => {
+      unsub = Bus.subscribeAll((event) => {
+        // Output events in selected JSON format
+        if (event.type === 'message.part.updated') {
+          const part = event.properties.part
+          if (part.sessionID !== sessionID) return
+
+          // Output different event types
+          if (part.type === 'step-start') {
+            eventHandler.output({
+              type: 'step_start',
+              timestamp: Date.now(),
+              sessionID,
+              part
+            })
+          }
+
+          if (part.type === 'step-finish') {
+            eventHandler.output({
+              type: 'step_finish',
+              timestamp: Date.now(),
+              sessionID,
+              part
+            })
+          }
+
+          if (part.type === 'text' && part.time?.end) {
+            eventHandler.output({
+              type: 'text',
+              timestamp: Date.now(),
+              sessionID,
+              part
+            })
+          }
+
+          if (part.type === 'tool' && part.state.status === 'completed') {
+            eventHandler.output({
+              type: 'tool_use',
+              timestamp: Date.now(),
+              sessionID,
+              part
+            })
+          }
+        }
+
+        // Handle session idle to know when to stop
+        if (event.type === 'session.idle' && event.properties.sessionID === sessionID) {
+          resolve()
+        }
+
+        // Handle errors
+        if (event.type === 'session.error') {
+          const props = event.properties
+          if (props.sessionID !== sessionID || !props.error) return
+          hasError = true
+          eventHandler.output({
+            type: 'error',
+            timestamp: Date.now(),
+            sessionID,
+            error: props.error
+          })
+        }
+      })
+    })
+
+    // Send message to session directly
+    const message = request.message || "hi"
+    const parts = [{ type: "text", text: message }]
+
+    // Start the prompt directly without HTTP
+    SessionPrompt.prompt({
+      sessionID,
+      parts,
+      model: {
+        providerID,
+        modelID
+      },
+      system: systemMessage,
+      appendSystem: appendSystemMessage
+    }).catch((error) => {
+      hasError = true
+      eventHandler.output({
+        type: 'error',
+        timestamp: Date.now(),
+        sessionID,
+        error: error instanceof Error ? error.message : String(error)
+      })
+    })
+
+    // Wait for session to become idle
+    await eventPromise
+  } finally {
+    // Always clean up resources
+    if (unsub) unsub()
+    await Instance.dispose()
+  }
+}
+
 async function main() {
   try {
-    // Parse command line arguments
+    // Parse command line arguments with subcommands
     const argv = await yargs(hideBin(process.argv))
+      .scriptName('agent')
+      .usage('$0 [command] [options]')
+      // MCP subcommand
+      .command(McpCommand)
+      // Default run mode (when piping stdin)
       .option('model', {
         type: 'string',
         description: 'Model to use in format providerID/modelID',
         default: 'opencode/grok-code'
       })
+      .option('json-standard', {
+        type: 'string',
+        description: 'JSON output format standard: "opencode" (default) or "claude" (experimental)',
+        default: 'opencode',
+        choices: ['opencode', 'claude']
+      })
       .option('system-message', {
         type: 'string',
         description: 'Full override of the system message'
@@ -68,302 +422,23 @@ async function main() {
       .help()
       .argv
 
-    // Parse model argument
-    const modelParts = argv.model.split('/')
-    const providerID = modelParts[0] || 'opencode'
-    const modelID = modelParts[1] || 'grok-code'
-
-    // Read system message files
-    let systemMessage = argv['system-message']
-    let appendSystemMessage = argv['append-system-message']
-
-    if (argv['system-message-file']) {
-      const resolvedPath = require('path').resolve(process.cwd(), argv['system-message-file'])
-      const file = Bun.file(resolvedPath)
-      if (!(await file.exists())) {
-        console.error(`System message file not found: ${argv['system-message-file']}`)
-        process.exit(1)
-      }
-      systemMessage = await file.text()
-    }
+    // If a command was executed (like mcp), yargs handles it
+    // Otherwise, check if we should run in agent mode (stdin piped)
+    const commandExecuted = argv._ && argv._.length > 0
 
-    if (argv['append-system-message-file']) {
-      const resolvedPath = require('path').resolve(process.cwd(), argv['append-system-message-file'])
-      const file = Bun.file(resolvedPath)
-      if (!(await file.exists())) {
-        console.error(`Append system message file not found: ${argv['append-system-message-file']}`)
-        process.exit(1)
-      }
-      appendSystemMessage = await file.text()
+    if (!commandExecuted) {
+      // No command specified, run in default agent mode (stdin processing)
+      await runAgentMode(argv)
     }
-
-    // Initialize logging to redirect to log file instead of stderr
-    // This prevents log messages from mixing with JSON output
-    await Log.init({
-      print: false,  // Don't print to stderr
-      level: 'INFO'
-    })
-
-    // Read input from stdin
-    const input = await readStdin()
-    const trimmedInput = input.trim()
-
-    // Try to parse as JSON, if it fails treat it as plain text message
-    let request
-    try {
-      request = JSON.parse(trimmedInput)
-    } catch (e) {
-      // Not JSON, treat as plain text message
-      request = {
-        message: trimmedInput
-      }
-    }
-
-    // Wrap in Instance.provide for OpenCode infrastructure
-    await Instance.provide({
-      directory: process.cwd(),
-      fn: async () => {
-        if (argv.server) {
-          // SERVER MODE: Start server and communicate via HTTP
-          await runServerMode()
-        } else {
-          // DIRECT MODE: Run everything in single process
-          await runDirectMode()
-        }
-      }
-    })
-
-    async function runServerMode() {
-      // Start server like OpenCode does
-      const server = Server.listen({ port: 0, hostname: "127.0.0.1" })
-      let unsub = null
-
-      try {
-        // Create a session
-        const createRes = await fetch(`http://${server.hostname}:${server.port}/session`, {
-          method: 'POST',
-          headers: { 'Content-Type': 'application/json' },
-          body: JSON.stringify({})
-        })
-        const session = await createRes.json()
-        const sessionID = session.id
-
-        if (!sessionID) {
-          throw new Error("Failed to create session")
-        }
-
-        // Subscribe to all bus events to output them in OpenCode format
-        const eventPromise = new Promise((resolve) => {
-          unsub = Bus.subscribeAll((event) => {
-            // Output events in OpenCode JSON format
-            if (event.type === 'message.part.updated') {
-              const part = event.properties.part
-              if (part.sessionID !== sessionID) return
-
-              // Output different event types (pretty-printed for readability)
-              if (part.type === 'step-start') {
-                process.stdout.write(JSON.stringify({
-                  type: 'step_start',
-                  timestamp: Date.now(),
-                  sessionID,
-                  part
-                }, null, 2) + EOL)
-              }
-
-              if (part.type === 'step-finish') {
-                process.stdout.write(JSON.stringify({
-                  type: 'step_finish',
-                  timestamp: Date.now(),
-                  sessionID,
-                  part
-                }, null, 2) + EOL)
-              }
-
-              if (part.type === 'text' && part.time?.end) {
-                process.stdout.write(JSON.stringify({
-                  type: 'text',
-                  timestamp: Date.now(),
-                  sessionID,
-                  part
-                }, null, 2) + EOL)
-              }
-
-              if (part.type === 'tool' && part.state.status === 'completed') {
-                process.stdout.write(JSON.stringify({
-                  type: 'tool_use',
-                  timestamp: Date.now(),
-                  sessionID,
-                  part
-                }, null, 2) + EOL)
-              }
-            }
-
-            // Handle session idle to know when to stop
-            if (event.type === 'session.idle' && event.properties.sessionID === sessionID) {
-              resolve()
-            }
-
-            // Handle errors
-            if (event.type === 'session.error') {
-              const props = event.properties
-              if (props.sessionID !== sessionID || !props.error) return
-              process.stdout.write(JSON.stringify({
-                type: 'error',
-                timestamp: Date.now(),
-                sessionID,
-                error: props.error
-              }, null, 2) + EOL)
-            }
-          })
-        })
-
-        // Send message to session with specified model (default: opencode/grok-code)
-        const message = request.message || "hi"
-        const parts = [{ type: "text", text: message }]
-
-        // Start the prompt (don't wait for response, events come via Bus)
-        fetch(`http://${server.hostname}:${server.port}/session/${sessionID}/message`, {
-          method: 'POST',
-          headers: { 'Content-Type': 'application/json' },
-          body: JSON.stringify({
-            parts,
-            model: {
-              providerID,
-              modelID
-            },
-            system: systemMessage,
-            appendSystem: appendSystemMessage
-          })
-        }).catch(() => {
-          // Ignore errors, we're listening to events
-        })
-
-        // Wait for session to become idle
-        await eventPromise
-      } finally {
-        // Always clean up resources
-        if (unsub) unsub()
-        server.stop()
-        await Instance.dispose()
-      }
-    }
-
-    async function runDirectMode() {
-      // DIRECT MODE: Run in single process without server
-      let unsub = null
-
-      try {
-        // Create a session directly
-        const session = await Session.createNext({
-          directory: process.cwd()
-        })
-        const sessionID = session.id
-
-        // Subscribe to all bus events to output them in OpenCode format
-        const eventPromise = new Promise((resolve) => {
-          unsub = Bus.subscribeAll((event) => {
-            // Output events in OpenCode JSON format
-            if (event.type === 'message.part.updated') {
-              const part = event.properties.part
-              if (part.sessionID !== sessionID) return
-
-              // Output different event types (pretty-printed for readability)
-              if (part.type === 'step-start') {
-                process.stdout.write(JSON.stringify({
-                  type: 'step_start',
-                  timestamp: Date.now(),
-                  sessionID,
-                  part
-                }, null, 2) + EOL)
-              }
-
-              if (part.type === 'step-finish') {
-                process.stdout.write(JSON.stringify({
-                  type: 'step_finish',
-                  timestamp: Date.now(),
-                  sessionID,
-                  part
-                }, null, 2) + EOL)
-              }
-
-              if (part.type === 'text' && part.time?.end) {
-                process.stdout.write(JSON.stringify({
-                  type: 'text',
-                  timestamp: Date.now(),
-                  sessionID,
-                  part
-                }, null, 2) + EOL)
-              }
-
-              if (part.type === 'tool' && part.state.status === 'completed') {
-                process.stdout.write(JSON.stringify({
-                  type: 'tool_use',
-                  timestamp: Date.now(),
-                  sessionID,
-                  part
-                }, null, 2) + EOL)
-              }
-            }
-
-            // Handle session idle to know when to stop
-            if (event.type === 'session.idle' && event.properties.sessionID === sessionID) {
-              resolve()
-            }
-
-            // Handle errors
-            if (event.type === 'session.error') {
-              const props = event.properties
-              if (props.sessionID !== sessionID || !props.error) return
-              process.stdout.write(JSON.stringify({
-                type: 'error',
-                timestamp: Date.now(),
-                sessionID,
-                error: props.error
-              }, null, 2) + EOL)
-            }
-          })
-        })
-
-        // Send message to session directly
-        const message = request.message || "hi"
-        const parts = [{ type: "text", text: message }]
-
-        // Start the prompt directly without HTTP
-        SessionPrompt.prompt({
-          sessionID,
-          parts,
-          model: {
-            providerID,
-            modelID
-          },
-          system: systemMessage,
-          appendSystem: appendSystemMessage
-        }).catch((error) => {
-          process.stdout.write(JSON.stringify({
-            type: 'error',
-            timestamp: Date.now(),
-            sessionID,
-            error: error instanceof Error ? error.message : String(error)
-          }, null, 2) + EOL)
-        })
-
-        // Wait for session to become idle
-        await eventPromise
-      } finally {
-        // Always clean up resources
-        if (unsub) unsub()
-        await Instance.dispose()
-      }
-    }
-
-    // Explicitly exit to ensure process terminates
-    process.exit(0)
   } catch (error) {
+    hasError = true
     console.error(JSON.stringify({
       type: 'error',
       timestamp: Date.now(),
-      error: error instanceof Error ? error.message : String(error)
-    }))
+      errorType: error instanceof Error ? error.name : 'Error',
+      message: error instanceof Error ? error.message : String(error),
+      stack: error instanceof Error ? error.stack : undefined
+    }, null, 2))
     process.exit(1)
   }
 }

package/src/json-standard/index.ts

@@ -0,0 +1,157 @@
+/**
+ * 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'
+}