tlc-claude-code 1.2.29 → 1.4.0

package/server/lib/bulk-repo-init.test.js

@@ -0,0 +1,388 @@
+import { describe, it, expect, beforeEach, afterEach } from 'vitest';
+import fs from 'fs';
+import path from 'path';
+import os from 'os';
+
+const { BulkRepoInit } = await import('./bulk-repo-init.js');
+
+describe('BulkRepoInit', () => {
+  let tempDir;
+  let bulkInit;
+
+  beforeEach(() => {
+    tempDir = fs.mkdtempSync(path.join(os.tmpdir(), 'bulk-repo-init-test-'));
+  });
+
+  afterEach(() => {
+    fs.rmSync(tempDir, { recursive: true, force: true });
+  });
+
+  describe('detection', () => {
+    it('detects repo without .tlc.json', () => {
+      // Create a repo without TLC config
+      const repoPath = path.join(tempDir, 'my-repo');
+      fs.mkdirSync(repoPath);
+      fs.writeFileSync(path.join(repoPath, 'package.json'), '{"name": "my-repo"}');
+
+      bulkInit = new BulkRepoInit(tempDir);
+      const repos = bulkInit.findUninitializedRepos();
+
+      expect(repos).toContain('my-repo');
+    });
+
+    it('skips repos that already have .tlc.json', () => {
+      // Create a repo WITH TLC config
+      const repoPath = path.join(tempDir, 'initialized-repo');
+      fs.mkdirSync(repoPath);
+      fs.writeFileSync(path.join(repoPath, 'package.json'), '{"name": "initialized-repo"}');
+      fs.writeFileSync(path.join(repoPath, '.tlc.json'), '{}');
+
+      bulkInit = new BulkRepoInit(tempDir);
+      const repos = bulkInit.findUninitializedRepos();
+
+      expect(repos).not.toContain('initialized-repo');
+    });
+  });
+
+  describe('project type detection', () => {
+    it('detects Node.js project (package.json)', () => {
+      const repoPath = path.join(tempDir, 'node-repo');
+      fs.mkdirSync(repoPath);
+      fs.writeFileSync(path.join(repoPath, 'package.json'), '{"name": "node-repo"}');
+
+      bulkInit = new BulkRepoInit(tempDir);
+      const projectType = bulkInit.detectProjectType(repoPath);
+
+      expect(projectType).toBe('node');
+    });
+
+    it('detects Python project (pyproject.toml)', () => {
+      const repoPath = path.join(tempDir, 'python-repo');
+      fs.mkdirSync(repoPath);
+      fs.writeFileSync(path.join(repoPath, 'pyproject.toml'), '[project]\nname = "python-repo"');
+
+      bulkInit = new BulkRepoInit(tempDir);
+      const projectType = bulkInit.detectProjectType(repoPath);
+
+      expect(projectType).toBe('python');
+    });
+
+    it('detects Python project (setup.py)', () => {
+      const repoPath = path.join(tempDir, 'python-repo-2');
+      fs.mkdirSync(repoPath);
+      fs.writeFileSync(path.join(repoPath, 'setup.py'), 'from setuptools import setup\nsetup()');
+
+      bulkInit = new BulkRepoInit(tempDir);
+      const projectType = bulkInit.detectProjectType(repoPath);
+
+      expect(projectType).toBe('python');
+    });
+
+    it('detects Go project (go.mod)', () => {
+      const repoPath = path.join(tempDir, 'go-repo');
+      fs.mkdirSync(repoPath);
+      fs.writeFileSync(path.join(repoPath, 'go.mod'), 'module example.com/go-repo\n\ngo 1.21');
+
+      bulkInit = new BulkRepoInit(tempDir);
+      const projectType = bulkInit.detectProjectType(repoPath);
+
+      expect(projectType).toBe('go');
+    });
+
+    it('returns unknown for unrecognized project type', () => {
+      const repoPath = path.join(tempDir, 'unknown-repo');
+      fs.mkdirSync(repoPath);
+      fs.writeFileSync(path.join(repoPath, 'README.md'), '# Unknown Project');
+
+      bulkInit = new BulkRepoInit(tempDir);
+      const projectType = bulkInit.detectProjectType(repoPath);
+
+      expect(projectType).toBe('unknown');
+    });
+  });
+
+  describe('test framework detection', () => {
+    it('infers vitest from vite.config', () => {
+      const repoPath = path.join(tempDir, 'vitest-repo');
+      fs.mkdirSync(repoPath);
+      fs.writeFileSync(path.join(repoPath, 'package.json'), '{"name": "vitest-repo"}');
+      fs.writeFileSync(path.join(repoPath, 'vite.config.js'), 'export default {}');
+
+      bulkInit = new BulkRepoInit(tempDir);
+      const framework = bulkInit.detectTestFramework(repoPath);
+
+      expect(framework).toBe('vitest');
+    });
+
+    it('infers vitest from vitest.config', () => {
+      const repoPath = path.join(tempDir, 'vitest-repo-2');
+      fs.mkdirSync(repoPath);
+      fs.writeFileSync(path.join(repoPath, 'package.json'), '{"name": "vitest-repo-2"}');
+      fs.writeFileSync(path.join(repoPath, 'vitest.config.js'), 'export default {}');
+
+      bulkInit = new BulkRepoInit(tempDir);
+      const framework = bulkInit.detectTestFramework(repoPath);
+
+      expect(framework).toBe('vitest');
+    });
+
+    it('infers jest from jest.config', () => {
+      const repoPath = path.join(tempDir, 'jest-repo');
+      fs.mkdirSync(repoPath);
+      fs.writeFileSync(path.join(repoPath, 'package.json'), '{"name": "jest-repo"}');
+      fs.writeFileSync(path.join(repoPath, 'jest.config.js'), 'module.exports = {}');
+
+      bulkInit = new BulkRepoInit(tempDir);
+      const framework = bulkInit.detectTestFramework(repoPath);
+
+      expect(framework).toBe('jest');
+    });
+
+    it('infers pytest from pytest.ini', () => {
+      const repoPath = path.join(tempDir, 'pytest-repo');
+      fs.mkdirSync(repoPath);
+      fs.writeFileSync(path.join(repoPath, 'pyproject.toml'), '[project]\nname = "pytest-repo"');
+      fs.writeFileSync(path.join(repoPath, 'pytest.ini'), '[pytest]\ntestpaths = tests');
+
+      bulkInit = new BulkRepoInit(tempDir);
+      const framework = bulkInit.detectTestFramework(repoPath);
+
+      expect(framework).toBe('pytest');
+    });
+
+    it('infers pytest from pyproject.toml with pytest config', () => {
+      const repoPath = path.join(tempDir, 'pytest-repo-2');
+      fs.mkdirSync(repoPath);
+      fs.writeFileSync(
+        path.join(repoPath, 'pyproject.toml'),
+        '[project]\nname = "pytest-repo-2"\n\n[tool.pytest.ini_options]\ntestpaths = ["tests"]'
+      );
+
+      bulkInit = new BulkRepoInit(tempDir);
+      const framework = bulkInit.detectTestFramework(repoPath);
+
+      expect(framework).toBe('pytest');
+    });
+
+    it('infers mocha from mocha config', () => {
+      const repoPath = path.join(tempDir, 'mocha-repo');
+      fs.mkdirSync(repoPath);
+      fs.writeFileSync(path.join(repoPath, 'package.json'), '{"name": "mocha-repo"}');
+      fs.writeFileSync(path.join(repoPath, '.mocharc.json'), '{}');
+
+      bulkInit = new BulkRepoInit(tempDir);
+      const framework = bulkInit.detectTestFramework(repoPath);
+
+      expect(framework).toBe('mocha');
+    });
+
+    it('infers test framework from package.json devDependencies', () => {
+      const repoPath = path.join(tempDir, 'jest-dep-repo');
+      fs.mkdirSync(repoPath);
+      fs.writeFileSync(
+        path.join(repoPath, 'package.json'),
+        JSON.stringify({
+          name: 'jest-dep-repo',
+          devDependencies: { jest: '^29.0.0' },
+        })
+      );
+
+      bulkInit = new BulkRepoInit(tempDir);
+      const framework = bulkInit.detectTestFramework(repoPath);
+
+      expect(framework).toBe('jest');
+    });
+
+    it('returns null for unknown test framework', () => {
+      const repoPath = path.join(tempDir, 'no-test-repo');
+      fs.mkdirSync(repoPath);
+      fs.writeFileSync(path.join(repoPath, 'package.json'), '{"name": "no-test-repo"}');
+
+      bulkInit = new BulkRepoInit(tempDir);
+      const framework = bulkInit.detectTestFramework(repoPath);
+
+      expect(framework).toBeNull();
+    });
+  });
+
+  describe('initialization', () => {
+    it('creates .tlc.json with inferred settings', () => {
+      const repoPath = path.join(tempDir, 'init-repo');
+      fs.mkdirSync(repoPath);
+      fs.writeFileSync(
+        path.join(repoPath, 'package.json'),
+        JSON.stringify({ name: 'init-repo' })
+      );
+      fs.writeFileSync(path.join(repoPath, 'jest.config.js'), 'module.exports = {}');
+
+      bulkInit = new BulkRepoInit(tempDir);
+      bulkInit.initializeRepo('init-repo');
+
+      const tlcConfigPath = path.join(repoPath, '.tlc.json');
+      expect(fs.existsSync(tlcConfigPath)).toBe(true);
+
+      const config = JSON.parse(fs.readFileSync(tlcConfigPath, 'utf-8'));
+      expect(config.project).toBe('init-repo');
+      expect(config.testFrameworks.primary).toBe('jest');
+    });
+
+    it('creates minimal .tlc.json for each repo', () => {
+      const repoPath = path.join(tempDir, 'minimal-repo');
+      fs.mkdirSync(repoPath);
+      fs.writeFileSync(path.join(repoPath, 'package.json'), '{"name": "minimal-repo"}');
+
+      bulkInit = new BulkRepoInit(tempDir);
+      bulkInit.initializeRepo('minimal-repo');
+
+      const tlcConfigPath = path.join(repoPath, '.tlc.json');
+      const config = JSON.parse(fs.readFileSync(tlcConfigPath, 'utf-8'));
+
+      // Should have minimal required fields
+      expect(config).toHaveProperty('project');
+      expect(config).toHaveProperty('testFrameworks');
+      expect(config).toHaveProperty('paths');
+    });
+
+    it('sets project name from package.json', () => {
+      const repoPath = path.join(tempDir, 'named-repo');
+      fs.mkdirSync(repoPath);
+      fs.writeFileSync(
+        path.join(repoPath, 'package.json'),
+        JSON.stringify({ name: '@scope/my-package' })
+      );
+
+      bulkInit = new BulkRepoInit(tempDir);
+      bulkInit.initializeRepo('named-repo');
+
+      const tlcConfigPath = path.join(repoPath, '.tlc.json');
+      const config = JSON.parse(fs.readFileSync(tlcConfigPath, 'utf-8'));
+
+      expect(config.project).toBe('@scope/my-package');
+    });
+  });
+
+  describe('bulk initialization', () => {
+    it('initializes multiple repos at once', () => {
+      // Create multiple repos
+      ['repo-a', 'repo-b', 'repo-c'].forEach(name => {
+        const repoPath = path.join(tempDir, name);
+        fs.mkdirSync(repoPath);
+        fs.writeFileSync(path.join(repoPath, 'package.json'), JSON.stringify({ name }));
+      });
+
+      bulkInit = new BulkRepoInit(tempDir);
+      const result = bulkInit.initializeAll();
+
+      expect(result.initialized).toBe(3);
+      expect(fs.existsSync(path.join(tempDir, 'repo-a', '.tlc.json'))).toBe(true);
+      expect(fs.existsSync(path.join(tempDir, 'repo-b', '.tlc.json'))).toBe(true);
+      expect(fs.existsSync(path.join(tempDir, 'repo-c', '.tlc.json'))).toBe(true);
+    });
+
+    it('handles mixed project types in workspace', () => {
+      // Create Node repo
+      const nodeRepo = path.join(tempDir, 'node-app');
+      fs.mkdirSync(nodeRepo);
+      fs.writeFileSync(path.join(nodeRepo, 'package.json'), '{"name": "node-app"}');
+
+      // Create Python repo
+      const pythonRepo = path.join(tempDir, 'python-app');
+      fs.mkdirSync(pythonRepo);
+      fs.writeFileSync(path.join(pythonRepo, 'pyproject.toml'), '[project]\nname = "python-app"');
+
+      // Create Go repo
+      const goRepo = path.join(tempDir, 'go-app');
+      fs.mkdirSync(goRepo);
+      fs.writeFileSync(path.join(goRepo, 'go.mod'), 'module example.com/go-app\n\ngo 1.21');
+
+      bulkInit = new BulkRepoInit(tempDir);
+      const result = bulkInit.initializeAll();
+
+      expect(result.initialized).toBe(3);
+
+      // Verify each has correct project type
+      const nodeConfig = JSON.parse(fs.readFileSync(path.join(nodeRepo, '.tlc.json'), 'utf-8'));
+      expect(nodeConfig.projectType).toBe('node');
+
+      const pythonConfig = JSON.parse(fs.readFileSync(path.join(pythonRepo, '.tlc.json'), 'utf-8'));
+      expect(pythonConfig.projectType).toBe('python');
+
+      const goConfig = JSON.parse(fs.readFileSync(path.join(goRepo, '.tlc.json'), 'utf-8'));
+      expect(goConfig.projectType).toBe('go');
+    });
+
+    it('reports summary (X initialized, Y failed)', () => {
+      // Create repos - 2 that can be initialized
+      ['good-repo-1', 'good-repo-2'].forEach(name => {
+        const repoPath = path.join(tempDir, name);
+        fs.mkdirSync(repoPath);
+        fs.writeFileSync(path.join(repoPath, 'package.json'), JSON.stringify({ name }));
+      });
+
+      // Create a repo that already has .tlc.json (should be skipped, not failed)
+      const existingRepo = path.join(tempDir, 'existing-repo');
+      fs.mkdirSync(existingRepo);
+      fs.writeFileSync(path.join(existingRepo, 'package.json'), '{"name": "existing-repo"}');
+      fs.writeFileSync(path.join(existingRepo, '.tlc.json'), '{}');
+
+      bulkInit = new BulkRepoInit(tempDir);
+      const result = bulkInit.initializeAll();
+
+      expect(result.initialized).toBe(2);
+      expect(result.skipped).toBe(1);
+      expect(result.failed).toBe(0);
+      expect(result.total).toBe(3);
+    });
+
+    it('reports failures per repo', () => {
+      // Create a repo with read-only .tlc.json location (simulate failure)
+      const repoPath = path.join(tempDir, 'fail-repo');
+      fs.mkdirSync(repoPath);
+      fs.writeFileSync(path.join(repoPath, 'package.json'), '{"name": "fail-repo"}');
+
+      // Create a directory named .tlc.json to cause write failure
+      fs.mkdirSync(path.join(repoPath, '.tlc.json'));
+
+      bulkInit = new BulkRepoInit(tempDir);
+      const result = bulkInit.initializeAll();
+
+      expect(result.failed).toBe(1);
+      expect(result.errors).toHaveLength(1);
+      expect(result.errors[0].repo).toBe('fail-repo');
+      expect(result.errors[0].error).toBeDefined();
+    });
+
+    it('provides list of initialized repos in result', () => {
+      ['repo-x', 'repo-y'].forEach(name => {
+        const repoPath = path.join(tempDir, name);
+        fs.mkdirSync(repoPath);
+        fs.writeFileSync(path.join(repoPath, 'package.json'), JSON.stringify({ name }));
+      });
+
+      bulkInit = new BulkRepoInit(tempDir);
+      const result = bulkInit.initializeAll();
+
+      expect(result.repos).toContain('repo-x');
+      expect(result.repos).toContain('repo-y');
+    });
+  });
+
+  describe('selective initialization', () => {
+    it('can initialize specific repos only', () => {
+      // Create multiple repos
+      ['repo-1', 'repo-2', 'repo-3'].forEach(name => {
+        const repoPath = path.join(tempDir, name);
+        fs.mkdirSync(repoPath);
+        fs.writeFileSync(path.join(repoPath, 'package.json'), JSON.stringify({ name }));
+      });
+
+      bulkInit = new BulkRepoInit(tempDir);
+      const result = bulkInit.initializeRepos(['repo-1', 'repo-3']);
+
+      expect(result.initialized).toBe(2);
+      expect(fs.existsSync(path.join(tempDir, 'repo-1', '.tlc.json'))).toBe(true);
+      expect(fs.existsSync(path.join(tempDir, 'repo-2', '.tlc.json'))).toBe(false);
+      expect(fs.existsSync(path.join(tempDir, 'repo-3', '.tlc.json'))).toBe(true);
+    });
+  });
+});

package/server/lib/candidates-tracker.js

@@ -0,0 +1,210 @@
+/**
+ * Candidates Tracker
+ * Maintain REFACTOR-CANDIDATES.md automatically
+ */
+
+const fs = require('fs');
+const path = require('path');
+
+class CandidatesTracker {
+  constructor(options = {}) {
+    this.filePath = options.filePath || '.planning/REFACTOR-CANDIDATES.md';
+    this.readFile = options.readFile || fs.promises.readFile;
+    this.writeFile = options.writeFile || fs.promises.writeFile;
+    this.mkdir = options.mkdir || fs.promises.mkdir;
+  }
+
+  /**
+   * Load existing candidates from file
+   */
+  async load() {
+    try {
+      const content = await this.readFile(this.filePath, 'utf-8');
+      return this.parse(content);
+    } catch {
+      return { high: [], medium: [], low: [], notes: '' };
+    }
+  }
+
+  /**
+   * Parse markdown content into structured data
+   */
+  parse(content) {
+    const result = { high: [], medium: [], low: [], notes: '' };
+    let currentSection = null;
+    let notesStart = -1;
+
+    const lines = content.split('\n');
+
+    for (let i = 0; i < lines.length; i++) {
+      const line = lines[i];
+
+      if (line.includes('High Priority') || line.includes('Impact 80+')) {
+        currentSection = 'high';
+      } else if (line.includes('Medium Priority') || line.includes('Impact 50-79')) {
+        currentSection = 'medium';
+      } else if (line.includes('Low Priority') || line.includes('Impact <50')) {
+        currentSection = 'low';
+      } else if (line.includes('## Notes') || line.includes('## Manual Notes')) {
+        notesStart = i;
+        break;
+      } else if (currentSection && line.startsWith('- [')) {
+        const candidate = this.parseLine(line);
+        if (candidate) {
+          result[currentSection].push(candidate);
+        }
+      }
+    }
+
+    // Preserve notes section
+    if (notesStart >= 0) {
+      result.notes = lines.slice(notesStart).join('\n');
+    }
+
+    return result;
+  }
+
+  /**
+   * Parse a single candidate line
+   */
+  parseLine(line) {
+    // Format: - [x] file.js:10-20 - Description (Impact: 85)
+    const match = line.match(/- \[([ x])\] (.+?):(\d+)(?:-(\d+))? - (.+?) \(Impact: (\d+)\)/);
+    if (!match) return null;
+
+    return {
+      completed: match[1] === 'x',
+      file: match[2],
+      startLine: parseInt(match[3], 10),
+      endLine: match[4] ? parseInt(match[4], 10) : parseInt(match[3], 10),
+      description: match[5],
+      impact: parseInt(match[6], 10),
+      key: `${match[2]}:${match[3]}`,
+    };
+  }
+
+  /**
+   * Add candidates from analysis
+   */
+  async add(candidates) {
+    const existing = await this.load();
+
+    for (const candidate of candidates) {
+      const tier = this.getTier(candidate.impact);
+      const key = `${candidate.file}:${candidate.startLine}`;
+
+      // Check for duplicate
+      const existingIndex = existing[tier].findIndex(c => c.key === key);
+
+      if (existingIndex >= 0) {
+        // Update impact score
+        existing[tier][existingIndex].impact = candidate.impact;
+        existing[tier][existingIndex].description = candidate.description;
+      } else {
+        // Add new
+        existing[tier].push({
+          ...candidate,
+          key,
+          completed: false,
+        });
+      }
+    }
+
+    // Re-sort by impact
+    for (const tier of ['high', 'medium', 'low']) {
+      existing[tier].sort((a, b) => b.impact - a.impact);
+    }
+
+    await this.save(existing);
+    return existing;
+  }
+
+  /**
+   * Mark a candidate as complete
+   */
+  async markComplete(file, line) {
+    const existing = await this.load();
+    const key = `${file}:${line}`;
+
+    for (const tier of ['high', 'medium', 'low']) {
+      const candidate = existing[tier].find(c => c.key === key);
+      if (candidate) {
+        candidate.completed = true;
+        break;
+      }
+    }
+
+    await this.save(existing);
+  }
+
+  /**
+   * Get priority tier from impact score
+   */
+  getTier(impact) {
+    if (impact >= 80) return 'high';
+    if (impact >= 50) return 'medium';
+    return 'low';
+  }
+
+  /**
+   * Save candidates to file
+   */
+  async save(data) {
+    const content = this.format(data);
+
+    // Ensure directory exists
+    const dir = path.dirname(this.filePath);
+    await this.mkdir(dir, { recursive: true });
+
+    await this.writeFile(this.filePath, content);
+  }
+
+  /**
+   * Format data as markdown
+   */
+  format(data) {
+    let md = '# Refactor Candidates\n\n';
+    md += '_Auto-generated by TLC. Run `/tlc:refactor` to process._\n\n';
+
+    md += '## High Priority (Impact 80+)\n\n';
+    for (const c of data.high) {
+      md += this.formatCandidate(c);
+    }
+    if (data.high.length === 0) md += '_None_\n';
+    md += '\n';
+
+    md += '## Medium Priority (Impact 50-79)\n\n';
+    for (const c of data.medium) {
+      md += this.formatCandidate(c);
+    }
+    if (data.medium.length === 0) md += '_None_\n';
+    md += '\n';
+
+    md += '## Low Priority (Impact <50)\n\n';
+    for (const c of data.low) {
+      md += this.formatCandidate(c);
+    }
+    if (data.low.length === 0) md += '_None_\n';
+    md += '\n';
+
+    // Preserve notes
+    if (data.notes) {
+      md += data.notes;
+    }
+
+    return md;
+  }
+
+  /**
+   * Format a single candidate as markdown line
+   */
+  formatCandidate(c) {
+    const checkbox = c.completed ? 'x' : ' ';
+    const lineRange = c.endLine && c.endLine !== c.startLine
+      ? `${c.startLine}-${c.endLine}`
+      : `${c.startLine}`;
+    return `- [${checkbox}] ${c.file}:${lineRange} - ${c.description} (Impact: ${c.impact})\n`;
+  }
+}
+
+module.exports = { CandidatesTracker };