@rayburst/cli 0.2.2 → 0.2.4

package/dist/{chunk-ZAT3D23Y.js → chunk-74JMCHWV.js}

@@ -8,6 +8,25 @@ import crypto from "crypto";
 // src/git-utils.ts
 import { execSync } from "child_process";
 import path from "path";
+function getUncommittedChanges(projectPath) {
+  try {
+    if (!isGitRepository(projectPath)) {
+      return [];
+    }
+    const command = "git diff --name-only HEAD && git diff --name-only --cached";
+    const output = execSync(command, {
+      cwd: projectPath,
+      encoding: "utf8",
+      stdio: ["pipe", "pipe", "ignore"]
+      // Ignore stderr
+    });
+    const files = output.split("\n").filter(Boolean).map((file) => path.resolve(projectPath, file.trim()));
+    return [...new Set(files)];
+  } catch (error) {
+    console.error("Failed to get git diff:", error.message);
+    return [];
+  }
+}
 function isGitRepository(projectPath) {
   try {
     execSync("git rev-parse --is-inside-work-tree", {
@@ -20,6 +39,27 @@ function isGitRepository(projectPath) {
     return false;
   }
 }
+function getUntrackedFiles(projectPath) {
+  try {
+    if (!isGitRepository(projectPath)) {
+      return [];
+    }
+    const output = execSync("git ls-files --others --exclude-standard", {
+      cwd: projectPath,
+      encoding: "utf8",
+      stdio: ["pipe", "pipe", "ignore"]
+    });
+    return output.split("\n").filter(Boolean).map((file) => path.resolve(projectPath, file.trim()));
+  } catch (error) {
+    console.error("Failed to get untracked files:", error.message);
+    return [];
+  }
+}
+function getAllChangedFiles(projectPath) {
+  const uncommitted = getUncommittedChanges(projectPath);
+  const untracked = getUntrackedFiles(projectPath);
+  return [.../* @__PURE__ */ new Set([...uncommitted, ...untracked])];
+}
 function getChangedFilesVsRemote(projectPath, remoteBranch = void 0) {
   try {
     if (!isGitRepository(projectPath)) {
@@ -74,7 +114,9 @@ function getChangedFilesVsRemote(projectPath, remoteBranch = void 0) {
       encoding: "utf8",
       stdio: ["pipe", "pipe", "ignore"]
     });
-    return output.split("\n").filter(Boolean).map((file) => path.resolve(projectPath, file.trim()));
+    const committedChanges = output.split("\n").filter(Boolean).map((file) => path.resolve(projectPath, file.trim()));
+    const uncommittedChanges = getAllChangedFiles(projectPath);
+    return [.../* @__PURE__ */ new Set([...committedChanges, ...uncommittedChanges])];
   } catch (error) {
     console.warn("Failed to get changed files vs remote:", error.message);
     return [];
@@ -267,10 +309,119 @@ function getUniqueNodeId(filePath, nodeName, gitHash, usedIds, idCounters) {
   return id;
 }
 function isReactComponent(func) {
+  const name = func.getName() || func.getParent()?.asKind?.(SyntaxKind.VariableDeclaration)?.getName?.();
+  const hasComponentName = name && /^[A-Z]/.test(name);
+  const returnType = func.getReturnType().getText();
+  const hasJsxReturnType = returnType.includes("JSX.Element") || returnType.includes("React.ReactElement") || returnType.includes("ReactElement") || returnType.includes("React.ReactNode") || returnType.includes("ReactNode");
   const body = func.getBody();
   if (!body) return false;
-  const text = body.getText();
-  return text.includes("return") && (text.includes("</") || text.includes("<>") || text.includes("jsx"));
+  const hasJsxElements = body.getDescendantsOfKind(SyntaxKind.JsxElement).length > 0 || body.getDescendantsOfKind(SyntaxKind.JsxSelfClosingElement).length > 0 || body.getDescendantsOfKind(SyntaxKind.JsxFragment).length > 0;
+  const hasHooks = body.getDescendantsOfKind(SyntaxKind.CallExpression).some((call) => {
+    const expr = call.getExpression().getText();
+    return expr.startsWith("use") && /^use[A-Z]/.test(expr);
+  });
+  if (hasJsxElements) return true;
+  if (hasJsxReturnType) return true;
+  if (hasComponentName && hasHooks) return true;
+  return false;
+}
+function analyzeReturnStatements(func) {
+  const body = func.getBody();
+  if (!body) {
+    return {
+      hasJsxReturn: false,
+      hasNullReturn: false,
+      hasUndefinedReturn: false,
+      returnValueSummary: "void",
+      primaryReturnType: "undefined"
+    };
+  }
+  const returnStatements = body.getDescendantsOfKind(SyntaxKind.ReturnStatement);
+  let hasJsxReturn = false;
+  let hasNullReturn = false;
+  let hasUndefinedReturn = false;
+  const returnTypes = [];
+  for (const returnStmt of returnStatements) {
+    const expr = returnStmt.getExpression();
+    if (!expr) {
+      hasUndefinedReturn = true;
+      returnTypes.push("undefined");
+      continue;
+    }
+    if (Node.isJsxElement(expr) || Node.isJsxSelfClosingElement(expr) || Node.isJsxFragment(expr)) {
+      hasJsxReturn = true;
+      let jsxName = "JSX";
+      if (Node.isJsxElement(expr)) {
+        jsxName = expr.getOpeningElement().getTagNameNode().getText();
+      } else if (Node.isJsxSelfClosingElement(expr)) {
+        jsxName = expr.getTagNameNode().getText();
+      } else {
+        jsxName = "<>";
+      }
+      returnTypes.push(`<${jsxName}>`);
+      continue;
+    }
+    if (expr.getKind() === SyntaxKind.NullKeyword) {
+      hasNullReturn = true;
+      returnTypes.push("null");
+      continue;
+    }
+    if (expr.getKind() === SyntaxKind.Identifier && expr.getText() === "undefined") {
+      hasUndefinedReturn = true;
+      returnTypes.push("undefined");
+      continue;
+    }
+    if (Node.isConditionalExpression(expr)) {
+      const whenTrue = expr.getWhenTrue();
+      const whenFalse = expr.getWhenFalse();
+      const trueIsJsx = Node.isJsxElement(whenTrue) || Node.isJsxSelfClosingElement(whenTrue);
+      const falseIsJsx = Node.isJsxElement(whenFalse) || Node.isJsxSelfClosingElement(whenFalse);
+      if (trueIsJsx || falseIsJsx) hasJsxReturn = true;
+      if (whenTrue.getText() === "null") hasNullReturn = true;
+      if (whenFalse.getText() === "null") hasNullReturn = true;
+      const trueText = whenTrue.getText().length > 20 ? whenTrue.getText().substring(0, 17) + "..." : whenTrue.getText();
+      const falseText = whenFalse.getText().length > 20 ? whenFalse.getText().substring(0, 17) + "..." : whenFalse.getText();
+      returnTypes.push(`${trueText} : ${falseText}`);
+      continue;
+    }
+    const exprText = expr.getText();
+    const truncated = exprText.length > 50 ? exprText.substring(0, 47) + "..." : exprText;
+    returnTypes.push(truncated);
+  }
+  let primaryReturnType = "mixed";
+  if (hasJsxReturn && !hasNullReturn && !hasUndefinedReturn) {
+    primaryReturnType = "jsx";
+  } else if (hasNullReturn && !hasJsxReturn && !hasUndefinedReturn) {
+    primaryReturnType = "null";
+  } else if (hasUndefinedReturn && !hasJsxReturn && !hasNullReturn) {
+    primaryReturnType = "undefined";
+  } else if (returnTypes.length === 1) {
+    primaryReturnType = "primitive";
+  }
+  const uniqueReturns = Array.from(new Set(returnTypes));
+  const returnValueSummary = uniqueReturns.join(" | ") || "void";
+  return {
+    hasJsxReturn,
+    hasNullReturn,
+    hasUndefinedReturn,
+    returnValueSummary,
+    primaryReturnType
+  };
+}
+function getReturnDescription(returnAnalysis) {
+  if (returnAnalysis.hasJsxReturn && returnAnalysis.hasNullReturn) {
+    return "Returns JSX or null";
+  }
+  if (returnAnalysis.hasJsxReturn) {
+    return "Returns JSX";
+  }
+  if (returnAnalysis.hasNullReturn) {
+    return "Returns null";
+  }
+  if (returnAnalysis.hasUndefinedReturn) {
+    return "Returns void";
+  }
+  return "Returns value";
 }
 function extractComponents(sourceFile, relativePath, gitHash, baseX, startY, nodes, nodeMap, usedIds, idCounters) {
   let count = 0;
@@ -283,6 +434,7 @@ function extractComponents(sourceFile, relativePath, gitHash, baseX, startY, nod
       const params = func.getParameters();
       const propsParam = params[0];
       const propsType = propsParam ? propsParam.getType().getText() : "any";
+      const returnAnalysis = analyzeReturnStatements(func);
       const node = {
         id,
         type: "component",
@@ -291,7 +443,12 @@ function extractComponents(sourceFile, relativePath, gitHash, baseX, startY, nod
           componentName: name,
           props: propsType,
           label: name,
-          description: `Component in ${relativePath}`
+          description: `Component in ${relativePath}`,
+          returnValueSummary: returnAnalysis.returnValueSummary,
+          returnDescription: getReturnDescription(returnAnalysis),
+          hasJsxReturn: returnAnalysis.hasJsxReturn,
+          hasNullReturn: returnAnalysis.hasNullReturn,
+          primaryReturnType: returnAnalysis.primaryReturnType
         }
       };
       nodes.push(node);
@@ -311,6 +468,7 @@ function extractComponents(sourceFile, relativePath, gitHash, baseX, startY, nod
         const params = init.getParameters();
         const propsParam = params[0];
         const propsType = propsParam ? propsParam.getType().getText() : "any";
+        const returnAnalysis = analyzeReturnStatements(init);
         const node = {
           id,
           type: "component",
@@ -319,7 +477,12 @@ function extractComponents(sourceFile, relativePath, gitHash, baseX, startY, nod
             componentName: name,
             props: propsType,
             label: name,
-            description: `Component in ${relativePath}`
+            description: `Component in ${relativePath}`,
+            returnValueSummary: returnAnalysis.returnValueSummary,
+            returnDescription: getReturnDescription(returnAnalysis),
+            hasJsxReturn: returnAnalysis.hasJsxReturn,
+            hasNullReturn: returnAnalysis.hasNullReturn,
+            primaryReturnType: returnAnalysis.primaryReturnType
           }
         };
         nodes.push(node);
@@ -347,6 +510,7 @@ function extractFunctions(sourceFile, relativePath, gitHash, baseX, startY, node
         return `${paramName}: ${paramType}`;
       }).join(", ");
       const returnType = func.getReturnType().getText();
+      const returnAnalysis = analyzeReturnStatements(func);
       const node = {
         id,
         type: "function",
@@ -356,7 +520,12 @@ function extractFunctions(sourceFile, relativePath, gitHash, baseX, startY, node
           parameters: params,
           returnType,
           label: name,
-          description: `Function in ${relativePath}`
+          description: `Function in ${relativePath}`,
+          returnValueSummary: returnAnalysis.returnValueSummary,
+          returnDescription: getReturnDescription(returnAnalysis),
+          hasJsxReturn: returnAnalysis.hasJsxReturn,
+          hasNullReturn: returnAnalysis.hasNullReturn,
+          primaryReturnType: returnAnalysis.primaryReturnType
         }
       };
       nodes.push(node);

package/dist/index.js

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

package/dist/vite-plugin.js

@@ -1,6 +1,6 @@
 import {
   rayburstPlugin
-} from "./chunk-ZAT3D23Y.js";
+} from "./chunk-74JMCHWV.js";
 export {
   rayburstPlugin
 };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@rayburst/cli",
-  "version": "0.2.2",
+  "version": "0.2.4",
   "description": "Rayburst - Automatic code analysis for TypeScript/JavaScript projects via Vite plugin",
   "type": "module",
   "main": "./dist/index.js",
@@ -42,12 +42,12 @@
     }
   },
   "dependencies": {
-    "@rayburst/types": "^0.1.3",
     "chalk": "^5.3.0",
     "ts-morph": "^21.0.1",
     "zod": "^4.2.0"
   },
   "devDependencies": {
+    "@rayburst/types": "^0.1.4",
     "@types/node": "^25.0.2",
     "tsup": "^8.5.1",
     "typescript": "^5.9.3",