Restore Jedi call graph at level 1; filter lib→lib edges

- Fix regression: Jedi call-graph edges are now always built at
  analysis_level >= 1 (level 1 = Jedi only, level 2 = Jedi + PyCG).
- Add filter_external_edges() in call_graph.py: drops edges where both
  source and target are outside the app namespace, using the full
  recursive callable walk (inner_callables, inner_classes) so nested
  functions and closures are correctly treated as app symbols.
- Apply filter unconditionally after call graph construction in core.py.

Signed-off-by: Saurabh Sinha <sinha108@gmail.com>

Author: sinha108

codeanalyzer/__main__.py

@@ -32,7 +32,7 @@ def main(
         typer.Option(
             "-a",
             "--analysis-level",
-            help="Analysis depth: 1=symbol table only, 2=+call graph (PyCG+Jedi).",
+            help="Analysis depth: 1=symbol table+Jedi call graph, 2=+PyCG call graph.",
             min=1,
             max=2,
         ),

codeanalyzer/core.py

@@ -11,6 +11,7 @@
 from codeanalyzer.schema import PyApplication, PyModule, model_dump_json, model_validate_json
 from codeanalyzer.schema.py_schema import PyCallEdge
 from codeanalyzer.semantic_analysis.call_graph import (
+    filter_external_edges,
     jedi_call_graph_edges,
     merge_edges,
     resolve_unresolved_constructors,
@@ -329,23 +330,19 @@ def analyze(self) -> PyApplication:
         # Build symbol table from cached application if available (if no available, the build a new one)
         symbol_table = self._build_symbol_table(cached_pyapplication.symbol_table if cached_pyapplication else {})
 
-        # Level 1: symbol table only — constructor heuristic still runs to
-        # enrich PyCallsite.callee_signature inside the symbol table itself,
-        # but no call_graph edge list is produced.
         resolve_unresolved_constructors(symbol_table)
 
-        call_graph = []
+        # Level 1: Jedi call graph (always built when analysis_level >= 1).
+        jedi_edges = jedi_call_graph_edges(symbol_table)
+        call_graph = list(jedi_edges)
+
         if self.analysis_level >= 2:
-            # Level 2: build call graph.
-            #   1. Derive Jedi edges from the augmented symbol table.
-            #   2. Run PyCG (iterative name-pointer analysis) for additional
-            #      edges — particularly locally-scoped function calls and
-            #      higher-order patterns that Jedi misses.
-            #   3. Merge; provenance unions for edges seen by both backends.
-            jedi_edges = jedi_call_graph_edges(symbol_table)
+            # Level 2: add PyCG edges and merge with Jedi.
             pycg_edges = self._get_pycg_call_graph(symbol_table)
             call_graph = merge_edges(jedi_edges, pycg_edges)
 
+        call_graph = filter_external_edges(call_graph, symbol_table)
+
         # Recreate pyapplication
         app = PyApplication.builder().symbol_table(symbol_table).call_graph(call_graph).build()
 

codeanalyzer/semantic_analysis/call_graph.py

@@ -246,6 +246,27 @@ def scope_score(c: PyClass, _caller_sig: str = caller.signature) -> int:
     return resolved
 
 
+def filter_external_edges(
+    edges: List[PyCallEdge],
+    symbol_table: Dict[str, PyModule],
+) -> List[PyCallEdge]:
+    """Remove edges where both source and target are outside the app namespace.
+
+    Edges where an app callable calls a library function (or vice-versa) are
+    retained; only lib→lib edges are dropped.  The app symbol set is built by
+    walking every callable in the symbol table recursively (including nested
+    functions and closures via ``inner_callables``) plus every class, so
+    PyCG-discovered closure nodes are correctly recognised as app symbols.
+    """
+    app_symbols: set = {c.signature for c in iter_callables_in_symbol_table(symbol_table)}
+    app_symbols.update(cls.signature for cls in iter_classes_in_symbol_table(symbol_table))
+
+    return [
+        e for e in edges
+        if e.source in app_symbols or e.target in app_symbols
+    ]
+
+
 def merge_edges(*edge_lists: list) -> list:
     """Merge multiple ``List[PyCallEdge]`` into one.