geny-executor 2.3.0__tar.gz → 2.4.0__tar.gz

{geny_executor-2.3.0 → geny_executor-2.4.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: geny-executor
-Version: 2.3.0
+Version: 2.4.0
 Summary: Harness-engineered agent pipeline library with 21-stage dual-abstraction architecture, built on the Anthropic API
 Project-URL: Homepage, https://github.com/CocoRoF/geny-executor
 Project-URL: Repository, https://github.com/CocoRoF/geny-executor

{geny_executor-2.3.0 → geny_executor-2.4.0}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "hatchling.build"
 
 [project]
 name = "geny-executor"
-version = "2.3.0"
+version = "2.4.0"
 description = "Harness-engineered agent pipeline library with 21-stage dual-abstraction architecture, built on the Anthropic API"
 readme = "README.md"
 license = "MIT"

{geny_executor-2.3.0 → geny_executor-2.4.0}/src/geny_executor/__init__.py

@@ -64,7 +64,14 @@ from geny_executor.core.environment import (
     ToolsSnapshot,
     validate_manifest,
 )
-from geny_executor.core.manifest_factory import build_manifest, known_manifest_presets
+from geny_executor.core.manifest_factory import (
+    PresetDescriptor,
+    build_manifest,
+    build_manifest_for,
+    get_preset_descriptor,
+    known_manifest_presets,
+    preset_catalog,
+)
 from geny_executor.core.artifact import (
     ArtifactInfo,
     create_stage,
@@ -153,7 +160,11 @@ __all__ = [
     "ToolsSnapshot",
     "validate_manifest",
     "build_manifest",
+    "build_manifest_for",
     "known_manifest_presets",
+    "preset_catalog",
+    "get_preset_descriptor",
+    "PresetDescriptor",
     "DiffEntry",
     "EnvironmentDiff",
     # Artifact system

{geny_executor-2.3.0 → geny_executor-2.4.0}/src/geny_executor/core/manifest_factory.py

@@ -54,8 +54,9 @@ intent the host helpers read.
 
 from __future__ import annotations
 
+from dataclasses import dataclass
 from datetime import datetime, timezone
-from typing import Any, Dict, List, Optional
+from typing import Any, Dict, List, Optional, Tuple
 from uuid import uuid4
 
 from geny_executor.core.environment import (
@@ -680,3 +681,131 @@ def build_manifest(
         stages=[e.to_dict() for e in entries],
         tools=tools,
     )
+
+
+# ── Preset catalog (host-facing, generalised) ────────────────────────
+#
+# The manifest presets above are stage blueprints; the *catalog* layers
+# host-facing selection metadata on top so any consumer (Geny or other)
+# can list selectable presets — display name, description, recommended
+# Stage-6 provider, tags — without re-deriving them. A host shows
+# :func:`preset_catalog`, lets the user pick a key, and materialises it
+# via :func:`build_manifest_for`. Geny then builds its *own* custom
+# presets on top of these (its tool-bearing templates reference a
+# ``base_preset`` / catalog key here).
+
+
+@dataclass(frozen=True)
+class PresetDescriptor:
+    """One selectable entry in the built-in preset catalog.
+
+    ``base_preset`` is the canonical 21-stage blueprint (a member of
+    :data:`MANIFEST_PRESETS`). ``provider`` is the recommended/locked
+    Stage-6 backend (``None`` → the host chooses at build time). ``key``
+    is the stable catalog id a host stores; it may differ from
+    ``base_preset`` (e.g. ``claude_code_worker`` → base ``worker_adaptive``
+    + provider ``claude_code_cli``).
+    """
+
+    key: str
+    name: str
+    description: str
+    base_preset: str
+    provider: Optional[str] = None
+    tags: Tuple[str, ...] = ()
+
+    def to_dict(self) -> Dict[str, Any]:
+        return {
+            "key": self.key,
+            "name": self.name,
+            "description": self.description,
+            "base_preset": self.base_preset,
+            "provider": self.provider,
+            "tags": list(self.tags),
+        }
+
+
+_PRESET_CATALOG: List[PresetDescriptor] = [
+    PresetDescriptor(
+        key=_WORKER_ADAPTIVE,
+        name="Worker (Adaptive)",
+        description="Autonomous tool-using worker — the full 21-stage agentic loop with an adaptive turn budget.",
+        base_preset=_WORKER_ADAPTIVE,
+        provider=None,
+        tags=("worker", "agent"),
+    ),
+    PresetDescriptor(
+        key=_VTUBER,
+        name="VTuber",
+        description="Conversational persona — a lighter loop with a narrowed tool roster, tuned for TTS replies.",
+        base_preset=_VTUBER,
+        provider=None,
+        tags=("vtuber", "chat"),
+    ),
+    PresetDescriptor(
+        key="claude_code_worker",
+        name="Claude Code · Worker",
+        description="Worker agentic loop backed by the Claude Code CLI provider (subscription auth, native CLI tool loop).",
+        base_preset=_WORKER_ADAPTIVE,
+        provider="claude_code_cli",
+        tags=("worker", "agent", "claude_code"),
+    ),
+    PresetDescriptor(
+        key="claude_code_vtuber",
+        name="Claude Code · VTuber",
+        description="Conversational VTuber persona backed by the Claude Code CLI provider.",
+        base_preset=_VTUBER,
+        provider="claude_code_cli",
+        tags=("vtuber", "chat", "claude_code"),
+    ),
+]
+
+
+def preset_catalog() -> List[PresetDescriptor]:
+    """The built-in, host-facing preset catalog (a fresh list copy)."""
+    return list(_PRESET_CATALOG)
+
+
+def get_preset_descriptor(key: str) -> Optional[PresetDescriptor]:
+    """Look up a catalog entry by its ``key`` (``None`` if absent)."""
+    for d in _PRESET_CATALOG:
+        if d.key == key:
+            return d
+    return None
+
+
+def build_manifest_for(
+    key: str,
+    *,
+    provider: Optional[str] = None,
+    **kwargs: Any,
+) -> EnvironmentManifest:
+    """Materialise an :class:`EnvironmentManifest` from a *catalog* key.
+
+    Resolves the descriptor and calls :func:`build_manifest` with its
+    ``base_preset`` + provider. The ``provider`` argument overrides the
+    descriptor's recommended provider; if neither is set a ``ValueError``
+    is raised (the caller must choose a backend). A bare
+    :data:`MANIFEST_PRESETS` name is also accepted (then ``provider`` is
+    required), so this is a strict superset of :func:`build_manifest`.
+    Display ``name`` / ``description`` default to the descriptor's.
+    Extra kwargs (``model`` / ``built_in_tools`` / ``external_tools`` /
+    ``mcp_servers``) pass through to :func:`build_manifest`.
+    """
+    desc = get_preset_descriptor(key)
+    if desc is None:
+        if key in MANIFEST_PRESETS:
+            if not provider:
+                raise ValueError(f"preset {key!r} requires an explicit provider=")
+            return build_manifest(key, provider=provider, **kwargs)
+        raise ValueError(
+            f"unknown preset key {key!r}. Catalog: {[d.key for d in _PRESET_CATALOG]}"
+        )
+    eff_provider = provider or desc.provider
+    if not eff_provider:
+        raise ValueError(
+            f"preset {key!r} has no recommended provider; pass provider= explicitly."
+        )
+    kwargs.setdefault("name", desc.name)
+    kwargs.setdefault("description", desc.description)
+    return build_manifest(desc.base_preset, provider=eff_provider, **kwargs)

{geny_executor-2.3.0 → geny_executor-2.4.0}/tests/unit/test_manifest_factory.py

@@ -201,3 +201,66 @@ class TestGenyLayoutCompatibility:
     def test_full_21_slot_layout(self, snapshot, preset):
         ours = build_manifest(preset, provider="anthropic").to_dict()["stages"]
         assert [e["order"] for e in ours] == list(range(1, 22))
+
+
+# ── 2.4.0 — host-facing preset catalog ───────────────────────────────
+
+
+class TestPresetCatalog:
+    def test_catalog_keys(self):
+        from geny_executor import preset_catalog
+        keys = [d.key for d in preset_catalog()]
+        assert keys == ["worker_adaptive", "vtuber", "claude_code_worker", "claude_code_vtuber"]
+
+    def test_catalog_entries_have_display_metadata(self):
+        from geny_executor import preset_catalog
+        for d in preset_catalog():
+            assert d.name and d.description
+            assert d.base_preset in ("worker_adaptive", "vtuber")
+            assert isinstance(d.tags, tuple)
+
+    def test_get_preset_descriptor(self):
+        from geny_executor import get_preset_descriptor
+        d = get_preset_descriptor("claude_code_worker")
+        assert d is not None
+        assert d.base_preset == "worker_adaptive"
+        assert d.provider == "claude_code_cli"
+        assert get_preset_descriptor("nope") is None
+
+    def test_descriptor_to_dict(self):
+        from geny_executor import get_preset_descriptor
+        d = get_preset_descriptor("vtuber").to_dict()
+        assert d["key"] == "vtuber" and d["provider"] is None and isinstance(d["tags"], list)
+
+    def test_build_manifest_for_claude_code_worker(self):
+        from geny_executor import build_manifest_for
+        m = build_manifest_for("claude_code_worker")
+        assert m.stages[5]["config"]["provider"] == "claude_code_cli"
+        assert m.metadata.base_preset == "worker_adaptive"
+        assert [e["order"] for e in m.to_dict()["stages"]] == list(range(1, 22))
+
+    def test_build_manifest_for_provider_override(self):
+        from geny_executor import build_manifest_for
+        m = build_manifest_for("worker_adaptive", provider="anthropic")
+        assert m.stages[5]["config"]["provider"] == "anthropic"
+
+    def test_build_manifest_for_requires_provider_when_none(self):
+        from geny_executor import build_manifest_for
+        with pytest.raises(ValueError):
+            build_manifest_for("worker_adaptive")  # catalog provider is None → must pass one
+
+    def test_build_manifest_for_accepts_bare_preset_name(self):
+        from geny_executor import build_manifest_for
+        m = build_manifest_for("vtuber", provider="anthropic")
+        assert m.metadata.base_preset == "vtuber"
+
+    def test_build_manifest_for_unknown_key_raises(self):
+        from geny_executor import build_manifest_for
+        with pytest.raises(ValueError):
+            build_manifest_for("does-not-exist", provider="anthropic")
+
+    def test_claude_code_manifest_builds_strict(self):
+        from geny_executor import Pipeline, build_manifest_for
+        m = build_manifest_for("claude_code_worker")
+        # Round-trips and builds strict like any other manifest.
+        Pipeline.from_manifest(EnvironmentManifest.from_dict(m.to_dict()), strict=True)

geny_executor-2.3.0/docs/ci/README.md

@@ -1,18 +0,0 @@
-# Pending CI workflow updates (2.2.0)
-
-`2.2.0-workflow-updates.patch` carries the wave-3 CI changes that could not be
-pushed from the automation environment: the GitHub OAuth token used by the
-release tooling has `repo` scope but not `workflow` scope, and GitHub rejects
-any push that modifies `.github/workflows/*` without it.
-
-Contents of the patch:
-- `ci.yml`: ruff now genuinely lints `tests/` (the old config silently
-  force-excluded it), a mypy job over `core` + `llm_client`, and an
-  events-docs `--check` step (`scripts/gen_event_docs.py`).
-- `publish.yml`: a release gate asserting the pyproject version has a
-  matching `## [<version>]` CHANGELOG header before publishing.
-
-Apply from a checkout with workflow-scoped credentials:
-
-    git apply docs/ci/2.2.0-workflow-updates.patch
-    git add .github && git commit -m "ci: apply 2.2.0 workflow updates"