@soulcraft/brainy 3.0.0 → 3.0.1

package/dist/api/SecurityAPI.d.ts

@@ -0,0 +1,50 @@
+/**
+ * Security API for Brainy 3.0
+ * Provides encryption, decryption, hashing, and secure storage
+ */
+export declare class SecurityAPI {
+    private config?;
+    private encryptionKey?;
+    constructor(config?: {
+        encryptionKey?: string;
+    } | undefined);
+    /**
+     * Encrypt data using AES-256-CBC
+     */
+    encrypt(data: string): Promise<string>;
+    /**
+     * Decrypt data encrypted with encrypt()
+     */
+    decrypt(encryptedData: string): Promise<string>;
+    /**
+     * Create a one-way hash of data (for passwords, etc)
+     */
+    hash(data: string, algorithm?: 'sha256' | 'sha512'): Promise<string>;
+    /**
+     * Compare data with a hash (for password verification)
+     */
+    compare(data: string, hash: string, algorithm?: 'sha256' | 'sha512'): Promise<boolean>;
+    /**
+     * Generate a secure random token
+     */
+    generateToken(bytes?: number): Promise<string>;
+    /**
+     * Derive a key from a password using PBKDF2
+     * Note: Simplified version using hash instead of PBKDF2 which may not be available
+     */
+    deriveKey(password: string, salt?: string, iterations?: number): Promise<{
+        key: string;
+        salt: string;
+    }>;
+    /**
+     * Sign data with HMAC
+     */
+    sign(data: string, secret?: string): Promise<string>;
+    /**
+     * Verify HMAC signature
+     */
+    verify(data: string, signature: string, secret: string): Promise<boolean>;
+    private hexToBytes;
+    private bytesToHex;
+    private constantTimeCompare;
+}

package/dist/api/SecurityAPI.js

@@ -0,0 +1,139 @@
+/**
+ * Security API for Brainy 3.0
+ * Provides encryption, decryption, hashing, and secure storage
+ */
+export class SecurityAPI {
+    constructor(config) {
+        this.config = config;
+        if (config?.encryptionKey) {
+            // Use provided key (must be 32 bytes hex string)
+            this.encryptionKey = this.hexToBytes(config.encryptionKey);
+        }
+    }
+    /**
+     * Encrypt data using AES-256-CBC
+     */
+    async encrypt(data) {
+        const crypto = await import('../universal/crypto.js');
+        // Generate or use existing key
+        const key = this.encryptionKey || crypto.randomBytes(32);
+        const iv = crypto.randomBytes(16);
+        const cipher = crypto.createCipheriv('aes-256-cbc', key, iv);
+        let encrypted = cipher.update(data, 'utf8', 'hex');
+        encrypted += cipher.final('hex');
+        // Package encrypted data with metadata
+        // In production, store keys separately in a key management service
+        return JSON.stringify({
+            encrypted,
+            key: this.bytesToHex(key),
+            iv: this.bytesToHex(iv),
+            algorithm: 'aes-256-cbc',
+            timestamp: Date.now()
+        });
+    }
+    /**
+     * Decrypt data encrypted with encrypt()
+     */
+    async decrypt(encryptedData) {
+        const crypto = await import('../universal/crypto.js');
+        try {
+            const parsed = JSON.parse(encryptedData);
+            const { encrypted, key: keyHex, iv: ivHex, algorithm } = parsed;
+            if (algorithm && algorithm !== 'aes-256-cbc') {
+                throw new Error(`Unsupported encryption algorithm: ${algorithm}`);
+            }
+            const key = this.hexToBytes(keyHex);
+            const iv = this.hexToBytes(ivHex);
+            const decipher = crypto.createDecipheriv('aes-256-cbc', key, iv);
+            let decrypted = decipher.update(encrypted, 'hex', 'utf8');
+            decrypted += decipher.final('utf8');
+            return decrypted;
+        }
+        catch (error) {
+            throw new Error(`Decryption failed: ${error.message}`);
+        }
+    }
+    /**
+     * Create a one-way hash of data (for passwords, etc)
+     */
+    async hash(data, algorithm = 'sha256') {
+        const crypto = await import('../universal/crypto.js');
+        const hash = crypto.createHash(algorithm);
+        hash.update(data);
+        return hash.digest('hex');
+    }
+    /**
+     * Compare data with a hash (for password verification)
+     */
+    async compare(data, hash, algorithm = 'sha256') {
+        const dataHash = await this.hash(data, algorithm);
+        return this.constantTimeCompare(dataHash, hash);
+    }
+    /**
+     * Generate a secure random token
+     */
+    async generateToken(bytes = 32) {
+        const crypto = await import('../universal/crypto.js');
+        const buffer = crypto.randomBytes(bytes);
+        return this.bytesToHex(buffer);
+    }
+    /**
+     * Derive a key from a password using PBKDF2
+     * Note: Simplified version using hash instead of PBKDF2 which may not be available
+     */
+    async deriveKey(password, salt, iterations = 100000) {
+        const crypto = await import('../universal/crypto.js');
+        const actualSalt = salt || this.bytesToHex(crypto.randomBytes(32));
+        // Simplified key derivation using repeated hashing
+        // In production, use a proper PBKDF2 implementation
+        let derived = password + actualSalt;
+        for (let i = 0; i < Math.min(iterations, 1000); i++) {
+            const hash = crypto.createHash('sha256');
+            hash.update(derived);
+            derived = hash.digest('hex');
+        }
+        return {
+            key: derived,
+            salt: actualSalt
+        };
+    }
+    /**
+     * Sign data with HMAC
+     */
+    async sign(data, secret) {
+        const crypto = await import('../universal/crypto.js');
+        const actualSecret = secret || (await this.generateToken());
+        const hmac = crypto.createHmac('sha256', actualSecret);
+        hmac.update(data);
+        return hmac.digest('hex');
+    }
+    /**
+     * Verify HMAC signature
+     */
+    async verify(data, signature, secret) {
+        const expectedSignature = await this.sign(data, secret);
+        return this.constantTimeCompare(signature, expectedSignature);
+    }
+    // Helper methods
+    hexToBytes(hex) {
+        const matches = hex.match(/.{1,2}/g);
+        if (!matches)
+            throw new Error('Invalid hex string');
+        return new Uint8Array(matches.map(byte => parseInt(byte, 16)));
+    }
+    bytesToHex(bytes) {
+        return Array.from(bytes)
+            .map(b => b.toString(16).padStart(2, '0'))
+            .join('');
+    }
+    constantTimeCompare(a, b) {
+        if (a.length !== b.length)
+            return false;
+        let result = 0;
+        for (let i = 0; i < a.length; i++) {
+            result |= a.charCodeAt(i) ^ b.charCodeAt(i);
+        }
+        return result === 0;
+    }
+}
+//# sourceMappingURL=SecurityAPI.js.map

package/dist/api/UniversalImportAPI.d.ts

@@ -0,0 +1,134 @@
+/**
+ * Universal Neural Import API
+ *
+ * ALWAYS uses neural matching to map ANY data to our strict NounTypes and VerbTypes
+ * Never falls back to rules - neural matching is MANDATORY
+ *
+ * Handles:
+ * - Strings (text, JSON, CSV, YAML, Markdown)
+ * - Files (local paths, any format)
+ * - URLs (web pages, APIs, documents)
+ * - Objects (structured data)
+ * - Binary data (images, PDFs via extraction)
+ */
+import { NounType, VerbType } from '../types/graphTypes.js';
+import { Vector } from '../coreTypes.js';
+import type { Brainy } from '../brainy.js';
+export interface ImportSource {
+    type: 'string' | 'file' | 'url' | 'object' | 'binary';
+    data: any;
+    format?: string;
+    metadata?: any;
+}
+export interface NeuralImportResult {
+    entities: Array<{
+        id: string;
+        type: NounType;
+        data: any;
+        vector: Vector;
+        confidence: number;
+        metadata: any;
+    }>;
+    relationships: Array<{
+        id: string;
+        from: string;
+        to: string;
+        type: VerbType;
+        weight: number;
+        confidence: number;
+        metadata?: any;
+    }>;
+    stats: {
+        totalProcessed: number;
+        entitiesCreated: number;
+        relationshipsCreated: number;
+        averageConfidence: number;
+        processingTimeMs: number;
+    };
+}
+export declare class UniversalImportAPI {
+    private brain;
+    private typeMatcher;
+    private neuralImport;
+    private embedCache;
+    constructor(brain: Brainy<any>);
+    /**
+     * Initialize the neural import system
+     */
+    init(): Promise<void>;
+    /**
+     * Universal import - handles ANY data source
+     * ALWAYS uses neural matching, NEVER falls back
+     */
+    import(source: ImportSource | string | any): Promise<NeuralImportResult>;
+    /**
+     * Import from URL - fetches and processes
+     */
+    importFromURL(url: string): Promise<NeuralImportResult>;
+    /**
+     * Import from file - reads and processes
+     * Note: In browser environment, use File API instead
+     */
+    importFromFile(filePath: string): Promise<NeuralImportResult>;
+    /**
+     * Normalize any input to ImportSource
+     */
+    private normalizeSource;
+    /**
+     * Extract structured data from source
+     */
+    private extractData;
+    /**
+     * Extract data from URL
+     */
+    private extractFromURL;
+    /**
+     * Extract data from file
+     */
+    private extractFromFile;
+    /**
+     * Extract data from string based on format
+     */
+    private extractFromString;
+    /**
+     * Extract from binary data (images, PDFs, etc)
+     */
+    private extractFromBinary;
+    /**
+     * Extract entities from plain text
+     */
+    private extractFromText;
+    /**
+     * Neural processing - CORE of the system
+     * ALWAYS uses embeddings and neural matching
+     */
+    private neuralProcess;
+    /**
+     * Generate embedding for any data
+     */
+    private generateEmbedding;
+    /**
+     * Convert any data to text for embedding
+     */
+    private dataToText;
+    /**
+     * Detect relationships using neural matching
+     */
+    private detectNeuralRelationships;
+    /**
+     * Check if a field looks like a reference
+     */
+    private looksLikeReference;
+    /**
+     * Store processed data in brain
+     */
+    private storeInBrain;
+    private detectFormat;
+    private parseCSV;
+    private parseYAML;
+    private parseMarkdown;
+    private parseHTML;
+    private generateId;
+    private simpleHash;
+    private hashBinary;
+}