opencode-mega-agent 0.1.0

package/README.md

@@ -0,0 +1,106 @@
+# opencode-mega-agent
+
+OpenCode plugin that connects [MegaRouter](https://megarouter.ai) cloud agents to your editor. Agents are domain-trained specialist AIs (code reviewer, security auditor, debugger, etc.) that can read files, run commands, and search your codebase.
+
+## Install
+
+```bash
+npm install opencode-mega-agent
+```
+
+## Setup
+
+Add to your `opencode.json`:
+
+```json
+{
+  "plugin": ["opencode-mega-agent"],
+  "provider": {
+    "mega-router": {
+      "npm": "@ai-sdk/openai-compatible",
+      "options": {
+        "baseURL": "https://api.megarouter.ai/v1",
+        "apiKey": "sk-mega-..."
+      }
+    }
+  }
+}
+```
+
+That's it. The plugin auto-discovers available agents from the API on startup and registers them as native OpenCode subagents. No manual agent or model definitions needed.
+
+Restart OpenCode — cloud agents will appear as subagents in the task tool.
+
+## How It Works
+
+On startup the plugin:
+
+1. **Discovers agents** — calls `GET /api/v1/agents` to fetch available agents
+2. **Injects config** — registers each agent as a native subagent (`cfg.agent`) and model (`cfg.provider.models`)
+3. **Caches manifest** — writes to `.opencode/.mega-router-agents.json` for offline resilience
+4. **Injects system prompt** — teaches the AI about available agents and how to invoke them
+5. **Registers fallback tool** — `cloud_agent` tool with local file access via SSE tool loop
+
+## Invocation
+
+The AI can invoke agents two ways:
+
+```
+task(subagent_type="code-reviewer", prompt="Review auth.go for security issues")
+```
+
+Or via the fallback tool (if native subagent isn't available):
+
+```
+cloud_agent(agent="code-reviewer", message="Review auth.go for security issues")
+```
+
+## Available Agents
+
+| Agent | Specialty |
+|-------|-----------|
+| code-reviewer | Code review — bugs, security, style |
+| security-reviewer | OWASP security audit |
+| frontend-advisor | Frontend/UX — components, a11y, performance |
+| code-debugger | Root cause debugging |
+| devops-cli | Infrastructure & deployment |
+| doc-writer | Technical documentation |
+| data-analyst | Data analysis & visualization |
+| research-assistant | Deep research with citations |
+| git-assistant | Git workflow — commits, rebases |
+| api-tester | API endpoint testing |
+| office-hours | Product/business brainstorming |
+| creative-writer | Stories, poems, copywriting |
+
+## Offline / Backend Down
+
+If the MegaRouter API is unreachable at startup, the plugin loads agents from:
+
+1. **Disk cache** (`.opencode/.mega-router-agents.json`) — from last successful discovery
+2. **Hardcoded fallback** — built-in list of 12 standard agents
+
+## Configuration
+
+| Source | Priority | Notes |
+|--------|----------|-------|
+| `opencode.json` provider.mega-router.options | 1st | Recommended |
+| `MEGAROUTER_BASE_URL` / `MEGAROUTER_API_KEY` env vars | 2nd | Fallback |
+
+## Troubleshooting
+
+**"Authentication failed"** — Your API key is invalid or expired. Check `opencode.json` → `provider.mega-router.options.apiKey`.
+
+**"Insufficient credits"** — Your MegaRouter balance is too low. Top up at the dashboard.
+
+**"Agent not found"** — The agent ID doesn't exist. Check available agents in the system prompt or run `curl $BASE_URL/api/v1/agents`.
+
+**Agents not showing up** — Make sure the MegaRouter backend is running and reachable at the configured `baseURL`. Check `.opencode/.mega-router-agents.json` for cached state.
+
+## Development
+
+```bash
+cd plugins/opencode-cloud-agent
+npm install
+npx vitest run        # run tests
+npx vitest --watch    # watch mode
+```

package/index.mjs

@@ -0,0 +1,504 @@
+import { tool } from "@opencode-ai/plugin"
+
+// ── Fallback Agent Registry ─────────────────────────────────────────
+
+const FALLBACK_AGENTS = [
+  { id: "code-reviewer",      description: "Review code for bugs, security issues, race conditions, and style", category: "coding" },
+  { id: "security-reviewer",  description: "OWASP-trained security auditor — injection, auth bypass, supply chain", category: "security" },
+  { id: "frontend-advisor",   description: "Frontend/UX specialist — component architecture, a11y, performance", category: "coding" },
+  { id: "devops-cli",         description: "Infrastructure & deployment — Docker, CI/CD, cloud CLI tools", category: "coding" },
+  { id: "code-debugger",      description: "Systematic debugging from root cause to verified fix", category: "coding" },
+  { id: "doc-writer",         description: "Technical writing — READMEs, API docs, architecture guides", category: "productivity" },
+  { id: "data-analyst",       description: "Data analysis with visualization and statistical methods", category: "research" },
+  { id: "research-assistant", description: "Deep research with citations and structured summaries", category: "research" },
+  { id: "git-assistant",      description: "Git workflow — clean commits, rebases, history analysis", category: "productivity" },
+  { id: "api-tester",         description: "API endpoint testing with repeatable test cases", category: "coding" },
+  { id: "office-hours",       description: "YC-style product/business brainstorming", category: "creative" },
+  { id: "creative-writer",    description: "Creative content — stories, poems, copywriting", category: "creative" },
+]
+
+// ── Config ──────────────────────────────────────────────────────────
+
+const MODEL_PREFIX       = "agent:"
+const PROVIDER_KEY       = "mega-router"
+const DISCOVERY_TIMEOUT  = 5_000    // ms — don't block startup too long
+const MAX_TOOL_ROUNDS    = 30       // safety limit per invocation
+const TOTAL_TIMEOUT_MS   = 5 * 60 * 1000  // 5 min hard cap for entire cloud_agent call
+const CACHE_FILENAME     = ".opencode/.mega-router-agents.json"
+
+let providerConfigCache = null
+let discoveredAgents    = []
+let projectDir          = null
+
+function resolveConfig() {
+  if (providerConfigCache?.[PROVIDER_KEY]?.options) {
+    const opts = providerConfigCache[PROVIDER_KEY].options
+    const raw  = opts.baseURL || opts.baseUrl || ""
+    const baseUrl = raw.replace(/\/v1\/?$/, "").replace(/\/$/, "")
+    return {
+      baseUrl: baseUrl || "http://localhost:8080",
+      apiKey:  opts.apiKey || "",
+    }
+  }
+  return {
+    baseUrl: (process.env.MEGAROUTER_BASE_URL || "http://localhost:8080").replace(/\/$/, ""),
+    apiKey:  process.env.MEGAROUTER_API_KEY || "",
+  }
+}
+
+function agentList() {
+  return discoveredAgents.length > 0 ? discoveredAgents : FALLBACK_AGENTS
+}
+
+// ── Manifest Cache ──────────────────────────────────────────────────
+
+async function readCachedManifest(dir) {
+  if (!dir) return null
+  try {
+    const { readFileSync } = await import("fs")
+    const { join } = await import("path")
+    const raw = readFileSync(join(dir, CACHE_FILENAME), "utf-8")
+    const data = JSON.parse(raw)
+    if (Array.isArray(data) && data.length > 0 && data[0].id) return data
+  } catch { /* no cache or corrupt */ }
+  return null
+}
+
+async function writeCachedManifest(dir, agents) {
+  if (!dir || !agents?.length) return
+  try {
+    const { writeFileSync, mkdirSync } = await import("fs")
+    const { join, dirname } = await import("path")
+    const path = join(dir, CACHE_FILENAME)
+    mkdirSync(dirname(path), { recursive: true })
+    writeFileSync(path, JSON.stringify(agents, null, 2), "utf-8")
+  } catch { /* best-effort, non-fatal */ }
+}
+
+// ── Agent Discovery ─────────────────────────────────────────────────
+
+async function discoverAgents(baseUrl, apiKey) {
+  const ac = new AbortController()
+  const timer = setTimeout(() => ac.abort(), DISCOVERY_TIMEOUT)
+  try {
+    const headers = {}
+    if (apiKey) headers["Authorization"] = `Bearer ${apiKey}`
+    const resp = await fetch(`${baseUrl}/api/v1/agents`, {
+      headers,
+      signal: ac.signal,
+    })
+    clearTimeout(timer)
+    if (!resp.ok) return null
+    const data = await resp.json()
+    const agents = (data.agents || data || [])
+    return agents
+      .filter(a => a.id && a.id !== "direct")
+      .map(a => ({
+        id:          a.id,
+        name:        a.name || a.id,
+        description: a.description || "",
+        category:    a.category || "",
+        tags:        a.tags || [],
+      }))
+  } catch {
+    clearTimeout(timer)
+    return null
+  }
+}
+
+// ── SSE Parser ──────────────────────────────────────────────────────
+
+function parseSSEStream(raw) {
+  const chunks = []
+  for (const line of raw.split("\n")) {
+    if (!line.startsWith("data: ")) continue
+    const payload = line.slice(6).trim()
+    if (payload === "[DONE]") break
+    try { chunks.push(JSON.parse(payload)) } catch { /* skip malformed */ }
+  }
+  return chunks
+}
+
+function extractFromChunks(chunks) {
+  let conversationId = ""
+  let text = ""
+  let toolCall = null
+  let finishReason = null
+
+  for (const chunk of chunks) {
+    if (chunk.x_conversation_id) conversationId = chunk.x_conversation_id
+    const choice = chunk.choices?.[0]
+    if (!choice) continue
+    if (choice.delta?.content)             text += choice.delta.content
+    if (choice.delta?.tool_calls?.length)  {
+      const tc = choice.delta.tool_calls[0]
+      toolCall = { id: tc.id, name: tc.function?.name, arguments: tc.function?.arguments }
+    }
+    if (choice.finish_reason) finishReason = choice.finish_reason
+  }
+  return { conversationId, text, toolCall, finishReason }
+}
+
+// ── Error Helpers ───────────────────────────────────────────────────
+
+function parseAPIError(responseText) {
+  try {
+    const data = JSON.parse(responseText)
+    return data?.error?.message || data?.error || responseText
+  } catch {
+    return responseText
+  }
+}
+
+function formatAPIError(status, responseText) {
+  const msg = parseAPIError(responseText)
+  switch (status) {
+    case 401:
+      return `Authentication failed: ${msg}. Check your MegaRouter API key in opencode.json provider.mega-router.options.apiKey`
+    case 402:
+      return `Insufficient credits. ${msg}. Top up your balance to continue using cloud agents.`
+    case 404:
+      return `Agent not found: ${msg}. Run with a valid agent name — check available agents in the system prompt.`
+    case 429:
+      return `Rate limited: ${msg}. Too many requests — wait a moment and retry.`
+    case 500:
+    case 502:
+      return `MegaRouter server error (${status}): ${msg}. The backend may be restarting — retry in a few seconds.`
+    case 503:
+      return `MegaRouter unavailable (503): ${msg}. The service is temporarily down — retry shortly.`
+    default:
+      return `MegaRouter API error (${status}): ${msg}`
+  }
+}
+
+// ── Local Tool Executor ─────────────────────────────────────────────
+
+async function executeLocalTool(toolName, argsJson, directory) {
+  let args
+  try { args = JSON.parse(argsJson) } catch { return `Error: invalid JSON arguments for ${toolName}: ${argsJson.slice(0, 200)}` }
+
+  const { execSync }   = await import("child_process")
+  const { readFileSync, readdirSync, statSync, writeFileSync, mkdirSync } = await import("fs")
+  const { join, dirname } = await import("path")
+
+  const resolve = (p) => {
+    if (!p) return directory
+    if (p.startsWith("/")) return p
+    return join(directory, p)
+  }
+
+  try {
+    switch (toolName) {
+      case "Read": {
+        const target = resolve(args.file_path)
+        const stat = statSync(target)
+        if (stat.isDirectory()) {
+          return readdirSync(target, { withFileTypes: true })
+            .map(e => e.isDirectory() ? `${e.name}/` : e.name)
+            .join("\n")
+        }
+        const content = readFileSync(target, "utf-8")
+        return content.length > 100_000
+          ? content.slice(0, 100_000) + "\n... [truncated at 100 KB]"
+          : content
+      }
+
+      case "Bash": {
+        const result = execSync(args.command, {
+          cwd: directory, timeout: 30_000,
+          maxBuffer: 1024 * 1024, encoding: "utf-8",
+          stdio: ["pipe", "pipe", "pipe"],
+        })
+        return (result.length > 100_000
+          ? result.slice(0, 100_000) + "\n... [truncated at 100 KB]"
+          : result) || "(no output)"
+      }
+
+      case "Glob": {
+        const cmd = `find . -path './${args.pattern}' 2>/dev/null | head -200`
+        try {
+          const r = execSync(cmd, { cwd: directory, timeout: 10_000, maxBuffer: 256 * 1024, encoding: "utf-8" })
+          return r.trim() || "(no matches)"
+        } catch { return "(no matches)" }
+      }
+
+      case "Grep": {
+        const inc   = args.include ? `--include='${args.include}'` : ""
+        const paths = args.paths?.join(" ") || "."
+        const safe  = args.pattern.replace(/'/g, "'\\''")
+        const cmd   = `grep -rn ${inc} '${safe}' ${paths} 2>/dev/null | head -150`
+        try {
+          return execSync(cmd, { cwd: directory, timeout: 15_000, maxBuffer: 512 * 1024, encoding: "utf-8" }) || "(no matches)"
+        } catch (e) { return e.stdout || "(no matches)" }
+      }
+
+      case "Edit": {
+        const target  = resolve(args.file_path)
+        const content = readFileSync(target, "utf-8")
+        if (!content.includes(args.old_string)) return `Error: old_string not found in ${args.file_path}. File exists but the search string doesn't match.`
+        writeFileSync(target, content.replace(args.old_string, args.new_string), "utf-8")
+        return `Edited ${args.file_path}`
+      }
+
+      case "Write": {
+        const target = resolve(args.file_path)
+        mkdirSync(dirname(target), { recursive: true })
+        writeFileSync(target, args.content, "utf-8")
+        return `Wrote ${args.file_path}`
+      }
+
+      default:
+        return `Tool "${toolName}" is not available in this context. Use Read, Bash, Glob, or Grep.`
+    }
+  } catch (err) {
+    return `Error executing ${toolName}: ${err.message}`
+  }
+}
+
+// ── Client Tool Definitions ─────────────────────────────────────────
+
+const CLIENT_TOOLS = [
+  { type: "function", function: { name: "Read",  description: "Read file contents or list directory contents", parameters: { type: "object", properties: { file_path: { type: "string", description: "Path to file or directory" } }, required: ["file_path"] } } },
+  { type: "function", function: { name: "Bash",  description: "Execute bash command in local environment",     parameters: { type: "object", properties: { command:   { type: "string", description: "Bash command to execute" } }, required: ["command"]   } } },
+  { type: "function", function: { name: "Glob",  description: "Find files matching pattern",                   parameters: { type: "object", properties: { pattern:   { type: "string", description: "Glob pattern like **/*.go" } }, required: ["pattern"]   } } },
+  { type: "function", function: { name: "Grep",  description: "Search code with regex pattern",                parameters: { type: "object", properties: { pattern: { type: "string", description: "Regex pattern" }, paths: { type: "array", items: { type: "string" }, description: "Paths to search" }, include: { type: "string", description: "File pattern to include" } }, required: ["pattern"] } } },
+  { type: "function", function: { name: "Edit",  description: "Replace text in file",                          parameters: { type: "object", properties: { file_path: { type: "string" }, old_string: { type: "string" }, new_string: { type: "string" } }, required: ["file_path", "old_string", "new_string"] } } },
+  { type: "function", function: { name: "Write", description: "Create or overwrite file",                      parameters: { type: "object", properties: { file_path: { type: "string" }, content: { type: "string" } }, required: ["file_path", "content"] } } },
+]
+
+// ── Cloud Agent Call with Tool Loop ─────────────────────────────────
+
+async function callCloudAgent(baseUrl, apiKey, agentName, message, abort, directory) {
+  const model = `${MODEL_PREFIX}${agentName}`
+  const url   = `${baseUrl}/v1/chat/completions`
+  const deadline = Date.now() + TOTAL_TIMEOUT_MS
+
+  let conversationId = ""
+  let messages = [{ role: "user", content: message }]
+  let fullText = ""
+
+  for (let round = 0; round < MAX_TOOL_ROUNDS; round++) {
+    if (abort?.aborted) throw new Error("Aborted by user")
+    if (Date.now() > deadline) {
+      return fullText || `Cloud agent timed out after ${TOTAL_TIMEOUT_MS / 1000}s. Partial output above (if any).`
+    }
+
+    const headers = { "Content-Type": "application/json" }
+    if (apiKey)         headers["Authorization"]     = `Bearer ${apiKey}`
+    if (conversationId) headers["X-Conversation-ID"] = conversationId
+
+    const response = await fetch(url, {
+      method: "POST",
+      headers,
+      body: JSON.stringify({ model, messages, stream: true, tools: CLIENT_TOOLS }),
+      signal: abort,
+    })
+
+    if (!response.ok) {
+      const errText = await response.text().catch(() => "")
+      throw new Error(formatAPIError(response.status, errText))
+    }
+
+    const raw = await response.text()
+    const chunks = parseSSEStream(raw)
+    const { conversationId: cid, text, toolCall, finishReason } = extractFromChunks(chunks)
+
+    if (cid) conversationId = cid
+    if (text) fullText += text
+
+    if (finishReason === "tool_calls" && toolCall) {
+      const toolResult = await executeLocalTool(toolCall.name, toolCall.arguments, directory)
+      messages = [
+        ...messages,
+        {
+          role: "assistant",
+          content: null,
+          tool_calls: [{ id: toolCall.id, type: "function", function: { name: toolCall.name, arguments: toolCall.arguments } }],
+        },
+        {
+          role: "tool",
+          tool_call_id: toolCall.id,
+          content: toolResult,
+        },
+      ]
+      continue
+    }
+
+    return fullText || "(Cloud agent returned no text)"
+  }
+
+  return fullText || `Cloud agent exhausted ${MAX_TOOL_ROUNDS} tool rounds without completing.`
+}
+
+// ── System Prompt Builder ───────────────────────────────────────────
+
+function buildSystemPrompt(agents) {
+  const grouped = {}
+  for (const a of agents) {
+    const cat = a.category || "other"
+    if (!grouped[cat]) grouped[cat] = []
+    grouped[cat].push(a)
+  }
+
+  const categoryLabels = {
+    coding:       "Coding & Review",
+    security:     "Security",
+    research:     "Research & Analysis",
+    productivity: "Productivity",
+    creative:     "Creative",
+    other:        "Other",
+  }
+
+  let table = ""
+  for (const [cat, label] of Object.entries(categoryLabels)) {
+    const items = grouped[cat]
+    if (!items?.length) continue
+    table += `\n**${label}**\n`
+    for (const a of items) {
+      table += `| ${a.id} | ${a.description} |\n`
+    }
+  }
+
+  return `## MegaRouter Cloud Agents
+
+You have access to MegaRouter cloud agents — domain-trained specialist AIs with dedicated skills and sandboxed execution. They produce better, more focused results than you for their specialty.
+
+### How to invoke
+
+Cloud agents are registered as native subagents. Use \`task()\`:
+\`\`\`
+task(subagent_type="code-reviewer", prompt="Review backend/internal/auth/session.go for security issues.")
+\`\`\`
+
+If \`task()\` is unavailable, use the \`cloud_agent\` tool as fallback:
+\`\`\`
+cloud_agent(agent="code-reviewer", message="Review backend/internal/auth/session.go for security issues.")
+\`\`\`
+
+### Available agents
+
+| Agent | Specialty |
+|-------|-----------|${table}
+
+### Tips
+- **Be specific**: Include file paths, code snippets, and exactly what you need.
+- **One task per call**: Don't bundle unrelated tasks.
+- Cloud agents can read files, run commands, and search your local codebase.`
+}
+
+// ── Tool Creator ────────────────────────────────────────────────────
+
+function createCloudAgentTool() {
+  const fallbackDesc = FALLBACK_AGENTS.map(a => `${a.id} (${a.description})`).join("; ")
+
+  return tool({
+    description: `Delegate a task to a MegaRouter cloud agent — a domain-trained specialist AI with dedicated skills and sandboxed execution. Cloud agents can read files, run commands, and search your codebase. This is a fallback — prefer using task(subagent_type="agent-name") when available.
+
+Available agents: ${fallbackDesc}
+
+Use when: code review, security audit, frontend advice, debugging, documentation, DevOps, research, data analysis, API testing, or creative writing.`,
+
+    args: {
+      agent: tool.schema.string().describe(
+        `Cloud agent name. One of: ${FALLBACK_AGENTS.map(a => a.id).join(", ")}`
+      ),
+      message: tool.schema.string().describe(
+        "The task to send. Be specific — include file paths, code context, and what you need."
+      ),
+    },
+
+    async execute(args, ctx) {
+      const agentName = args.agent.trim().toLowerCase()
+      const agents    = agentList()
+      const known     = agents.find(a => a.id === agentName)
+
+      if (!known) {
+        const available = agents.map(a => a.id)
+        const closest   = available.find(id => id.includes(agentName) || agentName.includes(id))
+        const hint      = closest ? ` Did you mean "${closest}"?` : ""
+        return `Unknown cloud agent "${args.agent}".${hint} Available: ${available.join(", ")}`
+      }
+
+      const config = resolveConfig()
+      try {
+        const result = await callCloudAgent(
+          config.baseUrl,
+          config.apiKey,
+          agentName,
+          args.message,
+          ctx.abort,
+          ctx.directory || process.cwd(),
+        )
+        return `[Cloud Agent: ${agentName}]\n\n${result}`
+      } catch (err) {
+        return `Cloud agent "${agentName}" error: ${err.message || err}`
+      }
+    },
+  })
+}
+
+// ── Plugin Entry Point ──────────────────────────────────────────────
+
+const plugin = async (ctx) => {
+  projectDir = ctx?.directory || ctx?.worktree || null
+
+  return {
+    config: async (cfg) => {
+      providerConfigCache = null
+      discoveredAgents = []
+
+      if (cfg?.provider?.[PROVIDER_KEY]) {
+        providerConfigCache = cfg.provider
+      }
+
+      const config = resolveConfig()
+      if (config.baseUrl) {
+        const agents = await discoverAgents(config.baseUrl, config.apiKey)
+        if (agents && agents.length > 0) {
+          discoveredAgents = agents
+          await writeCachedManifest(projectDir, agents)
+        }
+      }
+
+      if (discoveredAgents.length === 0) {
+        const cached = await readCachedManifest(projectDir)
+        if (cached) discoveredAgents = cached
+      }
+
+      const agents = agentList()
+
+      if (!cfg.agent) cfg.agent = {}
+      for (const agent of agents) {
+        if (cfg.agent[agent.id]) continue
+        cfg.agent[agent.id] = {
+          model:       `${PROVIDER_KEY}/${MODEL_PREFIX}${agent.id}`,
+          mode:        "subagent",
+          description: agent.description,
+        }
+      }
+
+      if (cfg.provider?.[PROVIDER_KEY]) {
+        if (!cfg.provider[PROVIDER_KEY].models) cfg.provider[PROVIDER_KEY].models = {}
+        for (const agent of agents) {
+          const modelKey = `${MODEL_PREFIX}${agent.id}`
+          if (cfg.provider[PROVIDER_KEY].models[modelKey]) continue
+          cfg.provider[PROVIDER_KEY].models[modelKey] = {
+            name:      agent.name || agent.id,
+            tool_call: true,
+            limit:     { context: 200000, output: 32000 },
+          }
+        }
+      }
+    },
+
+    tool: {
+      cloud_agent: createCloudAgentTool(),
+    },
+
+    "experimental.chat.system.transform": async (_input, output) => {
+      output.system.push(buildSystemPrompt(agentList()))
+    },
+  }
+}
+
+export default plugin

package/package.json

@@ -0,0 +1,39 @@
+{
+  "name": "opencode-mega-agent",
+  "version": "0.1.0",
+  "description": "OpenCode plugin for MegaRouter cloud agents — auto-discovers and registers specialist AI agents (code review, security audit, debugging, etc.) as native subagents",
+  "main": "index.mjs",
+  "type": "module",
+  "license": "MIT",
+  "keywords": [
+    "opencode",
+    "opencode-plugin",
+    "megarouter",
+    "cloud-agent",
+    "ai-agent",
+    "code-review",
+    "security-audit"
+  ],
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/kiyoakii/mega-router.git",
+    "directory": "plugins/opencode-cloud-agent"
+  },
+  "homepage": "https://github.com/kiyoakii/mega-router/tree/main/plugins/opencode-cloud-agent#readme",
+  "bugs": {
+    "url": "https://github.com/kiyoakii/mega-router/issues"
+  },
+  "files": [
+    "index.mjs",
+    "README.md"
+  ],
+  "engines": {
+    "node": ">=18"
+  },
+  "dependencies": {
+    "@opencode-ai/plugin": "^1.3.2"
+  },
+  "devDependencies": {
+    "vitest": "^3.1.1"
+  }
+}