@grafema/core 0.1.1-alpha → 0.2.0-beta

package/dist/plugins/indexing/JSModuleIndexer.js

@@ -5,6 +5,7 @@
 import { readFileSync, existsSync } from 'fs';
 import { join, resolve, dirname, relative, basename } from 'path';
 import { createHash } from 'crypto';
+import { minimatch } from 'minimatch';
 import { Plugin, createErrorResult } from '../Plugin.js';
 // @ts-expect-error - no type declarations for node-source-walk
 import Walker from 'node-source-walk';
@@ -25,6 +26,10 @@ export class JSModuleIndexer extends Plugin {
     cache;
     testPatterns;
     markTestFiles;
+    // Include/exclude pattern filtering (REG-185)
+    includePatterns;
+    excludePatterns;
+    projectPath = '';
     constructor() {
         super();
         this.walker = new Walker({
@@ -42,6 +47,39 @@ export class JSModuleIndexer extends Plugin {
             return false;
         return this.testPatterns.some(pattern => pattern.test(filePath));
     }
+    /**
+     * Check if a file should be skipped based on include/exclude patterns.
+     *
+     * Logic:
+     * 1. If file matches any exclude pattern -> SKIP
+     * 2. If include patterns specified AND file doesn't match any -> SKIP
+     * 3. Otherwise -> PROCESS
+     *
+     * @param absolutePath - Absolute path to the file
+     * @returns true if file should be skipped, false if it should be processed
+     */
+    shouldSkipFile(absolutePath) {
+        // Normalize to relative path for pattern matching
+        const relativePath = relative(this.projectPath, absolutePath).replace(/\\/g, '/');
+        // Check exclude patterns first (if any match, skip)
+        if (this.excludePatterns && this.excludePatterns.length > 0) {
+            for (const pattern of this.excludePatterns) {
+                if (minimatch(relativePath, pattern, { dot: true })) {
+                    return true; // Excluded
+                }
+            }
+        }
+        // Check include patterns (if specified, file must match at least one)
+        if (this.includePatterns && this.includePatterns.length > 0) {
+            for (const pattern of this.includePatterns) {
+                if (minimatch(relativePath, pattern, { dot: true })) {
+                    return false; // Included
+                }
+            }
+            return true; // Include specified but file didn't match any
+        }
+        return false; // No filtering, process file
+    }
     get metadata() {
         return {
             name: 'JSModuleIndexer',
@@ -171,6 +209,19 @@ export class JSModuleIndexer extends Plugin {
             const service = manifest?.service ?? { id: '', name: '', path: '' };
             // Collect parse errors to report (REG-147)
             const parseErrors = [];
+            // Store projectPath for shouldSkipFile()
+            this.projectPath = projectPath;
+            // Read include/exclude patterns from config (REG-185)
+            const orchConfig = config;
+            this.includePatterns = orchConfig?.include;
+            this.excludePatterns = orchConfig?.exclude;
+            // Log if patterns are configured
+            if (this.includePatterns || this.excludePatterns) {
+                logger.info('File filtering enabled', {
+                    include: this.includePatterns?.length ?? 0,
+                    exclude: this.excludePatterns?.length ?? 0,
+                });
+            }
             // Check config for test file marking
             if (config?.analysis?.tests?.markTestFiles === false) {
                 this.markTestFiles = false;
@@ -197,6 +248,13 @@ export class JSModuleIndexer extends Plugin {
             const PROGRESS_INTERVAL = 10; // Report every N files
             while (stack.length > 0 && visited.size < MAX_MODULES) {
                 const { file: currentFile, depth } = stack.pop();
+                // Check if file should be skipped based on include/exclude patterns (REG-185)
+                if (this.shouldSkipFile(currentFile)) {
+                    logger.debug('Skipping file (filtered by patterns)', {
+                        file: currentFile.replace(projectPath, '')
+                    });
+                    continue; // Don't process, don't follow imports
+                }
                 // Report progress every PROGRESS_INTERVAL files
                 if (onProgress && visited.size - lastProgressReport >= PROGRESS_INTERVAL) {
                     onProgress({

package/dist/plugins/indexing/RustModuleIndexer.d.ts

@@ -1,6 +1,6 @@
 /**
  * RustModuleIndexer - plugin for indexing Rust modules
- * Discovers .rs files in rust-engine/src/ directory
+ * Discovers .rs files in packages/rfdb-server/src/ directory
  */
 import { Plugin } from '../Plugin.js';
 import type { PluginContext, PluginResult, PluginMetadata } from '../Plugin.js';

package/dist/plugins/indexing/RustModuleIndexer.js

@@ -1,6 +1,6 @@
 /**
  * RustModuleIndexer - plugin for indexing Rust modules
- * Discovers .rs files in rust-engine/src/ directory
+ * Discovers .rs files in packages/rfdb-server/src/ directory
  */
 import { readFileSync, existsSync, readdirSync, statSync } from 'fs';
 import { resolve, relative, basename, join } from 'path';
@@ -89,10 +89,10 @@ export class RustModuleIndexer extends Plugin {
         // Cast manifest to expected shape
         const typedManifest = manifest;
         const { projectPath } = typedManifest;
-        // Find rust-engine/src directory
-        const rustRoot = resolve(projectPath, 'rust-engine/src');
+        // Find packages/rfdb-server/src directory
+        const rustRoot = resolve(projectPath, 'packages/rfdb-server/src');
         if (!existsSync(rustRoot)) {
-            logger.info('rust-engine/src not found, skipping');
+            logger.info('packages/rfdb-server/src not found, skipping');
             return createSuccessResult({ nodes: 0, edges: 0 }, { skipped: true });
         }
         // Discover all .rs files recursively

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

@@ -0,0 +1,31 @@
+/**
+ * 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 } from '../Plugin.js';
+import type { PluginContext, PluginResult, PluginMetadata } from '../Plugin.js';
+export declare class BrokenImportValidator extends Plugin {
+    private globalsRegistry;
+    constructor(config?: Record<string, unknown>);
+    get metadata(): PluginMetadata;
+    execute(context: PluginContext): Promise<PluginResult>;
+}
+//# sourceMappingURL=BrokenImportValidator.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"BrokenImportValidator.d.ts","sourceRoot":"","sources":["../../../src/plugins/validation/BrokenImportValidator.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;GAqBG;AAEH,OAAO,EAAE,MAAM,EAAuB,MAAM,cAAc,CAAC;AAC3D,OAAO,KAAK,EAAE,aAAa,EAAE,YAAY,EAAE,cAAc,EAAE,MAAM,cAAc,CAAC;AAqChF,qBAAa,qBAAsB,SAAQ,MAAM;IAC/C,OAAO,CAAC,eAAe,CAAkB;gBAE7B,MAAM,GAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAM;IAWhD,IAAI,QAAQ,IAAI,cAAc,CAW7B;IAEK,OAAO,CAAC,OAAO,EAAE,aAAa,GAAG,OAAO,CAAC,YAAY,CAAC;CA4O7D"}

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;IAwE5D;;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"}