atomadic-forge 0.3.2__py3-none-any.whl

atomadic_forge/a1_at_functions/generation_quality.py

@@ -0,0 +1,322 @@
+"""Tier a1 — deterministic quality phases for generated packages.
+
+These helpers run after an LLM has emitted code.  They do not invent
+business behavior; they add baseline documentation, docstrings, and import
+smoke tests so generated packages start with a usable maintenance surface.
+"""
+
+from __future__ import annotations
+
+import ast
+from pathlib import Path
+from typing import Any
+
+from ..a0_qk_constants.tier_names import TIER_NAMES
+
+_GENERATED_MARKER = "<!-- generated by atomadic-forge quality phase -->"
+
+_TIER_LABELS = {
+    "a0_qk_constants": "constants and type shapes",
+    "a1_at_functions": "pure functions",
+    "a2_mo_composites": "stateful composites",
+    "a3_og_features": "feature orchestration",
+    "a4_sy_orchestration": "entry points and CLI wiring",
+}
+
+
+def apply_docstring_phase(package_root: Path) -> dict[str, Any]:
+    """Add conservative docstrings to Python modules missing them."""
+    package_root = Path(package_root)
+    changed: list[str] = []
+    scanned = 0
+    if not package_root.exists():
+        return {"phase": "docstrings", "language": "python",
+                "files_scanned": 0, "files_changed": []}
+    for path in sorted(package_root.rglob("*.py")):
+        if "__pycache__" in path.parts or path.name == "__init__.py":
+            continue
+        scanned += 1
+        try:
+            original = path.read_text(encoding="utf-8")
+        except OSError:
+            continue
+        updated = add_missing_docstrings(original, rel_path=path.relative_to(package_root))
+        if updated != original:
+            path.write_text(updated, encoding="utf-8")
+            changed.append(path.relative_to(package_root).as_posix())
+    return {"phase": "docstrings", "language": "python",
+            "files_scanned": scanned, "files_changed": changed}
+
+
+def add_missing_docstrings(source: str, *, rel_path: Path | str) -> str:
+    """Return ``source`` with missing module/class/function docstrings added."""
+    try:
+        tree = ast.parse(source)
+    except SyntaxError:
+        return source
+    lines = source.splitlines()
+    if not lines:
+        return source
+    rel = Path(rel_path).as_posix()
+    inserts: list[tuple[int, str]] = []
+
+    if ast.get_docstring(tree) is None:
+        inserts.append((0, f'"""{_module_docstring(rel)}"""'))
+
+    for node in ast.walk(tree):
+        if isinstance(node, ast.ClassDef):
+            if node.name.startswith("_") or ast.get_docstring(node) is not None:
+                continue
+            inserts.append(_docstring_insert(node, _class_docstring(node.name)))
+        elif isinstance(node, ast.FunctionDef | ast.AsyncFunctionDef):
+            if node.name.startswith("_") and node.name != "__init__":
+                continue
+            if ast.get_docstring(node) is not None:
+                continue
+            inserts.append(_docstring_insert(node, _function_docstring(node.name)))
+
+    for index, text in sorted(inserts, key=lambda item: item[0], reverse=True):
+        lines.insert(index, text)
+    return "\n".join(lines) + ("\n" if source.endswith("\n") else "")
+
+
+def _docstring_insert(node: ast.ClassDef | ast.FunctionDef | ast.AsyncFunctionDef,
+                      text: str) -> tuple[int, str]:
+    if not node.body:
+        return (node.lineno, f'    """{text}"""')
+    first = node.body[0]
+    indent = " " * getattr(first, "col_offset", 4)
+    return (max(0, first.lineno - 1), f'{indent}"""{text}"""')
+
+
+def _module_docstring(rel: str) -> str:
+    tier = next((part for part in rel.split("/") if part in TIER_NAMES), "")
+    label = _TIER_LABELS.get(tier, "generated package code")
+    stem = Path(rel).stem.replace("_", " ")
+    return f"{label.capitalize()} for {stem}."
+
+
+def _class_docstring(name: str) -> str:
+    words = _humanize_name(name)
+    return f"Coordinate {words} behavior."
+
+
+def _function_docstring(name: str) -> str:
+    if name == "__init__":
+        return "Initialize the instance."
+    words = _humanize_name(name)
+    if name.startswith(("is_", "has_", "can_", "should_")):
+        return f"Return whether {words}."
+    if name.startswith(("parse_", "load_", "read_")):
+        return f"Parse {words} input."
+    if name.startswith(("render_", "format_", "build_")):
+        return f"Build {words} output."
+    if name.startswith(("validate_", "check_")):
+        return f"Validate {words}."
+    return f"Run the {words} operation."
+
+
+def _humanize_name(name: str) -> str:
+    if name == "__init__":
+        return "instance"
+    out: list[str] = []
+    current = ""
+    for ch in name.replace("_", " "):
+        if ch.isupper() and current and not current.endswith(" "):
+            out.append(current)
+            current = ch.lower()
+        else:
+            current += ch.lower()
+    if current:
+        out.append(current)
+    return " ".join("".join(out).split())
+
+
+def apply_docs_phase(*, output_root: Path, package_root: Path,
+                     package: str, intent: str) -> dict[str, Any]:
+    """Create generated API and testing docs without overwriting custom docs."""
+    docs_dir = Path(output_root) / "docs"
+    docs_dir.mkdir(parents=True, exist_ok=True)
+    written: list[str] = []
+    skipped: list[str] = []
+    files = {
+        docs_dir / "API.md": render_api_doc(package_root=package_root,
+                                             package=package, intent=intent),
+        docs_dir / "TESTING.md": render_testing_doc(package=package),
+    }
+    for path, content in files.items():
+        if _write_generated(path, content):
+            written.append(path.relative_to(output_root).as_posix())
+        else:
+            skipped.append(path.relative_to(output_root).as_posix())
+    return {"phase": "docs", "files_written": written, "files_skipped": skipped}
+
+
+def render_api_doc(*, package_root: Path, package: str, intent: str) -> str:
+    """Render a compact API reference from public Python symbols."""
+    symbols = _collect_symbols(package_root)
+    lines = [
+        _GENERATED_MARKER,
+        f"# {package} API",
+        "",
+        "This reference is generated from the package source after the Forge",
+        "quality phase has added missing docstrings.",
+        "",
+        "## Intent",
+        "",
+        f"> {intent.strip() or '(unspecified)'}",
+        "",
+    ]
+    if not symbols:
+        lines.extend([
+            "## Public Surface",
+            "",
+            "No public Python symbols were discovered yet.",
+            "",
+        ])
+    for tier in TIER_NAMES:
+        items = symbols.get(tier, [])
+        if not items:
+            continue
+        lines.extend([f"## {tier}", ""])
+        for item in items:
+            doc = f" — {item['doc']}" if item["doc"] else ""
+            lines.append(f"- `{item['signature']}`{doc} (`{item['module']}`)")
+        lines.append("")
+    return "\n".join(lines)
+
+
+def render_testing_doc(*, package: str) -> str:
+    """Render generated testing guidance for the package."""
+    return "\n".join([
+        _GENERATED_MARKER,
+        f"# Testing {package}",
+        "",
+        "Forge creates a baseline import-smoke test so every generated module",
+        "is at least importable. Treat it as a floor, not a substitute for",
+        "behavioral tests against real inputs.",
+        "",
+        "```bash",
+        "pytest tests/",
+        f"forge certify . --package {package}",
+        "```",
+        "",
+        "Add focused tests beside `tests/test_generated_smoke.py` as the",
+        "package behavior becomes clearer.",
+        "",
+    ])
+
+
+def apply_test_phase(*, output_root: Path, package_root: Path,
+                     package: str) -> dict[str, Any]:
+    """Create or refresh the generated import-smoke test."""
+    tests_dir = Path(output_root) / "tests"
+    tests_dir.mkdir(parents=True, exist_ok=True)
+    target = tests_dir / "test_generated_smoke.py"
+    content = render_smoke_test(package_root=package_root, package=package)
+    target.write_text(content, encoding="utf-8")
+    return {"phase": "tests",
+            "files_written": [target.relative_to(output_root).as_posix()],
+            "module_count": len(_module_names(package_root, package))}
+
+
+def render_smoke_test(*, package_root: Path, package: str) -> str:
+    """Render a stdlib-only pytest-compatible import-smoke test."""
+    modules = _module_names(package_root, package)
+    module_lines = "\n".join(f"    {name!r}," for name in modules)
+    package_import = (
+        f"import {package} as generated_package"
+        if package.isidentifier()
+        else f"generated_package = importlib.import_module({package!r})"
+    )
+    import_lines = ["import importlib", "", package_import]
+    return "\n".join([
+        f'"""Generated import-smoke tests for {package}."""',
+        "",
+        "from __future__ import annotations",
+        "",
+        *import_lines,
+        "",
+        "MODULES = [",
+        module_lines,
+        "]",
+        "",
+        "",
+        "def test_generated_package_imports():",
+        "    assert generated_package",
+        "",
+        "",
+        "def test_generated_modules_import():",
+        "    for module_name in MODULES:",
+        "        assert importlib.import_module(module_name)",
+        "",
+    ])
+
+
+def _write_generated(path: Path, content: str) -> bool:
+    if path.exists():
+        existing = path.read_text(encoding="utf-8", errors="replace")
+        if _GENERATED_MARKER not in existing:
+            return False
+    path.write_text(content, encoding="utf-8")
+    return True
+
+
+def _module_names(package_root: Path, package: str) -> list[str]:
+    out = [package]
+    if package_root.exists():
+        for py in sorted(package_root.rglob("*.py")):
+            if "__pycache__" in py.parts or py.name == "__init__.py":
+                continue
+            rel = py.relative_to(package_root).with_suffix("")
+            parts = ".".join(rel.parts)
+            out.append(f"{package}.{parts}")
+    return sorted(dict.fromkeys(out))
+
+
+def _collect_symbols(package_root: Path) -> dict[str, list[dict[str, str]]]:
+    out: dict[str, list[dict[str, str]]] = {}
+    if not package_root.exists():
+        return out
+    for tier in TIER_NAMES:
+        tier_dir = package_root / tier
+        if not tier_dir.exists():
+            continue
+        items: list[dict[str, str]] = []
+        for py in sorted(tier_dir.glob("*.py")):
+            if py.name == "__init__.py":
+                continue
+            try:
+                tree = ast.parse(py.read_text(encoding="utf-8"))
+            except (SyntaxError, OSError):
+                continue
+            module = f"{tier}/{py.name}"
+            for node in tree.body:
+                if isinstance(node, ast.ClassDef) and not node.name.startswith("_"):
+                    items.append({
+                        "module": module,
+                        "signature": f"class {node.name}",
+                        "doc": _first_doc_line(node),
+                    })
+                elif isinstance(node, ast.FunctionDef | ast.AsyncFunctionDef):
+                    if node.name.startswith("_"):
+                        continue
+                    items.append({
+                        "module": module,
+                        "signature": _signature(node),
+                        "doc": _first_doc_line(node),
+                    })
+        if items:
+            out[tier] = items
+    return out
+
+
+def _first_doc_line(node: ast.AST) -> str:
+    doc = ast.get_docstring(node) or ""
+    return doc.strip().split("\n", 1)[0] if doc else ""
+
+
+def _signature(fn: ast.FunctionDef | ast.AsyncFunctionDef) -> str:
+    args = [a.arg for a in fn.args.args if a.arg not in {"self", "cls"}]
+    prefix = "async def" if isinstance(fn, ast.AsyncFunctionDef) else "def"
+    return f"{prefix} {fn.name}({', '.join(args)})"

atomadic_forge/a1_at_functions/import_repair.py

@@ -0,0 +1,211 @@
+"""Tier a1 — pure import-repair pass for assimilated symbol files.
+
+When ``atomadic-forge assimilate`` materialises a symbol from a flat-layout sibling
+repo into the 5-tier monadic package, intra-package references (e.g.
+``from kg import infer_tier``) are not rewritten to the new sibling file
+paths.  The result is a thousand-file package that silently refuses to
+import.
+
+This module provides a deterministic post-process that:
+
+1. Scans a tier folder for ``*.py`` files materialised by the assimilator.
+2. Builds a name-to-relative-module map from the per-source filename
+   convention (``a<N>_source_<root>_<symbol>.py`` exposes ``<symbol>``).
+3. Rewrites every broken ``from <flat-name> import X`` line to the matching
+   ``from .a<N>_source_<root>_<flat-name> import X`` sibling reference.
+
+It is pure: takes file paths and returns a diff list of (path, new_text).
+The caller decides whether to apply.
+"""
+
+from __future__ import annotations
+
+import re
+from collections.abc import Iterable
+from pathlib import Path
+
+_SOURCE_HEAD = re.compile(r"^a\d_source_")
+_FROM_LINE = re.compile(r"^from\s+([A-Za-z_][\w]*)\s+import\s+(.+)$", re.MULTILINE)
+
+
+# Roots the assimilator can encode in file stems.  Add new roots as needed.
+KNOWN_SOURCE_ROOTS: tuple[str, ...] = ("atomadic_forge_seed", "atomadic_v2", "atomadic_engine")
+
+
+def _split_source_stem(stem: str,
+                       roots: tuple[str, ...] = KNOWN_SOURCE_ROOTS) -> tuple[str, str] | None:
+    """Return ``(root, symbol)`` for ``a<N>_source_<root>_<symbol>``.
+
+    Uses prefix-stripping with a known root list so symbols containing
+    underscores (``infer_tier``, ``cherry_pick_dict``) are split correctly.
+    """
+    head = _SOURCE_HEAD.match(stem)
+    if not head:
+        return None
+    rest = stem[head.end():]
+    for root in roots:
+        if rest.startswith(root + "_"):
+            return root, rest[len(root) + 1:]
+        if rest == root:
+            return root, ""
+    return None
+
+
+def build_symbol_map(tier_dir: Path) -> dict[str, str]:
+    """Return ``{flat_module_name: tier_relative_module}`` for every assimilated file.
+
+    A file like ``a1_source_atomadic_v2_kg.py`` maps the flat name ``kg``
+    to the relative module path ``.a1_source_atomadic_v2_kg``.
+    Last-write-wins on collisions (later files override earlier ones).
+    """
+    out: dict[str, str] = {}
+    for f in sorted(tier_dir.glob("a*_source_*.py")):
+        parsed = _split_source_stem(f.stem)
+        if not parsed:
+            continue
+        _root, flat_name = parsed
+        out[flat_name] = "." + f.stem
+    return out
+
+
+def build_name_to_file_map(*tier_dirs: Path) -> dict[str, str]:
+    """Return ``{symbol_name: relative_module}`` across all listed tier dirs.
+
+    The assimilator emits one file per symbol whose stem encodes the symbol
+    in lowercase (``a1_source_atomadic_v2_infer_tier.py`` → ``infer_tier``;
+    ``a1_source_atomadic_v2_agenticswarm.py`` → ``agenticswarm`` ≈ class
+    ``AgenticSwarm``).  We therefore key on case-folded names and accept
+    variants when rewriting.
+    """
+    out: dict[str, str] = {}
+    for tier_dir in tier_dirs:
+        if not tier_dir.exists():
+            continue
+        for f in sorted(tier_dir.glob("a*_source_*.py")):
+            parsed = _split_source_stem(f.stem)
+            if not parsed:
+                continue
+            _root, name = parsed
+            out[name.lower()] = "." + f.stem
+    return out
+
+
+def rewrite_imports(source: str, symbol_map: dict[str, str],
+                    stdlib_safelist: Iterable[str] = (),
+                    name_to_file: dict[str, str] | None = None) -> str:
+    """Return ``source`` with broken flat imports rewritten to sibling paths.
+
+    Two passes:
+
+    1. ``from <X> import Y`` where ``X`` is in ``symbol_map`` (a known module
+       name) → ``from <symbol_map[X]> import Y``.
+    2. ``from <X> import Y[, Z, ...]`` where ``X`` is unknown but one or more
+       of the imported names are in ``name_to_file`` → split into one
+       ``from .<file> import <name>`` per imported name.
+
+    Imports of stdlib / third-party modules in ``stdlib_safelist`` are left
+    alone.
+    """
+    safe = set(stdlib_safelist)
+    name_to_file = name_to_file or {}
+
+    def replace(match: re.Match[str]) -> str:
+        head = match.group(1)
+        rest = match.group(2).strip()
+        if head in safe:
+            return match.group(0)
+        if head in symbol_map:
+            return f"from {symbol_map[head]} import {rest}"
+        # try per-name resolution
+        names = [n.strip() for n in rest.split(",") if n.strip()]
+        resolved: list[str] = []
+        unresolved: list[str] = []
+        for n in names:
+            base_name = n.split(" as ")[0].strip()
+            key = base_name.lower()
+            if key in name_to_file:
+                resolved.append(f"from {name_to_file[key]} import {n}")
+            else:
+                unresolved.append(n)
+        if resolved and not unresolved:
+            return "\n".join(resolved)
+        return match.group(0)
+
+    return _FROM_LINE.sub(replace, source)
+
+
+def repair_tier_directory(tier_dir: Path,
+                          dry_run: bool = True,
+                          name_to_file: dict[str, str] | None = None) -> dict[str, str]:
+    """Repair every ``a*_source_*.py`` file in ``tier_dir``.
+
+    ``name_to_file`` (optional) maps symbol names (case-folded) to relative
+    module paths and is used as a fallback resolver when the import head
+    isn't a known sibling module.  Build it once via
+    :func:`build_name_to_file_map` over every tier and pass it to each call.
+
+    Returns ``{path: new_text}`` for files that would change.  When
+    ``dry_run`` is False the changes are written back to disk.
+    """
+    symbol_map = build_symbol_map(tier_dir)
+    diffs: dict[str, str] = {}
+    for f in sorted(tier_dir.glob("a*_source_*.py")):
+        try:
+            current = f.read_text(encoding="utf-8")
+        except OSError:
+            continue
+        new_text = rewrite_imports(current, symbol_map,
+                                   _BUILTIN_AND_THIRD_PARTY,
+                                   name_to_file=name_to_file)
+        if new_text != current:
+            diffs[str(f)] = new_text
+            if not dry_run:
+                f.write_text(new_text, encoding="utf-8")
+    return diffs
+
+
+def repair_assimilation_output(package_root: Path,
+                               dry_run: bool = True) -> dict[str, dict[str, str]]:
+    """Repair every tier under ``package_root`` (e.g. ``…/src/atomadic_forge``).
+
+    Builds one global ``name_to_file`` map across all tiers (because a tier-a2
+    composite often imports a tier-a1 helper) and applies the rewrite pass.
+    """
+    tiers = ["a0_qk_constants", "a1_at_functions", "a2_mo_composites",
+             "a3_og_features", "a4_sy_orchestration"]
+    tier_dirs = [package_root / t for t in tiers if (package_root / t).exists()]
+    out: dict[str, dict[str, str]] = {}
+    for t, tier_dir in zip(tiers, tier_dirs, strict=False):
+        # name_to_file uses tier-internal relative paths.  When repairing
+        # *a different* tier, we still need relative-from-self paths.  The
+        # convention here: a single global map keyed by symbol with paths
+        # relative to *its own* tier directory still works because the
+        # output package re-exports everything via per-tier ``__init__.py``
+        # modules — but for cross-tier refs we'd want absolute imports.
+        # In practice, the assimilator places nearly all atomadic-v2
+        # symbols at a1, so a tier-local map is sufficient for this dataset.
+        local_n2f = build_name_to_file_map(tier_dir)
+        out[t] = repair_tier_directory(tier_dir, dry_run=dry_run,
+                                       name_to_file=local_n2f)
+    return out
+
+
+# Common stdlib + third-party top-level names we should never rewrite.
+_BUILTIN_AND_THIRD_PARTY = frozenset({
+    # stdlib (representative — extend as needed)
+    "abc", "argparse", "ast", "asyncio", "base64", "collections", "concurrent",
+    "contextlib", "copy", "csv", "dataclasses", "datetime", "decimal", "enum",
+    "functools", "glob", "hashlib", "hmac", "html", "http", "importlib", "inspect",
+    "io", "itertools", "json", "logging", "math", "operator", "os", "pathlib",
+    "pickle", "pkgutil", "platform", "pprint", "queue", "random", "re", "secrets",
+    "shlex", "shutil", "signal", "socket", "sqlite3", "statistics", "string",
+    "struct", "subprocess", "sys", "tempfile", "textwrap", "threading", "time",
+    "tomllib", "traceback", "types", "typing", "unicodedata", "urllib", "uuid",
+    "warnings", "weakref", "xml", "zipfile",
+    # third-party
+    "click", "cryptography", "fastapi", "httpx", "jinja2", "jsonschema", "numpy",
+    "pandas", "peft", "pydantic", "pytest", "rich", "ruff", "torch", "transformers",
+    "typer", "uvicorn", "yaml", "edge_tts", "x402", "discord", "datasets",
+    # atomadic_forge itself
+    "atomadic_forge",
+})

atomadic_forge/a1_at_functions/import_smoke.py

@@ -0,0 +1,102 @@
+"""Tier a1 — runtime import smoke for a generated package.
+
+Wire/tier discipline tells you the architecture is legal.  It does NOT
+tell you the code actually loads — a syntax error, a missing import, or a
+relative-import gone wrong all pass wire-check but fail at runtime.
+
+This module spawns a Python subprocess and tries
+``python -c "import <pkg>"`` with the appropriate ``PYTHONPATH``.  Returns
+a structured report Forge can fold into certify and into LLM feedback.
+"""
+
+from __future__ import annotations
+
+import subprocess
+import sys
+from pathlib import Path
+from typing import TypedDict
+
+
+class ImportSmokeReport(TypedDict):
+    schema_version: str       # "atomadic-forge.import_smoke/v1"
+    package: str
+    src_root: str
+    importable: bool
+    duration_ms: int
+    error_kind: str           # "" | "SyntaxError" | "ImportError" | "ModuleNotFoundError" | "Other"
+    error_message: str        # short
+    traceback_excerpt: str    # last ~600 chars of stderr
+
+
+def _classify_error(stderr: str) -> str:
+    if not stderr:
+        return ""
+    lowered_lines = [ln for ln in stderr.splitlines() if ln.strip()]
+    last = lowered_lines[-1] if lowered_lines else ""
+    for kind in ("ModuleNotFoundError", "ImportError", "SyntaxError",
+                 "AttributeError", "NameError", "TypeError",
+                 "IndentationError"):
+        if kind in last or kind in stderr:
+            return kind
+    return "Other"
+
+
+def _short_message(stderr: str) -> str:
+    if not stderr:
+        return ""
+    lines = [ln for ln in stderr.splitlines() if ln.strip()]
+    return lines[-1][:200] if lines else stderr[:200]
+
+
+def import_smoke(*, output_root: Path, package: str,
+                 timeout_s: float = 30.0) -> ImportSmokeReport:
+    """Try ``python -c 'import <package>'`` with src-layout PYTHONPATH.
+
+    ``output_root`` is the parent of ``src/`` (the directory that contains
+    a ``src/<package>/`` materialized by Forge).
+    """
+    output_root = Path(output_root).resolve()
+    src_root = output_root / "src"
+    if not (src_root / package).exists():
+        return ImportSmokeReport(
+            schema_version="atomadic-forge.import_smoke/v1",
+            package=package, src_root=str(src_root),
+            importable=False, duration_ms=0,
+            error_kind="ModuleNotFoundError",
+            error_message=f"package {package!r} not present under {src_root}",
+            traceback_excerpt="",
+        )
+    import time
+    env = {**__import__("os").environ}
+    existing_pp = env.get("PYTHONPATH", "")
+    env["PYTHONPATH"] = (str(src_root) + (";" if existing_pp else "") + existing_pp
+                          if sys.platform == "win32"
+                          else str(src_root) + (":" if existing_pp else "") + existing_pp)
+    env["PYTHONIOENCODING"] = "utf-8"
+    start = time.perf_counter()
+    try:
+        proc = subprocess.run(
+            [sys.executable, "-c", f"import {package}"],
+            env=env, capture_output=True, text=True, timeout=timeout_s,
+            encoding="utf-8", errors="replace",
+        )
+        duration_ms = int((time.perf_counter() - start) * 1000)
+    except subprocess.TimeoutExpired:
+        return ImportSmokeReport(
+            schema_version="atomadic-forge.import_smoke/v1",
+            package=package, src_root=str(src_root),
+            importable=False, duration_ms=int(timeout_s * 1000),
+            error_kind="TimeoutExpired",
+            error_message=f"import timed out after {timeout_s}s",
+            traceback_excerpt="",
+        )
+    importable = proc.returncode == 0
+    stderr = proc.stderr or ""
+    return ImportSmokeReport(
+        schema_version="atomadic-forge.import_smoke/v1",
+        package=package, src_root=str(src_root),
+        importable=importable, duration_ms=duration_ms,
+        error_kind="" if importable else _classify_error(stderr),
+        error_message="" if importable else _short_message(stderr),
+        traceback_excerpt="" if importable else stderr[-600:],
+    )