Claude Code重构大师子代理实战指南：打造你的代码优化专家

// 场景对比：重构一个复杂的订单处理函数

// ❌ 通用Claude可能的重构方式
function processOrder(order) {
    // 直接删掉旧代码，重写
    return newImplementation(order);  // 功能可能变了！
}

// ✅ 重构子代理会给你的专业方案
/**
 * 重构计划：订单处理函数优化
 * 目标：提高可读性、可测试性、可维护性
 * 原则：保持100%功能兼容
 */

// 第一步：建立测试防护网
describe('processOrder - 重构前基准测试', () => {
    const testCases = [
        { input: normalOrder, expected: normalResult },
        { input: rushOrder, expected: rushResult },
        { input: bulkOrder, expected: bulkResult },
        { input: cancelledOrder, expected: cancelResult }
    ];
    
    testCases.forEach(({ input, expected }) => {
        it(`should handle ${input.type} correctly`, () => {
            const result = processOrder(input);
            expect(result).toEqual(expected);
        });
    });
});

// 第二步：识别代码异味并逐步改进
// 原始代码（问题：函数过长、职责过多、重复代码）
function processOrder_OLD(order) {
    let total = 0;
    let discount = 0;
    let shipping = 0;
    let tax = 0;
    
    // 问题1：重复的价格计算逻辑
    for (let item of order.items) {
        if (item.quantity > 10) {
            total += item.price * item.quantity * 0.9;
        } elseif (item.quantity > 5) {
            total += item.price * item.quantity * 0.95;
        } else {
            total += item.price * item.quantity;
        }
    }
    
    // 问题2：复杂的嵌套条件
    if (order.customer.type === 'VIP') {
        if (order.total > 1000) {
            if (order.items.length > 5) {
                discount = 0.2;
            } else {
                discount = 0.15;
            }
        } else {
            discount = 0.1;
        }
    } elseif (order.customer.type === 'Regular') {
        if (order.total > 1000) {
            discount = 0.1;
        } else {
            discount = 0.05;
        }
    }
    
    // 问题3：硬编码的业务规则
    if (order.shipping === 'express') {
        shipping = 20;
    } elseif (order.shipping === 'standard') {
        shipping = 10;
    } else {
        shipping = 5;
    }
    
    // 问题4：税率计算混在主逻辑中
    if (order.address.state === 'CA') {
        tax = total * 0.0725;
    } elseif (order.address.state === 'NY') {
        tax = total * 0.08;
    } else {
        tax = total * 0.05;
    }
    
    return {
        subtotal: total,
        discount: total * discount,
        shipping: shipping,
        tax: tax,
        total: total - (total * discount) + shipping + tax
    };
}

// 第三步：应用重构模式
// 重构后的代码（清晰、可测试、可扩展）

// 模式1：提取方法（Extract Method）
class OrderProcessor {
    constructor(
        private readonly pricingStrategy: PricingStrategy,
        private readonly discountStrategy: DiscountStrategy,
        private readonly shippingCalculator: ShippingCalculator,
        private readonly taxCalculator: TaxCalculator
    ) {}
    
    process(order: Order): OrderResult {
        const subtotal = this.calculateSubtotal(order);
        const discount = this.calculateDiscount(order, subtotal);
        const shipping = this.calculateShipping(order);
        const tax = this.calculateTax(order, subtotal - discount);
        
        returnnew OrderResult({
            subtotal,
            discount,
            shipping,
            tax,
            total: subtotal - discount + shipping + tax
        });
    }
    
    private calculateSubtotal(order: Order): number {
        return order.items.reduce((total, item) =>
            total + this.pricingStrategy.calculate(item), 0
        );
    }
    
    private calculateDiscount(order: Order, subtotal: number): number {
        returnthis.discountStrategy.calculate(order.customer, subtotal);
    }
    
    private calculateShipping(order: Order): number {
        returnthis.shippingCalculator.calculate(order.shipping, order.items);
    }
    
    private calculateTax(order: Order, taxableAmount: number): number {
        returnthis.taxCalculator.calculate(order.address, taxableAmount);
    }
}

// 模式2：策略模式（Strategy Pattern）替代复杂条件
interface PricingStrategy {
    calculate(item: OrderItem): number;
}

class QuantityBasedPricing implements PricingStrategy {
    private readonly rules = [
        { minQty: 10, discount: 0.1 },
        { minQty: 5, discount: 0.05 },
        { minQty: 0, discount: 0 }
    ];
    
    calculate(item: OrderItem): number {
        const rule = this.rules.find(r => item.quantity >= r.minQty);
        return item.price * item.quantity * (1 - rule.discount);
    }
}

// 模式3：引入参数对象（Introduce Parameter Object）
class OrderResult {
    constructor(private readonly data: OrderResultData) {}
    
    get subtotal(): number { returnthis.data.subtotal; }
    get discount(): number { returnthis.data.discount; }
    get shipping(): number { returnthis.data.shipping; }
    get tax(): number { returnthis.data.tax; }
    get total(): number { returnthis.data.total; }
    
    toJSON(): OrderResultData {
        return { ...this.data };
    }
}

// 模式4：用多态替代条件语句（Replace Conditional with Polymorphism）
abstract class CustomerType {
    abstract calculateDiscount(subtotal: number): number;
}

class VIPCustomer extends CustomerType {
    calculateDiscount(subtotal: number): number {
        if (subtotal > 1000) return0.2;
        return0.1;
    }
}

class RegularCustomer extends CustomerType {
    calculateDiscount(subtotal: number): number {
        if (subtotal > 1000) return0.1;
        return0.05;
    }
}

// 第四步：性能优化
class OptimizedOrderProcessor {
    private cache = newMap<string, OrderResult>();
    
    process(order: Order): OrderResult {
        const cacheKey = this.generateCacheKey(order);
        
        if (this.cache.has(cacheKey)) {
            returnthis.cache.get(cacheKey);
        }
        
        const result = this.calculateOrder(order);
        this.cache.set(cacheKey, result);
        
        return result;
    }
    
    private generateCacheKey(order: Order): string {
        return`${order.id}_${order.version}_${order.lastModified}`;
    }
}

// 第五步：验证重构结果
describe('processOrder - 重构后验证', () => {
    it('should maintain backward compatibility', () => {
        const oldResult = processOrder_OLD(testOrder);
        const newResult = new OrderProcessor().process(testOrder);
        
        expect(newResult.toJSON()).toEqual(oldResult);
    });
    
    it('should improve performance', () => {
        const startOld = performance.now();
        for (let i = 0; i < 10000; i++) {
            processOrder_OLD(testOrder);
        }
        const timeOld = performance.now() - startOld;
        
        const startNew = performance.now();
        for (let i = 0; i < 10000; i++) {
            processor.process(testOrder);
        }
        const timeNew = performance.now() - startNew;
        
        expect(timeNew).toBeLessThan(timeOld * 0.7); // 至少30%性能提升
    });
});

---
name: code-refactor
description: Improve code structure, performance, and maintainability through systematic refactoring. Specializes in legacy modernization and technical debt reduction. Use PROACTIVELY for code quality improvements and architectural evolution.
model: sonnet
---
You are a code refactoring expert specializing in systematic code improvement while preserving functionality and minimizing risk.

## Refactoring Expertise
- Systematic refactoring patterns and techniques
- Legacy code modernization strategies
- Technical debt assessment and prioritization
- Design pattern implementation and improvement
- Code smell identification and elimination
- Performance optimization through structural changes
- Dependency injection and inversion of control
- Test-driven refactoring with comprehensive coverage

## Refactoring Methodology
1. Comprehensive test suite creation before changes
2. Small, incremental changes with continuous validation
3. Automated refactoring tools utilization when possible
4. Code metrics tracking for improvement measurement
5. Risk assessment and rollback strategy planning
6. Team communication and change documentation
7. Performance benchmarking before and after changes
8. Code review integration for quality assurance

## Common Refactoring Patterns
- Extract Method/Class for better code organization
- Replace Conditional with Polymorphism
- Introduce Parameter Object for complex signatures
- Replace Magic Numbers with Named Constants
- Eliminate Duplicate Code through abstraction
- Simplify Complex Conditionals with Guard Clauses
- Replace Inheritance with Composition
- Introduce Factory Methods for object creation
- Replace Nested Conditionals with Early Returns

## Modernization Strategies
- Framework and library upgrade planning
- Language feature adoption (async/await, generics, etc.)
- Architecture pattern migration (MVC to microservices)
- Database schema evolution and optimization
- API design improvement and versioning
- Security vulnerability remediation through refactoring
- Performance bottleneck elimination
- Code style and formatting standardization
- Documentation improvement during refactoring

Execute refactoring systematically with comprehensive testing and risk mitigation. Focus on incremental improvements that deliver measurable value while maintaining system stability and team productivity.

---
name:code-refactor
description:通过系统重构改善代码结构、性能和可维护性。专精遗留代码现代化和技术债务减少。在代码质量改进和架构演进时主动使用。
model:sonnet
---
你是一位代码重构专家，专精在保持功能不变和最小化风险的同时进行系统化代码改进。

## 重构专业技能 / Refactoring Expertise
-系统化重构模式和技术
-遗留代码现代化策略
-技术债务评估和优先级排序
-设计模式实现和改进
-代码异味识别和消除
-通过结构变更进行性能优化
-依赖注入和控制反转
-带全面覆盖的测试驱动重构

## 重构方法论 / Refactoring Methodology
1.更改前创建全面的测试套件
2.持续验证的小步增量更改
3.尽可能使用自动重构工具
4.跟踪代码指标以衡量改进
5.风险评估和回滚策略规划
6.团队沟通和变更文档
7.更改前后的性能基准测试
8.质量保证的代码审查集成

## 常见重构模式 / Common Refactoring Patterns
-提取方法/类以改善代码组织
-用多态替代条件语句
-为复杂签名引入参数对象
-用命名常量替代魔法数字
-通过抽象消除重复代码
-用卫语句简化复杂条件
-用组合替代继承
-引入工厂方法创建对象
-用提前返回替代嵌套条件

## 现代化策略 / Modernization Strategies
-框架和库升级规划
-语言特性采用（async/await、泛型等）
-架构模式迁移（MVC到微服务）
-数据库模式演进和优化
-API设计改进和版本控制
-通过重构修复安全漏洞
-性能瓶颈消除
-代码风格和格式标准化
-重构期间的文档改进

系统化执行重构，配合全面测试和风险缓解。
专注于提供可衡量价值的渐进式改进，同时保持系统稳定性和团队生产力。

// 1. 什么是代码异味（Code Smell）？
// 就像食物变质的味道，提示代码有问题

// 异味1：重复代码
function calculatePrice(item) {
    return item.price * item.quantity * 0.9;
}
function calculateDiscountedPrice(item) {
    return item.price * item.quantity * 0.9;  // 重复！
}

// 2. 什么是技术债务？
// 就像信用卡欠款，越拖越多利息
// 快速实现 = 借债
// 重构 = 还债

// 3. 什么是依赖注入？
// 就像组装电脑，零件可以随时更换
class Computer {
    constructor(cpu, memory, storage) {  // 注入依赖
        this.cpu = cpu;
        this.memory = memory;
        this.storage = storage;
    }
}

// 4. 什么是提取方法？
// 把长函数分解成小函数，像把长文章分段
function processData_BEFORE(data) {
    // 100行代码...
}

function processData_AFTER(data) {
    const cleaned = cleanData(data);
    const validated = validateData(cleaned);
    return transformData(validated);
}

# 在Claude Code中输入
/agents

重构这个充满问题的用户管理类，提高可维护性

// ========== 重构计划 ==========
// 目标：将紧耦合的UserManager重构为清晰的领域模型
// 策略：渐进式重构，保持向后兼容

// BEFORE: 问题代码
class UserManager {
    constructor() {
        this.db = mysql.createConnection({...});  // 问题1：直接依赖具体实现
    }
    
    // 问题2：方法过长，职责过多
    async createUser(data) {
        // 验证
        if (!data.email || !data.email.includes('@')) {
            thrownewError('Invalid email');
        }
        if (!data.password || data.password.length < 6) {
            thrownewError('Invalid password');
        }
        
        // 检查重复
        const existing = awaitthis.db.query(
            'SELECT * FROM users WHERE email = ?', 
            [data.email]
        );
        if (existing.length > 0) {
            thrownewError('User exists');
        }
        
        // 加密密码
        const salt = crypto.randomBytes(16).toString('hex');
        const hash = crypto.pbkdf2Sync(data.password, salt, 1000, 64, 'sha512').toString('hex');
        
        // 保存
        const result = awaitthis.db.query(
            'INSERT INTO users (email, password, salt) VALUES (?, ?, ?)',
            [data.email, hash, salt]
        );
        
        // 发邮件
        const transporter = nodemailer.createTransport({...});
        await transporter.sendMail({
            to: data.email,
            subject: 'Welcome',
            text: 'Welcome to our service!'
        });
        
        return result.insertId;
    }
}

// AFTER: 重构后的代码
// Step 1: 定义清晰的领域模型
class User {
    private constructor(
        private readonly id: string,
        private readonly email: Email,
        private readonly hashedPassword: HashedPassword,
        private readonly createdAt: Date
    ) {}
    
    static create(email: string, password: string): User {
        returnnew User(
            generateId(),
            new Email(email),
            HashedPassword.create(password),
            newDate()
        );
    }
}

// Step 2: 值对象封装业务规则
class Email {
    constructor(private readonly value: string) {
        if (!this.isValid(value)) {
            thrownew InvalidEmailError(value);
        }
    }
    
    private isValid(email: string): boolean {
        return/^[^\s@]+@[^\s@]+\.[^\s@]+$/.test(email);
    }
    
    toString(): string {
        returnthis.value;
    }
}

class HashedPassword {
    private constructor(
        private readonly hash: string,
        private readonly salt: string
    ) {}
    
    static create(plainPassword: string): HashedPassword {
        if (plainPassword.length < 8) {
            thrownew WeakPasswordError();
        }
        
        const salt = crypto.randomBytes(16).toString('hex');
        const hash = this.hashPassword(plainPassword, salt);
        returnnew HashedPassword(hash, salt);
    }
    
    private static hashPassword(password: string, salt: string): string {
        return crypto.pbkdf2Sync(password, salt, 10000, 64, 'sha512').toString('hex');
    }
    
    verify(plainPassword: string): boolean {
        const hash = HashedPassword.hashPassword(plainPassword, this.salt);
        return hash === this.hash;
    }
}

// Step 3: 仓储模式解耦数据访问
interface UserRepository {
    save(user: User): Promise<void>;
    findByEmail(email: Email): Promise<User | null>;
    exists(email: Email): Promise<boolean>;
}

class MySQLUserRepository implements UserRepository {
    constructor(private readonly db: DatabaseConnection) {}
    
    async save(user: User): Promise<void> {
        awaitthis.db.execute(
            'INSERT INTO users (id, email, password_hash, password_salt, created_at) VALUES (?, ?, ?, ?, ?)',
            [user.id, user.email.toString(), user.hashedPassword.hash, user.hashedPassword.salt, user.createdAt]
        );
    }
    
    async findByEmail(email: Email): Promise<User | null> {
        const result = awaitthis.db.query(
            'SELECT * FROM users WHERE email = ?',
            [email.toString()]
        );
        
        return result[0] ? this.mapToUser(result[0]) : null;
    }
    
    async exists(email: Email): Promise<boolean> {
        const count = awaitthis.db.scalar(
            'SELECT COUNT(*) FROM users WHERE email = ?',
            [email.toString()]
        );
        
        return count > 0;
    }
}

// Step 4: 服务层编排业务逻辑
class UserService {
    constructor(
        private readonly userRepository: UserRepository,
        private readonly emailService: EmailService,
        private readonly eventBus: EventBus
    ) {}
    
    async registerUser(dto: RegisterUserDto): Promise<UserDto> {
        // 1. 创建领域对象
        const user = User.create(dto.email, dto.password);
        
        // 2. 检查唯一性
        if (awaitthis.userRepository.exists(user.email)) {
            thrownew UserAlreadyExistsError(dto.email);
        }
        
        // 3. 持久化
        awaitthis.userRepository.save(user);
        
        // 4. 发送事件（异步处理邮件等副作用）
        awaitthis.eventBus.publish(new UserRegisteredEvent(user));
        
        return UserDto.fromDomain(user);
    }
}

// Step 5: 事件驱动处理副作用
class EmailNotificationHandler {
    constructor(private readonly emailService: EmailService) {}
    
    @EventHandler(UserRegisteredEvent)
    async handle(event: UserRegisteredEvent): Promise<void> {
        awaitthis.emailService.sendWelcomeEmail(event.user.email);
    }
}

// Step 6: 依赖注入容器配置
const container = new Container();
container.bind(UserRepository).to(MySQLUserRepository);
container.bind(EmailService).to(SMTPEmailService);
container.bind(EventBus).to(InMemoryEventBus);
container.bind(UserService).toSelf();

这个数据处理函数性能很差，帮我重构优化

// 性能优化重构方案

// BEFORE: 性能问题代码
function processLargeDataset(data) {
    let result = [];
    
    // 问题1：嵌套循环 O(n²)
    for (let i = 0; i < data.length; i++) {
        for (let j = 0; j < data.length; j++) {
            if (data[i].id === data[j].parentId) {
                result.push({
                    parent: data[i],
                    child: data[j]
                });
            }
        }
    }
    
    // 问题2：重复计算
    result = result.map(item => ({
        ...item,
        score: calculateComplexScore(item)  // 每次都重新计算
    }));
    
    // 问题3：同步阻塞
    result.forEach(item => {
        saveToDatabase(item);  // 同步保存
    });
    
    return result;
}

// AFTER: 优化后的代码
class OptimizedDataProcessor {
    private cache = newMap();
    private indexMap = newMap();
    
    async processLargeDataset(data: DataItem[]): Promise<ProcessedItem[]> {
        // 优化1：建立索引，O(n) 替代 O(n²)
        this.buildIndex(data);
        
        // 优化2：并行处理
        const chunks = this.chunkArray(data, 1000);
        const processedChunks = awaitPromise.all(
            chunks.map(chunk =>this.processChunk(chunk))
        );
        
        // 优化3：批量操作
        const result = processedChunks.flat();
        awaitthis.batchSave(result);
        
        return result;
    }
    
    private buildIndex(data: DataItem[]): void {
        // 使用Map建立索引，查找复杂度从O(n)降到O(1)
        data.forEach(item => {
            if (!this.indexMap.has(item.id)) {
                this.indexMap.set(item.id, []);
            }
            this.indexMap.get(item.id).push(item);
        });
    }
    
    private async processChunk(chunk: DataItem[]): Promise<ProcessedItem[]> {
        return chunk.map(item => {
            // 使用索引快速查找
            const children = this.indexMap.get(item.id) || [];
            
            // 使用缓存避免重复计算
            const score = this.getCachedScore(item);
            
            return {
                ...item,
                children,
                score
            };
        });
    }
    
    private getCachedScore(item: DataItem): number {
        const key = this.generateCacheKey(item);
        
        if (!this.cache.has(key)) {
            this.cache.set(key, calculateComplexScore(item));
        }
        
        returnthis.cache.get(key);
    }
    
    private async batchSave(items: ProcessedItem[]): Promise<void> {
        // 批量插入而不是逐个插入
        const batches = this.chunkArray(items, 100);
        
        awaitPromise.all(
            batches.map(batch =>
                this.db.batchInsert('processed_items', batch)
            )
        );
    }
    
    private chunkArray<T>(array: T[], size: number): T[][] {
        const chunks: T[][] = [];
        for (let i = 0; i < array.length; i += size) {
            chunks.push(array.slice(i, i + size));
        }
        return chunks;
    }
}

// 性能测试对比
asyncfunction performanceComparison() {
    const testData = generateLargeDataset(10000);
    
    console.time('Original');
    await processLargeDataset(testData);
    console.timeEnd('Original');  // 45秒
    
    console.time('Optimized');
    const processor = new OptimizedDataProcessor();
    await processor.processLargeDataset(testData);
    console.timeEnd('Optimized');  // 2秒
    
    // 性能提升：22.5倍！
}

## Refactoring Expertise
- ES6+现代化（箭头函数、解构、模板字符串）
- Promise到async/await迁移
- 类型安全重构
- 模块化改造

## Refactoring Expertise
- Python 2到3迁移
- 类型提示添加
- 数据类使用
- 异步改造

## Team Standards
- 重构粒度：每次PR不超过500行
- 测试要求：重构前后测试覆盖率不降低
- 审查流程：重构需要两人审查
- 文档更新：重构需同步更新文档

// 1. 创建完整测试套件
describe('重构前后对比测试', () => {
    const testCases = generateTestCases();
    
    testCases.forEach(testCase => {
        it(`should maintain functionality for ${testCase.name}`, () => {
            const oldResult = oldFunction(testCase.input);
            const newResult = newFunction(testCase.input);
            expect(newResult).toEqual(oldResult);
        });
    });
});

// 2. 使用特性开关
const featureFlags = {
    useNewImplementation: process.env.USE_NEW_CODE === 'true'
};

function processData(data) {
    if (featureFlags.useNewImplementation) {
        return newImplementation(data);
    }
    return oldImplementation(data);
}

// 3. 渐进式迁移
class MigrationAdapter {
    constructor(oldSystem, newSystem) {
        this.old = oldSystem;
        this.new = newSystem;
        this.migrationProgress = 0;
    }
    
    process(data) {
        // 双写模式：同时写入新旧系统
        const oldResult = this.old.process(data);
        const newResult = this.new.process(data);
        
        // 对比结果
        if (!this.resultsMatch(oldResult, newResult)) {
            this.logDiscrepancy(oldResult, newResult);
        }
        
        // 根据迁移进度返回结果
        returnthis.migrationProgress < 100 ? oldResult : newResult;
    }
}

// 重构价值评估框架
const refactoringMetrics = {
    // 代码质量指标
    cyclomaticComplexity: { before: 15, after: 5 },  // 圈复杂度降低
    codeLines: { before: 500, after: 300 },          // 代码行数减少
    duplicateCode: { before: '30%', after: '5%' },   // 重复代码减少
    
    // 性能指标
    executionTime: { before: '500ms', after: '100ms' },
    memoryUsage: { before: '100MB', after: '50MB' },
    
    // 维护性指标
    testCoverage: { before: '40%', after: '90%' },
    bugFixTime: { before: '2 days', after: '2 hours' },
    
    // ROI计算
    investmentHours: 40,
    savedHoursPerMonth: 20,
    paybackPeriod: '2 months'
};

// 大规模重构策略
class LargeScaleRefactoring {
    // 1. 分解为小任务
    breakDownTasks() {
        return [
            { phase: 1, task: '建立测试基准', duration: '1 week' },
            { phase: 2, task: '提取核心接口', duration: '2 weeks' },
            { phase: 3, task: '模块化改造', duration: '3 weeks' },
            { phase: 4, task: '性能优化', duration: '1 week' },
            { phase: 5, task: '清理和文档', duration: '1 week' }
        ];
    }
    
    // 2. 并行处理
    async executeParallel() {
        const independentTasks = this.identifyIndependentTasks();
        awaitPromise.all(independentTasks.map(task =>this.refactor(task)));
    }
    
    // 3. 风险管理
    mitigateRisks() {
        return {
            backupStrategy: '每个阶段前创建分支',
            rollbackPlan: '保留旧代码30天',
            monitoringPeriod: '重构后监控2周',
            gradualRollout: '灰度发布到10%用户'
        };
    }
}

const refactoringPrinciples = {
    // 1. 小步前进
    "步子要小": "每次只改一点，确保能快速回滚",
    
    // 2. 测试先行
    "测试保护": "没有测试就没有重构",
    
    // 3. 保持功能
    "功能不变": "重构是改进结构，不是改变功能",
    
    // 4. 持续集成
    "频繁提交": "小批量、高频率的提交",
    
    // 5. 团队协作
    "沟通充分": "重构影响团队，需要充分沟通"
};

// 何时重构？
const whenToRefactor = {
    "三次法则": "第一次勉强完成，第二次产生反感，第三次必须重构",
    "添加功能时": "发现现有代码结构阻碍新功能",
    "修复Bug时": "发现代码难以理解",
    "代码审查时": "发现可以改进的地方",
    "性能优化时": "结构问题导致性能瓶颈"
};

// 何时不重构？
const whenNotToRefactor = {
    "截止日期临近": "风险太大",
    "代码将被废弃": "没有价值",
    "团队不支持": "缺乏共识",
    "没有测试": "风险不可控"
};

// 必备重构工具
const refactoringTools = {
    // IDE重构功能
    ide: {
        "VSCode": ["重命名", "提取方法", "移动文件"],
        "IntelliJ": ["安全删除", "内联变量", "改变签名"],
        "WebStorm": ["提取组件", "优化导入", "代码检查"]
    },
    
    // 代码分析工具
    analysis: {
        "SonarQube": "代码质量分析",
        "ESLint": "代码规范检查",
        "CodeClimate": "技术债务评估"
    },
    
    // 测试工具
    testing: {
        "Jest": "单元测试",
        "Cypress": "E2E测试",
        "Stryker": "变异测试"
    },
    
    // 性能工具
    performance: {
        "Lighthouse": "性能审计",
        "WebPageTest": "性能测试",
        "Chrome DevTools": "性能分析"
    }
};

/**
 * 重构之道
 * 
 * 勇气：敢于改变现状
 * 谨慎：小步安全前进
 * 坚持：持续改进不止
 * 
 * "让开发更快乐，让代码更优雅"
 */

class RefactoringMaster {
    motto = "Clean code is not written, it's refactored";
    
    refactor(code) {
        while (!code.isPerfect()) {  // 永远为假，因为没有完美的代码
            const smell = this.findWorstSmell(code);
            const pattern = this.selectPattern(smell);
            code = this.applyPattern(code, pattern);
            this.test(code);
            this.commit(code);
        }
    }
    
    wisdom() {
        return`
            重构是一种习惯，
            不是一个项目。
            今天重构一点点，
            明天代码更灿烂。
        `;
    }
}