@soulcraft/brainy 3.20.2 → 3.20.3

package/dist/config/distributedPresets-new.js

@@ -1,318 +0,0 @@
-/**
- * Extended Distributed Configuration Presets
- * Common patterns for distributed and multi-service architectures
- * All strongly typed with enums for compile-time safety
- */
-/**
- * Strongly typed enum for preset names
- */
-export var PresetName;
-(function (PresetName) {
-    // Basic presets
-    PresetName["PRODUCTION"] = "production";
-    PresetName["DEVELOPMENT"] = "development";
-    PresetName["MINIMAL"] = "minimal";
-    PresetName["ZERO"] = "zero";
-    // Distributed presets
-    PresetName["WRITER"] = "writer";
-    PresetName["READER"] = "reader";
-    // Service-specific presets
-    PresetName["INGESTION_SERVICE"] = "ingestion-service";
-    PresetName["SEARCH_API"] = "search-api";
-    PresetName["ANALYTICS_SERVICE"] = "analytics-service";
-    PresetName["EDGE_CACHE"] = "edge-cache";
-    PresetName["BATCH_PROCESSOR"] = "batch-processor";
-    PresetName["STREAMING_SERVICE"] = "streaming-service";
-    PresetName["ML_TRAINING"] = "ml-training";
-    PresetName["SIDECAR"] = "sidecar";
-})(PresetName || (PresetName = {}));
-/**
- * Preset categories for organization
- */
-export var PresetCategory;
-(function (PresetCategory) {
-    PresetCategory["BASIC"] = "basic";
-    PresetCategory["DISTRIBUTED"] = "distributed";
-    PresetCategory["SERVICE"] = "service";
-})(PresetCategory || (PresetCategory = {}));
-/**
- * Model precision options
- */
-export var ModelPrecision;
-(function (ModelPrecision) {
-    ModelPrecision["FP32"] = "fp32";
-    ModelPrecision["Q8"] = "q8";
-    ModelPrecision["AUTO"] = "auto";
-    ModelPrecision["FAST"] = "fast";
-    ModelPrecision["SMALL"] = "small";
-})(ModelPrecision || (ModelPrecision = {}));
-/**
- * Storage options
- */
-export var StorageOption;
-(function (StorageOption) {
-    StorageOption["AUTO"] = "auto";
-    StorageOption["MEMORY"] = "memory";
-    StorageOption["DISK"] = "disk";
-    StorageOption["CLOUD"] = "cloud";
-})(StorageOption || (StorageOption = {}));
-/**
- * Feature set options
- */
-export var FeatureSet;
-(function (FeatureSet) {
-    FeatureSet["MINIMAL"] = "minimal";
-    FeatureSet["DEFAULT"] = "default";
-    FeatureSet["FULL"] = "full";
-    FeatureSet["CUSTOM"] = "custom"; // For custom feature arrays
-})(FeatureSet || (FeatureSet = {}));
-/**
- * Distributed role options
- */
-export var DistributedRole;
-(function (DistributedRole) {
-    DistributedRole["WRITER"] = "writer";
-    DistributedRole["READER"] = "reader";
-    DistributedRole["HYBRID"] = "hybrid";
-})(DistributedRole || (DistributedRole = {}));
-/**
- * Strongly typed preset configurations
- */
-export const PRESET_CONFIGS = {
-    // Basic presets
-    [PresetName.PRODUCTION]: {
-        storage: StorageOption.DISK,
-        model: ModelPrecision.AUTO,
-        features: FeatureSet.DEFAULT,
-        distributed: false,
-        verbose: false,
-        description: 'Optimized for production use',
-        category: PresetCategory.BASIC
-    },
-    [PresetName.DEVELOPMENT]: {
-        storage: StorageOption.MEMORY,
-        model: ModelPrecision.FP32,
-        features: FeatureSet.FULL,
-        distributed: false,
-        verbose: true,
-        description: 'Optimized for development with verbose logging',
-        category: PresetCategory.BASIC
-    },
-    [PresetName.MINIMAL]: {
-        storage: StorageOption.MEMORY,
-        model: ModelPrecision.Q8,
-        features: FeatureSet.MINIMAL,
-        distributed: false,
-        verbose: false,
-        description: 'Minimal footprint configuration',
-        category: PresetCategory.BASIC
-    },
-    [PresetName.ZERO]: {
-        storage: StorageOption.AUTO,
-        model: ModelPrecision.AUTO,
-        features: FeatureSet.DEFAULT,
-        distributed: false,
-        verbose: false,
-        description: 'True zero configuration with auto-detection',
-        category: PresetCategory.BASIC
-    },
-    // Distributed basic presets
-    [PresetName.WRITER]: {
-        storage: StorageOption.AUTO,
-        model: ModelPrecision.AUTO,
-        features: FeatureSet.MINIMAL,
-        distributed: true,
-        role: DistributedRole.WRITER,
-        writeOnly: true,
-        allowDirectReads: true,
-        verbose: false,
-        description: 'Write-only instance for distributed setups',
-        category: PresetCategory.DISTRIBUTED
-    },
-    [PresetName.READER]: {
-        storage: StorageOption.AUTO,
-        model: ModelPrecision.AUTO,
-        features: FeatureSet.DEFAULT,
-        distributed: true,
-        role: DistributedRole.READER,
-        readOnly: true,
-        lazyLoadInReadOnlyMode: true,
-        verbose: false,
-        description: 'Read-only instance for distributed setups',
-        category: PresetCategory.DISTRIBUTED
-    },
-    // Service-specific presets
-    [PresetName.INGESTION_SERVICE]: {
-        storage: StorageOption.CLOUD,
-        model: ModelPrecision.Q8,
-        features: ['core', 'batch-processing', 'entity-registry'],
-        distributed: true,
-        role: DistributedRole.WRITER,
-        writeOnly: true,
-        allowDirectReads: true,
-        verbose: false,
-        description: 'High-throughput data ingestion service',
-        category: PresetCategory.SERVICE
-    },
-    [PresetName.SEARCH_API]: {
-        storage: StorageOption.CLOUD,
-        model: ModelPrecision.FP32,
-        features: ['core', 'search', 'cache', 'triple-intelligence'],
-        distributed: true,
-        role: DistributedRole.READER,
-        readOnly: true,
-        lazyLoadInReadOnlyMode: true,
-        cache: {
-            hotCacheMaxSize: 10000,
-            autoTune: true
-        },
-        verbose: false,
-        description: 'Low-latency search API service',
-        category: PresetCategory.SERVICE
-    },
-    [PresetName.ANALYTICS_SERVICE]: {
-        storage: StorageOption.CLOUD,
-        model: ModelPrecision.AUTO,
-        features: ['core', 'search', 'metrics', 'monitoring'],
-        distributed: true,
-        role: DistributedRole.HYBRID,
-        verbose: false,
-        description: 'Analytics and data processing service',
-        category: PresetCategory.SERVICE
-    },
-    [PresetName.EDGE_CACHE]: {
-        storage: StorageOption.AUTO,
-        model: ModelPrecision.Q8,
-        features: ['core', 'search', 'cache'],
-        distributed: true,
-        role: DistributedRole.READER,
-        readOnly: true,
-        lazyLoadInReadOnlyMode: true,
-        cache: {
-            hotCacheMaxSize: 1000,
-            autoTune: false
-        },
-        verbose: false,
-        description: 'Edge location cache with minimal footprint',
-        category: PresetCategory.SERVICE
-    },
-    [PresetName.BATCH_PROCESSOR]: {
-        storage: StorageOption.CLOUD,
-        model: ModelPrecision.Q8,
-        features: ['core', 'batch-processing', 'neural-api'],
-        distributed: true,
-        role: DistributedRole.HYBRID,
-        cache: {
-            hotCacheMaxSize: 5000,
-            batchSize: 500
-        },
-        verbose: false,
-        description: 'Batch processing and bulk operations',
-        category: PresetCategory.SERVICE
-    },
-    [PresetName.STREAMING_SERVICE]: {
-        storage: StorageOption.CLOUD,
-        model: ModelPrecision.Q8,
-        features: ['core', 'batch-processing', 'wal'],
-        distributed: true,
-        role: DistributedRole.WRITER,
-        writeOnly: true,
-        allowDirectReads: false,
-        verbose: false,
-        description: 'Real-time data streaming service',
-        category: PresetCategory.SERVICE
-    },
-    [PresetName.ML_TRAINING]: {
-        storage: StorageOption.CLOUD,
-        model: ModelPrecision.FP32,
-        features: FeatureSet.FULL,
-        distributed: true,
-        role: DistributedRole.HYBRID,
-        cache: {
-            hotCacheMaxSize: 20000,
-            autoTune: true
-        },
-        verbose: true,
-        description: 'Machine learning training service',
-        category: PresetCategory.SERVICE
-    },
-    [PresetName.SIDECAR]: {
-        storage: StorageOption.AUTO,
-        model: ModelPrecision.Q8,
-        features: FeatureSet.MINIMAL,
-        distributed: false,
-        verbose: false,
-        description: 'Lightweight sidecar for microservices',
-        category: PresetCategory.SERVICE
-    }
-};
-/**
- * Type-safe preset getter
- */
-export function getPreset(name) {
-    return PRESET_CONFIGS[name];
-}
-/**
- * Check if a string is a valid preset name
- */
-export function isValidPreset(name) {
-    return Object.values(PresetName).includes(name);
-}
-/**
- * Get presets by category
- */
-export function getPresetsByCategory(category) {
-    return Object.entries(PRESET_CONFIGS)
-        .filter(([_, config]) => config.category === category)
-        .map(([name]) => name);
-}
-/**
- * Get all preset names
- */
-export function getAllPresetNames() {
-    return Object.values(PresetName);
-}
-/**
- * Get preset description
- */
-export function getPresetDescription(name) {
-    return PRESET_CONFIGS[name].description;
-}
-/**
- * Convert preset config to Brainy config
- */
-export function presetToBrainyConfig(preset) {
-    const config = {
-        storage: preset.storage,
-        model: preset.model,
-        verbose: preset.verbose
-    };
-    // Handle features
-    if (Array.isArray(preset.features)) {
-        config.features = preset.features;
-    }
-    else {
-        config.features = preset.features; // Will be expanded by processZeroConfig
-    }
-    // Handle distributed settings
-    if (preset.distributed) {
-        config.distributed = {
-            enabled: true,
-            role: preset.role
-        };
-        if (preset.readOnly)
-            config.readOnly = true;
-        if (preset.writeOnly)
-            config.writeOnly = true;
-        if (preset.allowDirectReads)
-            config.allowDirectReads = true;
-        if (preset.lazyLoadInReadOnlyMode)
-            config.lazyLoadInReadOnlyMode = true;
-    }
-    // Handle cache settings
-    if (preset.cache) {
-        config.cache = preset.cache;
-    }
-    return config;
-}
-//# sourceMappingURL=distributedPresets-new.js.map

package/dist/config/modelPrecisionManager.d.ts

@@ -1,42 +0,0 @@
-/**
- * Central Model Precision Manager
- *
- * Single source of truth for model precision configuration.
- * Ensures consistent usage of Q8 or FP32 models throughout the system.
- */
-import { ModelPrecision } from './modelAutoConfig.js';
-export declare class ModelPrecisionManager {
-    private static instance;
-    private precision;
-    private isLocked;
-    private constructor();
-    static getInstance(): ModelPrecisionManager;
-    /**
-     * Get the current model precision
-     */
-    getPrecision(): ModelPrecision;
-    /**
-     * Set the model precision (can only be done before first model load)
-     */
-    setPrecision(precision: ModelPrecision): void;
-    /**
-     * Lock the precision (called after first model load)
-     */
-    lock(): void;
-    /**
-     * Check if precision is locked
-     */
-    isConfigLocked(): boolean;
-    /**
-     * Get precision info for logging
-     */
-    getInfo(): string;
-    /**
-     * Validate that a given precision matches the configured one
-     */
-    validatePrecision(precision: ModelPrecision): boolean;
-}
-export declare const getModelPrecision: () => ModelPrecision;
-export declare const setModelPrecision: (precision: ModelPrecision) => void;
-export declare const lockModelPrecision: () => void;
-export declare const validateModelPrecision: (precision: ModelPrecision) => boolean;

package/dist/config/modelPrecisionManager.js

@@ -1,98 +0,0 @@
-/**
- * Central Model Precision Manager
- *
- * Single source of truth for model precision configuration.
- * Ensures consistent usage of Q8 or FP32 models throughout the system.
- */
-export class ModelPrecisionManager {
-    constructor() {
-        this.precision = 'q8'; // DEFAULT TO Q8
-        this.isLocked = false;
-        // Check environment variable override
-        const envPrecision = process.env.BRAINY_MODEL_PRECISION;
-        if (envPrecision === 'fp32' || envPrecision === 'q8') {
-            this.precision = envPrecision;
-            console.log(`Model precision set from environment: ${envPrecision.toUpperCase()}`);
-        }
-        else {
-            console.log('Using default model precision: Q8 (75% smaller, 99% accuracy)');
-        }
-    }
-    static getInstance() {
-        if (!ModelPrecisionManager.instance) {
-            ModelPrecisionManager.instance = new ModelPrecisionManager();
-        }
-        return ModelPrecisionManager.instance;
-    }
-    /**
-     * Get the current model precision
-     */
-    getPrecision() {
-        return this.precision;
-    }
-    /**
-     * Set the model precision (can only be done before first model load)
-     */
-    setPrecision(precision) {
-        if (this.isLocked) {
-            console.warn(`⚠️ Cannot change precision after model initialization. Current: ${this.precision.toUpperCase()}`);
-            return;
-        }
-        if (precision !== this.precision) {
-            console.log(`Model precision changed: ${this.precision.toUpperCase()} → ${precision.toUpperCase()}`);
-            this.precision = precision;
-        }
-    }
-    /**
-     * Lock the precision (called after first model load)
-     */
-    lock() {
-        if (!this.isLocked) {
-            this.isLocked = true;
-            console.log(`Model precision locked: ${this.precision.toUpperCase()}`);
-        }
-    }
-    /**
-     * Check if precision is locked
-     */
-    isConfigLocked() {
-        return this.isLocked;
-    }
-    /**
-     * Get precision info for logging
-     */
-    getInfo() {
-        const info = this.precision === 'q8'
-            ? 'Q8 (quantized, 23MB, 99% accuracy)'
-            : 'FP32 (full precision, 90MB, 100% accuracy)';
-        return `${info}${this.isLocked ? ' [LOCKED]' : ''}`;
-    }
-    /**
-     * Validate that a given precision matches the configured one
-     */
-    validatePrecision(precision) {
-        if (precision !== this.precision) {
-            console.error(`❌ Precision mismatch! Expected: ${this.precision.toUpperCase()}, Got: ${precision.toUpperCase()}`);
-            console.error('This will cause incompatible embeddings!');
-            return false;
-        }
-        return true;
-    }
-}
-// Export singleton instance getter
-export const getModelPrecision = () => {
-    return ModelPrecisionManager.getInstance().getPrecision();
-};
-// Export setter (for configuration phase)
-export const setModelPrecision = (precision) => {
-    ModelPrecisionManager.getInstance().setPrecision(precision);
-};
-// Export lock function (for after model initialization)
-export const lockModelPrecision = () => {
-    ModelPrecisionManager.getInstance().lock();
-};
-// Export validation function
-export const validateModelPrecision = (precision) => {
-    return ModelPrecisionManager.getInstance().validatePrecision(precision);
-};
-//# sourceMappingURL=modelPrecisionManager.js.map

package/dist/connectors/interfaces/IConnector.d.ts

@@ -1,143 +0,0 @@
-/**
- * Brainy Connector Interface - Atomic Age Integration Framework
- *
- * 🧠 Base interface for all premium connectors in Brain Cloud
- * ⚛️ Open source interface, implementations are premium-only
- */
-export interface ConnectorConfig {
-    /** Connector identifier (e.g., 'notion', 'salesforce') */
-    connectorId: string;
-    /** Premium license key (required for Brain Cloud connectors) */
-    licenseKey: string;
-    /** API credentials for the external service */
-    credentials: {
-        apiKey?: string;
-        accessToken?: string;
-        refreshToken?: string;
-        clientId?: string;
-        clientSecret?: string;
-        [key: string]: any;
-    };
-    /** Connector-specific configuration */
-    options?: {
-        syncInterval?: number;
-        batchSize?: number;
-        retryAttempts?: number;
-        [key: string]: any;
-    };
-    /** Brainy database instance configuration */
-    brainy?: {
-        endpoint?: string;
-        storage?: string;
-        [key: string]: any;
-    };
-}
-export interface SyncResult {
-    /** Number of items successfully synced */
-    synced: number;
-    /** Number of items that failed to sync */
-    failed: number;
-    /** Number of items skipped (duplicates, etc.) */
-    skipped: number;
-    /** Total processing time in milliseconds */
-    duration: number;
-    /** Sync operation timestamp */
-    timestamp: string;
-    /** Error details for failed items */
-    errors?: Array<{
-        item: string;
-        error: string;
-        retryable: boolean;
-    }>;
-    /** Metadata about the sync operation */
-    metadata?: {
-        lastSyncId?: string;
-        nextPageToken?: string;
-        hasMore?: boolean;
-        [key: string]: any;
-    };
-}
-export interface ConnectorStatus {
-    /** Current connector state */
-    status: 'connected' | 'disconnected' | 'error' | 'syncing' | 'paused';
-    /** Human-readable status message */
-    message: string;
-    /** Last successful sync timestamp */
-    lastSync?: string;
-    /** Next scheduled sync timestamp */
-    nextSync?: string;
-    /** Connection health indicators */
-    health: {
-        apiReachable: boolean;
-        credentialsValid: boolean;
-        licenseValid: boolean;
-        quotaRemaining?: number;
-    };
-    /** Usage statistics */
-    stats?: {
-        totalSyncs: number;
-        totalItems: number;
-        averageDuration: number;
-        errorRate: number;
-    };
-}
-/**
- * Base interface for all Brainy premium connectors
- *
- * Implementations auto-load with Brain Cloud subscription after auth
- */
-export interface IConnector {
-    /** Unique connector identifier */
-    readonly id: string;
-    /** Human-readable connector name */
-    readonly name: string;
-    /** Connector version */
-    readonly version: string;
-    /** Supported data types this connector can handle */
-    readonly supportedTypes: string[];
-    /**
-     * Initialize the connector with configuration
-     */
-    initialize(config: ConnectorConfig): Promise<void>;
-    /**
-     * Test connection to the external service
-     */
-    testConnection(): Promise<boolean>;
-    /**
-     * Get current connector status and health
-     */
-    getStatus(): Promise<ConnectorStatus>;
-    /**
-     * Start syncing data from the external service
-     */
-    startSync(): Promise<SyncResult>;
-    /**
-     * Stop any ongoing sync operations
-     */
-    stopSync(): Promise<void>;
-    /**
-     * Perform incremental sync (delta changes only)
-     */
-    incrementalSync(): Promise<SyncResult>;
-    /**
-     * Perform full sync (all data)
-     */
-    fullSync(): Promise<SyncResult>;
-    /**
-     * Preview what would be synced without actually syncing
-     */
-    previewSync(limit?: number): Promise<{
-        items: Array<{
-            type: string;
-            title: string;
-            preview: string;
-            relationships: string[];
-        }>;
-        totalCount: number;
-        estimatedDuration: number;
-    }>;
-    /**
-     * Clean up resources and disconnect
-     */
-    disconnect(): Promise<void>;
-}

package/dist/connectors/interfaces/IConnector.js

@@ -1,8 +0,0 @@
-/**
- * Brainy Connector Interface - Atomic Age Integration Framework
- *
- * 🧠 Base interface for all premium connectors in Brain Cloud
- * ⚛️ Open source interface, implementations are premium-only
- */
-export {};
-//# sourceMappingURL=IConnector.js.map