code-graph-context 2.4.4 → 2.5.0

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

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

package/dist/core/utils/edge-factory.js

@@ -1,37 +0,0 @@
-/**
- * Edge Factory
- * Shared utilities for creating framework edges with consistent ID generation and properties
- */
-import crypto from 'crypto';
-/**
- * Generate a deterministic edge ID based on semantic type, source, and target.
- * Uses SHA256 hash truncated to 16 characters for uniqueness.
- */
-export const generateFrameworkEdgeId = (semanticType, sourceNodeId, targetNodeId) => {
-    const edgeIdentity = `${semanticType}::${sourceNodeId}::${targetNodeId}`;
-    const edgeHash = crypto.createHash('sha256').update(edgeIdentity).digest('hex').substring(0, 16);
-    return `${semanticType}:${edgeHash}`;
-};
-/**
- * Create framework edge ID and properties.
- * Returns common edge data that can be used to construct either ParsedEdge or Neo4jEdge.
- *
- * @param params - Edge parameters
- * @returns Edge ID and properties object
- */
-export const createFrameworkEdgeData = (params) => {
-    const { semanticType, sourceNodeId, targetNodeId, projectId, context = {}, relationshipWeight = 0.5 } = params;
-    const id = generateFrameworkEdgeId(semanticType, sourceNodeId, targetNodeId);
-    const properties = {
-        coreType: semanticType,
-        projectId,
-        semanticType,
-        source: 'pattern',
-        confidence: 0.8,
-        relationshipWeight,
-        filePath: '',
-        createdAt: new Date().toISOString(),
-        context,
-    };
-    return { id, properties };
-};