@monoes/monomindcli 1.11.14 → 1.13.0

package/dist/src/services/worker-daemon.js

@@ -10,7 +10,7 @@
  * - testgaps: Test coverage analysis (20 min interval)
  */
 import { EventEmitter } from 'events';
-import { existsSync, mkdirSync, writeFileSync, renameSync, readFileSync, appendFileSync, unlinkSync } from 'fs';
+import { existsSync, mkdirSync, writeFileSync, renameSync, readFileSync, appendFileSync, unlinkSync, statSync } from 'fs';
 import { cpus } from 'os';
 import { join, resolve } from 'path';
 import { HeadlessWorkerExecutor, isHeadlessWorker, } from './headless-worker-executor.js';
@@ -106,14 +106,15 @@ export class WorkerDaemon extends EventEmitter {
             this.headlessAvailable = await this.headlessExecutor.isAvailable();
             if (this.headlessAvailable) {
                 this.log('info', 'Claude Code headless mode available - AI workers enabled');
-                // Forward headless executor events
-                this.headlessExecutor.on('execution:start', (data) => {
+                // Forward headless executor events.
+                // The executor emits 'start', 'complete', 'error' (not 'execution:*').
+                this.headlessExecutor.on('start', (data) => {
                     this.emit('headless:start', data);
                 });
-                this.headlessExecutor.on('execution:complete', (data) => {
+                this.headlessExecutor.on('complete', (data) => {
                     this.emit('headless:complete', data);
                 });
-                this.headlessExecutor.on('execution:error', (data) => {
+                this.headlessExecutor.on('error', (data) => {
                     this.emit('headless:error', data);
                 });
                 this.headlessExecutor.on('output', (data) => {
@@ -189,6 +190,12 @@ export class WorkerDaemon extends EventEmitter {
             return {};
         }
         try {
+            // Guard against OOM from an oversized config file (tampered or corrupted).
+            const configSize = statSync(configPath).size;
+            if (configSize > 1_048_576 /* 1 MB */) {
+                this.log('warn', `config.json is unusually large (${configSize} bytes) — ignoring daemon config`);
+                return {};
+            }
             const raw = JSON.parse(readFileSync(configPath, 'utf-8'));
             // Support both flat keys at root and nested under scopes.project
             const cfg = raw?.scopes?.project ?? raw;
@@ -271,6 +278,12 @@ export class WorkerDaemon extends EventEmitter {
         // Try to restore state from file
         if (existsSync(this.config.stateFile)) {
             try {
+                // Guard against OOM from an oversized state file (tampered or corrupted).
+                const stateSize = statSync(this.config.stateFile).size;
+                if (stateSize > 5_242_880 /* 5 MB */) {
+                    this.log('warn', `daemon-state.json is unusually large (${stateSize} bytes) — starting with fresh state`);
+                    return;
+                }
                 const saved = JSON.parse(readFileSync(this.config.stateFile, 'utf-8'));
                 // CRITICAL: Restore worker config (including enabled flag) from saved state
                 // This fixes #950: daemon enable command not persisting worker state
@@ -555,6 +568,17 @@ export class WorkerDaemon extends EventEmitter {
         const state = this.workers.get(workerConfig.type);
         const workerId = `${workerConfig.type}_${Date.now()}`;
         const startTime = Date.now();
+        // Track the headless executionId assigned by HeadlessWorkerExecutor so we
+        // can cancel it precisely on timeout. The executor generates its own ID
+        // (format: `${type}_${ts}_${random}`) which never matches workerId, so we
+        // capture it from the 'start' event instead.
+        let headlessExecutionId = null;
+        const onHeadlessStart = (data) => {
+            headlessExecutionId = data.executionId ?? null;
+        };
+        if (this.headlessExecutor) {
+            this.headlessExecutor.on('start', onHeadlessStart);
+        }
         // Track running worker
         this.runningWorkers.add(workerConfig.type);
         state.isRunning = true;
@@ -566,11 +590,13 @@ export class WorkerDaemon extends EventEmitter {
             // cancelAll() was too broad — it would kill concurrent healthy workers.
             const output = await this.runWithTimeout(() => this.runWorkerLogic(workerConfig), this.config.workerTimeoutMs, `Worker ${workerConfig.type} timed out after ${this.config.workerTimeoutMs / 1000}s`, () => {
                 if (this.headlessExecutor) {
-                    // Try exact-ID cancel first; fall back to type-based cancel which
-                    // avoids killing unrelated concurrent workers (cancelByType).
-                    if (!this.headlessExecutor.cancel(workerId)) {
-                        this.headlessExecutor.cancelByType(workerConfig.type);
+                    // Use the exact executionId captured from the 'start' event.
+                    // Fall back to cancelByType only if we didn't capture an ID yet
+                    // (e.g. timeout fired before the executor emitted 'start').
+                    if (headlessExecutionId && this.headlessExecutor.cancel(headlessExecutionId)) {
+                        return;
                     }
+                    this.headlessExecutor.cancelByType(workerConfig.type);
                 }
             });
             const durationMs = Date.now() - startTime;
@@ -615,6 +641,10 @@ export class WorkerDaemon extends EventEmitter {
         finally {
             // Remove from running set and process queue
             this.runningWorkers.delete(workerConfig.type);
+            // Unsubscribe the executionId capture listener regardless of outcome
+            if (this.headlessExecutor) {
+                this.headlessExecutor.off('start', onHeadlessStart);
+            }
             this.processPendingWorkers();
         }
     }
@@ -731,6 +761,59 @@ export class WorkerDaemon extends EventEmitter {
             },
             scannedAt: Date.now(),
         };
+        // Enrich with monograph graph stats for LLM context injection.
+        // Lazy-import to avoid hard dependency; silently skip on any error.
+        try {
+            const { openDb, closeDb, countNodes, countEdges } = await import('@monoes/monograph');
+            const dbPath = join(this.projectRoot, '.monomind', 'monograph.db');
+            if (existsSync(dbPath)) {
+                const db = openDb(dbPath);
+                try {
+                    // Node/edge counts
+                    map['graph'] = {
+                        nodes: countNodes(db),
+                        edges: countEdges(db),
+                    };
+                    // Top 3 god nodes (high degree internal files) — same SQL as monograph_god_nodes tool
+                    const excluded = ['File', 'Folder', 'Community', 'Concept'];
+                    const rows = db.prepare(`
+            SELECT n.name, n.file_path, n.start_line,
+                   COUNT(DISTINCT e1.id) + COUNT(DISTINCT e2.id) AS degree
+            FROM nodes n
+            LEFT JOIN edges e1 ON e1.source_id = n.id
+            LEFT JOIN edges e2 ON e2.target_id = n.id
+            WHERE n.label NOT IN (${excluded.map(() => '?').join(',')})
+            GROUP BY n.id HAVING degree > 0
+            ORDER BY degree DESC LIMIT 3
+          `).all(...excluded);
+                    if (rows.length > 0) {
+                        map['topFiles'] = rows.map(r => ({
+                            ref: r.file_path
+                                ? (r.start_line != null ? `${r.file_path}:${r.start_line}` : r.file_path)
+                                : r.name,
+                            degree: r.degree,
+                        }));
+                    }
+                    // Index staleness via git — same approach as monograph_health tool
+                    try {
+                        const { execSync } = await import('child_process');
+                        const lastHash = db.prepare("SELECT value FROM meta WHERE key = 'last_commit_hash' LIMIT 1").get()?.value;
+                        if (lastHash) {
+                            const countOut = execSync(`git -C ${JSON.stringify(this.projectRoot)} rev-list --count ${lastHash}..HEAD`, { timeout: 5000 }).toString().trim();
+                            const commitsBehind = parseInt(countOut, 10);
+                            if (!isNaN(commitsBehind)) {
+                                map['graphStaleness'] = { commitsBehind };
+                            }
+                        }
+                    }
+                    catch { /* git unavailable — skip staleness */ }
+                }
+                finally {
+                    closeDb(db);
+                }
+            }
+        }
+        catch { /* monograph unavailable — skip graph enrichment */ }
         const metricsFileTmp1 = metricsFile + '.tmp';
         writeFileSync(metricsFileTmp1, JSON.stringify(map, null, 2));
         renameSync(metricsFileTmp1, metricsFile);
@@ -752,12 +835,74 @@ export class WorkerDaemon extends EventEmitter {
             checks: {
                 envFilesProtected: !existsSync(join(this.projectRoot, '.env.local')),
                 gitIgnoreExists: existsSync(join(this.projectRoot, '.gitignore')),
-                noHardcodedSecrets: true, // Would need actual scanning
+                noHardcodedSecrets: null, // Not checked in local mode — requires AI-powered scan
             },
             riskLevel: 'low',
             recommendations: [],
             note: 'Install Claude Code CLI for AI-powered security analysis',
         };
+        // Enrich with monograph high-centrality files and surprising cross-community edges.
+        // God-node files are high-value targets for security review: they are imported by
+        // many consumers, so a vulnerability there has the largest blast radius.
+        // Cross-community edges reveal unexpected coupling that may indicate hidden attack surfaces.
+        try {
+            const { openDb, closeDb } = await import('@monoes/monograph');
+            const dbPath = join(this.projectRoot, '.monomind', 'monograph.db');
+            if (existsSync(dbPath)) {
+                const db = openDb(dbPath);
+                try {
+                    const godFileRows = db.prepare(`
+            SELECT n.file_path,
+                   COUNT(DISTINCT e1.id) + COUNT(DISTINCT e2.id) AS degree
+            FROM nodes n
+            LEFT JOIN edges e1 ON e1.source_id = n.id
+            LEFT JOIN edges e2 ON e2.target_id = n.id
+            WHERE n.label NOT IN ('File','Folder','Community','Concept')
+              AND n.file_path IS NOT NULL
+              AND n.file_path NOT LIKE '%node_modules%'
+              AND n.file_path NOT LIKE '%/dist/%'
+              AND n.file_path NOT LIKE '%.test.%'
+              AND n.file_path NOT LIKE '%.spec.%'
+            GROUP BY n.file_path
+            ORDER BY degree DESC
+            LIMIT 5
+          `).all();
+                    const surpriseRows = db.prepare(`
+            SELECT n1.name as src_name, n2.name as tgt_name, e.relation, e.confidence_score,
+                   n1.file_path as src_file, n2.file_path as tgt_file
+            FROM edges e
+            JOIN nodes n1 ON n1.id = e.source_id
+            JOIN nodes n2 ON n2.id = e.target_id
+            WHERE e.confidence != 'EXTRACTED'
+              AND n1.community_id IS NOT NULL
+              AND n2.community_id IS NOT NULL
+              AND n1.community_id != n2.community_id
+            ORDER BY e.confidence_score ASC
+            LIMIT 5
+          `).all();
+                    if (godFileRows.length > 0) {
+                        audit['priorityScanTargets'] = godFileRows.map(r => ({
+                            file: r.file_path.replace(this.projectRoot + '/', '').replace(this.projectRoot + '\\', ''),
+                            degree: r.degree,
+                            reason: 'high-centrality: vulnerability here affects the most consumers',
+                        }));
+                    }
+                    if (surpriseRows.length > 0) {
+                        audit['unexpectedCoupling'] = surpriseRows.map(r => ({
+                            edge: `${r.src_name} --${r.relation}--> ${r.tgt_name}`,
+                            srcFile: r.src_file ?? '(unknown)',
+                            tgtFile: r.tgt_file ?? '(unknown)',
+                            confidenceScore: r.confidence_score,
+                            reason: 'cross-community edge: may indicate hidden dependency or attack surface',
+                        }));
+                    }
+                }
+                finally {
+                    closeDb(db);
+                }
+            }
+        }
+        catch { /* monograph unavailable — skip graph enrichment */ }
         const auditFileTmp = auditFile + '.tmp';
         writeFileSync(auditFileTmp, JSON.stringify(audit, null, 2));
         renameSync(auditFileTmp, auditFile);
@@ -779,8 +924,8 @@ export class WorkerDaemon extends EventEmitter {
             memoryUsage: process.memoryUsage(),
             uptime: process.uptime(),
             optimizations: {
-                cacheHitRate: 0.78,
-                avgResponseTime: 45,
+                cacheHitRate: null, // Not measured in local mode — requires AI-powered analysis
+                avgResponseTime: null, // Not measured in local mode — requires AI-powered analysis
             },
             note: 'Install Claude Code CLI for AI-powered optimization suggestions',
         };
@@ -897,13 +1042,95 @@ export class WorkerDaemon extends EventEmitter {
      * Local ultralearn worker (fallback when headless unavailable)
      */
     async runUltralearnWorkerLocal() {
-        return {
+        const result = {
             timestamp: new Date().toISOString(),
             mode: 'local',
             patternsLearned: 0,
             insightsGained: [],
-            note: 'Install Claude Code CLI for AI-powered deep learning',
         };
+        // Enrich with monograph community clusters and bridge-node patterns for LLM context injection.
+        // Bridge nodes (symbols that cross community boundaries) are architecturally significant —
+        // they represent coupling points an LLM should be aware of when reasoning about change impact.
+        try {
+            const { openDb, closeDb, countNodes, countEdges } = await import('@monoes/monograph');
+            const dbPath = join(this.projectRoot, '.monomind', 'monograph.db');
+            if (existsSync(dbPath)) {
+                const db = openDb(dbPath);
+                try {
+                    const nodeCount = countNodes(db);
+                    const edgeCount = countEdges(db);
+                    const communityRows = db.prepare(`
+            SELECT community_id, COUNT(*) AS member_count
+            FROM nodes
+            WHERE community_id IS NOT NULL
+              AND label NOT IN ('File','Folder','Community','Concept')
+            GROUP BY community_id
+            ORDER BY member_count DESC
+            LIMIT 5
+          `).all();
+                    const bridgeRows = db.prepare(`
+            SELECT n.name, n.label, n.file_path, n.start_line,
+                   COUNT(DISTINCT e.id) AS cross_edges
+            FROM nodes n
+            JOIN edges e ON (e.source_id = n.id OR e.target_id = n.id)
+            JOIN nodes n2 ON (
+              CASE WHEN e.source_id = n.id THEN e.target_id ELSE e.source_id END = n2.id
+            )
+            WHERE n.community_id IS NOT NULL
+              AND n2.community_id IS NOT NULL
+              AND n.community_id != n2.community_id
+              AND n.label NOT IN ('File','Folder','Community','Concept')
+              AND (n.file_path IS NULL OR (
+                n.file_path NOT LIKE '%node_modules%'
+                AND n.file_path NOT LIKE '%/dist/%'
+                AND n.file_path NOT LIKE '%.test.%'
+                AND n.file_path NOT LIKE '%.spec.%'
+              ))
+            GROUP BY n.id
+            ORDER BY cross_edges DESC
+            LIMIT 5
+          `).all();
+                    const insights = result['insightsGained'];
+                    if (communityRows.length > 0) {
+                        insights.push({
+                            category: 'community_clusters',
+                            description: `Top ${communityRows.length} community clusters by size`,
+                            items: communityRows.map(r => ({
+                                communityId: r.community_id,
+                                memberCount: r.member_count,
+                            })),
+                        });
+                    }
+                    if (bridgeRows.length > 0) {
+                        insights.push({
+                            category: 'bridge_nodes',
+                            description: `Top ${bridgeRows.length} bridge nodes crossing community boundaries (high coupling risk)`,
+                            items: bridgeRows.map(r => {
+                                const loc = r.file_path
+                                    ? (r.start_line != null ? `${r.file_path}:${r.start_line}` : r.file_path)
+                                    : '(unknown)';
+                                return {
+                                    name: r.name,
+                                    label: r.label,
+                                    location: loc,
+                                    crossCommunityEdges: r.cross_edges,
+                                };
+                            }),
+                        });
+                        result['patternsLearned'] = bridgeRows.length + communityRows.length;
+                    }
+                    result['graph'] = { nodes: nodeCount, edges: edgeCount };
+                }
+                finally {
+                    closeDb(db);
+                }
+            }
+            else {
+                result['note'] = 'Monograph index not built — run `monomind monograph build` for deep learning';
+            }
+        }
+        catch { /* monograph unavailable — return minimal result */ }
+        return result;
     }
     /**
      * Local refactor worker (fallback when headless unavailable)
@@ -921,13 +1148,106 @@ export class WorkerDaemon extends EventEmitter {
      * Local deepdive worker (fallback when headless unavailable)
      */
     async runDeepdiveWorkerLocal() {
-        return {
+        const deepdiveFile = join(this.projectRoot, '.monomind', 'metrics', 'deepdive.json');
+        const metricsDir = join(this.projectRoot, '.monomind', 'metrics');
+        if (!existsSync(metricsDir)) {
+            mkdirSync(metricsDir, { recursive: true });
+        }
+        const result = {
             timestamp: new Date().toISOString(),
             mode: 'local',
-            analysisDepth: 'shallow',
+            analysisDepth: 'graph',
             findings: [],
-            note: 'Install Claude Code CLI for AI-powered deep code analysis',
         };
+        // Enrich with monograph god nodes and high-degree file analysis for LLM context injection.
+        // Lazy-import to avoid hard dependency; silently skip on any error.
+        try {
+            const { openDb, closeDb, countNodes, countEdges } = await import('@monoes/monograph');
+            const dbPath = join(this.projectRoot, '.monomind', 'monograph.db');
+            if (existsSync(dbPath)) {
+                const db = openDb(dbPath);
+                try {
+                    const nodeCount = countNodes(db);
+                    const edgeCount = countEdges(db);
+                    const godNodeRows = db.prepare(`
+            SELECT n.name, n.file_path, n.label,
+                   COUNT(DISTINCT e1.id) + COUNT(DISTINCT e2.id) AS degree
+            FROM nodes n
+            LEFT JOIN edges e1 ON e1.source_id = n.id
+            LEFT JOIN edges e2 ON e2.target_id = n.id
+            WHERE n.label NOT IN ('File','Folder','Community','Concept')
+              AND (n.file_path IS NULL OR (
+                n.file_path NOT LIKE '%node_modules%'
+                AND n.file_path NOT LIKE '%/dist/%'
+                AND n.file_path NOT LIKE '%.test.%'
+                AND n.file_path NOT LIKE '%.spec.%'
+              ))
+            GROUP BY n.id
+            ORDER BY degree DESC
+            LIMIT 5
+          `).all();
+                    const godNodes = godNodeRows.map(r => ({
+                        name: r.name,
+                        label: r.label,
+                        file: r.file_path ?? '(unknown)',
+                        degree: r.degree,
+                    }));
+                    const fileRows = db.prepare(`
+            SELECT n.file_path,
+                   COUNT(DISTINCT e2.id) AS in_deg,
+                   COUNT(DISTINCT e1.id) AS out_deg
+            FROM nodes n
+            LEFT JOIN edges e1 ON e1.source_id = n.id
+            LEFT JOIN edges e2 ON e2.target_id = n.id
+            WHERE n.label = 'File'
+              AND n.file_path NOT LIKE '%node_modules%'
+              AND n.file_path NOT LIKE '%/dist/%'
+              AND n.file_path NOT LIKE '%.test.%'
+              AND n.file_path NOT LIKE '%.spec.%'
+            GROUP BY n.id
+            ORDER BY (in_deg + out_deg) DESC
+            LIMIT 5
+          `).all();
+                    const highDegFiles = fileRows.map(r => ({
+                        file: r.file_path
+                            .replace(this.projectRoot + '/', '')
+                            .replace(this.projectRoot + '\\', ''),
+                        inDegree: r.in_deg,
+                        outDegree: r.out_deg,
+                        totalDegree: r.in_deg + r.out_deg,
+                    }));
+                    const findings = [];
+                    if (godNodes.length > 0) {
+                        findings.push({
+                            category: 'god_nodes',
+                            description: `Top ${godNodes.length} high-centrality symbols (most imported/referenced)`,
+                            items: godNodes,
+                        });
+                    }
+                    if (highDegFiles.length > 0) {
+                        findings.push({
+                            category: 'high_degree_files',
+                            description: `Top ${highDegFiles.length} files by total edge degree (import + export connections)`,
+                            items: highDegFiles,
+                        });
+                    }
+                    result['graph'] = { nodes: nodeCount, edges: edgeCount };
+                    result['findings'] = findings;
+                    result['analysisDepth'] = 'graph';
+                }
+                finally {
+                    closeDb(db);
+                }
+            }
+            else {
+                result['note'] = 'Monograph index not built — run `monomind monograph build` for deep analysis';
+            }
+        }
+        catch { /* monograph unavailable — return minimal result */ }
+        const deepdiveFileTmp = deepdiveFile + '.tmp';
+        writeFileSync(deepdiveFileTmp, JSON.stringify(result, null, 2));
+        renameSync(deepdiveFileTmp, deepdiveFile);
+        return result;
     }
     /**
      * Local benchmark worker
@@ -1042,6 +1362,17 @@ export class WorkerDaemon extends EventEmitter {
         try {
             const logFile = join(this.config.logDir, 'daemon.log');
             appendFileSync(logFile, logMessage + '\n');
+            // Opportunistic rotation: keep the log under 10 MB. When exceeded,
+            // discard the oldest half so recent entries are always retained.
+            const MAX_LOG_BYTES = 10 * 1024 * 1024;
+            if (statSync(logFile).size > MAX_LOG_BYTES) {
+                const content = readFileSync(logFile, 'utf-8');
+                const lines = content.split('\n').filter(Boolean);
+                const trimmed = lines.slice(Math.floor(lines.length / 2)).join('\n') + '\n';
+                const tmp = `${logFile}.${process.pid}.${Date.now()}.tmp`;
+                writeFileSync(tmp, trimmed);
+                renameSync(tmp, logFile);
+            }
         }
         catch {
             // Ignore log write errors