cpf/enhancement: Django ORM Pattern Resolution

sourcecode-parser/graph/callgraph/benchmark_test.go

@@ -339,18 +339,19 @@ func BenchmarkResolveCallTarget(b *testing.B) {
 	importMap.AddImport("helper", "myapp.helpers")
 
 	currentModule := "myapp.main"
+	codeGraph := &graph.CodeGraph{Nodes: make(map[string]*graph.Node)}
 
 	b.ResetTimer()
 	b.ReportAllocs()
 
 	for i := 0; i < b.N; i++ {
 		// Test simple attribute access (most common case)
-		_, _ = resolveCallTarget("utils.process_data", importMap, registry, currentModule)
+		_, _ = resolveCallTarget("utils.process_data", importMap, registry, currentModule, codeGraph)
 
 		// Test aliased import
-		_, _ = resolveCallTarget("helper.format", importMap, registry, currentModule)
+		_, _ = resolveCallTarget("helper.format", importMap, registry, currentModule, codeGraph)
 
 		// Test fully qualified name
-		_, _ = resolveCallTarget("myapp.utils.validate", importMap, registry, currentModule)
+		_, _ = resolveCallTarget("myapp.utils.validate", importMap, registry, currentModule, codeGraph)
 	}
 }

sourcecode-parser/graph/callgraph/builder.go

@@ -183,7 +183,7 @@ func BuildCallGraph(codeGraph *graph.CodeGraph, registry *ModuleRegistry, projec
 			}
 
 			// Resolve the call target to a fully qualified name
-			targetFQN, resolved := resolveCallTarget(callSite.Target, importMap, registry, modulePath)
+			targetFQN, resolved := resolveCallTarget(callSite.Target, importMap, registry, modulePath, codeGraph)
 
 			// Update call site with resolution information
 			callSite.TargetFQN = targetFQN
@@ -423,7 +423,7 @@ func categorizeResolutionFailure(target, targetFQN string) string {
 	return "unknown"
 }
 
-func resolveCallTarget(target string, importMap *ImportMap, registry *ModuleRegistry, currentModule string) (string, bool) {
+func resolveCallTarget(target string, importMap *ImportMap, registry *ModuleRegistry, currentModule string, codeGraph *graph.CodeGraph) (string, bool) {
 	// Handle self.method() calls - resolve to current module
 	if strings.HasPrefix(target, "self.") {
 		methodName := strings.TrimPrefix(target, "self.")
@@ -479,6 +479,10 @@ func resolveCallTarget(target string, importMap *ImportMap, registry *ModuleRegi
 		if isKnown, _ := IsKnownFramework(fullFQN); isKnown {
 			return fullFQN, true
 		}
+		// Check if it's an ORM pattern (before validateFQN, since ORM methods don't exist in source)
+		if ormFQN, resolved := ResolveORMCall(target, currentModule, registry, codeGraph); resolved {
+			return ormFQN, true
+		}
 		if validateFQN(fullFQN, registry) {
 			return fullFQN, true
 		}
@@ -492,6 +496,12 @@ func resolveCallTarget(target string, importMap *ImportMap, registry *ModuleRegi
 		return fullFQN, true
 	}
 
+	// Before giving up, check if it's an ORM pattern (Django, SQLAlchemy, etc.)
+	// ORM methods are dynamically generated at runtime and won't be in source
+	if ormFQN, resolved := ResolveORMCall(target, currentModule, registry, codeGraph); resolved {
+		return ormFQN, true
+	}
+
 	// Can't resolve - return as-is
 	return target, false
 }

sourcecode-parser/graph/callgraph/builder_framework_test.go

@@ -6,6 +6,7 @@ import (
 	"strings"
 	"testing"
 
+	"github.com/shivasurya/code-pathfinder/sourcecode-parser/graph"
 	"github.com/stretchr/testify/assert"
 )
 
@@ -63,28 +64,31 @@ def test_stdlib():
 	modulePath, ok := registry.FileToModule[testFile]
 	assert.True(t, ok)
 
+	// Create empty code graph for tests
+	codeGraph := &graph.CodeGraph{Nodes: make(map[string]*graph.Node)}
+
 	// Test Django models resolution
-	targetFQN, resolved := resolveCallTarget("models.User", importMap, registry, modulePath)
+	targetFQN, resolved := resolveCallTarget("models.User", importMap, registry, modulePath, codeGraph)
 	assert.True(t, resolved, "Django models.User should be resolved")
 	assert.Equal(t, "django.db.models.User", targetFQN)
 
 	// Test REST framework resolution
-	targetFQN, resolved = resolveCallTarget("serializers.ModelSerializer", importMap, registry, modulePath)
+	targetFQN, resolved = resolveCallTarget("serializers.ModelSerializer", importMap, registry, modulePath, codeGraph)
 	assert.True(t, resolved, "REST framework serializers should be resolved")
 	assert.Equal(t, "rest_framework.serializers.ModelSerializer", targetFQN)
 
 	// Test pytest resolution
-	targetFQN, resolved = resolveCallTarget("pytest.fixture", importMap, registry, modulePath)
+	targetFQN, resolved = resolveCallTarget("pytest.fixture", importMap, registry, modulePath, codeGraph)
 	assert.True(t, resolved, "pytest.fixture should be resolved")
 	assert.Equal(t, "pytest.fixture", targetFQN)
 
 	// Test json (stdlib) resolution
-	targetFQN, resolved = resolveCallTarget("json.loads", importMap, registry, modulePath)
+	targetFQN, resolved = resolveCallTarget("json.loads", importMap, registry, modulePath, codeGraph)
 	assert.True(t, resolved, "json.loads should be resolved")
 	assert.Equal(t, "json.loads", targetFQN)
 
 	// Test logging (stdlib) resolution
-	targetFQN, resolved = resolveCallTarget("logging.getLogger", importMap, registry, modulePath)
+	targetFQN, resolved = resolveCallTarget("logging.getLogger", importMap, registry, modulePath, codeGraph)
 	assert.True(t, resolved, "logging.getLogger should be resolved")
 	assert.Equal(t, "logging.getLogger", targetFQN)
 }
@@ -135,12 +139,15 @@ def process():
 	modulePath, ok := registry.FileToModule[testFile]
 	assert.True(t, ok)
 
+	// Create empty code graph for tests
+	codeGraph := &graph.CodeGraph{Nodes: make(map[string]*graph.Node)}
+
 	// Test local function resolution (should resolve to local module)
-	targetFQN, resolved := resolveCallTarget("sanitize", importMap, registry, modulePath)
+	targetFQN, resolved := resolveCallTarget("sanitize", importMap, registry, modulePath, codeGraph)
 	assert.True(t, resolved, "Local function sanitize should be resolved")
 	assert.Contains(t, targetFQN, "utils.sanitize")
 
-	targetFQN, resolved = resolveCallTarget("validate", importMap, registry, modulePath)
+	targetFQN, resolved = resolveCallTarget("validate", importMap, registry, modulePath, codeGraph)
 	assert.True(t, resolved, "Local function validate should be resolved")
 	assert.Contains(t, targetFQN, "utils.validate")
 }
@@ -186,8 +193,11 @@ def process():
 	modulePath, ok := registry.FileToModule[testFile]
 	assert.True(t, ok)
 
+	// Create empty code graph for tests
+	codeGraph := &graph.CodeGraph{Nodes: make(map[string]*graph.Node)}
+
 	// Test that local json takes precedence over stdlib
-	targetFQN, resolved := resolveCallTarget("loads", importMap, registry, modulePath)
+	targetFQN, resolved := resolveCallTarget("loads", importMap, registry, modulePath, codeGraph)
 	assert.True(t, resolved, "Local json.loads should be resolved")
 	// When there's a local module that shadows stdlib, it resolves to local
 	// The FQN will be json.loads but from the local module, not stdlib
@@ -243,13 +253,16 @@ def process():
 	modulePath, ok := registry.FileToModule[testFile]
 	assert.True(t, ok)
 
+	// Create empty code graph for tests
+	codeGraph := &graph.CodeGraph{Nodes: make(map[string]*graph.Node)}
+
 	// Test local function resolution
-	targetFQN, resolved := resolveCallTarget("helper", importMap, registry, modulePath)
+	targetFQN, resolved := resolveCallTarget("helper", importMap, registry, modulePath, codeGraph)
 	assert.True(t, resolved, "Local helper should be resolved")
 	assert.Contains(t, targetFQN, "utils.helper")
 
 	// Test framework resolution
-	targetFQN, resolved = resolveCallTarget("json.loads", importMap, registry, modulePath)
+	targetFQN, resolved = resolveCallTarget("json.loads", importMap, registry, modulePath, codeGraph)
 	assert.True(t, resolved, "json.loads should be resolved as framework")
 	assert.Equal(t, "json.loads", targetFQN)
 }

sourcecode-parser/graph/callgraph/builder_test.go

@@ -22,7 +22,8 @@ func TestResolveCallTarget_SimpleImportedFunction(t *testing.T) {
 	importMap := NewImportMap("/project/myapp/views.py")
 	importMap.AddImport("sanitize", "myapp.utils.sanitize")
 
-	fqn, resolved := resolveCallTarget("sanitize", importMap, registry, "myapp.views")
+	codeGraph := &graph.CodeGraph{Nodes: make(map[string]*graph.Node)}
+	fqn, resolved := resolveCallTarget("sanitize", importMap, registry, "myapp.views", codeGraph)
 
 	assert.True(t, resolved)
 	assert.Equal(t, "myapp.utils.sanitize", fqn)
@@ -40,7 +41,8 @@ func TestResolveCallTarget_QualifiedImport(t *testing.T) {
 	importMap := NewImportMap("/project/myapp/views.py")
 	importMap.AddImport("utils", "myapp.utils")
 
-	fqn, resolved := resolveCallTarget("utils.sanitize", importMap, registry, "myapp.views")
+	codeGraph := &graph.CodeGraph{Nodes: make(map[string]*graph.Node)}
+	fqn, resolved := resolveCallTarget("utils.sanitize", importMap, registry, "myapp.views", codeGraph)
 
 	assert.True(t, resolved)
 	assert.Equal(t, "myapp.utils.sanitize", fqn)
@@ -55,7 +57,8 @@ func TestResolveCallTarget_SameModuleFunction(t *testing.T) {
 
 	importMap := NewImportMap("/project/myapp/views.py")
 
-	fqn, resolved := resolveCallTarget("helper", importMap, registry, "myapp.views")
+	codeGraph := &graph.CodeGraph{Nodes: make(map[string]*graph.Node)}
+	fqn, resolved := resolveCallTarget("helper", importMap, registry, "myapp.views", codeGraph)
 
 	assert.True(t, resolved)
 	assert.Equal(t, "myapp.views.helper", fqn)
@@ -70,7 +73,8 @@ func TestResolveCallTarget_UnresolvedMethodCall(t *testing.T) {
 
 	importMap := NewImportMap("/project/myapp/views.py")
 
-	fqn, resolved := resolveCallTarget("obj.method", importMap, registry, "myapp.views")
+	codeGraph := &graph.CodeGraph{Nodes: make(map[string]*graph.Node)}
+	fqn, resolved := resolveCallTarget("obj.method", importMap, registry, "myapp.views", codeGraph)
 
 	assert.False(t, resolved)
 	assert.Equal(t, "obj.method", fqn)
@@ -85,7 +89,8 @@ func TestResolveCallTarget_NonExistentFunction(t *testing.T) {
 	importMap := NewImportMap("/project/myapp/views.py")
 	importMap.AddImport("missing", "nonexistent.module.function")
 
-	fqn, resolved := resolveCallTarget("missing", importMap, registry, "myapp.views")
+	codeGraph := &graph.CodeGraph{Nodes: make(map[string]*graph.Node)}
+	fqn, resolved := resolveCallTarget("missing", importMap, registry, "myapp.views", codeGraph)
 
 	assert.False(t, resolved)
 	assert.Equal(t, "nonexistent.module.function", fqn)