atomadic-forge 0.3.2__py3-none-any.whl

atomadic_forge/a1_at_functions/stub_detector.py

@@ -0,0 +1,158 @@
+"""Tier a1 — pure stub-body detector.
+
+When an LLM emits a file with ``pass``, ``raise NotImplementedError``, or
+a ``# TODO`` / ``# Implement me!`` placeholder, the file *looks* like a
+real symbol but won't run.  We must catch this so the certify score can't
+be gamed by emitting empty shells.
+
+The detector inspects function/class bodies via AST; placeholder comments
+are matched via Python tokenization so docstrings and prompt text are not
+mistaken for code stubs.  Returns one record per stub-shaped symbol with
+the file path, qualname, and the specific stub kind detected.
+"""
+
+from __future__ import annotations
+
+import ast
+import io
+import re
+import tokenize
+from collections.abc import Iterable
+from pathlib import Path
+from typing import Literal, TypedDict
+
+StubKind = Literal["pass_only", "not_implemented", "comment_only",
+                   "todo_marker"]
+
+
+class StubFinding(TypedDict):
+    file: str            # repo-relative
+    qualname: str
+    lineno: int
+    kind: StubKind
+    excerpt: str         # one line, for prompt feedback
+
+
+_TODO_RE = re.compile(
+    r"#\s*(TODO|FIXME|XXX|HACK|implement\s+me|implement\s+this|"
+    r"add\s+actual|fill\s+this)\b",
+    re.IGNORECASE,
+)
+
+
+def _function_body_is_pass_only(fn: ast.AST) -> bool:
+    if not isinstance(fn, ast.FunctionDef | ast.AsyncFunctionDef):
+        return False
+    body = list(fn.body)
+    # Strip docstring.
+    if (body and isinstance(body[0], ast.Expr)
+            and isinstance(body[0].value, ast.Constant)
+            and isinstance(body[0].value.value, str)):
+        body = body[1:]
+    if not body:
+        return True
+    if len(body) == 1 and isinstance(body[0], ast.Pass):
+        return True
+    return False
+
+
+def _function_body_raises_not_implemented(fn: ast.AST) -> bool:
+    if not isinstance(fn, ast.FunctionDef | ast.AsyncFunctionDef):
+        return False
+    for node in ast.walk(fn):
+        if isinstance(node, ast.Raise) and node.exc is not None:
+            target = node.exc
+            if isinstance(target, ast.Call):
+                target = target.func
+            if isinstance(target, ast.Name) and target.id == "NotImplementedError":
+                return True
+            if isinstance(target, ast.Attribute) and target.attr == "NotImplementedError":
+                return True
+    return False
+
+
+def _todo_comment_lines(src: str) -> list[tuple[int, str]]:
+    """Return placeholder comments only, excluding docstrings and strings."""
+    out: list[tuple[int, str]] = []
+    try:
+        tokens = tokenize.generate_tokens(io.StringIO(src).readline)
+        for tok in tokens:
+            if tok.type == tokenize.COMMENT and _TODO_RE.search(tok.string):
+                out.append((tok.start[0], tok.line.rstrip()))
+    except tokenize.TokenError:
+        return []
+    return out
+
+
+def detect_stubs_in_file(path: Path, *, repo_root: Path | None = None
+                         ) -> list[StubFinding]:
+    """Return a finding per stub-shaped function/class in ``path``.
+
+    Only reports public callables (no leading underscore) so we don't flag
+    private helpers that legitimately ``pass``.
+    """
+    try:
+        src = path.read_text(encoding="utf-8", errors="replace")
+        tree = ast.parse(src, filename=str(path))
+    except (SyntaxError, OSError):
+        return []
+    rel = (path.relative_to(repo_root).as_posix()
+            if repo_root else path.as_posix())
+    src_lines = src.splitlines()
+    out: list[StubFinding] = []
+
+    todo_lines = _todo_comment_lines(src)
+
+    def add(qualname: str, lineno: int, kind: StubKind, excerpt: str) -> None:
+        out.append(StubFinding(file=rel, qualname=qualname, lineno=lineno,
+                                kind=kind, excerpt=excerpt[:120]))
+
+    def visit(node: ast.AST, prefix: str = "") -> None:
+        if isinstance(node, ast.FunctionDef | ast.AsyncFunctionDef):
+            if node.name.startswith("_") and node.name != "__init__":
+                return
+            qual = f"{prefix}{node.name}" if prefix else node.name
+            line = src_lines[node.lineno - 1] if 0 < node.lineno <= len(src_lines) else ""
+            if _function_body_is_pass_only(node):
+                add(qual, node.lineno, "pass_only", line)
+            elif _function_body_raises_not_implemented(node):
+                add(qual, node.lineno, "not_implemented", line)
+            return
+        if isinstance(node, ast.ClassDef):
+            for sub in node.body:
+                visit(sub, prefix=f"{node.name}.")
+            return
+
+    for node in tree.body:
+        visit(node)
+
+    # File-level TODO/FIXME markers — surface even when the body otherwise looks fine.
+    for ln, line in todo_lines:
+        if not any(f["lineno"] == ln for f in out):
+            kind: StubKind = "todo_marker"
+            add(f"<line {ln}>", ln, kind, line.strip())
+
+    return out
+
+
+def detect_stubs(*, package_root: Path,
+                 only_emitted: Iterable[Path] | None = None
+                 ) -> list[StubFinding]:
+    """Walk a tier package (or a specific list of files) and aggregate stubs."""
+    package_root = Path(package_root)
+    files: Iterable[Path]
+    if only_emitted is not None:
+        files = [Path(p) for p in only_emitted]
+    else:
+        files = package_root.rglob("*.py")
+    out: list[StubFinding] = []
+    for f in files:
+        if not f.exists() or "__pycache__" in f.parts or f.name == "__init__.py":
+            continue
+        out.extend(detect_stubs_in_file(f, repo_root=package_root))
+    return out
+
+
+def stub_penalty(findings: list[StubFinding]) -> int:
+    """Cap-aware penalty for the certify score: 8 points per stub, max 40."""
+    return min(40, 8 * len(findings))

atomadic_forge/a1_at_functions/synergy_detect.py

@@ -0,0 +1,166 @@
+"""Tier a1 — pure synergy detector.
+
+Given a list of :class:`FeatureSurfaceCard`, produce ranked
+:class:`SynergyCandidateCard`s.
+
+Five signals (each contributes to the score):
+
+* ``json_artifact``      — A emits ``--json-out``, B accepts a path/file arg.
+* ``in_memory_pipe``     — vocabulary from A's outputs overlaps B's inputs.
+* ``shared_schema``      — both reference the same ``atomadic-forge.<x>/v<n>`` schema.
+* ``shared_vocabulary``  — Jaccard(vocab_A, vocab_B) ≥ threshold.
+* ``phase_omission``     — A.phase_hint == "emit" and B.phase_hint == "ingest"
+                            (or analogous predecessor → successor).
+
+The detector ALWAYS proposes pairs (A, B) with A ≠ B and returns them
+sorted by descending score.
+"""
+
+from __future__ import annotations
+
+import hashlib
+from collections.abc import Iterable
+
+from ..a0_qk_constants.synergy_types import (
+    FeatureSurfaceCard,
+    SynergyCandidateCard,
+    SynergyKind,
+)
+
+_PHASE_FLOW = [
+    "recon", "ingest", "plan", "materialize", "certify", "emit", "register",
+]
+_PHASE_NEXT = {p: _PHASE_FLOW[i + 1] for i, p in enumerate(_PHASE_FLOW[:-1])}
+
+
+def _candidate_id(producer: str, consumer: str, kind: str) -> str:
+    h = hashlib.sha256(f"{producer}->{consumer}|{kind}".encode()).hexdigest()
+    return f"syn-{h[:8]}"
+
+
+def _jaccard(a: set[str], b: set[str]) -> float:
+    if not a and not b:
+        return 0.0
+    return len(a & b) / max(1, len(a | b))
+
+
+def _detect_pair(a: FeatureSurfaceCard,
+                 b: FeatureSurfaceCard) -> list[SynergyCandidateCard]:
+    out: list[SynergyCandidateCard] = []
+
+    # 1. JSON-artifact handoff: producer outputs a JSON, consumer takes a file.
+    json_out_signals = [o for o in a["outputs"] if "json" in o or "out" in o]
+    file_in_signals = [f for f in b["input_files"] if f]
+    if json_out_signals and file_in_signals:
+        score_breakdown = {
+            "json_handoff": 35,
+            "phase_step": 15 if _PHASE_NEXT.get(a["phase_hint"]) == b["phase_hint"] else 0,
+            "vocab_overlap": min(20, int(20 * _jaccard(set(a["vocabulary"]),
+                                                      set(b["vocabulary"])))),
+        }
+        score = sum(score_breakdown.values())
+        if score >= 30:
+            out.append(SynergyCandidateCard(
+                candidate_id=_candidate_id(a["name"], b["name"], "json_artifact"),
+                producer=a["name"],
+                consumer=b["name"],
+                kind="json_artifact",
+                why=[
+                    f"{a['name']} emits {json_out_signals[0]}",
+                    f"{b['name']} accepts {file_in_signals[0]}",
+                ],
+                score=float(score),
+                score_breakdown=score_breakdown,
+                proposed_adapter_name=f"{a['name']}-then-{b['name']}",
+                proposed_summary=(
+                    f"Run {a['name']} to emit a JSON artifact, then feed it to "
+                    f"{b['name']} for the next phase."
+                ),
+            ))
+
+    # 2. Shared schema reference — both source files mention the same
+    #    atomadic-forge.<x>/v<n> schema string.  Strong signal regardless of phase.
+    shared_schemas = sorted(set(a["schemas"]) & set(b["schemas"]))
+    if shared_schemas:
+        score_breakdown = {"schema_match": 50, "schemas_count": min(10, 5 * len(shared_schemas))}
+        score = sum(score_breakdown.values())
+        out.append(SynergyCandidateCard(
+            candidate_id=_candidate_id(a["name"], b["name"], "shared_schema"),
+            producer=a["name"],
+            consumer=b["name"],
+            kind="shared_schema",
+            why=[f"both reference schema(s) {', '.join(shared_schemas)}"],
+            score=float(score),
+            score_breakdown=score_breakdown,
+            proposed_adapter_name=f"{a['name']}-feeds-{b['name']}",
+            proposed_summary=(
+                f"{a['name']} and {b['name']} share schema {shared_schemas[0]} — "
+                "wire them as a pipeline rather than running each by hand."
+            ),
+        ))
+
+    # 3. Phase-omission: producer is at step N, consumer at step N+1, but
+    #    neither lists the other in its vocabulary (i.e. no existing mention
+    #    of the partner).
+    if (_PHASE_NEXT.get(a["phase_hint"]) == b["phase_hint"]
+            and a["name"].lower() not in set(b["vocabulary"])
+            and b["name"].lower() not in set(a["vocabulary"])):
+        score_breakdown = {"phase_step": 30, "missing_mention": 20}
+        score = sum(score_breakdown.values())
+        out.append(SynergyCandidateCard(
+            candidate_id=_candidate_id(a["name"], b["name"], "phase_omission"),
+            producer=a["name"],
+            consumer=b["name"],
+            kind="phase_omission",
+            why=[
+                f"{a['name']} is at phase '{a['phase_hint']}', "
+                f"{b['name']} at '{b['phase_hint']}' — natural successor",
+                "neither references the other in help/docstring",
+            ],
+            score=float(score),
+            score_breakdown=score_breakdown,
+            proposed_adapter_name=f"{a['name']}-into-{b['name']}",
+            proposed_summary=(
+                f"{a['name']} produces {a['phase_hint']}-phase output that "
+                f"{b['name']} could consume — currently un-piped."
+            ),
+        ))
+
+    # 4. High-overlap vocabulary (subject-matter pairs working in same area).
+    overlap = _jaccard(set(a["vocabulary"]), set(b["vocabulary"]))
+    if overlap >= 0.4:
+        score_breakdown = {"vocab_overlap": int(40 * overlap)}
+        score = sum(score_breakdown.values())
+        if score >= 25:
+            shared = sorted(set(a["vocabulary"]) & set(b["vocabulary"]))[:6]
+            out.append(SynergyCandidateCard(
+                candidate_id=_candidate_id(a["name"], b["name"], "shared_vocabulary"),
+                producer=a["name"],
+                consumer=b["name"],
+                kind="shared_vocabulary",
+                why=[f"shared vocabulary: {', '.join(shared)}"],
+                score=float(score),
+                score_breakdown=score_breakdown,
+                proposed_adapter_name=f"{a['name']}-with-{b['name']}",
+                proposed_summary=(
+                    f"{a['name']} and {b['name']} talk about the same domain "
+                    f"({', '.join(shared[:3])}) but aren't wired together."
+                ),
+            ))
+    return out
+
+
+def detect_synergies(features: Iterable[FeatureSurfaceCard]) -> list[SynergyCandidateCard]:
+    feats = list(features)
+    out: list[SynergyCandidateCard] = []
+    seen: set[tuple[str, str, SynergyKind]] = set()
+    for i, a in enumerate(feats):
+        for b in feats[i + 1:] + feats[:i]:
+            for cand in _detect_pair(a, b):
+                key = (cand["producer"], cand["consumer"], cand["kind"])
+                if key in seen:
+                    continue
+                seen.add(key)
+                out.append(cand)
+    out.sort(key=lambda c: c["score"], reverse=True)
+    return out

atomadic_forge/a1_at_functions/synergy_render.py

@@ -0,0 +1,252 @@
+"""Tier a1 — pure source synthesiser for a Synergy adapter.
+
+Given a :class:`SynergyCandidateCard`, render a tiny ``commands/<name>.py``
+Typer module that wires producer to consumer.  Four templates cover the
+detected synergy kinds:
+
+* ``json_artifact``    — producer emits ``--json-out PATH`` then consumer
+                         reads PATH as its first positional argument.
+* ``in_memory_pipe``   — both modules importable; run the producer's main
+                         in-process, capture its return, hand to consumer.
+* ``phase_omission``   — producer + consumer in the natural phase order
+                         with a clear ``# review: arg alignment`` marker
+                         since signatures may not match.
+* ``shared_schema``    — like ``json_artifact`` but the adapter validates
+                         the JSON against the shared schema before piping.
+
+The right template is picked from ``card["kind"]``.
+"""
+
+from __future__ import annotations
+
+from ..a0_qk_constants.synergy_types import SynergyCandidateCard
+
+
+def render_synergy_adapter(card: SynergyCandidateCard) -> str:
+    """Dispatch to the right per-kind renderer."""
+    renderers = {
+        "json_artifact": _render_json_artifact,
+        "in_memory_pipe": _render_in_memory_pipe,
+        "phase_omission": _render_phase_omission,
+        "shared_schema": _render_shared_schema,
+        "shared_vocabulary": _render_phase_omission,  # treat like a soft chain
+    }
+    return renderers.get(card["kind"], _render_json_artifact)(card)
+
+
+def _header_lines(card: SynergyCandidateCard) -> list[str]:
+    name = card["proposed_adapter_name"]
+    safe_help = card["proposed_summary"].replace('"""', "'''")
+    lines = [
+        '"""',
+        f"Auto-synthesized synergy adapter ({card['candidate_id']}).",
+        "",
+        f"Producer:  {card['producer']}",
+        f"Consumer:  {card['consumer']}",
+        f"Kind:      {card['kind']}",
+        f"Score:     {card['score']:.0f}",
+        "",
+        "Why this synergy was detected:",
+    ]
+    for w in card["why"]:
+        lines.append(f"  - {w}")
+    lines.extend([
+        "",
+        "Re-emit with ``atomadic-forge synergy implement <id>`` after surfaces change.",
+        '"""',
+        "",
+        "from __future__ import annotations",
+        "",
+        "import json",
+        "import subprocess",
+        "import sys",
+        "import tempfile",
+        "from pathlib import Path",
+        "from typing import Annotated",
+        "",
+        "import typer",
+        "",
+        f"COMMAND_NAME = {name!r}",
+        f"COMMAND_HELP = {safe_help!r}",
+        "",
+        f'app = typer.Typer(no_args_is_help=False, help={safe_help!r})',
+        "",
+    ])
+    return lines
+
+
+def _render_json_artifact(card: SynergyCandidateCard) -> str:
+    body = _header_lines(card)
+    body.extend([
+        "@app.callback(invoke_without_command=True)",
+        "def run(",
+        "    ctx: typer.Context,",
+        "    producer_args: Annotated[list[str] | None, typer.Argument(",
+        "        help='Args forwarded to the producer command.')] = None,",
+        ") -> None:",
+        f'    """Run {card["producer"]} → capture artifact → feed to {card["consumer"]}."""',
+        "    if ctx.invoked_subcommand is not None:",
+        "        return",
+        "    producer_args = producer_args or []",
+        "    with tempfile.TemporaryDirectory(prefix='synergy-') as tmp:",
+        "        artifact = Path(tmp) / 'producer.json'",
+        "        cmd_a = [sys.executable, '-m',",
+        "                 'atomadic_forge.a4_sy_orchestration.unified_cli',",
+        f"                 {card['producer']!r}, *producer_args,",
+        "                 '--json-out', str(artifact)]",
+        "        rc = subprocess.run(cmd_a, capture_output=False).returncode",
+        "        if rc != 0:",
+        "            typer.secho(f'producer exited {rc}', fg='red', err=True)",
+        "            raise typer.Exit(rc)",
+        "        cmd_b = [sys.executable, '-m',",
+        "                 'atomadic_forge.a4_sy_orchestration.unified_cli',",
+        f"                 {card['consumer']!r}, str(artifact)]",
+        "        rc = subprocess.run(cmd_b, capture_output=False).returncode",
+        "        if rc != 0:",
+        "            typer.secho(f'consumer exited {rc}', fg='red', err=True)",
+        "            raise typer.Exit(rc)",
+        "        try:",
+        "            data = json.loads(artifact.read_text(encoding='utf-8'))",
+        "        except (OSError, json.JSONDecodeError):",
+        "            data = None",
+        "        typer.echo(json.dumps({",
+        f"            'synergy': {card['candidate_id']!r},",
+        f"            'producer': {card['producer']!r},",
+        f"            'consumer': {card['consumer']!r},",
+        "            'artifact_size_bytes': artifact.stat().st_size,",
+        "            'producer_payload_keys': sorted(data.keys()) if isinstance(data, dict) else None,",
+        "        }, indent=2))",
+        "",
+    ])
+    return "\n".join(body) + "\n"
+
+
+def _render_in_memory_pipe(card: SynergyCandidateCard) -> str:
+    """Run producer + consumer in-process; pass producer return to consumer.
+
+    Falls back to subprocess JSON-piping if either side isn't importable.
+    """
+    body = _header_lines(card)
+    body.extend([
+        "@app.callback(invoke_without_command=True)",
+        "def run(ctx: typer.Context) -> None:",
+        f'    """Run {card["producer"]} in-process and pass its return to {card["consumer"]}."""',
+        "    if ctx.invoked_subcommand is not None:",
+        "        return",
+        "    # NOTE: in-memory pipe assumes producer and consumer expose a",
+        "    # callable named `run` (or `main`) at module level.  Manual wiring",
+        "    # required if signatures don't align — see arg-alignment marker.",
+        "    try:",
+        f"        from atomadic_forge.commands import {card['producer']!s} as _producer  # type: ignore[import-not-found]",
+        f"        from atomadic_forge.commands import {card['consumer']!s} as _consumer  # type: ignore[import-not-found]",
+        "    except ImportError as exc:",
+        "        typer.secho(f'in-memory pipe unavailable: {exc}', fg='yellow', err=True)",
+        "        raise typer.Exit(2) from exc",
+        "    producer_fn = getattr(_producer, 'run', None) or getattr(_producer, 'main', None)",
+        "    consumer_fn = getattr(_consumer, 'run', None) or getattr(_consumer, 'main', None)",
+        "    if producer_fn is None or consumer_fn is None:",
+        "        typer.secho('producer or consumer has no `run`/`main` callable', fg='red', err=True)",
+        "        raise typer.Exit(2)",
+        "    intermediate = producer_fn()",
+        "    # review: arg alignment — consumer may need shaping of `intermediate`",
+        "    result = consumer_fn(intermediate)",
+        "    typer.echo(json.dumps({",
+        f"        'synergy': {card['candidate_id']!r},",
+        "        'result': str(result)[:2000],",
+        "    }, indent=2))",
+        "",
+    ])
+    return "\n".join(body) + "\n"
+
+
+def _render_phase_omission(card: SynergyCandidateCard) -> str:
+    """Producer at phase N → consumer at phase N+1.  Both via subprocess.
+
+    Args may not align — emits a clear ``# review:`` marker so the operator
+    knows to inspect.  Default behaviour is to run producer with no args
+    then prompt for consumer args.
+    """
+    body = _header_lines(card)
+    body.extend([
+        "@app.callback(invoke_without_command=True)",
+        "def run(",
+        "    ctx: typer.Context,",
+        "    producer_args: Annotated[list[str] | None, typer.Argument(",
+        "        help='Args for producer (everything before --consumer-args).')] = None,",
+        "    consumer_args: Annotated[list[str] | None, typer.Option('--consumer-args',",
+        "        help='Args forwarded to consumer (space-separated).')] = None,",
+        ") -> None:",
+        f'    """Phase chain: {card["producer"]} (phase) → {card["consumer"]} (next phase)."""',
+        "    if ctx.invoked_subcommand is not None:",
+        "        return",
+        "    # review: arg alignment — phase_omission synergies are heuristic.",
+        "    # The producer and consumer were inferred from phase order alone, so",
+        "    # their CLI signatures are almost certainly different.  Pass args",
+        "    # explicitly via positional + --consumer-args until you hand-shape",
+        "    # this adapter.",
+        "    producer_args = producer_args or []",
+        "    consumer_args = (consumer_args or '').split() if isinstance(consumer_args, str) else (consumer_args or [])",
+        "    cmd_a = [sys.executable, '-m', 'atomadic_forge.a4_sy_orchestration.unified_cli',",
+        f"             {card['producer']!r}, *producer_args]",
+        "    rc = subprocess.run(cmd_a, capture_output=False).returncode",
+        "    if rc != 0:",
+        "        typer.secho(f'producer exited {rc}', fg='red', err=True)",
+        "        raise typer.Exit(rc)",
+        "    cmd_b = [sys.executable, '-m', 'atomadic_forge.a4_sy_orchestration.unified_cli',",
+        f"             {card['consumer']!r}, *consumer_args]",
+        "    rc = subprocess.run(cmd_b, capture_output=False).returncode",
+        "    if rc != 0:",
+        "        typer.secho(f'consumer exited {rc}', fg='red', err=True)",
+        "        raise typer.Exit(rc)",
+        "    typer.echo(json.dumps({",
+        f"        'synergy': {card['candidate_id']!r},",
+        f"        'phase_chain': [{card['producer']!r}, {card['consumer']!r}],",
+        "    }, indent=2))",
+        "",
+    ])
+    return "\n".join(body) + "\n"
+
+
+def _render_shared_schema(card: SynergyCandidateCard) -> str:
+    """Like json_artifact but validates the producer JSON before piping."""
+    body = _header_lines(card)
+    body.extend([
+        "@app.callback(invoke_without_command=True)",
+        "def run(",
+        "    ctx: typer.Context,",
+        "    producer_args: Annotated[list[str] | None, typer.Argument(",
+        "        help='Args forwarded to the producer command.')] = None,",
+        ") -> None:",
+        f'    """Run {card["producer"]} → validate shared schema → feed to {card["consumer"]}."""',
+        "    if ctx.invoked_subcommand is not None:",
+        "        return",
+        "    producer_args = producer_args or []",
+        "    with tempfile.TemporaryDirectory(prefix='synergy-') as tmp:",
+        "        artifact = Path(tmp) / 'producer.json'",
+        "        cmd_a = [sys.executable, '-m', 'atomadic_forge.a4_sy_orchestration.unified_cli',",
+        f"                 {card['producer']!r}, *producer_args, '--json-out', str(artifact)]",
+        "        rc = subprocess.run(cmd_a, capture_output=False).returncode",
+        "        if rc != 0:",
+        "            raise typer.Exit(rc)",
+        "        try:",
+        "            payload = json.loads(artifact.read_text(encoding='utf-8'))",
+        "        except (OSError, json.JSONDecodeError) as exc:",
+        "            typer.secho(f'producer JSON invalid: {exc}', fg='red', err=True)",
+        "            raise typer.Exit(2) from exc",
+        "        schema_id = payload.get('schema_version') or payload.get('schema')",
+        "        if not schema_id:",
+        "            typer.secho('producer payload missing schema_version field', fg='yellow', err=True)",
+        "        cmd_b = [sys.executable, '-m', 'atomadic_forge.a4_sy_orchestration.unified_cli',",
+        f"                 {card['consumer']!r}, str(artifact)]",
+        "        rc = subprocess.run(cmd_b, capture_output=False).returncode",
+        "        if rc != 0:",
+        "            raise typer.Exit(rc)",
+        "        typer.echo(json.dumps({",
+        f"            'synergy': {card['candidate_id']!r},",
+        "            'schema_id': schema_id,",
+        f"            'producer': {card['producer']!r},",
+        f"            'consumer': {card['consumer']!r},",
+        "        }, indent=2))",
+        "",
+    ])
+    return "\n".join(body) + "\n"