@grafema/core 0.1.0-alpha.5 → 0.2.0-beta

package/dist/plugins/discovery/ZonServiceDiscovery.js

@@ -1,204 +0,0 @@
-/**
- * ZonServiceDiscovery - плагин для поиска сервисов в zon1 монорепозитории
- *
- * Точная реализация логики из file2host.js:
- * 1. Читает servers.js - база данных серверов
- * 2. Использует zserver_conf.prepare_conf() для получения конфигурации каждого сервера
- * 3. Читает k8s/deploy/configs/apps.json - kubernetes приложения
- * 4. Извлекает entrypoint'ы для каждого сервиса
- */
-import { DiscoveryPlugin } from './DiscoveryPlugin.js';
-import { createSuccessResult, createErrorResult } from '../Plugin.js';
-import { existsSync, readFileSync } from 'fs';
-import { join } from 'path';
-import { createRequire } from 'module';
-export class ZonServiceDiscovery extends DiscoveryPlugin {
-    constructor(config = {}) {
-        super(config);
-    }
-    // Debug: show which file was loaded at runtime
-    static __loaded = (() => {
-        try {
-            console.log('[ZonServiceDiscovery] module loaded from', import.meta.url);
-        }
-        catch {
-            // Ignore
-        }
-        return true;
-    })();
-    get metadata() {
-        return {
-            name: 'ZonServiceDiscovery',
-            phase: 'DISCOVERY',
-            priority: 100,
-            creates: {
-                nodes: ['SERVICE'],
-                edges: []
-            },
-            dependencies: []
-        };
-    }
-    hostname_base(hostname) {
-        return hostname.replace(/(-ec2)?\d*$/, '$1');
-    }
-    async execute(context) {
-        const { projectPath, graph } = context;
-        console.log(`[ZonServiceDiscovery] Scanning ${projectPath}`);
-        try {
-            // Set environment variable to avoid BUILD error
-            process.env.ZON_CONFIG_FALLBACK = '1';
-            const services = [];
-            const require = createRequire(import.meta.url);
-            // Paths
-            const serversDbPath = join(projectPath, 'pkg/system/db/servers.js');
-            const zserverConfPath = join(projectPath, 'pkg/system/agent/zserver_conf.js');
-            const appsJsonPath = join(projectPath, 'pkg/k8s/deploy/configs/apps.json');
-            // Check if this is zon1 repository
-            if (!existsSync(serversDbPath)) {
-                console.log(`[ZonServiceDiscovery] servers.js not found - not a zon1 repository`);
-                return createErrorResult(new Error(`Not a zon1 repository - servers.js not found`));
-            }
-            console.log(`[ZonServiceDiscovery] Loading servers.js...`);
-            // Load modules
-            let servers_js;
-            let zserver_conf;
-            let k8s_apps = {};
-            try {
-                // Clear require cache to get fresh modules
-                delete require.cache[require.resolve(serversDbPath)];
-                delete require.cache[require.resolve(zserverConfPath)];
-                servers_js = require(serversDbPath);
-                console.log(`[ZonServiceDiscovery] Loaded servers.js`);
-            }
-            catch (err) {
-                console.log(`[ZonServiceDiscovery] Failed to load servers.js:`, err.message);
-                return createErrorResult(err);
-            }
-            try {
-                zserver_conf = require(zserverConfPath);
-                console.log(`[ZonServiceDiscovery] Loaded zserver_conf.js`);
-            }
-            catch (err) {
-                console.log(`[ZonServiceDiscovery] Failed to load zserver_conf.js:`, err.message);
-                return createErrorResult(err);
-            }
-            // Load k8s apps (optional)
-            if (existsSync(appsJsonPath)) {
-                try {
-                    const appsContent = readFileSync(appsJsonPath, 'utf-8');
-                    k8s_apps = JSON.parse(appsContent);
-                    console.log(`[ZonServiceDiscovery] Loaded k8s apps.json`);
-                }
-                catch (err) {
-                    console.log(`[ZonServiceDiscovery] Warning: Failed to load apps.json:`, err.message);
-                }
-            }
-            // Build service tree - exact logic from file2host.js
-            const allServers = Object.entries(servers_js.servers);
-            // Note: file2host uses v.file2host filter, but we'll use entrypoint presence
-            const k8sEntries = Object.entries(k8s_apps).filter(([, v]) => v.entrypoint);
-            console.log(`[ZonServiceDiscovery] Processing ${allServers.length} servers and ${k8sEntries.length} k8s apps...`);
-            const processedGroups = new Set();
-            const serviceMap = new Map(); // entrypoint -> {hosts: [...]}
-            // Process traditional servers - exact logic from file2host.js
-            for (const [hostname, serverConfig] of allServers) {
-                const is_zagent = servers_js.lib.re.zagent.test(hostname);
-                // Skip LPM zagents (util files are transcoded during build)
-                if (is_zagent && serverConfig.type === 'lpm') {
-                    continue;
-                }
-                const hostGroup = is_zagent
-                    ? `${serverConfig.type} zagents`
-                    : this.hostname_base(hostname);
-                if (processedGroups.has(hostGroup)) {
-                    continue;
-                }
-                processedGroups.add(hostGroup);
-                try {
-                    // Get configuration - exact call from file2host.js
-                    const conf = zserver_conf.prepare_conf(hostname)
-                        .filter(c => (c.conf || c.init) && c.file)
-                        .map(({ init, file }) => {
-                        if (!init) {
-                            return file.split('.conf')[0];
-                        }
-                        return init.upstart.xvfs.split(' ')[0];
-                    });
-                    for (const service of conf) {
-                        if (!serviceMap.has(service)) {
-                            serviceMap.set(service, { hosts: [] });
-                        }
-                        serviceMap.get(service).hosts.push({
-                            hostGroup,
-                            hostname,
-                            type: 'traditional'
-                        });
-                    }
-                }
-                catch (err) {
-                    console.log(`[ZonServiceDiscovery] Error processing ${hostname}:`, err.message);
-                }
-            }
-            // Process k8s applications - exact logic from file2host.js
-            for (const [name, config] of k8sEntries) {
-                if (config.entrypoint) {
-                    const entrypoint = config.entrypoint.replace('pkg/', '');
-                    if (!serviceMap.has(entrypoint)) {
-                        serviceMap.set(entrypoint, { hosts: [] });
-                    }
-                    serviceMap.get(entrypoint).hosts.push({
-                        hostGroup: name,
-                        hostname: name,
-                        type: 'k8s'
-                    });
-                }
-            }
-            console.log(`[ZonServiceDiscovery] Found ${serviceMap.size} unique services`);
-            // Show first 20 services as preview
-            const serviceList = Array.from(serviceMap.keys()).sort();
-            console.log(`[ZonServiceDiscovery] Services (showing first 20 of ${serviceList.length}):`);
-            serviceList.slice(0, 20).forEach(s => {
-                const hosts = serviceMap.get(s).hosts;
-                console.log(`  - ${s} (${hosts.length} host${hosts.length > 1 ? 's' : ''})`);
-            });
-            if (serviceList.length > 20) {
-                console.log(`  ... and ${serviceList.length - 20} more`);
-            }
-            // Create SERVICE nodes
-            for (const [entrypoint, data] of serviceMap) {
-                // Use format matching VersionManager.generateStableId()
-                const serviceId = `SERVICE:${entrypoint}`;
-                const servicePath = join(projectPath, 'pkg', entrypoint);
-                // Cast through unknown since we're creating a dynamic service node
-                const metadata = {
-                    discoveryMethod: 'zon',
-                    entrypoint,
-                    hosts: data.hosts,
-                    hostCount: data.hosts.length
-                };
-                const serviceNode = {
-                    id: serviceId,
-                    type: 'SERVICE',
-                    name: entrypoint,
-                    path: servicePath,
-                    metadata
-                };
-                await graph.addNode(serviceNode);
-                services.push({
-                    id: serviceId,
-                    name: entrypoint,
-                    path: servicePath,
-                    type: 'zon-service',
-                    metadata
-                });
-            }
-            console.log(`[ZonServiceDiscovery] Created ${services.length} SERVICE nodes`);
-            return createSuccessResult({ nodes: services.length, edges: 0 }, { services });
-        }
-        catch (error) {
-            console.error(`[ZonServiceDiscovery] Fatal error:`, error);
-            console.error(error.stack);
-            return createErrorResult(error);
-        }
-    }
-}

package/src/core/AnalysisWorker.ts

@@ -1,410 +0,0 @@
-/**
- * AnalysisWorker - worker thread for parallel AST analysis
- *
- * Each worker:
- * 1. Connects to RFDB server
- * 2. Receives file paths to analyze
- * 3. Parses AST and writes nodes/edges directly to RFDB
- *
- * Communication:
- *   Main -> Worker: { type: 'analyze', file, moduleId, moduleName }
- *   Worker -> Main: { type: 'done', file, stats } | { type: 'error', file, error }
- */
-
-import { parentPort, workerData } from 'worker_threads';
-import { readFileSync } from 'fs';
-import { parse, ParserPlugin } from '@babel/parser';
-import traverseModule from '@babel/traverse';
-import type { ImportDeclaration, FunctionDeclaration, ArrowFunctionExpression, ClassDeclaration, CallExpression, Identifier } from '@babel/types';
-import type { NodePath } from '@babel/traverse';
-
-import { RFDBClient } from '@grafema/rfdb-client';
-
-// eslint-disable-next-line @typescript-eslint/no-explicit-any
-const traverse = (traverseModule as any).default || traverseModule;
-
-/**
- * Worker data from main thread
- */
-interface WorkerDataInput {
-  workerId?: number;
-  socketPath?: string;
-  autoConnect?: boolean;
-}
-
-/**
- * Message types from main thread
- */
-interface ConnectMessage {
-  type: 'connect';
-  socketPath?: string;
-}
-
-interface AnalyzeMessage {
-  type: 'analyze';
-  file: string;
-  moduleId: string;
-  moduleName: string;
-}
-
-interface DisconnectMessage {
-  type: 'disconnect';
-}
-
-interface ExitMessage {
-  type: 'exit';
-}
-
-type WorkerMessage = ConnectMessage | AnalyzeMessage | DisconnectMessage | ExitMessage;
-
-/**
- * Analysis stats
- */
-interface AnalysisStats {
-  nodes: number;
-  edges: number;
-  functions: number;
-  calls: number;
-}
-
-/**
- * Wire node for RFDB
- */
-interface WireNode {
-  id: string;
-  type: string;
-  name: string;
-  file: string;
-  metadata?: string;
-}
-
-/**
- * Wire edge for RFDB
- */
-interface WireEdge {
-  src: string;
-  dst: string;
-  type: string;
-}
-
-// Worker state
-let client: RFDBClient | null = null;
-const workerId = (workerData as WorkerDataInput)?.workerId || 0;
-let socketPath = (workerData as WorkerDataInput)?.socketPath || '/tmp/rfdb.sock';
-let connected = false;
-
-/**
- * Connect to RFDB server
- */
-async function connect(): Promise<void> {
-  if (connected) return;
-
-  client = new RFDBClient(socketPath);
-  await client.connect();
-  connected = true;
-
-  parentPort?.postMessage({ type: 'ready', workerId });
-}
-
-/**
- * Parse a file and write results directly to RFDB
- */
-async function analyzeFile(filePath: string, moduleId: string, moduleName: string): Promise<AnalysisStats> {
-  const stats: AnalysisStats = { nodes: 0, edges: 0, functions: 0, calls: 0 };
-
-  try {
-    const code = readFileSync(filePath, 'utf-8');
-
-    const ast = parse(code, {
-      sourceType: 'module',
-      plugins: ['jsx', 'typescript'] as ParserPlugin[],
-      errorRecovery: true
-    });
-
-    // Collections to batch write
-    const nodes: WireNode[] = [];
-    const edges: WireEdge[] = [];
-
-    // Counters for unique IDs
-    let callCounter = 0;
-
-    // Add module node
-    nodes.push({
-      id: moduleId,
-      type: 'MODULE',
-      name: moduleName,
-      file: filePath
-    });
-
-    // Extract imports
-    traverse(ast, {
-      ImportDeclaration(path: NodePath<ImportDeclaration>) {
-        const node = path.node;
-        const source = node.source.value;
-
-        node.specifiers.forEach(spec => {
-          let importedName: string;
-          let localName: string;
-
-          if (spec.type === 'ImportDefaultSpecifier') {
-            importedName = 'default';
-            localName = spec.local.name;
-          } else if (spec.type === 'ImportNamespaceSpecifier') {
-            importedName = '*';
-            localName = spec.local.name;
-          } else {
-            importedName = (spec.imported as Identifier)?.name || spec.local.name;
-            localName = spec.local.name;
-          }
-
-          const importId = `IMPORT#${localName}#${filePath}#${node.loc!.start.line}`;
-          nodes.push({
-            id: importId,
-            type: 'IMPORT',
-            name: localName,
-            file: filePath,
-            metadata: JSON.stringify({ importedName, source, line: node.loc!.start.line })
-          });
-
-          edges.push({ src: moduleId, dst: importId, type: 'CONTAINS' });
-        });
-      }
-    });
-
-    // Extract functions
-    traverse(ast, {
-      FunctionDeclaration(path: NodePath<FunctionDeclaration>) {
-        if (path.getFunctionParent()) return;
-
-        const node = path.node;
-        if (!node.id) return;
-
-        const funcName = node.id.name;
-        const functionId = `FUNCTION#${funcName}#${filePath}#${node.loc!.start.line}`;
-
-        nodes.push({
-          id: functionId,
-          type: 'FUNCTION',
-          name: funcName,
-          file: filePath,
-          metadata: JSON.stringify({
-            line: node.loc!.start.line,
-            async: node.async || false,
-            generator: node.generator || false,
-            exported: path.parent?.type?.includes('Export') || false
-          })
-        });
-
-        edges.push({ src: moduleId, dst: functionId, type: 'CONTAINS' });
-        stats.functions++;
-
-        // Extract parameters
-        node.params.forEach((param, index) => {
-          if (param.type === 'Identifier') {
-            const paramId = `PARAMETER#${param.name}#${functionId}#${index}`;
-            nodes.push({
-              id: paramId,
-              type: 'PARAMETER',
-              name: param.name,
-              file: filePath,
-              metadata: JSON.stringify({ index, functionId })
-            });
-            edges.push({ src: functionId, dst: paramId, type: 'CONTAINS' });
-          }
-        });
-      },
-
-      ArrowFunctionExpression(path: NodePath<ArrowFunctionExpression>) {
-        // Only process top-level arrow functions assigned to variables
-        if (path.getFunctionParent()) return;
-
-        const parent = path.parent;
-        if (parent.type !== 'VariableDeclarator') return;
-        if (!('id' in parent) || !parent.id || parent.id.type !== 'Identifier') return;
-
-        const funcName = parent.id.name;
-        const functionId = `FUNCTION#${funcName}#${filePath}#${path.node.loc!.start.line}`;
-
-        nodes.push({
-          id: functionId,
-          type: 'FUNCTION',
-          name: funcName,
-          file: filePath,
-          metadata: JSON.stringify({
-            line: path.node.loc!.start.line,
-            async: path.node.async || false,
-            arrowFunction: true
-          })
-        });
-
-        edges.push({ src: moduleId, dst: functionId, type: 'CONTAINS' });
-        stats.functions++;
-      }
-    });
-
-    // Extract classes
-    traverse(ast, {
-      ClassDeclaration(path: NodePath<ClassDeclaration>) {
-        if (path.getFunctionParent()) return;
-
-        const node = path.node;
-        if (!node.id) return;
-
-        const className = node.id.name;
-        const classId = `CLASS#${className}#${filePath}#${node.loc!.start.line}`;
-
-        nodes.push({
-          id: classId,
-          type: 'CLASS',
-          name: className,
-          file: filePath,
-          metadata: JSON.stringify({
-            line: node.loc!.start.line,
-            superClass: (node.superClass as Identifier)?.name || null
-          })
-        });
-
-        edges.push({ src: moduleId, dst: classId, type: 'CONTAINS' });
-
-        // Extract methods
-        node.body.body.forEach(member => {
-          if (member.type === 'ClassMethod' && member.key.type === 'Identifier') {
-            const methodName = member.key.name;
-            const methodId = `METHOD#${className}.${methodName}#${filePath}#${member.loc!.start.line}`;
-
-            nodes.push({
-              id: methodId,
-              type: 'METHOD',
-              name: methodName,
-              file: filePath,
-              metadata: JSON.stringify({
-                className,
-                line: member.loc!.start.line,
-                async: member.async || false,
-                static: member.static || false,
-                isConstructor: member.kind === 'constructor'
-              })
-            });
-
-            edges.push({ src: classId, dst: methodId, type: 'CONTAINS' });
-            stats.functions++;
-          }
-        });
-      }
-    });
-
-    // Extract call expressions (simplified)
-    traverse(ast, {
-      CallExpression(path: NodePath<CallExpression>) {
-        const node = path.node;
-
-        if (node.callee.type === 'Identifier') {
-          const callId = `CALL#${node.callee.name}#${filePath}#${node.loc!.start.line}:${callCounter++}`;
-
-          nodes.push({
-            id: callId,
-            type: 'CALL',
-            name: node.callee.name,
-            file: filePath,
-            metadata: JSON.stringify({
-              line: node.loc!.start.line,
-              argsCount: node.arguments.length
-            })
-          });
-
-          // Find parent function to connect
-          const parentFunc = path.getFunctionParent();
-          if (parentFunc) {
-            const parentName =
-              (parentFunc.node as { id?: Identifier }).id?.name ||
-              ((parentFunc.parent as { id?: Identifier })?.id?.name) ||
-              'anonymous';
-            edges.push({
-              src: `FUNCTION#${parentName}#${filePath}#${parentFunc.node.loc!.start.line}`,
-              dst: callId,
-              type: 'CONTAINS'
-            });
-          } else {
-            edges.push({ src: moduleId, dst: callId, type: 'CONTAINS' });
-          }
-
-          stats.calls++;
-        }
-      }
-    });
-
-    // Batch write to RFDB
-    if (nodes.length > 0 && client) {
-      await client.addNodes(nodes);
-      stats.nodes = nodes.length;
-    }
-
-    if (edges.length > 0 && client) {
-      await client.addEdges(edges, true); // skipValidation for speed
-      stats.edges = edges.length;
-    }
-
-    return stats;
-  } catch (err) {
-    throw new Error(`Failed to analyze ${filePath}: ${(err as Error).message}`);
-  }
-}
-
-/**
- * Handle messages from main thread
- */
-if (parentPort) {
-  parentPort.on('message', async (msg: WorkerMessage) => {
-    switch (msg.type) {
-      case 'connect':
-        try {
-          socketPath = msg.socketPath || socketPath;
-          await connect();
-        } catch (err) {
-          parentPort!.postMessage({ type: 'error', error: (err as Error).message });
-        }
-        break;
-
-      case 'analyze':
-        try {
-          const stats = await analyzeFile(msg.file, msg.moduleId, msg.moduleName);
-          parentPort!.postMessage({
-            type: 'done',
-            file: msg.file,
-            stats,
-            workerId
-          });
-        } catch (err) {
-          parentPort!.postMessage({
-            type: 'error',
-            file: msg.file,
-            error: (err as Error).message,
-            workerId
-          });
-        }
-        break;
-
-      case 'disconnect':
-        if (client) {
-          await client.close();
-          connected = false;
-        }
-        parentPort!.postMessage({ type: 'disconnected', workerId });
-        break;
-
-      case 'exit':
-        if (client) {
-          await client.close();
-        }
-        process.exit(0);
-        break;
-    }
-  });
-
-  // Auto-connect on start if socketPath provided
-  if ((workerData as WorkerDataInput)?.autoConnect) {
-    connect().catch(err => {
-      parentPort!.postMessage({ type: 'error', error: (err as Error).message });
-    });
-  }
-}