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

package/dist/plugins/validation/BrokenImportValidator.js

@@ -0,0 +1,249 @@
+/**
+ * BrokenImportValidator - detects broken imports and undefined symbols (REG-261)
+ *
+ * This VALIDATION plugin queries the graph (built by ANALYSIS and ENRICHMENT phases)
+ * to detect:
+ *
+ * 1. ERR_BROKEN_IMPORT: Named/default import references non-existent export
+ *    - IMPORT node with relative source but no IMPORTS_FROM edge
+ *    - Skips: external (npm) imports, namespace imports, type-only imports
+ *
+ * 2. ERR_UNDEFINED_SYMBOL: Symbol used but not defined, imported, or global
+ *    - CALL node without CALLS edge
+ *    - Not a method call (no `object` property)
+ *    - Not a local definition (FUNCTION/CLASS/VARIABLE in same file)
+ *    - Not an import (IMPORT with matching local name)
+ *    - Not a known global (console, setTimeout, etc.)
+ *
+ * Architecture follows existing validator patterns:
+ * - Phase: VALIDATION
+ * - Priority: 85 (after enrichment, before general validators)
+ * - Returns: ValidationError[] collected via DiagnosticCollector
+ */
+import { Plugin, createSuccessResult } from '../Plugin.js';
+import { ValidationError } from '../../errors/GrafemaError.js';
+import { GlobalsRegistry } from '../../data/globals/index.js';
+// === CONSTANTS ===
+const ERROR_CODES = {
+    BROKEN_IMPORT: 'ERR_BROKEN_IMPORT',
+    UNDEFINED_SYMBOL: 'ERR_UNDEFINED_SYMBOL',
+};
+// Types that represent local definitions
+const DEFINITION_TYPES = new Set([
+    'FUNCTION',
+    'CLASS',
+    'VARIABLE_DECLARATION',
+    'CONSTANT',
+    'PARAMETER',
+]);
+// === PLUGIN CLASS ===
+export class BrokenImportValidator extends Plugin {
+    globalsRegistry;
+    constructor(config = {}) {
+        super(config);
+        this.globalsRegistry = new GlobalsRegistry();
+        // Allow custom globals from config
+        const customGlobals = config.customGlobals;
+        if (customGlobals) {
+            this.globalsRegistry.addCustomGlobals(customGlobals);
+        }
+    }
+    get metadata() {
+        return {
+            name: 'BrokenImportValidator',
+            phase: 'VALIDATION',
+            priority: 85, // After enrichment plugins, before general validators
+            creates: {
+                nodes: [],
+                edges: []
+            },
+            dependencies: ['ImportExportLinker', 'FunctionCallResolver']
+        };
+    }
+    async execute(context) {
+        const { graph, onProgress } = context;
+        const logger = this.log(context);
+        logger.info('Starting broken import validation');
+        const startTime = Date.now();
+        const errors = [];
+        const stats = {
+            importsChecked: 0,
+            brokenImports: 0,
+            callsChecked: 0,
+            undefinedSymbols: 0,
+            skipped: {
+                externalImports: 0,
+                namespaceImports: 0,
+                typeOnlyImports: 0,
+                methodCalls: 0,
+                alreadyResolved: 0,
+                localDefinitions: 0,
+                imports: 0,
+                globals: 0,
+            },
+        };
+        // === Step 1: Build indexes ===
+        // Index: file -> Set<name> for local definitions
+        const definitionsByFile = new Map();
+        for await (const node of graph.queryNodes({})) {
+            if (!DEFINITION_TYPES.has(node.type))
+                continue;
+            if (!node.file || !node.name)
+                continue;
+            if (!definitionsByFile.has(node.file)) {
+                definitionsByFile.set(node.file, new Set());
+            }
+            definitionsByFile.get(node.file).add(node.name);
+        }
+        logger.debug('Indexed definitions', { files: definitionsByFile.size });
+        // Index: file:local -> ImportNode
+        const importsByFile = new Map();
+        const allImports = [];
+        for await (const node of graph.queryNodes({ nodeType: 'IMPORT' })) {
+            const imp = node;
+            if (!imp.file)
+                continue;
+            allImports.push(imp);
+            // Index by local name for undefined symbol checking
+            const localName = imp.local || imp.name;
+            if (localName) {
+                if (!importsByFile.has(imp.file)) {
+                    importsByFile.set(imp.file, new Map());
+                }
+                importsByFile.get(imp.file).set(localName, imp);
+            }
+        }
+        logger.debug('Indexed imports', { count: allImports.length });
+        // === Step 2: Check for broken imports ===
+        for (const imp of allImports) {
+            stats.importsChecked++;
+            // Progress reporting
+            if (onProgress && stats.importsChecked % 100 === 0) {
+                onProgress({
+                    phase: 'validation',
+                    currentPlugin: 'BrokenImportValidator',
+                    message: `Checking imports ${stats.importsChecked}/${allImports.length}`,
+                    totalFiles: allImports.length,
+                    processedFiles: stats.importsChecked
+                });
+            }
+            // Skip external (npm) imports - only check relative imports
+            const isRelative = imp.source &&
+                (imp.source.startsWith('./') || imp.source.startsWith('../'));
+            if (!isRelative) {
+                stats.skipped.externalImports++;
+                continue;
+            }
+            // Skip namespace imports - they link to MODULE, not EXPORT
+            if (imp.importType === 'namespace') {
+                stats.skipped.namespaceImports++;
+                continue;
+            }
+            // Skip type-only imports (TypeScript) - erased at compile time
+            if (imp.importBinding === 'type') {
+                stats.skipped.typeOnlyImports++;
+                continue;
+            }
+            // Check for IMPORTS_FROM edge
+            const importsFromEdges = await graph.getOutgoingEdges(imp.id, ['IMPORTS_FROM']);
+            if (importsFromEdges.length === 0) {
+                // No IMPORTS_FROM edge = broken import
+                const importedName = imp.imported || imp.local || imp.name;
+                errors.push(new ValidationError(`Import "${importedName}" from "${imp.source}" - export doesn't exist`, ERROR_CODES.BROKEN_IMPORT, {
+                    filePath: imp.file,
+                    lineNumber: imp.line,
+                    phase: 'VALIDATION',
+                    plugin: 'BrokenImportValidator',
+                    importedName,
+                    source: imp.source,
+                    importType: imp.importType,
+                }, `Check if "${importedName}" is exported from "${imp.source}"`, 'error'));
+                stats.brokenImports++;
+            }
+        }
+        logger.debug('Broken imports found', { count: stats.brokenImports });
+        // === Step 3: Check for undefined symbols ===
+        const callsToCheck = [];
+        for await (const node of graph.queryNodes({ nodeType: 'CALL' })) {
+            const call = node;
+            // Skip method calls (have object attribute)
+            if (call.object) {
+                stats.skipped.methodCalls++;
+                continue;
+            }
+            // Skip if already has CALLS edge (resolved)
+            const callsEdges = await graph.getOutgoingEdges(call.id, ['CALLS']);
+            if (callsEdges.length > 0) {
+                stats.skipped.alreadyResolved++;
+                continue;
+            }
+            callsToCheck.push(call);
+        }
+        logger.debug('Unresolved calls to check', { count: callsToCheck.length });
+        for (const call of callsToCheck) {
+            stats.callsChecked++;
+            const calledName = call.name;
+            const file = call.file;
+            if (!calledName || !file)
+                continue;
+            // Check 1: Is it a local definition?
+            const fileDefinitions = definitionsByFile.get(file);
+            if (fileDefinitions?.has(calledName)) {
+                stats.skipped.localDefinitions++;
+                continue;
+            }
+            // Check 2: Is it imported? (even if broken, that's a different error)
+            const fileImports = importsByFile.get(file);
+            if (fileImports?.has(calledName)) {
+                stats.skipped.imports++;
+                continue;
+            }
+            // Check 3: Is it a global?
+            if (this.globalsRegistry.isGlobal(calledName)) {
+                stats.skipped.globals++;
+                continue;
+            }
+            // Symbol is undefined
+            errors.push(new ValidationError(`"${calledName}" is used but not defined or imported`, ERROR_CODES.UNDEFINED_SYMBOL, {
+                filePath: file,
+                lineNumber: call.line,
+                phase: 'VALIDATION',
+                plugin: 'BrokenImportValidator',
+                symbol: calledName,
+            }, `Add an import for "${calledName}" or define it locally`, 'warning' // Warning severity - might be a false positive
+            ));
+            stats.undefinedSymbols++;
+        }
+        // === Step 4: Summary ===
+        const totalTime = ((Date.now() - startTime) / 1000).toFixed(2);
+        const summary = {
+            importsChecked: stats.importsChecked,
+            brokenImports: stats.brokenImports,
+            callsChecked: stats.callsChecked,
+            undefinedSymbols: stats.undefinedSymbols,
+            skipped: stats.skipped,
+            totalIssues: stats.brokenImports + stats.undefinedSymbols,
+            time: `${totalTime}s`,
+        };
+        logger.info('Validation complete', summary);
+        if (errors.length > 0) {
+            logger.warn('Issues found', {
+                brokenImports: stats.brokenImports,
+                undefinedSymbols: stats.undefinedSymbols,
+            });
+            // Log first few errors for visibility
+            for (const error of errors.slice(0, 5)) {
+                if (error.code === ERROR_CODES.BROKEN_IMPORT) {
+                    logger.error(`[${error.code}] ${error.message}`);
+                }
+                else {
+                    logger.warn(`[${error.code}] ${error.message}`);
+                }
+            }
+            if (errors.length > 5) {
+                logger.debug(`... and ${errors.length - 5} more issues`);
+            }
+        }
+        return createSuccessResult({ nodes: 0, edges: 0 }, { summary }, errors);
+    }
+}

package/dist/plugins/validation/CallResolverValidator.d.ts

@@ -1,14 +1,14 @@
 /**
- * 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 } from '../Plugin.js';
 import type { PluginContext, PluginResult, PluginMetadata } from '../Plugin.js';
@@ -16,8 +16,19 @@ export declare class CallResolverValidator extends Plugin {
     get metadata(): PluginMetadata;
     execute(context: PluginContext): Promise<PluginResult>;
     /**
-     * Подсчитывает статистику по вызовам
+     * 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 determineResolutionType;
+    /**
+     * Create a warning for an unresolved call.
      */
-    private countMethodCalls;
+    private createWarning;
 }
 //# sourceMappingURL=CallResolverValidator.d.ts.map

package/dist/plugins/validation/CallResolverValidator.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"CallResolverValidator.d.ts","sourceRoot":"","sources":["../../../src/plugins/validation/CallResolverValidator.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;GAWG;AAEH,OAAO,EAAE,MAAM,EAAuB,MAAM,cAAc,CAAC;AAC3D,OAAO,KAAK,EAAE,aAAa,EAAE,YAAY,EAAE,cAAc,EAAE,MAAM,cAAc,CAAC;AA2ChF,qBAAa,qBAAsB,SAAQ,MAAM;IAC/C,IAAI,QAAQ,IAAI,cAAc,CAU7B;IAEK,OAAO,CAAC,OAAO,EAAE,aAAa,GAAG,OAAO,CAAC,YAAY,CAAC;IAuE5D;;OAEG;YACW,gBAAgB;CAyB/B"}
+{"version":3,"file":"CallResolverValidator.d.ts","sourceRoot":"","sources":["../../../src/plugins/validation/CallResolverValidator.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;GAWG;AAEH,OAAO,EAAE,MAAM,EAAuB,MAAM,cAAc,CAAC;AAC3D,OAAO,KAAK,EAAE,aAAa,EAAE,YAAY,EAAE,cAAc,EAAE,MAAM,cAAc,CAAC;AA8BhF,qBAAa,qBAAsB,SAAQ,MAAM;IAC/C,IAAI,QAAQ,IAAI,cAAc,CAW7B;IAEK,OAAO,CAAC,OAAO,EAAE,aAAa,GAAG,OAAO,CAAC,YAAY,CAAC;IAgE5D;;;;;;;;;OASG;YACW,uBAAuB;IAuCrC;;OAEG;IACH,OAAO,CAAC,aAAa;CAgBtB"}

package/dist/plugins/validation/CallResolverValidator.js

@@ -1,16 +1,18 @@
 /**
- * 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 { ValidationError } from '../../errors/GrafemaError.js';
+import { JS_GLOBAL_FUNCTIONS } from '../../data/builtins/index.js';
 export class CallResolverValidator extends Plugin {
     get metadata() {
         return {
@@ -20,89 +22,113 @@ export class CallResolverValidator extends Plugin {
             creates: {
                 nodes: [],
                 edges: []
-            }
+            },
+            dependencies: ['FunctionCallResolver', 'ExternalCallResolver']
         };
     }
     async execute(context) {
         const { graph } = context;
-        console.log('[CallResolverValidator] Starting call resolution validation using Datalog...');
-        // 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 });
-        }
-        // Datalog гарантия:
-        // CALL без "object" (т.е. CALL_SITE) должен иметь CALLS ребро
-        const violations = await graph.checkGuarantee(`
-      violation(X) :- node(X, "CALL"), \\+ attr(X, "object", _), \\+ edge(X, _, "CALLS").
-    `);
-        const issues = [];
-        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,
-                            nodeId: nodeId,
-                            file: node.file,
-                            line: node.line
-                        });
-                    }
-                }
-            }
-        }
-        // Также проверим METHOD_CALL на известные внешние методы
-        // (это информационно, не ошибка)
-        const methodCallStats = await this.countMethodCalls(graph);
+        const logger = this.log(context);
+        logger.info('Starting call resolution validation');
+        const warnings = [];
         const summary = {
-            totalCalls: methodCallStats.total,
-            resolvedInternalCalls: methodCallStats.resolved,
-            unresolvedInternalCalls: issues.length,
-            externalMethodCalls: methodCallStats.external,
-            issues: issues.length
+            totalCalls: 0,
+            resolvedInternal: 0,
+            resolvedExternal: 0,
+            resolvedBuiltin: 0,
+            methodCalls: 0,
+            unresolvedCalls: 0,
+            warnings: 0
         };
-        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}`);
+        // Process all CALL nodes
+        for await (const node of graph.queryNodes({ nodeType: 'CALL' })) {
+            summary.totalCalls++;
+            const callNode = node;
+            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;
             }
-            if (issues.length > 10) {
-                console.log(`  ... and ${issues.length - 10} more`);
+        }
+        logger.info('Validation complete', { ...summary });
+        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 (warnings.length > 10) {
+                logger.debug(`... and ${warnings.length - 10} more`);
             }
         }
-        return createSuccessResult({ nodes: 0, edges: 0 }, { summary, issues });
+        return createSuccessResult({ nodes: 0, edges: 0 }, { 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'
      */
-    async countMethodCalls(graph) {
-        const stats = {
-            total: 0,
-            resolved: 0,
-            external: 0
-        };
-        // Подсчитываем все CALL узлы
-        for await (const node of graph.queryNodes({ nodeType: 'CALL' })) {
-            stats.total++;
-            // Проверяем наличие "object" в метаданных (METHOD_CALL)
-            if (node.object) {
-                stats.external++;
-            }
-            else {
-                // CALL_SITE - проверяем есть ли CALLS ребро
-                const edges = await graph.getOutgoingEdges(node.id, ['CALLS']);
-                if (edges.length > 0) {
-                    stats.resolved++;
+    async determineResolutionType(graph, callNode) {
+        // 1. Check if method call (has object attribute)
+        if (callNode.object) {
+            return 'method';
+        }
+        // 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';
+        }
+        // 3. Check if builtin
+        const calledName = callNode.name;
+        if (calledName && JS_GLOBAL_FUNCTIONS.has(calledName)) {
+            return 'builtin';
         }
-        return stats;
+        // 4. Unresolved
+        return 'unresolved';
+    }
+    /**
+     * Create a warning for an unresolved call.
+     */
+    createWarning(callNode) {
+        return new ValidationError(`Unresolved call to "${callNode.name}" at ${callNode.file}:${callNode.line || '?'}`, 'WARN_UNRESOLVED_CALL', {
+            filePath: callNode.file,
+            lineNumber: callNode.line,
+            phase: 'VALIDATION',
+            plugin: 'CallResolverValidator',
+            nodeId: callNode.id,
+            callName: callNode.name,
+        }, 'Ensure the function is defined, imported, or is a known global', 'warning' // Severity: warning (not error)
+        );
     }
 }

package/dist/plugins/validation/DataFlowValidator.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"DataFlowValidator.d.ts","sourceRoot":"","sources":["../../../src/plugins/validation/DataFlowValidator.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;GAYG;AAEH,OAAO,EAAE,MAAM,EAAuB,MAAM,cAAc,CAAC;AAC3D,OAAO,KAAK,EAAE,aAAa,EAAE,YAAY,EAAE,cAAc,EAAE,MAAM,cAAc,CAAC;AA4ChF,qBAAa,iBAAkB,SAAQ,MAAM;IAC3C,IAAI,QAAQ,IAAI,cAAc,CAU7B;IAEK,OAAO,CAAC,OAAO,EAAE,aAAa,GAAG,OAAO,CAAC,YAAY,CAAC;IAkH5D;;OAEG;IACH,OAAO,CAAC,cAAc;CA2CvB"}
+{"version":3,"file":"DataFlowValidator.d.ts","sourceRoot":"","sources":["../../../src/plugins/validation/DataFlowValidator.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;GAYG;AAEH,OAAO,EAAE,MAAM,EAAuB,MAAM,cAAc,CAAC;AAC3D,OAAO,KAAK,EAAE,aAAa,EAAE,YAAY,EAAE,cAAc,EAAE,MAAM,cAAc,CAAC;AAgChF,qBAAa,iBAAkB,SAAQ,MAAM;IAC3C,IAAI,QAAQ,IAAI,cAAc,CAU7B;IAEK,OAAO,CAAC,OAAO,EAAE,aAAa,GAAG,OAAO,CAAC,YAAY,CAAC;IAwI5D;;OAEG;IACH,OAAO,CAAC,cAAc;CAsDvB"}