@claude-flow/cli 3.32.1 → 3.32.3

package/dist/src/transfer/models/seraphine.js

@@ -1,373 +0,0 @@
-/**
- * Seraphine Genesis Model
- * The first Claude Flow 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 Claude Flow pattern model. Contains core routing patterns, complexity heuristics, and coordination trajectories for multi-agent swarms.',
-    author: {
-        id: 'claude-flow-team',
-        displayName: 'Claude Flow Team',
-    },
-    license: 'MIT',
-    tags: [
-        'genesis',
-        'foundational',
-        'routing',
-        'swarm',
-        'coordination',
-        'multi-agent',
-        'hello-world',
-    ],
-    language: 'typescript',
-    framework: 'claude-flow',
-};
-/**
- * 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 Claude Flow 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/dist/src/transfer/serialization/cfp.d.ts

@@ -1,49 +0,0 @@
-/**
- * CFP Format Serializer
- * Claude Flow 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/dist/src/transfer/serialization/cfp.js

@@ -1,183 +0,0 @@
-/**
- * CFP Format Serializer
- * Claude Flow Pattern format serialization
- */
-import * as crypto from 'crypto';
-// Version info
-const CFP_VERSION = '1.0.0';
-const GENERATOR = 'claude-flow@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/dist/src/transfer/storage/gcs.d.ts

@@ -1,82 +0,0 @@
-/**
- * Google Cloud Storage Backend
- * Real storage implementation using gcloud CLI or GCS APIs
- *
- * @module @claude-flow/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