atomadic-forge 0.3.2__py3-none-any.whl

atomadic_forge/a1_at_functions/body_extractor.py

@@ -0,0 +1,306 @@
+"""Source body extraction and made_of graph — Phase 3 pure logic (ported from atomadic-forge-v1)."""
+
+from __future__ import annotations
+
+import ast
+import re
+import textwrap
+from dataclasses import dataclass
+from pathlib import Path
+from typing import Any
+
+_MAX_FILE_BYTES = 2_000_000
+
+
+@dataclass
+class ExtractedBody:
+    source_path: str
+    source_line: int
+    symbol_name: str
+    language: str
+    body: str
+    imports: list[str]
+    callers_of: list[str]
+    exceptions_raised: list[str]
+    # Sibling top-level names defined in the same source file that are
+    # referenced from inside the extracted body.  After extraction these
+    # become cross-file references and must be re-imported by the materializer.
+    sibling_refs: list[str] = None  # type: ignore[assignment]
+    # Tier-classification hints harvested from the body itself.  Two cheap
+    # signals: ``has_self_assign`` (mutable instance state) and
+    # ``has_class_attr_collections`` (mutable class-level dict/list/set).
+    has_self_assign: bool = False
+    has_class_attr_collections: bool = False
+
+    def __post_init__(self) -> None:
+        if self.sibling_refs is None:
+            self.sibling_refs = []
+
+
+def _collect_top_level_names(tree: ast.Module) -> set[str]:
+    """Return every name bound at module top level (classes, functions, vars)."""
+    names: set[str] = set()
+    for node in tree.body:
+        if isinstance(node, ast.FunctionDef | ast.AsyncFunctionDef | ast.ClassDef):
+            names.add(node.name)
+        elif isinstance(node, ast.Assign):
+            for target in node.targets:
+                if isinstance(target, ast.Name):
+                    names.add(target.id)
+        elif isinstance(node, ast.AnnAssign):
+            if isinstance(node.target, ast.Name):
+                names.add(node.target.id)
+        elif isinstance(node, ast.Import | ast.ImportFrom):
+            for alias in node.names:
+                names.add(alias.asname or alias.name.split(".", 1)[0])
+    return names
+
+
+def _detect_state_markers(target: ast.AST) -> tuple[bool, bool]:
+    """Return ``(has_self_assign, has_class_attr_collections)``.
+
+    ``has_self_assign``: the class/function body contains ``self.<attr> = …``
+    (mutable instance state — strong signal for tier a2).
+    ``has_class_attr_collections``: a class-level assignment like
+    ``foo: list[str] = []`` (also a state signal).
+    """
+    has_self = False
+    has_class_attr = False
+    if isinstance(target, ast.ClassDef):
+        for node in ast.walk(target):
+            if isinstance(node, ast.Assign):
+                for t in node.targets:
+                    if (isinstance(t, ast.Attribute)
+                            and isinstance(t.value, ast.Name)
+                            and t.value.id == "self"):
+                        has_self = True
+        for node in target.body:
+            if isinstance(node, ast.Assign | ast.AnnAssign):
+                value = getattr(node, "value", None)
+                if isinstance(value, ast.List | ast.Dict | ast.Set | ast.ListComp | ast.DictComp | ast.SetComp):
+                    has_class_attr = True
+    return has_self, has_class_attr
+
+
+def _extract_python_body(source_text: str, symbol_name: str) -> ExtractedBody | None:
+    try:
+        tree = ast.parse(source_text)
+    except SyntaxError:
+        return None
+
+    imports: list[str] = []
+    for node in ast.walk(tree):
+        if isinstance(node, ast.Import):
+            imports.extend(alias.name for alias in node.names)
+        elif isinstance(node, ast.ImportFrom):
+            mod = node.module or ""
+            imports.extend(f"{mod}.{alias.name}" if mod else alias.name for alias in node.names)
+
+    target: ast.AST | None = None
+    for node in ast.walk(tree):
+        if isinstance(node, ast.FunctionDef | ast.AsyncFunctionDef | ast.ClassDef):
+            if node.name == symbol_name:
+                target = node
+                break
+    if target is None:
+        return None
+
+    lines = source_text.splitlines(keepends=True)
+    start = max(0, target.lineno - 1)
+    end = getattr(target, "end_lineno", None) or start + 1
+    body = textwrap.dedent("".join(lines[start:end]))
+
+    callers: list[str] = []
+    for node in ast.walk(target):
+        if isinstance(node, ast.Call):
+            func = node.func
+            if isinstance(func, ast.Name):
+                callers.append(func.id)
+            elif isinstance(func, ast.Attribute):
+                callers.append(func.attr)
+
+    raised: list[str] = []
+    for node in ast.walk(target):
+        if isinstance(node, ast.Raise) and node.exc is not None:
+            if isinstance(node.exc, ast.Name):
+                raised.append(node.exc.id)
+            elif isinstance(node.exc, ast.Call) and isinstance(node.exc.func, ast.Name):
+                raised.append(node.exc.func.id)
+
+    # ── Sibling references — names defined at module top level in the same
+    # source file that are referenced from inside the extracted body.
+    # After single-symbol extraction these become cross-file references.
+    top_names = _collect_top_level_names(tree)
+    referenced: set[str] = set()
+    locally_bound: set[str] = {symbol_name}
+    if isinstance(target, ast.FunctionDef | ast.AsyncFunctionDef):
+        for arg in target.args.args + target.args.kwonlyargs:
+            locally_bound.add(arg.arg)
+        if target.args.vararg:
+            locally_bound.add(target.args.vararg.arg)
+        if target.args.kwarg:
+            locally_bound.add(target.args.kwarg.arg)
+    for node in ast.walk(target):
+        if isinstance(node, ast.Name):
+            referenced.add(node.id)
+        elif isinstance(node, ast.Assign):
+            for t in node.targets:
+                if isinstance(t, ast.Name):
+                    locally_bound.add(t.id)
+        elif isinstance(node, ast.FunctionDef | ast.AsyncFunctionDef):
+            locally_bound.add(node.name)
+            for arg in node.args.args + node.args.kwonlyargs:
+                locally_bound.add(arg.arg)
+    sibling_refs = sorted(
+        n for n in referenced
+        if n in top_names and n != symbol_name and n not in locally_bound
+    )
+
+    has_self_assign, has_class_attr_collections = _detect_state_markers(target)
+
+    return ExtractedBody(
+        source_path="",
+        source_line=target.lineno,
+        symbol_name=symbol_name,
+        language="python",
+        body=body,
+        imports=imports,
+        callers_of=list(dict.fromkeys(callers)),
+        exceptions_raised=list(dict.fromkeys(raised)),
+        sibling_refs=sibling_refs,
+        has_self_assign=has_self_assign,
+        has_class_attr_collections=has_class_attr_collections,
+    )
+
+
+def _extract_regex_body(
+    source_text: str, symbol_name: str, language: str
+) -> ExtractedBody | None:
+    pattern = re.compile(rf"\b{re.escape(symbol_name)}\b", re.MULTILINE)
+    match = pattern.search(source_text)
+    if not match:
+        return None
+    lines = source_text.splitlines(keepends=True)
+    match_line = source_text.count("\n", 0, match.start())
+    start = max(0, match_line - 2)
+    end = min(len(lines), match_line + 40)
+    body = textwrap.dedent("".join(lines[start:end]))
+    body = re.sub(
+        r"(?m)^\s*// Extracted from .*\n"
+        r"(?:\s*// Component id: .*\n)?"
+        r"\s*\n?",
+        "",
+        body,
+    )
+    if language == "rust":
+        import_pat = re.compile(r"^\s*use\s+([\w:]+);", re.MULTILINE)
+    else:
+        import_pat = re.compile(
+            r"^\s*(?:import|export)\s.*?from\s+['\"]([^'\"]+)", re.MULTILINE
+        )
+    imports = import_pat.findall(source_text)
+    return ExtractedBody(
+        source_path="",
+        source_line=match_line + 1,
+        symbol_name=symbol_name,
+        language=language,
+        body=body,
+        imports=list(dict.fromkeys(imports)),
+        callers_of=[],
+        exceptions_raised=[],
+    )
+
+
+def extract_body(
+    source_path: str | Path, symbol_name: str, language: str = "python"
+) -> ExtractedBody | None:
+    """Extract the body of one symbol from one source file. Returns None on failure."""
+    p = Path(source_path)
+    if not p.exists() or p.stat().st_size > _MAX_FILE_BYTES:
+        return None
+    try:
+        text = p.read_text(encoding="utf-8", errors="replace")
+    except OSError:
+        return None
+
+    if language == "python" or p.suffix == ".py":
+        result = _extract_python_body(text, symbol_name)
+    else:
+        result = _extract_regex_body(text, symbol_name, language)
+    if result is not None:
+        result.source_path = p.as_posix()
+    return result
+
+
+def enrich_components_with_bodies(
+    plan: dict[str, Any],
+    *,
+    max_body_chars: int | None = None,
+) -> dict[str, Any]:
+    """Attach extracted source bodies to every proposed component. Mutates ``plan``.
+
+    Also recomputes the tier when body extraction reveals a stateful class
+    that was originally classified at a1 by name heuristics alone.  The
+    recompute is conservative — it only PROMOTES (a1 → a2), never demotes.
+    """
+    for prop in plan.get("proposed_components") or []:
+        sym = prop.get("source_symbol") or {}
+        src_path = sym.get("path") or ""
+        name = sym.get("name") or prop.get("name")
+        lang = sym.get("language") or "python"
+        if not src_path or not name:
+            continue
+        extracted = extract_body(src_path, str(name), str(lang))
+        if extracted is None:
+            continue
+        if max_body_chars is None:
+            prop["body"] = extracted.body
+            prop["body_truncated"] = False
+        else:
+            prop["body"] = extracted.body[:max_body_chars]
+            prop["body_truncated"] = len(extracted.body) > max_body_chars
+        prop["imports"] = extracted.imports
+        prop["callers_of"] = extracted.callers_of
+        prop["exceptions_raised"] = extracted.exceptions_raised
+        prop["sibling_refs"] = extracted.sibling_refs
+        prop["has_self_assign"] = extracted.has_self_assign
+        prop["has_class_attr_collections"] = extracted.has_class_attr_collections
+
+        # Body-aware tier promotion: a class with mutable instance state
+        # belongs in a2_mo_composites, not a1_at_functions.  Only promote;
+        # don't demote (the assimilator may have legitimately placed it
+        # higher because of name signals).
+        kind = str(sym.get("kind") or "").lower()
+        if (kind in ("class", "type")
+                and (extracted.has_self_assign
+                     or extracted.has_class_attr_collections)
+                and prop.get("tier") == "a1_at_functions"):
+            prop["tier"] = "a2_mo_composites"
+            prop["tier_promotion_reason"] = (
+                "body has self.<attr> = … or class-level mutable collection — "
+                "ASS-ADE law promotes from a1 to a2"
+            )
+            # Re-stamp the component id so downstream stem/manifest paths
+            # match the new tier prefix.
+            cid = str(prop.get("id") or "")
+            if cid.startswith("a1."):
+                prop["id"] = "a2." + cid[3:]
+    return plan
+
+
+def derive_made_of_graph(plan: dict[str, Any]) -> dict[str, Any]:
+    """Populate each component's ``made_of`` from call-graph analysis. Mutates ``plan``."""
+    by_name: dict[str, str] = {}
+    for prop in plan.get("proposed_components") or []:
+        name = (prop.get("name") or "").lower()
+        if name:
+            by_name[name] = str(prop["id"])
+
+    for prop in plan.get("proposed_components") or []:
+        made_of: list[str] = list(prop.get("made_of") or [])
+        for callee in prop.get("callers_of") or []:
+            target_id = by_name.get((callee or "").lower())
+            if target_id and target_id != prop["id"] and target_id not in made_of:
+                made_of.append(target_id)
+        prop["made_of"] = made_of
+    return plan

atomadic_forge/a1_at_functions/card_renderer.py

@@ -0,0 +1,210 @@
+"""Tier a1 — render a Forge Receipt as a 60×24 box-drawing card.
+
+Golden Path Lane A W1 (paired with ``receipt_emitter.py``). This
+renderer is what the "62 → 5" 30-second viral demo (Lane E W2)
+screen-grabs and what ``forge auto`` / ``forge certify`` print at the
+bottom of a successful run.
+
+Pure: takes a Receipt dict and returns a string. No I/O, no imports
+above a0. Snapshot-tested at ~60 columns wide; height is variable
+but bounded (target ≤ 24 rows for 'fits in one mobile screenshot').
+
+Style notes (so the output stays visually consistent across releases):
+  * Single-line box drawing characters (U+2500..U+257F)
+  * Title bar uses U+2550 (heavy horizontal) for visual weight
+  * Verdict color hint emitted as a leading symbol (✓ / ✗ / ↻ / ⏸)
+    so terminals without color can still distinguish the four
+    verdicts. Caller may wrap with ANSI if desired.
+  * Numeric fields right-aligned; labels left-aligned; one column of
+    padding per side. No tabs, no trailing whitespace per row.
+"""
+from __future__ import annotations
+
+from typing import Any
+
+from ..a0_qk_constants.receipt_schema import VALID_VERDICTS, ForgeReceiptV1
+
+_VERDICT_GLYPH: dict[str, str] = {
+    "PASS":       "✓",
+    "FAIL":       "✗",
+    "REFINE":     "↻",
+    "QUARANTINE": "⏸",
+}
+
+
+def _truncate(text: str, max_len: int) -> str:
+    """Truncate ``text`` to ``max_len`` characters, adding an ellipsis
+    when shortened. Returns ``text`` unchanged when already short enough.
+    """
+    if max_len <= 1:
+        return text[:max_len]
+    return text if len(text) <= max_len else text[: max_len - 1] + "…"
+
+
+def _row(left: str, right: str, *, width: int) -> str:
+    """Format a single content row inside a card of total ``width``.
+
+    Layout: │ <left> .... <right> │
+    Inner width = width - 4 (two box chars + two single-space pads).
+    """
+    inner = width - 4
+    if inner <= 0:
+        return ""
+    if not right:
+        return f"│ {_truncate(left, inner):<{inner}} │"
+    pad = inner - len(left) - len(right)
+    if pad < 1:
+        # Right-align right; truncate left.
+        max_left = max(0, inner - len(right) - 1)
+        left = _truncate(left, max_left)
+        pad = inner - len(left) - len(right)
+        pad = max(1, pad)
+    return f"│ {left}{' ' * pad}{right} │"
+
+
+def _hr(width: int, *, heavy: bool = False) -> str:
+    char = "═" if heavy else "─"
+    return ("╔" if heavy else "├") + char * (width - 2) + ("╗" if heavy else "┤")
+
+
+def _top(width: int) -> str:
+    return "╔" + "═" * (width - 2) + "╗"
+
+
+def _bottom(width: int) -> str:
+    return "╚" + "═" * (width - 2) + "╝"
+
+
+def _mid(width: int) -> str:
+    return "├" + "─" * (width - 2) + "┤"
+
+
+def _verdict_line(receipt: ForgeReceiptV1, *, width: int) -> str:
+    verdict = str(receipt.get("verdict", "FAIL"))
+    glyph = _VERDICT_GLYPH.get(verdict, "?")
+    return _row(f"{glyph} {verdict}",
+                f"forge {receipt.get('forge_version', '?')}",
+                width=width)
+
+
+def _certify_lines(receipt: ForgeReceiptV1, *, width: int) -> list[str]:
+    cert: dict[str, Any] = dict(receipt.get("certify", {}))  # type: ignore[arg-type]
+    score = cert.get("score", 0.0)
+    axes: dict[str, Any] = dict(cert.get("axes", {}))  # type: ignore[arg-type]
+    flag_glyph = lambda b: "✓" if b else "✗"  # noqa: E731
+    rows: list[str] = []
+    rows.append(_row("CERTIFY", f"{score:>5.1f} / 100", width=width))
+    rows.append(_row(
+        f"  docs {flag_glyph(axes.get('documentation_complete'))}  "
+        f"tests {flag_glyph(axes.get('tests_present'))}  "
+        f"layout {flag_glyph(axes.get('tier_layout_present'))}  "
+        f"wire {flag_glyph(axes.get('no_upward_imports'))}",
+        "",
+        width=width,
+    ))
+    return rows
+
+
+def _wire_line(receipt: ForgeReceiptV1, *, width: int) -> str:
+    wire: dict[str, Any] = dict(receipt.get("wire", {}))  # type: ignore[arg-type]
+    verdict = wire.get("verdict", "FAIL")
+    n = wire.get("violation_count", 0)
+    fixable = wire.get("auto_fixable", 0)
+    if fixable:
+        return _row("WIRE", f"{verdict}  ({n} viol, {fixable} auto-fix)",
+                    width=width)
+    return _row("WIRE", f"{verdict}  ({n} violation{'' if n == 1 else 's'})",
+                width=width)
+
+
+def _scout_line(receipt: ForgeReceiptV1, *, width: int) -> str:
+    scout: dict[str, Any] = dict(receipt.get("scout", {}))  # type: ignore[arg-type]
+    sym = scout.get("symbol_count", 0)
+    lang = scout.get("primary_language", "?")
+    tiers = scout.get("tier_distribution", {}) or {}
+    tier_total = sum(int(v) for v in tiers.values())
+    return _row(
+        f"SCOUT  {sym} symbol{'' if sym == 1 else 's'}  ({lang})",
+        f"{tier_total} tier-placed",
+        width=width,
+    )
+
+
+def _project_line(receipt: ForgeReceiptV1, *, width: int) -> str:
+    proj: dict[str, Any] = dict(receipt.get("project", {}))  # type: ignore[arg-type]
+    name = str(proj.get("name", "?"))
+    vcs: dict[str, Any] = dict(proj.get("vcs") or {})  # type: ignore[arg-type]
+    short = vcs.get("short_sha") or vcs.get("head_sha", "")[:7]
+    branch = vcs.get("branch")
+    if short and branch:
+        right = f"{branch}@{short}"
+    elif short:
+        right = short
+    else:
+        right = ""
+    return _row(name, right, width=width)
+
+
+def _attestation_line(receipt: ForgeReceiptV1, *, width: int) -> str:
+    att: dict[str, Any] = dict(receipt.get("lean4_attestation") or {})  # type: ignore[arg-type]
+    total = att.get("total_theorems", 0)
+    if not total:
+        return _row("LEAN4  (no attestation)", "", width=width)
+    corpora = att.get("corpora") or []
+    corpus_count = len(corpora)
+    return _row(
+        f"LEAN4  {total} theorem{'' if total == 1 else 's'} "
+        f"across {corpus_count} corpus{'' if corpus_count == 1 else 'es'}",
+        "0 sorry",
+        width=width,
+    )
+
+
+def _signature_line(receipt: ForgeReceiptV1, *, width: int) -> str:
+    sigs: dict[str, Any] = dict(receipt.get("signatures") or {})  # type: ignore[arg-type]
+    has_sigstore = bool(sigs.get("sigstore"))
+    has_nexus = bool(sigs.get("aaaa_nexus"))
+    if has_sigstore and has_nexus:
+        return _row("SIGNED  Sigstore + AAAA-Nexus", "", width=width)
+    if has_sigstore:
+        return _row("SIGNED  Sigstore", "", width=width)
+    if has_nexus:
+        return _row("SIGNED  AAAA-Nexus", "", width=width)
+    return _row("UNSIGNED  (run --sign to attest)", "", width=width)
+
+
+def render_receipt_card(
+    receipt: ForgeReceiptV1,
+    *,
+    width: int = 60,
+) -> str:
+    """Render a Receipt as a multi-line box-drawing card.
+
+    ``width`` defaults to 60. Terminal widths < 40 will look cramped
+    (every label gets truncated); the function never raises on small
+    widths but the output is best-effort below 40.
+    """
+    if width < 20:
+        raise ValueError("card width must be >= 20")
+    verdict = str(receipt.get("verdict", "FAIL"))
+    if verdict not in VALID_VERDICTS:
+        verdict = "FAIL"
+
+    lines: list[str] = []
+    lines.append(_top(width))
+    title = "Atomadic Forge Receipt"
+    lines.append(_row(title, receipt.get("schema_version", "?"), width=width))
+    lines.append(_mid(width))
+    lines.append(_verdict_line(receipt, width=width))
+    lines.append(_project_line(receipt, width=width))
+    lines.append(_mid(width))
+    lines.extend(_certify_lines(receipt, width=width))
+    lines.append(_wire_line(receipt, width=width))
+    lines.append(_scout_line(receipt, width=width))
+    lines.append(_mid(width))
+    lines.append(_attestation_line(receipt, width=width))
+    lines.append(_signature_line(receipt, width=width))
+    ts = str(receipt.get("generated_at_utc", "?"))
+    lines.append(_row("emitted", ts, width=width))
+    lines.append(_bottom(width))
+    return "\n".join(lines)