@rayburst/cli 0.2.8 → 0.3.0

package/dist/{chunk-K4NZXXX4.js → chunk-L6EQILHI.js}

@@ -297,6 +297,109 @@ function extractComponentPathsFromImports(sourceFile, projectPath) {
   }
   return componentPaths;
 }
+function extractComponentsFromRouteFile(sourceFile, projectPath) {
+  const componentPaths = [];
+  try {
+    const callExpressions = sourceFile.getDescendantsOfKind(SyntaxKind.CallExpression);
+    for (const callExpr of callExpressions) {
+      const expr = callExpr.getExpression();
+      const functionName = expr.getText();
+      if (!functionName.includes("createFileRoute") && !functionName.includes("createRootRoute")) {
+        continue;
+      }
+      const args = callExpr.getArguments();
+      if (args.length === 0) continue;
+      let configObject;
+      const parent = callExpr.getParent();
+      if (Node.isCallExpression(parent)) {
+        const parentArgs = parent.getArguments();
+        if (parentArgs.length > 0 && Node.isObjectLiteralExpression(parentArgs[0])) {
+          configObject = parentArgs[0];
+        }
+      }
+      if (!configObject && Node.isObjectLiteralExpression(args[0])) {
+        configObject = args[0];
+      }
+      if (!configObject) continue;
+      const properties = extractObjectLiteralProperties(configObject);
+      const componentValue = properties.get("component");
+      if (!componentValue) continue;
+      if (isIdentifier(componentValue)) {
+        const componentName = componentValue.getText();
+        const decl = traceIdentifierToDeclaration(componentValue);
+        if (decl) {
+          const importDecl = decl.getFirstAncestorByKind(SyntaxKind.ImportDeclaration);
+          if (importDecl) {
+            const importedSourceFile = getImportSourceFile(importDecl);
+            if (importedSourceFile) {
+              const filePath = importedSourceFile.getFilePath();
+              const relativePath = filePath.replace(projectPath + "/", "");
+              if (!relativePath.includes("node_modules")) {
+                componentPaths.push(relativePath);
+              }
+            }
+          } else {
+            const localComponentPaths = findNodesInFile(
+              sourceFile.getFilePath().replace(projectPath + "/", ""),
+              /* @__PURE__ */ new Map()
+              // This won't work without nodeMap, but we'll handle it differently
+            );
+          }
+        }
+      } else if (Node.isArrowFunction(componentValue) || Node.isFunctionExpression(componentValue)) {
+        const jsxElements = componentValue.getDescendantsOfKind(SyntaxKind.JsxElement);
+        const jsxSelfClosing = componentValue.getDescendantsOfKind(SyntaxKind.JsxSelfClosingElement);
+        for (const jsxElement of jsxElements) {
+          const tagName = jsxElement.getOpeningElement().getTagNameNode().getText();
+          const importSource = resolveImportSource(sourceFile, tagName);
+          if (importSource && !importSource.startsWith(".") && !importSource.startsWith("/")) {
+            continue;
+          }
+          const importDecls = sourceFile.getImportDeclarations();
+          for (const importDecl of importDecls) {
+            const namedImports = importDecl.getNamedImports();
+            const defaultImport = importDecl.getDefaultImport();
+            if (namedImports.some((ni) => ni.getName() === tagName) || defaultImport?.getText() === tagName) {
+              const importedSourceFile = getImportSourceFile(importDecl);
+              if (importedSourceFile) {
+                const filePath = importedSourceFile.getFilePath();
+                const relativePath = filePath.replace(projectPath + "/", "");
+                if (!relativePath.includes("node_modules")) {
+                  componentPaths.push(relativePath);
+                }
+              }
+            }
+          }
+        }
+        for (const jsxElement of jsxSelfClosing) {
+          const tagName = jsxElement.getTagNameNode().getText();
+          const importSource = resolveImportSource(sourceFile, tagName);
+          if (importSource && !importSource.startsWith(".") && !importSource.startsWith("/")) {
+            continue;
+          }
+          const importDecls = sourceFile.getImportDeclarations();
+          for (const importDecl of importDecls) {
+            const namedImports = importDecl.getNamedImports();
+            const defaultImport = importDecl.getDefaultImport();
+            if (namedImports.some((ni) => ni.getName() === tagName) || defaultImport?.getText() === tagName) {
+              const importedSourceFile = getImportSourceFile(importDecl);
+              if (importedSourceFile) {
+                const filePath = importedSourceFile.getFilePath();
+                const relativePath = filePath.replace(projectPath + "/", "");
+                if (!relativePath.includes("node_modules")) {
+                  componentPaths.push(relativePath);
+                }
+              }
+            }
+          }
+        }
+      }
+    }
+  } catch (error) {
+    console.error("[extractComponentsFromRouteFile] Error:", error);
+  }
+  return componentPaths;
+}
 function findNodesInFile(filePath, nodeMap) {
   const nodes = [];
   for (const [nodeId, node] of nodeMap.entries()) {
@@ -331,30 +434,46 @@ function createConfigBasedEdges(sourceNode, targetFilePaths, nodeMap, edges, edg
   }
   return edgesCreated;
 }
-function analyzeJsxPropsForComponents(jsxElement, propName, projectPath) {
+function analyzeJsxPropsForComponents(jsxElement, propName, projectPath, project) {
   const componentPaths = [];
   try {
-    const attributes = jsxElement.getChildrenOfKind(SyntaxKind.JsxAttribute);
+    const jsxAttributes = jsxElement.getChildrenOfKind(SyntaxKind.JsxAttributes)[0];
+    if (!jsxAttributes) {
+      console.log(`[DEBUG analyzeJsxProps] No JsxAttributes container found`);
+      return componentPaths;
+    }
+    const attributes = jsxAttributes.getChildrenOfKind(SyntaxKind.JsxAttribute);
+    console.log(`[DEBUG analyzeJsxProps] Attributes found: ${attributes.length}, looking for: ${propName}`);
     for (const attr of attributes) {
       const attrName = attr.getChildrenOfKind(SyntaxKind.Identifier)[0]?.getText();
+      console.log(`[DEBUG analyzeJsxProps] Attribute name: ${attrName}`);
       if (attrName !== propName) {
         continue;
       }
+      console.log(`[DEBUG analyzeJsxProps] Found matching prop: ${propName}`);
       const initializer = attr.getChildrenOfKind(SyntaxKind.JsxExpression)[0];
+      console.log(`[DEBUG analyzeJsxProps] Initializer exists: ${!!initializer}`);
       if (!initializer) continue;
       const identifier = initializer.getChildrenOfKind(SyntaxKind.Identifier)[0];
+      console.log(`[DEBUG analyzeJsxProps] Identifier: ${identifier?.getText()}`);
       if (!identifier) continue;
       const declaration = traceIdentifierToDeclaration(identifier);
+      console.log(`[DEBUG analyzeJsxProps] Declaration found: ${!!declaration}, is VariableDeclaration: ${declaration ? isVariableDeclaration(declaration) : false}`);
       if (!declaration || !isVariableDeclaration(declaration)) continue;
       const dataFlow = traceVariableDataFlow(declaration);
+      console.log(`[DEBUG analyzeJsxProps] DataFlow found: ${!!dataFlow}, is CallExpression: ${dataFlow ? isCallExpression(dataFlow) : false}`);
       if (!dataFlow || !isCallExpression(dataFlow)) continue;
       const args = dataFlow.getChildrenOfKind(SyntaxKind.SyntaxList)[0];
+      console.log(`[DEBUG analyzeJsxProps] Args found: ${!!args}`);
       if (!args) continue;
       const configArg = args.getChildrenOfKind(SyntaxKind.ObjectLiteralExpression)[0];
+      console.log(`[DEBUG analyzeJsxProps] ConfigArg found: ${!!configArg}`);
       if (!configArg) continue;
       const commonPropNames = ["routeTree", "routes", "children", "components"];
       for (const commonPropName of commonPropNames) {
-        const paths = traceConfigToComponentPaths(configArg, commonPropName, projectPath);
+        console.log(`[DEBUG analyzeJsxProps] Checking config property: ${commonPropName}`);
+        const paths = traceConfigToComponentPaths(configArg, commonPropName, projectPath, project);
+        console.log(`[DEBUG analyzeJsxProps] Paths found for ${commonPropName}: ${paths.length}`);
         if (paths.length > 0) {
           return paths;
         }
@@ -365,16 +484,34 @@ function analyzeJsxPropsForComponents(jsxElement, propName, projectPath) {
   }
   return componentPaths;
 }
-function traceConfigToComponentPaths(configObject, propertyName, projectPath) {
+function traceConfigToComponentPaths(configObject, propertyName, projectPath, project) {
   try {
     const propertyNode = traceConfigProperty(configObject, propertyName);
+    console.log(`[DEBUG traceConfigToComponentPaths] Property node for "${propertyName}": ${propertyNode ? propertyNode.getKindName() : "NULL"}`);
     if (!propertyNode) {
       return [];
     }
     if (isImportDeclaration(propertyNode)) {
       const sourceFile = getImportSourceFile(propertyNode);
       if (sourceFile) {
-        return extractComponentPathsFromImports(sourceFile, projectPath);
+        const filePath = sourceFile.getFilePath();
+        const relativePath = filePath.replace(projectPath + "/", "");
+        console.log(`[DEBUG traceConfigToComponentPaths] Found routeTree file: ${relativePath}`);
+        const routeFilePaths = extractComponentPathsFromImports(sourceFile, projectPath);
+        console.log(`[DEBUG traceConfigToComponentPaths] Found ${routeFilePaths.length} route files`);
+        const allComponentPaths = [];
+        for (const routePath of routeFilePaths) {
+          const routeSourceFile = project.getSourceFile(projectPath + "/" + routePath);
+          if (!routeSourceFile) {
+            console.log(`[DEBUG traceConfigToComponentPaths] Could not load route file: ${routePath}`);
+            continue;
+          }
+          console.log(`[DEBUG traceConfigToComponentPaths] Extracting components from route: ${routePath}`);
+          const componentPaths = extractComponentsFromRouteFile(routeSourceFile, projectPath);
+          console.log(`[DEBUG traceConfigToComponentPaths] Found ${componentPaths.length} components in ${routePath}`);
+          allComponentPaths.push(...componentPaths);
+        }
+        return [...routeFilePaths, ...allComponentPaths];
       }
     }
     if (isObjectLiteralExpression(propertyNode)) {
@@ -399,13 +536,19 @@ function traceConfigToComponentPaths(configObject, propertyName, projectPath) {
   }
   return [];
 }
-function detectConfigBasedComponents(sourceFile, nodeMap, edges, projectPath) {
+function detectConfigBasedComponents(sourceFile, nodeMap, edges, projectPath, project) {
   let totalEdgesCreated = 0;
   try {
     const jsxElements = sourceFile.getDescendantsOfKind(SyntaxKind.JsxSelfClosingElement);
+    console.log(`[DEBUG] File: ${sourceFile.getFilePath()}, JSX elements: ${jsxElements.length}`);
     for (const jsxElement of jsxElements) {
+      console.log(`[DEBUG] Processing JSX element: ${jsxElement.getText().substring(0, 50)}...`);
       const containingFunc = jsxElement.getFirstAncestorByKind(SyntaxKind.FunctionDeclaration) || jsxElement.getFirstAncestorByKind(SyntaxKind.ArrowFunction);
-      if (!containingFunc) continue;
+      if (!containingFunc) {
+        console.log("[DEBUG] No containing function found, skipping");
+        continue;
+      }
+      console.log(`[DEBUG] Containing function kind: ${containingFunc.getKindName()}`);
       let parentName = null;
       if (containingFunc.getKind() === SyntaxKind.FunctionDeclaration) {
         parentName = containingFunc.getName?.();
@@ -415,16 +558,27 @@ function detectConfigBasedComponents(sourceFile, nodeMap, edges, projectPath) {
           parentName = varDecl.getName?.();
         }
       }
-      if (!parentName) continue;
+      console.log(`[DEBUG] Parent name: ${parentName}`);
+      if (!parentName) {
+        console.log("[DEBUG] No parent name found, skipping");
+        continue;
+      }
       const sourceNode = Array.from(nodeMap.values()).find((node) => {
         const nodeName = node.id.split("::")[1];
         return nodeName === parentName;
       });
-      if (!sourceNode) continue;
+      console.log(`[DEBUG] Source node found: ${sourceNode ? sourceNode.id : "NO"}`);
+      if (!sourceNode) {
+        console.log("[DEBUG] No source node in nodeMap, skipping");
+        continue;
+      }
       const commonPropNames = ["router", "config", "routes", "navigation"];
       for (const propName of commonPropNames) {
-        const componentPaths = analyzeJsxPropsForComponents(jsxElement, propName, projectPath);
+        console.log(`[DEBUG] Checking prop: ${propName}`);
+        const componentPaths = analyzeJsxPropsForComponents(jsxElement, propName, projectPath, project);
+        console.log(`[DEBUG] Component paths found: ${componentPaths.length}`);
         if (componentPaths.length > 0) {
+          console.log(`[DEBUG] Creating edges for ${componentPaths.length} components`);
           const edgesCreated = createConfigBasedEdges(
             sourceNode,
             componentPaths,
@@ -432,6 +586,7 @@ function detectConfigBasedComponents(sourceFile, nodeMap, edges, projectPath) {
             edges,
             `config:${propName}`
           );
+          console.log(`[DEBUG] Edges created: ${edgesCreated}`);
           totalEdgesCreated += edgesCreated;
         }
       }
@@ -469,6 +624,7 @@ async function analyzeProject(projectPath, projectId, onLog) {
     const nodes = [];
     const edges = [];
     const nodeMap = /* @__PURE__ */ new Map();
+    const externalNodeMap = /* @__PURE__ */ new Map();
     const usedIds = /* @__PURE__ */ new Set();
     const idCounters = /* @__PURE__ */ new Map();
     let fileIndex = 0;
@@ -499,13 +655,13 @@ async function analyzeProject(projectPath, projectId, onLog) {
     }
     log(`  Extracted ${nodes.length} nodes`);
     for (const sourceFile of sourceFiles) {
-      generateEdges(sourceFile, nodeMap, edges);
+      generateEdges(sourceFile, nodeMap, edges, nodes, externalNodeMap);
     }
     log(`  Generated ${edges.length} edges (syntactic analysis)`);
     log(`  Analyzing config-based components...`);
     let totalConfigEdges = 0;
     for (const sourceFile of sourceFiles) {
-      const configEdges = detectConfigBasedComponents(sourceFile, nodeMap, edges, projectPath);
+      const configEdges = detectConfigBasedComponents(sourceFile, nodeMap, edges, projectPath, project);
       totalConfigEdges += configEdges;
     }
     if (totalConfigEdges > 0) {
@@ -986,25 +1142,86 @@ function extractState(sourceFile, relativePath, gitHash, baseX, startY, nodes, n
   });
   return count;
 }
-function generateEdges(sourceFile, nodeMap, edges) {
+function resolveImportSource(sourceFile, identifierName) {
+  const importDecls = sourceFile.getImportDeclarations();
+  for (const importDecl of importDecls) {
+    const namedImports = importDecl.getNamedImports();
+    const defaultImport = importDecl.getDefaultImport();
+    const namespaceImport = importDecl.getNamespaceImport();
+    if (namedImports.some((ni) => ni.getName() === identifierName)) {
+      return importDecl.getModuleSpecifierValue();
+    }
+    if (defaultImport?.getText() === identifierName) {
+      return importDecl.getModuleSpecifierValue();
+    }
+    if (namespaceImport && identifierName.startsWith(namespaceImport.getText() + ".")) {
+      return importDecl.getModuleSpecifierValue();
+    }
+  }
+  return null;
+}
+function createExternalComponentNode(componentName, packageName, sourceFilePath, nodes, nodeMap, externalNodeMap) {
+  const externalId = `external::${packageName}::${componentName}`;
+  if (externalNodeMap.has(externalId)) {
+    return externalNodeMap.get(externalId);
+  }
+  const node = {
+    id: externalId,
+    type: "component",
+    position: { x: 1200, y: nodes.length * 150 },
+    // Position externals to the right
+    data: {
+      componentName,
+      props: "external",
+      label: componentName,
+      description: `External: ${packageName}`,
+      returnValueSummary: `<${componentName} />`,
+      returnDescription: `External component from ${packageName}`,
+      hasJsxReturn: true,
+      hasNullReturn: false,
+      primaryReturnType: "jsx"
+    }
+  };
+  externalNodeMap.set(externalId, node);
+  nodeMap.set(componentName, node);
+  nodes.push(node);
+  return node;
+}
+function generateEdges(sourceFile, nodeMap, edges, nodes, externalNodeMap) {
   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"
-            });
+      if (parentName && nodeMap.has(parentName)) {
+        let targetNode = nodeMap.get(tagName);
+        if (!targetNode) {
+          const importSource = resolveImportSource(sourceFile, tagName);
+          if (importSource && !importSource.startsWith(".") && !importSource.startsWith("/")) {
+            const sourceFilePath = sourceFile.getFilePath();
+            targetNode = createExternalComponentNode(
+              tagName,
+              importSource,
+              sourceFilePath,
+              nodes,
+              nodeMap,
+              externalNodeMap
+            );
+          }
+        }
+        if (targetNode) {
+          const sourceNode = nodeMap.get(parentName);
+          if (sourceNode) {
+            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"
+              });
+            }
           }
         }
       }
@@ -1015,18 +1232,34 @@ function generateEdges(sourceFile, nodeMap, edges) {
     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"
-            });
+      if (parentName && nodeMap.has(parentName)) {
+        let targetNode = nodeMap.get(tagName);
+        if (!targetNode) {
+          const importSource = resolveImportSource(sourceFile, tagName);
+          if (importSource && !importSource.startsWith(".") && !importSource.startsWith("/")) {
+            const sourceFilePath = sourceFile.getFilePath();
+            targetNode = createExternalComponentNode(
+              tagName,
+              importSource,
+              sourceFilePath,
+              nodes,
+              nodeMap,
+              externalNodeMap
+            );
+          }
+        }
+        if (targetNode) {
+          const sourceNode = nodeMap.get(parentName);
+          if (sourceNode) {
+            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"
+              });
+            }
           }
         }
       }

package/dist/index.js

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

package/dist/vite-plugin.js

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

package/package.json

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