@soulcraft/brainy 3.0.0 → 3.0.1

package/dist/augmentations/marketplace/AugmentationMarketplace.d.ts

@@ -0,0 +1,168 @@
+/**
+ * Augmentation Marketplace
+ *
+ * A VS Code/WebStorm-style plugin marketplace for Brainy augmentations
+ * Integrates with Soulcraft Brain-Cloud API for premium augmentations
+ *
+ * Features:
+ * - Browse and search augmentations
+ * - Install from cloud registry
+ * - Manage local augmentations
+ * - Auto-updates and licensing
+ */
+import { AugmentationManifest } from '../manifest.js';
+/**
+ * Cloud augmentation metadata from Brain-Cloud API
+ */
+export interface CloudAugmentation {
+    id: string;
+    name: string;
+    displayName: string;
+    author: string;
+    authorUrl?: string;
+    version: string;
+    description: string;
+    longDescription?: string;
+    category: 'premium' | 'community' | 'official' | 'enterprise';
+    tags: string[];
+    price?: number;
+    currency?: string;
+    rating: number;
+    reviews: number;
+    downloads: number;
+    lastUpdated: string;
+    minBrainyVersion: string;
+    maxBrainyVersion?: string;
+    requirements: string[];
+    permissions: string[];
+    screenshots?: string[];
+    repositoryUrl?: string;
+    documentationUrl?: string;
+    supportUrl?: string;
+    license: string;
+    size: number;
+}
+/**
+ * Local augmentation installation info
+ */
+export interface InstalledAugmentation {
+    id: string;
+    name: string;
+    version: string;
+    installedAt: string;
+    installedFrom: 'local' | 'cloud' | 'file';
+    cloudId?: string;
+    enabled: boolean;
+    autoUpdate: boolean;
+    config?: Record<string, any>;
+    path: string;
+}
+/**
+ * Installation options
+ */
+export interface InstallOptions {
+    version?: string;
+    autoUpdate?: boolean;
+    enable?: boolean;
+    config?: Record<string, any>;
+}
+/**
+ * Search filters
+ */
+export interface SearchFilters {
+    category?: CloudAugmentation['category'];
+    tags?: string[];
+    minRating?: number;
+    free?: boolean;
+    verified?: boolean;
+    compatible?: boolean;
+}
+/**
+ * Marketplace configuration
+ */
+export interface MarketplaceConfig {
+    apiUrl?: string;
+    apiKey?: string;
+    cacheDir?: string;
+    augmentationsDir?: string;
+    autoUpdate?: boolean;
+    checkInterval?: number;
+}
+/**
+ * Augmentation Marketplace - Main class
+ */
+export declare class AugmentationMarketplace {
+    private config;
+    private installedCache;
+    private cloudCache;
+    private updateCheckTimer?;
+    constructor(config?: MarketplaceConfig);
+    /**
+     * Get all installed augmentations
+     */
+    getInstalled(): InstalledAugmentation[];
+    /**
+     * Get available local augmentations (built-in)
+     */
+    getAvailableLocal(): Promise<AugmentationManifest[]>;
+    /**
+     * Search cloud registry
+     */
+    searchCloud(query?: string, filters?: SearchFilters, page?: number, limit?: number): Promise<{
+        results: CloudAugmentation[];
+        total: number;
+        page: number;
+        pages: number;
+    }>;
+    /**
+     * Get detailed information about a cloud augmentation
+     */
+    getCloudDetails(id: string): Promise<CloudAugmentation>;
+    /**
+     * Install augmentation from cloud
+     */
+    installFromCloud(id: string, options?: InstallOptions): Promise<InstalledAugmentation>;
+    /**
+     * Install from local file
+     */
+    installFromFile(filePath: string, options?: InstallOptions): Promise<InstalledAugmentation>;
+    /**
+     * Enable an installed augmentation
+     */
+    enable(name: string): Promise<void>;
+    /**
+     * Disable an installed augmentation
+     */
+    disable(name: string): Promise<void>;
+    /**
+     * Uninstall an augmentation
+     */
+    uninstall(name: string): Promise<void>;
+    /**
+     * Update an augmentation
+     */
+    update(name: string): Promise<void>;
+    /**
+     * Check for updates for all installed augmentations
+     */
+    checkForUpdates(): Promise<Array<{
+        augmentation: InstalledAugmentation;
+        newVersion: string;
+    }>>;
+    private getBrainyVersion;
+    private isCompatible;
+    private getInstalledByName;
+    private getInstalledByCloudId;
+    private downloadPackage;
+    private extractPackage;
+    private loadAugmentation;
+    private unloadAugmentation;
+    private removeAugmentationFiles;
+    private loadInstalledAugmentations;
+    private saveInstalledAugmentations;
+    private startUpdateChecker;
+    /**
+     * Cleanup resources
+     */
+    destroy(): void;
+}

package/dist/augmentations/marketplace/AugmentationMarketplace.js

@@ -0,0 +1,329 @@
+/**
+ * Augmentation Marketplace
+ *
+ * A VS Code/WebStorm-style plugin marketplace for Brainy augmentations
+ * Integrates with Soulcraft Brain-Cloud API for premium augmentations
+ *
+ * Features:
+ * - Browse and search augmentations
+ * - Install from cloud registry
+ * - Manage local augmentations
+ * - Auto-updates and licensing
+ */
+import { v4 as uuidv4 } from '../../universal/uuid.js';
+/**
+ * Augmentation Marketplace - Main class
+ */
+export class AugmentationMarketplace {
+    constructor(config = {}) {
+        this.installedCache = new Map();
+        this.cloudCache = new Map();
+        this.config = {
+            apiUrl: config.apiUrl || 'https://api.brain-cloud.soulcraft.com/v1',
+            apiKey: config.apiKey || process.env.BRAIN_CLOUD_API_KEY || '',
+            cacheDir: config.cacheDir || '.brainy/cache',
+            augmentationsDir: config.augmentationsDir || '.brainy/augmentations',
+            autoUpdate: config.autoUpdate ?? true,
+            checkInterval: config.checkInterval || 24 * 60 * 60 * 1000 // 24 hours
+        };
+        this.loadInstalledAugmentations();
+        if (this.config.autoUpdate) {
+            this.startUpdateChecker();
+        }
+    }
+    /**
+     * Get all installed augmentations
+     */
+    getInstalled() {
+        return Array.from(this.installedCache.values());
+    }
+    /**
+     * Get available local augmentations (built-in)
+     */
+    async getAvailableLocal() {
+        // Import and return built-in augmentations
+        const { createDefaultAugmentations } = await import('../defaultAugmentations.js');
+        const augmentations = createDefaultAugmentations();
+        return augmentations.map(aug => aug.getManifest());
+    }
+    /**
+     * Search cloud registry
+     */
+    async searchCloud(query = '', filters = {}, page = 1, limit = 20) {
+        const params = new URLSearchParams({
+            q: query,
+            page: page.toString(),
+            limit: limit.toString()
+        });
+        // Add filters
+        if (filters.category)
+            params.append('category', filters.category);
+        if (filters.tags)
+            filters.tags.forEach(tag => params.append('tag', tag));
+        if (filters.minRating)
+            params.append('minRating', filters.minRating.toString());
+        if (filters.free !== undefined)
+            params.append('free', filters.free.toString());
+        if (filters.verified !== undefined)
+            params.append('verified', filters.verified.toString());
+        if (filters.compatible !== undefined)
+            params.append('compatible', filters.compatible.toString());
+        const response = await fetch(`${this.config.apiUrl}/augmentations?${params}`, {
+            headers: {
+                'Authorization': `Bearer ${this.config.apiKey}`,
+                'Content-Type': 'application/json'
+            }
+        });
+        if (!response.ok) {
+            throw new Error(`Failed to search augmentations: ${response.statusText}`);
+        }
+        const data = await response.json();
+        // Cache results
+        data.results.forEach((aug) => {
+            this.cloudCache.set(aug.id, aug);
+        });
+        return data;
+    }
+    /**
+     * Get detailed information about a cloud augmentation
+     */
+    async getCloudDetails(id) {
+        // Check cache first
+        if (this.cloudCache.has(id)) {
+            return this.cloudCache.get(id);
+        }
+        const response = await fetch(`${this.config.apiUrl}/augmentations/${id}`, {
+            headers: {
+                'Authorization': `Bearer ${this.config.apiKey}`,
+                'Content-Type': 'application/json'
+            }
+        });
+        if (!response.ok) {
+            throw new Error(`Failed to get augmentation details: ${response.statusText}`);
+        }
+        const augmentation = await response.json();
+        this.cloudCache.set(id, augmentation);
+        return augmentation;
+    }
+    /**
+     * Install augmentation from cloud
+     */
+    async installFromCloud(id, options = {}) {
+        // Get augmentation details
+        const cloudAug = await this.getCloudDetails(id);
+        // Check compatibility
+        const brainyVersion = await this.getBrainyVersion();
+        if (!this.isCompatible(cloudAug, brainyVersion)) {
+            throw new Error(`Augmentation ${cloudAug.name} is not compatible with Brainy ${brainyVersion}`);
+        }
+        // Check if already installed
+        const existing = this.getInstalledByCloudId(id);
+        if (existing) {
+            throw new Error(`Augmentation ${cloudAug.name} is already installed`);
+        }
+        // Download augmentation package
+        const packageData = await this.downloadPackage(id);
+        // Extract and install
+        const installPath = await this.extractPackage(packageData, cloudAug);
+        // Create installation record
+        const installed = {
+            id: uuidv4(),
+            name: cloudAug.name,
+            version: options.version || cloudAug.version,
+            installedAt: new Date().toISOString(),
+            installedFrom: 'cloud',
+            cloudId: id,
+            enabled: options.enable ?? true,
+            autoUpdate: options.autoUpdate ?? this.config.autoUpdate,
+            config: options.config,
+            path: installPath
+        };
+        // Save installation info
+        this.installedCache.set(installed.id, installed);
+        await this.saveInstalledAugmentations();
+        // Load and initialize if enabled
+        if (installed.enabled) {
+            await this.loadAugmentation(installed);
+        }
+        return installed;
+    }
+    /**
+     * Install from local file
+     */
+    async installFromFile(filePath, options = {}) {
+        // Implementation for installing from local .brainy-aug file
+        throw new Error('Not implemented yet');
+    }
+    /**
+     * Enable an installed augmentation
+     */
+    async enable(name) {
+        const augmentation = this.getInstalledByName(name);
+        if (!augmentation) {
+            throw new Error(`Augmentation ${name} not found`);
+        }
+        augmentation.enabled = true;
+        await this.saveInstalledAugmentations();
+        await this.loadAugmentation(augmentation);
+    }
+    /**
+     * Disable an installed augmentation
+     */
+    async disable(name) {
+        const augmentation = this.getInstalledByName(name);
+        if (!augmentation) {
+            throw new Error(`Augmentation ${name} not found`);
+        }
+        augmentation.enabled = false;
+        await this.saveInstalledAugmentations();
+        await this.unloadAugmentation(augmentation);
+    }
+    /**
+     * Uninstall an augmentation
+     */
+    async uninstall(name) {
+        const augmentation = this.getInstalledByName(name);
+        if (!augmentation) {
+            throw new Error(`Augmentation ${name} not found`);
+        }
+        // Unload if loaded
+        if (augmentation.enabled) {
+            await this.unloadAugmentation(augmentation);
+        }
+        // Remove files
+        await this.removeAugmentationFiles(augmentation);
+        // Remove from cache
+        this.installedCache.delete(augmentation.id);
+        await this.saveInstalledAugmentations();
+    }
+    /**
+     * Update an augmentation
+     */
+    async update(name) {
+        const augmentation = this.getInstalledByName(name);
+        if (!augmentation) {
+            throw new Error(`Augmentation ${name} not found`);
+        }
+        if (!augmentation.cloudId) {
+            throw new Error(`Augmentation ${name} was not installed from cloud`);
+        }
+        // Check for updates
+        const cloudAug = await this.getCloudDetails(augmentation.cloudId);
+        if (cloudAug.version === augmentation.version) {
+            throw new Error(`Augmentation ${name} is already up to date`);
+        }
+        // Uninstall old version
+        await this.uninstall(name);
+        // Install new version
+        await this.installFromCloud(augmentation.cloudId, {
+            enable: augmentation.enabled,
+            autoUpdate: augmentation.autoUpdate,
+            config: augmentation.config
+        });
+    }
+    /**
+     * Check for updates for all installed augmentations
+     */
+    async checkForUpdates() {
+        const updates = [];
+        for (const augmentation of this.installedCache.values()) {
+            if (!augmentation.cloudId)
+                continue;
+            try {
+                const cloudAug = await this.getCloudDetails(augmentation.cloudId);
+                if (cloudAug.version !== augmentation.version) {
+                    updates.push({
+                        augmentation,
+                        newVersion: cloudAug.version
+                    });
+                }
+            }
+            catch (error) {
+                console.warn(`Failed to check updates for ${augmentation.name}:`, error);
+            }
+        }
+        return updates;
+    }
+    // Private helper methods
+    async getBrainyVersion() {
+        // Get Brainy version from package.json
+        try {
+            const packageJson = await import('../../../package.json');
+            return packageJson.version;
+        }
+        catch {
+            return '0.0.0';
+        }
+    }
+    isCompatible(augmentation, brainyVersion) {
+        // Simple version comparison - can be enhanced
+        return true; // TODO: Implement proper semver comparison
+    }
+    getInstalledByName(name) {
+        return Array.from(this.installedCache.values()).find(a => a.name === name);
+    }
+    getInstalledByCloudId(cloudId) {
+        return Array.from(this.installedCache.values()).find(a => a.cloudId === cloudId);
+    }
+    async downloadPackage(id) {
+        const response = await fetch(`${this.config.apiUrl}/augmentations/${id}/download`, {
+            headers: {
+                'Authorization': `Bearer ${this.config.apiKey}`
+            }
+        });
+        if (!response.ok) {
+            throw new Error(`Failed to download augmentation: ${response.statusText}`);
+        }
+        return response.arrayBuffer();
+    }
+    async extractPackage(packageData, cloudAug) {
+        // Extract package to augmentations directory
+        // This would use tar/zip extraction in real implementation
+        const installPath = `${this.config.augmentationsDir}/${cloudAug.name}-${cloudAug.version}`;
+        // TODO: Implement actual extraction
+        return installPath;
+    }
+    async loadAugmentation(augmentation) {
+        // Dynamically import and register the augmentation
+        // TODO: Implement dynamic loading
+    }
+    async unloadAugmentation(augmentation) {
+        // Unregister the augmentation from the system
+        // TODO: Implement unloading
+    }
+    async removeAugmentationFiles(augmentation) {
+        // Remove augmentation files from disk
+        // TODO: Implement file removal
+    }
+    async loadInstalledAugmentations() {
+        // Load installed augmentations from disk
+        // TODO: Implement loading from disk
+    }
+    async saveInstalledAugmentations() {
+        // Save installed augmentations to disk
+        // TODO: Implement saving to disk
+    }
+    startUpdateChecker() {
+        this.updateCheckTimer = setInterval(async () => {
+            try {
+                const updates = await this.checkForUpdates();
+                if (updates.length > 0) {
+                    console.log(`Found ${updates.length} augmentation updates available`);
+                    // Could emit an event or callback here
+                }
+            }
+            catch (error) {
+                console.warn('Failed to check for augmentation updates:', error);
+            }
+        }, this.config.checkInterval);
+    }
+    /**
+     * Cleanup resources
+     */
+    destroy() {
+        if (this.updateCheckTimer) {
+            clearInterval(this.updateCheckTimer);
+        }
+    }
+}
+//# sourceMappingURL=AugmentationMarketplace.js.map

package/dist/augmentations/marketplace/cli.d.ts

@@ -0,0 +1,47 @@
+/**
+ * Augmentation Marketplace CLI Commands
+ *
+ * Provides command-line interface for managing augmentations
+ * Similar to npm/yarn but for Brainy augmentations
+ */
+import { AugmentationMarketplace } from './AugmentationMarketplace.js';
+/**
+ * List installed augmentations
+ */
+export declare function listCommand(marketplace: AugmentationMarketplace): Promise<void>;
+/**
+ * Search cloud registry
+ */
+export declare function searchCommand(marketplace: AugmentationMarketplace, query: string, options?: {
+    category?: string;
+    free?: boolean;
+    limit?: number;
+}): Promise<void>;
+/**
+ * Show augmentation details
+ */
+export declare function infoCommand(marketplace: AugmentationMarketplace, nameOrId: string): Promise<void>;
+/**
+ * Install augmentation
+ */
+export declare function installCommand(marketplace: AugmentationMarketplace, nameOrId: string, options?: {
+    version?: string;
+    noEnable?: boolean;
+    noAutoUpdate?: boolean;
+}): Promise<void>;
+/**
+ * Uninstall augmentation
+ */
+export declare function uninstallCommand(marketplace: AugmentationMarketplace, name: string): Promise<void>;
+/**
+ * Enable augmentation
+ */
+export declare function enableCommand(marketplace: AugmentationMarketplace, name: string): Promise<void>;
+/**
+ * Disable augmentation
+ */
+export declare function disableCommand(marketplace: AugmentationMarketplace, name: string): Promise<void>;
+/**
+ * Update augmentation
+ */
+export declare function updateCommand(marketplace: AugmentationMarketplace, name?: string): Promise<void>;