code-graph-context 0.1.0

package/dist/core/config/schema.js

@@ -0,0 +1,799 @@
+/* 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',
+    // AST Getters Map - single source of truth
+    astGetters: {
+        [CoreNodeType.SOURCE_FILE]: 'self', // Special case - entry point
+        [CoreNodeType.CLASS_DECLARATION]: 'getClasses',
+        [CoreNodeType.METHOD_DECLARATION]: 'getMethods',
+        [CoreNodeType.PROPERTY_DECLARATION]: 'getProperties',
+        [CoreNodeType.PARAMETER_DECLARATION]: 'getParameters',
+        [CoreNodeType.DECORATOR]: 'getDecorators',
+        [CoreNodeType.INTERFACE_DECLARATION]: 'getInterfaces',
+        [CoreNodeType.FUNCTION_DECLARATION]: 'getFunctions',
+        [CoreNodeType.IMPORT_DECLARATION]: 'getImportDeclarations',
+        [CoreNodeType.VARIABLE_DECLARATION]: 'getDeclarations', // Called on VariableStatement
+        [CoreNodeType.ENUM_DECLARATION]: 'getEnums',
+        [CoreNodeType.CONSTRUCTOR_DECLARATION]: 'getConstructors',
+        [CoreNodeType.EXPORT_DECLARATION]: 'getExportDeclarations',
+    },
+    nodeTypes: {
+        [CoreNodeType.SOURCE_FILE]: {
+            coreType: CoreNodeType.SOURCE_FILE,
+            astNodeKind: 311,
+            astGetter: 'self',
+            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: [], // SourceFile doesn't have reference relationships, only containment
+            children: {
+                [CoreNodeType.CLASS_DECLARATION]: CoreEdgeType.CONTAINS,
+                [CoreNodeType.INTERFACE_DECLARATION]: CoreEdgeType.CONTAINS,
+                [CoreNodeType.FUNCTION_DECLARATION]: CoreEdgeType.CONTAINS,
+                [CoreNodeType.IMPORT_DECLARATION]: CoreEdgeType.CONTAINS,
+                [CoreNodeType.ENUM_DECLARATION]: CoreEdgeType.CONTAINS,
+            },
+            neo4j: {
+                labels: ['SourceFile', 'TypeScript'],
+                primaryLabel: 'SourceFile',
+                indexed: ['name', 'filePath', 'isExported'],
+                skipEmbedding: true,
+            },
+        },
+        [CoreNodeType.CLASS_DECLARATION]: {
+            coreType: CoreNodeType.CLASS_DECLARATION,
+            astNodeKind: 262,
+            astGetter: 'getClasses',
+            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: [
+                {
+                    edgeType: CoreEdgeType.EXTENDS,
+                    method: 'getBaseClass',
+                    cardinality: 'single',
+                    targetNodeType: CoreNodeType.CLASS_DECLARATION,
+                },
+                {
+                    edgeType: CoreEdgeType.IMPLEMENTS,
+                    method: 'getImplements',
+                    cardinality: 'array',
+                    targetNodeType: CoreNodeType.INTERFACE_DECLARATION,
+                },
+            ],
+            children: {
+                [CoreNodeType.METHOD_DECLARATION]: CoreEdgeType.HAS_MEMBER,
+                [CoreNodeType.PROPERTY_DECLARATION]: CoreEdgeType.HAS_MEMBER,
+                [CoreNodeType.CONSTRUCTOR_DECLARATION]: CoreEdgeType.HAS_MEMBER,
+                [CoreNodeType.DECORATOR]: CoreEdgeType.DECORATED_WITH,
+            },
+            neo4j: {
+                labels: ['Class', 'TypeScript'],
+                primaryLabel: 'Class',
+                indexed: ['name', 'isExported', 'visibility'],
+            },
+        },
+        [CoreNodeType.METHOD_DECLARATION]: {
+            coreType: CoreNodeType.METHOD_DECLARATION,
+            astNodeKind: 172,
+            astGetter: 'getMethods',
+            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: [], // CALLS would need call-site analysis, not implemented yet
+            children: {
+                [CoreNodeType.PARAMETER_DECLARATION]: CoreEdgeType.HAS_PARAMETER,
+                [CoreNodeType.DECORATOR]: CoreEdgeType.DECORATED_WITH,
+            },
+            neo4j: {
+                labels: ['Method', 'TypeScript'],
+                primaryLabel: 'Method',
+                indexed: ['name', 'visibility'],
+            },
+        },
+        [CoreNodeType.PROPERTY_DECLARATION]: {
+            coreType: CoreNodeType.PROPERTY_DECLARATION,
+            astNodeKind: 171,
+            astGetter: 'getProperties',
+            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: [], // TYPED_AS would need type resolution, not implemented yet
+            children: {
+                [CoreNodeType.DECORATOR]: CoreEdgeType.DECORATED_WITH,
+            },
+            neo4j: {
+                labels: ['Property', 'TypeScript'],
+                primaryLabel: 'Property',
+                indexed: ['name', 'visibility'],
+                skipEmbedding: true,
+            },
+        },
+        [CoreNodeType.PARAMETER_DECLARATION]: {
+            coreType: CoreNodeType.PARAMETER_DECLARATION,
+            astNodeKind: 169,
+            astGetter: 'getParameters',
+            properties: [
+                {
+                    name: 'name',
+                    type: 'string',
+                    extraction: { method: 'ast', source: 'getName' },
+                    neo4j: { indexed: true, unique: false, required: true },
+                },
+            ],
+            relationships: [], // TYPED_AS would need type resolution, not implemented yet
+            children: {
+                [CoreNodeType.DECORATOR]: CoreEdgeType.DECORATED_WITH,
+            },
+            neo4j: {
+                labels: ['Parameter', 'TypeScript'],
+                primaryLabel: 'Parameter',
+                indexed: ['name'],
+                skipEmbedding: true,
+            },
+        },
+        [CoreNodeType.IMPORT_DECLARATION]: {
+            coreType: CoreNodeType.IMPORT_DECLARATION,
+            astNodeKind: 272,
+            astGetter: 'getImportDeclarations',
+            properties: [
+                {
+                    name: 'name',
+                    type: 'string',
+                    extraction: { method: 'ast', source: 'getModuleSpecifierValue' },
+                    neo4j: { indexed: true, unique: false, required: true },
+                },
+            ],
+            relationships: [], // IMPORTS to SourceFile would need module resolution
+            children: {},
+            neo4j: {
+                labels: ['Import', 'TypeScript'],
+                primaryLabel: 'Import',
+                indexed: ['name'],
+                skipEmbedding: true,
+            },
+        },
+        [CoreNodeType.DECORATOR]: {
+            coreType: CoreNodeType.DECORATOR,
+            astNodeKind: 170,
+            astGetter: 'getDecorators',
+            properties: [
+                {
+                    name: 'name',
+                    type: 'string',
+                    extraction: { method: 'ast', source: 'getName' },
+                    neo4j: { indexed: true, unique: false, required: true },
+                },
+            ],
+            relationships: [],
+            children: {},
+            neo4j: {
+                labels: ['Decorator'],
+                primaryLabel: 'Decorator',
+                indexed: ['name'],
+                skipEmbedding: true,
+            },
+        },
+        [CoreNodeType.INTERFACE_DECLARATION]: {
+            coreType: CoreNodeType.INTERFACE_DECLARATION,
+            astNodeKind: 263,
+            astGetter: 'getInterfaces',
+            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: [
+                {
+                    edgeType: CoreEdgeType.EXTENDS,
+                    method: 'getExtends',
+                    cardinality: 'array',
+                    targetNodeType: CoreNodeType.INTERFACE_DECLARATION,
+                },
+            ],
+            children: {},
+            neo4j: {
+                labels: ['Interface', 'TypeScript'],
+                primaryLabel: 'Interface',
+                indexed: ['name', 'isExported'],
+            },
+        },
+        [CoreNodeType.ENUM_DECLARATION]: {
+            coreType: CoreNodeType.ENUM_DECLARATION,
+            astNodeKind: 264,
+            astGetter: 'getEnums',
+            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: [],
+            children: {},
+            neo4j: {
+                labels: ['Enum', 'TypeScript'],
+                primaryLabel: 'Enum',
+                indexed: ['name', 'isExported'],
+                skipEmbedding: true,
+            },
+        },
+        [CoreNodeType.FUNCTION_DECLARATION]: {
+            coreType: CoreNodeType.FUNCTION_DECLARATION,
+            astNodeKind: 261,
+            astGetter: 'getFunctions',
+            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: [], // CALLS would need call-site analysis, not implemented yet
+            children: {
+                [CoreNodeType.PARAMETER_DECLARATION]: CoreEdgeType.HAS_PARAMETER,
+            },
+            neo4j: {
+                labels: ['Function', 'TypeScript'],
+                primaryLabel: 'Function',
+                indexed: ['name', 'isExported'],
+            },
+        },
+        [CoreNodeType.VARIABLE_DECLARATION]: {
+            coreType: CoreNodeType.VARIABLE_DECLARATION,
+            astNodeKind: 258,
+            astGetter: 'getDeclarations',
+            properties: [
+                {
+                    name: 'name',
+                    type: 'string',
+                    extraction: { method: 'ast', source: 'getName' },
+                    neo4j: { indexed: true, unique: false, required: true },
+                },
+            ],
+            relationships: [],
+            children: {},
+            neo4j: {
+                labels: ['Variable', 'TypeScript'],
+                primaryLabel: 'Variable',
+                indexed: ['name'],
+                skipEmbedding: true,
+            },
+        },
+        [CoreNodeType.CONSTRUCTOR_DECLARATION]: {
+            coreType: CoreNodeType.CONSTRUCTOR_DECLARATION,
+            astNodeKind: 175,
+            astGetter: 'getConstructors',
+            properties: [
+                {
+                    name: 'name',
+                    type: 'string',
+                    extraction: { method: 'static', defaultValue: 'constructor' },
+                    neo4j: { indexed: true, unique: false, required: true },
+                },
+            ],
+            relationships: [], // Parameters are handled via children, not relationship extractors
+            children: {
+                [CoreNodeType.PARAMETER_DECLARATION]: CoreEdgeType.HAS_PARAMETER,
+            },
+            neo4j: {
+                labels: ['Constructor', 'TypeScript'],
+                primaryLabel: 'Constructor',
+                indexed: ['name'],
+                skipEmbedding: true,
+            },
+        },
+        [CoreNodeType.EXPORT_DECLARATION]: {
+            coreType: CoreNodeType.EXPORT_DECLARATION,
+            astNodeKind: 273,
+            astGetter: 'getExportDeclarations',
+            properties: [
+                {
+                    name: 'name',
+                    type: 'string',
+                    extraction: { method: 'static', defaultValue: 'export' },
+                    neo4j: { indexed: true, unique: false, required: true },
+                },
+            ],
+            relationships: [],
+            children: {},
+            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 },
+                },
+            ],
+            relationshipWeight: 0.4, // Structural - useful but not primary focus
+            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 },
+                },
+            ],
+            relationshipWeight: 0.6, // Medium - important for understanding class structure
+            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 },
+                },
+            ],
+            relationshipWeight: 0.35, // Low - rarely primary traversal target
+            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 },
+                },
+            ],
+            relationshipWeight: 0.3, // Low - metadata, not code flow
+            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 },
+                },
+            ],
+            relationshipWeight: 0.55, // Medium - useful for dependency tracing
+            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 },
+                },
+            ],
+            relationshipWeight: 0.5, // Medium - public API surface
+            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 },
+                },
+            ],
+            relationshipWeight: 0.85, // High - inheritance is critical for understanding
+            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 },
+                },
+            ],
+            relationshipWeight: 0.75, // High - contract relationships are important
+            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 },
+                },
+            ],
+            relationshipWeight: 0.5, // Medium - type info useful but not primary
+            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 },
+                },
+            ],
+            relationshipWeight: 0.85, // Critical - execution flow is primary
+            neo4j: {
+                relationshipType: 'CALLS',
+                direction: 'OUTGOING',
+            },
+        },
+    },
+};
+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: [],
+};