moflo 4.8.31 → 4.8.32

package/src/@claude-flow/cli/dist/src/production/rate-limiter.d.ts

@@ -1,80 +0,0 @@
-/**
- * Production Rate Limiting
- *
- * Provides token bucket rate limiting with:
- * - Per-operation limits
- * - Per-user/agent limits
- * - Burst allowance
- * - Sliding window tracking
- *
- * @module @claude-flow/cli/production/rate-limiter
- */
-export interface RateLimiterConfig {
-    maxRequests: number;
-    windowMs: number;
-    burstMultiplier: number;
-    whitelist: string[];
-    operationLimits: Record<string, {
-        maxRequests: number;
-        windowMs: number;
-    }>;
-    perUserLimits: boolean;
-    maxTrackedUsers: number;
-}
-export interface RateLimitResult {
-    allowed: boolean;
-    remaining: number;
-    resetAt: number;
-    retryAfterMs?: number;
-}
-export declare class RateLimiter {
-    private config;
-    private buckets;
-    private globalBucket;
-    constructor(config?: Partial<RateLimiterConfig>);
-    /**
-     * Check if a request is allowed
-     */
-    check(operation: string, userId?: string): RateLimitResult;
-    /**
-     * Consume a token (use after successful request)
-     */
-    consume(operation: string, userId?: string): boolean;
-    /**
-     * Get current rate limit status
-     */
-    getStatus(operation: string, userId?: string): {
-        current: number;
-        limit: number;
-        remaining: number;
-        resetAt: number;
-    };
-    /**
-     * Reset limits for a specific key
-     */
-    reset(operation: string, userId?: string): void;
-    /**
-     * Reset all limits
-     */
-    resetAll(): void;
-    /**
-     * Get statistics
-     */
-    getStats(): {
-        totalBuckets: number;
-        activeUsers: number;
-        mostLimitedOperations: Array<{
-            operation: string;
-            requests: number;
-        }>;
-    };
-    private getLimits;
-    private createBucket;
-    private cleanupBuckets;
-}
-/**
- * Create a rate limiter with default config
- */
-export declare function createRateLimiter(config?: Partial<RateLimiterConfig>): RateLimiter;
-export default RateLimiter;
-//# sourceMappingURL=rate-limiter.d.ts.map

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

@@ -1,48 +0,0 @@
-/**
- * Production Retry Mechanisms
- *
- * Provides retry with:
- * - Exponential backoff
- * - Jitter
- * - Per-error-type configuration
- * - Circuit breaker integration
- *
- * @module @claude-flow/cli/production/retry
- */
-export interface RetryConfig {
-    maxAttempts: number;
-    initialDelayMs: number;
-    maxDelayMs: number;
-    backoffMultiplier: number;
-    jitter: number;
-    nonRetryableErrors: string[];
-    shouldRetry?: (error: Error, attempt: number) => boolean;
-    onRetry?: (error: Error, attempt: number, delayMs: number) => void;
-}
-export interface RetryResult<T> {
-    success: boolean;
-    result?: T;
-    error?: Error;
-    attempts: number;
-    totalTimeMs: number;
-    retryHistory: Array<{
-        attempt: number;
-        error: string;
-        delayMs: number;
-    }>;
-}
-export type RetryStrategy = 'exponential' | 'linear' | 'constant' | 'fibonacci';
-/**
- * Execute a function with retry logic
- */
-export declare function withRetry<T>(fn: () => Promise<T>, config?: Partial<RetryConfig>, strategy?: RetryStrategy): Promise<RetryResult<T>>;
-/**
- * Create a retryable version of a function
- */
-export declare function makeRetryable<T extends (...args: unknown[]) => Promise<unknown>>(fn: T, config?: Partial<RetryConfig>, strategy?: RetryStrategy): (...args: Parameters<T>) => Promise<RetryResult<Awaited<ReturnType<T>>>>;
-/**
- * Retry decorator for class methods
- */
-export declare function Retryable(config?: Partial<RetryConfig>, strategy?: RetryStrategy): (_target: unknown, _propertyKey: string, descriptor: PropertyDescriptor) => PropertyDescriptor;
-export default withRetry;
-//# sourceMappingURL=retry.d.ts.map

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

@@ -1,44 +0,0 @@
-/**
- * V3 CLI Interactive Prompt System
- * Modern interactive prompts for user input
- */
-import type { SelectPromptOptions, SelectOption, ConfirmPromptOptions, InputPromptOptions, MultiSelectPromptOptions } from './types.js';
-import { OutputFormatter } from './output.js';
-declare class PromptManager {
-    private rl;
-    private formatter;
-    constructor(formatter?: OutputFormatter);
-    private createInterface;
-    private close;
-    private question;
-    select<T = string>(options: SelectPromptOptions<T>): Promise<T>;
-    confirm(options: ConfirmPromptOptions): Promise<boolean>;
-    input(options: InputPromptOptions): Promise<string>;
-    private inputMasked;
-    multiSelect<T = string>(options: MultiSelectPromptOptions<T>): Promise<T[]>;
-    text(message: string, placeholder?: string): Promise<string>;
-    number(message: string, options?: {
-        default?: number;
-        min?: number;
-        max?: number;
-    }): Promise<number>;
-    autocomplete<T = string>(message: string, choices: SelectOption<T>[], options?: {
-        limit?: number;
-    }): Promise<T>;
-}
-export declare const promptManager: PromptManager;
-export declare const select: <T = string>(options: SelectPromptOptions<T>) => Promise<T>;
-export declare const confirm: (options: ConfirmPromptOptions) => Promise<boolean>;
-export declare const input: (options: InputPromptOptions) => Promise<string>;
-export declare const multiSelect: <T = string>(options: MultiSelectPromptOptions<T>) => Promise<T[]>;
-export declare const text: (message: string, placeholder?: string) => Promise<string>;
-export declare const number: (message: string, options?: {
-    default?: number;
-    min?: number;
-    max?: number;
-}) => Promise<number>;
-export declare const autocomplete: <T = string>(message: string, choices: SelectOption<T>[], options?: {
-    limit?: number;
-}) => Promise<T>;
-export {};
-//# sourceMappingURL=prompt.d.ts.map

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

@@ -1,60 +0,0 @@
-#!/usr/bin/env node
-/**
- * Headless Runtime for Background Workers
- * Runs without TTY for daemon processes and scheduled tasks
- *
- * Usage:
- *   npx moflo headless --worker <type>
- *   npx moflo headless --daemon
- *   npx moflo headless --benchmark
- *
- * Environment:
- *   CLAUDE_FLOW_HEADLESS=true
- *   CLAUDE_CODE_HEADLESS=true
- *
- * @module v3/cli/runtime/headless
- */
-import { type HeadlessWorkerType } from '../services/headless-worker-executor.js';
-interface HeadlessConfig {
-    mode: 'worker' | 'daemon' | 'benchmark' | 'status';
-    workerType?: HeadlessWorkerType;
-    timeout?: number;
-    verbose?: boolean;
-}
-interface BenchmarkResults {
-    sona: {
-        avgMs: number;
-        targetMet: boolean;
-    };
-    flashAttention: {
-        throughputPerMs: number;
-        speedup: number;
-    };
-    hnsw: {
-        entriesIndexed: number;
-        searchTime: number;
-    };
-}
-/**
- * Run a specific worker
- */
-declare function runWorker(workerType: HeadlessWorkerType, timeout: number): Promise<void>;
-/**
- * Run daemon mode
- */
-declare function runDaemon(): Promise<void>;
-/**
- * Run benchmarks
- */
-declare function runBenchmarks(): Promise<BenchmarkResults>;
-/**
- * Show system status
- */
-declare function showStatus(): Promise<void>;
-/**
- * Main entry point
- */
-declare function main(): Promise<void>;
-export { main, runWorker, runDaemon, runBenchmarks, showStatus };
-export type { HeadlessConfig, BenchmarkResults };
-//# sourceMappingURL=headless.d.ts.map

package/src/@claude-flow/cli/dist/src/ruvector/ast-analyzer.d.ts

@@ -1,67 +0,0 @@
-/**
- * AST Analyzer for Code Analysis
- *
- * Analyzes Abstract Syntax Trees for code understanding
- * and intelligent routing decisions.
- *
- * @module ast-analyzer
- */
-export interface ASTAnalyzerConfig {
-    maxFileSize: number;
-    languages: string[];
-    includeComments: boolean;
-    extractTypes: boolean;
-    maxDepth: number;
-}
-export interface ASTNode {
-    type: string;
-    name: string;
-    startLine: number;
-    endLine: number;
-    children: ASTNode[];
-    metadata?: Record<string, unknown>;
-}
-export interface ASTAnalysis {
-    filePath: string;
-    language: string;
-    root: ASTNode;
-    functions: ASTNode[];
-    classes: ASTNode[];
-    imports: string[];
-    exports: string[];
-    complexity: {
-        cyclomatic: number;
-        cognitive: number;
-        loc: number;
-        commentDensity: number;
-    };
-    timestamp: number;
-    durationMs: number;
-}
-export declare class ASTAnalyzer {
-    private config;
-    private ruvectorEngine;
-    private useNative;
-    private analysisCache;
-    constructor(config?: Partial<ASTAnalyzerConfig>);
-    initialize(): Promise<void>;
-    analyze(code: string, filePath?: string): ASTAnalysis;
-    getFunctionAtLine(analysis: ASTAnalysis, line: number): ASTNode | null;
-    getClassAtLine(analysis: ASTAnalysis, line: number): ASTNode | null;
-    getSymbols(analysis: ASTAnalysis): string[];
-    getStats(): Record<string, number>;
-    clearCache(): void;
-    private getCacheKey;
-    private detectLanguage;
-    private parseAST;
-    private matchFunction;
-    private matchClass;
-    private findBlockEnd;
-    private extractFunctions;
-    private extractClasses;
-    private extractImports;
-    private extractExports;
-    private calculateComplexity;
-}
-export declare function createASTAnalyzer(config?: Partial<ASTAnalyzerConfig>): ASTAnalyzer;
-//# sourceMappingURL=ast-analyzer.d.ts.map

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

@@ -1,160 +0,0 @@
-/**
- * Coverage Router for Test Routing
- *
- * Optimizations:
- * - Async file I/O for non-blocking coverage loading
- * - TTL-based caching of coverage data
- * - Singleton router instance
- */
-/**
- * Clear coverage cache
- */
-export declare function clearCoverageCache(): void;
-/**
- * Get coverage cache stats
- */
-export declare function getCoverageCacheStats(): {
-    size: number;
-};
-export interface CoverageRouterConfig {
-    minCoverage: number;
-    targetCoverage: number;
-    incremental: boolean;
-    coverageTypes: ('line' | 'branch' | 'function' | 'statement')[];
-}
-export interface FileCoverage {
-    path: string;
-    lineCoverage: number;
-    branchCoverage: number;
-    functionCoverage: number;
-    statementCoverage: number;
-    uncoveredLines: number[];
-    totalLines: number;
-    coveredLines: number;
-}
-export interface CoverageReport {
-    overall: number;
-    byType: {
-        line: number;
-        branch: number;
-        function: number;
-        statement: number;
-    };
-    byFile: FileCoverage[];
-    lowestCoverage: FileCoverage[];
-    highestCoverage: FileCoverage[];
-    uncoveredCritical: string[];
-    timestamp: number;
-}
-export interface CoverageRouteResult {
-    action: 'add-tests' | 'review-coverage' | 'skip' | 'prioritize';
-    priority: number;
-    targetFiles: string[];
-    testTypes: ('unit' | 'integration' | 'e2e')[];
-    gaps: Array<{
-        file: string;
-        currentCoverage: number;
-        targetCoverage: number;
-        gap: number;
-        suggestedTests: string[];
-    }>;
-    estimatedEffort: number;
-    impactScore: number;
-}
-export declare class CoverageRouter {
-    private config;
-    private ruvectorEngine;
-    private useNative;
-    private coverageHistory;
-    constructor(config?: Partial<CoverageRouterConfig>);
-    initialize(): Promise<void>;
-    parseCoverage(data: unknown, format?: 'lcov' | 'istanbul' | 'cobertura' | 'json'): CoverageReport;
-    route(coverage: CoverageReport, changedFiles?: string[]): CoverageRouteResult;
-    getTrend(): {
-        direction: 'up' | 'down' | 'stable';
-        change: number;
-    };
-    addToHistory(report: CoverageReport): void;
-    getStats(): Record<string, number | boolean>;
-    private parseLcov;
-    private parseIstanbul;
-    private parseCobertura;
-    private parseJson;
-    private finalizeFileCoverage;
-    private buildReport;
-    private findCriticalUncovered;
-    private calculateGaps;
-    private suggestTests;
-    private prioritizeFiles;
-    private determineAction;
-    private calculatePriority;
-    private recommendTestTypes;
-    private estimateEffort;
-    private calculateImpact;
-}
-export declare function createCoverageRouter(config?: Partial<CoverageRouterConfig>): CoverageRouter;
-/**
- * Coverage suggestion result
- */
-export interface CoverageSuggestResult {
-    path: string;
-    suggestions: Array<{
-        file: string;
-        currentCoverage: number;
-        targetCoverage: number;
-        gap: number;
-        priority: number;
-        suggestedTests: string[];
-    }>;
-    totalGap: number;
-    estimatedEffort: number;
-}
-/**
- * Coverage gaps result
- */
-export interface CoverageGapsResult {
-    totalGaps: number;
-    gaps: Array<{
-        file: string;
-        currentCoverage: number;
-        targetCoverage: number;
-        gap: number;
-        priority: number;
-        suggestedAgent: string;
-    }>;
-    byAgent: Record<string, string[]>;
-    summary: string;
-}
-/**
- * Coverage route options
- */
-export interface CoverageRouteOptions {
-    projectRoot?: string;
-    threshold?: number;
-    useRuvector?: boolean;
-}
-/**
- * Coverage suggest options
- */
-export interface CoverageSuggestOptions extends CoverageRouteOptions {
-    limit?: number;
-}
-/**
- * Coverage gaps options
- */
-export interface CoverageGapsOptions extends CoverageRouteOptions {
-    groupByAgent?: boolean;
-}
-/**
- * Route a task based on coverage analysis
- */
-export declare function coverageRoute(task: string, options?: CoverageRouteOptions): Promise<CoverageRouteResult>;
-/**
- * Suggest coverage improvements for a path
- */
-export declare function coverageSuggest(path: string, options?: CoverageSuggestOptions): Promise<CoverageSuggestResult>;
-/**
- * List all coverage gaps with agent assignments
- */
-export declare function coverageGaps(options?: CoverageGapsOptions): Promise<CoverageGapsResult>;
-//# sourceMappingURL=coverage-router.d.ts.map

package/src/@claude-flow/cli/dist/src/ruvector/coverage-tools.d.ts

@@ -1,33 +0,0 @@
-/**
- * Coverage Router MCP Tools
- *
- * MCP tool implementations for coverage-aware routing.
- * Integrates with hooks_coverage_route and hooks_coverage_suggest from ruvector.
- */
-import type { MCPTool } from '../mcp-tools/types.js';
-/**
- * Coverage-aware routing MCP tool
- *
- * Routes tasks to optimal agents based on test coverage gaps.
- * Uses ruvector's hooks_coverage_route when available.
- */
-export declare const hooksCoverageRoute: MCPTool;
-/**
- * Coverage suggestions MCP tool
- *
- * Suggests which files need better coverage in a given path.
- * Uses ruvector's hooks_coverage_suggest when available.
- */
-export declare const hooksCoverageSuggest: MCPTool;
-/**
- * Coverage gaps MCP tool
- *
- * Lists all coverage gaps in the project with agent assignments.
- */
-export declare const hooksCoverageGaps: MCPTool;
-/**
- * All coverage router MCP tools
- */
-export declare const coverageRouterTools: MCPTool[];
-export default coverageRouterTools;
-//# sourceMappingURL=coverage-tools.d.ts.map

package/src/@claude-flow/cli/dist/src/ruvector/diff-classifier.d.ts

@@ -1,175 +0,0 @@
-/**
- * Diff Classifier for Change Analysis
- */
-export interface DiffClassifierConfig {
-    maxDiffSize: number;
-    classifyByImpact: boolean;
-    detectRefactoring: boolean;
-    minConfidence: number;
-}
-export interface DiffHunk {
-    oldStart: number;
-    oldLines: number;
-    newStart: number;
-    newLines: number;
-    content: string;
-    changes: DiffChange[];
-}
-export interface DiffChange {
-    type: 'add' | 'remove' | 'context';
-    lineNumber: number;
-    content: string;
-}
-export interface DiffClassification {
-    primary: 'feature' | 'bugfix' | 'refactor' | 'docs' | 'test' | 'config' | 'style' | 'unknown';
-    secondary: string[];
-    confidence: number;
-    impactLevel: 'low' | 'medium' | 'high' | 'critical';
-    suggestedReviewers: string[];
-    testingStrategy: string[];
-    riskFactors: string[];
-}
-export interface FileDiff {
-    path: string;
-    hunks: DiffHunk[];
-    additions: number;
-    deletions: number;
-    classification: DiffClassification;
-}
-export interface DiffAnalysis {
-    files: FileDiff[];
-    overall: DiffClassification;
-    stats: {
-        totalAdditions: number;
-        totalDeletions: number;
-        filesChanged: number;
-        avgConfidence: number;
-    };
-    timestamp: number;
-}
-export declare class DiffClassifier {
-    private config;
-    private ruvectorEngine;
-    private useNative;
-    private classificationCache;
-    constructor(config?: Partial<DiffClassifierConfig>);
-    initialize(): Promise<void>;
-    parseDiff(diffContent: string): FileDiff[];
-    classify(files: FileDiff[]): DiffAnalysis;
-    classifyCommitMessage(message: string): DiffClassification['primary'];
-    getStats(): Record<string, number | boolean>;
-    clearCache(): void;
-    private parseHunks;
-    private parseChanges;
-    private classifyFile;
-    private getCacheKey;
-    private determinePrimaryClassification;
-    private isRefactoring;
-    private determineSecondaryClassifications;
-    private calculateConfidence;
-    private determineImpactLevel;
-    private suggestReviewers;
-    private determineTestingStrategy;
-    private identifyRiskFactors;
-    private computeOverallClassification;
-}
-export declare function createDiffClassifier(config?: Partial<DiffClassifierConfig>): DiffClassifier;
-/**
- * Risk level type for file risk assessment
- */
-export type RiskLevel = 'low' | 'medium' | 'high' | 'critical';
-/**
- * Diff file interface for analyze tools
- */
-export interface DiffFile {
-    path: string;
-    status: 'added' | 'modified' | 'deleted' | 'renamed';
-    additions: number;
-    deletions: number;
-    hunks: number;
-    binary: boolean;
-}
-/**
- * File risk assessment result
- */
-export interface FileRisk {
-    file: string;
-    risk: RiskLevel;
-    score: number;
-    reasons: string[];
-}
-/**
- * Overall risk assessment result
- */
-export interface OverallRisk {
-    overall: RiskLevel;
-    score: number;
-    breakdown: {
-        low: number;
-        medium: number;
-        high: number;
-        critical: number;
-    };
-}
-/**
- * Diff analysis result
- */
-export interface DiffAnalysisResult {
-    ref: string;
-    timestamp: number;
-    files: DiffFile[];
-    risk: OverallRisk;
-    classification: DiffClassification;
-    summary: string;
-    fileRisks?: FileRisk[];
-    recommendedReviewers?: string[];
-}
-/**
- * Get git diff statistics using SINGLE combined command (optimized)
- * Replaces two separate git commands with one
- */
-export declare function getGitDiffNumstat(ref?: string): DiffFile[];
-/**
- * Async version of getGitDiffNumstat for non-blocking operation
- */
-export declare function getGitDiffNumstatAsync(ref?: string): Promise<DiffFile[]>;
-/**
- * Clear the diff cache (call when git state changes)
- */
-export declare function clearDiffCache(): void;
-/**
- * Assess risk for a single file
- */
-export declare function assessFileRisk(file: DiffFile): FileRisk;
-/**
- * Assess overall risk from files and file risks
- */
-export declare function assessOverallRisk(files: DiffFile[], fileRisks: FileRisk[]): OverallRisk;
-/**
- * Classify a diff based on files (uses singleton classifier)
- */
-export declare function classifyDiff(files: DiffFile[]): DiffClassification;
-/**
- * Suggest reviewers based on files and risks
- */
-export declare function suggestReviewers(files: DiffFile[], fileRisks: FileRisk[]): string[];
-/**
- * Analyze a diff with full analysis (optimized with caching)
- */
-export declare function analyzeDiff(options: {
-    ref?: string;
-    useRuVector?: boolean;
-    skipCache?: boolean;
-}): Promise<DiffAnalysisResult>;
-/**
- * Synchronous version of analyzeDiff for backward compatibility
- */
-export declare function analyzeDiffSync(options: {
-    ref?: string;
-    useRuVector?: boolean;
-}): DiffAnalysisResult;
-/**
- * Clear all diff-related caches
- */
-export declare function clearAllDiffCaches(): void;
-//# sourceMappingURL=diff-classifier.d.ts.map