moflo 4.8.30 → 4.8.32

package/src/@claude-flow/cli/dist/src/services/worker-queue.d.ts

@@ -1,194 +0,0 @@
-/**
- * Worker Queue Service
- * Redis-based task queue for distributed headless worker execution.
- *
- * ADR-020: Headless Worker Integration Architecture - Phase 4
- * - Priority-based task scheduling
- * - Result persistence and retrieval
- * - Distributed locking for task assignment
- * - Dead letter queue for failed tasks
- * - Metrics and monitoring
- *
- * Key Features:
- * - FIFO with priority levels (critical, high, normal, low)
- * - Automatic retry with exponential backoff
- * - Task timeout detection
- * - Result caching with TTL
- * - Worker heartbeat monitoring
- */
-import { EventEmitter } from 'events';
-import type { HeadlessWorkerType, HeadlessExecutionResult, WorkerPriority } from './headless-worker-executor.js';
-/**
- * Task status
- */
-export type TaskStatus = 'pending' | 'processing' | 'completed' | 'failed' | 'timeout' | 'cancelled';
-/**
- * Queue task
- */
-export interface QueueTask {
-    id: string;
-    workerType: HeadlessWorkerType;
-    priority: WorkerPriority;
-    payload: {
-        prompt?: string;
-        contextPatterns?: string[];
-        sandbox?: string;
-        model?: string;
-        timeoutMs?: number;
-    };
-    status: TaskStatus;
-    createdAt: Date;
-    startedAt?: Date;
-    completedAt?: Date;
-    workerId?: string;
-    retryCount: number;
-    maxRetries: number;
-    result?: HeadlessExecutionResult;
-    error?: string;
-}
-/**
- * Queue configuration
- */
-export interface WorkerQueueConfig {
-    /** Redis connection URL */
-    redisUrl: string;
-    /** Queue name prefix */
-    queuePrefix: string;
-    /** Default task timeout in ms */
-    defaultTimeoutMs: number;
-    /** Maximum retries for failed tasks */
-    maxRetries: number;
-    /** Task result TTL in seconds */
-    resultTtlSeconds: number;
-    /** Worker heartbeat interval in ms */
-    heartbeatIntervalMs: number;
-    /** Dead letter queue enabled */
-    deadLetterEnabled: boolean;
-    /** Visibility timeout in ms (task processing lock) */
-    visibilityTimeoutMs: number;
-}
-/**
- * Queue statistics
- */
-export interface QueueStats {
-    pending: number;
-    processing: number;
-    completed: number;
-    failed: number;
-    deadLetter: number;
-    byPriority: Record<WorkerPriority, number>;
-    byWorkerType: Partial<Record<HeadlessWorkerType, number>>;
-    averageWaitTimeMs: number;
-    averageProcessingTimeMs: number;
-}
-/**
- * Worker registration info
- */
-export interface WorkerRegistration {
-    workerId: string;
-    workerTypes: HeadlessWorkerType[];
-    maxConcurrent: number;
-    currentTasks: number;
-    lastHeartbeat: Date;
-    registeredAt: Date;
-    hostname?: string;
-    containerId?: string;
-}
-/**
- * WorkerQueue - Redis-based task queue for distributed worker execution
- */
-export declare class WorkerQueue extends EventEmitter {
-    private config;
-    private store;
-    private workerId;
-    private heartbeatTimer?;
-    private processingTasks;
-    private isShuttingDown;
-    private maxConcurrent;
-    private initialized;
-    constructor(config?: Partial<WorkerQueueConfig>);
-    /**
-     * Initialize the queue (starts cleanup timers)
-     */
-    initialize(): Promise<void>;
-    /**
-     * Enqueue a new task
-     */
-    enqueue(workerType: HeadlessWorkerType, payload?: QueueTask['payload'], options?: {
-        priority?: WorkerPriority;
-        maxRetries?: number;
-        timeoutMs?: number;
-    }): Promise<string>;
-    /**
-     * Dequeue a task for processing
-     */
-    dequeue(workerTypes: HeadlessWorkerType[]): Promise<QueueTask | null>;
-    /**
-     * Complete a task with result
-     */
-    complete(taskId: string, result: HeadlessExecutionResult): Promise<void>;
-    /**
-     * Fail a task with error
-     */
-    fail(taskId: string, error: string, retryable?: boolean): Promise<void>;
-    /**
-     * Get task status
-     */
-    getTask(taskId: string): Promise<QueueTask | null>;
-    /**
-     * Get task result
-     */
-    getResult(taskId: string): Promise<HeadlessExecutionResult | null>;
-    /**
-     * Cancel a pending task
-     */
-    cancel(taskId: string): Promise<boolean>;
-    /**
-     * Register this instance as a worker
-     */
-    registerWorker(workerTypes: HeadlessWorkerType[], options?: {
-        maxConcurrent?: number;
-        hostname?: string;
-        containerId?: string;
-    }): Promise<string>;
-    /**
-     * Unregister this worker
-     */
-    unregisterWorker(): Promise<void>;
-    /**
-     * Get all registered workers
-     */
-    getWorkers(): Promise<WorkerRegistration[]>;
-    /**
-     * Get queue statistics
-     */
-    getStats(): Promise<QueueStats>;
-    /**
-     * Start processing tasks
-     */
-    start(workerTypes: HeadlessWorkerType[], handler: (task: QueueTask) => Promise<HeadlessExecutionResult>, options?: {
-        maxConcurrent?: number;
-    }): Promise<void>;
-    /**
-     * Process a single task
-     */
-    private processTask;
-    /**
-     * Shutdown the queue gracefully
-     */
-    shutdown(): Promise<void>;
-    /**
-     * Get queue name for worker type
-     */
-    private getQueueName;
-    /**
-     * Start heartbeat timer
-     */
-    private startHeartbeat;
-    /**
-     * Stop heartbeat timer
-     */
-    private stopHeartbeat;
-}
-export default WorkerQueue;
-//# sourceMappingURL=worker-queue.d.ts.map

package/src/@claude-flow/cli/dist/src/services/workflow-gate.d.ts

@@ -1,88 +0,0 @@
-/**
- * Workflow Gate Service
- * Enforces TaskCreate + memory-first patterns before agent spawning
- * and file exploration. Tracks context bracket by interaction count.
- *
- * Ported from Motailz .claude/scripts/workflow-gate.mjs into MoFlo core.
- *
- * Gate types:
- *   check-before-agent     — blocks Agent tool if no TaskCreate or no memory search
- *   check-before-scan      — blocks Glob/Grep if no memory search (deduplicated)
- *   check-before-read      — blocks Read on .claude/guidance/ if no memory search
- *   record-task-created     — records TaskCreate usage
- *   check-bash-memory       — detects memory search in Bash commands
- *   record-memory-searched  — records MCP memory search
- *   prompt-reminder         — resets memory gate, increments interaction count
- *   session-reset           — resets all state
- */
-export interface WorkflowState {
-    tasksCreated: boolean;
-    taskCount: number;
-    memorySearched: boolean;
-    memoryRequired: boolean;
-    interactionCount: number;
-    sessionStart: string | null;
-    lastBlockedAt: string | null;
-}
-export type ContextBracket = 'FRESH' | 'MODERATE' | 'DEPLETED' | 'CRITICAL';
-export interface GateResult {
-    allowed: boolean;
-    message?: string;
-}
-export declare class WorkflowGateService {
-    private stateFilePath;
-    private config;
-    constructor(projectRoot?: string);
-    readState(): WorkflowState;
-    writeState(state: WorkflowState): void;
-    getContextBracket(interactionCount: number): ContextBracket;
-    /**
-     * Check if Agent tool spawn is allowed.
-     * Requires both TaskCreate and memory search.
-     */
-    checkBeforeAgent(): GateResult;
-    /**
-     * Check if Glob/Grep is allowed.
-     * Blocks if memory is required AND not yet searched.
-     * Warns (but allows) if memory is not required.
-     */
-    checkBeforeScan(pattern?: string, searchPath?: string): GateResult;
-    /**
-     * Check if Read on guidance files is allowed.
-     * Only gates reads targeting .claude/guidance/ files.
-     */
-    checkBeforeRead(filePath?: string): GateResult;
-    recordTaskCreated(): void;
-    recordMemorySearched(): void;
-    /**
-     * Check if a bash command contains a memory search.
-     * If so, auto-record memory as searched.
-     */
-    checkBashMemory(command: string): void;
-    /**
-     * Classify whether a user prompt requires memory search.
-     * Directives (commit, rename, yes/no) don't need memory.
-     * Tasks (fix, implement, debug, /flo) do.
-     * Ambiguous prompts default to requiring memory.
-     */
-    classifyPrompt(prompt: string): boolean;
-    /**
-     * Called on each new user prompt.
-     * Classifies prompt, resets memory gate, increments interaction count,
-     * returns context bracket.
-     */
-    promptReminder(userPrompt?: string): {
-        reminder?: string;
-        bracket?: string;
-    };
-    /**
-     * Reset all workflow state (new session).
-     */
-    sessionReset(): void;
-}
-/**
- * Process a workflow gate command from CLI args.
- * Used by hooks.mjs dispatcher.
- */
-export declare function processGateCommand(command: string, env?: Record<string, string | undefined>): void;
-//# sourceMappingURL=workflow-gate.d.ts.map

package/src/@claude-flow/cli/dist/src/suggest.d.ts

@@ -1,53 +0,0 @@
-/**
- * V3 CLI Smart Error Suggestions
- * Levenshtein distance and command suggestions
- *
- * Created with motailz.com
- */
-/**
- * Calculate Levenshtein distance between two strings
- */
-export declare function levenshteinDistance(a: string, b: string): number;
-/**
- * Calculate similarity score (0-1) between two strings
- */
-export declare function similarityScore(a: string, b: string): number;
-/**
- * Find similar strings from a list
- */
-export declare function findSimilar(input: string, candidates: string[], options?: {
-    maxSuggestions?: number;
-    minSimilarity?: number;
-    maxDistance?: number;
-}): string[];
-/**
- * Format suggestion message for CLI errors
- */
-export declare function formatSuggestion(invalidInput: string, suggestions: string[], context?: 'command' | 'subcommand' | 'option' | 'value'): string;
-/**
- * Common typos and their corrections
- */
-export declare const COMMON_TYPOS: Record<string, string>;
-/**
- * Get corrected command if it's a common typo
- */
-export declare function getTypoCorrection(input: string): string | undefined;
-/**
- * Smart command suggestion for unknown commands
- */
-export declare function suggestCommand(unknownCommand: string, availableCommands: string[]): {
-    correction?: string;
-    suggestions: string[];
-    message: string;
-};
-declare const _default: {
-    levenshteinDistance: typeof levenshteinDistance;
-    similarityScore: typeof similarityScore;
-    findSimilar: typeof findSimilar;
-    formatSuggestion: typeof formatSuggestion;
-    suggestCommand: typeof suggestCommand;
-    getTypoCorrection: typeof getTypoCorrection;
-    COMMON_TYPOS: Record<string, string>;
-};
-export default _default;
-//# sourceMappingURL=suggest.d.ts.map

package/src/@claude-flow/cli/dist/src/transfer/anonymization/index.d.ts

@@ -1,25 +0,0 @@
-/**
- * Anonymization Pipeline
- * PII detection and redaction for pattern export
- */
-import type { CFPFormat, AnonymizationLevel, PIIDetectionResult } from '../types.js';
-/**
- * Detect PII in a string
- */
-export declare function detectPII(content: string): PIIDetectionResult;
-/**
- * Redact PII from a string
- */
-export declare function redactPII(content: string): string;
-/**
- * Apply anonymization to CFP document
- */
-export declare function anonymizeCFP(cfp: CFPFormat, level: AnonymizationLevel): {
-    cfp: CFPFormat;
-    transforms: string[];
-};
-/**
- * Scan CFP for PII without modification
- */
-export declare function scanCFPForPII(cfp: CFPFormat): PIIDetectionResult;
-//# sourceMappingURL=index.d.ts.map

package/src/@claude-flow/cli/dist/src/transfer/deploy-seraphine.d.ts

@@ -1,13 +0,0 @@
-#!/usr/bin/env npx tsx
-/**
- * Deploy Seraphine Genesis Model
- * Exports and uploads the first Claude Flow pattern model to IPFS
- *
- * Usage:
- *   npx tsx deploy-seraphine.ts
- *   npx tsx deploy-seraphine.ts --output ./patterns/
- *   npx tsx deploy-seraphine.ts --to-ipfs
- *   npx tsx deploy-seraphine.ts --to-ipfs --anonymize strict
- */
-export {};
-//# sourceMappingURL=deploy-seraphine.d.ts.map

package/src/@claude-flow/cli/dist/src/transfer/export.d.ts

@@ -1,25 +0,0 @@
-/**
- * Pattern Export Pipeline
- * Export patterns with anonymization and optional IPFS upload
- */
-import type { CFPFormat, ExportOptions, ExportResult } from './types.js';
-/**
- * Export patterns to file or IPFS
- */
-export declare function exportPatterns(cfp: CFPFormat, options?: ExportOptions): Promise<ExportResult>;
-/**
- * Export Seraphine genesis model
- */
-export declare function exportSeraphine(options?: ExportOptions): Promise<ExportResult>;
-/**
- * Quick export to file
- */
-export declare function quickExport(cfp: CFPFormat, outputPath: string): Promise<ExportResult>;
-/**
- * Quick export to IPFS
- */
-export declare function quickExportToIPFS(cfp: CFPFormat, options?: {
-    gateway?: string;
-    pin?: boolean;
-}): Promise<ExportResult>;
-//# sourceMappingURL=export.d.ts.map

package/src/@claude-flow/cli/dist/src/transfer/index.d.ts

@@ -1,12 +0,0 @@
-/**
- * Transfer Module
- * Pattern export, import, anonymization, and IPFS sharing
- */
-export * from './types.js';
-export { createCFP, serializeToJson, serializeToBuffer, deserializeCFP, validateCFP, getFileExtension, detectFormat, } from './serialization/cfp.js';
-export { detectPII, redactPII, anonymizeCFP, scanCFPForPII, } from './anonymization/index.js';
-export { exportPatterns, exportSeraphine, quickExport, quickExportToIPFS, } from './export.js';
-export { uploadToIPFS, pinContent, unpinContent, checkContent, getGatewayURL, getIPNSURL, } from './ipfs/upload.js';
-export { SERAPHINE_VERSION, SERAPHINE_METADATA, SERAPHINE_ROUTING_PATTERNS, SERAPHINE_COMPLEXITY_PATTERNS, SERAPHINE_COVERAGE_PATTERNS, SERAPHINE_TRAJECTORY_PATTERNS, SERAPHINE_CUSTOM_PATTERNS, createSeraphinePatterns, createSeraphineGenesis, getSeraphineInfo, } from './models/seraphine.js';
-export { type PatternEntry, type PatternAuthor, type PatternCategory, type PatternRegistry, type SearchOptions, type SearchResult, type PublishOptions, type PublishResult, type DownloadOptions, type DownloadResult, type KnownRegistry, type StoreConfig, type DiscoveryResult, type IPNSResolution, type DownloadProgressCallback, type ContributionRequest, REGISTRY_VERSION, BOOTSTRAP_REGISTRIES, DEFAULT_STORE_CONFIG, createRegistry, getDefaultCategories, addPatternToRegistry, removePatternFromRegistry, serializeRegistry, deserializeRegistry, signRegistry, verifyRegistrySignature, mergeRegistries, generatePatternId, PatternDiscovery, createDiscoveryService, searchPatterns, getFeaturedPatterns, getTrendingPatterns, getNewestPatterns, getPatternById, getPatternByName, getPatternsByAuthor, getPatternsByCategory, getSimilarPatterns, getCategoryStats, getTagCloud, getSearchSuggestions, PatternDownloader, batchDownload, createDownloader, PatternPublisher, submitContribution, checkContributionStatus, createPublisher, quickPublish, PatternStore, createPatternStore, } from './store/index.js';
-//# sourceMappingURL=index.d.ts.map

package/src/@claude-flow/cli/dist/src/transfer/ipfs/client.d.ts

@@ -1,109 +0,0 @@
-/**
- * IPFS Client Module
- * Low-level IPFS operations for discovery and fetching
- *
- * Supports multiple gateways with automatic fallback:
- * - Pinata (recommended for pinned content)
- * - Cloudflare IPFS
- * - Protocol Labs ipfs.io
- * - dweb.link (LibP2P)
- */
-/**
- * Available IPFS gateways in priority order
- */
-export declare const IPFS_GATEWAYS: string[];
-/**
- * IPNS resolvers
- */
-export declare const IPNS_RESOLVERS: string[];
-/**
- * Gateway configuration
- */
-export interface GatewayConfig {
-    url: string;
-    timeout?: number;
-    headers?: Record<string, string>;
-    priority?: number;
-}
-/**
- * Fetch result with metadata
- */
-export interface FetchResult<T> {
-    data: T;
-    gateway: string;
-    cid: string;
-    cached: boolean;
-    latencyMs: number;
-}
-/**
- * Resolve IPNS name to CID with fallback across multiple gateways
- *
- * @param ipnsName - IPNS key or DNSLink domain
- * @param preferredGateway - Optional preferred gateway to try first
- * @returns CID string or null if resolution fails
- */
-export declare function resolveIPNS(ipnsName: string, preferredGateway?: string): Promise<string | null>;
-/**
- * Fetch content from IPFS by CID with fallback across multiple gateways
- *
- * @param cid - Content Identifier
- * @param preferredGateway - Optional preferred gateway to try first
- * @returns Parsed JSON content or null if fetch fails
- */
-export declare function fetchFromIPFS<T>(cid: string, preferredGateway?: string): Promise<T | null>;
-/**
- * Fetch with full result metadata
- */
-export declare function fetchFromIPFSWithMetadata<T>(cid: string, preferredGateway?: string): Promise<FetchResult<T> | null>;
-/**
- * Check if CID is pinned/available on a gateway
- */
-export declare function isPinned(cid: string, gateway?: string): Promise<boolean>;
-/**
- * Check availability across multiple gateways
- */
-export declare function checkAvailability(cid: string): Promise<{
-    available: boolean;
-    gateways: Array<{
-        url: string;
-        available: boolean;
-        latencyMs: number;
-    }>;
-}>;
-/**
- * Get IPFS gateway URL for a CID
- */
-export declare function getGatewayUrl(cid: string, gateway?: string): string;
-/**
- * Get multiple gateway URLs for redundancy
- */
-export declare function getGatewayUrls(cid: string): string[];
-/**
- * Validate CID format (CIDv0 and CIDv1)
- */
-export declare function isValidCID(cid: string): boolean;
-/**
- * Validate IPNS name format
- */
-export declare function isValidIPNS(ipnsName: string): boolean;
-/**
- * Generate content hash for verification
- */
-export declare function hashContent(content: Buffer | string): string;
-/**
- * Verify Ed25519 signature (async import to avoid bundling issues)
- */
-export declare function verifyEd25519Signature(message: string, signature: string, publicKey: string): Promise<boolean>;
-/**
- * Parse CID to extract metadata
- */
-export declare function parseCID(cid: string): {
-    version: 0 | 1;
-    codec: string;
-    hash: string;
-} | null;
-/**
- * Format bytes to human readable
- */
-export declare function formatBytes(bytes: number): string;
-//# sourceMappingURL=client.d.ts.map

package/src/@claude-flow/cli/dist/src/transfer/ipfs/upload.d.ts

@@ -1,95 +0,0 @@
-/**
- * IPFS Upload Module
- * Real upload support via web3.storage, Pinata, or local IPFS
- *
- * @module @claude-flow/cli/transfer/ipfs/upload
- * @version 3.0.0
- */
-import type { PinningService } from '../types.js';
-/**
- * IPFS upload options
- */
-export interface IPFSUploadOptions {
-    pin?: boolean;
-    pinningService?: PinningService;
-    gateway?: string;
-    name?: string;
-    wrapWithDirectory?: boolean;
-    apiKey?: string;
-    apiSecret?: string;
-}
-/**
- * IPFS upload result
- */
-export interface IPFSUploadResult {
-    cid: string;
-    size: number;
-    gateway: string;
-    pinnedAt?: string;
-    url: string;
-}
-/**
- * Upload content to IPFS
- *
- * Supports (in order of preference):
- * - Local/Custom IPFS node (IPFS_API_URL) - FREE, your own node
- * - web3.storage (WEB3_STORAGE_TOKEN) - Free 5GB tier
- * - Pinata (PINATA_API_KEY + PINATA_API_SECRET) - Free 1GB tier
- * - Demo mode (generates deterministic CIDs when no credentials)
- */
-export declare function uploadToIPFS(content: Buffer, options?: IPFSUploadOptions): Promise<IPFSUploadResult>;
-/**
- * Pin content by CID
- */
-export declare function pinContent(cid: string, options?: {
-    service?: PinningService;
-    name?: string;
-}): Promise<{
-    success: boolean;
-    pinnedAt: string;
-}>;
-/**
- * Unpin content by CID
- */
-export declare function unpinContent(cid: string, options?: {
-    service?: PinningService;
-}): Promise<{
-    success: boolean;
-}>;
-/**
- * Check if content exists on IPFS
- */
-export declare function checkContent(cid: string, gateway?: string): Promise<{
-    exists: boolean;
-    size?: number;
-}>;
-/**
- * Get gateway URL for CID
- */
-export declare function getGatewayURL(cid: string, gateway?: string): string;
-/**
- * Get IPNS URL for name
- */
-export declare function getIPNSURL(name: string, gateway?: string): string;
-/**
- * Check if local IPFS node is available
- */
-declare function checkLocalIPFSNode(): Promise<boolean>;
-/**
- * Check if real IPFS credentials are available
- */
-export declare function hasIPFSCredentials(): boolean;
-/**
- * Get IPFS service status
- */
-export declare function getIPFSServiceStatus(): {
-    service: 'local' | 'web3storage' | 'pinata' | 'demo';
-    configured: boolean;
-    message: string;
-    apiUrl?: string;
-};
-/**
- * Export the local IPFS check for external use
- */
-export { checkLocalIPFSNode };
-//# sourceMappingURL=upload.d.ts.map

package/src/@claude-flow/cli/dist/src/transfer/models/seraphine.d.ts

@@ -1,72 +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 type { CFPFormat, PatternCollection, RoutingPattern, ComplexityPattern, CoveragePattern, TrajectoryPattern, CustomPattern } from '../types.js';
-/**
- * Seraphine model version
- */
-export declare const SERAPHINE_VERSION = "1.0.0";
-/**
- * Seraphine model metadata
- */
-export declare const SERAPHINE_METADATA: {
-    name: string;
-    displayName: string;
-    description: string;
-    author: {
-        id: string;
-        displayName: string;
-    };
-    license: string;
-    tags: string[];
-    language: string;
-    framework: string;
-};
-/**
- * Core routing patterns for Seraphine
- * These define how tasks are routed to appropriate agents
- */
-export declare const SERAPHINE_ROUTING_PATTERNS: RoutingPattern[];
-/**
- * Complexity heuristics for Seraphine
- * These help estimate task complexity for resource allocation
- */
-export declare const SERAPHINE_COMPLEXITY_PATTERNS: ComplexityPattern[];
-/**
- * Coverage patterns for Seraphine
- * These track knowledge domain coverage
- */
-export declare const SERAPHINE_COVERAGE_PATTERNS: CoveragePattern[];
-/**
- * Trajectory patterns for Seraphine
- * These capture successful task execution paths
- */
-export declare const SERAPHINE_TRAJECTORY_PATTERNS: TrajectoryPattern[];
-/**
- * Custom patterns for Seraphine
- * These are specialized patterns unique to Seraphine
- */
-export declare const SERAPHINE_CUSTOM_PATTERNS: CustomPattern[];
-/**
- * Create the complete Seraphine pattern collection
- */
-export declare function createSeraphinePatterns(): PatternCollection;
-/**
- * Create the Seraphine Genesis CFP document
- */
-export declare function createSeraphineGenesis(): CFPFormat;
-/**
- * Get Seraphine model info
- */
-export declare function getSeraphineInfo(): {
-    name: string;
-    version: string;
-    description: string;
-    patternCounts: Record<string, number>;
-};
-//# sourceMappingURL=seraphine.d.ts.map