arcvision 0.2.1 → 0.2.3

package/dist/index.js

@@ -56569,6 +56569,692 @@ var require_parser = __commonJS({
   }
 });
 
+// src/core/di-detector.js
+var require_di_detector = __commonJS({
+  "src/core/di-detector.js"(exports2, module2) {
+    var traverse = require_lib8().default;
+    function detectConstructorInjection(ast) {
+      const injections = [];
+      traverse(ast, {
+        ClassDeclaration(path2) {
+          const className = path2.node.id ? path2.node.id.name : "Anonymous";
+          const constructor = path2.node.body.body.find(
+            (member) => member.kind === "constructor"
+          );
+          if (constructor && constructor.params) {
+            constructor.params.forEach((param) => {
+              let paramName = null;
+              let paramType = null;
+              if (param.type === "TSParameterProperty") {
+                if (param.parameter.type === "Identifier") {
+                  paramName = param.parameter.name;
+                  if (param.parameter.typeAnnotation) {
+                    paramType = extractTypeName(param.parameter.typeAnnotation);
+                  }
+                }
+              } else if (param.type === "Identifier") {
+                paramName = param.name;
+                if (param.typeAnnotation) {
+                  paramType = extractTypeName(param.typeAnnotation);
+                }
+              }
+              if (paramName) {
+                injections.push({
+                  className,
+                  paramName,
+                  paramType,
+                  pattern: "constructor_injection",
+                  loc: constructor.loc
+                });
+              }
+            });
+          }
+        }
+      });
+      return injections;
+    }
+    function detectReactContextUsage(ast) {
+      const contextUsages = [];
+      traverse(ast, {
+        // Detect useContext hook calls
+        CallExpression(path2) {
+          if (path2.node.callee.name === "useContext" && path2.node.arguments.length > 0) {
+            const contextArg = path2.node.arguments[0];
+            let contextName = null;
+            if (contextArg.type === "Identifier") {
+              contextName = contextArg.name;
+            } else if (contextArg.type === "MemberExpression") {
+              contextName = extractMemberExpressionName(contextArg);
+            }
+            if (contextName) {
+              contextUsages.push({
+                type: "useContext",
+                contextName,
+                pattern: "context_consumer",
+                loc: path2.node.loc
+              });
+            }
+          }
+        },
+        // Detect Context.Provider usage in JSX
+        JSXElement(path2) {
+          const openingElement = path2.node.openingElement;
+          if (openingElement.name.type === "JSXMemberExpression") {
+            const objectName = openingElement.name.object.name;
+            const propertyName = openingElement.name.property.name;
+            if (propertyName === "Provider" || propertyName === "Consumer") {
+              contextUsages.push({
+                type: "JSXProvider",
+                contextName: objectName,
+                pattern: propertyName === "Provider" ? "context_provider" : "context_consumer",
+                loc: path2.node.loc
+              });
+            }
+          }
+        }
+      });
+      return contextUsages;
+    }
+    function detectHookDependencies(ast) {
+      const hookDeps = [];
+      traverse(ast, {
+        CallExpression(path2) {
+          const calleeName = path2.node.callee.name;
+          if (calleeName && calleeName.startsWith("use") && calleeName !== "useContext") {
+            hookDeps.push({
+              hookName: calleeName,
+              pattern: "custom_hook",
+              loc: path2.node.loc
+            });
+          }
+        }
+      });
+      return hookDeps;
+    }
+    function detectDependencyInjection(ast) {
+      if (!ast) {
+        return {
+          constructorInjections: [],
+          contextUsages: [],
+          hookDependencies: []
+        };
+      }
+      return {
+        constructorInjections: detectConstructorInjection(ast),
+        contextUsages: detectReactContextUsage(ast),
+        hookDependencies: detectHookDependencies(ast)
+      };
+    }
+    function extractTypeName(typeAnnotation) {
+      if (!typeAnnotation)
+        return null;
+      const annotation = typeAnnotation.typeAnnotation || typeAnnotation;
+      if (annotation.type === "TSTypeReference" && annotation.typeName) {
+        if (annotation.typeName.type === "Identifier") {
+          return annotation.typeName.name;
+        }
+      }
+      return null;
+    }
+    function extractMemberExpressionName(node) {
+      if (node.type === "MemberExpression") {
+        const object = node.object.name || "";
+        const property = node.property.name || "";
+        return object + "." + property;
+      }
+      return null;
+    }
+    module2.exports = {
+      detectConstructorInjection,
+      detectReactContextUsage,
+      detectHookDependencies,
+      detectDependencyInjection
+    };
+  }
+});
+
+// src/core/method-tracker.js
+var require_method_tracker = __commonJS({
+  "src/core/method-tracker.js"(exports2, module2) {
+    var traverse = require_lib8().default;
+    function trackMethodCalls(ast, imports = []) {
+      const functionCalls = [];
+      const methodCalls = [];
+      const constructorCalls = [];
+      if (!ast) {
+        return { functionCalls, methodCalls, constructorCalls };
+      }
+      const importedSymbols = /* @__PURE__ */ new Set();
+      imports.forEach((imp) => {
+        if (imp.specifiers && Array.isArray(imp.specifiers)) {
+          imp.specifiers.forEach((spec) => {
+            const localName = spec.local || spec.imported || spec;
+            if (typeof localName === "string") {
+              importedSymbols.add(localName);
+            }
+          });
+        }
+      });
+      traverse(ast, {
+        CallExpression(path2) {
+          const callee = path2.node.callee;
+          if (callee.type === "Identifier") {
+            const functionName = callee.name;
+            if (importedSymbols.has(functionName) || /^[A-Z]/.test(functionName)) {
+              functionCalls.push({
+                name: functionName,
+                type: "function_call",
+                loc: path2.node.loc
+              });
+            }
+          } else if (callee.type === "MemberExpression") {
+            const objectName = extractObjectName(callee.object);
+            const methodName = callee.property.name || callee.property.value;
+            if (objectName && methodName) {
+              methodCalls.push({
+                object: objectName,
+                method: methodName,
+                type: "method_call",
+                loc: path2.node.loc
+              });
+            }
+          }
+        },
+        // Track constructor calls: new ClassName()
+        NewExpression(path2) {
+          const callee = path2.node.callee;
+          if (callee.type === "Identifier") {
+            const className = callee.name;
+            if (importedSymbols.has(className)) {
+              constructorCalls.push({
+                className,
+                type: "constructor_call",
+                loc: path2.node.loc
+              });
+            }
+          }
+        }
+      });
+      return {
+        functionCalls,
+        methodCalls,
+        constructorCalls
+      };
+    }
+    function buildCallGraph(nodes) {
+      const callEdges = [];
+      nodes.forEach((node) => {
+        const filePath = node.id;
+        const metadata = node.metadata;
+        if (!metadata)
+          return;
+        if (metadata.functionCalls && Array.isArray(metadata.functionCalls)) {
+          metadata.functionCalls.forEach((call) => {
+            callEdges.push({
+              source: filePath,
+              callType: "function",
+              calledSymbol: call.name,
+              loc: call.loc
+            });
+          });
+        }
+        if (metadata.constructorCalls && Array.isArray(metadata.constructorCalls)) {
+          metadata.constructorCalls.forEach((call) => {
+            callEdges.push({
+              source: filePath,
+              callType: "constructor",
+              calledSymbol: call.className,
+              loc: call.loc
+            });
+          });
+        }
+        if (metadata.methodCalls && Array.isArray(metadata.methodCalls)) {
+          metadata.methodCalls.forEach((call) => {
+            callEdges.push({
+              source: filePath,
+              callType: "method",
+              calledSymbol: `${call.object}.${call.method}`,
+              loc: call.loc
+            });
+          });
+        }
+      });
+      return callEdges;
+    }
+    function extractObjectName(node) {
+      if (node.type === "Identifier") {
+        return node.name;
+      } else if (node.type === "ThisExpression") {
+        return "this";
+      } else if (node.type === "MemberExpression") {
+        const object = extractObjectName(node.object);
+        const property = node.property.name || node.property.value;
+        return object && property ? `${object}.${property}` : object;
+      }
+      return null;
+    }
+    module2.exports = {
+      trackMethodCalls,
+      buildCallGraph
+    };
+  }
+});
+
+// src/core/type-analyzer.js
+var require_type_analyzer = __commonJS({
+  "src/core/type-analyzer.js"(exports2, module2) {
+    var traverse = require_lib8().default;
+    function extractTypeImports(ast) {
+      const typeImports = [];
+      if (!ast)
+        return typeImports;
+      traverse(ast, {
+        ImportDeclaration(path2) {
+          const node = path2.node;
+          if (node.importKind === "type") {
+            const specifiers = [];
+            node.specifiers.forEach((spec) => {
+              if (spec.imported) {
+                specifiers.push({
+                  imported: spec.imported.name || spec.imported.value,
+                  local: spec.local.name
+                });
+              }
+            });
+            typeImports.push({
+              source: node.source.value,
+              specifiers,
+              importKind: "type",
+              loc: node.loc
+            });
+          } else {
+            const typeSpecifiers = [];
+            node.specifiers.forEach((spec) => {
+              if (spec.importKind === "type" && spec.imported) {
+                typeSpecifiers.push({
+                  imported: spec.imported.name || spec.imported.value,
+                  local: spec.local.name
+                });
+              }
+            });
+            if (typeSpecifiers.length > 0) {
+              typeImports.push({
+                source: node.source.value,
+                specifiers: typeSpecifiers,
+                importKind: "mixed",
+                loc: node.loc
+              });
+            }
+          }
+        }
+      });
+      return typeImports;
+    }
+    function extractInterfaceDependencies(ast) {
+      const interfaceDeps = [];
+      if (!ast)
+        return interfaceDeps;
+      traverse(ast, {
+        // Interface extends
+        TSInterfaceDeclaration(path2) {
+          const node = path2.node;
+          const interfaceName = node.id.name;
+          if (node.extends && node.extends.length > 0) {
+            node.extends.forEach((ext) => {
+              const extendedInterface = extractTypeName(ext.expression);
+              if (extendedInterface) {
+                interfaceDeps.push({
+                  interface: interfaceName,
+                  extends: extendedInterface,
+                  type: "interface_extends",
+                  loc: node.loc
+                });
+              }
+            });
+          }
+        },
+        // Class implements
+        ClassDeclaration(path2) {
+          const node = path2.node;
+          const className = node.id ? node.id.name : "Anonymous";
+          if (node.implements && node.implements.length > 0) {
+            node.implements.forEach((impl) => {
+              const implementedInterface = extractTypeName(impl.expression);
+              if (implementedInterface) {
+                interfaceDeps.push({
+                  class: className,
+                  implements: implementedInterface,
+                  type: "class_implements",
+                  loc: node.loc
+                });
+              }
+            });
+          }
+        }
+      });
+      return interfaceDeps;
+    }
+    function extractGenericDependencies(ast) {
+      const genericDeps = [];
+      if (!ast)
+        return genericDeps;
+      traverse(ast, {
+        // Function return types
+        FunctionDeclaration(path2) {
+          const node = path2.node;
+          const functionName = node.id ? node.id.name : "anonymous";
+          if (node.returnType) {
+            const returnTypeName = extractComplexTypeName(node.returnType.typeAnnotation);
+            if (returnTypeName) {
+              genericDeps.push({
+                function: functionName,
+                returnType: returnTypeName,
+                type: "return_type",
+                loc: node.loc
+              });
+            }
+          }
+        },
+        // Arrow function return types
+        ArrowFunctionExpression(path2) {
+          const node = path2.node;
+          if (node.returnType) {
+            const returnTypeName = extractComplexTypeName(node.returnType.typeAnnotation);
+            if (returnTypeName) {
+              genericDeps.push({
+                function: "arrow_function",
+                returnType: returnTypeName,
+                type: "return_type",
+                loc: node.loc
+              });
+            }
+          }
+        },
+        // Variable type annotations
+        VariableDeclarator(path2) {
+          const node = path2.node;
+          const varName = node.id.name;
+          if (node.id.typeAnnotation) {
+            const typeName = extractComplexTypeName(node.id.typeAnnotation.typeAnnotation);
+            if (typeName) {
+              genericDeps.push({
+                variable: varName,
+                type: typeName,
+                kind: "variable_type",
+                loc: node.loc
+              });
+            }
+          }
+        }
+      });
+      return genericDeps;
+    }
+    function analyzeTypeDependencies(ast) {
+      if (!ast) {
+        return {
+          typeImports: [],
+          interfaceDependencies: [],
+          genericDependencies: []
+        };
+      }
+      return {
+        typeImports: extractTypeImports(ast),
+        interfaceDependencies: extractInterfaceDependencies(ast),
+        genericDependencies: extractGenericDependencies(ast)
+      };
+    }
+    function extractTypeName(node) {
+      if (!node)
+        return null;
+      if (node.type === "Identifier") {
+        return node.name;
+      } else if (node.type === "TSTypeReference" && node.typeName) {
+        if (node.typeName.type === "Identifier") {
+          return node.typeName.name;
+        }
+      }
+      return null;
+    }
+    function extractComplexTypeName(node) {
+      if (!node)
+        return null;
+      if (node.type === "TSTypeReference" && node.typeName) {
+        let baseName = extractTypeName(node);
+        if (node.typeParameters && node.typeParameters.params) {
+          const params = node.typeParameters.params.map((p) => extractComplexTypeName(p)).filter(Boolean).join(", ");
+          if (params) {
+            baseName += `<${params}>`;
+          }
+        }
+        return baseName;
+      } else if (node.type === "Identifier") {
+        return node.name;
+      } else if (node.type === "TSArrayType") {
+        const elementType = extractComplexTypeName(node.elementType);
+        return elementType ? `${elementType}[]` : null;
+      }
+      return null;
+    }
+    module2.exports = {
+      extractTypeImports,
+      extractInterfaceDependencies,
+      extractGenericDependencies,
+      analyzeTypeDependencies
+    };
+  }
+});
+
+// src/core/react-nextjs-detector.js
+var require_react_nextjs_detector = __commonJS({
+  "src/core/react-nextjs-detector.js"(exports2, module2) {
+    var traverse = require_lib8().default;
+    function detectComponentUsage(ast) {
+      const componentUsages = [];
+      if (!ast)
+        return componentUsages;
+      traverse(ast, {
+        JSXElement(path2) {
+          const openingElement = path2.node.openingElement;
+          let componentName = null;
+          if (openingElement.name.type === "JSXIdentifier") {
+            componentName = openingElement.name.name;
+            if (/^[A-Z]/.test(componentName)) {
+              componentUsages.push({
+                component: componentName,
+                type: "jsx_component",
+                loc: path2.node.loc
+              });
+            }
+          } else if (openingElement.name.type === "JSXMemberExpression") {
+            const object = openingElement.name.object.name;
+            const property = openingElement.name.property.name;
+            componentName = `${object}.${property}`;
+            componentUsages.push({
+              component: componentName,
+              type: "jsx_member_component",
+              loc: path2.node.loc
+            });
+          }
+        }
+      });
+      return componentUsages;
+    }
+    function detectServerClientBoundaries(content) {
+      const boundaries = {
+        isClientComponent: false,
+        isServerComponent: false,
+        isServerAction: false
+      };
+      if (!content)
+        return boundaries;
+      if (/['"]use client['"]/.test(content)) {
+        boundaries.isClientComponent = true;
+      }
+      if (/['"]use server['"]/.test(content)) {
+        boundaries.isServerAction = true;
+      }
+      if (!boundaries.isClientComponent && !boundaries.isServerAction) {
+        boundaries.isServerComponent = true;
+      }
+      return boundaries;
+    }
+    function detectAPIRouteDependencies(ast) {
+      const apiDeps = [];
+      if (!ast)
+        return apiDeps;
+      traverse(ast, {
+        // Detect Next.js API route handlers: export async function GET/POST/etc
+        ExportNamedDeclaration(path2) {
+          const node = path2.node;
+          if (node.declaration && node.declaration.type === "FunctionDeclaration") {
+            const funcName = node.declaration.id ? node.declaration.id.name : null;
+            if (["GET", "POST", "PUT", "DELETE", "PATCH", "HEAD", "OPTIONS"].includes(funcName)) {
+              apiDeps.push({
+                handler: funcName,
+                type: "api_route_handler",
+                loc: node.loc
+              });
+            }
+          }
+        },
+        // Detect fetch calls and database queries within API routes
+        CallExpression(path2) {
+          const callee = path2.node.callee;
+          if (callee.type === "MemberExpression") {
+            const objectName = callee.object.name;
+            const methodName = callee.property.name || callee.property.value;
+            if (objectName === "supabase" || /supabase/i.test(objectName)) {
+              apiDeps.push({
+                service: "supabase",
+                method: methodName,
+                type: "database_query",
+                loc: path2.node.loc
+              });
+            }
+            if (objectName === "prisma" || /prisma/i.test(objectName)) {
+              apiDeps.push({
+                service: "prisma",
+                method: methodName,
+                type: "database_query",
+                loc: path2.node.loc
+              });
+            }
+          }
+        }
+      });
+      return apiDeps;
+    }
+    function detectMiddlewareDependencies(ast, filePath = "") {
+      const middlewareDeps = [];
+      const isMiddleware = /middleware\.(ts|js)$/.test(filePath);
+      if (!isMiddleware || !ast)
+        return middlewareDeps;
+      traverse(ast, {
+        // Detect middleware function export
+        ExportNamedDeclaration(path2) {
+          const node = path2.node;
+          if (node.declaration && node.declaration.type === "FunctionDeclaration") {
+            const funcName = node.declaration.id ? node.declaration.id.name : null;
+            if (funcName === "middleware") {
+              middlewareDeps.push({
+                function: funcName,
+                type: "middleware_function",
+                loc: node.loc
+              });
+            }
+          }
+        },
+        // Detect auth checks and redirects
+        CallExpression(path2) {
+          const callee = path2.node.callee;
+          if (callee.type === "MemberExpression") {
+            const methodName = callee.property.name || callee.property.value;
+            if (methodName === "getUser" || methodName === "getSession") {
+              middlewareDeps.push({
+                service: "auth",
+                method: methodName,
+                type: "auth_check",
+                loc: path2.node.loc
+              });
+            }
+            if (methodName === "redirect" || methodName === "rewrite") {
+              middlewareDeps.push({
+                service: "next",
+                method: methodName,
+                type: "middleware_action",
+                loc: path2.node.loc
+              });
+            }
+          }
+        }
+      });
+      return middlewareDeps;
+    }
+    function detectReactNextJSPatterns(ast, content = "", filePath = "") {
+      return {
+        componentUsages: detectComponentUsage(ast),
+        boundaries: detectServerClientBoundaries(content),
+        apiDependencies: detectAPIRouteDependencies(ast),
+        middlewareDependencies: detectMiddlewareDependencies(ast, filePath)
+      };
+    }
+    module2.exports = {
+      detectComponentUsage,
+      detectServerClientBoundaries,
+      detectAPIRouteDependencies,
+      detectMiddlewareDependencies,
+      detectReactNextJSPatterns
+    };
+  }
+});
+
+// src/core/parser-enhanced.js
+var require_parser_enhanced = __commonJS({
+  "src/core/parser-enhanced.js"(exports2, module2) {
+    var { parseFile: originalParseFile } = require_parser();
+    var { detectDependencyInjection } = require_di_detector();
+    var { trackMethodCalls } = require_method_tracker();
+    var { analyzeTypeDependencies } = require_type_analyzer();
+    var { detectReactNextJSPatterns } = require_react_nextjs_detector();
+    var fs2 = require("fs");
+    function parseFileEnhanced(filePath) {
+      const metadata = originalParseFile(filePath);
+      if (!metadata.ast) {
+        return metadata;
+      }
+      const ast = metadata.ast;
+      const fileContent = fs2.readFileSync(filePath, "utf-8");
+      try {
+        const diPatterns = detectDependencyInjection(ast);
+        metadata.constructorInjections = diPatterns.constructorInjections || [];
+        metadata.contextUsages = diPatterns.contextUsages || [];
+        metadata.hookDependencies = diPatterns.hookDependencies || [];
+        const callTracking = trackMethodCalls(ast, metadata.imports);
+        metadata.functionCalls = callTracking.functionCalls || [];
+        metadata.constructorCalls = callTracking.constructorCalls || [];
+        metadata.methodCalls = callTracking.methodCalls || [];
+        const typeDeps = analyzeTypeDependencies(ast);
+        metadata.typeImports = typeDeps.typeImports || [];
+        metadata.interfaceDependencies = typeDeps.interfaceDependencies || [];
+        metadata.genericDependencies = typeDeps.genericDependencies || [];
+        const reactPatterns = detectReactNextJSPatterns(ast, fileContent, filePath);
+        metadata.componentUsage = reactPatterns.componentUsages || [];
+        metadata.serverClientBoundaries = reactPatterns.boundaries || {};
+        metadata.apiDependencies = reactPatterns.apiDependencies || [];
+        metadata.middlewareDependencies = reactPatterns.middlewareDependencies || [];
+      } catch (error) {
+        console.warn(`\u26A0\uFE0F Enhanced analysis failed for ${filePath}: ${error.message}`);
+      }
+      delete metadata.ast;
+      return metadata;
+    }
+    module2.exports = {
+      parseFile: parseFileEnhanced,
+      parseFileBasic: originalParseFile
+    };
+  }
+});
+
 // src/plugins/plugin-manager.js
 var require_plugin_manager = __commonJS({
   "src/plugins/plugin-manager.js"(exports2, module2) {
@@ -56597,7 +57283,7 @@ var require_plugin_manager = __commonJS({
               enhancedMetadata = { ...enhancedMetadata, ...result };
             }
           } catch (error) {
-            console.warn(`Plugin ${plugin.name} failed: ${error.message}`);
+            console.warn(`Plugin ${plugin.name} failed: ${error.message || error}`);
           }
         }
         return enhancedMetadata;
@@ -56695,7 +57381,7 @@ var require_path_resolver = __commonJS({
               const suffix = importPath.substring(patternBase.length);
               for (const target of aliasTargets) {
                 const targetBase = target.replace(/\*.*$/, "");
-                const targetPath = path2.resolve(projectRoot, targetBase) + suffix;
+                const targetPath = path2.resolve(projectRoot, path2.join(targetBase, suffix));
                 const extensions = [".ts", ".tsx", ".js", ".jsx", ".mjs", ".cjs", ".json"];
                 for (const ext of extensions) {
                   if (fs2.existsSync(targetPath + ext)) {
@@ -56982,29 +57668,43 @@ var require_context_builder = __commonJS({
       for (const edge of edges) {
         const sourceNode = nodes.find((n) => n.path === edge.source);
         const targetNode = nodes.find((n) => n.path === edge.target);
-        if (sourceNode && targetNode) {
+        if (sourceNode) {
           let relationType = "imports";
           if (edge.type === "imports" || edge.type === "require" || edge.type === "export-from" || edge.type === "export-all" || edge.type === "dynamic-import" || edge.type === "require-assignment") {
             relationType = "imports";
+          } else if (edge.type === "function_call" || edge.type === "method_call") {
+            relationType = "calls";
+          } else if (edge.type === "constructor_call") {
+            relationType = "calls";
+          } else if (edge.type === "component_usage" || edge.type === "jsx_component" || edge.type === "jsx_member_component") {
+            relationType = "imports";
           } else if (edge.type === "calls") {
             relationType = "calls";
           } else if (edge.type === "owns") {
             relationType = "owns";
           } else if (edge.type === "depends_on") {
             relationType = "depends_on";
+          } else {
+            relationType = "imports";
+          }
+          if (targetNode) {
+            schemaEdges.push({
+              from: sourceNode.id,
+              to: targetNode.id,
+              relation: relationType
+            });
+          } else {
           }
-          schemaEdges.push({
-            from: sourceNode.id,
-            to: targetNode.id,
-            relation: relationType
-          });
         }
       }
       const metrics = {
         total_files: nodes.length,
         total_nodes: nodes.length,
         total_edges: schemaEdges.length,
-        total_imports: schemaEdges.length,
+        total_imports: schemaEdges.filter((edge) => edge.relation === "imports").length,
+        total_calls: schemaEdges.filter((edge) => edge.relation === "calls").length,
+        total_owns: schemaEdges.filter((edge) => edge.relation === "owns").length,
+        total_depends_on: schemaEdges.filter((edge) => edge.relation === "depends_on").length,
         files_with_functions: nodes.filter((n) => n.role === "Implementation").length
       };
       const context = {
@@ -63577,13 +64277,167 @@ var require_context_sorter = __commonJS({
   }
 });
 
+// src/core/semantic-analyzer.js
+var require_semantic_analyzer = __commonJS({
+  "src/core/semantic-analyzer.js"(exports2, module2) {
+    function buildSymbolTable(nodes) {
+      const symbolTable = /* @__PURE__ */ new Map();
+      nodes.forEach((node) => {
+        const filePath = node.id;
+        const metadata = node.metadata;
+        if (!metadata)
+          return;
+        if (metadata.exports && Array.isArray(metadata.exports)) {
+          metadata.exports.forEach((exp) => {
+            const symbolName = exp.name;
+            if (!symbolTable.has(symbolName)) {
+              symbolTable.set(symbolName, []);
+            }
+            symbolTable.get(symbolName).push({
+              file: filePath,
+              type: exp.type,
+              loc: exp.loc
+            });
+          });
+        }
+        if (metadata.functions && Array.isArray(metadata.functions)) {
+          metadata.functions.forEach((func) => {
+            const symbolName = func.name;
+            if (!symbolTable.has(symbolName)) {
+              symbolTable.set(symbolName, []);
+            }
+            symbolTable.get(symbolName).push({
+              file: filePath,
+              type: "function",
+              loc: func.loc
+            });
+          });
+        }
+        if (metadata.classes && Array.isArray(metadata.classes)) {
+          metadata.classes.forEach((cls) => {
+            const symbolName = cls.name;
+            if (!symbolTable.has(symbolName)) {
+              symbolTable.set(symbolName, []);
+            }
+            symbolTable.get(symbolName).push({
+              file: filePath,
+              type: "class",
+              loc: cls.loc
+            });
+          });
+        }
+      });
+      return symbolTable;
+    }
+    function resolveSymbolUsage(node, symbolTable) {
+      const resolvedUsages = [];
+      const metadata = node.metadata;
+      if (!metadata)
+        return resolvedUsages;
+      const importedSymbols = /* @__PURE__ */ new Map();
+      if (metadata.imports && Array.isArray(metadata.imports)) {
+        metadata.imports.forEach((imp) => {
+          if (imp.specifiers && Array.isArray(imp.specifiers)) {
+            imp.specifiers.forEach((spec) => {
+              const localName = spec.local || spec.imported || spec;
+              const importedName = spec.imported || spec.local || spec;
+              importedSymbols.set(localName, {
+                source: imp.source,
+                originalName: importedName
+              });
+            });
+          }
+        });
+      }
+      if (metadata.functionCalls && Array.isArray(metadata.functionCalls)) {
+        metadata.functionCalls.forEach((call) => {
+          const callName = call.name;
+          if (importedSymbols.has(callName)) {
+            const importInfo = importedSymbols.get(callName);
+            resolvedUsages.push({
+              type: "function_call",
+              symbol: callName,
+              source: importInfo.source,
+              loc: call.loc
+            });
+          }
+        });
+      }
+      if (metadata.constructorCalls && Array.isArray(metadata.constructorCalls)) {
+        metadata.constructorCalls.forEach((call) => {
+          const className = call.className;
+          if (importedSymbols.has(className)) {
+            const importInfo = importedSymbols.get(className);
+            resolvedUsages.push({
+              type: "constructor_call",
+              symbol: className,
+              source: importInfo.source,
+              loc: call.loc
+            });
+          }
+        });
+      }
+      if (metadata.componentUsage && Array.isArray(metadata.componentUsage)) {
+        metadata.componentUsage.forEach((comp) => {
+          const componentName = comp.component;
+          if (importedSymbols.has(componentName)) {
+            const importInfo = importedSymbols.get(componentName);
+            resolvedUsages.push({
+              type: "component_usage",
+              symbol: componentName,
+              source: importInfo.source,
+              loc: comp.loc
+            });
+          }
+        });
+      }
+      return resolvedUsages;
+    }
+    function trackCrossFileReferences(nodes, symbolTable) {
+      const usageEdges = [];
+      nodes.forEach((node) => {
+        const filePath = node.id;
+        const resolvedUsages = resolveSymbolUsage(node, symbolTable);
+        resolvedUsages.forEach((usage) => {
+          usageEdges.push({
+            source: filePath,
+            target: usage.source,
+            type: usage.type,
+            symbol: usage.symbol,
+            loc: usage.loc
+          });
+        });
+      });
+      return usageEdges;
+    }
+    function analyzeSemantics(nodes) {
+      const symbolTable = buildSymbolTable(nodes);
+      const usageEdges = trackCrossFileReferences(nodes, symbolTable);
+      return {
+        symbolTable,
+        usageEdges,
+        stats: {
+          totalSymbols: symbolTable.size,
+          totalUsages: usageEdges.length
+        }
+      };
+    }
+    module2.exports = {
+      buildSymbolTable,
+      resolveSymbolUsage,
+      trackCrossFileReferences,
+      analyzeSemantics
+    };
+  }
+});
+
 // src/core/scanner.js
 var require_scanner = __commonJS({
   "src/core/scanner.js"(exports2, module2) {
     var { glob } = require_commonjs5();
     var path2 = require("path");
     var fs2 = require("fs");
-    var parser = require_parser();
+    var parser = require_parser_enhanced();
     var pluginManager = require_plugin_manager();
     var { loadTSConfig } = require_tsconfig_utils();
     var { resolveImport } = require_path_resolver();
@@ -63591,6 +64445,7 @@ var require_scanner = __commonJS({
     var { buildContext } = require_context_builder();
     var { validateContext } = require_context_validator();
     var { sortContext } = require_context_sorter();
+    var { analyzeSemantics } = require_semantic_analyzer();
     async function scan(directory) {
       const normalize = (p) => p.replace(/\\/g, "/");
       const options = {
@@ -63607,6 +64462,7 @@ var require_scanner = __commonJS({
           edges: []
         };
         const fileMap = /* @__PURE__ */ new Map();
+        let totalImportsFound = 0;
         for (const file of files) {
           try {
             const relativePath = path2.relative(directory, file);
@@ -63632,6 +64488,9 @@ var require_scanner = __commonJS({
               metadata = parser.parseFile(file);
             }
             metadata = await pluginManager.processFile(file, metadata);
+            if (metadata.imports && Array.isArray(metadata.imports)) {
+              totalImportsFound += metadata.imports.length;
+            }
             const node = {
               id: normalizedRelativePath,
               type: "file",
@@ -63643,42 +64502,266 @@ var require_scanner = __commonJS({
             console.warn(`\u26A0\uFE0F Failed to process ${file} \u2014 file skipped, you should check manually (${e.message})`);
           }
         }
+        console.log("Performing semantic analysis...");
+        const semanticResults = analyzeSemantics(architectureMap.nodes);
+        console.log(`Semantic analysis complete: ${semanticResults.stats.totalSymbols} symbols, ${semanticResults.stats.totalUsages} usage edges`);
         const tsconfig = loadTSConfig(directory);
+        const allPossiblePaths = /* @__PURE__ */ new Set();
         const pathToNodeIdMap = /* @__PURE__ */ new Map();
         architectureMap.nodes.forEach((node) => {
           const normalizedPath = normalize(node.id);
+          allPossiblePaths.add(normalizedPath);
           pathToNodeIdMap.set(normalizedPath, node.id);
         });
+        let unresolvedImports = 0;
+        let resolvedImports = 0;
         architectureMap.nodes.forEach((node) => {
           if (node.metadata.imports && Array.isArray(node.metadata.imports)) {
             node.metadata.imports.forEach((imp) => {
               if (imp.source && typeof imp.source === "string") {
-                const resolvedPath = resolveImport(
-                  imp.source,
-                  path2.join(directory, node.id),
-                  directory,
-                  tsconfig
-                );
-                if (resolvedPath) {
-                  const relativeResolvedPath = path2.relative(directory, resolvedPath);
-                  const normalizedResolvedPath = normalize(relativeResolvedPath);
-                  if (pathToNodeIdMap.has(normalizedResolvedPath)) {
+                let targetFound = false;
+                try {
+                  if (allPossiblePaths.has(imp.source)) {
                     architectureMap.edges.push({
                       source: normalize(node.id),
-                      target: normalizedResolvedPath,
+                      target: imp.source,
                       type: imp.type || "import"
                     });
+                    resolvedImports++;
+                    targetFound = true;
                   }
+                  if (!targetFound) {
+                    const resolvedPath = resolveImport(
+                      imp.source,
+                      path2.join(directory, node.id),
+                      directory,
+                      tsconfig
+                    );
+                    if (resolvedPath) {
+                      const relativeResolvedPath = path2.relative(directory, resolvedPath);
+                      const normalizedResolvedPath = normalize(relativeResolvedPath);
+                      if (allPossiblePaths.has(normalizedResolvedPath)) {
+                        architectureMap.edges.push({
+                          source: normalize(node.id),
+                          target: normalizedResolvedPath,
+                          type: imp.type || "import"
+                        });
+                        resolvedImports++;
+                        targetFound = true;
+                      }
+                    }
+                  }
+                  if (!targetFound) {
+                    try {
+                      const baseDir = path2.dirname(path2.join(directory, node.id));
+                      const calculatedAbsolutePath = path2.resolve(baseDir, imp.source);
+                      const calculatedRelativePath = path2.relative(directory, calculatedAbsolutePath);
+                      const calculatedNormalizedPath = normalize(calculatedRelativePath);
+                      if (allPossiblePaths.has(calculatedNormalizedPath)) {
+                        architectureMap.edges.push({
+                          source: normalize(node.id),
+                          target: calculatedNormalizedPath,
+                          type: imp.type || "import"
+                        });
+                        resolvedImports++;
+                        targetFound = true;
+                      }
+                    } catch (e) {
+                      console.warn(`\u26A0\uFE0F Path calculation failed for import '${imp.source}' in file '${node.id}': ${e.message}`);
+                    }
+                  }
+                  if (!targetFound) {
+                    if (imp.source.startsWith("./") || imp.source.startsWith("../")) {
+                      const extensions = ["", ".js", ".ts", ".jsx", ".tsx", ".mjs", ".cjs"];
+                      for (const ext of extensions) {
+                        let testPath = imp.source;
+                        if (!imp.source.endsWith(ext)) {
+                          testPath = imp.source + ext;
+                        }
+                        try {
+                          const baseDir = path2.dirname(path2.join(directory, node.id));
+                          const calculatedAbsolutePath = path2.resolve(baseDir, testPath);
+                          const calculatedRelativePath = path2.relative(directory, calculatedAbsolutePath);
+                          const calculatedNormalizedPath = normalize(calculatedRelativePath);
+                          if (allPossiblePaths.has(calculatedNormalizedPath)) {
+                            architectureMap.edges.push({
+                              source: normalize(node.id),
+                              target: calculatedNormalizedPath,
+                              type: imp.type || "import"
+                            });
+                            resolvedImports++;
+                            targetFound = true;
+                            break;
+                          }
+                        } catch (e) {
+                          console.warn(`\u26A0\uFE0F Extension path calculation failed for import '${imp.source}' with extension '${ext}' in file '${node.id}': ${e.message}`);
+                        }
+                      }
+                    }
+                  }
+                  if (!targetFound) {
+                    if (imp.source.startsWith("./") || imp.source.startsWith("../")) {
+                      try {
+                        const baseDir = path2.dirname(path2.join(directory, node.id));
+                        const calculatedAbsolutePath = path2.resolve(baseDir, imp.source);
+                        const directoryPath = calculatedAbsolutePath;
+                        const indexFiles = ["index.js", "index.ts", "index.jsx", "index.tsx", "index.mjs", "index.cjs"];
+                        for (const indexFile of indexFiles) {
+                          const indexPath = path2.join(directoryPath, indexFile);
+                          const indexRelativePath = path2.relative(directory, indexPath);
+                          const indexNormalizedPath = normalize(indexRelativePath);
+                          if (allPossiblePaths.has(indexNormalizedPath)) {
+                            architectureMap.edges.push({
+                              source: normalize(node.id),
+                              target: indexNormalizedPath,
+                              type: imp.type || "import"
+                            });
+                            resolvedImports++;
+                            targetFound = true;
+                            break;
+                          }
+                        }
+                      } catch (e) {
+                        console.warn(`\u26A0\uFE0F Index file check failed for import '${imp.source}' in file '${node.id}': ${e.message}`);
+                      }
+                    }
+                  }
+                  if (!targetFound) {
+                    if (imp.source.startsWith("@") || imp.source.startsWith("/") || !imp.source.startsWith(".")) {
+                      const commonSourceDirs = ["src", "app", "lib", "components", "utils", "services", "assets"];
+                      for (const srcDir of commonSourceDirs) {
+                        const potentialPath = path2.join(srcDir, imp.source);
+                        const potentialRelativePath = path2.relative(directory, path2.resolve(directory, potentialPath));
+                        const potentialNormalizedPath = normalize(potentialRelativePath);
+                        if (allPossiblePaths.has(potentialNormalizedPath)) {
+                          architectureMap.edges.push({
+                            source: normalize(node.id),
+                            target: potentialNormalizedPath,
+                            type: imp.type || "import"
+                          });
+                          resolvedImports++;
+                          targetFound = true;
+                          break;
+                        }
+                        const extensions = [
+                          ".js",
+                          ".ts",
+                          ".jsx",
+                          ".tsx",
+                          ".mjs",
+                          ".cjs",
+                          "index.js",
+                          "index.ts",
+                          "index.jsx",
+                          "index.tsx",
+                          "index.mjs",
+                          "index.cjs"
+                        ];
+                        for (const ext of extensions) {
+                          let testPath;
+                          if (ext.startsWith("index")) {
+                            testPath = path2.join(srcDir, imp.source, ext);
+                          } else {
+                            testPath = path2.join(srcDir, imp.source + ext);
+                          }
+                          const testRelativePath = path2.relative(directory, path2.resolve(directory, testPath));
+                          const testNormalizedPath = normalize(testRelativePath);
+                          if (allPossiblePaths.has(testNormalizedPath)) {
+                            architectureMap.edges.push({
+                              source: normalize(node.id),
+                              target: testNormalizedPath,
+                              type: imp.type || "import"
+                            });
+                            resolvedImports++;
+                            targetFound = true;
+                            break;
+                          }
+                        }
+                        if (targetFound)
+                          break;
+                      }
+                    }
+                  }
+                  if (!targetFound) {
+                    if (imp.source.startsWith("@") || imp.source.startsWith("/")) {
+                      try {
+                        const parts = imp.source.split("/");
+                        if (parts.length > 1) {
+                          const dirParts = parts.slice(0, -1);
+                          const fileName = parts[parts.length - 1];
+                          const dirPath = dirParts.join("/") + "/index";
+                          const indexFiles = ["index.js", "index.ts", "index.jsx", "index.tsx", "index.mjs", "index.cjs"];
+                          for (const indexFile of indexFiles) {
+                            const indexPath = path2.join(dirParts.join("/"), indexFile);
+                            const indexRelativePath = path2.relative(directory, path2.resolve(directory, indexPath));
+                            const indexNormalizedPath = normalize(indexRelativePath);
+                            if (allPossiblePaths.has(indexNormalizedPath)) {
+                              architectureMap.edges.push({
+                                source: normalize(node.id),
+                                target: indexNormalizedPath,
+                                type: imp.type || "import"
+                              });
+                              resolvedImports++;
+                              targetFound = true;
+                              break;
+                            }
+                          }
+                        }
+                      } catch (e) {
+                        console.warn(`\u26A0\uFE0F Barrel file check failed for import '${imp.source}' in file '${node.id}': ${e.message}`);
+                      }
+                    }
+                  }
+                  if (!targetFound) {
+                    for (const possiblePath of allPossiblePaths) {
+                      if (possiblePath.toLowerCase() === imp.source.toLowerCase()) {
+                        architectureMap.edges.push({
+                          source: normalize(node.id),
+                          target: possiblePath,
+                          type: imp.type || "import"
+                        });
+                        resolvedImports++;
+                        targetFound = true;
+                        break;
+                      }
+                    }
+                  }
+                } catch (e) {
+                  console.error(`\u274C Critical error processing import '${imp.source}' in file '${node.id}': ${e.message}`);
+                  console.error(e.stack);
+                  unresolvedImports++;
+                }
+                if (!targetFound) {
+                  unresolvedImports++;
                 }
               }
             });
           }
         });
+        console.log("RESOLVED IMPORTS:", resolvedImports);
+        console.log("UNRESOLVED IMPORTS:", unresolvedImports);
+        console.log("IMPORT EDGES CREATED:", architectureMap.edges.length);
+        if (semanticResults && semanticResults.usageEdges) {
+          semanticResults.usageEdges.forEach((usageEdge) => {
+            const sourceExists = architectureMap.nodes.some((n) => n.id === usageEdge.source);
+            const targetExists = architectureMap.nodes.some((n) => n.id === usageEdge.target);
+            if (sourceExists && targetExists) {
+              architectureMap.edges.push({
+                source: normalize(usageEdge.source),
+                target: normalize(usageEdge.target),
+                type: usageEdge.type
+                // 'function_call', 'constructor_call', 'component_usage'
+              });
+            }
+          });
+        }
+        console.log("TOTAL EDGES (with usage):", architectureMap.edges.length);
         const reverseGraph = buildReverseDependencyGraph(architectureMap);
         const blastRadiusMap = computeBlastRadius(reverseGraph);
         architectureMap.nodes.forEach((node) => {
           node.metadata.blast_radius = blastRadiusMap[node.id] || 0;
         });
+        console.log("BEFORE DEDUPLICATION EDGES:", architectureMap.edges.length);
         const validEdges = [];
         const edgeSet = /* @__PURE__ */ new Set();
         architectureMap.edges.forEach((edge) => {
@@ -63696,6 +64779,7 @@ var require_scanner = __commonJS({
             });
           }
         });
+        console.log("AFTER DEDUPLICATION EDGES:", validEdges.length);
         architectureMap.edges = validEdges;
         const totalFiles = architectureMap.nodes.length;
         const { computeBlastRadiusWithPercentage: computeBlastRadiusWithPercentage2, analyzeCriticality } = require_blastRadius();