@rayburst/cli 0.2.1 → 0.2.3

package/README.md

@@ -83,7 +83,16 @@ The generated `analysis.json` contains:
 - **Branches**: Git branch information
 - **Files**: Modification timestamps
 
-This data can be visualized using the [Rayburst web application](https://rayburst.app).
+## Viewing Your Analysis
+
+Once analysis is complete, open the [Rayburst web application](https://rayburst.app) in Chrome or Edge:
+
+1. Click "Add Project" button
+2. Select your project folder
+3. The app will load `.rayburst/analysis.json` automatically
+4. Explore your codebase visually with interactive dependency graphs
+
+The web app uses the File System Access API (Chrome/Edge only) to read your local analysis data.
 
 ## Example Output
 

package/dist/{chunk-NIOHEIF6.js → chunk-2VW2AH2U.js}

@@ -1,9 +1,129 @@
 // src/analysis/analyze-project.ts
 import { Project, SyntaxKind, Node } from "ts-morph";
-import { execSync } from "child_process";
+import { execSync as execSync2 } from "child_process";
 import * as fs from "fs";
-import * as path from "path";
+import * as path2 from "path";
 import crypto from "crypto";
+
+// src/git-utils.ts
+import { execSync } from "child_process";
+import path from "path";
+function getUncommittedChanges(projectPath) {
+  try {
+    if (!isGitRepository(projectPath)) {
+      return [];
+    }
+    const command = "git diff --name-only HEAD && git diff --name-only --cached";
+    const output = execSync(command, {
+      cwd: projectPath,
+      encoding: "utf8",
+      stdio: ["pipe", "pipe", "ignore"]
+      // Ignore stderr
+    });
+    const files = output.split("\n").filter(Boolean).map((file) => path.resolve(projectPath, file.trim()));
+    return [...new Set(files)];
+  } catch (error) {
+    console.error("Failed to get git diff:", error.message);
+    return [];
+  }
+}
+function isGitRepository(projectPath) {
+  try {
+    execSync("git rev-parse --is-inside-work-tree", {
+      cwd: projectPath,
+      encoding: "utf8",
+      stdio: ["pipe", "pipe", "ignore"]
+    });
+    return true;
+  } catch {
+    return false;
+  }
+}
+function getUntrackedFiles(projectPath) {
+  try {
+    if (!isGitRepository(projectPath)) {
+      return [];
+    }
+    const output = execSync("git ls-files --others --exclude-standard", {
+      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 untracked files:", error.message);
+    return [];
+  }
+}
+function getAllChangedFiles(projectPath) {
+  const uncommitted = getUncommittedChanges(projectPath);
+  const untracked = getUntrackedFiles(projectPath);
+  return [.../* @__PURE__ */ new Set([...uncommitted, ...untracked])];
+}
+function getChangedFilesVsRemote(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 {
+      const branchOutput = execSync("git rev-parse --abbrev-ref HEAD", {
+        cwd: projectPath,
+        encoding: "utf8",
+        stdio: ["pipe", "pipe", "ignore"]
+      }).trim();
+      currentBranch = branchOutput;
+    }
+    const remote = remoteBranch || `origin/${currentBranch}`;
+    try {
+      execSync("git fetch origin --quiet", {
+        cwd: projectPath,
+        stdio: "ignore",
+        timeout: 5e3
+      });
+    } catch {
+    }
+    try {
+      execSync(`git rev-parse --verify ${remote}`, {
+        cwd: projectPath,
+        stdio: "ignore"
+      });
+    } catch {
+      if (remote !== "origin/main") {
+        try {
+          execSync("git rev-parse --verify origin/main", {
+            cwd: projectPath,
+            stdio: "ignore"
+          });
+          return getChangedFilesVsRemote(projectPath, "origin/main");
+        } catch {
+          console.warn(`No remote branch found (tried ${remote} and origin/main)`);
+          return [];
+        }
+      }
+      return [];
+    }
+    const output = execSync(`git diff --name-only ${remote}...HEAD`, {
+      cwd: projectPath,
+      encoding: "utf8",
+      stdio: ["pipe", "pipe", "ignore"]
+    });
+    const committedChanges = output.split("\n").filter(Boolean).map((file) => path.resolve(projectPath, file.trim()));
+    const uncommittedChanges = getAllChangedFiles(projectPath);
+    return [.../* @__PURE__ */ new Set([...committedChanges, ...uncommittedChanges])];
+  } catch (error) {
+    console.warn("Failed to get changed files vs remote:", error.message);
+    return [];
+  }
+}
+
+// src/analysis/analyze-project.ts
 async function analyzeProject(projectPath, projectId, onLog) {
   const logs = [];
   const log = (message) => {
@@ -18,7 +138,7 @@ async function analyzeProject(projectPath, projectId, onLog) {
   const gitInfo = getGitInfo(projectPath);
   log(`  Git hash: ${gitHash}`);
   log(`  Current branch: ${gitInfo.branch}`);
-  const tsconfigPath = path.join(projectPath, "tsconfig.json");
+  const tsconfigPath = path2.join(projectPath, "tsconfig.json");
   if (!fs.existsSync(tsconfigPath)) {
     log(`  Warning: No tsconfig.json found, skipping TypeScript analysis`);
     const emptyAnalysis = createEmptyAnalysis(projectPath, gitInfo);
@@ -65,15 +185,15 @@ async function analyzeProject(projectPath, projectId, onLog) {
       generateEdges(sourceFile, nodeMap, edges);
     }
     log(`  Generated ${edges.length} edges`);
-    const packageJsonPath = path.join(projectPath, "package.json");
-    let packageJson = { name: path.basename(projectPath) };
+    const packageJsonPath = path2.join(projectPath, "package.json");
+    let packageJson = { name: path2.basename(projectPath) };
     if (fs.existsSync(packageJsonPath)) {
       packageJson = JSON.parse(fs.readFileSync(packageJsonPath, "utf-8"));
     }
     const branchId = gitInfo.branch.replace(/[^a-zA-Z0-9]/g, "-");
     const projectMetadata = {
       id: projectId || crypto.createHash("md5").update(projectPath).digest("hex").substring(0, 12),
-      title: packageJson.name || path.basename(projectPath),
+      title: packageJson.name || path2.basename(projectPath),
       subtitle: (/* @__PURE__ */ new Date()).toLocaleDateString(),
       value: `${nodes.length} nodes`,
       trend: 0,
@@ -94,6 +214,9 @@ async function analyzeProject(projectPath, projectId, onLog) {
       nodes,
       edges
     };
+    log("  Checking for changed files vs remote...");
+    const changedFiles = getChangedFilesVsRemote(projectPath);
+    log(`  Found ${changedFiles.length} changed files`);
     const result = {
       project: projectMetadata,
       branches: [branchMetadata],
@@ -101,7 +224,10 @@ async function analyzeProject(projectPath, projectId, onLog) {
         [branchId]: planData
       },
       analyzedAt: (/* @__PURE__ */ new Date()).toISOString(),
-      logs
+      logs,
+      changedFilesVsRemote: changedFiles.length > 0 ? {
+        [branchId]: changedFiles
+      } : void 0
     };
     return result;
   } catch (error) {
@@ -113,8 +239,8 @@ async function analyzeProject(projectPath, projectId, onLog) {
   }
 }
 function createEmptyAnalysis(projectPath, gitInfo) {
-  const packageJsonPath = path.join(projectPath, "package.json");
-  let packageJson = { name: path.basename(projectPath) };
+  const packageJsonPath = path2.join(projectPath, "package.json");
+  let packageJson = { name: path2.basename(projectPath) };
   if (fs.existsSync(packageJsonPath)) {
     packageJson = JSON.parse(fs.readFileSync(packageJsonPath, "utf-8"));
   }
@@ -122,7 +248,7 @@ function createEmptyAnalysis(projectPath, gitInfo) {
   return {
     project: {
       id: crypto.createHash("md5").update(projectPath).digest("hex").substring(0, 12),
-      title: packageJson.name || path.basename(projectPath),
+      title: packageJson.name || path2.basename(projectPath),
       subtitle: (/* @__PURE__ */ new Date()).toLocaleDateString(),
       value: "0 nodes",
       trend: 0,
@@ -145,17 +271,17 @@ function createEmptyAnalysis(projectPath, gitInfo) {
 }
 function getGitHash(projectPath) {
   try {
-    return execSync("git rev-parse --short HEAD", { cwd: projectPath, encoding: "utf-8" }).trim();
+    return execSync2("git rev-parse --short HEAD", { cwd: projectPath, encoding: "utf-8" }).trim();
   } catch {
     return "nogit";
   }
 }
 function getGitInfo(projectPath) {
   try {
-    const branch = execSync("git branch --show-current", { cwd: projectPath, encoding: "utf-8" }).trim() || "main";
-    const lastCommit = execSync("git log -1 --pretty=%s", { cwd: projectPath, encoding: "utf-8" }).trim() || "No commits";
-    const author = execSync("git log -1 --pretty=%an", { cwd: projectPath, encoding: "utf-8" }).trim() || "Unknown";
-    const commitCount = parseInt(execSync("git rev-list --count HEAD", { cwd: projectPath, encoding: "utf-8" }).trim() || "0");
+    const branch = execSync2("git branch --show-current", { cwd: projectPath, encoding: "utf-8" }).trim() || "main";
+    const lastCommit = execSync2("git log -1 --pretty=%s", { cwd: projectPath, encoding: "utf-8" }).trim() || "No commits";
+    const author = execSync2("git log -1 --pretty=%an", { cwd: projectPath, encoding: "utf-8" }).trim() || "Unknown";
+    const commitCount = parseInt(execSync2("git rev-list --count HEAD", { cwd: projectPath, encoding: "utf-8" }).trim() || "0");
     return { branch, lastCommit, author, commitCount };
   } catch {
     return {
@@ -400,14 +526,14 @@ function generateEdges(sourceFile, nodeMap, edges) {
 
 // src/local-storage.ts
 import { promises as fs2 } from "fs";
-import path2 from "path";
+import path3 from "path";
 async function ensureRayburstDir(projectPath) {
-  const rayburstDir = path2.join(projectPath, ".rayburst");
+  const rayburstDir = path3.join(projectPath, ".rayburst");
   await fs2.mkdir(rayburstDir, { recursive: true });
   return rayburstDir;
 }
 async function readLocalAnalysis(projectPath) {
-  const analysisPath = path2.join(projectPath, ".rayburst", "analysis.json");
+  const analysisPath = path3.join(projectPath, ".rayburst", "analysis.json");
   try {
     const data = await fs2.readFile(analysisPath, "utf-8");
     return JSON.parse(data);
@@ -417,11 +543,11 @@ async function readLocalAnalysis(projectPath) {
 }
 async function writeLocalAnalysis(projectPath, analysis) {
   await ensureRayburstDir(projectPath);
-  const analysisPath = path2.join(projectPath, ".rayburst", "analysis.json");
+  const analysisPath = path3.join(projectPath, ".rayburst", "analysis.json");
   await fs2.writeFile(analysisPath, JSON.stringify(analysis, null, 2), "utf-8");
 }
 async function readLocalMeta(projectPath) {
-  const metaPath = path2.join(projectPath, ".rayburst", "meta.json");
+  const metaPath = path3.join(projectPath, ".rayburst", "meta.json");
   try {
     const data = await fs2.readFile(metaPath, "utf-8");
     return JSON.parse(data);
@@ -431,11 +557,11 @@ async function readLocalMeta(projectPath) {
 }
 async function writeLocalMeta(projectPath, meta) {
   await ensureRayburstDir(projectPath);
-  const metaPath = path2.join(projectPath, ".rayburst", "meta.json");
+  const metaPath = path3.join(projectPath, ".rayburst", "meta.json");
   await fs2.writeFile(metaPath, JSON.stringify(meta, null, 2), "utf-8");
 }
 async function addGitignoreEntry(projectPath) {
-  const gitignorePath = path2.join(projectPath, ".gitignore");
+  const gitignorePath = path3.join(projectPath, ".gitignore");
   let gitignoreContent = "";
   try {
     gitignoreContent = await fs2.readFile(gitignorePath, "utf-8");
@@ -449,7 +575,7 @@ async function addGitignoreEntry(projectPath) {
   await fs2.writeFile(gitignorePath, gitignoreContent, "utf-8");
 }
 async function isProjectInitialized(projectPath) {
-  const rayburstDir = path2.join(projectPath, ".rayburst");
+  const rayburstDir = path3.join(projectPath, ".rayburst");
   try {
     const stats = await fs2.stat(rayburstDir);
     return stats.isDirectory();
@@ -471,20 +597,20 @@ async function initializeProject(projectPath, projectName, cliVersion) {
   return meta;
 }
 function generateProjectId(projectPath) {
-  const baseName = path2.basename(projectPath);
+  const baseName = path3.basename(projectPath);
   const timestamp = Date.now().toString(36);
   return `${baseName}-${timestamp}`;
 }
 
 // src/registry.ts
-import path3 from "path";
+import path4 from "path";
 import { fileURLToPath } from "url";
 import os from "os";
 var __filename = fileURLToPath(import.meta.url);
-var __dirname = path3.dirname(__filename);
-var RAYBURST_DIR = path3.join(os.homedir(), ".rayburst");
-var PROJECTS_FILE = path3.join(RAYBURST_DIR, "projects.json");
-var ANALYZED_DIR = path3.join(RAYBURST_DIR, "analyzed");
+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";

package/dist/index.js

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

package/dist/vite-plugin.js

@@ -1,6 +1,6 @@
 import {
   rayburstPlugin
-} from "./chunk-NIOHEIF6.js";
+} from "./chunk-2VW2AH2U.js";
 export {
   rayburstPlugin
 };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@rayburst/cli",
-  "version": "0.2.1",
+  "version": "0.2.3",
   "description": "Rayburst - Automatic code analysis for TypeScript/JavaScript projects via Vite plugin",
   "type": "module",
   "main": "./dist/index.js",
@@ -42,7 +42,7 @@
     }
   },
   "dependencies": {
-    "@rayburst/types": "^0.1.1",
+    "@rayburst/types": "^0.1.3",
     "chalk": "^5.3.0",
     "ts-morph": "^21.0.1",
     "zod": "^4.2.0"