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

package/src/plugins/validation/GraphConnectivityValidator.ts

@@ -6,6 +6,7 @@
 import { Plugin, createSuccessResult } from '../Plugin.js';
 import type { PluginContext, PluginMetadata, PluginResult } from '../Plugin.js';
 import type { NodeRecord } from '@grafema/types';
+import { ValidationError } from '../../errors/GrafemaError.js';
 
 /**
  * Edge structure
@@ -60,33 +61,34 @@ export class GraphConnectivityValidator extends Plugin {
 
   async execute(context: PluginContext): Promise<PluginResult> {
     const { graph, manifest } = context;
+    const logger = this.log(context);
     const manifestWithValidation = manifest as ManifestWithValidation;
 
-    console.log('[GraphConnectivityValidator] Starting connectivity validation...');
+    logger.info('Starting connectivity validation');
 
     // Получаем все узлы
     const allNodes = await graph.getAllNodes();
-    console.log(`[GraphConnectivityValidator] Total nodes: ${allNodes.length}`);
+    logger.debug('Nodes collected', { totalNodes: allNodes.length });
 
     // Находим корневые узлы (SERVICE, MODULE)
     const rootTypes = ['SERVICE', 'MODULE', 'PROJECT'];
     const rootNodes = allNodes.filter(n => rootTypes.includes(n.type));
-    console.log(`[GraphConnectivityValidator] Root nodes: ${rootNodes.length}`);
+    logger.debug('Root nodes found', { rootCount: rootNodes.length });
 
     if (rootNodes.length === 0) {
-      console.warn('[GraphConnectivityValidator] No root nodes found!');
+      logger.warn('No root nodes found');
       return createSuccessResult({ nodes: 0, edges: 0 }, { skipped: true, reason: 'No root nodes' });
     }
 
     // Check if graph supports getAllEdges
     if (!graph.getAllEdges) {
-      console.log('[GraphConnectivityValidator] Graph does not support getAllEdges, skipping validation');
+      logger.debug('Graph does not support getAllEdges, skipping validation');
       return createSuccessResult({ nodes: 0, edges: 0 }, { skipped: true, reason: 'No getAllEdges support' });
     }
 
     // Собираем все ребра
     const allEdges = await graph.getAllEdges();
-    console.log(`[GraphConnectivityValidator] Total edges: ${allEdges.length}`);
+    logger.debug('Edges collected', { totalEdges: allEdges.length });
 
     // Строим карты смежности (обе направления)
     const adjacencyOut = new Map<string, string[]>(); // nodeId -> [targetIds]
@@ -129,15 +131,13 @@ export class GraphConnectivityValidator extends Plugin {
 
     // Находим недостижимые узлы
     const unreachable = allNodes.filter(n => !reachable.has(n.id));
+    const errors: ValidationError[] = [];
 
     if (unreachable.length > 0) {
-      // ЯРКОЕ ПРЕДУПРЕЖДЕНИЕ В КОНСОЛИ
-      console.error('\n' + '='.repeat(80));
-      console.error('⚠️  GRAPH VALIDATION ERROR: DISCONNECTED NODES FOUND');
-      console.error('='.repeat(80));
-      console.error(`Found ${unreachable.length} unreachable nodes (${((unreachable.length / allNodes.length) * 100).toFixed(1)}% of total)`);
-      console.error(`These nodes are not connected to the main graph (SERVICE/MODULE/PROJECT level)`);
-      console.error('');
+      const percentage = ((unreachable.length / allNodes.length) * 100).toFixed(1);
+      logger.error('GRAPH VALIDATION ERROR: DISCONNECTED NODES FOUND');
+      logger.error(`Found ${unreachable.length} unreachable nodes (${percentage}% of total)`);
+      logger.error('These nodes are not connected to the main graph (SERVICE/MODULE/PROJECT level)');
 
       // Группируем по типам для читаемости
       const byType: Record<string, NodeRecord[]> = {};
@@ -147,27 +147,25 @@ export class GraphConnectivityValidator extends Plugin {
       }
 
       for (const [type, nodes] of Object.entries(byType)) {
-        console.error(`  ${type}: ${nodes.length} nodes`);
+        logger.error(`${type}: ${nodes.length} nodes`);
         // Показываем первые 5 для каждого типа
         for (const node of nodes.slice(0, 5)) {
-          console.error(`    - ${node.name || node.id}`);
+          logger.debug(`  - ${node.name || node.id}`);
 
           // Показываем связи этого узла
           const out = adjacencyOut.get(node.id) || [];
           const incoming = adjacencyIn.get(node.id) || [];
           if (out.length > 0 || incoming.length > 0) {
-            console.error(`      Edges: ${incoming.length} incoming, ${out.length} outgoing`);
+            logger.debug(`    Edges: ${incoming.length} incoming, ${out.length} outgoing`);
           }
         }
         if (nodes.length > 5) {
-          console.error(`    ... and ${nodes.length - 5} more`);
+          logger.debug(`  ... and ${nodes.length - 5} more`);
         }
       }
 
-      console.error('');
-      console.error('💡 ACTION REQUIRED: Fix analysis plugins to ensure all nodes are connected');
-      console.error('   Anonymous functions, callbacks, and method calls should be linked to parent nodes');
-      console.error('='.repeat(80) + '\n');
+      logger.error('ACTION REQUIRED: Fix analysis plugins to ensure all nodes are connected');
+      logger.error('Anonymous functions, callbacks, and method calls should be linked to parent nodes');
 
       // Сохраняем информацию в manifest для дальнейшего использования
       if (!manifestWithValidation.validation) manifestWithValidation.validation = {} as ValidationResult;
@@ -183,19 +181,55 @@ export class GraphConnectivityValidator extends Plugin {
       manifestWithValidation.validation.unreachableByType = Object.fromEntries(
         Object.entries(byType).map(([type, nodes]) => [type, nodes.length])
       );
+
+      // Create summary error for disconnected nodes
+      errors.push(new ValidationError(
+        `Found ${unreachable.length} unreachable nodes (${percentage}% of total)`,
+        'ERR_DISCONNECTED_NODES',
+        {
+          phase: 'VALIDATION',
+          plugin: 'GraphConnectivityValidator',
+          totalNodes: allNodes.length,
+          reachableNodes: reachable.size,
+          unreachableCount: unreachable.length,
+          unreachableByType: Object.fromEntries(
+            Object.entries(byType).map(([type, nodes]) => [type, nodes.length])
+          ),
+        },
+        'Fix analysis plugins to ensure all nodes are connected'
+      ));
+
+      // Create individual errors for each disconnected node (limit to 50)
+      const maxIndividualErrors = 50;
+      for (const node of unreachable.slice(0, maxIndividualErrors)) {
+        errors.push(new ValidationError(
+          `Node "${node.name || node.id}" (type: ${node.type}) is not connected to the main graph`,
+          'ERR_DISCONNECTED_NODE',
+          {
+            filePath: node.file,
+            lineNumber: node.line as number | undefined,
+            phase: 'VALIDATION',
+            plugin: 'GraphConnectivityValidator',
+            nodeId: node.id,
+            nodeType: node.type,
+            nodeName: node.name,
+          }
+        ));
+      }
     } else {
-      console.log('[GraphConnectivityValidator] ✅ All nodes are reachable from root nodes');
+      logger.info('All nodes are reachable from root nodes');
       if (!manifestWithValidation.validation) manifestWithValidation.validation = {} as ValidationResult;
       manifestWithValidation.validation.hasErrors = false;
       manifestWithValidation.validation.totalNodes = allNodes.length;
       manifestWithValidation.validation.reachableNodes = reachable.size;
     }
 
-    console.log(`[GraphConnectivityValidator] Validation complete: ${reachable.size}/${allNodes.length} nodes reachable`);
+    logger.info('Validation complete', { reachable: reachable.size, total: allNodes.length });
 
     return createSuccessResult(
       { nodes: 0, edges: 0 },
-      { totalNodes: allNodes.length, reachableNodes: reachable.size }
+      { totalNodes: allNodes.length, reachableNodes: reachable.size },
+      errors
     );
   }
 }