rote-cli 0.7.0__tar.gz → 0.9.0__tar.gz

{rote_cli-0.7.0 → rote_cli-0.9.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: rote-cli
-Version: 0.7.0
+Version: 0.9.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
@@ -32,11 +32,17 @@ Requires-Dist: dbos>=2.26; extra == 'dev'
 Requires-Dist: fastmcp>=3.4.2; extra == 'dev'
 Requires-Dist: httpx>=0.28; extra == 'dev'
 Requires-Dist: mypy>=1.10; extra == 'dev'
+Requires-Dist: openai>=2.45; extra == 'dev'
 Requires-Dist: pytest-asyncio>=0.23; extra == 'dev'
 Requires-Dist: pytest>=8.0; extra == 'dev'
 Requires-Dist: ruff>=0.6; extra == 'dev'
 Requires-Dist: temporalio>=1.7; extra == 'dev'
 Requires-Dist: types-pyyaml; extra == 'dev'
+Provides-Extra: mcp
+Requires-Dist: fastmcp>=3.4.2; extra == 'mcp'
+Requires-Dist: httpx>=0.28; extra == 'mcp'
+Provides-Extra: openai-api
+Requires-Dist: openai>=2.45; extra == 'openai-api'
 Provides-Extra: serve
 Requires-Dist: fastmcp>=3.4.2; extra == 'serve'
 Requires-Dist: httpx>=0.28; extra == 'serve'

{rote_cli-0.7.0 → rote_cli-0.9.0}/pyproject.toml

@@ -50,6 +50,9 @@ temporal = [
 api = [
     "anthropic>=0.89",
 ]
+openai-api = [
+    "openai>=2.45",
+]
 dbos = [
     "dbos>=2.26",
 ]
@@ -57,6 +60,10 @@ serve = [
     "fastmcp>=3.4.2",
     "httpx>=0.28",
 ]
+mcp = [
+    "fastmcp>=3.4.2",
+    "httpx>=0.28",
+]
 dev = [
     "pytest>=8.0",
     "pytest-asyncio>=0.23",
@@ -65,6 +72,7 @@ dev = [
     "types-pyyaml",
     "temporalio>=1.7",
     "anthropic>=0.89",
+    "openai>=2.45",
     "dbos>=2.26",
     "fastmcp>=3.4.2",
     "httpx>=0.28",

{rote_cli-0.7.0 → rote_cli-0.9.0}/skills/rote-graduate/SKILL.md

@@ -46,6 +46,19 @@ re-deriving a known-fixed procedure at runtime is waste.
 
 ## Pipeline
 
+**Progress markers.** At the START of each Phase N, rewrite
+`progress.ndjson` in the work directory so it holds one JSON line per
+phase entered so far, in order:
+
+```
+{"phase": 1, "name": "Intake"}
+{"phase": 2, "name": "Node Classification"}
+```
+
+Rewrite the whole file each time (append the new phase's line to the
+ones already there). This file is machine-read for live progress
+display; it is not a deliverable and never affects the IR.
+
 ### Phase 1: Intake
 
 Read the target directory exhaustively:

{rote_cli-0.7.0 → rote_cli-0.9.0}/skills/rote-graduate/references/eval-estimates.md

@@ -25,6 +25,13 @@ Ground rules:
   (agents batch parallel calls). If it says "repeat until you have 25
   qualified contacts", estimate the realistic iteration count from any
   hints (quota sizes, batch sizes, typical yields), not the worst case.
+- **Steps that repeat per item MUST declare `iterations`.** A "process
+  each row" step costs its per-row turns *times the row count* — this
+  is almost always the dominant term, and flattening it understates the
+  whole run by 5–20×. Put the per-iteration turns in `estimated_turns`
+  and the realistic item-count range in `iterations` (page sizes,
+  pagination labels, batch quotas, and filter windows in the skill text
+  are your evidence). The loader multiplies them; never pre-multiply.
 - **Include the overhead the prose hides.** Reading reference files,
   re-checking rubric sections, correcting malformed tool calls — a
   realistic agent spends turns on these. A step whose happy path is 2
@@ -54,9 +61,14 @@ steps:
     phase: "1"
     estimated_turns: {low: 1, high: 2}
     estimated_tool_calls: {low: 4, high: 4}
-totals:                             # optional — omit if the sum is right
-  low: 28
-  high: 45
+  - description: "Push each eligible invoice and capture its sent date"
+    node_id: process_invoices_loop
+    phase: "Processing"
+    estimated_turns: {low: 3, high: 6}      # PER ROW —
+    iterations: {low: 20, high: 90}         # — × realistic row count
+totals:                             # optional — omit if the sum is right;
+  low: 88                           # must be WHOLE-RUN (post-iteration)
+  high: 602                         # when any step declares iterations
 notes: >-
   Lead generation dominates: the loop re-queries ZoomInfo with adjusted
   filters until the quota is met; typical campaigns converge in 3-5
@@ -72,30 +84,39 @@ Field reference:
 | `steps[].description` | yes | The step, in the skill's own vocabulary |
 | `steps[].node_id` | no | IR node id, only when the mapping is clean 1:1 |
 | `steps[].phase` | no | Source skill phase, same convention as the IR |
-| `steps[].estimated_turns` | yes | `{low, high}` agent turns |
+| `steps[].estimated_turns` | yes | `{low, high}` agent turns (per iteration when `iterations` is set) |
 | `steps[].estimated_tool_calls` | no | `{low, high}` tool calls, when distinct from turns |
-| `totals` | no | Whole-run `{low, high}`; omit to mean "sum the steps" |
+| `steps[].iterations` | when the step repeats | `{low, high}` repeats per run (rows, pages, items); whole-run cost = turns × iterations |
+| `totals` | no | Whole-run `{low, high}`; omit to mean "sum the steps (× iterations)" |
 | `notes` | no | The one paragraph a reader needs to trust the numbers |
 
 Validated by `rote.eval.sidecar.EvalEstimates` — if you can run Python,
 `load_eval_estimates("eval.yaml")` is the dry check, same pattern as
 `load_pipeline`.
 
-## Calibration anchors (BDR reference points)
-
-From real runs of BDR-scale skills (7 phases, ~20 distinct steps,
-heavy tool use):
-
-- Whole-run turn counts landed in the **30–57 turn** range.
-- Wall clock was **~13 seconds per turn** including tool execution.
-- A single fixed API call step: 1–2 turns. A batch-and-review step:
-  2–4. A bounded search loop: 6–15. A genuinely open research step:
-  4–10.
-
-If your step estimates sum to something wildly outside the anchor range
-for a comparably sized skill, re-examine before writing — either the
-skill really is bigger/smaller (fine, say so in `notes`) or a step
-estimate is off.
+## Calibration anchors (measured production runs)
+
+Whole-run turn counts are regime-dependent — anchor to the skill's
+*shape*, not to a universal range:
+
+- **Sequential tool-heavy skills** (BDR-scale: 7 phases, ~20 distinct
+  steps, no per-item loop): **30–57 turns** measured. ~13 seconds per
+  turn including tool execution.
+- **Per-item loop skills** (browser automation over a table, per-record
+  processing): measured production runs landed at **184 and 730 turns**
+  — the loop multiplier dominates everything else in the file. If a
+  skill says "for each row…", expect hundreds of turns, not tens, and
+  express it via `iterations`, never by inflating per-step turns.
+- Per-step anchors: a single fixed API call step: 1–2 turns. A
+  batch-and-review step: 2–4. A bounded search loop: 6–15. A genuinely
+  open research step: 4–10. One iteration of a per-row browser cycle
+  (locate, act, confirm, refresh): 2–6.
+
+If your estimate lands wildly outside the anchor for the skill's shape,
+re-examine before writing — either the skill really is bigger/smaller
+(fine, say so in `notes`) or a step estimate is off. A per-item skill
+whose whole-run total sums to under ~100 turns almost certainly has a
+missing `iterations` block.
 
 ## What NOT to do
 

{rote_cli-0.7.0 → rote_cli-0.9.0}/src/rote/__init__.py

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

rote_cli-0.9.0/src/rote/__main__.py

@@ -0,0 +1,12 @@
+"""``python -m rote`` — the same CLI as the ``rote`` console script.
+
+Exists so generated configs can invoke rote through a known
+interpreter (``sys.executable -m rote``) instead of guessing at PATH —
+the eval harness's ``headersHelper`` wiring depends on this.
+"""
+
+import sys
+
+from rote.cli import main
+
+sys.exit(main())

{rote_cli-0.7.0 → rote_cli-0.9.0}/src/rote/adapters/__init__.py

@@ -31,7 +31,17 @@ class Adapter(Protocol):
 #: Options a factory may receive (forwarded from ``get_adapter``). Factories
 #: swallow unknown keys via ``**options`` — mirrors the driver-registry
 #: convention — so a runtime that doesn't support an option just ignores it.
-#: ``external_backend`` ("mcp" | "api") is understood by the DBOS adapter.
+#: ``external_backend`` ("mcp" | "api") is understood by the DBOS, DBOS-TS,
+#: and Inngest adapters.
+
+
+def _validated_backend(options: dict[str, Any]) -> Literal["mcp", "api"] | None:
+    backend = options.get("external_backend")
+    if backend is None:
+        return None
+    if backend not in ("mcp", "api"):
+        raise ValueError(f"external_backend must be 'mcp' or 'api', got {backend!r}")
+    return cast(Literal["mcp", "api"], backend)
 
 
 def _temporal_adapter_factory(**options: Any) -> Adapter:
@@ -43,32 +53,39 @@ def _temporal_adapter_factory(**options: Any) -> Adapter:
 
 
 def _cloudflare_adapter_factory(**options: Any) -> Adapter:
-    from rote.adapters.cloudflare import CloudflareAdapter
+    from rote.adapters.cloudflare import CloudflareAdapter, CloudflareAdapterConfig
 
-    return CloudflareAdapter()
+    backend = _validated_backend(options)
+    if backend is None:
+        return CloudflareAdapter()
+    return CloudflareAdapter(CloudflareAdapterConfig(external_backend=backend))
 
 
 def _dbos_adapter_factory(**options: Any) -> Adapter:
     from rote.adapters.dbos import DbosAdapter, DbosAdapterConfig
 
-    backend = options.get("external_backend")
+    backend = _validated_backend(options)
     if backend is None:
         return DbosAdapter()
-    if backend not in ("mcp", "api"):
-        raise ValueError(f"external_backend must be 'mcp' or 'api', got {backend!r}")
-    return DbosAdapter(DbosAdapterConfig(external_backend=cast(Literal["mcp", "api"], backend)))
+    return DbosAdapter(DbosAdapterConfig(external_backend=backend))
 
 
 def _dbos_ts_adapter_factory(**options: Any) -> Adapter:
-    from rote.adapters.dbos_ts import DbosTsAdapter
+    from rote.adapters.dbos_ts import DbosTsAdapter, DbosTsAdapterConfig
 
-    return DbosTsAdapter()
+    backend = _validated_backend(options)
+    if backend is None:
+        return DbosTsAdapter()
+    return DbosTsAdapter(DbosTsAdapterConfig(external_backend=backend))
 
 
 def _inngest_adapter_factory(**options: Any) -> Adapter:
-    from rote.adapters.inngest import InngestAdapter
+    from rote.adapters.inngest import InngestAdapter, InngestAdapterConfig
 
-    return InngestAdapter()
+    backend = _validated_backend(options)
+    if backend is None:
+        return InngestAdapter()
+    return InngestAdapter(InngestAdapterConfig(external_backend=backend))
 
 
 def _python_adapter_factory(**options: Any) -> Adapter:

{rote_cli-0.7.0 → rote_cli-0.9.0}/src/rote/adapters/_common.py

@@ -194,6 +194,27 @@ class EmitWriter:
         )
 
 
+class EmitResult(dict[str, Path]):
+    """An adapter emit mapping that also carries preserved-conflict paths.
+
+    It *is* the ``label -> written path`` dict every ``emit()`` has always
+    returned (the path is the ``.new`` sibling when a user-edited file was
+    preserved), so existing consumers that iterate it keep working
+    unchanged. The extra :attr:`preserved` attribute exposes the
+    :class:`EmitWriter`'s ``rel -> .new path`` map directly, for callers
+    (the cloud runner) that want the conflict set without sniffing ``.new``
+    suffixes off the values.
+    """
+
+    def __init__(
+        self,
+        written: dict[str, Path] | None = None,
+        preserved: dict[str, Path] | None = None,
+    ) -> None:
+        super().__init__(written or {})
+        self.preserved: dict[str, Path] = dict(preserved or {})
+
+
 # ───────── Case conversion ─────────
 
 
@@ -238,6 +259,32 @@ def _pipeline_hash(pipeline: Pipeline) -> str:
     return hashlib.sha256(payload.encode()).hexdigest()[:8]
 
 
+def workflow_class_name(pipeline: Pipeline) -> str:
+    """The generated workflow class name: ``<PascalName>Workflow``.
+
+    The Cloudflare and Temporal adapters both name their emitted
+    workflow class this way; centralizing it here keeps the manifest the
+    cloud consumes and the emitted TypeScript from drifting apart.
+    """
+    return f"{_to_pascal_case(pipeline.name)}Workflow"
+
+
+def pipeline_identity(pipeline: Pipeline) -> dict[str, str]:
+    """Stable identity fields for a pipeline, shared by emitters and manifests.
+
+    Returns ``{name, version, pipeline_hash, class_name}`` — the same four
+    values the Cloudflare adapter bakes into the workflow.ts header and
+    writes into ``manifest.json`` for the cloud runner. Single source of
+    truth so the two can't disagree.
+    """
+    return {
+        "name": pipeline.name,
+        "version": pipeline.version,
+        "pipeline_hash": _pipeline_hash(pipeline),
+        "class_name": workflow_class_name(pipeline),
+    }
+
+
 # ───────── Duration strings ─────────
 
 _IR_DURATION_RE = re.compile(r"^(\d+(?:\.\d+)?)(ms|s|m|h|d)$")