@rayburst/cli 0.1.0 → 0.1.8

package/src/registry.js

@@ -0,0 +1,262 @@
+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;
+  }
+}
+
+/**
+ * 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/vite-plugin-api.js

@@ -0,0 +1,123 @@
+import {
+  listProjects,
+  getProject,
+  readAnalysisData,
+  registerProject,
+  unregisterProject,
+} from './src/registry.js';
+import { getAllChangedFiles } from './src/git-utils.js';
+
+/**
+ * Vite plugin to handle API routes during development
+ */
+export function apiPlugin() {
+  return {
+    name: 'rayburst-api',
+    configureServer(server) {
+      server.middlewares.use('/api', (req, res, next) => {
+        // Parse JSON body for POST requests
+        if (req.method === 'POST' || req.method === 'PUT') {
+          let body = '';
+          req.on('data', chunk => {
+            body += chunk.toString();
+          });
+          req.on('end', () => {
+            try {
+              req.body = JSON.parse(body);
+            } catch (e) {
+              req.body = {};
+            }
+            handleApiRequest(req, res, next);
+          });
+        } else {
+          handleApiRequest(req, res, next);
+        }
+      });
+    },
+  };
+}
+
+function handleApiRequest(req, res, next) {
+  const url = (req.url || '').replace('/api', ''); // Remove /api prefix since middleware already matched it
+  const method = req.method;
+
+  // Set JSON response headers
+  res.setHeader('Content-Type', 'application/json');
+
+  try {
+    // GET /api/projects - List all projects
+    if (method === 'GET' && url === '/projects') {
+      const projects = listProjects();
+      res.end(JSON.stringify({ projects }));
+      return;
+    }
+
+    // GET /projects/:id/changed-files - Get uncommitted changed files (check before generic project route)
+    if (method === 'GET' && url.includes('/changed-files')) {
+      const id = url.split('/')[2];
+      const project = getProject(id);
+      if (!project) {
+        res.statusCode = 404;
+        res.end(JSON.stringify({ error: 'Project not found' }));
+        return;
+      }
+      const changedFiles = getAllChangedFiles(project.path);
+      res.end(JSON.stringify({ changedFiles }));
+      return;
+    }
+
+    // GET /projects/:id/analysis - Get project analysis
+    if (method === 'GET' && url.includes('/analysis')) {
+      const id = url.split('/')[2];
+      const analysisData = readAnalysisData(id);
+      if (!analysisData) {
+        res.statusCode = 404;
+        res.end(JSON.stringify({ error: 'Analysis data not found' }));
+        return;
+      }
+      res.end(JSON.stringify(analysisData));
+      return;
+    }
+
+    // GET /projects/:id - Get specific project
+    if (method === 'GET' && url.startsWith('/projects/') && !url.includes('/analysis') && !url.includes('/changed-files')) {
+      const id = url.split('/')[2];
+      const project = getProject(id);
+      if (!project) {
+        res.statusCode = 404;
+        res.end(JSON.stringify({ error: 'Project not found' }));
+        return;
+      }
+      res.end(JSON.stringify({ project }));
+      return;
+    }
+
+    // POST /projects/register - Register project
+    if (method === 'POST' && url === '/projects/register') {
+      const { path } = req.body || {};
+      if (!path) {
+        res.statusCode = 400;
+        res.end(JSON.stringify({ error: 'Path is required' }));
+        return;
+      }
+      const project = registerProject(path);
+      res.end(JSON.stringify({ project }));
+      return;
+    }
+
+    // DELETE /projects/:id - Unregister project
+    if (method === 'DELETE' && url.startsWith('/projects/')) {
+      const id = url.split('/')[2];
+      const project = unregisterProject(id);
+      res.end(JSON.stringify({ project }));
+      return;
+    }
+
+    // No matching route
+    res.statusCode = 404;
+    res.end(JSON.stringify({ error: 'API endpoint not found' }));
+  } catch (error) {
+    res.statusCode = 500;
+    res.end(JSON.stringify({ error: error.message }));
+  }
+}

package/vite.config.ts

@@ -0,0 +1,72 @@
+import { defineConfig } from 'vite';
+import react from '@vitejs/plugin-react';
+import { federation } from '@module-federation/vite';
+import { apiPlugin } from './vite-plugin-api.js';
+
+// Determine remote URL based on environment
+function getRemoteUrl(env: string): string {
+  switch (env) {
+    case 'production':
+      return 'https://www.rayburst.app';
+    case 'staging':
+      return 'https://dev.rayburst.app';
+    case 'development':
+    default:
+      return 'http://localhost:3000';
+  }
+}
+
+export default defineConfig(() => {
+  const environment = process.env.NODE_ENV || 'development';
+  const remoteUrl = getRemoteUrl(environment);
+
+  console.log(`🔧 Building CLI for environment: ${environment}`);
+  console.log(`📡 Remote URL: ${remoteUrl}`);
+
+  return {
+    plugins: [
+      apiPlugin(),
+      react(),
+      federation({
+        name: 'rayburstCli',
+        remotes: {
+          rayburstApp: {
+            type: 'module',
+            name: 'rayburstApp',
+            entry: `${remoteUrl}/remoteEntry.js?t=${Date.now()}`,
+          },
+        },
+        shared: {
+          react: {
+            singleton: true,
+            requiredVersion: '^19.0.0',
+          },
+          'react-dom': {
+            singleton: true,
+            requiredVersion: '^19.0.0',
+          },
+        },
+      }),
+    ],
+
+    build: {
+      modulePreload: false,
+      target: 'esnext',
+      minify: false,
+      cssCodeSplit: false,
+      outDir: 'dist',
+    },
+
+    server: {
+      port: 3105,
+      strictPort: true,
+      host: true,
+    },
+
+    preview: {
+      port: 3105,
+      strictPort: true,
+      host: true,
+    },
+  };
+});

package/dist/assets/_commonjsHelpers-B85MJLTf.js

@@ -1,5 +0,0 @@
-function getDefaultExportFromCjs (x) {
-	return x && x.__esModule && Object.prototype.hasOwnProperty.call(x, 'default') ? x['default'] : x;
-}
-
-export { getDefaultExportFromCjs as g };

package/dist/assets/hostInit-CYZeRSfr.js

@@ -1,9 +0,0 @@
-import { _ as __vitePreload } from './preload-helper-Dea3Szod.js';
-
-const remoteEntryPromise = __vitePreload(() => import('./remoteEntry-BkHjZ4dx.js'),true              ?[]:void 0);
-    // __tla only serves as a hack for vite-plugin-top-level-await.
-    Promise.resolve(remoteEntryPromise)
-      .then(remoteEntry => {
-        return Promise.resolve(remoteEntry.__tla)
-          .then(remoteEntry.init).catch(remoteEntry.init)
-      });