@rayburst/cli 0.1.18 → 0.2.0

package/src/file-watcher.js

@@ -1,174 +0,0 @@
-import chokidar from 'chokidar';
-import path from 'path';
-import chalk from 'chalk';
-
-/**
- * File Watcher for Rayburst Projects
- *
- * Watches registered project directories for file changes and triggers
- * incremental analysis on relevant file modifications.
- */
-
-const watchers = new Map(); // Map<projectId, { watcher, callback }>
-
-/**
- * Start watching a project directory for file changes
- *
- * @param {string} projectId - Unique project identifier
- * @param {string} projectPath - Absolute path to project directory
- * @param {Function} onChange - Callback function (changedFiles: string[]) => void
- * @param {Object} options - Watch options
- * @returns {Object} - Watcher instance
- */
-export function watchProject(projectId, projectPath, onChange, options = {}) {
-  // Stop existing watcher if any
-  unwatchProject(projectId);
-
-  const {
-    debounceMs = 1500,
-    ignorePatterns = [
-      '**/node_modules/**',
-      '**/.git/**',
-      '**/dist/**',
-      '**/build/**',
-      '**/*.test.ts',
-      '**/*.test.tsx',
-      '**/*.spec.ts',
-      '**/*.spec.tsx',
-    ],
-  } = options;
-
-  console.log(chalk.blue(`👁️  Watching project: ${projectId}`));
-  console.log(chalk.gray(`   Path: ${projectPath}`));
-
-  // Track pending changes for debouncing
-  let pendingChanges = new Set();
-  let debounceTimer = null;
-
-  const handleChange = (filePath) => {
-    const relativePath = path.relative(projectPath, filePath);
-
-    // Only track relevant files
-    if (!isRelevantFile(filePath)) {
-      return;
-    }
-
-    pendingChanges.add(filePath);
-
-    // Debounce: wait for a pause in file changes
-    if (debounceTimer) {
-      clearTimeout(debounceTimer);
-    }
-
-    debounceTimer = setTimeout(() => {
-      const changedFiles = Array.from(pendingChanges);
-      pendingChanges.clear();
-
-      console.log(chalk.yellow(`📝 File changes detected in ${projectId}:`));
-      changedFiles.forEach(file => {
-        const rel = path.relative(projectPath, file);
-        console.log(chalk.gray(`   - ${rel}`));
-      });
-
-      // Trigger onChange callback
-      onChange(changedFiles);
-    }, debounceMs);
-  };
-
-  // Create watcher
-  const watcher = chokidar.watch(projectPath, {
-    ignored: ignorePatterns,
-    persistent: true,
-    ignoreInitial: true,
-    awaitWriteFinish: {
-      stabilityThreshold: 300,
-      pollInterval: 100,
-    },
-  });
-
-  // Listen for file change events
-  watcher.on('change', handleChange);
-  watcher.on('add', handleChange);
-  watcher.on('unlink', handleChange);
-
-  watcher.on('error', (error) => {
-    console.error(chalk.red(`❌ Watcher error for ${projectId}:`), error);
-  });
-
-  // Store watcher reference
-  watchers.set(projectId, {
-    watcher,
-    callback: onChange,
-    projectPath,
-  });
-
-  return watcher;
-}
-
-/**
- * Stop watching a project
- *
- * @param {string} projectId - Project identifier
- */
-export function unwatchProject(projectId) {
-  const watcherData = watchers.get(projectId);
-
-  if (watcherData) {
-    console.log(chalk.gray(`⏹️  Stopped watching project: ${projectId}`));
-    watcherData.watcher.close();
-    watchers.delete(projectId);
-  }
-}
-
-/**
- * Get all currently watched projects
- *
- * @returns {Array<string>} - Array of project IDs
- */
-export function getWatchedProjects() {
-  return Array.from(watchers.keys());
-}
-
-/**
- * Check if a project is being watched
- *
- * @param {string} projectId - Project identifier
- * @returns {boolean}
- */
-export function isWatching(projectId) {
-  return watchers.has(projectId);
-}
-
-/**
- * Stop all watchers
- */
-export function unwatchAll() {
-  console.log(chalk.gray('⏹️  Stopping all file watchers...'));
-  for (const projectId of watchers.keys()) {
-    unwatchProject(projectId);
-  }
-}
-
-/**
- * Check if a file is relevant for analysis
- *
- * @param {string} filePath - Absolute file path
- * @returns {boolean}
- */
-function isRelevantFile(filePath) {
-  const ext = path.extname(filePath).toLowerCase();
-  const relevantExtensions = ['.ts', '.tsx', '.js', '.jsx'];
-
-  // Check extension
-  if (!relevantExtensions.includes(ext)) {
-    return false;
-  }
-
-  // Skip test files
-  const basename = path.basename(filePath);
-  if (basename.includes('.test.') || basename.includes('.spec.')) {
-    return false;
-  }
-
-  return true;
-}

package/src/git-utils.js

@@ -1,105 +0,0 @@
-import { execSync } from 'child_process';
-import path from 'path';
-
-/**
- * Git Utilities
- *
- * Helper functions to interact with git repositories
- */
-
-/**
- * Get list of uncommitted changed files in a git repository
- *
- * @param {string} projectPath - Absolute path to project directory
- * @returns {string[]} - Array of absolute file paths that have uncommitted changes
- */
-export function getUncommittedChanges(projectPath) {
-  try {
-    // Check if directory is a git repository
-    if (!isGitRepository(projectPath)) {
-      return [];
-    }
-
-    // Get modified, added, and deleted files (staged and unstaged)
-    const command = 'git diff --name-only HEAD && git diff --name-only --cached';
-
-    const output = execSync(command, {
-      cwd: projectPath,
-      encoding: 'utf8',
-      stdio: ['pipe', 'pipe', 'ignore'], // Ignore stderr
-    });
-
-    // Parse output and convert to absolute paths
-    const files = output
-      .split('\n')
-      .filter(Boolean)
-      .map(file => path.resolve(projectPath, file.trim()));
-
-    // Remove duplicates
-    return [...new Set(files)];
-  } catch (error) {
-    // If git command fails, return empty array
-    console.error('Failed to get git diff:', error.message);
-    return [];
-  }
-}
-
-/**
- * Check if a directory is a git repository
- *
- * @param {string} projectPath - Absolute path to project directory
- * @returns {boolean}
- */
-export function isGitRepository(projectPath) {
-  try {
-    execSync('git rev-parse --is-inside-work-tree', {
-      cwd: projectPath,
-      encoding: 'utf8',
-      stdio: ['pipe', 'pipe', 'ignore'],
-    });
-    return true;
-  } catch {
-    return false;
-  }
-}
-
-/**
- * Get list of untracked files in a git repository
- *
- * @param {string} projectPath - Absolute path to project directory
- * @returns {string[]} - Array of absolute file paths that are untracked
- */
-export function getUntrackedFiles(projectPath) {
-  try {
-    if (!isGitRepository(projectPath)) {
-      return [];
-    }
-
-    const output = execSync('git ls-files --others --exclude-standard', {
-      cwd: projectPath,
-      encoding: 'utf8',
-      stdio: ['pipe', 'pipe', 'ignore'],
-    });
-
-    return output
-      .split('\n')
-      .filter(Boolean)
-      .map(file => path.resolve(projectPath, file.trim()));
-  } catch (error) {
-    console.error('Failed to get untracked files:', error.message);
-    return [];
-  }
-}
-
-/**
- * Get all files with changes (committed or not)
- *
- * @param {string} projectPath - Absolute path to project directory
- * @returns {string[]} - Array of absolute file paths
- */
-export function getAllChangedFiles(projectPath) {
-  const uncommitted = getUncommittedChanges(projectPath);
-  const untracked = getUntrackedFiles(projectPath);
-
-  return [...new Set([...uncommitted, ...untracked])];
-}

package/src/incremental-analyzer.js

@@ -1,295 +0,0 @@
-import { analyzeProject } from '../scripts/analyze-project.js';
-import { readAnalysisData, writeAnalysisData } from './registry.js';
-import chalk from 'chalk';
-
-/**
- * Incremental Analyzer
- *
- * Performs incremental analysis by comparing new analysis results with
- * previously stored results and generating a diff of changes.
- */
-
-/**
- * Perform incremental analysis on a project
- *
- * @param {string} projectId - Project identifier
- * @param {string} projectPath - Absolute path to project
- * @param {string[]} changedFiles - Optional array of changed file paths
- * @returns {Object} - Incremental update with added, removed, and modified nodes/edges
- */
-export function performIncrementalAnalysis(projectId, projectPath, changedFiles = []) {
-  console.log(chalk.blue(`🔄 Running incremental analysis for ${projectId}...`));
-
-  // Load previous analysis
-  const previousAnalysis = readAnalysisData(projectId);
-
-  if (!previousAnalysis) {
-    console.log(chalk.yellow('   No previous analysis found, running full analysis...'));
-    // Run full analysis if no previous data exists
-    const newAnalysis = analyzeProject(projectPath);
-    writeAnalysisData(projectId, newAnalysis);
-
-    return {
-      type: 'full',
-      analysis: newAnalysis,
-      update: null,
-    };
-  }
-
-  // Run full analysis (in the future, this could be optimized to analyze only changed files)
-  const newAnalysis = analyzeProject(projectPath);
-
-  // Generate diff
-  const update = generateDiff(previousAnalysis, newAnalysis);
-
-  // Save new analysis
-  writeAnalysisData(projectId, newAnalysis);
-
-  // Log statistics
-  const stats = getUpdateStats(update);
-  console.log(chalk.green(`✓ Incremental analysis complete:`));
-  console.log(chalk.gray(`   Added: ${stats.addedNodes} nodes, ${stats.addedEdges} edges`));
-  console.log(chalk.gray(`   Removed: ${stats.removedNodes} nodes, ${stats.removedEdges} edges`));
-  console.log(chalk.gray(`   Modified: ${stats.modifiedNodes} nodes, ${stats.modifiedEdges} edges`));
-
-  return {
-    type: 'incremental',
-    analysis: newAnalysis,
-    update,
-  };
-}
-
-/**
- * Generate diff between old and new analysis
- *
- * @param {Object} oldAnalysis - Previous analysis data
- * @param {Object} newAnalysis - New analysis data
- * @returns {Object} - Incremental update object
- */
-export function generateDiff(oldAnalysis, newAnalysis) {
-  const update = {
-    added: {
-      nodes: [],
-      edges: [],
-    },
-    removed: {
-      nodeIds: [],
-      edgeIds: [],
-    },
-    modified: {
-      nodes: [],
-      edges: [],
-    },
-  };
-
-  // Process each branch
-  const branches = new Set([
-    ...Object.keys(oldAnalysis.planData || {}),
-    ...Object.keys(newAnalysis.planData || {}),
-  ]);
-
-  for (const branchId of branches) {
-    const oldPlanData = oldAnalysis.planData?.[branchId];
-    const newPlanData = newAnalysis.planData?.[branchId];
-
-    if (!oldPlanData && newPlanData) {
-      // New branch - all nodes/edges are added
-      update.added.nodes.push(...(newPlanData.nodes || []));
-      update.added.edges.push(...(newPlanData.edges || []));
-      continue;
-    }
-
-    if (oldPlanData && !newPlanData) {
-      // Branch removed - all nodes/edges are removed
-      update.removed.nodeIds.push(...(oldPlanData.nodes || []).map(n => n.id));
-      update.removed.edgeIds.push(...(oldPlanData.edges || []).map(e => e.id));
-      continue;
-    }
-
-    // Branch exists in both - compare nodes and edges
-    const branchDiff = comparePlanData(oldPlanData, newPlanData);
-    update.added.nodes.push(...branchDiff.added.nodes);
-    update.added.edges.push(...branchDiff.added.edges);
-    update.removed.nodeIds.push(...branchDiff.removed.nodeIds);
-    update.removed.edgeIds.push(...branchDiff.removed.edgeIds);
-    update.modified.nodes.push(...branchDiff.modified.nodes);
-    update.modified.edges.push(...branchDiff.modified.edges);
-  }
-
-  return update;
-}
-
-/**
- * Compare plan data for a single branch
- *
- * @param {Object} oldPlanData - Previous plan data
- * @param {Object} newPlanData - New plan data
- * @returns {Object} - Diff object
- */
-function comparePlanData(oldPlanData, newPlanData) {
-  const oldNodes = oldPlanData?.nodes || [];
-  const newNodes = newPlanData?.nodes || [];
-  const oldEdges = oldPlanData?.edges || [];
-  const newEdges = newPlanData?.edges || [];
-
-  // Create maps for quick lookup
-  const oldNodeMap = new Map(oldNodes.map(n => [n.id, n]));
-  const newNodeMap = new Map(newNodes.map(n => [n.id, n]));
-  const oldEdgeMap = new Map(oldEdges.map(e => [e.id, e]));
-  const newEdgeMap = new Map(newEdges.map(e => [e.id, e]));
-
-  const diff = {
-    added: { nodes: [], edges: [] },
-    removed: { nodeIds: [], edgeIds: [] },
-    modified: { nodes: [], edges: [] },
-  };
-
-  // Find added and modified nodes
-  for (const [nodeId, newNode] of newNodeMap) {
-    const oldNode = oldNodeMap.get(nodeId);
-
-    if (!oldNode) {
-      // Node was added
-      diff.added.nodes.push(newNode);
-    } else if (hasNodeChanged(oldNode, newNode)) {
-      // Node was modified
-      diff.modified.nodes.push({
-        id: nodeId,
-        ...getNodeChanges(oldNode, newNode),
-      });
-    }
-  }
-
-  // Find removed nodes
-  for (const nodeId of oldNodeMap.keys()) {
-    if (!newNodeMap.has(nodeId)) {
-      diff.removed.nodeIds.push(nodeId);
-    }
-  }
-
-  // Find added and modified edges
-  for (const [edgeId, newEdge] of newEdgeMap) {
-    const oldEdge = oldEdgeMap.get(edgeId);
-
-    if (!oldEdge) {
-      // Edge was added
-      diff.added.edges.push(newEdge);
-    } else if (hasEdgeChanged(oldEdge, newEdge)) {
-      // Edge was modified
-      diff.modified.edges.push({
-        id: edgeId,
-        ...getEdgeChanges(oldEdge, newEdge),
-      });
-    }
-  }
-
-  // Find removed edges
-  for (const edgeId of oldEdgeMap.keys()) {
-    if (!newEdgeMap.has(edgeId)) {
-      diff.removed.edgeIds.push(edgeId);
-    }
-  }
-
-  return diff;
-}
-
-/**
- * Check if a node has changed
- *
- * @param {Object} oldNode - Previous node
- * @param {Object} newNode - New node
- * @returns {boolean}
- */
-function hasNodeChanged(oldNode, newNode) {
-  // Compare relevant properties (exclude position)
-  const oldData = JSON.stringify({ ...oldNode.data, type: oldNode.type });
-  const newData = JSON.stringify({ ...newNode.data, type: newNode.type });
-
-  return oldData !== newData;
-}
-
-/**
- * Get node changes
- *
- * @param {Object} oldNode - Previous node
- * @param {Object} newNode - New node
- * @returns {Object} - Changed properties
- */
-function getNodeChanges(oldNode, newNode) {
-  const changes = {};
-
-  if (oldNode.type !== newNode.type) {
-    changes.type = newNode.type;
-  }
-
-  if (JSON.stringify(oldNode.data) !== JSON.stringify(newNode.data)) {
-    changes.data = newNode.data;
-  }
-
-  return changes;
-}
-
-/**
- * Check if an edge has changed
- *
- * @param {Object} oldEdge - Previous edge
- * @param {Object} newEdge - New edge
- * @returns {boolean}
- */
-function hasEdgeChanged(oldEdge, newEdge) {
-  // Compare relevant properties
-  return (
-    oldEdge.source !== newEdge.source ||
-    oldEdge.target !== newEdge.target ||
-    oldEdge.type !== newEdge.type ||
-    JSON.stringify(oldEdge.data) !== JSON.stringify(newEdge.data)
-  );
-}
-
-/**
- * Get edge changes
- *
- * @param {Object} oldEdge - Previous edge
- * @param {Object} newEdge - New edge
- * @returns {Object} - Changed properties
- */
-function getEdgeChanges(oldEdge, newEdge) {
-  const changes = {};
-
-  if (oldEdge.source !== newEdge.source) changes.source = newEdge.source;
-  if (oldEdge.target !== newEdge.target) changes.target = newEdge.target;
-  if (oldEdge.type !== newEdge.type) changes.type = newEdge.type;
-  if (JSON.stringify(oldEdge.data) !== JSON.stringify(newEdge.data)) {
-    changes.data = newEdge.data;
-  }
-
-  return changes;
-}
-
-/**
- * Get statistics from an update
- *
- * @param {Object} update - Incremental update object
- * @returns {Object} - Statistics
- */
-function getUpdateStats(update) {
-  return {
-    addedNodes: update.added.nodes.length,
-    addedEdges: update.added.edges.length,
-    removedNodes: update.removed.nodeIds.length,
-    removedEdges: update.removed.edgeIds.length,
-    modifiedNodes: update.modified.nodes.length,
-    modifiedEdges: update.modified.edges.length,
-  };
-}
-
-/**
- * Check if an update has any changes
- *
- * @param {Object} update - Incremental update object
- * @returns {boolean}
- */
-export function hasChanges(update) {
-  const stats = getUpdateStats(update);
-  return Object.values(stats).some(count => count > 0);
-}