fix(python): restore method call edges in the call graph

The Python parser dropped every method call (`self.x()`, `obj.method()`),
so `get_callers`, `get_callees`, `analyze_impact` and `find_dead_imports`
were blind on Python codebases. Two defects had to be fixed together:

1. `extract_callee_name` returned the full text of a tree-sitter
   `attribute` node (`"self.simulator.partial_close"`). No symbol is
   registered under that name, so every callee lookup missed. It now keeps
   only the trailing method name, mirroring how `codegraph-rust` handles
   `field_expression`.

2. `ir_to_graph` indexed its `node_map` by bare name only, while the
   extractor attributes calls made inside a method to the qualified name
   `"Class.method"`. Every method call therefore missed its caller lookup
   and was silently dropped. The qualified name is now registered
   alongside the bare one.

Before: `run_tick` in a Python trading codebase reported 0 callees and
`analyze_impact` rated a live-trading hot path as `risk: low`.
After: 57 callees, 47 callers, `risk: medium`, and no false dead-import
reports.

Regression test added over the same path the server uses
(`parse_source` -> `ir_to_graph`).

Author: myzjs

crates/codegraph-python/src/extractor.rs

@@ -610,7 +610,18 @@ fn extract_callee_name(source: &[u8], node: Node) -> String {
         "identifier" => node.utf8_text(source).unwrap_or("").to_string(),
         "attribute" => {
             // Handle obj.method() or self.method()
-            node.utf8_text(source).unwrap_or("").to_string()
+            //
+            // Keep only the trailing method name. The receiver (`self`,
+            // `self.simulator`, `np`, ...) is not part of the callee's identity,
+            // and keeping it produced callee keys like "self.simulator.partial_close"
+            // that matched no symbol in the graph — so every method call silently
+            // lost its edge. Mirrors codegraph-rust's `field_expression` handling,
+            // which keeps just the field name.
+            let full = node.utf8_text(source).unwrap_or("");
+            match full.rsplit_once('.') {
+                Some((_, method)) => method.to_string(),
+                None => full.to_string(),
+            }
         }
         _ => String::new(),
     }
@@ -941,6 +952,62 @@ def greet(name):
         assert!(ir.calls.len() >= 2, "Should find at least 2 calls");
     }
 
+    #[test]
+    fn test_method_call_callee_names() {
+        // Method calls must be recorded with the bare method name so they can
+        // be matched against the symbol map; the receiver (`self`,
+        // `self.simulator`) is not part of the callee's identity.
+        let source = r#"
+class TradingEngine:
+    def run_tick(self):
+        self.simulator.close_position("BTC", 1.0)
+        self._emit_ops("x")
+        self._pool_ranks(alt_dfs)
+
+    def _emit_ops(self, x):
+        pass
+
+    def _pool_ranks(self, alt_dfs):
+        pass
+"#;
+        let path = Path::new("test.py");
+        let config = ParserConfig::default();
+        let ir = extract(source, path, &config).unwrap();
+
+        let calls: Vec<(&str, &str)> = ir
+            .calls
+            .iter()
+            .map(|c| (c.caller.as_str(), c.callee.as_str()))
+            .collect();
+        println!("extracted calls: {calls:?}");
+
+        println!(
+            "module-level functions: {:?}",
+            ir.functions.iter().map(|f| &f.name).collect::<Vec<_>>()
+        );
+        for class in &ir.classes {
+            println!(
+                "CLASS {:?} methods: {:?}",
+                class.name,
+                class.methods.iter().map(|m| &m.name).collect::<Vec<_>>()
+            );
+        }
+
+        // Every call inside a method is attributed to the qualified method name.
+        assert!(
+            calls.iter().all(|(caller, _)| *caller == "TradingEngine.run_tick"),
+            "all calls should be attributed to TradingEngine.run_tick, got {calls:?}"
+        );
+
+        // The receiver is stripped; only the method name survives.
+        for expected in ["close_position", "_emit_ops", "_pool_ranks"] {
+            assert!(
+                calls.iter().any(|(_, callee)| *callee == expected),
+                "expected a call to {expected}, got {calls:?}"
+            );
+        }
+    }
+
     #[test]
     fn test_extract_imports() {
         let source = r#"

crates/codegraph-python/src/parser_impl.rs

@@ -201,6 +201,12 @@ impl PythonParser {
                     graph
                         .add_edge(class_id, method_id, EdgeType::Contains, PropertyMap::new())
                         .map_err(|e| ParserError::GraphError(e.to_string()))?;
+                    // Also index the method under its qualified name. The
+                    // extractor attributes calls made inside a method to
+                    // "Class.method", while node_map is keyed by bare names —
+                    // without this entry every method call failed to resolve
+                    // and its edge was silently dropped.
+                    node_map.insert(format!("{}.{}", class.name, method.name), method_id);
                 }
             }
         }
@@ -554,6 +560,74 @@ fn extract_first_string_arg(attr: &str) -> Option<String> {
 #[cfg(test)]
 mod tests {
     use super::*;
+    use codegraph::{EdgeType, NodeType};
+
+    #[test]
+    fn test_method_call_edge_is_created() {
+        // End-to-end over the same path the server uses (parse_source ->
+        // ir_to_graph). A call made inside a method must produce a Calls edge.
+        let source = r#"
+class Probe:
+    def probe_method(self):
+        return 1
+
+    def probe_method_caller(self):
+        return self.probe_method()
+
+
+def probe_free_fn():
+    return 1
+
+
+def probe_free_caller():
+    return probe_free_fn()
+"#;
+        let mut graph = CodeGraph::in_memory().unwrap();
+        let parser = PythonParser::new();
+        parser
+            .parse_source(source, std::path::Path::new("probe.py"), &mut graph)
+            .expect("parse source");
+
+        let funcs = graph
+            .query()
+            .node_type(NodeType::Function)
+            .execute()
+            .expect("query functions");
+
+        let find = |name: &str| {
+            funcs
+                .iter()
+                .find(|id| {
+                    graph
+                        .get_node(**id)
+                        .ok()
+                        .and_then(|n| n.properties.get_string("name").map(|n| n == name))
+                        .unwrap_or(false)
+                })
+                .copied()
+                .expect("node for function")
+        };
+
+        for (caller_name, callee_name) in [
+            ("probe_method_caller", "probe_method"),
+            ("probe_free_caller", "probe_free_fn"),
+        ] {
+            let caller = find(caller_name);
+            let callee = find(callee_name);
+            let edges = graph
+                .get_edges_between(caller, callee)
+                .expect("edges between caller and callee");
+            assert!(
+                edges.iter().any(|e| {
+                    graph
+                        .get_edge(*e)
+                        .map(|edge| edge.edge_type == EdgeType::Calls)
+                        .unwrap_or(false)
+                }),
+                "expected a Calls edge from {caller_name} to {callee_name}"
+            );
+        }
+    }
 
     #[test]
     fn test_python_parser_new() {