@rayburst/cli 0.4.11 → 0.4.13

package/dist/{chunk-DWQK6WKX.js → chunk-CQMSZCXH.js}

@@ -1,3 +1,6 @@
+// src/vite-plugin.ts
+import { createUnplugin } from "unplugin";
+
 // src/analysis/analyze-project.ts
 import { Project, SyntaxKind, Node } from "ts-morph";
 import { execSync as execSync2 } from "child_process";
@@ -434,15 +437,15 @@ function createRouterDecisionNode(sourceFilePath, gitHash, routeCount) {
   };
 }
 function extractRoutePathFromFile(routeFilePath) {
-  let path6 = routeFilePath.replace(/^src\/routes\//, "/").replace(/\.(tsx?|jsx?)$/, "").replace(/\/route$/, "").replace(/\/index$/, "");
-  if (path6 === "/__root") {
+  let path5 = routeFilePath.replace(/^src\/routes\//, "/").replace(/\.(tsx?|jsx?)$/, "").replace(/\/route$/, "").replace(/\/index$/, "");
+  if (path5 === "/__root") {
     return "/";
   }
-  path6 = path6.replace(/\/\$([^/]+)/g, (_, param) => `/:${param}`);
-  if (path6 === "" || path6 === "/") {
+  path5 = path5.replace(/\/\$([^/]+)/g, (_, param) => `/:${param}`);
+  if (path5 === "" || path5 === "/") {
     return "/";
   }
-  return path6;
+  return path5;
 }
 function createConfigBasedEdges(sourceNode, targetFilePaths, nodeMap, edges, edgeType = "config", useRoutePathLabels = false) {
   let edgesCreated = 0;
@@ -1791,194 +1794,11 @@ function generateProjectId(projectPath) {
   return `${baseName}-${timestamp}`;
 }
 
-// src/registry.ts
-import path4 from "path";
-import { fileURLToPath } from "url";
-import os from "os";
-var __filename = fileURLToPath(import.meta.url);
-var __dirname = path4.dirname(__filename);
-var RAYBURST_DIR = path4.join(os.homedir(), ".rayburst");
-var PROJECTS_FILE = path4.join(RAYBURST_DIR, "projects.json");
-var ANALYZED_DIR = path4.join(RAYBURST_DIR, "analyzed");
-
-// src/incremental-analyzer.ts
-import chalk from "chalk";
-function generateDiff(oldAnalysis, newAnalysis) {
-  const update = {
-    added: {
-      nodes: [],
-      edges: []
-    },
-    removed: {
-      nodeIds: [],
-      edgeIds: []
-    },
-    modified: {
-      nodes: [],
-      edges: []
-    }
-  };
-  const branches = /* @__PURE__ */ 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) {
-      update.added.nodes.push(...newPlanData.nodes || []);
-      update.added.edges.push(...newPlanData.edges || []);
-      continue;
-    }
-    if (oldPlanData && !newPlanData) {
-      update.removed.nodeIds.push(...(oldPlanData.nodes || []).map((n) => n.id));
-      update.removed.edgeIds.push(...(oldPlanData.edges || []).map((e) => e.id));
-      continue;
-    }
-    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;
-}
-function comparePlanData(oldPlanData, newPlanData) {
-  const oldNodes = oldPlanData?.nodes || [];
-  const newNodes = newPlanData?.nodes || [];
-  const oldEdges = oldPlanData?.edges || [];
-  const newEdges = newPlanData?.edges || [];
-  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: [] }
-  };
-  for (const [nodeId, newNode] of newNodeMap) {
-    const oldNode = oldNodeMap.get(nodeId);
-    if (!oldNode) {
-      diff.added.nodes.push(newNode);
-    } else if (hasNodeChanged(oldNode, newNode)) {
-      diff.modified.nodes.push({
-        id: nodeId,
-        ...getNodeChanges(oldNode, newNode)
-      });
-    }
-  }
-  for (const nodeId of oldNodeMap.keys()) {
-    if (!newNodeMap.has(nodeId)) {
-      diff.removed.nodeIds.push(nodeId);
-    }
-  }
-  for (const [edgeId, newEdge] of newEdgeMap) {
-    const oldEdge = oldEdgeMap.get(edgeId);
-    if (!oldEdge) {
-      diff.added.edges.push(newEdge);
-    } else if (hasEdgeChanged(oldEdge, newEdge)) {
-      diff.modified.edges.push({
-        id: edgeId,
-        ...getEdgeChanges(oldEdge, newEdge)
-      });
-    }
-  }
-  for (const edgeId of oldEdgeMap.keys()) {
-    if (!newEdgeMap.has(edgeId)) {
-      diff.removed.edgeIds.push(edgeId);
-    }
-  }
-  return diff;
-}
-function hasNodeChanged(oldNode, newNode) {
-  const oldData = JSON.stringify({ ...oldNode.data, type: oldNode.type });
-  const newData = JSON.stringify({ ...newNode.data, type: newNode.type });
-  return oldData !== newData;
-}
-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;
-}
-function hasEdgeChanged(oldEdge, newEdge) {
-  return oldEdge.source !== newEdge.source || oldEdge.target !== newEdge.target || oldEdge.type !== newEdge.type || JSON.stringify(oldEdge.data) !== JSON.stringify(newEdge.data);
-}
-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;
-}
-function generateChangeHistoryEntry(diff, trigger, gitCommitHash, newPlanData) {
-  const timestamp = Date.now();
-  const analysisRunId = `${timestamp}-${Math.random().toString(36).substring(7)}`;
-  const nodeChanges = [];
-  for (const node of diff.added.nodes) {
-    const filePath = node.id.split("::")[0] || "unknown";
-    nodeChanges.push({
-      timestamp,
-      nodeId: node.id,
-      changeType: "added",
-      changedFields: void 0,
-      previousState: void 0,
-      currentState: node,
-      filePath
-    });
-  }
-  for (const nodeId of diff.removed.nodeIds) {
-    const filePath = nodeId.split("::")[0] || "unknown";
-    nodeChanges.push({
-      timestamp,
-      nodeId,
-      changeType: "removed",
-      changedFields: void 0,
-      previousState: void 0,
-      // We don't have the previous state in current diff
-      currentState: void 0,
-      filePath
-    });
-  }
-  for (const modifiedNode of diff.modified.nodes) {
-    const filePath = modifiedNode.id.split("::")[0] || "unknown";
-    const changedFields = Object.keys(modifiedNode.changes || {});
-    nodeChanges.push({
-      timestamp,
-      nodeId: modifiedNode.id,
-      changeType: "modified",
-      changedFields: changedFields.length > 0 ? changedFields : void 0,
-      previousState: void 0,
-      // Would need old plan data to populate
-      currentState: newPlanData.nodes.find((n) => n.id === modifiedNode.id),
-      filePath
-    });
-  }
-  return {
-    timestamp,
-    analysisRunId,
-    trigger,
-    nodeChanges,
-    gitCommitHash
-  };
-}
-
 // src/vite-plugin.ts
-import chalk2 from "chalk";
+import chalk from "chalk";
 import * as fs3 from "fs";
-import * as path5 from "path";
-import chokidar from "chokidar";
-function rayburstPlugin(options = {}) {
+import * as path4 from "path";
+var unpluginFactory = (options = {}) => {
   const {
     enabled = process.env.CI !== "true",
     // Disabled in CI by default
@@ -1989,14 +1809,13 @@ function rayburstPlugin(options = {}) {
   let isAnalyzing = false;
   let lastGitState = null;
   let gitPollInterval = null;
-  let fileWatcher = null;
   const checkGitState = (projectPath) => {
     try {
-      const gitDir = path5.join(projectPath, ".git");
+      const gitDir = path4.join(projectPath, ".git");
       if (!fs3.existsSync(gitDir)) {
         return false;
       }
-      const headPath = path5.join(gitDir, "HEAD");
+      const headPath = path4.join(gitDir, "HEAD");
       if (!fs3.existsSync(headPath)) {
         return false;
       }
@@ -2004,7 +1823,7 @@ function rayburstPlugin(options = {}) {
       let gitState = headContent;
       if (headContent.startsWith("ref: ")) {
         const refPath = headContent.substring(5);
-        const fullRefPath = path5.join(gitDir, refPath);
+        const fullRefPath = path4.join(gitDir, refPath);
         if (fs3.existsSync(fullRefPath)) {
           const refContent = fs3.readFileSync(fullRefPath, "utf-8").trim();
           gitState = `${headContent}:${refContent}`;
@@ -2030,159 +1849,100 @@ function rayburstPlugin(options = {}) {
       const projectPath = config.root;
       const previousAnalysis = await readLocalAnalysis(projectPath);
       const newAnalysis = await analyzeProject(projectPath);
-      const branches = Object.keys(newAnalysis.planData);
-      if (!newAnalysis.changeHistory && branches.length > 0) {
-        newAnalysis.changeHistory = {};
-        for (const branchId of branches) {
-          newAnalysis.changeHistory[branchId] = [];
-        }
-      }
       if (previousAnalysis) {
-        const diff = generateDiff(previousAnalysis, newAnalysis);
-        if (diff.added.nodes.length > 0 || diff.removed.nodeIds.length > 0 || diff.modified.nodes.length > 0) {
-          const trigger = triggerFile === "git-event" || triggerFile === "git-poll" ? "git-commit" : "file-change";
-          const firstBranch = Object.keys(newAnalysis.planData)[0];
-          if (firstBranch) {
-            const planData = newAnalysis.planData[firstBranch];
-            const historyEntry = generateChangeHistoryEntry(diff, trigger, void 0, planData);
-            const existingHistory = previousAnalysis.changeHistory?.[firstBranch] || [];
-            const maxHistoryEntries = 100;
-            const updatedHistory = [...existingHistory, historyEntry].slice(-maxHistoryEntries);
-            newAnalysis.changeHistory = {
-              ...newAnalysis.changeHistory,
-              [firstBranch]: updatedHistory
-            };
-          }
-        }
-        console.log(chalk2.green("[Rayburst] Analysis updated:"));
-        console.log(
-          chalk2.gray(
-            `  Added: ${diff.added.nodes.length} nodes, ${diff.added.edges.length} edges`
-          )
-        );
-        console.log(
-          chalk2.gray(
-            `  Removed: ${diff.removed.nodeIds.length} nodes, ${diff.removed.edgeIds.length} edges`
-          )
-        );
-        if (diff.modified.nodes.length > 0) {
-          console.log(chalk2.gray(`  Modified: ${diff.modified.nodes.length} nodes`));
-        }
+        console.log(chalk.green("[Rayburst] Analysis updated"));
       } 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(
-          chalk2.green(`[Rayburst] Initial analysis complete: ${nodeCount} nodes, ${edgeCount} edges`)
+          chalk.green(`[Rayburst] Initial analysis complete: ${nodeCount} nodes, ${edgeCount} edges`)
         );
       }
       await writeLocalAnalysis(projectPath, newAnalysis);
     } catch (error) {
       const message = error instanceof Error ? error.message : String(error);
-      console.error(chalk2.red("[Rayburst] Analysis failed:"), message);
+      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() {
-      if (!enabled || config.command !== "serve") {
+    enforce: "pre",
+    // This hook is automatically called by Vite/Rollup when files change!
+    async watchChange(id, { event }) {
+      if (!enabled) return;
+      console.log(chalk.gray(`[Rayburst] Raw file event: ${event} ${id}`));
+      if (!id.match(/\.(ts|tsx|js|jsx)$/)) {
+        console.log(chalk.gray(`[Rayburst] Skipping (not TS/JS): ${id}`));
         return;
       }
-      const projectPath = config.root;
-      await ensureRayburstDir(projectPath);
-      await addGitignoreEntry(projectPath);
-      console.log(chalk2.blue("[Rayburst] Starting code analysis..."));
-      await runAnalysis();
+      if (id.includes("node_modules") || id.includes(".rayburst") || id.includes(".test.") || id.includes(".spec.")) {
+        console.log(chalk.gray(`[Rayburst] Skipping (filtered): ${id}`));
+        return;
+      }
+      console.log(chalk.yellow(`[Rayburst] Accepted file ${event}: ${id}`));
+      if (debounceTimer) {
+        clearTimeout(debounceTimer);
+      }
+      debounceTimer = setTimeout(() => {
+        const relativePath = id.replace(config.root, "").replace(/^\//, "");
+        console.log(chalk.dim(`[Rayburst] Triggering analysis after debounce for: ${relativePath}`));
+        runAnalysis(id);
+      }, debounceMs);
     },
-    // Hook 3: Watch for changes using dedicated Chokidar watcher
-    configureServer(server) {
-      if (!enabled) return;
-      console.log(chalk2.blue("[Rayburst] Configuring file watcher..."));
-      const handleFileChange = (filePath) => {
-        console.log(chalk2.gray(`[Rayburst] Raw file event: ${filePath}`));
-        if (!filePath.match(/\.(ts|tsx|js|jsx)$/)) {
-          console.log(chalk2.gray(`[Rayburst] Skipping (not TS/JS): ${filePath}`));
-          return;
-        }
-        if (filePath.includes("node_modules") || filePath.includes(".rayburst") || filePath.includes(".test.") || filePath.includes(".spec.")) {
-          console.log(chalk2.gray(`[Rayburst] Skipping (filtered): ${filePath}`));
+    // Vite-specific hooks
+    vite: {
+      configResolved(resolvedConfig) {
+        config = resolvedConfig;
+      },
+      async buildStart() {
+        if (!enabled || config.command !== "serve") {
           return;
         }
-        console.log(chalk2.yellow(`[Rayburst] Accepted file change: ${filePath}`));
-        if (debounceTimer) {
-          clearTimeout(debounceTimer);
+        const projectPath = config.root;
+        await ensureRayburstDir(projectPath);
+        await addGitignoreEntry(projectPath);
+        console.log(chalk.blue("[Rayburst] Starting code analysis..."));
+        await runAnalysis();
+      },
+      configureServer(server) {
+        if (!enabled) return;
+        console.log(chalk.blue("[Rayburst] Configuring git watcher..."));
+        const gitHeadPath = path4.join(config.root, ".git", "HEAD");
+        if (fs3.existsSync(gitHeadPath)) {
+          server.watcher.add(gitHeadPath);
+          const handleGitChange = (changedPath) => {
+            if (changedPath === gitHeadPath || changedPath.includes(".git/refs/heads/")) {
+              console.log(chalk.dim("[Rayburst] Git state changed, re-analyzing..."));
+              runAnalysis("git-event");
+            }
+          };
+          server.watcher.on("change", handleGitChange);
+          checkGitState(config.root);
+          gitPollInterval = setInterval(() => {
+            if (checkGitState(config.root)) {
+              console.log(chalk.dim("[Rayburst] Git state changed (poll), re-analyzing..."));
+              runAnalysis("git-poll");
+            }
+          }, 5e3);
         }
-        debounceTimer = setTimeout(() => {
-          const relativePath = filePath.replace(config.root, "").replace(/^\//, "");
-          console.log(chalk2.dim(`[Rayburst] File changed (after debounce): ${relativePath}`));
-          runAnalysis(filePath);
-        }, debounceMs);
-      };
-      const srcPath = path5.join(config.root, "src");
-      if (fs3.existsSync(srcPath)) {
-        console.log(chalk2.blue("[Rayburst] Creating dedicated file watcher..."));
-        fileWatcher = chokidar.watch(srcPath, {
-          ignored: [
-            "**/node_modules/**",
-            "**/.rayburst/**",
-            "**/*.test.*",
-            "**/*.spec.*",
-            "**/.git/**"
-          ],
-          persistent: true,
-          ignoreInitial: true,
-          awaitWriteFinish: {
-            stabilityThreshold: 100,
-            pollInterval: 100
+        return () => {
+          if (debounceTimer) {
+            clearTimeout(debounceTimer);
           }
-        });
-        fileWatcher.on("ready", () => {
-          console.log(chalk2.green("[Rayburst] File watcher is ready and monitoring changes"));
-        });
-        fileWatcher.on("change", handleFileChange);
-        fileWatcher.on("add", handleFileChange);
-        fileWatcher.on("unlink", handleFileChange);
-        console.log(chalk2.dim(`[Rayburst] Watching directory: ${srcPath}`));
-      }
-      const gitHeadPath = path5.join(config.root, ".git", "HEAD");
-      if (fs3.existsSync(gitHeadPath)) {
-        server.watcher.add(gitHeadPath);
-        const handleGitChange = (changedPath) => {
-          if (changedPath === gitHeadPath || changedPath.includes(".git/refs/heads/")) {
-            console.log(chalk2.dim("[Rayburst] Git state changed, re-analyzing..."));
-            runAnalysis("git-event");
+          if (gitPollInterval) {
+            clearInterval(gitPollInterval);
           }
         };
-        server.watcher.on("change", handleGitChange);
-        checkGitState(config.root);
-        gitPollInterval = setInterval(() => {
-          if (checkGitState(config.root)) {
-            console.log(chalk2.dim("[Rayburst] Git state changed (poll), re-analyzing..."));
-            runAnalysis("git-poll");
-          }
-        }, 5e3);
       }
-      return () => {
-        if (fileWatcher) {
-          fileWatcher.close();
-        }
-        if (debounceTimer) {
-          clearTimeout(debounceTimer);
-        }
-        if (gitPollInterval) {
-          clearInterval(gitPollInterval);
-        }
-      };
     }
   };
-}
+};
+var unplugin = createUnplugin(unpluginFactory);
+var rayburstPlugin = unplugin.vite;
+var vite_plugin_default = rayburstPlugin;
 
 export {
   analyzeProject,
@@ -2194,5 +1954,7 @@ export {
   addGitignoreEntry,
   isProjectInitialized,
   initializeProject,
-  rayburstPlugin
+  unpluginFactory,
+  rayburstPlugin,
+  vite_plugin_default
 };

package/dist/index.d.ts

@@ -1,7 +1,8 @@
-export { RayburstPluginOptions, rayburstPlugin } from './vite-plugin.js';
+export { RayburstPluginOptions, default as rayburstPlugin } from './vite-plugin.js';
 import { AnalysisResult } from '@rayburst/types';
 export { AnalysisResult } from '@rayburst/types';
 import 'vite';
+import 'unplugin';
 
 /**
  * Analyze a TypeScript/React project and generate nodes/edges data

package/dist/index.js

@@ -9,7 +9,7 @@ import {
   readLocalMeta,
   writeLocalAnalysis,
   writeLocalMeta
-} from "./chunk-DWQK6WKX.js";
+} from "./chunk-CQMSZCXH.js";
 export {
   addGitignoreEntry,
   analyzeProject,

package/dist/vite-plugin.d.ts

@@ -1,10 +1,12 @@
-import { Plugin } from 'vite';
+import * as vite from 'vite';
+import { UnpluginFactory } from 'unplugin';
 
 interface RayburstPluginOptions {
     enabled?: boolean;
     debounceMs?: number;
     outputPath?: string;
 }
-declare function rayburstPlugin(options?: RayburstPluginOptions): Plugin;
+declare const unpluginFactory: UnpluginFactory<RayburstPluginOptions | undefined>;
+declare const rayburstPlugin: (options?: RayburstPluginOptions) => vite.Plugin<any> | vite.Plugin<any>[];
 
-export { type RayburstPluginOptions, rayburstPlugin };
+export { type RayburstPluginOptions, rayburstPlugin as default, rayburstPlugin, unpluginFactory };

package/dist/vite-plugin.js

@@ -1,6 +1,10 @@
 import {
-  rayburstPlugin
-} from "./chunk-DWQK6WKX.js";
+  rayburstPlugin,
+  unpluginFactory,
+  vite_plugin_default
+} from "./chunk-CQMSZCXH.js";
 export {
-  rayburstPlugin
+  vite_plugin_default as default,
+  rayburstPlugin,
+  unpluginFactory
 };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@rayburst/cli",
-  "version": "0.4.11",
+  "version": "0.4.13",
   "description": "Rayburst - Automatic code analysis for TypeScript/JavaScript projects via Vite plugin",
   "type": "module",
   "main": "./dist/index.js",
@@ -44,12 +44,12 @@
   "dependencies": {
     "@rayburst/cli": "^0.4.9",
     "chalk": "^5.3.0",
-    "chokidar": "^3.6.0",
     "ts-morph": "^21.0.1",
+    "unplugin": "^1.16.1",
     "zod": "^4.2.0"
   },
   "devDependencies": {
-    "@rayburst/types": "^0.1.9",
+    "@rayburst/types": "^0.1.10",
     "@types/node": "^25.0.2",
     "tsup": "^8.5.1",
     "typescript": "^5.9.3",