Gate and fix data-flow name binding and change detection

[Raman369AI]

Summary

This adds a regression gate for method data flow first, then fixes what it catches. The gate follows review feedback: put the failing fixture cases into semantic_cases.json before any more UI work.

Regression gate

tests/semantic_cases.json could only check call resolution. test_semantic_accuracy.py now also runs two data-flow check kinds:

• "kind": "changes": mustChange / mustNotChange names for a method.
• "kind": "name": the node kind a name read must have (module_global, closure_variable, exception, builtin, import_reference, external). It also has an allowedKinds form (e.g. comprehension variables, which may leave no outside node) and a mustBeUnbound form (e.g. a read after its except clause).

Nine new cases, each paired with a contrasting check so a fix can't pass by over-correcting:

Case	Contrast
Read-only callee doesn't change its argument	an appending callee still does
self.items.append changes self.items	a method that only reads it changes nothing
Factory -> Repo / -> Optional[Repo] types the receiver	an unannotated factory stays unresolved
Module constants, including inside try, are module globals	an undefined name stays external
except … as exc binds exc	reading exc after the try is unbound
Comprehension variables, including tuple targets, stay local	reading one after the comprehension is unbound
Builtins as values (key=str)	a module's own len wins
Closures: nested functions, lambdas, and a class inside a function	class-body names aren't visible to methods; an enclosing name beats a module global
Imports inside try/if, and __file__	none needed

The new cases fail on main and pass here. The gate has 54 checks, with zero incorrect supported results.

Fixes (dataflow.py, analyzer.py)

• Name lookup now follows Python's order (local → enclosing function → module → builtin). Module-level names, including those inside top-level blocks, and implicit module attributes resolve as module globals, with the value when assigned once. Names from an enclosing function are closure variables. Builtins are labelled as such. Imports inside if/try/with blocks are indexed.
• except … as, comprehensions and lambdas bind their names only within their own scope.
• Change detection:
  • Callees that only call read-only methods (count, index, get, keys, startswith, …) no longer mark the caller's argument as possibly changed. Known mutators and unknown methods still do.
  • self.items.append(item) records a change to self.items, and the summary chip shows self.items and highlights the lines that change it.
• Factory return annotations type the receiver of a call's result (probably, the same certainty as constructor-based candidates).

Effect on a real codebase (agent-kanban-pm, 1,174 functions, main → this branch)

• "Unbound read" gaps (unknown names in method data flow): 763 → 0. Threadline's own source is also at 0.
• False possible changes from read-only callees: 450 → 417.
• Call resolution: one call newly resolved through a factory annotation; nothing else moves.
• No data-flow errors before or after; run time is about the same (15 s → 16 s).

Testing

• python test_semantic_accuracy.py: 54 checks pass, 0 false supported.
• python -m pytest: 162 pass.
• tests/browser_smoke.py in all four modes (live, --changes, --html, --html --changes): all pass.
• mypy (CI scope): passes.

Not in this PR

• The effect catalog (DB write/read, network, file write, logging, propagated through resolved calls) is planned next, on top of this gate.
• Delegating resolution to pyright or Jedi remains a separate experiment, and no dependency is added.

🤖 Generated with Claude Code