archforge-optimizer 0.1.0__py3-none-any.whl

archforge/config.py

@@ -0,0 +1,140 @@
+"""ArchForge system config — internals only (NOT user-tunable).
+
+This holds the NON-tunable framework plumbing: identity (``VERSION``), the LLM
+provider ROSTER (the tuples the CLI's ``--provider`` choices come from), the
+on-disk storage DIRNAMES + pointer files, the content-addressing hash lengths,
+Anthropic's required ``max_tokens``, the ScriptedJudge noise pattern, the CLI
+program name + its scripted fixtures, and ``load_env`` (the ``.env`` loader for
+provider API keys). **Nothing here is a user preference** — every value a user
+might tune (τ, δ, R, the default provider + models, the rubric, the storage root,
+token budgets, grader resilience …) lives instead in the project's
+``.archforge/archforge.py`` (made by ``archforge-optimizer init``) and is read
+lazily by ``archforge.userconfig`` at use time. So ``config.py`` ↔ ``archforge.py``
+share NO variable (the two-file split), and this module never depends on the
+user's config — it imports cleanly before ``init`` has run.
+
+Pure leaf: stdlib + ``python-dotenv`` (a core dependency) only — imports nothing
+else from ``archforge``, so every other module may ``from archforge.config import …``
+with no risk of a back-edge.
+"""
+
+from __future__ import annotations
+
+import importlib.util
+import os
+from pathlib import Path
+
+# =========================================================================== #
+# Identity
+# =========================================================================== #
+# The package version. Read by hatchling for the built distribution and
+# re-exported as `archforge.__version__` (archforge/__init__.py). One place.
+VERSION: str = "0.1.0"
+
+
+# =========================================================================== #
+# LLM providers — the ROSTER only (NOT the default choice; that's a tunable)
+# =========================================================================== #
+# The providers the CLI's `--provider` flag ACCEPTS (its `choices`). `scripted` is
+# the zero-cost option (deterministic fakes, no SDK, no API key); the real
+# providers each need their SDK + an API key. WHICH provider is the default, and
+# each provider's default MODEL id, are tunables → they live in .archforge/archforge.py
+# (resolved by archforge.userconfig), NOT here. `REAL_PROVIDERS`/`ALL_PROVIDERS` are
+# re-exported from archforge.llm; `make_client(provider)` dispatches on these.
+SCRIPTED_PROVIDER: str = "scripted"
+REAL_PROVIDERS: tuple[str, ...] = ("anthropic", "openai", "groq", "gemini")
+ALL_PROVIDERS: tuple[str, ...] = (SCRIPTED_PROVIDER,) + REAL_PROVIDERS
+
+
+# =========================================================================== #
+# Project environment (`.env`) — how secrets reach the provider SDKs
+# =========================================================================== #
+# A pip-installed `archforge` reads the project folder's `.env` so a checked-out
+# repo "just runs" once API keys are added (the `.env` is gitignored — never commit
+# secrets). `load_env()` populates `os.environ` with `override=False`, so the
+# precedence is: an explicit `--api-key` (passed straight to the SDK by the CLI)
+# > a real process env var > the `.env` file. `python-dotenv` is a CORE dependency
+# here (handles `export ` prefixes, quoting, multiline values robustly); an absent
+# file is a no-op. Provider env-var names are NOT centralized here — the provider
+# SDKs read their own (`ANTHROPIC_API_KEY` … `GEMINI_API_KEY`); this loader only
+# populates env.
+#
+# The DEFAULT `.env` path is a tunable (DEFAULT_ENV_FILE in archforge.py); this
+# loader's own default arg is the literal ".env" so the function stays a pure leaf
+# that never touches the resolver (callable pre-init, e.g. to load keys).
+
+def load_env(path: str | os.PathLike[str] | None = ".env") -> None:
+    """Populate ``os.environ`` from a ``.env`` file (via python-dotenv, no override).
+
+    A real process env var therefore always wins (``override=False``); the CLI's
+    ``--api-key`` (handed straight to the SDK) wins above both. No-op when the file
+    is absent or ``path`` is falsy — so callers (CLI, runner) invoke it
+    unconditionally. ``python-dotenv`` (core dep) does the parsing.
+    """
+    if not path:
+        return
+    if importlib.util.find_spec("dotenv") is not None:
+        from dotenv import load_dotenv  # type: ignore[import-not-found]
+        load_dotenv(path, override=False)   # override=False ⇒ real env wins
+
+
+# =========================================================================== #
+# Storage layout
+# =========================================================================== #
+# On-disk layout under the CLI's `--root` (a path the user passes, or ".archforge" —
+# a tunable, but the dirnames themselves are plumbing). The stores name their
+# subdirectories + pointer files from these; rare to change.
+SPECS_DIRNAME: str = "specs"
+ATTEMPTS_DIRNAME: str = "attempts"
+TRACES_DIRNAME: str = "traces"
+ACTIVE_POINTER_FILE: str = "active.pointer"   # names the active incumbent spec_id
+ARCHIVED_FILE: str = "archived.jsonl"          # rolled-back spec_ids (I3 reachability)
+
+
+# =========================================================================== #
+# Internals — not for tuning
+# =========================================================================== #
+# Bookkeeping values wired into specific consumers. Change only if you know the
+# consumer; these are plumbing, not user preferences.
+
+# Content-addressing hash truncation (sha256 hex prefix lengths). SPEC_ID_HASH_LEN
+# is the Spec/Attempt content id (models.py, attempt_store); SHORT_HASH_LEN is the
+# short deterministic suffixes used by the fake host (responder + run_id).
+SPEC_ID_HASH_LEN: int = 16
+SHORT_HASH_LEN: int = 8
+
+# Anthropic's messages API requires a max_tokens; used when a caller omits it
+# (only the Anthropic adapter). Not a user preference — a provider requirement.
+ANTHROPIC_DEFAULT_MAX_TOKENS: int = 1024
+
+# The ScriptedJudge's deterministic noise band (E1 jitter pattern): the jitter
+# applied to a scripted aggregate is `pattern[run_index % len] * noise_width`,
+# so identical runs yield identical jitter (reproducible E1 margin-boundary tests).
+SCRIPTED_NOISE_PATTERN: tuple[float, ...] = (1.0, 0.0, -1.0, 0.5, -0.5, 0.25, -0.25)
+
+# The CLI program name (the installed console command + the prefix on result lines).
+PROG: str = "archforge-optimizer"
+
+# The CLI's free-run scripted fixtures: when `--provider scripted` is invoked
+# with no injected `components`, the evolve family runs against this one-task suite
+# so `archforge-optimizer evolve` is runnable end-to-end with zero configuration.
+DEFAULT_SUITE_ID: str = "cli-default"
+DEFAULT_TASK_ID: str = "t1"
+DEFAULT_TASK_INPUT: str = "hello"
+
+
+__all__ = [
+    # identity
+    "VERSION",
+    # llm provider roster
+    "SCRIPTED_PROVIDER", "REAL_PROVIDERS", "ALL_PROVIDERS",
+    # project environment (.env loader for provider API keys)
+    "load_env",
+    # storage layout
+    "SPECS_DIRNAME", "ATTEMPTS_DIRNAME", "TRACES_DIRNAME",
+    "ACTIVE_POINTER_FILE", "ARCHIVED_FILE",
+    # internals
+    "SPEC_ID_HASH_LEN", "SHORT_HASH_LEN", "ANTHROPIC_DEFAULT_MAX_TOKENS",
+    "SCRIPTED_NOISE_PATTERN", "PROG",
+    "DEFAULT_SUITE_ID", "DEFAULT_TASK_ID", "DEFAULT_TASK_INPUT",
+]

archforge/config_init.py

@@ -0,0 +1,150 @@
+"""Scaffolding text for `archforge-optimizer init` — the user-tunable config template.
+
+Owns the ACTIVE defaults that become `.archforge/archforge.py` (the project's sole
+source of ArchForge tunables, made by `init`) and the `.env.example` key template.
+
+Two roles, one source:
+  * `init` writes ``archforge_config_text()`` verbatim to ``.archforge/archforge.py`` →
+    the user's tunables. It ships with **active sane values** so the CLI works
+    immediately after `init`; the user edits a value to change behaviour.
+  * Under the test runner, ``archforge.userconfig`` execs the SAME ``TEMPLATE``
+    in-memory (no disk file) so the suite sees the sane defaults
+    (e.g. ``Thresholds().tau == 0.05``) with zero per-test files.
+
+The values here are ArchForge's sane defaults — keep them in sync with what the
+package historically shipped. This module is pure data (string constants); it imports
+nothing from `archforge` and never reads the live `.env`.
+"""
+from __future__ import annotations
+
+# --------------------------------------------------------------------------- #
+# the sane tunable defaults — the ONE place the values live
+# --------------------------------------------------------------------------- #
+# (name, active-value-as-assignment, one-line purpose). The assignment text is
+# emitted verbatim into the generated file AND exec'd by the resolver, so it must be
+# valid Python and carry the real sane value (note DEFAULT_ARCHITECT_MODELS /
+# DEFAULT_JUDGE_MODELS / DEFAULT_SUB_RUBRICS are the full dicts, not `{}` — the
+# resolver must resolve them without KeyError).
+
+_DEFAULT_ARCHITECT_MODELS = (
+    '{"anthropic": "claude-sonnet-5", "openai": "gpt-4o", '
+    '"groq": "openai/gpt-oss-120b", "gemini": "gemini-3.6-flash"}'
+)
+_DEFAULT_JUDGE_MODELS = (
+    '{"anthropic": "claude-sonnet-5", "openai": "gpt-4o", '
+    '"groq": "openai/gpt-oss-120b", "gemini": "gemini-3.6-flash"}'
+)
+_DEFAULT_SUB_RUBRICS = (
+    '{"correctness": "Is the final answer factually correct and aligned with the task?", '
+    '"completeness": "Does the answer address every part of the task?", '
+    '"grounding": "Are the claims supported by the inputs/context, not invented?"}'
+)
+
+# The starter suite `init` writes to .archforge/suite.json — byte-identical to the
+# one-task CLI fallback fixture (cli-default / t1 / hello), so the generated default
+# round-trips to the same Suite the CLI builds when the file is absent. A per-task
+# rubric_id is optional in the file; omitting it scores against the active rubric.
+_DEFAULT_SUITE_JSON = (
+    '{\n'
+    '  "suite_id": "cli-default",\n'
+    '  "tasks": [\n'
+    '    {"task_id": "t1", "input": "hello"}\n'
+    '  ]\n'
+    '}\n'
+)
+
+_FIELDS: tuple[tuple[str, str, str], ...] = (
+    # --- LLM provider
+    ("PROVIDER", '"gemini"',
+     "which LLM to use (scripted|anthropic|openai|groq|gemini); scripted needs no API key"),
+    ("DEFAULT_ARCHITECT_MODELS", _DEFAULT_ARCHITECT_MODELS,
+     "default Architect (proposer) model per provider; a bare LLMClient call falls "
+     "back here too — edit the dict to change it"),
+    ("DEFAULT_JUDGE_MODELS", _DEFAULT_JUDGE_MODELS,
+     "default Judge (scorer) model per provider — edit the dict to change it"),
+    # --- optimization policy
+    ("DEFAULT_TAU", "0.05", "how much better a candidate must score to be promoted (τ)"),
+    ("DEFAULT_DELTA", "0.07", "how far a promoted run can drop before it's rolled back (δ, >= τ)"),
+    ("DEFAULT_REPEATS", "1", "how many times each eval task is run; more = steadier scores, more cost (R)"),
+    ("MAX_REPEATS", "3", "upper bound on R"),
+    ("DEFAULT_UNRUNNABLE_FRAC", "0.25", "drop a candidate if more than this fraction of its tasks crash (ε)"),
+    ("DEFAULT_PLATEAU_CYCLES", "5", "stop after this many cycles in a row with no improvement (K)"),
+    ("DEFAULT_MAX_CYCLES", "20", "max optimization cycles per run"),
+    # --- grader resilience
+    ("DEFAULT_JUDGE_RETRIES", "2", "how many times to retry a failed judge call"),
+    ("BACKOFF_CAP_SECONDS", "30.0", "max seconds to wait between judge retries"),
+    # --- judge scoring
+    ("DEFAULT_RUBRIC_ID", '"default-v1"', "name of the scoring rubric (keep it stable so runs compare)"),
+    ("DEFAULT_SUB_RUBRICS", _DEFAULT_SUB_RUBRICS,
+     "the rubric's dimensions: what a high score looks like, per dimension"),
+    # --- environment / budget / storage
+    ("DEFAULT_ROOT_DIR", '".archforge"', "where run state is written (relative to where you run the CLI)"),
+    ("DEFAULT_ENV_FILE", '".env"', "the .env file loaded for API keys (a real env var always wins)"),
+    ("DEFAULT_SUITE_FILE", '".archforge/suite.json"', "the suite file defining your eval tasks (absent → the one-task default)"),
+    ("DEFAULT_MAX_TOKENS_TOTAL", "None", "whole-run token budget cap; None = no limit"),
+    ("DEFAULT_MAX_TOKENS_PER_CYCLE", "None", "per-cycle token cap (aborts mid-cycle if exceeded); None = no limit"),
+    ("DEFAULT_MAX_WALL_MS_PER_CYCLE", "None", "per-cycle wall-clock cap (ms); aborts if exceeded — "
+     "covers non-LLM nodes (retriever/tool/rule) that cost time, not tokens; None = no limit"),
+    ("DEFAULT_TRACE_TOTAL_BUDGET_TOK", "None", "total Judge-prompt token budget for OTel trace "
+     "projection of per-step LLM prompt/completion; None = lossy summarize() path (parity, "
+     "no tracing); an int turns on rich per-step Steps, shedding largest-evidence chunks first"),
+)
+
+# section break points in _FIELDS (for grouping the emitted file)
+_BREAKS: dict[int, str] = {
+    3: "# --- optimization policy ------------------------------------------------",
+    10: "# --- grader resilience ---------------------------------------------------",
+    12: "# --- judge scoring -------------------------------------------------------",
+    14: "# --- environment / budget / storage --------------------------------------",
+}
+
+_HEADER = """\
+# archforge.py — your ArchForge config (made by `archforge-optimizer init`).
+#
+# The values below already work — the CLI runs as-is after `init`. Edit any value
+# to change that default. Nothing here is required to make ArchForge import.
+#
+
+# --- LLM provider ------------------------------------------------------------
+"""
+
+_FOOTER = """
+# Changes here take effect on the next `archforge-optimizer` run.
+"""
+
+
+def archforge_config_text() -> str:
+    """The full body of the generated `.archforge/archforge.py` (active sane defaults)."""
+    lines = [_HEADER.rstrip("\n")]
+    for i, (name, value, purpose) in enumerate(_FIELDS):
+        if i in _BREAKS:
+            lines.append("")
+            lines.append(_BREAKS[i])
+        lines.append(f"# {purpose}")
+        lines.append(f"{name} = {value}")
+    lines.append(_FOOTER.rstrip("\n"))
+    return "\n".join(lines) + "\n"
+
+
+# The active sane-default assignments, exec'd by archforge.userconfig under the test
+# runner (so the suite sees sane defaults) — same string `init` writes to disk.
+TEMPLATE: str = archforge_config_text()
+
+
+def env_example_text() -> str:
+    """The body of the generated `.env.example` (empty provider key var names)."""
+    return (
+        "# fill in your API keys for provider you are going to use for archforge-optimizer.\n\n"
+        "# ANTHROPIC_API_KEY=\n"
+        "# OPENAI_API_KEY=\n"
+        "# GROQ_API_KEY=\n"
+        "# GEMINI_API_KEY=\n"
+        "\n# Other service keys you need for your tasks\n"
+    )
+
+
+# The tunable names — exported so callers/tests enumerate the editable surface.
+EDITABLE_NAMES: tuple[str, ...] = tuple(name for name, _, _ in _FIELDS)
+
+__all__ = ["archforge_config_text", "env_example_text", "TEMPLATE", "EDITABLE_NAMES",
+           "_DEFAULT_SUITE_JSON"]

archforge/diff.py

@@ -0,0 +1,206 @@
+"""Spec-level structural diff — what changed from the parent Spec to the candidate.
+
+ArchForge's ``Change`` record (``m.Change``) carries the *intent* of a mutation
+(kind/target/diff/rationale/scope) but NOT the field-level before/after — the
+``payload`` dict evaporates after ``apply_change`` (it is metadata, not
+persisted). So an inspectable "what did the Forge actually change" requires
+diffing the two persisted Specs node-by-node. Both specs live in the SpecStore
+(``spec_store.get(parent_id)`` / ``get(candidate_id)``), so the comparison is
+cheap and needs nothing beyond the Specs themselves.
+
+``spec_diff(parent, candidate)`` does exactly that: a pure comparison returning a
+deterministic list of ``DiffEntry`` records. It powers the CLI's per-cycle
+mutation-diff card (improvement #2) and is reuseable by any embedder that wants
+to surface what a candidate changed vs its parent.
+
+Only *real* changes surface — identical Specs yield ``[]``. Knob changes are
+classified against ``m._NAMED_KNOBS`` (the single source lifted into
+``archforge.models``): the named LLM knobs (temperature/retries/max_tokens) and
+the kind-specific extras (top_k/threshold/...) are both reported as
+``kind="knob"``; ``tunable`` is editability *metadata*, not a knob value, and is
+NOT reported. Deterministic order: parent-spec node order for matched/removed
+nodes, candidate-spec node order for added nodes, then edges.
+"""
+from __future__ import annotations
+
+from dataclasses import dataclass
+from typing import Any
+
+import archforge.models as m
+
+
+@dataclass(frozen=True)
+class DiffEntry:
+    """One field-level change between a parent Spec and its candidate.
+
+    ``kind``    : category of the change
+                 (knob|prompt|model|add_node|remove_node|edge|role|kind)
+    ``target``  : the node_id (for node fields) or "from->to" (for edges)
+    ``field``   : the field name on the target (system_prompt|model|role|kind|
+                 <knob_name>|edge|gate)
+    ``old``     : the parent's value (None for an addition);
+    ``new``     : the candidate's value (None for a removal)
+    """
+
+    kind: str
+    target: str
+    field: str
+    old: Any
+    new: Any
+
+    def one_liner(self) -> str:
+        """Compact ``field: old -> new`` for a card's change line."""
+        return f"{self.field}: {_fmt(self.old)} -> {_fmt(self.new)}"
+
+    def as_dict(self) -> dict[str, Any]:
+        return {"kind": self.kind, "target": self.target, "field": self.field,
+                "old": self.old, "new": self.new}
+
+
+def _fmt(v: Any) -> str:
+    if v is None:
+        return "(unset)"
+    if isinstance(v, bool):
+        return str(v).lower()
+    return str(v)
+
+
+# --------------------------------------------------------------------------- #
+# the diff
+# --------------------------------------------------------------------------- #
+
+
+def spec_diff(parent: m.Spec, candidate: m.Spec) -> list[DiffEntry]:
+    """Field-level diff of ``candidate`` vs ``parent`` (deterministic, pure).
+
+    Node diffs come before edge diffs. Within a matched node the order is
+    system_prompt, model, role, kind, then knobs (named knobs in a fixed order,
+    then extras). Returns ``[]`` for identical Specs.
+    """
+    out: list[DiffEntry] = []
+    pnodes: dict[str, m.Node] = {n.node_id: n for n in parent.nodes}
+    cnodes: dict[str, m.Node] = {n.node_id: n for n in candidate.nodes}
+
+    # matched + removed nodes (parent order), then added nodes (candidate order).
+    for pn in parent.nodes:
+        cn = cnodes.get(pn.node_id)
+        if cn is None:
+            out.append(DiffEntry("remove_node", pn.node_id, "node", pn.node_id, None))
+            continue
+        out.extend(_node_diff(pn, cn))
+    for cn in candidate.nodes:
+        if cn.node_id not in pnodes:
+            out.append(DiffEntry("add_node", cn.node_id, "node", None, cn.node_id))
+
+    out.extend(_edge_diff(parent, candidate))
+    return out
+
+
+def _node_diff(parent: m.Node, candidate: m.Node) -> list[DiffEntry]:
+    nid = parent.node_id
+    out: list[DiffEntry] = []
+    if parent.system_prompt != candidate.system_prompt:
+        out.append(DiffEntry("prompt", nid, "system_prompt",
+                             parent.system_prompt, candidate.system_prompt))
+    if parent.model != candidate.model:
+        out.append(DiffEntry("model", nid, "model", parent.model, candidate.model))
+    if parent.role != candidate.role:
+        out.append(DiffEntry("role", nid, "role", parent.role, candidate.role))
+    if parent.kind is not candidate.kind:
+        out.append(DiffEntry("kind", nid, "kind", parent.kind.value, candidate.kind.value))
+    out.extend(_knob_diff(nid, parent.knobs, candidate.knobs))
+    return out
+
+
+def _knob_diff(nid: str, pk: m.Knobs, ck: m.Knobs) -> list[DiffEntry]:
+    out: list[DiffEntry] = []
+    pd = pk.model_dump()
+    cd = ck.model_dump()
+    # named knobs in a fixed stable order, then extras in candidate insertion
+    # order, then parent-only extras (a knob dropped from the candidate).
+    named = ["temperature", "retries", "max_tokens"]
+    extras = [k for k in cd if k not in m._NAMED_KNOBS]
+    parent_extras = [k for k in pd if k not in m._NAMED_KNOBS and k not in extras]
+    for key in named + extras + parent_extras:
+        pv = pd.get(key)
+        cv = cd.get(key)
+        if pv != cv:
+            out.append(DiffEntry("knob", nid, key, pv, cv))
+    return out
+
+
+def _edge_key(e: m.Edge) -> tuple[str, str, str]:
+    return (e.from_, e.to, e.type.value)
+
+
+def _edge_diff(parent: m.Spec, candidate: m.Spec) -> list[DiffEntry]:
+    out: list[DiffEntry] = []
+    pedge: dict[tuple[str, str, str], m.Edge] = {_edge_key(e): e for e in parent.edges}
+    for pe in parent.edges:
+        ce = next((c for c in candidate.edges if _edge_key(c) == _edge_key(pe)), None)
+        if ce is None:
+            out.append(DiffEntry("edge", _edge_label(pe), "edge",
+                                _edge_describe(pe), None))
+        elif pe.gate != ce.gate:
+            out.append(DiffEntry("edge", _edge_label(pe), "gate", pe.gate, ce.gate))
+    for ce in candidate.edges:
+        if _edge_key(ce) not in pedge:
+            out.append(DiffEntry("edge", _edge_label(ce), "edge", None, _edge_describe(ce)))
+    return out
+
+
+def _edge_label(e: m.Edge) -> str:
+    return f"{e.from_}->{e.to}"
+
+
+def _edge_describe(e: m.Edge) -> str:
+    s = e.type.value
+    if e.gate:
+        s += f" gate={e.gate}"
+    return s
+
+
+# --------------------------------------------------------------------------- #
+# rendering helper — a compact one-liner for the CLI's change card
+# --------------------------------------------------------------------------- #
+
+
+def format_diff(entries: list[DiffEntry]) -> str:
+    """Compact one-liner for a card's change line, from a ``spec_diff`` list.
+
+    Field-level diffs (knob/prompt/model/role/kind on matched nodes) are joined
+    with "; " (most changes are a single field). Structural diffs (added/removed
+    nodes + edges — ADD_NODE/REMOVE_NODE/REWIRE) are summarized as a roster delta
+    (``+node v +edge 1 -edge 1 ~edge 1``) so the card stays one line even when a
+    -- proposed change touches several edges/nodes at once. Any field-level diffs
+    riding alongside a structural change (e.g. a rewire that also swapped a model)
+    are appended so nothing is silently dropped.
+    """
+    if not entries:
+        return "(no change)"
+    structural = [e for e in entries if e.kind in ("add_node", "remove_node", "edge")]
+    if not structural:
+        return "; ".join(e.one_liner() for e in entries)
+    parts: list[str] = []
+    added = [e.target for e in structural if e.kind == "add_node"]
+    removed = [e.target for e in structural if e.kind == "remove_node"]
+    added_edges = [e for e in structural if e.kind == "edge" and e.old is None]
+    removed_edges = [e for e in structural if e.kind == "edge" and e.new is None]
+    changed_edges = [e for e in structural if e.kind == "edge" and e.old is not None and e.new is not None]
+    if added:
+        parts.append(f"+node {' '.join(added)}")
+    if removed:
+        parts.append(f"-node {' '.join(removed)}")
+    if added_edges:
+        parts.append(f"+edge {len(added_edges)}")
+    if removed_edges:
+        parts.append(f"-edge {len(removed_edges)}")
+    if changed_edges:
+        parts.append(f"~edge {len(changed_edges)}")
+    field_level = [e for e in entries if e.kind not in ("add_node", "remove_node", "edge")]
+    if field_level:
+        parts.append("; ".join(e.one_liner() for e in field_level))
+    return " ".join(parts)
+
+
+__all__ = ["DiffEntry", "spec_diff", "format_diff"]