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

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: rote-cli
-Version: 0.8.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.8.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.8.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.8.0 → rote_cli-0.9.0}/src/rote/__init__.py

@@ -1,3 +1,3 @@
 """rote — graduate fuzzy AI skills into deterministic workflows."""
 
-__version__ = "0.8.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.8.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.8.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)$")