arcvision 0.2.3 → 0.2.4

package/src/core/semantic-analyzer.js

@@ -1,204 +0,0 @@
-/**
- * Semantic Analyzer
- * 
- * Builds cross-file symbol resolution and tracks actual usage of imported symbols.
- * This enables detection of which files actually USE imported functions/classes,
- * not just which files import them.
- */
-
-/**
- * Build a global symbol table from all file exports
- * @param {Array} nodes - All scanned file nodes with metadata
- * @returns {Map} Symbol table mapping symbol names to their source files
- */
-function buildSymbolTable(nodes) {
-    const symbolTable = new Map();
-    
-    nodes.forEach(node => {
-        const filePath = node.id;
-        const metadata = node.metadata;
-        
-        if (!metadata) return;
-        
-        // Register all exports from this file
-        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
-                });
-            });
-        }
-        
-        // Register all functions
-        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
-                });
-            });
-        }
-        
-        // Register all classes
-        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;
-}
-
-/**
- * Resolve symbol usage to their definitions
- * @param {Object} node - File node with metadata
- * @param {Map} symbolTable - Global symbol table
- * @returns {Array} Array of resolved symbol usages
- */
-function resolveSymbolUsage(node, symbolTable) {
-    const resolvedUsages = [];
-    const metadata = node.metadata;
-    
-    if (!metadata) return resolvedUsages;
-    
-    // Track which symbols this file imports
-    const importedSymbols = 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
-                    });
-                });
-            }
-        });
-    }
-    
-    // Check function calls against imported symbols
-    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
-                });
-            }
-        });
-    }
-    
-    // Check constructor calls against imported symbols
-    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
-                });
-            }
-        });
-    }
-    
-    // Check component usage (React/JSX)
-    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;
-}
-
-/**
- * Track cross-file references and build usage edges
- * @param {Array} nodes - All scanned file nodes
- * @param {Map} symbolTable - Global symbol table
- * @returns {Array} Array of usage edges
- */
-function trackCrossFileReferences(nodes, symbolTable) {
-    const usageEdges = [];
-    
-    nodes.forEach(node => {
-        const filePath = node.id;
-        const resolvedUsages = resolveSymbolUsage(node, symbolTable);
-        
-        resolvedUsages.forEach(usage => {
-            // Create an edge from this file to the source of the symbol
-            usageEdges.push({
-                source: filePath,
-                target: usage.source,
-                type: usage.type,
-                symbol: usage.symbol,
-                loc: usage.loc
-            });
-        });
-    });
-    
-    return usageEdges;
-}
-
-/**
- * Analyze semantic relationships in the codebase
- * @param {Array} nodes - All scanned file nodes
- * @returns {Object} Semantic analysis results
- */
-function analyzeSemantics(nodes) {
-    const symbolTable = buildSymbolTable(nodes);
-    const usageEdges = trackCrossFileReferences(nodes, symbolTable);
-    
-    return {
-        symbolTable,
-        usageEdges,
-        stats: {
-            totalSymbols: symbolTable.size,
-            totalUsages: usageEdges.length
-        }
-    };
-}
-
-module.exports = {
-    buildSymbolTable,
-    resolveSymbolUsage,
-    trackCrossFileReferences,
-    analyzeSemantics
-};

package/src/core/tsconfig-utils.js

@@ -1,35 +0,0 @@
-const fs = require('fs');
-const path = require('path');
-
-/**
- * Load and parse tsconfig.json from project root
- * @param {string} projectRoot - The root directory of the project
- * @returns {Object|null} The compilerOptions from tsconfig.json or null if not found
- */
-function loadTSConfig(projectRoot) {
-  const tsconfigPaths = [
-    path.join(projectRoot, 'tsconfig.json'),
-    path.join(projectRoot, 'jsconfig.json')
-  ];
-
-  for (const tsconfigPath of tsconfigPaths) {
-    if (fs.existsSync(tsconfigPath)) {
-      try {
-        let content = fs.readFileSync(tsconfigPath, 'utf-8');
-        // Remove BOM if present (0xFEFF)
-        if (content.charCodeAt(0) === 0xFEFF) {
-          content = content.slice(1);
-        }
-        const raw = JSON.parse(content);
-        return raw.compilerOptions || {};
-      } catch (error) {
-        console.warn(`Warning: Could not parse ${tsconfigPath}:`, error.message);
-        return null;
-      }
-    }
-  }
-
-  return null;
-}
-
-module.exports = { loadTSConfig };

package/src/core/type-analyzer.js

@@ -1,272 +0,0 @@
-/**
- * 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/core/watcher.js

@@ -1,18 +0,0 @@
-const chokidar = require('chokidar');
-
-function watch(directory, callback) {
-    const watcher = chokidar.watch(directory, {
-        ignored: [/(^|[\/\\])\../, '**/node_modules/**'], // ignore dotfiles
-        persistent: true,
-        ignoreInitial: true
-    });
-
-    watcher
-        .on('add', path => callback('add', path))
-        .on('change', path => callback('change', path))
-        .on('unlink', path => callback('unlink', path));
-
-    return watcher;
-}
-
-module.exports = { watch };

package/src/engine/context_builder.js

@@ -1,153 +0,0 @@
-const path = require('path');
-const { stableId } = require('./id-generator');
-
-/**
- * Build the context object that conforms to the Arcvision schema
- * @param {Array} files - List of files from scanner
- * @param {Array} edges - List of edges from scanner
- * @param {Object} options - Options including directory path and project name
- * @returns {Object} - Context object conforming to schema
- */
-function buildContext(files, edges, options = {}) {
-    const {
-        directory = '.',
-        projectName = 'arcvision',
-        language = 'javascript'
-    } = options;
-
-    // Build nodes from files
-    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();
-        if (file.metadata.imports && Array.isArray(file.metadata.imports)) {
-            file.metadata.imports.forEach(imp => {
-                if (imp.source && typeof imp.source === 'string') {
-                    // Only add unique dependencies
-                    if (!uniqueDeps.has(imp.source)) {
-                        uniqueDeps.add(imp.source);
-                        dependencies.push(imp.source);
-                    }
-                }
-            });
-        }
-
-        return {
-            id: stableId(normalizedPath),
-            type: 'file',
-            path: normalizedPath,
-            role: role,
-            dependencies: dependencies,
-            blast_radius: file.metadata.blast_radius || 0
-        };
-    });
-
-    // Build edges from dependencies
-    const schemaEdges = [];
-    for (const edge of edges) {
-        // 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';
-
-            // 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';
-            }
-            // 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({
-                    from: sourceNode.id,
-                    to: targetNode.id,
-                    relation: relationType
-                });
-            } else {
-                // Source exists but target doesn't (external dependency like node_modules)
-                // We'll still include the edge to preserve the relationship
-                // However, since the schema requires valid node IDs, we'll only add if the target is a known node
-                // For now, we'll skip edges to non-existent targets to maintain schema compliance
-            }
-        }
-    }
-
-    // Calculate metrics
-    const metrics = {
-        total_files: nodes.length,
-        total_nodes: nodes.length,
-        total_edges: 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
-    };
-
-    // Build and return the context object
-    const context = {
-        schema_version: '1.0.0',
-        generated_at: new Date().toISOString(),
-        system: {
-            name: projectName,
-            root_path: path.resolve(directory),
-            language: language
-        },
-        nodes,
-        edges: schemaEdges,
-        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;
-}
-
-module.exports = { buildContext };