tlc-claude-code 1.2.29 → 1.4.0

package/server/lib/refactor-executor.js

@@ -0,0 +1,254 @@
+/**
+ * Refactor Executor
+ * Apply refactoring changes with interactive confirmation
+ */
+
+const { CheckpointManager } = require('./checkpoint-manager.js');
+
+class RefactorExecutor {
+  constructor(options = {}) {
+    this.checkpointManager = options.checkpointManager || new CheckpointManager();
+    this.testCommand = options.testCommand || 'npm test';
+    this.maxAutofixAttempts = options.maxAutofixAttempts || 3;
+    this.interactive = options.interactive !== false;
+    this.prompt = options.prompt || this.defaultPrompt.bind(this);
+    this.exec = options.exec || this.defaultExec.bind(this);
+    this.writeFile = options.writeFile || require('fs').promises.writeFile;
+    this.readFile = options.readFile || require('fs').promises.readFile;
+
+    this.appliedChanges = [];
+    this.checkpoint = null;
+  }
+
+  defaultPrompt(question) {
+    // In real implementation, would use readline
+    return Promise.resolve('y');
+  }
+
+  async defaultExec(command) {
+    const { execSync } = require('child_process');
+    return execSync(command, { encoding: 'utf-8' });
+  }
+
+  /**
+   * Execute a list of refactorings
+   * @param {Array} refactorings - List of refactoring operations
+   * @returns {Object} Execution result
+   */
+  async execute(refactorings) {
+    this.appliedChanges = [];
+
+    // Create checkpoint before starting
+    this.checkpoint = await this.checkpointManager.create();
+
+    const results = {
+      applied: [],
+      skipped: [],
+      failed: [],
+      rolledBack: false,
+    };
+
+    for (const refactor of refactorings) {
+      try {
+        const result = await this.executeOne(refactor);
+
+        if (result.applied) {
+          results.applied.push(refactor);
+          this.appliedChanges.push({
+            refactor,
+            timestamp: new Date(),
+          });
+        } else if (result.skipped) {
+          results.skipped.push(refactor);
+        } else if (result.failed) {
+          results.failed.push({ refactor, error: result.error });
+
+          // Rollback on failure
+          await this.rollback();
+          results.rolledBack = true;
+          break;
+        }
+      } catch (error) {
+        results.failed.push({ refactor, error: error.message });
+        await this.rollback();
+        results.rolledBack = true;
+        break;
+      }
+    }
+
+    return results;
+  }
+
+  /**
+   * Execute a single refactoring
+   */
+  async executeOne(refactor) {
+    // Interactive confirmation
+    if (this.interactive) {
+      const description = this.describeRefactor(refactor);
+      const answer = await this.prompt(`${description}\nApply? [Y/n/skip]: `);
+
+      if (answer.toLowerCase() === 'n') {
+        return { applied: false, skipped: true };
+      }
+      if (answer.toLowerCase() === 'skip') {
+        return { applied: false, skipped: true };
+      }
+    }
+
+    // Apply the refactoring
+    await this.applyRefactor(refactor);
+
+    // Run tests
+    const testResult = await this.runTests();
+
+    if (!testResult.success) {
+      // Try autofix
+      const fixed = await this.attemptAutofix(refactor, testResult);
+      if (!fixed) {
+        return { applied: false, failed: true, error: 'Tests failed after autofix attempts' };
+      }
+    }
+
+    return { applied: true };
+  }
+
+  /**
+   * Describe a refactoring in plain English
+   */
+  describeRefactor(refactor) {
+    switch (refactor.type) {
+      case 'extract':
+        return `Extract "${refactor.name}" from "${refactor.source}" (${refactor.lines} lines)`;
+      case 'rename':
+        return `Rename "${refactor.oldName}" to "${refactor.newName}" in ${refactor.files?.length || 1} file(s)`;
+      case 'split':
+        return `Split "${refactor.source}" into ${refactor.targets?.length || 2} files`;
+      case 'inline':
+        return `Inline "${refactor.name}" into "${refactor.target}"`;
+      default:
+        return `Apply ${refactor.type} refactoring`;
+    }
+  }
+
+  /**
+   * Apply a refactoring to the codebase
+   */
+  async applyRefactor(refactor) {
+    switch (refactor.type) {
+      case 'extract':
+        await this.applyExtract(refactor);
+        break;
+      case 'rename':
+        await this.applyRename(refactor);
+        break;
+      case 'split':
+        await this.applySplit(refactor);
+        break;
+      default:
+        if (refactor.changes) {
+          for (const change of refactor.changes) {
+            await this.writeFile(change.file, change.content);
+          }
+        }
+    }
+  }
+
+  async applyExtract(refactor) {
+    const { source, name, startLine, endLine, newFile } = refactor;
+
+    const content = await this.readFile(source, 'utf-8');
+    const lines = content.split('\n');
+
+    // Extract the function body
+    const extractedLines = lines.slice(startLine - 1, endLine);
+    const extractedCode = extractedLines.join('\n');
+
+    // Create new file with extracted function
+    const newContent = `/**
+ * Extracted from ${source}
+ */
+
+${extractedCode}
+
+module.exports = { ${name} };
+`;
+
+    if (newFile) {
+      await this.writeFile(newFile, newContent);
+    }
+
+    // Update original file - replace with import/call
+    const updatedLines = [
+      ...lines.slice(0, startLine - 1),
+      `const { ${name} } = require('${newFile}');`,
+      ...lines.slice(endLine),
+    ];
+
+    await this.writeFile(source, updatedLines.join('\n'));
+  }
+
+  async applyRename(refactor) {
+    const { oldName, newName, files } = refactor;
+
+    for (const file of files || []) {
+      const content = await this.readFile(file, 'utf-8');
+      const updated = content.replace(new RegExp(oldName, 'g'), newName);
+      await this.writeFile(file, updated);
+    }
+  }
+
+  async applySplit(refactor) {
+    const { source, targets } = refactor;
+
+    for (const target of targets || []) {
+      await this.writeFile(target.file, target.content);
+    }
+  }
+
+  /**
+   * Run tests and return result
+   */
+  async runTests() {
+    try {
+      await this.exec(this.testCommand);
+      return { success: true };
+    } catch (error) {
+      return { success: false, error: error.message };
+    }
+  }
+
+  /**
+   * Attempt to autofix failing tests
+   */
+  async attemptAutofix(refactor, testResult) {
+    for (let attempt = 1; attempt <= this.maxAutofixAttempts; attempt++) {
+      // In real implementation, would analyze error and fix
+      // For now, just re-run tests
+      const result = await this.runTests();
+      if (result.success) {
+        return true;
+      }
+    }
+    return false;
+  }
+
+  /**
+   * Rollback to checkpoint
+   */
+  async rollback() {
+    if (this.checkpoint) {
+      await this.checkpointManager.rollback(this.checkpoint);
+      this.checkpoint = null;
+    }
+  }
+
+  /**
+   * Get log of applied changes
+   */
+  getLog() {
+    return this.appliedChanges;
+  }
+}
+
+module.exports = { RefactorExecutor };

package/server/lib/refactor-executor.test.js

@@ -0,0 +1,305 @@
+/**
+ * Refactor Executor Tests
+ */
+
+import { describe, it, expect, vi, beforeEach } from 'vitest';
+
+describe('RefactorExecutor', () => {
+  beforeEach(() => {
+    vi.resetAllMocks();
+  });
+
+  describe('extract refactoring', () => {
+    it('applies extract function refactoring', async () => {
+      const { RefactorExecutor } = await import('./refactor-executor.js');
+
+      const writeFileMock = vi.fn().mockResolvedValue();
+      const readFileMock = vi.fn().mockResolvedValue(`
+function main() {
+  const x = validateEmail(email);
+  return x;
+}
+
+function validateEmail(email) {
+  if (!email) return false;
+  return email.includes('@');
+}
+`);
+      const execMock = vi.fn().mockResolvedValue('');
+      const checkpointManager = {
+        create: vi.fn().mockResolvedValue({ id: 'test' }),
+        rollback: vi.fn().mockResolvedValue(),
+      };
+
+      const executor = new RefactorExecutor({
+        checkpointManager,
+        writeFile: writeFileMock,
+        readFile: readFileMock,
+        exec: execMock,
+        interactive: false,
+      });
+
+      const result = await executor.execute([{
+        type: 'extract',
+        source: 'src/main.js',
+        name: 'validateEmail',
+        startLine: 6,
+        endLine: 9,
+        newFile: 'src/validators.js',
+      }]);
+
+      expect(writeFileMock).toHaveBeenCalled();
+      expect(result.applied).toHaveLength(1);
+    });
+  });
+
+  describe('rename refactoring', () => {
+    it('applies rename refactoring across files', async () => {
+      const { RefactorExecutor } = await import('./refactor-executor.js');
+
+      const writeFileMock = vi.fn().mockResolvedValue();
+      const readFileMock = vi.fn().mockResolvedValue('const oldName = 1;');
+      const execMock = vi.fn().mockResolvedValue('');
+      const checkpointManager = {
+        create: vi.fn().mockResolvedValue({ id: 'test' }),
+        rollback: vi.fn().mockResolvedValue(),
+      };
+
+      const executor = new RefactorExecutor({
+        checkpointManager,
+        writeFile: writeFileMock,
+        readFile: readFileMock,
+        exec: execMock,
+        interactive: false,
+      });
+
+      const result = await executor.execute([{
+        type: 'rename',
+        oldName: 'oldName',
+        newName: 'newName',
+        files: ['file1.js', 'file2.js'],
+      }]);
+
+      expect(writeFileMock).toHaveBeenCalledTimes(2);
+      expect(result.applied).toHaveLength(1);
+    });
+  });
+
+  describe('interactive mode', () => {
+    it('pauses for confirmation in interactive mode', async () => {
+      const { RefactorExecutor } = await import('./refactor-executor.js');
+
+      const promptMock = vi.fn().mockResolvedValue('y');
+      const writeFileMock = vi.fn().mockResolvedValue();
+      const readFileMock = vi.fn().mockResolvedValue('code');
+      const execMock = vi.fn().mockResolvedValue('');
+      const checkpointManager = {
+        create: vi.fn().mockResolvedValue({ id: 'test' }),
+        rollback: vi.fn().mockResolvedValue(),
+      };
+
+      const executor = new RefactorExecutor({
+        checkpointManager,
+        writeFile: writeFileMock,
+        readFile: readFileMock,
+        exec: execMock,
+        prompt: promptMock,
+        interactive: true,
+      });
+
+      await executor.execute([{
+        type: 'rename',
+        oldName: 'x',
+        newName: 'count',
+        files: ['file.js'],
+      }]);
+
+      expect(promptMock).toHaveBeenCalled();
+    });
+
+    it('skips when user says skip', async () => {
+      const { RefactorExecutor } = await import('./refactor-executor.js');
+
+      const promptMock = vi.fn().mockResolvedValue('skip');
+      const writeFileMock = vi.fn();
+      const checkpointManager = {
+        create: vi.fn().mockResolvedValue({ id: 'test' }),
+        rollback: vi.fn().mockResolvedValue(),
+      };
+
+      const executor = new RefactorExecutor({
+        checkpointManager,
+        writeFile: writeFileMock,
+        prompt: promptMock,
+        interactive: true,
+      });
+
+      const result = await executor.execute([{
+        type: 'rename',
+        oldName: 'x',
+        newName: 'count',
+        files: [],
+      }]);
+
+      expect(result.skipped).toHaveLength(1);
+      expect(result.applied).toHaveLength(0);
+    });
+  });
+
+  describe('test running', () => {
+    it('runs test command after each change', async () => {
+      const { RefactorExecutor } = await import('./refactor-executor.js');
+
+      const execMock = vi.fn().mockResolvedValue('');
+      const checkpointManager = {
+        create: vi.fn().mockResolvedValue({ id: 'test' }),
+        rollback: vi.fn().mockResolvedValue(),
+      };
+
+      const executor = new RefactorExecutor({
+        checkpointManager,
+        testCommand: 'npm test',
+        exec: execMock,
+        interactive: false,
+        writeFile: vi.fn().mockResolvedValue(),
+        readFile: vi.fn().mockResolvedValue('code'),
+      });
+
+      await executor.execute([{
+        type: 'rename',
+        oldName: 'x',
+        newName: 'y',
+        files: ['file.js'],
+      }]);
+
+      expect(execMock).toHaveBeenCalledWith('npm test');
+    });
+  });
+
+  describe('autofix attempts', () => {
+    it('attempts autofix on failure up to 3 times', async () => {
+      const { RefactorExecutor } = await import('./refactor-executor.js');
+
+      let callCount = 0;
+      const execMock = vi.fn().mockImplementation(() => {
+        callCount++;
+        if (callCount <= 3) throw new Error('Test failed');
+        return '';
+      });
+
+      const checkpointManager = {
+        create: vi.fn().mockResolvedValue({ id: 'test' }),
+        rollback: vi.fn().mockResolvedValue(),
+      };
+
+      const executor = new RefactorExecutor({
+        checkpointManager,
+        exec: execMock,
+        maxAutofixAttempts: 3,
+        interactive: false,
+        writeFile: vi.fn().mockResolvedValue(),
+        readFile: vi.fn().mockResolvedValue('code'),
+      });
+
+      await executor.execute([{
+        type: 'rename',
+        oldName: 'x',
+        newName: 'y',
+        files: ['file.js'],
+      }]);
+
+      // 1 initial + 3 autofix attempts = 4 calls
+      expect(execMock).toHaveBeenCalledTimes(4);
+    });
+
+    it('rolls back after 3 failed attempts', async () => {
+      const { RefactorExecutor } = await import('./refactor-executor.js');
+
+      const execMock = vi.fn().mockImplementation(() => {
+        throw new Error('Test failed');
+      });
+
+      const checkpointManager = {
+        create: vi.fn().mockResolvedValue({ id: 'test' }),
+        rollback: vi.fn().mockResolvedValue(),
+      };
+
+      const executor = new RefactorExecutor({
+        checkpointManager,
+        exec: execMock,
+        maxAutofixAttempts: 3,
+        interactive: false,
+        writeFile: vi.fn().mockResolvedValue(),
+        readFile: vi.fn().mockResolvedValue('code'),
+      });
+
+      const result = await executor.execute([{
+        type: 'rename',
+        oldName: 'x',
+        newName: 'y',
+        files: ['file.js'],
+      }]);
+
+      expect(checkpointManager.rollback).toHaveBeenCalled();
+      expect(result.rolledBack).toBe(true);
+    });
+  });
+
+  describe('change tracking', () => {
+    it('tracks all applied changes in log', async () => {
+      const { RefactorExecutor } = await import('./refactor-executor.js');
+
+      const execMock = vi.fn().mockResolvedValue('');
+      const checkpointManager = {
+        create: vi.fn().mockResolvedValue({ id: 'test' }),
+        rollback: vi.fn().mockResolvedValue(),
+      };
+
+      const executor = new RefactorExecutor({
+        checkpointManager,
+        exec: execMock,
+        interactive: false,
+        writeFile: vi.fn().mockResolvedValue(),
+        readFile: vi.fn().mockResolvedValue('code'),
+      });
+
+      await executor.execute([
+        { type: 'rename', oldName: 'a', newName: 'b', files: ['f1.js'] },
+        { type: 'rename', oldName: 'c', newName: 'd', files: ['f2.js'] },
+      ]);
+
+      const log = executor.getLog();
+      expect(log).toHaveLength(2);
+      expect(log[0].refactor.oldName).toBe('a');
+      expect(log[1].refactor.oldName).toBe('c');
+    });
+  });
+
+  describe('checkpoint management', () => {
+    it('creates checkpoint before starting', async () => {
+      const { RefactorExecutor } = await import('./refactor-executor.js');
+
+      const checkpointManager = {
+        create: vi.fn().mockResolvedValue({ id: 'test' }),
+        rollback: vi.fn().mockResolvedValue(),
+      };
+
+      const executor = new RefactorExecutor({
+        checkpointManager,
+        exec: vi.fn().mockResolvedValue(''),
+        interactive: false,
+        writeFile: vi.fn().mockResolvedValue(),
+        readFile: vi.fn().mockResolvedValue('code'),
+      });
+
+      await executor.execute([{
+        type: 'rename',
+        oldName: 'x',
+        newName: 'y',
+        files: ['file.js'],
+      }]);
+
+      expect(checkpointManager.create).toHaveBeenCalled();
+    });
+  });
+});