tlc-claude-code 0.9.7 → 1.0.0

package/server/lib/export-command.test.js

@@ -0,0 +1,358 @@
+import { describe, it, expect } from 'vitest';
+import {
+  parseExportArgs,
+  loadProjectConfig,
+  formatToolList,
+  formatDetectionResult,
+  formatExportSummary,
+  executeExportCommand,
+  createExportCommand,
+} from './export-command.js';
+import { SUPPORTED_TOOLS } from './tool-rules.js';
+import { AI_TOOLS } from './tool-detector.js';
+
+describe('export-command', () => {
+  describe('parseExportArgs', () => {
+    it('returns defaults for empty args', () => {
+      const options = parseExportArgs('');
+
+      expect(options.tools).toEqual([]);
+      expect(options.projectName).toBeNull();
+      expect(options.testFramework).toBeNull();
+      expect(options.output).toBeNull();
+      expect(options.dryRun).toBe(false);
+      expect(options.detect).toBe(false);
+      expect(options.list).toBe(false);
+    });
+
+    it('parses --all flag', () => {
+      const options = parseExportArgs('--all');
+      expect(options.tools.length).toBe(9);
+    });
+
+    it('parses all as action', () => {
+      const options = parseExportArgs('all');
+      expect(options.tools.length).toBe(9);
+    });
+
+    it('parses --tool flag', () => {
+      const options = parseExportArgs('--tool cursor');
+      expect(options.tools).toContain('cursor');
+    });
+
+    it('parses multiple --tool flags', () => {
+      const options = parseExportArgs('--tool cursor --tool copilot');
+
+      expect(options.tools).toContain('cursor');
+      expect(options.tools).toContain('copilot');
+    });
+
+    it('parses direct tool name', () => {
+      const options = parseExportArgs('cursor');
+      expect(options.tools).toContain('cursor');
+    });
+
+    it('parses --project flag', () => {
+      const options = parseExportArgs('--project MyApp');
+      expect(options.projectName).toBe('MyApp');
+    });
+
+    it('parses --framework flag', () => {
+      const options = parseExportArgs('--framework jest');
+      expect(options.testFramework).toBe('jest');
+    });
+
+    it('parses --output flag', () => {
+      const options = parseExportArgs('--output /tmp/output');
+      expect(options.output).toBe('/tmp/output');
+    });
+
+    it('parses --dry-run flag', () => {
+      const options = parseExportArgs('--dry-run');
+      expect(options.dryRun).toBe(true);
+    });
+
+    it('parses --detect flag', () => {
+      const options = parseExportArgs('--detect');
+      expect(options.detect).toBe(true);
+    });
+
+    it('parses --list flag', () => {
+      const options = parseExportArgs('--list');
+      expect(options.list).toBe(true);
+    });
+
+    it('parses multiple flags together', () => {
+      const options = parseExportArgs('cursor --project Test --dry-run');
+
+      expect(options.tools).toContain('cursor');
+      expect(options.projectName).toBe('Test');
+      expect(options.dryRun).toBe(true);
+    });
+  });
+
+  describe('loadProjectConfig', () => {
+    it('returns defaults for non-existent directory', () => {
+      const config = loadProjectConfig('/nonexistent/path');
+
+      expect(config.projectName).toBe('Project');
+      expect(config.testFramework).toBe('vitest');
+    });
+  });
+
+  describe('formatToolList', () => {
+    it('generates tool list markdown', () => {
+      const output = formatToolList();
+
+      expect(output).toContain('# Supported AI Tools');
+      expect(output).toContain('| Tool | File Path |');
+    });
+
+    it('includes all tools', () => {
+      const output = formatToolList();
+
+      expect(output).toContain('Cursor');
+      expect(output).toContain('Copilot');
+      expect(output).toContain('Aider');
+      expect(output).toContain('AGENTS.md');
+    });
+
+    it('includes file paths', () => {
+      const output = formatToolList();
+
+      expect(output).toContain('.cursor/rules/tlc.mdc');
+      expect(output).toContain('.github/copilot-instructions.md');
+      expect(output).toContain('.aider.conf.yml');
+    });
+
+    it('includes usage examples', () => {
+      const output = formatToolList();
+
+      expect(output).toContain('Usage');
+      expect(output).toContain('/tlc:export all');
+      expect(output).toContain('/tlc:export cursor');
+      expect(output).toContain('--detect');
+    });
+  });
+
+  describe('formatDetectionResult', () => {
+    it('formats unknown detection', () => {
+      const detection = {
+        primaryTool: AI_TOOLS.UNKNOWN,
+        confidence: 0,
+        allDetected: [],
+        sources: { environment: [], process: [], configFiles: [] },
+      };
+
+      const output = formatDetectionResult(detection);
+
+      expect(output).toContain('AI Tool Detection');
+      expect(output).toContain('No AI tool detected');
+    });
+
+    it('formats detected tool', () => {
+      const detection = {
+        primaryTool: AI_TOOLS.CURSOR,
+        confidence: 75,
+        allDetected: [{ tool: AI_TOOLS.CURSOR, confidence: 75 }],
+        sources: {
+          environment: [AI_TOOLS.CURSOR],
+          process: [AI_TOOLS.CURSOR],
+          configFiles: [],
+        },
+      };
+
+      const output = formatDetectionResult(detection);
+
+      expect(output).toContain('Cursor');
+      expect(output).toContain('75%');
+      expect(output).toContain('Detection Sources');
+    });
+
+    it('formats multiple detected tools', () => {
+      const detection = {
+        primaryTool: AI_TOOLS.CURSOR,
+        confidence: 75,
+        allDetected: [
+          { tool: AI_TOOLS.CURSOR, confidence: 75 },
+          { tool: AI_TOOLS.COPILOT, confidence: 40 },
+        ],
+        sources: {
+          environment: [AI_TOOLS.CURSOR, AI_TOOLS.COPILOT],
+          process: [AI_TOOLS.CURSOR],
+          configFiles: [],
+        },
+      };
+
+      const output = formatDetectionResult(detection);
+
+      expect(output).toContain('All Detected Tools');
+      expect(output).toContain('Cursor');
+      expect(output).toContain('GitHub Copilot');
+    });
+  });
+
+  describe('formatExportSummary', () => {
+    it('formats export summary', () => {
+      const result = {
+        projectName: 'TestProject',
+        testFramework: 'vitest',
+        files: [
+          { path: 'AGENTS.md', written: true },
+          { path: '.cursor/rules/tlc.mdc', written: true },
+        ],
+      };
+
+      const output = formatExportSummary(result);
+
+      expect(output).toContain('TLC Rules Exported');
+      expect(output).toContain('TestProject');
+      expect(output).toContain('vitest');
+      expect(output).toContain('AGENTS.md');
+      expect(output).toContain('.cursor/rules/tlc.mdc');
+    });
+
+    it('shows file status', () => {
+      const result = {
+        projectName: 'Test',
+        testFramework: 'jest',
+        files: [
+          { path: 'AGENTS.md', written: true },
+          { path: '.cursor/rules/tlc.mdc', written: false },
+        ],
+      };
+
+      const output = formatExportSummary(result);
+
+      expect(output).toContain('[Created]');
+      expect(output).toContain('[Skipped]');
+    });
+
+    it('includes next steps', () => {
+      const result = {
+        projectName: 'Test',
+        testFramework: 'vitest',
+        files: [],
+      };
+
+      const output = formatExportSummary(result);
+
+      expect(output).toContain('Next Steps');
+      expect(output).toContain('Commit');
+      expect(output).toContain('ROADMAP.md');
+    });
+  });
+
+  describe('executeExportCommand', () => {
+    it('handles --list flag', async () => {
+      const result = await executeExportCommand('--list', {
+        projectDir: '/tmp',
+      });
+
+      expect(result.success).toBe(true);
+      expect(result.output).toContain('Supported AI Tools');
+    });
+
+    it('handles --detect flag', async () => {
+      const result = await executeExportCommand('--detect', {
+        projectDir: '/tmp',
+      });
+
+      expect(result.success).toBe(true);
+      expect(result.detection).toBeDefined();
+      expect(result.output).toContain('AI Tool Detection');
+    });
+
+    it('handles unknown tool error', async () => {
+      const result = await executeExportCommand('--tool unknown-tool', {
+        projectDir: '/tmp',
+      });
+
+      expect(result.success).toBe(false);
+      expect(result.error).toContain('Unknown tool');
+    });
+
+    it('handles dry run', async () => {
+      const result = await executeExportCommand('cursor --dry-run', {
+        projectDir: '/tmp',
+      });
+
+      expect(result.success).toBe(true);
+      expect(result.dryRun).toBe(true);
+      expect(result.output).toContain('Would generate');
+      expect(result.files[0].written).toBe(false);
+    });
+
+    it('generates rules for specific tool', async () => {
+      const result = await executeExportCommand('cursor --dry-run', {
+        projectDir: '/tmp',
+      });
+
+      expect(result.success).toBe(true);
+      expect(result.files.length).toBe(1);
+      expect(result.files[0].tool).toBe('cursor');
+    });
+
+    it('generates rules for all tools', async () => {
+      const result = await executeExportCommand('all --dry-run', {
+        projectDir: '/tmp',
+      });
+
+      expect(result.success).toBe(true);
+      expect(result.files.length).toBe(9);
+    });
+
+    it('uses custom project name', async () => {
+      const result = await executeExportCommand('cursor --project MyApp --dry-run', {
+        projectDir: '/tmp',
+      });
+
+      expect(result.success).toBe(true);
+      expect(result.projectName).toBe('MyApp');
+      expect(result.files[0].content).toContain('MyApp');
+    });
+
+    it('uses custom test framework', async () => {
+      const result = await executeExportCommand('cursor --framework jest --dry-run', {
+        projectDir: '/tmp',
+      });
+
+      expect(result.success).toBe(true);
+      expect(result.testFramework).toBe('jest');
+    });
+  });
+
+  describe('createExportCommand', () => {
+    it('creates command handler', () => {
+      const handler = createExportCommand();
+
+      expect(handler.execute).toBeDefined();
+      expect(handler.parseArgs).toBeDefined();
+      expect(handler.loadProjectConfig).toBeDefined();
+      expect(handler.formatToolList).toBeDefined();
+      expect(handler.formatDetectionResult).toBeDefined();
+      expect(handler.formatExportSummary).toBeDefined();
+    });
+
+    it('exposes constants', () => {
+      const handler = createExportCommand();
+
+      expect(handler.SUPPORTED_TOOLS).toBeDefined();
+      expect(handler.AI_TOOLS).toBeDefined();
+    });
+
+    it('executes with default options', async () => {
+      const handler = createExportCommand({ projectDir: '/tmp' });
+      const result = await handler.execute('--list');
+
+      expect(result.success).toBe(true);
+    });
+
+    it('merges context options', async () => {
+      const handler = createExportCommand({ projectDir: '/default' });
+      const result = await handler.execute('--detect', { projectDir: '/tmp' });
+
+      expect(result.success).toBe(true);
+    });
+  });
+});

package/server/lib/file-watcher.js

@@ -0,0 +1,350 @@
+/**
+ * File Watcher Module
+ * Handles file system watching for hot reload triggers
+ */
+
+/**
+ * Default ignore patterns for file watching
+ */
+const DEFAULT_IGNORE_PATTERNS = [
+  'node_modules',
+  '.git',
+  'dist',
+  'build',
+  '.next',
+  '.nuxt',
+  '__pycache__',
+  '*.pyc',
+  '.DS_Store',
+  'Thumbs.db',
+  '*.log',
+  '*.tmp',
+  '.env.local',
+  'coverage',
+  '.nyc_output',
+];
+
+/**
+ * File change event types
+ */
+const ChangeTypes = {
+  ADD: 'add',
+  CHANGE: 'change',
+  UNLINK: 'unlink',
+  ADD_DIR: 'addDir',
+  UNLINK_DIR: 'unlinkDir',
+};
+
+/**
+ * Check if a path matches any ignore pattern
+ * @param {string} path - File path to check
+ * @param {Array<string>} patterns - Ignore patterns
+ * @returns {boolean} True if path should be ignored
+ */
+function shouldIgnore(path, patterns = DEFAULT_IGNORE_PATTERNS) {
+  const normalizedPath = path.replace(/\\/g, '/');
+
+  for (const pattern of patterns) {
+    // Exact directory match
+    if (normalizedPath.includes(`/${pattern}/`) || normalizedPath.startsWith(`${pattern}/`)) {
+      return true;
+    }
+
+    // File extension pattern (*.ext)
+    if (pattern.startsWith('*.')) {
+      const ext = pattern.slice(1);
+      if (normalizedPath.endsWith(ext)) {
+        return true;
+      }
+    }
+
+    // Exact file match
+    if (normalizedPath.endsWith(`/${pattern}`) || normalizedPath === pattern) {
+      return true;
+    }
+  }
+
+  return false;
+}
+
+/**
+ * Determine which service a file change affects
+ * @param {string} path - Changed file path
+ * @param {Array<Object>} services - List of services with paths
+ * @returns {Object|null} Affected service or null
+ */
+function getAffectedService(path, services) {
+  const normalizedPath = path.replace(/\\/g, '/');
+
+  for (const service of services) {
+    const servicePath = (service.path || '.').replace(/\\/g, '/');
+
+    // Check if file is within service directory
+    if (servicePath === '.') {
+      // Root service - check if not in another service's path
+      const inOtherService = services.some(
+        s => s.path && s.path !== '.' && normalizedPath.startsWith(s.path.replace(/\\/g, '/'))
+      );
+      if (!inOtherService) {
+        return service;
+      }
+    } else if (normalizedPath.startsWith(servicePath)) {
+      return service;
+    }
+  }
+
+  return null;
+}
+
+/**
+ * Determine the type of file that changed
+ * @param {string} path - File path
+ * @returns {string} File type category
+ */
+function getFileType(path) {
+  const ext = path.split('.').pop()?.toLowerCase();
+
+  const typeMap = {
+    // Source files
+    js: 'source',
+    jsx: 'source',
+    ts: 'source',
+    tsx: 'source',
+    py: 'source',
+    go: 'source',
+    rb: 'source',
+    rs: 'source',
+
+    // Config files
+    json: 'config',
+    yaml: 'config',
+    yml: 'config',
+    toml: 'config',
+    ini: 'config',
+
+    // Style files
+    css: 'style',
+    scss: 'style',
+    sass: 'style',
+    less: 'style',
+
+    // Template files
+    html: 'template',
+    ejs: 'template',
+    hbs: 'template',
+    pug: 'template',
+    vue: 'template',
+    svelte: 'template',
+
+    // Asset files
+    png: 'asset',
+    jpg: 'asset',
+    jpeg: 'asset',
+    gif: 'asset',
+    svg: 'asset',
+    ico: 'asset',
+    woff: 'asset',
+    woff2: 'asset',
+    ttf: 'asset',
+    eot: 'asset',
+
+    // Documentation
+    md: 'docs',
+    txt: 'docs',
+    rst: 'docs',
+  };
+
+  return typeMap[ext] || 'other';
+}
+
+/**
+ * Determine reload action needed for a file change
+ * @param {string} path - File path
+ * @param {string} changeType - Type of change (add, change, unlink)
+ * @returns {Object} Reload action
+ */
+function getReloadAction(path, changeType) {
+  const fileType = getFileType(path);
+  const filename = path.split('/').pop() || path;
+
+  // Package.json changes require full rebuild
+  if (filename === 'package.json' || filename === 'package-lock.json') {
+    return {
+      action: 'rebuild',
+      reason: 'Dependencies may have changed',
+      priority: 'high',
+    };
+  }
+
+  // Dockerfile changes require rebuild
+  if (filename === 'Dockerfile' || filename.startsWith('Dockerfile.')) {
+    return {
+      action: 'rebuild',
+      reason: 'Container definition changed',
+      priority: 'high',
+    };
+  }
+
+  // Docker-compose changes require restart
+  if (filename.startsWith('docker-compose')) {
+    return {
+      action: 'restart',
+      reason: 'Compose configuration changed',
+      priority: 'high',
+    };
+  }
+
+  // Config file changes usually need restart
+  if (fileType === 'config') {
+    return {
+      action: 'restart',
+      reason: 'Configuration changed',
+      priority: 'medium',
+    };
+  }
+
+  // Source and style files trigger hot reload
+  if (fileType === 'source' || fileType === 'style' || fileType === 'template') {
+    return {
+      action: 'hot-reload',
+      reason: `${fileType} file ${changeType}`,
+      priority: 'low',
+    };
+  }
+
+  // Assets and docs don't need reload
+  if (fileType === 'asset' || fileType === 'docs') {
+    return {
+      action: 'none',
+      reason: 'No reload needed for assets/docs',
+      priority: 'none',
+    };
+  }
+
+  return {
+    action: 'hot-reload',
+    reason: 'File changed',
+    priority: 'low',
+  };
+}
+
+/**
+ * Create a change event object
+ * @param {string} path - File path
+ * @param {string} changeType - Type of change
+ * @param {Object} service - Affected service
+ * @returns {Object} Change event
+ */
+function createChangeEvent(path, changeType, service = null) {
+  const reloadAction = getReloadAction(path, changeType);
+
+  return {
+    path,
+    changeType,
+    fileType: getFileType(path),
+    service: service?.name || null,
+    timestamp: new Date().toISOString(),
+    ...reloadAction,
+  };
+}
+
+/**
+ * Debounce configuration for file watching
+ * @param {Object} options - Debounce options
+ * @returns {Object} Debounce config
+ */
+function getDebounceConfig(options = {}) {
+  const {
+    stabilityThreshold = 100,
+    pollInterval = 100,
+    binaryInterval = 300,
+  } = options;
+
+  return {
+    stabilityThreshold, // Wait this ms after last change
+    pollInterval,       // How often to poll for changes
+    binaryInterval,     // Interval for binary files
+    awaitWriteFinish: {
+      stabilityThreshold,
+      pollInterval,
+    },
+  };
+}
+
+/**
+ * Create watcher options for chokidar
+ * @param {Object} options - Watch options
+ * @returns {Object} Chokidar options
+ */
+function createWatcherOptions(options = {}) {
+  const {
+    ignorePatterns = DEFAULT_IGNORE_PATTERNS,
+    persistent = true,
+    ignoreInitial = true,
+    followSymlinks = false,
+    debounce = {},
+  } = options;
+
+  const debounceConfig = getDebounceConfig(debounce);
+
+  return {
+    ignored: (path) => shouldIgnore(path, ignorePatterns),
+    persistent,
+    ignoreInitial,
+    followSymlinks,
+    ...debounceConfig,
+  };
+}
+
+/**
+ * Batch multiple file changes into a single reload action
+ * @param {Array<Object>} changes - Array of change events
+ * @returns {Object} Batched reload action
+ */
+function batchChanges(changes) {
+  if (changes.length === 0) {
+    return { action: 'none', changes: [] };
+  }
+
+  // Find highest priority action
+  const priorities = { high: 3, medium: 2, low: 1, none: 0 };
+  const actions = { rebuild: 3, restart: 2, 'hot-reload': 1, none: 0 };
+
+  let maxPriority = 0;
+  let maxAction = 'none';
+  const affectedServices = new Set();
+
+  for (const change of changes) {
+    if (priorities[change.priority] > maxPriority) {
+      maxPriority = priorities[change.priority];
+    }
+    if (actions[change.action] > actions[maxAction]) {
+      maxAction = change.action;
+    }
+    if (change.service) {
+      affectedServices.add(change.service);
+    }
+  }
+
+  return {
+    action: maxAction,
+    services: Array.from(affectedServices),
+    changes: changes.length,
+    reason: changes.length === 1
+      ? changes[0].reason
+      : `${changes.length} files changed`,
+  };
+}
+
+module.exports = {
+  DEFAULT_IGNORE_PATTERNS,
+  ChangeTypes,
+  shouldIgnore,
+  getAffectedService,
+  getFileType,
+  getReloadAction,
+  createChangeEvent,
+  getDebounceConfig,
+  createWatcherOptions,
+  batchChanges,
+};