mio-agent-runtime 0.5.14 → 0.5.16

package/server/runtime-modules.js

@@ -0,0 +1,111 @@
+'use strict'
+
+const fs = require('fs')
+const path = require('path')
+
+const RUNTIME_NAME = 'mio-agent-runtime'
+
+const evolutionModules = [
+  {
+    name: '@akemi-mio/runtime-contracts',
+    packageDir: 'runtime-contracts',
+    health: (module) => typeof module.createRuntimeEvent === 'function',
+  },
+  {
+    name: '@akemi-mio/runtime-foundation',
+    packageDir: 'runtime-foundation',
+    health: (module) => typeof module.JsonlStore === 'function' && typeof module.EventBus === 'function',
+  },
+  {
+    name: '@akemi-mio/experience-memory',
+    packageDir: 'experience-memory',
+    health: (module) => typeof module.ExperienceMemory === 'function',
+  },
+  {
+    name: '@akemi-mio/evolution-learning',
+    packageDir: 'evolution-learning',
+    health: (module) => typeof module.createLearningModule === 'function' && typeof module.evaluateAnalysis === 'function',
+  },
+  {
+    name: '@akemi-mio/evolution-strategy',
+    packageDir: 'evolution-strategy',
+    health: (module) => typeof module.createStrategyModule === 'function' && typeof module.buildProposal === 'function',
+  },
+  {
+    name: '@akemi-mio/evolution-safety',
+    packageDir: 'evolution-safety',
+    health: (module) => typeof module.createSafetyModule === 'function' && typeof module.validateProposal === 'function',
+  },
+  {
+    name: '@akemi-mio/evolution-scheduler',
+    packageDir: 'evolution-scheduler',
+    health: (module) => typeof module.createSchedulerModule === 'function' && typeof module.createSchedulePlan === 'function',
+  },
+]
+
+function fallbackPackagePath(entry) {
+  return path.resolve(__dirname, '..', '..', entry.packageDir)
+}
+
+function loadEvolutionModule(entry) {
+  try {
+    return require(entry.name)
+  } catch (_) {
+    return require(fallbackPackagePath(entry))
+  }
+}
+
+function readPackageVersion(entry) {
+  try {
+    const packagePath = require.resolve(`${entry.name}/package.json`)
+    return JSON.parse(fs.readFileSync(packagePath, 'utf8')).version
+  } catch (_) {
+    try {
+      return JSON.parse(fs.readFileSync(path.join(fallbackPackagePath(entry), 'package.json'), 'utf8')).version
+    } catch (_) {
+      return null
+    }
+  }
+}
+
+function runtimeVersion() {
+  try {
+    return JSON.parse(fs.readFileSync(path.resolve(__dirname, '..', 'package.json'), 'utf8')).version
+  } catch (_) {
+    return null
+  }
+}
+
+function getEvolutionStatus() {
+  const modules = evolutionModules.map((entry) => {
+    let loaded = false
+    let healthy = false
+    try {
+      const module = loadEvolutionModule(entry)
+      loaded = true
+      healthy = Boolean(entry.health(module))
+    } catch (_) {}
+    return {
+      name: entry.name,
+      version: readPackageVersion(entry),
+      loaded,
+      healthy,
+    }
+  })
+  return { runtime: RUNTIME_NAME, version: runtimeVersion(), modules }
+}
+
+function formatEvolutionStatusText(status) {
+  const lines = [`${status.runtime} ${status.version || 'unknown'}`]
+  for (const module of status.modules) {
+    lines.push(`${module.name}@${module.version || 'unknown'}: ${module.healthy ? 'healthy' : 'unavailable'}`)
+  }
+  return lines.join('\n')
+}
+
+module.exports = {
+  RUNTIME_NAME,
+  evolutionModules,
+  getEvolutionStatus,
+  formatEvolutionStatusText,
+}

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

@@ -1,171 +0,0 @@
-const fs = require('fs')
-const path = require('path')
-const http = require('http')
-const os = require('os')
-const { spawn } = require('child_process')
-
-function dataDir() {
-  return process.env.MIO_DATA_DIR || path.join(os.homedir(), '.mio-intelligence')
-}
-
-function readJsonl(file) {
-  const full = path.join(dataDir(), file)
-  if (!fs.existsSync(full)) return []
-  try {
-    return fs.readFileSync(full, 'utf8')
-      .split('\n')
-      .map(function (l) { return l.trim() })
-      .filter(function (l) { return l.length })
-      .map(function (l) {
-        try { return JSON.parse(l) } catch (_) { return null }
-      })
-      .filter(Boolean)
-  } catch (_) {
-    return []
-  }
-}
-
-function tally(rows, keyFn) {
-  const out = {}
-  for (const r of rows) {
-    const k = keyFn(r)
-    if (k == null || k === '') continue
-    out[k] = (out[k] || 0) + 1
-  }
-  return out
-}
-
-function topN(obj, n) {
-  return Object.keys(obj)
-    .sort(function (a, b) { return obj[b] - obj[a] })
-    .slice(0, n)
-    .map(function (k) { return { key: k, count: obj[k] } })
-}
-
-function aggregate() {
-  const memory = readJsonl('memory.jsonl')
-  const traces = readJsonl('traces.jsonl')
-  const experience = readJsonl('experience_reuse.jsonl')
-  const ideas = readJsonl('ideas.jsonl')
-  const suggestions = readJsonl('suggestions.jsonl')
-  const agents = readJsonl('agents.jsonl')
-
-  const memoryByKind = tally(memory, function (r) { return r.kind })
-  const memoryBySource = tally(memory, function (r) { return r.source })
-  const memoryByProject = tally(memory, function (r) { return r.project })
-
-  const tracesByHost = tally(traces, function (r) { return r.host || 'unknown' })
-  const tracesByOutcome = tally(traces, function (r) { return r.outcome || 'unknown' })
-  const tracesByEventType = tally(traces, function (r) { return r.event_type || 'unknown' })
-
-  const taskOutcomes = traces.filter(function (t) { return t.event_type === 'task_outcome' })
-  const successCount = taskOutcomes.filter(function (t) { return t.outcome === 'success' }).length
-  const taskTotal = taskOutcomes.length
-  const successRate = taskTotal ? (successCount / taskTotal * 100).toFixed(1) : '0.0'
-
-  const verified = experience.filter(function (e) {
-    return e.reuse && e.behaviorChanged && e.outcomeImproved
-  }).length
-  const reuseCount = experience.filter(function (e) { return e.reuse }).length
-  const crossAgent = experience.filter(function (e) {
-    return e.sourceAgent && e.targetAgent && e.sourceAgent !== e.targetAgent
-  }).length
-
-  const hosts = Object.keys(tracesByHost).filter(function (h) { return h && h !== 'mcp' })
-  const phase0 = {
-    hosts: hosts.length,
-    tasks: taskTotal,
-    verifiedReuse: verified,
-    successRate: successRate,
-    thresholds: { hosts: 2, tasks: 20, verifiedReuse: 5 },
-    passed: hosts.length >= 2 && taskTotal >= 20 && verified >= 5,
-  }
-
-  function recent(rows, n) {
-    return rows.slice(-n).map(function (r) {
-      return {
-        id: r.id,
-        timestamp: r.timestamp,
-        kind: r.kind || r.event_type || null,
-        source: r.source || r.host || null,
-        text: (r.content || r.notes || r.trace_id || '').toString().slice(0, 160),
-      }
-    })
-  }
-
-  return {
-    generatedAt: new Date().toISOString(),
-    dataDir: dataDir(),
-    summary: {
-      memory: memory.length,
-      traces: traces.length,
-      experience: experience.length,
-      ideas: ideas.length,
-      suggestions: suggestions.length,
-      agents: agents.length,
-    },
-    memoryByKind: topN(memoryByKind, 10),
-    memoryBySource: topN(memoryBySource, 10),
-    memoryByProject: topN(memoryByProject, 10),
-    tracesByHost: topN(tracesByHost, 10),
-    tracesByOutcome: topN(tracesByOutcome, 10),
-    tracesByEventType: topN(tracesByEventType, 10),
-    experience: {
-      total: experience.length,
-      reuse: reuseCount,
-      verified: verified,
-      crossAgent: crossAgent,
-      reuseRate: experience.length ? (reuseCount / experience.length * 100).toFixed(1) : '0.0',
-    },
-    agents: agents.slice(-10),
-    phase0: phase0,
-    ideas: ideas.slice(-10).map(function (i) {
-      return { id: i.id, title: i.title, goal: i.goal, strategy: i.provenance && i.provenance.strategy }
-    }),
-    suggestions: suggestions.slice(-10).map(function (s) {
-      return { id: s.id, title: s.title, nextAction: s.nextAction, impact: s.impact }
-    }),
-    recentMemory: recent(memory, 10).reverse(),
-    recentTraces: recent(traces, 10).reverse(),
-  }
-}
-
-function startServer(port, htmlPath) {
-  const server = http.createServer(function (req, res) {
-    const url = (req.url || '/').split('?')[0]
-    if (url === '/api/data' || url === '/api/health') {
-      res.setHeader('Content-Type', 'application/json; charset=utf-8')
-      res.setHeader('Access-Control-Allow-Origin', '*')
-      if (url === '/api/health') {
-        res.end(JSON.stringify({ ok: true }))
-        return
-      }
-      res.end(JSON.stringify(aggregate(), null, 2))
-      return
-    }
-    if (url === '/' || url === '/index.html' || url === '/dashboard') {
-      res.setHeader('Content-Type', 'text/html; charset=utf-8')
-      if (htmlPath && fs.existsSync(htmlPath)) {
-        res.end(fs.readFileSync(htmlPath, 'utf8'))
-      } else {
-        res.end('<h1>Mio Dashboard</h1><p>HTML not found at ' + htmlPath + '</p>')
-      }
-      return
-    }
-    res.statusCode = 404
-    res.end('Not found')
-  })
-  server.listen(port, function () {
-    console.log('Mio dashboard running at http://localhost:' + port)
-  })
-  return server
-}
-
-// When run directly: `node dashboard-server.js [port]`
-if (require.main === module) {
-  const port = parseInt(process.argv[2] || process.env.MIO_DASHBOARD_PORT || '8787', 10)
-  const htmlPath = path.join(__dirname, '..', '..', 'mio-dashboard.html')
-  startServer(port, htmlPath)
-}
-
-module.exports = { startServer, aggregate, dataDir }