ast-based variable extraction with occurrence detection
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.
Unique: Uses Abstract Syntax Tree (AST) parsing to perform structurally-aware variable extraction across 40+ JavaScript/TypeScript language variants (ES5 through ES2022, JSX, TSX, Vue), enabling detection of semantically identical expressions that text-based tools would miss, with built-in support for template literals and complex nested expressions.
vs alternatives: More accurate than VS Code's native Extract Variable (which uses regex-based heuristics) because it understands code structure; faster than language-server-based refactoring because analysis is local and incremental rather than full-project re-analysis.
logical expression simplification via operator normalization
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.
Unique: Implements a pattern-matching engine that recognizes 10+ distinct anti-patterns in boolean expressions (comparison chains, double negation, redundant operators) and applies AST-level transformations to emit modern JavaScript idioms (optional chaining, array.includes(), inverted conditions) without requiring external linting rules or configuration.
vs alternatives: More targeted than generic linters (ESLint) because it provides interactive, in-editor refactoring suggestions with one-click application; more comprehensive than IDE-native simplifications because it covers ES2020+ patterns like optional chaining that older tools don't recognize.
interactive code action discovery via context menus and keyboard shortcuts
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.
Unique: Integrates deeply with VS Code's code action system through multiple UI surfaces (Quick Fix, Refactor, Source Action menus) and direct keyboard shortcuts, with context-aware filtering that surfaces only relevant actions for the current cursor position and selection, enabling efficient one-click refactoring workflows.
vs alternatives: More discoverable than command-line tools because it uses VS Code's native UI surfaces; more efficient than manual refactoring because it requires only a single action to apply complex transformations.
automated suggestion panel with file-level refactoring recommendations
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.
Unique: Implements file-level pattern scanning that identifies refactoring opportunities across the entire file and surfaces them in a suggestion panel with visual indicators, enabling proactive code quality improvements without requiring explicit user action or command invocation.
vs alternatives: More proactive than on-demand refactoring tools because it continuously scans the file and surfaces suggestions; more discoverable than linting tools because it uses VS Code's native UI surfaces rather than separate output panels.
keybinding-driven refactoring with macos touch bar support
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.
Unique: Provides comprehensive keyboard shortcut coverage for common refactoring actions with platform-specific variants (macOS, Windows, Linux) and adds dedicated Touch Bar buttons on macOS, enabling power users to apply refactorings without navigating menus or using the mouse.
vs alternatives: More efficient than menu-driven refactoring because it eliminates the need to navigate UI; more accessible than command-line tools because it integrates with VS Code's native keybinding system.
freemium licensing with free tier and premium features
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.
Unique: Implements a freemium licensing model with free core refactoring actions and premium advanced features, using VS Code's extension marketplace for distribution and in-app upgrade prompts, enabling users to evaluate the tool before committing to a paid subscription.
vs alternatives: More accessible than paid-only tools because it offers a free tier for evaluation; more sustainable than free-only tools because it provides a revenue model for ongoing development and support.
inline variable elimination with scope-aware replacement
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.
Unique: Performs scope-aware AST analysis to ensure inlining does not violate JavaScript scoping rules (block scope, function scope, temporal dead zone) and validates that the inlined expression does not create variable shadowing conflicts or alter execution semantics before applying the transformation.
vs alternatives: More reliable than manual inlining because it automatically validates scope boundaries and reference correctness; safer than text-based find-and-replace because it understands variable scope and prevents accidental shadowing or reference errors.
return statement extraction from assignments
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.
Unique: Recognizes the specific anti-pattern of assignment-then-return through AST pattern matching and applies a single-step transformation that preserves expression semantics while eliminating the intermediate variable, with validation that the variable is not referenced elsewhere in the function.
vs alternatives: More targeted than generic refactoring tools because it specifically identifies and eliminates this common anti-pattern; faster than manual refactoring because it requires a single action rather than multiple edits.
+6 more capabilities