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

package/src/plugins/validation/CallResolverValidator.ts

@@ -1,58 +1,45 @@
 /**
- * CallResolverValidator - проверяет что все вызовы функций ссылаются на определения
+ * CallResolverValidator - validates function call resolution (REG-227)
  *
- * Использует Datalog для декларативной проверки гарантии:
- * "Все внутренние вызовы функций (CALL_SITE) должны иметь CALLS ребро к FUNCTION"
+ * Checks that all function calls are properly resolved:
+ * - Internal calls: CALLS edge to FUNCTION node
+ * - External calls: CALLS edge to EXTERNAL_MODULE node
+ * - Builtin calls: recognized by name (no edge needed)
+ * - Unresolved: no edge, not builtin -> WARNING
  *
- * ПРАВИЛО (Datalog):
- * violation(X) :- node(X, "CALL"), \+ attr(X, "object", _), \+ edge(X, _, "CALLS").
- *
- * Это находит CALL узлы без "object" метаданных (т.е. CALL_SITE, не METHOD_CALL),
- * которые не имеют CALLS ребра к определению функции.
+ * This validator runs AFTER FunctionCallResolver and ExternalCallResolver
+ * to verify resolution quality and report issues.
  */
 
 import { Plugin, createSuccessResult } from '../Plugin.js';
 import type { PluginContext, PluginResult, PluginMetadata } from '../Plugin.js';
-import type { NodeRecord } from '@grafema/types';
+import type { BaseNodeRecord } from '@grafema/types';
+import { ValidationError } from '../../errors/GrafemaError.js';
+import { JS_GLOBAL_FUNCTIONS } from '../../data/builtins/index.js';
 
 /**
- * Call resolver issue
+ * Resolution type for a CALL node
  */
-interface CallResolverIssue {
-  type: string;
-  severity: string;
-  message: string;
-  callName: string;
-  nodeId: string;
-  file?: string;
-  line?: number;
-}
+type ResolutionType = 'internal' | 'external' | 'builtin' | 'method' | 'unresolved';
 
 /**
- * Method call statistics
+ * Call node with optional attributes
  */
-interface MethodCallStats {
-  total: number;
-  resolved: number;
-  external: number;
+interface CallNode extends BaseNodeRecord {
+  object?: string; // If present, this is a method call
 }
 
 /**
- * Validation summary
+ * Validation summary showing resolution breakdown
  */
 interface ValidationSummary {
   totalCalls: number;
-  resolvedInternalCalls: number;
-  unresolvedInternalCalls: number;
-  externalMethodCalls: number;
-  issues: number;
-}
-
-/**
- * Datalog violation result
- */
-interface DatalogViolation {
-  bindings: Array<{ name: string; value: string }>;
+  resolvedInternal: number;   // CALLS -> FUNCTION
+  resolvedExternal: number;   // CALLS -> EXTERNAL_MODULE
+  resolvedBuiltin: number;    // Name in JS_GLOBAL_FUNCTIONS
+  methodCalls: number;        // Has 'object' attribute (not validated)
+  unresolvedCalls: number;    // No edge, not builtin
+  warnings: number;           // = unresolvedCalls
 }
 
 export class CallResolverValidator extends Plugin {
@@ -64,107 +51,141 @@ export class CallResolverValidator extends Plugin {
       creates: {
         nodes: [],
         edges: []
-      }
+      },
+      dependencies: ['FunctionCallResolver', 'ExternalCallResolver']
     };
   }
 
   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');
 
-    // Check if graph supports checkGuarantee
-    if (!graph.checkGuarantee) {
-      console.log('[CallResolverValidator] Graph does not support checkGuarantee, skipping validation');
-      return createSuccessResult({ nodes: 0, edges: 0 }, { skipped: true });
-    }
+    const warnings: ValidationError[] = [];
+    const summary: ValidationSummary = {
+      totalCalls: 0,
+      resolvedInternal: 0,
+      resolvedExternal: 0,
+      resolvedBuiltin: 0,
+      methodCalls: 0,
+      unresolvedCalls: 0,
+      warnings: 0
+    };
 
-    // Datalog гарантия:
-    // CALL без "object" (т.е. CALL_SITE) должен иметь CALLS ребро
-    const violations = await graph.checkGuarantee(`
-      violation(X) :- node(X, "CALL"), \\+ attr(X, "object", _), \\+ edge(X, _, "CALLS").
-    `) as DatalogViolation[];
-
-    const issues: CallResolverIssue[] = [];
-
-    if (violations.length > 0) {
-      console.log(`[CallResolverValidator] Found ${violations.length} unresolved function calls`);
-
-      for (const v of violations) {
-        const nodeId = v.bindings.find(b => b.name === 'X')?.value;
-        if (nodeId) {
-          const node = await graph.getNode(nodeId);
-          if (node) {
-            issues.push({
-              type: 'UNRESOLVED_FUNCTION_CALL',
-              severity: 'WARNING',
-              message: `Call to "${node.name}" at ${node.file}:${node.line || '?'} does not resolve to a function definition`,
-              callName: node.name as string,
-              nodeId: nodeId,
-              file: node.file,
-              line: node.line as number | undefined
-            });
-          }
-        }
+    // Process all CALL nodes
+    for await (const node of graph.queryNodes({ nodeType: 'CALL' })) {
+      summary.totalCalls++;
+      const callNode = node as CallNode;
+
+      const resolutionType = await this.determineResolutionType(graph, callNode);
+
+      switch (resolutionType) {
+        case 'internal':
+          summary.resolvedInternal++;
+          break;
+        case 'external':
+          summary.resolvedExternal++;
+          break;
+        case 'builtin':
+          summary.resolvedBuiltin++;
+          break;
+        case 'method':
+          summary.methodCalls++;
+          break;
+        case 'unresolved':
+          summary.unresolvedCalls++;
+          summary.warnings++;
+          warnings.push(this.createWarning(callNode));
+          break;
       }
     }
 
-    // Также проверим METHOD_CALL на известные внешние методы
-    // (это информационно, не ошибка)
-    const methodCallStats = await this.countMethodCalls(graph);
-
-    const summary: ValidationSummary = {
-      totalCalls: methodCallStats.total,
-      resolvedInternalCalls: methodCallStats.resolved,
-      unresolvedInternalCalls: issues.length,
-      externalMethodCalls: methodCallStats.external,
-      issues: issues.length
-    };
+    logger.info('Validation complete', { ...summary });
 
-    console.log('[CallResolverValidator] Summary:', summary);
-
-    if (issues.length > 0) {
-      console.log(`[CallResolverValidator] Unresolved calls:`);
-      for (const issue of issues.slice(0, 10)) { // Show first 10
-        console.log(`  ⚠️ ${issue.message}`);
+    if (warnings.length > 0) {
+      logger.warn('Unresolved calls detected', { count: warnings.length });
+      for (const warning of warnings.slice(0, 10)) {
+        logger.warn(warning.message);
       }
-      if (issues.length > 10) {
-        console.log(`  ... and ${issues.length - 10} more`);
+      if (warnings.length > 10) {
+        logger.debug(`... and ${warnings.length - 10} more`);
       }
     }
 
     return createSuccessResult(
       { nodes: 0, edges: 0 },
-      { summary, issues }
+      { summary },
+      warnings
     );
   }
 
   /**
-   * Подсчитывает статистику по вызовам
+   * Determine the resolution type for a CALL node.
+   *
+   * Resolution priority:
+   * 1. Method call (has 'object' attribute) -> 'method'
+   * 2. Has CALLS edge to FUNCTION -> 'internal'
+   * 3. Has CALLS edge to EXTERNAL_MODULE -> 'external'
+   * 4. Name in JS_GLOBAL_FUNCTIONS -> 'builtin'
+   * 5. Otherwise -> 'unresolved'
    */
-  private async countMethodCalls(graph: PluginContext['graph']): Promise<MethodCallStats> {
-    const stats: MethodCallStats = {
-      total: 0,
-      resolved: 0,
-      external: 0
-    };
+  private async determineResolutionType(
+    graph: PluginContext['graph'],
+    callNode: CallNode
+  ): Promise<ResolutionType> {
+    // 1. Check if method call (has object attribute)
+    if (callNode.object) {
+      return 'method';
+    }
 
-    // Подсчитываем все CALL узлы
-    for await (const node of graph.queryNodes({ nodeType: 'CALL' })) {
-      stats.total++;
-
-      // Проверяем наличие "object" в метаданных (METHOD_CALL)
-      if ((node as NodeRecord & { object?: string }).object) {
-        stats.external++;
-      } else {
-        // CALL_SITE - проверяем есть ли CALLS ребро
-        const edges = await graph.getOutgoingEdges(node.id, ['CALLS']);
-        if (edges.length > 0) {
-          stats.resolved++;
+    // 2. Check for CALLS edges
+    const edges = await graph.getOutgoingEdges(callNode.id, ['CALLS']);
+    if (edges.length > 0) {
+      // Determine destination type
+      const edge = edges[0];
+      const dstNode = await graph.getNode(edge.dst);
+
+      if (dstNode) {
+        if (dstNode.type === 'FUNCTION') {
+          return 'internal';
+        }
+        if (dstNode.type === 'EXTERNAL_MODULE') {
+          return 'external';
         }
       }
+
+      // Has edge but unknown destination type - treat as resolved
+      return 'internal';
     }
 
-    return stats;
+    // 3. Check if builtin
+    const calledName = callNode.name as string;
+    if (calledName && JS_GLOBAL_FUNCTIONS.has(calledName)) {
+      return 'builtin';
+    }
+
+    // 4. Unresolved
+    return 'unresolved';
+  }
+
+  /**
+   * Create a warning for an unresolved call.
+   */
+  private createWarning(callNode: CallNode): ValidationError {
+    return new ValidationError(
+      `Unresolved call to "${callNode.name}" at ${callNode.file}:${callNode.line || '?'}`,
+      'WARN_UNRESOLVED_CALL',
+      {
+        filePath: callNode.file,
+        lineNumber: callNode.line as number | undefined,
+        phase: 'VALIDATION',
+        plugin: 'CallResolverValidator',
+        nodeId: callNode.id,
+        callName: callNode.name as string,
+      },
+      'Ensure the function is defined, imported, or is a known global',
+      'warning' // Severity: warning (not error)
+    );
   }
 }

package/src/plugins/validation/DataFlowValidator.ts

@@ -15,6 +15,7 @@
 import { Plugin, createSuccessResult } from '../Plugin.js';
 import type { PluginContext, PluginResult, PluginMetadata } from '../Plugin.js';
 import type { NodeRecord } from '@grafema/types';
+import { ValidationError } from '../../errors/GrafemaError.js';
 
 /**
  * Edge structure
@@ -26,19 +27,6 @@ interface EdgeRecord {
   [key: string]: unknown;
 }
 
-/**
- * Data flow issue
- */
-interface DataFlowIssue {
-  type: string;
-  severity: string;
-  message: string;
-  variable: string;
-  file?: string;
-  line?: number;
-  chain?: string[];
-}
-
 /**
  * Path finding result
  */
@@ -72,12 +60,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 +78,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 errors: ValidationError[] = [];
     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',    // Вызовы методов (промежуточные узлы)
@@ -112,75 +101,96 @@ export class DataFlowValidator extends Plugin {
       );
 
       if (!assignment) {
-        issues.push({
-          type: 'MISSING_ASSIGNMENT',
-          severity: 'WARNING',
-          message: `Variable "${variable.name}" (${variable.file}:${variable.line}) has no ASSIGNED_FROM edge`,
-          variable: variable.name as string,
-          file: variable.file,
-          line: variable.line as number | undefined
-        });
+        errors.push(new ValidationError(
+          `Variable "${variable.name}" (${variable.file}:${variable.line}) has no ASSIGNED_FROM edge`,
+          'ERR_MISSING_ASSIGNMENT',
+          {
+            filePath: variable.file,
+            lineNumber: variable.line as number | undefined,
+            phase: 'VALIDATION',
+            plugin: 'DataFlowValidator',
+            variable: variable.name as string,
+          },
+          undefined,
+          'warning'
+        ));
         continue;
       }
 
       // Проверяем что источник существует
       const source = allNodes.find(n => n.id === assignment.dst);
       if (!source) {
-        issues.push({
-          type: 'BROKEN_REFERENCE',
-          severity: 'ERROR',
-          message: `Variable "${variable.name}" references non-existent node ${assignment.dst}`,
-          variable: variable.name as string,
-          file: variable.file,
-          line: variable.line as number | undefined
-        });
+        errors.push(new ValidationError(
+          `Variable "${variable.name}" references non-existent node ${assignment.dst}`,
+          'ERR_BROKEN_REFERENCE',
+          {
+            filePath: variable.file,
+            lineNumber: variable.line as number | undefined,
+            phase: 'VALIDATION',
+            plugin: 'DataFlowValidator',
+            variable: variable.name as string,
+            targetNodeId: assignment.dst,
+          },
+          undefined,
+          'error'
+        ));
         continue;
       }
 
       // Проверяем путь до листового узла
       const path = this.findPathToLeaf(variable, allNodes, allEdges, leafTypes);
       if (!path.found) {
-        issues.push({
-          type: 'NO_LEAF_NODE',
-          severity: 'WARNING',
-          message: `Variable "${variable.name}" (${variable.file}:${variable.line}) does not trace to a leaf node. Chain: ${path.chain.join(' -> ')}`,
-          variable: variable.name as string,
-          file: variable.file,
-          line: variable.line as number | undefined,
-          chain: path.chain
-        });
+        errors.push(new ValidationError(
+          `Variable "${variable.name}" (${variable.file}:${variable.line}) does not trace to a leaf node. Chain: ${path.chain.join(' -> ')}`,
+          'ERR_NO_LEAF_NODE',
+          {
+            filePath: variable.file,
+            lineNumber: variable.line as number | undefined,
+            phase: 'VALIDATION',
+            plugin: 'DataFlowValidator',
+            variable: variable.name as string,
+            chain: path.chain,
+          },
+          undefined,
+          'warning'
+        ));
       }
     }
 
-    // Группируем issues по типу
-    const summary: ValidationSummary = {
-      total: variables.length,
-      validated: variables.length - issues.length,
-      issues: issues.length,
-      byType: {}
-    };
-
-    for (const issue of issues) {
-      if (!summary.byType[issue.type]) {
-        summary.byType[issue.type] = 0;
+    // Группируем errors по коду
+    const byCode: Record<string, number> = {};
+    for (const error of errors) {
+      if (!byCode[error.code]) {
+        byCode[error.code] = 0;
       }
-      summary.byType[issue.type]++;
+      byCode[error.code]++;
     }
 
-    console.log('[DataFlowValidator] Summary:', summary);
+    const summary: ValidationSummary = {
+      total: variables.length,
+      validated: variables.length - errors.length,
+      issues: errors.length,
+      byType: byCode
+    };
 
-    // Выводим issues
-    if (issues.length > 0) {
-      console.log(`[DataFlowValidator] Found ${issues.length} issues:`);
-      for (const issue of issues) {
-        const level = issue.severity === 'ERROR' ? '❌' : '⚠️';
-        console.log(`  ${level} [${issue.type}] ${issue.message}`);
+    logger.info('Validation complete', { ...summary });
+
+    // Выводим errors
+    if (errors.length > 0) {
+      logger.warn('Data flow issues found', { count: errors.length });
+      for (const error of errors) {
+        if (error.severity === 'error') {
+          logger.error(`[${error.code}] ${error.message}`);
+        } else {
+          logger.warn(`[${error.code}] ${error.message}`);
+        }
       }
     }
 
     return createSuccessResult(
       { nodes: 0, edges: 0 },
-      { summary, issues }
+      { summary },
+      errors
     );
   }
 
@@ -208,6 +218,17 @@ export class DataFlowValidator extends Plugin {
       return { found: true, chain };
     }
 
+    // REG-262: Check if variable is used by a method call (incoming USES edge)
+    // If something USES this variable, the variable is not dead
+    const usedByCall = allEdges.find(e =>
+      e.type === 'USES' && e.dst === startNode.id
+    );
+    if (usedByCall) {
+      const callNode = allNodes.find(n => n.id === usedByCall.src);
+      const callName = callNode?.name ?? usedByCall.src;
+      return { found: true, chain: [...chain, `(used by ${callName})`] };
+    }
+
     // Ищем ASSIGNED_FROM ребро
     const assignment = allEdges.find(e =>
       e.type === 'ASSIGNED_FROM' && e.src === startNode.id

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(