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

package/src/plugins/indexing/JSModuleIndexer.ts

@@ -4,13 +4,15 @@
  */
 
 import { readFileSync, existsSync } from 'fs';
-import { join, resolve, dirname } from 'path';
+import { join, resolve, dirname, relative, basename } from 'path';
 import { createHash } from 'crypto';
-import { Plugin, createSuccessResult, createErrorResult } from '../Plugin.js';
+import { minimatch } from 'minimatch';
+import { Plugin, createErrorResult } from '../Plugin.js';
 import type { PluginContext, PluginResult, PluginMetadata } from '../Plugin.js';
 // @ts-expect-error - no type declarations for node-source-walk
 import Walker from 'node-source-walk';
 import { NodeFactory } from '../../core/NodeFactory.js';
+import { LanguageError } from '../../errors/GrafemaError.js';
 
 /**
  * Manifest with service info
@@ -21,6 +23,10 @@ interface IndexerManifest {
     id: string;
     name: string;
     path: string;
+    metadata?: {
+      entrypoint?: string;
+      [key: string]: unknown;
+    };
   };
 }
 
@@ -71,10 +77,16 @@ export class JSModuleIndexer extends Plugin {
   private cache: Map<string, string[] | Error>;
   private testPatterns: RegExp[];
   private markTestFiles: boolean;
+  // Include/exclude pattern filtering (REG-185)
+  private includePatterns?: string[];
+  private excludePatterns?: string[];
+  private projectPath: string = '';
 
   constructor() {
     super();
-    this.walker = new Walker();
+    this.walker = new Walker({
+      plugins: ['jsx', 'typescript']
+    });
     this.cache = new Map(); // Кеш зависимостей файла
     this.testPatterns = DEFAULT_TEST_PATTERNS;
     this.markTestFiles = true; // Default: enabled
@@ -88,6 +100,43 @@ export class JSModuleIndexer extends Plugin {
     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
+   */
+  private shouldSkipFile(absolutePath: string): boolean {
+    // 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(): PluginMetadata {
     return {
       name: 'JSModuleIndexer',
@@ -208,26 +257,46 @@ export class JSModuleIndexer extends Plugin {
   }
 
   async execute(context: PluginContext): Promise<PluginResult> {
+    const logger = this.log(context);
     try {
       const { graph, onProgress, config } = context;
       const manifest = context.manifest as IndexerManifest | undefined;
       const projectPath = manifest?.projectPath ?? '';
       const service = manifest?.service ?? { id: '', name: '', path: '' };
 
+      // Collect parse errors to report (REG-147)
+      const parseErrors: Error[] = [];
+
+      // Store projectPath for shouldSkipFile()
+      this.projectPath = projectPath;
+
+      // Read include/exclude patterns from config (REG-185)
+      const orchConfig = config as { include?: string[]; exclude?: string[] } | undefined;
+      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 as { analysis?: { tests?: { markTestFiles?: boolean } } })?.analysis?.tests?.markTestFiles === false) {
         this.markTestFiles = false;
       }
 
-      const entrypoint = service.path;
-      // const pkgPath = join(projectPath, 'pkg');
+      // Use metadata.entrypoint if available (from config services), otherwise fall back to path
+      const entrypoint = service.metadata?.entrypoint || service.path;
 
       // Резолвим entrypoint относительно projectPath
       const absoluteEntrypoint = entrypoint.startsWith('/')
         ? entrypoint
         : join(projectPath, entrypoint);
 
-      console.log(`[JSModuleIndexer] Building dependency tree from ${service.name}`);
+      logger.info('Building dependency tree', { service: service.name });
 
       // DFS через стек (как в file2host.js)
       const visited = new Set<string>();
@@ -249,6 +318,14 @@ export class JSModuleIndexer extends Plugin {
       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({
@@ -261,37 +338,55 @@ export class JSModuleIndexer extends Plugin {
           lastProgressReport = visited.size;
         }
 
-        console.log(`[JSModuleIndexer] Processing: ${currentFile.replace(projectPath, '')} (depth ${depth})`);
+        logger.debug('Processing file', { file: currentFile.replace(projectPath, ''), depth });
 
         if (depth > MAX_DEPTH) {
-          console.log(`[JSModuleIndexer] Max depth ${MAX_DEPTH} reached at ${currentFile}`);
+          logger.warn('Max depth reached', { maxDepth: MAX_DEPTH, file: currentFile });
           continue;
         }
 
         // Парсим зависимости
         const deps = this.processFile(currentFile, projectPath);
-        console.log(`[JSModuleIndexer] Found ${deps instanceof Error ? 0 : deps.length} dependencies in ${currentFile.replace(projectPath, '')}`);
+        logger.debug('Found dependencies', { file: currentFile.replace(projectPath, ''), count: deps instanceof Error ? 0 : deps.length });
 
         if (deps instanceof Error) {
           if (!deps.message.includes('ENOENT')) {
-            console.log(`[JSModuleIndexer] Error parsing ${currentFile}: ${deps.message}`);
+            const relativePath = relative(projectPath, currentFile) || basename(currentFile);
+            const error = new LanguageError(
+              `Failed to parse ${relativePath}: ${deps.message}`,
+              'ERR_PARSE_FAILURE',
+              {
+                filePath: currentFile,
+                phase: 'INDEXING',
+                plugin: 'JSModuleIndexer',
+              },
+              'Check file syntax or ensure the file is a supported JavaScript/TypeScript file'
+            );
+            parseErrors.push(error);
+            logger.debug('Parse error', { file: currentFile, error: deps.message });
           }
           continue;
         }
 
-        // Создаём MODULE ноду для текущего файла
+        // Создаём MODULE ноду для текущего файла с semantic ID
         const fileHash = this.calculateFileHash(currentFile);
-        const moduleId = `MODULE:${fileHash}`; // StableID-based for deduplication
+        const relativePath = relative(projectPath, currentFile) || basename(currentFile);
+        const semanticId = `${relativePath}->global->MODULE->module`;
 
-        // Используем NodeFactory для создания MODULE ноды
-        // ВСЕГДА создаём ноду в графе (граф может быть пустой после force)
+        // Construct MODULE node manually to preserve absolute file path for analyzers
         const isTest = this.isTestFile(currentFile);
-        const moduleNode = NodeFactory.createModule(currentFile, projectPath, {
-          contentHash: fileHash ?? undefined,
+        const moduleNode = {
+          id: semanticId,
+          type: 'MODULE' as const,
+          name: relativePath,
+          file: currentFile, // Keep absolute path for file reading in analyzers
+          line: 0,
+          contentHash: fileHash || '',
           isTest
-        });
+        };
+        const moduleId = moduleNode.id;
 
-        console.log(`[JSModuleIndexer] Creating MODULE node: ${moduleNode.id}`);
+        logger.debug('Creating MODULE node', { moduleId: moduleNode.id });
         await graph.addNode(moduleNode);
         nodesCreated++;
 
@@ -306,25 +401,26 @@ export class JSModuleIndexer extends Plugin {
         for (const dep of deps) {
           if (dep.startsWith('package::')) {
             // npm пакет - игнорируем пока
-            console.log(`[JSModuleIndexer]   Skipping npm package: ${dep}`);
+            logger.debug('Skipping npm package', { package: dep });
             continue;
           }
 
           const resolvedDep = this.resolveModulePath(dep);
-          console.log(`[JSModuleIndexer]   Resolved: ${dep} -> ${resolvedDep.replace(projectPath, '')}`);
+          logger.debug('Resolved dependency', { from: dep, to: resolvedDep.replace(projectPath, '') });
 
           // Добавляем в стек если ещё не посещали
           if (!visited.has(resolvedDep)) {
             visited.add(resolvedDep);
             stack.push({ file: resolvedDep, depth: depth + 1 });
-            console.log(`[JSModuleIndexer]   Added to stack (depth ${depth + 1})`);
+            logger.debug('Added to stack', { depth: depth + 1 });
           } else {
-            console.log(`[JSModuleIndexer]   Already visited, skipping`);
+            logger.debug('Already visited, skipping', { file: resolvedDep });
           }
 
           // Queue DEPENDS_ON edges for later (after all nodes exist)
-          const depHash = this.calculateFileHash(resolvedDep);
-          const depModuleId = `MODULE:${depHash}`;
+          // Use semantic ID format for dependency reference
+          const depRelativePath = relative(projectPath, resolvedDep) || basename(resolvedDep);
+          const depModuleId = `${depRelativePath}->global->MODULE->module`;
           pendingDependsOnEdges.push({
             src: moduleId,
             dst: depModuleId,
@@ -342,9 +438,11 @@ export class JSModuleIndexer extends Plugin {
 
       // Warning if hit MAX_MODULES limit
       if (visited.size >= MAX_MODULES) {
-        console.warn(`[JSModuleIndexer] ⚠️  ${service.name} hit MAX_MODULES limit (${MAX_MODULES})!`);
-        console.warn(`[JSModuleIndexer]    This service may be pulling in too many dependencies.`);
-        console.warn(`[JSModuleIndexer]    Unprocessed files in stack: ${stack.length}`);
+        logger.warn('Hit MAX_MODULES limit', {
+          service: service.name,
+          limit: MAX_MODULES,
+          unprocessedInStack: stack.length
+        });
       }
 
       // Final progress report
@@ -359,15 +457,23 @@ export class JSModuleIndexer extends Plugin {
         });
       }
 
-      console.log(`[JSModuleIndexer] ${service.name}: ${nodesCreated} modules, ${visited.size} total in tree`);
-
-      return createSuccessResult(
-        { nodes: nodesCreated, edges: edgesCreated },
-        { totalModules: visited.size }
-      );
+      logger.info('Indexing complete', {
+        service: service.name,
+        modulesCreated: nodesCreated,
+        totalInTree: visited.size
+      });
+
+      // Return result with parse errors (REG-147)
+      return {
+        success: true,
+        created: { nodes: nodesCreated, edges: edgesCreated },
+        errors: parseErrors,
+        warnings: [],
+        metadata: { totalModules: visited.size },
+      };
 
     } catch (error) {
-      console.error(`[JSModuleIndexer] Error:`, error);
+      logger.error('Indexing failed', { error });
       return createErrorResult(error as Error);
     }
   }

package/src/plugins/indexing/RustModuleIndexer.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 { readFileSync, existsSync, readdirSync, statSync } from 'fs';
@@ -93,23 +93,24 @@ 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;
     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)) {
-      console.log('[RustModuleIndexer] 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
     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/BrokenImportValidator.ts

@@ -0,0 +1,325 @@
+/**
+ * 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 type { PluginContext, PluginResult, PluginMetadata } from '../Plugin.js';
+import type { BaseNodeRecord } from '@grafema/types';
+import { ValidationError } from '../../errors/GrafemaError.js';
+import { GlobalsRegistry } from '../../data/globals/index.js';
+
+// === INTERFACES ===
+
+interface ImportNode extends BaseNodeRecord {
+  source?: string;
+  importType?: string; // 'default' | 'named' | 'namespace'
+  imported?: string;   // Original name in source module
+  local?: string;      // Local binding name in this file
+  importBinding?: string; // 'value' | 'type' (TypeScript)
+}
+
+interface CallNode extends BaseNodeRecord {
+  object?: string; // If present, this is a method call
+}
+
+// === CONSTANTS ===
+
+const ERROR_CODES = {
+  BROKEN_IMPORT: 'ERR_BROKEN_IMPORT',
+  UNDEFINED_SYMBOL: 'ERR_UNDEFINED_SYMBOL',
+} as const;
+
+// Types that represent local definitions
+const DEFINITION_TYPES = new Set([
+  'FUNCTION',
+  'CLASS',
+  'VARIABLE_DECLARATION',
+  'CONSTANT',
+  'PARAMETER',
+]);
+
+// === PLUGIN CLASS ===
+
+export class BrokenImportValidator extends Plugin {
+  private globalsRegistry: GlobalsRegistry;
+
+  constructor(config: Record<string, unknown> = {}) {
+    super(config);
+    this.globalsRegistry = new GlobalsRegistry();
+
+    // Allow custom globals from config
+    const customGlobals = config.customGlobals as string[] | undefined;
+    if (customGlobals) {
+      this.globalsRegistry.addCustomGlobals(customGlobals);
+    }
+  }
+
+  get metadata(): PluginMetadata {
+    return {
+      name: 'BrokenImportValidator',
+      phase: 'VALIDATION',
+      priority: 85, // After enrichment plugins, before general validators
+      creates: {
+        nodes: [],
+        edges: []
+      },
+      dependencies: ['ImportExportLinker', 'FunctionCallResolver']
+    };
+  }
+
+  async execute(context: PluginContext): Promise<PluginResult> {
+    const { graph, onProgress } = context;
+    const logger = this.log(context);
+
+    logger.info('Starting broken import validation');
+    const startTime = Date.now();
+
+    const errors: ValidationError[] = [];
+    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<string, Set<string>>();
+    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<string, Map<string, ImportNode>>();
+    const allImports: ImportNode[] = [];
+
+    for await (const node of graph.queryNodes({ nodeType: 'IMPORT' })) {
+      const imp = node as ImportNode;
+      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 as number | undefined,
+            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: CallNode[] = [];
+    for await (const node of graph.queryNodes({ nodeType: 'CALL' })) {
+      const call = node as CallNode;
+
+      // 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 as number | undefined,
+          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
+    );
+  }
+}