monomind 1.10.0 → 1.10.2

package/packages/@monomind/cli/dist/src/transfer/models/seraphine.js

@@ -0,0 +1,373 @@
+/**
+ * Seraphine Genesis Model
+ * The first Monomind pattern model - "Hello World" for pattern sharing
+ *
+ * Seraphine represents the foundational patterns for intelligent agent coordination.
+ * Named after the Greek "Seraphim" (burning ones), symbolizing the spark of knowledge
+ * that ignites collaborative AI intelligence.
+ */
+import { createCFP } from '../serialization/cfp.js';
+/**
+ * Seraphine model version
+ */
+export const SERAPHINE_VERSION = '1.0.0';
+/**
+ * Seraphine model metadata
+ */
+export const SERAPHINE_METADATA = {
+    name: 'seraphine-genesis',
+    displayName: 'Seraphine Genesis',
+    description: 'The foundational Monomind pattern model. Contains core routing patterns, complexity heuristics, and coordination trajectories for multi-agent swarms.',
+    author: {
+        id: 'monomind-team',
+        displayName: 'Monomind Team',
+    },
+    license: 'MIT',
+    tags: [
+        'genesis',
+        'foundational',
+        'routing',
+        'swarm',
+        'coordination',
+        'multi-agent',
+        'hello-world',
+    ],
+    language: 'typescript',
+    framework: 'monomind',
+};
+/**
+ * Core routing patterns for Seraphine
+ * These define how tasks are routed to appropriate agents
+ */
+export const SERAPHINE_ROUTING_PATTERNS = [
+    {
+        id: 'route-code-to-coder',
+        trigger: 'implement|code|write|create function|build feature',
+        action: 'spawn coder agent',
+        confidence: 0.95,
+        usageCount: 1000,
+        successRate: 0.92,
+        context: {
+            category: 'development',
+            priority: 'high',
+        },
+    },
+    {
+        id: 'route-test-to-tester',
+        trigger: 'test|validate|verify|check|ensure quality',
+        action: 'spawn tester agent',
+        confidence: 0.93,
+        usageCount: 850,
+        successRate: 0.89,
+        context: {
+            category: 'quality',
+            priority: 'high',
+        },
+    },
+    {
+        id: 'route-review-to-reviewer',
+        trigger: 'review|audit|analyze code|check security',
+        action: 'spawn reviewer agent',
+        confidence: 0.91,
+        usageCount: 720,
+        successRate: 0.87,
+        context: {
+            category: 'quality',
+            priority: 'medium',
+        },
+    },
+    {
+        id: 'route-research-to-researcher',
+        trigger: 'research|investigate|explore|find|search codebase',
+        action: 'spawn researcher agent',
+        confidence: 0.94,
+        usageCount: 680,
+        successRate: 0.91,
+        context: {
+            category: 'discovery',
+            priority: 'medium',
+        },
+    },
+    {
+        id: 'route-architecture-to-architect',
+        trigger: 'design|architect|plan structure|refactor system',
+        action: 'spawn architect agent',
+        confidence: 0.88,
+        usageCount: 420,
+        successRate: 0.85,
+        context: {
+            category: 'design',
+            priority: 'high',
+        },
+    },
+    {
+        id: 'route-complex-to-swarm',
+        trigger: 'complex task|multi-file|feature implementation|major refactor',
+        action: 'initialize hierarchical swarm',
+        confidence: 0.87,
+        usageCount: 350,
+        successRate: 0.82,
+        context: {
+            category: 'coordination',
+            priority: 'critical',
+            agentCount: 5,
+        },
+    },
+    {
+        id: 'route-security-to-auditor',
+        trigger: 'security|vulnerability|CVE|threat|penetration',
+        action: 'spawn security-architect agent',
+        confidence: 0.96,
+        usageCount: 280,
+        successRate: 0.94,
+        context: {
+            category: 'security',
+            priority: 'critical',
+        },
+    },
+    {
+        id: 'route-performance-to-optimizer',
+        trigger: 'optimize|performance|speed|memory|benchmark',
+        action: 'spawn performance-engineer agent',
+        confidence: 0.89,
+        usageCount: 310,
+        successRate: 0.86,
+        context: {
+            category: 'optimization',
+            priority: 'high',
+        },
+    },
+];
+/**
+ * Complexity heuristics for Seraphine
+ * These help estimate task complexity for resource allocation
+ */
+export const SERAPHINE_COMPLEXITY_PATTERNS = [
+    {
+        id: 'complexity-single-file',
+        pattern: 'single file modification',
+        complexity: 1,
+        tokens: 500,
+        frequency: 0.45,
+    },
+    {
+        id: 'complexity-multi-file',
+        pattern: 'multiple file changes (2-5 files)',
+        complexity: 3,
+        tokens: 2000,
+        frequency: 0.35,
+    },
+    {
+        id: 'complexity-feature',
+        pattern: 'new feature implementation',
+        complexity: 5,
+        tokens: 5000,
+        frequency: 0.12,
+    },
+    {
+        id: 'complexity-refactor',
+        pattern: 'system-wide refactoring',
+        complexity: 8,
+        tokens: 10000,
+        frequency: 0.05,
+    },
+    {
+        id: 'complexity-migration',
+        pattern: 'major version migration',
+        complexity: 10,
+        tokens: 20000,
+        frequency: 0.03,
+    },
+];
+/**
+ * Coverage patterns for Seraphine
+ * These track knowledge domain coverage
+ */
+export const SERAPHINE_COVERAGE_PATTERNS = [
+    {
+        id: 'coverage-typescript',
+        domain: 'TypeScript Development',
+        coverage: 0.92,
+        gaps: ['advanced generics', 'decorators'],
+    },
+    {
+        id: 'coverage-testing',
+        domain: 'Testing & QA',
+        coverage: 0.88,
+        gaps: ['e2e testing', 'visual regression'],
+    },
+    {
+        id: 'coverage-security',
+        domain: 'Security Analysis',
+        coverage: 0.85,
+        gaps: ['supply chain', 'zero-day detection'],
+    },
+    {
+        id: 'coverage-swarm',
+        domain: 'Multi-Agent Coordination',
+        coverage: 0.90,
+        gaps: ['byzantine consensus', 'network partitions'],
+    },
+];
+/**
+ * Trajectory patterns for Seraphine
+ * These capture successful task execution paths
+ */
+export const SERAPHINE_TRAJECTORY_PATTERNS = [
+    {
+        id: 'traj-bug-fix',
+        steps: [
+            'research: identify bug location',
+            'coder: implement fix',
+            'tester: write regression test',
+            'reviewer: verify fix quality',
+        ],
+        outcome: 'success',
+        duration: 1800000, // 30 minutes
+        learnings: [
+            'Always add regression test for bug fixes',
+            'Review similar code for same bug pattern',
+        ],
+    },
+    {
+        id: 'traj-feature-impl',
+        steps: [
+            'architect: design feature structure',
+            'researcher: analyze existing patterns',
+            'coder: implement feature',
+            'tester: write comprehensive tests',
+            'reviewer: security and quality review',
+            'coder: address review feedback',
+        ],
+        outcome: 'success',
+        duration: 7200000, // 2 hours
+        learnings: [
+            'Design before implementation reduces rework',
+            'Parallel testing accelerates delivery',
+        ],
+    },
+    {
+        id: 'traj-refactor',
+        steps: [
+            'researcher: map affected code',
+            'architect: plan refactoring strategy',
+            'tester: ensure test coverage exists',
+            'coder: incremental refactoring',
+            'tester: verify no regressions',
+            'reviewer: architectural review',
+        ],
+        outcome: 'success',
+        duration: 10800000, // 3 hours
+        learnings: [
+            'Test coverage before refactoring is critical',
+            'Small incremental changes are safer',
+        ],
+    },
+    {
+        id: 'traj-security-audit',
+        steps: [
+            'security-architect: threat modeling',
+            'researcher: dependency analysis',
+            'security-auditor: code scanning',
+            'coder: remediation',
+            'security-architect: verification',
+        ],
+        outcome: 'success',
+        duration: 14400000, // 4 hours
+        learnings: [
+            'Automated scanning catches common issues',
+            'Manual review needed for logic flaws',
+        ],
+    },
+];
+/**
+ * Custom patterns for Seraphine
+ * These are specialized patterns unique to Seraphine
+ */
+export const SERAPHINE_CUSTOM_PATTERNS = [
+    {
+        id: 'custom-swarm-topology',
+        type: 'topology-recommendation',
+        data: {
+            taskType: 'feature-implementation',
+            recommendedTopology: 'hierarchical',
+            agentRoles: ['coordinator', 'architect', 'coder', 'tester', 'reviewer'],
+            communicationPattern: 'hub-spoke',
+        },
+        metadata: {
+            confidence: 0.89,
+            source: 'production-data',
+        },
+    },
+    {
+        id: 'custom-memory-strategy',
+        type: 'memory-optimization',
+        data: {
+            pattern: 'vector-search-first',
+            hnswParams: { m: 16, efConstruction: 200 },
+            cacheStrategy: 'lru-with-embedding',
+        },
+        metadata: {
+            speedup: '150x',
+            memoryReduction: '60%',
+        },
+    },
+    {
+        id: 'custom-hello-world',
+        type: 'greeting',
+        data: {
+            message: 'Hello, World! Welcome to Monomind pattern sharing.',
+            version: SERAPHINE_VERSION,
+            genesis: true,
+        },
+        metadata: {
+            significance: 'First pattern ever exported via transfer hook system',
+            timestamp: new Date().toISOString(),
+        },
+    },
+];
+/**
+ * Create the complete Seraphine pattern collection
+ */
+export function createSeraphinePatterns() {
+    return {
+        routing: SERAPHINE_ROUTING_PATTERNS,
+        complexity: SERAPHINE_COMPLEXITY_PATTERNS,
+        coverage: SERAPHINE_COVERAGE_PATTERNS,
+        trajectory: SERAPHINE_TRAJECTORY_PATTERNS,
+        custom: SERAPHINE_CUSTOM_PATTERNS,
+    };
+}
+/**
+ * Create the Seraphine Genesis CFP document
+ */
+export function createSeraphineGenesis() {
+    return createCFP({
+        name: SERAPHINE_METADATA.name,
+        description: SERAPHINE_METADATA.description,
+        patterns: createSeraphinePatterns(),
+        author: SERAPHINE_METADATA.author,
+        license: SERAPHINE_METADATA.license,
+        tags: SERAPHINE_METADATA.tags,
+        language: SERAPHINE_METADATA.language,
+        framework: SERAPHINE_METADATA.framework,
+    });
+}
+/**
+ * Get Seraphine model info
+ */
+export function getSeraphineInfo() {
+    return {
+        name: SERAPHINE_METADATA.displayName,
+        version: SERAPHINE_VERSION,
+        description: SERAPHINE_METADATA.description,
+        patternCounts: {
+            routing: SERAPHINE_ROUTING_PATTERNS.length,
+            complexity: SERAPHINE_COMPLEXITY_PATTERNS.length,
+            coverage: SERAPHINE_COVERAGE_PATTERNS.length,
+            trajectory: SERAPHINE_TRAJECTORY_PATTERNS.length,
+            custom: SERAPHINE_CUSTOM_PATTERNS.length,
+        },
+    };
+}
+//# sourceMappingURL=seraphine.js.map

package/packages/@monomind/cli/dist/src/transfer/serialization/cfp.d.ts

@@ -0,0 +1,49 @@
+/**
+ * CFP Format Serializer
+ * Monomind Pattern format serialization
+ */
+import type { CFPFormat, SerializationFormat, PatternCollection } from '../types.js';
+/**
+ * Create a new CFP document
+ */
+export declare function createCFP(options: {
+    name: string;
+    description: string;
+    patterns: PatternCollection;
+    author?: {
+        id: string;
+        displayName?: string;
+    };
+    license?: string;
+    tags?: string[];
+    language?: string;
+    framework?: string;
+}): CFPFormat;
+/**
+ * Serialize CFP to JSON string
+ */
+export declare function serializeToJson(cfp: CFPFormat): string;
+/**
+ * Serialize CFP to Buffer (for CBOR/binary formats)
+ */
+export declare function serializeToBuffer(cfp: CFPFormat, format: SerializationFormat): Buffer;
+/**
+ * Deserialize CFP from string/buffer
+ */
+export declare function deserializeCFP(data: string | Buffer): CFPFormat;
+/**
+ * Validate CFP document
+ */
+export declare function validateCFP(cfp: CFPFormat): {
+    valid: boolean;
+    errors: string[];
+};
+/**
+ * Get file extension for format
+ */
+export declare function getFileExtension(format: SerializationFormat): string;
+/**
+ * Detect format from file path
+ */
+export declare function detectFormat(filePath: string): SerializationFormat;
+//# sourceMappingURL=cfp.d.ts.map

package/packages/@monomind/cli/dist/src/transfer/serialization/cfp.js

@@ -0,0 +1,183 @@
+/**
+ * CFP Format Serializer
+ * Monomind Pattern format serialization
+ */
+import * as crypto from 'crypto';
+// Version info
+const CFP_VERSION = '1.0.0';
+const GENERATOR = 'monomind@3.0.0-alpha';
+/**
+ * Create a new CFP document
+ */
+export function createCFP(options) {
+    const now = new Date().toISOString();
+    const id = crypto.randomUUID();
+    return {
+        magic: 'CFP1',
+        version: CFP_VERSION,
+        createdAt: now,
+        generatedBy: GENERATOR,
+        metadata: {
+            id,
+            name: options.name,
+            description: options.description,
+            author: options.author ? {
+                id: options.author.id,
+                displayName: options.author.displayName,
+                verified: false,
+            } : undefined,
+            license: options.license || 'MIT',
+            tags: options.tags || [],
+            language: options.language,
+            framework: options.framework,
+            createdAt: now,
+            updatedAt: now,
+        },
+        anonymization: {
+            level: 'minimal',
+            appliedTransforms: [],
+            piiRedacted: false,
+            pathsStripped: false,
+            timestampsGeneralized: false,
+            checksum: '',
+        },
+        patterns: options.patterns,
+        statistics: calculateStatistics(options.patterns),
+    };
+}
+/**
+ * Calculate pattern statistics
+ */
+function calculateStatistics(patterns) {
+    const counts = {
+        routing: patterns.routing.length,
+        complexity: patterns.complexity.length,
+        coverage: patterns.coverage.length,
+        trajectory: patterns.trajectory.length,
+        custom: patterns.custom.length,
+    };
+    const total = Object.values(counts).reduce((a, b) => a + b, 0);
+    // Calculate average confidence from routing patterns
+    const confidences = patterns.routing.map(p => p.confidence);
+    const avgConfidence = confidences.length > 0
+        ? confidences.reduce((a, b) => a + b, 0) / confidences.length
+        : 0;
+    return {
+        totalPatterns: total,
+        avgConfidence,
+        patternTypes: counts,
+        timeRange: {
+            start: new Date().toISOString(),
+            end: new Date().toISOString(),
+        },
+    };
+}
+/**
+ * Serialize CFP to JSON string
+ */
+export function serializeToJson(cfp) {
+    // Calculate checksum before serialization
+    const content = JSON.stringify({
+        magic: cfp.magic,
+        version: cfp.version,
+        metadata: cfp.metadata,
+        patterns: cfp.patterns,
+    });
+    cfp.anonymization.checksum = crypto
+        .createHash('sha256')
+        .update(content)
+        .digest('hex');
+    return JSON.stringify(cfp, null, 2);
+}
+/**
+ * Serialize CFP to Buffer (for CBOR/binary formats)
+ */
+export function serializeToBuffer(cfp, format) {
+    // For now, just use JSON - in production, would use cbor-x or msgpack
+    const json = serializeToJson(cfp);
+    switch (format) {
+        case 'json':
+            return Buffer.from(json, 'utf-8');
+        case 'cbor':
+        case 'cbor.gz':
+        case 'cbor.zstd':
+        case 'msgpack':
+            throw new Error(`Serialization format '${format}' is not implemented. Use 'json' instead.`);
+        default:
+            return Buffer.from(json, 'utf-8');
+    }
+}
+/**
+ * Deserialize CFP from string/buffer
+ */
+export function deserializeCFP(data) {
+    const str = typeof data === 'string' ? data : data.toString('utf-8');
+    let parsed;
+    try {
+        parsed = JSON.parse(str);
+    }
+    catch (e) {
+        throw new Error(`Invalid CFP file: ${e instanceof Error ? e.message : String(e)}`);
+    }
+    // Validate magic bytes
+    if (parsed.magic !== 'CFP1') {
+        throw new Error(`Invalid CFP format: expected magic 'CFP1', got '${parsed.magic}'`);
+    }
+    return parsed;
+}
+/**
+ * Validate CFP document
+ */
+export function validateCFP(cfp) {
+    const errors = [];
+    if (cfp.magic !== 'CFP1') {
+        errors.push(`Invalid magic bytes: ${cfp.magic}`);
+    }
+    if (!cfp.version) {
+        errors.push('Missing version');
+    }
+    if (!cfp.metadata?.id) {
+        errors.push('Missing metadata.id');
+    }
+    if (!cfp.patterns) {
+        errors.push('Missing patterns');
+    }
+    return {
+        valid: errors.length === 0,
+        errors,
+    };
+}
+/**
+ * Get file extension for format
+ */
+export function getFileExtension(format) {
+    switch (format) {
+        case 'json':
+            return '.cfp.json';
+        case 'cbor':
+            return '.cfp';
+        case 'cbor.gz':
+            return '.cfp.gz';
+        case 'cbor.zstd':
+            return '.cfp.zst';
+        case 'msgpack':
+            return '.cfp.mp';
+        default:
+            return '.cfp';
+    }
+}
+/**
+ * Detect format from file path
+ */
+export function detectFormat(filePath) {
+    if (filePath.endsWith('.cfp.json'))
+        return 'json';
+    if (filePath.endsWith('.cfp.gz'))
+        return 'cbor.gz';
+    if (filePath.endsWith('.cfp.zst'))
+        return 'cbor.zstd';
+    if (filePath.endsWith('.cfp.mp'))
+        return 'msgpack';
+    return 'cbor';
+}
+//# sourceMappingURL=cfp.js.map

package/packages/@monomind/cli/dist/src/transfer/storage/gcs.d.ts

@@ -0,0 +1,82 @@
+/**
+ * Google Cloud Storage Backend
+ * Real storage implementation using gcloud CLI or GCS APIs
+ *
+ * @module @monoes/cli/transfer/storage/gcs
+ * @version 3.0.0
+ */
+/**
+ * GCS configuration
+ */
+export interface GCSConfig {
+    bucket: string;
+    projectId?: string;
+    keyFile?: string;
+    prefix?: string;
+}
+/**
+ * GCS upload result
+ */
+export interface GCSUploadResult {
+    success: boolean;
+    uri: string;
+    publicUrl: string;
+    size: number;
+    checksum: string;
+    contentId: string;
+}
+/**
+ * Get GCS configuration from environment
+ */
+export declare function getGCSConfig(): GCSConfig | null;
+/**
+ * Check if gcloud CLI is available
+ */
+export declare function isGCloudAvailable(): boolean;
+/**
+ * Check if authenticated with gcloud
+ */
+export declare function isGCloudAuthenticated(): Promise<boolean>;
+/**
+ * Upload content to Google Cloud Storage using gcloud CLI
+ */
+export declare function uploadToGCS(content: Buffer, options?: {
+    name?: string;
+    contentType?: string;
+    config?: GCSConfig;
+    metadata?: Record<string, string>;
+}): Promise<GCSUploadResult>;
+/**
+ * Download content from Google Cloud Storage
+ */
+export declare function downloadFromGCS(uri: string, config?: GCSConfig): Promise<Buffer | null>;
+/**
+ * Check if object exists in GCS
+ */
+export declare function existsInGCS(uri: string, config?: GCSConfig): Promise<boolean>;
+/**
+ * List objects in GCS bucket with prefix
+ */
+export declare function listGCSObjects(prefix?: string, config?: GCSConfig): Promise<Array<{
+    name: string;
+    size: number;
+    updated: string;
+}>>;
+/**
+ * Delete object from GCS
+ */
+export declare function deleteFromGCS(uri: string, config?: GCSConfig): Promise<boolean>;
+/**
+ * Get GCS storage status
+ */
+export declare function getGCSStatus(): {
+    available: boolean;
+    authenticated: boolean;
+    bucket?: string;
+    message: string;
+};
+/**
+ * Export for storage backend detection
+ */
+export declare function hasGCSCredentials(): boolean;
+//# sourceMappingURL=gcs.d.ts.map