@soulcraft/brainy 3.0.0 → 3.0.1

package/dist/augmentations/marketplace/cli.js

@@ -0,0 +1,265 @@
+/**
+ * Augmentation Marketplace CLI Commands
+ *
+ * Provides command-line interface for managing augmentations
+ * Similar to npm/yarn but for Brainy augmentations
+ */
+/**
+ * Format augmentation for display
+ */
+function formatAugmentation(aug) {
+    const price = aug.price ? `$${aug.price}` : 'Free';
+    const rating = '⭐'.repeat(Math.round(aug.rating));
+    return `
+${aug.displayName} v${aug.version} by ${aug.author}
+${aug.description}
+Category: ${aug.category} | Price: ${price} | Rating: ${rating} (${aug.reviews} reviews)
+Downloads: ${aug.downloads.toLocaleString()} | Size: ${formatBytes(aug.size)}
+Tags: ${aug.tags.join(', ')}
+`.trim();
+}
+/**
+ * Format bytes to human readable
+ */
+function formatBytes(bytes) {
+    if (bytes < 1024)
+        return bytes + ' B';
+    if (bytes < 1024 * 1024)
+        return (bytes / 1024).toFixed(1) + ' KB';
+    if (bytes < 1024 * 1024 * 1024)
+        return (bytes / 1024 / 1024).toFixed(1) + ' MB';
+    return (bytes / 1024 / 1024 / 1024).toFixed(1) + ' GB';
+}
+/**
+ * List installed augmentations
+ */
+export async function listCommand(marketplace) {
+    const installed = marketplace.getInstalled();
+    if (installed.length === 0) {
+        console.log('No augmentations installed');
+        return;
+    }
+    console.log('\nInstalled Augmentations:');
+    console.log('========================\n');
+    for (const aug of installed) {
+        const status = aug.enabled ? '✅ Enabled' : '❌ Disabled';
+        const autoUpdate = aug.autoUpdate ? '🔄' : '';
+        console.log(`${aug.name} v${aug.version} ${status} ${autoUpdate}`);
+        console.log(`  Installed: ${new Date(aug.installedAt).toLocaleDateString()}`);
+        console.log(`  From: ${aug.installedFrom}`);
+        if (aug.cloudId) {
+            console.log(`  Cloud ID: ${aug.cloudId}`);
+        }
+        console.log('');
+    }
+    // Check for updates
+    console.log('Checking for updates...');
+    const updates = await marketplace.checkForUpdates();
+    if (updates.length > 0) {
+        console.log(`\n⚠️  ${updates.length} update(s) available:`);
+        for (const update of updates) {
+            console.log(`  ${update.augmentation.name}: ${update.augmentation.version} → ${update.newVersion}`);
+        }
+        console.log('\nRun "brainy augment update <name>" to update');
+    }
+    else {
+        console.log('All augmentations are up to date ✨');
+    }
+}
+/**
+ * Search cloud registry
+ */
+export async function searchCommand(marketplace, query, options = {}) {
+    console.log(`Searching for "${query}"...`);
+    const filters = {};
+    if (options.category)
+        filters.category = options.category;
+    if (options.free !== undefined)
+        filters.free = options.free;
+    const results = await marketplace.searchCloud(query, filters, 1, options.limit || 10);
+    if (results.total === 0) {
+        console.log('No augmentations found');
+        return;
+    }
+    console.log(`\nFound ${results.total} augmentation(s):`);
+    console.log('================================\n');
+    for (const aug of results.results) {
+        console.log(formatAugmentation(aug));
+        console.log('---');
+    }
+    if (results.pages > 1) {
+        console.log(`\nShowing page ${results.page} of ${results.pages}`);
+        console.log('Use --page flag to see more results');
+    }
+}
+/**
+ * Show augmentation details
+ */
+export async function infoCommand(marketplace, nameOrId) {
+    // Check if it's installed locally first
+    const installed = marketplace.getInstalled().find(a => a.name === nameOrId);
+    if (installed) {
+        console.log('\n📦 Installed Augmentation:');
+        console.log('=========================\n');
+        console.log(`Name: ${installed.name}`);
+        console.log(`Version: ${installed.version}`);
+        console.log(`Status: ${installed.enabled ? 'Enabled' : 'Disabled'}`);
+        console.log(`Auto-update: ${installed.autoUpdate ? 'Yes' : 'No'}`);
+        console.log(`Installed: ${new Date(installed.installedAt).toLocaleString()}`);
+        console.log(`Path: ${installed.path}`);
+        if (installed.cloudId) {
+            console.log('\nFetching cloud details...');
+            try {
+                const cloudAug = await marketplace.getCloudDetails(installed.cloudId);
+                console.log('\n' + formatAugmentation(cloudAug));
+                if (cloudAug.documentationUrl) {
+                    console.log(`\n📚 Documentation: ${cloudAug.documentationUrl}`);
+                }
+                if (cloudAug.repositoryUrl) {
+                    console.log(`📦 Repository: ${cloudAug.repositoryUrl}`);
+                }
+                if (cloudAug.supportUrl) {
+                    console.log(`🆘 Support: ${cloudAug.supportUrl}`);
+                }
+            }
+            catch (error) {
+                console.log('Could not fetch cloud details');
+            }
+        }
+    }
+    else {
+        // Try to find in cloud
+        try {
+            const cloudAug = await marketplace.getCloudDetails(nameOrId);
+            console.log('\n☁️  Cloud Augmentation:');
+            console.log('=====================\n');
+            console.log(formatAugmentation(cloudAug));
+            if (cloudAug.longDescription) {
+                console.log(`\n${cloudAug.longDescription}`);
+            }
+            if (cloudAug.requirements.length > 0) {
+                console.log('\n📋 Requirements:');
+                cloudAug.requirements.forEach(req => console.log(`  - ${req}`));
+            }
+            if (cloudAug.permissions.length > 0) {
+                console.log('\n🔐 Permissions:');
+                cloudAug.permissions.forEach(perm => console.log(`  - ${perm}`));
+            }
+            if (cloudAug.documentationUrl) {
+                console.log(`\n📚 Documentation: ${cloudAug.documentationUrl}`);
+            }
+            if (cloudAug.repositoryUrl) {
+                console.log(`📦 Repository: ${cloudAug.repositoryUrl}`);
+            }
+            if (cloudAug.supportUrl) {
+                console.log(`🆘 Support: ${cloudAug.supportUrl}`);
+            }
+            console.log('\nTo install, run: brainy augment install ' + nameOrId);
+        }
+        catch (error) {
+            console.error(`Augmentation "${nameOrId}" not found`);
+        }
+    }
+}
+/**
+ * Install augmentation
+ */
+export async function installCommand(marketplace, nameOrId, options = {}) {
+    console.log(`Installing ${nameOrId}...`);
+    try {
+        const installed = await marketplace.installFromCloud(nameOrId, {
+            version: options.version,
+            enable: !options.noEnable,
+            autoUpdate: !options.noAutoUpdate
+        });
+        console.log(`✅ Successfully installed ${installed.name} v${installed.version}`);
+        if (installed.enabled) {
+            console.log('   Augmentation is enabled and ready to use');
+        }
+        else {
+            console.log('   Run "brainy augment enable ' + installed.name + '" to enable');
+        }
+    }
+    catch (error) {
+        console.error(`❌ Failed to install: ${error.message}`);
+        process.exit(1);
+    }
+}
+/**
+ * Uninstall augmentation
+ */
+export async function uninstallCommand(marketplace, name) {
+    console.log(`Uninstalling ${name}...`);
+    try {
+        await marketplace.uninstall(name);
+        console.log(`✅ Successfully uninstalled ${name}`);
+    }
+    catch (error) {
+        console.error(`❌ Failed to uninstall: ${error.message}`);
+        process.exit(1);
+    }
+}
+/**
+ * Enable augmentation
+ */
+export async function enableCommand(marketplace, name) {
+    try {
+        await marketplace.enable(name);
+        console.log(`✅ Enabled ${name}`);
+    }
+    catch (error) {
+        console.error(`❌ Failed to enable: ${error.message}`);
+        process.exit(1);
+    }
+}
+/**
+ * Disable augmentation
+ */
+export async function disableCommand(marketplace, name) {
+    try {
+        await marketplace.disable(name);
+        console.log(`✅ Disabled ${name}`);
+    }
+    catch (error) {
+        console.error(`❌ Failed to disable: ${error.message}`);
+        process.exit(1);
+    }
+}
+/**
+ * Update augmentation
+ */
+export async function updateCommand(marketplace, name) {
+    if (name) {
+        // Update specific augmentation
+        console.log(`Updating ${name}...`);
+        try {
+            await marketplace.update(name);
+            console.log(`✅ Successfully updated ${name}`);
+        }
+        catch (error) {
+            console.error(`❌ Failed to update: ${error.message}`);
+            process.exit(1);
+        }
+    }
+    else {
+        // Update all augmentations
+        console.log('Checking for updates...');
+        const updates = await marketplace.checkForUpdates();
+        if (updates.length === 0) {
+            console.log('All augmentations are up to date ✨');
+            return;
+        }
+        console.log(`Found ${updates.length} update(s)`);
+        for (const update of updates) {
+            console.log(`\nUpdating ${update.augmentation.name}: ${update.augmentation.version} → ${update.newVersion}`);
+            try {
+                await marketplace.update(update.augmentation.name);
+                console.log(`✅ Updated successfully`);
+            }
+            catch (error) {
+                console.error(`❌ Failed: ${error.message}`);
+            }
+        }
+    }
+}
+//# sourceMappingURL=cli.js.map

package/dist/augmentations/metricsAugmentation.d.ts

@@ -1,7 +1,7 @@
 /**
  * Metrics Augmentation - Optional Performance & Usage Metrics
  *
- * Replaces the hardcoded StatisticsCollector in BrainyData with an optional augmentation.
+ * Replaces the hardcoded StatisticsCollector in Brainy with an optional augmentation.
  * Tracks performance metrics, usage patterns, and system statistics.
  *
  * Zero-config: Automatically enabled for observability
@@ -30,10 +30,10 @@ export declare class MetricsAugmentation extends BaseAugmentation {
     readonly metadata: "readonly";
     readonly name = "metrics";
     readonly timing: "after";
-    operations: ("add" | "search" | "delete" | "clear" | "all")[];
+    operations: ("add" | "update" | "search" | "find" | "similar" | "delete" | "relate" | "unrelate" | "clear" | "all")[];
     readonly priority = 40;
     private statisticsCollector;
-    private config;
+    protected config: MetricsConfig;
     private metricsTimer;
     constructor(config?: MetricsConfig);
     protected onInitialize(): Promise<void>;

package/dist/augmentations/metricsAugmentation.js

@@ -1,7 +1,7 @@
 /**
  * Metrics Augmentation - Optional Performance & Usage Metrics
  *
- * Replaces the hardcoded StatisticsCollector in BrainyData with an optional augmentation.
+ * Replaces the hardcoded StatisticsCollector in Brainy with an optional augmentation.
  * Tracks performance metrics, usage patterns, and system statistics.
  *
  * Zero-config: Automatically enabled for observability
@@ -24,7 +24,7 @@ export class MetricsAugmentation extends BaseAugmentation {
         this.metadata = 'readonly'; // Reads metadata for metrics
         this.name = 'metrics';
         this.timing = 'after';
-        this.operations = ['add', 'search', 'delete', 'clear', 'all'];
+        this.operations = ['add', 'update', 'search', 'find', 'similar', 'delete', 'relate', 'unrelate', 'clear', 'all'];
         this.priority = 40; // Low priority, runs after other augmentations
         this.statisticsCollector = null;
         this.metricsTimer = null;

package/dist/augmentations/monitoringAugmentation.d.ts

@@ -1,7 +1,7 @@
 /**
  * Monitoring Augmentation - Optional Health & Performance Monitoring
  *
- * Replaces the hardcoded HealthMonitor in BrainyData with an optional augmentation.
+ * Replaces the hardcoded HealthMonitor in Brainy with an optional augmentation.
  * Provides health checks, performance monitoring, and distributed system tracking.
  *
  * Zero-config: Automatically enabled for distributed deployments
@@ -31,11 +31,11 @@ export declare class MonitoringAugmentation extends BaseAugmentation {
     readonly metadata: "readonly";
     readonly name = "monitoring";
     readonly timing: "after";
-    operations: ("search" | "add" | "delete" | "all")[];
+    operations: ("search" | "find" | "similar" | "add" | "update" | "delete" | "relate" | "unrelate" | "all")[];
     readonly priority = 30;
     private healthMonitor;
     private configManager;
-    private config;
+    protected config: MonitoringConfig;
     private requestStartTimes;
     constructor(config?: MonitoringConfig);
     protected onInitialize(): Promise<void>;

package/dist/augmentations/monitoringAugmentation.js

@@ -1,7 +1,7 @@
 /**
  * Monitoring Augmentation - Optional Health & Performance Monitoring
  *
- * Replaces the hardcoded HealthMonitor in BrainyData with an optional augmentation.
+ * Replaces the hardcoded HealthMonitor in Brainy with an optional augmentation.
  * Provides health checks, performance monitoring, and distributed system tracking.
  *
  * Zero-config: Automatically enabled for distributed deployments
@@ -26,7 +26,7 @@ export class MonitoringAugmentation extends BaseAugmentation {
         this.metadata = 'readonly'; // Reads metadata for monitoring
         this.name = 'monitoring';
         this.timing = 'after';
-        this.operations = ['search', 'add', 'delete', 'all'];
+        this.operations = ['search', 'find', 'similar', 'add', 'update', 'delete', 'relate', 'unrelate', 'all'];
         this.priority = 30; // Low priority, observability layer
         this.healthMonitor = null;
         this.configManager = null;

package/dist/augmentations/neuralImport.d.ts

@@ -61,7 +61,7 @@ export declare class NeuralImportAugmentation extends BaseAugmentation {
     };
     operations: ("add" | "addNoun" | "addVerb" | "all")[];
     readonly priority = 80;
-    private config;
+    protected config: NeuralImportConfig;
     private analysisCache;
     private typeMatcher;
     constructor(config?: Partial<NeuralImportConfig>);

package/dist/augmentations/neuralImport.js

@@ -8,7 +8,7 @@
  */
 import { BaseAugmentation } from './brainyAugmentation.js';
 import * as path from '../universal/path.js';
-import { getTypeMatcher } from './typeMatching/intelligentTypeMatcher.js';
+import { getBrainyTypes } from './typeMatching/brainyTypes.js';
 import { prodLog } from '../utils/logger.js';
 /**
  * Neural Import Augmentation - Unified Implementation
@@ -37,7 +37,7 @@ export class NeuralImportAugmentation extends BaseAugmentation {
     }
     async onInitialize() {
         try {
-            this.typeMatcher = await getTypeMatcher();
+            this.typeMatcher = await getBrainyTypes();
             this.log('🧠 Neural Import augmentation initialized with intelligent type matching');
         }
         catch (error) {
@@ -378,7 +378,7 @@ export class NeuralImportAugmentation extends BaseAugmentation {
     async inferNounType(obj) {
         if (!this.typeMatcher) {
             // Initialize type matcher if not available
-            this.typeMatcher = await getTypeMatcher();
+            this.typeMatcher = await getBrainyTypes();
         }
         const result = await this.typeMatcher.matchNounType(obj);
         // Log if confidence is low for debugging
@@ -428,7 +428,7 @@ export class NeuralImportAugmentation extends BaseAugmentation {
     async inferVerbType(fieldName, sourceObj, targetObj) {
         if (!this.typeMatcher) {
             // Initialize type matcher if not available
-            this.typeMatcher = await getTypeMatcher();
+            this.typeMatcher = await getBrainyTypes();
         }
         const result = await this.typeMatcher.matchVerbType(sourceObj, targetObj, fieldName);
         // Log if confidence is low for debugging

package/dist/augmentations/rateLimitAugmentation.d.ts

@@ -0,0 +1,82 @@
+/**
+ * Rate Limiting Augmentation
+ * Provides configurable rate limiting for Brainy operations
+ */
+import { BaseAugmentation } from './brainyAugmentation.js';
+import { AugmentationManifest } from './manifest.js';
+export interface RateLimitConfig {
+    enabled?: boolean;
+    limits?: {
+        searches?: number;
+        writes?: number;
+        reads?: number;
+        deletes?: number;
+    };
+    windowMs?: number;
+    skipSuccessfulRequests?: boolean;
+    skipFailedRequests?: boolean;
+    keyGenerator?: (context: any) => string;
+}
+/**
+ * Rate Limit Augmentation
+ */
+export declare class RateLimitAugmentation extends BaseAugmentation {
+    readonly name = "rateLimiter";
+    readonly timing: "before";
+    readonly metadata: "none";
+    operations: any;
+    readonly priority = 10;
+    readonly category: "core";
+    readonly description = "Provides rate limiting for Brainy operations";
+    private limiters;
+    private windowMs;
+    constructor(config?: RateLimitConfig);
+    getManifest(): AugmentationManifest;
+    /**
+     * Initialize rate limiters for each operation type
+     */
+    private initializeLimiters;
+    /**
+     * Default key generator (could be IP, user ID, etc.)
+     */
+    private defaultKeyGenerator;
+    /**
+     * Check if request should be rate limited
+     */
+    private checkRateLimit;
+    /**
+     * Get remaining requests for an operation
+     */
+    private getRemainingRequests;
+    /**
+     * Get time until reset
+     */
+    private getResetTime;
+    protected onInitialize(): Promise<void>;
+    protected onShutdown(): Promise<void>;
+    /**
+     * Execute augmentation - apply rate limiting
+     */
+    execute<T = any>(operation: string, params: any, next: () => Promise<T>): Promise<T>;
+    /**
+     * Get rate limit statistics
+     */
+    getStats(): {
+        operations: Record<string, {
+            activeKeys: number;
+            totalRequests: number;
+        }>;
+    };
+    /**
+     * Clear all rate limit entries
+     */
+    clear(): void;
+    /**
+     * Clear expired entries (cleanup)
+     */
+    cleanup(): void;
+}
+/**
+ * Create rate limit augmentation
+ */
+export declare function createRateLimitAugmentation(config?: RateLimitConfig): RateLimitAugmentation;