@grafema/mcp 0.2.11 → 0.3.0-beta

package/src/analysis-worker.ts

@@ -1,306 +1,14 @@
 /**
- * Analysis Worker - runs in separate process to avoid blocking MCP server
+ * Analysis Worker — DEPRECATED
  *
- * Usage: node analysis-worker.js <projectPath> [serviceName]
+ * Analysis is now handled by the grafema-orchestrator Rust binary.
+ * This file is kept as a stub to prevent import errors from any remaining references.
  *
- * Sends progress updates via IPC to parent process
+ * Use analysis.ts ensureAnalyzed() which spawns grafema-orchestrator.
  */
 
-import { join } from 'path';
-import { existsSync, readdirSync, readFileSync } from 'fs';
-import { pathToFileURL } from 'url';
-
-import {
-  Orchestrator,
-  RFDBServerBackend,
-  // Indexing
-  JSModuleIndexer,
-  // Analysis
-  JSASTAnalyzer,
-  ExpressRouteAnalyzer,
-  ExpressResponseAnalyzer,
-  NestJSRouteAnalyzer,
-  SocketIOAnalyzer,
-  DatabaseAnalyzer,
-  FetchAnalyzer,
-  ServiceLayerAnalyzer,
-  ReactAnalyzer,
-  // Enrichment
-  MethodCallResolver,
-  ArgumentParameterLinker,
-  AliasTracker,
-  ValueDomainAnalyzer,
-  MountPointResolver,
-  PrefixEvaluator,
-  ConfigRoutingMapBuilder,
-  ServiceConnectionEnricher,
-  RejectionPropagationEnricher,
-  // Validation
-  CallResolverValidator,
-  EvalBanValidator,
-  SQLInjectionValidator,
-  AwaitInLoopValidator,
-  ShadowingDetector,
-  GraphConnectivityValidator,
-  DataFlowValidator,
-  UnconnectedRouteValidator,
-} from '@grafema/core';
-import type { ParallelConfig ,
-  Plugin} from '@grafema/core';
-
-/**
- * Config structure
- */
-interface WorkerConfig {
-  plugins?: Record<string, string[]>;
-  analysis?: {
-    parallel?: ParallelConfig & { workers?: number; socketPath?: string };
-  };
-}
-
-/**
- * Progress message
- */
-interface ProgressMessage {
-  type: 'progress';
-  phase?: string;
-  message?: string;
-  servicesDiscovered?: number;
-  servicesAnalyzed?: number;
-}
-
-/**
- * Complete message
- */
-interface CompleteMessage {
-  type: 'complete';
-  nodeCount: number;
-  edgeCount: number;
-  totalTime: string;
-}
-
-/**
- * Error message
- */
-interface ErrorMessage {
-  type: 'error';
-  message: string;
-  stack?: string;
-}
-
-
-const projectPath = process.argv[2];
-const serviceName = process.argv[3] && process.argv[3] !== '' ? process.argv[3] : null;
-const indexOnly = process.argv[4] === 'indexOnly';
-
-if (!projectPath) {
-  console.error('Usage: node analysis-worker.js <projectPath> [serviceName] [indexOnly]');
-  process.exit(1);
-}
-
-function sendProgress(data: Omit<ProgressMessage, 'type'>): void {
-  if (process.send) {
-    process.send({ type: 'progress', ...data } as ProgressMessage);
-  }
-}
-
-function sendComplete(data: Omit<CompleteMessage, 'type'>): void {
-  if (process.send) {
-    process.send({ type: 'complete', ...data } as CompleteMessage);
-  }
-}
-
-function sendError(error: Error): void {
-  if (process.send) {
-    process.send({ type: 'error', message: error.message, stack: error.stack } as ErrorMessage);
-  }
-}
-
-async function loadConfig(): Promise<WorkerConfig> {
-  const configPath = join(projectPath, '.grafema', 'config.json');
-  if (existsSync(configPath)) {
-    return JSON.parse(readFileSync(configPath, 'utf8')) as WorkerConfig;
-  }
-  return { plugins: {} };
-}
-
-async function loadCustomPlugins(): Promise<Record<string, new () => Plugin>> {
-  const pluginsDir = join(projectPath, '.grafema', 'plugins');
-  const customPlugins: Record<string, new () => Plugin> = {};
-
-  if (!existsSync(pluginsDir)) {
-    return customPlugins;
-  }
-
-  const files = readdirSync(pluginsDir).filter(f => f.endsWith('.mjs') || f.endsWith('.js'));
-  for (const file of files) {
-    try {
-      const module = await import(pathToFileURL(join(pluginsDir, file)).href);
-      const PluginClass = module.default as new () => Plugin;
-      if (PluginClass) {
-        customPlugins[PluginClass.name] = PluginClass;
-      }
-    } catch (err) {
-      console.error(`Failed to load plugin ${file}:`, (err as Error).message);
-    }
-  }
-
-  return customPlugins;
-}
-
-async function run(): Promise<void> {
-  const startTime = Date.now();
-  let db: RFDBServerBackend | null = null;
-
-  try {
-    sendProgress({ phase: 'starting', message: 'Loading configuration...' });
-
-    const config = await loadConfig();
-    const customPlugins = await loadCustomPlugins();
-
-    // Built-in plugins map
-    const builtinPlugins: Record<string, () => Plugin> = {
-      JSModuleIndexer: () => new JSModuleIndexer(),
-      JSASTAnalyzer: () => new JSASTAnalyzer(),
-      ExpressRouteAnalyzer: () => new ExpressRouteAnalyzer(),
-      ExpressResponseAnalyzer: () => new ExpressResponseAnalyzer(),
-      NestJSRouteAnalyzer: () => new NestJSRouteAnalyzer(),
-      SocketIOAnalyzer: () => new SocketIOAnalyzer(),
-      DatabaseAnalyzer: () => new DatabaseAnalyzer(),
-      FetchAnalyzer: () => new FetchAnalyzer(),
-      ServiceLayerAnalyzer: () => new ServiceLayerAnalyzer(),
-      ReactAnalyzer: () => new ReactAnalyzer(),
-      MethodCallResolver: () => new MethodCallResolver(),
-      ArgumentParameterLinker: () => new ArgumentParameterLinker(),
-      AliasTracker: () => new AliasTracker(),
-      ValueDomainAnalyzer: () => new ValueDomainAnalyzer(),
-      MountPointResolver: () => new MountPointResolver(),
-      PrefixEvaluator: () => new PrefixEvaluator(),
-      ConfigRoutingMapBuilder: () => new ConfigRoutingMapBuilder(),
-      ServiceConnectionEnricher: () => new ServiceConnectionEnricher(),
-      RejectionPropagationEnricher: () => new RejectionPropagationEnricher(),
-      CallResolverValidator: () => new CallResolverValidator(),
-      EvalBanValidator: () => new EvalBanValidator(),
-      SQLInjectionValidator: () => new SQLInjectionValidator(),
-      AwaitInLoopValidator: () => new AwaitInLoopValidator(),
-      ShadowingDetector: () => new ShadowingDetector(),
-      GraphConnectivityValidator: () => new GraphConnectivityValidator(),
-      DataFlowValidator: () => new DataFlowValidator(),
-      UnconnectedRouteValidator: () => new UnconnectedRouteValidator(),
-    };
-
-    // Add custom plugins
-    for (const [name, PluginClass] of Object.entries(customPlugins)) {
-      builtinPlugins[name] = () => new PluginClass();
-    }
-
-    // Build plugins array from config
-    const plugins: Plugin[] = [];
-    for (const [_phase, pluginNames] of Object.entries(config.plugins || {})) {
-      for (const name of pluginNames) {
-        if (builtinPlugins[name]) {
-          plugins.push(builtinPlugins[name]());
-        } else if (customPlugins[name]) {
-          plugins.push(new customPlugins[name]());
-          console.log(`[Worker] Loaded custom plugin: ${name}`);
-        } else {
-          console.warn(`[Worker] Plugin not found: ${name}`);
-        }
-      }
-    }
-
-    console.log(`[Worker] Loaded ${plugins.length} plugins:`, plugins.map(p => p.metadata?.name || p.constructor?.name || 'unknown'));
-    sendProgress({ phase: 'starting', message: `Loaded ${plugins.length} plugins` });
-
-    // Get parallel analysis config
-    const parallelConfig = config.analysis?.parallel;
-    if (parallelConfig?.enabled) {
-      console.log(`[Worker] Queue-based parallel mode enabled: workers=${parallelConfig.workers}`);
-    }
-
-    // Connect to RFDB server (shared with MCP server)
-    // The MCP server starts the RFDB server if not running
-    const dbPath = join(projectPath, '.grafema', 'graph.rfdb');
-    const socketPath = config.analysis?.parallel?.socketPath || '/tmp/rfdb.sock';
-
-    console.log(`[Worker] Connecting to RFDB server: socket=${socketPath}, db=${dbPath}`);
-    db = new RFDBServerBackend({ socketPath, dbPath });
-    await db.connect();
-
-    // NOTE: db.clear() is NOT called here.
-    // MCP server clears DB INSIDE the analysis lock BEFORE spawning this worker.
-    // This prevents race conditions where concurrent analysis calls could both
-    // clear the database. Worker assumes DB is already clean.
-    // See: REG-159 implementation, Phase 2.5 (Worker Clear Coordination)
-
-    sendProgress({ phase: 'discovery', message: 'Starting analysis...' });
-
-    // Create orchestrator
-    const orchestrator = new Orchestrator({
-      graph: db,
-      plugins,
-      parallel: parallelConfig as ParallelConfig | undefined, // Pass parallel config for queue-based analysis
-      serviceFilter: serviceName,
-      indexOnly: indexOnly,
-      onProgress: (progress) => {
-        sendProgress({
-          phase: progress.phase,
-          message: progress.message,
-          servicesAnalyzed: progress.servicesAnalyzed
-        });
-      }
-    });
-
-    // Run analysis
-    await orchestrator.run(projectPath);
-
-    // Get final stats
-    let nodeCount = 0;
-    let edgeCount = 0;
-
-    // Use async methods for RFDBServerBackend
-    const allEdges = await db.getAllEdgesAsync();
-    edgeCount = allEdges.length;
-
-    for await (const _node of db.queryNodes({})) {
-      nodeCount++;
-    }
-
-    // Flush to disk using proper async method
-    console.log('[Worker] Flushing database to disk...');
-    await db.flush();
-    console.log('[Worker] Database flushed successfully');
-
-    const totalTime = ((Date.now() - startTime) / 1000).toFixed(2);
-
-    sendComplete({
-      nodeCount,
-      edgeCount,
-      totalTime
-    });
-
-    // Close database properly before exit
-    await db.close();
-    console.log('[Worker] Database closed');
-
-    process.exit(0);
-  } finally {
-    // Ensure database connection is closed even on error
-    if (db && db.connected) {
-      try {
-        await db.close();
-        console.log('[Worker] Database connection closed in cleanup');
-      } catch (closeErr) {
-        const message = closeErr instanceof Error ? closeErr.message : String(closeErr);
-        console.error('[Worker] Error closing database connection:', message);
-      }
-    }
-  }
-}
-
-run().catch(err => {
-  const error = err instanceof Error ? err : new Error(String(err));
-  sendError(error);
-  console.error('Analysis failed:', err);
-  process.exit(1);
-});
+throw new Error(
+  'Analysis is now handled by grafema-orchestrator. ' +
+    'Use analysis.ts ensureAnalyzed() instead. ' +
+    'The worker pattern is no longer needed since we shell out to a native binary.'
+);

package/src/analysis.ts

@@ -1,9 +1,15 @@
 /**
  * MCP Analysis Orchestration
+ *
+ * Shells out to the `grafema-orchestrator` Rust binary instead of using
+ * the JS Orchestrator class. The binary handles file discovery, parsing,
+ * analysis, resolution, and RFDB ingestion.
  */
 
-import type { Plugin } from '@grafema/core';
-import { Orchestrator } from '@grafema/core';
+import { existsSync } from 'fs';
+import { join } from 'path';
+import { spawn } from 'child_process';
+import { findOrchestratorBinary, getBinaryNotFoundMessage } from '@grafema/util';
 import {
   getOrCreateBackend,
   getProjectPath,
@@ -13,11 +19,103 @@ import {
   setAnalysisStatus,
   isAnalysisRunning,
   acquireAnalysisLock,
+  getKnowledgeBase,
 } from './state.js';
-import { loadConfig, loadCustomPlugins, createPlugins } from './config.js';
+import { loadConfig } from './config.js';
 import { log } from './utils.js';
 import type { GraphBackend } from '@grafema/types';
 
+/**
+ * Resolve the config file path for grafema-orchestrator.
+ *
+ * The orchestrator expects a YAML config with `root`, `include`, `exclude` fields.
+ * Looks for:
+ * 1. grafema.config.yaml in project root
+ * 2. .grafema/config.yaml as fallback
+ */
+function findConfigPath(projectPath: string): string | null {
+  const candidates = [
+    join(projectPath, 'grafema.config.yaml'),
+    join(projectPath, '.grafema', 'config.yaml'),
+  ];
+
+  for (const candidate of candidates) {
+    if (existsSync(candidate)) return candidate;
+  }
+
+  return null;
+}
+
+/**
+ * Resolve the RFDB socket path for the current project.
+ *
+ * Uses the same logic as state.ts getOrCreateBackend():
+ * config.analysis.parallel.socketPath > default derived from dbPath
+ */
+function resolveSocketPath(projectPath: string): string {
+  const config = loadConfig(projectPath);
+  const configSocket = (config as any).analysis?.parallel?.socketPath;
+  if (configSocket) return configSocket;
+
+  // Default: same as RFDBServerBackend derives from dbPath
+  return join(projectPath, '.grafema', 'rfdb.sock');
+}
+
+/**
+ * Spawn grafema-orchestrator and wait for it to complete.
+ *
+ * @returns Promise that resolves on success, rejects on failure
+ */
+function runOrchestrator(
+  binaryPath: string,
+  args: string[],
+): Promise<void> {
+  return new Promise((resolve, reject) => {
+    log(`[Grafema MCP] Spawning: ${binaryPath} ${args.join(' ')}`);
+
+    const child = spawn(binaryPath, args, {
+      stdio: ['ignore', 'pipe', 'pipe'],
+    });
+
+    let stdout = '';
+    let stderr = '';
+
+    child.stdout.on('data', (data: Buffer) => {
+      const text = data.toString();
+      stdout += text;
+      // Forward orchestrator output to MCP log
+      for (const line of text.split('\n').filter(Boolean)) {
+        log(`[orchestrator] ${line}`);
+      }
+    });
+
+    child.stderr.on('data', (data: Buffer) => {
+      const text = data.toString();
+      stderr += text;
+      for (const line of text.split('\n').filter(Boolean)) {
+        log(`[orchestrator] ${line}`);
+      }
+    });
+
+    child.on('error', (err: Error) => {
+      reject(new Error(`Failed to spawn grafema-orchestrator: ${err.message}`));
+    });
+
+    child.on('close', (code: number | null) => {
+      if (code === 0) {
+        resolve();
+      } else {
+        reject(
+          new Error(
+            `grafema-orchestrator exited with code ${code}\n` +
+              (stderr || stdout || '(no output)')
+          )
+        );
+      }
+    });
+  });
+}
+
 /**
  * Ensure project is analyzed, optionally filtering to a single service.
  *
@@ -26,8 +124,8 @@ import type { GraphBackend } from '@grafema/types';
  * - Concurrent calls wait for the current analysis to complete
  * - force=true while analysis is running returns an error immediately
  *
- * @param serviceName - Optional service to analyze (null = all)
- * @param force - If true, clear DB and re-analyze even if already analyzed.
+ * @param serviceName - Optional service to analyze (null = all) — currently unused by the orchestrator
+ * @param force - If true, add --force flag to re-analyze all files.
  *                ERROR if another analysis is already running.
  * @throws Error if force=true and analysis is already running
  */
@@ -62,8 +160,6 @@ export async function ensureAnalyzed(
     }
 
     // Clear DB inside lock, BEFORE running analysis
-    // This is critical for worker coordination: MCP server clears DB here,
-    // worker does NOT call db.clear() (see analysis-worker.ts)
     if (force || !getIsAnalyzed()) {
       log('[Grafema MCP] Clearing database before analysis...');
       if (db.clear) {
@@ -76,45 +172,48 @@ export async function ensureAnalyzed(
       `[Grafema MCP] Analyzing project: ${projectPath}${serviceName ? ` (service: ${serviceName})` : ''}`
     );
 
-    const config = loadConfig(projectPath);
-    const { pluginMap: customPluginMap } = await loadCustomPlugins(projectPath);
-
-    // Create plugins from config
-    const plugins = createPlugins(config.plugins, customPluginMap);
-
-    log(`[Grafema MCP] Total plugins: ${plugins.length}`);
-
-    // Check for parallel analysis config
-    const parallelConfig = (config as any).analysis?.parallel;
-    log(`[Grafema MCP] Config analysis section: ${JSON.stringify((config as any).analysis)}`);
+    // Find the orchestrator binary
+    const binaryPath = findOrchestratorBinary();
+    if (!binaryPath) {
+      throw new Error(getBinaryNotFoundMessage('grafema-orchestrator'));
+    }
 
-    if (parallelConfig?.enabled) {
-      log(
-        `[Grafema MCP] Parallel analysis enabled: maxWorkers=${parallelConfig.maxWorkers || 'auto'}, socket=${parallelConfig.socketPath || '/tmp/rfdb.sock'}`
+    // Find config file
+    const configPath = findConfigPath(projectPath);
+    if (!configPath) {
+      throw new Error(
+        `No config file found for grafema-orchestrator.\n` +
+          `Expected one of:\n` +
+          `  - ${join(projectPath, 'grafema.config.yaml')}\n` +
+          `  - ${join(projectPath, '.grafema', 'config.yaml')}\n`
       );
     }
 
+    // Resolve socket path
+    const socketPath = resolveSocketPath(projectPath);
+
     const analysisStatus = getAnalysisStatus();
     const startTime = Date.now();
 
-    const orchestrator = new Orchestrator({
-      graph: db,
-      plugins: plugins as Plugin[],
-      parallel: parallelConfig,
-      serviceFilter: serviceName,
-      onProgress: (progress: any) => {
-        log(`[Grafema MCP] ${progress.phase}: ${progress.message}`);
-
-        setAnalysisStatus({
-          phase: progress.phase,
-          message: progress.message,
-          servicesDiscovered: progress.servicesDiscovered || analysisStatus.servicesDiscovered,
-          servicesAnalyzed: progress.servicesAnalyzed || analysisStatus.servicesAnalyzed,
-        });
-      },
+    setAnalysisStatus({
+      phase: 'starting',
+      message: 'Spawning grafema-orchestrator...',
+      servicesDiscovered: analysisStatus.servicesDiscovered,
+      servicesAnalyzed: analysisStatus.servicesAnalyzed,
     });
 
-    await orchestrator.run(projectPath);
+    // Build args
+    const args = ['analyze', '--config', configPath, '--socket', socketPath];
+    if (force) {
+      args.push('--force');
+    }
+
+    log(`[Grafema MCP] Binary: ${binaryPath}`);
+    log(`[Grafema MCP] Config: ${configPath}`);
+    log(`[Grafema MCP] Socket: ${socketPath}`);
+
+    // Run the orchestrator
+    await runOrchestrator(binaryPath, args);
 
     // Flush if available
     if ('flush' in db && typeof db.flush === 'function') {
@@ -123,8 +222,17 @@ export async function ensureAnalyzed(
 
     setIsAnalyzed(true);
 
+    // Bump KB resolver generation so cached resolutions are re-evaluated
+    const kb = getKnowledgeBase();
+    if (kb) {
+      kb.invalidateResolutionCache();
+      log('[Grafema MCP] KnowledgeBase resolution cache invalidated after analysis');
+    }
+
     const totalTime = ((Date.now() - startTime) / 1000).toFixed(2);
     setAnalysisStatus({
+      phase: 'complete',
+      message: `Analysis complete in ${totalTime}s`,
       timings: {
         ...analysisStatus.timings,
         total: parseFloat(totalTime),
@@ -141,47 +249,13 @@ export async function ensureAnalyzed(
 }
 
 /**
- * Discover services without running full analysis
+ * Discover services without running full analysis.
+ *
+ * Service discovery is now handled by grafema-orchestrator's file discovery.
+ * This returns an empty array — the orchestrator handles discovery internally.
  */
 export async function discoverServices(): Promise<unknown[]> {
-  const db = await getOrCreateBackend();
   const projectPath = getProjectPath();
-
-  log(`[Grafema MCP] Discovering services in: ${projectPath}`);
-
-  const config = loadConfig(projectPath);
-  const { pluginMap: customPluginMap } = await loadCustomPlugins(projectPath);
-
-  const availablePlugins: Record<string, () => unknown> = {
-    ...Object.fromEntries(
-      Object.entries(customPluginMap).map(([name, PluginClass]) => [
-        name,
-        () => new PluginClass(),
-      ])
-    ),
-  };
-
-  const plugins: unknown[] = [];
-  const discoveryPluginNames = config.plugins.discovery ?? [];
-
-  for (const name of discoveryPluginNames) {
-    const factory = availablePlugins[name];
-    if (factory) {
-      plugins.push(factory());
-      log(`[Grafema MCP] Enabled discovery plugin: ${name}`);
-    } else {
-      log(`[Grafema MCP] Warning: Unknown discovery plugin ${name}`);
-    }
-  }
-
-  const orchestrator = new Orchestrator({
-    graph: db,
-    plugins: plugins as Plugin[],
-  });
-
-  const manifest = await orchestrator.discover(projectPath);
-
-  log(`[Grafema MCP] Discovery complete: found ${manifest.services?.length || 0} services`);
-
-  return manifest.services || [];
+  log(`[Grafema MCP] Service discovery is handled by grafema-orchestrator. Project: ${projectPath}`);
+  return [];
 }