@soulcraft/brainy 3.20.1 → 3.20.3

package/dist/augmentationRegistryLoader.js

@@ -1,213 +0,0 @@
-/**
- * Augmentation Registry Loader
- *
- * This module provides functionality for loading augmentation registrations
- * at build time. It's designed to be used with build tools like webpack or rollup
- * to automatically discover and register augmentations.
- */
-import { registerAugmentation } from './augmentationRegistry.js';
-/**
- * Default options for the augmentation registry loader
- */
-const DEFAULT_OPTIONS = {
-    autoInitialize: false,
-    debug: false
-};
-/**
- * Loads augmentations from the specified modules
- *
- * This function is designed to be used with build tools like webpack or rollup
- * to automatically discover and register augmentations.
- *
- * @param modules An object containing modules with augmentations to register
- * @param options Options for the loader
- * @returns A promise that resolves with the result of loading the augmentations
- *
- * @example
- * ```typescript
- * // webpack.config.js
- * const { AugmentationRegistryPlugin } = require('brainy/dist/webpack');
- *
- * module.exports = {
- *   // ... other webpack config
- *   plugins: [
- *     new AugmentationRegistryPlugin({
- *       // Pattern to match files containing augmentations
- *       pattern: /augmentation\.js$/,
- *       // Options for the loader
- *       options: {
- *         autoInitialize: true,
- *         debug: true
- *       }
- *     })
- *   ]
- * };
- * ```
- */
-export async function loadAugmentationsFromModules(modules, options = {}) {
-    const opts = { ...DEFAULT_OPTIONS, ...options };
-    const result = {
-        augmentations: [],
-        errors: []
-    };
-    if (opts.debug) {
-        console.log(`[AugmentationRegistryLoader] Loading augmentations from ${Object.keys(modules).length} modules`);
-    }
-    // Process each module
-    for (const [modulePath, module] of Object.entries(modules)) {
-        try {
-            if (opts.debug) {
-                console.log(`[AugmentationRegistryLoader] Processing module: ${modulePath}`);
-            }
-            // Extract augmentations from the module
-            const augmentations = extractAugmentationsFromModule(module);
-            if (augmentations.length === 0) {
-                if (opts.debug) {
-                    console.log(`[AugmentationRegistryLoader] No augmentations found in module: ${modulePath}`);
-                }
-                continue;
-            }
-            // Register each augmentation
-            for (const augmentation of augmentations) {
-                try {
-                    const registered = registerAugmentation(augmentation);
-                    result.augmentations.push(registered);
-                    if (opts.debug) {
-                        console.log(`[AugmentationRegistryLoader] Registered augmentation: ${registered.name}`);
-                    }
-                }
-                catch (error) {
-                    const err = error instanceof Error ? error : new Error(String(error));
-                    result.errors.push(err);
-                    if (opts.debug) {
-                        console.error(`[AugmentationRegistryLoader] Failed to register augmentation: ${err.message}`);
-                    }
-                }
-            }
-        }
-        catch (error) {
-            const err = error instanceof Error ? error : new Error(String(error));
-            result.errors.push(err);
-            if (opts.debug) {
-                console.error(`[AugmentationRegistryLoader] Error processing module ${modulePath}: ${err.message}`);
-            }
-        }
-    }
-    if (opts.debug) {
-        console.log(`[AugmentationRegistryLoader] Loaded ${result.augmentations.length} augmentations with ${result.errors.length} errors`);
-    }
-    return result;
-}
-/**
- * Extracts augmentations from a module
- *
- * @param module The module to extract augmentations from
- * @returns An array of augmentations found in the module
- */
-function extractAugmentationsFromModule(module) {
-    const augmentations = [];
-    // If the module itself is an augmentation, add it
-    if (isAugmentation(module)) {
-        augmentations.push(module);
-    }
-    // Check for exported augmentations
-    if (module && typeof module === 'object') {
-        for (const key of Object.keys(module)) {
-            const exported = module[key];
-            // Skip non-objects and null
-            if (!exported || typeof exported !== 'object') {
-                continue;
-            }
-            // If the exported value is an augmentation, add it
-            if (isAugmentation(exported)) {
-                augmentations.push(exported);
-            }
-            // If the exported value is an array of augmentations, add them
-            if (Array.isArray(exported) && exported.every(isAugmentation)) {
-                augmentations.push(...exported);
-            }
-        }
-    }
-    return augmentations;
-}
-/**
- * Checks if an object is an augmentation
- *
- * @param obj The object to check
- * @returns True if the object is an augmentation
- */
-function isAugmentation(obj) {
-    return (obj &&
-        typeof obj === 'object' &&
-        typeof obj.name === 'string' &&
-        typeof obj.initialize === 'function' &&
-        typeof obj.shutDown === 'function' &&
-        typeof obj.getStatus === 'function');
-}
-/**
- * Creates a webpack plugin for automatically loading augmentations
- *
- * @param options Options for the plugin
- * @returns A webpack plugin
- *
- * @example
- * ```typescript
- * // webpack.config.js
- * const { createAugmentationRegistryPlugin } = require('brainy/dist/webpack');
- *
- * module.exports = {
- *   // ... other webpack config
- *   plugins: [
- *     createAugmentationRegistryPlugin({
- *       pattern: /augmentation\.js$/,
- *       options: {
- *         autoInitialize: true,
- *         debug: true
- *       }
- *     })
- *   ]
- * };
- * ```
- */
-export function createAugmentationRegistryPlugin(options) {
-    // This is just a placeholder - the actual implementation would depend on the build tool
-    return {
-        name: 'AugmentationRegistryPlugin',
-        pattern: options.pattern,
-        options: options.options || {}
-    };
-}
-/**
- * Creates a rollup plugin for automatically loading augmentations
- *
- * @param options Options for the plugin
- * @returns A rollup plugin
- *
- * @example
- * ```typescript
- * // rollup.config.js
- * import { createAugmentationRegistryRollupPlugin } from 'brainy/dist/rollup';
- *
- * export default {
- *   // ... other rollup config
- *   plugins: [
- *     createAugmentationRegistryRollupPlugin({
- *       pattern: /augmentation\.js$/,
- *       options: {
- *         autoInitialize: true,
- *         debug: true
- *       }
- *     })
- *   ]
- * };
- * ```
- */
-export function createAugmentationRegistryRollupPlugin(options) {
-    // This is just a placeholder - the actual implementation would depend on the build tool
-    return {
-        name: 'augmentation-registry-rollup-plugin',
-        pattern: options.pattern,
-        options: options.options || {}
-    };
-}
-//# sourceMappingURL=augmentationRegistryLoader.js.map

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/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 {};