arcvision 0.2.0 → 0.2.1

package/arcvision.context.json

@@ -1,119 +1,99 @@
 {
   "schema_version": "1.0.0",
-  "generated_at": "2026-01-06T04:33:19.544Z",
+  "generated_at": "2026-01-06T06:57:00.243Z",
   "system": {
-    "name": "engine",
-    "root_path": "C:\\Users\\AHMAD RAZA\\Downloads\\ArcVision\\cli\\src\\engine",
+    "name": "plugins",
+    "root_path": "C:\\Users\\AHMAD RAZA\\Downloads\\ArcVision\\cli\\src\\plugins",
     "language": "javascript"
   },
   "nodes": [
     {
-      "id": "18f3b408c9f517b4",
+      "id": "9788ca3218e16ddf",
       "type": "file",
-      "path": "id-generator.js",
-      "role": "Implementation",
+      "path": "express-plugin.js",
+      "role": "Structure",
       "dependencies": [
-        "crypto"
+        "@babel/parser",
+        "@babel/traverse",
+        "fs"
       ],
-      "blast_radius": 1
-    },
-    {
-      "id": "906fe6a206ee8ed6",
-      "type": "file",
-      "path": "context_sorter.js",
-      "role": "Implementation",
-      "dependencies": [],
       "blast_radius": 0
     },
     {
-      "id": "a90facc61fceac47",
+      "id": "d3f4923fd01ce58d",
       "type": "file",
-      "path": "context_builder.js",
-      "role": "Implementation",
+      "path": "react-plugin.js",
+      "role": "Structure",
       "dependencies": [
-        "path",
-        "./id-generator"
+        "@babel/parser",
+        "@babel/traverse",
+        "fs"
       ],
       "blast_radius": 0
     },
     {
-      "id": "e23459b69864dc40",
+      "id": "d6515f66bafa0b42",
       "type": "file",
-      "path": "context_validator.js",
+      "path": "plugin-manager.js",
       "role": "Implementation",
       "dependencies": [
         "fs",
-        "path",
-        "ajv"
+        "path"
       ],
       "blast_radius": 0
     }
   ],
-  "edges": [
-    {
-      "from": "a90facc61fceac47",
-      "to": "18f3b408c9f517b4",
-      "relation": "imports"
-    }
-  ],
+  "edges": [],
   "metrics": {
-    "files_with_functions": 4,
+    "files_with_functions": 1,
     "files_with_high_blast_radius": 0,
-    "total_dependencies": 1,
-    "total_edges": 1,
-    "total_files": 4,
-    "total_imports": 1,
-    "total_nodes": 4
+    "total_dependencies": 0,
+    "total_edges": 0,
+    "total_files": 3,
+    "total_imports": 0,
+    "total_nodes": 3
   },
   "contextSurface": {
     "topBlastRadiusFiles": [
       {
-        "file": "id-generator.js",
-        "blastRadius": 1,
-        "percentOfGraph": 25
+        "file": "express-plugin.js",
+        "blastRadius": 0,
+        "percentOfGraph": 0
       },
       {
-        "file": "context_builder.js",
+        "file": "plugin-manager.js",
         "blastRadius": 0,
         "percentOfGraph": 0
       },
       {
-        "file": "context_sorter.js",
+        "file": "react-plugin.js",
         "blastRadius": 0,
         "percentOfGraph": 0
       }
     ],
     "criticalityAnalysis": [
       {
-        "file": "id-generator.js",
-        "blastRadius": 1,
-        "dependencies": 1,
-        "dependencyStrength": 0,
-        "criticalityScore": 2,
-        "isHub": false
-      },
-      {
-        "file": "context_validator.js",
+        "file": "react-plugin.js",
         "blastRadius": 0,
         "dependencies": 0,
         "dependencyStrength": 0,
-        "criticalityScore": 1,
+        "criticalityScore": 0,
         "isHub": false
       },
       {
-        "file": "context_sorter.js",
+        "file": "plugin-manager.js",
         "blastRadius": 0,
         "dependencies": 0,
         "dependencyStrength": 0,
-        "criticalityScore": 1,
+        "criticalityScore": 0,
         "isHub": false
       },
       {
-        "file": "context_builder.js",
+        "file": "express-plugin.js",
         "blastRadius": 0,
         "dependencies": 0,
         "dependencyStrength": 0,
-        "criticalityScore": 1,
+        "criticalityScore": 0,
         "isHub": false
       }
     ]

package/dist/index.js

@@ -56407,6 +56407,16 @@ var require_parser = __commonJS({
                       });
                     }
                   });
+                } else if (decl.id.type === "ArrayPattern") {
+                  decl.id.elements.forEach((element) => {
+                    if (element && element.name) {
+                      metadata.exports.push({
+                        name: element.name,
+                        type: "variable",
+                        loc: element.loc
+                      });
+                    }
+                  });
                 }
               });
             }
@@ -56530,6 +56540,27 @@ var require_parser = __commonJS({
               loc: node.loc
             });
           }
+          if (node.callee.type === "Import" && node.arguments.length > 0) {
+            const sourceArg = node.arguments[0];
+            if (sourceArg && sourceArg.type === "StringLiteral") {
+              metadata.imports.push({
+                source: sourceArg.value,
+                specifiers: [],
+                type: "dynamic-import"
+              });
+            }
+          }
+        },
+        VariableDeclarator({ node }) {
+          if (node.init && node.init.type === "CallExpression" && node.init.callee.name === "require" && node.init.arguments.length > 0 && node.init.arguments[0].type === "StringLiteral") {
+            metadata.imports.push({
+              source: node.init.arguments[0].value,
+              specifiers: [],
+              type: "require-assignment"
+            });
+          }
+        },
+        MemberExpression({ node }) {
         }
       });
       return metadata;
@@ -56635,13 +56666,13 @@ var require_path_resolver = __commonJS({
       }
       if (importPath.startsWith(".")) {
         let resolvedPath = path2.resolve(path2.dirname(importerPath), importPath);
-        const extensions = [".ts", ".tsx", ".js", ".jsx", ".mjs", ".cjs"];
+        const extensions = [".ts", ".tsx", ".js", ".jsx", ".mjs", ".cjs", ".json"];
         for (const ext of extensions) {
           if (fs2.existsSync(resolvedPath + ext)) {
             return resolvedPath + ext;
           }
         }
-        const indexFiles = ["index.ts", "index.tsx", "index.js", "index.jsx"];
+        const indexFiles = ["index.ts", "index.tsx", "index.js", "index.jsx", "index.json"];
         for (const idxFile of indexFiles) {
           const indexPath = path2.join(resolvedPath, idxFile);
           if (fs2.existsSync(indexPath)) {
@@ -56665,13 +56696,13 @@ var require_path_resolver = __commonJS({
               for (const target of aliasTargets) {
                 const targetBase = target.replace(/\*.*$/, "");
                 const targetPath = path2.resolve(projectRoot, targetBase) + suffix;
-                const extensions = [".ts", ".tsx", ".js", ".jsx", ".mjs", ".cjs"];
+                const extensions = [".ts", ".tsx", ".js", ".jsx", ".mjs", ".cjs", ".json"];
                 for (const ext of extensions) {
                   if (fs2.existsSync(targetPath + ext)) {
                     return targetPath + ext;
                   }
                 }
-                const indexFiles = ["index.ts", "index.tsx", "index.js", "index.jsx"];
+                const indexFiles = ["index.ts", "index.tsx", "index.js", "index.jsx", "index.json"];
                 for (const idxFile of indexFiles) {
                   const indexPath = path2.join(targetPath, idxFile);
                   if (fs2.existsSync(indexPath)) {
@@ -56691,13 +56722,13 @@ var require_path_resolver = __commonJS({
                   const remainingPath = importPath.substring(aliasPattern.length);
                   targetPath = path2.join(targetPath, remainingPath);
                 }
-                const extensions = [".ts", ".tsx", ".js", ".jsx", ".mjs", ".cjs"];
+                const extensions = [".ts", ".tsx", ".js", ".jsx", ".mjs", ".cjs", ".json"];
                 for (const ext of extensions) {
                   if (fs2.existsSync(targetPath + ext)) {
                     return targetPath + ext;
                   }
                 }
-                const indexFiles = ["index.ts", "index.tsx", "index.js", "index.jsx"];
+                const indexFiles = ["index.ts", "index.tsx", "index.js", "index.jsx", "index.json"];
                 for (const idxFile of indexFiles) {
                   const indexPath = path2.join(targetPath, idxFile);
                   if (fs2.existsSync(indexPath)) {
@@ -56714,13 +56745,13 @@ var require_path_resolver = __commonJS({
       }
       if (tsconfig && tsconfig.baseUrl && !importPath.startsWith(".")) {
         let resolvedPath = path2.resolve(projectRoot, tsconfig.baseUrl, importPath);
-        const extensions = [".ts", ".tsx", ".js", ".jsx", ".mjs", ".cjs"];
+        const extensions = [".ts", ".tsx", ".js", ".jsx", ".mjs", ".cjs", ".json"];
         for (const ext of extensions) {
           if (fs2.existsSync(resolvedPath + ext)) {
             return resolvedPath + ext;
           }
         }
-        const indexFiles = ["index.ts", "index.tsx", "index.js", "index.jsx"];
+        const indexFiles = ["index.ts", "index.tsx", "index.js", "index.jsx", "index.json"];
         for (const idxFile of indexFiles) {
           const indexPath = path2.join(resolvedPath, idxFile);
           if (fs2.existsSync(indexPath)) {
@@ -56927,10 +56958,14 @@ var require_context_builder = __commonJS({
           role = "Interface";
         }
         const dependencies = [];
+        const uniqueDeps = /* @__PURE__ */ new Set();
         if (file.metadata.imports && Array.isArray(file.metadata.imports)) {
           file.metadata.imports.forEach((imp) => {
             if (imp.source && typeof imp.source === "string") {
-              dependencies.push(imp.source);
+              if (!uniqueDeps.has(imp.source)) {
+                uniqueDeps.add(imp.source);
+                dependencies.push(imp.source);
+              }
             }
           });
         }
@@ -56948,10 +56983,20 @@ var require_context_builder = __commonJS({
         const sourceNode = nodes.find((n) => n.path === edge.source);
         const targetNode = nodes.find((n) => n.path === edge.target);
         if (sourceNode && targetNode) {
+          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 === "calls") {
+            relationType = "calls";
+          } else if (edge.type === "owns") {
+            relationType = "owns";
+          } else if (edge.type === "depends_on") {
+            relationType = "depends_on";
+          }
           schemaEdges.push({
             from: sourceNode.id,
             to: targetNode.id,
-            relation: "imports"
+            relation: relationType
           });
         }
       }
@@ -63599,34 +63644,59 @@ var require_scanner = __commonJS({
           }
         }
         const tsconfig = loadTSConfig(directory);
-        const normalizedFileMap = /* @__PURE__ */ new Map();
-        architectureMap.nodes.forEach((n) => normalizedFileMap.set(normalize(n.id), n.id));
+        const pathToNodeIdMap = /* @__PURE__ */ new Map();
         architectureMap.nodes.forEach((node) => {
-          node.metadata.imports.forEach((imp) => {
-            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 (normalizedFileMap.has(normalizedResolvedPath)) {
-                architectureMap.edges.push({
-                  source: normalize(node.id),
-                  target: normalizedResolvedPath,
-                  type: "import"
-                });
+          const normalizedPath = normalize(node.id);
+          pathToNodeIdMap.set(normalizedPath, node.id);
+        });
+        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)) {
+                    architectureMap.edges.push({
+                      source: normalize(node.id),
+                      target: normalizedResolvedPath,
+                      type: imp.type || "import"
+                    });
+                  }
+                }
               }
-            }
-          });
+            });
+          }
         });
         const reverseGraph = buildReverseDependencyGraph(architectureMap);
         const blastRadiusMap = computeBlastRadius(reverseGraph);
         architectureMap.nodes.forEach((node) => {
           node.metadata.blast_radius = blastRadiusMap[node.id] || 0;
         });
+        const validEdges = [];
+        const edgeSet = /* @__PURE__ */ new Set();
+        architectureMap.edges.forEach((edge) => {
+          const normalizedSource = normalize(edge.source);
+          const normalizedTarget = normalize(edge.target);
+          const edgeKey = `${normalizedSource}\u2192${normalizedTarget}`;
+          const sourceNodeExists = architectureMap.nodes.some((node) => node.id === normalizedSource);
+          const targetNodeExists = architectureMap.nodes.some((node) => node.id === normalizedTarget);
+          if (sourceNodeExists && targetNodeExists && !edgeSet.has(edgeKey)) {
+            edgeSet.add(edgeKey);
+            validEdges.push({
+              source: normalizedSource,
+              target: normalizedTarget,
+              type: edge.type
+            });
+          }
+        });
+        architectureMap.edges = validEdges;
         const totalFiles = architectureMap.nodes.length;
         const { computeBlastRadiusWithPercentage: computeBlastRadiusWithPercentage2, analyzeCriticality } = require_blastRadius();
         const allFilesWithPercentage = computeBlastRadiusWithPercentage2(blastRadiusMap, totalFiles);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "arcvision",
-  "version": "0.2.0",
+  "version": "0.2.1",
   "description": "Architecture scanner for modern codebases",
   "bin": {
     "arcvision": "./dist/index.js"

package/src/core/parser.js

@@ -159,6 +159,17 @@ function parseFile(filePath) {
                                     });
                                 }
                             });
+                        } else if (decl.id.type === 'ArrayPattern') {
+                            // Handle array destructuring exports: export const [a, b] = arr
+                            decl.id.elements.forEach(element => {
+                                if (element && element.name) {
+                                    metadata.exports.push({
+                                        name: element.name,
+                                        type: 'variable',
+                                        loc: element.loc
+                                    });
+                                }
+                            });
                         }
                     });
                 }
@@ -293,6 +304,36 @@ function parseFile(filePath) {
                     loc: node.loc
                 });
             }
+            
+            // Handle other common import patterns like import() in function calls
+            if (node.callee.type === 'Import' && node.arguments.length > 0) {
+                const sourceArg = node.arguments[0];
+                if (sourceArg && sourceArg.type === 'StringLiteral') {
+                    metadata.imports.push({
+                        source: sourceArg.value,
+                        specifiers: [],
+                        type: 'dynamic-import'
+                    });
+                }
+            }
+        },
+        
+        VariableDeclarator({ node }) {
+            // Handle import assignments like: const { something } = require('module')
+            if (node.init && node.init.type === 'CallExpression' && 
+                node.init.callee.name === 'require' && 
+                node.init.arguments.length > 0 &&
+                node.init.arguments[0].type === 'StringLiteral') {
+                metadata.imports.push({
+                    source: node.init.arguments[0].value,
+                    specifiers: [],
+                    type: 'require-assignment'
+                });
+            }
+        },
+        
+        MemberExpression({ node }) {
+            // Additional member expression handling for complex import patterns
         }
     });
 

package/src/core/path-resolver.js

@@ -23,7 +23,7 @@ function resolveImport(importPath, importerPath, projectRoot, tsconfig) {
     let resolvedPath = path.resolve(path.dirname(importerPath), importPath);
     
     // Try with various extensions in order of preference
-    const extensions = ['.ts', '.tsx', '.js', '.jsx', '.mjs', '.cjs'];
+    const extensions = ['.ts', '.tsx', '.js', '.jsx', '.mjs', '.cjs', '.json'];
     for (const ext of extensions) {
       if (fs.existsSync(resolvedPath + ext)) {
         return resolvedPath + ext;
@@ -31,7 +31,7 @@ function resolveImport(importPath, importerPath, projectRoot, tsconfig) {
     }
     
     // Try as directory with index files
-    const indexFiles = ['index.ts', 'index.tsx', 'index.js', 'index.jsx'];
+    const indexFiles = ['index.ts', 'index.tsx', 'index.js', 'index.jsx', 'index.json'];
     for (const idxFile of indexFiles) {
       const indexPath = path.join(resolvedPath, idxFile);
       if (fs.existsSync(indexPath)) {
@@ -69,7 +69,7 @@ function resolveImport(importPath, importerPath, projectRoot, tsconfig) {
             const targetPath = path.resolve(projectRoot, targetBase) + suffix;
             
             // Try with extensions
-            const extensions = ['.ts', '.tsx', '.js', '.jsx', '.mjs', '.cjs'];
+            const extensions = ['.ts', '.tsx', '.js', '.jsx', '.mjs', '.cjs', '.json'];
             for (const ext of extensions) {
               if (fs.existsSync(targetPath + ext)) {
                 return targetPath + ext;
@@ -77,7 +77,7 @@ function resolveImport(importPath, importerPath, projectRoot, tsconfig) {
             }
             
             // Try as directory with index files
-            const indexFiles = ['index.ts', 'index.tsx', 'index.js', 'index.jsx'];
+            const indexFiles = ['index.ts', 'index.tsx', 'index.js', 'index.jsx', 'index.json'];
             for (const idxFile of indexFiles) {
               const indexPath = path.join(targetPath, idxFile);
               if (fs.existsSync(indexPath)) {
@@ -104,7 +104,7 @@ function resolveImport(importPath, importerPath, projectRoot, tsconfig) {
             }
             
             // Try with extensions
-            const extensions = ['.ts', '.tsx', '.js', '.jsx', '.mjs', '.cjs'];
+            const extensions = ['.ts', '.tsx', '.js', '.jsx', '.mjs', '.cjs', '.json'];
             for (const ext of extensions) {
               if (fs.existsSync(targetPath + ext)) {
                 return targetPath + ext;
@@ -112,7 +112,7 @@ function resolveImport(importPath, importerPath, projectRoot, tsconfig) {
             }
             
             // Try as directory with index files
-            const indexFiles = ['index.ts', 'index.tsx', 'index.js', 'index.jsx'];
+            const indexFiles = ['index.ts', 'index.tsx', 'index.js', 'index.jsx', 'index.json'];
             for (const idxFile of indexFiles) {
               const indexPath = path.join(targetPath, idxFile);
               if (fs.existsSync(indexPath)) {
@@ -135,7 +135,7 @@ function resolveImport(importPath, importerPath, projectRoot, tsconfig) {
     let resolvedPath = path.resolve(projectRoot, tsconfig.baseUrl, importPath);
     
     // Try with extensions
-    const extensions = ['.ts', '.tsx', '.js', '.jsx', '.mjs', '.cjs'];
+    const extensions = ['.ts', '.tsx', '.js', '.jsx', '.mjs', '.cjs', '.json'];
     for (const ext of extensions) {
       if (fs.existsSync(resolvedPath + ext)) {
         return resolvedPath + ext;
@@ -143,7 +143,7 @@ function resolveImport(importPath, importerPath, projectRoot, tsconfig) {
     }
     
     // Try as directory with index files
-    const indexFiles = ['index.ts', 'index.tsx', 'index.js', 'index.jsx'];
+    const indexFiles = ['index.ts', 'index.tsx', 'index.js', 'index.jsx', 'index.json'];
     for (const idxFile of indexFiles) {
       const indexPath = path.join(resolvedPath, idxFile);
       if (fs.existsSync(indexPath)) {

package/src/core/scanner.js

@@ -88,34 +88,43 @@ async function scan(directory) {
         // Load tsconfig for path resolution
         const tsconfig = loadTSConfig(directory);
         
-        const normalizedFileMap = new Map();
-        architectureMap.nodes.forEach(n => normalizedFileMap.set(normalize(n.id), n.id));
+        // Create a map of normalized relative paths to actual node IDs
+        const pathToNodeIdMap = new Map();
+        architectureMap.nodes.forEach(node => {
+            const normalizedPath = normalize(node.id);
+            pathToNodeIdMap.set(normalizedPath, node.id);
+        });
 
+        // Process imports to create edges
         architectureMap.nodes.forEach(node => {
-            node.metadata.imports.forEach(imp => {
-                // Resolve the import path using the new resolver
-                const resolvedPath = resolveImport(
-                    imp.source,
-                    path.join(directory, node.id),
-                    directory,
-                    tsconfig
-                );
-                
-                if (resolvedPath) {
-                    // Convert resolved absolute path back to relative path
-                    const relativeResolvedPath = path.relative(directory, resolvedPath);
-                    const normalizedResolvedPath = normalize(relativeResolvedPath);
-                    
-                    // Check if the resolved file exists in our scanned files
-                    if (normalizedFileMap.has(normalizedResolvedPath)) {
-                        architectureMap.edges.push({
-                            source: normalize(node.id),
-                            target: normalizedResolvedPath,
-                            type: 'import'
-                        });
+            if (node.metadata.imports && Array.isArray(node.metadata.imports)) {
+                node.metadata.imports.forEach(imp => {
+                    if (imp.source && typeof imp.source === 'string') {
+                        // Resolve the import path using the new resolver
+                        const resolvedPath = resolveImport(
+                            imp.source,
+                            path.join(directory, node.id),
+                            directory,
+                            tsconfig
+                        );
+                        
+                        if (resolvedPath) {
+                            // Convert resolved absolute path back to relative path
+                            const relativeResolvedPath = path.relative(directory, resolvedPath);
+                            const normalizedResolvedPath = normalize(relativeResolvedPath);
+                            
+                            // Check if the resolved file exists in our scanned files
+                            if (pathToNodeIdMap.has(normalizedResolvedPath)) {
+                                architectureMap.edges.push({
+                                    source: normalize(node.id),
+                                    target: normalizedResolvedPath,
+                                    type: imp.type || 'import'
+                                });
+                            }
+                        }
                     }
-                }
-            });
+                });
+            }
         });
 
         // Calculate blast radius for each file
@@ -127,6 +136,35 @@ async function scan(directory) {
             node.metadata.blast_radius = blastRadiusMap[node.id] || 0;
         });
         
+        // Process edges to ensure they match existing nodes and remove duplicates
+        const validEdges = [];
+        const edgeSet = new Set(); // To track unique edges
+        
+        architectureMap.edges.forEach(edge => {
+            // Normalize both source and target paths for consistent matching
+            const normalizedSource = normalize(edge.source);
+            const normalizedTarget = normalize(edge.target);
+            
+            // Create a unique key for the edge to avoid duplicates
+            const edgeKey = `${normalizedSource}→${normalizedTarget}`;
+            
+            // Check if both source and target nodes exist in our architecture map
+            const sourceNodeExists = architectureMap.nodes.some(node => node.id === normalizedSource);
+            const targetNodeExists = architectureMap.nodes.some(node => node.id === normalizedTarget);
+            
+            if (sourceNodeExists && targetNodeExists && !edgeSet.has(edgeKey)) {
+                edgeSet.add(edgeKey);
+                validEdges.push({
+                    source: normalizedSource,
+                    target: normalizedTarget,
+                    type: edge.type
+                });
+            }
+        });
+        
+        // Replace the edges with only valid ones
+        architectureMap.edges = validEdges;
+        
         // Add top blast radius files to the architecture map
         const totalFiles = architectureMap.nodes.length;
         const { computeBlastRadiusWithPercentage, analyzeCriticality } = require('./blastRadius');

package/src/engine/context_builder.js

@@ -33,12 +33,17 @@ function buildContext(files, edges, options = {}) {
             role = 'Interface';
         }
         
-        // Extract dependencies more accurately
+        // Extract dependencies more accurately and remove duplicates
         const dependencies = [];
+        const uniqueDeps = new Set();
         if (file.metadata.imports && Array.isArray(file.metadata.imports)) {
             file.metadata.imports.forEach(imp => {
                 if (imp.source && typeof imp.source === 'string') {
-                    dependencies.push(imp.source);
+                    // Only add unique dependencies
+                    if (!uniqueDeps.has(imp.source)) {
+                        uniqueDeps.add(imp.source);
+                        dependencies.push(imp.source);
+                    }
                 }
             });
         }
@@ -62,10 +67,22 @@ function buildContext(files, edges, options = {}) {
         
         // Only include edges where both source and target nodes exist
         if (sourceNode && targetNode) {
+            // 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') {
+                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';
+            }
+            
             schemaEdges.push({
                 from: sourceNode.id,
                 to: targetNode.id,
-                relation: 'imports'
+                relation: relationType
             });
         }
     }