@soulcraft/brainy 4.4.0 → 4.5.1

package/dist/augmentations/intelligentImport/handlers/csvHandler.js

@@ -30,13 +30,26 @@ export class CSVHandler extends BaseFormatHandler {
     }
     async process(data, options) {
         const startTime = Date.now();
+        const progressHooks = options.progressHooks;
         // Convert to buffer if string
         const buffer = Buffer.isBuffer(data) ? data : Buffer.from(data, 'utf-8');
+        const totalBytes = buffer.length;
+        // v4.5.0: Report total bytes for progress tracking
+        if (progressHooks?.onBytesProcessed) {
+            progressHooks.onBytesProcessed(0);
+        }
+        if (progressHooks?.onCurrentItem) {
+            progressHooks.onCurrentItem('Detecting CSV encoding and delimiter...');
+        }
         // Detect encoding
         const detectedEncoding = options.encoding || this.detectEncodingSafe(buffer);
         const text = buffer.toString(detectedEncoding);
         // Detect delimiter if not specified
         const delimiter = options.csvDelimiter || this.detectDelimiter(text);
+        // v4.5.0: Report progress - parsing started
+        if (progressHooks?.onCurrentItem) {
+            progressHooks.onCurrentItem(`Parsing CSV rows (delimiter: "${delimiter}")...`);
+        }
         // Parse CSV
         const hasHeaders = options.csvHeaders !== false;
         const maxRows = options.maxRows;
@@ -50,19 +63,38 @@ export class CSVHandler extends BaseFormatHandler {
                 to: maxRows,
                 cast: false // We'll do type inference ourselves
             });
+            // v4.5.0: Report bytes processed (entire file parsed)
+            if (progressHooks?.onBytesProcessed) {
+                progressHooks.onBytesProcessed(totalBytes);
+            }
             // Convert to array of objects
             const data = Array.isArray(records) ? records : [records];
+            // v4.5.0: Report data extraction progress
+            if (progressHooks?.onDataExtracted) {
+                progressHooks.onDataExtracted(data.length, data.length);
+            }
+            if (progressHooks?.onCurrentItem) {
+                progressHooks.onCurrentItem(`Extracted ${data.length} rows, inferring types...`);
+            }
             // Infer types and convert values
             const fields = data.length > 0 ? Object.keys(data[0]) : [];
             const types = this.inferFieldTypes(data);
-            const convertedData = data.map(row => {
+            const convertedData = data.map((row, index) => {
                 const converted = {};
                 for (const [key, value] of Object.entries(row)) {
                     converted[key] = this.convertValue(value, types[key] || 'string');
                 }
+                // v4.5.0: Report progress every 1000 rows
+                if (progressHooks?.onCurrentItem && index > 0 && index % 1000 === 0) {
+                    progressHooks.onCurrentItem(`Converting types: ${index}/${data.length} rows...`);
+                }
                 return converted;
             });
             const processingTime = Date.now() - startTime;
+            // v4.5.0: Final progress update
+            if (progressHooks?.onCurrentItem) {
+                progressHooks.onCurrentItem(`CSV processing complete: ${convertedData.length} rows`);
+            }
             return {
                 format: this.format,
                 data: convertedData,

package/dist/augmentations/intelligentImport/handlers/excelHandler.js

@@ -19,8 +19,17 @@ export class ExcelHandler extends BaseFormatHandler {
     }
     async process(data, options) {
         const startTime = Date.now();
+        const progressHooks = options.progressHooks;
         // Convert to buffer if string (though Excel should always be binary)
         const buffer = Buffer.isBuffer(data) ? data : Buffer.from(data, 'binary');
+        const totalBytes = buffer.length;
+        // v4.5.0: Report start
+        if (progressHooks?.onBytesProcessed) {
+            progressHooks.onBytesProcessed(0);
+        }
+        if (progressHooks?.onCurrentItem) {
+            progressHooks.onCurrentItem('Loading Excel workbook...');
+        }
         try {
             // Read workbook
             const workbook = XLSX.read(buffer, {
@@ -31,10 +40,19 @@ export class ExcelHandler extends BaseFormatHandler {
             });
             // Determine which sheets to process
             const sheetsToProcess = this.getSheetsToProcess(workbook, options);
+            // v4.5.0: Report workbook loaded
+            if (progressHooks?.onCurrentItem) {
+                progressHooks.onCurrentItem(`Processing ${sheetsToProcess.length} sheets...`);
+            }
             // Extract data from sheets
             const allData = [];
             const sheetMetadata = {};
-            for (const sheetName of sheetsToProcess) {
+            for (let sheetIndex = 0; sheetIndex < sheetsToProcess.length; sheetIndex++) {
+                const sheetName = sheetsToProcess[sheetIndex];
+                // v4.5.0: Report current sheet
+                if (progressHooks?.onCurrentItem) {
+                    progressHooks.onCurrentItem(`Reading sheet: ${sheetName} (${sheetIndex + 1}/${sheetsToProcess.length})`);
+                }
                 const sheet = workbook.Sheets[sheetName];
                 if (!sheet)
                     continue;
@@ -75,12 +93,28 @@ export class ExcelHandler extends BaseFormatHandler {
                     columnCount: headers.length,
                     headers
                 };
+                // v4.5.0: Estimate bytes processed (sheets are sequential)
+                const bytesProcessed = Math.floor(((sheetIndex + 1) / sheetsToProcess.length) * totalBytes);
+                if (progressHooks?.onBytesProcessed) {
+                    progressHooks.onBytesProcessed(bytesProcessed);
+                }
+                // v4.5.0: Report extraction progress
+                if (progressHooks?.onDataExtracted) {
+                    progressHooks.onDataExtracted(allData.length, undefined); // Total unknown until complete
+                }
+            }
+            // v4.5.0: Report data extraction complete
+            if (progressHooks?.onCurrentItem) {
+                progressHooks.onCurrentItem(`Extracted ${allData.length} rows, inferring types...`);
+            }
+            if (progressHooks?.onDataExtracted) {
+                progressHooks.onDataExtracted(allData.length, allData.length);
             }
             // Infer types (excluding _sheet field)
             const fields = allData.length > 0 ? Object.keys(allData[0]).filter(k => k !== '_sheet') : [];
             const types = this.inferFieldTypes(allData);
             // Convert values to appropriate types
-            const convertedData = allData.map(row => {
+            const convertedData = allData.map((row, index) => {
                 const converted = {};
                 for (const [key, value] of Object.entries(row)) {
                     if (key === '_sheet') {
@@ -90,9 +124,21 @@ export class ExcelHandler extends BaseFormatHandler {
                         converted[key] = this.convertValue(value, types[key] || 'string');
                     }
                 }
+                // v4.5.0: Report progress every 1000 rows (avoid spam)
+                if (progressHooks?.onCurrentItem && index > 0 && index % 1000 === 0) {
+                    progressHooks.onCurrentItem(`Converting types: ${index}/${allData.length} rows...`);
+                }
                 return converted;
             });
+            // v4.5.0: Final progress - all bytes processed
+            if (progressHooks?.onBytesProcessed) {
+                progressHooks.onBytesProcessed(totalBytes);
+            }
             const processingTime = Date.now() - startTime;
+            // v4.5.0: Report completion
+            if (progressHooks?.onCurrentItem) {
+                progressHooks.onCurrentItem(`Excel complete: ${sheetsToProcess.length} sheets, ${convertedData.length} rows`);
+            }
             return {
                 format: this.format,
                 data: convertedData,

package/dist/augmentations/intelligentImport/handlers/pdfHandler.js

@@ -42,8 +42,17 @@ export class PDFHandler extends BaseFormatHandler {
     }
     async process(data, options) {
         const startTime = Date.now();
+        const progressHooks = options.progressHooks;
         // Convert to buffer
         const buffer = Buffer.isBuffer(data) ? data : Buffer.from(data, 'binary');
+        const totalBytes = buffer.length;
+        // v4.5.0: Report start
+        if (progressHooks?.onBytesProcessed) {
+            progressHooks.onBytesProcessed(0);
+        }
+        if (progressHooks?.onCurrentItem) {
+            progressHooks.onCurrentItem('Loading PDF document...');
+        }
         try {
             // Load PDF document
             const loadingTask = pdfjsLib.getDocument({
@@ -55,11 +64,19 @@ export class PDFHandler extends BaseFormatHandler {
             // Extract metadata
             const metadata = await pdfDoc.getMetadata();
             const numPages = pdfDoc.numPages;
+            // v4.5.0: Report document loaded
+            if (progressHooks?.onCurrentItem) {
+                progressHooks.onCurrentItem(`Processing ${numPages} pages...`);
+            }
             // Extract text and structure from all pages
             const allData = [];
             let totalTextLength = 0;
             let detectedTables = 0;
             for (let pageNum = 1; pageNum <= numPages; pageNum++) {
+                // v4.5.0: Report current page
+                if (progressHooks?.onCurrentItem) {
+                    progressHooks.onCurrentItem(`Processing page ${pageNum} of ${numPages}`);
+                }
                 const page = await pdfDoc.getPage(pageNum);
                 const textContent = await page.getTextContent();
                 // Extract text items with positions
@@ -96,8 +113,28 @@ export class PDFHandler extends BaseFormatHandler {
                         });
                     }
                 }
+                // v4.5.0: Estimate bytes processed (pages are sequential)
+                const bytesProcessed = Math.floor((pageNum / numPages) * totalBytes);
+                if (progressHooks?.onBytesProcessed) {
+                    progressHooks.onBytesProcessed(bytesProcessed);
+                }
+                // v4.5.0: Report extraction progress
+                if (progressHooks?.onDataExtracted) {
+                    progressHooks.onDataExtracted(allData.length, undefined); // Total unknown until complete
+                }
+            }
+            // v4.5.0: Final progress - all bytes processed
+            if (progressHooks?.onBytesProcessed) {
+                progressHooks.onBytesProcessed(totalBytes);
+            }
+            if (progressHooks?.onDataExtracted) {
+                progressHooks.onDataExtracted(allData.length, allData.length);
             }
             const processingTime = Date.now() - startTime;
+            // v4.5.0: Report completion
+            if (progressHooks?.onCurrentItem) {
+                progressHooks.onCurrentItem(`PDF complete: ${numPages} pages, ${allData.length} items extracted`);
+            }
             // Get all unique fields (excluding metadata fields)
             const fields = allData.length > 0
                 ? Object.keys(allData[0]).filter(k => !k.startsWith('_'))

package/dist/augmentations/intelligentImport/types.d.ts

@@ -2,6 +2,29 @@
  * Types for Intelligent Import Augmentation
  * Handles Excel, PDF, and CSV import with intelligent extraction
  */
+/**
+ * Progress hooks for format handlers
+ *
+ * Handlers call these hooks to report progress during processing.
+ * This enables real-time progress tracking for any file format.
+ */
+export interface FormatHandlerProgressHooks {
+    /**
+     * Report bytes processed
+     * Call this as you read/parse the file
+     */
+    onBytesProcessed?: (bytes: number) => void;
+    /**
+     * Set current processing context
+     * Examples: "Processing page 5", "Reading sheet: Q2 Sales"
+     */
+    onCurrentItem?: (item: string) => void;
+    /**
+     * Report structured data extraction progress
+     * Examples: "Extracted 100 rows", "Parsed 50 paragraphs"
+     */
+    onDataExtracted?: (count: number, total?: number) => void;
+}
 export interface FormatHandler {
     /**
      * Format name (e.g., 'csv', 'xlsx', 'pdf')
@@ -47,6 +70,16 @@ export interface FormatHandlerOptions {
     maxRows?: number;
     /** Whether to stream large files */
     streaming?: boolean;
+    /**
+     * Progress hooks (v4.5.0)
+     * Handlers call these to report progress during processing
+     */
+    progressHooks?: FormatHandlerProgressHooks;
+    /**
+     * Total file size in bytes (v4.5.0)
+     * Used for progress percentage calculation
+     */
+    totalBytes?: number;
 }
 export interface ProcessedData {
     /** Format that was processed */

package/dist/brainy.d.ts

@@ -800,9 +800,27 @@ export declare class Brainy<T = any> implements BrainyInterface<T> {
      *   groupBy: 'type',                   // Organize by entity type
      *   preserveSource: true,              // Keep original file
      *
-     *   // Progress tracking
-     *   onProgress: (p) => console.log(p.message)
+     *   // Progress tracking (v4.5.0 - STANDARDIZED FOR ALL 7 FORMATS!)
+     *   onProgress: (p) => {
+     *     console.log(`[${p.stage}] ${p.message}`)
+     *     console.log(`Entities: ${p.entities || 0}, Rels: ${p.relationships || 0}`)
+     *     if (p.throughput) console.log(`Rate: ${p.throughput.toFixed(1)}/sec`)
+     *   }
      * })
+     * // THIS SAME HANDLER WORKS FOR CSV, PDF, Excel, JSON, Markdown, YAML, DOCX!
+     * ```
+     *
+     * @example Universal Progress Handler (v4.5.0)
+     * ```typescript
+     * // ONE handler for ALL 7 formats - no format-specific code needed!
+     * const universalProgress = (p) => {
+     *   updateUI(p.stage, p.message, p.entities, p.relationships)
+     * }
+     *
+     * await brain.import(csvBuffer, { onProgress: universalProgress })
+     * await brain.import(pdfBuffer, { onProgress: universalProgress })
+     * await brain.import(excelBuffer, { onProgress: universalProgress })
+     * // Works for JSON, Markdown, YAML, DOCX too!
      * ```
      *
      * @example Performance Tuning (Large Files)
@@ -827,6 +845,7 @@ export declare class Brainy<T = any> implements BrainyInterface<T> {
      *
      * @see {@link https://brainy.dev/docs/api/import API Documentation}
      * @see {@link https://brainy.dev/docs/guides/migrating-to-v4 Migration Guide}
+     * @see {@link https://brainy.dev/docs/guides/standard-import-progress Standard Progress API (v4.5.0)}
      *
      * @remarks
      * **⚠️ Breaking Changes from v3.x:**
@@ -857,7 +876,7 @@ export declare class Brainy<T = any> implements BrainyInterface<T> {
      * - Reduced confusion (removed redundant options)
      */
     import(source: Buffer | string | object, options?: {
-        format?: 'excel' | 'pdf' | 'csv' | 'json' | 'markdown';
+        format?: 'excel' | 'pdf' | 'csv' | 'json' | 'markdown' | 'yaml' | 'docx';
         vfsPath?: string;
         groupBy?: 'type' | 'sheet' | 'flat' | 'custom';
         customGrouping?: (entity: any) => string;

package/dist/brainy.js

@@ -846,6 +846,13 @@ export class Brainy {
         if (params.service) {
             filter.service = params.service;
         }
+        // v4.5.1: Exclude VFS relationships by default (same pattern as brain.find())
+        // VFS relationships have metadata.isVFS = true
+        // Only include VFS relationships if explicitly requested
+        if (params.includeVFS !== true) {
+            filter.metadata = filter.metadata || {};
+            filter.metadata.isVFS = { notEquals: true };
+        }
         // Fetch from storage with pagination at storage layer (efficient!)
         const result = await this.storage.getVerbs({
             pagination: {
@@ -1757,9 +1764,27 @@ export class Brainy {
      *   groupBy: 'type',                   // Organize by entity type
      *   preserveSource: true,              // Keep original file
      *
-     *   // Progress tracking
-     *   onProgress: (p) => console.log(p.message)
+     *   // Progress tracking (v4.5.0 - STANDARDIZED FOR ALL 7 FORMATS!)
+     *   onProgress: (p) => {
+     *     console.log(`[${p.stage}] ${p.message}`)
+     *     console.log(`Entities: ${p.entities || 0}, Rels: ${p.relationships || 0}`)
+     *     if (p.throughput) console.log(`Rate: ${p.throughput.toFixed(1)}/sec`)
+     *   }
      * })
+     * // THIS SAME HANDLER WORKS FOR CSV, PDF, Excel, JSON, Markdown, YAML, DOCX!
+     * ```
+     *
+     * @example Universal Progress Handler (v4.5.0)
+     * ```typescript
+     * // ONE handler for ALL 7 formats - no format-specific code needed!
+     * const universalProgress = (p) => {
+     *   updateUI(p.stage, p.message, p.entities, p.relationships)
+     * }
+     *
+     * await brain.import(csvBuffer, { onProgress: universalProgress })
+     * await brain.import(pdfBuffer, { onProgress: universalProgress })
+     * await brain.import(excelBuffer, { onProgress: universalProgress })
+     * // Works for JSON, Markdown, YAML, DOCX too!
      * ```
      *
      * @example Performance Tuning (Large Files)
@@ -1784,6 +1809,7 @@ export class Brainy {
      *
      * @see {@link https://brainy.dev/docs/api/import API Documentation}
      * @see {@link https://brainy.dev/docs/guides/migrating-to-v4 Migration Guide}
+     * @see {@link https://brainy.dev/docs/guides/standard-import-progress Standard Progress API (v4.5.0)}
      *
      * @remarks
      * **⚠️ Breaking Changes from v3.x:**

package/dist/cli/commands/core.d.ts

@@ -12,6 +12,8 @@ interface AddOptions extends CoreOptions {
     id?: string;
     metadata?: string;
     type?: string;
+    confidence?: string;
+    weight?: string;
 }
 interface SearchOptions extends CoreOptions {
     limit?: string;
@@ -25,6 +27,7 @@ interface SearchOptions extends CoreOptions {
     via?: string;
     explain?: boolean;
     includeRelations?: boolean;
+    includeVfs?: boolean;
     fusion?: string;
     vectorWeight?: string;
     graphWeight?: string;

package/dist/cli/commands/core.js

@@ -109,23 +109,37 @@ export const coreCommands = {
                 spinner.text = `Using detected type: ${nounType}`;
             }
             // Add with explicit type
-            const result = await brain.add({
+            const addParams = {
                 data: text,
                 type: nounType,
                 metadata
-            });
+            };
+            // v4.3.x: Add confidence and weight if provided
+            if (options.confidence) {
+                addParams.confidence = parseFloat(options.confidence);
+            }
+            if (options.weight) {
+                addParams.weight = parseFloat(options.weight);
+            }
+            const result = await brain.add(addParams);
             spinner.succeed('Added successfully');
             if (!options.json) {
                 console.log(chalk.green(`✓ Added with ID: ${result}`));
                 if (options.type) {
                     console.log(chalk.dim(`  Type: ${options.type}`));
                 }
+                if (options.confidence) {
+                    console.log(chalk.dim(`  Confidence: ${options.confidence}`));
+                }
+                if (options.weight) {
+                    console.log(chalk.dim(`  Weight: ${options.weight}`));
+                }
                 if (Object.keys(metadata).length > 0) {
                     console.log(chalk.dim(`  Metadata: ${JSON.stringify(metadata)}`));
                 }
             }
             else {
-                formatOutput({ id: result, metadata }, options);
+                formatOutput({ id: result, metadata, confidence: addParams.confidence, weight: addParams.weight }, options);
             }
         }
         catch (error) {
@@ -260,6 +274,10 @@ export const coreCommands = {
             if (options.includeRelations) {
                 searchParams.includeRelations = true;
             }
+            // Include VFS files (v4.4.0 - find excludes VFS by default)
+            if (options.includeVfs) {
+                searchParams.includeVFS = true;
+            }
             // Triple Intelligence Fusion - custom weighting
             if (options.fusion || options.vectorWeight || options.graphWeight || options.fieldWeight) {
                 searchParams.fusion = {

package/dist/cli/commands/import.js

@@ -120,19 +120,25 @@ export const importCommands = {
                     }]);
                 options.recursive = answer.recursive;
             }
-            spinner = ora('Initializing neural import...').start();
+            spinner = ora('Initializing import...').start();
             const brain = getBrainy();
-            // Load UniversalImportAPI
-            const { UniversalImportAPI } = await import('../../api/UniversalImportAPI.js');
-            const universalImport = new UniversalImportAPI(brain);
-            await universalImport.init();
-            spinner.text = 'Processing import...';
             // Handle different source types
             let result;
             if (isURL) {
-                // URL import
+                // URL import - fetch first
                 spinner.text = `Fetching from ${source}...`;
-                result = await universalImport.importFromURL(source);
+                const response = await fetch(source);
+                const buffer = Buffer.from(await response.arrayBuffer());
+                spinner.text = 'Importing...';
+                result = await brain.import(buffer, {
+                    enableNeuralExtraction: options.extractEntities !== false,
+                    enableRelationshipInference: options.detectRelationships !== false,
+                    enableConceptExtraction: options.extractConcepts || false,
+                    confidenceThreshold: options.confidence ? parseFloat(options.confidence) : 0.6,
+                    onProgress: options.progress ? (p) => {
+                        spinner.text = `${p.message}${p.entities ? ` (${p.entities} entities)` : ''}`;
+                    } : undefined
+                });
             }
             else if (isDirectory) {
                 // Directory import - process each file
@@ -163,31 +169,42 @@ export const importCommands = {
                 };
                 await collectFiles(source);
                 spinner.succeed(`Found ${files.length} files`);
-                // Process files in batches
-                const batchSize = options.batchSize ? parseInt(options.batchSize) : 100;
+                // Process files with progress
                 let totalEntities = 0;
                 let totalRelationships = 0;
                 let filesProcessed = 0;
-                for (let i = 0; i < files.length; i += batchSize) {
-                    const batch = files.slice(i, i + batchSize);
-                    if (options.progress) {
-                        spinner = ora(`Processing batch ${Math.floor(i / batchSize) + 1}/${Math.ceil(files.length / batchSize)} (${filesProcessed}/${files.length} files)...`).start();
-                    }
-                    for (const file of batch) {
-                        try {
-                            const fileResult = await universalImport.importFromFile(file);
-                            totalEntities += fileResult.stats.entitiesCreated;
-                            totalRelationships += fileResult.stats.relationshipsCreated;
-                            filesProcessed++;
+                for (const file of files) {
+                    try {
+                        if (options.progress) {
+                            spinner = ora(`[${filesProcessed + 1}/${files.length}] Importing ${file}...`).start();
                         }
-                        catch (error) {
-                            if (options.verbose) {
-                                console.log(chalk.yellow(`⚠️  Failed to import ${file}: ${error.message}`));
-                            }
+                        const fileResult = await brain.import(file, {
+                            enableNeuralExtraction: options.extractEntities !== false,
+                            enableRelationshipInference: options.detectRelationships !== false,
+                            enableConceptExtraction: options.extractConcepts || false,
+                            confidenceThreshold: options.confidence ? parseFloat(options.confidence) : 0.6,
+                            onProgress: options.progress ? (p) => {
+                                spinner.text = `[${filesProcessed + 1}/${files.length}] ${p.message}`;
+                            } : undefined
+                        });
+                        totalEntities += fileResult.entities.length;
+                        totalRelationships += fileResult.relationships.length;
+                        filesProcessed++;
+                        if (options.progress) {
+                            spinner.succeed(`[${filesProcessed}/${files.length}] ${file}`);
+                        }
+                    }
+                    catch (error) {
+                        if (options.verbose) {
+                            if (spinner)
+                                spinner.fail(`Failed: ${file}`);
+                            console.log(chalk.yellow(`⚠️  ${error.message}`));
                         }
                     }
                 }
                 result = {
+                    entities: [],
+                    relationships: [],
                     stats: {
                         filesProcessed,
                         entitiesCreated: totalEntities,
@@ -195,11 +212,23 @@ export const importCommands = {
                         totalProcessed: filesProcessed
                     }
                 };
-                spinner.succeed('Directory import complete');
+                spinner = ora().succeed(`Directory import complete: ${filesProcessed} files`);
             }
             else {
-                // File import
-                result = await universalImport.importFromFile(source);
+                // File import with progress
+                result = await brain.import(source, {
+                    format: options.format,
+                    enableNeuralExtraction: options.extractEntities !== false,
+                    enableRelationshipInference: options.detectRelationships !== false,
+                    enableConceptExtraction: options.extractConcepts || false,
+                    confidenceThreshold: options.confidence ? parseFloat(options.confidence) : 0.6,
+                    onProgress: options.progress ? (p) => {
+                        spinner.text = `${p.message}${p.entities ? ` (${p.entities} entities, ${p.relationships || 0} relationships)` : ''}`;
+                        if (p.throughput && p.eta) {
+                            spinner.text += ` - ${p.throughput.toFixed(1)}/sec, ETA: ${Math.round(p.eta / 1000)}s`;
+                        }
+                    } : undefined
+                });
             }
             spinner.succeed('Import complete');
             // Post-processing: extract concepts if requested
@@ -270,15 +299,21 @@ export const importCommands = {
             if (!options.json && !options.quiet) {
                 console.log(chalk.cyan('\n📊 Import Results:\n'));
                 console.log(chalk.bold('Statistics:'));
-                console.log(`  Entities created: ${chalk.green(result.stats.entitiesCreated)}`);
-                if (result.stats.relationshipsCreated > 0) {
-                    console.log(`  Relationships created: ${chalk.green(result.stats.relationshipsCreated)}`);
+                const entitiesCount = result.stats?.entitiesCreated || result.entities?.length || 0;
+                const relationshipsCount = result.stats?.relationshipsCreated || result.relationships?.length || 0;
+                console.log(`  Entities created: ${chalk.green(entitiesCount)}`);
+                if (relationshipsCount > 0) {
+                    console.log(`  Relationships created: ${chalk.green(relationshipsCount)}`);
                 }
-                if (result.stats.filesProcessed) {
+                if (result.stats?.filesProcessed) {
                     console.log(`  Files processed: ${chalk.green(result.stats.filesProcessed)}`);
                 }
-                console.log(`  Average confidence: ${chalk.yellow((result.stats.averageConfidence * 100).toFixed(1))}%`);
-                console.log(`  Processing time: ${chalk.dim(result.stats.processingTimeMs)}ms`);
+                if (result.stats?.averageConfidence) {
+                    console.log(`  Average confidence: ${chalk.yellow((result.stats.averageConfidence * 100).toFixed(1))}%`);
+                }
+                if (result.stats?.processingTimeMs) {
+                    console.log(`  Processing time: ${chalk.dim(result.stats.processingTimeMs)}ms`);
+                }
                 if (options.verbose && result.entities && result.entities.length > 0) {
                     console.log(chalk.bold('\n📦 Imported Entities (first 10):'));
                     result.entities.slice(0, 10).forEach((entity, i) => {

package/dist/importers/SmartCSVImporter.js

@@ -53,10 +53,44 @@ export class SmartCSVImporter {
             ...options
         };
         // Parse CSV using existing handler
+        // v4.5.0: Pass progress hooks to handler for file parsing progress
         const processedData = await this.csvHandler.process(buffer, {
             ...options,
             csvDelimiter: opts.csvDelimiter,
-            csvHeaders: opts.csvHeaders
+            csvHeaders: opts.csvHeaders,
+            totalBytes: buffer.length,
+            progressHooks: {
+                onBytesProcessed: (bytes) => {
+                    // Handler reports bytes processed during parsing
+                    opts.onProgress?.({
+                        processed: 0,
+                        total: 0,
+                        entities: 0,
+                        relationships: 0,
+                        phase: `Parsing CSV (${Math.round((bytes / buffer.length) * 100)}%)`
+                    });
+                },
+                onCurrentItem: (message) => {
+                    // Handler reports current processing step
+                    opts.onProgress?.({
+                        processed: 0,
+                        total: 0,
+                        entities: 0,
+                        relationships: 0,
+                        phase: message
+                    });
+                },
+                onDataExtracted: (count, total) => {
+                    // Handler reports rows extracted
+                    opts.onProgress?.({
+                        processed: 0,
+                        total: total || count,
+                        entities: 0,
+                        relationships: 0,
+                        phase: `Extracted ${count} rows`
+                    });
+                }
+            }
         });
         const rows = processedData.data;
         if (rows.length === 0) {

package/dist/importers/SmartDOCXImporter.js

@@ -54,10 +54,22 @@ export class SmartDOCXImporter {
         if (!this.mammothLoaded) {
             await this.init();
         }
+        // v4.5.0: Report parsing start
+        options.onProgress?.({
+            processed: 0,
+            entities: 0,
+            relationships: 0
+        });
         // Extract raw text for entity extraction
         const textResult = await mammoth.extractRawText({ buffer });
         // Extract HTML for structure analysis (headings, tables)
         const htmlResult = await mammoth.convertToHtml({ buffer });
+        // v4.5.0: Report parsing complete
+        options.onProgress?.({
+            processed: 0,
+            entities: 0,
+            relationships: 0
+        });
         // Process the document
         const result = await this.extractFromContent(textResult.value, htmlResult.value, options);
         result.processingTime = Date.now() - startTime;