codeanalyzer-python 1.1.1__py3-none-any.whl → 1.3.0__py3-none-any.whl

codeanalyzer/__main__.py

@@ -1,8 +1,9 @@
+import json
 import os
 import sys
 from importlib.metadata import version as _pkg_version, PackageNotFoundError
 from pathlib import Path
-from typing import Optional, Annotated
+from typing import List, Optional, Annotated
 
 import typer
 
@@ -10,7 +11,7 @@ import typer
 def _pin_hash_seed() -> None:
     """Re-exec once with ``PYTHONHASHSEED=0`` unless the caller pinned one.
 
-    PyCG's capped fixpoint (``--pycg-max-iter``) iterates hash-ordered sets
+    Jedi's inference (and any hash-ordered iteration in the pipeline) walks sets
     keyed on module/access-path strings, so an unpinned per-interpreter hash
     seed makes the emitted L2+ call graph vary run to run (issue #99). The
     seed cannot be set after interpreter start, hence the exec. Export
@@ -37,9 +38,8 @@ def _pin_hash_seed() -> None:
 
 from codeanalyzer.core import Codeanalyzer
 from codeanalyzer.utils import _set_log_level, logger
-from codeanalyzer.config import OutputFormat
-from codeanalyzer.schema import model_dump_json
-from codeanalyzer.options import AnalysisOptions, EmitTarget, ShardStrategy
+from codeanalyzer.schema import model_dump, model_dump_json, strip_internal_only
+from codeanalyzer.options import AnalysisOptions, EmitTarget
 
 
 def _version_callback(value: bool) -> None:
@@ -80,15 +80,6 @@ def main(
         Optional[Path],
         typer.Option("-o", "--output", help="Output directory for artifacts."),
     ] = None,
-    format: Annotated[
-        OutputFormat,
-        typer.Option(
-            "-f",
-            "--format",
-            help="Output format for --emit json: json or msgpack.",
-            case_sensitive=False,
-        ),
-    ] = OutputFormat.JSON,
     emit: Annotated[
         EmitTarget,
         typer.Option(
@@ -141,26 +132,31 @@ def main(
         ),
     ] = None,
     analysis_level: Annotated[
-        int,
+        Optional[int],
         typer.Option(
             "-a",
             "--analysis-level",
-            help="Analysis depth: 1=symbol table+Jedi call graph, 2=+PyCG call "
+            help="Analysis depth: 1=symbol table+Jedi call graph, 2=+defuse-linker call "
             "graph, 3=+native intraprocedural dataflow (CFG/PDG), "
-            "4=+interprocedural SDG (param/summary edges, alias-aware DDG).",
+            "4=+interprocedural SDG (param/summary edges, alias-aware DDG). "
+            "[default: 1; incompatible with --emit neo4j, which is always "
+            "full-depth]",
             min=1,
             max=4,
+            show_default="1",
         ),
-    ] = 1,
+    ] = None,
     graphs: Annotated[
-        str,
+        Optional[str],
         typer.Option(
             "--graphs",
             help="Level 3+ only: comma-separated program-graph sections to emit "
             "(cfg, dfg, pdg, sdg). Default: cfg,dfg,pdg. `dfg` emits the PDG's data "
-            "edges only; `sdg` requires -a 4.",
+            "edges only; `sdg` requires -a 4. Incompatible with --emit neo4j "
+            "(always full-depth).",
+            show_default="cfg,dfg,pdg",
         ),
-    ] = "cfg,dfg,pdg",
+    ] = None,
     graph_field_depth: Annotated[
         int,
         typer.Option(
@@ -197,6 +193,14 @@ def main(
             "imports against the ambient Python environment instead.",
         ),
     ] = False,
+    resolve_installed: Annotated[
+        bool,
+        typer.Option(
+            "--resolve-installed",
+            help="Additionally bind imports via the project venv's installed metadata "
+            "(*.dist-info); output becomes machine-dependent (prov: installed-metadata).",
+        ),
+    ] = False,
     file_name: Annotated[
         Optional[Path],
         typer.Option(
@@ -222,87 +226,72 @@ def main(
     verbosity: Annotated[
         int, typer.Option("-v", count=True, help="Increase verbosity: -v, -vv, -vvv")
     ] = 0,
-    pycg_shard: Annotated[
-        bool,
-        typer.Option(
-            "--pycg-shard/--no-pycg-shard",
-            help=(
-                "Shard PyCG call-graph analysis by Python package (level 2 only). "
-                "When the project exceeds the 500-file ceiling, PyCG is run "
-                "independently per top-level package with cross-package imports "
-                "treated as ghost nodes. Without this flag, projects over the "
-                "ceiling fall back to Jedi-only edges."
-            ),
-        ),
-    ] = False,
-    pycg_shard_ceiling: Annotated[
-        int,
-        typer.Option(
-            "--pycg-shard-ceiling",
-            help=(
-                "Maximum files per shard when --pycg-shard is active (default 100). "
-                "Shards exceeding this limit are skipped; their call edges are "
-                "omitted from the call graph (Jedi edges for those packages are "
-                "still included). Lower values are safer for packages with deep "
-                "class hierarchies or heavy import graphs."
-            ),
-            min=1,
-        ),
-    ] = 100,
-    pycg_shard_timeout: Annotated[
-        int,
+    entrypoint_rules: Annotated[
+        Optional[List[Path]],
         typer.Option(
-            "--pycg-shard-timeout",
-            help=(
-                "Per-shard wall-clock timeout in seconds when --pycg-shard is "
-                "active (default 120). A shard that exceeds this limit is skipped "
-                "gracefully. PyCG's fixpoint is bimodal: it either converges "
-                "quickly or diverges indefinitely, so the timeout acts as a final "
-                "safety net after the file-count ceiling. Set to 0 to disable. "
-                "POSIX only (macOS / Linux); ignored on Windows."
-            ),
-            min=0,
+            "--entrypoint-rules",
+            help="Extra entrypoint rules file (YAML). Repeatable; merges with "
+            "the shipped rules. A malformed file is an error.",
         ),
-    ] = 120,
-    pycg_shard_strategy: Annotated[
-        ShardStrategy,
+    ] = None,
+    artifact_text: Annotated[
+        bool,
         typer.Option(
-            "--pycg-shard-strategy",
-            help=(
-                "How --pycg-shard groups files (level 2 only). 'jedi' (default) "
-                "partitions the Jedi module-dependency graph (SCC + Louvain) so "
-                "tightly-coupled modules co-compute and few call edges are "
-                "severed between shards; import cycles are never split. "
-                "'package' uses the legacy one-shard-per-package-directory "
-                "grouping."
-            ),
+            "--artifact-text/--no-artifact-text",
+            help="Capture verbatim `source` text on discovered artifacts. "
+            "--no-artifact-text empties `source` everywhere (inventory unchanged).",
         ),
-    ] = ShardStrategy.JEDI,
-    pycg_max_iter: Annotated[
+    ] = True,
+    artifact_text_max_bytes: Annotated[
         int,
         typer.Option(
-            "--pycg-max-iter",
-            help=(
-                "Cap on PyCG's fixpoint passes per shard/project (level 2; "
-                "default 50). PyCG iterates until its points-to state stops "
-                "changing, but its access-path domain has no convergence bound, "
-                "so heavy metaclass/mixin code (e.g. an ORM) can loop with each "
-                "pass costing seconds. The cap returns a sound-but-incomplete "
-                "call graph instead of looping until the timeout kills it. "
-                "Set to -1 for PyCG's unbounded run-to-convergence behaviour."
-            ),
-            min=-1,
+            "--artifact-text-max-bytes",
+            help="Per-file byte cap on captured artifact `source`; a decodable "
+            "file over the cap is truncated (text_truncated=True). "
+            "sha256/size_bytes always reflect the full file.",
+            min=1,
         ),
-    ] = 50,
+    ] = 262144,
 ):
     # Determinism: pin the interpreter hash seed before any analysis (no-op
     # when PYTHONHASHSEED is already set; --version exits before this).
     _pin_hash_seed()
 
     # Flag validation (strict: unrecognized values error out, never fall back).
-    selected_graphs = [g.strip() for g in graphs.split(",") if g.strip()]
+    # -a and --graphs use None sentinels so an explicitly-passed flag is
+    # distinguishable from the default (#119).
+    explicit_level = analysis_level is not None
+    explicit_graphs = graphs is not None
+
+    # Neo4j is always full-depth (#119): the graph carries every level's
+    # facts, so depth/section selectors cannot be combined with it — reject
+    # explicitly-passed flags and force level 4 with every graph section.
     from codeanalyzer.dataflow.builder import VALID_GRAPHS
 
+    if emit == EmitTarget.NEO4J:
+        explicit = [
+            flag
+            for flag, was_explicit in (
+                ("-a/--analysis-level", explicit_level),
+                ("--graphs", explicit_graphs),
+            )
+            if was_explicit
+        ]
+        if explicit:
+            logger.error(
+                "--emit neo4j is always full-depth (level 4, all graph "
+                f"sections); {' and '.join(explicit)} cannot be combined with it."
+            )
+            raise typer.Exit(code=2)
+        analysis_level = 4
+        graphs = ",".join(VALID_GRAPHS)
+
+    if analysis_level is None:
+        analysis_level = 1
+    if graphs is None:
+        graphs = "cfg,dfg,pdg"
+    selected_graphs = [g.strip() for g in graphs.split(",") if g.strip()]
+
     unknown_graphs = [g for g in selected_graphs if g not in VALID_GRAPHS]
     if unknown_graphs:
         logger.error(
@@ -316,7 +305,7 @@ def main(
     if "sdg" in selected_graphs and analysis_level < 4:
         logger.error("--graphs sdg requires -a 4 (interprocedural SDG).")
         raise typer.Exit(code=2)
-    if analysis_level < 3 and graphs != "cfg,dfg,pdg":
+    if analysis_level < 3 and explicit_graphs:
         logger.error("--graphs is a level-3 option; pass -a 3 to emit program graphs.")
         raise typer.Exit(code=2)
     if analysis_level < 3 and graph_field_depth != 3:
@@ -326,7 +315,7 @@ def main(
     options = AnalysisOptions(
         input=input,
         output=output,
-        format=format,
+
         emit=emit,
         app_name=app_name,
         neo4j_uri=neo4j_uri,
@@ -340,19 +329,32 @@ def main(
         rebuild_analysis=rebuild_analysis,
         skip_tests=skip_tests,
         no_venv=no_venv,
+        resolve_installed=resolve_installed,
         file_name=file_name,
         cache_dir=cache_dir,
         clear_cache=clear_cache,
         verbosity=verbosity,
-        pycg_shard=pycg_shard,
-        pycg_shard_ceiling=pycg_shard_ceiling,
-        pycg_shard_timeout=pycg_shard_timeout,
-        pycg_shard_strategy=pycg_shard_strategy,
-        pycg_max_iter=pycg_max_iter,
+        entrypoint_rules=tuple(entrypoint_rules or ()),
+        artifact_text=artifact_text,
+        artifact_text_max_bytes=artifact_text_max_bytes,
     )
 
     _set_log_level(options.verbosity)
 
+    # Entrypoint rules are configuration, validated before any analysis work
+    # starts (#122 review) -- a typo must fail in milliseconds, not after the
+    # symbol table, venv build, Jedi and the defuse linker have all run. `detect_entrypoints`
+    # loads the rules again at its own call site; that second load is cheap
+    # and keeps the entrypoints pipeline self-contained.
+    if options.entrypoint_rules:
+        from codeanalyzer.entrypoints.rules import RulesError, load_rules
+
+        try:
+            load_rules(options.entrypoint_rules)
+        except RulesError as exc:
+            logger.error(f"Invalid --entrypoint-rules: {exc}")
+            raise typer.Exit(code=1)
+
     # The schema contract is a static artifact — no project analysis required.
     if options.emit == EmitTarget.SCHEMA:
         from codeanalyzer.neo4j.emit import emit_schema
@@ -392,37 +394,36 @@ def main(
 
             emit_neo4j(artifacts, options)
         elif options.output is None:
-            print(model_dump_json(artifacts, exclude_none=True))
+            print(
+                json.dumps(
+                    strip_internal_only(
+                        model_dump(artifacts, mode="json", exclude_none=True)
+                    )
+                )
+            )
         else:
             options.output.mkdir(parents=True, exist_ok=True)
-            _write_output(artifacts, options.output, options.format)
-
-
-def _write_output(artifacts, output_dir: Path, format: OutputFormat):
-    """Write artifacts to file in the specified format."""
-    if format == OutputFormat.JSON:
-        output_file = output_dir / "analysis.json"
-        # Use Pydantic's model_dump_json() for compact output
-        json_str = model_dump_json(artifacts, indent=None, exclude_none=True)
-        with output_file.open("w") as f:
-            f.write(json_str)
-        logger.info(f"Analysis saved to {output_file}")
-
-    elif format == OutputFormat.MSGPACK:
-        output_file = output_dir / "analysis.msgpack"
-        msgpack_data = artifacts.to_msgpack_bytes()
-        with output_file.open("wb") as f:
-            f.write(msgpack_data)
-        logger.info(f"Analysis saved to {output_file}")
-        logger.info(
-            f"Compression ratio: {artifacts.get_compression_ratio():.1%} of JSON size"
-        )
+            _write_output(artifacts, options.output)
+
+
+def _write_output(artifacts, output_dir: Path):
+    """Write analysis.json (the single wire format since #118)."""
+    output_file = output_dir / "analysis.json"
+    # Use Pydantic's model_dump_json() for compact output
+    # Strip internal-only fields here rather than with a field-level Pydantic
+    # `exclude`: the analysis cache shares the serializer and must keep them.
+    json_str = json.dumps(
+        strip_internal_only(model_dump(artifacts, mode="json", exclude_none=True))
+    )
+    with output_file.open("w") as f:
+        f.write(json_str)
+    logger.info(f"Analysis saved to {output_file}")
 
 
 app = typer.Typer(
     callback=main,
     name="canpy",
-    help="Static Analysis on Python source code using Jedi, PyCG and Tree sitter.",
+    help="Static Analysis on Python source code using Jedi and Tree sitter.",
     invoke_without_command=True,
     no_args_is_help=True,
     add_completion=False,

codeanalyzer/artifacts/__init__.py

@@ -0,0 +1,20 @@
+"""Non-code artifact capture and dependency extraction (spec 2026-08-27).
+
+Capture never drops a file (every non-`.py` file becomes a
+:class:`~codeanalyzer.schema.py_schema.PyArtifact`, rule-matched or not,
+text or binary -- issue #157 follow-up); extraction is narrow (only
+dependency manifests are parsed for meaning in this unit)."""
+
+from codeanalyzer.artifacts.config_keys import extract_config_keys, is_config_eligible
+from codeanalyzer.artifacts.config_use import (
+    dataflow_intra_tier, dataflow_interproc_tier, detect_config_reads, resolve_uses,
+)
+from codeanalyzer.artifacts.dependencies import build_dependency_view
+from codeanalyzer.artifacts.discovery import discover_artifacts
+
+__all__ = [
+    "discover_artifacts", "build_dependency_view",
+    "extract_config_keys", "is_config_eligible",
+    "detect_config_reads", "resolve_uses",
+    "dataflow_intra_tier", "dataflow_interproc_tier",
+]