@soulcraft/brainy 3.27.1 → 3.28.0

package/dist/importers/SmartImportOrchestrator.js

@@ -0,0 +1,531 @@
+/**
+ * Smart Import Orchestrator
+ *
+ * Coordinates the entire smart import pipeline:
+ * 1. Extract entities/relationships using SmartExcelImporter
+ * 2. Create entities and relationships in Brainy
+ * 3. Organize into VFS structure using VFSStructureGenerator
+ *
+ * NO MOCKS - Production-ready implementation
+ */
+import { VirtualFileSystem } from '../vfs/VirtualFileSystem.js';
+import { NounType } from '../types/graphTypes.js';
+import { SmartExcelImporter } from './SmartExcelImporter.js';
+import { SmartPDFImporter } from './SmartPDFImporter.js';
+import { SmartCSVImporter } from './SmartCSVImporter.js';
+import { SmartJSONImporter } from './SmartJSONImporter.js';
+import { SmartMarkdownImporter } from './SmartMarkdownImporter.js';
+import { VFSStructureGenerator } from './VFSStructureGenerator.js';
+/**
+ * SmartImportOrchestrator - Main entry point for smart imports
+ */
+export class SmartImportOrchestrator {
+    constructor(brain) {
+        this.brain = brain;
+        this.excelImporter = new SmartExcelImporter(brain);
+        this.pdfImporter = new SmartPDFImporter(brain);
+        this.csvImporter = new SmartCSVImporter(brain);
+        this.jsonImporter = new SmartJSONImporter(brain);
+        this.markdownImporter = new SmartMarkdownImporter(brain);
+        this.vfsGenerator = new VFSStructureGenerator(brain);
+    }
+    /**
+     * Initialize the orchestrator
+     */
+    async init() {
+        await this.excelImporter.init();
+        await this.pdfImporter.init();
+        await this.csvImporter.init();
+        await this.jsonImporter.init();
+        await this.markdownImporter.init();
+        await this.vfsGenerator.init();
+    }
+    /**
+     * Import Excel file with full pipeline
+     */
+    async importExcel(buffer, options = {}, onProgress) {
+        const startTime = Date.now();
+        const result = {
+            success: false,
+            extraction: null,
+            entityIds: [],
+            relationshipIds: [],
+            stats: {
+                rowsProcessed: 0,
+                entitiesCreated: 0,
+                relationshipsCreated: 0,
+                filesCreated: 0,
+                totalTime: 0
+            },
+            errors: []
+        };
+        try {
+            // Phase 1: Extract entities and relationships
+            onProgress?.({
+                phase: 'extracting',
+                message: 'Extracting entities and relationships...',
+                processed: 0,
+                total: 0,
+                entities: 0,
+                relationships: 0
+            });
+            result.extraction = await this.excelImporter.extract(buffer, {
+                ...options,
+                onProgress: (stats) => {
+                    onProgress?.({
+                        phase: 'extracting',
+                        message: `Processing row ${stats.processed}/${stats.total}...`,
+                        processed: stats.processed,
+                        total: stats.total,
+                        entities: stats.entities,
+                        relationships: stats.relationships
+                    });
+                }
+            });
+            result.stats.rowsProcessed = result.extraction.rowsProcessed;
+            // Phase 2: Create entities in Brainy
+            if (options.createEntities !== false) {
+                onProgress?.({
+                    phase: 'creating',
+                    message: 'Creating entities in knowledge graph...',
+                    processed: 0,
+                    total: result.extraction.rows.length,
+                    entities: 0,
+                    relationships: 0
+                });
+                for (let i = 0; i < result.extraction.rows.length; i++) {
+                    const extracted = result.extraction.rows[i];
+                    try {
+                        // Create main entity
+                        const entityId = await this.brain.add({
+                            data: extracted.entity.description,
+                            type: extracted.entity.type,
+                            metadata: {
+                                ...extracted.entity.metadata,
+                                name: extracted.entity.name,
+                                confidence: extracted.entity.confidence,
+                                importedFrom: 'smart-import'
+                            }
+                        });
+                        result.entityIds.push(entityId);
+                        result.stats.entitiesCreated++;
+                        // Update entity ID in extraction result
+                        extracted.entity.id = entityId;
+                        onProgress?.({
+                            phase: 'creating',
+                            message: `Created entity: ${extracted.entity.name}`,
+                            processed: i + 1,
+                            total: result.extraction.rows.length,
+                            entities: result.entityIds.length,
+                            relationships: result.relationshipIds.length
+                        });
+                    }
+                    catch (error) {
+                        result.errors.push(`Failed to create entity ${extracted.entity.name}: ${error.message}`);
+                    }
+                }
+            }
+            // Phase 3: Create relationships
+            if (options.createRelationships !== false && options.createEntities !== false) {
+                onProgress?.({
+                    phase: 'creating',
+                    message: 'Creating relationships...',
+                    processed: 0,
+                    total: result.extraction.rows.length,
+                    entities: result.entityIds.length,
+                    relationships: 0
+                });
+                // Build entity name -> ID map
+                const entityMap = new Map();
+                for (const extracted of result.extraction.rows) {
+                    entityMap.set(extracted.entity.name.toLowerCase(), extracted.entity.id);
+                }
+                // Create relationships
+                for (const extracted of result.extraction.rows) {
+                    for (const rel of extracted.relationships) {
+                        try {
+                            // Find target entity ID
+                            let toEntityId;
+                            // Try to find by name in our extracted entities
+                            for (const otherExtracted of result.extraction.rows) {
+                                if (rel.to.toLowerCase().includes(otherExtracted.entity.name.toLowerCase()) ||
+                                    otherExtracted.entity.name.toLowerCase().includes(rel.to.toLowerCase())) {
+                                    toEntityId = otherExtracted.entity.id;
+                                    break;
+                                }
+                            }
+                            // If not found, create a placeholder entity
+                            if (!toEntityId) {
+                                toEntityId = await this.brain.add({
+                                    data: rel.to,
+                                    type: NounType.Thing,
+                                    metadata: {
+                                        name: rel.to,
+                                        placeholder: true,
+                                        extractedFrom: extracted.entity.name
+                                    }
+                                });
+                                result.entityIds.push(toEntityId);
+                            }
+                            // Create relationship
+                            const relId = await this.brain.relate({
+                                from: extracted.entity.id,
+                                to: toEntityId,
+                                type: rel.type,
+                                metadata: {
+                                    confidence: rel.confidence,
+                                    evidence: rel.evidence
+                                }
+                            });
+                            result.relationshipIds.push(relId);
+                            result.stats.relationshipsCreated++;
+                        }
+                        catch (error) {
+                            result.errors.push(`Failed to create relationship: ${error.message}`);
+                        }
+                    }
+                }
+            }
+            // Phase 4: Create VFS structure
+            if (options.createVFSStructure !== false) {
+                onProgress?.({
+                    phase: 'organizing',
+                    message: 'Organizing into file structure...',
+                    processed: 0,
+                    total: result.extraction.rows.length,
+                    entities: result.entityIds.length,
+                    relationships: result.relationshipIds.length
+                });
+                const vfsOptions = {
+                    rootPath: options.vfsRootPath || '/imports/' + (options.filename || 'import'),
+                    groupBy: options.vfsGroupBy || 'type',
+                    preserveSource: true,
+                    sourceBuffer: buffer,
+                    sourceFilename: options.filename || 'import.xlsx',
+                    createRelationshipFile: true,
+                    createMetadataFile: true
+                };
+                const vfsResult = await this.vfsGenerator.generate(result.extraction, vfsOptions);
+                result.vfsStructure = {
+                    rootPath: vfsResult.rootPath,
+                    directories: vfsResult.directories,
+                    files: vfsResult.files.length
+                };
+                result.stats.filesCreated = vfsResult.files.length;
+            }
+            // Complete
+            result.success = result.errors.length === 0;
+            result.stats.totalTime = Date.now() - startTime;
+            onProgress?.({
+                phase: 'complete',
+                message: `Import complete: ${result.stats.entitiesCreated} entities, ${result.stats.relationshipsCreated} relationships`,
+                processed: result.extraction.rows.length,
+                total: result.extraction.rows.length,
+                entities: result.stats.entitiesCreated,
+                relationships: result.stats.relationshipsCreated
+            });
+        }
+        catch (error) {
+            result.errors.push(`Import failed: ${error.message}`);
+            result.success = false;
+        }
+        return result;
+    }
+    /**
+     * Import PDF file with full pipeline
+     */
+    async importPDF(buffer, options = {}, onProgress) {
+        const startTime = Date.now();
+        const result = {
+            success: false,
+            extraction: null,
+            entityIds: [],
+            relationshipIds: [],
+            stats: {
+                rowsProcessed: 0,
+                entitiesCreated: 0,
+                relationshipsCreated: 0,
+                filesCreated: 0,
+                totalTime: 0
+            },
+            errors: []
+        };
+        try {
+            // Phase 1: Extract from PDF
+            onProgress?.({ phase: 'extracting', message: 'Extracting from PDF...', processed: 0, total: 0, entities: 0, relationships: 0 });
+            const pdfResult = await this.pdfImporter.extract(buffer, options);
+            // Convert PDF result to Excel-like format for processing
+            result.extraction = this.convertPDFToExcelFormat(pdfResult);
+            result.stats.rowsProcessed = pdfResult.sectionsProcessed;
+            // Phase 2 & 3: Create entities and relationships
+            await this.createEntitiesAndRelationships(result, options, onProgress);
+            // Phase 4: Create VFS structure
+            if (options.createVFSStructure !== false) {
+                const vfsOptions = {
+                    rootPath: options.vfsRootPath || '/imports/' + (options.filename || 'import'),
+                    groupBy: options.vfsGroupBy || 'type',
+                    preserveSource: true,
+                    sourceBuffer: buffer,
+                    sourceFilename: options.filename || 'import.pdf',
+                    createRelationshipFile: true,
+                    createMetadataFile: true
+                };
+                const vfsResult = await this.vfsGenerator.generate(result.extraction, vfsOptions);
+                result.vfsStructure = { rootPath: vfsResult.rootPath, directories: vfsResult.directories, files: vfsResult.files.length };
+                result.stats.filesCreated = vfsResult.files.length;
+            }
+            result.success = result.errors.length === 0;
+            result.stats.totalTime = Date.now() - startTime;
+            onProgress?.({ phase: 'complete', message: `Import complete: ${result.stats.entitiesCreated} entities, ${result.stats.relationshipsCreated} relationships`, processed: result.stats.rowsProcessed, total: result.stats.rowsProcessed, entities: result.stats.entitiesCreated, relationships: result.stats.relationshipsCreated });
+        }
+        catch (error) {
+            result.errors.push(`PDF import failed: ${error.message}`);
+            result.success = false;
+        }
+        return result;
+    }
+    /**
+     * Import CSV file with full pipeline
+     */
+    async importCSV(buffer, options = {}, onProgress) {
+        // CSV is very similar to Excel, can reuse importExcel logic
+        return this.importExcel(buffer, options, onProgress);
+    }
+    /**
+     * Import JSON data with full pipeline
+     */
+    async importJSON(data, options = {}, onProgress) {
+        const startTime = Date.now();
+        const result = {
+            success: false,
+            extraction: null,
+            entityIds: [],
+            relationshipIds: [],
+            stats: {
+                rowsProcessed: 0,
+                entitiesCreated: 0,
+                relationshipsCreated: 0,
+                filesCreated: 0,
+                totalTime: 0
+            },
+            errors: []
+        };
+        try {
+            onProgress?.({ phase: 'extracting', message: 'Extracting from JSON...', processed: 0, total: 0, entities: 0, relationships: 0 });
+            const jsonResult = await this.jsonImporter.extract(data, options);
+            result.extraction = this.convertJSONToExcelFormat(jsonResult);
+            result.stats.rowsProcessed = jsonResult.nodesProcessed;
+            await this.createEntitiesAndRelationships(result, options, onProgress);
+            if (options.createVFSStructure !== false) {
+                const sourceBuffer = Buffer.from(typeof data === 'string' ? data : JSON.stringify(data, null, 2));
+                const vfsOptions = {
+                    rootPath: options.vfsRootPath || '/imports/' + (options.filename || 'import'),
+                    groupBy: options.vfsGroupBy || 'type',
+                    preserveSource: true,
+                    sourceBuffer,
+                    sourceFilename: options.filename || 'import.json',
+                    createRelationshipFile: true,
+                    createMetadataFile: true
+                };
+                const vfsResult = await this.vfsGenerator.generate(result.extraction, vfsOptions);
+                result.vfsStructure = { rootPath: vfsResult.rootPath, directories: vfsResult.directories, files: vfsResult.files.length };
+                result.stats.filesCreated = vfsResult.files.length;
+            }
+            result.success = result.errors.length === 0;
+            result.stats.totalTime = Date.now() - startTime;
+            onProgress?.({ phase: 'complete', message: `Import complete: ${result.stats.entitiesCreated} entities, ${result.stats.relationshipsCreated} relationships`, processed: result.stats.rowsProcessed, total: result.stats.rowsProcessed, entities: result.stats.entitiesCreated, relationships: result.stats.relationshipsCreated });
+        }
+        catch (error) {
+            result.errors.push(`JSON import failed: ${error.message}`);
+            result.success = false;
+        }
+        return result;
+    }
+    /**
+     * Import Markdown content with full pipeline
+     */
+    async importMarkdown(markdown, options = {}, onProgress) {
+        const startTime = Date.now();
+        const result = {
+            success: false,
+            extraction: null,
+            entityIds: [],
+            relationshipIds: [],
+            stats: {
+                rowsProcessed: 0,
+                entitiesCreated: 0,
+                relationshipsCreated: 0,
+                filesCreated: 0,
+                totalTime: 0
+            },
+            errors: []
+        };
+        try {
+            onProgress?.({ phase: 'extracting', message: 'Extracting from Markdown...', processed: 0, total: 0, entities: 0, relationships: 0 });
+            const mdResult = await this.markdownImporter.extract(markdown, options);
+            result.extraction = this.convertMarkdownToExcelFormat(mdResult);
+            result.stats.rowsProcessed = mdResult.sectionsProcessed;
+            await this.createEntitiesAndRelationships(result, options, onProgress);
+            if (options.createVFSStructure !== false) {
+                const sourceBuffer = Buffer.from(markdown, 'utf-8');
+                const vfsOptions = {
+                    rootPath: options.vfsRootPath || '/imports/' + (options.filename || 'import'),
+                    groupBy: options.vfsGroupBy || 'type',
+                    preserveSource: true,
+                    sourceBuffer,
+                    sourceFilename: options.filename || 'import.md',
+                    createRelationshipFile: true,
+                    createMetadataFile: true
+                };
+                const vfsResult = await this.vfsGenerator.generate(result.extraction, vfsOptions);
+                result.vfsStructure = { rootPath: vfsResult.rootPath, directories: vfsResult.directories, files: vfsResult.files.length };
+                result.stats.filesCreated = vfsResult.files.length;
+            }
+            result.success = result.errors.length === 0;
+            result.stats.totalTime = Date.now() - startTime;
+            onProgress?.({ phase: 'complete', message: `Import complete: ${result.stats.entitiesCreated} entities, ${result.stats.relationshipsCreated} relationships`, processed: result.stats.rowsProcessed, total: result.stats.rowsProcessed, entities: result.stats.entitiesCreated, relationships: result.stats.relationshipsCreated });
+        }
+        catch (error) {
+            result.errors.push(`Markdown import failed: ${error.message}`);
+            result.success = false;
+        }
+        return result;
+    }
+    /**
+     * Helper: Create entities and relationships from extraction result
+     */
+    async createEntitiesAndRelationships(result, options, onProgress) {
+        if (options.createEntities !== false) {
+            onProgress?.({ phase: 'creating', message: 'Creating entities in knowledge graph...', processed: 0, total: result.extraction.rows.length, entities: 0, relationships: 0 });
+            for (let i = 0; i < result.extraction.rows.length; i++) {
+                const extracted = result.extraction.rows[i];
+                try {
+                    const entityId = await this.brain.add({
+                        data: extracted.entity.description,
+                        type: extracted.entity.type,
+                        metadata: { ...extracted.entity.metadata, name: extracted.entity.name, confidence: extracted.entity.confidence, importedFrom: 'smart-import' }
+                    });
+                    result.entityIds.push(entityId);
+                    result.stats.entitiesCreated++;
+                    extracted.entity.id = entityId;
+                }
+                catch (error) {
+                    result.errors.push(`Failed to create entity ${extracted.entity.name}: ${error.message}`);
+                }
+            }
+        }
+        if (options.createRelationships !== false && options.createEntities !== false) {
+            onProgress?.({ phase: 'creating', message: 'Creating relationships...', processed: 0, total: result.extraction.rows.length, entities: result.entityIds.length, relationships: 0 });
+            for (const extracted of result.extraction.rows) {
+                for (const rel of extracted.relationships) {
+                    try {
+                        let toEntityId;
+                        for (const otherExtracted of result.extraction.rows) {
+                            if (rel.to.toLowerCase().includes(otherExtracted.entity.name.toLowerCase()) || otherExtracted.entity.name.toLowerCase().includes(rel.to.toLowerCase())) {
+                                toEntityId = otherExtracted.entity.id;
+                                break;
+                            }
+                        }
+                        if (!toEntityId) {
+                            toEntityId = await this.brain.add({ data: rel.to, type: NounType.Thing, metadata: { name: rel.to, placeholder: true, extractedFrom: extracted.entity.name } });
+                            result.entityIds.push(toEntityId);
+                        }
+                        const relId = await this.brain.relate({ from: extracted.entity.id, to: toEntityId, type: rel.type, metadata: { confidence: rel.confidence, evidence: rel.evidence } });
+                        result.relationshipIds.push(relId);
+                        result.stats.relationshipsCreated++;
+                    }
+                    catch (error) {
+                        result.errors.push(`Failed to create relationship: ${error.message}`);
+                    }
+                }
+            }
+        }
+    }
+    /**
+     * Helper: Convert PDF result to Excel-like format
+     */
+    convertPDFToExcelFormat(pdfResult) {
+        const rows = pdfResult.sections.flatMap(section => section.entities.map(entity => ({
+            entity,
+            relatedEntities: [],
+            relationships: section.relationships.filter(r => r.from === entity.id),
+            concepts: section.concepts
+        })));
+        return {
+            rowsProcessed: pdfResult.sectionsProcessed,
+            entitiesExtracted: pdfResult.entitiesExtracted,
+            relationshipsInferred: pdfResult.relationshipsInferred,
+            rows,
+            entityMap: pdfResult.entityMap,
+            processingTime: pdfResult.processingTime,
+            stats: pdfResult.stats
+        };
+    }
+    /**
+     * Helper: Convert JSON result to Excel-like format
+     */
+    convertJSONToExcelFormat(jsonResult) {
+        const rows = jsonResult.entities.map(entity => ({
+            entity,
+            relatedEntities: [],
+            relationships: jsonResult.relationships.filter(r => r.from === entity.id),
+            concepts: entity.metadata.concepts || []
+        }));
+        return {
+            rowsProcessed: jsonResult.nodesProcessed,
+            entitiesExtracted: jsonResult.entitiesExtracted,
+            relationshipsInferred: jsonResult.relationshipsInferred,
+            rows,
+            entityMap: jsonResult.entityMap,
+            processingTime: jsonResult.processingTime,
+            stats: jsonResult.stats
+        };
+    }
+    /**
+     * Helper: Convert Markdown result to Excel-like format
+     */
+    convertMarkdownToExcelFormat(mdResult) {
+        const rows = mdResult.sections.flatMap(section => section.entities.map(entity => ({
+            entity,
+            relatedEntities: [],
+            relationships: section.relationships.filter(r => r.from === entity.id),
+            concepts: section.concepts
+        })));
+        return {
+            rowsProcessed: mdResult.sectionsProcessed,
+            entitiesExtracted: mdResult.entitiesExtracted,
+            relationshipsInferred: mdResult.relationshipsInferred,
+            rows,
+            entityMap: mdResult.entityMap,
+            processingTime: mdResult.processingTime,
+            stats: mdResult.stats
+        };
+    }
+    /**
+     * Get import statistics
+     */
+    async getImportStatistics(vfsRootPath) {
+        // Read metadata file
+        const vfs = new VirtualFileSystem(this.brain);
+        await vfs.init();
+        const metadataPath = `${vfsRootPath}/_metadata.json`;
+        try {
+            const metadataBuffer = await vfs.readFile(metadataPath);
+            const metadata = JSON.parse(metadataBuffer.toString('utf-8'));
+            return {
+                entitiesInGraph: metadata.import.stats.entitiesExtracted,
+                relationshipsInGraph: metadata.import.stats.relationshipsInferred,
+                filesInVFS: metadata.structure.fileCount,
+                lastImport: new Date(metadata.import.timestamp)
+            };
+        }
+        catch (error) {
+            return {
+                entitiesInGraph: 0,
+                relationshipsInGraph: 0,
+                filesInVFS: 0
+            };
+        }
+    }
+}
+//# sourceMappingURL=SmartImportOrchestrator.js.map

package/dist/importers/SmartJSONImporter.d.ts

@@ -0,0 +1,135 @@
+/**
+ * Smart JSON Importer
+ *
+ * Extracts entities and relationships from JSON files using:
+ * - Recursive traversal of nested structures
+ * - NeuralEntityExtractor for entity extraction from text values
+ * - NaturalLanguageProcessor for relationship inference
+ * - Hierarchical relationship creation (parent-child, contains, etc.)
+ *
+ * NO MOCKS - Production-ready implementation
+ */
+import { Brainy } from '../brainy.js';
+import { NounType, VerbType } from '../types/graphTypes.js';
+export interface SmartJSONOptions {
+    /** Enable neural entity extraction from string values */
+    enableNeuralExtraction?: boolean;
+    /** Enable hierarchical relationship creation */
+    enableHierarchicalRelationships?: boolean;
+    /** Enable concept extraction for tagging */
+    enableConceptExtraction?: boolean;
+    /** Confidence threshold for entities (0-1) */
+    confidenceThreshold?: number;
+    /** Maximum depth to traverse */
+    maxDepth?: number;
+    /** Minimum string length to process for entity extraction */
+    minStringLength?: number;
+    /** Keys that indicate entity names */
+    nameKeys?: string[];
+    /** Keys that indicate entity descriptions */
+    descriptionKeys?: string[];
+    /** Keys that indicate entity types */
+    typeKeys?: string[];
+    /** Progress callback */
+    onProgress?: (stats: {
+        processed: number;
+        entities: number;
+        relationships: number;
+    }) => void;
+}
+export interface ExtractedJSONEntity {
+    /** Entity ID */
+    id: string;
+    /** Entity name */
+    name: string;
+    /** Entity type */
+    type: NounType;
+    /** Entity description/value */
+    description: string;
+    /** Confidence score */
+    confidence: number;
+    /** JSON path to this entity */
+    path: string;
+    /** Parent path in JSON hierarchy */
+    parentPath: string | null;
+    /** Metadata */
+    metadata: Record<string, any>;
+}
+export interface ExtractedJSONRelationship {
+    from: string;
+    to: string;
+    type: VerbType;
+    confidence: number;
+    evidence: string;
+}
+export interface SmartJSONResult {
+    /** Total nodes processed */
+    nodesProcessed: number;
+    /** Entities extracted */
+    entitiesExtracted: number;
+    /** Relationships inferred */
+    relationshipsInferred: number;
+    /** All extracted entities */
+    entities: ExtractedJSONEntity[];
+    /** All relationships */
+    relationships: ExtractedJSONRelationship[];
+    /** Entity ID mapping (path -> ID) */
+    entityMap: Map<string, string>;
+    /** Processing time in ms */
+    processingTime: number;
+    /** Extraction statistics */
+    stats: {
+        byType: Record<string, number>;
+        byDepth: Record<number, number>;
+        byConfidence: {
+            high: number;
+            medium: number;
+            low: number;
+        };
+    };
+}
+/**
+ * SmartJSONImporter - Extracts structured knowledge from JSON files
+ */
+export declare class SmartJSONImporter {
+    private brain;
+    private extractor;
+    private nlp;
+    constructor(brain: Brainy);
+    /**
+     * Initialize the importer
+     */
+    init(): Promise<void>;
+    /**
+     * Extract entities and relationships from JSON data
+     */
+    extract(data: any, options?: SmartJSONOptions): Promise<SmartJSONResult>;
+    /**
+     * Recursively traverse JSON structure
+     */
+    private traverseJSON;
+    /**
+     * Extract entity from JSON object
+     */
+    private extractEntityFromObject;
+    /**
+     * Find value in object by key patterns
+     */
+    private findValue;
+    /**
+     * Infer type from JSON structure
+     */
+    private inferTypeFromStructure;
+    /**
+     * Map type string to NounType
+     */
+    private mapTypeString;
+    /**
+     * Generate consistent entity ID
+     */
+    private generateEntityId;
+    /**
+     * Update statistics
+     */
+    private updateStats;
+}