tlc-claude-code 1.2.29 → 1.4.0

package/server/lib/candidates-tracker.test.js

@@ -0,0 +1,300 @@
+/**
+ * Candidates Tracker Tests
+ */
+
+import { describe, it, expect, vi, beforeEach } from 'vitest';
+
+describe('CandidatesTracker', () => {
+  describe('file creation', () => {
+    it('creates file if not exists', async () => {
+      const { CandidatesTracker } = await import('./candidates-tracker.js');
+
+      const writeFileMock = vi.fn().mockResolvedValue();
+      const readFileMock = vi.fn().mockRejectedValue(new Error('ENOENT'));
+      const mkdirMock = vi.fn().mockResolvedValue();
+
+      const tracker = new CandidatesTracker({
+        readFile: readFileMock,
+        writeFile: writeFileMock,
+        mkdir: mkdirMock,
+      });
+
+      await tracker.add([
+        { file: 'test.js', startLine: 10, description: 'Test issue', impact: 85 },
+      ]);
+
+      expect(writeFileMock).toHaveBeenCalled();
+      expect(mkdirMock).toHaveBeenCalled();
+    });
+  });
+
+  describe('priority sections', () => {
+    it('appends new candidates to correct priority section', async () => {
+      const { CandidatesTracker } = await import('./candidates-tracker.js');
+
+      let savedContent = '';
+      const writeFileMock = vi.fn().mockImplementation((path, content) => {
+        savedContent = content;
+        return Promise.resolve();
+      });
+      const readFileMock = vi.fn().mockRejectedValue(new Error('ENOENT'));
+      const mkdirMock = vi.fn().mockResolvedValue();
+
+      const tracker = new CandidatesTracker({
+        readFile: readFileMock,
+        writeFile: writeFileMock,
+        mkdir: mkdirMock,
+      });
+
+      await tracker.add([
+        { file: 'high.js', startLine: 1, description: 'High priority', impact: 90 },
+        { file: 'medium.js', startLine: 1, description: 'Medium priority', impact: 65 },
+        { file: 'low.js', startLine: 1, description: 'Low priority', impact: 30 },
+      ]);
+
+      expect(savedContent).toContain('High Priority');
+      expect(savedContent).toContain('high.js:1');
+      expect(savedContent).toContain('Medium Priority');
+      expect(savedContent).toContain('medium.js:1');
+      expect(savedContent).toContain('Low Priority');
+      expect(savedContent).toContain('low.js:1');
+    });
+
+    it('correctly categorizes by impact score', async () => {
+      const { CandidatesTracker } = await import('./candidates-tracker.js');
+      const tracker = new CandidatesTracker({});
+
+      expect(tracker.getTier(90)).toBe('high');
+      expect(tracker.getTier(80)).toBe('high');
+      expect(tracker.getTier(79)).toBe('medium');
+      expect(tracker.getTier(50)).toBe('medium');
+      expect(tracker.getTier(49)).toBe('low');
+    });
+  });
+
+  describe('deduplication', () => {
+    it('deduplicates by file:line key', async () => {
+      const { CandidatesTracker } = await import('./candidates-tracker.js');
+
+      const existingContent = `# Refactor Candidates
+
+## High Priority (Impact 80+)
+
+- [ ] test.js:10 - Existing issue (Impact: 85)
+
+## Medium Priority (Impact 50-79)
+
+_None_
+
+## Low Priority (Impact <50)
+
+_None_
+`;
+
+      let savedContent = '';
+      const writeFileMock = vi.fn().mockImplementation((path, content) => {
+        savedContent = content;
+        return Promise.resolve();
+      });
+      const readFileMock = vi.fn().mockResolvedValue(existingContent);
+      const mkdirMock = vi.fn().mockResolvedValue();
+
+      const tracker = new CandidatesTracker({
+        readFile: readFileMock,
+        writeFile: writeFileMock,
+        mkdir: mkdirMock,
+      });
+
+      await tracker.add([
+        { file: 'test.js', startLine: 10, description: 'Updated issue', impact: 90 },
+      ]);
+
+      // Should only have one entry for test.js:10
+      const matches = savedContent.match(/test\.js:10/g);
+      expect(matches).toHaveLength(1);
+      expect(savedContent).toContain('Updated issue');
+      expect(savedContent).toContain('Impact: 90');
+    });
+  });
+
+  describe('impact score updates', () => {
+    it('updates impact scores on re-analysis', async () => {
+      const { CandidatesTracker } = await import('./candidates-tracker.js');
+
+      const existingContent = `# Refactor Candidates
+
+## High Priority (Impact 80+)
+
+- [ ] test.js:10 - Old description (Impact: 85)
+
+## Medium Priority (Impact 50-79)
+
+_None_
+
+## Low Priority (Impact <50)
+
+_None_
+`;
+
+      let savedContent = '';
+      const tracker = new CandidatesTracker({
+        readFile: vi.fn().mockResolvedValue(existingContent),
+        writeFile: vi.fn().mockImplementation((p, c) => { savedContent = c; return Promise.resolve(); }),
+        mkdir: vi.fn().mockResolvedValue(),
+      });
+
+      await tracker.add([
+        { file: 'test.js', startLine: 10, description: 'New description', impact: 95 },
+      ]);
+
+      expect(savedContent).toContain('Impact: 95');
+      expect(savedContent).toContain('New description');
+    });
+  });
+
+  describe('completion marking', () => {
+    it('marks candidate as complete after refactoring', async () => {
+      const { CandidatesTracker } = await import('./candidates-tracker.js');
+
+      const existingContent = `# Refactor Candidates
+
+## High Priority (Impact 80+)
+
+- [ ] test.js:10 - Test issue (Impact: 85)
+
+## Medium Priority (Impact 50-79)
+
+_None_
+
+## Low Priority (Impact <50)
+
+_None_
+`;
+
+      let savedContent = '';
+      const tracker = new CandidatesTracker({
+        readFile: vi.fn().mockResolvedValue(existingContent),
+        writeFile: vi.fn().mockImplementation((p, c) => { savedContent = c; return Promise.resolve(); }),
+        mkdir: vi.fn().mockResolvedValue(),
+      });
+
+      await tracker.markComplete('test.js', 10);
+
+      expect(savedContent).toContain('[x] test.js:10');
+    });
+  });
+
+  describe('notes preservation', () => {
+    it('preserves manual notes in file', async () => {
+      const { CandidatesTracker } = await import('./candidates-tracker.js');
+
+      const existingContent = `# Refactor Candidates
+
+## High Priority (Impact 80+)
+
+- [ ] test.js:10 - Test issue (Impact: 85)
+
+## Medium Priority (Impact 50-79)
+
+_None_
+
+## Low Priority (Impact <50)
+
+_None_
+
+## Notes
+
+This is a manual note that should be preserved.
+Another line of notes.
+`;
+
+      let savedContent = '';
+      const tracker = new CandidatesTracker({
+        readFile: vi.fn().mockResolvedValue(existingContent),
+        writeFile: vi.fn().mockImplementation((p, c) => { savedContent = c; return Promise.resolve(); }),
+        mkdir: vi.fn().mockResolvedValue(),
+      });
+
+      await tracker.add([
+        { file: 'new.js', startLine: 5, description: 'New issue', impact: 70 },
+      ]);
+
+      expect(savedContent).toContain('## Notes');
+      expect(savedContent).toContain('manual note that should be preserved');
+    });
+  });
+
+  describe('parsing', () => {
+    it('parses existing candidates correctly', async () => {
+      const { CandidatesTracker } = await import('./candidates-tracker.js');
+
+      const content = `# Refactor Candidates
+
+## High Priority (Impact 80+)
+
+- [ ] src/api.js:10-25 - Extract validation (Impact: 85)
+- [x] src/utils.js:5 - Rename variable (Impact: 82)
+
+## Medium Priority (Impact 50-79)
+
+- [ ] src/helpers.js:30 - Simplify logic (Impact: 65)
+
+## Low Priority (Impact <50)
+
+_None_
+`;
+
+      const tracker = new CandidatesTracker({
+        readFile: vi.fn().mockResolvedValue(content),
+        writeFile: vi.fn().mockResolvedValue(),
+        mkdir: vi.fn().mockResolvedValue(),
+      });
+
+      const data = await tracker.load();
+
+      expect(data.high).toHaveLength(2);
+      expect(data.high[0].file).toBe('src/api.js');
+      expect(data.high[0].startLine).toBe(10);
+      expect(data.high[0].endLine).toBe(25);
+      expect(data.high[0].completed).toBe(false);
+      expect(data.high[1].completed).toBe(true);
+      expect(data.medium).toHaveLength(1);
+      expect(data.low).toHaveLength(0);
+    });
+  });
+
+  describe('formatting', () => {
+    it('formats line ranges correctly', async () => {
+      const { CandidatesTracker } = await import('./candidates-tracker.js');
+      const tracker = new CandidatesTracker({});
+
+      const line = tracker.formatCandidate({
+        completed: false,
+        file: 'test.js',
+        startLine: 10,
+        endLine: 20,
+        description: 'Test',
+        impact: 85,
+      });
+
+      expect(line).toContain('test.js:10-20');
+    });
+
+    it('formats single line correctly', async () => {
+      const { CandidatesTracker } = await import('./candidates-tracker.js');
+      const tracker = new CandidatesTracker({});
+
+      const line = tracker.formatCandidate({
+        completed: false,
+        file: 'test.js',
+        startLine: 10,
+        endLine: 10,
+        description: 'Test',
+        impact: 85,
+      });
+
+      expect(line).toContain('test.js:10 -');
+      expect(line).not.toContain('10-10');
+    });
+  });
+});

package/server/lib/checkpoint-manager.js

@@ -0,0 +1,251 @@
+/**
+ * Checkpoint Manager
+ * Create and manage git-based checkpoints for safe refactoring
+ */
+
+const { execSync } = require('child_process');
+const fs = require('fs');
+const path = require('path');
+
+class CheckpointManager {
+  constructor(options = {}) {
+    this.exec = options.exec || this.defaultExec.bind(this);
+    this.readFile = options.readFile || this.defaultReadFile.bind(this);
+    this.writeFile = options.writeFile || this.defaultWriteFile.bind(this);
+    this.stateFile = options.stateFile || '.tlc/checkpoint.json';
+  }
+
+  /**
+   * Default exec implementation
+   */
+  async defaultExec(command) {
+    return new Promise((resolve, reject) => {
+      try {
+        const stdout = execSync(command, { encoding: 'utf-8' });
+        resolve({ stdout });
+      } catch (error) {
+        reject(error);
+      }
+    });
+  }
+
+  /**
+   * Default read file implementation
+   */
+  async defaultReadFile(filePath) {
+    return fs.promises.readFile(filePath, 'utf-8');
+  }
+
+  /**
+   * Default write file implementation
+   */
+  async defaultWriteFile(filePath, content) {
+    const dir = path.dirname(filePath);
+    await fs.promises.mkdir(dir, { recursive: true });
+    await fs.promises.writeFile(filePath, content, 'utf-8');
+  }
+
+  /**
+   * Create a new checkpoint
+   * @param {Object} options - Creation options
+   * @returns {Object} Checkpoint info
+   */
+  async create(options = {}) {
+    // Check for existing checkpoint
+    if (!options.force) {
+      const existing = await this.load();
+      if (existing) {
+        throw new Error('Checkpoint already exists. Use rollback() first or force: true');
+      }
+    }
+
+    // Get current branch
+    let originalBranch;
+    let wasDetached = false;
+
+    try {
+      const { stdout } = await this.exec('git branch --show-current');
+      originalBranch = stdout.trim();
+
+      if (!originalBranch) {
+        // Detached HEAD
+        const { stdout: headCommit } = await this.exec('git rev-parse HEAD');
+        originalBranch = headCommit.trim();
+        wasDetached = true;
+      }
+    } catch (error) {
+      throw new Error('Failed to get current branch: ' + error.message);
+    }
+
+    // Check for uncommitted changes
+    const { stdout: status } = await this.exec('git status --porcelain');
+    const hasChanges = status.trim().length > 0;
+    let hasStash = false;
+    let stashRef = null;
+
+    // Stash changes if any
+    if (hasChanges) {
+      await this.exec('git stash push -m "TLC checkpoint stash"');
+      hasStash = true;
+      stashRef = 'stash@{0}';
+    }
+
+    // Create refactor branch
+    const timestamp = Date.now();
+    let branch = `refactor/${timestamp}`;
+    let attempts = 0;
+
+    while (attempts < 3) {
+      try {
+        await this.exec(`git checkout -b ${branch}`);
+        break;
+      } catch (error) {
+        if (error.message.includes('already exists')) {
+          attempts++;
+          branch = `refactor/${timestamp}-${attempts}`;
+        } else {
+          throw error;
+        }
+      }
+    }
+
+    // Get commit hash
+    const { stdout: commitHash } = await this.exec('git rev-parse HEAD');
+
+    const checkpoint = {
+      id: `checkpoint-${timestamp}`,
+      branch,
+      originalBranch,
+      wasDetached,
+      hasStash,
+      stashRef,
+      commitHash: commitHash.trim(),
+      createdAt: new Date(),
+    };
+
+    // Save checkpoint state
+    await this.save(checkpoint);
+
+    return checkpoint;
+  }
+
+  /**
+   * Rollback to checkpoint state
+   * @param {Object} checkpoint - Checkpoint to rollback to
+   */
+  async rollback(checkpoint) {
+    // Checkout original branch
+    await this.exec(`git checkout ${checkpoint.originalBranch}`);
+
+    // Delete refactor branch
+    try {
+      await this.exec(`git branch -D ${checkpoint.branch}`);
+    } catch (error) {
+      // Branch might not exist
+    }
+
+    // Pop stash if we stashed
+    if (checkpoint.hasStash) {
+      try {
+        await this.exec('git stash pop');
+      } catch (error) {
+        // Stash might be empty or conflict
+      }
+    }
+
+    // Clear checkpoint state
+    await this.clear();
+  }
+
+  /**
+   * Commit current changes
+   * @param {string} message - Commit message
+   */
+  async commit(message) {
+    await this.exec('git add -A');
+    await this.exec(`git commit -m "${message.replace(/"/g, '\\"')}"`);
+  }
+
+  /**
+   * Merge refactor branch back to original
+   * @param {Object} checkpoint - Checkpoint info
+   * @param {Object} options - Merge options
+   */
+  async merge(checkpoint, options = {}) {
+    // Checkout original branch
+    await this.exec(`git checkout ${checkpoint.originalBranch}`);
+
+    // Merge refactor branch
+    await this.exec(`git merge ${checkpoint.branch}`);
+
+    // Cleanup if requested
+    if (options.cleanup) {
+      await this.exec(`git branch -d ${checkpoint.branch}`);
+    }
+
+    // Clear checkpoint state
+    await this.clear();
+  }
+
+  /**
+   * Save checkpoint state to file
+   */
+  async save(checkpoint) {
+    await this.writeFile(this.stateFile, JSON.stringify(checkpoint, null, 2));
+  }
+
+  /**
+   * Load existing checkpoint state
+   * @returns {Object|null} Checkpoint or null if none exists
+   */
+  async load() {
+    try {
+      const content = await this.readFile(this.stateFile);
+      return JSON.parse(content);
+    } catch (error) {
+      return null;
+    }
+  }
+
+  /**
+   * Clear checkpoint state
+   */
+  async clear() {
+    try {
+      await fs.promises.unlink(this.stateFile);
+    } catch (error) {
+      // File might not exist
+    }
+  }
+
+  /**
+   * Get current checkpoint status
+   * @returns {Object} Status info
+   */
+  async status() {
+    const checkpoint = await this.load();
+
+    if (!checkpoint) {
+      return {
+        active: false,
+      };
+    }
+
+    // Get current branch
+    const { stdout: currentBranch } = await this.exec('git branch --show-current');
+
+    // Check for uncommitted changes
+    const { stdout: status } = await this.exec('git status --porcelain');
+
+    return {
+      active: true,
+      branch: checkpoint.branch,
+      originalBranch: checkpoint.originalBranch,
+      isOnRefactorBranch: currentBranch.trim() === checkpoint.branch,
+      hasUncommittedChanges: status.trim().length > 0,
+      createdAt: checkpoint.createdAt,
+    };
+  }
+}
+
+module.exports = { CheckpointManager };