@soulcraft/brainy 6.2.1 → 6.2.2

package/CHANGELOG.md

@@ -2,6 +2,12 @@
 
 All notable changes to this project will be documented in this file. See [standard-version](https://github.com/conventional-changelog/standard-version) for commit guidelines.
 
+### [6.2.2](https://github.com/soulcraftlabs/brainy/compare/v6.2.1...v6.2.2) (2025-11-25)
+
+- refactor: remove 3,700+ LOC of unused HNSW implementations (e3146ce)
+- fix(hnsw): entry point recovery prevents import failures and log spam (52eae67)
+
+
 ## [6.2.0](https://github.com/soulcraftlabs/brainy/compare/v6.1.0...v6.2.0) (2025-11-20)
 
 ### ⚡ Critical Performance Fix

package/dist/brainy.js

@@ -6,7 +6,6 @@
  */
 import { v4 as uuidv4 } from './universal/uuid.js';
 import { HNSWIndex } from './hnsw/hnswIndex.js';
-import { HNSWIndexOptimized } from './hnsw/hnswIndexOptimized.js';
 import { TypeAwareHNSWIndex } from './hnsw/typeAwareHNSWIndex.js';
 import { createStorage } from './storage/storageFactory.js';
 import { defaultEmbeddingFunction, cosineDistance } from './utils/index.js';
@@ -802,7 +801,7 @@ export class Brainy {
                     if (this.index instanceof TypeAwareHNSWIndex && metadata.noun) {
                         tx.addOperation(new RemoveFromTypeAwareHNSWOperation(this.index, id, noun.vector, metadata.noun));
                     }
-                    else if (this.index instanceof HNSWIndex || this.index instanceof HNSWIndexOptimized) {
+                    else if (this.index instanceof HNSWIndex) {
                         tx.addOperation(new RemoveFromHNSWOperation(this.index, id, noun.vector));
                     }
                 }
@@ -1887,7 +1886,7 @@ export class Brainy {
                                 if (this.index instanceof TypeAwareHNSWIndex && metadata.noun) {
                                     tx.addOperation(new RemoveFromTypeAwareHNSWOperation(this.index, id, noun.vector, metadata.noun));
                                 }
-                                else if (this.index instanceof HNSWIndex || this.index instanceof HNSWIndexOptimized) {
+                                else if (this.index instanceof HNSWIndex) {
                                     tx.addOperation(new RemoveFromHNSWOperation(this.index, id, noun.vector));
                                 }
                             }

package/dist/hnsw/hnswIndex.d.ts

@@ -83,6 +83,12 @@ export declare class HNSWIndex {
      * Add a vector to the index
      */
     addItem(item: VectorDocument): Promise<string>;
+    /**
+     * O(1) entry point recovery using highLevelNodes index (v6.2.3).
+     * At any reasonable scale (1000+ nodes), level 2+ nodes are guaranteed to exist.
+     * For tiny indexes with only level 0-1 nodes, any node works as entry point.
+     */
+    private recoverEntryPointO1;
     /**
      * Search for nearest neighbors
      */

package/dist/hnsw/hnswIndex.js

@@ -210,9 +210,8 @@ export class HNSWIndex {
         }
         // Find entry point
         if (!this.entryPointId) {
-            console.error('Entry point ID is null');
-            // If there's no entry point, this is the first noun, so we should have returned earlier
-            // This is a safety check
+            // No entry point but nouns exist - corrupted state, recover by using this item
+            // This shouldn't normally happen as first item sets entry point above
             this.entryPointId = id;
             this.maxLevel = nounLevel;
             this.nouns.set(id, noun);
@@ -220,7 +219,7 @@ export class HNSWIndex {
         }
         const entryPoint = this.nouns.get(this.entryPointId);
         if (!entryPoint) {
-            console.error(`Entry point with ID ${this.entryPointId} not found`);
+            // Entry point was deleted but ID not updated - recover by using new item
             // If the entry point doesn't exist, treat this as the first noun
             this.entryPointId = id;
             this.maxLevel = nounLevel;
@@ -383,6 +382,27 @@ export class HNSWIndex {
         }
         return id;
     }
+    /**
+     * O(1) entry point recovery using highLevelNodes index (v6.2.3).
+     * At any reasonable scale (1000+ nodes), level 2+ nodes are guaranteed to exist.
+     * For tiny indexes with only level 0-1 nodes, any node works as entry point.
+     */
+    recoverEntryPointO1() {
+        // O(1) recovery: check highLevelNodes from highest to lowest level
+        for (let level = this.MAX_TRACKED_LEVELS; level >= 2; level--) {
+            const nodesAtLevel = this.highLevelNodes.get(level);
+            if (nodesAtLevel && nodesAtLevel.size > 0) {
+                for (const nodeId of nodesAtLevel) {
+                    if (this.nouns.has(nodeId)) {
+                        return { id: nodeId, level };
+                    }
+                }
+            }
+        }
+        // No high-level nodes - use any available node (works fine for HNSW)
+        const firstNode = this.nouns.keys().next().value;
+        return { id: firstNode ?? null, level: 0 };
+    }
     /**
      * Search for nearest neighbors
      */
@@ -398,14 +418,33 @@ export class HNSWIndex {
             throw new Error(`Query vector dimension mismatch: expected ${this.dimension}, got ${queryVector.length}`);
         }
         // Start from the entry point
+        // If entry point is null but nouns exist, attempt O(1) recovery (v6.2.3)
+        if (!this.entryPointId && this.nouns.size > 0) {
+            const { id: recoveredId, level: recoveredLevel } = this.recoverEntryPointO1();
+            if (recoveredId) {
+                this.entryPointId = recoveredId;
+                this.maxLevel = recoveredLevel;
+            }
+        }
         if (!this.entryPointId) {
-            console.error('Entry point ID is null');
+            // Truly empty index - return empty results silently
             return [];
         }
-        const entryPoint = this.nouns.get(this.entryPointId);
+        let entryPoint = this.nouns.get(this.entryPointId);
         if (!entryPoint) {
-            console.error(`Entry point with ID ${this.entryPointId} not found`);
-            return [];
+            // Entry point ID exists but noun was deleted - O(1) recovery (v6.2.3)
+            if (this.nouns.size > 0) {
+                const { id: recoveredId, level: recoveredLevel } = this.recoverEntryPointO1();
+                if (recoveredId) {
+                    this.entryPointId = recoveredId;
+                    this.maxLevel = recoveredLevel;
+                    entryPoint = this.nouns.get(recoveredId);
+                }
+            }
+            // If still no entry point, return empty
+            if (!entryPoint) {
+                return [];
+            }
         }
         let currObj = entryPoint;
         // OPTIMIZATION: Preload entry point vector
@@ -915,6 +954,40 @@ export class HNSWIndex {
                     offset += batchSize; // v5.7.11: Increment offset for next page
                 }
             }
+            // Step 5: CRITICAL - Recover entry point if missing (v6.2.3 - O(1))
+            // This ensures consistency even if getHNSWSystem() returned null
+            if (this.nouns.size > 0 && this.entryPointId === null) {
+                prodLog.warn('HNSW rebuild: Entry point was null after loading nouns - recovering with O(1) lookup');
+                const { id: recoveredId, level: recoveredLevel } = this.recoverEntryPointO1();
+                this.entryPointId = recoveredId;
+                this.maxLevel = recoveredLevel;
+                prodLog.info(`HNSW entry point recovered: ${recoveredId} at level ${recoveredLevel}`);
+                // Persist recovered state to prevent future recovery
+                if (this.storage && recoveredId) {
+                    await this.storage.saveHNSWSystem({
+                        entryPointId: this.entryPointId,
+                        maxLevel: this.maxLevel
+                    }).catch((error) => {
+                        prodLog.error('Failed to persist recovered HNSW system data:', error);
+                    });
+                }
+            }
+            // Step 6: Validate entry point exists if set (handles stale/deleted entry point)
+            if (this.entryPointId && !this.nouns.has(this.entryPointId)) {
+                prodLog.warn(`HNSW: Entry point ${this.entryPointId} not found in loaded nouns - recovering with O(1) lookup`);
+                const { id: recoveredId, level: recoveredLevel } = this.recoverEntryPointO1();
+                this.entryPointId = recoveredId;
+                this.maxLevel = recoveredLevel;
+                // Persist corrected state
+                if (this.storage && recoveredId) {
+                    await this.storage.saveHNSWSystem({
+                        entryPointId: this.entryPointId,
+                        maxLevel: this.maxLevel
+                    }).catch((error) => {
+                        prodLog.error('Failed to persist corrected HNSW system data:', error);
+                    });
+                }
+            }
             const cacheInfo = shouldPreload
                 ? ` (vectors preloaded)`
                 : ` (adaptive caching - vectors loaded on-demand)`;

package/dist/index.d.ts

@@ -51,9 +51,8 @@ export { StorageAugmentation, DynamicStorageAugmentation, MemoryStorageAugmentat
 export { WebSocketConduitAugmentation };
 import type { Vector, VectorDocument, SearchResult, DistanceFunction, EmbeddingFunction, EmbeddingModel, HNSWNoun, HNSWVerb, HNSWConfig, StorageAdapter } from './coreTypes.js';
 import { HNSWIndex } from './hnsw/hnswIndex.js';
-import { HNSWIndexOptimized, HNSWOptimizedConfig } from './hnsw/hnswIndexOptimized.js';
-export { HNSWIndex, HNSWIndexOptimized };
-export type { Vector, VectorDocument, SearchResult, DistanceFunction, EmbeddingFunction, EmbeddingModel, HNSWNoun, HNSWVerb, HNSWConfig, HNSWOptimizedConfig, StorageAdapter };
+export { HNSWIndex };
+export type { Vector, VectorDocument, SearchResult, DistanceFunction, EmbeddingFunction, EmbeddingModel, HNSWNoun, HNSWVerb, HNSWConfig, StorageAdapter };
 import type { AugmentationResponse, BrainyAugmentation, BaseAugmentation, AugmentationContext } from './types/augmentations.js';
 export { AugmentationManager, type AugmentationInfo } from './augmentationManager.js';
 export type { AugmentationResponse, BrainyAugmentation, BaseAugmentation, AugmentationContext };

package/dist/index.js

@@ -111,10 +111,9 @@ MemoryStorageAugmentation, FileSystemStorageAugmentation, OPFSStorageAugmentatio
 createAutoStorageAugmentation, createStorageAugmentationFromConfig };
 // Other augmentation exports
 export { WebSocketConduitAugmentation };
-// Export HNSW index and optimized version
+// Export HNSW index
 import { HNSWIndex } from './hnsw/hnswIndex.js';
-import { HNSWIndexOptimized } from './hnsw/hnswIndexOptimized.js';
-export { HNSWIndex, HNSWIndexOptimized };
+export { HNSWIndex };
 // Export augmentation manager for type-safe augmentation management
 export { AugmentationManager } from './augmentationManager.js';
 import { NounType, VerbType } from './types/graphTypes.js';

package/dist/storage/adapters/azureBlobStorage.js

@@ -1269,7 +1269,15 @@ export class AzureBlobStorage extends BaseStorage {
             return JSON.parse(downloaded.toString());
         }
         catch (error) {
-            if (error.statusCode === 404 || error.code === 'BlobNotFound') {
+            // Azure may return not found errors in different formats
+            const isNotFound = error.statusCode === 404 ||
+                error.code === 'BlobNotFound' ||
+                error.code === 404 ||
+                error.details?.code === 'BlobNotFound' ||
+                error.message?.includes('BlobNotFound') ||
+                error.message?.includes('not found') ||
+                error.message?.includes('404');
+            if (isNotFound) {
                 return null;
             }
             this.logger.error('Failed to get HNSW system data:', error);

package/dist/storage/adapters/gcsStorage.js

@@ -1260,7 +1260,14 @@ export class GcsStorage extends BaseStorage {
             return JSON.parse(contents.toString());
         }
         catch (error) {
-            if (error.code === 404) {
+            // GCS may return 404 in different formats depending on SDK version
+            const is404 = error.code === 404 ||
+                error.statusCode === 404 ||
+                error.status === 404 ||
+                error.message?.includes('No such object') ||
+                error.message?.includes('not found') ||
+                error.message?.includes('404');
+            if (is404) {
                 return null;
             }
             this.logger.error('Failed to get HNSW system data:', error);

package/dist/storage/adapters/s3CompatibleStorage.js

@@ -2829,9 +2829,14 @@ export class S3CompatibleStorage extends BaseStorage {
             return JSON.parse(bodyContents);
         }
         catch (error) {
-            if (error.name === 'NoSuchKey' ||
+            // S3 may return not found errors in different formats
+            const isNotFound = error.name === 'NoSuchKey' ||
+                error.code === 'NoSuchKey' ||
+                error.$metadata?.httpStatusCode === 404 ||
                 error.message?.includes('NoSuchKey') ||
-                error.message?.includes('not found')) {
+                error.message?.includes('not found') ||
+                error.message?.includes('404');
+            if (isNotFound) {
                 return null;
             }
             this.logger.error('Failed to get HNSW system data:', error);

package/dist/triple/TripleIntelligenceSystem.d.ts

@@ -13,7 +13,6 @@
  * - Fusion: O(k log k) where k = result count
  */
 import { HNSWIndex } from '../hnsw/hnswIndex.js';
-import { HNSWIndexOptimized } from '../hnsw/hnswIndexOptimized.js';
 import { TypeAwareHNSWIndex } from '../hnsw/typeAwareHNSWIndex.js';
 import { MetadataIndexManager } from '../utils/metadataIndex.js';
 import { Vector } from '../coreTypes.js';
@@ -68,7 +67,7 @@ export declare class TripleIntelligenceSystem {
     private planner;
     private embedder;
     private storage;
-    constructor(metadataIndex: MetadataIndexManager, hnswIndex: HNSWIndex | HNSWIndexOptimized | TypeAwareHNSWIndex, graphIndex: GraphAdjacencyIndex, embedder: (text: string) => Promise<Vector>, storage: any);
+    constructor(metadataIndex: MetadataIndexManager, hnswIndex: HNSWIndex | TypeAwareHNSWIndex, graphIndex: GraphAdjacencyIndex, embedder: (text: string) => Promise<Vector>, storage: any);
     /**
      * Main find method - executes Triple Intelligence queries
      * Phase 3: Now with automatic type inference for 40% latency reduction

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@soulcraft/brainy",
-  "version": "6.2.1",
+  "version": "6.2.2",
   "description": "Universal Knowledge Protocol™ - World's first Triple Intelligence database unifying vector, graph, and document search in one API. Stage 3 CANONICAL: 42 nouns × 127 verbs covering 96-97% of all human knowledge.",
   "main": "dist/index.js",
   "module": "dist/index.js",

package/dist/augmentations/KnowledgeAugmentation.d.ts

@@ -1,40 +0,0 @@
-/**
- * Knowledge Layer Augmentation for VFS
- *
- * Adds intelligent features to VFS without modifying core functionality:
- * - Event recording for all operations
- * - Semantic versioning based on content changes
- * - Entity and concept extraction
- * - Git bridge for import/export
- *
- * This is a TRUE augmentation - VFS works perfectly without it
- */
-import { Brainy } from '../brainy.js';
-import { BaseAugmentation } from './brainyAugmentation.js';
-export declare class KnowledgeAugmentation extends BaseAugmentation {
-    name: string;
-    timing: 'after';
-    metadata: 'none';
-    operations: any;
-    priority: number;
-    constructor(config?: any);
-    execute<T = any>(operation: string, params: any, next: () => Promise<T>): Promise<T>;
-    private eventRecorder?;
-    private semanticVersioning?;
-    private entitySystem?;
-    private conceptSystem?;
-    private gitBridge?;
-    private originalMethods;
-    initialize(context: any): Promise<void>;
-    augment(brain: Brainy): Promise<void>;
-    /**
-     * Wrap a VFS method to add Knowledge Layer functionality
-     */
-    private wrapMethod;
-    /**
-     * Add Knowledge Layer methods to VFS
-     */
-    private addKnowledgeMethods;
-    private isSemanticChange;
-    cleanup(brain: Brainy): Promise<void>;
-}

package/dist/augmentations/KnowledgeAugmentation.js

@@ -1,251 +0,0 @@
-/**
- * Knowledge Layer Augmentation for VFS
- *
- * Adds intelligent features to VFS without modifying core functionality:
- * - Event recording for all operations
- * - Semantic versioning based on content changes
- * - Entity and concept extraction
- * - Git bridge for import/export
- *
- * This is a TRUE augmentation - VFS works perfectly without it
- */
-import { BaseAugmentation } from './brainyAugmentation.js';
-import { EventRecorder } from '../vfs/EventRecorder.js';
-import { SemanticVersioning } from '../vfs/SemanticVersioning.js';
-import { PersistentEntitySystem } from '../vfs/PersistentEntitySystem.js';
-import { ConceptSystem } from '../vfs/ConceptSystem.js';
-import { GitBridge } from '../vfs/GitBridge.js';
-export class KnowledgeAugmentation extends BaseAugmentation {
-    constructor(config = {}) {
-        super(config);
-        this.name = 'knowledge';
-        this.timing = 'after'; // Process after VFS operations
-        this.metadata = 'none'; // No metadata access needed
-        this.operations = []; // VFS-specific augmentation, no operation interception
-        this.priority = 100; // Run last
-        this.originalMethods = new Map();
-    }
-    async execute(operation, params, next) {
-        // Pass through - this augmentation works at VFS level, not operation level
-        return await next();
-    }
-    async initialize(context) {
-        await this.augment(context.brain);
-    }
-    async augment(brain) {
-        // Only augment if VFS exists
-        const vfs = brain.vfs?.();
-        if (!vfs) {
-            console.warn('KnowledgeAugmentation: VFS not found, skipping');
-            return;
-        }
-        // Initialize Knowledge Layer components
-        this.eventRecorder = new EventRecorder(brain);
-        this.semanticVersioning = new SemanticVersioning(brain);
-        this.entitySystem = new PersistentEntitySystem(brain);
-        this.conceptSystem = new ConceptSystem(brain);
-        this.gitBridge = new GitBridge(vfs, brain);
-        // Wrap VFS methods to add intelligence WITHOUT slowing them down
-        this.wrapMethod(vfs, 'writeFile', async (original, path, data, options) => {
-            // Call original first (stays fast)
-            const result = await original.call(vfs, path, data, options);
-            // Knowledge processing in background (non-blocking)
-            setImmediate(async () => {
-                try {
-                    // Record event
-                    if (this.eventRecorder) {
-                        await this.eventRecorder.recordEvent({
-                            type: 'write',
-                            path,
-                            content: data,
-                            size: data.length,
-                            author: options?.author || 'system'
-                        });
-                    }
-                    // Check for semantic versioning
-                    if (this.semanticVersioning) {
-                        const existingContent = await vfs.readFile(path).catch(() => null);
-                        const shouldVersion = existingContent && this.isSemanticChange(existingContent, data);
-                        if (shouldVersion) {
-                            await this.semanticVersioning.createVersion(path, data, {
-                                message: 'Automatic semantic version'
-                            });
-                        }
-                    }
-                    // Extract concepts
-                    if (this.conceptSystem && options?.extractConcepts !== false) {
-                        await this.conceptSystem.extractAndLinkConcepts(path, data);
-                    }
-                    // Extract entities
-                    if (this.entitySystem && options?.extractEntities !== false) {
-                        await this.entitySystem.extractEntities(data.toString('utf8'), data);
-                    }
-                }
-                catch (error) {
-                    // Knowledge Layer errors should not affect VFS operations
-                    console.debug('KnowledgeLayer background processing error:', error);
-                }
-            });
-            return result;
-        });
-        this.wrapMethod(vfs, 'unlink', async (original, path) => {
-            const result = await original.call(vfs, path);
-            // Record deletion event
-            setImmediate(async () => {
-                if (this.eventRecorder) {
-                    await this.eventRecorder.recordEvent({
-                        type: 'delete',
-                        path,
-                        author: 'system'
-                    });
-                }
-            });
-            return result;
-        });
-        this.wrapMethod(vfs, 'rename', async (original, oldPath, newPath) => {
-            const result = await original.call(vfs, oldPath, newPath);
-            // Record rename event
-            setImmediate(async () => {
-                if (this.eventRecorder) {
-                    await this.eventRecorder.recordEvent({
-                        type: 'rename',
-                        path: oldPath,
-                        metadata: { newPath },
-                        author: 'system'
-                    });
-                }
-            });
-            return result;
-        });
-        // Add Knowledge Layer methods to VFS
-        this.addKnowledgeMethods(vfs);
-        console.log('✨ Knowledge Layer augmentation enabled');
-    }
-    /**
-     * Wrap a VFS method to add Knowledge Layer functionality
-     */
-    wrapMethod(vfs, methodName, wrapper) {
-        const original = vfs[methodName];
-        if (!original)
-            return;
-        // Store original for cleanup
-        this.originalMethods.set(methodName, original);
-        // Replace with wrapped version
-        vfs[methodName] = async (...args) => {
-            return await wrapper(original, ...args);
-        };
-    }
-    /**
-     * Add Knowledge Layer methods to VFS
-     */
-    addKnowledgeMethods(vfs) {
-        // Event history
-        vfs.getHistory = async (path, options) => {
-            if (!this.eventRecorder)
-                throw new Error('Knowledge Layer not initialized');
-            return await this.eventRecorder.getHistory(path, options);
-        };
-        vfs.reconstructAtTime = async (path, timestamp) => {
-            if (!this.eventRecorder)
-                throw new Error('Knowledge Layer not initialized');
-            return await this.eventRecorder.reconstructFileAtTime(path, timestamp);
-        };
-        // Semantic versioning
-        vfs.getVersions = async (path) => {
-            if (!this.semanticVersioning)
-                throw new Error('Knowledge Layer not initialized');
-            return await this.semanticVersioning.getVersions(path);
-        };
-        vfs.restoreVersion = async (path, versionId) => {
-            if (!this.semanticVersioning)
-                throw new Error('Knowledge Layer not initialized');
-            const version = await this.semanticVersioning.getVersion(path, versionId);
-            if (version) {
-                await vfs.writeFile(path, version);
-            }
-        };
-        // Entities
-        vfs.findEntity = async (query) => {
-            if (!this.entitySystem)
-                throw new Error('Knowledge Layer not initialized');
-            return await this.entitySystem.findEntity(query);
-        };
-        vfs.getEntityAppearances = async (entityId) => {
-            if (!this.entitySystem)
-                throw new Error('Knowledge Layer not initialized');
-            return await this.entitySystem.getEvolution(entityId);
-        };
-        // Concepts
-        vfs.getConcepts = async (path) => {
-            if (!this.conceptSystem)
-                throw new Error('Knowledge Layer not initialized');
-            const concepts = await this.conceptSystem.findConcepts({ manifestedIn: path });
-            return concepts;
-        };
-        vfs.getConceptGraph = async (options) => {
-            if (!this.conceptSystem)
-                throw new Error('Knowledge Layer not initialized');
-            return await this.conceptSystem.getConceptGraph(options);
-        };
-        // Git bridge
-        vfs.exportToGit = async (vfsPath, gitPath) => {
-            if (!this.gitBridge)
-                throw new Error('Knowledge Layer not initialized');
-            return await this.gitBridge.exportToGit(vfsPath, gitPath);
-        };
-        vfs.importFromGit = async (gitPath, vfsPath) => {
-            if (!this.gitBridge)
-                throw new Error('Knowledge Layer not initialized');
-            return await this.gitBridge.importFromGit(gitPath, vfsPath);
-        };
-        // Temporal coupling
-        vfs.findTemporalCoupling = async (path, windowMs) => {
-            if (!this.eventRecorder)
-                throw new Error('Knowledge Layer not initialized');
-            return await this.eventRecorder.findTemporalCoupling(path, windowMs);
-        };
-    }
-    isSemanticChange(oldContent, newContent) {
-        // Simple heuristic - significant size change or different content
-        const oldStr = oldContent.toString('utf8');
-        const newStr = newContent.toString('utf8');
-        // Check for significant size change (>10%)
-        const sizeDiff = Math.abs(oldStr.length - newStr.length) / oldStr.length;
-        if (sizeDiff > 0.1)
-            return true;
-        // Check for structural changes (simplified)
-        const oldLines = oldStr.split('\n').filter(l => l.trim());
-        const newLines = newStr.split('\n').filter(l => l.trim());
-        // Different number of non-empty lines
-        return Math.abs(oldLines.length - newLines.length) > 5;
-    }
-    async cleanup(brain) {
-        const vfs = brain.vfs?.();
-        if (!vfs)
-            return;
-        // Restore original methods
-        for (const [methodName, original] of this.originalMethods) {
-            vfs[methodName] = original;
-        }
-        // Remove added methods
-        delete vfs.getHistory;
-        delete vfs.reconstructAtTime;
-        delete vfs.getVersions;
-        delete vfs.restoreVersion;
-        delete vfs.findEntity;
-        delete vfs.getEntityAppearances;
-        delete vfs.getConcepts;
-        delete vfs.getConceptGraph;
-        delete vfs.exportToGit;
-        delete vfs.importFromGit;
-        delete vfs.findTemporalCoupling;
-        // Clean up components
-        this.eventRecorder = undefined;
-        this.semanticVersioning = undefined;
-        this.entitySystem = undefined;
-        this.conceptSystem = undefined;
-        this.gitBridge = undefined;
-        console.log('Knowledge Layer augmentation removed');
-    }
-}
-//# sourceMappingURL=KnowledgeAugmentation.js.map

package/dist/importManager.d.ts

@@ -1,78 +0,0 @@
-/**
- * Import Manager - Comprehensive data import with intelligent type detection
- *
- * Handles multiple data sources:
- * - Direct data (objects, arrays)
- * - Files (JSON, CSV, text)
- * - URLs (fetch and parse)
- * - Streams (for large files)
- *
- * Uses NeuralImportAugmentation for intelligent processing
- */
-import { NounType } from './types/graphTypes.js';
-export interface ImportOptions {
-    source?: 'data' | 'file' | 'url' | 'auto';
-    format?: 'json' | 'csv' | 'text' | 'yaml' | 'auto';
-    batchSize?: number;
-    autoDetect?: boolean;
-    typeHint?: NounType;
-    extractRelationships?: boolean;
-    csvDelimiter?: string;
-    csvHeaders?: boolean;
-    parallel?: boolean;
-    maxConcurrency?: number;
-}
-export interface ImportResult {
-    success: boolean;
-    nouns: string[];
-    verbs: string[];
-    errors: string[];
-    stats: {
-        total: number;
-        imported: number;
-        failed: number;
-        relationships: number;
-    };
-}
-export declare class ImportManager {
-    private neuralImport;
-    private typeMatcher;
-    private brain;
-    constructor(brain: any);
-    /**
-     * Initialize the import manager
-     */
-    init(): Promise<void>;
-    /**
-     * Main import method - handles all sources
-     */
-    import(source: string | Buffer | any[] | any, options?: ImportOptions): Promise<ImportResult>;
-    /**
-     * Import from file
-     */
-    importFile(filePath: string, options?: ImportOptions): Promise<ImportResult>;
-    /**
-     * Import from URL
-     */
-    importUrl(url: string, options?: ImportOptions): Promise<ImportResult>;
-    /**
-     * Detect source type
-     */
-    private detectSourceType;
-    /**
-     * Detect format from file path
-     */
-    private detectFormatFromPath;
-    /**
-     * Read file
-     */
-    private readFile;
-    /**
-     * Fetch from URL
-     */
-    private fetchFromUrl;
-}
-/**
- * Create an import manager instance
- */
-export declare function createImportManager(brain: any): ImportManager;