@monoes/monomindcli 1.10.57 → 1.11.1

package/dist/src/ui/server.mjs

@@ -167,7 +167,7 @@ function pathToSections(filename) {
   if (f.includes('route') || f.includes('worker-dispatch'))  return ['hooks'];
   if (f.includes('chunk') || f.includes('skills')) return ['knowledge'];
   if (f.includes('memory.db') || f.includes('memory.graph') || f.includes('hnsw.index') ||
-      f.includes('ruvector.db') || f.includes('ranked-context') ||
+      f.includes('monovector.db') || f.includes('ranked-context') ||
       (f.includes('/memory/') && f.endsWith('.md'))) return ['memory', 'sessions'];
   if (f.includes('palace') || f.includes('drawers') || f.includes('identity')) return ['memory', 'sessions'];
   if (f.includes('ddd') || f.includes('learning') || f.includes('audit')) return ['metrics'];
@@ -294,6 +294,36 @@ function resolveSlugToPath(slug, projDir) {
 }
 
 export async function startServer({ port = 4242, projectDir, openBrowser = true } = {}) {
+  // Parse a .claude/agents/*.md definition into { name, description, capability{}, document }.
+  // Tolerant line-based parse of the YAML frontmatter (expertise / task_types as lists).
+  function parseAgentDef(raw) {
+    const out = { name: '', description: '', capability: {}, document: '' };
+    const fm = String(raw).match(/^---\s*\n([\s\S]*?)\n---\s*\n?([\s\S]*)$/);
+    let front = '', body = String(raw);
+    if (fm) { front = fm[1]; body = fm[2]; }
+    out.document = body.trim();
+    const strip = (s) => s.trim().replace(/^["']|["']$/g, '');
+    let inCap = false, listKey = null;
+    for (const line of front.split('\n')) {
+      const top = line.match(/^([a-z_]+):\s*(.*)$/i);
+      if (top && !/^\s/.test(line)) {
+        inCap = (top[1] === 'capability'); listKey = null;
+        if (top[1] === 'name') out.name = strip(top[2]);
+        else if (top[1] === 'description') out.description = strip(top[2]);
+        continue;
+      }
+      if (!inCap) continue;
+      const li = line.match(/^\s+-\s+(.+)$/);
+      if (li && listKey) { (out.capability[listKey] = out.capability[listKey] || []).push(strip(li[1])); continue; }
+      const kv = line.match(/^\s+([a-z_]+):\s*(.*)$/i);
+      if (kv) {
+        if (kv[2].trim() === '') { listKey = kv[1]; out.capability[kv[1]] = out.capability[kv[1]] || []; }
+        else { listKey = null; out.capability[kv[1]] = strip(kv[2]); }
+      }
+    }
+    return out;
+  }
+
   const server = http.createServer(async (req, res) => {
     const url = req.url.split('?')[0];
 
@@ -311,6 +341,21 @@ export async function startServer({ port = 4242, projectDir, openBrowser = true
       return;
     }
 
+    // ------------------------------------------------- GET /data/avatars/*.svg (agent avatars)
+    if (req.method === 'GET' && /^\/data\/avatars\/[A-Za-z0-9._-]+\.svg$/.test(url)) {
+      try {
+        const name = path.basename(decodeURIComponent(url));
+        if (!/^[A-Za-z0-9._-]+\.svg$/.test(name) || name.includes('..')) { res.writeHead(400); res.end(); return; }
+        const avatarsDir = path.join(__dirname, 'data', 'avatars');
+        const filePath = path.join(avatarsDir, name);
+        if (!filePath.startsWith(avatarsDir + path.sep) || !fs.existsSync(filePath)) { res.writeHead(404); res.end(); return; }
+        const svg = fs.readFileSync(filePath);
+        res.writeHead(200, { 'Content-Type': 'image/svg+xml; charset=utf-8', 'Cache-Control': 'public, max-age=86400' });
+        res.end(svg);
+      } catch (_) { res.writeHead(404); res.end(); }
+      return;
+    }
+
     // ----------------------------------------------------------------- GET /v2 (alias → /)
     if (req.method === 'GET' && url === '/v2') {
       res.writeHead(301, { 'Location': '/' });
@@ -805,11 +850,37 @@ export async function startServer({ port = 4242, projectDir, openBrowser = true
               }
             }
           }
-          return { filename: fname, name, description, type, body, mtime: stat ? stat.mtimeMs : null };
+          return { filename: fname, name, description, type, body, source: 'file', readonly: false, mtime: stat ? stat.mtimeMs : null };
         }).sort((a, b) => (b.mtime || 0) - (a.mtime || 0));
 
+        // Merge backend store (AgentDB / auto-memory bridge). These live in the
+        // SQLite-backed store, not as .md files, so the file-only listing above
+        // misses them. Surface them read-only with a source badge so the dashboard
+        // reflects ALL memory, not just whatever has been flushed to disk.
+        let backend = [];
+        try {
+          const storePath = path.join(d, '.monomind', 'data', 'auto-memory-store.json');
+          if (fs.existsSync(storePath)) {
+            const raw = JSON.parse(fs.readFileSync(storePath, 'utf8'));
+            const rows = Array.isArray(raw) ? raw : (raw.entries || []);
+            backend = rows
+              .filter(e => e && (e.content != null) && e.status !== 'deleted')
+              .map(e => ({
+                filename: 'backend:' + (e.key || e.id),
+                name: e.key || e.id || 'entry',
+                description: e.namespace ? ('namespace: ' + e.namespace) : '',
+                type: e.type || 'semantic',
+                body: String(e.content),
+                source: 'backend',
+                readonly: true,
+                mtime: e.updatedAt || e.createdAt || null,
+              }))
+              .sort((a, b) => (b.mtime || 0) - (a.mtime || 0));
+          }
+        } catch {}
+
         res.writeHead(200, { 'Content-Type': 'application/json', 'Access-Control-Allow-Origin': '*', 'Cache-Control': 'no-cache' });
-        res.end(JSON.stringify({ memories, memDir }));
+        res.end(JSON.stringify({ memories: memories.concat(backend), memDir }));
       } catch (err) {
         res.writeHead(500, { 'Content-Type': 'application/json' });
         res.end(JSON.stringify({ error: err.message }));
@@ -2993,16 +3064,44 @@ export async function startServer({ port = 4242, projectDir, openBrowser = true
         if (orgName.length > 64 || !/^[a-z0-9][a-z0-9_-]*$/i.test(orgName)) { res.writeHead(400); res.end('[]'); return; }
         const _actQs = new URL(req.url, 'http://localhost').searchParams;
         const d = path.resolve(_actQs.get('dir') || projectDir || process.cwd());
+        const orgsDir = path.join(d, '.monomind', 'orgs');
+        const readJ = (f) => { try { return JSON.parse(fs.readFileSync(f, 'utf8')); } catch(_) { return null; } };
+        const events = [];
+
+        // 1) Global mastermind events that EXPLICITLY belong to this org (strict — no untagged leak)
         const eventsFile = path.join(d, 'data', 'mastermind-events.jsonl');
-        let events = [];
         if (fs.existsSync(eventsFile)) {
           const lines = fs.readFileSync(eventsFile, 'utf8').split('\n').filter(Boolean);
-          events = lines.slice(-500).map(l => { try { return JSON.parse(l); } catch { return null; } }).filter(Boolean)
-            .filter(e => e.org === orgName || !e.org)
-            .reverse().slice(0, 100);
+          for (const l of lines.slice(-1000)) {
+            try { const e = JSON.parse(l); if (e && e.org === orgName) events.push(e); } catch(_) {}
+          }
+        }
+
+        // 2) Synthesize an org-scoped timeline from this org's own records (real data, distinct per org)
+        const cfg = readJ(path.join(orgsDir, `${orgName}.json`));
+        if (cfg) {
+          const createdMs = cfg.created_at ? Date.parse(cfg.created_at) : null;
+          if (createdMs) events.push({ type: 'org:create', ts: createdMs, msg: String(cfg.goal || 'Org created').slice(0, 80) });
+          (cfg.roles || []).forEach((r, i) => {
+            events.push({ type: 'role:defined', ts: createdMs ? createdMs + (i + 1) * 1000 : null, role: r.title || r.id, msg: r.agent_type || '' });
+          });
         }
+        const goals = readJ(path.join(orgsDir, `${orgName}-goals.json`));
+        (goals?.goals || []).forEach(g => events.push({ type: 'goal', ts: Date.parse(g.created_at || g.updated_at || '') || null, role: g.status || '', msg: String(g.text || g.title || g.goal || '').slice(0, 80) }));
+        const appr = readJ(path.join(orgsDir, `${orgName}-approvals.json`));
+        (appr?.approvals || []).forEach(a => { const ts = (typeof a.ts === 'number') ? a.ts : (Date.parse(a.created_at || a.ts || '') || null); events.push({ type: 'approval', ts, role: a.agent_id || a.requester || '', msg: String(a.title || a.action || '').slice(0, 80) }); });
+        const state = readJ(path.join(orgsDir, `${orgName}-state.json`));
+        if (state && state.agents) {
+          for (const [aid, a] of Object.entries(state.agents)) {
+            const raw = a.lastHeartbeat || a.last_seen || a.updated_at || null;
+            const ts = (typeof raw === 'number') ? raw : (raw ? Date.parse(raw) : null);
+            events.push({ type: 'org:heartbeat', ts, agent: aid, msg: a.status || '' });
+          }
+        }
+
+        const out = events.filter(e => e && e.ts).sort((a, b) => b.ts - a.ts).slice(0, 100);
         res.writeHead(200, { 'Content-Type': 'application/json', 'Access-Control-Allow-Origin': '*' });
-        res.end(JSON.stringify(events));
+        res.end(JSON.stringify(out));
       } catch(_) { res.writeHead(500); res.end('[]'); }
       return;
     }
@@ -3125,6 +3224,62 @@ export async function startServer({ port = 4242, projectDir, openBrowser = true
       return;
     }
 
+    // GET /api/org/:name/agent/:roleId — full agent detail: org role + .claude/agents definition
+    //   (characteristics, skills/expertise, responsibilities, instructions document)
+    if (req.method === 'GET' && /^\/api\/org\/[a-z0-9][a-z0-9_-]{0,63}\/agent\/[a-z0-9][a-z0-9_-]{0,63}$/i.test(url)) {
+      try {
+        const parts = url.split('/');
+        const orgName = decodeURIComponent(parts[3]);
+        const roleId = decodeURIComponent(parts[5]);
+        if (orgName.length > 64 || !/^[a-z0-9][a-z0-9_-]*$/i.test(orgName)) { res.writeHead(400); res.end('{}'); return; }
+        if (roleId.length > 64 || !/^[a-z0-9][a-z0-9_-]*$/i.test(roleId)) { res.writeHead(400); res.end('{}'); return; }
+        const _agentQs = new URL(req.url, 'http://localhost').searchParams;
+        const d = path.resolve(_agentQs.get('dir') || projectDir || process.cwd());
+        const orgFile = path.join(d, '.monomind', 'orgs', `${orgName}.json`);
+        if (!fs.existsSync(orgFile)) { res.writeHead(404); res.end('{}'); return; }
+        const config = JSON.parse(fs.readFileSync(orgFile, 'utf8'));
+        const role = (config.roles || []).find(r => r.id === roleId);
+        if (!role) { res.writeHead(404); res.end('{}'); return; }
+
+        const agentType = String(role.agent_type || role.type || '').toLowerCase();
+        const wanted = [agentType, String(role.id).toLowerCase()].filter(Boolean);
+
+        // Find a matching agent definition under .claude/agents (recursive); match frontmatter name then filename.
+        const agentsDir = path.join(d, '.claude', 'agents');
+        let definition = { found: false };
+        if (wanted.length && fs.existsSync(agentsDir)) {
+          const stack = [agentsDir];
+          let nameMatch = null, slugMatch = null;
+          while (stack.length && !nameMatch) {
+            const dir = stack.pop();
+            let entries = [];
+            try { entries = fs.readdirSync(dir, { withFileTypes: true }); } catch (_) { continue; }
+            for (const e of entries) {
+              const full = path.join(dir, e.name);
+              if (e.isDirectory()) { stack.push(full); continue; }
+              if (!e.name.endsWith('.md') || e.name.startsWith('_')) continue;
+              const slug = e.name.replace(/\.md$/, '').toLowerCase();
+              let raw = '';
+              try { raw = fs.readFileSync(full, 'utf8'); } catch (_) { continue; }
+              const fmName = ((raw.match(/^name:\s*(.+)$/m) || [])[1] || '').trim().toLowerCase();
+              if (fmName && wanted.includes(fmName)) { nameMatch = { full, raw }; break; }
+              if (!slugMatch && wanted.includes(slug)) slugMatch = { full, raw };
+            }
+          }
+          const match = nameMatch || slugMatch;
+          if (match) {
+            definition = parseAgentDef(match.raw);
+            definition.found = true;
+            definition.file = path.relative(d, match.full);
+          }
+        }
+
+        res.writeHead(200, { 'Content-Type': 'application/json', 'Access-Control-Allow-Origin': '*', 'Cache-Control': 'no-cache' });
+        res.end(JSON.stringify({ role, definition }));
+      } catch (_) { res.writeHead(500); res.end('{}'); }
+      return;
+    }
+
     // GET /api/org/:name/search?q=<query> — fuzzy search across org data
     if (req.method === 'GET' && /^\/api\/org\/[a-z0-9][a-z0-9_-]{0,63}\/search(\?.*)?$/i.test(url)) {
       try {