@hongmaple0820/scale-engine 0.43.0 → 0.45.0

package/dist/dashboard/DashboardServer.js

@@ -1,86 +1,232 @@
 /**
- * Dashboard Server — Web-based visualization for SCALE Engine state
- * Part of P2-2: Web Dashboard for real-time monitoring
+ * Dashboard Server 2.0 — Unified Hono server with Node.js adapter
+ * SPA architecture, SSE real-time, ECharts visualization
  */
 import { Hono } from 'hono';
 import { cors } from 'hono/cors';
-import { serveStatic } from 'hono/bun';
-import { readFileSync } from 'node:fs';
-import { join, dirname } from 'node:path';
+import { streamSSE } from 'hono/streaming';
+import { readFileSync, existsSync, readdirSync, statSync } from 'node:fs';
+import { join, dirname, extname } from 'node:path';
 import { fileURLToPath } from 'node:url';
+import { dumpCodeGraphData } from '../codegraph/CodeIntelligence.js';
+import { classifyLayers } from '../topology/LayerClassifier.js';
+import { mapDomains } from '../topology/DomainMapper.js';
+import { generateTour } from '../topology/TourGenerator.js';
+import { aggregateGovernanceMetrics } from './MetricsAggregator.js';
+import { logger } from '../core/logger.js';
 const __dirname = dirname(fileURLToPath(import.meta.url));
-/**
- * DashboardServer — Hono-based web server for dashboard
- */
+// ── Dashboard Server ─────────────────────────────────────────────────────
 export class DashboardServer {
-    constructor(bus, options = {}) {
-        this.store = null;
-        this.fsm = null;
-        this.evaluator = null;
-        this.detectorTracker = null;
+    constructor(options = {}) {
+        this.server = null;
         this.app = new Hono();
-        this.bus = bus;
+        this.bus = options.bus ?? null;
         this.store = options.store ?? null;
         this.fsm = options.fsm ?? null;
         this.evaluator = options.evaluator ?? null;
         this.detectorTracker = options.detectorTracker ?? null;
-        this.port = options.port ?? 3000;
-        this.setupRoutes();
+        this.port = options.port ?? 3210;
+        this.host = options.host ?? '0.0.0.0';
+        this.projectDir = options.projectDir ?? process.cwd();
+        this.scaleDir = options.scaleDir ?? join(this.projectDir, '.scale');
+        this.setupMiddleware();
+        this.setupSPA();
+        this.setupAPI();
+        this.setupSSE();
+        this.setupWriteOps();
     }
-    setupRoutes() {
-        // CORS for cross-origin requests
+    // ── Middleware ────────────────────────────────────────────────────────
+    setupMiddleware() {
         this.app.use('*', cors());
-        // Static files for frontend
-        this.app.use('/static/*', serveStatic({ root: './src/dashboard/static' }));
-        // Health check
-        this.app.get('/health', (c) => c.json({ status: 'ok', timestamp: Date.now() }));
-        // Main dashboard state
-        this.app.get('/api/state', async (c) => {
-            const state = await this.getDashboardState();
-            return c.json(state);
+    }
+    // ── SPA Serves ───────────────────────────────────────────────────────
+    setupSPA() {
+        // Resolve SPA dir: try dist/spa first, fall back to src/spa
+        const distSpa = join(__dirname, 'spa');
+        const srcSpa = join(__dirname, '..', '..', 'src', 'dashboard', 'spa');
+        const spaDir = existsSync(distSpa) ? distSpa : srcSpa;
+        const mimeTypes = {
+            '.html': 'text/html; charset=utf-8',
+            '.js': 'application/javascript; charset=utf-8',
+            '.css': 'text/css; charset=utf-8',
+            '.json': 'application/json',
+            '.png': 'image/png',
+            '.svg': 'image/svg+xml',
+            '.ico': 'image/x-icon',
+        };
+        // Serve SPA static files
+        this.app.get('/spa/*', async (c) => {
+            const path = c.req.path.replace('/spa/', '') || 'index.html';
+            const filePath = join(spaDir, path);
+            if (!existsSync(filePath) || !statSync(filePath).isFile()) {
+                return c.notFound();
+            }
+            const ext = extname(filePath);
+            const contentType = mimeTypes[ext] ?? 'application/octet-stream';
+            const content = readFileSync(filePath);
+            return new Response(content, {
+                headers: { 'Content-Type': contentType, 'Cache-Control': 'no-cache' },
+            });
         });
-        // Artifact tree
-        this.app.get('/api/artifacts', async (c) => {
-            const tree = await this.getArtifactTree();
-            return c.json(tree);
+        // Root redirect to SPA
+        this.app.get('/', (c) => c.redirect('/spa/'));
+        // Legacy views (backward compat)
+        const distViews = join(__dirname, 'views');
+        const srcViews = join(__dirname, '..', '..', 'src', 'dashboard', 'views');
+        const viewsDir = existsSync(distViews) ? distViews : srcViews;
+        this.app.get('/legacy/:view', (c) => {
+            const view = c.req.param('view');
+            const viewMap = {
+                'artifacts': 'artifact-flow.html',
+                'sessions': 'session-timeline.html',
+                'knowledge': 'knowledge-graph.html',
+                'evolution': 'evolution-metrics.html',
+                'agents': 'agent-stats.html',
+                'topology': 'topology.html',
+            };
+            const viewFile = viewMap[view];
+            if (!viewFile)
+                return c.notFound();
+            try {
+                const content = readFileSync(join(viewsDir, viewFile), 'utf-8');
+                return c.html(content);
+            }
+            catch {
+                return c.notFound();
+            }
         });
+        // Health check
+        this.app.get('/health', (c) => c.json({ status: 'ok', timestamp: Date.now(), version: '2.0.0' }));
+    }
+    // ── API Routes ───────────────────────────────────────────────────────
+    setupAPI() {
+        // Full dashboard state
+        this.app.get('/api/state', async (c) => c.json(await this.getDashboardState()));
+        // Artifact tree
+        this.app.get('/api/artifacts', async (c) => c.json(await this.getArtifactTree()));
         // Evolution metrics
-        this.app.get('/api/evolution', async (c) => {
-            const metrics = await this.getEvolutionMetrics();
-            return c.json(metrics);
-        });
+        this.app.get('/api/evolution', async (c) => c.json(await this.getEvolutionMetrics()));
         // Detector stats
-        this.app.get('/api/detectors', async (c) => {
-            const stats = this.getDetectorStats();
-            return c.json(stats);
-        });
+        this.app.get('/api/detectors', (c) => c.json(this.getDetectorStats()));
         // Recent events
         this.app.get('/api/events', async (c) => {
             const limit = parseInt(c.req.query('limit') ?? '50');
-            const events = await this.getRecentEvents(limit);
-            return c.json(events);
+            return c.json(await this.getRecentEvents(limit));
+        });
+        // Auto-defect stats
+        this.app.get('/api/auto-defects', async (c) => c.json(await this.getAutoDefectStats()));
+        // Governance metrics (aggregated from MetricsAggregator)
+        this.app.get('/api/metrics', (c) => {
+            try {
+                const metrics = aggregateGovernanceMetrics({
+                    projectDir: this.projectDir,
+                    scaleDir: this.scaleDir,
+                    sinceDays: parseInt(c.req.query('days') ?? '7'),
+                });
+                return c.json(metrics);
+            }
+            catch (e) {
+                return c.json({ error: e instanceof Error ? e.message : String(e) }, 500);
+            }
         });
-        // AutoDefect statistics
-        this.app.get('/api/auto-defects', async (c) => {
-            const stats = await this.getAutoDefectStats();
-            return c.json(stats);
+        // Topology graph
+        this.app.get('/api/topology', (c) => c.json(this.getTopology()));
+        // Guided tour
+        this.app.get('/api/topology/tour', (c) => c.json(generateTour(this.getTopology())));
+        // Domain mapping
+        this.app.get('/api/topology/domains', (c) => {
+            const graph = this.getTopology();
+            return c.json(mapDomains(graph));
         });
-        // ── Write Operations ──────────────────────────────────────────────
+        // Available documents in .scale/
+        this.app.get('/api/documents', (c) => {
+            return c.json(this.listDocuments());
+        });
+        // Serve a document by path
+        this.app.get('/api/documents/*', (c) => {
+            const docPath = c.req.path.replace('/api/documents/', '');
+            return this.serveDocument(docPath, c);
+        });
+        // Available FSM actions for artifact
+        this.app.get('/api/artifacts/:id/actions', async (c) => {
+            if (!this.fsm)
+                return c.json({ error: 'FSM not available' }, 503);
+            try {
+                const actions = await this.fsm.availableActions(c.req.param('id'));
+                return c.json({ id: c.req.param('id'), actions });
+            }
+            catch (e) {
+                return c.json({ error: e instanceof Error ? e.message : String(e) }, 500);
+            }
+        });
+    }
+    // ── SSE (Server-Sent Events) ─────────────────────────────────────────
+    setupSSE() {
+        this.app.get('/api/stream', (c) => {
+            return streamSSE(c, async (stream) => {
+                // Send initial state
+                const state = await this.getDashboardState();
+                await stream.writeSSE({ data: JSON.stringify({ type: 'init', state }), event: 'init' });
+                // Subscribe to EventBus for real-time updates
+                let alive = true;
+                const heartbeat = setInterval(async () => {
+                    if (!alive)
+                        return;
+                    try {
+                        await stream.writeSSE({ data: '{}', event: 'heartbeat' });
+                    }
+                    catch {
+                        alive = false;
+                    }
+                }, 30000);
+                // Listen for events
+                const unsub = this.bus?.on('*', async (event) => {
+                    if (!alive)
+                        return;
+                    try {
+                        await stream.writeSSE({
+                            data: JSON.stringify({
+                                type: 'event',
+                                event: {
+                                    type: event.type,
+                                    timestamp: event.timestamp,
+                                    artifactId: event.artifactId,
+                                },
+                            }),
+                            event: 'event',
+                        });
+                    }
+                    catch {
+                        alive = false;
+                    }
+                });
+                // Wait until client disconnects
+                stream.onAbort(() => {
+                    alive = false;
+                    clearInterval(heartbeat);
+                    unsub?.unsubscribe();
+                });
+                // Keep alive
+                while (alive) {
+                    await new Promise(r => setTimeout(r, 1000));
+                }
+            });
+        });
+    }
+    // ── Write Operations ─────────────────────────────────────────────────
+    setupWriteOps() {
         // Artifact transition
         this.app.post('/api/artifacts/:id/transition', async (c) => {
-            if (!this.fsm || !this.store) {
+            if (!this.fsm || !this.store)
                 return c.json({ error: 'FSM or store not available' }, 503);
-            }
             const id = c.req.param('id');
             const body = await c.req.json();
-            if (!body.action) {
+            if (!body.action)
                 return c.json({ error: 'Missing required field: action' }, 400);
-            }
             try {
                 const artifact = await this.store.get(id);
                 if (!artifact)
                     return c.json({ error: `Artifact not found: ${id}` }, 404);
-                // Check available actions first
                 const available = await this.fsm.availableActions(id);
                 if (!available.includes(body.action)) {
                     return c.json({
@@ -92,94 +238,64 @@ export class DashboardServer {
                     actor: { kind: 'system', component: 'dashboard' },
                     reason: body.reason ?? `Dashboard transition: ${body.action}`,
                 });
-                if (!result.success) {
-                    return c.json({
-                        error: 'Transition blocked by guards',
-                        blockedBy: result.blockedBy,
-                    }, 422);
-                }
-                return c.json({
-                    success: true,
-                    artifact: result.artifact,
-                    effectsExecuted: result.effectsExecuted,
-                });
-            }
-            catch (e) {
-                return c.json({ error: e instanceof Error ? e.message : String(e) }, 500);
-            }
-        });
-        // Get available transitions for an artifact
-        this.app.get('/api/artifacts/:id/actions', async (c) => {
-            if (!this.fsm)
-                return c.json({ error: 'FSM not available' }, 503);
-            const id = c.req.param('id');
-            try {
-                const actions = await this.fsm.availableActions(id);
-                return c.json({ id, actions });
+                if (!result.success)
+                    return c.json({ error: 'Transition blocked', blockedBy: result.blockedBy }, 422);
+                return c.json({ success: true, artifact: result.artifact, effectsExecuted: result.effectsExecuted });
             }
             catch (e) {
                 return c.json({ error: e instanceof Error ? e.message : String(e) }, 500);
             }
         });
-        // Lesson approve (PROPOSED → APPROVED)
+        // Lesson approve
         this.app.post('/api/lessons/:id/approve', async (c) => {
-            if (!this.fsm || !this.store) {
+            if (!this.fsm || !this.store)
                 return c.json({ error: 'FSM or store not available' }, 503);
-            }
             const id = c.req.param('id');
             try {
                 const artifact = await this.store.get(id);
-                if (!artifact || artifact.type !== 'Lesson') {
+                if (!artifact || artifact.type !== 'Lesson')
                     return c.json({ error: `Lesson not found: ${id}` }, 404);
-                }
-                if (artifact.status !== 'PROPOSED') {
+                if (artifact.status !== 'PROPOSED')
                     return c.json({ error: `Lesson is "${artifact.status}", can only approve from PROPOSED` }, 400);
-                }
                 const body = await c.req.json().catch(() => ({}));
                 const result = await this.fsm.transition(id, 'review', {
                     actor: { kind: 'system', component: 'dashboard' },
                     reason: body.reason ?? 'Approved via dashboard',
                 });
-                if (!result.success) {
+                if (!result.success)
                     return c.json({ error: 'Transition blocked', blockedBy: result.blockedBy }, 422);
-                }
                 return c.json({ success: true, artifact: result.artifact });
             }
             catch (e) {
                 return c.json({ error: e instanceof Error ? e.message : String(e) }, 500);
             }
         });
-        // Lesson reject (PROPOSED → REJECTED)
+        // Lesson reject
         this.app.post('/api/lessons/:id/reject', async (c) => {
-            if (!this.fsm || !this.store) {
+            if (!this.fsm || !this.store)
                 return c.json({ error: 'FSM or store not available' }, 503);
-            }
             const id = c.req.param('id');
             try {
                 const artifact = await this.store.get(id);
-                if (!artifact || artifact.type !== 'Lesson') {
+                if (!artifact || artifact.type !== 'Lesson')
                     return c.json({ error: `Lesson not found: ${id}` }, 404);
-                }
-                if (artifact.status !== 'PROPOSED') {
+                if (artifact.status !== 'PROPOSED')
                     return c.json({ error: `Lesson is "${artifact.status}", can only reject from PROPOSED` }, 400);
-                }
                 const body = await c.req.json().catch(() => ({}));
                 const result = await this.fsm.transition(id, 'reject', {
                     actor: { kind: 'system', component: 'dashboard' },
                     reason: body.reason ?? 'Rejected via dashboard',
                 });
-                if (!result.success) {
+                if (!result.success)
                     return c.json({ error: 'Transition blocked', blockedBy: result.blockedBy }, 422);
-                }
                 return c.json({ success: true, artifact: result.artifact });
             }
             catch (e) {
                 return c.json({ error: e instanceof Error ? e.message : String(e) }, 500);
             }
         });
-        // Index page - serve static HTML
-        this.app.get('/', (c) => c.html(this.getIndexHtml()));
     }
+    // ── Data Collection ──────────────────────────────────────────────────
     async getDashboardState() {
         const [artifacts, evolutionMetrics, detectorStats, autoDefectStats, recentEvents] = await Promise.all([
             this.getArtifactTree(),
@@ -188,67 +304,41 @@ export class DashboardServer {
             this.getAutoDefectStats(),
             this.getRecentEvents(20),
         ]);
-        return {
-            artifacts,
-            evolutionMetrics,
-            detectorStats,
-            autoDefectStats,
-            recentEvents,
-            timestamp: Date.now(),
-        };
+        return { artifacts, evolutionMetrics, detectorStats, autoDefectStats, recentEvents, timestamp: Date.now() };
     }
     async getArtifactTree() {
         if (!this.store)
             return [];
         const artifacts = await this.store.query({});
-        const nodes = [];
-        // Build parent-child relationships
         const byId = new Map();
         for (const a of artifacts) {
-            const node = {
-                id: a.id,
-                type: a.type,
-                title: a.title,
-                status: a.status,
-                version: a.version,
-                children: [],
+            byId.set(a.id, {
+                id: a.id, type: a.type, title: a.title, status: a.status, version: a.version, children: [],
                 gates: a.gates?.map((g) => ({ name: g.name, required: g.required, passed: g.passed })),
-            };
-            byId.set(a.id, node);
+            });
         }
-        // Connect children to parents
         for (const a of artifacts) {
-            if (a.parents && a.parents.length > 0) {
-                for (const parentId of a.parents) {
-                    const parent = byId.get(parentId);
-                    if (parent) {
-                        const child = byId.get(a.id);
-                        if (child)
-                            parent.children.push(child);
-                    }
+            if (a.parents?.length) {
+                for (const pid of a.parents) {
+                    const parent = byId.get(pid);
+                    const child = byId.get(a.id);
+                    if (parent && child)
+                        parent.children.push(child);
                 }
             }
         }
-        // Root nodes have no parents
-        for (const a of artifacts) {
-            if (!a.parents || a.parents.length === 0) {
-                const node = byId.get(a.id);
-                if (node)
-                    nodes.push(node);
-            }
-        }
-        return nodes;
+        return artifacts
+            .filter(a => !a.parents?.length)
+            .map(a => byId.get(a.id))
+            .filter(Boolean);
     }
     async getEvolutionMetrics() {
-        if (!this.evaluator)
-            return null;
-        return await this.evaluator.evaluate();
+        return this.evaluator?.evaluate() ?? null;
     }
     getDetectorStats() {
         if (!this.detectorTracker)
             return [];
-        const allStats = this.detectorTracker.getAllStats();
-        return allStats.map(s => ({
+        return this.detectorTracker.getAllStats().map(s => ({
             name: s.detectorName,
             totalTriggers: s.totalTriggers,
             bySeverity: s.bySeverity,
@@ -258,70 +348,112 @@ export class DashboardServer {
     async getAutoDefectStats() {
         if (!this.store)
             return null;
-        // Query all Defect artifacts
         const defects = await this.store.query({ type: 'Defect' });
-        const autoCreated = defects.filter(d => {
-            const payload = d.payload;
-            return payload.autoCreated === true;
-        });
-        // Count by rootCauseCategory
+        const autoCreated = defects.filter(d => d.payload?.autoCreated === true);
         const byRootCause = {};
         const bySeverity = {};
         for (const d of autoCreated) {
-            const payload = d.payload;
-            const rootCause = payload.rootCauseCategory ?? 'unknown';
-            const severity = payload.severity ?? 'unknown';
-            byRootCause[rootCause] = (byRootCause[rootCause] ?? 0) + 1;
-            bySeverity[severity] = (bySeverity[severity] ?? 0) + 1;
+            const p = d.payload;
+            byRootCause[p.rootCauseCategory ?? 'unknown'] = (byRootCause[p.rootCauseCategory ?? 'unknown'] ?? 0) + 1;
+            bySeverity[p.severity ?? 'unknown'] = (bySeverity[p.severity ?? 'unknown'] ?? 0) + 1;
         }
-        // Recent defects (last 10)
-        const recentDefects = autoCreated
-            .slice(-10)
-            .reverse()
-            .map(d => {
-            const payload = d.payload;
+        const recentDefects = autoCreated.slice(-10).reverse().map(d => {
+            const p = d.payload;
             return {
-                id: d.id,
-                title: d.title,
-                rootCause: payload.rootCauseCategory ?? 'unknown',
-                severity: payload.severity ?? 'unknown',
-                detector: payload.detector ?? 'unknown',
-                createdAt: d.createdAt ?? (payload.timestamp ?? 0),
+                id: d.id, title: d.title,
+                rootCause: p.rootCauseCategory ?? 'unknown',
+                severity: p.severity ?? 'unknown',
+                detector: p.detector ?? 'unknown',
+                createdAt: d.createdAt ?? (p.timestamp ?? 0),
             };
         });
-        return {
-            totalDefects: defects.length,
-            autoCreatedCount: autoCreated.length,
-            byRootCause,
-            bySeverity,
-            recentDefects,
-        };
+        return { totalDefects: defects.length, autoCreatedCount: autoCreated.length, byRootCause, bySeverity, recentDefects };
     }
     async getRecentEvents(limit) {
-        // Get recent events from EventBus via query
+        if (!this.bus)
+            return [];
         const events = await this.bus.query({ limit });
         return events.map(e => ({
-            type: e.type,
-            timestamp: e.timestamp,
-            artifactId: e.artifactId,
+            type: e.type, timestamp: e.timestamp, artifactId: e.artifactId,
             data: e.payload,
         }));
     }
-    start() {
-        console.log(`Dashboard server starting on port ${this.port}`);
-        // @ts-expect-error Bun runtime API - types not available in npm package
-        Bun.serve({
-            port: this.port,
-            fetch: this.app.fetch,
-        });
+    getTopology() {
+        const raw = dumpCodeGraphData({ projectDir: this.projectDir });
+        return classifyLayers(raw);
+    }
+    listDocuments() {
+        const docs = [];
+        const scanDir = (dir, prefix) => {
+            if (!existsSync(dir))
+                return;
+            for (const entry of readdirSync(dir, { withFileTypes: true })) {
+                const fullPath = join(dir, entry.name);
+                const relPath = prefix ? `${prefix}/${entry.name}` : entry.name;
+                if (entry.isDirectory()) {
+                    scanDir(fullPath, relPath);
+                }
+                else if (entry.isFile() && /\.(html|md|json)$/.test(entry.name)) {
+                    const stat = statSync(fullPath);
+                    docs.push({ name: entry.name, path: relPath, type: extname(entry.name).slice(1), size: stat.size });
+                }
+            }
+        };
+        // Scan common doc locations
+        scanDir(join(this.scaleDir, 'docs'), '.scale/docs');
+        scanDir(join(this.scaleDir, 'artifacts'), '.scale/artifacts');
+        scanDir(join(this.projectDir, 'docs'), 'docs');
+        return docs;
+    }
+    serveDocument(docPath, c) {
+        // docPath already includes prefix (e.g., 'docs/foo.md' or '.scale/docs/foo.md')
+        // Try direct resolution from project root and scale root
+        const searchDirs = [
+            this.projectDir,
+            this.scaleDir,
+        ];
+        for (const dir of searchDirs) {
+            const fullPath = join(dir, docPath);
+            if (existsSync(fullPath) && statSync(fullPath).isFile()) {
+                const ext = extname(fullPath);
+                const contentType = ext === '.html' ? 'text/html; charset=utf-8' : ext === '.json' ? 'application/json' : 'text/plain; charset=utf-8';
+                return new Response(readFileSync(fullPath), { headers: { 'Content-Type': contentType } });
+            }
+        }
+        return c.json({ error: 'Document not found' }, 404);
+    }
+    // ── Lifecycle ────────────────────────────────────────────────────────
+    async start() {
+        try {
+            const { serve } = await import('@hono/node-server');
+            this.server = serve({
+                fetch: this.app.fetch,
+                port: this.port,
+                hostname: this.host,
+            });
+            logger.info({ port: this.port, host: this.host }, 'Dashboard 2.0 started');
+        }
+        catch {
+            // Fallback: Bun runtime
+            // @ts-expect-error Bun runtime API
+            if (typeof Bun !== 'undefined') {
+                // @ts-expect-error Bun runtime API
+                Bun.serve({ port: this.port, fetch: this.app.fetch });
+                logger.info({ port: this.port }, 'Dashboard 2.0 started (Bun)');
+            }
+            else {
+                throw new Error('No compatible runtime found. Install @hono/node-server for Node.js.');
+            }
+        }
     }
     stop() {
-        // Bun server stops automatically when process exits
-        console.log('Dashboard server stopped');
+        this.server?.close();
+        this.server = null;
+        logger.info('Dashboard 2.0 stopped');
     }
-    getIndexHtml() {
-        const htmlPath = join(__dirname, 'index.html');
-        return readFileSync(htmlPath, 'utf-8');
+    /** Get the underlying Hono app (for testing or embedding) */
+    getApp() {
+        return this.app;
     }
 }
 //# sourceMappingURL=DashboardServer.js.map