code-graph-context 2.0.0 → 2.0.1

package/dist/core/config/nestjs-framework-schema.js

@@ -84,6 +84,38 @@ function extractInjectionToken(node) {
     }
     return null;
 }
+/**
+ * Extract constructor parameter types and @Inject tokens for edge detection.
+ * This allows INJECTS detection to work without AST access (for cross-chunk detection).
+ */
+function extractConstructorParamTypes(node) {
+    const types = [];
+    const injectTokens = new Map();
+    const constructors = node.getConstructors();
+    if (constructors.length === 0)
+        return { types, injectTokens };
+    const constructor = constructors[0];
+    const parameters = constructor.getParameters();
+    for (const param of parameters) {
+        const typeNode = param.getTypeNode();
+        if (typeNode) {
+            const typeName = typeNode.getText();
+            types.push(typeName);
+            // Check for @Inject decorator
+            const decorators = param.getDecorators();
+            for (const decorator of decorators) {
+                if (decorator.getName() === 'Inject') {
+                    const args = decorator.getArguments();
+                    if (args.length > 0) {
+                        const token = args[0].getText().replace(/['"]/g, '');
+                        injectTokens.set(typeName, token);
+                    }
+                }
+            }
+        }
+    }
+    return { types, injectTokens };
+}
 function hasDynamicMethods(node) {
     const methods = node.getMethods();
     const dynamicMethods = ['forRoot', 'forFeature', 'forRootAsync', 'forFeatureAsync'];
@@ -262,59 +294,39 @@ function detectDependencyInjection(sourceNode, targetNode) {
         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;
-        });
-    });
+    if (!targetName)
+        return false;
+    // Use pre-extracted constructor params from context (works after AST cleanup)
+    const constructorParamTypes = sourceNode.properties?.context?.constructorParamTypes ?? [];
+    const injectTokens = sourceNode.properties?.context?.injectTokens ?? {};
+    // Check if target is in constructor params by type
+    if (constructorParamTypes.includes(targetName))
+        return true;
+    // Check if target is referenced via @Inject token
+    return Object.values(injectTokens).includes(targetName);
 }
 function extractInjectionTokenFromRelation(sourceNode, targetNode) {
-    const constructors = sourceNode.sourceNode?.getConstructors();
-    if (!constructors || constructors.length === 0)
+    const targetName = targetNode.properties?.name;
+    if (!targetName)
         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, '');
-                }
-            }
+    // Use pre-extracted inject tokens from context (works after AST cleanup)
+    const injectTokens = sourceNode.properties?.context?.injectTokens ?? {};
+    // Find the token that maps to the target
+    for (const [typeName, token] of Object.entries(injectTokens)) {
+        if (token === targetName || typeName === targetName) {
+            return token;
         }
     }
     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;
-    });
+    if (!targetName)
+        return -1;
+    // Use pre-extracted constructor params from context (works after AST cleanup)
+    const constructorParamTypes = sourceNode.properties?.context?.constructorParamTypes ?? [];
+    return constructorParamTypes.indexOf(targetName);
 }
 function computeFullPathFromNodes(sourceNode, targetNode) {
     const basePath = sourceNode.properties?.context?.basePath ?? '';
@@ -791,6 +803,8 @@ export const NESTJS_FRAMEWORK_SCHEMA = {
                 const node = parsedNode.sourceNode;
                 if (!node)
                     return {};
+                // Extract constructor param types for INJECTS edge detection
+                const { types, injectTokens } = extractConstructorParamTypes(node);
                 return {
                     isAbstract: node.getAbstractKeyword() != null,
                     isDefaultExport: node.isDefaultExport(),
@@ -800,6 +814,9 @@ export const NESTJS_FRAMEWORK_SCHEMA = {
                     methodCount: node.getMethods().length,
                     propertyCount: node.getProperties().length,
                     constructorParameterCount: countConstructorParameters(node),
+                    // Pre-extracted for cross-chunk edge detection
+                    constructorParamTypes: types,
+                    injectTokens: Object.fromEntries(injectTokens),
                 };
             },
             priority: 1,

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

@@ -876,13 +876,12 @@ export class TypeScriptParser {
     }
     async applyEdgeEnhancement(edgeEnhancement) {
         try {
-            // Combine parsed nodes and existing nodes for target matching
-            // Sources must be parsed (have AST), targets can be either
+            // Combine parsed nodes and existing nodes for edge matching
+            // Detection patterns should use pre-extracted context, not raw AST
             const allTargetNodes = new Map([...this.parsedNodes, ...this.existingNodes]);
             for (const [sourceId, sourceNode] of this.parsedNodes) {
-                // Skip if source doesn't have AST (shouldn't happen for parsedNodes, but be safe)
-                if (!sourceNode.sourceNode)
-                    continue;
+                // Note: sourceNode.sourceNode may be undefined after AST cleanup
+                // Detection patterns should use pre-extracted context from node.properties.context
                 for (const [targetId, targetNode] of allTargetNodes) {
                     if (sourceId === targetId)
                         continue;

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

@@ -174,10 +174,11 @@ export class WorkspaceParser {
                 for (const [nodeId, parsedNode] of innerParsedNodes) {
                     this.accumulatedParsedNodes.set(nodeId, {
                         id: parsedNode.id,
+                        coreType: parsedNode.coreType, // Needed for detection patterns
                         semanticType: parsedNode.semanticType,
                         properties: {
                             name: parsedNode.properties.name,
-                            context: parsedNode.properties.context, // Contains propertyTypes
+                            context: parsedNode.properties.context, // Contains propertyTypes, dependencies
                         },
                     });
                 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "code-graph-context",
-  "version": "2.0.0",
+  "version": "2.0.1",
   "description": "MCP server that builds code graphs to provide rich context to LLMs",
   "type": "module",
   "homepage": "https://github.com/drewdrewH/code-graph-context#readme",