@soulcraft/brainy 3.20.2 → 3.20.3

package/dist/vfs/KnowledgeAugmentation.d.ts

@@ -1,104 +0,0 @@
-/**
- * Knowledge Augmentation
- *
- * Main orchestrator for the Knowledge Layer that coordinates all knowledge systems
- * and enhances the VFS with intelligent capabilities
- */
-import { Brainy } from '../brainy.js';
-import { VirtualFileSystem } from './VirtualFileSystem.js';
-import { EventRecorder } from './EventRecorder.js';
-import { SemanticVersioning } from './SemanticVersioning.js';
-import { PersistentEntitySystem } from './PersistentEntitySystem.js';
-import { ConceptSystem } from './ConceptSystem.js';
-import { GitBridge } from './GitBridge.js';
-export interface KnowledgeAugmentationConfig {
-    enabled: boolean;
-    eventRecording?: {
-        enabled: boolean;
-        maxEvents?: number;
-    };
-    semanticVersioning?: {
-        enabled: boolean;
-        maxVersions?: number;
-    };
-    entitySystem?: {
-        enabled: boolean;
-        autoExtract?: boolean;
-    };
-    conceptSystem?: {
-        enabled: boolean;
-        autoExtract?: boolean;
-    };
-    gitBridge?: {
-        enabled: boolean;
-        autoSync?: boolean;
-    };
-}
-export declare class KnowledgeAugmentation {
-    private brain;
-    private vfs;
-    private config;
-    private eventRecorder?;
-    private semanticVersioning?;
-    private entitySystem?;
-    private conceptSystem?;
-    private gitBridge?;
-    private enabled;
-    constructor(config: KnowledgeAugmentationConfig);
-    /**
-     * Initialize the Knowledge Augmentation with Brainy instance
-     */
-    init(brain: Brainy, vfs: VirtualFileSystem): Promise<void>;
-    /**
-     * Enable the Knowledge Augmentation
-     */
-    enable(): Promise<void>;
-    /**
-     * Disable the Knowledge Augmentation
-     */
-    disable(): Promise<void>;
-    /**
-     * Check if the knowledge augmentation is enabled
-     */
-    isEnabled(): boolean;
-    /**
-     * Get the EventRecorder instance
-     */
-    getEventRecorder(): EventRecorder | undefined;
-    /**
-     * Get the SemanticVersioning instance
-     */
-    getSemanticVersioning(): SemanticVersioning | undefined;
-    /**
-     * Get the PersistentEntitySystem instance
-     */
-    getEntitySystem(): PersistentEntitySystem | undefined;
-    /**
-     * Get the ConceptSystem instance
-     */
-    getConceptSystem(): ConceptSystem | undefined;
-    /**
-     * Get the GitBridge instance
-     */
-    getGitBridge(): GitBridge | undefined;
-    /**
-     * Record a file event (called by VFS)
-     */
-    recordEvent(type: string, path: string, metadata?: any): Promise<void>;
-    /**
-     * Create a semantic version (called by VFS)
-     */
-    createVersion(path: string, content: Buffer): Promise<void>;
-    /**
-     * Extract entities from content (called by VFS)
-     */
-    extractEntities(path: string, content: string): Promise<void>;
-    /**
-     * Extract concepts from content (called by VFS)
-     */
-    extractConcepts(path: string, content: string): Promise<void>;
-    /**
-     * Enhance the VFS with knowledge methods
-     */
-    private enhanceVFS;
-}

package/dist/vfs/KnowledgeAugmentation.js

@@ -1,146 +0,0 @@
-/**
- * Knowledge Augmentation
- *
- * Main orchestrator for the Knowledge Layer that coordinates all knowledge systems
- * and enhances the VFS with intelligent capabilities
- */
-import crypto from 'crypto';
-import { EventRecorder } from './EventRecorder.js';
-import { SemanticVersioning } from './SemanticVersioning.js';
-import { PersistentEntitySystem } from './PersistentEntitySystem.js';
-import { ConceptSystem } from './ConceptSystem.js';
-import { GitBridge } from './GitBridge.js';
-export class KnowledgeAugmentation {
-    constructor(config) {
-        this.enabled = false;
-        this.config = config;
-    }
-    /**
-     * Initialize the Knowledge Augmentation with Brainy instance
-     */
-    async init(brain, vfs) {
-        this.brain = brain;
-        this.vfs = vfs;
-        if (!this.config.enabled) {
-            return;
-        }
-        // Initialize sub-systems
-        if (this.config.eventRecording?.enabled) {
-            this.eventRecorder = new EventRecorder(this.brain);
-        }
-        if (this.config.semanticVersioning?.enabled !== false) {
-            this.semanticVersioning = new SemanticVersioning(this.brain);
-        }
-        if (this.config.entitySystem?.enabled !== false) {
-            this.entitySystem = new PersistentEntitySystem(this.brain);
-        }
-        if (this.config.conceptSystem?.enabled !== false) {
-            this.conceptSystem = new ConceptSystem(this.brain);
-        }
-        if (this.config.gitBridge?.enabled !== false) {
-            this.gitBridge = new GitBridge(this.brain, this.vfs);
-        }
-        this.enabled = true;
-    }
-    /**
-     * Enable the Knowledge Augmentation
-     */
-    async enable() {
-        if (!this.brain || !this.vfs) {
-            throw new Error('Knowledge augmentation not initialized. Call init() first.');
-        }
-        this.enabled = true;
-        // Enhance VFS with knowledge methods
-        this.enhanceVFS();
-    }
-    /**
-     * Disable the Knowledge Augmentation
-     */
-    async disable() {
-        this.enabled = false;
-        // Remove VFS enhancements if any were added
-        // For now, just mark as disabled
-    }
-    /**
-     * Check if the knowledge augmentation is enabled
-     */
-    isEnabled() {
-        return this.enabled;
-    }
-    /**
-     * Get the EventRecorder instance
-     */
-    getEventRecorder() {
-        return this.eventRecorder;
-    }
-    /**
-     * Get the SemanticVersioning instance
-     */
-    getSemanticVersioning() {
-        return this.semanticVersioning;
-    }
-    /**
-     * Get the PersistentEntitySystem instance
-     */
-    getEntitySystem() {
-        return this.entitySystem;
-    }
-    /**
-     * Get the ConceptSystem instance
-     */
-    getConceptSystem() {
-        return this.conceptSystem;
-    }
-    /**
-     * Get the GitBridge instance
-     */
-    getGitBridge() {
-        return this.gitBridge;
-    }
-    /**
-     * Record a file event (called by VFS)
-     */
-    async recordEvent(type, path, metadata) {
-        if (!this.enabled || !this.eventRecorder)
-            return;
-        await this.eventRecorder.recordEvent({
-            id: crypto.randomUUID(),
-            timestamp: Date.now(),
-            type,
-            path,
-            metadata
-        });
-    }
-    /**
-     * Create a semantic version (called by VFS)
-     */
-    async createVersion(path, content) {
-        if (!this.enabled || !this.semanticVersioning)
-            return;
-        await this.semanticVersioning.createVersion(path, content);
-    }
-    /**
-     * Extract entities from content (called by VFS)
-     */
-    async extractEntities(path, content) {
-        if (!this.enabled || !this.entitySystem)
-            return;
-        await this.entitySystem.extractEntities(content, { sourcePath: path });
-    }
-    /**
-     * Extract concepts from content (called by VFS)
-     */
-    async extractConcepts(path, content) {
-        if (!this.enabled || !this.conceptSystem)
-            return;
-        await this.conceptSystem.extractConcepts(content, { sourcePath: path });
-    }
-    /**
-     * Enhance the VFS with knowledge methods
-     */
-    enhanceVFS() {
-        // For now, the VFS calls the knowledge methods directly
-        // In the future, we could add methods to the VFS prototype
-    }
-}
-//# sourceMappingURL=KnowledgeAugmentation.js.map

package/dist/vfs/KnowledgeLayer.d.ts

@@ -1,35 +0,0 @@
-/**
- * Knowledge Layer for VFS
- *
- * This is the REAL integration that makes VFS intelligent.
- * It wraps VFS operations and adds Knowledge Layer processing.
- */
-import { VirtualFileSystem } from './VirtualFileSystem.js';
-import { Brainy } from '../brainy.js';
-export declare class KnowledgeLayer {
-    private vfs;
-    private brain;
-    private eventRecorder;
-    private semanticVersioning;
-    private entitySystem;
-    private conceptSystem;
-    private gitBridge;
-    private enabled;
-    constructor(vfs: VirtualFileSystem, brain: Brainy);
-    /**
-     * Enable Knowledge Layer by wrapping VFS methods
-     */
-    enable(): Promise<void>;
-    /**
-     * Add Knowledge Layer query methods to VFS
-     */
-    private addKnowledgeMethods;
-    /**
-     * Disable Knowledge Layer
-     */
-    disable(): Promise<void>;
-}
-/**
- * Enable Knowledge Layer on a VFS instance
- */
-export declare function enableKnowledgeLayer(vfs: VirtualFileSystem, brain: Brainy): Promise<KnowledgeLayer>;