JS Refactoring Assistant

Analyzes JavaScript/TypeScript syntax trees to identify selected code or expressions, then automatically detects all semantically equivalent occurrences in the current file scope. Generates refactored code with a new variable declaration and replaces all matched instances, handling both single and multiple occurrence scenarios through AST pattern matching rather than text-based regex.

Detects common patterns in conditional logic (string comparisons, double negations, redundant operators) and applies targeted transformations using AST rewriting. Converts verbose boolean expressions into modern JavaScript idioms (optional chaining, array.includes()) by pattern-matching against known anti-patterns and emitting optimized AST nodes that are then serialized back to source code.

Integrates with VS Code's code action system to surface refactoring suggestions through multiple UI surfaces: Quick Fix menu (Cmd+.), Refactor menu (Ctrl+Cmd+R), Source Action menu (Ctrl+Cmd+S), and direct keyboard shortcuts (Ctrl+Cmd+X for Extract, Ctrl+Cmd+I for Inline). Analyzes cursor position and selection context to determine available actions and displays them in a prioritized list, enabling one-click application of refactorings.

Scans the current file for common refactoring opportunities and displays recommendations in a suggestion panel with visual indicators (underlines with three dots) marking code that can be refactored. Analyzes the entire file scope to identify patterns that match known refactoring rules, then surfaces suggestions without requiring explicit user action, enabling proactive code quality improvements.

Provides direct keyboard shortcuts for common refactoring actions (Extract: Ctrl+Cmd+X, Inline: Ctrl+Cmd+I, Toggle Braces: Ctrl+Cmd+B, Move Up/Down: Ctrl+Alt+↑↓) with platform-specific variants for Windows/Linux, and adds dedicated Touch Bar buttons on macOS for Rename, Quick Fix, Refactor, and Source Action. Enables power users to apply refactorings without navigating menus, using keyboard-driven workflows for maximum efficiency.

Offers a free tier with core refactoring actions (extract variable, inline variable, basic simplifications) and a premium tier with advanced features (additional code actions, priority support, early access to new features). Uses VS Code's extension marketplace for distribution and licensing, with in-app prompts to upgrade to premium for advanced features.

Identifies variable declarations and their usage sites within the current file scope, then replaces all references with the variable's assigned value by performing AST-level substitution. Handles scope boundaries (block scope, function scope) and validates that inlining does not create unintended variable shadowing or reference errors before applying the transformation.

Detects variable assignments that are immediately followed by a return statement (or are the final statement in a function), then refactors the code to eliminate the intermediate variable by replacing the assignment with a direct return of the assigned expression. Uses AST pattern matching to identify this specific anti-pattern and applies a single-step transformation.

Analyzes conditional expressions and if-statements to identify opportunities for logical inversion, then generates refactored code with inverted operators (< to >, && to ||) or flipped if-else branches. Uses AST transformation to negate conditions and swap branch bodies while preserving semantic equivalence, improving code readability by reducing nested negations.

Detects negation operators (!) in boolean expressions and applies De Morgan's laws to move negation deeper into expressions (push-down) or pull negation out of nested expressions (pull-up). Uses AST rewriting to transform expressions like !(a && b) into !a || !b or vice versa, improving code readability by reducing double negations and simplifying boolean logic.

Identifies patterns where a variable is compared against multiple string literals using OR operators (a === 'x' || a === 'y' || a === 'z'), then automatically refactors the expression into a single array.includes() call (['x', 'y', 'z'].includes(a)). Uses AST pattern matching to detect this anti-pattern and generates optimized code that is more readable and performant for large comparison chains.

Analyzes property access and method call expressions that are preceded by explicit null/undefined checks (if (obj && obj.prop) or if (obj !== null && obj.method())), then refactors the code to use the optional chaining operator (?.) to eliminate the verbose guard clause. Uses AST pattern matching to identify guard patterns and generates modernized code that is more concise and readable.

Detects double negation patterns (!!x) in boolean expressions and refactors them to their simplified form (x for truthy coercion, or !x for single negation). Uses AST analysis to identify redundant negation operators and applies targeted transformations that preserve semantic equivalence while improving code readability.

Provides unified refactoring interface across JavaScript, TypeScript, React (JSX/TSX), and Vue.js, with language-specific code actions that adapt to each language's syntax and idioms. Automatically detects file type and language context, then surfaces only relevant refactoring actions for that language, using language-specific AST parsers and transformation rules.