claude-code-templates 1.8.0 → 1.8.2

package/src/analytics/core/FileWatcher.js

@@ -0,0 +1,285 @@
+const chalk = require('chalk');
+const chokidar = require('chokidar');
+const path = require('path');
+
+/**
+ * FileWatcher - Handles file system watching and automatic data refresh
+ * Extracted from monolithic analytics.js for better maintainability
+ */
+class FileWatcher {
+  constructor() {
+    this.watchers = [];
+    this.intervals = [];
+    this.isActive = false;
+  }
+
+  /**
+   * Setup file watchers for real-time updates
+   * @param {string} claudeDir - Path to Claude directory
+   * @param {Function} dataRefreshCallback - Callback to refresh data
+   * @param {Function} processRefreshCallback - Callback to refresh process data
+   * @param {Object} dataCache - DataCache instance for invalidation
+   */
+  setupFileWatchers(claudeDir, dataRefreshCallback, processRefreshCallback, dataCache = null) {
+    console.log(chalk.blue('👀 Setting up file watchers for real-time updates...'));
+
+    this.claudeDir = claudeDir;
+    this.dataRefreshCallback = dataRefreshCallback;
+    this.processRefreshCallback = processRefreshCallback;
+    this.dataCache = dataCache;
+
+    this.setupConversationWatcher();
+    this.setupProjectWatcher();
+    this.setupPeriodicRefresh();
+    
+    this.isActive = true;
+  }
+
+  /**
+   * Setup watcher for conversation files (.jsonl)
+   */
+  setupConversationWatcher() {
+    const conversationWatcher = chokidar.watch([
+      path.join(this.claudeDir, '**/*.jsonl')
+    ], {
+      persistent: true,
+      ignoreInitial: true,
+    });
+
+    conversationWatcher.on('change', async (filePath) => {
+      console.log(chalk.yellow('🔄 Conversation file changed, updating data...'));
+      
+      // Invalidate cache for the changed file
+      if (this.dataCache && filePath) {
+        this.dataCache.invalidateFile(filePath);
+      }
+      
+      await this.triggerDataRefresh();
+      console.log(chalk.green('✅ Data updated'));
+    });
+
+    conversationWatcher.on('add', async () => {
+      console.log(chalk.yellow('📝 New conversation file detected...'));
+      await this.triggerDataRefresh();
+      console.log(chalk.green('✅ Data updated'));
+    });
+
+    this.watchers.push(conversationWatcher);
+  }
+
+  /**
+   * Setup watcher for project directories
+   */
+  setupProjectWatcher() {
+    const projectWatcher = chokidar.watch(this.claudeDir, {
+      persistent: true,
+      ignoreInitial: true,
+      depth: 2, // Increased depth to catch subdirectories
+    });
+
+    projectWatcher.on('addDir', async () => {
+      console.log(chalk.yellow('📁 New project directory detected...'));
+      await this.triggerDataRefresh();
+      console.log(chalk.green('✅ Data updated'));
+    });
+
+    projectWatcher.on('change', async () => {
+      console.log(chalk.yellow('📁 Project directory changed...'));
+      await this.triggerDataRefresh();
+      console.log(chalk.green('✅ Data updated'));
+    });
+
+    this.watchers.push(projectWatcher);
+  }
+
+  /**
+   * Setup periodic refresh intervals
+   */
+  setupPeriodicRefresh() {
+    // Periodic refresh to catch any missed changes (reduced frequency)
+    const dataRefreshInterval = setInterval(async () => {
+      console.log(chalk.blue('⏱️  Periodic data refresh...'));
+      await this.triggerDataRefresh();
+    }, 120000); // Every 2 minutes (reduced from 30 seconds)
+
+    this.intervals.push(dataRefreshInterval);
+
+    // Process updates for active processes (reduced frequency)
+    const processRefreshInterval = setInterval(async () => {
+      if (this.processRefreshCallback) {
+        await this.processRefreshCallback();
+      }
+    }, 30000); // Every 30 seconds (reduced from 10 seconds)
+
+    this.intervals.push(processRefreshInterval);
+  }
+
+  /**
+   * Trigger data refresh with error handling
+   */
+  async triggerDataRefresh() {
+    try {
+      if (this.dataRefreshCallback) {
+        await this.dataRefreshCallback();
+      }
+    } catch (error) {
+      console.error(chalk.red('Error during data refresh:'), error.message);
+    }
+  }
+
+  /**
+   * Add a custom watcher
+   * @param {Object} watcher - Chokidar watcher instance
+   */
+  addWatcher(watcher) {
+    this.watchers.push(watcher);
+  }
+
+  /**
+   * Add a custom interval
+   * @param {number} intervalId - Interval ID from setInterval
+   */
+  addInterval(intervalId) {
+    this.intervals.push(intervalId);
+  }
+
+  /**
+   * Pause all watchers and intervals
+   */
+  pause() {
+    console.log(chalk.yellow('⏸️  Pausing file watchers...'));
+    
+    // Pause watchers (they will still exist but not trigger events)
+    this.watchers.forEach(watcher => {
+      if (watcher.unwatch) {
+        // Temporarily remove all watched paths
+        const watchedPaths = watcher.getWatched();
+        Object.keys(watchedPaths).forEach(dir => {
+          watchedPaths[dir].forEach(file => {
+            watcher.unwatch(path.join(dir, file));
+          });
+        });
+      }
+    });
+
+    this.isActive = false;
+  }
+
+  /**
+   * Resume all watchers
+   */
+  resume() {
+    if (!this.isActive && this.claudeDir) {
+      console.log(chalk.green('▶️  Resuming file watchers...'));
+      
+      // Clear existing watchers
+      this.stop();
+      
+      // Restart watchers
+      this.setupFileWatchers(
+        this.claudeDir, 
+        this.dataRefreshCallback, 
+        this.processRefreshCallback
+      );
+    }
+  }
+
+  /**
+   * Stop and cleanup all watchers and intervals
+   */
+  stop() {
+    console.log(chalk.red('🛑 Stopping file watchers...'));
+
+    // Close all watchers
+    this.watchers.forEach(watcher => {
+      try {
+        watcher.close();
+      } catch (error) {
+        console.warn(chalk.yellow('Warning: Error closing watcher:'), error.message);
+      }
+    });
+
+    // Clear all intervals
+    this.intervals.forEach(intervalId => {
+      clearInterval(intervalId);
+    });
+
+    // Reset arrays
+    this.watchers = [];
+    this.intervals = [];
+    this.isActive = false;
+  }
+
+  /**
+   * Get watcher status
+   * @returns {Object} Status information
+   */
+  getStatus() {
+    return {
+      isActive: this.isActive,
+      watcherCount: this.watchers.length,
+      intervalCount: this.intervals.length,
+      watchedDir: this.claudeDir
+    };
+  }
+
+  /**
+   * Check if watchers are active
+   * @returns {boolean} True if watchers are active
+   */
+  isWatching() {
+    return this.isActive && this.watchers.length > 0;
+  }
+
+  /**
+   * Get list of watched paths (for debugging)
+   * @returns {Array} Array of watched paths
+   */
+  getWatchedPaths() {
+    const watchedPaths = [];
+    
+    this.watchers.forEach(watcher => {
+      if (watcher.getWatched) {
+        const watched = watcher.getWatched();
+        Object.keys(watched).forEach(dir => {
+          watched[dir].forEach(file => {
+            watchedPaths.push(path.join(dir, file));
+          });
+        });
+      }
+    });
+
+    return watchedPaths;
+  }
+
+  /**
+   * Set debounced refresh to avoid spam
+   * @param {number} debounceMs - Debounce time in milliseconds
+   */
+  setDebounce(debounceMs = 200) {
+    let debounceTimeout;
+    const originalCallback = this.dataRefreshCallback;
+    
+    this.dataRefreshCallback = async (...args) => {
+      clearTimeout(debounceTimeout);
+      debounceTimeout = setTimeout(async () => {
+        if (originalCallback) {
+          await originalCallback(...args);
+        }
+      }, debounceMs);
+    };
+  }
+
+  /**
+   * Force immediate refresh
+   */
+  async forceRefresh() {
+    console.log(chalk.cyan('🔄 Force refreshing data...'));
+    await this.triggerDataRefresh();
+    if (this.processRefreshCallback) {
+      await this.processRefreshCallback();
+    }
+  }
+}
+
+module.exports = FileWatcher;

package/src/analytics/core/ProcessDetector.js

@@ -0,0 +1,242 @@
+const { exec } = require('child_process');
+const fs = require('fs-extra');
+const path = require('path');
+
+/**
+ * ProcessDetector - Handles Claude CLI process detection and conversation matching
+ * Extracted from monolithic analytics.js for better maintainability
+ */
+class ProcessDetector {
+  constructor() {
+    // Cache for process detection to avoid repeated shell commands
+    this.processCache = {
+      data: null,
+      timestamp: 0,
+      ttl: 500 // 500ms cache
+    };
+  }
+
+  /**
+   * Detect running Claude CLI processes
+   * @returns {Promise<Array>} Array of active Claude processes
+   */
+  async detectRunningClaudeProcesses() {
+    // Check cache first
+    const now = Date.now();
+    if (this.processCache.data && (now - this.processCache.timestamp) < this.processCache.ttl) {
+      return this.processCache.data;
+    }
+
+    return new Promise((resolve) => {
+      // Search for processes containing 'claude' but exclude our own analytics process and system processes
+      exec('ps aux | grep -i claude | grep -v grep | grep -v analytics | grep -v "/Applications/Claude.app" | grep -v "npm start"', (error, stdout) => {
+        if (error) {
+          resolve([]);
+          return;
+        }
+        
+        const processes = stdout.split('\n')
+          .filter(line => line.trim())
+          .filter(line => {
+            // Only include actual Claude CLI processes, not system processes
+            const fullCommand = line.split(/\s+/).slice(10).join(' ');
+            return fullCommand.includes('claude') && 
+                   !fullCommand.includes('chrome_crashpad_handler') &&
+                   !fullCommand.includes('create-claude-config') &&
+                   !fullCommand.includes('node bin/') &&
+                   fullCommand.trim() === 'claude'; // Only the basic claude command
+          })
+          .map(line => {
+            const parts = line.split(/\s+/);
+            const fullCommand = parts.slice(10).join(' ');
+            
+            // Extract useful information from command  
+            const cwdMatch = fullCommand.match(/--cwd[=\s]+([^\s]+)/);
+            let workingDir = cwdMatch ? cwdMatch[1] : 'unknown';
+            
+            // Skip pwdx for now since it doesn't exist on macOS
+            
+            return {
+              pid: parts[1],
+              command: fullCommand,
+              workingDir: workingDir,
+              startTime: new Date(), // For now we use current time
+              status: 'running',
+              user: parts[0]
+            };
+          });
+        
+        // Cache the result
+        this.processCache = {
+          data: processes,
+          timestamp: now,
+          ttl: 500
+        };
+        
+        resolve(processes);
+      });
+    });
+  }
+
+  /**
+   * Enrich conversation data with running process information
+   * @param {Array} conversations - Array of conversation objects
+   * @param {string} claudeDir - Path to Claude directory for file operations
+   * @param {Object} stateCalculator - StateCalculator instance for state calculations
+   * @returns {Promise<Object>} Object with enriched conversations and orphan processes
+   */
+  async enrichWithRunningProcesses(conversations, claudeDir, stateCalculator) {
+    try {
+      const runningProcesses = await this.detectRunningClaudeProcesses();
+      
+      // Add active process information to each conversation
+      for (const conversation of conversations) {
+        // Look for active process for this project
+        // If workingDir is unknown, match with the most recently modified conversation
+        let matchingProcess = runningProcesses.find(process => 
+          process.workingDir.includes(conversation.project) ||
+          process.command.includes(conversation.project)
+        );
+        
+        // Fallback: if no direct match and workingDir is unknown, 
+        // assume the most recently modified conversation belongs to the active process
+        if (!matchingProcess && runningProcesses.length > 0 && runningProcesses[0].workingDir === 'unknown') {
+          // Find the most recently modified conversation
+          const sortedConversations = [...conversations].sort((a, b) => 
+            new Date(b.lastModified) - new Date(a.lastModified)
+          );
+          
+          if (conversation === sortedConversations[0]) {
+            matchingProcess = runningProcesses[0];
+          }
+        }
+        
+        if (matchingProcess) {
+          // ENRICH without changing existing logic
+          conversation.runningProcess = {
+            pid: matchingProcess.pid,
+            startTime: matchingProcess.startTime,
+            workingDir: matchingProcess.workingDir,
+            hasActiveCommand: true
+          };
+          
+          // Only change status if not already marked as active by existing logic
+          if (conversation.status !== 'active') {
+            conversation.status = 'active';
+            conversation.statusReason = 'running_process';
+          }
+          
+          // Recalculate conversation state with process information
+          const conversationFile = path.join(claudeDir, conversation.fileName);
+          try {
+            const content = await fs.readFile(conversationFile, 'utf8');
+            const parsedMessages = content.split('\n')
+              .filter(line => line.trim())
+              .map(line => JSON.parse(line));
+            
+            const stats = await fs.stat(conversationFile);
+            conversation.conversationState = stateCalculator.determineConversationState(
+              parsedMessages, 
+              stats.mtime, 
+              conversation.runningProcess
+            );
+          } catch (error) {
+            // If we can't read the file, keep the existing state
+          }
+        } else {
+          conversation.runningProcess = null;
+        }
+      }
+      
+      // Disable orphan process detection to reduce noise
+      const orphanProcesses = [];
+      
+      return {
+        conversations,
+        orphanProcesses,
+        activeProcessCount: runningProcesses.length
+      };
+      
+    } catch (error) {
+      // Silently handle process detection errors
+      return {
+        conversations,
+        orphanProcesses: [],
+        activeProcessCount: 0
+      };
+    }
+  }
+
+  /**
+   * Get cached processes without triggering detection
+   * @returns {Array} Cached process data or empty array
+   */
+  getCachedProcesses() {
+    const now = Date.now();
+    if (this.processCache.data && (now - this.processCache.timestamp) < this.processCache.ttl) {
+      return this.processCache.data;
+    }
+    return [];
+  }
+
+  /**
+   * Clear process cache to force fresh detection
+   */
+  clearCache() {
+    this.processCache = {
+      data: null,
+      timestamp: 0,
+      ttl: 500
+    };
+  }
+
+  /**
+   * Check if there are any active Claude processes
+   * @returns {Promise<boolean>} True if there are active processes
+   */
+  async hasActiveProcesses() {
+    const processes = await this.detectRunningClaudeProcesses();
+    return processes.length > 0;
+  }
+
+  /**
+   * Get process statistics
+   * @returns {Promise<Object>} Process statistics
+   */
+  async getProcessStats() {
+    const processes = await this.detectRunningClaudeProcesses();
+    return {
+      total: processes.length,
+      withKnownWorkingDir: processes.filter(p => p.workingDir !== 'unknown').length,
+      withUnknownWorkingDir: processes.filter(p => p.workingDir === 'unknown').length,
+      processes: processes
+    };
+  }
+
+  /**
+   * Match a specific process to conversations
+   * @param {Object} process - Process object
+   * @param {Array} conversations - Array of conversation objects
+   * @returns {Object|null} Matched conversation or null
+   */
+  matchProcessToConversation(process, conversations) {
+    // Direct match by working directory or project name
+    let match = conversations.find(conv => 
+      process.workingDir.includes(conv.project) ||
+      process.command.includes(conv.project)
+    );
+
+    // Fallback for unknown working directories
+    if (!match && process.workingDir === 'unknown' && conversations.length > 0) {
+      // Match to most recently modified conversation
+      const sorted = [...conversations].sort((a, b) => 
+        new Date(b.lastModified) - new Date(a.lastModified)
+      );
+      match = sorted[0];
+    }
+
+    return match;
+  }
+}
+
+module.exports = ProcessDetector;