tlc-claude-code 1.6.4 → 1.7.0

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

@@ -0,0 +1,114 @@
+/**
+ * Gate Command
+ *
+ * /tlc:gate command to install, configure, and run the code gate.
+ * Subcommands: install, check, status, config
+ *
+ * @module code-gate/gate-command
+ */
+
+/**
+ * Parse gate command arguments into structured options.
+ *
+ * @param {string} args - Raw argument string
+ * @returns {{ subcommand: string }}
+ */
+function parseGateArgs(args) {
+  const trimmed = (args || '').trim();
+  const subcommand = trimmed.split(/\s+/)[0] || 'check';
+
+  const valid = ['install', 'check', 'status', 'config'];
+  return {
+    subcommand: valid.includes(subcommand) ? subcommand : 'check',
+  };
+}
+
+/**
+ * Create a gate command with injectable dependencies.
+ * This allows testing without real file system or git operations.
+ *
+ * @param {Object} deps - Dependencies
+ * @param {string} deps.projectPath - Project root path
+ * @param {Function} [deps.installHooks] - Hook installer function
+ * @param {Function} [deps.runGate] - Gate engine runner function
+ * @param {Function} [deps.getStagedFiles] - Get staged files function
+ * @param {Function} [deps.loadConfig] - Config loader function
+ * @param {Function} [deps.saveConfig] - Config saver function
+ * @param {Function} [deps.isHookInstalled] - Hook check function
+ * @returns {{ execute: Function }}
+ */
+function createGateCommand(deps) {
+  const {
+    projectPath,
+    installHooks,
+    runGate,
+    getStagedFiles,
+    loadConfig,
+    saveConfig,
+    isHookInstalled,
+  } = deps;
+
+  return {
+    /**
+     * Execute a gate subcommand.
+     *
+     * @param {string} subcommand - install|check|status|config
+     * @param {Object} [options] - Subcommand-specific options
+     * @returns {Promise<Object>} Subcommand result
+     */
+    async execute(subcommand, options = {}) {
+      switch (subcommand) {
+        case 'install':
+          return handleInstall();
+        case 'check':
+          return handleCheck();
+        case 'status':
+          return handleStatus();
+        case 'config':
+          return handleConfig(options);
+        default:
+          return { success: false, error: `Unknown subcommand: ${subcommand}` };
+      }
+    },
+  };
+
+  async function handleInstall() {
+    if (!installHooks) {
+      return { success: false, error: 'Hook installer not available' };
+    }
+    const result = await installHooks(projectPath);
+    return { success: true, installed: result.installed };
+  }
+
+  async function handleCheck() {
+    if (!runGate) {
+      return { success: false, error: 'Gate engine not available' };
+    }
+    const files = getStagedFiles ? await getStagedFiles() : [];
+    return await runGate(files);
+  }
+
+  async function handleStatus() {
+    const config = loadConfig ? loadConfig(projectPath) : {};
+    const hooks = {
+      'pre-commit': isHookInstalled ? isHookInstalled(projectPath, 'pre-commit') : false,
+      'pre-push': isHookInstalled ? isHookInstalled(projectPath, 'pre-push') : false,
+    };
+    return { config, hooks };
+  }
+
+  async function handleConfig(updates) {
+    if (!saveConfig) {
+      return { success: false, error: 'Config saver not available' };
+    }
+    const current = loadConfig ? loadConfig(projectPath) : {};
+    const merged = { ...current, ...updates };
+    saveConfig(merged);
+    return { success: true, config: merged };
+  }
+}
+
+module.exports = {
+  createGateCommand,
+  parseGateArgs,
+};

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);
+    });
+  });
+});