monomind 1.10.0 → 1.10.2

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

@@ -0,0 +1,301 @@
+/**
+ * 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

@@ -0,0 +1,54 @@
+/**
+ * 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

@@ -0,0 +1,232 @@
+/**
+ * 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

@@ -0,0 +1,12 @@
+#!/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