@rayburst/cli 0.2.0 → 0.2.2

package/dist/incremental-analyzer.js

@@ -1,259 +0,0 @@
-import { analyzeProject } from './analysis/analyze-project';
-import { readAnalysisData, writeAnalysisData } from './registry';
-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);
-}

package/dist/local-storage.d.ts

@@ -1,39 +0,0 @@
-import type { AnalysisResult } from '@rayburst/types';
-export interface ProjectMeta {
-    projectId: string;
-    projectName: string;
-    createdAt: string;
-    cliVersion: string;
-}
-/**
- * Ensures the .rayburst directory exists in the project
- */
-export declare function ensureRayburstDir(projectPath: string): Promise<string>;
-/**
- * Reads analysis data from .rayburst/analysis.json
- */
-export declare function readLocalAnalysis(projectPath: string): Promise<AnalysisResult | null>;
-/**
- * Writes analysis data to .rayburst/analysis.json
- */
-export declare function writeLocalAnalysis(projectPath: string, analysis: AnalysisResult): Promise<void>;
-/**
- * Reads project metadata from .rayburst/meta.json
- */
-export declare function readLocalMeta(projectPath: string): Promise<ProjectMeta | null>;
-/**
- * Writes project metadata to .rayburst/meta.json
- */
-export declare function writeLocalMeta(projectPath: string, meta: ProjectMeta): Promise<void>;
-/**
- * Adds .rayburst/ entry to .gitignore if not already present
- */
-export declare function addGitignoreEntry(projectPath: string): Promise<void>;
-/**
- * Checks if a project has been initialized (has .rayburst directory)
- */
-export declare function isProjectInitialized(projectPath: string): Promise<boolean>;
-/**
- * Initializes a project with .rayburst directory and metadata
- */
-export declare function initializeProject(projectPath: string, projectName: string, cliVersion: string): Promise<ProjectMeta>;

package/dist/local-storage.js

@@ -1,117 +0,0 @@
-import { promises as fs } from 'fs';
-import path from 'path';
-/**
- * Ensures the .rayburst directory exists in the project
- */
-export async function ensureRayburstDir(projectPath) {
-    const rayburstDir = path.join(projectPath, '.rayburst');
-    await fs.mkdir(rayburstDir, { recursive: true });
-    return rayburstDir;
-}
-/**
- * Reads analysis data from .rayburst/analysis.json
- */
-export async function readLocalAnalysis(projectPath) {
-    const analysisPath = path.join(projectPath, '.rayburst', 'analysis.json');
-    try {
-        const data = await fs.readFile(analysisPath, 'utf-8');
-        return JSON.parse(data);
-    }
-    catch (error) {
-        // File doesn't exist or is invalid
-        return null;
-    }
-}
-/**
- * Writes analysis data to .rayburst/analysis.json
- */
-export async function writeLocalAnalysis(projectPath, analysis) {
-    await ensureRayburstDir(projectPath);
-    const analysisPath = path.join(projectPath, '.rayburst', 'analysis.json');
-    await fs.writeFile(analysisPath, JSON.stringify(analysis, null, 2), 'utf-8');
-}
-/**
- * Reads project metadata from .rayburst/meta.json
- */
-export async function readLocalMeta(projectPath) {
-    const metaPath = path.join(projectPath, '.rayburst', 'meta.json');
-    try {
-        const data = await fs.readFile(metaPath, 'utf-8');
-        return JSON.parse(data);
-    }
-    catch (error) {
-        return null;
-    }
-}
-/**
- * Writes project metadata to .rayburst/meta.json
- */
-export async function writeLocalMeta(projectPath, meta) {
-    await ensureRayburstDir(projectPath);
-    const metaPath = path.join(projectPath, '.rayburst', 'meta.json');
-    await fs.writeFile(metaPath, JSON.stringify(meta, null, 2), 'utf-8');
-}
-/**
- * Adds .rayburst/ entry to .gitignore if not already present
- */
-export async function addGitignoreEntry(projectPath) {
-    const gitignorePath = path.join(projectPath, '.gitignore');
-    let gitignoreContent = '';
-    try {
-        gitignoreContent = await fs.readFile(gitignorePath, 'utf-8');
-    }
-    catch (error) {
-        // .gitignore doesn't exist, will create it
-    }
-    // Check if .rayburst is already in .gitignore
-    if (gitignoreContent.includes('.rayburst')) {
-        return; // Already exists
-    }
-    // Add .rayburst entry
-    const entry = '\n# Rayburst analysis data\n.rayburst/\n';
-    gitignoreContent += entry;
-    await fs.writeFile(gitignorePath, gitignoreContent, 'utf-8');
-}
-/**
- * Checks if a project has been initialized (has .rayburst directory)
- */
-export async function isProjectInitialized(projectPath) {
-    const rayburstDir = path.join(projectPath, '.rayburst');
-    try {
-        const stats = await fs.stat(rayburstDir);
-        return stats.isDirectory();
-    }
-    catch (error) {
-        return false;
-    }
-}
-/**
- * Initializes a project with .rayburst directory and metadata
- */
-export async function initializeProject(projectPath, projectName, cliVersion) {
-    // Ensure directory exists
-    await ensureRayburstDir(projectPath);
-    // Generate project ID (simple hash based on path and timestamp)
-    const projectId = generateProjectId(projectPath);
-    // Create metadata
-    const meta = {
-        projectId,
-        projectName,
-        createdAt: new Date().toISOString(),
-        cliVersion,
-    };
-    // Write metadata
-    await writeLocalMeta(projectPath, meta);
-    // Add to .gitignore
-    await addGitignoreEntry(projectPath);
-    return meta;
-}
-/**
- * Generates a simple project ID based on path
- */
-function generateProjectId(projectPath) {
-    // Simple hash: take last part of path + timestamp
-    const baseName = path.basename(projectPath);
-    const timestamp = Date.now().toString(36);
-    return `${baseName}-${timestamp}`;
-}

package/dist/registry.d.ts

@@ -1,89 +0,0 @@
-/**
- * Ensure the .rayburst directory and subdirectories exist
- */
-export declare function ensureRayburstDir(): void;
-/**
- * Read the projects registry
- */
-export declare function readRegistry(): any;
-/**
- * Write to the projects registry
- */
-export declare function writeRegistry(registry: any): boolean;
-/**
- * Generate a unique project ID from the project path
- */
-export declare function generateProjectId(projectPath: any): string;
-/**
- * Check if a directory is a valid project (has package.json)
- */
-export declare function isValidProject(projectPath: any): boolean;
-/**
- * Read package.json from a project
- */
-export declare function readPackageJson(projectPath: any): any;
-/**
- * Validate if a project's path still exists and is valid
- */
-export declare function validateProjectPath(project: any): boolean;
-/**
- * Validate all registered projects
- * Returns array of projects with validation status
- */
-export declare function validateAllProjects(): any;
-/**
- * Update a project's path
- * Validates the new path and ensures it's the same project
- */
-export declare function updateProjectPath(projectId: any, newPath: any): any;
-/**
- * Register a new project
- */
-export declare function registerProject(projectPath: any): {
-    id: string;
-    name: any;
-    path: string;
-    registeredAt: string;
-    lastAnalyzed: any;
-    packageJson: {
-        name: any;
-        version: any;
-        description: any;
-    };
-};
-/**
- * Unregister a project
- */
-export declare function unregisterProject(projectPathOrId: any): any;
-/**
- * List all registered projects
- */
-export declare function listProjects(): any;
-/**
- * Get a specific project by ID or path
- */
-export declare function getProject(projectIdOrPath: any): any;
-/**
- * Update project's lastAnalyzed timestamp
- */
-export declare function updateProjectAnalysis(projectId: any): any;
-/**
- * Get path to analysis file for a project
- */
-export declare function getAnalysisFilePath(projectId: any): string;
-/**
- * Read analysis data for a project
- */
-export declare function readAnalysisData(projectId: any): any;
-/**
- * Write analysis data for a project
- */
-export declare function writeAnalysisData(projectId: any, analysisData: any): boolean;
-/**
- * Get registry paths for external access
- */
-export declare function getRegistryPaths(): {
-    rayburstDir: string;
-    projectsFile: string;
-    analyzedDir: string;
-};