fix(detector/python): emit anchor nodes for imports edges

Same anti-pattern fix as TypeScript imports (commit a9fb22d) — the Python
structures detector emitted imports edges with raw file paths and module
names as endpoints. Both endpoints lacked CodeNodes; every edge dropped.

Fix: emit py:file:<path> for the source file once per detector pass,
py:external:<module> for each imported module. The GraphBuilder dedup
collapses the external nodes across files so the graph gets a real
dependency view at no extra cost.

Bench (airflow, 9151 Python-heavy files):
- 95758 nodes, 134400 edges
- 80181 nodes deduped (per-file + per-external collapsed across files)
- 7888 phantom edges dropped (was higher pre-fix)

The dedup count of 80k tells the story: pre-fix, those 80k import emissions
each went to a phantom target. Now they collapse to ~thousands of unique
external module nodes, and the imports edges actually survive.

Co-Authored-By: Claude Opus 4.7 (1M context) <noreply@anthropic.com>

Author: aksOps

go/internal/detector/python/structures.go

@@ -199,29 +199,57 @@ func (d PythonStructuresDetector) Detect(ctx *detector.Context) *detector.Result
 		}
 	}
 
-	// Imports
+	// Imports — emit anchor nodes so the edges survive the GraphBuilder
+	// phantom-drop. Pre-fix, both endpoints were free-form strings (file
+	// path and module name) with no matching CodeNode. The dedup map
+	// collapses the per-file external nodes across files (every file
+	// importing `requests` gets one shared py:external:requests target).
+	fileModuleID := "py:file:" + fp
+	importSeen := make(map[string]bool)
+	ensureFile := func() {
+		if !importSeen["__file__"] {
+			importSeen["__file__"] = true
+			fn := model.NewCodeNode(fileModuleID, model.NodeModule, fp)
+			fn.FilePath = fp
+			fn.Source = "PythonStructuresDetector"
+			fn.Confidence = model.ConfidenceLexical
+			fn.Properties["module_type"] = "py_file"
+			nodes = append(nodes, fn)
+		}
+	}
+	emitImport := func(mod string) {
+		mod = strings.TrimSpace(mod)
+		if mod == "" || importSeen["mod:"+mod] {
+			return
+		}
+		importSeen["mod:"+mod] = true
+		ensureFile()
+		targetID := "py:external:" + mod
+		if !importSeen["tgt:"+mod] {
+			importSeen["tgt:"+mod] = true
+			tn := model.NewCodeNode(targetID, model.NodeExternal, mod)
+			tn.Source = "PythonStructuresDetector"
+			tn.Confidence = model.ConfidenceLexical
+			tn.Properties["module"] = mod
+			nodes = append(nodes, tn)
+		}
+		e := model.NewCodeEdge(fileModuleID+"->imports->"+targetID, model.EdgeImports, fileModuleID, targetID)
+		e.Source = "PythonStructuresDetector"
+		e.Confidence = model.ConfidenceLexical
+		edges = append(edges, e)
+	}
 	for _, m := range pyImportRE.FindAllStringSubmatchIndex(text, -1) {
 		var fromMod string
 		if m[2] >= 0 {
 			fromMod = text[m[2]:m[3]]
 		}
-		importNames := text[m[4]:m[5]]
 		if fromMod != "" {
-			e := model.NewCodeEdge(fp+"->imports->"+fromMod, model.EdgeImports, fp, fromMod)
-			e.Source = "PythonStructuresDetector"
-			e.Confidence = model.ConfidenceLexical
-			edges = append(edges, e)
-		} else {
-			for _, n := range strings.Split(importNames, ",") {
-				t := strings.TrimSpace(n)
-				if t == "" {
-					continue
-				}
-				e := model.NewCodeEdge(fp+"->imports->"+t, model.EdgeImports, fp, t)
-				e.Source = "PythonStructuresDetector"
-				e.Confidence = model.ConfidenceLexical
-				edges = append(edges, e)
-			}
+			emitImport(fromMod)
+			continue
+		}
+		importNames := text[m[4]:m[5]]
+		for _, n := range strings.Split(importNames, ",") {
+			emitImport(n)
 		}
 	}
 

go/internal/detector/python/structures_test.go

@@ -57,8 +57,9 @@ func TestPythonStructuresPositive(t *testing.T) {
 	if methods < 4 {
 		t.Errorf("expected at least 4 methods (top-level + class methods), got %d", methods)
 	}
-	if modules != 1 {
-		t.Errorf("expected 1 module node (__all__), got %d", modules)
+	// 1 __all__ module + 1 file-as-module (anchor for imports edges).
+	if modules != 2 {
+		t.Errorf("expected 2 module nodes (__all__ + file anchor), got %d", modules)
 	}
 	// Import edges + defines + extends
 	if len(r.Edges) < 4 {