hypergumbo-lang-scip-python 8.1.0__tar.gz

hypergumbo_lang_scip_python-8.1.0/.gitignore

@@ -0,0 +1,117 @@
+# python
+__pycache__/
+*.py[cod]
+*.egg-info/
+dist/
+build/
+.venv/
+.env
+
+# tooling
+.pytest_cache/
+.mypy_cache/
+.ruff_cache/
+.hypothesis/
+
+# hypergumbo
+.hypergumbo/
+hypergumbo_capsule/
+hypergumbo.results.json
+hypergumbo.results.*.json
+slice.json
+slice.*.json
+
+# Agent configuration
+**/*.local.json
+**/*.local.md
+**/.claude/cache/
+**/.gemini/cache/
+**/.cursor/state/
+**/*-session/
+AUTONOMOUS_MODE.txt
+autonomous_intent.txt
+.agent/LOOP
+.agent/disabled.LOOP
+.agent/invariant-ledger.md
+# WI-zonur edit-mode log (per-checkout, OS-owned by the human user; the agent
+# can't unlink it, so it MUST never reach git or sync code paths).
+.agent/tracker/.edit-mode/
+.agent/tracker-workspace/.edit-mode/
+# Defense-in-depth: the previous (now-fixed) placement was inside .ops/. Match
+# any stray .edit-mode/ subdir so a stale checkout doesn't re-introduce the
+# files that PR #4045 accidentally committed.
+.agent/tracker/.ops/.edit-mode/
+.agent/tracker-workspace/.ops/.edit-mode/
+# Per-session transcript pipeline (ADR-0018, per-session amendment 2026-04-08).
+# Each session writes per-session-keyed files. The .last_*/.second_to_last_*
+# global slots are written at session END by rotate-on-session-end.sh.
+.agent/.current_session_transcript.*.jsonl
+.agent/.current_injection_history.*.jsonl
+.agent/.transcript-sync.*.pid
+.agent/.transcript-sync-state.*.json
+.agent/.transcript-poll-state.*
+.agent/.transcript-injection-state.*.json
+.agent/.transcript-injection-state.*.lock
+.agent/.last_session_transcript.jsonl
+.agent/.second_to_last_transcript.jsonl
+.agent/.last_injection_history.jsonl
+.agent/.second_to_last_injection_history.jsonl
+.agent/.archived-transcripts/
+
+# Plaintext secret list consumed by .agent/hooks/_shared/scrub-secrets.py at
+# every transcript-retention point. Holds real credentials -- never commit it.
+# A committed .example sibling documents the format.
+.secrets_for_scrubbing_upon_archive.txt
+
+# Atomic-replace temp files from scrub_secrets.py. A SIGKILL mid-scrub leaves
+# one behind holding transcript content; never commit it.
+.agent/.scrub-*
+.agent/.rotation.lock
+# Legacy paths from before the per-session amendment (ignored for one-time
+# upgrade-cleanup safety; may be removed once no repo still has these).
+.agent/.current_session_transcript.jsonl
+.agent/.transcript-sync.pid
+.agent/.transcript-sync-state.json
+.agent/.transcript-poll-state
+.agent/.transcript-injection-state.json
+.agent/.transcript-session-token
+.agent/.current_injection_history.jsonl
+hook-canary.txt
+
+# Coverage
+.coverage
+.coverage.*
+htmlcov/
+coverage-report.txt
+
+# Snapshot reports (pytest-textual-snapshot)
+snapshot_report.html
+
+# Node (bats testing)
+node_modules/
+package.json
+package-lock.json
+
+# htrac-frontend: allow tracked JS/TS project files
+!packages/htrac-frontend/package.json
+!packages/htrac-frontend/package-lock.json
+
+# Hypergumbo cache
+.hypergumbo_cache/
+.ci/pytest-output.log
+.ci/pytest-results.xml
+.ci/smart-test-fallback.log
+# Rewritten by the coverage-directed selector on every run (shadow phase).
+.ci/selection-shadow.json
+
+# Tracker
+**/config.yaml
+!**/config.yaml.template
+.agent/.cache-*.db
+.agent/.sync-logs/
+.agent/.training-data.jsonl
+.agent/.training-data-selected.jsonl
+.agent/.training-data-v1-snapshot-*.jsonl
+.agent/.deprecated-datasets/
+.agent/finetuned-model/
+.agent/transcript-model.gguf

hypergumbo_lang_scip_python-8.1.0/PKG-INFO

@@ -0,0 +1,84 @@
+Metadata-Version: 2.5
+Name: hypergumbo-lang-scip-python
+Version: 8.1.0
+Summary: SCIP-backed Python analyzer for hypergumbo (scip-python / pyright integration)
+Author: Hypergumbo contributors
+License: AGPL-3.0-or-later
+Keywords: code-graph,pyright,python,scip,static-analysis
+Classifier: Development Status :: 3 - Alpha
+Classifier: License :: OSI Approved :: GNU Affero General Public License v3 or later (AGPLv3+)
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3 :: Only
+Requires-Python: >=3.10
+Requires-Dist: hypergumbo-core==8.1.0
+Requires-Dist: hypergumbo-lang-mainstream==8.1.0
+Description-Content-Type: text/markdown
+
+<!-- SPDX-License-Identifier: AGPL-3.0-or-later -->
+# hypergumbo-lang-scip-python
+
+SCIP-backed Python analyzer for hypergumbo, driven by
+[scip-python](https://github.com/sourcegraph/scip-python) (pyright).
+
+This optional package is the second opt-in fidelity backend (after
+`hypergumbo-lang-rust-analyzer`) and the first that **executes nothing** from
+the analysed repository: pyright performs static inference only. It runs
+*beside* the ast-based `python` analyzer, never instead of it — the two
+producers' records for one declaration are folded into one node by the
+ADR-0057 merge pass, and every disagreement stays visible in the provenance
+slot.
+
+## What it adds, measured
+
+On hypergumbo-core's own 179 source files (2026-09-19, scip-python 0.6.6):
+the syntax arm left 4,133 method-call receivers untyped (`obj.method()` with
+`obj` of unknown module); scip-python typed **3,973 of them (96.1%)** — 3,840
+to the stdlib (`builtins.str`, `dict`, `list`, `pathlib.Path`, `re.Pattern`, …),
+96 in-repo, 37 third-party. That module is what `hypergumbo verify-claims`'s
+I/O-boundary and taint verdicts key on. The Rust backend measured zero
+receivers typed.
+
+## Enabling it
+
+```
+npm install -g @sourcegraph/scip-python@0.6.6     # the producer (node + npm)
+pipx install 'hypergumbo[scip-python]'            # this wrapper
+hypergumbo survey . --backend scip-python         # one run
+```
+
+Durably, as a preference in either ADR-0045 config tier (allowed because the
+backend executes nothing):
+
+```toml
+# $XDG_CONFIG_HOME/hypergumbo/config.toml  or  <repo>/.hypergumbo.toml
+[backends]
+scip_python = true
+```
+
+`HYPERGUMBO_SCIP_PYTHON=1` is the environment spelling; `--backend tree-sitter`
+turns every opt-in backend off for one run. Precedence: flag > environment >
+project config > user config.
+
+When enabled but the binary or this package is missing, the CLI exits 2 with
+the install line rather than silently falling through.
+
+## What the translation does with scip-python's output
+
+- Global definitions become `Symbol`s through the shared importer
+  (`hypergumbo_core.scip`); scip-python declares no `Document.language` and
+  no `SymbolInformation.kind`, so the importer reads the file extension and
+  the SCIP descriptor grammar instead.
+- Parameter symbols and the per-module `__init__:` declaration are dropped:
+  the syntax arm models neither, and a node nothing can pair with is noise.
+- References to in-repo definitions become `calls` / `references` edges.
+- References to **external** callables (stdlib, third-party) become external
+  call edges carrying the receiver's module — `python:pathlib.Path:0-0:glob:unresolved`
+  with a structured `dst_ref` — the same shape the syntax arm mints when it
+  knows the module, so the two arms are comparable at every call site.
+
+## Recorded fixture
+
+`recorded/sample_project/` is a three-file package and the `index.scip`
+scip-python 0.6.6 emitted for it (`metadata.project_root` normalised). Every
+cross-backend test reads that recording, never anything derived from the
+syntax arm's own output (ADR-0057 §12).

hypergumbo_lang_scip_python-8.1.0/README.md

@@ -0,0 +1,68 @@
+<!-- SPDX-License-Identifier: AGPL-3.0-or-later -->
+# hypergumbo-lang-scip-python
+
+SCIP-backed Python analyzer for hypergumbo, driven by
+[scip-python](https://github.com/sourcegraph/scip-python) (pyright).
+
+This optional package is the second opt-in fidelity backend (after
+`hypergumbo-lang-rust-analyzer`) and the first that **executes nothing** from
+the analysed repository: pyright performs static inference only. It runs
+*beside* the ast-based `python` analyzer, never instead of it — the two
+producers' records for one declaration are folded into one node by the
+ADR-0057 merge pass, and every disagreement stays visible in the provenance
+slot.
+
+## What it adds, measured
+
+On hypergumbo-core's own 179 source files (2026-09-19, scip-python 0.6.6):
+the syntax arm left 4,133 method-call receivers untyped (`obj.method()` with
+`obj` of unknown module); scip-python typed **3,973 of them (96.1%)** — 3,840
+to the stdlib (`builtins.str`, `dict`, `list`, `pathlib.Path`, `re.Pattern`, …),
+96 in-repo, 37 third-party. That module is what `hypergumbo verify-claims`'s
+I/O-boundary and taint verdicts key on. The Rust backend measured zero
+receivers typed.
+
+## Enabling it
+
+```
+npm install -g @sourcegraph/scip-python@0.6.6     # the producer (node + npm)
+pipx install 'hypergumbo[scip-python]'            # this wrapper
+hypergumbo survey . --backend scip-python         # one run
+```
+
+Durably, as a preference in either ADR-0045 config tier (allowed because the
+backend executes nothing):
+
+```toml
+# $XDG_CONFIG_HOME/hypergumbo/config.toml  or  <repo>/.hypergumbo.toml
+[backends]
+scip_python = true
+```
+
+`HYPERGUMBO_SCIP_PYTHON=1` is the environment spelling; `--backend tree-sitter`
+turns every opt-in backend off for one run. Precedence: flag > environment >
+project config > user config.
+
+When enabled but the binary or this package is missing, the CLI exits 2 with
+the install line rather than silently falling through.
+
+## What the translation does with scip-python's output
+
+- Global definitions become `Symbol`s through the shared importer
+  (`hypergumbo_core.scip`); scip-python declares no `Document.language` and
+  no `SymbolInformation.kind`, so the importer reads the file extension and
+  the SCIP descriptor grammar instead.
+- Parameter symbols and the per-module `__init__:` declaration are dropped:
+  the syntax arm models neither, and a node nothing can pair with is noise.
+- References to in-repo definitions become `calls` / `references` edges.
+- References to **external** callables (stdlib, third-party) become external
+  call edges carrying the receiver's module — `python:pathlib.Path:0-0:glob:unresolved`
+  with a structured `dst_ref` — the same shape the syntax arm mints when it
+  knows the module, so the two arms are comparable at every call site.
+
+## Recorded fixture
+
+`recorded/sample_project/` is a three-file package and the `index.scip`
+scip-python 0.6.6 emitted for it (`metadata.project_root` normalised). Every
+cross-backend test reads that recording, never anything derived from the
+syntax arm's own output (ADR-0057 §12).

hypergumbo_lang_scip_python-8.1.0/pyproject.toml

@@ -0,0 +1,41 @@
+[build-system]
+requires = ["hatchling>=1.24"]
+build-backend = "hatchling.build"
+
+[project]
+name = "hypergumbo-lang-scip-python"
+version = "8.1.0"
+description = "SCIP-backed Python analyzer for hypergumbo (scip-python / pyright integration)"
+readme = "README.md"
+requires-python = ">=3.10"
+license = { text = "AGPL-3.0-or-later" }
+authors = [{ name = "Hypergumbo contributors" }]
+keywords = ["static-analysis", "code-graph", "python", "pyright", "scip"]
+classifiers = [
+  "Development Status :: 3 - Alpha",
+  "License :: OSI Approved :: GNU Affero General Public License v3 or later (AGPLv3+)",
+  "Programming Language :: Python :: 3",
+  "Programming Language :: Python :: 3 :: Only",
+]
+dependencies = [
+  "hypergumbo-core==8.1.0",
+  "hypergumbo-lang-mainstream==8.1.0",
+]
+
+[project.entry-points."hypergumbo.analyzers"]
+scip_python = "hypergumbo_lang_scip_python:ANALYZER_MODULES"
+
+[tool.hatch.build.targets.wheel]
+packages = ["src/hypergumbo_lang_scip_python"]
+
+[tool.ruff]
+target-version = "py310"
+line-length = 100
+src = ["src", "tests"]
+
+[tool.ruff.lint]
+select = ["E", "W", "F", "B", "C4", "S", "RUF"]
+ignore = ["E501", "S101", "S105", "S106", "S110", "RUF059", "RUF005", "B028"]
+
+[tool.ruff.lint.per-file-ignores]
+"tests/**/*.py" = ["S101", "S105", "S106", "S603", "S108", "E741", "F401", "F841", "RUF005"]

hypergumbo_lang_scip_python-8.1.0/recorded/recorded_scip_python_0_6_6.py

@@ -0,0 +1,152 @@
+# SPDX-License-Identifier: AGPL-3.0-or-later
+"""Recorded producer-shaped output of scip-python 0.6.6 (ADR-0057 §12, WI-nanom).
+
+scip-python is an npm package that is not installed in CI, so every
+cross-backend test for the Python arms consumes RECORDED output of the real
+producer rather than anything derived from the syntax arm's own records
+(a control that cannot fail is not a control). This module is the one
+place that recording is exposed; it lives under the scip-python package's
+``recorded/`` directory (owned by the producer's package, not shipped in
+its wheel) and is on pytest's ``pythonpath`` so core, mainstream and
+scip-python tests import it by its bare name.
+
+ONE RECORDING: ``sample_project/`` — a three-file package (``pkg/__init__.py``,
+``pkg/shapes.py``, ``pkg/app.py``: a class with methods and a property, a
+module constant, a free function, a cross-file import and call, and calls on
+stdlib receivers — ``str.upper``, ``list.append``, ``str.strip``,
+``Path.glob``, ``re.compile``, ``Pattern.search``, ``Match.group``) beside
+the ``index.scip`` that ``scip-python index . --project-name sample_project
+--project-version 0.1.0`` (v0.6.6, node 20) emitted for it on 2026-09-19.
+The index is committed RAW (protobuf, 10 KB); the one edit is
+``metadata.project_root``, rewritten from the recording machine's absolute
+path to ``file:///sample_project``. Re-record (2 s) rather than edit.
+
+What the recording pins about the producer, read off the bytes:
+
+* ``Document.language`` is EMPTY on every document and
+  ``SymbolInformation.kind`` is 0 on every symbol — the two silences the
+  shared importer now fills from the file extension and the descriptor
+  grammar (PR #1082).
+* Every global Definition occurrence's ``range`` is the identifier TOKEN
+  (single-line), so this arm's ``span_role`` is ``token``.
+* Parameters are GLOBAL symbols (``main().(argv)``), one per parameter, and
+  every module carries a META ``__init__:`` declaration — both dropped by
+  ``translate_scip_python_to_hg`` because the syntax arm models neither.
+* Occurrences on stdlib receivers name the DEFINING class:
+  ``builtins/str#upper().``, ``pathlib/Path#glob().``, ``re/Pattern#search().``.
+"""
+from __future__ import annotations
+
+from pathlib import Path
+
+_HERE = Path(__file__).resolve().parent
+
+PRODUCER_VERSION = "0.6.6"
+
+
+def sample_project_root() -> Path:
+    """The committed package the index was recorded on."""
+    return _HERE / "sample_project"
+
+
+def sample_project_index_bytes() -> bytes:
+    """The recorded ``index.scip``, exactly as ``translate_scip_python_to_hg`` reads it."""
+    return (_HERE / "sample_project" / "index.scip").read_bytes()
+
+
+#: Global symbols in the recording, by the descriptor's leaf kind.
+SAMPLE_PROJECT_COUNTS = {
+    "documents": 3,
+    "global_symbols": 24,
+    "parameter_symbols": 9,
+    "module_declarations": 3,
+    "external_stdlib_occurrences": 29,
+}
+
+# What the two Python arms do with the recording (ADR-0057 §3/§5/§13/§14), as
+# the fixture tests pin them and `hypergumbo backend-agreement` reports them.
+# The translation keeps 11 of the 24 global symbols: 9 parameters and 3 module
+# declarations are dropped, and `Shape#tags` (an annotated `self.tags = []`)
+# has no Definition occurrence in the recording, so the importer never mints
+# it. Every one of the syntax arm's 10 non-file records pairs; the SCIP-only
+# leftover is the `name` field (`self.name = name`), which the syntax arm
+# emits no Symbol for.
+SAMPLE_PROJECT_PAIRING = {
+    "scip_symbols": 11,
+    "paired": 10,
+    "ambiguous": 0,
+    "unpaired_field": 1,
+}
+# Per attribute over the 10 paired records: (agree, disagree, python only, scip_python only).
+# `name`: the four methods are `Shape.x` here and `x` there. `is_exported`:
+# one-sided to the incumbent on ALL 10 — `py.py` computes exportedness and the
+# SCIP arm computes none, so only the incumbent supplies a value.
+#
+# WAS 6 of 10 UNTIL WI-kohah, and the four missing ones were the METHODS. This
+# comment used to read "for which neither arm has a rule: since INV-kubup the
+# field abstains (`None`)" — an accurate description of a PRODUCER GAP that the
+# fixture had been recording as though it were a property of the comparison.
+# py.py now decides a method's exportedness conjunctively (the enclosing class's
+# verdict AND the method not being private-by-name), so the incumbent supplies
+# all 10 and the count is one-sided for the same reason at every record rather
+# than for two different reasons at six and four.
+# `span`: token vs item, by construction.
+# `stable_id`: contested on all 10, because the arms hash different things. It read 8 / 2-one-sided
+# while the harness skipped the kind backstop a survey runs before the merge:
+# the 2 were the syntax arm's variables, reaching the merge with no id
+# (WI-paluk). This follows from the survey's code path; it is not a live measurement,
+# because scip-python is not installed where this was pinned.
+SAMPLE_PROJECT_ATTRIBUTE_AGREEMENT = {
+    "docstring": (0, 0, 2, 0),
+    "is_exported": (0, 0, 10, 0),
+    "kind": (10, 0, 0, 0),
+    "name": (6, 4, 0, 0),
+    "qualified_name": (0, 0, 8, 0),
+    "signature": (0, 0, 7, 0),
+    "span": (0, 10, 0, 0),
+    "stable_id": (0, 10, 0, 0),
+}
+# Per (edge type, resolved) after the fold: (both, python only, scip_python only).
+# External `calls` BOTH is 8: the two sites where the syntax arm already knew
+# the module (`pathlib.Path.glob`, `builtins.sorted`) fold on identical ids
+# under §11, and the six module-less stubs are absorbed by their typed twins
+# under §15 — a partial external key matched by a complete one. scip_python-only
+# is 0 BECAUSE of that absorption: before §15 those six twins had no partner,
+# and one call carried two edges.
+SAMPLE_PROJECT_EDGE_OVERLAP = {
+    ("calls", True): (3, 0, 1),
+    ("calls", False): (8, 5, 0),
+    ("imports", True): (0, 2, 0),
+    ("imports", False): (0, 2, 0),
+    ("instantiates", True): (0, 1, 0),
+    ("references", True): (2, 0, 3),
+}
+# The external callees scip-python types, as (caller, dst id, call_construct, line).
+SAMPLE_PROJECT_TYPED_EXTERNALS = [
+    ("describe", "python:builtins.str:0-0:join:unresolved", "method", 29),
+    ("label", "python:builtins.str:0-0:upper:unresolved", "method", 17),
+    ("list_configs", "python:builtins:0-0:sorted:unresolved", "function", 33),
+    ("list_configs", "python:pathlib.Path:0-0:glob:unresolved", "method", 33),
+    ("main", "python:re.Match:0-0:group:unresolved", "method", 17),
+    ("main", "python:re.Pattern:0-0:search:unresolved", "method", 15),
+    ("tag", "python:builtins.list:0-0:append:unresolved", "method", 23),
+    ("tag", "python:builtins.str:0-0:strip:unresolved", "method", 23),
+]
+# The syntax arm's module-less stubs (`python:external:0-0:<name>:unresolved`)
+# and what happens to each: six are ABSORBED by the typed twin the SCIP arm
+# emits at the same site (§15, WI-hupod) and survive as one edge carrying the
+# stated module and both origins; `label` is a property the SCIP arm RESOLVES
+# in-repo, so no twin states a module and the stub is superseded instead (§14).
+# Seven stubs in, one sentinel stub out.
+SAMPLE_PROJECT_MODULE_LESS_STUBS = ["append", "group", "join", "label", "search", "strip", "upper"]
+#: What each absorbed stub's survivor states, as (callee, module path). The six
+#: names here are the six of MODULE_LESS_STUBS that a typed twin reaches.
+SAMPLE_PROJECT_ABSORBED = [
+    ("append", "builtins.list"), ("group", "re.Match"), ("join", "builtins.str"),
+    ("search", "re.Pattern"), ("strip", "builtins.str"), ("upper", "builtins.str"),
+]
+SAMPLE_PROJECT_SUPERSEDED = 1
+#: §13: the six §15 absorptions pair two distinct pathways, as do the seven
+#: §11 folds on identical ids.
+SAMPLE_PROJECT_CORROBORATED = 13
+SAMPLE_PROJECT_EXTERNAL_FOLDS = 6

hypergumbo_lang_scip_python-8.1.0/recorded/sample_project/pkg/__init__.py

@@ -0,0 +1,2 @@
+# SPDX-License-Identifier: AGPL-3.0-or-later
+"""A sample package recorded for the scip-python backend fixture."""

hypergumbo_lang_scip_python-8.1.0/recorded/sample_project/pkg/app.py

@@ -0,0 +1,18 @@
+# SPDX-License-Identifier: AGPL-3.0-or-later
+"""Cross-file calls: import, instantiate, call methods, and a stdlib receiver."""
+import re
+
+from pkg.shapes import Shape, describe
+
+
+PATTERN = re.compile(r"\d+")
+
+
+def main(argv: list[str]) -> int:
+    shape = Shape(argv[0] if argv else "unit")
+    shape.tag(" first ")
+    text = describe(shape)
+    match = PATTERN.search(text)
+    if match is not None:
+        return int(match.group(0))
+    return len(shape.tags)

hypergumbo_lang_scip_python-8.1.0/recorded/sample_project/pkg/shapes.py

@@ -0,0 +1,33 @@
+# SPDX-License-Identifier: AGPL-3.0-or-later
+"""Shapes: a class with methods, a property, a constant and a free function."""
+from pathlib import Path
+
+UNIT = 1.0
+
+
+class Shape:
+    """A named shape."""
+
+    def __init__(self, name: str) -> None:
+        self.name = name
+        self.tags: list[str] = []
+
+    @property
+    def label(self) -> str:
+        return self.name.upper()
+
+    def area(self) -> float:
+        return UNIT
+
+    def tag(self, value: str) -> None:
+        self.tags.append(value.strip())
+
+
+def describe(shape: Shape) -> str:
+    """Free function calling a method and a stdlib method on a typed receiver."""
+    parts = [shape.label, str(shape.area())]
+    return " ".join(parts)
+
+
+def list_configs(root: Path) -> list[Path]:
+    return sorted(root.glob("*.toml"))

hypergumbo_lang_scip_python-8.1.0/src/hypergumbo_lang_scip_python/__init__.py

@@ -0,0 +1,42 @@
+# SPDX-License-Identifier: AGPL-3.0-or-later
+"""Hypergumbo SCIP-backed Python analyzer (scip-python / pyright), WI-nanom.
+
+The second opt-in fidelity backend and the first that executes nothing from
+the analysed repository. Its parts mirror ``hypergumbo_lang_rust_analyzer``:
+
+- ``invoke.py`` shells out to ``scip-python index`` to produce a SCIP blob.
+- ``translate.py`` turns that blob into ``(symbols, edges)`` through the
+  shared importer, plus the one thing the Rust arm never did: external
+  callees keep the receiver's MODULE.
+- ``gate.py`` answers "did the user ask?" — flag > environment > config
+  tiers (a preference, ADR-0045 ruling 5) — and whether the binary is there.
+- ``analyzer.py`` registers ``scip_python`` beside the ``python`` analyzer
+  with the merge anchor the ADR-0057 pass pairs on.
+"""
+from hypergumbo_lang_scip_python.gate import should_use_scip_python_backend
+from hypergumbo_lang_scip_python.invoke import (
+    ScipPythonError,
+    ScipPythonInvocationFailed,
+    ScipPythonNoOutput,
+    ScipPythonNotInstalled,
+    run_scip_python_index,
+)
+from hypergumbo_lang_scip_python.translate import translate_scip_python_to_hg
+
+__version__ = "8.1.0"
+
+#: Module paths for analyzer discovery via entry-points (ADR-0012 Step 1).
+ANALYZER_MODULES = [
+    "hypergumbo_lang_scip_python.analyzer",
+]
+
+__all__ = [
+    "ANALYZER_MODULES",
+    "ScipPythonError",
+    "ScipPythonInvocationFailed",
+    "ScipPythonNoOutput",
+    "ScipPythonNotInstalled",
+    "run_scip_python_index",
+    "should_use_scip_python_backend",
+    "translate_scip_python_to_hg",
+]