moflo 4.8.30 → 4.8.32

package/src/@claude-flow/cli/dist/src/ruvector/q-learning-router.d.ts

@@ -1,211 +0,0 @@
-/**
- * Q-Learning Router for Task Routing
- *
- * Uses reinforcement learning to optimize task routing decisions
- * based on historical performance and context.
- *
- * Features:
- * - Caching for repeated task patterns (LRU cache)
- * - Optimized state space with feature hashing
- * - Epsilon decay with exponential annealing
- * - Experience replay buffer for stable learning
- * - Model persistence to .swarm/q-learning-model.json
- *
- * @module q-learning-router
- */
-/**
- * Q-Learning Router Configuration
- */
-export interface QLearningRouterConfig {
-    /** Learning rate (default: 0.1) */
-    learningRate: number;
-    /** Discount factor (default: 0.99) */
-    gamma: number;
-    /** Initial exploration rate (default: 1.0) */
-    explorationInitial: number;
-    /** Final exploration rate (default: 0.01) */
-    explorationFinal: number;
-    /** Exploration decay steps (default: 10000) */
-    explorationDecay: number;
-    /** Exploration decay type (default: 'exponential') */
-    explorationDecayType: 'linear' | 'exponential' | 'cosine';
-    /** Maximum states in Q-table (default: 10000) */
-    maxStates: number;
-    /** Number of actions/routes (default: 8) */
-    numActions: number;
-    /** Experience replay buffer size (default: 1000) */
-    replayBufferSize: number;
-    /** Mini-batch size for replay (default: 32) */
-    replayBatchSize: number;
-    /** Enable experience replay (default: true) */
-    enableReplay: boolean;
-    /** Route cache size (default: 256) */
-    cacheSize: number;
-    /** Cache TTL in milliseconds (default: 300000 = 5 minutes) */
-    cacheTTL: number;
-    /** Model persistence path (default: '.swarm/q-learning-model.json') */
-    modelPath: string;
-    /** Auto-save interval in updates (default: 100) */
-    autoSaveInterval: number;
-    /** State space dimensionality for feature hashing (default: 64) */
-    stateSpaceDim: number;
-}
-/**
- * Route decision result
- */
-export interface RouteDecision {
-    /** Selected route/action */
-    route: string;
-    /** Confidence score (0-1) */
-    confidence: number;
-    /** Q-values for all routes */
-    qValues: number[];
-    /** Was exploration used */
-    explored: boolean;
-    /** Route alternatives */
-    alternatives: Array<{
-        route: string;
-        score: number;
-    }>;
-}
-/**
- * Q-Learning Router for intelligent task routing
- *
- * Optimized with:
- * - LRU cache for repeated task patterns
- * - Feature hashing for efficient state space
- * - Exponential epsilon decay
- * - Prioritized experience replay
- * - Model persistence
- */
-export declare class QLearningRouter {
-    private config;
-    private qTable;
-    private epsilon;
-    private stepCount;
-    private updateCount;
-    private avgTDError;
-    private ruvectorEngine;
-    private useNative;
-    private replayBuffer;
-    private replayBufferIdx;
-    private totalExperiences;
-    private routeCache;
-    private cacheOrder;
-    private cacheHits;
-    private cacheMisses;
-    private featureHashCache;
-    constructor(config?: Partial<QLearningRouterConfig>);
-    /**
-     * Initialize the router, attempting to load ruvector native module
-     * and restore persisted model if available
-     */
-    initialize(): Promise<void>;
-    /**
-     * Load model from persistence file
-     */
-    loadModel(path?: string): Promise<boolean>;
-    /**
-     * Save model to persistence file
-     */
-    saveModel(path?: string): Promise<boolean>;
-    /**
-     * Route a task based on its context
-     * Uses LRU cache for repeated task patterns
-     */
-    route(taskContext: string, explore?: boolean): RouteDecision;
-    /**
-     * Get cached route decision (LRU cache)
-     */
-    private getCachedRoute;
-    /**
-     * Cache a route decision (LRU eviction)
-     */
-    private cacheRoute;
-    /**
-     * Invalidate cache (call after significant Q-table updates)
-     */
-    invalidateCache(): void;
-    /**
-     * Update Q-values based on feedback
-     * Includes experience replay for stable learning
-     */
-    update(taskContext: string, action: string, reward: number, nextContext?: string): number;
-    /**
-     * Internal Q-value update
-     */
-    private updateQValue;
-    /**
-     * Add experience to circular replay buffer
-     */
-    private addToReplayBuffer;
-    /**
-     * Perform prioritized experience replay
-     * Samples mini-batch from buffer and updates Q-values
-     */
-    private experienceReplay;
-    /**
-     * Sample a prioritized batch from replay buffer
-     * Uses proportional prioritization
-     */
-    private samplePrioritizedBatch;
-    /**
-     * Calculate epsilon using configured decay strategy
-     */
-    private calculateEpsilon;
-    /**
-     * Get statistics including cache and replay buffer metrics
-     */
-    getStats(): Record<string, number>;
-    /**
-     * Reset the router (clears all learned data)
-     */
-    reset(): void;
-    /**
-     * Export Q-table for persistence
-     */
-    export(): Record<string, {
-        qValues: number[];
-        visits: number;
-    }>;
-    /**
-     * Import Q-table from persistence
-     */
-    import(data: Record<string, {
-        qValues: number[];
-        visits: number;
-    }>): void;
-    /**
-     * Legacy hash function (kept for backward compatibility)
-     */
-    private hashState;
-    /**
-     * Optimized state hashing using feature extraction
-     * Creates a more semantic representation of the task context
-     */
-    private hashStateOptimized;
-    /**
-     * Extract feature vector from task context
-     * Uses keyword matching and n-gram hashing
-     */
-    private extractFeatures;
-    /**
-     * Convert feature vector to state key
-     * Uses locality-sensitive hashing for similar contexts
-     */
-    private featureVectorToKey;
-    /**
-     * MurmurHash3 32-bit implementation for n-gram hashing
-     */
-    private murmurhash3;
-    private getQValues;
-    private getOrCreateEntry;
-    private argmax;
-    private softmaxConfidence;
-    private pruneQTable;
-}
-/**
- * Factory function
- */
-export declare function createQLearningRouter(config?: Partial<QLearningRouterConfig>): QLearningRouter;
-//# sourceMappingURL=q-learning-router.d.ts.map

package/src/@claude-flow/cli/dist/src/ruvector/semantic-router.d.ts

@@ -1,77 +0,0 @@
-/**
- * Pure JavaScript SemanticRouter implementation
- *
- * Provides intent routing using cosine similarity.
- * This is a fallback implementation since @ruvector/router's native VectorDb has bugs.
- *
- * Performance: ~50,000 routes/sec with 100 intents (sufficient for agent routing)
- */
-export interface Intent {
-    name: string;
-    utterances: string[];
-    metadata?: Record<string, unknown>;
-}
-export interface RouteResult {
-    intent: string;
-    score: number;
-    metadata: Record<string, unknown>;
-}
-export interface RouterConfig {
-    dimension: number;
-    metric?: 'cosine' | 'euclidean' | 'dotProduct';
-}
-export declare class SemanticRouter {
-    private dimension;
-    private metric;
-    private intents;
-    private totalVectors;
-    constructor(config: RouterConfig);
-    /**
-     * Add an intent with pre-computed embeddings
-     */
-    addIntentWithEmbeddings(name: string, embeddings: Float32Array[], metadata?: Record<string, unknown>): void;
-    /**
-     * Route a query using a pre-computed embedding
-     */
-    routeWithEmbedding(embedding: Float32Array, k?: number): RouteResult[];
-    /**
-     * Remove an intent
-     */
-    removeIntent(name: string): boolean;
-    /**
-     * Get all intent names
-     */
-    getIntents(): string[];
-    /**
-     * Get intent details
-     */
-    getIntent(name: string): Intent | null;
-    /**
-     * Clear all intents
-     */
-    clear(): void;
-    /**
-     * Get total vector count
-     */
-    count(): number;
-    /**
-     * Get number of intents
-     */
-    intentCount(): number;
-    /**
-     * Normalize a vector for cosine similarity
-     */
-    private normalize;
-    /**
-     * Calculate similarity between two normalized vectors
-     */
-    private similarity;
-    private dotProduct;
-    private euclideanDistance;
-}
-/**
- * Create a SemanticRouter with the given configuration
- */
-export declare function createSemanticRouter(config: RouterConfig): SemanticRouter;
-export default SemanticRouter;
-//# sourceMappingURL=semantic-router.d.ts.map

package/src/@claude-flow/cli/dist/src/ruvector/vector-db.d.ts

@@ -1,69 +0,0 @@
-/**
- * Vector Database Module
- *
- * Provides optional ruvector WASM-accelerated vector operations for:
- * - Semantic similarity search
- * - HNSW indexing (150x faster)
- * - Embedding generation
- *
- * Gracefully degrades when ruvector is not installed.
- *
- * Created with love by motailz.com
- */
-export interface VectorDB {
-    insert(embedding: Float32Array, id: string, metadata?: Record<string, unknown>): void | Promise<void>;
-    search(query: Float32Array, k?: number): Array<{
-        id: string;
-        score: number;
-        metadata?: Record<string, unknown>;
-    }> | Promise<Array<{
-        id: string;
-        score: number;
-        metadata?: Record<string, unknown>;
-    }>>;
-    remove(id: string): boolean | Promise<boolean>;
-    size(): number | Promise<number>;
-    clear(): void | Promise<void>;
-}
-export interface RuVectorModule {
-    createVectorDB(dimensions: number): Promise<VectorDB>;
-    generateEmbedding(text: string, dimensions?: number): Float32Array;
-    cosineSimilarity(a: Float32Array, b: Float32Array): number;
-    isWASMAccelerated(): boolean;
-}
-/**
- * Attempt to load the ruvector module
- * Returns true if successfully loaded, false otherwise
- */
-export declare function loadRuVector(): Promise<boolean>;
-/**
- * Check if ruvector is available
- */
-export declare function isRuVectorAvailable(): boolean;
-/**
- * Check if WASM acceleration is enabled
- */
-export declare function isWASMAccelerated(): boolean;
-/**
- * Create a vector database
- * Uses ruvector HNSW if available, falls back to brute-force search
- */
-export declare function createVectorDB(dimensions?: number): Promise<VectorDB>;
-/**
- * Generate an embedding for text
- * Uses ruvector if available, falls back to hash-based embedding
- */
-export declare function generateEmbedding(text: string, dimensions?: number): Float32Array;
-/**
- * Compute cosine similarity between two vectors
- */
-export declare function computeSimilarity(a: Float32Array, b: Float32Array): number;
-/**
- * Get status information about the ruvector module
- */
-export declare function getStatus(): {
-    available: boolean;
-    wasmAccelerated: boolean;
-    backend: 'ruvector-wasm' | 'ruvector' | 'fallback';
-};
-//# sourceMappingURL=vector-db.d.ts.map

package/src/@claude-flow/cli/dist/src/services/agent-router.d.ts

@@ -1,63 +0,0 @@
-/**
- * Agent Router Service
- *
- * Routes tasks to optimal agent types based on learned patterns
- * and hardcoded keyword matching. Learned patterns take priority
- * over static patterns (0.9 vs 0.8 confidence).
- */
-export interface RouteResult {
-    agentType: string;
-    confidence: number;
-    reason: string;
-}
-export type AgentType = 'coder' | 'tester' | 'reviewer' | 'researcher' | 'architect' | 'backend-dev' | 'frontend-dev' | 'devops' | 'security-architect' | 'security-auditor' | 'memory-specialist' | 'coordinator' | 'analyst' | 'optimizer';
-export declare const AGENT_CAPABILITIES: Record<string, string[]>;
-export declare class AgentRouter {
-    private learnedPatterns;
-    constructor(projectRoot?: string);
-    /**
-     * Route a task description to the optimal agent type.
-     *
-     * Priority:
-     * 1. Learned patterns (confidence 0.9)
-     * 2. Static regex patterns (confidence 0.8)
-     * 3. Default to 'coder' (confidence 0.5)
-     */
-    routeTask(description: string): RouteResult;
-    /**
-     * Reload learned patterns from disk.
-     */
-    reload(projectRoot?: string): void;
-    /**
-     * Get all available agent types.
-     */
-    getAgentTypes(): string[];
-    /**
-     * Get capabilities for an agent type.
-     */
-    getCapabilities(agentType: string): string[];
-    /**
-     * Get the number of loaded learned patterns.
-     */
-    getLearnedPatternCount(): number;
-    /**
-     * Get routing statistics from persisted outcomes.
-     */
-    getStats(projectRoot?: string): {
-        totalOutcomes: number;
-        successRate: number;
-        avgQuality: number;
-        agentDistribution: Record<string, number>;
-        learnedPatterns: number;
-    };
-    /**
-     * Write routing accuracy stats to learning.json for dashboard consumption.
-     */
-    syncLearningMetrics(projectRoot?: string): void;
-}
-export declare function getAgentRouter(projectRoot?: string): AgentRouter;
-/**
- * Convenience function matching the original router.js API.
- */
-export declare function routeTask(description: string, projectRoot?: string): RouteResult;
-//# sourceMappingURL=agent-router.d.ts.map

package/src/@claude-flow/cli/dist/src/services/agentic-flow-bridge.d.ts

@@ -1,50 +0,0 @@
-/**
- * agentic-flow v3 integration bridge
- *
- * Provides a single lazy-loading entry point for all agentic-flow v3
- * subpath exports. Every accessor returns `null` when agentic-flow is
- * not installed — callers never throw on missing optional dependency.
- *
- * @module agentic-flow-bridge
- */
-/**
- * Load the ReasoningBank module (4-step learning pipeline).
- * Returns null if agentic-flow is not installed.
- * Race-safe: concurrent callers share the same import Promise.
- */
-export declare function getReasoningBank(): Promise<any>;
-/**
- * Load the ModelRouter module (multi-provider LLM routing).
- * Returns null if agentic-flow is not installed.
- */
-export declare function getRouter(): Promise<any>;
-/**
- * Load the Orchestration module (workflow engine).
- * Returns null if agentic-flow is not installed.
- */
-export declare function getOrchestration(): Promise<any>;
-/**
- * Compute an embedding vector via ReasoningBank, falling back to null.
- */
-export declare function computeEmbedding(text: string): Promise<number[] | null>;
-/**
- * Retrieve memories matching a query via ReasoningBank.
- */
-export declare function retrieveMemories(query: string, opts?: {
-    k?: number;
-}): Promise<any[]>;
-/**
- * Check whether agentic-flow v3 is available at runtime.
- */
-export declare function isAvailable(): Promise<boolean>;
-/**
- * Return a summary of available agentic-flow v3 capabilities.
- */
-export declare function capabilities(): Promise<{
-    available: boolean;
-    reasoningBank: boolean;
-    router: boolean;
-    orchestration: boolean;
-    version: string | null;
-}>;
-//# sourceMappingURL=agentic-flow-bridge.d.ts.map

package/src/@claude-flow/cli/dist/src/services/claim-service.d.ts

@@ -1,204 +0,0 @@
-/**
- * V3 Collaborative Issue Claims Service
- *
- * Implements ADR-016: Collaborative Issue Claims for Human-Agent Workflows
- *
- * Features:
- * - Issue claiming/releasing for humans and agents
- * - Handoff mechanisms between humans and agents
- * - Work stealing for idle agents
- * - Load balancing across swarm
- * - GitHub integration
- *
- * @see /v3/implementation/adrs/ADR-016-collaborative-issue-claims.md
- */
-import { EventEmitter } from 'events';
-export type Claimant = {
-    type: 'human';
-    userId: string;
-    name: string;
-} | {
-    type: 'agent';
-    agentId: string;
-    agentType: string;
-};
-export type ClaimStatus = 'active' | 'paused' | 'handoff-pending' | 'review-requested' | 'blocked' | 'stealable' | 'completed';
-export type StealReason = 'overloaded' | 'stale' | 'blocked-timeout' | 'voluntary';
-export interface IssueClaim {
-    issueId: string;
-    claimant: Claimant;
-    claimedAt: Date;
-    status: ClaimStatus;
-    statusChangedAt: Date;
-    expiresAt?: Date;
-    handoffTo?: Claimant;
-    handoffReason?: string;
-    blockReason?: string;
-    progress: number;
-    context?: string;
-}
-export interface StealableInfo {
-    reason: StealReason;
-    stealableAt: Date;
-    preferredTypes?: string[];
-    progress: number;
-    context?: string;
-}
-export interface ClaimResult {
-    success: boolean;
-    claim?: IssueClaim;
-    error?: string;
-}
-export interface StealResult {
-    success: boolean;
-    claim?: IssueClaim;
-    previousOwner?: Claimant;
-    context?: StealableInfo;
-    error?: string;
-}
-export interface AgentLoadInfo {
-    agentId: string;
-    agentType: string;
-    claimCount: number;
-    maxClaims: number;
-    utilization: number;
-    claims: IssueClaim[];
-    avgCompletionTime: number;
-    currentBlockedCount: number;
-}
-export interface RebalanceResult {
-    moved: Array<{
-        issueId: string;
-        from: Claimant;
-        to: Claimant;
-    }>;
-    suggested: Array<{
-        issueId: string;
-        currentOwner: Claimant;
-        suggestedOwner: Claimant;
-        reason: string;
-    }>;
-}
-export interface WorkStealingConfig {
-    staleThresholdMinutes: number;
-    blockedThresholdMinutes: number;
-    overloadThreshold: number;
-    gracePeriodMinutes: number;
-    minProgressToProtect: number;
-    contestWindowMinutes: number;
-    requireSameType: boolean;
-    allowCrossTypeSteal: string[][];
-}
-export interface IssueFilters {
-    status?: ClaimStatus[];
-    labels?: string[];
-    agentTypes?: string[];
-    priority?: string[];
-}
-export interface GitHubIssue {
-    number: number;
-    title: string;
-    body: string;
-    state: 'open' | 'closed';
-    labels: string[];
-    assignees: string[];
-    url: string;
-    createdAt: Date;
-    updatedAt: Date;
-}
-export interface GitHubSyncConfig {
-    enabled: boolean;
-    repo?: string;
-    syncLabels: boolean;
-    claimLabel: string;
-    autoAssign: boolean;
-    commentOnClaim: boolean;
-    commentOnRelease: boolean;
-}
-export interface GitHubSyncResult {
-    success: boolean;
-    synced: number;
-    errors: string[];
-    issues?: GitHubIssue[];
-}
-export type ClaimEventType = 'issue:claimed' | 'issue:released' | 'issue:handoff:requested' | 'issue:handoff:accepted' | 'issue:handoff:rejected' | 'issue:status:changed' | 'issue:review:requested' | 'issue:expired' | 'issue:stealable' | 'issue:stolen' | 'issue:steal:contested' | 'issue:steal:resolved' | 'swarm:rebalanced' | 'agent:overloaded' | 'agent:underloaded';
-export interface ClaimEvent {
-    type: ClaimEventType;
-    timestamp: Date;
-    issueId?: string;
-    claimant?: Claimant;
-    previousClaimant?: Claimant;
-    data?: Record<string, unknown>;
-}
-export declare class ClaimService extends EventEmitter {
-    private claims;
-    private stealableInfo;
-    private storagePath;
-    private config;
-    private eventLog;
-    constructor(projectRoot: string, config?: Partial<WorkStealingConfig>);
-    initialize(): Promise<void>;
-    private loadClaims;
-    private saveClaims;
-    claim(issueId: string, claimant: Claimant): Promise<ClaimResult>;
-    release(issueId: string, claimant: Claimant): Promise<void>;
-    requestHandoff(issueId: string, from: Claimant, to: Claimant, reason: string): Promise<void>;
-    acceptHandoff(issueId: string, claimant: Claimant): Promise<void>;
-    rejectHandoff(issueId: string, claimant: Claimant, reason: string): Promise<void>;
-    updateStatus(issueId: string, status: ClaimStatus, note?: string): Promise<void>;
-    updateProgress(issueId: string, progress: number): Promise<void>;
-    requestReview(issueId: string, reviewers: Claimant[]): Promise<void>;
-    markStealable(issueId: string, info: StealableInfo): Promise<void>;
-    steal(issueId: string, stealer: Claimant): Promise<StealResult>;
-    getStealable(agentType?: string): Promise<IssueClaim[]>;
-    contestSteal(issueId: string, originalClaimant: Claimant, reason: string): Promise<void>;
-    getAgentLoad(agentId: string): Promise<AgentLoadInfo>;
-    rebalance(swarmId: string): Promise<RebalanceResult>;
-    getClaimedBy(claimant: Claimant): Promise<IssueClaim[]>;
-    getAvailableIssues(_filters?: IssueFilters): Promise<string[]>;
-    getIssueStatus(issueId: string): Promise<IssueClaim | null>;
-    getAllClaims(): Promise<IssueClaim[]>;
-    getByStatus(status: ClaimStatus): Promise<IssueClaim[]>;
-    expireStale(maxAgeMinutes?: number): Promise<IssueClaim[]>;
-    private formatClaimant;
-    private isSameClaimant;
-    private emitEvent;
-    getEventLog(limit?: number): ClaimEvent[];
-}
-export declare class GitHubSync {
-    private config;
-    private claimService;
-    constructor(claimService: ClaimService, config?: Partial<GitHubSyncConfig>);
-    /**
-     * Check if GitHub CLI is available
-     */
-    isGhAvailable(): boolean;
-    /**
-     * Get the current repository from git remote
-     */
-    getRepo(): string | null;
-    /**
-     * Sync issues from GitHub
-     */
-    syncIssues(state?: 'open' | 'closed' | 'all'): Promise<GitHubSyncResult>;
-    /**
-     * Sync a local claim to GitHub (add label/assignee/comment)
-     */
-    claimOnGitHub(issueNumber: number, claimant: Claimant): Promise<GitHubSyncResult>;
-    /**
-     * Release claim on GitHub (remove label/assignee/comment)
-     */
-    releaseOnGitHub(issueNumber: number, claimant: Claimant): Promise<GitHubSyncResult>;
-    /**
-     * Bulk sync all local claims to GitHub
-     */
-    syncAllClaimsToGitHub(): Promise<GitHubSyncResult>;
-    /**
-     * Get GitHub issues that are claimed locally
-     */
-    getClaimedGitHubIssues(): Promise<GitHubIssue[]>;
-}
-export declare function createClaimService(projectRoot: string, config?: Partial<WorkStealingConfig>): ClaimService;
-export declare function createGitHubSync(claimService: ClaimService, config?: Partial<GitHubSyncConfig>): GitHubSync;
-export default ClaimService;
-//# sourceMappingURL=claim-service.d.ts.map