@rayburst/cli 0.4.12 → 0.4.14

package/dist/{chunk-ANVJHFHG.js → chunk-Q2M2UILE.js}

@@ -30,6 +30,79 @@ function getUncommittedChanges(projectPath) {
     return [];
   }
 }
+function getUnstagedChanges(projectPath) {
+  try {
+    if (!isGitRepository(projectPath)) {
+      return [];
+    }
+    const output = execSync("git diff --name-only", {
+      cwd: projectPath,
+      encoding: "utf8",
+      stdio: ["pipe", "pipe", "ignore"]
+    });
+    return output.split("\n").filter(Boolean).map((file) => path.resolve(projectPath, file.trim()));
+  } catch (error) {
+    console.error("Failed to get unstaged changes:", error.message);
+    return [];
+  }
+}
+function getStagedChanges(projectPath) {
+  try {
+    if (!isGitRepository(projectPath)) {
+      return [];
+    }
+    const output = execSync("git diff --name-only --cached", {
+      cwd: projectPath,
+      encoding: "utf8",
+      stdio: ["pipe", "pipe", "ignore"]
+    });
+    return output.split("\n").filter(Boolean).map((file) => path.resolve(projectPath, file.trim()));
+  } catch (error) {
+    console.error("Failed to get staged changes:", error.message);
+    return [];
+  }
+}
+function getCommittedChanges(projectPath, remoteBranch = void 0) {
+  try {
+    if (!isGitRepository(projectPath)) {
+      return [];
+    }
+    let currentBranch;
+    try {
+      currentBranch = execSync("git branch --show-current", {
+        cwd: projectPath,
+        encoding: "utf8",
+        stdio: ["pipe", "pipe", "ignore"]
+      }).trim();
+    } catch {
+      currentBranch = execSync("git rev-parse --abbrev-ref HEAD", {
+        cwd: projectPath,
+        encoding: "utf8",
+        stdio: ["pipe", "pipe", "ignore"]
+      }).trim();
+    }
+    const remote = remoteBranch || `origin/${currentBranch}`;
+    try {
+      execSync(`git rev-parse --verify ${remote}`, {
+        cwd: projectPath,
+        stdio: ["pipe", "pipe", "ignore"]
+      });
+    } catch {
+      return [];
+    }
+    const output = execSync(`git diff --name-only ${remote}...HEAD`, {
+      cwd: projectPath,
+      encoding: "utf8",
+      stdio: ["pipe", "pipe", "ignore"]
+    });
+    const allChanges = output.split("\n").filter(Boolean).map((file) => path.resolve(projectPath, file.trim()));
+    const uncommitted = new Set(getUncommittedChanges(projectPath));
+    return allChanges.filter((file) => !uncommitted.has(file));
+  } catch (error) {
+    console.error("Failed to get committed changes:", error.message);
+    return [];
+  }
+}
 function isGitRepository(projectPath) {
   try {
     execSync("git rev-parse --is-inside-work-tree", {
@@ -437,15 +510,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;
@@ -946,26 +1019,44 @@ async function analyzeProject(projectPath, projectId, onLog) {
       nodes,
       edges
     };
+    const filterAndCollectMetadata = (files) => {
+      const filtered = files.filter((filePath) => {
+        return !filePath.includes("node_modules") && !filePath.includes(".test.") && !filePath.includes(".spec.") && (filePath.endsWith(".ts") || filePath.endsWith(".tsx") || filePath.endsWith(".js") || filePath.endsWith(".jsx"));
+      });
+      const metadata = [];
+      for (const filePath of filtered) {
+        try {
+          const stats = fs.statSync(filePath);
+          metadata.push({
+            filePath,
+            lastModified: stats.mtimeMs
+          });
+        } catch (error) {
+          log(`  Warning: Could not get stats for ${filePath}`);
+        }
+      }
+      return { filtered, metadata };
+    };
     log("  Checking for changed files vs remote...");
     const allChangedFiles = getChangedFilesVsRemote(projectPath);
     log(`  Found ${allChangedFiles.length} changed files`);
-    const changedFiles = allChangedFiles.filter((filePath) => {
-      return !filePath.includes("node_modules") && !filePath.includes(".test.") && !filePath.includes(".spec.") && (filePath.endsWith(".ts") || filePath.endsWith(".tsx") || filePath.endsWith(".js") || filePath.endsWith(".jsx"));
-    });
+    const { filtered: changedFiles, metadata: changedFilesMetadata } = filterAndCollectMetadata(allChangedFiles);
     log(`  Filtered to ${changedFiles.length} analyzed source files`);
-    const changedFilesMetadata = [];
-    for (const filePath of changedFiles) {
-      try {
-        const stats = fs.statSync(filePath);
-        changedFilesMetadata.push({
-          filePath,
-          lastModified: stats.mtimeMs
-          // Unix timestamp in milliseconds
-        });
-      } catch (error) {
-        log(`  Warning: Could not get stats for ${filePath}`);
-      }
-    }
+    log("  Checking for unstaged changes...");
+    const allUnstagedFiles = getUnstagedChanges(projectPath);
+    log(`  Found ${allUnstagedFiles.length} unstaged files`);
+    const { filtered: unstagedFiles, metadata: unstagedFilesMetadata } = filterAndCollectMetadata(allUnstagedFiles);
+    log(`  Filtered to ${unstagedFiles.length} analyzed source files`);
+    log("  Checking for staged changes...");
+    const allStagedFiles = getStagedChanges(projectPath);
+    log(`  Found ${allStagedFiles.length} staged files`);
+    const { filtered: stagedFiles, metadata: stagedFilesMetadata } = filterAndCollectMetadata(allStagedFiles);
+    log(`  Filtered to ${stagedFiles.length} analyzed source files`);
+    log("  Checking for committed changes...");
+    const allCommittedFiles = getCommittedChanges(projectPath);
+    log(`  Found ${allCommittedFiles.length} committed files`);
+    const { filtered: committedFiles, metadata: committedFilesMetadata } = filterAndCollectMetadata(allCommittedFiles);
+    log(`  Filtered to ${committedFiles.length} analyzed source files`);
     const result = {
       project: projectMetadata,
       branches: [branchMetadata],
@@ -979,6 +1070,24 @@ async function analyzeProject(projectPath, projectId, onLog) {
       } : void 0,
       changedFilesMetadata: changedFilesMetadata.length > 0 ? {
         [branchId]: changedFilesMetadata
+      } : void 0,
+      unstagedFiles: unstagedFiles.length > 0 ? {
+        [branchId]: unstagedFiles
+      } : void 0,
+      unstagedFilesMetadata: unstagedFilesMetadata.length > 0 ? {
+        [branchId]: unstagedFilesMetadata
+      } : void 0,
+      stagedFiles: stagedFiles.length > 0 ? {
+        [branchId]: stagedFiles
+      } : void 0,
+      stagedFilesMetadata: stagedFilesMetadata.length > 0 ? {
+        [branchId]: stagedFilesMetadata
+      } : void 0,
+      committedFiles: committedFiles.length > 0 ? {
+        [branchId]: committedFiles
+      } : void 0,
+      committedFilesMetadata: committedFilesMetadata.length > 0 ? {
+        [branchId]: committedFilesMetadata
       } : void 0
     };
     return result;
@@ -1794,192 +1903,10 @@ 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 * as path4 from "path";
 var unpluginFactory = (options = {}) => {
   const {
     enabled = process.env.CI !== "true",
@@ -1993,11 +1920,11 @@ var unpluginFactory = (options = {}) => {
   let gitPollInterval = 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;
       }
@@ -2005,7 +1932,7 @@ var unpluginFactory = (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}`;
@@ -2031,56 +1958,20 @@ var unpluginFactory = (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;
     }
@@ -2091,22 +1982,22 @@ var unpluginFactory = (options = {}) => {
     // This hook is automatically called by Vite/Rollup when files change!
     async watchChange(id, { event }) {
       if (!enabled) return;
-      console.log(chalk2.gray(`[Rayburst] Raw file event: ${event} ${id}`));
+      console.log(chalk.gray(`[Rayburst] Raw file event: ${event} ${id}`));
       if (!id.match(/\.(ts|tsx|js|jsx)$/)) {
-        console.log(chalk2.gray(`[Rayburst] Skipping (not TS/JS): ${id}`));
+        console.log(chalk.gray(`[Rayburst] Skipping (not TS/JS): ${id}`));
         return;
       }
       if (id.includes("node_modules") || id.includes(".rayburst") || id.includes(".test.") || id.includes(".spec.")) {
-        console.log(chalk2.gray(`[Rayburst] Skipping (filtered): ${id}`));
+        console.log(chalk.gray(`[Rayburst] Skipping (filtered): ${id}`));
         return;
       }
-      console.log(chalk2.yellow(`[Rayburst] Accepted file ${event}: ${id}`));
+      console.log(chalk.yellow(`[Rayburst] Accepted file ${event}: ${id}`));
       if (debounceTimer) {
         clearTimeout(debounceTimer);
       }
       debounceTimer = setTimeout(() => {
         const relativePath = id.replace(config.root, "").replace(/^\//, "");
-        console.log(chalk2.dim(`[Rayburst] Triggering analysis after debounce for: ${relativePath}`));
+        console.log(chalk.dim(`[Rayburst] Triggering analysis after debounce for: ${relativePath}`));
         runAnalysis(id);
       }, debounceMs);
     },
@@ -2122,18 +2013,18 @@ var unpluginFactory = (options = {}) => {
         const projectPath = config.root;
         await ensureRayburstDir(projectPath);
         await addGitignoreEntry(projectPath);
-        console.log(chalk2.blue("[Rayburst] Starting code analysis..."));
+        console.log(chalk.blue("[Rayburst] Starting code analysis..."));
         await runAnalysis();
       },
       configureServer(server) {
         if (!enabled) return;
-        console.log(chalk2.blue("[Rayburst] Configuring git watcher..."));
-        const gitHeadPath = path5.join(config.root, ".git", "HEAD");
+        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(chalk2.dim("[Rayburst] Git state changed, re-analyzing..."));
+              console.log(chalk.dim("[Rayburst] Git state changed, re-analyzing..."));
               runAnalysis("git-event");
             }
           };
@@ -2141,7 +2032,7 @@ var unpluginFactory = (options = {}) => {
           checkGitState(config.root);
           gitPollInterval = setInterval(() => {
             if (checkGitState(config.root)) {
-              console.log(chalk2.dim("[Rayburst] Git state changed (poll), re-analyzing..."));
+              console.log(chalk.dim("[Rayburst] Git state changed (poll), re-analyzing..."));
               runAnalysis("git-poll");
             }
           }, 5e3);

package/dist/index.js

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

package/dist/vite-plugin.js

@@ -2,7 +2,7 @@ import {
   rayburstPlugin,
   unpluginFactory,
   vite_plugin_default
-} from "./chunk-ANVJHFHG.js";
+} from "./chunk-Q2M2UILE.js";
 export {
   vite_plugin_default as default,
   rayburstPlugin,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@rayburst/cli",
-  "version": "0.4.12",
+  "version": "0.4.14",
   "description": "Rayburst - Automatic code analysis for TypeScript/JavaScript projects via Vite plugin",
   "type": "module",
   "main": "./dist/index.js",
@@ -49,7 +49,7 @@
     "zod": "^4.2.0"
   },
   "devDependencies": {
-    "@rayburst/types": "^0.1.9",
+    "@rayburst/types": "^0.1.11",
     "@types/node": "^25.0.2",
     "tsup": "^8.5.1",
     "typescript": "^5.9.3",