@soulcraft/brainy 2.15.0 → 3.0.1

package/dist/api/ConfigAPI.d.ts

@@ -0,0 +1,67 @@
+/**
+ * Configuration API for Brainy 3.0
+ * Provides configuration storage with optional encryption
+ */
+import { StorageAdapter } from '../coreTypes.js';
+export interface ConfigOptions {
+    encrypt?: boolean;
+    decrypt?: boolean;
+}
+export interface ConfigEntry {
+    key: string;
+    value: any;
+    encrypted: boolean;
+    createdAt: number;
+    updatedAt: number;
+}
+export declare class ConfigAPI {
+    private storage;
+    private security;
+    private configCache;
+    private CONFIG_NOUN_PREFIX;
+    constructor(storage: StorageAdapter);
+    /**
+     * Set a configuration value with optional encryption
+     */
+    set(params: {
+        key: string;
+        value: any;
+        encrypt?: boolean;
+    }): Promise<void>;
+    /**
+     * Get a configuration value with optional decryption
+     */
+    get(params: {
+        key: string;
+        decrypt?: boolean;
+        defaultValue?: any;
+    }): Promise<any>;
+    /**
+     * Delete a configuration value
+     */
+    delete(key: string): Promise<void>;
+    /**
+     * List all configuration keys
+     */
+    list(): Promise<string[]>;
+    /**
+     * Check if a configuration key exists
+     */
+    has(key: string): Promise<boolean>;
+    /**
+     * Clear all configuration
+     */
+    clear(): Promise<void>;
+    /**
+     * Export all configuration
+     */
+    export(): Promise<Record<string, ConfigEntry>>;
+    /**
+     * Import configuration
+     */
+    import(config: Record<string, ConfigEntry>): Promise<void>;
+    /**
+     * Get raw config entry (without decryption)
+     */
+    private getEntry;
+}

package/dist/api/ConfigAPI.js

@@ -0,0 +1,166 @@
+/**
+ * Configuration API for Brainy 3.0
+ * Provides configuration storage with optional encryption
+ */
+import { SecurityAPI } from './SecurityAPI.js';
+export class ConfigAPI {
+    constructor(storage) {
+        this.storage = storage;
+        this.configCache = new Map();
+        this.CONFIG_NOUN_PREFIX = '_config_';
+        this.security = new SecurityAPI();
+    }
+    /**
+     * Set a configuration value with optional encryption
+     */
+    async set(params) {
+        const { key, value, encrypt = false } = params;
+        // Serialize and optionally encrypt the value
+        let storedValue = value;
+        if (typeof value !== 'string') {
+            storedValue = JSON.stringify(value);
+        }
+        if (encrypt) {
+            storedValue = await this.security.encrypt(storedValue);
+        }
+        // Create config entry
+        const entry = {
+            key,
+            value: storedValue,
+            encrypted: encrypt,
+            createdAt: this.configCache.get(key)?.createdAt || Date.now(),
+            updatedAt: Date.now()
+        };
+        // Store in cache
+        this.configCache.set(key, entry);
+        // Persist to storage
+        const configId = this.CONFIG_NOUN_PREFIX + key;
+        await this.storage.saveMetadata(configId, entry);
+    }
+    /**
+     * Get a configuration value with optional decryption
+     */
+    async get(params) {
+        const { key, decrypt, defaultValue } = params;
+        // Check cache first
+        let entry = this.configCache.get(key);
+        // If not in cache, load from storage
+        if (!entry) {
+            const configId = this.CONFIG_NOUN_PREFIX + key;
+            const metadata = await this.storage.getMetadata(configId);
+            if (!metadata) {
+                return defaultValue;
+            }
+            entry = metadata;
+            this.configCache.set(key, entry);
+        }
+        let value = entry.value;
+        // Decrypt if needed
+        const shouldDecrypt = decrypt !== undefined ? decrypt : entry.encrypted;
+        if (shouldDecrypt && entry.encrypted && typeof value === 'string') {
+            value = await this.security.decrypt(value);
+        }
+        // Try to parse JSON if it looks like JSON
+        if (typeof value === 'string' && (value.startsWith('{') || value.startsWith('['))) {
+            try {
+                value = JSON.parse(value);
+            }
+            catch {
+                // Not JSON, return as string
+            }
+        }
+        return value;
+    }
+    /**
+     * Delete a configuration value
+     */
+    async delete(key) {
+        // Remove from cache
+        this.configCache.delete(key);
+        // Remove from storage
+        const configId = this.CONFIG_NOUN_PREFIX + key;
+        await this.storage.saveMetadata(configId, null);
+    }
+    /**
+     * List all configuration keys
+     */
+    async list() {
+        // Get all metadata keys from storage
+        const allMetadata = await this.storage.getMetadata('');
+        if (!allMetadata || typeof allMetadata !== 'object') {
+            return [];
+        }
+        // Filter for config keys
+        const configKeys = [];
+        for (const key of Object.keys(allMetadata)) {
+            if (key.startsWith(this.CONFIG_NOUN_PREFIX)) {
+                configKeys.push(key.substring(this.CONFIG_NOUN_PREFIX.length));
+            }
+        }
+        return configKeys;
+    }
+    /**
+     * Check if a configuration key exists
+     */
+    async has(key) {
+        if (this.configCache.has(key)) {
+            return true;
+        }
+        const configId = this.CONFIG_NOUN_PREFIX + key;
+        const metadata = await this.storage.getMetadata(configId);
+        return metadata !== null && metadata !== undefined;
+    }
+    /**
+     * Clear all configuration
+     */
+    async clear() {
+        // Clear cache
+        this.configCache.clear();
+        // Clear from storage
+        const keys = await this.list();
+        for (const key of keys) {
+            await this.delete(key);
+        }
+    }
+    /**
+     * Export all configuration
+     */
+    async export() {
+        const keys = await this.list();
+        const config = {};
+        for (const key of keys) {
+            const entry = await this.getEntry(key);
+            if (entry) {
+                config[key] = entry;
+            }
+        }
+        return config;
+    }
+    /**
+     * Import configuration
+     */
+    async import(config) {
+        for (const [key, entry] of Object.entries(config)) {
+            this.configCache.set(key, entry);
+            const configId = this.CONFIG_NOUN_PREFIX + key;
+            await this.storage.saveMetadata(configId, entry);
+        }
+    }
+    /**
+     * Get raw config entry (without decryption)
+     */
+    async getEntry(key) {
+        if (this.configCache.has(key)) {
+            return this.configCache.get(key);
+        }
+        const configId = this.CONFIG_NOUN_PREFIX + key;
+        const metadata = await this.storage.getMetadata(configId);
+        if (!metadata) {
+            return null;
+        }
+        const entry = metadata;
+        this.configCache.set(key, entry);
+        return entry;
+    }
+}
+//# sourceMappingURL=ConfigAPI.js.map

package/dist/api/DataAPI.d.ts

@@ -0,0 +1,123 @@
+/**
+ * Data Management API for Brainy 3.0
+ * Provides backup, restore, import, export, and data management
+ */
+import { StorageAdapter } from '../coreTypes.js';
+import { Entity, Relation } from '../types/brainy.types.js';
+import { NounType } from '../types/graphTypes.js';
+export interface BackupOptions {
+    includeVectors?: boolean;
+    compress?: boolean;
+    format?: 'json' | 'binary';
+}
+export interface RestoreOptions {
+    merge?: boolean;
+    overwrite?: boolean;
+    validate?: boolean;
+}
+export interface ImportOptions {
+    format: 'json' | 'csv';
+    mapping?: Record<string, string>;
+    batchSize?: number;
+    validate?: boolean;
+}
+export interface ExportOptions {
+    format?: 'json' | 'csv';
+    filter?: {
+        type?: NounType | NounType[];
+        where?: Record<string, any>;
+        service?: string;
+    };
+    includeVectors?: boolean;
+}
+export interface BackupData {
+    version: string;
+    timestamp: number;
+    entities: Array<{
+        id: string;
+        vector?: number[];
+        type: string;
+        metadata: any;
+        service?: string;
+    }>;
+    relations: Array<{
+        id: string;
+        from: string;
+        to: string;
+        type: string;
+        weight: number;
+        metadata?: any;
+    }>;
+    config?: Record<string, any>;
+    stats: {
+        entityCount: number;
+        relationCount: number;
+        vectorDimensions?: number;
+    };
+}
+export interface ImportResult {
+    successful: number;
+    failed: number;
+    errors: Array<{
+        item: any;
+        error: string;
+    }>;
+    duration: number;
+}
+export declare class DataAPI {
+    private storage;
+    private getEntity;
+    private getRelation?;
+    private brain;
+    constructor(storage: StorageAdapter, getEntity: (id: string) => Promise<Entity | null>, getRelation?: ((id: string) => Promise<Relation | null>) | undefined, brain?: any);
+    /**
+     * Create a backup of all data
+     */
+    backup(options?: BackupOptions): Promise<BackupData | {
+        compressed: boolean;
+        data: string;
+        originalSize: number;
+        compressedSize: number;
+    }>;
+    /**
+     * Restore data from a backup
+     */
+    restore(params: {
+        backup: BackupData;
+        merge?: boolean;
+        overwrite?: boolean;
+        validate?: boolean;
+    }): Promise<void>;
+    /**
+     * Clear data
+     */
+    clear(params?: {
+        entities?: boolean;
+        relations?: boolean;
+        config?: boolean;
+    }): Promise<void>;
+    /**
+     * Import data from various formats
+     */
+    import(params: ImportOptions & {
+        data: any;
+    }): Promise<ImportResult>;
+    /**
+     * Export data to various formats
+     */
+    export(params?: ExportOptions): Promise<any>;
+    /**
+     * Get storage statistics
+     */
+    getStats(): Promise<{
+        entities: number;
+        relations: number;
+        storageSize?: number;
+        vectorDimensions?: number;
+    }>;
+    private applyMapping;
+    private validateImportItem;
+    private matchesFilter;
+    private convertToCSV;
+    private generateId;
+}