@rayburst/cli 0.2.7 → 0.2.9

package/dist/{chunk-JMVBDG54.js → chunk-7HEX7KJS.js}

@@ -334,27 +334,43 @@ function createConfigBasedEdges(sourceNode, targetFilePaths, nodeMap, edges, edg
 function analyzeJsxPropsForComponents(jsxElement, propName, projectPath) {
   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) {
+        console.log(`[DEBUG analyzeJsxProps] Checking config property: ${commonPropName}`);
         const paths = traceConfigToComponentPaths(configArg, commonPropName, projectPath);
+        console.log(`[DEBUG analyzeJsxProps] Paths found for ${commonPropName}: ${paths.length}`);
         if (paths.length > 0) {
           return paths;
         }
@@ -403,20 +419,45 @@ function detectConfigBasedComponents(sourceFile, nodeMap, edges, projectPath) {
   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;
-      const parentName = containingFunc.getName?.() || containingFunc.getParent()?.asKind(SyntaxKind.VariableDeclaration)?.getName() || null;
-      if (!parentName) 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?.();
+      } else if (containingFunc.getKind() === SyntaxKind.ArrowFunction) {
+        const varDecl = containingFunc.getParent();
+        if (varDecl && varDecl.getKind() === SyntaxKind.VariableDeclaration) {
+          parentName = varDecl.getName?.();
+        }
+      }
+      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) {
+        console.log(`[DEBUG] Checking prop: ${propName}`);
         const componentPaths = analyzeJsxPropsForComponents(jsxElement, propName, projectPath);
+        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,
@@ -424,6 +465,7 @@ function detectConfigBasedComponents(sourceFile, nodeMap, edges, projectPath) {
             edges,
             `config:${propName}`
           );
+          console.log(`[DEBUG] Edges created: ${edgesCreated}`);
           totalEdgesCreated += edgesCreated;
         }
       }
@@ -461,6 +503,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;
@@ -491,7 +534,7 @@ 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...`);
@@ -978,25 +1021,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"
+              });
+            }
           }
         }
       }
@@ -1007,18 +1111,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-JMVBDG54.js";
+} from "./chunk-7HEX7KJS.js";
 export {
   addGitignoreEntry,
   analyzeProject,

package/dist/vite-plugin.js

@@ -1,6 +1,6 @@
 import {
   rayburstPlugin
-} from "./chunk-JMVBDG54.js";
+} from "./chunk-7HEX7KJS.js";
 export {
   rayburstPlugin
 };

package/package.json

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