rote-cli 0.3.0__tar.gz → 0.5.0__tar.gz

{rote_cli-0.3.0 → rote_cli-0.5.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: rote-cli
-Version: 0.3.0
+Version: 0.5.0
 Summary: Graduate fuzzy AI skills into deterministic, reliable workflows
 Project-URL: Homepage, https://github.com/trevhud/rote
 Project-URL: Repository, https://github.com/trevhud/rote
@@ -59,8 +59,13 @@ applies a structured graduation rubric, and emits:
 - and runtime code for your durable execution engine of choice.
 
 ```sh
-# Two runtimes shipped today — emit Python for Temporal, or TypeScript
-# for Cloudflare Workflows:
+pip install rote-cli    # or zero-install: uvx --from rote-cli rote ...
+
+# Default target is DBOS — durable execution as a plain Python library,
+# no orchestrator to run, SQLite for dev / Postgres for prod:
+rote graduate ./examples/bdr-outreach/skill --out ./graduated/
+
+# Or target Temporal (Python) or Cloudflare Workflows (TypeScript):
 rote graduate ./examples/bdr-outreach/skill --runtime temporal   --out ./graduated/
 rote graduate ./examples/bdr-outreach/skill --runtime cloudflare --out ./graduated/
 ```
@@ -140,6 +145,10 @@ The graduator independently:
 After the agent finishes, a runtime adapter consumes the IR and emits
 the target runtime's native code shape:
 
+- The **DBOS** adapter (the default) emits a single `main.py` — one
+  `@DBOS.workflow` DAG plus a `@DBOS.step` per node, checkpointing to
+  SQLite or Postgres. `python main.py` *is* the runtime; there is no
+  orchestrator to deploy.
 - The **Temporal** adapter emits `workflow.py` (the orchestration
   class with `@workflow.defn` and signal handlers for the HITL gates)
   and `activities.py` (one `@activity.defn` per node, lazy-importing
@@ -150,6 +159,24 @@ the target runtime's native code shape:
   `signatures/*.ts` (Zod schemas + Anthropic SDK calls) and the
   supporting `wrangler.jsonc` / `package.json` / `tsconfig.json`. The
   output is `wrangler deploy`-ready.
+- The **DBOS (TypeScript)** adapter (`--runtime dbos-ts`) emits a
+  Node.js app for DBOS Transact: `src/main.ts` registers one durable
+  workflow (`DBOS.registerWorkflow`) running the DAG waves and one
+  `DBOS.registerStep` per node, with `DBOS.recv(...)` parking each
+  HITL gate durably in Postgres until `DBOS.send(...)` resumes it.
+  Zero-orchestrator like the Python DBOS target — `node dist/main.js`
+  *is* the runtime — but note the TS SDK is Postgres-only (no SQLite
+  mode; `npx dbos postgres start` covers local dev).
+- The **Inngest** adapter (`--runtime inngest`) emits a TypeScript
+  Inngest app for teams whose graduated skill should live inside the
+  Node/Next.js service they already deploy: `src/inngest/pipeline.ts`
+  is one durable `inngest.createFunction` running the DAG waves
+  (`step.run` per node, `Promise.all` fan-out, `step.waitForEvent`
+  parking each HITL gate until its namespaced resume event), plus a
+  framework-neutral `inngest/node` serve entrypoint. The emitted
+  README shows the drop-in Next.js mount (`inngest/next`). Note:
+  Inngest v4 retries are function-level only — the emitter sets the
+  max across per-node policies and documents the deltas as comments.
 
 None of the emitted code references an MCP runtime, in either
 language — the agent's crystallization step replaces tool calls with
@@ -297,11 +324,12 @@ The repository includes a real BDR outreach skill in
 `examples/bdr-outreach/skill/`. Graduate it:
 
 ```sh
-rote graduate examples/bdr-outreach/skill \
-  --runtime temporal \
-  --out /tmp/bdr-graduated
+rote graduate examples/bdr-outreach/skill --out /tmp/bdr-graduated
 ```
 
+This targets DBOS by default; pass `--runtime temporal` or
+`--runtime cloudflare` for the other adapters.
+
 By default `rote` auto-detects an available agent driver in this
 order: `claude` (Claude Code CLI) → `codex` (Codex CLI) → `api`
 (Anthropic SDK with `ANTHROPIC_API_KEY`). Override with `--agent`:
@@ -320,10 +348,12 @@ The output directory is structured as:
 │   ├── signatures/*.py          # typed LLM-judge signatures
 │   ├── evals/*.jsonl            # seed eval examples
 │   └── graduation-report.md     # human-readable summary
-└── runtime/temporal/            # produced by the adapter
-    ├── workflow.py
-    ├── activities.py
-    └── __init__.py
+└── runtime/dbos/                # produced by the adapter
+    ├── main.py                  # @DBOS.workflow + one @DBOS.step per node
+    ├── extracted/*.py           # copied deterministic functions
+    ├── signatures/*.py          # generated Pydantic + vendor-SDK judges
+    ├── dbos-config.yaml
+    └── README.md                # how to run, signal HITL gates, deploy
 ```
 
 ### Render an IR without re-running the agent
@@ -332,6 +362,7 @@ If you already have a `pipeline.yaml` (hand-written or from a previous
 graduation), `rote emit` runs just the adapter step:
 
 ```sh
+rote emit /path/to/pipeline.yaml --out /tmp/emitted/            # dbos (default)
 rote emit /path/to/pipeline.yaml --runtime temporal --out /tmp/emitted/
 ```
 
@@ -393,10 +424,12 @@ Opus's extra reasoning earns its cost.
 ## Status
 
 `rote` is **pre-1.0**. The end-to-end flow works on the BDR example
-and the test suite covers each layer (133 tests in the fast suite,
-plus 3 slow tests that compile the emitted Cloudflare TypeScript
-against the real `@cloudflare/workers-types` definitions and drive a
-real workflow instance through both HITL gates via `wrangler dev`).
+and the test suite covers each layer (231 tests in the fast suite,
+plus 5 slow tests that run the emitted code against real runtimes:
+a DBOS runtime over SQLite, Temporal's time-skipping test server, the
+emitted Cloudflare TypeScript compiled against real
+`@cloudflare/workers-types` and driven through both HITL gates via
+`wrangler dev`, and the MCP server over a real stdio transport).
 Run `pytest tests/` for the fast suite; `pytest tests/ -m slow` for
 the toolchain-dependent integration tests.
 
@@ -406,15 +439,18 @@ the toolchain-dependent integration tests.
 | Temporal adapter | working (validated with mocked-activities e2e test) |
 | Cloudflare Workflows adapter | working (validated with `tsc --noEmit` over the real emitted output) |
 | DBOS adapter | working (validated against a real DBOS runtime over SQLite in the e2e test) |
+| DBOS TypeScript adapter (`dbos-ts`) | working (validated with `tsc --noEmit` over the real emitted output and a live run on the DBOS TS runtime against Docker Postgres) |
+| Raw Python adapter (`python`) | working (emitted script executed as a subprocess in the e2e test: wave order, payload threading, and a live retry loop; refuses `hitl_gate` pipelines at emit time) |
 | Graduator orchestrator | working |
 | `rote graduate` / `rote emit` CLI commands | working |
 | `claude` driver | working |
 | `api` (Anthropic SDK) driver | working |
 | `codex` driver | stub (`is_available` works; `run` not implemented) |
-| Inngest / Restate adapters | planned |
+| Inngest adapter (`inngest`) | working (validated with `tsc --noEmit` over the real emitted output and a live run through both HITL gates against the Inngest dev server) |
+| Restate adapter | planned |
 | Real implementations of the extracted modules | the agent produces stubs that raise `NotImplementedError`; humans fill them in with real API client code |
-| Workflow data flow between activities | working — nodes declare `inputs:` bindings and all three adapters (Temporal, Cloudflare, DBOS) thread real payloads through the DAG, validated in the runtime e2e tests |
-| Distribution via PyPI | not yet published — install from source. The release pipeline (tag-driven, Trusted Publishing) is in place; see [docs/releasing.md](docs/releasing.md) |
+| Workflow data flow between activities | working — nodes declare `inputs:` bindings and all five adapters (Temporal, Cloudflare, DBOS, DBOS-TS, Inngest) thread real payloads through the DAG, validated in the runtime e2e tests |
+| Distribution via PyPI | published as [`rote-cli`](https://pypi.org/project/rote-cli/) (`pip install rote-cli`); tag-driven Trusted Publishing releases — see [docs/releasing.md](docs/releasing.md) |
 
 The project explicitly **does not** depend on `claude-agent-sdk`.
 Anthropic's terms of service forbid third-party agents built on the
@@ -523,11 +559,15 @@ In rough priority order:
    graduator the new field, but no real graduator run has produced
    one yet. Re-running `rote graduate examples/bdr-outreach/skill`
    should produce the structured form natively.
-3. **A third runtime adapter.** Probably Inngest, since its
-   programming model is meaningfully different from both Temporal and
-   Cloudflare. Each new adapter is also a stress test on whether the
-   IR is genuinely runtime-agnostic vs. accidentally shaped like one
-   of the existing targets.
+3. **A third runtime adapter.** *(Done — the Inngest adapter shipped,
+   alongside DBOS Python/TS.)* Its programming model is meaningfully
+   different from both Temporal and Cloudflare — retries are
+   function-level, the platform drives execution from outside the
+   process — and the IR survived without changes (the per-node retry
+   gap is documented at emission, not papered over in the IR). Each
+   new adapter remains a stress test on whether the IR is genuinely
+   runtime-agnostic vs. accidentally shaped like one of the existing
+   targets.
 4. **Pre-filter as `pure_function` node.** Today the rubric lifts
    hard thresholds into a Python `forward()` method, which works for
    Temporal but not for Cloudflare. Modeling the pre-filter as a
@@ -561,7 +601,7 @@ The most useful contributions right now are:
   needs to be tested against more.
 - **Add a runtime adapter.** The Temporal adapter in
   `src/rote/adapters/temporal.py` is ~450 lines and follows a clear
-  pattern. Inngest, Restate, and Hatchet are all good targets.
+  pattern. Restate and Hatchet are both good targets.
 - **Add a graduator driver.** The Protocol in
   `src/rote/graduator/drivers/__init__.py` is simple. Aider, Gemini
   CLI, and Cursor Agent are reasonable additions.

{rote_cli-0.3.0 → rote_cli-0.5.0}/README.md

@@ -13,8 +13,13 @@ applies a structured graduation rubric, and emits:
 - and runtime code for your durable execution engine of choice.
 
 ```sh
-# Two runtimes shipped today — emit Python for Temporal, or TypeScript
-# for Cloudflare Workflows:
+pip install rote-cli    # or zero-install: uvx --from rote-cli rote ...
+
+# Default target is DBOS — durable execution as a plain Python library,
+# no orchestrator to run, SQLite for dev / Postgres for prod:
+rote graduate ./examples/bdr-outreach/skill --out ./graduated/
+
+# Or target Temporal (Python) or Cloudflare Workflows (TypeScript):
 rote graduate ./examples/bdr-outreach/skill --runtime temporal   --out ./graduated/
 rote graduate ./examples/bdr-outreach/skill --runtime cloudflare --out ./graduated/
 ```
@@ -94,6 +99,10 @@ The graduator independently:
 After the agent finishes, a runtime adapter consumes the IR and emits
 the target runtime's native code shape:
 
+- The **DBOS** adapter (the default) emits a single `main.py` — one
+  `@DBOS.workflow` DAG plus a `@DBOS.step` per node, checkpointing to
+  SQLite or Postgres. `python main.py` *is* the runtime; there is no
+  orchestrator to deploy.
 - The **Temporal** adapter emits `workflow.py` (the orchestration
   class with `@workflow.defn` and signal handlers for the HITL gates)
   and `activities.py` (one `@activity.defn` per node, lazy-importing
@@ -104,6 +113,24 @@ the target runtime's native code shape:
   `signatures/*.ts` (Zod schemas + Anthropic SDK calls) and the
   supporting `wrangler.jsonc` / `package.json` / `tsconfig.json`. The
   output is `wrangler deploy`-ready.
+- The **DBOS (TypeScript)** adapter (`--runtime dbos-ts`) emits a
+  Node.js app for DBOS Transact: `src/main.ts` registers one durable
+  workflow (`DBOS.registerWorkflow`) running the DAG waves and one
+  `DBOS.registerStep` per node, with `DBOS.recv(...)` parking each
+  HITL gate durably in Postgres until `DBOS.send(...)` resumes it.
+  Zero-orchestrator like the Python DBOS target — `node dist/main.js`
+  *is* the runtime — but note the TS SDK is Postgres-only (no SQLite
+  mode; `npx dbos postgres start` covers local dev).
+- The **Inngest** adapter (`--runtime inngest`) emits a TypeScript
+  Inngest app for teams whose graduated skill should live inside the
+  Node/Next.js service they already deploy: `src/inngest/pipeline.ts`
+  is one durable `inngest.createFunction` running the DAG waves
+  (`step.run` per node, `Promise.all` fan-out, `step.waitForEvent`
+  parking each HITL gate until its namespaced resume event), plus a
+  framework-neutral `inngest/node` serve entrypoint. The emitted
+  README shows the drop-in Next.js mount (`inngest/next`). Note:
+  Inngest v4 retries are function-level only — the emitter sets the
+  max across per-node policies and documents the deltas as comments.
 
 None of the emitted code references an MCP runtime, in either
 language — the agent's crystallization step replaces tool calls with
@@ -251,11 +278,12 @@ The repository includes a real BDR outreach skill in
 `examples/bdr-outreach/skill/`. Graduate it:
 
 ```sh
-rote graduate examples/bdr-outreach/skill \
-  --runtime temporal \
-  --out /tmp/bdr-graduated
+rote graduate examples/bdr-outreach/skill --out /tmp/bdr-graduated
 ```
 
+This targets DBOS by default; pass `--runtime temporal` or
+`--runtime cloudflare` for the other adapters.
+
 By default `rote` auto-detects an available agent driver in this
 order: `claude` (Claude Code CLI) → `codex` (Codex CLI) → `api`
 (Anthropic SDK with `ANTHROPIC_API_KEY`). Override with `--agent`:
@@ -274,10 +302,12 @@ The output directory is structured as:
 │   ├── signatures/*.py          # typed LLM-judge signatures
 │   ├── evals/*.jsonl            # seed eval examples
 │   └── graduation-report.md     # human-readable summary
-└── runtime/temporal/            # produced by the adapter
-    ├── workflow.py
-    ├── activities.py
-    └── __init__.py
+└── runtime/dbos/                # produced by the adapter
+    ├── main.py                  # @DBOS.workflow + one @DBOS.step per node
+    ├── extracted/*.py           # copied deterministic functions
+    ├── signatures/*.py          # generated Pydantic + vendor-SDK judges
+    ├── dbos-config.yaml
+    └── README.md                # how to run, signal HITL gates, deploy
 ```
 
 ### Render an IR without re-running the agent
@@ -286,6 +316,7 @@ If you already have a `pipeline.yaml` (hand-written or from a previous
 graduation), `rote emit` runs just the adapter step:
 
 ```sh
+rote emit /path/to/pipeline.yaml --out /tmp/emitted/            # dbos (default)
 rote emit /path/to/pipeline.yaml --runtime temporal --out /tmp/emitted/
 ```
 
@@ -347,10 +378,12 @@ Opus's extra reasoning earns its cost.
 ## Status
 
 `rote` is **pre-1.0**. The end-to-end flow works on the BDR example
-and the test suite covers each layer (133 tests in the fast suite,
-plus 3 slow tests that compile the emitted Cloudflare TypeScript
-against the real `@cloudflare/workers-types` definitions and drive a
-real workflow instance through both HITL gates via `wrangler dev`).
+and the test suite covers each layer (231 tests in the fast suite,
+plus 5 slow tests that run the emitted code against real runtimes:
+a DBOS runtime over SQLite, Temporal's time-skipping test server, the
+emitted Cloudflare TypeScript compiled against real
+`@cloudflare/workers-types` and driven through both HITL gates via
+`wrangler dev`, and the MCP server over a real stdio transport).
 Run `pytest tests/` for the fast suite; `pytest tests/ -m slow` for
 the toolchain-dependent integration tests.
 
@@ -360,15 +393,18 @@ the toolchain-dependent integration tests.
 | Temporal adapter | working (validated with mocked-activities e2e test) |
 | Cloudflare Workflows adapter | working (validated with `tsc --noEmit` over the real emitted output) |
 | DBOS adapter | working (validated against a real DBOS runtime over SQLite in the e2e test) |
+| DBOS TypeScript adapter (`dbos-ts`) | working (validated with `tsc --noEmit` over the real emitted output and a live run on the DBOS TS runtime against Docker Postgres) |
+| Raw Python adapter (`python`) | working (emitted script executed as a subprocess in the e2e test: wave order, payload threading, and a live retry loop; refuses `hitl_gate` pipelines at emit time) |
 | Graduator orchestrator | working |
 | `rote graduate` / `rote emit` CLI commands | working |
 | `claude` driver | working |
 | `api` (Anthropic SDK) driver | working |
 | `codex` driver | stub (`is_available` works; `run` not implemented) |
-| Inngest / Restate adapters | planned |
+| Inngest adapter (`inngest`) | working (validated with `tsc --noEmit` over the real emitted output and a live run through both HITL gates against the Inngest dev server) |
+| Restate adapter | planned |
 | Real implementations of the extracted modules | the agent produces stubs that raise `NotImplementedError`; humans fill them in with real API client code |
-| Workflow data flow between activities | working — nodes declare `inputs:` bindings and all three adapters (Temporal, Cloudflare, DBOS) thread real payloads through the DAG, validated in the runtime e2e tests |
-| Distribution via PyPI | not yet published — install from source. The release pipeline (tag-driven, Trusted Publishing) is in place; see [docs/releasing.md](docs/releasing.md) |
+| Workflow data flow between activities | working — nodes declare `inputs:` bindings and all five adapters (Temporal, Cloudflare, DBOS, DBOS-TS, Inngest) thread real payloads through the DAG, validated in the runtime e2e tests |
+| Distribution via PyPI | published as [`rote-cli`](https://pypi.org/project/rote-cli/) (`pip install rote-cli`); tag-driven Trusted Publishing releases — see [docs/releasing.md](docs/releasing.md) |
 
 The project explicitly **does not** depend on `claude-agent-sdk`.
 Anthropic's terms of service forbid third-party agents built on the
@@ -477,11 +513,15 @@ In rough priority order:
    graduator the new field, but no real graduator run has produced
    one yet. Re-running `rote graduate examples/bdr-outreach/skill`
    should produce the structured form natively.
-3. **A third runtime adapter.** Probably Inngest, since its
-   programming model is meaningfully different from both Temporal and
-   Cloudflare. Each new adapter is also a stress test on whether the
-   IR is genuinely runtime-agnostic vs. accidentally shaped like one
-   of the existing targets.
+3. **A third runtime adapter.** *(Done — the Inngest adapter shipped,
+   alongside DBOS Python/TS.)* Its programming model is meaningfully
+   different from both Temporal and Cloudflare — retries are
+   function-level, the platform drives execution from outside the
+   process — and the IR survived without changes (the per-node retry
+   gap is documented at emission, not papered over in the IR). Each
+   new adapter remains a stress test on whether the IR is genuinely
+   runtime-agnostic vs. accidentally shaped like one of the existing
+   targets.
 4. **Pre-filter as `pure_function` node.** Today the rubric lifts
    hard thresholds into a Python `forward()` method, which works for
    Temporal but not for Cloudflare. Modeling the pre-filter as a
@@ -515,7 +555,7 @@ The most useful contributions right now are:
   needs to be tested against more.
 - **Add a runtime adapter.** The Temporal adapter in
   `src/rote/adapters/temporal.py` is ~450 lines and follows a clear
-  pattern. Inngest, Restate, and Hatchet are all good targets.
+  pattern. Restate and Hatchet are both good targets.
 - **Add a graduator driver.** The Protocol in
   `src/rote/graduator/drivers/__init__.py` is simple. Aider, Gemini
   CLI, and Cursor Agent are reasonable additions.

{rote_cli-0.3.0 → rote_cli-0.5.0}/src/rote/__init__.py

@@ -1,3 +1,3 @@
 """rote — graduate fuzzy AI skills into deterministic workflows."""
 
-__version__ = "0.3.0"
+__version__ = "0.5.0"

{rote_cli-0.3.0 → rote_cli-0.5.0}/src/rote/adapters/__init__.py

@@ -6,8 +6,8 @@ adapters are template substitution.
 
 The "two adapters minimum" rule applies: until at least two adapters
 work end-to-end, assume the IR shape is secretly leaking the first
-runtime's mental model. Inngest is the planned second target after
-Temporal.
+runtime's mental model. (Satisfied — five adapters share the IR today:
+Temporal, Cloudflare, DBOS Python, DBOS TypeScript, and Inngest.)
 
 Adapters are registered in :data:`ADAPTERS` and dispatched by name from
 the CLI (``rote emit --runtime <name>``).
@@ -48,12 +48,33 @@ def _dbos_adapter_factory() -> Adapter:
     return DbosAdapter()
 
 
+def _dbos_ts_adapter_factory() -> Adapter:
+    from rote.adapters.dbos_ts import DbosTsAdapter
+
+    return DbosTsAdapter()
+
+
+def _inngest_adapter_factory() -> Adapter:
+    from rote.adapters.inngest import InngestAdapter
+
+    return InngestAdapter()
+
+
+def _python_adapter_factory() -> Adapter:
+    from rote.adapters.python import PythonAdapter
+
+    return PythonAdapter()
+
+
 #: Name → factory. Keep the values as zero-arg callables so adapters can
 #: lazy-import their heavy dependencies.
 ADAPTERS: dict[str, Callable[[], Adapter]] = {
     "temporal": _temporal_adapter_factory,
     "cloudflare": _cloudflare_adapter_factory,
     "dbos": _dbos_adapter_factory,
+    "dbos-ts": _dbos_ts_adapter_factory,
+    "inngest": _inngest_adapter_factory,
+    "python": _python_adapter_factory,
 }
 
 

{rote_cli-0.3.0 → rote_cli-0.5.0}/src/rote/adapters/_common.py

@@ -13,9 +13,63 @@ from __future__ import annotations
 
 import hashlib
 import re
+from pathlib import Path
 
 from rote.ir import Node, Pipeline, parse_input_ref
 
+# ───────── Prose → safe code comment/docstring ─────────
+
+
+def safe_docstring_line(text: str, fallback: str = "") -> str:
+    """First line of ``text``, escaped so it cannot break out of a docstring.
+
+    Node ``description`` is prose (it legitimately contains quotes and
+    backslashes), yet adapters splice its first line straight into a
+    ``\"\"\"…\"\"\"`` Python docstring / block comment. An unescaped
+    ``\"\"\"`` — or a trailing backslash that escapes the closing quote —
+    lets a crafted pipeline.yaml close the docstring early and inject
+    code. Escaping backslashes and double-quotes neutralizes both without
+    charset-restricting prose at the IR layer.
+    """
+    stripped = text.strip() if text else ""
+    first = stripped.splitlines()[0] if stripped else fallback
+    return first.replace("\\", "\\\\").replace('"', '\\"')
+
+
+def safe_block_comment_line(text: str, fallback: str = "") -> str:
+    """First line of ``text``, safe to splice into a ``/* … */`` block comment.
+
+    The TypeScript adapter emits ``description`` first-lines into JSDoc
+    comments. An unescaped ``*/`` would close the comment early and let a
+    crafted pipeline.yaml inject code after it; neutralize the sequence by
+    inserting a space (``*/`` → ``* /``). Newlines are already dropped by
+    taking the first line.
+    """
+    stripped = text.strip() if text else ""
+    first = stripped.splitlines()[0] if stripped else fallback
+    return first.replace("*/", "* /")
+
+
+# ───────── Output-path containment ─────────
+
+
+def resolve_within(base: Path, *parts: str) -> Path:
+    """Join ``parts`` onto ``base`` and assert the result stays inside it.
+
+    Defense-in-depth for emitted-file paths. IR validation already pins
+    ``node.id`` to an identifier, but this guard means any future field
+    that reaches a filename cannot escape the output directory via an
+    absolute segment or ``..`` traversal — it fails loudly at emit time.
+    """
+    base_resolved = base.resolve()
+    target = base_resolved.joinpath(*parts).resolve()
+    if target != base_resolved and base_resolved not in target.parents:
+        raise ValueError(
+            f"Refusing to write outside output directory: {target} is not within {base_resolved}"
+        )
+    return target
+
+
 # ───────── Case conversion ─────────