@rayburst/cli 0.3.7 → 0.4.0

package/dist/{chunk-IUY7AA22.js → chunk-CK7EVFWN.js}

@@ -671,26 +671,29 @@ function detectConfigBasedComponents(sourceFile, nodes, nodeMap, edges, projectP
             const routerNode = createRouterDecisionNode(relativePath, gitHash, componentPaths.length);
             nodes.push(routerNode);
             nodeMap.set(routerNode.id, routerNode);
-            console.log(`[DEBUG] Created router node: ${routerNode.id}`);
             const routerProviderExternalId = "external::@tanstack/react-router::RouterProvider";
             const routerProviderNode = externalNodeMap.get(routerProviderExternalId);
             if (routerProviderNode) {
               const providerToRouterEdgeId = `e-${routerProviderNode.id}-${routerNode.id}`;
               if (!edges.find((e) => e.id === providerToRouterEdgeId)) {
-                edges.push({
+                const newEdge = {
                   id: providerToRouterEdgeId,
                   source: routerProviderNode.id,
                   target: routerNode.id,
                   type: "floating",
                   label: "router prop"
-                });
+                };
+                edges.push(newEdge);
                 totalEdgesCreated++;
-                console.log(`[DEBUG] Created edge: RouterProvider -> Router`);
-                console.log(`[DEBUG]   Source ID: ${routerProviderNode.id}`);
-                console.log(`[DEBUG]   Target ID: ${routerNode.id}`);
+                console.log(`[ROUTER-EDGE] Created edge from RouterProvider to Router`);
+                console.log(`[ROUTER-EDGE]   Edge ID: ${newEdge.id}`);
+                console.log(`[ROUTER-EDGE]   Source: ${newEdge.source}`);
+                console.log(`[ROUTER-EDGE]   Target: ${newEdge.target}`);
+                console.log(`[ROUTER-EDGE]   Total edges now: ${edges.length}`);
               }
             } else {
-              console.warn("[DEBUG] RouterProvider external node not found, falling back to App -> Router edge");
+              console.warn("[ROUTER-EDGE] RouterProvider external node NOT FOUND in externalNodeMap");
+              console.warn("[ROUTER-EDGE] Available external nodes:", Array.from(externalNodeMap.keys()));
               const appToRouterEdgeId = `e-${sourceNode.id}-${routerNode.id}`;
               if (!edges.find((e) => e.id === appToRouterEdgeId)) {
                 edges.push({
@@ -701,20 +704,60 @@ function detectConfigBasedComponents(sourceFile, nodes, nodeMap, edges, projectP
                   label: "router prop"
                 });
                 totalEdgesCreated++;
-                console.log(`[DEBUG] Created edge: App -> Router (fallback)`);
               }
             }
-            const routerToRoutesEdges = createConfigBasedEdges(
-              routerNode,
-              componentPaths,
-              nodeMap,
-              edges,
-              "route",
-              true
-              // Use route path labels
-            );
-            console.log(`[DEBUG] Created ${routerToRoutesEdges} edges from Router to routes`);
-            totalEdgesCreated += routerToRoutesEdges;
+            let decisionNodesCreated = 0;
+            let decisionEdgesCreated = 0;
+            for (const routeFilePath of componentPaths) {
+              const routePath = extractRoutePathFromFile(routeFilePath);
+              const isDynamic = routePath.includes(":");
+              const decisionNodeId = `${routerNode.id}::decision::${routePath.replace(/[/:]/g, "_")}`;
+              const decisionNode = {
+                id: decisionNodeId,
+                type: "conditional",
+                position: { x: 800, y: 400 + decisionNodesCreated * 100 },
+                data: {
+                  label: isDynamic ? `matches "${routePath}"` : `path === "${routePath}"`,
+                  description: `Route condition for ${routePath}`,
+                  condition: isDynamic ? `pathname.matches("${routePath}")` : `pathname === "${routePath}"`,
+                  trueLabel: "render",
+                  falseLabel: "skip"
+                }
+              };
+              nodes.push(decisionNode);
+              nodeMap.set(decisionNode.id, decisionNode);
+              decisionNodesCreated++;
+              const routerToDecisionEdgeId = `e-${routerNode.id}-${decisionNode.id}`;
+              if (!edges.find((e) => e.id === routerToDecisionEdgeId)) {
+                edges.push({
+                  id: routerToDecisionEdgeId,
+                  source: routerNode.id,
+                  target: decisionNode.id,
+                  type: "floating",
+                  label: routePath
+                });
+                decisionEdgesCreated++;
+              }
+              const targetNodes = findNodesInFile(routeFilePath, nodeMap);
+              for (const targetNode of targetNodes) {
+                if (targetNode.type !== "component") {
+                  continue;
+                }
+                const decisionToComponentEdgeId = `e-${decisionNode.id}-${targetNode.id}`;
+                if (!edges.find((e) => e.id === decisionToComponentEdgeId)) {
+                  edges.push({
+                    id: decisionToComponentEdgeId,
+                    source: decisionNode.id,
+                    target: targetNode.id,
+                    type: "floating",
+                    label: "true"
+                  });
+                  decisionEdgesCreated++;
+                }
+              }
+            }
+            console.log(`[ROUTER] Created ${decisionNodesCreated} decision nodes and ${decisionEdgesCreated} edges`);
+            totalEdgesCreated += decisionEdgesCreated;
           } else {
             console.log(`[DEBUG] Creating edges for ${componentPaths.length} components`);
             const edgesCreated = createConfigBasedEdges(
@@ -807,6 +850,18 @@ async function analyzeProject(projectPath, projectId, onLog) {
       log(`  Generated ${totalConfigEdges} additional edges from config analysis`);
     }
     log(`  Total edges: ${edges.length}`);
+    const routerProviderEdge = edges.find((e) => e.source === "external::@tanstack/react-router::RouterProvider");
+    if (routerProviderEdge) {
+      console.log(`[FINAL-CHECK] \u2713 RouterProvider edge EXISTS in final edges array`);
+      console.log(`[FINAL-CHECK]   Edge: ${routerProviderEdge.source} -> ${routerProviderEdge.target}`);
+    } else {
+      console.warn(`[FINAL-CHECK] \u2717 RouterProvider edge NOT FOUND in final edges array`);
+      console.warn(`[FINAL-CHECK]   Checking all edges with 'RouterProvider' in source or target...`);
+      const relatedEdges = edges.filter(
+        (e) => e.source.includes("RouterProvider") || e.target.includes("RouterProvider") || e.source.includes("RouterDecision") || e.target.includes("RouterDecision")
+      );
+      console.warn(`[FINAL-CHECK]   Found ${relatedEdges.length} related edges:`, relatedEdges.map((e) => `${e.source} -> ${e.target}`));
+    }
     const packageJsonPath = path2.join(projectPath, "package.json");
     let packageJson = { name: path2.basename(projectPath) };
     if (fs.existsSync(packageJsonPath)) {

package/dist/index.js

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

package/dist/vite-plugin.js

@@ -1,6 +1,6 @@
 import {
   rayburstPlugin
-} from "./chunk-IUY7AA22.js";
+} from "./chunk-CK7EVFWN.js";
 export {
   rayburstPlugin
 };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@rayburst/cli",
-  "version": "0.3.7",
+  "version": "0.4.0",
   "description": "Rayburst - Automatic code analysis for TypeScript/JavaScript projects via Vite plugin",
   "type": "module",
   "main": "./dist/index.js",