@soulcraft/brainy 3.20.2 → 3.20.4

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/augmentations/intelligentVerbScoring.d.ts

@@ -1,158 +0,0 @@
-import { ICognitionAugmentation, AugmentationResponse } from '../types/augmentations.js';
-/**
- * Configuration options for the Intelligent Verb Scoring augmentation
- */
-export interface IVerbScoringConfig {
-    /** Enable semantic proximity scoring based on entity embeddings */
-    enableSemanticScoring: boolean;
-    /** Enable frequency-based weight amplification */
-    enableFrequencyAmplification: boolean;
-    /** Enable temporal decay for weights */
-    enableTemporalDecay: boolean;
-    /** Decay rate per day for temporal scoring (0-1) */
-    temporalDecayRate: number;
-    /** Minimum weight threshold */
-    minWeight: number;
-    /** Maximum weight threshold */
-    maxWeight: number;
-    /** Base confidence score for new relationships */
-    baseConfidence: number;
-    /** Learning rate for adaptive scoring (0-1) */
-    learningRate: number;
-}
-/**
- * Default configuration for the Intelligent Verb Scoring augmentation
- */
-export declare const DEFAULT_VERB_SCORING_CONFIG: IVerbScoringConfig;
-/**
- * Relationship statistics for learning and adaptation
- */
-interface RelationshipStats {
-    count: number;
-    totalWeight: number;
-    averageWeight: number;
-    lastSeen: Date;
-    firstSeen: Date;
-    semanticSimilarity?: number;
-}
-/**
- * Intelligent Verb Scoring Cognition Augmentation
- *
- * Automatically generates intelligent weight and confidence scores for verb relationships
- * using semantic analysis, frequency patterns, and temporal factors.
- */
-export declare class IntelligentVerbScoring implements ICognitionAugmentation {
-    readonly name = "intelligent-verb-scoring";
-    readonly description = "Automatically generates intelligent weight and confidence scores for verb relationships";
-    enabled: boolean;
-    private config;
-    private relationshipStats;
-    private brainyInstance;
-    private isInitialized;
-    constructor(config?: Partial<IVerbScoringConfig>);
-    initialize(): Promise<void>;
-    shutDown(): Promise<void>;
-    getStatus(): Promise<'active' | 'inactive' | 'error'>;
-    /**
-     * Set reference to the BrainyData instance for accessing graph data
-     */
-    setBrainyInstance(instance: any): void;
-    /**
-     * Main reasoning method for generating intelligent verb scores
-     */
-    reason(query: string, context?: Record<string, unknown>): AugmentationResponse<{
-        inference: string;
-        confidence: number;
-    }>;
-    infer(dataSubset: Record<string, unknown>): AugmentationResponse<Record<string, unknown>>;
-    executeLogic(ruleId: string, input: Record<string, unknown>): AugmentationResponse<boolean>;
-    /**
-     * Generate intelligent weight and confidence scores for a verb relationship
-     *
-     * @param sourceId - ID of the source entity
-     * @param targetId - ID of the target entity
-     * @param verbType - Type of the relationship
-     * @param existingWeight - Existing weight if any
-     * @param metadata - Additional metadata about the relationship
-     * @returns Computed weight and confidence scores
-     */
-    computeVerbScores(sourceId: string, targetId: string, verbType: string, existingWeight?: number, metadata?: any): Promise<{
-        weight: number;
-        confidence: number;
-        reasoning: string[];
-    }>;
-    /**
-     * Calculate semantic similarity between two entities using their embeddings
-     */
-    private calculateSemanticScore;
-    /**
-     * Calculate frequency-based boost for repeated relationships
-     */
-    private calculateFrequencyBoost;
-    /**
-     * Calculate temporal decay factor based on recency
-     */
-    private calculateTemporalFactor;
-    /**
-     * Calculate learning-based adjustment using historical patterns
-     */
-    private calculateLearningAdjustment;
-    /**
-     * Update relationship statistics for learning
-     */
-    private updateRelationshipStats;
-    /**
-     * Blend two scores using a weighted average
-     */
-    private blendScores;
-    /**
-     * Get current configuration
-     */
-    getConfig(): IVerbScoringConfig;
-    /**
-     * Update configuration
-     */
-    updateConfig(newConfig: Partial<IVerbScoringConfig>): void;
-    /**
-     * Get relationship statistics (for debugging/monitoring)
-     */
-    getRelationshipStats(): Map<string, RelationshipStats>;
-    /**
-     * Clear relationship statistics
-     */
-    clearStats(): void;
-    /**
-     * Provide feedback to improve future scoring
-     * This allows the system to learn from user corrections or validation
-     *
-     * @param sourceId - Source entity ID
-     * @param targetId - Target entity ID
-     * @param verbType - Relationship type
-     * @param feedbackWeight - The corrected/validated weight (0-1)
-     * @param feedbackConfidence - The corrected/validated confidence (0-1)
-     * @param feedbackType - Type of feedback ('correction', 'validation', 'enhancement')
-     */
-    provideFeedback(sourceId: string, targetId: string, verbType: string, feedbackWeight: number, feedbackConfidence?: number, feedbackType?: 'correction' | 'validation' | 'enhancement'): Promise<void>;
-    /**
-     * Get learning statistics for monitoring and debugging
-     */
-    getLearningStats(): {
-        totalRelationships: number;
-        averageConfidence: number;
-        feedbackCount: number;
-        topRelationships: Array<{
-            relationship: string;
-            count: number;
-            averageWeight: number;
-        }>;
-    };
-    /**
-     * Export learning data for backup or analysis
-     */
-    exportLearningData(): string;
-    /**
-     * Import learning data from backup
-     */
-    importLearningData(jsonData: string): void;
-}
-export {};