monomind 1.9.16 → 1.10.0

package/packages/@monomind/cli/dist/src/transfer/store/registry.js

@@ -1,301 +0,0 @@
-/**
- * Decentralized Pattern Registry
- * IPFS-based registry with IPNS for mutable references
- */
-import * as crypto from 'crypto';
-/**
- * Registry version
- */
-export const REGISTRY_VERSION = '1.0.0';
-/**
- * Default bootstrap registries for discovery
- */
-export const BOOTSTRAP_REGISTRIES = [
-    {
-        name: 'monomind-official',
-        description: 'Official Monomind pattern registry',
-        ipnsName: 'k51qzi5uqu5dj0w8q1xvqn8ql2g4p7x8qpk9vz3xm1y2n3o4p5q6r7s8t9u0v',
-        gateway: 'https://w3s.link',
-        publicKey: 'ed25519:monomind-registry-key',
-        trusted: true,
-    },
-    {
-        name: 'community-patterns',
-        description: 'Community-contributed patterns',
-        ipnsName: 'k51qzi5uqu5dkkph0w8q1xvqn8ql2g4p7x8qpk9vz3xm1y2n3o4p5q6r7s8',
-        gateway: 'https://dweb.link',
-        publicKey: 'ed25519:community-registry-key',
-        trusted: false,
-    },
-];
-/**
- * Default store configuration
- */
-export const DEFAULT_STORE_CONFIG = {
-    registries: BOOTSTRAP_REGISTRIES,
-    defaultRegistry: 'monomind-official',
-    gateway: 'https://w3s.link',
-    timeout: 30000,
-    cacheDir: '.monomind/patterns/cache',
-    cacheExpiry: 3600000, // 1 hour
-    // Default to true: tampered downloads must be rejected, not warned about.
-    // Override with --allow-unverified flag for explicit developer-only use.
-    requireVerification: true,
-    minTrustLevel: 'unverified',
-    trustedAuthors: [],
-    blockedPatterns: [],
-};
-/**
- * Create a new empty registry
- */
-export function createRegistry(ipnsName) {
-    return {
-        version: REGISTRY_VERSION,
-        updatedAt: new Date().toISOString(),
-        ipnsName,
-        patterns: [],
-        categories: getDefaultCategories(),
-        authors: [],
-        totalPatterns: 0,
-        totalDownloads: 0,
-        totalAuthors: 0,
-        featured: [],
-        trending: [],
-        newest: [],
-    };
-}
-/**
- * Default pattern categories
- */
-export function getDefaultCategories() {
-    return [
-        {
-            id: 'routing',
-            name: 'Task Routing',
-            description: 'Patterns for routing tasks to appropriate agents',
-            patternCount: 0,
-            icon: '🔀',
-        },
-        {
-            id: 'coordination',
-            name: 'Swarm Coordination',
-            description: 'Multi-agent coordination and communication patterns',
-            patternCount: 0,
-            icon: '🐝',
-        },
-        {
-            id: 'security',
-            name: 'Security',
-            description: 'Security analysis and vulnerability detection patterns',
-            patternCount: 0,
-            icon: '🔒',
-        },
-        {
-            id: 'performance',
-            name: 'Performance',
-            description: 'Performance optimization and profiling patterns',
-            patternCount: 0,
-            icon: '⚡',
-        },
-        {
-            id: 'testing',
-            name: 'Testing',
-            description: 'Test generation and quality assurance patterns',
-            patternCount: 0,
-            icon: '🧪',
-        },
-        {
-            id: 'documentation',
-            name: 'Documentation',
-            description: 'Documentation generation and maintenance patterns',
-            patternCount: 0,
-            icon: '📚',
-        },
-        {
-            id: 'refactoring',
-            name: 'Refactoring',
-            description: 'Code refactoring and improvement patterns',
-            patternCount: 0,
-            icon: '🔧',
-        },
-        {
-            id: 'language',
-            name: 'Language-Specific',
-            description: 'Patterns optimized for specific programming languages',
-            patternCount: 0,
-            icon: '💻',
-            subcategories: [
-                { id: 'typescript', name: 'TypeScript', description: 'TypeScript patterns', patternCount: 0 },
-                { id: 'python', name: 'Python', description: 'Python patterns', patternCount: 0 },
-                { id: 'rust', name: 'Rust', description: 'Rust patterns', patternCount: 0 },
-                { id: 'go', name: 'Go', description: 'Go patterns', patternCount: 0 },
-            ],
-        },
-        {
-            id: 'framework',
-            name: 'Framework-Specific',
-            description: 'Patterns for specific frameworks',
-            patternCount: 0,
-            icon: '🏗️',
-            subcategories: [
-                { id: 'react', name: 'React', description: 'React patterns', patternCount: 0 },
-                { id: 'nextjs', name: 'Next.js', description: 'Next.js patterns', patternCount: 0 },
-                { id: 'node', name: 'Node.js', description: 'Node.js patterns', patternCount: 0 },
-            ],
-        },
-    ];
-}
-/**
- * Add a pattern to the registry
- */
-export function addPatternToRegistry(registry, entry) {
-    const updated = { ...registry, patterns: [...registry.patterns], authors: [...registry.authors], categories: registry.categories.map(c => ({ ...c })) };
-    // Check for existing pattern with same name
-    const existingIndex = updated.patterns.findIndex(p => p.name === entry.name);
-    if (existingIndex >= 0) {
-        // Update existing
-        updated.patterns[existingIndex] = entry;
-    }
-    else {
-        // Add new
-        updated.patterns.push(entry);
-    }
-    // Update author
-    const authorIndex = updated.authors.findIndex(a => a.id === entry.author.id);
-    if (authorIndex >= 0) {
-        updated.authors[authorIndex].patterns++;
-    }
-    else {
-        updated.authors.push(entry.author);
-    }
-    // Update category counts
-    for (const cat of updated.categories) {
-        cat.patternCount = updated.patterns.filter(p => p.categories.includes(cat.id)).length;
-    }
-    // Update stats
-    updated.totalPatterns = updated.patterns.length;
-    updated.totalAuthors = updated.authors.length;
-    updated.updatedAt = new Date().toISOString();
-    // Update newest
-    updated.newest = updated.patterns
-        .sort((a, b) => new Date(b.createdAt).getTime() - new Date(a.createdAt).getTime())
-        .slice(0, 10)
-        .map(p => p.id);
-    // Update trending (by recent downloads - simplified)
-    updated.trending = updated.patterns
-        .sort((a, b) => b.downloads - a.downloads)
-        .slice(0, 10)
-        .map(p => p.id);
-    return updated;
-}
-/**
- * Remove a pattern from the registry
- */
-export function removePatternFromRegistry(registry, patternId) {
-    const updated = { ...registry };
-    updated.patterns = updated.patterns.filter(p => p.id !== patternId);
-    updated.totalPatterns = updated.patterns.length;
-    updated.updatedAt = new Date().toISOString();
-    return updated;
-}
-/**
- * Serialize registry to JSON
- */
-export function serializeRegistry(registry) {
-    return JSON.stringify(registry, null, 2);
-}
-/**
- * Deserialize registry from JSON
- */
-export function deserializeRegistry(json) {
-    const registry = JSON.parse(json);
-    // Validate version
-    if (!registry.version) {
-        throw new Error('Invalid registry: missing version');
-    }
-    return registry;
-}
-/**
- * Sign registry with private key
- */
-export async function signRegistry(registry, privateKey) {
-    const content = JSON.stringify({
-        version: registry.version,
-        updatedAt: registry.updatedAt,
-        patterns: registry.patterns.map(p => p.cid),
-        totalPatterns: registry.totalPatterns,
-    });
-    const ed = await import('@noble/ed25519');
-    const privKeyBytes = privateKey.length === 64
-        ? Buffer.from(privateKey, 'hex')
-        : crypto.createHash('sha256').update(privateKey).digest();
-    const pubKeyBytes = await ed.getPublicKeyAsync(privKeyBytes);
-    const sigBytes = await ed.signAsync(Buffer.from(content), privKeyBytes);
-    return {
-        ...registry,
-        registrySignature: 'ed25519:' + Buffer.from(sigBytes).toString('hex'),
-        registryPublicKey: 'ed25519:' + Buffer.from(pubKeyBytes).toString('hex'),
-    };
-}
-/**
- * Verify registry signature using real Ed25519
- */
-export async function verifyRegistrySignature(registry) {
-    if (!registry.registrySignature || !registry.registryPublicKey)
-        return false;
-    const sigHex = registry.registrySignature.replace(/^ed25519:/, '');
-    const pubKeyHex = registry.registryPublicKey.replace(/^ed25519:/, '');
-    if (sigHex.length !== 128 || pubKeyHex.length !== 64)
-        return false;
-    const content = JSON.stringify({
-        version: registry.version,
-        updatedAt: registry.updatedAt,
-        patterns: registry.patterns.map(p => p.cid),
-        totalPatterns: registry.totalPatterns,
-    });
-    try {
-        const ed = await import('@noble/ed25519');
-        return await ed.verifyAsync(Buffer.from(sigHex, 'hex'), Buffer.from(content), Buffer.from(pubKeyHex, 'hex'));
-    }
-    catch {
-        return false;
-    }
-}
-/**
- * Merge two registries (for sync)
- */
-export function mergeRegistries(local, remote) {
-    const merged = createRegistry(local.ipnsName);
-    // Combine patterns, preferring newer versions
-    const patternMap = new Map();
-    for (const pattern of [...local.patterns, ...remote.patterns]) {
-        const existing = patternMap.get(pattern.name);
-        if (!existing || new Date(pattern.lastUpdated) > new Date(existing.lastUpdated)) {
-            patternMap.set(pattern.name, pattern);
-        }
-    }
-    merged.patterns = Array.from(patternMap.values());
-    // Combine authors
-    const authorMap = new Map();
-    for (const author of [...local.authors, ...remote.authors]) {
-        const existing = authorMap.get(author.id);
-        if (!existing || author.patterns > existing.patterns) {
-            authorMap.set(author.id, author);
-        }
-    }
-    merged.authors = Array.from(authorMap.values());
-    // Update stats
-    merged.totalPatterns = merged.patterns.length;
-    merged.totalAuthors = merged.authors.length;
-    merged.totalDownloads = merged.patterns.reduce((sum, p) => sum + p.downloads, 0);
-    return merged;
-}
-/**
- * Generate pattern ID from name
- */
-export function generatePatternId(name) {
-    const normalized = name.toLowerCase().replace(/[^a-z0-9-]/g, '-');
-    const hash = crypto.createHash('sha256').update(name + Date.now()).digest('hex').slice(0, 8);
-    return `${normalized}-${hash}`;
-}
-//# sourceMappingURL=registry.js.map

package/packages/@monomind/cli/dist/src/transfer/store/search.d.ts

@@ -1,54 +0,0 @@
-/**
- * Pattern Search Service
- * Search and filter patterns from decentralized registry
- */
-import type { PatternRegistry, PatternEntry, SearchOptions, SearchResult } from './types.js';
-/**
- * Search patterns in registry
- */
-export declare function searchPatterns(registry: PatternRegistry, options?: SearchOptions): SearchResult;
-/**
- * Get featured patterns
- */
-export declare function getFeaturedPatterns(registry: PatternRegistry): PatternEntry[];
-/**
- * Get trending patterns
- */
-export declare function getTrendingPatterns(registry: PatternRegistry): PatternEntry[];
-/**
- * Get newest patterns
- */
-export declare function getNewestPatterns(registry: PatternRegistry): PatternEntry[];
-/**
- * Get pattern by ID
- */
-export declare function getPatternById(registry: PatternRegistry, patternId: string): PatternEntry | undefined;
-/**
- * Get pattern by name
- */
-export declare function getPatternByName(registry: PatternRegistry, name: string): PatternEntry | undefined;
-/**
- * Get patterns by author
- */
-export declare function getPatternsByAuthor(registry: PatternRegistry, authorId: string): PatternEntry[];
-/**
- * Get patterns by category
- */
-export declare function getPatternsByCategory(registry: PatternRegistry, categoryId: string): PatternEntry[];
-/**
- * Get similar patterns (by tags and category)
- */
-export declare function getSimilarPatterns(registry: PatternRegistry, pattern: PatternEntry, limit?: number): PatternEntry[];
-/**
- * Get category stats
- */
-export declare function getCategoryStats(registry: PatternRegistry): Map<string, number>;
-/**
- * Get tag cloud (tag -> count)
- */
-export declare function getTagCloud(registry: PatternRegistry): Map<string, number>;
-/**
- * Autocomplete search suggestions
- */
-export declare function getSearchSuggestions(registry: PatternRegistry, partial: string, limit?: number): string[];
-//# sourceMappingURL=search.d.ts.map

package/packages/@monomind/cli/dist/src/transfer/store/search.js

@@ -1,232 +0,0 @@
-/**
- * Pattern Search Service
- * Search and filter patterns from decentralized registry
- */
-/**
- * Search patterns in registry
- */
-export function searchPatterns(registry, options = {}) {
-    let patterns = [...registry.patterns];
-    // Text search
-    if (options.query) {
-        const query = options.query.toLowerCase();
-        patterns = patterns.filter(p => p.name.toLowerCase().includes(query) ||
-            p.displayName.toLowerCase().includes(query) ||
-            p.description.toLowerCase().includes(query) ||
-            p.tags.some(t => t.toLowerCase().includes(query)));
-    }
-    // Category filter
-    if (options.category) {
-        patterns = patterns.filter(p => p.categories.includes(options.category));
-    }
-    // Language filter
-    if (options.language) {
-        patterns = patterns.filter(p => p.language === options.language);
-    }
-    // Framework filter
-    if (options.framework) {
-        patterns = patterns.filter(p => p.framework === options.framework);
-    }
-    // Tags filter
-    if (options.tags && options.tags.length > 0) {
-        patterns = patterns.filter(p => options.tags.some(t => p.tags.includes(t)));
-    }
-    // Author filter
-    if (options.author) {
-        patterns = patterns.filter(p => p.author.id === options.author);
-    }
-    // Rating filter
-    if (options.minRating !== undefined) {
-        patterns = patterns.filter(p => p.rating >= options.minRating);
-    }
-    // Downloads filter
-    if (options.minDownloads !== undefined) {
-        patterns = patterns.filter(p => p.downloads >= options.minDownloads);
-    }
-    // Verified filter
-    if (options.verified !== undefined) {
-        patterns = patterns.filter(p => p.verified === options.verified);
-    }
-    // Trust level filter
-    if (options.trustLevel) {
-        const trustLevels = ['unverified', 'community', 'verified', 'official'];
-        const minLevel = trustLevels.indexOf(options.trustLevel);
-        patterns = patterns.filter(p => {
-            const patternLevel = trustLevels.indexOf(p.trustLevel);
-            return patternLevel >= minLevel;
-        });
-    }
-    // Sort
-    const sortBy = options.sortBy || 'downloads';
-    const sortOrder = options.sortOrder || 'desc';
-    patterns.sort((a, b) => {
-        let comparison = 0;
-        switch (sortBy) {
-            case 'downloads':
-                comparison = a.downloads - b.downloads;
-                break;
-            case 'rating':
-                comparison = a.rating - b.rating;
-                break;
-            case 'newest':
-                comparison = new Date(a.createdAt).getTime() - new Date(b.createdAt).getTime();
-                break;
-            case 'name':
-                comparison = a.name.localeCompare(b.name);
-                break;
-        }
-        return sortOrder === 'desc' ? -comparison : comparison;
-    });
-    // Pagination
-    const total = patterns.length;
-    const limit = options.limit || 20;
-    const offset = options.offset || 0;
-    const page = Math.floor(offset / limit) + 1;
-    patterns = patterns.slice(offset, offset + limit);
-    return {
-        patterns,
-        total,
-        page,
-        pageSize: limit,
-        hasMore: offset + patterns.length < total,
-        query: options,
-    };
-}
-/**
- * Get featured patterns
- */
-export function getFeaturedPatterns(registry) {
-    return registry.featured
-        .map(id => registry.patterns.find(p => p.id === id))
-        .filter((p) => p !== undefined);
-}
-/**
- * Get trending patterns
- */
-export function getTrendingPatterns(registry) {
-    return registry.trending
-        .map(id => registry.patterns.find(p => p.id === id))
-        .filter((p) => p !== undefined);
-}
-/**
- * Get newest patterns
- */
-export function getNewestPatterns(registry) {
-    return registry.newest
-        .map(id => registry.patterns.find(p => p.id === id))
-        .filter((p) => p !== undefined);
-}
-/**
- * Get pattern by ID
- */
-export function getPatternById(registry, patternId) {
-    return registry.patterns.find(p => p.id === patternId);
-}
-/**
- * Get pattern by name
- */
-export function getPatternByName(registry, name) {
-    return registry.patterns.find(p => p.name === name);
-}
-/**
- * Get patterns by author
- */
-export function getPatternsByAuthor(registry, authorId) {
-    return registry.patterns.filter(p => p.author.id === authorId);
-}
-/**
- * Get patterns by category
- */
-export function getPatternsByCategory(registry, categoryId) {
-    return registry.patterns.filter(p => p.categories.includes(categoryId));
-}
-/**
- * Get similar patterns (by tags and category)
- */
-export function getSimilarPatterns(registry, pattern, limit = 5) {
-    const scores = new Map();
-    for (const p of registry.patterns) {
-        if (p.id === pattern.id)
-            continue;
-        let score = 0;
-        // Shared tags
-        const sharedTags = p.tags.filter(t => pattern.tags.includes(t));
-        score += sharedTags.length * 2;
-        // Shared categories
-        const sharedCategories = p.categories.filter(c => pattern.categories.includes(c));
-        score += sharedCategories.length * 3;
-        // Same language
-        if (p.language === pattern.language)
-            score += 1;
-        // Same framework
-        if (p.framework === pattern.framework)
-            score += 2;
-        // Same author
-        if (p.author.id === pattern.author.id)
-            score += 1;
-        if (score > 0) {
-            scores.set(p.id, score);
-        }
-    }
-    // Sort by score and return top matches
-    return Array.from(scores.entries())
-        .sort((a, b) => b[1] - a[1])
-        .slice(0, limit)
-        .map(([id]) => registry.patterns.find(p => p.id === id))
-        .filter(p => p !== undefined);
-}
-/**
- * Get category stats
- */
-export function getCategoryStats(registry) {
-    const stats = new Map();
-    for (const category of registry.categories) {
-        const count = registry.patterns.filter(p => p.categories.includes(category.id)).length;
-        stats.set(category.id, count);
-    }
-    return stats;
-}
-/**
- * Get tag cloud (tag -> count)
- */
-export function getTagCloud(registry) {
-    const tags = new Map();
-    for (const pattern of registry.patterns) {
-        for (const tag of pattern.tags) {
-            tags.set(tag, (tags.get(tag) || 0) + 1);
-        }
-    }
-    return tags;
-}
-/**
- * Autocomplete search suggestions
- */
-export function getSearchSuggestions(registry, partial, limit = 10) {
-    const suggestions = new Set();
-    const query = partial.toLowerCase();
-    // Add matching pattern names
-    for (const pattern of registry.patterns) {
-        if (pattern.name.toLowerCase().includes(query)) {
-            suggestions.add(pattern.name);
-        }
-        if (pattern.displayName.toLowerCase().includes(query)) {
-            suggestions.add(pattern.displayName);
-        }
-    }
-    // Add matching tags
-    for (const pattern of registry.patterns) {
-        for (const tag of pattern.tags) {
-            if (tag.toLowerCase().includes(query)) {
-                suggestions.add(tag);
-            }
-        }
-    }
-    // Add matching categories
-    for (const category of registry.categories) {
-        if (category.name.toLowerCase().includes(query)) {
-            suggestions.add(category.name);
-        }
-    }
-    return Array.from(suggestions).slice(0, limit);
-}
-//# sourceMappingURL=search.js.map

package/packages/@monomind/cli/dist/src/transfer/store/tests/standalone-test.d.ts

@@ -1,12 +0,0 @@
-#!/usr/bin/env npx tsx
-/**
- * Standalone Pattern Store Test
- * Run this in any environment to verify the IPFS-based pattern store works
- *
- * Usage:
- *   npx tsx standalone-test.ts
- *   # or
- *   npm run test:pattern-store
- */
-export {};
-//# sourceMappingURL=standalone-test.d.ts.map