tlc-claude-code 1.6.2 → 1.7.0

package/server/lib/code-gate/gate-command.test.js

@@ -0,0 +1,111 @@
+/**
+ * Gate Command Tests
+ *
+ * /tlc:gate command to install, configure, and run the code gate.
+ */
+import { describe, it, expect, vi } from 'vitest';
+
+const {
+  createGateCommand,
+  parseGateArgs,
+} = require('./gate-command.js');
+
+describe('Gate Command', () => {
+  describe('parseGateArgs', () => {
+    it('parses install subcommand', () => {
+      const args = parseGateArgs('install');
+      expect(args.subcommand).toBe('install');
+    });
+
+    it('parses check subcommand', () => {
+      const args = parseGateArgs('check');
+      expect(args.subcommand).toBe('check');
+    });
+
+    it('parses status subcommand', () => {
+      const args = parseGateArgs('status');
+      expect(args.subcommand).toBe('status');
+    });
+
+    it('defaults to check when no subcommand', () => {
+      const args = parseGateArgs('');
+      expect(args.subcommand).toBe('check');
+    });
+
+    it('parses config subcommand', () => {
+      const args = parseGateArgs('config');
+      expect(args.subcommand).toBe('config');
+    });
+  });
+
+  describe('createGateCommand', () => {
+    it('creates command with injectable dependencies', () => {
+      const cmd = createGateCommand({ projectPath: '/test' });
+      expect(cmd).toBeDefined();
+      expect(cmd.execute).toBeTypeOf('function');
+    });
+
+    it('install subcommand calls hooks installer', async () => {
+      const mockInstallHooks = vi.fn().mockResolvedValue({ installed: ['pre-commit', 'pre-push'] });
+      const cmd = createGateCommand({
+        projectPath: '/test',
+        installHooks: mockInstallHooks,
+      });
+
+      const result = await cmd.execute('install');
+      expect(mockInstallHooks).toHaveBeenCalled();
+      expect(result.success).toBe(true);
+    });
+
+    it('check subcommand runs gate engine', async () => {
+      const mockRunGate = vi.fn().mockResolvedValue({
+        passed: true,
+        findings: [],
+        summary: { total: 0, block: 0, warn: 0, info: 0 },
+      });
+      const mockGetStagedFiles = vi.fn().mockResolvedValue([]);
+      const cmd = createGateCommand({
+        projectPath: '/test',
+        runGate: mockRunGate,
+        getStagedFiles: mockGetStagedFiles,
+      });
+
+      const result = await cmd.execute('check');
+      expect(result.passed).toBe(true);
+    });
+
+    it('status subcommand returns gate configuration', async () => {
+      const mockLoadConfig = vi.fn().mockReturnValue({
+        enabled: true,
+        strictness: 'strict',
+        preCommit: true,
+        prePush: true,
+      });
+      const mockIsInstalled = vi.fn().mockReturnValue(true);
+      const cmd = createGateCommand({
+        projectPath: '/test',
+        loadConfig: mockLoadConfig,
+        isHookInstalled: mockIsInstalled,
+      });
+
+      const result = await cmd.execute('status');
+      expect(result.config).toBeDefined();
+      expect(result.config.strictness).toBe('strict');
+      expect(result.hooks).toBeDefined();
+    });
+
+    it('config subcommand updates .tlc.json', async () => {
+      let savedConfig = null;
+      const mockSaveConfig = vi.fn((config) => { savedConfig = config; });
+      const cmd = createGateCommand({
+        projectPath: '/test',
+        saveConfig: mockSaveConfig,
+        loadConfig: vi.fn().mockReturnValue({ enabled: true, strictness: 'strict' }),
+      });
+
+      const result = await cmd.execute('config', { strictness: 'standard' });
+      expect(mockSaveConfig).toHaveBeenCalled();
+      expect(result.success).toBe(true);
+    });
+  });
+});

package/server/lib/code-gate/gate-config.js

@@ -0,0 +1,163 @@
+/**
+ * Gate Configuration
+ *
+ * Reads gate config from .tlc.json, supports rule enable/disable,
+ * severity overrides, ignore patterns, and strictness levels.
+ *
+ * @module code-gate/gate-config
+ */
+
+const path = require('path');
+const fs = require('fs');
+
+/** Strictness levels control default severity thresholds */
+const STRICTNESS = {
+  RELAXED: 'relaxed',
+  STANDARD: 'standard',
+  STRICT: 'strict',
+};
+
+/**
+ * Return the default gate configuration.
+ * Defaults to strict mode — block on all high/critical findings.
+ *
+ * @returns {Object} Default gate config
+ */
+function getDefaultGateConfig() {
+  return {
+    enabled: true,
+    strictness: STRICTNESS.STRICT,
+    preCommit: true,
+    prePush: true,
+    rules: {},
+    ignore: ['*.md', '*.json', '*.lock', '*.yml', '*.yaml'],
+  };
+}
+
+/**
+ * Load gate configuration from .tlc.json in the given project path.
+ * Falls back to defaults if no config exists or if parsing fails.
+ *
+ * @param {string} projectPath - Path to project root
+ * @param {Object} [options] - Options with injectable dependencies
+ * @param {Object} [options.fs] - File system module (for testing)
+ * @returns {Object} Resolved gate configuration
+ */
+function loadGateConfig(projectPath, options = {}) {
+  const fsModule = options.fs || fs;
+  const defaults = getDefaultGateConfig();
+  const configPath = path.join(projectPath, '.tlc.json');
+
+  if (!fsModule.existsSync(configPath)) {
+    return defaults;
+  }
+
+  try {
+    const raw = fsModule.readFileSync(configPath, 'utf-8');
+    const parsed = JSON.parse(raw);
+    const gateSection = parsed.gate || {};
+    return mergeGateConfig(defaults, gateSection);
+  } catch {
+    return defaults;
+  }
+}
+
+/**
+ * Deep-merge user gate config over defaults.
+ * Rules are merged as an override map. Ignore arrays are concatenated
+ * with deduplication.
+ *
+ * @param {Object} defaults - Default gate config
+ * @param {Object} userConfig - User overrides from .tlc.json
+ * @returns {Object} Merged config
+ */
+function mergeGateConfig(defaults, userConfig) {
+  const merged = { ...defaults };
+
+  // Simple scalar overrides
+  if (userConfig.enabled !== undefined) merged.enabled = userConfig.enabled;
+  if (userConfig.strictness !== undefined) merged.strictness = userConfig.strictness;
+  if (userConfig.preCommit !== undefined) merged.preCommit = userConfig.preCommit;
+  if (userConfig.prePush !== undefined) merged.prePush = userConfig.prePush;
+
+  // Merge rules as override map
+  if (userConfig.rules) {
+    merged.rules = { ...defaults.rules, ...userConfig.rules };
+  }
+
+  // Concatenate ignore arrays, deduplicate
+  if (userConfig.ignore) {
+    const combined = [...defaults.ignore, ...userConfig.ignore];
+    merged.ignore = [...new Set(combined)];
+  }
+
+  return merged;
+}
+
+/**
+ * Resolve the effective severity for a rule, considering user overrides.
+ *
+ * @param {string} ruleId - Rule identifier
+ * @param {string} defaultSeverity - The rule's built-in severity
+ * @param {Object} config - Gate config with rules overrides
+ * @returns {string|false} Effective severity, or false if rule is disabled
+ */
+function resolveRuleSeverity(ruleId, defaultSeverity, config) {
+  if (config.rules && config.rules[ruleId] !== undefined) {
+    return config.rules[ruleId];
+  }
+  return defaultSeverity;
+}
+
+/**
+ * Check if a file should be ignored based on config ignore patterns.
+ * Supports simple glob matching: *.ext and dir/* patterns.
+ *
+ * @param {string} filePath - File path to check
+ * @param {Object} config - Gate config with ignore array
+ * @returns {boolean} True if file should be ignored
+ */
+function shouldIgnoreFile(filePath, config) {
+  const patterns = config.ignore || [];
+  for (const pattern of patterns) {
+    if (matchPattern(filePath, pattern)) {
+      return true;
+    }
+  }
+  return false;
+}
+
+/**
+ * Simple glob pattern matcher.
+ *
+ * @param {string} filePath
+ * @param {string} pattern
+ * @returns {boolean}
+ */
+function matchPattern(filePath, pattern) {
+  // *.ext — match extension anywhere
+  if (pattern.startsWith('*.')) {
+    return filePath.endsWith(pattern.slice(1));
+  }
+  // **/*.ext — match extension in any nested path
+  if (pattern.startsWith('**/')) {
+    const sub = pattern.slice(3);
+    return matchPattern(filePath, sub) || matchPattern(path.basename(filePath), sub);
+  }
+  // dir/* — match files starting with dir/
+  if (pattern.endsWith('/*')) {
+    const dir = pattern.slice(0, -2);
+    return filePath.startsWith(dir + '/');
+  }
+  // Exact match
+  return filePath === pattern;
+}
+
+module.exports = {
+  loadGateConfig,
+  getDefaultGateConfig,
+  mergeGateConfig,
+  resolveRuleSeverity,
+  shouldIgnoreFile,
+  STRICTNESS,
+};

package/server/lib/code-gate/gate-config.test.js

@@ -0,0 +1,181 @@
+/**
+ * Gate Configuration Tests
+ *
+ * Reads gate config from .tlc.json, supports rule enable/disable,
+ * severity overrides, ignore patterns, and strictness levels.
+ */
+import { describe, it, expect, vi } from 'vitest';
+
+const {
+  loadGateConfig,
+  getDefaultGateConfig,
+  mergeGateConfig,
+  resolveRuleSeverity,
+  shouldIgnoreFile,
+  STRICTNESS,
+} = require('./gate-config.js');
+
+describe('Gate Configuration', () => {
+  describe('STRICTNESS', () => {
+    it('defines all strictness levels', () => {
+      expect(STRICTNESS.RELAXED).toBe('relaxed');
+      expect(STRICTNESS.STANDARD).toBe('standard');
+      expect(STRICTNESS.STRICT).toBe('strict');
+    });
+  });
+
+  describe('getDefaultGateConfig', () => {
+    it('returns default config with strict mode', () => {
+      const config = getDefaultGateConfig();
+      expect(config.enabled).toBe(true);
+      expect(config.strictness).toBe('strict');
+      expect(config.preCommit).toBe(true);
+      expect(config.prePush).toBe(true);
+    });
+
+    it('includes default ignore patterns', () => {
+      const config = getDefaultGateConfig();
+      expect(config.ignore).toContain('*.md');
+      expect(config.ignore).toContain('*.json');
+    });
+
+    it('has empty rules override by default', () => {
+      const config = getDefaultGateConfig();
+      expect(config.rules).toEqual({});
+    });
+  });
+
+  describe('loadGateConfig', () => {
+    it('returns defaults when no .tlc.json exists', () => {
+      const mockFs = {
+        existsSync: vi.fn().mockReturnValue(false),
+      };
+      const config = loadGateConfig('/project', { fs: mockFs });
+      expect(config.enabled).toBe(true);
+      expect(config.strictness).toBe('strict');
+    });
+
+    it('reads gate section from .tlc.json', () => {
+      const tlcJson = {
+        gate: {
+          enabled: true,
+          strictness: 'standard',
+          rules: { 'no-hardcoded-urls': 'warn' },
+        },
+      };
+      const mockFs = {
+        existsSync: vi.fn().mockReturnValue(true),
+        readFileSync: vi.fn().mockReturnValue(JSON.stringify(tlcJson)),
+      };
+      const config = loadGateConfig('/project', { fs: mockFs });
+      expect(config.strictness).toBe('standard');
+      expect(config.rules['no-hardcoded-urls']).toBe('warn');
+    });
+
+    it('merges user config with defaults', () => {
+      const tlcJson = {
+        gate: {
+          strictness: 'relaxed',
+        },
+      };
+      const mockFs = {
+        existsSync: vi.fn().mockReturnValue(true),
+        readFileSync: vi.fn().mockReturnValue(JSON.stringify(tlcJson)),
+      };
+      const config = loadGateConfig('/project', { fs: mockFs });
+      // User override
+      expect(config.strictness).toBe('relaxed');
+      // Defaults preserved
+      expect(config.enabled).toBe(true);
+      expect(config.preCommit).toBe(true);
+    });
+
+    it('handles malformed .tlc.json gracefully', () => {
+      const mockFs = {
+        existsSync: vi.fn().mockReturnValue(true),
+        readFileSync: vi.fn().mockReturnValue('not valid json{{{'),
+      };
+      const config = loadGateConfig('/project', { fs: mockFs });
+      expect(config.enabled).toBe(true);
+      expect(config.strictness).toBe('strict');
+    });
+
+    it('handles missing gate section gracefully', () => {
+      const mockFs = {
+        existsSync: vi.fn().mockReturnValue(true),
+        readFileSync: vi.fn().mockReturnValue(JSON.stringify({ project: 'test' })),
+      };
+      const config = loadGateConfig('/project', { fs: mockFs });
+      expect(config.strictness).toBe('strict');
+    });
+  });
+
+  describe('mergeGateConfig', () => {
+    it('overrides defaults with user values', () => {
+      const defaults = getDefaultGateConfig();
+      const userConfig = { strictness: 'relaxed', prePush: false };
+      const merged = mergeGateConfig(defaults, userConfig);
+      expect(merged.strictness).toBe('relaxed');
+      expect(merged.prePush).toBe(false);
+      expect(merged.preCommit).toBe(true);
+    });
+
+    it('merges rules as override map', () => {
+      const defaults = getDefaultGateConfig();
+      const userConfig = { rules: { 'no-eval': 'warn', 'no-hardcoded-urls': 'info' } };
+      const merged = mergeGateConfig(defaults, userConfig);
+      expect(merged.rules['no-eval']).toBe('warn');
+      expect(merged.rules['no-hardcoded-urls']).toBe('info');
+    });
+
+    it('concatenates ignore arrays', () => {
+      const defaults = getDefaultGateConfig();
+      const userConfig = { ignore: ['migrations/*', 'generated/*'] };
+      const merged = mergeGateConfig(defaults, userConfig);
+      expect(merged.ignore).toContain('*.md');
+      expect(merged.ignore).toContain('migrations/*');
+      expect(merged.ignore).toContain('generated/*');
+    });
+  });
+
+  describe('resolveRuleSeverity', () => {
+    it('returns rule default when no override', () => {
+      const config = getDefaultGateConfig();
+      expect(resolveRuleSeverity('no-eval', 'block', config)).toBe('block');
+    });
+
+    it('returns override when configured', () => {
+      const config = { ...getDefaultGateConfig(), rules: { 'no-eval': 'warn' } };
+      expect(resolveRuleSeverity('no-eval', 'block', config)).toBe('warn');
+    });
+
+    it('disables rule when override is false', () => {
+      const config = { ...getDefaultGateConfig(), rules: { 'no-eval': false } };
+      expect(resolveRuleSeverity('no-eval', 'block', config)).toBe(false);
+    });
+  });
+
+  describe('shouldIgnoreFile', () => {
+    it('ignores files matching patterns', () => {
+      const config = { ignore: ['*.md', 'dist/*'] };
+      expect(shouldIgnoreFile('README.md', config)).toBe(true);
+      expect(shouldIgnoreFile('dist/bundle.js', config)).toBe(true);
+    });
+
+    it('does not ignore non-matching files', () => {
+      const config = { ignore: ['*.md'] };
+      expect(shouldIgnoreFile('src/app.js', config)).toBe(false);
+    });
+
+    it('handles empty ignore list', () => {
+      const config = { ignore: [] };
+      expect(shouldIgnoreFile('anything.js', config)).toBe(false);
+    });
+
+    it('matches nested glob patterns', () => {
+      const config = { ignore: ['**/*.test.js'] };
+      expect(shouldIgnoreFile('src/deep/file.test.js', config)).toBe(true);
+      expect(shouldIgnoreFile('src/deep/file.js', config)).toBe(false);
+    });
+  });
+});

package/server/lib/code-gate/gate-engine.js

@@ -0,0 +1,193 @@
+/**
+ * Code Gate Engine
+ *
+ * Core engine that accepts changed files and runs configurable rule sets
+ * against each file, returning pass/fail with detailed findings per file.
+ *
+ * @module code-gate/gate-engine
+ */
+
+const path = require('path');
+
+/**
+ * Severity levels for gate findings.
+ * - block: Commit/push is rejected
+ * - warn: Warning shown but allowed through
+ * - info: Informational, no action needed
+ */
+const SEVERITY = {
+  BLOCK: 'block',
+  WARN: 'warn',
+  INFO: 'info',
+};
+
+/** Deduction points per severity level for scoring */
+const SCORE_DEDUCTIONS = {
+  [SEVERITY.BLOCK]: 25,
+  [SEVERITY.WARN]: 10,
+  [SEVERITY.INFO]: 2,
+};
+
+/**
+ * Create a gate engine instance with configurable rules and options.
+ *
+ * @param {Object} options - Engine options
+ * @param {Array<{id: string, check: Function}>} [options.rules] - Rule set to run
+ * @param {string[]} [options.ignore] - Glob patterns for files to skip
+ * @returns {{ rules: Array, options: Object }}
+ */
+function createGateEngine(options = {}) {
+  return {
+    rules: options.rules || [],
+    options: {
+      ignore: options.ignore || [],
+    },
+  };
+}
+
+/**
+ * Run all configured rules against a set of changed files.
+ *
+ * @param {{ rules: Array, options: Object }} engine - Gate engine instance
+ * @param {Array<{path: string, content: string}>} files - Changed files to check
+ * @returns {Promise<{passed: boolean, findings: Array, summary: Object, duration: number}>}
+ */
+async function runGate(engine, files) {
+  const start = Date.now();
+  const findings = [];
+
+  for (const file of files) {
+    if (shouldIgnore(file.path, engine.options.ignore)) {
+      continue;
+    }
+
+    for (const rule of engine.rules) {
+      try {
+        const ruleFindings = rule.check(file.path, file.content);
+        for (const finding of ruleFindings) {
+          findings.push({ ...finding, file: file.path });
+        }
+      } catch (err) {
+        findings.push({
+          severity: SEVERITY.WARN,
+          rule: rule.id,
+          file: file.path,
+          message: `Rule error: ${err.message}`,
+          fix: 'Check rule configuration',
+        });
+      }
+    }
+  }
+
+  const summary = buildSummary(findings);
+  const passed = summary.block === 0;
+
+  return {
+    passed,
+    findings,
+    summary,
+    duration: Date.now() - start,
+  };
+}
+
+/**
+ * Group findings by file path for reporting.
+ *
+ * @param {Array} findings - Array of finding objects
+ * @returns {Object.<string, Array>} Findings grouped by file
+ */
+function aggregateFindings(findings) {
+  const grouped = {};
+  for (const finding of findings) {
+    const key = finding.file;
+    if (!grouped[key]) {
+      grouped[key] = [];
+    }
+    grouped[key].push(finding);
+  }
+  return grouped;
+}
+
+/**
+ * Calculate a 0-100 quality score from findings.
+ * Starts at 100, deducts per severity. Floors at 0.
+ *
+ * @param {Array<{severity: string}>} findings - Finding objects with severity
+ * @returns {number} Score from 0 to 100
+ */
+function calculateScore(findings) {
+  let score = 100;
+  for (const finding of findings) {
+    const deduction = SCORE_DEDUCTIONS[finding.severity] || 0;
+    score -= deduction;
+  }
+  return Math.max(0, score);
+}
+
+/**
+ * Build summary counts from findings array.
+ *
+ * @param {Array<{severity: string}>} findings
+ * @returns {{ total: number, block: number, warn: number, info: number }}
+ */
+function buildSummary(findings) {
+  const summary = { total: findings.length, block: 0, warn: 0, info: 0 };
+  for (const finding of findings) {
+    if (summary[finding.severity] !== undefined) {
+      summary[finding.severity]++;
+    }
+  }
+  return summary;
+}
+
+/**
+ * Check if a file path matches any ignore pattern.
+ * Supports simple glob matching: *.ext and dir/* patterns.
+ *
+ * @param {string} filePath - File path to check
+ * @param {string[]} patterns - Glob patterns
+ * @returns {boolean} True if file should be ignored
+ */
+function shouldIgnore(filePath, patterns) {
+  for (const pattern of patterns) {
+    if (matchGlob(filePath, pattern)) {
+      return true;
+    }
+  }
+  return false;
+}
+
+/**
+ * Simple glob matcher for common patterns.
+ *
+ * @param {string} filePath
+ * @param {string} pattern
+ * @returns {boolean}
+ */
+function matchGlob(filePath, pattern) {
+  // *.ext — match extension anywhere
+  if (pattern.startsWith('*.')) {
+    const ext = pattern.slice(1);
+    return filePath.endsWith(ext);
+  }
+  // **/*.ext — match extension in any directory
+  if (pattern.startsWith('**/')) {
+    const sub = pattern.slice(3);
+    return matchGlob(filePath, sub) || matchGlob(path.basename(filePath), sub);
+  }
+  // dir/* — match files in directory
+  if (pattern.endsWith('/*')) {
+    const dir = pattern.slice(0, -2);
+    return filePath.startsWith(dir + '/') || filePath.startsWith(dir + path.sep);
+  }
+  // Exact match
+  return filePath === pattern;
+}
+
+module.exports = {
+  createGateEngine,
+  runGate,
+  aggregateFindings,
+  calculateScore,
+  SEVERITY,
+};