@rayburst/cli 0.4.13 → 0.4.15

package/dist/{chunk-CQMSZCXH.js → chunk-TYZZLVC2.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", {
@@ -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;
@@ -1809,6 +1918,60 @@ var unpluginFactory = (options = {}) => {
   let isAnalyzing = false;
   let lastGitState = null;
   let gitPollInterval = null;
+  const changeHistoryMap = {};
+  const MAX_HISTORY_ENTRIES = 100;
+  const generateNodeChanges = (branchId, oldNodes, newNodes) => {
+    const changes = [];
+    const timestamp = Date.now();
+    const oldNodesMap = new Map((oldNodes || []).map((n) => [n.id, n]));
+    const newNodesMap = new Map(newNodes.map((n) => [n.id, n]));
+    for (const newNode of newNodes) {
+      const oldNode = oldNodesMap.get(newNode.id);
+      if (!oldNode) {
+        changes.push({
+          timestamp,
+          nodeId: newNode.id,
+          changeType: "added",
+          currentState: newNode,
+          filePath: newNode.id.split("::")[0] || ""
+        });
+      } else {
+        const nodeChanged = JSON.stringify(oldNode) !== JSON.stringify(newNode);
+        if (nodeChanged) {
+          changes.push({
+            timestamp,
+            nodeId: newNode.id,
+            changeType: "modified",
+            previousState: oldNode,
+            currentState: newNode,
+            filePath: newNode.id.split("::")[0] || ""
+          });
+        }
+      }
+    }
+    for (const oldNode of oldNodes || []) {
+      if (!newNodesMap.has(oldNode.id)) {
+        changes.push({
+          timestamp,
+          nodeId: oldNode.id,
+          changeType: "removed",
+          previousState: oldNode,
+          filePath: oldNode.id.split("::")[0] || ""
+        });
+      }
+    }
+    return changes;
+  };
+  const addToChangeHistory = (branchId, changes) => {
+    if (changes.length === 0) return;
+    if (!changeHistoryMap[branchId]) {
+      changeHistoryMap[branchId] = [];
+    }
+    changeHistoryMap[branchId].push(...changes);
+    if (changeHistoryMap[branchId].length > MAX_HISTORY_ENTRIES) {
+      changeHistoryMap[branchId] = changeHistoryMap[branchId].slice(-MAX_HISTORY_ENTRIES);
+    }
+  };
   const checkGitState = (projectPath) => {
     try {
       const gitDir = path4.join(projectPath, ".git");
@@ -1849,6 +2012,18 @@ var unpluginFactory = (options = {}) => {
       const projectPath = config.root;
       const previousAnalysis = await readLocalAnalysis(projectPath);
       const newAnalysis = await analyzeProject(projectPath);
+      if (previousAnalysis) {
+        for (const branchId of Object.keys(newAnalysis.planData)) {
+          const oldNodes = previousAnalysis.planData[branchId]?.nodes;
+          const newNodes = newAnalysis.planData[branchId]?.nodes || [];
+          const changes = generateNodeChanges(branchId, oldNodes, newNodes);
+          addToChangeHistory(branchId, changes);
+          if (changes.length > 0) {
+            console.log(chalk.yellow(`[Rayburst] Detected ${changes.length} node changes in branch ${branchId}`));
+          }
+        }
+      }
+      newAnalysis.changeHistory = { ...changeHistoryMap };
       if (previousAnalysis) {
         console.log(chalk.green("[Rayburst] Analysis updated"));
       } else {

package/dist/index.js

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

package/dist/vite-plugin.js

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

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@rayburst/cli",
-  "version": "0.4.13",
+  "version": "0.4.15",
   "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.10",
+    "@rayburst/types": "file:../rayburst-types",
     "@types/node": "^25.0.2",
     "tsup": "^8.5.1",
     "typescript": "^5.9.3",