@claude-flow/cli 3.32.3 → 3.32.4

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

@@ -0,0 +1,157 @@
+/**
+ * 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

@@ -0,0 +1,175 @@
+/**
+ * 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