syncade 0.6.2__py3-none-any.whl

syncade/cli/config_keys.py

@@ -0,0 +1,135 @@
+"""Schema-driven dotted-key resolution + coercion for ``--config set`` (pr-v2-31 Increment 2).
+
+Shared by ``cli.config_mode`` (the ``--config set`` verb) and ``cli.config_tui`` (the menu), so
+both surfaces resolve and coerce identically. Resolves a dotted key against ``SyncadeConfig``'s
+pydantic schema to the leaf field's declared type, and coerces a raw CLI string to that type.
+
+A path that does not resolve to a settable SCALAR leaf (an unknown field, or a whole
+section/roster) is an :class:`UnknownKey`; a value that does not fit the leaf's type is an
+:class:`InvalidValue`.
+"""
+
+from __future__ import annotations
+
+from types import UnionType
+from typing import Literal, Union, get_args, get_origin
+
+from pydantic import BaseModel
+
+from syncade.config import SyncadeConfig
+
+_TRUE = {"true", "1", "yes", "on"}
+_FALSE = {"false", "0", "no", "off"}
+
+
+class UnknownKey(Exception):
+    """A dotted key that does not resolve to a settable scalar field."""
+
+
+class InvalidValue(Exception):
+    """A raw string that cannot be coerced to the field's declared type."""
+
+
+def coerce(annotation, raw: str):
+    """Coerce ``raw`` (a CLI string) to ``annotation``'s Python type.
+
+    Raises :class:`InvalidValue` when the string does not fit. An optional field (``X | None``)
+    clears to ``None`` on empty input; ``str``/``Path`` and other scalars keep the raw string
+    (pydantic coerces on load, and TOML has no ``Path`` type).
+    """
+    origin = get_origin(annotation)
+    args = get_args(annotation)
+
+    # Optional (X | None): empty input clears; otherwise coerce the non-None arm.
+    if origin in (Union, UnionType) and type(None) in args:
+        if raw == "":
+            return None
+        (inner,) = [a for a in args if a is not type(None)]
+        return coerce(inner, raw)
+
+    if origin is Literal:
+        if raw not in args:
+            raise InvalidValue(f"{raw!r} is not one of {list(args)}")
+        return raw
+
+    if origin is list:
+        return [s.strip() for s in raw.split(",") if s.strip()]
+
+    if annotation is bool:
+        low = raw.strip().lower()
+        if low in _TRUE:
+            return True
+        if low in _FALSE:
+            return False
+        raise InvalidValue(f"{raw!r} is not a boolean (use true/false)")
+
+    if annotation is int:
+        try:
+            return int(raw)
+        except ValueError:
+            raise InvalidValue(f"{raw!r} is not an integer") from None
+
+    if annotation is float:
+        try:
+            return float(raw)
+        except ValueError:
+            raise InvalidValue(f"{raw!r} is not a number") from None
+
+    return raw
+
+
+def resolve_annotation(key: str):
+    """Walk ``SyncadeConfig``'s schema along the dotted ``key`` to the leaf field's declared
+    annotation.
+
+    Raises :class:`UnknownKey` for an unknown field, a non-index where a list index is expected,
+    or a leaf that is a whole section/roster (a pydantic model, or a list of them) rather than a
+    settable scalar.
+    """
+    current = SyncadeConfig
+    for part in key.split("."):
+        if get_origin(current) is list:  # walking into a list element
+            elem = (get_args(current) or (str,))[0]
+            if not _is_model(elem):  # a list-of-values (list[str]) is set WHOLE (csv), not indexed
+                raise UnknownKey(f"{key!r}: {part!r} indexes a list set as a whole, not by element")
+            if not part.isdigit():
+                raise UnknownKey(f"{key!r}: {part!r} is not a list index")
+            current = elem
+            continue
+        fields = getattr(current, "model_fields", None)
+        if fields is None or part not in fields:
+            raise UnknownKey(f"{key!r}: unknown field {part!r}")
+        current = fields[part].annotation
+    if not _settable_scalar(current):
+        raise UnknownKey(f"{key!r} is a section or roster, not a settable field")
+    return current
+
+
+def _settable_scalar(annotation) -> bool:
+    """A leaf is settable iff it is not a pydantic model and not a list of models (``list[str]``
+    is fine; ``list[ReviewerConfig]`` is not — you set elements by index, not the whole roster)."""
+    origin = get_origin(annotation)
+    if origin is dict:  # a dict-shaped roster (e.g. pricing.models) is not a settable scalar
+        return False
+    if origin is list:
+        elem = (get_args(annotation) or (str,))[0]
+        return not _is_model(elem)
+    if origin in (Union, UnionType):
+        return all(_settable_scalar(a) for a in get_args(annotation) if a is not type(None))
+    return not _is_model(annotation)
+
+
+def _is_model(annotation) -> bool:
+    return isinstance(annotation, type) and issubclass(annotation, BaseModel)
+
+
+def _empty_clears(annotation) -> bool:
+    """True for Optional (X | None) and list fields — empty input clears instead of no-op."""
+    origin = get_origin(annotation)
+    return origin is list or (origin in (Union, UnionType) and type(None) in get_args(annotation))
+
+
+# Keys whose opt-out sentinel is explicit 0, not omission. Clearing these to None would strip the
+# TOML key, causing the default (budget_tokens=50M) or resume inheritance (budget_usd) to
+# silently re-activate. Empty input must be rejected with a "set 0 to disable" message.
+BUDGET_KEYS: frozenset[str] = frozenset({"loop.budget_tokens", "loop.budget_usd"})

syncade/cli/config_list.py

@@ -0,0 +1,82 @@
+"""Enumerate the FULL settable config surface for ``syncade --config list --all`` (pr-v2-32).
+
+A leaf module. It walks the ``SyncadeConfig`` schema with the SAME settability rule as
+``--config set`` (``config_keys._settable_scalar``), so the ``--all`` surface can never drift from
+what ``set`` accepts. It decides only WHAT fields exist and how they group; ``config_mode`` renders
+each row's value, layer, and ``overrides`` note.
+"""
+
+from __future__ import annotations
+
+from typing import get_args, get_origin
+
+from syncade.cli import config_keys
+from syncade.config import SyncadeConfig
+from syncade.config_loader import _PAIRED_SECTIONS
+
+# Sections whose TOML table replaces WHOLESALE (layer is section-granular → subkey=None); others
+# merge key-by-key (layer is per-field). Mirrors config_loader / config_menu_rows.
+_WHOLESALE = _PAIRED_SECTIONS | {"reviewers", "checks"}
+
+# Display order + section headers. Sections not listed here are appended after, under a `[<name>]`
+# fallback header — a completeness test asserts every settable field is emitted, so none vanish.
+_HEADERS = {
+    "producer": "[producer]",
+    "reviewers": "[[reviewers]]",
+    "synthesizer": "[synthesizer]  (judge)",
+    "loop": "[loop]",
+    "review": "[review]",
+    "retry": "[advanced.retry]",
+    "gc": "[advanced.gc]",
+    "checks": "[advanced.checks]",
+    "drafter": "[advanced.drafter]",
+    "auditor": "[advanced.auditor]",
+    "worktree_base": "[advanced]",
+}
+
+
+def header_for(section: str) -> str:
+    return _HEADERS.get(section, f"[{section}]")
+
+
+def _subkey(section: str, parts: list[str]) -> str | None:
+    """Layer granularity for ``_layer_of``: per-field for a key-merge section (a model section not
+    replaced wholesale, e.g. loop/review/retry/gc); section-granular (None) for wholesale sections
+    and top-level scalars."""
+    if len(parts) == 1 or section in _WHOLESALE:
+        return None
+    return parts[-1]
+
+
+def _walk(value, annotation, prefix: str):
+    """Yield the dotted key of every settable scalar under ``value`` (a config instance/section)."""
+    if config_keys._settable_scalar(annotation):
+        yield prefix
+        return
+    if get_origin(annotation) is list:
+        elems = [a for a in get_args(annotation) if a is not type(None)]
+        if elems and config_keys._is_model(elems[0]):
+            for i, item in enumerate(value):
+                yield from _walk(item, elems[0], f"{prefix}.{i}")
+        return
+    if config_keys._is_model(annotation):
+        for name, field in annotation.model_fields.items():
+            yield from _walk(getattr(value, name), field.annotation, f"{prefix}.{name}")
+
+
+def all_rows(config) -> list[tuple[str, str, str, str | None]]:
+    """``(key, label, section, subkey)`` for every settable scalar field, in display order.
+
+    ``label`` is the key minus its section prefix (unambiguous per section); ``config`` is the
+    effective config, whose roster sizes drive the reviewer/check indices."""
+    fields = SyncadeConfig.model_fields
+    sections = list(_HEADERS) + [s for s in fields if s not in _HEADERS]
+    rows = []
+    for section in sections:
+        if section not in fields:
+            continue
+        for key in _walk(getattr(config, section), fields[section].annotation, section):
+            parts = key.split(".")
+            label = key[len(section) + 1 :] if "." in key else key
+            rows.append((key, label, section, _subkey(section, parts)))
+    return rows

syncade/cli/config_menu_rows.py

@@ -0,0 +1,166 @@
+"""Screen/row model for the drill-in config menu (pr-v2-31 inc 4).
+
+The menu is a tree of screens: the top screen, one per actor (``producer`` / ``reviewers.N`` /
+``synthesizer``), an ``advanced`` screen, and one per advanced section (``retry`` / ``gc`` /
+``review`` / ``checks`` and each ``checks.N``). Each screen is a list of :class:`Row`; a row is an
+``edit`` (a settable scalar field), a ``drill`` (navigate to a child screen), or an ``info`` (an
+inert placeholder, e.g. an empty ``checks`` screen). Pure — no curses; ``ConfigMenu`` drives it.
+"""
+
+from __future__ import annotations
+
+from dataclasses import dataclass
+from typing import get_args, get_origin
+
+from syncade.cli import config_keys
+from syncade.config import SyncadeConfig
+from syncade.config_loader import _PAIRED_SECTIONS
+
+# Sections whose TOML table replaces WHOLESALE (shadow is section-granular → subkey=None); every
+# other section merges key-by-key (shadow is per-key → subkey=field). Mirrors the loader's rule.
+_WHOLESALE = _PAIRED_SECTIONS | {"reviewers", "checks"}
+_ACTOR_SECTIONS = _PAIRED_SECTIONS | {"reviewers"}
+
+# Actor fields shown in a drill screen, in display order — filtered to the fields the actor actually
+# has. ``provider`` is folded into the Model row (edited as ``provider/model``); ``api_key_env`` is
+# CLI-only, kept out of the menu to stay scannable.
+_ACTOR_FIELD_ORDER = [
+    "model",
+    "thinking",
+    "permissions",
+    "auth",
+    "timeout_seconds",
+    "name",
+    "adversarial_lens",
+    "bug_class_sweep",
+    "template",
+]
+_SKIP_FIELDS = {"provider", "api_key_env"}
+
+_LABELS = {
+    "model": "Model",
+    "thinking": "Thinking",
+    "permissions": "Permissions",
+    "auth": "Auth",
+    "timeout_seconds": "Timeout (s)",
+    "name": "Name",
+    "adversarial_lens": "Adversarial lens",
+    "bug_class_sweep": "Bug-class sweep",
+    "template": "Template",
+    "max_retries": "Max retries",
+    "keep": "Keep (runs)",
+    "max_age_days": "Max age (days)",
+    "strip_repo_context_files": "Strip repo-context files",
+    "command": "Command",
+    "severity": "Severity",
+    "test_command": "Test command",
+    "test_timeout_seconds": "Test timeout (s)",
+    "budget_tokens": "Budget (tokens)",
+}
+
+
+@dataclass(frozen=True)
+class Row:
+    """One menu row. ``kind``: ``edit`` (``key`` is a dotted field path), ``drill`` (``key`` is the
+    child screen id), or ``info`` (inert). ``value_key`` is the dotted key whose value to display
+    (``None`` → no value column); ``section``/``subkey`` drive the shadow flag for edit rows."""
+
+    label: str
+    kind: str
+    key: str
+    section: str | None = None
+    subkey: str | None = None
+    value_key: str | None = None
+
+
+def _label(field: str) -> str:
+    return _LABELS.get(field, field.replace("_", " ").capitalize())
+
+
+def _model_at(screen: str):
+    """The pydantic model class shown by ``screen`` (walks list indices to the element type)."""
+    current = SyncadeConfig
+    for part in screen.split("."):
+        if get_origin(current) is list:
+            current = get_args(current)[0]  # element type; `part` is the index
+            continue
+        current = current.model_fields[part].annotation
+    return current
+
+
+def _settable(model) -> list[str]:
+    return [n for n, f in model.model_fields.items() if config_keys._settable_scalar(f.annotation)]
+
+
+def _field_rows(config, screen: str) -> list[Row]:
+    """Edit rows for every settable scalar field of the model at ``screen`` (actor or section)."""
+    section = screen.split(".")[0]
+    fields = [f for f in _settable(_model_at(screen)) if f not in _SKIP_FIELDS]
+    if section in _ACTOR_SECTIONS:
+        fields = [f for f in _ACTOR_FIELD_ORDER if f in fields]
+    subkey_none = section in _WHOLESALE
+    return [
+        Row(
+            _label(f), "edit", f"{screen}.{f}", section, None if subkey_none else f, f"{screen}.{f}"
+        )
+        for f in fields
+    ]
+
+
+def _top_rows(config) -> list[Row]:
+    rows = [Row("Producer", "drill", "producer", "producer", None, "producer.model")]
+    for i in range(len(config.reviewers)):
+        rows.append(
+            Row(
+                f"Reviewer {i + 1}",
+                "drill",
+                f"reviewers.{i}",
+                "reviewers",
+                None,
+                f"reviewers.{i}.model",
+            )
+        )
+    rows += [
+        Row("Judge", "drill", "synthesizer", "synthesizer", None, "synthesizer.model"),
+        Row("Rounds (max)", "edit", "loop.max_rounds", "loop", "max_rounds", "loop.max_rounds"),
+        Row(
+            "Time per subprocess (s)",
+            "edit",
+            "loop.timeout_seconds",
+            "loop",
+            "timeout_seconds",
+            "loop.timeout_seconds",
+        ),
+        Row("Cost cap (USD)", "edit", "loop.budget_usd", "loop", "budget_usd", "loop.budget_usd"),
+        Row("Advanced…", "drill", "advanced"),
+    ]
+    return rows
+
+
+def _advanced_rows(config) -> list[Row]:
+    return [
+        Row("Retry", "drill", "retry"),
+        Row("GC", "drill", "gc"),
+        Row("Review", "drill", "review"),
+        Row("Checks", "drill", "checks"),
+    ]
+
+
+def _checks_rows(config) -> list[Row]:
+    if not config.checks:
+        return [Row("(no checks configured — add via config.toml)", "info", "")]
+    return [
+        Row(f"Check {i + 1}: {c.name}", "drill", f"checks.{i}", "checks", None, f"checks.{i}.name")
+        for i, c in enumerate(config.checks)
+    ]
+
+
+def screen_rows(config, screen: str) -> list[Row]:
+    """The rows for ``screen`` (``""`` = top). ``config`` is the effective (merged) config."""
+    if screen == "":
+        return _top_rows(config)
+    if screen == "advanced":
+        return _advanced_rows(config)
+    if screen == "checks":
+        return _checks_rows(config)
+    return _field_rows(config, screen)