code-graph-context 0.1.0

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

@@ -0,0 +1,1595 @@
+/* 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],
+};