@claude-flow/cli 3.32.1 → 3.32.3

package/dist/src/ruvector/ast-analyzer.js

@@ -1,277 +0,0 @@
-/**
- * AST Analyzer for Code Analysis
- *
- * Analyzes Abstract Syntax Trees for code understanding
- * and intelligent routing decisions.
- *
- * @module ast-analyzer
- */
-const DEFAULT_CONFIG = {
-    maxFileSize: 1024 * 1024,
-    languages: ['typescript', 'javascript', 'python', 'rust', 'go'],
-    includeComments: true,
-    extractTypes: true,
-    maxDepth: 20,
-};
-const LANGUAGE_PATTERNS = {
-    typescript: [/\.tsx?$/, /^import\s+.*from\s+['"]/, /:\s*(string|number|boolean|void)/],
-    javascript: [/\.jsx?$/, /^(const|let|var)\s+\w+\s*=/, /module\.exports/],
-    python: [/\.py$/, /^(def|class|import|from)\s+/, /^#!/],
-    rust: [/\.rs$/, /^(fn|struct|impl|use)\s+/, /^(pub\s+)?mod\s+/],
-    go: [/\.go$/, /^package\s+/, /^func\s+/],
-};
-export class ASTAnalyzer {
-    config;
-    ruvectorEngine = null;
-    useNative = false;
-    analysisCache = new Map();
-    constructor(config = {}) {
-        this.config = { ...DEFAULT_CONFIG, ...config };
-    }
-    async initialize() {
-        try {
-            // @ruvector/ast is optional - gracefully fallback if not installed
-            const ruvector = await import('@ruvector/ast').catch(() => null);
-            if (ruvector) {
-                this.ruvectorEngine = ruvector.createASTAnalyzer?.(this.config);
-                this.useNative = !!this.ruvectorEngine;
-            }
-        }
-        catch {
-            this.useNative = false;
-        }
-    }
-    analyze(code, filePath = 'unknown') {
-        const startTime = performance.now();
-        if (code.length > this.config.maxFileSize) {
-            throw new Error(`File too large: ${code.length} bytes exceeds ${this.config.maxFileSize}`);
-        }
-        const cacheKey = this.getCacheKey(code, filePath);
-        const cached = this.analysisCache.get(cacheKey);
-        if (cached)
-            return cached;
-        const language = this.detectLanguage(code, filePath);
-        const root = this.parseAST(code, language);
-        const functions = this.extractFunctions(root);
-        const classes = this.extractClasses(root);
-        const imports = this.extractImports(code, language);
-        const exports = this.extractExports(code, language);
-        const complexity = this.calculateComplexity(code, root);
-        const durationMs = performance.now() - startTime;
-        const analysis = {
-            filePath, language, root, functions, classes, imports, exports,
-            complexity, timestamp: Date.now(), durationMs,
-        };
-        this.analysisCache.set(cacheKey, analysis);
-        return analysis;
-    }
-    getFunctionAtLine(analysis, line) {
-        for (const func of analysis.functions) {
-            if (line >= func.startLine && line <= func.endLine)
-                return func;
-        }
-        return null;
-    }
-    getClassAtLine(analysis, line) {
-        for (const cls of analysis.classes) {
-            if (line >= cls.startLine && line <= cls.endLine)
-                return cls;
-        }
-        return null;
-    }
-    getSymbols(analysis) {
-        const symbols = [];
-        for (const func of analysis.functions)
-            symbols.push(func.name);
-        for (const cls of analysis.classes)
-            symbols.push(cls.name);
-        return symbols;
-    }
-    getStats() {
-        return { cacheSize: this.analysisCache.size, useNative: this.useNative ? 1 : 0 };
-    }
-    clearCache() { this.analysisCache.clear(); }
-    getCacheKey(code, filePath) {
-        let hash = 0;
-        const str = filePath + code.substring(0, 1000);
-        for (let i = 0; i < str.length; i++) {
-            const char = str.charCodeAt(i);
-            hash = ((hash << 5) - hash) + char;
-            hash = hash & hash;
-        }
-        return `ast_${hash}_${code.length}`;
-    }
-    detectLanguage(code, filePath) {
-        for (const [lang, patterns] of Object.entries(LANGUAGE_PATTERNS)) {
-            for (const pattern of patterns) {
-                if (pattern.test(filePath) || pattern.test(code))
-                    return lang;
-            }
-        }
-        return 'unknown';
-    }
-    parseAST(code, language) {
-        const lines = code.split('\n');
-        const root = { type: 'program', name: 'root', startLine: 1, endLine: lines.length, children: [] };
-        for (let i = 0; i < lines.length; i++) {
-            const line = lines[i];
-            const lineNum = i + 1;
-            const funcMatch = this.matchFunction(line, language);
-            if (funcMatch) {
-                const funcNode = {
-                    type: 'function', name: funcMatch.name, startLine: lineNum,
-                    endLine: lineNum + this.findBlockEnd(lines, i), children: [],
-                    metadata: { params: funcMatch.params },
-                };
-                root.children.push(funcNode);
-                continue;
-            }
-            const classMatch = this.matchClass(line, language);
-            if (classMatch) {
-                const classNode = {
-                    type: 'class', name: classMatch.name, startLine: lineNum,
-                    endLine: lineNum + this.findBlockEnd(lines, i), children: [],
-                    metadata: { extends: classMatch.extends },
-                };
-                root.children.push(classNode);
-            }
-        }
-        return root;
-    }
-    matchFunction(line, language) {
-        const patterns = {
-            typescript: /(?:export\s+)?(?:async\s+)?function\s+(\w+)\s*\(([^)]*)\)/,
-            javascript: /(?:export\s+)?(?:async\s+)?function\s+(\w+)\s*\(([^)]*)\)/,
-            python: /def\s+(\w+)\s*\(([^)]*)\)/,
-            rust: /(?:pub\s+)?(?:async\s+)?fn\s+(\w+)\s*\(([^)]*)\)/,
-            go: /func\s+(?:\([^)]*\)\s+)?(\w+)\s*\(([^)]*)\)/,
-        };
-        const pattern = patterns[language];
-        if (!pattern)
-            return null;
-        const match = line.match(pattern);
-        if (match)
-            return { name: match[1], params: match[2] || '' };
-        const arrowMatch = line.match(/(?:const|let|var)\s+(\w+)\s*=\s*(?:async\s+)?\([^)]*\)\s*=>/);
-        if (arrowMatch)
-            return { name: arrowMatch[1], params: '' };
-        const methodMatch = line.match(/^\s*(?:async\s+)?(\w+)\s*\([^)]*\)\s*(?::\s*\w+)?\s*\{/);
-        if (methodMatch && methodMatch[1] !== 'if' && methodMatch[1] !== 'while' && methodMatch[1] !== 'for') {
-            return { name: methodMatch[1], params: '' };
-        }
-        return null;
-    }
-    matchClass(line, language) {
-        const patterns = {
-            typescript: /(?:export\s+)?class\s+(\w+)(?:\s+extends\s+(\w+))?/,
-            javascript: /(?:export\s+)?class\s+(\w+)(?:\s+extends\s+(\w+))?/,
-            python: /class\s+(\w+)(?:\((\w+)\))?/,
-            rust: /(?:pub\s+)?struct\s+(\w+)/,
-            go: /type\s+(\w+)\s+struct/,
-        };
-        const pattern = patterns[language];
-        if (!pattern)
-            return null;
-        const match = line.match(pattern);
-        if (match)
-            return { name: match[1], extends: match[2] };
-        return null;
-    }
-    findBlockEnd(lines, startIdx) {
-        let depth = 0;
-        let inBlock = false;
-        for (let i = startIdx; i < lines.length; i++) {
-            const line = lines[i];
-            const opens = (line.match(/[\{]/g) || []).length;
-            const closes = (line.match(/[\}]/g) || []).length;
-            if (opens > 0)
-                inBlock = true;
-            depth += opens - closes;
-            if (inBlock && depth <= 0)
-                return i - startIdx;
-        }
-        return Math.min(50, lines.length - startIdx);
-    }
-    extractFunctions(root) {
-        const functions = [];
-        const visit = (node) => {
-            if (node.type === 'function')
-                functions.push(node);
-            for (const child of node.children)
-                visit(child);
-        };
-        visit(root);
-        return functions;
-    }
-    extractClasses(root) {
-        const classes = [];
-        const visit = (node) => {
-            if (node.type === 'class')
-                classes.push(node);
-            for (const child of node.children)
-                visit(child);
-        };
-        visit(root);
-        return classes;
-    }
-    extractImports(code, language) {
-        const imports = [];
-        const lines = code.split('\n');
-        const patterns = {
-            typescript: /import\s+(?:.*\s+from\s+)?['"]([^'"]+)['"]/,
-            javascript: /(?:import\s+.*from\s+|require\s*\(\s*)['"]([^'"]+)['"]/,
-            python: /(?:from\s+(\S+)\s+import|import\s+(\S+))/,
-            rust: /use\s+(\S+)/,
-            go: /import\s+(?:\(\s*)?["']([^"']+)["']/,
-        };
-        const pattern = patterns[language];
-        if (!pattern)
-            return imports;
-        for (const line of lines) {
-            const match = line.match(pattern);
-            if (match)
-                imports.push(match[1] || match[2]);
-        }
-        return imports;
-    }
-    extractExports(code, language) {
-        const exports = [];
-        const lines = code.split('\n');
-        for (const line of lines) {
-            const exportMatch = line.match(/export\s+(?:default\s+)?(?:const|let|var|function|class|interface|type|enum)\s+(\w+)/);
-            if (exportMatch)
-                exports.push(exportMatch[1]);
-            const namedExportMatch = line.match(/export\s*\{\s*([^}]+)\s*\}/);
-            if (namedExportMatch) {
-                const names = namedExportMatch[1].split(',').map(n => n.trim().split(/\s+as\s+/)[0]);
-                exports.push(...names);
-            }
-        }
-        return exports;
-    }
-    calculateComplexity(code, root) {
-        const lines = code.split('\n');
-        const nonEmptyLines = lines.filter(l => l.trim().length > 0);
-        const commentLines = lines.filter(l => /^\s*(\/\/|\/\*|\*|#)/.test(l));
-        const decisionPoints = (code.match(/\b(if|else|for|while|switch|case|catch|&&|\|\||\?)\b/g) || []).length;
-        const cyclomatic = decisionPoints + 1;
-        let cognitive = 0;
-        let nestingLevel = 0;
-        for (const line of lines) {
-            const opens = (line.match(/[\{]/g) || []).length;
-            const closes = (line.match(/[\}]/g) || []).length;
-            if (/\b(if|for|while|switch)\b/.test(line))
-                cognitive += 1 + nestingLevel;
-            nestingLevel += opens - closes;
-            nestingLevel = Math.max(0, nestingLevel);
-        }
-        return {
-            cyclomatic, cognitive, loc: nonEmptyLines.length,
-            commentDensity: lines.length > 0 ? commentLines.length / lines.length : 0,
-        };
-    }
-}
-export function createASTAnalyzer(config) {
-    return new ASTAnalyzer(config);
-}
-//# sourceMappingURL=ast-analyzer.js.map

package/dist/src/ruvector/codemods/engine.d.ts

@@ -1,45 +0,0 @@
-/**
- * Deterministic Codemod Engine (ADR-143)
- *
- * Truly $0, no-LLM Tier-1 code transforms. Uses the TypeScript compiler API to
- * locate exact AST nodes, then applies formatting-preserving text-range edits to
- * the original source string (we never re-print the whole file, so comments and
- * formatting survive).
- *
- * Only intents that can be transformed *deterministically and safely* live here.
- * Intents that need inference or judgement (add-types, add-error-handling,
- * async-await) are intentionally NOT codemods — they route to a model. See
- * ADR-143 for the rationale.
- *
- * @module ruvector/codemods/engine
- */
-export type CodemodIntent = 'var-to-const' | 'remove-console' | 'add-logging';
-/** Intents this engine can apply deterministically with $0 cost. */
-export declare const DETERMINISTIC_CODEMOD_INTENTS: readonly CodemodIntent[];
-/** Intents recognised by the router but NOT safe as deterministic codemods. */
-export declare const MODEL_ROUTED_INTENTS: readonly string[];
-export type CodemodLanguage = 'javascript' | 'typescript' | 'jsx' | 'tsx';
-export interface CodemodResult {
-    intent: CodemodIntent;
-    success: boolean;
-    /** true if the output differs from the input. */
-    changed: boolean;
-    output: string;
-    /** number of discrete edit sites applied. */
-    edits: number;
-    language: CodemodLanguage;
-    reason?: string;
-}
-export declare function isDeterministicCodemod(intent: string): intent is CodemodIntent;
-export interface ApplyCodemodOptions {
-    language?: CodemodLanguage;
-}
-/**
- * Apply a deterministic codemod to a source string.
- *
- * Returns the transformed source plus metadata. Never throws on malformed input
- * — it reports `success: false` with a reason instead. Guarantees the output
- * does not introduce new parse errors (otherwise it returns the input unchanged).
- */
-export declare function applyCodemod(intent: string, code: string, opts?: ApplyCodemodOptions): CodemodResult;
-//# sourceMappingURL=engine.d.ts.map

package/dist/src/ruvector/codemods/engine.js

@@ -1,291 +0,0 @@
-/**
- * Deterministic Codemod Engine (ADR-143)
- *
- * Truly $0, no-LLM Tier-1 code transforms. Uses the TypeScript compiler API to
- * locate exact AST nodes, then applies formatting-preserving text-range edits to
- * the original source string (we never re-print the whole file, so comments and
- * formatting survive).
- *
- * Only intents that can be transformed *deterministically and safely* live here.
- * Intents that need inference or judgement (add-types, add-error-handling,
- * async-await) are intentionally NOT codemods — they route to a model. See
- * ADR-143 for the rationale.
- *
- * @module ruvector/codemods/engine
- */
-import ts from 'typescript';
-import { buildReassignmentResolver } from './scope-analysis.js';
-/** Intents this engine can apply deterministically with $0 cost. */
-export const DETERMINISTIC_CODEMOD_INTENTS = [
-    'var-to-const',
-    'remove-console',
-    'add-logging',
-];
-/** Intents recognised by the router but NOT safe as deterministic codemods. */
-export const MODEL_ROUTED_INTENTS = [
-    'add-types',
-    'add-error-handling',
-    'async-await',
-];
-export function isDeterministicCodemod(intent) {
-    return DETERMINISTIC_CODEMOD_INTENTS.includes(intent);
-}
-// ============================================================================
-// Parsing & edit application
-// ============================================================================
-function scriptKind(language) {
-    switch (language) {
-        case 'typescript':
-            return ts.ScriptKind.TS;
-        case 'tsx':
-            return ts.ScriptKind.TSX;
-        case 'jsx':
-            return ts.ScriptKind.JSX;
-        default:
-            return ts.ScriptKind.JS;
-    }
-}
-function parse(code, language) {
-    return ts.createSourceFile(`codemod-input.${language}`, code, ts.ScriptTarget.Latest, 
-    /* setParentNodes */ true, scriptKind(language));
-}
-function parseDiagnosticCount(sf) {
-    // parseDiagnostics is internal but stable; guard so a missing field never throws.
-    return sf.parseDiagnostics?.length ?? 0;
-}
-/** Apply edits to the original source, right-to-left so offsets stay valid. */
-function applyEdits(code, edits) {
-    const sorted = [...edits].sort((a, b) => b.start - a.start);
-    let out = code;
-    for (const e of sorted) {
-        out = out.slice(0, e.start) + e.replacement + out.slice(e.end);
-    }
-    return out;
-}
-function lineStartOffset(code, pos) {
-    let i = pos;
-    while (i > 0 && code[i - 1] !== '\n')
-        i--;
-    return i;
-}
-function leadingIndent(code, lineStart) {
-    let i = lineStart;
-    while (i < code.length && (code[i] === ' ' || code[i] === '\t'))
-        i++;
-    return code.slice(lineStart, i);
-}
-// ============================================================================
-// var-to-const  (scope-aware reassignment analysis — see scope-analysis.ts)
-// ============================================================================
-function isVarList(list) {
-    return !(list.flags & (ts.NodeFlags.Let | ts.NodeFlags.Const));
-}
-function collectBindingNames(name, out) {
-    if (ts.isIdentifier(name)) {
-        out.add(name.text);
-        return;
-    }
-    for (const el of name.elements) {
-        if (ts.isBindingElement(el))
-            collectBindingNames(el.name, out);
-    }
-}
-function varToConstEdits(code, sf) {
-    const resolver = buildReassignmentResolver(sf);
-    const edits = [];
-    const visit = (node) => {
-        if (ts.isVariableDeclarationList(node) && isVarList(node)) {
-            const names = new Set();
-            for (const decl of node.declarations)
-                collectBindingNames(decl.name, names);
-            // `const` only when no declared binding is reassigned *within its own scope*.
-            const anyReassigned = [...names].some((n) => resolver.isReassigned(n, node));
-            const keyword = anyReassigned ? 'let' : 'const';
-            // The `var` keyword is the first token of the declaration list.
-            const start = node.getStart(sf);
-            // Only rewrite when the literal text really is `var` (guards against odd trivia).
-            if (code.slice(start, start + 3) === 'var') {
-                edits.push({ start, end: start + 3, replacement: keyword });
-            }
-        }
-        ts.forEachChild(node, visit);
-    };
-    visit(sf);
-    return edits;
-}
-// ============================================================================
-// remove-console
-// ============================================================================
-function rootIdentifier(expr) {
-    let cur = expr;
-    while (ts.isPropertyAccessExpression(cur) || ts.isElementAccessExpression(cur)) {
-        cur = cur.expression;
-    }
-    return ts.isIdentifier(cur) ? cur : undefined;
-}
-function isConsoleCallStatement(stmt) {
-    if (!ts.isExpressionStatement(stmt))
-        return false;
-    let expr = stmt.expression;
-    // unwrap `void console.log(x)` and awaited/comma forms defensively
-    if (ts.isCallExpression(expr)) {
-        const root = rootIdentifier(expr.expression);
-        return !!root && root.text === 'console';
-    }
-    return false;
-}
-function removeConsoleEdits(code, sf) {
-    const edits = [];
-    const visit = (node) => {
-        if (isConsoleCallStatement(node)) {
-            const stmt = node;
-            const start = stmt.getStart(sf);
-            const end = stmt.getEnd();
-            const ls = lineStartOffset(code, start);
-            const beforeIsBlank = code.slice(ls, start).trim() === '';
-            // Is the rest of the line after the statement only whitespace?
-            let lineEnd = end;
-            while (lineEnd < code.length && code[lineEnd] !== '\n')
-                lineEnd++;
-            const afterIsBlank = code.slice(end, lineEnd).trim() === '';
-            if (beforeIsBlank && afterIsBlank) {
-                // Statement owns its line(s): drop the whole line incl. trailing newline.
-                const dropEnd = lineEnd < code.length ? lineEnd + 1 : lineEnd;
-                edits.push({ start: ls, end: dropEnd, replacement: '' });
-            }
-            else {
-                // Inline with other code: remove just the statement, tidy one trailing space.
-                let e = end;
-                if (code[e] === ' ')
-                    e++;
-                edits.push({ start, end: e, replacement: '' });
-            }
-        }
-        ts.forEachChild(node, visit);
-    };
-    visit(sf);
-    return edits;
-}
-function isFunctionLikeWithBlock(node) {
-    return ((ts.isFunctionDeclaration(node) ||
-        ts.isFunctionExpression(node) ||
-        ts.isArrowFunction(node) ||
-        ts.isMethodDeclaration(node) ||
-        ts.isConstructorDeclaration(node) ||
-        ts.isGetAccessor(node) ||
-        ts.isSetAccessor(node)) &&
-        !!node.body &&
-        ts.isBlock(node.body));
-}
-function functionName(node) {
-    if (ts.isConstructorDeclaration(node))
-        return 'constructor';
-    if ((ts.isFunctionDeclaration(node) ||
-        ts.isFunctionExpression(node) ||
-        ts.isMethodDeclaration(node) ||
-        ts.isGetAccessor(node) ||
-        ts.isSetAccessor(node)) &&
-        node.name &&
-        (ts.isIdentifier(node.name) || ts.isStringLiteral(node.name))) {
-        return node.name.text;
-    }
-    // function expression / arrow assigned to a variable or property
-    const parent = node.parent;
-    if (parent && ts.isVariableDeclaration(parent) && ts.isIdentifier(parent.name))
-        return parent.name.text;
-    if (parent && ts.isPropertyAssignment(parent) && ts.isIdentifier(parent.name))
-        return parent.name.text;
-    return 'anonymous';
-}
-function alreadyLogsEntry(body, name) {
-    const first = body.statements[0];
-    if (!first || !isConsoleCallStatement(first))
-        return false;
-    const text = first.getText();
-    return text.includes(`'${name} called'`) || text.includes(`"${name} called"`);
-}
-function addLoggingEdits(code, sf) {
-    const edits = [];
-    const visit = (node) => {
-        if (isFunctionLikeWithBlock(node)) {
-            const body = node.body;
-            const name = functionName(node);
-            if (!alreadyLogsEntry(body, name)) {
-                const braceOffset = body.getStart(sf); // position of '{'
-                const headerLineStart = lineStartOffset(code, node.getStart(sf));
-                const indent = leadingIndent(code, headerLineStart);
-                const bodyIndent = indent + '  ';
-                const insertion = `\n${bodyIndent}console.log(${JSON.stringify(`${name} called`)});`;
-                edits.push({ start: braceOffset + 1, end: braceOffset + 1, replacement: insertion });
-            }
-        }
-        ts.forEachChild(node, visit);
-    };
-    visit(sf);
-    return edits;
-}
-// ============================================================================
-// Public API
-// ============================================================================
-const TRANSFORMS = {
-    'var-to-const': varToConstEdits,
-    'remove-console': removeConsoleEdits,
-    'add-logging': addLoggingEdits,
-};
-/**
- * Apply a deterministic codemod to a source string.
- *
- * Returns the transformed source plus metadata. Never throws on malformed input
- * — it reports `success: false` with a reason instead. Guarantees the output
- * does not introduce new parse errors (otherwise it returns the input unchanged).
- */
-export function applyCodemod(intent, code, opts = {}) {
-    const language = opts.language ?? 'typescript';
-    if (!isDeterministicCodemod(intent)) {
-        return {
-            intent: intent,
-            success: false,
-            changed: false,
-            output: code,
-            edits: 0,
-            language,
-            reason: `"${intent}" is not a deterministic codemod — route it to a model (Tier 2/3).`,
-        };
-    }
-    let sf;
-    try {
-        sf = parse(code, language);
-    }
-    catch (err) {
-        return {
-            intent,
-            success: false,
-            changed: false,
-            output: code,
-            edits: 0,
-            language,
-            reason: `parse failed: ${err.message}`,
-        };
-    }
-    const beforeDiagnostics = parseDiagnosticCount(sf);
-    const edits = TRANSFORMS[intent](code, sf);
-    if (edits.length === 0) {
-        return { intent, success: true, changed: false, output: code, edits: 0, language };
-    }
-    const output = applyEdits(code, edits);
-    // Safety net: never hand back source that parses worse than the input.
-    const afterDiagnostics = parseDiagnosticCount(parse(output, language));
-    if (afterDiagnostics > beforeDiagnostics) {
-        return {
-            intent,
-            success: false,
-            changed: false,
-            output: code,
-            edits: 0,
-            language,
-            reason: 'transform would introduce parse errors — aborted (input returned unchanged).',
-        };
-    }
-    return { intent, success: true, changed: true, output, edits: edits.length, language };
-}
-//# sourceMappingURL=engine.js.map

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

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