@rayburst/cli 0.2.0 → 0.2.2

package/dist/chunk-ZAT3D23Y.js

@@ -0,0 +1,806 @@
+// src/analysis/analyze-project.ts
+import { Project, SyntaxKind, Node } from "ts-morph";
+import { execSync as execSync2 } from "child_process";
+import * as fs from "fs";
+import * as path2 from "path";
+import crypto from "crypto";
+
+// src/git-utils.ts
+import { execSync } from "child_process";
+import path from "path";
+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 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"]
+    });
+    return output.split("\n").filter(Boolean).map((file) => path.resolve(projectPath, file.trim()));
+  } 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) => {
+    console.log(message);
+    logs.push(message);
+    if (onLog) {
+      onLog(message);
+    }
+  };
+  log(`Analyzing project at: ${projectPath}`);
+  const gitHash = getGitHash(projectPath);
+  const gitInfo = getGitInfo(projectPath);
+  log(`  Git hash: ${gitHash}`);
+  log(`  Current branch: ${gitInfo.branch}`);
+  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);
+    emptyAnalysis.logs = logs;
+    return emptyAnalysis;
+  }
+  try {
+    const project = new Project({
+      tsConfigFilePath: tsconfigPath
+    });
+    const nodes = [];
+    const edges = [];
+    const nodeMap = /* @__PURE__ */ new Map();
+    const usedIds = /* @__PURE__ */ new Set();
+    const idCounters = /* @__PURE__ */ new Map();
+    let fileIndex = 0;
+    const filePositions = /* @__PURE__ */ new Map();
+    const sourceFiles = project.getSourceFiles().filter((sf) => {
+      const filePath = sf.getFilePath();
+      return !filePath.includes("node_modules") && !filePath.includes(".test.") && !filePath.includes(".spec.") && (filePath.endsWith(".ts") || filePath.endsWith(".tsx"));
+    });
+    log(`  Analyzing ${sourceFiles.length} source files...`);
+    for (let i = 0; i < sourceFiles.length; i++) {
+      const sourceFile = sourceFiles[i];
+      const filePath = sourceFile.getFilePath();
+      const relativePath = filePath.replace(projectPath + "/", "");
+      if (!filePositions.has(relativePath)) {
+        filePositions.set(relativePath, fileIndex++);
+      }
+      const baseX = (filePositions.get(relativePath) || 0) * 400;
+      let nodeY = 100;
+      const components = extractComponents(sourceFile, relativePath, gitHash, baseX, nodeY, nodes, nodeMap, usedIds, idCounters);
+      nodeY += components * 150;
+      const functions = extractFunctions(sourceFile, relativePath, gitHash, baseX, nodeY, nodes, nodeMap, usedIds, idCounters);
+      nodeY += functions * 150;
+      const states = extractState(sourceFile, relativePath, gitHash, baseX, nodeY, nodes, nodeMap, usedIds, idCounters);
+      nodeY += states * 150;
+      if (i % 10 === 0 && i > 0) {
+        await new Promise((resolve) => setImmediate(resolve));
+      }
+    }
+    log(`  Extracted ${nodes.length} nodes`);
+    for (const sourceFile of sourceFiles) {
+      generateEdges(sourceFile, nodeMap, edges);
+    }
+    log(`  Generated ${edges.length} edges`);
+    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 || path2.basename(projectPath),
+      subtitle: (/* @__PURE__ */ new Date()).toLocaleDateString(),
+      value: `${nodes.length} nodes`,
+      trend: 0,
+      chartData: [30, 40, 35, 50, 45, 60, 55, 70],
+      chartColor: "#22c55e"
+    };
+    const branchMetadata = {
+      id: branchId,
+      name: gitInfo.branch,
+      lastCommit: gitInfo.lastCommit,
+      lastCommitDate: "just now",
+      author: gitInfo.author,
+      status: "active",
+      commitCount: gitInfo.commitCount,
+      pullRequests: 0
+    };
+    const planData = {
+      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],
+      planData: {
+        [branchId]: planData
+      },
+      analyzedAt: (/* @__PURE__ */ new Date()).toISOString(),
+      logs,
+      changedFilesVsRemote: changedFiles.length > 0 ? {
+        [branchId]: changedFiles
+      } : void 0
+    };
+    return result;
+  } catch (error) {
+    console.error(`  Error analyzing project:`, error.message);
+    log(`  Error: ${error.message}`);
+    const emptyAnalysis = createEmptyAnalysis(projectPath, gitInfo);
+    emptyAnalysis.logs = logs;
+    return emptyAnalysis;
+  }
+}
+function createEmptyAnalysis(projectPath, gitInfo) {
+  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, "-");
+  return {
+    project: {
+      id: crypto.createHash("md5").update(projectPath).digest("hex").substring(0, 12),
+      title: packageJson.name || path2.basename(projectPath),
+      subtitle: (/* @__PURE__ */ new Date()).toLocaleDateString(),
+      value: "0 nodes",
+      trend: 0,
+      chartData: [],
+      chartColor: "#6b7280"
+    },
+    branches: [{
+      id: branchId,
+      name: gitInfo.branch,
+      lastCommit: gitInfo.lastCommit,
+      lastCommitDate: "just now",
+      author: gitInfo.author,
+      status: "active",
+      commitCount: gitInfo.commitCount,
+      pullRequests: 0
+    }],
+    planData: {},
+    analyzedAt: (/* @__PURE__ */ new Date()).toISOString()
+  };
+}
+function getGitHash(projectPath) {
+  try {
+    return execSync2("git rev-parse --short HEAD", { cwd: projectPath, encoding: "utf-8" }).trim();
+  } catch {
+    return "nogit";
+  }
+}
+function getGitInfo(projectPath) {
+  try {
+    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 {
+      branch: "main",
+      lastCommit: "No commits",
+      author: "Unknown",
+      commitCount: 0
+    };
+  }
+}
+function createNodeId(filePath, nodeName, gitHash, counter = 0) {
+  const suffix = counter > 0 ? `-${counter}` : "";
+  return `${filePath}::${nodeName}${suffix}::${gitHash}`;
+}
+function getUniqueNodeId(filePath, nodeName, gitHash, usedIds, idCounters) {
+  const baseKey = `${filePath}::${nodeName}`;
+  const counter = idCounters.get(baseKey) || 0;
+  const id = createNodeId(filePath, nodeName, gitHash, counter);
+  if (usedIds.has(id)) {
+    idCounters.set(baseKey, counter + 1);
+    return getUniqueNodeId(filePath, nodeName, gitHash, usedIds, idCounters);
+  }
+  usedIds.add(id);
+  idCounters.set(baseKey, counter + 1);
+  return id;
+}
+function isReactComponent(func) {
+  const body = func.getBody();
+  if (!body) return false;
+  const text = body.getText();
+  return text.includes("return") && (text.includes("</") || text.includes("<>") || text.includes("jsx"));
+}
+function extractComponents(sourceFile, relativePath, gitHash, baseX, startY, nodes, nodeMap, usedIds, idCounters) {
+  let count = 0;
+  let y = startY;
+  const functions = sourceFile.getFunctions();
+  for (const func of functions) {
+    if (isReactComponent(func)) {
+      const name = func.getName() || "AnonymousComponent";
+      const id = getUniqueNodeId(relativePath, name, gitHash, usedIds, idCounters);
+      const params = func.getParameters();
+      const propsParam = params[0];
+      const propsType = propsParam ? propsParam.getType().getText() : "any";
+      const node = {
+        id,
+        type: "component",
+        position: { x: baseX, y },
+        data: {
+          componentName: name,
+          props: propsType,
+          label: name,
+          description: `Component in ${relativePath}`
+        }
+      };
+      nodes.push(node);
+      nodeMap.set(id, node);
+      nodeMap.set(name, node);
+      count++;
+      y += 150;
+    }
+  }
+  const variables = sourceFile.getVariableDeclarations();
+  for (const variable of variables) {
+    const init = variable.getInitializer();
+    if (init && (Node.isArrowFunction(init) || Node.isFunctionExpression(init))) {
+      if (isReactComponent(init)) {
+        const name = variable.getName();
+        const id = getUniqueNodeId(relativePath, name, gitHash, usedIds, idCounters);
+        const params = init.getParameters();
+        const propsParam = params[0];
+        const propsType = propsParam ? propsParam.getType().getText() : "any";
+        const node = {
+          id,
+          type: "component",
+          position: { x: baseX, y },
+          data: {
+            componentName: name,
+            props: propsType,
+            label: name,
+            description: `Component in ${relativePath}`
+          }
+        };
+        nodes.push(node);
+        nodeMap.set(id, node);
+        nodeMap.set(name, node);
+        count++;
+        y += 150;
+      }
+    }
+  }
+  return count;
+}
+function extractFunctions(sourceFile, relativePath, gitHash, baseX, startY, nodes, nodeMap, usedIds, idCounters) {
+  let count = 0;
+  let y = startY;
+  const functions = sourceFile.getFunctions();
+  for (const func of functions) {
+    if (!isReactComponent(func)) {
+      const name = func.getName() || "anonymous";
+      if (name === "anonymous") continue;
+      const id = getUniqueNodeId(relativePath, name, gitHash, usedIds, idCounters);
+      const params = func.getParameters().map((p) => {
+        const paramName = p.getName();
+        const paramType = p.getType().getText();
+        return `${paramName}: ${paramType}`;
+      }).join(", ");
+      const returnType = func.getReturnType().getText();
+      const node = {
+        id,
+        type: "function",
+        position: { x: baseX, y },
+        data: {
+          functionName: name,
+          parameters: params,
+          returnType,
+          label: name,
+          description: `Function in ${relativePath}`
+        }
+      };
+      nodes.push(node);
+      nodeMap.set(id, node);
+      nodeMap.set(name, node);
+      count++;
+      y += 150;
+    }
+  }
+  return count;
+}
+function extractState(sourceFile, relativePath, gitHash, baseX, startY, nodes, nodeMap, usedIds, idCounters) {
+  let count = 0;
+  let y = startY;
+  sourceFile.getDescendantsOfKind(SyntaxKind.CallExpression).forEach((callExpr) => {
+    const expr = callExpr.getExpression();
+    if (expr.getText() === "useState") {
+      const parent = callExpr.getParent();
+      if (Node.isVariableDeclaration(parent)) {
+        const nameNode = parent.getNameNode();
+        if (Node.isArrayBindingPattern(nameNode)) {
+          const elements = nameNode.getElements();
+          if (elements.length > 0) {
+            const stateName = elements[0].getText();
+            const id = getUniqueNodeId(relativePath, stateName, gitHash, usedIds, idCounters);
+            const args = callExpr.getArguments();
+            const initialValue = args.length > 0 ? args[0].getText() : "undefined";
+            const stateType = parent.getType().getText();
+            const node = {
+              id,
+              type: "state",
+              position: { x: baseX, y },
+              data: {
+                stateName,
+                stateType,
+                initialValue,
+                label: stateName,
+                description: `State in ${relativePath}`
+              }
+            };
+            nodes.push(node);
+            nodeMap.set(id, node);
+            nodeMap.set(stateName, node);
+            count++;
+            y += 150;
+          }
+        }
+      }
+    }
+  });
+  return count;
+}
+function generateEdges(sourceFile, nodeMap, edges) {
+  sourceFile.getDescendantsOfKind(SyntaxKind.JsxElement).forEach((jsxElement) => {
+    const openingElement = jsxElement.getOpeningElement();
+    const tagName = openingElement.getTagNameNode().getText();
+    const containingFunc = jsxElement.getFirstAncestorByKind(SyntaxKind.FunctionDeclaration) || jsxElement.getFirstAncestorByKind(SyntaxKind.ArrowFunction);
+    if (containingFunc) {
+      const parentName = containingFunc.getName?.() || containingFunc.getParent()?.asKind(SyntaxKind.VariableDeclaration)?.getName() || null;
+      if (parentName && nodeMap.has(parentName) && nodeMap.has(tagName)) {
+        const sourceNode = nodeMap.get(parentName);
+        const targetNode = nodeMap.get(tagName);
+        if (sourceNode && targetNode) {
+          const edgeId = `e-${sourceNode.id}-${targetNode.id}`;
+          if (!edges.find((e) => e.id === edgeId)) {
+            edges.push({
+              id: edgeId,
+              source: sourceNode.id,
+              target: targetNode.id,
+              type: "floating"
+            });
+          }
+        }
+      }
+    }
+  });
+  sourceFile.getDescendantsOfKind(SyntaxKind.JsxSelfClosingElement).forEach((jsxElement) => {
+    const tagName = jsxElement.getTagNameNode().getText();
+    const containingFunc = jsxElement.getFirstAncestorByKind(SyntaxKind.FunctionDeclaration) || jsxElement.getFirstAncestorByKind(SyntaxKind.ArrowFunction);
+    if (containingFunc) {
+      const parentName = containingFunc.getName?.() || containingFunc.getParent()?.asKind(SyntaxKind.VariableDeclaration)?.getName() || null;
+      if (parentName && nodeMap.has(parentName) && nodeMap.has(tagName)) {
+        const sourceNode = nodeMap.get(parentName);
+        const targetNode = nodeMap.get(tagName);
+        if (sourceNode && targetNode) {
+          const edgeId = `e-${sourceNode.id}-${targetNode.id}`;
+          if (!edges.find((e) => e.id === edgeId)) {
+            edges.push({
+              id: edgeId,
+              source: sourceNode.id,
+              target: targetNode.id,
+              type: "floating"
+            });
+          }
+        }
+      }
+    }
+  });
+  sourceFile.getDescendantsOfKind(SyntaxKind.CallExpression).forEach((callExpr) => {
+    const expr = callExpr.getExpression();
+    const calledName = expr.getText().split(".").pop();
+    if (calledName && nodeMap.has(calledName)) {
+      const containingFunc = callExpr.getFirstAncestorByKind(SyntaxKind.FunctionDeclaration) || callExpr.getFirstAncestorByKind(SyntaxKind.ArrowFunction);
+      if (containingFunc) {
+        const parentName = containingFunc.getName?.() || containingFunc.getParent()?.asKind(SyntaxKind.VariableDeclaration)?.getName() || null;
+        if (parentName && nodeMap.has(parentName)) {
+          const sourceNode = nodeMap.get(parentName);
+          const targetNode = nodeMap.get(calledName);
+          if (sourceNode && targetNode && sourceNode.id !== targetNode.id) {
+            const edgeId = `e-${sourceNode.id}-${targetNode.id}`;
+            if (!edges.find((e) => e.id === edgeId)) {
+              edges.push({
+                id: edgeId,
+                source: sourceNode.id,
+                target: targetNode.id,
+                type: "floating"
+              });
+            }
+          }
+        }
+      }
+    }
+  });
+}
+
+// src/local-storage.ts
+import { promises as fs2 } from "fs";
+import path3 from "path";
+async function ensureRayburstDir(projectPath) {
+  const rayburstDir = path3.join(projectPath, ".rayburst");
+  await fs2.mkdir(rayburstDir, { recursive: true });
+  return rayburstDir;
+}
+async function readLocalAnalysis(projectPath) {
+  const analysisPath = path3.join(projectPath, ".rayburst", "analysis.json");
+  try {
+    const data = await fs2.readFile(analysisPath, "utf-8");
+    return JSON.parse(data);
+  } catch (error) {
+    return null;
+  }
+}
+async function writeLocalAnalysis(projectPath, analysis) {
+  await ensureRayburstDir(projectPath);
+  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 = path3.join(projectPath, ".rayburst", "meta.json");
+  try {
+    const data = await fs2.readFile(metaPath, "utf-8");
+    return JSON.parse(data);
+  } catch (error) {
+    return null;
+  }
+}
+async function writeLocalMeta(projectPath, meta) {
+  await ensureRayburstDir(projectPath);
+  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 = path3.join(projectPath, ".gitignore");
+  let gitignoreContent = "";
+  try {
+    gitignoreContent = await fs2.readFile(gitignorePath, "utf-8");
+  } catch (error) {
+  }
+  if (gitignoreContent.includes(".rayburst")) {
+    return;
+  }
+  const entry = "\n# Rayburst analysis data\n.rayburst/\n";
+  gitignoreContent += entry;
+  await fs2.writeFile(gitignorePath, gitignoreContent, "utf-8");
+}
+async function isProjectInitialized(projectPath) {
+  const rayburstDir = path3.join(projectPath, ".rayburst");
+  try {
+    const stats = await fs2.stat(rayburstDir);
+    return stats.isDirectory();
+  } catch (error) {
+    return false;
+  }
+}
+async function initializeProject(projectPath, projectName, cliVersion) {
+  await ensureRayburstDir(projectPath);
+  const projectId = generateProjectId(projectPath);
+  const meta = {
+    projectId,
+    projectName,
+    createdAt: (/* @__PURE__ */ new Date()).toISOString(),
+    cliVersion
+  };
+  await writeLocalMeta(projectPath, meta);
+  await addGitignoreEntry(projectPath);
+  return meta;
+}
+function generateProjectId(projectPath) {
+  const baseName = path3.basename(projectPath);
+  const timestamp = Date.now().toString(36);
+  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;
+}
+
+// src/vite-plugin.ts
+import chalk2 from "chalk";
+function rayburstPlugin(options = {}) {
+  const {
+    enabled = process.env.CI !== "true",
+    // Disabled in CI by default
+    debounceMs = 1500
+  } = options;
+  let config;
+  let debounceTimer = null;
+  let isAnalyzing = false;
+  const runAnalysis = async (triggerFile) => {
+    if (isAnalyzing) return;
+    isAnalyzing = true;
+    try {
+      const projectPath = config.root;
+      const previousAnalysis = await readLocalAnalysis(projectPath);
+      const newAnalysis = await analyzeProject(projectPath);
+      await writeLocalAnalysis(projectPath, newAnalysis);
+      if (previousAnalysis) {
+        const diff = generateDiff(previousAnalysis, newAnalysis);
+        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`));
+        }
+      } 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`)
+        );
+      }
+    } catch (error) {
+      const message = error instanceof Error ? error.message : String(error);
+      console.error(chalk2.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") {
+        return;
+      }
+      const projectPath = config.root;
+      await ensureRayburstDir(projectPath);
+      await addGitignoreEntry(projectPath);
+      console.log(chalk2.blue("[Rayburst] Starting code analysis..."));
+      await runAnalysis();
+    },
+    // Hook 3: Watch for changes using Vite's built-in watcher
+    configureServer(server) {
+      if (!enabled) return;
+      const handleFileChange = (filePath) => {
+        if (!filePath.match(/\.(ts|tsx|js|jsx)$/)) {
+          return;
+        }
+        if (filePath.includes("node_modules") || filePath.includes(".rayburst") || filePath.includes(".test.") || filePath.includes(".spec.")) {
+          return;
+        }
+        if (debounceTimer) {
+          clearTimeout(debounceTimer);
+        }
+        debounceTimer = setTimeout(() => {
+          const relativePath = filePath.replace(config.root, "").replace(/^\//, "");
+          console.log(chalk2.dim(`[Rayburst] File changed: ${relativePath}`));
+          runAnalysis(filePath);
+        }, debounceMs);
+      };
+      server.watcher.on("change", handleFileChange);
+      server.watcher.on("add", handleFileChange);
+      server.watcher.on("unlink", handleFileChange);
+      return () => {
+        server.watcher.off("change", handleFileChange);
+        server.watcher.off("add", handleFileChange);
+        server.watcher.off("unlink", handleFileChange);
+        if (debounceTimer) {
+          clearTimeout(debounceTimer);
+        }
+      };
+    }
+  };
+}
+
+export {
+  analyzeProject,
+  ensureRayburstDir,
+  readLocalAnalysis,
+  writeLocalAnalysis,
+  readLocalMeta,
+  writeLocalMeta,
+  addGitignoreEntry,
+  isProjectInitialized,
+  initializeProject,
+  rayburstPlugin
+};