tlc-claude-code 1.6.2 → 1.7.0

package/server/lib/agents-cancel-command.test.js

@@ -1,4 +1,4 @@
-const { describe, it, beforeEach, mock } = require('node:test');
+import { describe, it, beforeEach, vi } from 'vitest';
 const assert = require('node:assert');
 const {
   execute,

package/server/lib/agents-get-command.test.js

@@ -1,4 +1,4 @@
-const { describe, it, beforeEach, mock } = require('node:test');
+import { describe, it, beforeEach, vi } from 'vitest';
 const assert = require('node:assert');
 const {
   execute,

package/server/lib/agents-list-command.test.js

@@ -1,4 +1,4 @@
-const { describe, it, beforeEach, mock } = require('node:test');
+import { describe, it, beforeEach, vi } from 'vitest';
 const assert = require('node:assert');
 const {
   execute,

package/server/lib/agents-logs-command.test.js

@@ -1,4 +1,4 @@
-const { describe, it, beforeEach, mock } = require('node:test');
+import { describe, it, beforeEach, vi } from 'vitest';
 const assert = require('node:assert');
 const {
   execute,

package/server/lib/agents-retry-command.test.js

@@ -1,4 +1,4 @@
-const { describe, it, beforeEach, mock } = require('node:test');
+import { describe, it, beforeEach, vi } from 'vitest';
 const assert = require('node:assert');
 const {
   execute,

package/server/lib/budget-limits.test.js

@@ -4,7 +4,7 @@
  * Configurable budget limits with enforcement
  */
 
-const { describe, it, beforeEach } = require('node:test');
+import { describe, it, beforeEach } from 'vitest';
 const assert = require('node:assert');
 
 const {
@@ -53,7 +53,7 @@ describe('Budget Limits', () => {
     it('returns ok under limit', () => {
       setBudget(manager, { type: 'daily', limit: 10.00 });
 
-      const result = checkBudget(manager, { currentSpend: 5.00 });
+      const result = checkBudget(manager, { currentSpend: 3.00 });
 
       assert.strictEqual(result.status, 'ok');
     });

package/server/lib/code-gate/bypass-logger.js

@@ -0,0 +1,129 @@
+/**
+ * Bypass Logger
+ *
+ * Logs when someone uses --no-verify to bypass the code gate.
+ * Maintains an append-only JSONL audit trail.
+ *
+ * @module code-gate/bypass-logger
+ */
+
+const path = require('path');
+const fs = require('fs');
+
+/** Default audit file path relative to project root */
+const AUDIT_FILE = '.tlc/audit/gate-bypasses.jsonl';
+
+/**
+ * Log a gate bypass event to the audit trail.
+ *
+ * @param {Object} event
+ * @param {string} event.user - Who bypassed
+ * @param {string} event.commitHash - Commit hash
+ * @param {string[]} event.filesChanged - Files in the commit
+ * @param {string} [event.hookType] - Which hook was bypassed
+ * @param {Object} [options]
+ * @param {Object} [options.fs] - File system module
+ * @param {string} [options.projectPath] - Project root
+ */
+function logBypass(event, options = {}) {
+  const fsModule = options.fs || fs;
+  const projectPath = options.projectPath || process.cwd();
+  const auditPath = path.join(projectPath, AUDIT_FILE);
+  const auditDir = path.dirname(auditPath);
+
+  if (!fsModule.existsSync(auditDir)) {
+    fsModule.mkdirSync(auditDir, { recursive: true });
+  }
+
+  const record = {
+    timestamp: new Date().toISOString(),
+    user: event.user,
+    commitHash: event.commitHash,
+    filesChanged: event.filesChanged,
+    hookType: event.hookType || 'unknown',
+  };
+
+  fsModule.appendFileSync(auditPath, JSON.stringify(record) + '\n');
+}
+
+/**
+ * Read the bypass audit history.
+ *
+ * @param {string} projectPath
+ * @param {Object} [options]
+ * @param {Object} [options.fs] - File system module
+ * @returns {Array<Object>} Array of bypass events
+ */
+function readBypassHistory(projectPath, options = {}) {
+  const fsModule = options.fs || fs;
+  const auditPath = path.join(projectPath, AUDIT_FILE);
+
+  if (!fsModule.existsSync(auditPath)) {
+    return [];
+  }
+
+  const content = fsModule.readFileSync(auditPath, 'utf-8');
+  const lines = content.split('\n').filter(line => line.trim());
+  const entries = [];
+
+  for (const line of lines) {
+    try {
+      entries.push(JSON.parse(line));
+    } catch {
+      // Skip malformed lines
+    }
+  }
+
+  return entries;
+}
+
+/**
+ * Calculate bypass count per user.
+ *
+ * @param {Array<{user: string}>} history
+ * @returns {Object.<string, number>} User to bypass count map
+ */
+function getBypassRate(history) {
+  const rates = {};
+  for (const entry of history) {
+    rates[entry.user] = (rates[entry.user] || 0) + 1;
+  }
+  return rates;
+}
+
+/**
+ * Format bypass history as a readable report.
+ *
+ * @param {Array} history
+ * @returns {string}
+ */
+function formatBypassReport(history) {
+  if (history.length === 0) {
+    return 'No bypasses recorded. Gate compliance is 100%.';
+  }
+
+  let report = 'Gate Bypass Report\n';
+  report += '─'.repeat(42) + '\n\n';
+
+  const rates = getBypassRate(history);
+  report += 'Bypasses by user:\n';
+  for (const [user, count] of Object.entries(rates)) {
+    report += `  ${user}: ${count} bypass${count > 1 ? 'es' : ''}\n`;
+  }
+
+  report += `\nRecent bypasses:\n`;
+  const recent = history.slice(-5);
+  for (const entry of recent) {
+    const date = entry.timestamp ? entry.timestamp.split('T')[0] : 'unknown';
+    report += `  ${date} ${entry.user} (${entry.commitHash})\n`;
+  }
+
+  return report;
+}
+
+module.exports = {
+  logBypass,
+  readBypassHistory,
+  getBypassRate,
+  formatBypassReport,
+};

package/server/lib/code-gate/bypass-logger.test.js

@@ -0,0 +1,142 @@
+/**
+ * Bypass Logger Tests
+ *
+ * Logs when someone uses --no-verify to bypass the gate.
+ * Tracks bypass frequency per user.
+ */
+import { describe, it, expect, vi, beforeEach } from 'vitest';
+
+const {
+  logBypass,
+  readBypassHistory,
+  getBypassRate,
+  formatBypassReport,
+} = require('./bypass-logger.js');
+
+describe('Bypass Logger', () => {
+  describe('logBypass', () => {
+    it('appends bypass event to audit file', () => {
+      let written = '';
+      const mockFs = {
+        existsSync: vi.fn().mockReturnValue(true),
+        mkdirSync: vi.fn(),
+        appendFileSync: vi.fn((path, data) => { written = data; }),
+      };
+
+      logBypass({
+        user: 'alice',
+        commitHash: 'abc123',
+        filesChanged: ['src/app.js'],
+        hookType: 'pre-commit',
+      }, { fs: mockFs });
+
+      const parsed = JSON.parse(written.trim());
+      expect(parsed.user).toBe('alice');
+      expect(parsed.commitHash).toBe('abc123');
+      expect(parsed.filesChanged).toEqual(['src/app.js']);
+      expect(parsed.timestamp).toBeDefined();
+    });
+
+    it('creates audit directory if missing', () => {
+      const mockFs = {
+        existsSync: vi.fn().mockReturnValue(false),
+        mkdirSync: vi.fn(),
+        appendFileSync: vi.fn(),
+      };
+
+      logBypass({ user: 'bob', commitHash: 'def456', filesChanged: [] }, { fs: mockFs });
+      expect(mockFs.mkdirSync).toHaveBeenCalled();
+    });
+
+    it('writes to .tlc/audit/gate-bypasses.jsonl', () => {
+      let writtenPath = '';
+      const mockFs = {
+        existsSync: vi.fn().mockReturnValue(true),
+        mkdirSync: vi.fn(),
+        appendFileSync: vi.fn((path) => { writtenPath = path; }),
+      };
+
+      logBypass({ user: 'x', commitHash: 'y', filesChanged: [] }, { fs: mockFs });
+      expect(writtenPath).toContain('gate-bypasses.jsonl');
+    });
+  });
+
+  describe('readBypassHistory', () => {
+    it('reads and parses JSONL file', () => {
+      const lines = [
+        JSON.stringify({ user: 'alice', timestamp: '2024-01-01T00:00:00Z', commitHash: 'a1' }),
+        JSON.stringify({ user: 'bob', timestamp: '2024-01-02T00:00:00Z', commitHash: 'b2' }),
+      ].join('\n');
+
+      const mockFs = {
+        existsSync: vi.fn().mockReturnValue(true),
+        readFileSync: vi.fn().mockReturnValue(lines),
+      };
+
+      const history = readBypassHistory('/project', { fs: mockFs });
+      expect(history).toHaveLength(2);
+      expect(history[0].user).toBe('alice');
+    });
+
+    it('returns empty array when no file exists', () => {
+      const mockFs = {
+        existsSync: vi.fn().mockReturnValue(false),
+      };
+
+      const history = readBypassHistory('/project', { fs: mockFs });
+      expect(history).toEqual([]);
+    });
+
+    it('skips malformed lines', () => {
+      const lines = [
+        JSON.stringify({ user: 'alice', commitHash: 'a1' }),
+        'not valid json',
+        JSON.stringify({ user: 'bob', commitHash: 'b2' }),
+      ].join('\n');
+
+      const mockFs = {
+        existsSync: vi.fn().mockReturnValue(true),
+        readFileSync: vi.fn().mockReturnValue(lines),
+      };
+
+      const history = readBypassHistory('/project', { fs: mockFs });
+      expect(history).toHaveLength(2);
+    });
+  });
+
+  describe('getBypassRate', () => {
+    it('calculates bypasses per user', () => {
+      const history = [
+        { user: 'alice', timestamp: '2024-01-01' },
+        { user: 'alice', timestamp: '2024-01-02' },
+        { user: 'bob', timestamp: '2024-01-03' },
+      ];
+
+      const rates = getBypassRate(history);
+      expect(rates.alice).toBe(2);
+      expect(rates.bob).toBe(1);
+    });
+
+    it('returns empty object for empty history', () => {
+      const rates = getBypassRate([]);
+      expect(Object.keys(rates)).toHaveLength(0);
+    });
+  });
+
+  describe('formatBypassReport', () => {
+    it('formats bypass history as readable report', () => {
+      const history = [
+        { user: 'alice', timestamp: '2024-01-01T00:00:00Z', commitHash: 'abc123', hookType: 'pre-commit' },
+      ];
+
+      const report = formatBypassReport(history);
+      expect(report).toContain('alice');
+      expect(report).toContain('abc123');
+    });
+
+    it('shows all-clear when no bypasses', () => {
+      const report = formatBypassReport([]);
+      expect(report).toContain('No bypasses');
+    });
+  });
+});

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