Function parseImports

masfactory-visualizer/src/parser/importResolver.ts:17–93

(rootNode: TSNode, code: string)

 * Parse all import statements from the AST
 */
export function parseImports(rootNode: TSNode, code: string): Map<string, ImportInfo> {
    const imports = new Map<string, ImportInfo>();
    
    // Handle "import xxx [as yyy]" statements (module imports)
    const importNodes = queryNodes(rootNode, 'import_statement');
    for (const importNode of importNodes) {
        for (const child of importNode.namedChildren) {
            if (!child) {continue;}
            if (child.type === 'aliased_import') {
                const nameNode = child.childForFieldName('name');
                const aliasNode = child.childForFieldName('alias');
                if (!nameNode || !aliasNode) {continue;}
                const modulePath = getNodeText(nameNode, code);
                const alias = getNodeText(aliasNode, code);
                imports.set(alias, { modulePath, className: '', alias, isModule: true });
            } else if (child.type === 'dotted_name') {
                const modulePath = getNodeText(child, code);
                // Only store non-dotted imports (e.g., "import masfactory") to avoid alias ambiguity.
                if (!modulePath.includes('.')) {
                    imports.set(modulePath, { modulePath, className: '', alias: modulePath, isModule: true });
                }
            }
        }
    }

    // Find all import_from_statement nodes
    // e.g., "from masfactory.components.compound_graph import InstructorAssistantGraph"
    const importFromNodes = queryNodes(rootNode, 'import_from_statement');
    
    for (const importNode of importFromNodes) {
        const moduleNameNode = importNode.childForFieldName('module_name');
        if (!moduleNameNode) {continue;}
        
        const modulePath = getNodeText(moduleNameNode, code);
        
        // Get imported names
        for (const child of importNode.namedChildren) {
            if (!child) {continue;}
            if (child.type === 'aliased_import') {
                // from xxx import YYY as ZZZ
                const nameNode = child.childForFieldName('name');
                const aliasNode = child.childForFieldName('alias');
                if (nameNode) {
                    const className = getNodeText(nameNode, code);
                    const alias = aliasNode ? getNodeText(aliasNode, code) : undefined;
                    const key = alias || className;
                    imports.set(key, { modulePath, className, alias, isModule: false });
                }
            } else if (child.type === 'import_list') {
                // from xxx import (YYY, ZZZ as AAA)
                for (const item of child.namedChildren) {
                    if (!item) {continue;}
                    if (item.type === 'aliased_import') {
                        const nameNode = item.childForFieldName('name');
                        const aliasNode = item.childForFieldName('alias');
                        if (!nameNode) {continue;}
                        const className = getNodeText(nameNode, code);
                        const alias = aliasNode ? getNodeText(aliasNode, code) : undefined;