whiletrue 0.1.0__py3-none-any.whl

whiletrue/github/plugin.py

@@ -0,0 +1,343 @@
+from __future__ import annotations
+
+from typing import Any, cast
+
+from pydantic import BaseModel, Field
+
+from whiletrue.basics.process import run_command, tail
+from whiletrue.core import (
+    ActionModule,
+    CommentRecord,
+    CommentsContext,
+    Emit,
+    IncomingComment,
+    Ports,
+    PortSpec,
+    RunItem,
+    SimplePlugin,
+    StepContext,
+    WakeContext,
+    WakeResult,
+    define_action,
+)
+from whiletrue.core.module import PortValues
+from whiletrue.github.client import (
+    GhCliClient,
+    GhComment,
+    GitHubClient,
+    GitHubError,
+    repo_from_remote,
+)
+from whiletrue.github.specs import parse_spec_refs
+
+
+async def _detect_repo(cwd: str) -> str:
+    result = await run_command("git", ["remote", "get-url", "origin"], cwd=cwd)
+    repo = repo_from_remote(result.stdout) if result.code == 0 else None
+    if repo is None:
+        raise GitHubError("Cannot tell which repository this is: set `repo: owner/name`")
+    return repo
+
+
+async def _repo(configured: str | None, cwd: str) -> str:
+    return configured or await _detect_repo(cwd)
+
+
+def _pr_ref(input: Any, item: dict[str, Any] | None) -> tuple[str | None, int | None]:
+    """The (repo, PR number) a step or a wake condition is about: the PR the previous step made."""
+    source = cast(dict[str, Any], input) if isinstance(input, dict) else {}
+    number = source.get("number") or (item or {}).get("pr")
+    repo = source.get("repo") or (item or {}).get("repo")
+    return (str(repo) if repo else None), (int(number) if number else None)
+
+
+def _encode_thread(repo: str, number: int, comment: GhComment) -> str:
+    return f"{repo}#{number}:{comment.id}:{comment.thread_root or ''}"
+
+
+def _decode_thread(thread: str | None) -> tuple[str, int, GhComment] | None:
+    if not thread or "#" not in thread:
+        return None
+    head, _, rest = thread.partition("#")
+    number, _, tail_ = rest.partition(":")
+    comment_id, _, root = tail_.rpartition(":")
+    kind = "inline" if comment_id.startswith("inline:") else "issue"
+    comment = GhComment(comment_id, kind, "", "", 0, thread_root=root or None)  # type: ignore[arg-type]
+    return head, int(number), comment
+
+
+class GithubIssuesSource:
+    def __init__(self, client: GitHubClient) -> None:
+        self._client = client
+
+    async def fetch(self, config: dict[str, Any], cwd: str) -> list[RunItem]:
+        repo = await _repo(config.get("repo"), cwd)
+        issues = await self._client.list_issues(
+            repo,
+            milestone=config.get("milestone"),
+            state=str(config.get("state", "open")),
+            labels=list(config.get("labels") or []),
+        )
+        numbers = {i.number for i in issues}
+        use_blocked_by = config.get("depends_on", "blocked_by") == "blocked_by"
+        return [
+            RunItem(
+                str(i.number),
+                {
+                    "number": i.number,
+                    "title": i.title,
+                    "body": i.body,
+                    "labels": i.labels,
+                    "url": i.url,
+                    "repo": repo,
+                    "spec_refs": parse_spec_refs(i.body),
+                },
+                [str(b) for b in i.blocked_by if b in numbers] if use_blocked_by else [],
+            )
+            for i in issues
+        ]
+
+
+class GithubPrComments:
+    """Review threads and conversation comments on the PR the item opened."""
+
+    def __init__(self, client: GitHubClient) -> None:
+        self._client = client
+
+    async def fetch(self, ctx: CommentsContext) -> list[IncomingComment]:
+        repo, number = _pr_ref(ctx.input, ctx.item)
+        if number is None:
+            return []
+        repo = await _repo(repo, ctx.cwd)
+        found = await self._client.list_comments(repo, number)
+        return [
+            IncomingComment(
+                external_id=c.id,
+                author=c.author,
+                body=c.body,
+                created_at=c.created_at,
+                thread=_encode_thread(repo, number, c),
+                url=c.url,
+                kind="reviewer" if c.author.endswith("[bot]") else "human",
+            )
+            for c in found
+            if not c.body.lstrip().startswith("[whiletrue]")
+        ]
+
+    async def reply(self, comment: CommentRecord, body: str, ctx: CommentsContext) -> str | None:
+        decoded = _decode_thread(comment.thread)
+        if decoded is None:
+            return None
+        repo, number, target = decoded
+        return await self._client.reply(repo, number, target, body)
+
+
+class GithubReviewWake:
+    """`github.pr_review`: `approved`, `changes_requested`, or omitted for either."""
+
+    def __init__(self, client: GitHubClient) -> None:
+        self._client = client
+
+    async def check(self, arg: Any, ctx: WakeContext) -> WakeResult | None:
+        repo, number = _pr_ref(ctx.input, ctx.item)
+        if number is None:
+            return None
+        pr = await self._client.get_pr(await _repo(repo, ctx.cwd), number)
+        wanted = {
+            None: {"approved", "changes_requested"},
+            "any": {"approved", "changes_requested"},
+        }.get(arg, {str(arg)})
+        if pr.review == "approved" and "approved" in wanted:
+            return WakeResult("approved", "approved on GitHub", by="github")
+        if pr.review == "changes_requested" and "changes_requested" in wanted:
+            note = "\n\n".join(pr.review_notes) or "changes requested on GitHub"
+            return WakeResult("rejected", note, by="github")
+        return None
+
+
+class GithubMergedWake:
+    """`github.pr_merged`: someone merged the PR outside whiletrue."""
+
+    def __init__(self, client: GitHubClient) -> None:
+        self._client = client
+
+    async def check(self, arg: Any, ctx: WakeContext) -> WakeResult | None:
+        repo, number = _pr_ref(ctx.input, ctx.item)
+        if number is None:
+            return None
+        pr = await self._client.get_pr(await _repo(repo, ctx.cwd), number)
+        return (
+            WakeResult("approved", "merged on GitHub", by="github")
+            if pr.state == "merged"
+            else None
+        )
+
+
+class OpenPrConfig(BaseModel):
+    repo: str | None = None
+    #: The branch to open the PR from (templates apply, e.g. `wt/{{item.number}}`).
+    head: str = Field(min_length=1)
+    base: str = "main"
+    title: str | None = None
+    body: str = ""
+    #: Issue number the PR closes; appended to the body as `Closes #N`.
+    closes: int | str | None = None
+    #: Push `head` to origin first.
+    push: bool = True
+
+
+class SyncBaseConfig(BaseModel):
+    base: str = "main"
+    strategy: str = Field(default="rebase", pattern="^rebase$")
+    push: bool = True
+
+
+class MergeConfig(BaseModel):
+    repo: str | None = None
+    number: int | None = None
+    method: str = Field(default="squash", pattern="^(squash|merge|rebase)$")
+    #: Hold this named lock while merging, so only one item merges at a time.
+    lock: str | None = None
+
+
+def _pr_value(pr: Any, repo: str) -> dict[str, Any]:
+    return {
+        "number": pr.number,
+        "url": pr.url,
+        "branch": pr.branch,
+        "base": pr.base,
+        "title": pr.title,
+        "repo": repo,
+    }
+
+
+def github_plugin(client: GitHubClient | None = None) -> SimplePlugin:
+    """Registers the GitHub source, modules, comments provider and wake conditions."""
+    gh: GitHubClient = client if client is not None else GhCliClient()
+
+    async def open_pr(input: PortValues, ctx: StepContext[OpenPrConfig]) -> Emit:
+        cfg = ctx.config
+        try:
+            repo = await _repo(cfg.repo, ctx.cwd)
+            if cfg.push:
+                pushed = await run_command(
+                    "git", ["push", "-u", "origin", cfg.head], cwd=ctx.cwd, signal=ctx.signal
+                )
+                if pushed.code != 0:
+                    return Emit("fail", {"error": f"git push failed: {tail(pushed.stderr)}"})
+            existing = await gh.find_pr(repo, cfg.head)
+            if existing is not None:
+                return Emit("ok", _pr_value(existing, repo))
+            item: dict[str, Any] = ctx.scope.get("item") or {}
+            title = cfg.title or str(item.get("title") or cfg.head)
+            body = cfg.body + (f"\n\nCloses #{cfg.closes}" if cfg.closes else "")
+            pr = await gh.create_pr(repo, head=cfg.head, base=cfg.base, title=title, body=body)
+            return Emit("ok", _pr_value(pr, repo))
+        except GitHubError as error:
+            return Emit("fail", {"error": str(error)})
+
+    async def sync_base(input: PortValues, ctx: StepContext[SyncBaseConfig]) -> Emit:
+        cfg = ctx.config
+
+        async def git(*args: str) -> Any:
+            return await run_command("git", list(args), cwd=ctx.cwd, signal=ctx.signal)
+
+        before = (await git("rev-parse", "HEAD")).stdout.strip()
+        fetched = await git("fetch", "origin", cfg.base)
+        if fetched.code != 0:
+            return Emit("fail", {"error": f"git fetch failed: {tail(fetched.stderr)}"})
+        rebased = await git("rebase", f"origin/{cfg.base}")
+        if rebased.code != 0:
+            conflicts = (await git("diff", "--name-only", "--diff-filter=U")).stdout.split()
+            await git("rebase", "--abort")
+            return Emit(
+                "needs_human",
+                {"reason": f"rebase onto {cfg.base} has conflicts", "files": conflicts},
+            )
+        after = (await git("rev-parse", "HEAD")).stdout.strip()
+        if cfg.push and after != before:
+            pushed = await git("push", "--force-with-lease", "origin", "HEAD")
+            if pushed.code != 0:
+                return Emit("fail", {"error": f"git push failed: {tail(pushed.stderr)}"})
+        return Emit("ok", input.get("in"))
+
+    async def merge(input: PortValues, ctx: StepContext[MergeConfig]) -> Emit:
+        cfg = ctx.config
+        in_repo, in_number = _pr_ref(input.get("in"), ctx.scope.get("item"))
+        number = cfg.number or in_number
+        if number is None:
+            return Emit("fail", {"error": "github.merge needs a PR number (config or input)"})
+        try:
+            repo = await _repo(cfg.repo or in_repo, ctx.cwd)
+
+            async def do() -> Emit:
+                pr = await gh.get_pr(repo, number)
+                if pr.state == "closed":
+                    return Emit("fail", {"error": f"PR #{number} is closed"})
+                if pr.state != "merged":
+                    await gh.merge_pr(repo, number, cfg.method)
+                    pr = await gh.get_pr(repo, number)
+                return Emit("ok", {**_pr_value(pr, repo), "state": pr.state})
+
+            if cfg.lock:
+                async with ctx.locks.hold(cfg.lock):
+                    return await do()
+            return await do()
+        except GitHubError as error:
+            return Emit("fail", {"error": str(error)})
+
+    pr_ports = Ports(inputs=[PortSpec("in", "Any")], outputs=[PortSpec("out", "PullRequest")])
+
+    def register(api: Any) -> None:
+        api.register_provider("source", "github_issues", GithubIssuesSource(gh))
+        api.register_provider("comments", "github_pr", GithubPrComments(gh))
+        api.register_provider("wake", "github.pr_review", GithubReviewWake(gh))
+        api.register_provider("wake", "github.pr_merged", GithubMergedWake(gh))
+        api.register_action(
+            define_action(
+                ActionModule(
+                    id="github.open_pr",
+                    config=OpenPrConfig,
+                    ports=pr_ports,
+                    effects="side-effect",
+                    cacheable=False,
+                    journal=True,
+                    idempotency_key=lambda _i, ctx: (
+                        f"github.open_pr:{ctx.config.repo or 'origin'}:{ctx.config.head}"
+                    ),
+                    run=open_pr,
+                )
+            )
+        )
+        api.register_action(
+            define_action(
+                ActionModule(
+                    id="github.sync_base",
+                    config=SyncBaseConfig,
+                    ports=Ports(inputs=[PortSpec("in", "Any")], outputs=[PortSpec("out", "Any")]),
+                    effects="side-effect",
+                    cacheable=False,
+                    idempotency_key=lambda _i, ctx: f"github.sync_base:{ctx.step_key}",
+                    run=sync_base,
+                )
+            )
+        )
+        api.register_action(
+            define_action(
+                ActionModule(
+                    id="github.merge",
+                    config=MergeConfig,
+                    ports=pr_ports,
+                    effects="side-effect",
+                    cacheable=False,
+                    journal=True,
+                    idempotency_key=lambda i, ctx: (
+                        f"github.merge:{ctx.config.repo or 'origin'}:"
+                        f"{ctx.config.number or _pr_ref(i.get('in'), None)[1]}"
+                    ),
+                    run=merge,
+                )
+            )
+        )
+
+    return SimplePlugin(name="whiletrue.github", register=register)

whiletrue/github/specs.py

@@ -0,0 +1,39 @@
+"""Spec links in issue bodies (OQ-5).
+
+An issue points at the spec text an agent should read with a line of the form
+
+    spec: specs/m3/api.md#L40-L88
+
+(also `specs:`, case-insensitive; several links separated by commas or spaces). A bare path means
+the whole file; `#L40` is one line and `#L40-L88` a range. Links are returned as written, so the
+knowledge provider can resolve them later.
+"""
+
+from __future__ import annotations
+
+import re
+
+_LINE = re.compile(r"^[ \t>*-]*specs?[ \t]*:[ \t]*(.+?)[ \t]*$", re.IGNORECASE | re.MULTILINE)
+_REF = re.compile(r"^[^\s#]+(?:#L\d+(?:-L\d+)?)?$")
+
+
+def parse_spec_refs(body: str | None) -> list[str]:
+    refs: list[str] = []
+    for match in _LINE.finditer(body or ""):
+        for raw in re.split(r"[,\s]+", match.group(1)):
+            ref = raw.strip("`<>()[]")
+            if ref and _REF.match(ref) and ref not in refs:
+                refs.append(ref)
+    return refs
+
+
+def blocked_by_in_body(body: str | None) -> list[int]:
+    """`Blocked by #12` lines: the fallback when the API has no dependency data."""
+    found: list[int] = []
+    for match in re.finditer(
+        r"blocked[ \t]+by[ \t:]*((?:#\d+[ \t,]*(?:and[ \t]*)?)+)", body or "", re.I
+    ):
+        for number in re.findall(r"#(\d+)", match.group(1)):
+            if int(number) not in found:
+                found.append(int(number))
+    return found

whiletrue/opencode/__init__.py

@@ -0,0 +1,25 @@
+"""The opencode runner (second opinions and review passes)."""
+
+from whiletrue.core import PluginApi, SimplePlugin
+from whiletrue.opencode.runner import (
+    OpencodeOptions,
+    OpencodeRunner,
+    build_opencode_args,
+    extract_json,
+)
+
+
+def opencode_plugin(options: OpencodeOptions | None = None) -> SimplePlugin:
+    def register(api: PluginApi) -> None:
+        api.register_runner(OpencodeRunner(options))
+
+    return SimplePlugin(name="whiletrue.opencode", register=register)
+
+
+__all__ = [
+    "OpencodeOptions",
+    "OpencodeRunner",
+    "build_opencode_args",
+    "extract_json",
+    "opencode_plugin",
+]

whiletrue/opencode/runner.py

@@ -0,0 +1,186 @@
+from __future__ import annotations
+
+import asyncio
+import json
+import re
+from dataclasses import dataclass, field
+from typing import Any, cast
+
+from whiletrue.basics.process import kill_process_group
+from whiletrue.claude_code.panes import PaneHost, StreamMirror
+from whiletrue.core import AgentRequest, AgentResult, RunContext, RunnerCapabilities
+
+_LINE_LIMIT = 64 * 1024 * 1024
+
+
+@dataclass
+class OpencodeOptions:
+    #: The opencode binary. Defaults to `opencode` on PATH.
+    command: str = "opencode"
+    #: Where to show the live stream (a read-only pane); None runs without one.
+    host: PaneHost | None = None
+    extra_args: list[str] = field(default_factory=lambda: [])
+
+
+_JSON_INSTRUCTION = (
+    "\n\nWhen you are finished, reply with ONLY a JSON value that matches this JSON Schema, "
+    "with no commentary and no code fence:\n{schema}"
+)
+
+
+def build_opencode_args(req: AgentRequest, extra_args: list[str] | None = None) -> list[str]:
+    """argv after the binary. The prompt is the last positional, after `--`."""
+    args = ["run", "--format", "json", "--dir", req.cwd]
+    if req.model:
+        args += ["--model", req.model]
+    if req.resume:
+        args += ["--session", req.resume]
+        if req.fork:
+            args += ["--fork"]
+    prompt = req.prompt
+    if req.output_schema:
+        prompt += _JSON_INSTRUCTION.format(schema=json.dumps(req.output_schema))
+    return [*args, *(extra_args or []), "--", prompt]
+
+
+def extract_json(text: str) -> Any:
+    """The last JSON object or array in a model's reply (raw, or inside a code fence)."""
+    candidates = re.findall(r"```(?:json)?\s*(.*?)```", text, re.DOTALL)
+    candidates.append(text)
+    for chunk in reversed(candidates):
+        decoder = json.JSONDecoder()
+        found: Any = None
+        for start in (m.start() for m in re.finditer(r"[{\[]", chunk)):
+            try:
+                value, _ = decoder.raw_decode(chunk[start:])
+            except ValueError:
+                continue
+            found = value
+            break
+        if found is not None:
+            return found
+    return None
+
+
+class OpencodeRunner:
+    """Runs a step with `opencode run --format json` (review passes, cheap second opinions).
+
+    There is no interactive mode: with a pane host, the step's live stream is shown in a
+    read-only pane. Structured output is requested in the prompt and checked by the agent module.
+    """
+
+    id = "opencode"
+    capabilities = RunnerCapabilities(
+        interactive=False, structured_output=True, resume=True, fork=True, budget=False
+    )
+
+    def __init__(self, options: OpencodeOptions | None = None) -> None:
+        self._options = options or OpencodeOptions()
+
+    async def run(self, request: AgentRequest, ctx: RunContext) -> AgentResult:
+        if ctx.signal.aborted:
+            return AgentResult(ok=False, text="", error="aborted")
+        mirror = StreamMirror(self._options.host)
+        await mirror.open(request.cwd, request.step_key, request.label or "opencode")
+        try:
+            return await self._run(request, ctx, mirror)
+        finally:
+            await mirror.close(keep=request.on_done == "keep", title=f"{request.label} (done)")
+
+    async def _run(
+        self, request: AgentRequest, ctx: RunContext, mirror: StreamMirror
+    ) -> AgentResult:
+        opts = self._options
+        try:
+            proc = await asyncio.create_subprocess_exec(
+                opts.command,
+                *build_opencode_args(request, opts.extra_args),
+                cwd=request.cwd,
+                stdin=asyncio.subprocess.DEVNULL,
+                stdout=asyncio.subprocess.PIPE,
+                stderr=asyncio.subprocess.PIPE,
+                start_new_session=True,
+                limit=_LINE_LIMIT,
+            )
+        except OSError as error:
+            return AgentResult(ok=False, text="", error=f"Failed to start {opts.command}: {error}")
+
+        texts: list[str] = []
+        state: dict[str, Any] = {"cost": 0.0, "session": None, "turns": 0, "error": None}
+
+        def emit(event: dict[str, Any]) -> None:
+            if ctx.on_event is not None:
+                ctx.on_event(event)
+
+        note = mirror.note
+
+        async def drive() -> None:
+            assert proc.stdout is not None
+            while raw := await proc.stdout.readline():
+                try:
+                    event = json.loads(raw)
+                except ValueError:
+                    continue
+                if not isinstance(event, dict):
+                    continue
+                fields = cast(dict[str, Any], event)
+                part = cast(dict[str, Any], fields.get("part") or {})
+                state["session"] = fields.get("sessionID") or state["session"]
+                kind = fields.get("type")
+                if kind == "text":
+                    text = str(part.get("text", ""))
+                    texts.append(text)
+                    note(text)
+                    emit({"kind": "text"})
+                elif kind == "step_finish":
+                    state["turns"] += 1
+                    state["cost"] += float(part.get("cost") or 0)
+                elif kind in ("tool_use", "tool"):
+                    name = str(part.get("tool") or part.get("name") or "")
+                    note(f"[tool] {name}")
+                    emit({"kind": "tool_use", "name": name})
+                elif kind == "error":
+                    state["error"] = json.dumps(fields.get("error", fields))[:400]
+                    note(f"[error] {state['error']}")
+
+        drive_task = asyncio.ensure_future(drive())
+        stderr_task = asyncio.ensure_future(proc.stderr.read() if proc.stderr else asyncio.sleep(0))
+        abort_task = asyncio.ensure_future(ctx.signal.wait())
+        wall_ms = request.limits.wall_ms if request.limits is not None else None
+        try:
+            done, _ = await asyncio.wait(
+                {drive_task, abort_task},
+                timeout=None if wall_ms is None else wall_ms / 1000,
+                return_when=asyncio.FIRST_COMPLETED,
+            )
+            if drive_task not in done:
+                kill_process_group(proc.pid)
+                drive_task.cancel()
+                await asyncio.gather(drive_task, return_exceptions=True)
+                await proc.wait()
+                return AgentResult(
+                    ok=False,
+                    text="".join(texts),
+                    error="aborted" if abort_task in done else "wall-time limit exceeded",
+                )
+            code = await proc.wait()
+            stderr = (await stderr_task or b"").decode(errors="replace").strip()  # type: ignore[union-attr]
+        finally:
+            abort_task.cancel()
+            stderr_task.cancel()
+        text = "".join(texts).strip()
+        common: dict[str, Any] = {
+            "text": text,
+            "session_id": state["session"],
+            "cost_usd": state["cost"],
+            "turns": state["turns"],
+        }
+        if code != 0 or state["error"]:
+            detail = state["error"] or stderr[-400:]
+            return AgentResult(
+                ok=False, error=f"{opts.command} exited with code {code}: {detail}", **common
+            )
+        output = extract_json(text) if request.output_schema else None
+        if request.output_schema and output is None:
+            return AgentResult(ok=False, error="the reply contained no JSON value", **common)
+        return AgentResult(ok=True, output=output, **common)

whiletrue/recipes/issue-loop.yaml

@@ -0,0 +1,59 @@
+# One issue, open to merged: implement on a branch, open a PR, let a person review it while every
+# comment gets an answer, fix what they reject, then merge after a final approval.
+#
+#   source: { github_issues: { milestone: M3 } }      # items are issues; blockers come first
+#   pipeline:
+#     composite: { uses: "recipe:issue-loop", params: { implementer: ./agents/implement.md, ... } }
+composite: issue-loop
+params:
+  implementer: { required: true }  # agent file: implements the issue and commits
+  fixer: { required: true }        # agent file: fixes what a reviewer rejected ({{input}} has the note)
+  responder: { required: true }    # agent file that answers comments (see recipe:review-respond)
+  gate: { default: pytest }        # must pass before a PR opens, after fixes and after replies
+  base: { default: main }
+  repo: { default: "" }            # owner/name; empty means "read it from the origin remote"
+  merge_method: { default: squash }
+  lock: { default: "repo:main" }
+ports: { in: Any, out: Any }
+pipeline:
+  - shell: { run: "git checkout -B wt/{{item.id}}" }
+  - id: impl
+    retry: { max: 3, feedback: true }
+    do:
+      - agent: { uses: "{{params.implementer}}" }
+      - gate.shell: { run: "{{params.gate}}" }
+  - id: pr
+    github.open_pr:
+      repo: "{{params.repo}}"
+      head: "wt/{{item.id}}"
+      base: "{{params.base}}"
+      closes: "{{item.number}}"
+  - id: review
+    human.approve:
+      what: pr
+      wake: { any: [cli, { github.pr_review: any }] }
+    do:
+      - composite:
+          uses: "recipe:review-respond"
+          params: { responder: "{{params.responder}}", gate: "{{params.gate}}" }
+    wires: { rejected: fix }
+  - id: sync
+    github.sync_base: { base: "{{params.base}}" }
+  - id: merge_ok
+    human.approve:
+      what: merge
+      wake: { any: [cli, github.pr_merged] }
+    do:
+      - composite:
+          uses: "recipe:review-respond"
+          params: { responder: "{{params.responder}}", gate: "{{params.gate}}" }
+  - id: merge
+    github.merge: { repo: "{{params.repo}}", method: "{{params.merge_method}}", lock: "{{params.lock}}" }
+  # Reached only by a rejection: fix it, push, and ask for the review again.
+  - id: fix
+    tap:
+      do:
+        - agent: { uses: "{{params.fixer}}" }
+        - gate.shell: { run: "{{params.gate}}", pass_input: true }
+        - shell: { run: "git push --force-with-lease origin HEAD" }
+    wires: { ok: review }

whiletrue/recipes/ralph.yaml

@@ -0,0 +1,14 @@
+# Ralph loop: run an agent with a fresh context, check with a deterministic gate, repeat until
+# green. The agent sees the previous failure as {{iter.previous}}.
+composite: ralph
+params:
+  agent: { required: true }   # path to the agent file, e.g. ./agents/ralph.md
+  gate: { default: pytest }   # shell command; exit 0 means done
+  max: { default: 5 }         # iterations before the item is parked
+ports: { in: Any, out: Any }
+pipeline:
+  loop:
+    max: "{{params.max}}"
+    do:
+      - agent: { uses: "{{params.agent}}" }
+      - gate.shell: { run: "{{params.gate}}" }