@monoes/cli 1.2.1 → 1.2.3

package/dist/src/init/statusline-generator.js

@@ -44,7 +44,7 @@ const os = require('os');
 
 // Configuration
 const CONFIG = {
-  maxAgents: ${{ maxAgents }},
+  maxAgents: ${maxAgents},
 };
 
 const CWD = process.cwd();

package/dist/src/mcp-tools/graphify-tools.js

@@ -138,10 +138,16 @@ export const graphifyBuildTool = {
             return {
                 success: true,
                 graphPath: result.graphPath,
+                reportPath: result.reportPath,
                 filesProcessed: result.filesProcessed,
+                fromCache: result.fromCache,
                 nodes: result.analysis.stats.nodes,
                 edges: result.analysis.stats.edges,
-                message: `Knowledge graph built at ${result.graphPath}`,
+                communities: result.analysis.stats.communities,
+                graphQuality: result.graphQuality,
+                experimentStatus: result.experimentStatus,
+                corpusWarnings: result.corpusWarnings,
+                message: `[${result.experimentStatus}] Knowledge graph built — quality=${result.graphQuality.toFixed(4)} (${result.analysis.stats.nodes}n/${result.analysis.stats.edges}e/${result.analysis.stats.communities}c)`,
             };
         }
         catch (err) {
@@ -824,6 +830,320 @@ export const graphifyVisualizeTool = {
         }
     },
 };
+// ── Watch PID helpers ─────────────────────────────────────────────────────────
+function getPidPath(cwd) {
+    return resolve(join(cwd, '.monobrain', 'graph', 'watch.pid'));
+}
+function readWatchPid(cwd) {
+    const pidPath = getPidPath(cwd);
+    if (!existsSync(pidPath))
+        return null;
+    try {
+        const pid = parseInt(readFileSync(pidPath, 'utf-8').trim(), 10);
+        return isNaN(pid) ? null : pid;
+    }
+    catch {
+        return null;
+    }
+}
+function isProcessRunning(pid) {
+    try {
+        process.kill(pid, 0);
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+// ── Watch tools ───────────────────────────────────────────────────────────────
+export const graphifyWatchTool = {
+    name: 'graphify_watch',
+    description: 'Start a background file watcher that automatically rebuilds the knowledge graph ' +
+        '(graph.json + graph.html) whenever source files change. Uses a 2-second debounce ' +
+        'so rapid saves do not trigger repeated rebuilds. The watcher runs as a detached ' +
+        'background process — call graphify_watch_stop to stop it.',
+    category: 'graphify',
+    tags: ['knowledge-graph', 'watch', 'auto-rebuild'],
+    inputSchema: {
+        type: 'object',
+        properties: {
+            path: {
+                type: 'string',
+                description: 'Project root to watch (defaults to current project root)',
+            },
+            debounce: {
+                type: 'number',
+                description: 'Debounce delay in milliseconds (default 2000)',
+                default: 2000,
+            },
+            extensions: {
+                type: 'string',
+                description: 'Comma-separated list of file extensions to watch (default: ts,js,tsx,jsx,py,go,rs,java,cs,rb,cpp,c)',
+                default: 'ts,js,tsx,jsx,py,go,rs,java,cs,rb,cpp,c',
+            },
+        },
+    },
+    handler: async (params) => {
+        const cwd = getProjectCwd();
+        const targetPath = params.path || cwd;
+        const debounceMs = params.debounce || 2000;
+        const extensions = ((params.extensions) || 'ts,js,tsx,jsx,py,go,rs,java,cs,rb,cpp,c')
+            .split(',')
+            .map((e) => e.trim())
+            .filter(Boolean);
+        // Check if already running
+        const existingPid = readWatchPid(targetPath);
+        if (existingPid !== null && isProcessRunning(existingPid)) {
+            return {
+                success: false,
+                message: `Watcher already running (PID ${existingPid})`,
+                hint: 'Call graphify_watch_stop first to restart.',
+            };
+        }
+        const pidPath = getPidPath(targetPath);
+        const outputDir = resolve(join(targetPath, '.monobrain', 'graph'));
+        const watcherScript = `
+import { watch } from 'chokidar';
+import { writeFileSync, mkdirSync } from 'fs';
+
+const TARGET = ${JSON.stringify(targetPath)};
+const OUTPUT_DIR = ${JSON.stringify(outputDir)};
+const PID_PATH = ${JSON.stringify(pidPath)};
+const DEBOUNCE_MS = ${debounceMs};
+const EXTS = new Set(${JSON.stringify(extensions)});
+const IGNORE = [/node_modules/, /\\.git/, /\\.monobrain/, /dist[\\/]/, /\\.next/, /\\.turbo/, /coverage/];
+
+mkdirSync(OUTPUT_DIR, { recursive: true });
+writeFileSync(PID_PATH, String(process.pid));
+console.log('[graphify-watch] PID', process.pid, '— watching', TARGET);
+
+let timer = null;
+
+async function rebuild() {
+  const start = Date.now();
+  console.log('[graphify-watch] Change detected — rebuilding graph…');
+  try {
+    const { buildGraph } = await import('@monoes/graph');
+    const { exportHTML } = await import('@monoes/graph');
+    const { graph: serialized } = await buildGraph(TARGET, { outputDir: OUTPUT_DIR });
+    exportHTML(serialized, OUTPUT_DIR);
+    console.log('[graphify-watch] Done in', Date.now() - start, 'ms');
+  } catch (err) {
+    console.error('[graphify-watch] Build error:', err.message ?? err);
+  }
+}
+
+const watcher = watch(TARGET, {
+  ignored: (p) => IGNORE.some((r) => r.test(p)),
+  persistent: true,
+  ignoreInitial: true,
+  awaitWriteFinish: { stabilityThreshold: 300, pollInterval: 100 },
+});
+
+watcher.on('all', (event, filePath) => {
+  const ext = filePath.split('.').pop() ?? '';
+  if (!EXTS.has(ext)) return;
+  if (timer) clearTimeout(timer);
+  timer = setTimeout(rebuild, DEBOUNCE_MS);
+});
+
+watcher.on('error', (err) => console.error('[graphify-watch] Watcher error:', err));
+process.on('SIGINT', () => process.exit(0));
+process.on('SIGTERM', () => process.exit(0));
+`;
+        try {
+            const { spawn } = await import('child_process');
+            const { writeFileSync, mkdirSync } = await import('fs');
+            mkdirSync(outputDir, { recursive: true });
+            const scriptPath = resolve(join(outputDir, '_watcher.mjs'));
+            writeFileSync(scriptPath, watcherScript);
+            const child = spawn(process.execPath, [scriptPath], {
+                detached: true,
+                stdio: 'ignore',
+                env: { ...process.env },
+            });
+            child.unref();
+            await new Promise((r) => setTimeout(r, 500));
+            const pid = readWatchPid(targetPath) ?? child.pid;
+            return {
+                success: true,
+                pid,
+                watching: targetPath,
+                debounceMs,
+                extensions,
+                message: `Graph watcher started (PID ${pid}). graph.json + graph.html will rebuild on file changes.`,
+                hint: 'Call graphify_watch_stop to stop.',
+            };
+        }
+        catch (err) {
+            return { error: true, message: String(err) };
+        }
+    },
+};
+export const graphifyWatchStopTool = {
+    name: 'graphify_watch_stop',
+    description: 'Stop the background file watcher started by graphify_watch.',
+    category: 'graphify',
+    tags: ['knowledge-graph', 'watch'],
+    inputSchema: {
+        type: 'object',
+        properties: {
+            path: {
+                type: 'string',
+                description: 'Project root (defaults to current project root)',
+            },
+        },
+    },
+    handler: async (params) => {
+        const cwd = getProjectCwd();
+        const targetPath = params.path || cwd;
+        const pid = readWatchPid(targetPath);
+        if (pid === null) {
+            return { success: false, message: 'No watcher PID found — watcher may not be running.' };
+        }
+        if (!isProcessRunning(pid)) {
+            try {
+                const { unlinkSync } = await import('fs');
+                unlinkSync(getPidPath(targetPath));
+            }
+            catch { /* ignore */ }
+            return { success: false, message: `Process ${pid} is not running (stale PID cleaned up).` };
+        }
+        try {
+            process.kill(pid, 'SIGTERM');
+            try {
+                const { unlinkSync } = await import('fs');
+                unlinkSync(getPidPath(targetPath));
+            }
+            catch { /* ignore */ }
+            return { success: true, message: `Watcher (PID ${pid}) stopped.` };
+        }
+        catch (err) {
+            return { error: true, message: `Failed to stop PID ${pid}: ${String(err)}` };
+        }
+    },
+};
+/**
+ * Read the GRAPH_REPORT.md generated during the last build.
+ */
+export const graphifyReportTool = {
+    name: 'graphify_report',
+    description: 'Read the GRAPH_REPORT.md generated by the last graphify_build. ' +
+        'Returns the full markdown audit trail: corpus check, god nodes, surprising connections, ' +
+        'communities, ambiguous edges, knowledge gaps, and suggested questions.',
+    category: 'graphify',
+    tags: ['knowledge-graph', 'report', 'audit'],
+    inputSchema: {
+        type: 'object',
+        properties: {
+            path: {
+                type: 'string',
+                description: 'Project path (defaults to current project root)',
+            },
+        },
+    },
+    handler: async (params) => {
+        const cwd = getProjectCwd();
+        const targetPath = params.path || cwd;
+        const reportPath = resolve(join(targetPath, '.monobrain', 'graph', 'GRAPH_REPORT.md'));
+        if (!existsSync(reportPath)) {
+            return {
+                error: true,
+                message: 'No report found. Run graphify_build first.',
+                hint: `Expected: ${reportPath}`,
+            };
+        }
+        try {
+            const content = readFileSync(reportPath, 'utf-8');
+            return { success: true, reportPath, content };
+        }
+        catch (err) {
+            return { error: true, message: String(err) };
+        }
+    },
+};
+/**
+ * Suggest questions the knowledge graph can answer about the codebase.
+ */
+export const graphifySuggestTool = {
+    name: 'graphify_suggest',
+    description: 'Return a prioritised list of questions this knowledge graph is uniquely ' +
+        'positioned to answer — e.g. bridge nodes between subsystems, god nodes worth investigating, ' +
+        'isolated components with no connections, and low-cohesion communities. ' +
+        'Use after graphify_build to guide architectural analysis.',
+    category: 'graphify',
+    tags: ['knowledge-graph', 'questions', 'analysis'],
+    inputSchema: {
+        type: 'object',
+        properties: {
+            path: {
+                type: 'string',
+                description: 'Project path (defaults to current project root)',
+            },
+        },
+    },
+    handler: async (params) => {
+        const cwd = getProjectCwd();
+        const targetPath = params.path || cwd;
+        if (!graphExists(targetPath)) {
+            return { error: true, message: 'No graph found. Run graphify_build first.' };
+        }
+        try {
+            const { loadGraph, suggestQuestions, buildAnalysis, buildGraphologyGraph } = await import('@monoes/graph');
+            const graphPath = getGraphPath(targetPath);
+            const outputDir = resolve(join(targetPath, '.monobrain', 'graph'));
+            const raw = loadGraph(graphPath);
+            const graph = buildGraphologyGraph({ nodes: raw.nodes, edges: raw.edges, hyperedges: [], filesProcessed: 0, fromCache: 0, errors: [] });
+            const analysis = buildAnalysis(graph, outputDir);
+            const questions = suggestQuestions(graph, analysis.communities);
+            return { success: true, questions, total: questions.length };
+        }
+        catch (err) {
+            return { error: true, message: String(err) };
+        }
+    },
+};
+/**
+ * Run a corpus health check on the project files.
+ */
+export const graphifyHealthTool = {
+    name: 'graphify_health',
+    description: 'Run a corpus health check on the project directory — warns when the codebase ' +
+        'is too small for graph analysis, too large to be useful, security-sensitive files were ' +
+        'found, or when the doc-to-code ratio is skewed. Run before graphify_build to catch issues early.',
+    category: 'graphify',
+    tags: ['knowledge-graph', 'health', 'corpus'],
+    inputSchema: {
+        type: 'object',
+        properties: {
+            path: {
+                type: 'string',
+                description: 'Project path (defaults to current project root)',
+            },
+        },
+    },
+    handler: async (params) => {
+        const cwd = getProjectCwd();
+        const targetPath = params.path || cwd;
+        try {
+            const { collectFiles, corpusHealth } = await import('@monoes/graph');
+            const files = collectFiles(targetPath);
+            const warnings = corpusHealth(files);
+            return {
+                success: true,
+                totalFiles: files.length,
+                warnings,
+                healthy: warnings.length === 0,
+                message: warnings.length === 0
+                    ? `Corpus looks healthy (${files.length} files).`
+                    : `${warnings.length} warning(s) found.`,
+            };
+        }
+        catch (err) {
+            return { error: true, message: String(err) };
+        }
+    },
+};
 // ── Exports ───────────────────────────────────────────────────────────────────
 export const graphifyTools = [
     graphifyBuildTool,
@@ -835,6 +1155,11 @@ export const graphifyTools = [
     graphifyStatsTool,
     graphifySurprisesTool,
     graphifyVisualizeTool,
+    graphifyWatchTool,
+    graphifyWatchStopTool,
+    graphifyReportTool,
+    graphifySuggestTool,
+    graphifyHealthTool,
 ];
 export default graphifyTools;
 //# sourceMappingURL=graphify-tools.js.map

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@monoes/cli",
-  "version": "1.2.1",
+  "version": "1.2.3",
   "type": "module",
   "description": "Monobrain CLI - Enterprise AI agent orchestration with 60+ specialized agents, swarm coordination, MCP server, self-learning hooks, and vector memory for Claude Code",
   "main": "dist/src/index.js",