@soulcraft/brainy 3.43.1 → 3.43.2

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/types/brainyDataInterface.d.ts

@@ -1,52 +0,0 @@
-/**
- * BrainyInterface - Modern API Only
- *
- * This interface defines the MODERN methods from Brainy 3.0.
- * Used to break circular dependencies while enforcing modern API usage.
- *
- * NO DEPRECATED METHODS - Only clean, modern API patterns.
- */
-import { Vector } from '../coreTypes.js';
-import { AddParams, RelateParams, Result, Entity, FindParams, SimilarParams } from './brainy.types.js';
-export interface BrainyInterface<T = unknown> {
-    /**
-     * Initialize the database
-     */
-    init(): Promise<void>;
-    /**
-     * Modern add method - unified entity creation
-     * @param params Parameters for adding entities
-     * @returns The ID of the created entity
-     */
-    add(params: AddParams<T>): Promise<string>;
-    /**
-     * Modern relate method - unified relationship creation
-     * @param params Parameters for creating relationships
-     * @returns The ID of the created relationship
-     */
-    relate(params: RelateParams<T>): Promise<string>;
-    /**
-     * Modern find method - unified search and discovery
-     * @param query Search query or parameters object
-     * @returns Array of search results
-     */
-    find(query: string | FindParams<T>): Promise<Result<T>[]>;
-    /**
-     * Modern get method - retrieve entities by ID
-     * @param id The entity ID to retrieve
-     * @returns Entity or null if not found
-     */
-    get(id: string): Promise<Entity<T> | null>;
-    /**
-     * Modern similar method - find similar entities
-     * @param params Parameters for similarity search
-     * @returns Array of similar entities with scores
-     */
-    similar(params: SimilarParams<T>): Promise<Result<T>[]>;
-    /**
-     * Generate embedding vector from text
-     * @param text The text to embed
-     * @returns Vector representation of the text
-     */
-    embed(text: string): Promise<Vector>;
-}

package/dist/types/brainyDataInterface.js

@@ -1,10 +0,0 @@
-/**
- * BrainyInterface - Modern API Only
- *
- * This interface defines the MODERN methods from Brainy 3.0.
- * Used to break circular dependencies while enforcing modern API usage.
- *
- * NO DEPRECATED METHODS - Only clean, modern API patterns.
- */
-export {};
-//# sourceMappingURL=brainyDataInterface.js.map

package/dist/vfs/ConceptSystem.d.ts

@@ -1,203 +0,0 @@
-/**
- * Universal Concept System for VFS
- *
- * Manages concepts that transcend files and exist independently
- * Ideas that can be linked to multiple manifestations across domains
- * PRODUCTION-READY: Real implementation using Brainy
- */
-import { Brainy } from '../brainy.js';
-import { EntityManager, ManagedEntity } from './EntityManager.js';
-/**
- * Universal concept that exists independently of files
- */
-export interface UniversalConcept extends ManagedEntity {
-    id: string;
-    name: string;
-    description?: string;
-    domain: string;
-    category: string;
-    keywords: string[];
-    links: ConceptLink[];
-    manifestations: ConceptManifestation[];
-    strength: number;
-    created: number;
-    lastUpdated: number;
-    version: number;
-    metadata: Record<string, any>;
-    conceptType?: string;
-}
-/**
- * A link between concepts
- */
-export interface ConceptLink {
-    id: string;
-    targetConceptId: string;
-    relationship: 'extends' | 'implements' | 'uses' | 'opposite' | 'related' | 'contains' | 'part-of';
-    strength: number;
-    context?: string;
-    bidirectional: boolean;
-}
-/**
- * A manifestation of a concept in a specific location
- */
-export interface ConceptManifestation extends ManagedEntity {
-    id: string;
-    conceptId: string;
-    filePath: string;
-    context: string;
-    form: 'definition' | 'usage' | 'example' | 'discussion' | 'implementation';
-    position?: {
-        line?: number;
-        column?: number;
-        offset?: number;
-    };
-    confidence: number;
-    timestamp: number;
-    extractedBy: 'manual' | 'auto' | 'ai';
-}
-/**
- * Configuration for concept system
- */
-export interface ConceptSystemConfig {
-    autoLink?: boolean;
-    similarityThreshold?: number;
-    maxManifestations?: number;
-    strengthDecay?: number;
-}
-/**
- * Concept graph structure for visualization
- */
-export interface ConceptGraph {
-    concepts: Array<{
-        id: string;
-        name: string;
-        domain: string;
-        strength: number;
-        manifestationCount: number;
-    }>;
-    links: Array<{
-        source: string;
-        target: string;
-        relationship: string;
-        strength: number;
-    }>;
-}
-/**
- * Universal Concept System
- *
- * Manages concepts that exist independently of any specific file or context
- * Examples:
- * - "Authentication" concept appearing in docs, code, tests
- * - "Customer Journey" concept in marketing, UX, analytics
- * - "Dependency Injection" pattern across multiple codebases
- * - "Sustainability" theme in various research papers
- */
-export declare class ConceptSystem extends EntityManager {
-    private config;
-    private conceptCache;
-    constructor(brain: Brainy, config?: ConceptSystemConfig);
-    /**
-     * Create a new universal concept
-     */
-    createConcept(concept: Omit<UniversalConcept, 'id' | 'created' | 'lastUpdated' | 'version' | 'links' | 'manifestations'>): Promise<string>;
-    /**
-     * Find concepts by various criteria
-     */
-    findConcepts(query: {
-        name?: string;
-        domain?: string;
-        category?: string;
-        keywords?: string[];
-        similar?: string;
-        manifestedIn?: string;
-    }): Promise<UniversalConcept[]>;
-    /**
-     * Link two concepts together
-     */
-    linkConcept(fromConceptId: string, toConceptId: string, relationship: ConceptLink['relationship'], options?: {
-        strength?: number;
-        context?: string;
-        bidirectional?: boolean;
-    }): Promise<string>;
-    /**
-     * Record a manifestation of a concept in a file
-     */
-    recordManifestation(conceptId: string, filePath: string, context: string, form: ConceptManifestation['form'], options?: {
-        position?: ConceptManifestation['position'];
-        confidence?: number;
-        extractedBy?: ConceptManifestation['extractedBy'];
-    }): Promise<string>;
-    /**
-     * Extract and link concepts from content
-     */
-    extractAndLinkConcepts(filePath: string, content: Buffer): Promise<string[]>;
-    /**
-     * Get concept graph for visualization
-     */
-    getConceptGraph(options?: {
-        domain?: string;
-        minStrength?: number;
-        maxConcepts?: number;
-    }): Promise<ConceptGraph>;
-    /**
-     * Find appearances of a concept
-     */
-    findAppearances(conceptId: string, options?: {
-        filePath?: string;
-        form?: ConceptManifestation['form'];
-        minConfidence?: number;
-        limit?: number;
-    }): Promise<ConceptManifestation[]>;
-    /**
-     * Auto-link concept to similar concepts
-     */
-    private autoLinkConcept;
-    /**
-     * Get concept by ID
-     */
-    private getConcept;
-    /**
-     * Update stored concept
-     */
-    private updateConcept;
-    /**
-     * Calculate similarity between two concepts
-     */
-    private calculateConceptSimilarity;
-    /**
-     * Generate embedding for concept
-     */
-    private generateConceptEmbedding;
-    /**
-     * Generate embedding for text
-     */
-    private generateTextEmbedding;
-    /**
-     * Get reverse relationship type
-     */
-    private getReverseRelationship;
-    /**
-     * Map concept relationship to VerbType
-     */
-    private getVerbType;
-    /**
-     * Detect concept domain from context
-     */
-    private detectDomain;
-    /**
-     * Detect concept category
-     */
-    private detectCategory;
-    /**
-     * Detect manifestation form from context
-     */
-    private detectManifestationForm;
-    /**
-     * Extract context around a position
-     */
-    private extractContext;
-    /**
-     * Clear concept cache
-     */
-    clearCache(conceptId?: string): void;
-}