code-graph-context 2.4.4 → 2.5.0

package/dist/core/config/graph-v2.js

@@ -1,1595 +0,0 @@
-/* eslint-disable prefer-arrow/prefer-arrow-functions */
-/* eslint-disable @typescript-eslint/no-explicit-any */
-// graph.ts - Optimized for Neo4j performance with context-based framework properties
-// ============================================================================
-// CORE ENUMS
-// ============================================================================
-/**
- * Core TypeScript AST Node Types (from ts-morph)
- */
-export var CoreNodeType;
-(function (CoreNodeType) {
-    // File System & Workspace
-    CoreNodeType["SOURCE_FILE"] = "SourceFile";
-    // Core TypeScript AST Declarations
-    CoreNodeType["CLASS_DECLARATION"] = "ClassDeclaration";
-    CoreNodeType["INTERFACE_DECLARATION"] = "InterfaceDeclaration";
-    CoreNodeType["ENUM_DECLARATION"] = "EnumDeclaration";
-    CoreNodeType["FUNCTION_DECLARATION"] = "FunctionDeclaration";
-    CoreNodeType["VARIABLE_DECLARATION"] = "VariableDeclaration";
-    // Class Members
-    CoreNodeType["METHOD_DECLARATION"] = "MethodDeclaration";
-    CoreNodeType["PROPERTY_DECLARATION"] = "PropertyDeclaration";
-    CoreNodeType["CONSTRUCTOR_DECLARATION"] = "ConstructorDeclaration";
-    CoreNodeType["PARAMETER_DECLARATION"] = "ParameterDeclaration";
-    // Import/Export System
-    CoreNodeType["IMPORT_DECLARATION"] = "ImportDeclaration";
-    CoreNodeType["EXPORT_DECLARATION"] = "ExportDeclaration";
-    // Decorators
-    CoreNodeType["DECORATOR"] = "Decorator";
-})(CoreNodeType || (CoreNodeType = {}));
-/**
- * Core Edge Types (AST relationships)
- */
-export var CoreEdgeType;
-(function (CoreEdgeType) {
-    // File Structure
-    CoreEdgeType["CONTAINS"] = "CONTAINS";
-    // Import/Export
-    CoreEdgeType["IMPORTS"] = "IMPORTS";
-    CoreEdgeType["EXPORTS"] = "EXPORTS";
-    // Type System
-    CoreEdgeType["EXTENDS"] = "EXTENDS";
-    CoreEdgeType["IMPLEMENTS"] = "IMPLEMENTS";
-    CoreEdgeType["TYPED_AS"] = "TYPED_AS";
-    // Code Structure
-    CoreEdgeType["HAS_MEMBER"] = "HAS_MEMBER";
-    CoreEdgeType["HAS_PARAMETER"] = "HAS_PARAMETER";
-    CoreEdgeType["CALLS"] = "CALLS";
-    // Decorator
-    CoreEdgeType["DECORATED_WITH"] = "DECORATED_WITH";
-})(CoreEdgeType || (CoreEdgeType = {}));
-/**
- * Semantic Node Types (Framework interpretations)
- */
-export var SemanticNodeType;
-(function (SemanticNodeType) {
-    // NestJS Framework Types
-    SemanticNodeType["NEST_MODULE"] = "NestModule";
-    SemanticNodeType["NEST_CONTROLLER"] = "NestController";
-    SemanticNodeType["NEST_SERVICE"] = "NestService";
-    SemanticNodeType["NEST_GUARD"] = "NestGuard";
-    SemanticNodeType["NEST_PIPE"] = "NestPipe";
-    SemanticNodeType["NEST_INTERCEPTOR"] = "NestInterceptor";
-    SemanticNodeType["NEST_FILTER"] = "NestFilter";
-    SemanticNodeType["NEST_PROVIDER"] = "NestProvider";
-    // HTTP & API Types
-    SemanticNodeType["HTTP_ENDPOINT"] = "HttpEndpoint";
-    SemanticNodeType["MESSAGE_HANDLER"] = "MessageHandler";
-    // Data Types
-    SemanticNodeType["DTO_CLASS"] = "DTOClass";
-    SemanticNodeType["ENTITY_CLASS"] = "EntityClass";
-    SemanticNodeType["CONFIG_CLASS"] = "ConfigClass";
-    // Testing
-    SemanticNodeType["TEST_CLASS"] = "TestClass";
-})(SemanticNodeType || (SemanticNodeType = {}));
-/**
- * Semantic Edge Types (Framework relationships)
- */
-export var SemanticEdgeType;
-(function (SemanticEdgeType) {
-    // NestJS Module System
-    SemanticEdgeType["MODULE_IMPORTS"] = "MODULE_IMPORTS";
-    SemanticEdgeType["MODULE_PROVIDES"] = "MODULE_PROVIDES";
-    SemanticEdgeType["MODULE_EXPORTS"] = "MODULE_EXPORTS";
-    // Dependency Injection
-    SemanticEdgeType["INJECTS"] = "INJECTS";
-    SemanticEdgeType["PROVIDED_BY"] = "PROVIDED_BY";
-    // HTTP API
-    SemanticEdgeType["EXPOSES"] = "EXPOSES";
-    SemanticEdgeType["ACCEPTS"] = "ACCEPTS";
-    SemanticEdgeType["RESPONDS_WITH"] = "RESPONDS_WITH";
-    SemanticEdgeType["CONSUMES_MESSAGE"] = "CONSUMES_MESSAGE";
-    // Security & Middleware
-    SemanticEdgeType["GUARDED_BY"] = "GUARDED_BY";
-    SemanticEdgeType["TRANSFORMED_BY"] = "TRANSFORMED_BY";
-    SemanticEdgeType["INTERCEPTED_BY"] = "INTERCEPTED_BY";
-    // Domain Logic
-    SemanticEdgeType["MANAGES"] = "MANAGES";
-    SemanticEdgeType["VALIDATES"] = "VALIDATES";
-    // Testing
-    SemanticEdgeType["TESTS"] = "TESTS";
-})(SemanticEdgeType || (SemanticEdgeType = {}));
-// ============================================================================
-// CORE TYPESCRIPT SCHEMA
-// ============================================================================
-export const CORE_TYPESCRIPT_SCHEMA = {
-    name: 'Core TypeScript Schema',
-    version: '2.0.0',
-    nodeTypes: {
-        [CoreNodeType.SOURCE_FILE]: {
-            coreType: CoreNodeType.SOURCE_FILE,
-            astNodeKind: 311,
-            properties: [
-                {
-                    name: 'name',
-                    type: 'string',
-                    extraction: { method: 'ast', source: 'getBaseName' },
-                    neo4j: { indexed: true, unique: false, required: true },
-                },
-                {
-                    name: 'filePath',
-                    type: 'string',
-                    extraction: { method: 'ast', source: 'getFilePath' },
-                    neo4j: { indexed: true, unique: true, required: true },
-                },
-                {
-                    name: 'isExported',
-                    type: 'boolean',
-                    extraction: { method: 'static', defaultValue: false },
-                    neo4j: { indexed: true, unique: false, required: true },
-                },
-            ],
-            relationships: [CoreEdgeType.CONTAINS, CoreEdgeType.IMPORTS, CoreEdgeType.EXPORTS],
-            neo4j: {
-                labels: ['SourceFile', 'TypeScript'],
-                primaryLabel: 'SourceFile',
-                indexed: ['name', 'filePath', 'isExported'],
-                skipEmbedding: true,
-            },
-        },
-        [CoreNodeType.CLASS_DECLARATION]: {
-            coreType: CoreNodeType.CLASS_DECLARATION,
-            astNodeKind: 262,
-            properties: [
-                {
-                    name: 'name',
-                    type: 'string',
-                    extraction: { method: 'ast', source: 'getName' },
-                    neo4j: { indexed: true, unique: false, required: true },
-                },
-                {
-                    name: 'isExported',
-                    type: 'boolean',
-                    extraction: { method: 'ast', source: 'isExported', defaultValue: false },
-                    neo4j: { indexed: true, unique: false, required: true },
-                },
-                {
-                    name: 'visibility',
-                    type: 'string',
-                    extraction: {
-                        method: 'function',
-                        source: (node) => (node.isExported() ? 'public' : 'none'),
-                        defaultValue: 'none',
-                    },
-                    neo4j: { indexed: true, unique: false, required: true },
-                },
-            ],
-            relationships: [
-                CoreEdgeType.HAS_MEMBER,
-                CoreEdgeType.EXTENDS,
-                CoreEdgeType.IMPLEMENTS,
-                CoreEdgeType.DECORATED_WITH,
-            ],
-            neo4j: {
-                labels: ['Class', 'TypeScript'],
-                primaryLabel: 'Class',
-                indexed: ['name', 'isExported', 'visibility'],
-            },
-        },
-        [CoreNodeType.METHOD_DECLARATION]: {
-            coreType: CoreNodeType.METHOD_DECLARATION,
-            astNodeKind: 172,
-            properties: [
-                {
-                    name: 'name',
-                    type: 'string',
-                    extraction: { method: 'ast', source: 'getName' },
-                    neo4j: { indexed: true, unique: false, required: true },
-                },
-                {
-                    name: 'visibility',
-                    type: 'string',
-                    extraction: {
-                        method: 'function',
-                        source: (node) => {
-                            const modifiers = node.getModifiers();
-                            for (const modifier of modifiers) {
-                                const kind = modifier.getKind();
-                                if (kind === 125)
-                                    return 'public';
-                                if (kind === 123)
-                                    return 'private';
-                                if (kind === 124)
-                                    return 'protected';
-                            }
-                            return 'public';
-                        },
-                        defaultValue: 'public',
-                    },
-                    neo4j: { indexed: true, unique: false, required: true },
-                },
-            ],
-            relationships: [CoreEdgeType.HAS_PARAMETER, CoreEdgeType.CALLS, CoreEdgeType.DECORATED_WITH],
-            neo4j: {
-                labels: ['Method', 'TypeScript'],
-                primaryLabel: 'Method',
-                indexed: ['name', 'visibility'],
-            },
-        },
-        [CoreNodeType.PROPERTY_DECLARATION]: {
-            coreType: CoreNodeType.PROPERTY_DECLARATION,
-            astNodeKind: 171,
-            properties: [
-                {
-                    name: 'name',
-                    type: 'string',
-                    extraction: { method: 'ast', source: 'getName' },
-                    neo4j: { indexed: true, unique: false, required: true },
-                },
-                {
-                    name: 'visibility',
-                    type: 'string',
-                    extraction: {
-                        method: 'function',
-                        source: (node) => {
-                            const modifiers = node.getModifiers();
-                            for (const modifier of modifiers) {
-                                const kind = modifier.getKind();
-                                if (kind === 125)
-                                    return 'public';
-                                if (kind === 123)
-                                    return 'private';
-                                if (kind === 124)
-                                    return 'protected';
-                            }
-                            return 'public';
-                        },
-                        defaultValue: 'public',
-                    },
-                    neo4j: { indexed: true, unique: false, required: true },
-                },
-            ],
-            relationships: [CoreEdgeType.TYPED_AS, CoreEdgeType.DECORATED_WITH],
-            neo4j: {
-                labels: ['Property', 'TypeScript'],
-                primaryLabel: 'Property',
-                indexed: ['name', 'visibility'],
-                skipEmbedding: true,
-            },
-        },
-        [CoreNodeType.PARAMETER_DECLARATION]: {
-            coreType: CoreNodeType.PARAMETER_DECLARATION,
-            astNodeKind: 169,
-            properties: [
-                {
-                    name: 'name',
-                    type: 'string',
-                    extraction: { method: 'ast', source: 'getName' },
-                    neo4j: { indexed: true, unique: false, required: true },
-                },
-            ],
-            relationships: [CoreEdgeType.TYPED_AS, CoreEdgeType.DECORATED_WITH],
-            neo4j: {
-                labels: ['Parameter', 'TypeScript'],
-                primaryLabel: 'Parameter',
-                indexed: ['name'],
-                skipEmbedding: true,
-            },
-        },
-        [CoreNodeType.IMPORT_DECLARATION]: {
-            coreType: CoreNodeType.IMPORT_DECLARATION,
-            astNodeKind: 272,
-            properties: [
-                {
-                    name: 'name',
-                    type: 'string',
-                    extraction: { method: 'ast', source: 'getModuleSpecifierValue' },
-                    neo4j: { indexed: true, unique: false, required: true },
-                },
-            ],
-            relationships: [CoreEdgeType.IMPORTS],
-            neo4j: {
-                labels: ['Import', 'TypeScript'],
-                primaryLabel: 'Import',
-                indexed: ['name'],
-                skipEmbedding: true,
-            },
-        },
-        [CoreNodeType.DECORATOR]: {
-            coreType: CoreNodeType.DECORATOR,
-            astNodeKind: 170,
-            properties: [
-                {
-                    name: 'name',
-                    type: 'string',
-                    extraction: { method: 'ast', source: 'getName' },
-                    neo4j: { indexed: true, unique: false, required: true },
-                },
-            ],
-            relationships: [],
-            neo4j: {
-                labels: ['Decorator'],
-                primaryLabel: 'Decorator',
-                indexed: ['name'],
-                skipEmbedding: true,
-            },
-        },
-        // Add remaining core types with minimal properties
-        [CoreNodeType.INTERFACE_DECLARATION]: {
-            coreType: CoreNodeType.INTERFACE_DECLARATION,
-            astNodeKind: 263,
-            properties: [
-                {
-                    name: 'name',
-                    type: 'string',
-                    extraction: { method: 'ast', source: 'getName' },
-                    neo4j: { indexed: true, unique: false, required: true },
-                },
-                {
-                    name: 'isExported',
-                    type: 'boolean',
-                    extraction: { method: 'ast', source: 'isExported', defaultValue: false },
-                    neo4j: { indexed: true, unique: false, required: true },
-                },
-            ],
-            relationships: [CoreEdgeType.EXTENDS, CoreEdgeType.HAS_MEMBER],
-            neo4j: {
-                labels: ['Interface', 'TypeScript'],
-                primaryLabel: 'Interface',
-                indexed: ['name', 'isExported'],
-            },
-        },
-        [CoreNodeType.ENUM_DECLARATION]: {
-            coreType: CoreNodeType.ENUM_DECLARATION,
-            astNodeKind: 264,
-            properties: [
-                {
-                    name: 'name',
-                    type: 'string',
-                    extraction: { method: 'ast', source: 'getName' },
-                    neo4j: { indexed: true, unique: false, required: true },
-                },
-                {
-                    name: 'isExported',
-                    type: 'boolean',
-                    extraction: { method: 'ast', source: 'isExported', defaultValue: false },
-                    neo4j: { indexed: true, unique: false, required: true },
-                },
-            ],
-            relationships: [],
-            neo4j: {
-                labels: ['Enum', 'TypeScript'],
-                primaryLabel: 'Enum',
-                indexed: ['name', 'isExported'],
-                skipEmbedding: true,
-            },
-        },
-        [CoreNodeType.FUNCTION_DECLARATION]: {
-            coreType: CoreNodeType.FUNCTION_DECLARATION,
-            astNodeKind: 261,
-            properties: [
-                {
-                    name: 'name',
-                    type: 'string',
-                    extraction: { method: 'ast', source: 'getName' },
-                    neo4j: { indexed: true, unique: false, required: true },
-                },
-                {
-                    name: 'isExported',
-                    type: 'boolean',
-                    extraction: { method: 'ast', source: 'isExported', defaultValue: false },
-                    neo4j: { indexed: true, unique: false, required: true },
-                },
-            ],
-            relationships: [CoreEdgeType.HAS_PARAMETER, CoreEdgeType.CALLS],
-            neo4j: {
-                labels: ['Function', 'TypeScript'],
-                primaryLabel: 'Function',
-                indexed: ['name', 'isExported'],
-            },
-        },
-        [CoreNodeType.VARIABLE_DECLARATION]: {
-            coreType: CoreNodeType.VARIABLE_DECLARATION,
-            astNodeKind: 258,
-            properties: [
-                {
-                    name: 'name',
-                    type: 'string',
-                    extraction: { method: 'ast', source: 'getName' },
-                    neo4j: { indexed: true, unique: false, required: true },
-                },
-            ],
-            relationships: [],
-            neo4j: {
-                labels: ['Variable', 'TypeScript'],
-                primaryLabel: 'Variable',
-                indexed: ['name'],
-                skipEmbedding: true,
-            },
-        },
-        [CoreNodeType.CONSTRUCTOR_DECLARATION]: {
-            coreType: CoreNodeType.CONSTRUCTOR_DECLARATION,
-            astNodeKind: 175,
-            properties: [
-                {
-                    name: 'name',
-                    type: 'string',
-                    extraction: { method: 'static', defaultValue: 'constructor' },
-                    neo4j: { indexed: true, unique: false, required: true },
-                },
-            ],
-            relationships: [CoreEdgeType.HAS_PARAMETER],
-            neo4j: {
-                labels: ['Constructor', 'TypeScript'],
-                primaryLabel: 'Constructor',
-                indexed: ['name'],
-                skipEmbedding: true,
-            },
-        },
-        [CoreNodeType.EXPORT_DECLARATION]: {
-            coreType: CoreNodeType.EXPORT_DECLARATION,
-            astNodeKind: 273,
-            properties: [
-                {
-                    name: 'name',
-                    type: 'string',
-                    extraction: { method: 'static', defaultValue: 'export' },
-                    neo4j: { indexed: true, unique: false, required: true },
-                },
-            ],
-            relationships: [],
-            neo4j: {
-                labels: ['Export', 'TypeScript'],
-                primaryLabel: 'Export',
-                indexed: ['name'],
-                skipEmbedding: true,
-            },
-        },
-    },
-    edgeTypes: {
-        [CoreEdgeType.CONTAINS]: {
-            coreType: CoreEdgeType.CONTAINS,
-            sourceTypes: [CoreNodeType.SOURCE_FILE, CoreNodeType.CLASS_DECLARATION],
-            targetTypes: [
-                CoreNodeType.CLASS_DECLARATION,
-                CoreNodeType.INTERFACE_DECLARATION,
-                CoreNodeType.FUNCTION_DECLARATION,
-                CoreNodeType.METHOD_DECLARATION,
-                CoreNodeType.PROPERTY_DECLARATION,
-            ],
-            properties: [
-                {
-                    name: 'confidence',
-                    type: 'number',
-                    extraction: { method: 'static', defaultValue: 1.0 },
-                    neo4j: { indexed: true, unique: false, required: true },
-                },
-                {
-                    name: 'source',
-                    type: 'string',
-                    extraction: { method: 'static', defaultValue: 'ast' },
-                    neo4j: { indexed: true, unique: false, required: true },
-                },
-            ],
-            neo4j: {
-                relationshipType: 'CONTAINS',
-                direction: 'OUTGOING',
-            },
-        },
-        [CoreEdgeType.HAS_MEMBER]: {
-            coreType: CoreEdgeType.HAS_MEMBER,
-            sourceTypes: [CoreNodeType.CLASS_DECLARATION, CoreNodeType.INTERFACE_DECLARATION],
-            targetTypes: [
-                CoreNodeType.METHOD_DECLARATION,
-                CoreNodeType.PROPERTY_DECLARATION,
-                CoreNodeType.CONSTRUCTOR_DECLARATION,
-            ],
-            properties: [
-                {
-                    name: 'confidence',
-                    type: 'number',
-                    extraction: { method: 'static', defaultValue: 1.0 },
-                    neo4j: { indexed: true, unique: false, required: true },
-                },
-                {
-                    name: 'source',
-                    type: 'string',
-                    extraction: { method: 'static', defaultValue: 'ast' },
-                    neo4j: { indexed: true, unique: false, required: true },
-                },
-            ],
-            neo4j: {
-                relationshipType: 'HAS_MEMBER',
-                direction: 'OUTGOING',
-            },
-        },
-        [CoreEdgeType.HAS_PARAMETER]: {
-            coreType: CoreEdgeType.HAS_PARAMETER,
-            sourceTypes: [
-                CoreNodeType.METHOD_DECLARATION,
-                CoreNodeType.FUNCTION_DECLARATION,
-                CoreNodeType.CONSTRUCTOR_DECLARATION,
-            ],
-            targetTypes: [CoreNodeType.PARAMETER_DECLARATION],
-            properties: [
-                {
-                    name: 'confidence',
-                    type: 'number',
-                    extraction: { method: 'static', defaultValue: 1.0 },
-                    neo4j: { indexed: true, unique: false, required: true },
-                },
-                {
-                    name: 'source',
-                    type: 'string',
-                    extraction: { method: 'static', defaultValue: 'ast' },
-                    neo4j: { indexed: true, unique: false, required: true },
-                },
-            ],
-            neo4j: {
-                relationshipType: 'HAS_PARAMETER',
-                direction: 'OUTGOING',
-            },
-        },
-        [CoreEdgeType.DECORATED_WITH]: {
-            coreType: CoreEdgeType.DECORATED_WITH,
-            sourceTypes: [
-                CoreNodeType.CLASS_DECLARATION,
-                CoreNodeType.METHOD_DECLARATION,
-                CoreNodeType.PROPERTY_DECLARATION,
-                CoreNodeType.PARAMETER_DECLARATION,
-            ],
-            targetTypes: [CoreNodeType.DECORATOR],
-            properties: [
-                {
-                    name: 'confidence',
-                    type: 'number',
-                    extraction: { method: 'static', defaultValue: 1.0 },
-                    neo4j: { indexed: true, unique: false, required: true },
-                },
-                {
-                    name: 'source',
-                    type: 'string',
-                    extraction: { method: 'static', defaultValue: 'ast' },
-                    neo4j: { indexed: true, unique: false, required: true },
-                },
-            ],
-            neo4j: {
-                relationshipType: 'DECORATED_WITH',
-                direction: 'OUTGOING',
-            },
-        },
-        [CoreEdgeType.IMPORTS]: {
-            coreType: CoreEdgeType.IMPORTS,
-            sourceTypes: [CoreNodeType.SOURCE_FILE],
-            targetTypes: [CoreNodeType.SOURCE_FILE],
-            properties: [
-                {
-                    name: 'confidence',
-                    type: 'number',
-                    extraction: { method: 'static', defaultValue: 1.0 },
-                    neo4j: { indexed: true, unique: false, required: true },
-                },
-                {
-                    name: 'source',
-                    type: 'string',
-                    extraction: { method: 'static', defaultValue: 'ast' },
-                    neo4j: { indexed: true, unique: false, required: true },
-                },
-            ],
-            neo4j: {
-                relationshipType: 'IMPORTS',
-                direction: 'OUTGOING',
-            },
-        },
-        [CoreEdgeType.EXPORTS]: {
-            coreType: CoreEdgeType.EXPORTS,
-            sourceTypes: [CoreNodeType.SOURCE_FILE],
-            targetTypes: [
-                CoreNodeType.CLASS_DECLARATION,
-                CoreNodeType.INTERFACE_DECLARATION,
-                CoreNodeType.FUNCTION_DECLARATION,
-            ],
-            properties: [
-                {
-                    name: 'confidence',
-                    type: 'number',
-                    extraction: { method: 'static', defaultValue: 1.0 },
-                    neo4j: { indexed: true, unique: false, required: true },
-                },
-                {
-                    name: 'source',
-                    type: 'string',
-                    extraction: { method: 'static', defaultValue: 'ast' },
-                    neo4j: { indexed: true, unique: false, required: true },
-                },
-            ],
-            neo4j: {
-                relationshipType: 'EXPORTS',
-                direction: 'OUTGOING',
-            },
-        },
-        [CoreEdgeType.EXTENDS]: {
-            coreType: CoreEdgeType.EXTENDS,
-            sourceTypes: [CoreNodeType.CLASS_DECLARATION, CoreNodeType.INTERFACE_DECLARATION],
-            targetTypes: [CoreNodeType.CLASS_DECLARATION, CoreNodeType.INTERFACE_DECLARATION],
-            properties: [
-                {
-                    name: 'confidence',
-                    type: 'number',
-                    extraction: { method: 'static', defaultValue: 1.0 },
-                    neo4j: { indexed: true, unique: false, required: true },
-                },
-                {
-                    name: 'source',
-                    type: 'string',
-                    extraction: { method: 'static', defaultValue: 'ast' },
-                    neo4j: { indexed: true, unique: false, required: true },
-                },
-            ],
-            neo4j: {
-                relationshipType: 'EXTENDS',
-                direction: 'OUTGOING',
-            },
-        },
-        [CoreEdgeType.IMPLEMENTS]: {
-            coreType: CoreEdgeType.IMPLEMENTS,
-            sourceTypes: [CoreNodeType.CLASS_DECLARATION],
-            targetTypes: [CoreNodeType.INTERFACE_DECLARATION],
-            properties: [
-                {
-                    name: 'confidence',
-                    type: 'number',
-                    extraction: { method: 'static', defaultValue: 1.0 },
-                    neo4j: { indexed: true, unique: false, required: true },
-                },
-                {
-                    name: 'source',
-                    type: 'string',
-                    extraction: { method: 'static', defaultValue: 'ast' },
-                    neo4j: { indexed: true, unique: false, required: true },
-                },
-            ],
-            neo4j: {
-                relationshipType: 'IMPLEMENTS',
-                direction: 'OUTGOING',
-            },
-        },
-        [CoreEdgeType.TYPED_AS]: {
-            coreType: CoreEdgeType.TYPED_AS,
-            sourceTypes: [CoreNodeType.PARAMETER_DECLARATION, CoreNodeType.PROPERTY_DECLARATION],
-            targetTypes: [CoreNodeType.CLASS_DECLARATION, CoreNodeType.INTERFACE_DECLARATION],
-            properties: [
-                {
-                    name: 'confidence',
-                    type: 'number',
-                    extraction: { method: 'static', defaultValue: 1.0 },
-                    neo4j: { indexed: true, unique: false, required: true },
-                },
-                {
-                    name: 'source',
-                    type: 'string',
-                    extraction: { method: 'static', defaultValue: 'ast' },
-                    neo4j: { indexed: true, unique: false, required: true },
-                },
-            ],
-            neo4j: {
-                relationshipType: 'TYPED_AS',
-                direction: 'OUTGOING',
-            },
-        },
-        [CoreEdgeType.CALLS]: {
-            coreType: CoreEdgeType.CALLS,
-            sourceTypes: [CoreNodeType.METHOD_DECLARATION, CoreNodeType.FUNCTION_DECLARATION],
-            targetTypes: [CoreNodeType.METHOD_DECLARATION, CoreNodeType.FUNCTION_DECLARATION],
-            properties: [
-                {
-                    name: 'confidence',
-                    type: 'number',
-                    extraction: { method: 'static', defaultValue: 0.8 },
-                    neo4j: { indexed: true, unique: false, required: true },
-                },
-                {
-                    name: 'source',
-                    type: 'string',
-                    extraction: { method: 'static', defaultValue: 'pattern' },
-                    neo4j: { indexed: true, unique: false, required: true },
-                },
-            ],
-            neo4j: {
-                relationshipType: 'CALLS',
-                direction: 'OUTGOING',
-            },
-        },
-    },
-};
-// ============================================================================
-// NESTJS FRAMEWORK SCHEMA
-// ============================================================================
-export const NESTJS_FRAMEWORK_SCHEMA = {
-    name: 'NestJS Framework Schema',
-    version: '2.0.0',
-    description: 'NestJS-specific enhancements with context-based properties',
-    enhances: [CoreNodeType.CLASS_DECLARATION, CoreNodeType.METHOD_DECLARATION],
-    enhancements: {
-        NestController: {
-            name: 'NestController',
-            targetCoreType: CoreNodeType.CLASS_DECLARATION,
-            semanticType: SemanticNodeType.NEST_CONTROLLER,
-            detectionPatterns: [
-                {
-                    type: 'decorator',
-                    pattern: 'Controller',
-                    confidence: 0.95,
-                    priority: 10,
-                },
-                {
-                    type: 'filename',
-                    pattern: /\.controller\.ts$/,
-                    confidence: 0.7,
-                    priority: 5,
-                },
-            ],
-            contextExtractors: [
-                {
-                    nodeType: CoreNodeType.CLASS_DECLARATION,
-                    semanticType: SemanticNodeType.NEST_CONTROLLER,
-                    extractor: (parsedNode) => {
-                        const node = parsedNode.sourceNode;
-                        if (!node)
-                            return {};
-                        return {
-                            basePath: extractControllerPath(node),
-                            endpointCount: countHttpEndpoints(node),
-                            hasGlobalGuards: hasDecorator(node, 'UseGuards'),
-                            hasGlobalPipes: hasDecorator(node, 'UsePipes'),
-                            hasGlobalInterceptors: hasDecorator(node, 'UseInterceptors'),
-                            version: extractVersion(node),
-                        };
-                    },
-                    priority: 1,
-                },
-            ],
-            additionalRelationships: [SemanticEdgeType.EXPOSES, SemanticEdgeType.INJECTS],
-            neo4j: {
-                additionalLabels: ['Controller', 'NestJS'],
-                primaryLabel: 'Controller',
-            },
-            priority: 90,
-        },
-        NestService: {
-            name: 'NestService',
-            targetCoreType: CoreNodeType.CLASS_DECLARATION,
-            semanticType: SemanticNodeType.NEST_SERVICE,
-            detectionPatterns: [
-                {
-                    type: 'filename',
-                    pattern: /\.service\.ts$/,
-                    confidence: 0.9,
-                    priority: 9,
-                },
-                {
-                    type: 'function',
-                    pattern: (node) => node.getName()?.endsWith('Service'),
-                    confidence: 0.7,
-                    priority: 7,
-                },
-            ],
-            contextExtractors: [
-                {
-                    nodeType: CoreNodeType.CLASS_DECLARATION,
-                    semanticType: SemanticNodeType.NEST_SERVICE,
-                    extractor: (parsedNode) => {
-                        const node = parsedNode.sourceNode;
-                        if (!node)
-                            return {};
-                        return {
-                            scope: extractScope(node),
-                            isAsync: hasAsyncMethods(node),
-                            dependencyCount: countConstructorParameters(node),
-                            injectionToken: extractInjectionToken(node),
-                        };
-                    },
-                    priority: 1,
-                },
-            ],
-            additionalRelationships: [SemanticEdgeType.PROVIDED_BY, SemanticEdgeType.MANAGES],
-            neo4j: {
-                additionalLabels: ['Service', 'NestJS'],
-                primaryLabel: 'Service',
-            },
-            priority: 80,
-        },
-        NestModule: {
-            name: 'NestModule',
-            targetCoreType: CoreNodeType.CLASS_DECLARATION,
-            semanticType: SemanticNodeType.NEST_MODULE,
-            detectionPatterns: [
-                {
-                    type: 'decorator',
-                    pattern: 'Module',
-                    confidence: 0.95,
-                    priority: 10,
-                },
-                {
-                    type: 'filename',
-                    pattern: /\.module\.ts$/,
-                    confidence: 0.8,
-                    priority: 7,
-                },
-            ],
-            contextExtractors: [
-                {
-                    nodeType: CoreNodeType.CLASS_DECLARATION,
-                    semanticType: SemanticNodeType.NEST_MODULE,
-                    extractor: (parsedNode) => {
-                        const node = parsedNode.sourceNode;
-                        if (!node)
-                            return {};
-                        return {
-                            isGlobal: hasDecorator(node, 'Global'),
-                            isDynamic: hasDynamicMethods(node),
-                            imports: extractModuleImports(node),
-                            providers: extractModuleProviders(node),
-                            controllers: extractModuleControllers(node),
-                            exports: extractModuleExports(node),
-                        };
-                    },
-                    priority: 1,
-                },
-            ],
-            additionalRelationships: [SemanticEdgeType.MODULE_IMPORTS, SemanticEdgeType.MODULE_PROVIDES],
-            neo4j: {
-                additionalLabels: ['Module', 'NestJS'],
-                primaryLabel: 'Module',
-            },
-            priority: 95,
-        },
-        MessageHandler: {
-            name: 'MessageHandler',
-            targetCoreType: CoreNodeType.METHOD_DECLARATION,
-            semanticType: SemanticNodeType.MESSAGE_HANDLER,
-            detectionPatterns: [
-                {
-                    type: 'function',
-                    pattern: (node) => {
-                        const decorators = node.getDecorators?.() ?? [];
-                        const messageDecorators = ['MessagePattern', 'EventPattern'];
-                        return decorators.some((d) => messageDecorators.includes(d.getName()));
-                    },
-                    confidence: 0.98,
-                    priority: 15,
-                },
-            ],
-            contextExtractors: [
-                {
-                    nodeType: CoreNodeType.METHOD_DECLARATION,
-                    semanticType: SemanticNodeType.MESSAGE_HANDLER,
-                    extractor: (parsedNode) => {
-                        const node = parsedNode.sourceNode;
-                        if (!node)
-                            return {};
-                        return {
-                            messageQueueName: extractMessagePattern(node),
-                            isAsync: node.isAsync(),
-                            returnType: node.getReturnTypeNode()?.getText() ?? 'void',
-                            pattern: getPatternType(node),
-                            hasAuth: hasAuthDecorators(node),
-                            hasValidation: hasValidationDecorators(node),
-                            guardNames: extractGuardNames(node),
-                            pipeNames: extractPipeNames(node),
-                            interceptorNames: extractInterceptorNames(node),
-                            endpointType: 'RPC',
-                        };
-                    },
-                    priority: 1,
-                },
-            ],
-            additionalRelationships: [
-                SemanticEdgeType.CONSUMES_MESSAGE,
-                SemanticEdgeType.RESPONDS_WITH,
-                SemanticEdgeType.GUARDED_BY,
-            ],
-            neo4j: {
-                additionalLabels: ['MessageHandler', 'NestJS', 'Microservice'],
-                primaryLabel: 'MessageHandler',
-            },
-            priority: 88,
-        },
-        HttpEndpoint: {
-            name: 'HttpEndpoint',
-            targetCoreType: CoreNodeType.METHOD_DECLARATION,
-            semanticType: SemanticNodeType.HTTP_ENDPOINT,
-            detectionPatterns: [
-                {
-                    type: 'function',
-                    pattern: (node) => {
-                        const decorators = node.getDecorators?.() ?? [];
-                        const httpDecorators = ['Get', 'Post', 'Put', 'Delete', 'Patch', 'Head', 'Options'];
-                        return decorators.some((d) => httpDecorators.includes(d.getName()));
-                    },
-                    confidence: 0.98,
-                    priority: 15,
-                },
-            ],
-            contextExtractors: [
-                {
-                    nodeType: CoreNodeType.METHOD_DECLARATION,
-                    semanticType: SemanticNodeType.HTTP_ENDPOINT,
-                    extractor: (parsedNode) => {
-                        const node = parsedNode.sourceNode;
-                        if (!node)
-                            return {};
-                        return {
-                            httpMethod: extractHttpMethod(node),
-                            path: extractRoutePath(node),
-                            fullPath: computeFullPath(node),
-                            statusCode: extractStatusCode(node),
-                            hasAuth: hasAuthDecorators(node),
-                            hasValidation: hasValidationDecorators(node),
-                            guardNames: extractGuardNames(node),
-                            pipeNames: extractPipeNames(node),
-                            interceptorNames: extractInterceptorNames(node),
-                        };
-                    },
-                    priority: 1,
-                },
-            ],
-            additionalRelationships: [SemanticEdgeType.ACCEPTS, SemanticEdgeType.RESPONDS_WITH, SemanticEdgeType.GUARDED_BY],
-            neo4j: {
-                additionalLabels: ['HttpEndpoint', 'NestJS'],
-                primaryLabel: 'HttpEndpoint',
-            },
-            priority: 85,
-        },
-        EntityClass: {
-            name: 'EntityClass',
-            targetCoreType: CoreNodeType.CLASS_DECLARATION,
-            semanticType: SemanticNodeType.ENTITY_CLASS,
-            detectionPatterns: [
-                {
-                    type: 'decorator',
-                    pattern: 'Entity',
-                    confidence: 0.95,
-                    priority: 10,
-                },
-                {
-                    type: 'filename',
-                    pattern: /\.entity\.ts$/,
-                    confidence: 0.8,
-                    priority: 7,
-                },
-            ],
-            contextExtractors: [
-                {
-                    nodeType: CoreNodeType.CLASS_DECLARATION,
-                    semanticType: SemanticNodeType.ENTITY_CLASS,
-                    extractor: (parsedNode) => {
-                        const node = parsedNode.sourceNode;
-                        if (!node)
-                            return {};
-                        return {
-                            tableName: extractTableName(node),
-                            columnCount: countColumns(node),
-                            hasRelations: hasRelationDecorators(node),
-                        };
-                    },
-                    priority: 1,
-                },
-            ],
-            additionalRelationships: [],
-            neo4j: {
-                additionalLabels: ['Entity', 'NestJS'],
-                primaryLabel: 'Entity',
-            },
-            priority: 80,
-        },
-        DTOClass: {
-            name: 'DTOClass',
-            targetCoreType: CoreNodeType.CLASS_DECLARATION,
-            semanticType: SemanticNodeType.DTO_CLASS,
-            detectionPatterns: [
-                {
-                    type: 'filename',
-                    pattern: /\.dto\.ts$/,
-                    confidence: 0.9,
-                    priority: 8,
-                },
-                {
-                    type: 'classname',
-                    pattern: /.*Dto$/,
-                    confidence: 0.7,
-                    priority: 6,
-                },
-            ],
-            contextExtractors: [
-                {
-                    nodeType: CoreNodeType.CLASS_DECLARATION,
-                    semanticType: SemanticNodeType.DTO_CLASS,
-                    extractor: (parsedNode) => {
-                        const node = parsedNode.sourceNode;
-                        if (!node)
-                            return {};
-                        return {
-                            validationDecorators: extractValidationDecorators(node),
-                            isRequestDto: node.getName()?.toLowerCase().includes('request') ?? false,
-                            isResponseDto: node.getName()?.toLowerCase().includes('response') || false,
-                            isPartialDto: extendsPartialType(node),
-                            baseClass: extractBaseClass(node),
-                        };
-                    },
-                    priority: 1,
-                },
-            ],
-            additionalRelationships: [SemanticEdgeType.VALIDATES],
-            neo4j: {
-                additionalLabels: ['DTO', 'NestJS'],
-                primaryLabel: 'DTO',
-            },
-            priority: 70,
-        },
-    },
-    edgeEnhancements: {
-        DependencyInjection: {
-            name: 'DependencyInjection',
-            semanticType: SemanticEdgeType.INJECTS,
-            detectionPattern: (parsedSourceNode, parsedTargetNode) => {
-                return detectDependencyInjection(parsedSourceNode, parsedTargetNode);
-            },
-            contextExtractor: (parsedSourceNode, parsedTargetNode) => ({
-                injectionType: 'constructor',
-                injectionToken: extractInjectionTokenFromRelation(parsedSourceNode, parsedTargetNode),
-                parameterIndex: findParameterIndex(parsedSourceNode, parsedTargetNode),
-            }),
-            neo4j: {
-                relationshipType: 'INJECTS',
-                direction: 'OUTGOING',
-            },
-        },
-        MessageHandlerExposure: {
-            name: 'MessageHandlerExposure',
-            semanticType: SemanticEdgeType.EXPOSES,
-            detectionPattern: (parsedSourceNode, parsedTargetNode) => {
-                if (parsedSourceNode.properties?.semanticType !== SemanticNodeType.NEST_CONTROLLER ||
-                    parsedTargetNode.properties?.semanticType !== SemanticNodeType.MESSAGE_HANDLER) {
-                    return false;
-                }
-                if (parsedSourceNode.properties?.filePath !== parsedTargetNode.properties?.filePath) {
-                    return false;
-                }
-                // Access AST nodes to check parent relationship
-                const sourceNode = parsedSourceNode.sourceNode;
-                const targetNode = parsedTargetNode.sourceNode;
-                if (sourceNode && targetNode) {
-                    const methodParent = targetNode.getParent();
-                    if (methodParent === sourceNode) {
-                        return true;
-                    }
-                }
-                return false;
-            },
-            contextExtractor: (parsedSourceNode, parsedTargetNode) => ({
-                endpointType: 'RPC',
-            }),
-            neo4j: {
-                relationshipType: 'EXPOSES',
-                direction: 'OUTGOING',
-            },
-        },
-        HttpEndpointExposure: {
-            name: 'HttpEndpointExposure',
-            semanticType: SemanticEdgeType.EXPOSES,
-            detectionPattern: (parsedSourceNode, parsedTargetNode) => {
-                // Check if source is controller and target is HTTP endpoint
-                if (parsedSourceNode.properties?.semanticType !== SemanticNodeType.NEST_CONTROLLER ||
-                    parsedTargetNode.properties?.semanticType !== SemanticNodeType.HTTP_ENDPOINT) {
-                    return false;
-                }
-                if (parsedSourceNode.properties?.filePath !== parsedTargetNode.properties?.filePath) {
-                    return false;
-                }
-                // Access AST nodes to check parent relationship
-                const sourceNode = parsedSourceNode.sourceNode;
-                const targetNode = parsedTargetNode.sourceNode;
-                if (sourceNode && targetNode) {
-                    const methodParent = targetNode.getParent();
-                    if (methodParent === sourceNode) {
-                        return true;
-                    }
-                }
-                return false;
-            },
-            contextExtractor: (parsedSourceNode, parsedTargetNode) => ({
-                httpMethod: parsedTargetNode.properties?.context?.httpMethod ?? '',
-                fullPath: computeFullPathFromNodes(parsedSourceNode, parsedTargetNode),
-                statusCode: parsedTargetNode.properties?.context?.statusCode ?? 200,
-            }),
-            neo4j: {
-                relationshipType: 'EXPOSES',
-                direction: 'OUTGOING',
-            },
-        },
-    },
-    contextExtractors: [
-        {
-            nodeType: CoreNodeType.SOURCE_FILE,
-            extractor: (parsedNode) => {
-                const node = parsedNode.sourceNode;
-                if (!node)
-                    return {};
-                return {
-                    extension: node.getFilePath().substring(node.getFilePath().lastIndexOf('.')),
-                    relativePath: extractRelativePath(node),
-                    isTestFile: /\.(test|spec)\./.test(node.getFilePath()),
-                    isDeclarationFile: node.getFilePath().endsWith('.d.ts'),
-                    moduleKind: 'ES6',
-                    importCount: node.getImportDeclarations().length,
-                    exportCount: node.getExportDeclarations().length,
-                    declarationCount: countDeclarations({ node }),
-                };
-            },
-            priority: 1,
-        },
-        {
-            nodeType: CoreNodeType.CLASS_DECLARATION,
-            extractor: (parsedNode) => {
-                const node = parsedNode.sourceNode;
-                if (!node)
-                    return {};
-                return {
-                    isAbstract: node.getAbstractKeyword() != null,
-                    isDefaultExport: node.isDefaultExport(),
-                    extendsClause: node.getExtends()?.getText(),
-                    implementsClauses: node.getImplements().map((i) => i.getText()),
-                    decoratorNames: node.getDecorators().map((d) => d.getName()),
-                    methodCount: node.getMethods().length,
-                    propertyCount: node.getProperties().length,
-                    constructorParameterCount: countConstructorParameters(node),
-                };
-            },
-            priority: 1,
-        },
-        {
-            nodeType: CoreNodeType.METHOD_DECLARATION,
-            extractor: (parsedNode) => {
-                const node = parsedNode.sourceNode;
-                if (!node)
-                    return {};
-                return {
-                    isStatic: node.isStatic(),
-                    isAsync: node.isAsync(),
-                    isAbstract: node.isAbstract(),
-                    returnType: node.getReturnTypeNode()?.getText() || 'void',
-                    parameterCount: node.getParameters().length,
-                    decoratorNames: node.getDecorators().map((d) => d.getName()),
-                    isGetter: node.getKind() === 177,
-                    isSetter: node.getKind() === 178,
-                    overloadCount: 1, // Simplified
-                };
-            },
-            priority: 1,
-        },
-        {
-            nodeType: CoreNodeType.PROPERTY_DECLARATION,
-            extractor: (parsedNode) => {
-                const node = parsedNode.sourceNode;
-                if (!node)
-                    return {};
-                return {
-                    isStatic: node.isStatic(),
-                    isReadonly: node.isReadonly(),
-                    type: node.getTypeNode()?.getText() || 'any',
-                    hasInitializer: node.hasInitializer(),
-                    decoratorNames: node.getDecorators().map((d) => d.getName()),
-                    isOptional: node.hasQuestionToken(),
-                };
-            },
-            priority: 1,
-        },
-        {
-            nodeType: CoreNodeType.PARAMETER_DECLARATION,
-            extractor: (parsedNode) => {
-                const node = parsedNode.sourceNode;
-                if (!node)
-                    return {};
-                return {
-                    type: node.getTypeNode()?.getText() || 'any',
-                    isOptional: node.hasQuestionToken(),
-                    isRestParameter: node.isRestParameter(),
-                    hasDefaultValue: node.hasInitializer(),
-                    decoratorNames: node.getDecorators().map((d) => d.getName()),
-                    parameterIndex: node.getChildIndex(),
-                };
-            },
-            priority: 1,
-        },
-        {
-            nodeType: CoreNodeType.IMPORT_DECLARATION,
-            extractor: (parsedNode) => {
-                const node = parsedNode.sourceNode;
-                if (!node)
-                    return {};
-                return {
-                    moduleSpecifier: node.getModuleSpecifierValue(),
-                    isTypeOnly: node.isTypeOnly(),
-                    importKind: determineImportKind(node),
-                    namedImports: node.getNamedImports().map((ni) => ni.getName()),
-                    defaultImport: node.getDefaultImport()?.getText() || null,
-                    namespaceImport: node.getNamespaceImport()?.getText() || null,
-                };
-            },
-            priority: 1,
-        },
-        {
-            nodeType: CoreNodeType.DECORATOR,
-            extractor: (parsedNode) => {
-                const node = parsedNode.sourceNode;
-                if (!node)
-                    return {};
-                return {
-                    arguments: node.getArguments().map((arg) => arg.getText()),
-                    target: determineDecoratorTarget(node),
-                };
-            },
-            priority: 1,
-        },
-    ],
-    metadata: {
-        targetLanguages: ['typescript'],
-        dependencies: ['@nestjs/core', '@nestjs/common'],
-    },
-};
-// ============================================================================
-// HELPER FUNCTIONS
-// ============================================================================
-function extractMessagePattern(node) {
-    // Check for @EventPattern first
-    let decorator = node.getDecorator('EventPattern');
-    // Check for @MessagePattern
-    decorator ??= node.getDecorator('MessagePattern');
-    if (!decorator)
-        return '';
-    const args = decorator.getArguments();
-    if (args.length === 0)
-        return '';
-    // Get the raw text of the first argument
-    const rawPattern = args[0].getText();
-    return rawPattern;
-}
-function getPatternType(node) {
-    if (node.getDecorator('EventPattern'))
-        return 'event';
-    if (node.getDecorator('MessagePattern'))
-        return 'message';
-    return 'event'; // default
-}
-function extractControllerPath(node) {
-    const decorator = node.getDecorator('Controller');
-    if (!decorator)
-        return '';
-    const args = decorator.getArguments();
-    return args.length > 0 ? `/${args[0].getText().replace(/['"]/g, '')}` : '';
-}
-function countHttpEndpoints(node) {
-    const methods = node.getMethods();
-    const httpDecorators = ['Get', 'Post', 'Put', 'Delete', 'Patch', 'Head', 'Options'];
-    return methods.filter((method) => {
-        const decorators = method.getDecorators();
-        return decorators.some((d) => httpDecorators.includes(d.getName()));
-    }).length;
-}
-function hasDecorator(node, decoratorName) {
-    const decorators = node.getDecorators();
-    return decorators.some((d) => d.getName() === decoratorName);
-}
-function extractVersion(node) {
-    const decorator = node.getDecorator('Version');
-    if (!decorator)
-        return null;
-    const args = decorator.getArguments();
-    return args.length > 0 ? args[0].getText().replace(/['"]/g, '') : null;
-}
-function extractScope(node) {
-    const decorator = node.getDecorator('Injectable');
-    if (!decorator)
-        return 'DEFAULT';
-    const args = decorator.getArguments();
-    if (args.length === 0)
-        return 'DEFAULT';
-    const argText = args[0].getText();
-    if (argText.includes('REQUEST'))
-        return 'REQUEST';
-    if (argText.includes('TRANSIENT'))
-        return 'TRANSIENT';
-    return 'DEFAULT';
-}
-function hasAsyncMethods(node) {
-    const methods = node.getMethods();
-    return methods.some((method) => method.isAsync?.());
-}
-function countConstructorParameters(node) {
-    const constructors = node.getConstructors();
-    return constructors.length > 0 ? constructors[0].getParameters().length : 0;
-}
-function extractInjectionToken(node) {
-    const decorator = node.getDecorator('Injectable');
-    if (!decorator)
-        return null;
-    const args = decorator.getArguments();
-    if (args.length > 0 && args[0].getText().startsWith("'")) {
-        return args[0].getText().replace(/['"]/g, '');
-    }
-    return null;
-}
-function hasDynamicMethods(node) {
-    const methods = node.getMethods();
-    const dynamicMethods = ['forRoot', 'forFeature', 'forRootAsync', 'forFeatureAsync'];
-    return methods.some((method) => {
-        return method.isStatic?.() && dynamicMethods.includes(method.getName());
-    });
-}
-function extractModuleImports(node) {
-    return extractModuleArrayProperty(node, 'imports');
-}
-function extractModuleProviders(node) {
-    return extractModuleArrayProperty(node, 'providers');
-}
-function extractModuleControllers(node) {
-    return extractModuleArrayProperty(node, 'controllers');
-}
-function extractModuleExports(node) {
-    return extractModuleArrayProperty(node, 'exports');
-}
-function extractModuleArrayProperty(node, propertyName) {
-    const decorator = node.getDecorator('Module');
-    if (!decorator)
-        return [];
-    const args = decorator.getArguments();
-    if (args.length === 0)
-        return [];
-    const configText = args[0].getText();
-    const regex = new RegExp(`${propertyName}\\s*:\\s*\\[([^\\]]+)\\]`);
-    const match = configText.match(regex);
-    if (!match)
-        return [];
-    return match[1]
-        .split(',')
-        .map((item) => item.trim().replace(/['"]/g, ''))
-        .filter((item) => item.length > 0);
-}
-function extractHttpMethod(node) {
-    const decorators = node.getDecorators();
-    const httpDecorators = ['Get', 'Post', 'Put', 'Delete', 'Patch', 'Head', 'Options'];
-    const httpDecorator = decorators.find((d) => httpDecorators.includes(d.getName()));
-    return httpDecorator ? httpDecorator.getName().toUpperCase() : '';
-}
-function extractRoutePath(node) {
-    const decorators = node.getDecorators();
-    const httpDecorators = ['Get', 'Post', 'Put', 'Delete', 'Patch', 'Head', 'Options'];
-    const httpDecorator = decorators.find((d) => httpDecorators.includes(d.getName()));
-    if (!httpDecorator)
-        return '';
-    const args = httpDecorator.getArguments();
-    return args.length > 0 ? args[0].getText().replace(/['"]/g, '') : '';
-}
-function computeFullPath(node) {
-    const methodPath = extractRoutePath(node);
-    // Get the parent controller's base path
-    const parentClass = node.getParent();
-    const controllerPath = extractControllerPath(parentClass);
-    // Combine paths properly
-    const fullPath = `${controllerPath}/${methodPath}`.replace(/\/+/g, '/').replace(/\/$/, '') || '/';
-    return fullPath;
-}
-function extractStatusCode(node) {
-    const decorator = node.getDecorator('HttpCode');
-    if (!decorator)
-        return null;
-    const args = decorator.getArguments();
-    if (args.length > 0) {
-        const status = parseInt(args[0].getText());
-        return isNaN(status) ? null : status;
-    }
-    return null;
-}
-function hasAuthDecorators(node) {
-    const decorators = node.getDecorators();
-    const authDecorators = ['UseGuards', 'Auth', 'Roles', 'Public'];
-    return decorators.some((d) => authDecorators.includes(d.getName()));
-}
-function hasValidationDecorators(node) {
-    const decorators = node.getDecorators();
-    const validationDecorators = ['UsePipes', 'ValidationPipe'];
-    return decorators.some((d) => validationDecorators.includes(d.getName()));
-}
-function extractGuardNames(node) {
-    return extractDecoratorArguments(node, 'UseGuards');
-}
-function extractPipeNames(node) {
-    return extractDecoratorArguments(node, 'UsePipes');
-}
-function extractInterceptorNames(node) {
-    return extractDecoratorArguments(node, 'UseInterceptors');
-}
-function extractDecoratorArguments(node, decoratorName) {
-    const decorator = node.getDecorator(decoratorName);
-    if (!decorator)
-        return [];
-    const args = decorator.getArguments();
-    return args.map((arg) => arg.getText().replace(/[(),]/g, '').trim()).filter((name) => name.length > 0);
-}
-function extractTableName(node) {
-    const decorator = node.getDecorator('Entity');
-    if (!decorator)
-        return null;
-    const args = decorator.getArguments();
-    return args.length > 0 ? args[0].getText().replace(/['"]/g, '') : null;
-}
-function countColumns(node) {
-    const properties = node.getProperties();
-    return properties.filter((prop) => {
-        const decorators = prop.getDecorators();
-        return decorators.some((d) => ['Column', 'PrimaryGeneratedColumn'].includes(d.getName()));
-    }).length;
-}
-function hasRelationDecorators(node) {
-    const properties = node.getProperties();
-    const relationDecorators = ['OneToOne', 'OneToMany', 'ManyToOne', 'ManyToMany'];
-    return properties.some((prop) => {
-        const decorators = prop.getDecorators();
-        return decorators.some((d) => relationDecorators.includes(d.getName()));
-    });
-}
-function extractValidationDecorators(node) {
-    const properties = node.getProperties();
-    const validationDecorators = [];
-    const commonValidators = [
-        'IsString',
-        'IsNumber',
-        'IsEmail',
-        'IsOptional',
-        'IsNotEmpty',
-        'MinLength',
-        'MaxLength',
-        'IsArray',
-        'IsBoolean',
-        'IsDate',
-        'IsEnum',
-        'IsUUID',
-        'IsUrl',
-        'Min',
-        'Max',
-        'Matches',
-        'IsIn',
-        'IsNotIn',
-        'IsDefined',
-        'ValidateNested',
-    ];
-    properties.forEach((prop) => {
-        const decorators = prop.getDecorators();
-        decorators.forEach((decorator) => {
-            const name = decorator.getName();
-            if (commonValidators.includes(name)) {
-                validationDecorators.push(name);
-            }
-        });
-    });
-    return [...new Set(validationDecorators)];
-}
-function extendsPartialType(node) {
-    const baseClass = node.getBaseClass();
-    return baseClass ? baseClass.getText().includes('PartialType') : false;
-}
-function extractBaseClass(node) {
-    const baseClass = node.getBaseClass();
-    return baseClass ? baseClass.getText() : null;
-}
-function detectDependencyInjection(sourceNode, targetNode) {
-    if (sourceNode.properties?.coreType !== CoreNodeType.CLASS_DECLARATION)
-        return false;
-    if (targetNode.properties?.coreType !== CoreNodeType.CLASS_DECLARATION)
-        return false;
-    const constructors = sourceNode.sourceNode?.getConstructors();
-    if (!constructors || constructors.length === 0)
-        return false;
-    const constructor = constructors[0];
-    const parameters = constructor.getParameters();
-    const targetName = targetNode.properties?.name;
-    return parameters.some((param) => {
-        const paramType = param.getTypeNode()?.getText();
-        if (paramType === targetName)
-            return true;
-        const decorators = param.getDecorators();
-        return decorators.some((decorator) => {
-            if (decorator.getName() === 'Inject') {
-                const args = decorator.getArguments();
-                if (args.length > 0) {
-                    const token = args[0].getText().replace(/['"]/g, '');
-                    return token === targetName;
-                }
-            }
-            return false;
-        });
-    });
-}
-function extractInjectionTokenFromRelation(sourceNode, targetNode) {
-    const constructors = sourceNode.sourceNode?.getConstructors();
-    if (!constructors || constructors.length === 0)
-        return null;
-    const constructor = constructors[0];
-    const parameters = constructor.getParameters();
-    for (const param of parameters) {
-        const decorators = param.getDecorators();
-        for (const decorator of decorators) {
-            if (decorator.getName() === 'Inject') {
-                const args = decorator.getArguments();
-                if (args.length > 0) {
-                    return args[0].getText().replace(/['"]/g, '');
-                }
-            }
-        }
-    }
-    return null;
-}
-function findParameterIndex(sourceNode, targetNode) {
-    const constructors = sourceNode.sourceNode?.getConstructors();
-    if (!constructors || constructors.length === 0)
-        return 0;
-    const constructor = constructors[0];
-    const parameters = constructor.getParameters();
-    const targetName = targetNode.properties?.name;
-    return parameters.findIndex((param) => {
-        const paramType = param.getTypeNode()?.getText();
-        return paramType === targetName;
-    });
-}
-function computeFullPathFromNodes(sourceNode, targetNode) {
-    const basePath = sourceNode.properties?.context?.basePath ?? '';
-    const methodPath = targetNode.properties?.context?.path ?? '';
-    // Properly combine paths
-    const fullPath = `${basePath}/${methodPath}`.replace(/\/+/g, '/').replace(/\/$/, '') || '/';
-    return fullPath;
-}
-function extractRelativePath(node) {
-    const filePath = node.getFilePath();
-    const parts = filePath.split('/');
-    return parts.slice(-3).join('/');
-}
-function countDeclarations({ node }) {
-    return node.getClasses().length + node.getInterfaces().length + node.getFunctions().length + node.getEnums().length;
-}
-function determineImportKind(node) {
-    if (node.getDefaultImport())
-        return 'default';
-    if (node.getNamespaceImport())
-        return 'namespace';
-    if (node.getNamedImports().length > 0)
-        return 'named';
-    return 'side-effect';
-}
-function determineDecoratorTarget(node) {
-    const parent = node.getParent();
-    if (!parent)
-        return 'unknown';
-    const kind = parent.getKind();
-    if (kind === 262)
-        return 'class'; // ClassDeclaration
-    if (kind === 172)
-        return 'method'; // MethodDeclaration
-    if (kind === 171)
-        return 'property'; // PropertyDeclaration
-    if (kind === 169)
-        return 'parameter'; // Parameter
-    return 'unknown';
-}
-export const DEFAULT_PARSE_OPTIONS = {
-    includePatterns: ['**/*.ts', '**/*.tsx'],
-    excludePatterns: ['node_modules/', 'dist/', 'coverage/', '.d.ts', '.spec.ts', '.test.ts'],
-    maxFiles: 1000,
-    coreSchema: CORE_TYPESCRIPT_SCHEMA,
-    frameworkSchemas: [],
-};
-export const NESTJS_PARSE_OPTIONS = {
-    ...DEFAULT_PARSE_OPTIONS,
-    frameworkSchemas: [NESTJS_FRAMEWORK_SCHEMA],
-};