codeanalyzer-python 0.3.0__tar.gz → 0.3.2__tar.gz

{codeanalyzer_python-0.3.0 → codeanalyzer_python-0.3.2}/.gitignore

@@ -184,3 +184,6 @@ uv.lock
 # Node / Astro docs-site build artifacts (never commit these)
 node_modules/
 .astro/
+
+# Track this repo's CLAUDE.md even though a global gitignore excludes CLAUDE.md
+!CLAUDE.md

{codeanalyzer_python-0.3.0 → codeanalyzer_python-0.3.2}/PKG-INFO

@@ -1,6 +1,6 @@
-Metadata-Version: 2.4
+Metadata-Version: 2.5
 Name: codeanalyzer-python
-Version: 0.3.0
+Version: 0.3.2
 Summary: Static Analysis on Python source code using Jedi, CodeQL and Treesitter — emits analysis.json or a Neo4j property graph.
 Author-email: Rahul Krishna <i.m.ralk@gmail.com>
 License-File: LICENSE
@@ -12,12 +12,7 @@ Requires-Dist: msgpack<1.0.7,>=1.0.0; python_version < '3.11'
 Requires-Dist: msgpack<2.0.0,>=1.0.7; python_version >= '3.11'
 Requires-Dist: networkx<3.2.0,>=2.6.0; python_version < '3.11'
 Requires-Dist: networkx<4.0.0,>=3.0.0; python_version >= '3.11'
-Requires-Dist: numpy<1.24.0,>=1.21.0; python_version < '3.11'
-Requires-Dist: numpy<2.0.0,>=1.24.0; python_version >= '3.11' and python_version < '3.12'
-Requires-Dist: numpy<2.0.0,>=1.26.0; python_version >= '3.12'
 Requires-Dist: packaging>=25.0
-Requires-Dist: pandas<2.0.0,>=1.3.0; python_version < '3.11'
-Requires-Dist: pandas<3.0.0,>=2.0.0; python_version >= '3.11'
 Requires-Dist: pycg>=0.0.6
 Requires-Dist: pydantic<2.0.0,>=1.8.0; python_version < '3.11'
 Requires-Dist: pydantic<3.0.0,>=2.0.0; python_version >= '3.11'
@@ -181,19 +176,22 @@ $ canpy --help
  Static Analysis on Python source code using Jedi, PyCG and Tree sitter.
 
 ╭─ Options ────────────────────────────────────────────────────────────────────╮
-│ --input            -i                     PATH              Path to the      │
+│ --version                                                   Show the canpy   │
+│                                                             version and      │
+│                                                             exit.            │
+│ --input            -i                     <path>            Path to the      │
 │                                                             project root     │
 │                                                             directory (not   │
 │                                                             required for     │
 │                                                             --emit schema).  │
-│ --output           -o                     PATH              Output directory │
+│ --output           -o                     <path>            Output directory │
 │                                                             for artifacts.   │
-│ --format           -f                     [json|msgpack]    Output format    │
+│ --format           -f                     <json|msgpack>    Output format    │
 │                                                             for --emit json: │
 │                                                             json or msgpack. │
 │                                                             [default: json]  │
-│ --emit                                    [json|neo4j|sche  Output target:   │
-│                                           ma]               json             │
+│ --emit                                    <json|neo4j|sche  Output target:   │
+│                                           ma>               json             │
 │                                                             (analysis.json,  │
 │                                                             default) | neo4j │
 │                                                             (graph.cypher or │
@@ -203,13 +201,13 @@ $ canpy --help
 │                                                             schema.json      │
 │                                                             contract).       │
 │                                                             [default: json]  │
-│ --app-name                                TEXT              Logical          │
+│ --app-name                                <str>             Logical          │
 │                                                             application name │
 │                                                             for the graph    │
 │                                                             :PyApplication   │
 │                                                             anchor (default: │
 │                                                             input dir name). │
-│ --neo4j-uri                               TEXT              Push the graph   │
+│ --neo4j-uri                               <str>             Push the graph   │
 │                                                             to a live Neo4j  │
 │                                                             over Bolt        │
 │                                                             (incremental);   │
@@ -217,11 +215,11 @@ $ canpy --help
 │                                                             graph.cypher.    │
 │                                                             [env var:        │
 │                                                             NEO4J_URI]       │
-│ --neo4j-user                              TEXT              Neo4j username.  │
+│ --neo4j-user                              <str>             Neo4j username.  │
 │                                                             [env var:        │
 │                                                             NEO4J_USERNAME]  │
 │                                                             [default: neo4j] │
-│ --neo4j-password                          TEXT              Neo4j password.  │
+│ --neo4j-password                          <str>             Neo4j password.  │
 │                                                             Prefer the env   │
 │                                                             var over the     │
 │                                                             flag (the flag   │
@@ -231,12 +229,12 @@ $ canpy --help
 │                                                             [env var:        │
 │                                                             NEO4J_PASSWORD]  │
 │                                                             [default: neo4j] │
-│ --neo4j-database                          TEXT              Neo4j database   │
+│ --neo4j-database                          <str>             Neo4j database   │
 │                                                             name (default:   │
 │                                                             server default). │
 │                                                             [env var:        │
 │                                                             NEO4J_DATABASE]  │
-│ --analysis-level   -a                     INTEGER RANGE     Analysis depth:  │
+│ --analysis-level   -a                     <int range>       Analysis depth:  │
 │                                           [1<=x<=2]         1=symbol         │
 │                                                             table+Jedi call  │
 │                                                             graph, 2=+PyCG   │
@@ -266,12 +264,12 @@ $ canpy --help
 │                                                             environment      │
 │                                                             instead.         │
 │                                                             [default: venv]  │
-│ --file-name                               PATH              Analyze only the │
+│ --file-name                               <path>            Analyze only the │
 │                                                             specified file   │
 │                                                             (relative to     │
 │                                                             input            │
 │                                                             directory).      │
-│ --cache-dir        -c                     PATH              Directory to     │
+│ --cache-dir        -c                     <path>            Directory to     │
 │                                                             store analysis   │
 │                                                             cache. Defaults  │
 │                                                             to               │
@@ -285,7 +283,7 @@ $ canpy --help
 │                                                             retained.        │
 │                                                             [default:        │
 │                                                             keep-cache]      │
-│                    -v                     INTEGER           Increase         │
+│                    -v                     <int>             Increase         │
 │                                                             verbosity: -v,   │
 │                                                             -vv, -vvv        │
 │                                                             [default: 0]     │
@@ -312,7 +310,7 @@ $ canpy --help
 │                                                             Jedi-only edges. │
 │                                                             [default:        │
 │                                                             no-pycg-shard]   │
-│ --pycg-shard-cei…                         INTEGER RANGE     Maximum files    │
+│ --pycg-shard-cei…                         <int range>       Maximum files    │
 │                                           [x>=1]            per shard when   │
 │                                                             --pycg-shard is  │
 │                                                             active (default  │
@@ -334,7 +332,7 @@ $ canpy --help
 │                                                             heavy import     │
 │                                                             graphs.          │
 │                                                             [default: 100]   │
-│ --pycg-shard-tim…                         INTEGER RANGE     Per-shard        │
+│ --pycg-shard-tim…                         <int range>       Per-shard        │
 │                                           [x>=0]            wall-clock       │
 │                                                             timeout in       │
 │                                                             seconds when     │
@@ -362,7 +360,7 @@ $ canpy --help
 │                                                             ignored on       │
 │                                                             Windows.         │
 │                                                             [default: 120]   │
-│ --pycg-shard-str…                         [jedi|package]    How --pycg-shard │
+│ --pycg-shard-str…                         <jedi|package>    How --pycg-shard │
 │                                                             groups files     │
 │                                                             (level 2 only).  │
 │                                                             'jedi' (default) │
@@ -384,7 +382,7 @@ $ canpy --help
 │                                                             one-shard-per-p… │
 │                                                             grouping.        │
 │                                                             [default: jedi]  │
-│ --pycg-max-iter                           INTEGER RANGE     Cap on PyCG's    │
+│ --pycg-max-iter                           <int range>       Cap on PyCG's    │
 │                                           [x>=-1]           fixpoint passes  │
 │                                                             per              │
 │                                                             shard/project    │

{codeanalyzer_python-0.3.0 → codeanalyzer_python-0.3.2}/README.md

@@ -144,19 +144,22 @@ $ canpy --help
  Static Analysis on Python source code using Jedi, PyCG and Tree sitter.
 
 ╭─ Options ────────────────────────────────────────────────────────────────────╮
-│ --input            -i                     PATH              Path to the      │
+│ --version                                                   Show the canpy   │
+│                                                             version and      │
+│                                                             exit.            │
+│ --input            -i                     <path>            Path to the      │
 │                                                             project root     │
 │                                                             directory (not   │
 │                                                             required for     │
 │                                                             --emit schema).  │
-│ --output           -o                     PATH              Output directory │
+│ --output           -o                     <path>            Output directory │
 │                                                             for artifacts.   │
-│ --format           -f                     [json|msgpack]    Output format    │
+│ --format           -f                     <json|msgpack>    Output format    │
 │                                                             for --emit json: │
 │                                                             json or msgpack. │
 │                                                             [default: json]  │
-│ --emit                                    [json|neo4j|sche  Output target:   │
-│                                           ma]               json             │
+│ --emit                                    <json|neo4j|sche  Output target:   │
+│                                           ma>               json             │
 │                                                             (analysis.json,  │
 │                                                             default) | neo4j │
 │                                                             (graph.cypher or │
@@ -166,13 +169,13 @@ $ canpy --help
 │                                                             schema.json      │
 │                                                             contract).       │
 │                                                             [default: json]  │
-│ --app-name                                TEXT              Logical          │
+│ --app-name                                <str>             Logical          │
 │                                                             application name │
 │                                                             for the graph    │
 │                                                             :PyApplication   │
 │                                                             anchor (default: │
 │                                                             input dir name). │
-│ --neo4j-uri                               TEXT              Push the graph   │
+│ --neo4j-uri                               <str>             Push the graph   │
 │                                                             to a live Neo4j  │
 │                                                             over Bolt        │
 │                                                             (incremental);   │
@@ -180,11 +183,11 @@ $ canpy --help
 │                                                             graph.cypher.    │
 │                                                             [env var:        │
 │                                                             NEO4J_URI]       │
-│ --neo4j-user                              TEXT              Neo4j username.  │
+│ --neo4j-user                              <str>             Neo4j username.  │
 │                                                             [env var:        │
 │                                                             NEO4J_USERNAME]  │
 │                                                             [default: neo4j] │
-│ --neo4j-password                          TEXT              Neo4j password.  │
+│ --neo4j-password                          <str>             Neo4j password.  │
 │                                                             Prefer the env   │
 │                                                             var over the     │
 │                                                             flag (the flag   │
@@ -194,12 +197,12 @@ $ canpy --help
 │                                                             [env var:        │
 │                                                             NEO4J_PASSWORD]  │
 │                                                             [default: neo4j] │
-│ --neo4j-database                          TEXT              Neo4j database   │
+│ --neo4j-database                          <str>             Neo4j database   │
 │                                                             name (default:   │
 │                                                             server default). │
 │                                                             [env var:        │
 │                                                             NEO4J_DATABASE]  │
-│ --analysis-level   -a                     INTEGER RANGE     Analysis depth:  │
+│ --analysis-level   -a                     <int range>       Analysis depth:  │
 │                                           [1<=x<=2]         1=symbol         │
 │                                                             table+Jedi call  │
 │                                                             graph, 2=+PyCG   │
@@ -229,12 +232,12 @@ $ canpy --help
 │                                                             environment      │
 │                                                             instead.         │
 │                                                             [default: venv]  │
-│ --file-name                               PATH              Analyze only the │
+│ --file-name                               <path>            Analyze only the │
 │                                                             specified file   │
 │                                                             (relative to     │
 │                                                             input            │
 │                                                             directory).      │
-│ --cache-dir        -c                     PATH              Directory to     │
+│ --cache-dir        -c                     <path>            Directory to     │
 │                                                             store analysis   │
 │                                                             cache. Defaults  │
 │                                                             to               │
@@ -248,7 +251,7 @@ $ canpy --help
 │                                                             retained.        │
 │                                                             [default:        │
 │                                                             keep-cache]      │
-│                    -v                     INTEGER           Increase         │
+│                    -v                     <int>             Increase         │
 │                                                             verbosity: -v,   │
 │                                                             -vv, -vvv        │
 │                                                             [default: 0]     │
@@ -275,7 +278,7 @@ $ canpy --help
 │                                                             Jedi-only edges. │
 │                                                             [default:        │
 │                                                             no-pycg-shard]   │
-│ --pycg-shard-cei…                         INTEGER RANGE     Maximum files    │
+│ --pycg-shard-cei…                         <int range>       Maximum files    │
 │                                           [x>=1]            per shard when   │
 │                                                             --pycg-shard is  │
 │                                                             active (default  │
@@ -297,7 +300,7 @@ $ canpy --help
 │                                                             heavy import     │
 │                                                             graphs.          │
 │                                                             [default: 100]   │
-│ --pycg-shard-tim…                         INTEGER RANGE     Per-shard        │
+│ --pycg-shard-tim…                         <int range>       Per-shard        │
 │                                           [x>=0]            wall-clock       │
 │                                                             timeout in       │
 │                                                             seconds when     │
@@ -325,7 +328,7 @@ $ canpy --help
 │                                                             ignored on       │
 │                                                             Windows.         │
 │                                                             [default: 120]   │
-│ --pycg-shard-str…                         [jedi|package]    How --pycg-shard │
+│ --pycg-shard-str…                         <jedi|package>    How --pycg-shard │
 │                                                             groups files     │
 │                                                             (level 2 only).  │
 │                                                             'jedi' (default) │
@@ -347,7 +350,7 @@ $ canpy --help
 │                                                             one-shard-per-p… │
 │                                                             grouping.        │
 │                                                             [default: jedi]  │
-│ --pycg-max-iter                           INTEGER RANGE     Cap on PyCG's    │
+│ --pycg-max-iter                           <int range>       Cap on PyCG's    │
 │                                           [x>=-1]           fixpoint passes  │
 │                                                             per              │
 │                                                             shard/project    │

{codeanalyzer_python-0.3.0 → codeanalyzer_python-0.3.2}/codeanalyzer/__main__.py

@@ -1,3 +1,4 @@
+from importlib.metadata import version as _pkg_version, PackageNotFoundError
 from pathlib import Path
 from typing import Optional, Annotated
 
@@ -10,7 +11,32 @@ from codeanalyzer.schema import model_dump_json
 from codeanalyzer.options import AnalysisOptions, EmitTarget, ShardStrategy
 
 
+def _version_callback(value: bool) -> None:
+    """Print the installed ``codeanalyzer-python`` version and exit.
+
+    Eager so it fires before the rest of the CLI callback (no -i/--input
+    required). Reads the version from package metadata so it always reflects
+    what is actually installed rather than a hardcoded string."""
+    if not value:
+        return
+    try:
+        installed = _pkg_version("codeanalyzer-python")
+    except PackageNotFoundError:
+        installed = "unknown"
+    typer.echo(f"canpy {installed}")
+    raise typer.Exit()
+
+
 def main(
+    version: Annotated[
+        Optional[bool],
+        typer.Option(
+            "--version",
+            help="Show the canpy version and exit.",
+            callback=_version_callback,
+            is_eager=True,
+        ),
+    ] = None,
     input: Annotated[
         Optional[Path],
         typer.Option(

{codeanalyzer_python-0.3.0 → codeanalyzer_python-0.3.2}/codeanalyzer/core.py

@@ -26,9 +26,11 @@ from codeanalyzer.semantic_analysis.call_graph import (
 )
 from codeanalyzer.semantic_analysis.pycg import PyCG, PyCGExceptions
 from codeanalyzer.syntactic_analysis.exceptions import SymbolTableBuilderRayError
+from codeanalyzer.syntactic_analysis.import_resolver import resolve_imports
 from codeanalyzer.syntactic_analysis.symbol_table_builder import SymbolTableBuilder
 from codeanalyzer.utils import ProgressBar
 from codeanalyzer.options import AnalysisOptions
+from codeanalyzer.provenance import analyzer_info, repository_info
 
 @ray.remote
 def _process_file_with_ray(py_file: Union[Path, str], project_dir: Union[Path, str], virtualenv: Union[Path, str, None]) -> Dict[str, PyModule]:
@@ -411,8 +413,8 @@ class Codeanalyzer:
         Uses caching to avoid re-analyzing unchanged files.
         """
         cache_file = self.cache_dir / "analysis_cache.json"
-        
-        # Try to load existing cached analysis 
+
+        # Try to load existing cached analysis
         cached_pyapplication = None
         if not self.rebuild_analysis and cache_file.exists():
             try:
@@ -422,6 +424,12 @@ class Codeanalyzer:
                 logger.warning(f"Failed to load cache: {e}. Rebuilding analysis.")
                 cached_pyapplication = None
 
+        if cached_pyapplication is not None and not self._cache_analyzer_matches(
+            cached_pyapplication, analyzer_info(self.analysis_level).version
+        ):
+            logger.info("Analysis cache written by a different analyzer version; rebuilding.")
+            cached_pyapplication = None
+
         # 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 {})
 
@@ -454,12 +462,35 @@ class Codeanalyzer:
             .external_symbols(external_symbols)
             .build()
         )
-        
+
+        # Every run re-resolves import spellings against the analyzed module
+        # set -- pure and cheap; cached modules from older caches default to
+        # resolved_module=None and get stamped here (issue #82).
+        resolve_imports(app, self.project_dir)
+
+        # Single choke point for provenance: every produced app (fresh symbol
+        # table or reused-from-cache) passes through here before being cached
+        # or returned, so analyzer/repository always reflect *this* run/checkout
+        # even when the symbol table itself came from the on-disk cache.
+        app.analyzer = analyzer_info(self.analysis_level)
+        app.repository = repository_info(self.project_dir)
+
         # Save to cache
         self._save_analysis_cache(app, cache_file)
         
         return app
 
+    @staticmethod
+    def _cache_analyzer_matches(cached_app: Optional[PyApplication], current_version: str) -> bool:
+        """A cache written by another analyzer version (or before versions were
+        recorded) may lack fields the current models populate — pydantic fills
+        silent defaults, which would masquerade as analyzed absence."""
+        return (
+            cached_app is not None
+            and cached_app.analyzer is not None
+            and cached_app.analyzer.version == current_version
+        )
+
     def _load_pyapplication_from_cache(self, cache_file: Path) -> PyApplication:
         """Load cached analysis from file.
         

{codeanalyzer_python-0.3.0 → codeanalyzer_python-0.3.2}/codeanalyzer/neo4j/__init__.py

@@ -19,7 +19,7 @@ plus the two writers (cypher snapshot / bolt incremental). Nothing here runs
 unless ``--emit neo4j`` (or ``--emit schema``) is selected.
 """
 from codeanalyzer.neo4j.bolt import BoltConfig, bolt_writer
-from codeanalyzer.neo4j.catalog import (
+from codeanalyzer.neo4j.schema import (
     MARKER_LABELS,
     NODE_LABELS,
     REL_TYPES,

{codeanalyzer_python-0.3.0 → codeanalyzer_python-0.3.2}/codeanalyzer/neo4j/emit.py

@@ -28,7 +28,7 @@ from pathlib import Path
 from typing import Optional
 
 from codeanalyzer.neo4j.bolt import BoltConfig, bolt_writer
-from codeanalyzer.neo4j.catalog import build_schema_document
+from codeanalyzer.neo4j.schema import build_schema_document
 from codeanalyzer.neo4j.cypher import render_cypher
 from codeanalyzer.neo4j.project import project
 from codeanalyzer.options import AnalysisOptions
@@ -38,7 +38,7 @@ from codeanalyzer.utils import logger
 
 def emit_schema(output: Optional[Path]) -> None:
     """Emit the Neo4j schema contract (``schema.json``) — a static artifact derived
-    from the in-repo catalog, independent of any analyzed project. With no
+    from the in-repo schema, independent of any analyzed project. With no
     ``output`` it prints to stdout."""
     doc = json.dumps(build_schema_document(), indent=2) + "\n"
     if output is None:

{codeanalyzer_python-0.3.0 → codeanalyzer_python-0.3.2}/codeanalyzer/neo4j/project.py

@@ -36,7 +36,7 @@ import json
 from pathlib import Path
 from typing import Any, List, Optional
 
-from codeanalyzer.neo4j.catalog import SCHEMA_VERSION
+from codeanalyzer.neo4j.schema import SCHEMA_VERSION
 from codeanalyzer.neo4j.rows import GraphRows, NodeRef, Props, RowBuilder, prune
 from codeanalyzer.schema import (
     PyApplication,
@@ -53,10 +53,26 @@ from codeanalyzer.schema.py_schema import PyCallsite
 def project(app: PyApplication, app_name: str) -> GraphRows:
     b = RowBuilder()
 
-    app_ref = b.node(["PyApplication"], "name", app_name, {"schema_version": SCHEMA_VERSION})
+    app_ref = b.node(
+        ["PyApplication"],
+        "name",
+        app_name,
+        prune(
+            {
+                "schema_version": SCHEMA_VERSION,
+                "analyzer_name": app.analyzer.name if app.analyzer else None,
+                "analyzer_version": app.analyzer.version if app.analyzer else None,
+                "repo_uri": app.repository.uri if app.repository else None,
+                "source_revision": app.repository.revision if app.repository else None,
+                "repo_dirty": app.repository.dirty if app.repository else None,
+            }
+        ),
+    )
 
     for file_key, mod in app.symbol_table.items():
-        mod_ref = b.node(["PyModule"], "file_key", file_key, _module_props(mod, file_key))
+        mod_ref = b.node(
+            ["PyModule"], "file_key", file_key, _module_props(mod, file_key)
+        )
         b.edge("PY_HAS_MODULE", app_ref, mod_ref)
         _project_module_body(b, file_key, mod_ref, mod)
 
@@ -66,7 +82,9 @@ def project(app: PyApplication, app_name: str) -> GraphRows:
     for e in app.call_graph:
         src = _call_endpoint(b, e.source, externals)
         tgt = _call_endpoint(b, e.target, externals)
-        b.edge("PY_CALLS", src, tgt, _call_edge_props(e.weight, list(e.provenance or [])))
+        b.edge(
+            "PY_CALLS", src, tgt, _call_edge_props(e.weight, list(e.provenance or []))
+        )
 
     return b.finish()
 
@@ -86,9 +104,18 @@ def _call_endpoint(b: RowBuilder, signature: str, externals: dict) -> NodeRef:
     ext = externals.get(signature)
     if ext is None and b.has_key("PySymbol", signature):
         return _sym(signature)
-    name = ext.name if ext is not None else (signature.rsplit(".", 1)[-1] if "." in signature else signature)
+    name = (
+        ext.name
+        if ext is not None
+        else (signature.rsplit(".", 1)[-1] if "." in signature else signature)
+    )
     module = ext.module if ext is not None else None
-    return b.node(["PySymbol", "PyExternal"], "signature", signature, prune({"name": name, "module": module}))
+    return b.node(
+        ["PySymbol", "PyExternal"],
+        "signature",
+        signature,
+        prune({"name": name, "module": module}),
+    )
 
 
 # ----------------------------------------------------------------------------------------------
@@ -96,7 +123,9 @@ def _call_endpoint(b: RowBuilder, signature: str, externals: dict) -> NodeRef:
 # ----------------------------------------------------------------------------------------------
 
 
-def _project_module_body(b: RowBuilder, file_key: str, mod_ref: NodeRef, mod: PyModule) -> None:
+def _project_module_body(
+    b: RowBuilder, file_key: str, mod_ref: NodeRef, mod: PyModule
+) -> None:
     for fn in (mod.functions or {}).values():
         _project_callable(b, file_key, mod_ref, "PY_DECLARES", fn)
     for cl in (mod.classes or {}).values():
@@ -107,25 +136,47 @@ def _project_module_body(b: RowBuilder, file_key: str, mod_ref: NodeRef, mod: Py
 
 
 def _project_imports(b: RowBuilder, mod_ref: NodeRef, mod: PyModule) -> None:
-    # Per-target-module aggregation: collapse all bindings for a given imported
-    # module into one PY_IMPORTS edge to a shared :PyPackage node.
+    # At most one PY_IMPORTS edge per (module, target) pair -- mirrors PY_CALLS,
+    # which pre-aggregates for the same reason: both writers MERGE edges on
+    # (type, from, to) and SET their props, so a second row for the same pair
+    # would silently overwrite the first in Neo4j instead of adding an edge.
+    # Buckets key on the edge's target identity (the resolved module, or the
+    # spelling itself for unresolved/external imports), so the SAME target
+    # imported under different spellings (``from pkg import util``,
+    # ``from . import util as u``, ``from .util import helper``) collapses
+    # onto one edge; the raw spellings ride along as a ``spellings`` array.
+    # Resolved internal imports point at the real :PyModule; externals keep
+    # the shared :PyPackage. Unresolved *relative* spellings (".", ".foo")
+    # name no package -- they are dropped from the graph (the spelling
+    # survives in analysis.json), instead of minting bogus
+    # :PyPackage{name: "."} nodes.
     agg: dict = {}
     for im in mod.imports or []:
         if not im.module:
-            continue  # relative `from . import x` — no resolvable package
-        a = agg.setdefault(im.module, {"names": set(), "aliases": set()})
+            continue
+        if im.resolved_module is None and im.module.startswith("."):
+            continue
+        key = im.resolved_module or im.module
+        a = agg.setdefault(
+            key, {"spellings": set(), "names": set(), "aliases": set(), "resolved": im.resolved_module}
+        )
+        a["spellings"].add(im.module)
         if im.name:
             a["names"].add(im.name)
         if im.alias:
             a["aliases"].add(im.alias)
-    for module_name, a in agg.items():
-        pkg = b.node(["PyPackage"], "name", module_name, {})
+    for key, a in agg.items():
+        if a["resolved"] is not None:
+            target = NodeRef("PyModule", "file_key", a["resolved"])
+        else:
+            target = b.node(["PyPackage"], "name", key, {})
         b.edge(
             "PY_IMPORTS",
             mod_ref,
-            pkg,
+            target,
             prune(
                 {
+                    "spellings": sorted(a["spellings"]),
                     "imported_names": sorted(a["names"]) or None,
                     "aliases": sorted(a["aliases"]) or None,
                 }
@@ -141,7 +192,9 @@ def _project_imports(b: RowBuilder, mod_ref: NodeRef, mod: PyModule) -> None:
 def _project_class(
     b: RowBuilder, file_key: str, parent: NodeRef, parent_rel: str, cl: PyClass
 ) -> None:
-    ref = b.node(["PySymbol", "PyClass"], "signature", cl.signature, _class_props(cl, file_key))
+    ref = b.node(
+        ["PySymbol", "PyClass"], "signature", cl.signature, _class_props(cl, file_key)
+    )
     b.edge(parent_rel, parent, ref)
 
     for base in cl.base_classes or []:
@@ -158,7 +211,12 @@ def _project_class(
 def _project_callable(
     b: RowBuilder, file_key: str, owner: NodeRef, owner_rel: str, c: PyCallable
 ) -> None:
-    ref = b.node(["PySymbol", "PyCallable"], "signature", c.signature, _callable_props(c, file_key))
+    ref = b.node(
+        ["PySymbol", "PyCallable"],
+        "signature",
+        c.signature,
+        _callable_props(c, file_key),
+    )
     b.edge(owner_rel, owner, ref)
 
     for d in c.decorators or []:
@@ -166,7 +224,9 @@ def _project_callable(
 
     for s in c.call_sites or []:
         # Key off the relative file (a call site lives in its callable's file) so ids stay portable.
-        cs_id = f"{file_key}#{s.start_line}:{s.start_column}-{s.end_line}:{s.end_column}"
+        cs_id = (
+            f"{file_key}#{s.start_line}:{s.start_column}-{s.end_line}:{s.end_column}"
+        )
         cs = b.node(["PyCallSite"], "id", cs_id, _call_site_props(s, file_key))
         b.edge("PY_HAS_CALLSITE", ref, cs)
         if s.callee_signature:
@@ -189,7 +249,11 @@ def _project_attribute(
 
 
 def _project_variable(
-    b: RowBuilder, file_key: str, owner: NodeRef, owner_id: str, v: PyVariableDeclaration
+    b: RowBuilder,
+    file_key: str,
+    owner: NodeRef,
+    owner_id: str,
+    v: PyVariableDeclaration,
 ) -> None:
     var_id = f"{owner_id}#{v.name}@{v.start_line}"
     ref = b.node(["PyVariable"], "id", var_id, _variable_props(v, var_id, file_key))
@@ -258,6 +322,7 @@ def _attribute_props(a: PyClassAttribute, attr_id: str, file_key: str) -> Props:
             "id": attr_id,
             "name": a.name,
             "type": a.type,
+            "initializer": a.initializer,
             "docstring": _docstring_of(a.comments),
             "start_line": a.start_line,
             "end_line": a.end_line,
@@ -290,6 +355,7 @@ def _call_site_props(s: PyCallsite, file_key: str) -> Props:
             "receiver_expr": s.receiver_expr,
             "receiver_type": s.receiver_type,
             "argument_types": list(s.argument_types or []),
+            "arguments_json": _stringify_if(s.arguments),
             "return_type": s.return_type,
             "callee_signature": s.callee_signature,
             "is_constructor_call": s.is_constructor_call,