code-graph-context 0.1.0

package/dist/core/parsers/typescript-parser.js

@@ -0,0 +1,717 @@
+/* eslint-disable @typescript-eslint/no-explicit-any */
+import path from 'node:path';
+import { minimatch } from 'minimatch';
+import { Project, Node } from 'ts-morph';
+import { v4 as uuidv4 } from 'uuid';
+import { NESTJS_FRAMEWORK_SCHEMA } from '../config/nestjs-framework-schema.js';
+import { CoreNodeType, CORE_TYPESCRIPT_SCHEMA, DEFAULT_PARSE_OPTIONS, CoreEdgeType, } from '../config/schema.js';
+export class TypeScriptParser {
+    workspacePath;
+    tsConfigPath;
+    project;
+    coreSchema;
+    parseConfig;
+    frameworkSchemas;
+    parsedNodes = new Map();
+    parsedEdges = new Map();
+    deferredEdges = [];
+    sharedContext = new Map(); // Shared context for custom data
+    constructor(workspacePath, tsConfigPath = 'tsconfig.json', coreSchema = CORE_TYPESCRIPT_SCHEMA, frameworkSchemas = [NESTJS_FRAMEWORK_SCHEMA], parseConfig = DEFAULT_PARSE_OPTIONS) {
+        this.workspacePath = workspacePath;
+        this.tsConfigPath = tsConfigPath;
+        this.coreSchema = coreSchema;
+        this.frameworkSchemas = frameworkSchemas;
+        this.parseConfig = parseConfig;
+        // Initialize with proper compiler options for NestJS
+        this.project = new Project({
+            tsConfigFilePath: tsConfigPath,
+            skipAddingFilesFromTsConfig: false,
+            compilerOptions: {
+                experimentalDecorators: true,
+                emitDecoratorMetadata: true,
+                target: 7,
+                module: 1,
+                esModuleInterop: true,
+            },
+        });
+        this.project.addSourceFilesAtPaths(path.join(workspacePath, '**/*.ts'));
+    }
+    async parseWorkspace() {
+        const sourceFiles = this.project.getSourceFiles();
+        // Phase 1: Core parsing for ALL files
+        for (const sourceFile of sourceFiles) {
+            if (this.shouldSkipFile(sourceFile))
+                continue;
+            await this.parseCoreTypeScriptV2(sourceFile);
+        }
+        // Phase 1.5: Resolve deferred relationship edges (EXTENDS, IMPLEMENTS)
+        this.resolveDeferredEdges();
+        // Phase 2: Apply context extractors
+        await this.applyContextExtractors();
+        // Phase 3: Framework enhancements
+        if (this.frameworkSchemas.length > 0) {
+            await this.applyFrameworkEnhancements();
+        }
+        // Phase 4: Edge enhancements
+        await this.applyEdgeEnhancements();
+        // Convert to Neo4j format
+        const neo4jNodes = Array.from(this.parsedNodes.values()).map(this.toNeo4jNode);
+        const neo4jEdges = Array.from(this.parsedEdges.values()).map(this.toNeo4jEdge);
+        return { nodes: neo4jNodes, edges: neo4jEdges };
+    }
+    /**
+     * Check if variable declarations should be parsed for this file
+     * based on framework schema configurations
+     */
+    shouldParseVariables(filePath) {
+        for (const schema of this.frameworkSchemas) {
+            const parsePatterns = schema.metadata.parseVariablesFrom;
+            if (parsePatterns) {
+                for (const pattern of parsePatterns) {
+                    if (minimatch(filePath, pattern)) {
+                        return true;
+                    }
+                }
+            }
+        }
+        return false;
+    }
+    async parseCoreTypeScriptV2(sourceFile) {
+        const sourceFileNode = this.createCoreNode(sourceFile, CoreNodeType.SOURCE_FILE);
+        this.addNode(sourceFileNode);
+        // Parse configured children
+        this.parseChildNodes(this.coreSchema.nodeTypes[CoreNodeType.SOURCE_FILE], sourceFileNode, sourceFile);
+        // Special handling: Parse variable declarations if framework schema specifies patterns
+        if (this.shouldParseVariables(sourceFile.getFilePath())) {
+            for (const varStatement of sourceFile.getVariableStatements()) {
+                for (const varDecl of varStatement.getDeclarations()) {
+                    if (this.shouldSkipChildNode(varDecl))
+                        continue;
+                    const variableNode = this.createCoreNode(varDecl, CoreNodeType.VARIABLE_DECLARATION);
+                    this.addNode(variableNode);
+                    const containsEdge = this.createCoreEdge(CoreEdgeType.CONTAINS, sourceFileNode.id, variableNode.id);
+                    this.addEdge(containsEdge);
+                }
+            }
+        }
+    }
+    async parseChildNodes(parentNodeConfig, parentNode, astNode) {
+        if (!parentNodeConfig.children)
+            return;
+        for (const [childType, edgeType] of Object.entries(parentNodeConfig.children)) {
+            const type = childType;
+            const astGetterName = this.coreSchema.astGetters[type];
+            if (!astGetterName) {
+                console.warn(`No AST getter defined for child type ${type}`);
+                continue;
+            }
+            const astGetter = astNode[astGetterName];
+            if (typeof astGetter !== 'function') {
+                console.warn(`AST getter for child type ${type} is not a function`);
+                continue;
+            }
+            const children = astGetter.call(astNode);
+            if (!Array.isArray(children)) {
+                console.warn(`AST getter ${astGetterName} did not return an array for ${type}`);
+                continue;
+            }
+            for (const child of children) {
+                if (this.shouldSkipChildNode(child))
+                    continue;
+                const coreNode = this.createCoreNode(child, type);
+                this.addNode(coreNode);
+                const coreEdge = this.createCoreEdge(edgeType, parentNode.id, coreNode.id);
+                this.addEdge(coreEdge);
+                const childNodeConfig = this.coreSchema.nodeTypes[type];
+                if (childNodeConfig) {
+                    this.queueRelationshipNodes(childNodeConfig, coreNode, child);
+                    await this.parseChildNodes(childNodeConfig, coreNode, child);
+                }
+            }
+        }
+    }
+    /**
+     * Queue relationship edges for deferred processing
+     * These are resolved after all nodes are parsed since the target may not exist yet
+     */
+    queueRelationshipNodes(nodeConfig, parsedNode, astNode) {
+        if (!nodeConfig.relationships || nodeConfig.relationships.length === 0)
+            return;
+        for (const relationship of nodeConfig.relationships) {
+            const { edgeType, method, cardinality, targetNodeType } = relationship;
+            const astGetter = astNode[method];
+            if (typeof astGetter !== 'function')
+                continue;
+            const result = astGetter.call(astNode);
+            if (!result)
+                continue;
+            const targets = cardinality === 'single' ? [result] : result;
+            for (const target of targets) {
+                if (!target)
+                    continue;
+                const targetName = this.extractRelationshipTargetName(target);
+                if (!targetName)
+                    continue;
+                this.deferredEdges.push({
+                    edgeType: edgeType,
+                    sourceNodeId: parsedNode.id,
+                    targetName,
+                    targetType: targetNodeType,
+                });
+            }
+        }
+    }
+    /**
+     * Extract the target name from an AST node returned by relationship methods
+     */
+    extractRelationshipTargetName(target) {
+        if (Node.isClassDeclaration(target))
+            return target.getName();
+        if (Node.isInterfaceDeclaration(target))
+            return target.getName();
+        if (Node.isExpressionWithTypeArguments(target))
+            return target.getExpression().getText();
+        return undefined;
+    }
+    /**
+     * Find a parsed node by name and core type
+     */
+    findNodeByNameAndType(name, coreType) {
+        for (const node of this.parsedNodes.values()) {
+            if (node.coreType === coreType && node.properties.name === name) {
+                return node;
+            }
+        }
+        return undefined;
+    }
+    /**
+     * Resolve deferred edges after all nodes have been parsed
+     */
+    resolveDeferredEdges() {
+        for (const deferred of this.deferredEdges) {
+            const targetNode = this.findNodeByNameAndType(deferred.targetName, deferred.targetType);
+            if (targetNode) {
+                const edge = this.createCoreEdge(deferred.edgeType, deferred.sourceNodeId, targetNode.id);
+                this.addEdge(edge);
+            }
+            // If not found, it's likely an external type (from node_modules) - skip silently
+        }
+        this.deferredEdges = [];
+    }
+    async parseCoreTypeScript(sourceFile) {
+        try {
+            // Create source file node
+            const sourceFileNode = this.createCoreNode(sourceFile, CoreNodeType.SOURCE_FILE);
+            this.addNode(sourceFileNode);
+            // Parse classes
+            for (const classDecl of sourceFile.getClasses()) {
+                const classNode = this.createCoreNode(classDecl, CoreNodeType.CLASS_DECLARATION);
+                this.addNode(classNode);
+                // File contains class relationship
+                const containsEdge = this.createCoreEdge(CoreEdgeType.CONTAINS, sourceFileNode.id, classNode.id);
+                this.addEdge(containsEdge);
+                // Parse class decorators
+                for (const decorator of classDecl.getDecorators()) {
+                    const decoratorNode = this.createCoreNode(decorator, CoreNodeType.DECORATOR);
+                    this.addNode(decoratorNode);
+                    // Class decorated with decorator relationship
+                    const decoratedEdge = this.createCoreEdge(CoreEdgeType.DECORATED_WITH, classNode.id, decoratorNode.id);
+                    this.addEdge(decoratedEdge);
+                }
+                // Parse methods
+                for (const method of classDecl.getMethods()) {
+                    const methodNode = this.createCoreNode(method, CoreNodeType.METHOD_DECLARATION);
+                    this.addNode(methodNode);
+                    // Class has method relationship
+                    const hasMethodEdge = this.createCoreEdge(CoreEdgeType.HAS_MEMBER, classNode.id, methodNode.id);
+                    this.addEdge(hasMethodEdge);
+                    // Parse method decorators
+                    for (const decorator of method.getDecorators()) {
+                        const decoratorNode = this.createCoreNode(decorator, CoreNodeType.DECORATOR);
+                        this.addNode(decoratorNode);
+                        // Method decorated with decorator relationship
+                        const decoratedEdge = this.createCoreEdge(CoreEdgeType.DECORATED_WITH, methodNode.id, decoratorNode.id);
+                        this.addEdge(decoratedEdge);
+                    }
+                    // Parse method parameters
+                    for (const param of method.getParameters()) {
+                        const paramNode = this.createCoreNode(param, CoreNodeType.PARAMETER_DECLARATION);
+                        this.addNode(paramNode);
+                        // Method has parameter relationship
+                        const hasParamEdge = this.createCoreEdge(CoreEdgeType.HAS_PARAMETER, methodNode.id, paramNode.id);
+                        this.addEdge(hasParamEdge);
+                        // Parse parameter decorators
+                        for (const decorator of param.getDecorators()) {
+                            const decoratorNode = this.createCoreNode(decorator, CoreNodeType.DECORATOR);
+                            this.addNode(decoratorNode);
+                            // Parameter decorated with decorator relationship
+                            const decoratedEdge = this.createCoreEdge(CoreEdgeType.DECORATED_WITH, paramNode.id, decoratorNode.id);
+                            this.addEdge(decoratedEdge);
+                        }
+                    }
+                }
+                // Parse properties
+                for (const property of classDecl.getProperties()) {
+                    const propertyNode = this.createCoreNode(property, CoreNodeType.PROPERTY_DECLARATION);
+                    this.addNode(propertyNode);
+                    // Class has property relationship
+                    const hasPropertyEdge = this.createCoreEdge(CoreEdgeType.HAS_MEMBER, classNode.id, propertyNode.id);
+                    this.addEdge(hasPropertyEdge);
+                    // Parse property decorators
+                    for (const decorator of property.getDecorators()) {
+                        const decoratorNode = this.createCoreNode(decorator, CoreNodeType.DECORATOR);
+                        this.addNode(decoratorNode);
+                        // Property decorated with decorator relationship
+                        const decoratedEdge = this.createCoreEdge(CoreEdgeType.DECORATED_WITH, propertyNode.id, decoratorNode.id);
+                        this.addEdge(decoratedEdge);
+                    }
+                }
+            }
+            // Parse interfaces
+            for (const interfaceDecl of sourceFile.getInterfaces()) {
+                const interfaceNode = this.createCoreNode(interfaceDecl, CoreNodeType.INTERFACE_DECLARATION);
+                this.addNode(interfaceNode);
+                // File contains interface relationship
+                const containsEdge = this.createCoreEdge(CoreEdgeType.CONTAINS, sourceFileNode.id, interfaceNode.id);
+                this.addEdge(containsEdge);
+            }
+            // Parse functions
+            for (const funcDecl of sourceFile.getFunctions()) {
+                const functionNode = this.createCoreNode(funcDecl, CoreNodeType.FUNCTION_DECLARATION);
+                this.addNode(functionNode);
+                // File contains function relationship
+                const containsEdge = this.createCoreEdge(CoreEdgeType.CONTAINS, sourceFileNode.id, functionNode.id);
+                this.addEdge(containsEdge);
+                // Parse function parameters
+                for (const param of funcDecl.getParameters()) {
+                    const paramNode = this.createCoreNode(param, CoreNodeType.PARAMETER_DECLARATION);
+                    this.addNode(paramNode);
+                    // Function has parameter relationship
+                    const hasParamEdge = this.createCoreEdge(CoreEdgeType.HAS_PARAMETER, functionNode.id, paramNode.id);
+                    this.addEdge(hasParamEdge);
+                }
+            }
+            // Parse imports
+            for (const importDecl of sourceFile.getImportDeclarations()) {
+                const importNode = this.createCoreNode(importDecl, CoreNodeType.IMPORT_DECLARATION);
+                this.addNode(importNode);
+                // File contains import relationship
+                const containsEdge = this.createCoreEdge(CoreEdgeType.CONTAINS, sourceFileNode.id, importNode.id);
+                this.addEdge(containsEdge);
+            }
+            // Parse variable declarations if framework schema specifies this file should have them parsed
+            if (this.shouldParseVariables(sourceFile.getFilePath())) {
+                for (const varStatement of sourceFile.getVariableStatements()) {
+                    for (const varDecl of varStatement.getDeclarations()) {
+                        const variableNode = this.createCoreNode(varDecl, CoreNodeType.VARIABLE_DECLARATION);
+                        this.addNode(variableNode);
+                        // File contains variable relationship
+                        const containsEdge = this.createCoreEdge(CoreEdgeType.CONTAINS, sourceFileNode.id, variableNode.id);
+                        this.addEdge(containsEdge);
+                    }
+                }
+            }
+        }
+        catch (error) {
+            console.error(`Error parsing file ${sourceFile.getFilePath()}:`, error);
+        }
+    }
+    createCoreNode(astNode, coreType) {
+        const nodeId = `${coreType}:${uuidv4()}`;
+        // Extract base properties using schema
+        const properties = {
+            id: nodeId,
+            name: this.extractNodeName(astNode, coreType),
+            coreType,
+            filePath: astNode.getSourceFile().getFilePath(),
+            startLine: astNode.getStartLineNumber(),
+            endLine: astNode.getEndLineNumber(),
+            sourceCode: astNode.getText(),
+            createdAt: new Date().toISOString(),
+        };
+        // Extract schema-defined properties
+        const coreNodeDef = this.coreSchema.nodeTypes[coreType];
+        if (coreNodeDef) {
+            for (const propDef of coreNodeDef.properties) {
+                try {
+                    const value = this.extractProperty(astNode, propDef);
+                    if (value !== undefined && propDef.name !== 'context') {
+                        properties[propDef.name] = value;
+                    }
+                }
+                catch (error) {
+                    console.warn(`Failed to extract core property ${propDef.name}:`, error);
+                }
+            }
+        }
+        return {
+            id: nodeId,
+            coreType,
+            labels: [...(coreNodeDef?.neo4j.labels || [])],
+            properties,
+            sourceNode: astNode,
+            skipEmbedding: coreNodeDef?.neo4j.skipEmbedding ?? false,
+        };
+    }
+    async applyContextExtractors() {
+        console.log('🔧 Applying context extractors...');
+        // Apply global context extractors from framework schemas
+        for (const frameworkSchema of this.frameworkSchemas) {
+            for (const extractor of frameworkSchema.contextExtractors) {
+                await this.applyContextExtractor(extractor);
+            }
+        }
+    }
+    async applyContextExtractor(extractor) {
+        for (const [nodeId, node] of this.parsedNodes) {
+            // Check if this extractor applies to this node
+            if (node.coreType !== extractor.nodeType)
+                continue;
+            if (extractor.semanticType && node.semanticType !== extractor.semanticType)
+                continue;
+            try {
+                const context = extractor.extractor(node, this.parsedNodes, this.sharedContext);
+                if (context && Object.keys(context).length > 0) {
+                    // Merge context into node properties
+                    node.properties.context ??= {};
+                    Object.assign(node.properties.context, context);
+                }
+            }
+            catch (error) {
+                console.warn(`Failed to apply context extractor for ${nodeId}:`, error);
+            }
+        }
+    }
+    createCoreEdge(relationshipType, sourceNodeId, targetNodeId) {
+        // Get the weight from the core schema
+        const coreEdgeSchema = CORE_TYPESCRIPT_SCHEMA.edgeTypes[relationshipType];
+        const relationshipWeight = coreEdgeSchema?.relationshipWeight ?? 0.5;
+        return {
+            id: `${relationshipType}:${uuidv4()}`,
+            relationshipType,
+            sourceNodeId,
+            targetNodeId,
+            properties: {
+                coreType: relationshipType,
+                source: 'ast',
+                confidence: 1.0,
+                relationshipWeight,
+                filePath: '',
+                createdAt: new Date().toISOString(),
+            },
+        };
+    }
+    async applyFrameworkEnhancements() {
+        console.log('🎯 Starting framework enhancements...');
+        for (const frameworkSchema of this.frameworkSchemas) {
+            console.log(`📦 Applying framework schema: ${frameworkSchema.name}`);
+            await this.applyFrameworkSchema(frameworkSchema);
+        }
+        console.log('✅ Framework enhancements complete');
+    }
+    async applyFrameworkSchema(schema) {
+        // Sort enhancements by priority (highest first)
+        const sortedEnhancements = Object.values(schema.enhancements).sort((a, b) => b.priority - a.priority);
+        for (const [nodeId, coreNode] of this.parsedNodes) {
+            // Find applicable enhancements for this core node type
+            const applicableEnhancements = sortedEnhancements.filter((enhancement) => enhancement.targetCoreType === coreNode.coreType);
+            for (const enhancement of applicableEnhancements) {
+                if (this.matchesDetectionPatterns(coreNode, enhancement.detectionPatterns)) {
+                    // Enhance the node!
+                    this.enhanceNode(coreNode, enhancement);
+                    break; // First match wins (highest priority)
+                }
+            }
+        }
+    }
+    matchesDetectionPatterns(node, patterns) {
+        return patterns.some((pattern) => {
+            try {
+                switch (pattern.type) {
+                    case 'decorator':
+                        return this.hasMatchingDecorator(node, pattern.pattern);
+                    case 'filename':
+                        if (pattern.pattern instanceof RegExp) {
+                            return pattern.pattern.test(node.properties.filePath);
+                        }
+                        else {
+                            return node.properties.filePath.includes(pattern.pattern);
+                        }
+                    case 'function':
+                        if (typeof pattern.pattern === 'function') {
+                            return pattern.pattern(node);
+                        }
+                        return false;
+                    case 'classname':
+                        if (pattern.pattern instanceof RegExp) {
+                            return pattern.pattern.test(node.properties.name);
+                        }
+                        else {
+                            return node.properties.name.includes(pattern.pattern);
+                        }
+                    default:
+                        return false;
+                }
+            }
+            catch (error) {
+                console.warn(`Error matching detection pattern:`, error);
+                return false;
+            }
+        });
+    }
+    hasMatchingDecorator(node, decoratorName) {
+        try {
+            const context = node.properties.context;
+            const decoratorNames = context?.decoratorNames;
+            return decoratorNames?.includes(decoratorName) || false;
+        }
+        catch (error) {
+            console.warn(`Error checking decorator ${decoratorName}:`, error);
+            return false;
+        }
+    }
+    enhanceNode(coreNode, enhancement) {
+        try {
+            // Set semantic type (single, not array)
+            coreNode.semanticType = enhancement.semanticType;
+            coreNode.properties.semanticType = enhancement.semanticType;
+            // Add framework labels
+            enhancement.neo4j.additionalLabels.forEach((label) => {
+                if (!coreNode.labels.includes(label)) {
+                    coreNode.labels.unshift(label);
+                }
+            });
+            // Override primary label if specified
+            if (enhancement.neo4j.primaryLabel) {
+                const oldPrimaryIndex = coreNode.labels.findIndex((label) => label === enhancement.neo4j.primaryLabel);
+                if (oldPrimaryIndex > -1) {
+                    coreNode.labels.splice(oldPrimaryIndex, 1);
+                }
+                coreNode.labels.unshift(enhancement.neo4j.primaryLabel);
+            }
+            // Apply context extractors specific to this enhancement
+            for (const extractor of enhancement.contextExtractors) {
+                try {
+                    const context = extractor.extractor(coreNode, this.parsedNodes, this.sharedContext);
+                    if (context && Object.keys(context).length > 0) {
+                        coreNode.properties.context ??= {};
+                        Object.assign(coreNode.properties.context, context);
+                    }
+                }
+                catch (error) {
+                    console.warn(`Failed to apply enhancement context extractor:`, error);
+                }
+            }
+        }
+        catch (error) {
+            console.error(`Error enhancing node ${coreNode.id}:`, error);
+        }
+    }
+    async applyEdgeEnhancements() {
+        console.log('🔗 Applying edge enhancements...');
+        for (const frameworkSchema of this.frameworkSchemas) {
+            for (const edgeEnhancement of Object.values(frameworkSchema.edgeEnhancements)) {
+                await this.applyEdgeEnhancement(edgeEnhancement);
+            }
+        }
+    }
+    async applyEdgeEnhancement(edgeEnhancement) {
+        try {
+            for (const [sourceId, sourceNode] of this.parsedNodes) {
+                for (const [targetId, targetNode] of this.parsedNodes) {
+                    if (sourceId === targetId)
+                        continue;
+                    if (edgeEnhancement.detectionPattern(sourceNode, targetNode, this.parsedNodes, this.sharedContext)) {
+                        // Extract context for this edge
+                        let context = {};
+                        if (edgeEnhancement.contextExtractor) {
+                            context = edgeEnhancement.contextExtractor(sourceNode, targetNode, this.parsedNodes, this.sharedContext);
+                        }
+                        const edge = this.createFrameworkEdge(edgeEnhancement.semanticType, edgeEnhancement.neo4j.relationshipType, sourceId, targetId, context, edgeEnhancement.relationshipWeight);
+                        this.addEdge(edge);
+                    }
+                }
+            }
+        }
+        catch (error) {
+            console.error(`Error applying edge enhancement ${edgeEnhancement.name}:`, error);
+        }
+    }
+    createFrameworkEdge(semanticType, relationshipType, sourceNodeId, targetNodeId, context = {}, relationshipWeight = 0.5) {
+        const edgeId = `${semanticType}:${uuidv4()}`;
+        const properties = {
+            coreType: semanticType, // This might need adjustment based on schema
+            semanticType,
+            source: 'pattern',
+            confidence: 0.8,
+            relationshipWeight,
+            filePath: '',
+            createdAt: new Date().toISOString(),
+            context,
+        };
+        return {
+            id: edgeId,
+            relationshipType,
+            sourceNodeId,
+            targetNodeId,
+            properties,
+        };
+    }
+    extractProperty(astNode, propDef) {
+        const { method, source, defaultValue } = propDef.extraction;
+        try {
+            switch (method) {
+                case 'ast':
+                    if (typeof source === 'string') {
+                        const fn = astNode[source];
+                        return typeof fn === 'function' ? fn.call(astNode) : defaultValue;
+                    }
+                    return defaultValue;
+                case 'function':
+                    if (typeof source === 'function') {
+                        return source(astNode);
+                    }
+                    return defaultValue;
+                case 'static':
+                    return defaultValue;
+                case 'context':
+                    // Context properties are handled by context extractors
+                    return undefined;
+                default:
+                    return defaultValue;
+            }
+        }
+        catch (error) {
+            console.warn(`Failed to extract property ${propDef.name}:`, error);
+            return defaultValue;
+        }
+    }
+    extractNodeName(astNode, coreType) {
+        try {
+            switch (coreType) {
+                case CoreNodeType.SOURCE_FILE:
+                    if (Node.isSourceFile(astNode)) {
+                        return astNode.getBaseName();
+                    }
+                    break;
+                case CoreNodeType.CLASS_DECLARATION:
+                    if (Node.isClassDeclaration(astNode)) {
+                        return astNode.getName() ?? 'AnonymousClass';
+                    }
+                    break;
+                case CoreNodeType.METHOD_DECLARATION:
+                    if (Node.isMethodDeclaration(astNode)) {
+                        return astNode.getName();
+                    }
+                    break;
+                case CoreNodeType.FUNCTION_DECLARATION:
+                    if (Node.isFunctionDeclaration(astNode)) {
+                        return astNode.getName() ?? 'AnonymousFunction';
+                    }
+                    break;
+                case CoreNodeType.INTERFACE_DECLARATION:
+                    if (Node.isInterfaceDeclaration(astNode)) {
+                        return astNode.getName();
+                    }
+                    break;
+                case CoreNodeType.PROPERTY_DECLARATION:
+                    if (Node.isPropertyDeclaration(astNode)) {
+                        return astNode.getName();
+                    }
+                    break;
+                case CoreNodeType.PARAMETER_DECLARATION:
+                    if (Node.isParameterDeclaration(astNode)) {
+                        return astNode.getName();
+                    }
+                    break;
+                case CoreNodeType.IMPORT_DECLARATION:
+                    if (Node.isImportDeclaration(astNode)) {
+                        return astNode.getModuleSpecifierValue();
+                    }
+                    break;
+                case CoreNodeType.DECORATOR:
+                    if (Node.isDecorator(astNode)) {
+                        return astNode.getName();
+                    }
+                    break;
+                default:
+                    return astNode.getKindName();
+            }
+        }
+        catch (error) {
+            console.warn(`Error extracting name for ${coreType}:`, error);
+        }
+        return 'Unknown';
+    }
+    shouldSkipChildNode(node) {
+        const excludedNodeTypes = this.parseConfig.excludedNodeTypes ?? [];
+        return excludedNodeTypes.includes(node.getKindName());
+    }
+    shouldSkipFile(sourceFile) {
+        const filePath = sourceFile.getFilePath();
+        const excludedPatterns = this.parseConfig.excludePatterns ?? [];
+        for (const pattern of excludedPatterns) {
+            if (filePath.includes(pattern) || filePath.match(new RegExp(pattern))) {
+                console.log(`⏭️ Skipping excluded file: ${filePath}`);
+                return true;
+            }
+        }
+        return false;
+    }
+    toNeo4jNode(parsedNode) {
+        return {
+            id: parsedNode.id,
+            labels: parsedNode.labels,
+            properties: parsedNode.properties,
+            skipEmbedding: parsedNode.skipEmbedding ?? false,
+        };
+    }
+    toNeo4jEdge(parsedEdge) {
+        return {
+            id: parsedEdge.id,
+            type: parsedEdge.relationshipType,
+            startNodeId: parsedEdge.sourceNodeId,
+            endNodeId: parsedEdge.targetNodeId,
+            properties: parsedEdge.properties,
+        };
+    }
+    addNode(node) {
+        this.parsedNodes.set(node.id, node);
+    }
+    addEdge(edge) {
+        this.parsedEdges.set(edge.id, edge);
+    }
+    // Helper methods for statistics and debugging
+    getStats() {
+        const nodesByType = {};
+        const nodesBySemanticType = {};
+        for (const node of this.parsedNodes.values()) {
+            nodesByType[node.coreType] = (nodesByType[node.coreType] || 0) + 1;
+            if (node.semanticType) {
+                nodesBySemanticType[node.semanticType] = (nodesBySemanticType[node.semanticType] || 0) + 1;
+            }
+        }
+        return {
+            totalNodes: this.parsedNodes.size,
+            totalEdges: this.parsedEdges.size,
+            nodesByType,
+            nodesBySemanticType,
+        };
+    }
+    exportToJson() {
+        const nodes = Array.from(this.parsedNodes.values()).map((node) => ({
+            id: node.id,
+            labels: node.labels,
+            properties: node.properties,
+            skipEmbedding: node.skipEmbedding ?? false,
+        }));
+        const edges = Array.from(this.parsedEdges.values()).map((edge) => ({
+            id: edge.id,
+            type: edge.relationshipType,
+            startNodeId: edge.sourceNodeId,
+            endNodeId: edge.targetNodeId,
+            properties: edge.properties,
+        }));
+        return { nodes, edges };
+    }
+}