@rayburst/cli 0.2.6 → 0.2.7

package/dist/{chunk-XZXZKHVG.js → chunk-JMVBDG54.js}

@@ -124,6 +124,315 @@ function getChangedFilesVsRemote(projectPath, remoteBranch = void 0) {
 }
 
 // src/analysis/analyze-project.ts
+function isIdentifier(node) {
+  return node?.getKind() === SyntaxKind.Identifier;
+}
+function isVariableDeclaration(node) {
+  return node?.getKind() === SyntaxKind.VariableDeclaration;
+}
+function isCallExpression(node) {
+  return node?.getKind() === SyntaxKind.CallExpression;
+}
+function isObjectLiteralExpression(node) {
+  return node?.getKind() === SyntaxKind.ObjectLiteralExpression;
+}
+function isImportDeclaration(node) {
+  return node?.getKind() === SyntaxKind.ImportDeclaration;
+}
+function traceIdentifierToDeclaration(node) {
+  if (!isIdentifier(node)) {
+    return null;
+  }
+  try {
+    const symbol = node.getSymbol();
+    if (!symbol) {
+      return null;
+    }
+    const declarations = symbol.getDeclarations();
+    if (declarations.length === 0) {
+      return null;
+    }
+    return declarations[0];
+  } catch (error) {
+    console.error(`[traceIdentifierToDeclaration] Error tracing identifier "${node.getText()}":`, error);
+    return null;
+  }
+}
+function getImportSourceFile(importDeclaration) {
+  if (!isImportDeclaration(importDeclaration)) {
+    return null;
+  }
+  try {
+    const moduleSpecifier = importDeclaration.getChildrenOfKind(SyntaxKind.StringLiteral)[0];
+    if (!moduleSpecifier) {
+      return null;
+    }
+    const symbol = moduleSpecifier.getSymbol();
+    if (!symbol) {
+      return null;
+    }
+    const declarations = symbol.getDeclarations();
+    if (declarations.length === 0) {
+      return null;
+    }
+    return declarations[0].getSourceFile();
+  } catch (error) {
+    console.error(`[getImportSourceFile] Error getting import source:`, error);
+    return null;
+  }
+}
+function traceVariableDataFlow(variableNode, maxDepth = 5) {
+  if (maxDepth <= 0) {
+    console.log("[traceVariableDataFlow] Max depth reached, stopping recursion");
+    return null;
+  }
+  if (!isVariableDeclaration(variableNode)) {
+    return null;
+  }
+  try {
+    const initializer = variableNode.getChildrenOfKind(SyntaxKind.CallExpression)[0] || variableNode.getChildrenOfKind(SyntaxKind.ObjectLiteralExpression)[0] || variableNode.getChildrenOfKind(SyntaxKind.Identifier)[0];
+    if (!initializer) {
+      return null;
+    }
+    if (isCallExpression(initializer) || isObjectLiteralExpression(initializer)) {
+      return initializer;
+    }
+    if (isIdentifier(initializer)) {
+      const declaration = traceIdentifierToDeclaration(initializer);
+      if (declaration && isVariableDeclaration(declaration)) {
+        return traceVariableDataFlow(declaration, maxDepth - 1);
+      }
+      return declaration;
+    }
+    return initializer;
+  } catch (error) {
+    console.error("[traceVariableDataFlow] Error tracing variable:", error);
+    return null;
+  }
+}
+function extractObjectLiteralProperties(objectLiteral) {
+  const properties = /* @__PURE__ */ new Map();
+  if (!isObjectLiteralExpression(objectLiteral)) {
+    return properties;
+  }
+  try {
+    const propertyAssignments = objectLiteral.getChildrenOfKind(SyntaxKind.PropertyAssignment);
+    for (const prop of propertyAssignments) {
+      const nameNode = prop.getChildrenOfKind(SyntaxKind.Identifier)[0];
+      if (!nameNode) continue;
+      const propName = nameNode.getText();
+      const children = prop.getChildren();
+      const valueNode = children[children.length - 1];
+      if (valueNode) {
+        properties.set(propName, valueNode);
+      }
+    }
+    const shorthandProperties = objectLiteral.getChildrenOfKind(SyntaxKind.ShorthandPropertyAssignment);
+    for (const prop of shorthandProperties) {
+      const nameNode = prop.getChildrenOfKind(SyntaxKind.Identifier)[0];
+      if (nameNode) {
+        const propName = nameNode.getText();
+        properties.set(propName, nameNode);
+      }
+    }
+  } catch (error) {
+    console.error("[extractObjectLiteralProperties] Error extracting properties:", error);
+  }
+  return properties;
+}
+function traceConfigProperty(configObject, propertyName) {
+  if (!isObjectLiteralExpression(configObject)) {
+    return null;
+  }
+  try {
+    const properties = extractObjectLiteralProperties(configObject);
+    const propertyValue = properties.get(propertyName);
+    if (!propertyValue) {
+      return null;
+    }
+    if (isIdentifier(propertyValue)) {
+      const declaration = traceIdentifierToDeclaration(propertyValue);
+      if (!declaration) {
+        return null;
+      }
+      if (isVariableDeclaration(declaration)) {
+        return traceVariableDataFlow(declaration);
+      }
+      if (isImportDeclaration(declaration.getParent())) {
+        return declaration.getParent();
+      }
+      return declaration;
+    }
+    if (isObjectLiteralExpression(propertyValue) || isCallExpression(propertyValue)) {
+      return propertyValue;
+    }
+    return propertyValue;
+  } catch (error) {
+    console.error(`[traceConfigProperty] Error tracing property "${propertyName}":`, error);
+    return null;
+  }
+}
+function extractComponentPathsFromImports(sourceFile, projectPath) {
+  const componentPaths = [];
+  try {
+    const importDeclarations = sourceFile.getChildrenOfKind(SyntaxKind.ImportDeclaration);
+    for (const importDecl of importDeclarations) {
+      try {
+        const importedSourceFile = getImportSourceFile(importDecl);
+        if (!importedSourceFile) {
+          continue;
+        }
+        const filePath = importedSourceFile.getFilePath();
+        const relativePath = filePath.replace(projectPath + "/", "");
+        if (relativePath.includes("node_modules")) {
+          continue;
+        }
+        componentPaths.push(relativePath);
+      } catch (error) {
+        console.error("[extractComponentPathsFromImports] Error processing import:", error);
+      }
+    }
+  } catch (error) {
+    console.error("[extractComponentPathsFromImports] Error extracting imports:", error);
+  }
+  return componentPaths;
+}
+function findNodesInFile(filePath, nodeMap) {
+  const nodes = [];
+  for (const [nodeId, node] of nodeMap.entries()) {
+    const filePathInId = nodeId.split("::")[0];
+    if (filePathInId === filePath) {
+      nodes.push(node);
+    }
+  }
+  return nodes;
+}
+function createConfigBasedEdges(sourceNode, targetFilePaths, nodeMap, edges, edgeType = "config") {
+  let edgesCreated = 0;
+  for (const targetFilePath of targetFilePaths) {
+    const targetNodes = findNodesInFile(targetFilePath, nodeMap);
+    for (const targetNode of targetNodes) {
+      if (sourceNode.id === targetNode.id) {
+        continue;
+      }
+      const edgeId = `e-${sourceNode.id}-${targetNode.id}`;
+      if (edges.find((e) => e.id === edgeId)) {
+        continue;
+      }
+      edges.push({
+        id: edgeId,
+        source: sourceNode.id,
+        target: targetNode.id,
+        type: "floating",
+        label: edgeType
+      });
+      edgesCreated++;
+    }
+  }
+  return edgesCreated;
+}
+function analyzeJsxPropsForComponents(jsxElement, propName, projectPath) {
+  const componentPaths = [];
+  try {
+    const attributes = jsxElement.getChildrenOfKind(SyntaxKind.JsxAttribute);
+    for (const attr of attributes) {
+      const attrName = attr.getChildrenOfKind(SyntaxKind.Identifier)[0]?.getText();
+      if (attrName !== propName) {
+        continue;
+      }
+      const initializer = attr.getChildrenOfKind(SyntaxKind.JsxExpression)[0];
+      if (!initializer) continue;
+      const identifier = initializer.getChildrenOfKind(SyntaxKind.Identifier)[0];
+      if (!identifier) continue;
+      const declaration = traceIdentifierToDeclaration(identifier);
+      if (!declaration || !isVariableDeclaration(declaration)) continue;
+      const dataFlow = traceVariableDataFlow(declaration);
+      if (!dataFlow || !isCallExpression(dataFlow)) continue;
+      const args = dataFlow.getChildrenOfKind(SyntaxKind.SyntaxList)[0];
+      if (!args) continue;
+      const configArg = args.getChildrenOfKind(SyntaxKind.ObjectLiteralExpression)[0];
+      if (!configArg) continue;
+      const commonPropNames = ["routeTree", "routes", "children", "components"];
+      for (const commonPropName of commonPropNames) {
+        const paths = traceConfigToComponentPaths(configArg, commonPropName, projectPath);
+        if (paths.length > 0) {
+          return paths;
+        }
+      }
+    }
+  } catch (error) {
+    console.error("[analyzeJsxPropsForComponents] Error:", error);
+  }
+  return componentPaths;
+}
+function traceConfigToComponentPaths(configObject, propertyName, projectPath) {
+  try {
+    const propertyNode = traceConfigProperty(configObject, propertyName);
+    if (!propertyNode) {
+      return [];
+    }
+    if (isImportDeclaration(propertyNode)) {
+      const sourceFile = getImportSourceFile(propertyNode);
+      if (sourceFile) {
+        return extractComponentPathsFromImports(sourceFile, projectPath);
+      }
+    }
+    if (isObjectLiteralExpression(propertyNode)) {
+      const properties = extractObjectLiteralProperties(propertyNode);
+      const allPaths = [];
+      for (const [, value] of properties) {
+        if (isIdentifier(value)) {
+          const decl = traceIdentifierToDeclaration(value);
+          if (decl && isImportDeclaration(decl.getParent())) {
+            const sourceFile = getImportSourceFile(decl.getParent());
+            if (sourceFile) {
+              const paths = extractComponentPathsFromImports(sourceFile, projectPath);
+              allPaths.push(...paths);
+            }
+          }
+        }
+      }
+      return allPaths;
+    }
+  } catch (error) {
+    console.error("[traceConfigToComponentPaths] Error:", error);
+  }
+  return [];
+}
+function detectConfigBasedComponents(sourceFile, nodeMap, edges, projectPath) {
+  let totalEdgesCreated = 0;
+  try {
+    const jsxElements = sourceFile.getDescendantsOfKind(SyntaxKind.JsxSelfClosingElement);
+    for (const jsxElement of jsxElements) {
+      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;
+      const sourceNode = Array.from(nodeMap.values()).find((node) => {
+        const nodeName = node.id.split("::")[1];
+        return nodeName === parentName;
+      });
+      if (!sourceNode) continue;
+      const commonPropNames = ["router", "config", "routes", "navigation"];
+      for (const propName of commonPropNames) {
+        const componentPaths = analyzeJsxPropsForComponents(jsxElement, propName, projectPath);
+        if (componentPaths.length > 0) {
+          const edgesCreated = createConfigBasedEdges(
+            sourceNode,
+            componentPaths,
+            nodeMap,
+            edges,
+            `config:${propName}`
+          );
+          totalEdgesCreated += edgesCreated;
+        }
+      }
+    }
+  } catch (error) {
+    console.error("[detectConfigBasedComponents] Error:", error);
+  }
+  return totalEdgesCreated;
+}
 async function analyzeProject(projectPath, projectId, onLog) {
   const logs = [];
   const log = (message) => {
@@ -184,7 +493,17 @@ async function analyzeProject(projectPath, projectId, onLog) {
     for (const sourceFile of sourceFiles) {
       generateEdges(sourceFile, nodeMap, edges);
     }
-    log(`  Generated ${edges.length} edges`);
+    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);
+      totalConfigEdges += configEdges;
+    }
+    if (totalConfigEdges > 0) {
+      log(`  Generated ${totalConfigEdges} additional edges from config analysis`);
+    }
+    log(`  Total edges: ${edges.length}`);
     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-XZXZKHVG.js";
+} from "./chunk-JMVBDG54.js";
 export {
   addGitignoreEntry,
   analyzeProject,

package/dist/vite-plugin.js

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

package/package.json

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