@monoes/monomindcli 2.7.2 → 2.7.4

package/dist/src/ui/server.mjs

@@ -1874,6 +1874,22 @@ export async function startServer({ port = 4242, projectDir, openBrowser = true
       return;
     }
 
+    // GET /api/adr-file?file=<name>&dir=<dir> — read a single ADR markdown file
+    if (req.method === 'GET' && url === '/api/adr-file') {
+      try {
+        const qs = new URL(req.url, 'http://localhost').searchParams;
+        const dir = qs.get('dir') || projectDir || process.cwd();
+        const fname = (qs.get('file') || '').replace(/[/\\]/g, '');
+        if (!fname || !fname.endsWith('.md')) { res.writeHead(400); res.end('{"error":"invalid file"}'); return; }
+        const fpath = path.join(path.resolve(dir), 'docs', 'adrs', fname);
+        if (!fs.existsSync(fpath)) { res.writeHead(404); res.end('{"error":"not found"}'); return; }
+        const content = fs.readFileSync(fpath, 'utf8');
+        res.writeHead(200, { 'Content-Type': 'application/json', ...(corsOrigin ? { 'Access-Control-Allow-Origin': corsOrigin } : {}) });
+        res.end(JSON.stringify({ file: fname, content }));
+      } catch (err) { res.writeHead(500); res.end(JSON.stringify({ error: err.message })); }
+      return;
+    }
+
     // ------------------------------------------------------- GET /api/memory-files
     if (req.method === 'GET' && url === '/api/memory-files') {
       try {
@@ -6315,6 +6331,265 @@ new Sigma(g,document.getElementById('g'),{renderEdgeLabels:false,labelColor:{col
       return;
     }
 
+    // GET /api/second-brain-metrics — aggregated injection analytics from second-brain.jsonl
+    if (req.method === 'GET' && url === '/api/second-brain-metrics') {
+      try {
+        const metricsFile = path.join(projectDir || process.cwd(), '.monomind', 'metrics', 'second-brain.jsonl');
+        if (!fs.existsSync(metricsFile)) {
+          res.writeHead(200, { 'Content-Type': 'application/json', ...(corsOrigin ? { 'Access-Control-Allow-Origin': corsOrigin } : {}) });
+          res.end(JSON.stringify({ total: 0, injected: 0, hitRate: 0, methods: {}, avgScore: 0, sparkline: [], scores: [] }));
+          return;
+        }
+        const raw = fs.readFileSync(metricsFile, 'utf8');
+        const entries = raw.split('\n').filter(Boolean).map(l => { try { return JSON.parse(l); } catch { return null; } }).filter(Boolean);
+        const total = entries.length;
+        const injectedCount = entries.filter(e => e.injected).length;
+        const hitRate = total > 0 ? injectedCount / total : 0;
+        // Method distribution
+        const methods = {};
+        for (const e of entries) { const m = e.method || 'unknown'; methods[m] = (methods[m] || 0) + 1; }
+        // Average top score (only for entries with hits)
+        const withScores = entries.filter(e => typeof e.topScore === 'number' && e.topScore !== null);
+        const avgScore = withScores.length > 0 ? withScores.reduce((s, e) => s + e.topScore, 0) / withScores.length : 0;
+        // Score distribution buckets
+        const scoreBuckets = [0, 0, 0, 0, 0]; // <0.3, 0.3-0.5, 0.5-0.7, 0.7-0.9, 0.9+
+        for (const e of withScores) {
+          const s = e.topScore;
+          if (s < 0.3) scoreBuckets[0]++;
+          else if (s < 0.5) scoreBuckets[1]++;
+          else if (s < 0.7) scoreBuckets[2]++;
+          else if (s < 0.9) scoreBuckets[3]++;
+          else scoreBuckets[4]++;
+        }
+        // Sparkline: group by hour for last 24h, then by day for older
+        const now = Date.now();
+        const h24 = now - 86400000;
+        const sparkline = [];
+        // Last 24 hours in 2h buckets
+        for (let t = h24; t < now; t += 7200000) {
+          const bucket = entries.filter(e => e.ts >= t && e.ts < t + 7200000);
+          const inj = bucket.filter(e => e.injected).length;
+          sparkline.push({ t, total: bucket.length, injected: inj });
+        }
+        // Top sources from recent entries (last 200)
+        const recentSlice = entries.slice(-200);
+        const misses = recentSlice.filter(e => !e.injected).length;
+        // Route overrides (misroute counts)
+        let routeOverrides = {};
+        try {
+          const overridesFile = path.join(projectDir || process.cwd(), '.monomind', 'metrics', 'route-overrides.json');
+          if (fs.existsSync(overridesFile)) routeOverrides = JSON.parse(fs.readFileSync(overridesFile, 'utf8'));
+        } catch {}
+        res.writeHead(200, { 'Content-Type': 'application/json', ...(corsOrigin ? { 'Access-Control-Allow-Origin': corsOrigin } : {}) });
+        res.end(JSON.stringify({ total, injected: injectedCount, hitRate: +hitRate.toFixed(3), methods, avgScore: +avgScore.toFixed(3), sparkline, scoreBuckets, recentMisses: misses, recentTotal: recentSlice.length, routeOverrides }));
+      } catch (err) {
+        res.writeHead(500, { 'Content-Type': 'application/json' });
+        res.end(JSON.stringify({ error: err.message }));
+      }
+      return;
+    }
+
+    // POST /api/second-brain-route — show query router decision for a given query
+    if (req.method === 'POST' && url === '/api/second-brain-route') {
+      let body = '';
+      req.on('data', c => { body += c; if (body.length > 65536) { req.destroy(); return; } });
+      req.on('end', async () => {
+        try {
+          const { query } = JSON.parse(body || '{}');
+          if (!query) { res.writeHead(400, { 'Content-Type': 'application/json' }); res.end('{"error":"query required"}'); return; }
+          const routerMod = await import('../memory/query-router.js');
+          const route = routerMod.routeQuery(String(query).slice(0, 2000));
+          const overrides = routerMod.getRouteOverrides(true);
+          res.writeHead(200, { 'Content-Type': 'application/json', ...(corsOrigin ? { 'Access-Control-Allow-Origin': corsOrigin } : {}) });
+          res.end(JSON.stringify({ route, overrides }));
+        } catch (err) {
+          res.writeHead(500, { 'Content-Type': 'application/json' });
+          res.end(JSON.stringify({ error: err.message }));
+        }
+      });
+      return;
+    }
+
+    // GET/PUT /api/second-brain-config — read/write Second Brain config (.monomind/second-brain.json)
+    if ((req.method === 'GET' || req.method === 'PUT') && url === '/api/second-brain-config') {
+      const configFile = path.join(projectDir || process.cwd(), '.monomind', 'second-brain.json');
+      if (req.method === 'GET') {
+        try {
+          let config = { relevanceFloor: 0.35, injectionLimit: 5 };
+          try { config = { ...config, ...JSON.parse(fs.readFileSync(configFile, 'utf8')) }; } catch {}
+          // Auto-tune suggestion: analyze telemetry to suggest optimal floor
+          let suggestion = null;
+          try {
+            const metricsFile = path.join(projectDir || process.cwd(), '.monomind', 'metrics', 'second-brain.jsonl');
+            if (fs.existsSync(metricsFile)) {
+              const entries = fs.readFileSync(metricsFile, 'utf8').split('\n').filter(Boolean)
+                .map(l => { try { return JSON.parse(l); } catch { return null; } }).filter(Boolean);
+              const withScores = entries.filter(e => typeof e.topScore === 'number' && e.topScore !== null);
+              if (withScores.length >= 20) {
+                const scores = withScores.map(e => e.topScore).sort((a, b) => a - b);
+                const p25 = scores[Math.floor(scores.length * 0.25)];
+                const hitRate = entries.filter(e => e.injected).length / entries.length;
+                // If hit rate is very low (<30%), suggest lowering floor
+                // If hit rate is very high (>80%) with low avg scores, suggest raising
+                if (hitRate < 0.3 && p25 > 0.2) suggestion = { floor: +(p25 - 0.05).toFixed(2), reason: 'Low hit rate (' + (hitRate * 100).toFixed(0) + '%) — lowering floor may surface more relevant results' };
+                else if (hitRate > 0.8 && scores[Math.floor(scores.length * 0.1)] < 0.35) suggestion = { floor: 0.4, reason: 'High hit rate with low-quality matches — raising floor filters noise' };
+              }
+            }
+          } catch {}
+          res.writeHead(200, { 'Content-Type': 'application/json', ...(corsOrigin ? { 'Access-Control-Allow-Origin': corsOrigin } : {}) });
+          res.end(JSON.stringify({ config, suggestion }));
+        } catch (err) {
+          res.writeHead(500, { 'Content-Type': 'application/json' });
+          res.end(JSON.stringify({ error: err.message }));
+        }
+        return;
+      }
+      if (req.method === 'PUT') {
+        let body = '';
+        req.on('data', c => { body += c; if (body.length > 4096) { req.destroy(); return; } });
+        req.on('end', () => {
+          try {
+            const raw = JSON.parse(body || '{}');
+            const updates = {};
+            if (typeof raw.relevanceFloor === 'number' && raw.relevanceFloor >= 0 && raw.relevanceFloor <= 1) updates.relevanceFloor = raw.relevanceFloor;
+            if (typeof raw.injectionLimit === 'number' && raw.injectionLimit >= 1 && raw.injectionLimit <= 50) updates.injectionLimit = Math.floor(raw.injectionLimit);
+            if (Object.keys(updates).length === 0) { res.writeHead(400, { 'Content-Type': 'application/json' }); res.end('{"error":"no valid fields to update"}'); return; }
+            let config = {};
+            try { config = JSON.parse(fs.readFileSync(configFile, 'utf8')); } catch {}
+            config = { ...config, ...updates };
+            fs.mkdirSync(path.dirname(configFile), { recursive: true });
+            fs.writeFileSync(configFile, JSON.stringify(config, null, 2));
+            res.writeHead(200, { 'Content-Type': 'application/json', ...(corsOrigin ? { 'Access-Control-Allow-Origin': corsOrigin } : {}) });
+            res.end(JSON.stringify({ ok: true, config }));
+          } catch (err) {
+            res.writeHead(500, { 'Content-Type': 'application/json' });
+            res.end(JSON.stringify({ error: err.message }));
+          }
+        });
+        return;
+      }
+    }
+
+    // GET /api/second-brain-docs — document-level view from doc-metadata.jsonl
+    if (req.method === 'GET' && url === '/api/second-brain-docs') {
+      try {
+        const d = path.resolve(projectDir || process.cwd());
+        const metaFile = path.join(d, '.monomind', 'knowledge', 'doc-metadata.jsonl');
+        // Also check global brain
+        const globalDir = process.env.MONOMIND_GLOBAL_BRAIN_DIR || path.join(os.homedir(), '.monomind', 'global-brain');
+        const globalMetaFile = path.join(globalDir, '.monomind', 'knowledge', 'doc-metadata.jsonl');
+        const docs = [];
+        let totalSize = 0, totalChunks = 0;
+        for (const [file, scope] of [[metaFile, 'project'], [globalMetaFile, 'global']]) {
+          if (!fs.existsSync(file)) continue;
+          const latest = new Map();
+          for (const l of fs.readFileSync(file, 'utf8').split('\n')) {
+            if (!l.trim()) continue;
+            try {
+              const m = JSON.parse(l);
+              latest.set(m.filePath + ' ' + m.scope, m);
+            } catch {}
+          }
+          for (const m of latest.values()) {
+            if (m.chunkCount < 0) continue;
+            const exists = fs.existsSync(m.filePath);
+            docs.push({ ...m, brainScope: scope, exists, name: path.basename(m.filePath) });
+            totalSize += m.size || 0;
+            totalChunks += m.chunkCount || 0;
+          }
+        }
+        docs.sort((a, b) => (b.indexedAt || '').localeCompare(a.indexedAt || ''));
+        const globalCount = docs.filter(d => d.brainScope === 'global').length;
+        res.writeHead(200, { 'Content-Type': 'application/json', ...(corsOrigin ? { 'Access-Control-Allow-Origin': corsOrigin } : {}) });
+        res.end(JSON.stringify({ docs, totalDocs: docs.length, totalSize, totalChunks, globalCount, projectCount: docs.length - globalCount }));
+      } catch (err) {
+        res.writeHead(500, { 'Content-Type': 'application/json' });
+        res.end(JSON.stringify({ error: err.message }));
+      }
+      return;
+    }
+
+    // GET /api/second-brain-ingest-stream — SSE stream tailing doc-metadata.jsonl for live ingest events
+    if (req.method === 'GET' && url === '/api/second-brain-ingest-stream') {
+      res.writeHead(200, {
+        'Content-Type': 'text/event-stream', 'Cache-Control': 'no-cache', 'Connection': 'keep-alive',
+        ...(corsOrigin ? { 'Access-Control-Allow-Origin': corsOrigin } : {})
+      });
+      res.write('data: {"type":"connected"}\n\n');
+      const metaFile = path.join(projectDir || process.cwd(), '.monomind', 'knowledge', 'doc-metadata.jsonl');
+      let lastSize = 0;
+      try { lastSize = fs.statSync(metaFile).size; } catch {}
+      function _sseTailFile(filePath, lastSizeRef, eventType, transform) {
+        try {
+          const stat = fs.statSync(filePath);
+          if (stat.size < lastSizeRef.v) { lastSizeRef.v = 0; }
+          if (stat.size > lastSizeRef.v) {
+            let fd;
+            try {
+              fd = fs.openSync(filePath, 'r');
+              const buf = Buffer.alloc(stat.size - lastSizeRef.v);
+              fs.readSync(fd, buf, 0, buf.length, lastSizeRef.v);
+              lastSizeRef.v = stat.size;
+              const lines = buf.toString('utf8').split('\n').filter(Boolean);
+              for (const l of lines) {
+                try { const parsed = JSON.parse(l); res.write('data: ' + JSON.stringify(transform(parsed)) + '\n\n'); } catch {}
+              }
+            } finally { if (fd !== undefined) fs.closeSync(fd); }
+          }
+        } catch {}
+      }
+      const metaSize = { v: lastSize };
+      const interval = setInterval(() => _sseTailFile(metaFile, metaSize, 'ingest', m => ({ type: 'ingest', doc: { ...m, name: path.basename(m.filePath || '') } })), 2000);
+      const metricsFile = path.join(projectDir || process.cwd(), '.monomind', 'metrics', 'second-brain.jsonl');
+      const metricsSize = { v: 0 };
+      try { metricsSize.v = fs.statSync(metricsFile).size; } catch {}
+      const metricsInterval = setInterval(() => _sseTailFile(metricsFile, metricsSize, 'injection', e => ({ type: 'injection', event: e })), 3000);
+      req.on('close', () => { clearInterval(interval); clearInterval(metricsInterval); });
+      return;
+    }
+
+    // GET /api/second-brain-kg — knowledge graph triplets + stats for the KG explorer
+    if (req.method === 'GET' && url === '/api/second-brain-kg') {
+      try {
+        const qs = new URL(req.url, 'http://localhost').searchParams;
+        const query = (qs.get('q') || '').slice(0, 200);
+        const limit = Math.min(parseInt(qs.get('limit') || '50', 10), 200);
+        const monoDir = path.join(projectDir || process.cwd(), '.monomind');
+        const dbPath = path.join(monoDir, 'memory');
+        let stats = { nodes: 0, edges: 0 }, triplets = [], glossary = [];
+        try {
+          const kg = await import('../memory/memory-kg.js');
+          stats = await kg.kgStats({ dbPath });
+          glossary = await kg.kgGlossary({ dbPath, limit: 30 });
+          if (query) {
+            const searchResult = await kg.kgSearch({ query, limit, dbPath });
+            triplets = searchResult.triplets || searchResult || [];
+          } else {
+            const searchResult = await kg.kgSearch({ query: '*', limit, dbPath }).catch(() => null);
+            triplets = searchResult ? (searchResult.triplets || searchResult) : [];
+          }
+        } catch {}
+        // Also check palace kg.json as fallback
+        if (triplets.length === 0) {
+          try {
+            const palaceDir = path.join(monoDir, 'palace');
+            const kgData = JSON.parse(fs.readFileSync(path.join(palaceDir, 'kg.json'), 'utf8'));
+            if (Array.isArray(kgData)) {
+              triplets = kgData.slice(0, limit);
+              stats.nodes = new Set(kgData.flatMap(t => [t.subject || t.s, t.object || t.o])).size;
+              stats.edges = kgData.length;
+            }
+          } catch {}
+        }
+        res.writeHead(200, { 'Content-Type': 'application/json', ...(corsOrigin ? { 'Access-Control-Allow-Origin': corsOrigin } : {}) });
+        res.end(JSON.stringify({ stats, triplets, glossary }));
+      } catch (err) {
+        res.writeHead(500, { 'Content-Type': 'application/json' });
+        res.end(JSON.stringify({ error: err.message }));
+      }
+      return;
+    }
+
     // GET /api/mastermind/metrics — aggregate system metrics from token-summary and swarm-activity
     if (req.method === 'GET' && url === '/api/mastermind/metrics') {
       try {