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

{codeanalyzer_python-0.3.0 → codeanalyzer_python-0.3.1}/.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.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: codeanalyzer-python
-Version: 0.3.0
+Version: 0.3.1
 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
@@ -181,6 +181,9 @@ $ canpy --help
  Static Analysis on Python source code using Jedi, PyCG and Tree sitter.
 
 ╭─ Options ────────────────────────────────────────────────────────────────────╮
+│ --version                                                   Show the canpy   │
+│                                                             version and      │
+│                                                             exit.            │
 │ --input            -i                     PATH              Path to the      │
 │                                                             project root     │
 │                                                             directory (not   │

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

@@ -144,6 +144,9 @@ $ canpy --help
  Static Analysis on Python source code using Jedi, PyCG and Tree sitter.
 
 ╭─ Options ────────────────────────────────────────────────────────────────────╮
+│ --version                                                   Show the canpy   │
+│                                                             version and      │
+│                                                             exit.            │
 │ --input            -i                     PATH              Path to the      │
 │                                                             project root     │
 │                                                             directory (not   │

{codeanalyzer_python-0.3.0 → codeanalyzer_python-0.3.1}/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.1}/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.1}/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.1}/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.1}/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,

codeanalyzer_python-0.3.0/codeanalyzer/neo4j/catalog.py → codeanalyzer_python-0.3.1/codeanalyzer/neo4j/schema.py

@@ -14,27 +14,28 @@
 # limitations under the License.
 ################################################################################
 
-"""The declarative Neo4j schema catalog — the single in-repo source of truth for
-the graph contract (node labels, their keys and typed properties, relationship
-types and their endpoints). ``--emit schema`` serializes this (with the DDL from
-:mod:`codeanalyzer.neo4j.schema`) to a machine-readable ``schema.json``, and the
-conformance test (``test/test_neo4j_schema.py``) asserts the real emitter never
-produces a label / relationship / property that isn't declared here — so this
-file cannot silently drift from :mod:`codeanalyzer.neo4j.project`.
-
-SCHEMA_VERSION is the contract version: bump MAJOR on a breaking change
-(renamed/removed label, relationship or key), MINOR on an additive change (new
-label/rel/property). It is stamped onto the ``:PyApplication`` node of every
-emitted graph so any consumer can detect a producer/consumer mismatch at runtime.
 """
+The declarative Neo4j schema — the single in-repo source of truth for the graph contract: node
+labels with their keys and typed properties, relationship types and their endpoints, and the
+Cypher DDL (uniqueness constraints + indexes). The constraints are DERIVED from the node labels
+(one per distinct mergeLabel/key) so a new label brings its own constraint — there is no second
+list to keep in sync. `--emit schema` serializes all of this to a machine-readable schema.json,
+and the conformance test (``test/test_neo4j_schema.py``) asserts the real emitter never produces a
+label / relationship / property that isn't declared here — so this file cannot silently drift
+from :mod:`codeanalyzer.neo4j.project`.
+
+SCHEMA_VERSION is the contract version: bump MAJOR on a breaking change (renamed/removed label,
+relationship or key), MINOR on an additive change (new label/rel/property). It is stamped onto
+the :PyApplication node of every emitted graph so any consumer can detect a producer/consumer
+mismatch at runtime.
+"""
+
 from __future__ import annotations
 
 from dataclasses import dataclass, field
 from typing import Dict, List
 
-from codeanalyzer.neo4j.schema import CONSTRAINTS, INDEXES
-
-SCHEMA_VERSION = "1.1.0"
+SCHEMA_VERSION = "1.2.0"
 
 # PropType ∈ {"string", "integer", "float", "boolean", "string[]", "integer[]"}.
 
@@ -66,7 +67,15 @@ NODE_LABELS: List[NodeLabel] = [
         "PyApplication",
         "PyApplication",
         "name",
-        {"name": "string", "schema_version": "string"},
+        {
+            "name": "string",
+            "schema_version": "string",
+            "analyzer_name": "string",
+            "analyzer_version": "string",
+            "repo_uri": "string",
+            "source_revision": "string",
+            "repo_dirty": "boolean",
+        },
     ),
     NodeLabel(
         "PyModule",
@@ -138,6 +147,7 @@ NODE_LABELS: List[NodeLabel] = [
             "receiver_expr": "string",
             "receiver_type": "string",
             "argument_types": "string[]",
+            "arguments_json": "string",
             "return_type": "string",
             "callee_signature": "string",
             "is_constructor_call": "boolean",
@@ -156,6 +166,7 @@ NODE_LABELS: List[NodeLabel] = [
             "id": "string",
             "name": "string",
             "type": "string",
+            "initializer": "string",
             "docstring": "string",
             **_SPAN,
             "_module": "string",
@@ -198,13 +209,42 @@ REL_TYPES: List[RelType] = [
     RelType(
         "PY_IMPORTS",
         ["PyModule"],
-        ["PyPackage"],
-        {"imported_names": "string[]", "aliases": "string[]"},
+        ["PyModule", "PyPackage"],
+        {"spellings": "string[]", "imported_names": "string[]", "aliases": "string[]"},
     ),
     RelType("PY_DECORATED_BY", ["PyCallable"], ["PyDecorator"]),
 ]
 
 
+def uniqueness_constraints() -> list[str]:
+    """One uniqueness constraint per distinct (merge_label, key)."""
+    seen: set[tuple[str, str]] = set()
+    out: list[str] = []
+
+    for node in NODE_LABELS:
+        identifier = (node.merge_label, node.key)
+        if identifier in seen:
+            continue
+
+        seen.add(identifier)
+        out.append(
+            f"CREATE CONSTRAINT {node.merge_label.lower()}_{node.key} "
+            f"IF NOT EXISTS FOR (x:{node.merge_label}) "
+            f"REQUIRE x.{node.key} IS UNIQUE"
+        )
+
+    return out
+
+
+CONSTRAINTS: List[str] = uniqueness_constraints()
+
+INDEXES: List[str] = [
+    "CREATE INDEX py_callable_name IF NOT EXISTS FOR (c:PyCallable) ON (c.name)",
+    "CREATE INDEX py_class_name IF NOT EXISTS FOR (c:PyClass) ON (c.name)",
+    "CREATE FULLTEXT INDEX py_code_fts IF NOT EXISTS FOR (c:PyCallable) ON EACH [c.code, c.docstring]",
+]
+
+
 @dataclass
 class SchemaDocument:
     schema_version: str

codeanalyzer_python-0.3.1/codeanalyzer/provenance.py

@@ -0,0 +1,61 @@
+"""Provenance capture: repository (git) and analyzer identity for a snapshot.
+
+Runs git only as a subprocess query against the analyzed project directory —
+never mutates anything. Absence of git (no repo, no binary) degrades to None.
+"""
+from __future__ import annotations
+
+import subprocess
+from importlib.metadata import PackageNotFoundError, version as _pkg_version
+from pathlib import Path
+from typing import Optional, Union
+from urllib.parse import urlsplit, urlunsplit
+
+from codeanalyzer.schema.py_schema import PyAnalyzerInfo, PyRepositoryInfo
+
+
+def _strip_userinfo(uri: str) -> str:
+    """Drop credentials from URL-style remotes; scp-style git@host:path is a
+    username, not a secret, and parses with no netloc — left intact."""
+    parts = urlsplit(uri)
+    if parts.netloc and "@" in parts.netloc:
+        return urlunsplit(parts._replace(netloc=parts.netloc.rpartition("@")[2]))
+    return uri
+
+
+def _git(project_dir: Union[Path, str], *args: str) -> Optional[str]:
+    """One git query; None on any failure (no repo, no git, timeout)."""
+    try:
+        result = subprocess.run(
+            ["git", "-C", str(project_dir), *args],
+            capture_output=True, text=True, timeout=10, check=False,
+        )
+    except (OSError, subprocess.TimeoutExpired):
+        return None
+    if result.returncode != 0:
+        return None
+    return result.stdout.strip()
+
+
+def repository_info(project_dir: Union[Path, str]) -> Optional[PyRepositoryInfo]:
+    """Git provenance of ``project_dir``, or None when it isn't a git checkout."""
+    revision = _git(project_dir, "rev-parse", "HEAD")
+    if not revision:
+        return None
+    raw_uri = _git(project_dir, "remote", "get-url", "origin")
+    uri = _strip_userinfo(raw_uri) if raw_uri else None
+    status = _git(project_dir, "status", "--porcelain", "--untracked-files=no")
+    return PyRepositoryInfo(uri=uri, revision=revision, dirty=bool(status))
+
+
+def analyzer_info(analysis_level: int) -> PyAnalyzerInfo:
+    """Identity + configuration of this analyzer run."""
+    try:
+        version = _pkg_version("codeanalyzer-python")
+    except PackageNotFoundError:
+        version = "unknown"
+    return PyAnalyzerInfo(
+        name="codeanalyzer-python",
+        version=version,
+        config={"analysis_level": analysis_level},
+    )

{codeanalyzer_python-0.3.0 → codeanalyzer_python-0.3.1}/codeanalyzer/schema/py_schema.py

@@ -176,6 +176,7 @@ class PyImport(BaseModel):
     module: str
     name: str
     alias: Optional[str] = None
+    resolved_module: Optional[str] = None
     start_line: int = -1
     end_line: int = -1
     start_column: int = -1
@@ -240,6 +241,19 @@ class PyCallableParameter(BaseModel):
     end_column: int = -1
 
 
+@builder
+@msgpk
+class PyCallArgument(BaseModel):
+    """One call-site argument: AST category + inferred type, kept separate.
+
+    The legacy ``PyCallsite.argument_types`` mixed these two vocabularies
+    in one list; this model is the disambiguated replacement (#86).
+    """
+
+    ast_kind: str
+    inferred_type: Optional[str] = None
+
+
 @builder
 @msgpk
 class PyCallsite(BaseModel):
@@ -249,6 +263,7 @@ class PyCallsite(BaseModel):
     receiver_expr: Optional[str] = None
     receiver_type: Optional[str] = None
     argument_types: List[str] = []
+    arguments: List[PyCallArgument] = []
     return_type: Optional[str] = None
     callee_signature: Optional[str] = None
     is_constructor_call: bool = False
@@ -295,6 +310,7 @@ class PyClassAttribute(BaseModel):
 
     name: str
     type: Optional[str] = None
+    initializer: Optional[str] = None
     comments: List[PyComment] = []
     start_line: int = -1
     end_line: int = -1
@@ -369,6 +385,26 @@ class PyExternalSymbol(BaseModel):
     module: Optional[str] = None  # best-effort owning module, e.g. "requests"
 
 
+@builder
+@msgpk
+class PyRepositoryInfo(BaseModel):
+    """Where the analyzed source came from: git provenance captured at analysis time."""
+
+    uri: Optional[str] = None
+    revision: str
+    dirty: bool = False
+
+
+@builder
+@msgpk
+class PyAnalyzerInfo(BaseModel):
+    """Which analyzer produced this snapshot, and how it was configured."""
+
+    name: str
+    version: str
+    config: Dict[str, Any] = {}
+
+
 @builder
 @msgpk
 class PyApplication(BaseModel):
@@ -380,3 +416,5 @@ class PyApplication(BaseModel):
     # builtin members), keyed by signature. Populated by the analyzer so every
     # backend (JSON and Neo4j) shares one authoritative external-symbol set.
     external_symbols: Dict[str, PyExternalSymbol] = {}
+    analyzer: Optional[PyAnalyzerInfo] = None
+    repository: Optional[PyRepositoryInfo] = None

codeanalyzer_python-0.3.1/codeanalyzer/syntactic_analysis/import_resolver.py

@@ -0,0 +1,67 @@
+"""Static resolution of import spellings against the analyzed module set.
+
+Pure post-pass over a built ``PyApplication``: no filesystem access, no
+sys.path semantics — a spelling resolves iff it names a module that was
+itself analyzed (issue #82). External/library imports stay unresolved by
+design and keep their :PyPackage projection.
+"""
+from __future__ import annotations
+
+import os
+from pathlib import Path
+from typing import Dict, Optional, Union
+
+from codeanalyzer.schema.py_schema import PyApplication
+
+
+def _dotted_candidates(app: PyApplication, project_dir: Union[Path, str]) -> Dict[str, str]:
+    """dotted module path -> file_key, for every analyzed module.
+
+    ``pkg/util.py`` -> ``pkg.util``; ``pkg/__init__.py`` -> ``pkg``.
+    file_keys share project_dir's form (both come from the same CLI arg),
+    so os.path.relpath keeps mixed absolute/relative setups consistent.
+    """
+    mapping: Dict[str, str] = {}
+    for file_key in app.symbol_table:
+        rel = os.path.relpath(file_key, str(project_dir))
+        if rel.startswith(".."):
+            continue
+        parts = Path(rel).with_suffix("").parts
+        if parts and parts[-1] == "__init__":
+            parts = parts[:-1]
+        if parts:
+            mapping[".".join(parts)] = file_key
+    return mapping
+
+
+def _resolve_one(
+    spelling: str, original_name: str, importer_rel_parts: tuple, candidates: Dict[str, str]
+) -> Optional[str]:
+    if spelling.startswith("."):
+        level = len(spelling) - len(spelling.lstrip("."))
+        suffix = spelling.lstrip(".")
+        # level 1 = the importer's own package; each extra dot walks one up.
+        package_parts = importer_rel_parts[:-1]  # drop the filename
+        if level - 1 > len(package_parts):
+            return None
+        base = package_parts[: len(package_parts) - (level - 1)]
+        stems = list(base) + (suffix.split(".") if suffix else [])
+    else:
+        stems = spelling.split(".")
+    dotted = ".".join(stems)
+    with_name = f"{dotted}.{original_name}" if dotted else original_name
+    return candidates.get(with_name) or candidates.get(dotted)
+
+
+def resolve_imports(app: PyApplication, project_dir: Union[Path, str]) -> None:
+    """Stamp ``resolved_module`` on every import of every module, in place."""
+    candidates = _dotted_candidates(app, project_dir)
+    for file_key, module in app.symbol_table.items():
+        rel = os.path.relpath(file_key, str(project_dir))
+        importer_parts = Path(rel).parts
+        for im in module.imports or []:
+            if not im.module:
+                im.resolved_module = None
+                continue
+            original = im.alias or im.name
+            im.resolved_module = _resolve_one(im.module, original, importer_parts, candidates)

{codeanalyzer_python-0.3.0 → codeanalyzer_python-0.3.1}/codeanalyzer/syntactic_analysis/symbol_table_builder.py

@@ -1,5 +1,6 @@
 import ast
 import hashlib
+import os
 import tokenize
 from ast import AST, ClassDef
 from io import StringIO
@@ -13,6 +14,7 @@ from jedi.api.project import Project
 from codeanalyzer.schema.py_schema import (
     PyCallable,
     PyCallableParameter,
+    PyCallArgument,
     PyCallsite,
     PyClass,
     PyClassAttribute,
@@ -28,7 +30,11 @@ class SymbolTableBuilder:
     """A class for building a symbol table for a Python project."""
 
     def __init__(self, project_dir: Union[Path, str], virtualenv: Union[Path, str, None]) -> None:
-        self.project_dir = Path(project_dir)
+        # Jedi reports absolute Script paths, so a relative project_dir would
+        # crash every relative_to() fallback below. abspath (not resolve())
+        # keeps symlinks intact, matching Jedi's own absolute()-style
+        # normalization under symlinked roots like macOS /tmp.
+        self.project_dir = Path(os.path.abspath(project_dir))
         if virtualenv is None:
             # If no virtual environment is provided, create a jedi project without an environment.
             self.jedi_project: Project = jedi.Project(path=self.project_dir)
@@ -39,6 +45,16 @@ class SymbolTableBuilder:
                 environment_path=Path(virtualenv) / "bin" / "python",
             )
 
+    def _fallback_signature(self, script_path: Union[Path, str], name: str) -> str:
+        """Path-derived qualified name used when Jedi can't name a definition.
+
+        Strips only the terminal ``.py`` suffix — a bare ``str.replace``
+        would also eat interior ``.py`` substrings and corrupt the module
+        prefix (``odoo/tools/pycompat.py`` → ``odoo.toolscompat``).
+        """
+        relative = Path(script_path).relative_to(self.project_dir)
+        return ".".join(relative.with_suffix("").parts) + f".{name}"
+
     @staticmethod
     def _infer_type(script: Script, line: int, column: int) -> str:
         """Tries to infer the type at a given position using Jedi."""
@@ -97,6 +113,44 @@ class SymbolTableBuilder:
         except Exception:
             return None, False
 
+    @staticmethod
+    def _callee_anchor(node: ast.Call) -> Tuple[int, int]:
+        """Position of the callee *name* for Jedi inference.
+
+        An ``ast.Call``'s own ``lineno``/``col_offset`` is the first
+        character of the whole call expression — for an attribute call
+        ``receiver.method(...)`` that is the receiver token, and Jedi
+        would infer the receiver's type instead of the invoked method
+        (issue #80). Anchor attribute calls inside the attribute name —
+        its last character, so one-character names stay in range; other
+        callee shapes keep the call-expression start.
+        """
+        func_expr = node.func
+        if isinstance(func_expr, ast.Attribute):
+            return func_expr.end_lineno, func_expr.end_col_offset - 1
+        return node.lineno, node.col_offset
+
+    @staticmethod
+    def _infer_call_return_type(script: Script, line: int, column: int) -> Optional[str]:
+        """Inferred type of the call's *result*, not of the callee itself.
+
+        ``Script.infer`` at the callee name yields the function/class
+        being called; executing that definition yields what the call
+        evaluates to — a function's inferred return type, or the
+        instance for a constructor call. Returns ``None`` when Jedi
+        can't tell, so an unknown stays absent instead of masquerading
+        as the callee's own name.
+        """
+        try:
+            definitions = script.infer(line=line, column=column)
+            if definitions:
+                results = definitions[0].execute()
+                if results:
+                    return results[0].name
+        except Exception:
+            pass
+        return None
+
     def build_pymodule_from_file(self, py_file: Path) -> PyModule:
         """Builds a PyModule from a Python file.
 
@@ -203,10 +257,10 @@ class SymbolTableBuilder:
                     definitions = script.goto(line=start_line, column=child.col_offset)
                     signature = next(
                         (d.full_name for d in definitions if d.type == "class"),
-                        f"{Path(script.path).relative_to(self.project_dir).__str__().replace('/', '.').replace('.py', '')}.{class_name}"
+                        self._fallback_signature(script.path, class_name),
                     )
                 except Exception:
-                    signature = f"{Path(script.path).relative_to(self.project_dir).__str__().replace('/', '.').replace('.py', '')}.{class_name}"
+                    signature = self._fallback_signature(script.path, class_name)
             py_class = (
                 PyClass.builder()
                 .name(class_name)
@@ -258,8 +312,7 @@ class SymbolTableBuilder:
                     
                     # If Jedi didn't provide a signature, build one relative to project_dir
                     if not signature:
-                        relative_path = Path(script.path).relative_to(self.project_dir)
-                        signature = f"{str(relative_path).replace('/', '.').replace('.py', '')}.{method_name}"
+                        signature = self._fallback_signature(script.path, method_name)
                 py_callable = (
                     PyCallable.builder()
                     .name(method_name)  # Use the actual method name, not the full signature
@@ -380,6 +433,7 @@ class SymbolTableBuilder:
                                     script, target.lineno, target.col_offset
                                 )
                             )
+                            .initializer(ast.unparse(stmt.value) if stmt.value else None)
                             .start_line(getattr(target, "lineno", -1))
                             .end_line(getattr(stmt, "end_lineno", stmt.lineno))
                             .build()
@@ -398,6 +452,7 @@ class SymbolTableBuilder:
                                 script, target.lineno, target.col_offset
                             )
                         )
+                        .initializer(ast.unparse(stmt.value) if stmt.value else None)
                         .start_line(getattr(target, "lineno", -1))
                         .end_line(getattr(stmt, "end_lineno", stmt.lineno))
                         .build()
@@ -588,10 +643,11 @@ class SymbolTableBuilder:
             func_expr = node.func
 
             method_name = "<unknown>"
+            anchor_line, anchor_col = self._callee_anchor(node)
             callee_signature, is_constructor = self._infer_callee(
-                script, node.lineno, node.col_offset
+                script, anchor_line, anchor_col
             )
-            return_type = self._infer_type(script, node.lineno, node.col_offset)
+            return_type = self._infer_call_return_type(script, anchor_line, anchor_col)
 
             receiver_expr = None
             receiver_type = None
@@ -604,18 +660,26 @@ class SymbolTableBuilder:
             elif isinstance(func_expr, ast.Name):
                 method_name = func_expr.id
 
-            argument_types = [
-                self._infer_type(script, arg.lineno, arg.col_offset)
-                or type(arg).__name__
+            arguments = [
+                PyCallArgument(
+                    ast_kind=type(arg).__name__,
+                    inferred_type=self._infer_type(script, arg.lineno, arg.col_offset),
+                )
                 for arg in node.args
             ]
 
+            # Legacy field, derived from the structured arguments above rather
+            # than re-inferring: byte-identical to the old
+            # `self._infer_type(...) or type(arg).__name__` per argument.
+            argument_types = [a.inferred_type or a.ast_kind for a in arguments]
+
             call_sites.append(
                 PyCallsite.builder()
                 .method_name(method_name)
                 .receiver_expr(receiver_expr)
                 .receiver_type(receiver_type)
                 .argument_types(argument_types)
+                .arguments(arguments)
                 .return_type(return_type)
                 .callee_signature(callee_signature)
                 .is_constructor_call(is_constructor)

{codeanalyzer_python-0.3.0 → codeanalyzer_python-0.3.1}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "codeanalyzer-python"
-version = "0.3.0"
+version = "0.3.1"
 description = "Static Analysis on Python source code using Jedi, CodeQL and Treesitter — emits analysis.json or a Neo4j property graph."
 readme = "README.md"
 authors = [

{codeanalyzer_python-0.3.0 → codeanalyzer_python-0.3.1}/schema.neo4j.json

@@ -1,5 +1,5 @@
 {
-  "schema_version": "1.1.0",
+  "schema_version": "1.2.0",
   "generator": "codeanalyzer-python",
   "marker_labels": [],
   "node_labels": [
@@ -9,7 +9,12 @@
       "key": "name",
       "properties": {
         "name": "string",
-        "schema_version": "string"
+        "schema_version": "string",
+        "analyzer_name": "string",
+        "analyzer_version": "string",
+        "repo_uri": "string",
+        "source_revision": "string",
+        "repo_dirty": "boolean"
       }
     },
     {
@@ -97,6 +102,7 @@
         "receiver_expr": "string",
         "receiver_type": "string",
         "argument_types": "string[]",
+        "arguments_json": "string",
         "return_type": "string",
         "callee_signature": "string",
         "is_constructor_call": "boolean",
@@ -115,6 +121,7 @@
         "id": "string",
         "name": "string",
         "type": "string",
+        "initializer": "string",
         "docstring": "string",
         "start_line": "integer",
         "end_line": "integer",
@@ -244,9 +251,11 @@
         "PyModule"
       ],
       "to": [
+        "PyModule",
         "PyPackage"
       ],
       "properties": {
+        "spellings": "string[]",
         "imported_names": "string[]",
         "aliases": "string[]"
       }
@@ -263,14 +272,14 @@
     }
   ],
   "constraints": [
-    "CREATE CONSTRAINT py_symbol_sig IF NOT EXISTS FOR (s:PySymbol) REQUIRE s.signature IS UNIQUE",
-    "CREATE CONSTRAINT py_app_name IF NOT EXISTS FOR (a:PyApplication) REQUIRE a.name IS UNIQUE",
-    "CREATE CONSTRAINT py_module_key IF NOT EXISTS FOR (m:PyModule) REQUIRE m.file_key IS UNIQUE",
-    "CREATE CONSTRAINT py_package_name IF NOT EXISTS FOR (p:PyPackage) REQUIRE p.name IS UNIQUE",
-    "CREATE CONSTRAINT py_decorator_name IF NOT EXISTS FOR (d:PyDecorator) REQUIRE d.name IS UNIQUE",
-    "CREATE CONSTRAINT py_callsite_id IF NOT EXISTS FOR (c:PyCallSite) REQUIRE c.id IS UNIQUE",
-    "CREATE CONSTRAINT py_attribute_id IF NOT EXISTS FOR (a:PyAttribute) REQUIRE a.id IS UNIQUE",
-    "CREATE CONSTRAINT py_variable_id IF NOT EXISTS FOR (v:PyVariable) REQUIRE v.id IS UNIQUE"
+    "CREATE CONSTRAINT pyapplication_name IF NOT EXISTS FOR (x:PyApplication) REQUIRE x.name IS UNIQUE",
+    "CREATE CONSTRAINT pymodule_file_key IF NOT EXISTS FOR (x:PyModule) REQUIRE x.file_key IS UNIQUE",
+    "CREATE CONSTRAINT pysymbol_signature IF NOT EXISTS FOR (x:PySymbol) REQUIRE x.signature IS UNIQUE",
+    "CREATE CONSTRAINT pypackage_name IF NOT EXISTS FOR (x:PyPackage) REQUIRE x.name IS UNIQUE",
+    "CREATE CONSTRAINT pydecorator_name IF NOT EXISTS FOR (x:PyDecorator) REQUIRE x.name IS UNIQUE",
+    "CREATE CONSTRAINT pycallsite_id IF NOT EXISTS FOR (x:PyCallSite) REQUIRE x.id IS UNIQUE",
+    "CREATE CONSTRAINT pyattribute_id IF NOT EXISTS FOR (x:PyAttribute) REQUIRE x.id IS UNIQUE",
+    "CREATE CONSTRAINT pyvariable_id IF NOT EXISTS FOR (x:PyVariable) REQUIRE x.id IS UNIQUE"
   ],
   "indexes": [
     "CREATE INDEX py_callable_name IF NOT EXISTS FOR (c:PyCallable) ON (c.name)",

codeanalyzer_python-0.3.0/codeanalyzer/neo4j/schema.py

@@ -1,39 +0,0 @@
-################################################################################
-# Copyright IBM Corporation 2025
-#
-# Licensed under the Apache License, Version 2.0 (the "License");
-# you may not use this file except in compliance with the License.
-# You may obtain a copy of the License at
-#
-#       http://www.apache.org/licenses/LICENSE-2.0
-#
-# Unless required by applicable law or agreed to in writing, software
-# distributed under the License is distributed on an "AS IS" BASIS,
-# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-# See the License for the specific language governing permissions and
-# limitations under the License.
-################################################################################
-
-"""The Cypher DDL — uniqueness constraints and indexes — shared by both writers.
-Run BEFORE any load so MERGE uses an index seek (not a label scan) and the
-identity invariant is enforced by the database. Every statement is idempotent
-(``IF NOT EXISTS``).
-"""
-from typing import List
-
-CONSTRAINTS: List[str] = [
-    "CREATE CONSTRAINT py_symbol_sig IF NOT EXISTS FOR (s:PySymbol) REQUIRE s.signature IS UNIQUE",
-    "CREATE CONSTRAINT py_app_name IF NOT EXISTS FOR (a:PyApplication) REQUIRE a.name IS UNIQUE",
-    "CREATE CONSTRAINT py_module_key IF NOT EXISTS FOR (m:PyModule) REQUIRE m.file_key IS UNIQUE",
-    "CREATE CONSTRAINT py_package_name IF NOT EXISTS FOR (p:PyPackage) REQUIRE p.name IS UNIQUE",
-    "CREATE CONSTRAINT py_decorator_name IF NOT EXISTS FOR (d:PyDecorator) REQUIRE d.name IS UNIQUE",
-    "CREATE CONSTRAINT py_callsite_id IF NOT EXISTS FOR (c:PyCallSite) REQUIRE c.id IS UNIQUE",
-    "CREATE CONSTRAINT py_attribute_id IF NOT EXISTS FOR (a:PyAttribute) REQUIRE a.id IS UNIQUE",
-    "CREATE CONSTRAINT py_variable_id IF NOT EXISTS FOR (v:PyVariable) REQUIRE v.id IS UNIQUE",
-]
-
-INDEXES: List[str] = [
-    "CREATE INDEX py_callable_name IF NOT EXISTS FOR (c:PyCallable) ON (c.name)",
-    "CREATE INDEX py_class_name IF NOT EXISTS FOR (c:PyClass) ON (c.name)",
-    "CREATE FULLTEXT INDEX py_code_fts IF NOT EXISTS FOR (c:PyCallable) ON EACH [c.code, c.docstring]",
-]