@soulcraft/brainy 6.2.2 → 6.2.4

package/dist/augmentations/KnowledgeAugmentation.d.ts

@@ -0,0 +1,40 @@
+/**
+ * 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

@@ -0,0 +1,251 @@
+/**
+ * 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

@@ -0,0 +1,78 @@
+/**
+ * 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;

package/dist/importManager.js

@@ -0,0 +1,267 @@
+/**
+ * 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 { VerbType } from './types/graphTypes.js';
+import { NeuralImportAugmentation } from './augmentations/neuralImport.js';
+import * as fs from './universal/fs.js';
+import * as path from './universal/path.js';
+import { prodLog } from './utils/logger.js';
+export class ImportManager {
+    constructor(brain) {
+        this.typeMatcher = null;
+        this.brain = brain;
+        this.neuralImport = new NeuralImportAugmentation();
+    }
+    /**
+     * Initialize the import manager
+     */
+    async init() {
+        // Initialize neural import with proper context
+        const context = {
+            brain: this.brain,
+            storage: this.brain.storage,
+            config: {},
+            log: (message, level) => {
+                if (level === 'error') {
+                    prodLog.error(message);
+                }
+                else if (level === 'warn') {
+                    prodLog.warn(message);
+                }
+                else {
+                    prodLog.info(message);
+                }
+            }
+        };
+        await this.neuralImport.initialize(context);
+        // Get type matcher
+        const { getBrainyTypes } = await import('./augmentations/typeMatching/brainyTypes.js');
+        this.typeMatcher = await getBrainyTypes();
+    }
+    /**
+     * Main import method - handles all sources
+     */
+    async import(source, options = {}) {
+        const result = {
+            success: false,
+            nouns: [],
+            verbs: [],
+            errors: [],
+            stats: {
+                total: 0,
+                imported: 0,
+                failed: 0,
+                relationships: 0
+            }
+        };
+        try {
+            // Detect source type
+            const sourceType = await this.detectSourceType(source, options.source);
+            // Get data based on source type
+            let data;
+            let format = options.format || 'auto';
+            switch (sourceType) {
+                case 'url':
+                    data = await this.fetchFromUrl(source);
+                    break;
+                case 'file':
+                    const filePath = source;
+                    data = await this.readFile(filePath);
+                    if (format === 'auto') {
+                        format = this.detectFormatFromPath(filePath);
+                    }
+                    break;
+                case 'data':
+                default:
+                    data = source;
+                    break;
+            }
+            // Process data through neural import
+            let items;
+            let relationships = [];
+            if (Buffer.isBuffer(data) || typeof data === 'string') {
+                // Use neural import for parsing and analysis
+                const analysis = await this.neuralImport.getNeuralAnalysis(data, format);
+                // Extract items and relationships
+                items = analysis.detectedEntities.map(entity => ({
+                    data: entity.originalData,
+                    type: entity.nounType,
+                    confidence: entity.confidence,
+                    id: entity.suggestedId
+                }));
+                if (options.extractRelationships !== false) {
+                    relationships = analysis.detectedRelationships;
+                }
+                // Log insights
+                for (const insight of analysis.insights) {
+                    prodLog.info(`🧠 ${insight.description} (confidence: ${insight.confidence})`);
+                }
+            }
+            else if (Array.isArray(data)) {
+                items = data;
+            }
+            else {
+                items = [data];
+            }
+            result.stats.total = items.length;
+            // Import items in batches
+            const batchSize = options.batchSize || 50;
+            for (let i = 0; i < items.length; i += batchSize) {
+                const batch = items.slice(i, i + batchSize);
+                // Process batch in parallel if enabled
+                const promises = batch.map(async (item) => {
+                    try {
+                        // Detect type if needed
+                        let nounType = item.type || options.typeHint;
+                        if (!nounType && options.autoDetect !== false && this.typeMatcher) {
+                            const match = await this.typeMatcher.matchNounType(item.data || item);
+                            nounType = match.type;
+                        }
+                        // Prepare the data to import
+                        const dataToImport = item.data || item;
+                        // Create metadata combining original data with import metadata
+                        const metadata = {
+                            ...(typeof dataToImport === 'object' ? dataToImport : {}),
+                            ...(item.data?.metadata || {}),
+                            nounType,
+                            _importedAt: new Date().toISOString(),
+                            _confidence: item.confidence
+                        };
+                        // Add to brain using modern API signature
+                        const id = await this.brain.add({ data: dataToImport, type: nounType || 'content', metadata });
+                        result.nouns.push(id);
+                        result.stats.imported++;
+                        return id;
+                    }
+                    catch (error) {
+                        result.errors.push(`Failed to import item: ${error.message}`);
+                        result.stats.failed++;
+                        return null;
+                    }
+                });
+                if (options.parallel !== false) {
+                    await Promise.all(promises);
+                }
+                else {
+                    for (const promise of promises) {
+                        await promise;
+                    }
+                }
+            }
+            // Import relationships
+            for (const rel of relationships) {
+                try {
+                    // Match verb type if needed
+                    let verbType = rel.verbType;
+                    if (!Object.values(VerbType).includes(verbType) && this.typeMatcher) {
+                        const match = await this.typeMatcher.matchVerbType({ id: rel.sourceId }, { id: rel.targetId }, rel.verbType);
+                        verbType = match.type;
+                    }
+                    const verbId = await this.brain.relate({
+                        from: rel.sourceId,
+                        to: rel.targetId,
+                        type: verbType,
+                        metadata: rel.metadata,
+                        weight: rel.weight
+                    });
+                    result.verbs.push(verbId);
+                    result.stats.relationships++;
+                }
+                catch (error) {
+                    result.errors.push(`Failed to create relationship: ${error.message}`);
+                }
+            }
+            result.success = result.stats.imported > 0;
+            prodLog.info(`✨ Import complete: ${result.stats.imported}/${result.stats.total} items, ${result.stats.relationships} relationships`);
+        }
+        catch (error) {
+            result.errors.push(`Import failed: ${error.message}`);
+            prodLog.error('Import failed:', error);
+        }
+        return result;
+    }
+    /**
+     * Import from file
+     */
+    async importFile(filePath, options = {}) {
+        return this.import(filePath, { ...options, source: 'file' });
+    }
+    /**
+     * Import from URL
+     */
+    async importUrl(url, options = {}) {
+        return this.import(url, { ...options, source: 'url' });
+    }
+    /**
+     * Detect source type
+     */
+    async detectSourceType(source, hint) {
+        if (hint && hint !== 'auto') {
+            return hint;
+        }
+        if (typeof source === 'string') {
+            // Check if URL
+            if (source.startsWith('http://') || source.startsWith('https://')) {
+                return 'url';
+            }
+            // Check if file path exists
+            try {
+                if (await fs.exists(source)) {
+                    return 'file';
+                }
+            }
+            catch (error) {
+                // File system check failed, not a file path
+                console.debug('File path check failed:', error);
+            }
+        }
+        return 'data';
+    }
+    /**
+     * Detect format from file path
+     */
+    detectFormatFromPath(filePath) {
+        const ext = path.extname(filePath).toLowerCase();
+        switch (ext) {
+            case '.json': return 'json';
+            case '.csv': return 'csv';
+            case '.txt': return 'text';
+            case '.md': return 'text';
+            case '.yaml':
+            case '.yml': return 'yaml';
+            default: return 'auto';
+        }
+    }
+    /**
+     * Read file
+     */
+    async readFile(filePath) {
+        const content = await fs.readFile(filePath, 'utf8');
+        return Buffer.from(content, 'utf8');
+    }
+    /**
+     * Fetch from URL
+     */
+    async fetchFromUrl(url) {
+        const response = await fetch(url);
+        if (!response.ok) {
+            throw new Error(`Failed to fetch ${url}: ${response.statusText}`);
+        }
+        return response.text();
+    }
+}
+/**
+ * Create an import manager instance
+ */
+export function createImportManager(brain) {
+    return new ImportManager(brain);
+}
+//# sourceMappingURL=importManager.js.map