@rayburst/cli 0.1.18 → 0.2.0

package/dist/incremental-analyzer.js

@@ -0,0 +1,259 @@
+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/index.d.ts

@@ -0,0 +1,6 @@
+export { rayburstPlugin } from './vite-plugin';
+export type { RayburstPluginOptions } from './vite-plugin';
+export { analyzeProject } from './analysis/analyze-project';
+export { ensureRayburstDir, readLocalAnalysis, writeLocalAnalysis, readLocalMeta, writeLocalMeta, addGitignoreEntry, isProjectInitialized, initializeProject, } from './local-storage';
+export type { ProjectMeta } from './local-storage';
+export type { AnalysisResult } from '@rayburst/types';

package/dist/index.js

@@ -0,0 +1,6 @@
+// Main Vite plugin export
+export { rayburstPlugin } from './vite-plugin';
+// Re-export analysis functionality for advanced usage
+export { analyzeProject } from './analysis/analyze-project';
+// Re-export storage utilities
+export { ensureRayburstDir, readLocalAnalysis, writeLocalAnalysis, readLocalMeta, writeLocalMeta, addGitignoreEntry, isProjectInitialized, initializeProject, } from './local-storage';

package/dist/local-storage.d.ts

@@ -0,0 +1,39 @@
+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

@@ -0,0 +1,117 @@
+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

@@ -0,0 +1,89 @@
+/**
+ * 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;
+};