@rayburst/cli 0.1.18 → 0.2.0

package/dist/registry.js

@@ -0,0 +1,287 @@
+import fs from 'fs';
+import path from 'path';
+import { fileURLToPath } from 'url';
+import os from 'os';
+import crypto from 'crypto';
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = path.dirname(__filename);
+// Global rayburst directory in user's home
+const RAYBURST_DIR = path.join(os.homedir(), '.rayburst');
+const PROJECTS_FILE = path.join(RAYBURST_DIR, 'projects.json');
+const ANALYZED_DIR = path.join(RAYBURST_DIR, 'analyzed');
+/**
+ * Ensure the .rayburst directory and subdirectories exist
+ */
+export function ensureRayburstDir() {
+    if (!fs.existsSync(RAYBURST_DIR)) {
+        fs.mkdirSync(RAYBURST_DIR, { recursive: true });
+    }
+    if (!fs.existsSync(ANALYZED_DIR)) {
+        fs.mkdirSync(ANALYZED_DIR, { recursive: true });
+    }
+    if (!fs.existsSync(PROJECTS_FILE)) {
+        fs.writeFileSync(PROJECTS_FILE, JSON.stringify({ projects: [] }, null, 2));
+    }
+}
+/**
+ * Read the projects registry
+ */
+export function readRegistry() {
+    ensureRayburstDir();
+    try {
+        const data = fs.readFileSync(PROJECTS_FILE, 'utf-8');
+        return JSON.parse(data);
+    }
+    catch (error) {
+        console.error('Error reading registry:', error.message);
+        return { projects: [] };
+    }
+}
+/**
+ * Write to the projects registry
+ */
+export function writeRegistry(registry) {
+    ensureRayburstDir();
+    try {
+        fs.writeFileSync(PROJECTS_FILE, JSON.stringify(registry, null, 2));
+        return true;
+    }
+    catch (error) {
+        console.error('Error writing registry:', error.message);
+        return false;
+    }
+}
+/**
+ * Generate a unique project ID from the project path
+ */
+export function generateProjectId(projectPath) {
+    const hash = crypto.createHash('md5').update(projectPath).digest('hex');
+    return hash.substring(0, 12);
+}
+/**
+ * Check if a directory is a valid project (has package.json)
+ */
+export function isValidProject(projectPath) {
+    const packageJsonPath = path.join(projectPath, 'package.json');
+    return fs.existsSync(packageJsonPath);
+}
+/**
+ * Read package.json from a project
+ */
+export function readPackageJson(projectPath) {
+    const packageJsonPath = path.join(projectPath, 'package.json');
+    try {
+        const data = fs.readFileSync(packageJsonPath, 'utf-8');
+        return JSON.parse(data);
+    }
+    catch (error) {
+        console.error(`Error reading package.json:`, error.message);
+        return null;
+    }
+}
+/**
+ * Validate if a project's path still exists and is valid
+ */
+export function validateProjectPath(project) {
+    return fs.existsSync(project.path) && isValidProject(project.path);
+}
+/**
+ * Validate all registered projects
+ * Returns array of projects with validation status
+ */
+export function validateAllProjects() {
+    const registry = readRegistry();
+    return registry.projects.map(project => ({
+        ...project,
+        isValid: validateProjectPath(project),
+        pathExists: fs.existsSync(project.path)
+    }));
+}
+/**
+ * Update a project's path
+ * Validates the new path and ensures it's the same project
+ */
+export function updateProjectPath(projectId, newPath) {
+    const absolutePath = path.resolve(newPath);
+    // Validate new path
+    if (!isValidProject(absolutePath)) {
+        throw new Error(`Not a valid project: ${absolutePath} (missing package.json)`);
+    }
+    const registry = readRegistry();
+    const project = registry.projects.find(p => p.id === projectId);
+    if (!project) {
+        throw new Error(`Project not found: ${projectId}`);
+    }
+    // Check if package.json matches (to confirm it's the same project)
+    const oldPackageJson = project.packageJson;
+    const newPackageJson = readPackageJson(absolutePath);
+    if (!newPackageJson) {
+        throw new Error(`Failed to read package.json from ${absolutePath}`);
+    }
+    if (oldPackageJson.name !== newPackageJson.name) {
+        throw new Error(`Project mismatch: expected "${oldPackageJson.name}", found "${newPackageJson.name}"`);
+    }
+    // Update path and package.json info
+    project.path = absolutePath;
+    project.packageJson = {
+        name: newPackageJson.name,
+        version: newPackageJson.version,
+        description: newPackageJson.description,
+    };
+    project.updatedAt = new Date().toISOString();
+    if (writeRegistry(registry)) {
+        return project;
+    }
+    else {
+        throw new Error('Failed to update registry');
+    }
+}
+/**
+ * Register a new project
+ */
+export function registerProject(projectPath) {
+    const absolutePath = path.resolve(projectPath);
+    // Validate project
+    if (!isValidProject(absolutePath)) {
+        throw new Error(`Not a valid project: ${absolutePath} (missing package.json)`);
+    }
+    const registry = readRegistry();
+    const projectId = generateProjectId(absolutePath);
+    // Check if already registered
+    const existingIndex = registry.projects.findIndex(p => p.id === projectId);
+    if (existingIndex >= 0) {
+        throw new Error(`Project already registered: ${absolutePath}`);
+    }
+    // Read package.json
+    const packageJson = readPackageJson(absolutePath);
+    if (!packageJson) {
+        throw new Error(`Failed to read package.json from ${absolutePath}`);
+    }
+    // Create project entry
+    const project = {
+        id: projectId,
+        name: packageJson.name || path.basename(absolutePath),
+        path: absolutePath,
+        registeredAt: new Date().toISOString(),
+        lastAnalyzed: null,
+        packageJson: {
+            name: packageJson.name,
+            version: packageJson.version,
+            description: packageJson.description,
+        },
+    };
+    registry.projects.push(project);
+    if (writeRegistry(registry)) {
+        return project;
+    }
+    else {
+        throw new Error('Failed to write registry');
+    }
+}
+/**
+ * Unregister a project
+ */
+export function unregisterProject(projectPathOrId) {
+    const registry = readRegistry();
+    const absolutePath = path.resolve(projectPathOrId);
+    const projectId = generateProjectId(absolutePath);
+    // Find by ID or path
+    const index = registry.projects.findIndex(p => p.id === projectId || p.id === projectPathOrId || p.path === absolutePath);
+    if (index === -1) {
+        throw new Error(`Project not found: ${projectPathOrId}`);
+    }
+    const project = registry.projects[index];
+    registry.projects.splice(index, 1);
+    // Remove analysis data if it exists
+    const analysisFile = path.join(ANALYZED_DIR, `${project.id}.json`);
+    if (fs.existsSync(analysisFile)) {
+        fs.unlinkSync(analysisFile);
+    }
+    if (writeRegistry(registry)) {
+        return project;
+    }
+    else {
+        throw new Error('Failed to write registry');
+    }
+}
+/**
+ * List all registered projects
+ */
+export function listProjects() {
+    const registry = readRegistry();
+    return registry.projects;
+}
+/**
+ * Get a specific project by ID or path
+ */
+export function getProject(projectIdOrPath) {
+    const registry = readRegistry();
+    const absolutePath = path.resolve(projectIdOrPath);
+    const projectId = generateProjectId(absolutePath);
+    return registry.projects.find(p => p.id === projectId || p.id === projectIdOrPath || p.path === absolutePath);
+}
+/**
+ * Update project's lastAnalyzed timestamp
+ */
+export function updateProjectAnalysis(projectId) {
+    const registry = readRegistry();
+    const project = registry.projects.find(p => p.id === projectId);
+    if (!project) {
+        throw new Error(`Project not found: ${projectId}`);
+    }
+    project.lastAnalyzed = new Date().toISOString();
+    if (writeRegistry(registry)) {
+        return project;
+    }
+    else {
+        throw new Error('Failed to update registry');
+    }
+}
+/**
+ * Get path to analysis file for a project
+ */
+export function getAnalysisFilePath(projectId) {
+    return path.join(ANALYZED_DIR, `${projectId}.json`);
+}
+/**
+ * Read analysis data for a project
+ */
+export function readAnalysisData(projectId) {
+    const analysisFile = getAnalysisFilePath(projectId);
+    if (!fs.existsSync(analysisFile)) {
+        return null;
+    }
+    try {
+        const data = fs.readFileSync(analysisFile, 'utf-8');
+        return JSON.parse(data);
+    }
+    catch (error) {
+        console.error(`Error reading analysis data:`, error.message);
+        return null;
+    }
+}
+/**
+ * Write analysis data for a project
+ */
+export function writeAnalysisData(projectId, analysisData) {
+    ensureRayburstDir();
+    const analysisFile = getAnalysisFilePath(projectId);
+    try {
+        fs.writeFileSync(analysisFile, JSON.stringify(analysisData, null, 2));
+        return true;
+    }
+    catch (error) {
+        console.error(`Error writing analysis data:`, error.message);
+        return false;
+    }
+}
+/**
+ * Get registry paths for external access
+ */
+export function getRegistryPaths() {
+    return {
+        rayburstDir: RAYBURST_DIR,
+        projectsFile: PROJECTS_FILE,
+        analyzedDir: ANALYZED_DIR,
+    };
+}

package/dist/vite-plugin.d.ts

@@ -0,0 +1,7 @@
+import type { Plugin } from 'vite';
+export interface RayburstPluginOptions {
+    enabled?: boolean;
+    debounceMs?: number;
+    outputPath?: string;
+}
+export declare function rayburstPlugin(options?: RayburstPluginOptions): Plugin;

package/dist/vite-plugin.js

@@ -0,0 +1,109 @@
+import { analyzeProject } from './analysis/analyze-project';
+import { ensureRayburstDir, readLocalAnalysis, writeLocalAnalysis, addGitignoreEntry, } from './local-storage';
+import { generateDiff } from './incremental-analyzer';
+import chalk from 'chalk';
+export function rayburstPlugin(options = {}) {
+    const { enabled = process.env.CI !== 'true', // Disabled in CI by default
+    debounceMs = 1500, } = options;
+    let config;
+    let debounceTimer = null;
+    let isAnalyzing = false;
+    const runAnalysis = async (triggerFile) => {
+        if (isAnalyzing)
+            return;
+        isAnalyzing = true;
+        try {
+            const projectPath = config.root;
+            // Read previous analysis
+            const previousAnalysis = await readLocalAnalysis(projectPath);
+            // Run analysis
+            const newAnalysis = await analyzeProject(projectPath);
+            // Write to .rayburst/analysis.json
+            await writeLocalAnalysis(projectPath, newAnalysis);
+            // Show diff if previous exists
+            if (previousAnalysis) {
+                const diff = generateDiff(previousAnalysis, newAnalysis);
+                console.log(chalk.green('[Rayburst] Analysis updated:'));
+                console.log(chalk.gray(`  Added: ${diff.added.nodes.length} nodes, ${diff.added.edges.length} edges`));
+                console.log(chalk.gray(`  Removed: ${diff.removed.nodeIds.length} nodes, ${diff.removed.edgeIds.length} edges`));
+                if (diff.modified.nodes.length > 0) {
+                    console.log(chalk.gray(`  Modified: ${diff.modified.nodes.length} nodes`));
+                }
+            }
+            else {
+                const firstBranch = Object.keys(newAnalysis.planData)[0];
+                const nodeCount = firstBranch ? newAnalysis.planData[firstBranch].nodes.length : 0;
+                const edgeCount = firstBranch ? newAnalysis.planData[firstBranch].edges.length : 0;
+                console.log(chalk.green(`[Rayburst] Initial analysis complete: ${nodeCount} nodes, ${edgeCount} edges`));
+            }
+        }
+        catch (error) {
+            const message = error instanceof Error ? error.message : String(error);
+            console.error(chalk.red('[Rayburst] Analysis failed:'), message);
+        }
+        finally {
+            isAnalyzing = false;
+        }
+    };
+    return {
+        name: 'rayburst-analyzer',
+        // Hook 1: Store resolved config
+        configResolved(resolvedConfig) {
+            config = resolvedConfig;
+        },
+        // Hook 2: Run initial analysis when dev server starts
+        async buildStart() {
+            // Only run in dev mode (serve), not during build
+            if (!enabled || config.command !== 'serve') {
+                return;
+            }
+            const projectPath = config.root;
+            // Initialize project
+            await ensureRayburstDir(projectPath);
+            await addGitignoreEntry(projectPath);
+            console.log(chalk.blue('[Rayburst] Starting code analysis...'));
+            // Run initial analysis
+            await runAnalysis();
+        },
+        // Hook 3: Watch for changes using Vite's built-in watcher
+        configureServer(server) {
+            if (!enabled)
+                return;
+            const handleFileChange = (filePath) => {
+                // Only analyze TypeScript/JavaScript files
+                if (!filePath.match(/\.(ts|tsx|js|jsx)$/)) {
+                    return;
+                }
+                // Skip non-relevant files
+                if (filePath.includes('node_modules') ||
+                    filePath.includes('.rayburst') ||
+                    filePath.includes('.test.') ||
+                    filePath.includes('.spec.')) {
+                    return;
+                }
+                // Debounce rapid changes
+                if (debounceTimer) {
+                    clearTimeout(debounceTimer);
+                }
+                debounceTimer = setTimeout(() => {
+                    const relativePath = filePath.replace(config.root, '').replace(/^\//, '');
+                    console.log(chalk.dim(`[Rayburst] File changed: ${relativePath}`));
+                    runAnalysis(filePath);
+                }, debounceMs);
+            };
+            // Use Vite's built-in file watcher
+            server.watcher.on('change', handleFileChange);
+            server.watcher.on('add', handleFileChange);
+            server.watcher.on('unlink', handleFileChange);
+            // Cleanup function
+            return () => {
+                server.watcher.off('change', handleFileChange);
+                server.watcher.off('add', handleFileChange);
+                server.watcher.off('unlink', handleFileChange);
+                if (debounceTimer) {
+                    clearTimeout(debounceTimer);
+                }
+            };
+        },
+    };
+}

package/package.json

@@ -1,44 +1,55 @@
 {
   "name": "@rayburst/cli",
-  "version": "0.1.18",
-  "description": "Rayburst CLI - A module federation host for Rayburst app",
+  "version": "0.2.0",
+  "description": "Rayburst - Automatic code analysis for TypeScript/JavaScript projects via Vite plugin",
   "type": "module",
-  "bin": {
-    "rayburst": "./bin/rayburst.js"
+  "main": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.js"
+    },
+    "./vite": {
+      "types": "./dist/vite-plugin.d.ts",
+      "import": "./dist/vite-plugin.js"
+    }
   },
-  "main": "./server.js",
+  "files": [
+    "dist",
+    "README.md"
+  ],
   "scripts": {
-    "dev": "vite",
-    "build": "vite build",
-    "start": "node server.js"
+    "build": "tsc",
+    "dev": "tsc --watch"
   },
   "keywords": [
     "rayburst",
-    "cli",
-    "module-federation"
+    "vite-plugin",
+    "code-analysis",
+    "typescript",
+    "javascript",
+    "dependency-graph"
   ],
   "author": "",
   "license": "MIT",
+  "peerDependencies": {
+    "vite": "^4.0.0 || ^5.0.0 || ^6.0.0 || ^7.0.0"
+  },
+  "peerDependenciesMeta": {
+    "vite": {
+      "optional": true
+    }
+  },
   "dependencies": {
+    "@rayburst/types": "^0.1.1",
     "chalk": "^5.3.0",
-    "chokidar": "^4.0.3",
-    "commander": "^11.1.0",
-    "express": "^4.18.2",
     "ts-morph": "^21.0.1",
-    "ws": "^8.18.3"
+    "zod": "^4.2.0"
   },
   "devDependencies": {
-    "@module-federation/vite": "^1.9.0",
-    "@tailwindcss/vite": "^4.1.17",
-    "@vitejs/plugin-react": "^4.2.1",
-    "react": "^19.0.0",
-    "react-dom": "^19.0.0",
-    "tailwindcss": "^4.1.17",
-    "tw-animate-css": "^1.4.0",
+    "@types/node": "^25.0.2",
+    "typescript": "^5.9.3",
     "vite": "^7.1.7"
-  },
-  "peerDependencies": {
-    "react": "^19.0.0",
-    "react-dom": "^19.0.0"
   }
 }