@grafema/core 0.1.0-alpha.5 → 0.1.1-alpha

package/src/plugins/indexing/RustModuleIndexer.ts

@@ -93,6 +93,7 @@ export class RustModuleIndexer extends Plugin {
   }
 
   async execute(context: PluginContext): Promise<PluginResult> {
+    const logger = this.log(context);
     const { manifest, graph, onProgress } = context;
     // Cast manifest to expected shape
     const typedManifest = manifest as { projectPath: string } | undefined;
@@ -102,14 +103,14 @@ export class RustModuleIndexer extends Plugin {
     const rustRoot = resolve(projectPath, 'rust-engine/src');
 
     if (!existsSync(rustRoot)) {
-      console.log('[RustModuleIndexer] rust-engine/src not found, skipping');
+      logger.info('rust-engine/src not found, skipping');
       return createSuccessResult({ nodes: 0, edges: 0 }, { skipped: true });
     }
 
     // Discover all .rs files recursively
     const rsFiles = this.findRustFiles(rustRoot);
 
-    console.log(`[RustModuleIndexer] Found ${rsFiles.length} .rs files`);
+    logger.info('Found Rust files', { count: rsFiles.length });
 
     let nodesCreated = 0;
     const errors: Array<{ file: string; error: string }> = [];
@@ -151,10 +152,10 @@ export class RustModuleIndexer extends Plugin {
     }
 
     if (errors.length > 0) {
-      console.warn(`[RustModuleIndexer] ${errors.length} errors during indexing`);
+      logger.warn('Errors during indexing', { errorCount: errors.length });
     }
 
-    console.log(`[RustModuleIndexer] Indexed ${nodesCreated} Rust modules`);
+    logger.info('Rust modules indexed', { count: nodesCreated });
     return createSuccessResult({ nodes: nodesCreated, edges: 0 }, { errors: errors.length });
   }
 }

package/src/plugins/validation/CallResolverValidator.ts

@@ -70,12 +70,13 @@ export class CallResolverValidator extends Plugin {
 
   async execute(context: PluginContext): Promise<PluginResult> {
     const { graph } = context;
+    const logger = this.log(context);
 
-    console.log('[CallResolverValidator] Starting call resolution validation using Datalog...');
+    logger.info('Starting call resolution validation using Datalog');
 
     // Check if graph supports checkGuarantee
     if (!graph.checkGuarantee) {
-      console.log('[CallResolverValidator] Graph does not support checkGuarantee, skipping validation');
+      logger.debug('Graph does not support checkGuarantee, skipping validation');
       return createSuccessResult({ nodes: 0, edges: 0 }, { skipped: true });
     }
 
@@ -88,7 +89,7 @@ export class CallResolverValidator extends Plugin {
     const issues: CallResolverIssue[] = [];
 
     if (violations.length > 0) {
-      console.log(`[CallResolverValidator] Found ${violations.length} unresolved function calls`);
+      logger.debug('Unresolved function calls found', { count: violations.length });
 
       for (const v of violations) {
         const nodeId = v.bindings.find(b => b.name === 'X')?.value;
@@ -121,15 +122,15 @@ export class CallResolverValidator extends Plugin {
       issues: issues.length
     };
 
-    console.log('[CallResolverValidator] Summary:', summary);
+    logger.info('Validation complete', { ...summary });
 
     if (issues.length > 0) {
-      console.log(`[CallResolverValidator] Unresolved calls:`);
+      logger.warn('Unresolved calls detected', { count: issues.length });
       for (const issue of issues.slice(0, 10)) { // Show first 10
-        console.log(`  ⚠️ ${issue.message}`);
+        logger.warn(issue.message);
       }
       if (issues.length > 10) {
-        console.log(`  ... and ${issues.length - 10} more`);
+        logger.debug(`... and ${issues.length - 10} more`);
       }
     }
 

package/src/plugins/validation/DataFlowValidator.ts

@@ -72,12 +72,13 @@ export class DataFlowValidator extends Plugin {
 
   async execute(context: PluginContext): Promise<PluginResult> {
     const { graph } = context;
+    const logger = this.log(context);
 
-    console.log('[DataFlowValidator] Starting data flow validation...');
+    logger.info('Starting data flow validation');
 
     // Check if graph supports getAllEdges
     if (!graph.getAllEdges) {
-      console.log('[DataFlowValidator] Graph does not support getAllEdges, skipping validation');
+      logger.debug('Graph does not support getAllEdges, skipping validation');
       return createSuccessResult({ nodes: 0, edges: 0 }, { skipped: true });
     }
 
@@ -89,16 +90,16 @@ export class DataFlowValidator extends Plugin {
       n.type === 'VARIABLE_DECLARATION' || n.type === 'CONSTANT'
     );
 
-    console.log(`[DataFlowValidator] Found ${variables.length} variables to validate`);
+    logger.debug('Variables collected', { count: variables.length });
 
     const issues: DataFlowIssue[] = [];
     const leafTypes = new Set([
       'LITERAL',
-      'EXTERNAL_STDIO',
-      'EXTERNAL_DATABASE',
-      'EXTERNAL_NETWORK',
-      'EXTERNAL_FILESYSTEM',
-      'EVENT_LISTENER',
+      'net:stdio',
+      'db:query',
+      'net:request',
+      'fs:operation',
+      'event:listener',
       'CLASS',          // NewExpression - конструкторы классов
       'FUNCTION',       // Arrow functions и function expressions
       'METHOD_CALL',    // Вызовы методов (промежуточные узлы)
@@ -167,14 +168,17 @@ export class DataFlowValidator extends Plugin {
       summary.byType[issue.type]++;
     }
 
-    console.log('[DataFlowValidator] Summary:', summary);
+    logger.info('Validation complete', { ...summary });
 
     // Выводим issues
     if (issues.length > 0) {
-      console.log(`[DataFlowValidator] Found ${issues.length} issues:`);
+      logger.warn('Data flow issues found', { count: issues.length });
       for (const issue of issues) {
-        const level = issue.severity === 'ERROR' ? '❌' : '⚠️';
-        console.log(`  ${level} [${issue.type}] ${issue.message}`);
+        if (issue.severity === 'ERROR') {
+          logger.error(`[${issue.type}] ${issue.message}`);
+        } else {
+          logger.warn(`[${issue.type}] ${issue.message}`);
+        }
       }
     }
 

package/src/plugins/validation/EvalBanValidator.ts

@@ -69,17 +69,18 @@ export class EvalBanValidator extends Plugin {
 
   async execute(context: PluginContext): Promise<PluginResult> {
     const { graph } = context;
+    const logger = this.log(context);
 
-    console.log('[EvalBanValidator] Checking for eval/Function usage...');
+    logger.info('Starting eval/Function usage validation');
     const startTime = Date.now();
 
     const issues: EvalBanIssue[] = [];
 
-    // ОПТИМИЗАЦИЯ: вместо Datalog (медленный full scan), используем прямые graph queries
-    // Datalog зависает на больших графах из-за отсутствия индексов
+    // OPTIMIZATION: use direct graph queries instead of Datalog (slow full scan)
+    // Datalog hangs on large graphs due to lack of indexes
 
-    // 1. Прямой вызов eval("code") - ищем все CALL ноды с name="eval"
-    console.log('[EvalBanValidator] Searching for eval() calls...');
+    // 1. Direct eval("code") call - find all CALL nodes with name="eval"
+    logger.debug('Searching for eval() calls');
     const evalStart = Date.now();
     let evalCount = 0;
 
@@ -96,10 +97,10 @@ export class EvalBanValidator extends Plugin {
         });
       }
     }
-    console.log(`[EvalBanValidator] eval() search took ${Date.now() - evalStart}ms, found ${evalCount} violations`);
+    logger.debug('eval() search complete', { timeMs: Date.now() - evalStart, count: evalCount });
 
-    // 2. Вызов Function("code") или new Function("code")
-    console.log('[EvalBanValidator] Searching for Function() calls...');
+    // 2. Function("code") or new Function("code") call
+    logger.debug('Searching for Function() calls');
     const funcStart = Date.now();
     let funcCount = 0;
 
@@ -116,11 +117,11 @@ export class EvalBanValidator extends Plugin {
         });
       }
     }
-    console.log(`[EvalBanValidator] Function() search took ${Date.now() - funcStart}ms, found ${funcCount} violations`);
+    logger.debug('Function() search complete', { timeMs: Date.now() - funcStart, count: funcCount });
 
     // 3. Method call: window.eval, globalThis.eval, this.eval
     // Note: METHOD_CALL was merged into CALL - method calls have 'method' attribute
-    console.log('[EvalBanValidator] Searching for method eval() calls...');
+    logger.debug('Searching for method eval() calls');
     const methodStart = Date.now();
     let methodCount = 0;
 
@@ -141,10 +142,10 @@ export class EvalBanValidator extends Plugin {
         });
       }
     }
-    console.log(`[EvalBanValidator] method eval() search took ${Date.now() - methodStart}ms, found ${methodCount} violations`);
+    logger.debug('Method eval() search complete', { timeMs: Date.now() - methodStart, count: methodCount });
 
     // 4. Aliased eval - SKIP for now (complex Datalog query causes OOM)
-    console.log('[EvalBanValidator] Skipping aliased eval detection (requires optimized implementation)');
+    logger.debug('Skipping aliased eval detection', { reason: 'requires optimized implementation' });
 
     const totalTime = ((Date.now() - startTime) / 1000).toFixed(1);
     const summary: ValidationSummary = {
@@ -156,15 +157,15 @@ export class EvalBanValidator extends Plugin {
       timeSeconds: totalTime
     };
 
-    console.log('[EvalBanValidator] Summary:', summary);
+    logger.info('Validation summary', { ...summary });
 
     if (issues.length > 0) {
-      console.log('[EvalBanValidator] ❌ Security violations found:');
+      logger.info('Security violations found', { count: issues.length });
       for (const issue of issues) {
-        console.log(`  🚫 ${issue.message}`);
+        logger.warn('Violation', { message: issue.message, type: issue.type, file: issue.file, line: issue.line });
       }
     } else {
-      console.log('[EvalBanValidator] ✅ No eval/Function usage detected');
+      logger.info('Validation passed: no eval/Function usage detected');
     }
 
     return createSuccessResult(

package/src/plugins/validation/GraphConnectivityValidator.ts

@@ -60,33 +60,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]
@@ -131,13 +132,10 @@ export class GraphConnectivityValidator extends Plugin {
     const unreachable = allNodes.filter(n => !reachable.has(n.id));
 
     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 +145,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;
@@ -184,14 +180,14 @@ export class GraphConnectivityValidator extends Plugin {
         Object.entries(byType).map(([type, nodes]) => [type, nodes.length])
       );
     } 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 },