codegraph-ir 0.2.0__tar.gz → 0.2.1__tar.gz

{codegraph_ir-0.2.0 → codegraph_ir-0.2.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: codegraph-ir
-Version: 0.2.0
+Version: 0.2.1
 Summary: The deterministic contract layer for AI-modified codebases — effects, purity, contracts, and blast radius, with zero LLM calls.
 Project-URL: Homepage, https://github.com/asonkiya/llm-semantic-compilers
 Project-URL: Repository, https://github.com/asonkiya/llm-semantic-compilers

{codegraph_ir-0.2.0 → codegraph_ir-0.2.1}/pyproject.toml

@@ -6,7 +6,7 @@ build-backend = "hatchling.build"
 # Distribution name (the import package and CLI command are both `cgir`;
 # the PyPI project name `cgir` was already taken, so we ship as codegraph-ir).
 name = "codegraph-ir"
-version = "0.2.0"
+version = "0.2.1"
 description = "The deterministic contract layer for AI-modified codebases — effects, purity, contracts, and blast radius, with zero LLM calls."
 readme = "README.md"
 license = { file = "LICENSE" }

{codegraph_ir-0.2.0 → codegraph_ir-0.2.1}/src/cgir/__init__.py

@@ -3,4 +3,4 @@
 See ``Code-IR.md`` at the repo root for the product specification.
 """
 
-__version__ = "0.2.0"
+__version__ = "0.2.1"

{codegraph_ir-0.2.0 → codegraph_ir-0.2.1}/src/cgir/analyses/cfg.py

@@ -79,7 +79,13 @@ def build(graph: RepoGraph, repo_path: Path, adapter: LanguageAdapter | None = N
         body = file_adapter.function_body(func_ts)
         if body is None:
             continue
-        builder = _CFGBuilder(graph=graph, owner=func, source=source, adapter=file_adapter)
+        builder = _CFGBuilder(
+            graph=graph,
+            owner=func,
+            source=source,
+            adapter=file_adapter,
+            global_names=file_adapter.global_declared_names(func_ts, source),
+        )
         builder.build_block(body, predecessors=[func.id], controller=None)
 
 
@@ -89,6 +95,9 @@ class _CFGBuilder:
     owner: Node
     source: bytes
     adapter: LanguageAdapter
+    # names declared global/nonlocal in this function: writes to them mutate
+    # outer state and are recorded as `mutates`, not local `writes`.
+    global_names: set[str] = field(default_factory=set)
     _counter: int = field(default=0, init=False)
 
     def build_block(
@@ -102,6 +111,11 @@ class _CFGBuilder:
 
     def build_stmt(self, ts_node: TSNode, preds: list[str], controller: str | None) -> list[str]:
         desc = self.adapter.describe_statement(ts_node, self.source)
+        if isinstance(desc, AssignDesc) and self.global_names:
+            outer = [w for w in desc.writes if w in self.global_names]
+            if outer:
+                desc.writes = [w for w in desc.writes if w not in self.global_names]
+                desc.mutates = list(desc.mutates) + outer
         if isinstance(desc, BranchDesc):
             return self._build_branch(ts_node, desc, preds, controller)
         if isinstance(desc, LoopDesc):

{codegraph_ir-0.2.0 → codegraph_ir-0.2.1}/src/cgir/languages/base.py

@@ -264,6 +264,14 @@ class LanguageAdapter(ABC):
     def describe_statement(self, node: TSNode, source: bytes) -> StatementDesc:
         """Classify one statement and extract its parts (see descriptors)."""
 
+    def global_declared_names(self, func_node: TSNode, source: bytes) -> set[str]:
+        """Names this function declares as outer-scope (`global`/`nonlocal`).
+
+        Assignments to these names mutate state *outside* the function, so
+        the CFG builder records them as ``mutates`` rather than local
+        ``writes``. Default: none (TS/Go have no such declaration form)."""
+        return set()
+
     # --- phase 3: ingest extraction ------------------------------------------
 
     @abstractmethod

{codegraph_ir-0.2.0 → codegraph_ir-0.2.1}/src/cgir/languages/go.py

@@ -295,8 +295,11 @@ class GoAdapter(LanguageAdapter):
         first_decl = next(
             (c for c in root.named_children if c.type not in {"comment", "package_clause"}), None
         )
+        pinnable = {"function_declaration", "method_declaration", "type_declaration"}
         module_pins = pin_index.module_pins(
-            first_decl.start_point[0] if first_decl is not None else None
+            first_decl.start_point[0]
+            if first_decl is not None and first_decl.type in pinnable
+            else None
         )
         if module_pins:
             for decl in decls:

{codegraph_ir-0.2.0 → codegraph_ir-0.2.1}/src/cgir/languages/python.py

@@ -205,6 +205,28 @@ class PythonAdapter(LanguageAdapter):
     def function_body(self, func_node: TSNode) -> TSNode | None:
         return func_node.child_by_field_name("body")
 
+    def global_declared_names(self, func_node: TSNode, source: bytes) -> set[str]:
+        """Names bound by `global`/`nonlocal` in *this* function's own body.
+
+        Nested function bodies are skipped — their declarations apply to
+        their own CFG walk, not this one."""
+        names: set[str] = set()
+        body = func_node.child_by_field_name("body")
+        if body is None:
+            return names
+        stack: list[TSNode] = [body]
+        while stack:
+            node = stack.pop()
+            if node.type in {"function_definition", "class_definition"}:
+                continue  # a nested scope's declarations are not ours
+            if node.type in {"global_statement", "nonlocal_statement"}:
+                for child in node.named_children:
+                    if child.type == "identifier":
+                        names.add(_text(child, source))
+                continue
+            stack.extend(node.named_children)
+        return names
+
     def block_statements(self, block: TSNode) -> list[TSNode]:
         return [c for c in block.named_children if c.type != "comment"]
 
@@ -335,8 +357,14 @@ class PythonAdapter(LanguageAdapter):
         for child in root.children:
             decls.extend(self._top_level_decl(child, source, module_name, pin_index))
         first_decl = next((c for c in root.children if c.type != "comment"), None)
+        # A header block only belongs to the first statement when that
+        # statement is *pinnable* (a definition) — touching an import keeps
+        # the pins module-level.
+        pinnable = {"function_definition", "class_definition", "decorated_definition"}
         module_pins = pin_index.module_pins(
-            first_decl.start_point[0] if first_decl is not None else None
+            first_decl.start_point[0]
+            if first_decl is not None and first_decl.type in pinnable
+            else None
         )
         if module_pins:
             for decl in decls:

{codegraph_ir-0.2.0 → codegraph_ir-0.2.1}/src/cgir/languages/typescript.py

@@ -391,8 +391,20 @@ class TypeScriptAdapter(LanguageAdapter):
         for child in root.children:
             decls.extend(self._top_level(child, source, rel_path, pin_index))
         first_decl = next((c for c in root.children if c.type != "comment"), None)
+        # Only a pinnable definition claims an adjacent header block; an
+        # import keeps the pins module-level.
+        pinnable = {
+            "function_declaration",
+            "class_declaration",
+            "abstract_class_declaration",
+            "export_statement",
+            "lexical_declaration",
+            "variable_declaration",
+        }
         module_pins = pin_index.module_pins(
-            first_decl.start_point[0] if first_decl is not None else None
+            first_decl.start_point[0]
+            if first_decl is not None and first_decl.type in pinnable
+            else None
         )
         if module_pins:
             for decl in decls:

{codegraph_ir-0.2.0 → codegraph_ir-0.2.1}/tests/unit/test_pins.py

@@ -205,3 +205,27 @@ def test_pack_renders_pins() -> None:
     specs = [_spec("m.f", pins=["pure", "no-net"])]
     out = render_pack(build_pack(specs, "m.f"))
     assert "Pinned: no-net, pure" in out or "Pinned: pure, no-net" in out
+
+
+def test_module_pin_adjacent_to_imports_still_applies(tmp_path: Path) -> None:
+    """Real-world layout: the header pin sits directly above the imports.
+
+    Adjacency only disqualifies a header block when it touches a *pinnable
+    definition* — touching an import (or any plain statement) keeps it
+    module-level. Found dogfooding on camera-tracking.
+    """
+    (tmp_path / "m.py").write_text(
+        "# cgir: no-net\nfrom typing import Iterable\n\n\ndef f(x):\n    return x\n"
+    )
+    [spec] = _scan(tmp_path)
+    assert "no-net" in spec.pins
+
+
+def test_module_pin_adjacent_to_def_still_belongs_to_def(tmp_path: Path) -> None:
+    # No imports: header touching the first def is that def's pin, not module-wide.
+    (tmp_path / "m.py").write_text(
+        "# cgir: pure\ndef f(x):\n    return x\n\n\ndef g(x):\n    return x\n"
+    )
+    specs = {s.id: s for s in _scan(tmp_path)}
+    assert specs["m.f"].pins == ["pure"]
+    assert specs["m.g"].pins == []

{codegraph_ir-0.2.0 → codegraph_ir-0.2.1}/tests/unit/test_slicer.py

@@ -264,3 +264,69 @@ def test_subscript_write_to_local_is_not_state_transformation(tmp_path: Path) ->
         """,
     )
     assert specs["m.index"].kind == ComponentKind.pure_function
+
+
+def test_global_rebinding_is_state_transformer(tmp_path: Path) -> None:
+    """`global x; x = ...` mutates module state — found dogfooding: a lazy-init
+    service accessor with 34 callers scanned as pure_function."""
+    specs = _specs_for(
+        tmp_path,
+        """
+        _client = None
+
+
+        def get_client():
+            global _client
+            if _client is None:
+                _client = object()
+            return _client
+        """,
+    )
+    assert specs["m.get_client"].kind == ComponentKind.state_transformer
+
+
+def test_nonlocal_names_extracted_by_adapter(tmp_path: Path) -> None:
+    # nested functions aren't sliced as components (yet), so pin the adapter
+    # hook directly: nonlocal declarations are collected like global ones.
+    from cgir.languages.python import PythonAdapter
+
+    a = PythonAdapter()
+    src = b"def bump():\n    nonlocal count\n    count = count + 1\n"
+    fn = a.locate_function(a.parse(src), "bump", 0)
+    assert fn is not None
+    assert a.global_declared_names(fn, src) == {"count"}
+
+
+def test_local_rebinding_of_same_name_stays_pure(tmp_path: Path) -> None:
+    # a plain local assignment (no global decl) is not a mutation
+    specs = _specs_for(
+        tmp_path,
+        """
+        _client = None
+
+
+        def pure_shadow():
+            _client = 5
+            return _client
+        """,
+    )
+    assert specs["m.pure_shadow"].kind == ComponentKind.pure_function
+
+
+def test_nested_global_decl_does_not_taint_outer(tmp_path: Path) -> None:
+    # the nested function's `global x` must not make the OUTER local write a mutation
+    specs = _specs_for(
+        tmp_path,
+        """
+        x = 0
+
+
+        def outer():
+            x = 1
+            def inner():
+                global x
+                x = 2
+            return x
+        """,
+    )
+    assert specs["m.outer"].kind == ComponentKind.pure_function