How to Automate Python 3.13 Code Refactoring with AI (Save 4 Hours Per Week)

# Core AI and refactoring tools
pip install --upgrade pip
pip install libcst         # Python syntax tree manipulation
pip install autoflake      # Remove unused imports/variables
pip install pyupgrade      # Automatic Python syntax upgrades
pip install black          # Code formatting
pip install isort          # Import sorting

# AI-powered tools
pip install aider-chat     # AI pair programming
pip install gpt-engineer   # Code generation and refactoring

# VS Code extensions (if using VS Code)
code --install-extension GitHub.copilot
code --install-extension ms-python.python
code --install-extension charliermarsh.ruff

# Install pyenv if you don't have it
curl https://pyenv.run | bash

# Add to your shell profile (~/.zshrc or ~/.bashrc)
echo 'export PYENV_ROOT="$HOME/.pyenv"' >> ~/.zshrc
echo 'command -v pyenv >/dev/null || export PATH="$PYENV_ROOT/bin:$PATH"' >> ~/.zshrc
echo 'eval "$(pyenv init -)"' >> ~/.zshrc

# Restart terminal, then install Python 3.13
pyenv install 3.13.0
pyenv virtualenv 3.13.0 refactoring-env
pyenv activate refactoring-env

mkdir -p ~/.config/ai-refactor
cd ~/.config/ai-refactor

# refactor-config.yaml
python_version: "3.13"
refactoring_goals:
  - "Use Python 3.13 type hints with generic syntax"
  - "Replace deprecated asyncio calls with new syntax"  
  - "Implement structural pattern matching where applicable"
  - "Use exception groups for better error handling"
  - "Apply new string formatting methods"
  - "Modernize f-string usage with = syntax"

code_patterns:
  # Pattern matching opportunities
  pattern_matching:
    - "Replace complex if/elif chains with match statements"
    - "Convert dictionary-based dispatch to match/case"
  
  # Type hint improvements  
  type_hints:
    - "Use built-in generics (list[str] instead of List[str])"
    - "Add return type hints to functions missing them"
    - "Use Union syntax (str | int instead of Union[str, int])"
    
  # Exception handling
  exceptions:
    - "Group related exceptions with ExceptionGroup"
    - "Use exception notes for additional context"

ignore_patterns:
  - "Don't refactor working exception handling"
  - "Keep existing async context managers if functional"
  - "Preserve critical business logic structure"

#!/usr/bin/env python3
"""
AI-Powered Python 3.13 Code Refactoring Pipeline
Usage: python refactor.py <target_directory>
"""

import subprocess
import sys
import os
from pathlib import Path
import yaml

class PythonRefactorer:
    def __init__(self, target_dir, config_path="~/.config/ai-refactor/refactor-config.yaml"):
        self.target_dir = Path(target_dir)
        self.config_path = Path(config_path).expanduser()
        self.config = self.load_config()
        
    def load_config(self):
        """Load refactoring configuration"""
        try:
            with open(self.config_path, 'r') as f:
                return yaml.safe_load(f)
        except FileNotFoundError:
            print(f"Config file not found: {self.config_path}")
            return self.default_config()
    
    def default_config(self):
        """Fallback configuration if file missing"""
        return {
            'python_version': '3.13',
            'refactoring_goals': [
                'Use Python 3.13 type hints',
                'Modernize syntax patterns'
            ]
        }
    
    def run_command(self, command, description):
        """Execute shell command with error handling"""
        print(f"\n🔄 {description}")
        print(f"Running: {' '.join(command)}")
        
        try:
            result = subprocess.run(
                command, 
                capture_output=True, 
                text=True, 
                cwd=self.target_dir
            )
            
            if result.returncode == 0:
                print(f"✅ {description} completed")
                if result.stdout:
                    print(f"Output: {result.stdout[:200]}...")
            else:
                print(f"❌ {description} failed")
                print(f"Error: {result.stderr}")
                
        except Exception as e:
            print(f"❌ Command failed: {e}")
    
    def stage_1_basic_cleanup(self):
        """Remove unused imports and variables"""
        print("\n" + "="*50)
        print("STAGE 1: Basic Code Cleanup")
        print("="*50)
        
        # Remove unused imports
        self.run_command([
            "autoflake", 
            "--remove-all-unused-imports",
            "--remove-unused-variables", 
            "--in-place",
            "--recursive",
            "."
        ], "Removing unused imports and variables")
        
        # Sort imports consistently  
        self.run_command([
            "isort", 
            ".",
            "--profile", "black"
        ], "Sorting imports")
    
    def stage_2_syntax_upgrade(self):
        """Upgrade to modern Python syntax"""
        print("\n" + "="*50) 
        print("STAGE 2: Python 3.13 Syntax Updates")
        print("="*50)
        
        # Upgrade syntax automatically
        self.run_command([
            "pyupgrade", 
            "--py313-plus",
            "--keep-percent-format",  # Preserve % formatting if needed
            *self.target_dir.glob("**/*.py")
        ], "Upgrading to Python 3.13 syntax")
    
    def stage_3_ai_refactoring(self):
        """AI-powered intelligent refactoring"""
        print("\n" + "="*50)
        print("STAGE 3: AI-Powered Refactoring") 
        print("="*50)
        
        # Create AI refactoring prompt
        goals = "\n".join([f"- {goal}" for goal in self.config['refactoring_goals']])
        
        prompt = f"""
Please refactor this Python codebase with these goals:

{goals}

Focus on:
1. Using Python 3.13 features appropriately
2. Improving type hints with modern syntax  
3. Adding pattern matching where it improves readability
4. Modernizing exception handling
5. Keeping all functionality intact

Important: Only suggest changes you're confident about. Preserve working business logic.
"""
        
        # Save prompt for manual AI tool usage
        prompt_file = self.target_dir / "ai_refactoring_prompt.txt"
        with open(prompt_file, 'w') as f:
            f.write(prompt)
            
        print(f"📝 AI refactoring prompt saved to: {prompt_file}")
        print("\nNext steps:")
        print("1. Open your AI Coding Assistant (GitHub Copilot, Cursor, etc.)")
        print("2. Use the prompt above to guide refactoring")
        print("3. Review all AI suggestions before accepting")
        
    def stage_4_format_and_validate(self):
        """Final formatting and validation"""
        print("\n" + "="*50)
        print("STAGE 4: Format and Validate")
        print("="*50)
        
        # Apply consistent code formatting
        self.run_command([
            "black", 
            ".",
            "--line-length", "88"
        ], "Applying Black code formatting")
        
        # Final import sorting
        self.run_command([
            "isort", 
            ".",
            "--profile", "black",
            "--check-only"
        ], "Validating import sorting")
        
    def refactor(self):
        """Execute complete refactoring pipeline"""
        print(f"🚀 Starting AI-powered refactoring of: {self.target_dir}")
        print(f"Target Python version: {self.config['python_version']}")
        
        if not self.target_dir.exists():
            print(f"❌ Directory not found: {self.target_dir}")
            return
            
        # Execute refactoring stages
        self.stage_1_basic_cleanup()
        self.stage_2_syntax_upgrade() 
        self.stage_3_ai_refactoring()
        self.stage_4_format_and_validate()
        
        print("\n" + "="*50)
        print("🎉 REFACTORING COMPLETE!")
        print("="*50)
        print("\nNext steps:")
        print("1. Review the AI refactoring prompt")
        print("2. Test your refactored code")
        print("3. Run your test suite")
        print("4. Commit changes if everything works")

if __name__ == "__main__":
    if len(sys.argv) != 2:
        print("Usage: python refactor.py <target_directory>")
        sys.exit(1)
        
    target_directory = sys.argv[1]
    refactorer = PythonRefactorer(target_directory)
    refactorer.refactor()

#!/usr/bin/env python3
"""
Test refactored Python code for regressions
Usage: python test_refactored.py <project_directory>
"""

import subprocess
import sys
from pathlib import Path

def test_syntax():
    """Check for Python 3.13 syntax errors"""
    print("🔍 Checking syntax...")
    result = subprocess.run([
        "python", "-m", "py_compile", 
        *Path(".").glob("**/*.py")
    ], capture_output=True, text=True)
    
    if result.returncode == 0:
        print("✅ All files compile successfully")
    else:
        print("❌ Syntax errors found:")
        print(result.stderr)

def test_imports():
    """Verify all imports work"""
    print("\n🔍 Testing imports...")
    # Add your specific import tests here
    print("✅ Import testing complete")

def run_existing_tests():
    """Run project's existing test suite"""
    print("\n🔍 Running existing test suite...")
    
    # Try common test runners
    test_commands = [
        ["python", "-m", "pytest", "-v"],
        ["python", "-m", "unittest", "discover"],
        ["python", "manage.py", "test"]  # Django
    ]
    
    for cmd in test_commands:
        try:
            result = subprocess.run(cmd, capture_output=True, text=True)
            if result.returncode == 0:
                print(f"✅ Tests passed with: {' '.join(cmd)}")
                print(result.stdout[-500:])  # Last 500 chars
                return
        except FileNotFoundError:
            continue
    
    print("⚠️  No test runner found - manually verify functionality")

if __name__ == "__main__":
    test_syntax()
    test_imports() 
    run_existing_tests()
    print("\n🎉 Testing complete!")

# .pre-commit-config.yaml
repos:
  - repo: local
    hooks:
      - id: ai-refactor-check
        name: Check for refactoring opportunities
        entry: python ~/.config/ai-refactor/check-refactor-opportunities.py
        language: system
        types: [python]
        always_run: true

#!/usr/bin/env python3
"""
Check for common refactoring opportunities in Python code
"""

import ast
import sys
from pathlib import Path

class RefactorChecker(ast.NodeVisitor):
    def __init__(self):
        self.suggestions = []
    
    def visit_If(self, node):
        """Check for if/elif chains that could be match statements"""
        if self.is_dispatch_pattern(node):
            self.suggestions.append({
                'line': node.lineno,
                'type': 'pattern_matching',
                'message': 'Consider using match/case for this dispatch pattern'
            })
        self.generic_visit(node)
    
    def visit_FunctionDef(self, node):
        """Check for missing type hints"""
        if not node.returns:
            self.suggestions.append({
                'line': node.lineno, 
                'type': 'type_hints',
                'message': f'Function {node.name} missing return type hint'
            })
        self.generic_visit(node)
    
    def is_dispatch_pattern(self, node):
        """Detect if/elif chains suitable for pattern matching"""
        # Simple heuristic: 3+ elif branches comparing same variable
        elif_count = 0
        current = node
        
        while hasattr(current, 'orelse') and current.orelse:
            if isinstance(current.orelse[0], ast.If):
                elif_count += 1
                current = current.orelse[0]
            else:
                break
                
        return elif_count >= 3

def check_file(file_path):
    """Check single Python file for refactoring opportunities"""
    try:
        with open(file_path, 'r') as f:
            tree = ast.parse(f.read())
        
        checker = RefactorChecker()
        checker.visit(tree)
        
        if checker.suggestions:
            print(f"\n📝 {file_path}:")
            for suggestion in checker.suggestions:
                print(f"  Line {suggestion['line']}: {suggestion['message']}")
        
        return len(checker.suggestions)
        
    except Exception as e:
        print(f"❌ Error checking {file_path}: {e}")
        return 0

def main():
    total_suggestions = 0
    
    for py_file in Path(".").glob("**/*.py"):
        if "venv" in str(py_file) or "__pycache__" in str(py_file):
            continue
            
        total_suggestions += check_file(py_file)
    
    if total_suggestions > 0:
        print(f"\n💡 Found {total_suggestions} refactoring opportunities")
        print("Run 'python refactor.py .' to apply automated improvements")
    else:
        print("✅ No obvious refactoring opportunities found")

if __name__ == "__main__":
    main()