@claude-flow/cli 3.32.1 → 3.32.3

package/dist/src/ruvector/coverage-tools.js

@@ -1,157 +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 { coverageRoute, coverageSuggest, coverageGaps, } from './coverage-router.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 const hooksCoverageRoute = {
-    name: 'hooks_coverage-route',
-    description: 'Route task to agents based on test coverage gaps (ruvector integration)',
-    category: 'hooks',
-    tags: ['coverage', 'routing', 'testing', 'ruvector'],
-    inputSchema: {
-        type: 'object',
-        properties: {
-            task: {
-                type: 'string',
-                description: 'Task description to route',
-            },
-            projectRoot: {
-                type: 'string',
-                description: 'Project root directory (defaults to cwd)',
-            },
-            threshold: {
-                type: 'number',
-                description: 'Coverage threshold percentage (default: 80)',
-            },
-            useRuvector: {
-                type: 'boolean',
-                description: 'Use ruvector integration if available (default: true)',
-            },
-        },
-        required: ['task'],
-    },
-    handler: async (params) => {
-        const task = params.task;
-        const projectRoot = params.projectRoot;
-        const threshold = params.threshold;
-        const useRuvector = params.useRuvector;
-        return coverageRoute(task, {
-            projectRoot,
-            threshold,
-            useRuvector,
-        });
-    },
-};
-/**
- * Coverage suggestions MCP tool
- *
- * Suggests which files need better coverage in a given path.
- * Uses ruvector's hooks_coverage_suggest when available.
- */
-export const hooksCoverageSuggest = {
-    name: 'hooks_coverage-suggest',
-    description: 'Suggest coverage improvements for a path (ruvector integration)',
-    category: 'hooks',
-    tags: ['coverage', 'suggestions', 'testing', 'ruvector'],
-    inputSchema: {
-        type: 'object',
-        properties: {
-            path: {
-                type: 'string',
-                description: 'Path to analyze for coverage suggestions',
-            },
-            projectRoot: {
-                type: 'string',
-                description: 'Project root directory (defaults to cwd)',
-            },
-            threshold: {
-                type: 'number',
-                description: 'Coverage threshold percentage (default: 80)',
-            },
-            limit: {
-                type: 'number',
-                description: 'Maximum number of suggestions to return (default: 20)',
-            },
-            useRuvector: {
-                type: 'boolean',
-                description: 'Use ruvector integration if available (default: true)',
-            },
-        },
-        required: ['path'],
-    },
-    handler: async (params) => {
-        const path = params.path;
-        const projectRoot = params.projectRoot;
-        const threshold = params.threshold;
-        const limit = params.limit;
-        const useRuvector = params.useRuvector;
-        return coverageSuggest(path, {
-            projectRoot,
-            threshold,
-            limit,
-            useRuvector,
-        });
-    },
-};
-/**
- * Coverage gaps MCP tool
- *
- * Lists all coverage gaps in the project with agent assignments.
- */
-export const hooksCoverageGaps = {
-    name: 'hooks_coverage-gaps',
-    description: 'List all coverage gaps with priority scoring and agent assignments',
-    category: 'hooks',
-    tags: ['coverage', 'gaps', 'testing', 'analysis'],
-    inputSchema: {
-        type: 'object',
-        properties: {
-            projectRoot: {
-                type: 'string',
-                description: 'Project root directory (defaults to cwd)',
-            },
-            threshold: {
-                type: 'number',
-                description: 'Coverage threshold percentage (default: 80)',
-            },
-            groupByAgent: {
-                type: 'boolean',
-                description: 'Group gaps by suggested agent (default: true)',
-            },
-            useRuvector: {
-                type: 'boolean',
-                description: 'Use ruvector integration if available (default: true)',
-            },
-        },
-    },
-    handler: async (params) => {
-        const projectRoot = params.projectRoot;
-        const threshold = params.threshold;
-        const groupByAgent = params.groupByAgent;
-        const useRuvector = params.useRuvector;
-        return coverageGaps({
-            projectRoot,
-            threshold,
-            groupByAgent,
-            useRuvector,
-        });
-    },
-};
-/**
- * All coverage router MCP tools
- */
-export const coverageRouterTools = [
-    hooksCoverageRoute,
-    hooksCoverageSuggest,
-    hooksCoverageGaps,
-];
-export default coverageRouterTools;
-//# sourceMappingURL=coverage-tools.js.map

package/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