@claude-flow/cli 3.32.3 → 3.32.4

package/dist/src/ruvector/codemods/scope-analysis.d.ts

@@ -0,0 +1,29 @@
+/**
+ * Scope-aware reassignment analysis for the `var-to-const` codemod (ADR-143).
+ *
+ * The naive version marks a `var` as reassigned if its name is assigned to
+ * *anywhere* in the file. That is correct but over-conservative: a `var x` in
+ * one function is forced to `let` just because an unrelated function also has
+ * an `x = …`. This module resolves each assignment to the binding it actually
+ * mutates (function-scope hoisting semantics), so a `var` becomes `const`
+ * unless *its own* binding is reassigned.
+ *
+ * Soundness: resolution only ever attributes a reassignment to a scope that
+ * actually hoists the name (i.e. genuinely declares that binding). It therefore
+ * never marks a truly-reassigned binding as un-reassigned — so a `var` is only
+ * promoted to `const` when it is provably never reassigned. Block-scoped
+ * shadowing (let/const) is ignored for resolution, which can only make us *more*
+ * conservative (fall back to `let`), never wrong.
+ *
+ * @module ruvector/codemods/scope-analysis
+ */
+import ts from 'typescript';
+export interface ReassignmentResolver {
+    /** True if the `var` binding declared by `declarationList` (for `name`) is reassigned within its scope. */
+    isReassigned(name: string, declarationList: ts.VariableDeclarationList): boolean;
+}
+/**
+ * Build a scope-aware resolver: which `var` bindings are actually reassigned.
+ */
+export declare function buildReassignmentResolver(sf: ts.SourceFile): ReassignmentResolver;
+//# sourceMappingURL=scope-analysis.d.ts.map

package/dist/src/ruvector/codemods/scope-analysis.js

@@ -0,0 +1,162 @@
+/**
+ * Scope-aware reassignment analysis for the `var-to-const` codemod (ADR-143).
+ *
+ * The naive version marks a `var` as reassigned if its name is assigned to
+ * *anywhere* in the file. That is correct but over-conservative: a `var x` in
+ * one function is forced to `let` just because an unrelated function also has
+ * an `x = …`. This module resolves each assignment to the binding it actually
+ * mutates (function-scope hoisting semantics), so a `var` becomes `const`
+ * unless *its own* binding is reassigned.
+ *
+ * Soundness: resolution only ever attributes a reassignment to a scope that
+ * actually hoists the name (i.e. genuinely declares that binding). It therefore
+ * never marks a truly-reassigned binding as un-reassigned — so a `var` is only
+ * promoted to `const` when it is provably never reassigned. Block-scoped
+ * shadowing (let/const) is ignored for resolution, which can only make us *more*
+ * conservative (fall back to `let`), never wrong.
+ *
+ * @module ruvector/codemods/scope-analysis
+ */
+import ts from 'typescript';
+/** A scope is a function-like node or the SourceFile (the var-hoist boundaries). */
+function isScopeNode(node) {
+    return (ts.isSourceFile(node) ||
+        ts.isFunctionDeclaration(node) ||
+        ts.isFunctionExpression(node) ||
+        ts.isArrowFunction(node) ||
+        ts.isMethodDeclaration(node) ||
+        ts.isConstructorDeclaration(node) ||
+        ts.isGetAccessorDeclaration(node) ||
+        ts.isSetAccessorDeclaration(node));
+}
+function enclosingScope(node) {
+    let cur = node.parent;
+    while (cur && !isScopeNode(cur))
+        cur = cur.parent;
+    return cur ?? node.getSourceFile();
+}
+function parentScope(scope) {
+    if (ts.isSourceFile(scope))
+        return undefined;
+    return enclosingScope(scope);
+}
+function collectIdentifierNames(target, out) {
+    if (ts.isIdentifier(target)) {
+        out(target.text);
+        return;
+    }
+    // Destructuring assignment target (object/array literal on the LHS of `=`).
+    ts.forEachChild(target, (child) => collectIdentifierNames(child, out));
+}
+const ASSIGNMENT_OPERATORS = new Set([
+    ts.SyntaxKind.EqualsToken,
+    ts.SyntaxKind.PlusEqualsToken,
+    ts.SyntaxKind.MinusEqualsToken,
+    ts.SyntaxKind.AsteriskEqualsToken,
+    ts.SyntaxKind.AsteriskAsteriskEqualsToken,
+    ts.SyntaxKind.SlashEqualsToken,
+    ts.SyntaxKind.PercentEqualsToken,
+    ts.SyntaxKind.LessThanLessThanEqualsToken,
+    ts.SyntaxKind.GreaterThanGreaterThanEqualsToken,
+    ts.SyntaxKind.GreaterThanGreaterThanGreaterThanEqualsToken,
+    ts.SyntaxKind.AmpersandEqualsToken,
+    ts.SyntaxKind.BarEqualsToken,
+    ts.SyntaxKind.CaretEqualsToken,
+    ts.SyntaxKind.BarBarEqualsToken,
+    ts.SyntaxKind.AmpersandAmpersandEqualsToken,
+    ts.SyntaxKind.QuestionQuestionEqualsToken,
+]);
+/**
+ * Build a scope-aware resolver: which `var` bindings are actually reassigned.
+ */
+export function buildReassignmentResolver(sf) {
+    // Names hoisted into each scope: var-declared names, function declarations,
+    // and parameters. (Collected per scope, not crossing nested function scopes.)
+    const hoisted = new Map();
+    const ensure = (scope) => {
+        let s = hoisted.get(scope);
+        if (!s) {
+            s = new Set();
+            hoisted.set(scope, s);
+        }
+        return s;
+    };
+    ensure(sf);
+    const addBinding = (name, scope) => {
+        if (ts.isIdentifier(name)) {
+            ensure(scope).add(name.text);
+        }
+        else {
+            for (const el of name.elements) {
+                if (ts.isBindingElement(el))
+                    addBinding(el.name, scope);
+            }
+        }
+    };
+    // Pass 1 — record hoisted names per scope.
+    const collectHoisted = (node) => {
+        if (isScopeNode(node) && !ts.isSourceFile(node)) {
+            ensure(node);
+            // Parameters belong to the function's own scope.
+            const params = node.parameters;
+            if (params)
+                for (const p of params)
+                    addBinding(p.name, node);
+        }
+        if (ts.isVariableDeclarationList(node) && !(node.flags & (ts.NodeFlags.Let | ts.NodeFlags.Const))) {
+            const scope = enclosingScope(node); // var hoists to the nearest function/source scope
+            for (const decl of node.declarations)
+                addBinding(decl.name, scope);
+        }
+        if (ts.isFunctionDeclaration(node) && node.name) {
+            ensure(enclosingScope(node)).add(node.name.text);
+        }
+        ts.forEachChild(node, collectHoisted);
+    };
+    collectHoisted(sf);
+    const resolveScope = (name, from) => {
+        let scope = from;
+        while (scope) {
+            if (hoisted.get(scope)?.has(name))
+                return scope;
+            scope = parentScope(scope);
+        }
+        return undefined;
+    };
+    // Pass 2 — attribute each reassignment to the binding (scope) it mutates.
+    const reassigned = new Set(); // key: `${scopeId}::${name}`
+    const scopeIds = new Map();
+    let nextId = 0;
+    const scopeId = (scope) => {
+        let id = scopeIds.get(scope);
+        if (id === undefined) {
+            id = nextId++;
+            scopeIds.set(scope, id);
+        }
+        return id;
+    };
+    const markReassigned = (name, at) => {
+        const declScope = resolveScope(name, enclosingScope(at));
+        if (declScope)
+            reassigned.add(`${scopeId(declScope)}::${name}`);
+    };
+    const collectReassignments = (node) => {
+        if (ts.isBinaryExpression(node) && ASSIGNMENT_OPERATORS.has(node.operatorToken.kind)) {
+            collectIdentifierNames(node.left, (n) => markReassigned(n, node));
+        }
+        else if ((ts.isPostfixUnaryExpression(node) || ts.isPrefixUnaryExpression(node)) &&
+            (node.operator === ts.SyntaxKind.PlusPlusToken || node.operator === ts.SyntaxKind.MinusMinusToken) &&
+            ts.isIdentifier(node.operand)) {
+            markReassigned(node.operand.text, node);
+        }
+        ts.forEachChild(node, collectReassignments);
+    };
+    collectReassignments(sf);
+    return {
+        isReassigned(name, declarationList) {
+            const declScope = enclosingScope(declarationList);
+            return reassigned.has(`${scopeId(declScope)}::${name}`);
+        },
+    };
+}
+//# sourceMappingURL=scope-analysis.js.map

package/dist/src/ruvector/coverage-router.d.ts

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