arcvision 0.2.2 → 0.2.3

package/src/core/type-analyzer.js

@@ -0,0 +1,272 @@
+/**
+ * Type Dependency Analyzer
+ * 
+ * Tracks TypeScript type-only dependencies including:
+ * - Type-only imports
+ * - Interface extensions
+ * - Interface implementations
+ * - Generic type parameters
+ * - Return type dependencies
+ */
+
+const traverse = require('@babel/traverse').default;
+
+/**
+ * Extract type-only imports from AST
+ * @param {Object} ast - Babel AST
+ * @returns {Array} Array of type imports
+ */
+function extractTypeImports(ast) {
+    const typeImports = [];
+
+    if (!ast) return typeImports;
+
+    traverse(ast, {
+        ImportDeclaration(path) {
+            const node = path.node;
+
+            // Check if it's a type-only import: import type { ... }
+            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
+                });
+            }
+
+            // Check for individual type specifiers: import { type User } from '...'
+            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;
+}
+
+/**
+ * Extract interface dependencies (extends, implements)
+ * @param {Object} ast - Babel AST
+ * @returns {Array} Array of interface dependencies
+ */
+function extractInterfaceDependencies(ast) {
+    const interfaceDeps = [];
+
+    if (!ast) return interfaceDeps;
+
+    traverse(ast, {
+        // Interface extends
+        TSInterfaceDeclaration(path) {
+            const node = path.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(path) {
+            const node = path.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;
+}
+
+/**
+ * Extract generic type dependencies
+ * @param {Object} ast - Babel AST
+ * @returns {Array} Array of generic type usages
+ */
+function extractGenericDependencies(ast) {
+    const genericDeps = [];
+
+    if (!ast) return genericDeps;
+
+    traverse(ast, {
+        // Function return types
+        FunctionDeclaration(path) {
+            const node = path.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(path) {
+            const node = path.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(path) {
+            const node = path.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;
+}
+
+/**
+ * Analyze all type dependencies in a file
+ * @param {Object} ast - Babel AST
+ * @returns {Object} All type dependencies
+ */
+function analyzeTypeDependencies(ast) {
+    if (!ast) {
+        return {
+            typeImports: [],
+            interfaceDependencies: [],
+            genericDependencies: []
+        };
+    }
+
+    return {
+        typeImports: extractTypeImports(ast),
+        interfaceDependencies: extractInterfaceDependencies(ast),
+        genericDependencies: extractGenericDependencies(ast)
+    };
+}
+
+/**
+ * Helper: Extract type name from TypeScript type node
+ */
+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;
+}
+
+/**
+ * Helper: Extract complex type names (including generics)
+ */
+function extractComplexTypeName(node) {
+    if (!node) return null;
+
+    if (node.type === 'TSTypeReference' && node.typeName) {
+        let baseName = extractTypeName(node);
+
+        // Handle generic parameters
+        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;
+}
+
+module.exports = {
+    extractTypeImports,
+    extractInterfaceDependencies,
+    extractGenericDependencies,
+    analyzeTypeDependencies
+};

package/src/engine/context_builder.js

@@ -19,20 +19,20 @@ function buildContext(files, edges, options = {}) {
     const nodes = files.map(file => {
         // Use the node's id field which is already the normalized relative path
         const normalizedPath = file.id;
-    
+
         // Determine role based on multiple factors for better accuracy
         const hasFunctions = file.metadata.functions && file.metadata.functions.length > 0;
         const hasClasses = file.metadata.classes && file.metadata.classes.length > 0;
         const hasExports = file.metadata.exports && file.metadata.exports.length > 0;
         const hasApiCalls = file.metadata.apiCalls && file.metadata.apiCalls.length > 0;
-        
+
         let role = 'Structure';
         if (hasFunctions || hasClasses || hasApiCalls) {
             role = 'Implementation';
         } else if (hasExports) {
             role = 'Interface';
         }
-        
+
         // Extract dependencies more accurately and remove duplicates
         const dependencies = [];
         const uniqueDeps = new Set();
@@ -47,7 +47,7 @@ function buildContext(files, edges, options = {}) {
                 }
             });
         }
-        
+
         return {
             id: stableId(normalizedPath),
             type: 'file',
@@ -64,21 +64,41 @@ function buildContext(files, edges, options = {}) {
         // Find source and target nodes to get their stable IDs
         const sourceNode = nodes.find(n => n.path === edge.source);
         const targetNode = nodes.find(n => n.path === edge.target);
-        
+
         // Include edges where source exists (even if target doesn't exist as a node)
         if (sourceNode) {
             // Normalize the edge type to fit the schema
             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') {
+
+            // Handle import-related types
+            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';
+            }
+            // Handle call-related types (NEW)
+            else if (edge.type === 'function_call' || edge.type === 'method_call') {
+                relationType = 'calls';
+            }
+            // Handle constructor calls (NEW) - map to calls for schema compliance
+            else if (edge.type === 'constructor_call') {
+                relationType = 'calls';
+            }
+            // Handle component usage (NEW) - map to imports for schema compliance
+            else if (edge.type === 'component_usage' || edge.type === 'jsx_component' || edge.type === 'jsx_member_component') {
                 relationType = 'imports';
-            } else if (edge.type === 'calls') {
+            }
+            // Handle existing types
+            else if (edge.type === 'calls') {
                 relationType = 'calls';
             } else if (edge.type === 'owns') {
                 relationType = 'owns';
             } else if (edge.type === 'depends_on') {
                 relationType = 'depends_on';
+            } else {
+                // Default to 'imports' for any unknown edge types to ensure schema compliance
+                relationType = 'imports';
             }
-            
+
             if (targetNode) {
                 // Both source and target nodes exist
                 schemaEdges.push({
@@ -100,7 +120,10 @@ function buildContext(files, edges, options = {}) {
         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
     };
 
@@ -118,12 +141,12 @@ function buildContext(files, edges, options = {}) {
         metrics,
         contextSurface: options.contextSurface || {}
     };
-    
+
     // Add additional computed metrics
     context.metrics.files_with_functions = nodes.filter(n => n.role === 'Implementation').length;
     context.metrics.files_with_high_blast_radius = nodes.filter(n => n.blast_radius > 5).length;
     context.metrics.total_dependencies = schemaEdges.length;
-    
+
     return context;
 }