@soulcraft/brainy 3.0.0 → 3.0.1

package/dist/augmentations/defaultAugmentations.d.ts

@@ -2,17 +2,17 @@
  * Default Augmentations Registration
  *
  * Maintains zero-config philosophy by automatically registering
- * core augmentations that were previously hardcoded in BrainyData.
+ * core augmentations that were previously hardcoded in Brainy.
  *
  * These augmentations are optional but enabled by default for
  * backward compatibility and optimal performance.
  */
-import { BrainyData } from '../brainyData.js';
+import { Brainy } from '../brainy.js';
 import { BaseAugmentation } from './brainyAugmentation.js';
 import { CacheAugmentation } from './cacheAugmentation.js';
-import { IndexAugmentation } from './indexAugmentation.js';
 import { MetricsAugmentation } from './metricsAugmentation.js';
 import { MonitoringAugmentation } from './monitoringAugmentation.js';
+import { UniversalDisplayAugmentation } from './universalDisplayAugmentation.js';
 /**
  * Create default augmentations for zero-config operation
  * Returns an array of augmentations to be registered
@@ -22,14 +22,14 @@ import { MonitoringAugmentation } from './monitoringAugmentation.js';
  */
 export declare function createDefaultAugmentations(config?: {
     cache?: boolean | Record<string, any>;
-    index?: boolean | Record<string, any>;
     metrics?: boolean | Record<string, any>;
     monitoring?: boolean | Record<string, any>;
+    display?: boolean | Record<string, any>;
 }): BaseAugmentation[];
 /**
  * Get augmentation by name with type safety
  */
-export declare function getAugmentation<T>(brain: BrainyData, name: string): T | null;
+export declare function getAugmentation<T>(brain: Brainy, name: string): T | null;
 /**
  * Compatibility helpers for migrating from hardcoded features
  */
@@ -37,17 +37,21 @@ export declare const AugmentationHelpers: {
     /**
      * Get cache augmentation
      */
-    getCache(brain: BrainyData): CacheAugmentation | null;
+    getCache(brain: Brainy): CacheAugmentation | null;
     /**
-     * Get index augmentation
+     * Note: Index augmentation removed - metadata indexing is now core functionality
+     * Use brain.metadataIndex directly instead
      */
-    getIndex(brain: BrainyData): IndexAugmentation | null;
     /**
      * Get metrics augmentation
      */
-    getMetrics(brain: BrainyData): MetricsAugmentation | null;
+    getMetrics(brain: Brainy): MetricsAugmentation | null;
     /**
      * Get monitoring augmentation
      */
-    getMonitoring(brain: BrainyData): MonitoringAugmentation | null;
+    getMonitoring(brain: Brainy): MonitoringAugmentation | null;
+    /**
+     * Get display augmentation
+     */
+    getDisplay(brain: Brainy): UniversalDisplayAugmentation | null;
 };

package/dist/augmentations/defaultAugmentations.js

@@ -2,15 +2,15 @@
  * Default Augmentations Registration
  *
  * Maintains zero-config philosophy by automatically registering
- * core augmentations that were previously hardcoded in BrainyData.
+ * core augmentations that were previously hardcoded in Brainy.
  *
  * These augmentations are optional but enabled by default for
  * backward compatibility and optimal performance.
  */
 import { CacheAugmentation } from './cacheAugmentation.js';
-import { IndexAugmentation } from './indexAugmentation.js';
 import { MetricsAugmentation } from './metricsAugmentation.js';
 import { MonitoringAugmentation } from './monitoringAugmentation.js';
+import { UniversalDisplayAugmentation } from './universalDisplayAugmentation.js';
 /**
  * Create default augmentations for zero-config operation
  * Returns an array of augmentations to be registered
@@ -25,16 +25,17 @@ export function createDefaultAugmentations(config = {}) {
         const cacheConfig = typeof config.cache === 'object' ? config.cache : {};
         augmentations.push(new CacheAugmentation(cacheConfig));
     }
-    // Index augmentation (was MetadataIndex)
-    if (config.index !== false) {
-        const indexConfig = typeof config.index === 'object' ? config.index : {};
-        augmentations.push(new IndexAugmentation(indexConfig));
-    }
+    // Note: Index augmentation removed - metadata indexing is now core functionality
     // Metrics augmentation (was StatisticsCollector)
     if (config.metrics !== false) {
         const metricsConfig = typeof config.metrics === 'object' ? config.metrics : {};
         augmentations.push(new MetricsAugmentation(metricsConfig));
     }
+    // Display augmentation (AI-powered intelligent display fields)
+    if (config.display !== false) {
+        const displayConfig = typeof config.display === 'object' ? config.display : {};
+        augmentations.push(new UniversalDisplayAugmentation(displayConfig));
+    }
     // Monitoring augmentation (was HealthMonitor)
     // Only enable by default in distributed mode
     const isDistributed = process.env.BRAINY_MODE === 'distributed' ||
@@ -67,11 +68,9 @@ export const AugmentationHelpers = {
         return getAugmentation(brain, 'cache');
     },
     /**
-     * Get index augmentation
+     * Note: Index augmentation removed - metadata indexing is now core functionality
+     * Use brain.metadataIndex directly instead
      */
-    getIndex(brain) {
-        return getAugmentation(brain, 'index');
-    },
     /**
      * Get metrics augmentation
      */
@@ -83,6 +82,12 @@ export const AugmentationHelpers = {
      */
     getMonitoring(brain) {
         return getAugmentation(brain, 'monitoring');
+    },
+    /**
+     * Get display augmentation
+     */
+    getDisplay(brain) {
+        return getAugmentation(brain, 'display');
     }
 };
 //# sourceMappingURL=defaultAugmentations.js.map

package/dist/augmentations/discovery/catalogDiscovery.d.ts

@@ -0,0 +1,142 @@
+/**
+ * Brain-Cloud Catalog Discovery
+ *
+ * Discovers augmentations available in the brain-cloud catalog
+ * Handles free, premium, and community augmentations
+ */
+import { AugmentationManifest } from '../manifest.js';
+export interface CatalogAugmentation {
+    id: string;
+    name: string;
+    description: string;
+    longDescription?: string;
+    category: string;
+    status: 'available' | 'coming_soon' | 'deprecated';
+    tier: 'free' | 'premium' | 'enterprise';
+    price?: {
+        monthly?: number;
+        yearly?: number;
+        oneTime?: number;
+    };
+    manifest?: AugmentationManifest;
+    source: 'catalog';
+    cdnUrl?: string;
+    npmPackage?: string;
+    githubRepo?: string;
+    author?: {
+        name: string;
+        url?: string;
+    };
+    metrics?: {
+        installations: number;
+        rating: number;
+        reviews: number;
+    };
+    requirements?: {
+        minBrainyVersion?: string;
+        maxBrainyVersion?: string;
+        dependencies?: string[];
+    };
+}
+export interface CatalogOptions {
+    apiUrl?: string;
+    apiKey?: string;
+    cache?: boolean;
+    cacheTimeout?: number;
+}
+export interface CatalogFilters {
+    category?: string;
+    tier?: 'free' | 'premium' | 'enterprise';
+    status?: 'available' | 'coming_soon' | 'deprecated';
+    search?: string;
+    installed?: boolean;
+    minRating?: number;
+}
+/**
+ * Brain-Cloud Catalog Discovery
+ */
+export declare class CatalogDiscovery {
+    private apiUrl;
+    private apiKey?;
+    private cache;
+    private cacheTimeout;
+    constructor(options?: CatalogOptions);
+    /**
+     * Discover augmentations from catalog
+     */
+    discover(filters?: CatalogFilters): Promise<CatalogAugmentation[]>;
+    /**
+     * Get specific augmentation details
+     */
+    getAugmentation(id: string): Promise<CatalogAugmentation | null>;
+    /**
+     * Get augmentation manifest
+     */
+    getManifest(id: string): Promise<AugmentationManifest | null>;
+    /**
+     * Get CDN URL for dynamic loading
+     */
+    getCDNUrl(id: string): Promise<string | null>;
+    /**
+     * Check if user has access to augmentation
+     */
+    checkAccess(id: string): Promise<{
+        hasAccess: boolean;
+        requiresPurchase?: boolean;
+        requiredTier?: string;
+    }>;
+    /**
+     * Purchase/activate augmentation
+     */
+    purchase(id: string, licenseKey?: string): Promise<{
+        success: boolean;
+        cdnUrl?: string;
+        npmPackage?: string;
+        licenseKey?: string;
+    }>;
+    /**
+     * Get user's purchased augmentations
+     */
+    getPurchased(): Promise<CatalogAugmentation[]>;
+    /**
+     * Get categories
+     */
+    getCategories(): Promise<Array<{
+        id: string;
+        name: string;
+        description: string;
+        icon?: string;
+    }>>;
+    /**
+     * Search augmentations
+     */
+    search(query: string): Promise<CatalogAugmentation[]>;
+    /**
+     * Get trending augmentations
+     */
+    getTrending(limit?: number): Promise<CatalogAugmentation[]>;
+    /**
+     * Get recommended augmentations
+     */
+    getRecommended(): Promise<CatalogAugmentation[]>;
+    /**
+     * Transform catalog data
+     */
+    private transformCatalogData;
+    /**
+     * Transform single augmentation
+     */
+    private transformAugmentation;
+    /**
+     * Get request headers
+     */
+    private getHeaders;
+    /**
+     * Clear cache
+     */
+    clearCache(): void;
+    /**
+     * Set API key
+     */
+    setApiKey(apiKey: string): void;
+}

package/dist/augmentations/discovery/catalogDiscovery.js

@@ -0,0 +1,249 @@
+/**
+ * Brain-Cloud Catalog Discovery
+ *
+ * Discovers augmentations available in the brain-cloud catalog
+ * Handles free, premium, and community augmentations
+ */
+/**
+ * Brain-Cloud Catalog Discovery
+ */
+export class CatalogDiscovery {
+    constructor(options = {}) {
+        this.cache = new Map();
+        this.apiUrl = options.apiUrl || 'https://api.soulcraft.com/brain-cloud';
+        this.apiKey = options.apiKey;
+        this.cacheTimeout = options.cacheTimeout || 5 * 60 * 1000; // 5 minutes
+    }
+    /**
+     * Discover augmentations from catalog
+     */
+    async discover(filters = {}) {
+        const cacheKey = JSON.stringify(filters);
+        // Check cache
+        if (this.cache.has(cacheKey)) {
+            const cached = this.cache.get(cacheKey);
+            if (Date.now() - cached.timestamp < this.cacheTimeout) {
+                return cached.data;
+            }
+        }
+        // Build query parameters
+        const params = new URLSearchParams();
+        if (filters.category)
+            params.append('category', filters.category);
+        if (filters.tier)
+            params.append('tier', filters.tier);
+        if (filters.status)
+            params.append('status', filters.status);
+        if (filters.search)
+            params.append('q', filters.search);
+        if (filters.minRating)
+            params.append('minRating', filters.minRating.toString());
+        // Fetch from API
+        const response = await fetch(`${this.apiUrl}/augmentations/discover?${params}`, {
+            headers: this.getHeaders()
+        });
+        if (!response.ok) {
+            throw new Error(`Failed to fetch catalog: ${response.statusText}`);
+        }
+        const data = await response.json();
+        const augmentations = this.transformCatalogData(data);
+        // Cache result
+        this.cache.set(cacheKey, {
+            data: augmentations,
+            timestamp: Date.now()
+        });
+        return augmentations;
+    }
+    /**
+     * Get specific augmentation details
+     */
+    async getAugmentation(id) {
+        const response = await fetch(`${this.apiUrl}/augmentations/${id}`, {
+            headers: this.getHeaders()
+        });
+        if (!response.ok) {
+            if (response.status === 404)
+                return null;
+            throw new Error(`Failed to fetch augmentation: ${response.statusText}`);
+        }
+        const data = await response.json();
+        return this.transformAugmentation(data);
+    }
+    /**
+     * Get augmentation manifest
+     */
+    async getManifest(id) {
+        const response = await fetch(`${this.apiUrl}/augmentations/${id}/manifest`, {
+            headers: this.getHeaders()
+        });
+        if (!response.ok) {
+            if (response.status === 404)
+                return null;
+            throw new Error(`Failed to fetch manifest: ${response.statusText}`);
+        }
+        return response.json();
+    }
+    /**
+     * Get CDN URL for dynamic loading
+     */
+    async getCDNUrl(id) {
+        const aug = await this.getAugmentation(id);
+        return aug?.cdnUrl || null;
+    }
+    /**
+     * Check if user has access to augmentation
+     */
+    async checkAccess(id) {
+        if (!this.apiKey) {
+            // No API key, only free augmentations
+            const aug = await this.getAugmentation(id);
+            return {
+                hasAccess: aug?.tier === 'free',
+                requiresPurchase: aug?.tier !== 'free',
+                requiredTier: aug?.tier
+            };
+        }
+        const response = await fetch(`${this.apiUrl}/augmentations/${id}/access`, {
+            headers: this.getHeaders()
+        });
+        if (!response.ok) {
+            throw new Error(`Failed to check access: ${response.statusText}`);
+        }
+        return response.json();
+    }
+    /**
+     * Purchase/activate augmentation
+     */
+    async purchase(id, licenseKey) {
+        const body = licenseKey ? { licenseKey } : {};
+        const response = await fetch(`${this.apiUrl}/augmentations/${id}/purchase`, {
+            method: 'POST',
+            headers: {
+                ...this.getHeaders(),
+                'Content-Type': 'application/json'
+            },
+            body: JSON.stringify(body)
+        });
+        if (!response.ok) {
+            throw new Error(`Failed to purchase: ${response.statusText}`);
+        }
+        return response.json();
+    }
+    /**
+     * Get user's purchased augmentations
+     */
+    async getPurchased() {
+        if (!this.apiKey) {
+            return [];
+        }
+        const response = await fetch(`${this.apiUrl}/user/augmentations`, {
+            headers: this.getHeaders()
+        });
+        if (!response.ok) {
+            throw new Error(`Failed to fetch purchased: ${response.statusText}`);
+        }
+        const data = await response.json();
+        return this.transformCatalogData(data);
+    }
+    /**
+     * Get categories
+     */
+    async getCategories() {
+        const response = await fetch(`${this.apiUrl}/augmentations/categories`, {
+            headers: this.getHeaders()
+        });
+        if (!response.ok) {
+            throw new Error(`Failed to fetch categories: ${response.statusText}`);
+        }
+        return response.json();
+    }
+    /**
+     * Search augmentations
+     */
+    async search(query) {
+        return this.discover({ search: query });
+    }
+    /**
+     * Get trending augmentations
+     */
+    async getTrending(limit = 10) {
+        const response = await fetch(`${this.apiUrl}/augmentations/trending?limit=${limit}`, {
+            headers: this.getHeaders()
+        });
+        if (!response.ok) {
+            throw new Error(`Failed to fetch trending: ${response.statusText}`);
+        }
+        const data = await response.json();
+        return this.transformCatalogData(data);
+    }
+    /**
+     * Get recommended augmentations
+     */
+    async getRecommended() {
+        if (!this.apiKey) {
+            // Return popular free augmentations
+            return this.discover({ tier: 'free', minRating: 4 });
+        }
+        const response = await fetch(`${this.apiUrl}/augmentations/recommended`, {
+            headers: this.getHeaders()
+        });
+        if (!response.ok) {
+            throw new Error(`Failed to fetch recommended: ${response.statusText}`);
+        }
+        const data = await response.json();
+        return this.transformCatalogData(data);
+    }
+    /**
+     * Transform catalog data
+     */
+    transformCatalogData(data) {
+        return data.map(item => this.transformAugmentation(item));
+    }
+    /**
+     * Transform single augmentation
+     */
+    transformAugmentation(item) {
+        return {
+            id: item.id,
+            name: item.name,
+            description: item.description,
+            longDescription: item.longDescription,
+            category: item.category,
+            status: item.status || 'available',
+            tier: item.tier || 'free',
+            price: item.price,
+            manifest: item.manifest,
+            source: 'catalog',
+            cdnUrl: item.cdnUrl || `https://cdn.soulcraft.com/augmentations/${item.id}@latest`,
+            npmPackage: item.npmPackage,
+            githubRepo: item.githubRepo,
+            author: item.author,
+            metrics: item.metrics,
+            requirements: item.requirements
+        };
+    }
+    /**
+     * Get request headers
+     */
+    getHeaders() {
+        const headers = {};
+        if (this.apiKey) {
+            headers['Authorization'] = `Bearer ${this.apiKey}`;
+        }
+        return headers;
+    }
+    /**
+     * Clear cache
+     */
+    clearCache() {
+        this.cache.clear();
+    }
+    /**
+     * Set API key
+     */
+    setApiKey(apiKey) {
+        this.apiKey = apiKey;
+        this.clearCache(); // Clear cache when API key changes
+    }
+}
+//# sourceMappingURL=catalogDiscovery.js.map

package/dist/augmentations/discovery/localDiscovery.d.ts

@@ -0,0 +1,84 @@
+/**
+ * Local Augmentation Discovery
+ *
+ * Discovers augmentations installed locally in node_modules
+ * and built-in augmentations that ship with Brainy
+ */
+import { AugmentationManifest } from '../manifest.js';
+export interface LocalAugmentation {
+    id: string;
+    name: string;
+    source: 'builtin' | 'npm' | 'local';
+    path: string;
+    manifest?: AugmentationManifest;
+    package?: {
+        name: string;
+        version: string;
+        description?: string;
+    };
+}
+/**
+ * Discovers augmentations installed locally
+ */
+export declare class LocalAugmentationDiscovery {
+    private options;
+    private builtInAugmentations;
+    private installedAugmentations;
+    constructor(options?: {
+        brainyPath?: string;
+        projectPath?: string;
+        scanNodeModules?: boolean;
+    });
+    /**
+     * Register built-in augmentations that ship with Brainy
+     */
+    private registerBuiltIn;
+    /**
+     * Find Brainy installation path
+     */
+    private findBrainyPath;
+    /**
+     * Discover all augmentations
+     */
+    discoverAll(): Promise<LocalAugmentation[]>;
+    /**
+     * Scan node_modules for installed augmentations
+     */
+    private scanNodeModules;
+    /**
+     * Scan local project for augmentations
+     */
+    private scanLocalProject;
+    /**
+     * Load augmentation from package
+     */
+    private loadPackageAugmentation;
+    /**
+     * Load package.json
+     */
+    private loadPackageJson;
+    /**
+     * Convert name to human-readable format
+     */
+    private humanizeName;
+    /**
+     * Get built-in augmentations
+     */
+    getBuiltIn(): LocalAugmentation[];
+    /**
+     * Get installed augmentations
+     */
+    getInstalled(): LocalAugmentation[];
+    /**
+     * Check if augmentation is installed
+     */
+    isInstalled(id: string): boolean;
+    /**
+     * Get import path for augmentation
+     */
+    getImportPath(id: string): string | null;
+    /**
+     * Load augmentation module dynamically
+     */
+    loadAugmentation(id: string): Promise<any>;
+}