mio-agent-runtime 0.1.0

package/README.md

@@ -0,0 +1,41 @@
+# mio-agent-runtime
+
+Mio Agent Runtime 的可发布 CLI 包。
+
+安装一次，所有 Agent 自动接入 Mio。
+
+## Install
+
+```bash
+npm install -g mio-agent-runtime
+```
+
+## Commands
+
+```text
+mio init                    Initialize MIO_HOME
+mio mcp                     Start Mio MCP server (stdio)
+mio install <host>          Install Mio into a host (codex|opencode|workbuddy)
+mio status                  Show runtime and adapter status
+mio agents                  List installed agents
+mio --json status           Machine-readable status
+mio --json agents           Machine-readable agents
+```
+
+## MIO_HOME
+
+默认 `~/.mio-intelligence`，可通过环境变量 `MIO_HOME` 覆盖。
+
+## Package layout
+
+```text
+packages/mio-cli
+├── bin/mio.js
+├── adapters/
+│   ├── codex.js
+│   ├── opencode.js
+│   └── workbuddy.js
+├── server/
+│   └── mio-intelligence-mcp/index.js
+└── package.json
+```

package/adapters/codex.js

@@ -0,0 +1,62 @@
+'use strict'
+
+const fs = require('fs')
+const path = require('path')
+const os = require('os')
+
+function configPath() {
+  return path.join(os.homedir(), '.codex', 'config.toml')
+}
+
+function isInstalled() {
+  const target = configPath()
+  if (!fs.existsSync(target)) return false
+  return fs.readFileSync(target, 'utf8').includes('[mcp_servers.mio-intelligence]')
+}
+
+function install({ node, serverScript, home, workspace }) {
+  const target = configPath()
+  const backup = `${target}.bak-mio-${Date.now()}`
+  if (isInstalled()) {
+    return {
+      changed: false,
+      configPath: target,
+      message: 'Codex Mio MCP already installed.',
+    }
+  }
+
+  if (fs.existsSync(target)) {
+    fs.copyFileSync(target, backup)
+  }
+
+  const context = JSON.stringify({
+    agentId: 'codex',
+    workspace: workspace || process.cwd(),
+    sessionId: 'codex-session',
+  })
+
+  fs.mkdirSync(path.dirname(target), { recursive: true })
+  let toml = fs.existsSync(target) ? fs.readFileSync(target, 'utf8') : ''
+  if (!toml.endsWith('\n')) toml += '\n'
+  const section = [
+    '[mcp_servers.mio-intelligence]',
+    `command = '${node}'`,
+    `args = ['${serverScript}']`,
+    'startup_timeout_sec = 30',
+    '',
+    '[mcp_servers.mio-intelligence.env]',
+    `MIO_DATA_DIR = '${home}'`,
+    `MIO_CONTEXT = '${context}'`,
+    '',
+  ].join('\n')
+  fs.writeFileSync(target, `${toml}${section}\n`, 'utf8')
+
+  return {
+    changed: true,
+    configPath: target,
+    backup,
+    message: 'Codex Mio MCP installed. Restart Codex to load it.',
+  }
+}
+
+module.exports = { configPath, isInstalled, install }

package/adapters/opencode.js

@@ -0,0 +1,14 @@
+'use strict'
+
+function isInstalled() {
+  return false
+}
+
+function install() {
+  return {
+    changed: false,
+    message: 'OpenCode adapter is not implemented yet.',
+  }
+}
+
+module.exports = { isInstalled, install }

package/adapters/workbuddy.js

@@ -0,0 +1,14 @@
+'use strict'
+
+function isInstalled() {
+  return false
+}
+
+function install() {
+  return {
+    changed: false,
+    message: 'WorkBuddy adapter is not implemented yet.',
+  }
+}
+
+module.exports = { isInstalled, install }

package/bin/mio.js

@@ -0,0 +1,180 @@
+#!/usr/bin/env node
+'use strict'
+
+const fs = require('fs')
+const path = require('path')
+const os = require('os')
+
+const SERVER_SCRIPT = path.resolve(__dirname, '..', 'server', 'mio-intelligence-mcp', 'index.js')
+const MIO_HOME = process.env.MIO_HOME || path.join(os.homedir(), '.mio-intelligence')
+const CONFIG_FILE = path.join(MIO_HOME, 'config.json')
+
+const adapters = {
+  codex: require('../adapters/codex.js'),
+  opencode: require('../adapters/opencode.js'),
+  workbuddy: require('../adapters/workbuddy.js'),
+}
+
+function ensureHome() {
+  fs.mkdirSync(MIO_HOME, { recursive: true })
+  fs.mkdirSync(path.join(MIO_HOME, 'logs'), { recursive: true })
+}
+
+function readConfig() {
+  const fallback = { version: 1, home: MIO_HOME, agents: {} }
+  if (!fs.existsSync(CONFIG_FILE)) return fallback
+  try {
+    return { ...fallback, ...JSON.parse(fs.readFileSync(CONFIG_FILE, 'utf8')) }
+  } catch (_) {
+    return fallback
+  }
+}
+
+function writeConfig(config) {
+  ensureHome()
+  fs.writeFileSync(CONFIG_FILE, `${JSON.stringify(config, null, 2)}\n`, 'utf8')
+}
+
+function jsonOrText(payload, useJson) {
+  if (useJson) {
+    console.log(JSON.stringify(payload, null, 2))
+    return
+  }
+  return payload
+}
+
+function initCommand() {
+  ensureHome()
+  const config = readConfig()
+  if (!config.createdAt) config.createdAt = new Date().toISOString()
+  writeConfig(config)
+  console.log(`MIO_HOME ready: ${MIO_HOME}`)
+}
+
+function statusCommand(useJson) {
+  const config = readConfig()
+  const codex = adapters.codex
+  const installed = codex.isInstalled()
+  const payload = {
+    version: config.version,
+    home: MIO_HOME,
+    serverScript: SERVER_SCRIPT,
+    serverScriptExists: fs.existsSync(SERVER_SCRIPT),
+    agents: config.agents || {},
+    codexInstalled: installed,
+  }
+  if (useJson) {
+    jsonOrText(payload, true)
+    return
+  }
+  console.log(`MIO_HOME: ${MIO_HOME}`)
+  console.log(`MCP Server: ${SERVER_SCRIPT}`)
+  console.log(`Codex MCP: ${installed ? 'installed' : 'not installed'}`)
+}
+
+function agentsCommand(useJson) {
+  const config = readConfig()
+  const agents = config.agents || {}
+  if (useJson) {
+    jsonOrText(agents, true)
+    return
+  }
+  const names = Object.keys(agents)
+  if (names.length === 0) {
+    console.log('No agents installed.')
+    return
+  }
+  for (const name of names) {
+    console.log(`${name}\t${agents[name].installedAt || ''}`)
+  }
+}
+
+function installCommand(host, useJson) {
+  if (!host) {
+    console.error('Usage: mio install <codex|opencode|workbuddy>')
+    process.exitCode = 1
+    return
+  }
+  const adapter = adapters[host]
+  if (!adapter) {
+    console.error(`Unknown host: ${host}`)
+    process.exitCode = 1
+    return
+  }
+  ensureHome()
+  const config = readConfig()
+  let result
+  try {
+    result = adapter.install({
+      node: process.execPath,
+      serverScript: SERVER_SCRIPT,
+      home: MIO_HOME,
+      workspace: process.cwd(),
+    })
+  } catch (error) {
+    console.error(`Failed to install ${host}: ${error.message || error}`)
+    process.exitCode = 1
+    return
+  }
+  if (result.changed) {
+    config.agents = config.agents || {}
+    config.agents[host] = {
+      installedAt: new Date().toISOString(),
+      configPath: result.configPath || null,
+    }
+    writeConfig(config)
+  }
+  if (useJson) {
+    jsonOrText(result, true)
+    return
+  }
+  console.log(result.message || `${host} adapter completed.`)
+}
+
+function mcpCommand() {
+  require(SERVER_SCRIPT)
+}
+
+function help() {
+  console.log(`Mio Agent Runtime CLI
+
+Usage:
+  mio init                    Initialize MIO_HOME
+  mio mcp                     Start Mio MCP server (stdio)
+  mio install <host>          Install Mio into a host (codex|opencode|workbuddy)
+  mio status                  Show runtime and adapter status
+  mio agents                  List installed agents
+  mio --json status           Machine-readable status
+  mio --json agents           Machine-readable agents
+`)
+}
+
+function main() {
+  const args = process.argv.slice(2)
+  const jsonIndex = args.indexOf('--json')
+  const useJson = jsonIndex !== -1
+  if (useJson) args.splice(jsonIndex, 1)
+  const command = args[0] || 'help'
+
+  switch (command) {
+    case 'init':
+      return initCommand()
+    case 'mcp':
+      return mcpCommand()
+    case 'install':
+      return installCommand(args[1], useJson)
+    case 'status':
+      return statusCommand(useJson)
+    case 'agents':
+      return agentsCommand(useJson)
+    case 'help':
+    case '--help':
+      return help()
+    default:
+      console.error(`Unknown command: ${command}`)
+      help()
+      process.exitCode = 1
+  }
+}
+
+main()

package/package.json

@@ -0,0 +1,23 @@
+{
+  "name": "mio-agent-runtime",
+  "version": "0.1.0",
+  "description": "Mio Agent Runtime installer and MCP intelligence layer",
+  "license": "MIT",
+  "type": "commonjs",
+  "bin": {
+    "mio": "bin/mio.js"
+  },
+  "files": [
+    "bin/",
+    "server/",
+    "adapters/",
+    "README.md"
+  ],
+  "scripts": {
+    "check": "node --check bin/mio.js && node --check adapters/codex.js && node --check adapters/opencode.js && node --check adapters/workbuddy.js && node --check server/mio-intelligence-mcp/index.js",
+    "prepack": "npm run check"
+  },
+  "engines": {
+    "node": ">=18"
+  }
+}

package/server/mio-intelligence-mcp/index.js

@@ -0,0 +1,432 @@
+#!/usr/bin/env node
+'use strict'
+
+const fs = require('fs')
+const path = require('path')
+const crypto = require('crypto')
+const readline = require('readline')
+const { execFileSync } = require('child_process')
+
+const SERVER_INFO = { name: 'mio-intelligence-mcp', version: '0.1.0' }
+const PROTOCOL_VERSION = '2024-11-05'
+
+const dataDir = path.resolve(
+  process.env.MIO_DATA_DIR || path.join(process.cwd(), '.mio-intelligence')
+)
+const memoryPath = path.join(dataDir, 'memory.jsonl')
+const tracePath = path.join(dataDir, 'traces.jsonl')
+const experienceReusePath = path.join(dataDir, 'experience_reuse.jsonl')
+fs.mkdirSync(dataDir, { recursive: true })
+
+let runtimeContext = {}
+try {
+  const rawContext = process.env.MIO_CONTEXT
+  if (rawContext) {
+    const parsed = JSON.parse(rawContext)
+    if (parsed && typeof parsed === 'object' && !Array.isArray(parsed)) {
+      runtimeContext = parsed
+    }
+  }
+} catch (_) {
+  runtimeContext = {}
+}
+
+function runtimeAgentId() {
+  return runtimeContext.agentId || null
+}
+
+function createId(prefix) {
+  return `${prefix}_${Date.now()}_${crypto.randomBytes(6).toString('hex')}`
+}
+
+function appendJsonl(file, value) {
+  fs.appendFileSync(file, `${JSON.stringify(value)}\n`, 'utf8')
+}
+
+function readJsonl(file) {
+  if (!fs.existsSync(file)) return []
+  return fs
+    .readFileSync(file, 'utf8')
+    .split(/\r?\n/)
+    .filter(Boolean)
+    .map((line) => {
+      try {
+        return JSON.parse(line)
+      } catch (_) {
+        return null
+      }
+    })
+    .filter(Boolean)
+}
+
+let lastProjectCwd = null
+let lastProjectName = null
+
+function projectName() {
+  const currentCwd = process.cwd()
+  if (lastProjectCwd === currentCwd && lastProjectName) {
+    return lastProjectName
+  }
+  lastProjectCwd = currentCwd
+  if (runtimeContext.project) {
+    lastProjectName = runtimeContext.project
+    return lastProjectName
+  }
+  try {
+    const commonDir = execFileSync(
+      'git',
+      ['rev-parse', '--path-format=absolute', '--git-common-dir'],
+      {
+        cwd: currentCwd,
+        encoding: 'utf8',
+        stdio: ['ignore', 'pipe', 'ignore'],
+      }
+    ).trim()
+    if (commonDir) {
+      const repoRoot = path.dirname(commonDir)
+      const name = path.basename(repoRoot)
+      if (name) {
+        lastProjectName = name
+        return lastProjectName
+      }
+    }
+  } catch (_) {
+    // fall through to cwd basename
+  }
+  lastProjectName = path.basename(currentCwd)
+  return lastProjectName
+}
+
+function normalizeTags(tags) {
+  if (Array.isArray(tags)) return tags.map((tag) => String(tag).trim()).filter(Boolean)
+  if (typeof tags === 'string') {
+    return tags
+      .split(',')
+      .map((tag) => tag.trim())
+      .filter(Boolean)
+  }
+  return []
+}
+
+function tokenize(text) {
+  const normalized = String(text || '').toLowerCase()
+  const latin = normalized.match(/[a-z0-9]+/g) || []
+  const cjk = (normalized.match(/[\u4e00-\u9fff]/g) || []).map((char) => `cjk:${char}`)
+  return [...latin, ...cjk]
+}
+
+function scoreRecord(record, queryTokens, project) {
+  if (project && record.project && record.project !== project) return 0
+  const haystack = tokenize(
+    `${record.content || ''} ${(record.tags || []).join(' ')} ${record.kind || ''}`
+  )
+  let score = 0
+  for (const token of queryTokens) {
+    if (haystack.includes(token)) score += 1
+  }
+  if (record.timestamp) {
+    const ageDays = Math.max(0, (Date.now() - Date.parse(record.timestamp)) / 86400000)
+    score += Math.max(0, 0.5 - ageDays * 0.05)
+  }
+  return score
+}
+
+function queryMemory(args = {}) {
+  const query = String(args.query || '')
+  const project = args.project || projectName()
+  const limit = Math.min(Math.max(Number(args.limit) || 5, 1), 20)
+  const tokens = tokenize(query)
+  const results = readJsonl(memoryPath)
+    .filter((record) => scoreRecord(record, tokens, project) > 0)
+    .sort((a, b) => {
+      return scoreRecord(b, tokens, project) - scoreRecord(a, tokens, project)
+    })
+    .slice(0, limit)
+  return {
+    query,
+    project,
+    count: results.length,
+    results,
+  }
+}
+
+function recordMemory(args = {}) {
+  const content = String(args.content || '').trim()
+  if (!content) throw new Error('memory.record requires a non-empty content')
+  const record = {
+    id: createId('mem'),
+    timestamp: new Date().toISOString(),
+    kind: args.kind || 'note',
+    content,
+    tags: normalizeTags(args.tags),
+    project: args.project || projectName(),
+    source: args.source || runtimeAgentId() || 'mcp',
+  }
+  appendJsonl(memoryPath, record)
+  return record
+}
+
+function ingestObservation(args = {}) {
+  const traceId = String(args.trace_id || '').trim()
+  const eventType = String(args.event_type || '').trim()
+  if (!traceId) throw new Error('observer.ingest requires trace_id')
+  if (!eventType) throw new Error('observer.ingest requires event_type')
+  const event = {
+    id: createId('trace'),
+    timestamp: new Date().toISOString(),
+    trace_id: traceId,
+    event_type: eventType,
+    outcome: args.outcome || null,
+    payload: args.payload || {},
+    agent: args.agent || runtimeAgentId(),
+    host: args.host || 'mcp',
+    project: args.project || projectName(),
+  }
+  appendJsonl(tracePath, event)
+  return { recorded: true, event }
+}
+
+function policyCheck(args = {}) {
+  const action = String(args.action || '').trim()
+  if (!action) throw new Error('policy.check requires action')
+  const project = args.project || projectName()
+  const actionTokens = tokenize(action)
+  const traces = readJsonl(tracePath).filter((event) => {
+    if (project && event.project && event.project !== project) return false
+    const haystack = tokenize(
+      `${event.event_type || ''} ${JSON.stringify(event.payload || {})}`
+    )
+    return actionTokens.some((token) => haystack.includes(token))
+  })
+  const total = traces.length
+  const failures = traces.filter((event) =>
+    ['failure', 'error', 'aborted', 'retry'].includes(String(event.outcome || '').toLowerCase())
+  ).length
+  const risk = total > 0 ? failures / total : null
+  let suggestion
+  if (total === 0) {
+    suggestion = 'No history for this action. Treat as normal risk and record the outcome.'
+  } else if (risk >= 0.4) {
+    suggestion = 'Historically risky. Prefer an alternative approach or add rollback/verification.'
+  } else if (risk >= 0.2) {
+    suggestion = 'Moderate risk. Add verification before proceeding.'
+  } else {
+    suggestion = 'Low historical risk. Proceed with normal checks.'
+  }
+  const relatedMemories = readJsonl(memoryPath)
+    .filter((record) => scoreRecord(record, actionTokens, project) > 0)
+    .sort((a, b) => scoreRecord(b, actionTokens, project) - scoreRecord(a, actionTokens, project))
+    .slice(0, 3)
+    .map((record) => ({
+      id: record.id,
+      timestamp: record.timestamp,
+      kind: record.kind,
+      content: record.content,
+      tags: record.tags,
+    }))
+  return {
+    action,
+    project,
+    total,
+    failures,
+    risk: risk === null ? null : Number(risk.toFixed(3)),
+    suggestion,
+    related_memories: relatedMemories,
+  }
+}
+
+function recordExperienceReuse(args = {}) {
+  const sourceAgent = String(args.sourceAgent || '').trim()
+  const targetAgent = String(args.targetAgent || '').trim()
+  const experienceId = String(args.experienceId || '').trim()
+  if (!sourceAgent) throw new Error('experience.reuse requires sourceAgent')
+  if (!targetAgent) throw new Error('experience.reuse requires targetAgent')
+  if (!experienceId) throw new Error('experience.reuse requires experienceId')
+
+  const evidence = {
+    id: createId('xfer'),
+    timestamp: new Date().toISOString(),
+    sourceAgent,
+    targetAgent,
+    experienceId,
+    reuse: args.reuse === true || args.reuse === 'true',
+    behaviorChanged: args.behaviorChanged === true || args.behaviorChanged === 'true',
+    outcomeImproved: args.outcomeImproved === true || args.outcomeImproved === 'true',
+    project: args.project || projectName(),
+    notes: args.notes || null,
+  }
+  appendJsonl(experienceReusePath, evidence)
+  return evidence
+}
+
+const TOOLS = [
+  {
+    name: 'mio.memory.query',
+    description: 'Search local Mio project memory for context, decisions, and historical problems.',
+    inputSchema: {
+      type: 'object',
+      properties: {
+        query: { type: 'string', description: 'Question or topic to recall.' },
+        project: { type: 'string', description: 'Project name filter. Defaults to current directory name.' },
+        limit: { type: 'number', description: 'Maximum results, between 1 and 20. Defaults to 5.' },
+      },
+      required: ['query'],
+    },
+  },
+  {
+    name: 'mio.memory.record',
+    description: 'Record a decision, project context, or historical problem into local Mio memory.',
+    inputSchema: {
+      type: 'object',
+      properties: {
+        content: { type: 'string', description: 'Memory content.' },
+        kind: { type: 'string', description: 'Memory kind, such as decision, context, or problem.' },
+        tags: { type: 'array', items: { type: 'string' }, description: 'Optional tags.' },
+        project: { type: 'string', description: 'Project name. Defaults to current directory name.' },
+        source: { type: 'string', description: 'Recording source. Defaults to mcp.' },
+      },
+      required: ['content'],
+    },
+  },
+  {
+    name: 'mio.observer.ingest',
+    description: 'Ingest an Agent Trace event such as tool_call, error, retry, or task_outcome.',
+    inputSchema: {
+      type: 'object',
+      properties: {
+        trace_id: { type: 'string', description: 'Stable trace identifier.' },
+        event_type: { type: 'string', description: 'Event type, such as tool_call, error, retry, task_outcome.' },
+        payload: { type: 'object', description: 'Event payload.' },
+        outcome: { type: 'string', description: 'Optional outcome: success, failure, error, aborted, retry.' },
+        agent: { type: 'string', description: 'Agent identifier.' },
+        host: { type: 'string', description: 'Host name. Defaults to mcp.' },
+        project: { type: 'string', description: 'Project name. Defaults to current directory name.' },
+      },
+      required: ['trace_id', 'event_type'],
+    },
+  },
+  {
+    name: 'mio.policy.check',
+    description: 'Check historical risk for an action before executing it.',
+    inputSchema: {
+      type: 'object',
+      properties: {
+        action: { type: 'string', description: 'The action or tool operation to check.' },
+        project: { type: 'string', description: 'Project name filter. Defaults to current directory name.' },
+        context: { type: 'string', description: 'Optional additional context.' },
+      },
+      required: ['action'],
+    },
+  },
+  {
+    name: 'mio.experience.reuse',
+    description: 'Record Phase 0 evidence of cross-agent experience reuse.',
+    inputSchema: {
+      type: 'object',
+      properties: {
+        sourceAgent: { type: 'string', description: 'Agent that produced the experience.' },
+        targetAgent: { type: 'string', description: 'Agent that reused the experience.' },
+        experienceId: { type: 'string', description: 'Stable experience or memory id.' },
+        reuse: { type: 'boolean', description: 'True when memory.query returned historical experience and it was reused.' },
+        behaviorChanged: { type: 'boolean', description: 'True when target Agent behavior changed because of the reused experience.' },
+        outcomeImproved: { type: 'boolean', description: 'True when the task outcome improved.' },
+        project: { type: 'string', description: 'Project name filter. Defaults to current repository.' },
+        notes: { type: 'string', description: 'Optional evidence notes.' },
+      },
+      required: ['sourceAgent', 'targetAgent', 'experienceId', 'reuse', 'behaviorChanged', 'outcomeImproved'],
+    },
+  },
+]
+
+async function callTool(name, args = {}) {
+  switch (name) {
+    case 'mio.memory.query':
+      return queryMemory(args)
+    case 'mio.memory.record':
+      return recordMemory(args)
+    case 'mio.observer.ingest':
+      return ingestObservation(args)
+    case 'mio.policy.check':
+      return policyCheck(args)
+    case 'mio.experience.reuse':
+      return recordExperienceReuse(args)
+    default:
+      throw new Error(`Unknown tool: ${name}`)
+  }
+}
+
+function jsonRpcResult(id, result) {
+  return { jsonrpc: '2.0', id, result }
+}
+
+function jsonRpcError(id, code, message, data) {
+  const error = { code, message }
+  if (data !== undefined) error.data = data
+  return { jsonrpc: '2.0', id, error }
+}
+
+function send(message) {
+  if (message) process.stdout.write(`${JSON.stringify(message)}\n`)
+}
+
+async function handleMessage(message) {
+  if (!message || typeof message !== 'object' || message.jsonrpc !== '2.0') return
+  if (message.method && message.method.startsWith('notifications/')) return
+  if (message.id === undefined) return
+
+  try {
+    if (message.method === 'initialize') {
+      send(
+        jsonRpcResult(message.id, {
+          protocolVersion: PROTOCOL_VERSION,
+          capabilities: { tools: {} },
+          serverInfo: SERVER_INFO,
+        })
+      )
+      return
+    }
+    if (message.method === 'ping') {
+      send(jsonRpcResult(message.id, {}))
+      return
+    }
+    if (message.method === 'tools/list') {
+      send(jsonRpcResult(message.id, { tools: TOOLS }))
+      return
+    }
+    if (message.method === 'tools/call') {
+      const name = message.params && message.params.name
+      const args = (message.params && message.params.arguments) || {}
+      const result = await callTool(name, args)
+      send(
+        jsonRpcResult(message.id, {
+          content: [{ type: 'text', text: JSON.stringify(result, null, 2) }],
+          isError: false,
+        })
+      )
+      return
+    }
+    send(jsonRpcError(message.id, -32601, `Method not found: ${message.method}`))
+  } catch (error) {
+    send(jsonRpcError(message.id, -32603, error.message || String(error)))
+  }
+}
+
+const rl = readline.createInterface({ input: process.stdin, crlfDelay: Infinity })
+
+rl.on('line', (line) => {
+  let message
+  try {
+    message = JSON.parse(line)
+  } catch (_) {
+    return
+  }
+  handleMessage(message).catch((error) => {
+    send(jsonRpcError(message && message.id, -32603, error.message || String(error)))
+  })
+})
+
+rl.on('close', () => {
+  process.exit(0)
+})
+
+module.exports = { TOOLS, callTool, handleMessage, readJsonl, appendJsonl }