rhylthyme-cli-runner 0.2.5a0__tar.gz → 0.2.8a0__tar.gz

{rhylthyme_cli_runner-0.2.5a0/src/rhylthyme_cli_runner.egg-info → rhylthyme_cli_runner-0.2.8a0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: rhylthyme-cli-runner
-Version: 0.2.5a0
+Version: 0.2.8a0
 Summary: CLI runner for Rhylthyme real-time program schedules
 Home-page: https://github.com/rhylthyme/rhylthyme-cli-runner
 Author: Rhylthyme Team
@@ -26,7 +26,9 @@ Requires-Dist: click>=8.0.0
 Requires-Dist: jsonschema>=4.0.0
 Requires-Dist: pyyaml>=6.0
 Requires-Dist: colorama>=0.4.0
-Requires-Dist: rhylthyme-spec>=0.2.0a0
+Requires-Dist: rhylthyme-spec>=0.2.1a0
+Provides-Extra: galago
+Requires-Dist: rhylthyme-galago>=0.1.0a0; extra == "galago"
 Provides-Extra: dev
 Requires-Dist: pytest>=6.0.0; extra == "dev"
 Requires-Dist: pytest-cov>=2.10.0; extra == "dev"
@@ -561,8 +563,17 @@ rhylthyme search "pad thai" -i spoonacular                           # then impo
 ```
 
 **Options:** `-i IMPORTER` (default: chosen from the URL), `-o PATH`,
-`--stdout`, `--publish` (and `--open`), `--no-validate`. `-` reads pasted
-source from stdin (with `-i`).
+`--stdout`, `--publish` (and `--open`), `--no-validate`, `--review`. `-` reads
+pasted source from stdin (with `-i`).
+
+`--review` sends the import and its source to a model on the server (GPT-5.6
+Luna, the model that related steps best in the paper's evaluation) and prints
+what looks wrong: a default duration on "simmer until thick", a step the
+parser dropped, steps chained that the source runs in parallel, a total that
+disagrees with the source. It needs `rhylthyme login`, spends one model call
+(capped per day), and changes nothing: the findings are yours to apply. On
+rhylthyme.com the same review runs automatically after every import when you
+are signed in.
 
 ### `rhylthyme render`
 

{rhylthyme_cli_runner-0.2.5a0 → rhylthyme_cli_runner-0.2.8a0}/README.md

@@ -501,8 +501,17 @@ rhylthyme search "pad thai" -i spoonacular                           # then impo
 ```
 
 **Options:** `-i IMPORTER` (default: chosen from the URL), `-o PATH`,
-`--stdout`, `--publish` (and `--open`), `--no-validate`. `-` reads pasted
-source from stdin (with `-i`).
+`--stdout`, `--publish` (and `--open`), `--no-validate`, `--review`. `-` reads
+pasted source from stdin (with `-i`).
+
+`--review` sends the import and its source to a model on the server (GPT-5.6
+Luna, the model that related steps best in the paper's evaluation) and prints
+what looks wrong: a default duration on "simmer until thick", a step the
+parser dropped, steps chained that the source runs in parallel, a total that
+disagrees with the source. It needs `rhylthyme login`, spends one model call
+(capped per day), and changes nothing: the findings are yours to apply. On
+rhylthyme.com the same review runs automatically after every import when you
+are signed in.
 
 ### `rhylthyme render`
 

{rhylthyme_cli_runner-0.2.5a0 → rhylthyme_cli_runner-0.2.8a0}/setup.py

@@ -19,7 +19,7 @@ def read_readme():
 
 setup(
     name="rhylthyme-cli-runner",
-    version="0.2.5a0",
+    version="0.2.8a0",
     description="CLI runner for Rhylthyme real-time program schedules",
     long_description=read_readme(),
     long_description_content_type="text/markdown",
@@ -38,9 +38,11 @@ setup(
         "jsonschema>=4.0.0",
         "pyyaml>=6.0",
         "colorama>=0.4.0",
-        "rhylthyme-spec>=0.2.0a0",
+        "rhylthyme-spec>=0.2.1a0",
     ],
     extras_require={
+        # Instrument steps on galago-tools lab instruments (--workcell)
+        "galago": ["rhylthyme-galago>=0.1.0a0"],
         "dev": [
             # Testing framework
             "pytest>=6.0.0",

{rhylthyme_cli_runner-0.2.5a0 → rhylthyme_cli_runner-0.2.8a0}/src/rhylthyme_cli_runner/__init__.py

@@ -6,7 +6,7 @@ This package provides the command-line interface for running and validating
 Rhylthyme real-time program schedules.
 """
 
-__version__ = "0.2.5a0"
+__version__ = "0.2.8a0"
 __author__ = "Rhylthyme Team"
 __description__ = "CLI runner for Rhylthyme real-time program schedules"
 

{rhylthyme_cli_runner-0.2.5a0 → rhylthyme_cli_runner-0.2.8a0}/src/rhylthyme_cli_runner/cli.py

@@ -105,7 +105,18 @@ def cli(ctx, environments_dir):
     is_flag=True,
     help="Enforce all tasks must be defined in resourceConstraints (strict mode)",
 )
-def validate(program_files, schema, environment, verbose, json_output, strict):
+@click.option(
+    "--workcell",
+    type=click.Path(exists=True, dir_okay=False),
+    default=None,
+    help=(
+        "Workcell file: check instrument steps against its galago tools "
+        "(tool names, types, commands and params)"
+    ),
+)
+def validate(
+    program_files, schema, environment, verbose, json_output, strict, workcell
+):
     """
     Validate one or more program files against the schema.
 
@@ -115,6 +126,8 @@ def validate(program_files, schema, environment, verbose, json_output, strict):
     Use --json to get machine-readable output for CI or scripting.
     Use --strict to require all tasks used in steps/buffers to be defined in resourceConstraints.
     Use -e/--environment to validate against specific environment constraints.
+    Use --workcell to check instrument steps against a lab's galago tools;
+    without it, commands are checked against each step's toolType.
     """
     # Set up environment for validation if specified
     if environment:
@@ -165,7 +178,7 @@ def validate(program_files, schema, environment, verbose, json_output, strict):
     all_valid = True
     for program_file in program_files:
         success = validate_program_file(
-            program_file, schema, verbose, json_output, strict
+            program_file, schema, verbose, json_output, strict, workcell
         )
         if not success:
             all_valid = False
@@ -256,6 +269,28 @@ def validate(program_files, schema, environment, verbose, json_output, strict):
         "answers, which are what the record stores in context.userTags"
     ),
 )
+@click.option(
+    "--workcell",
+    type=click.Path(exists=True, dir_okay=False),
+    default=None,
+    help=(
+        "Workcell file mapping the program's instrument tools to galago-tools "
+        "servers; required for programs with instrument steps"
+    ),
+)
+@click.option(
+    "--live",
+    is_flag=True,
+    help=(
+        "Run instrument steps on real hardware instead of galago's simulated "
+        "mode; shows what will run and asks first"
+    ),
+)
+@click.option(
+    "--confirm-live",
+    is_flag=True,
+    help="Answer the --live question in advance (for scripts)",
+)
 def run(
     program_file,
     schema,
@@ -270,6 +305,9 @@ def run(
     history_file,
     no_history,
     predict_context,
+    workcell,
+    live,
+    confirm_live,
 ):
     """
     Run a program file with the interactive UI.
@@ -296,6 +334,11 @@ def run(
     --history FILE to read a specific corpus, --no-history to turn it off,
     and --predict-context KEY=VALUE to predict for a context other than the
     factor answers.
+
+    Programs with instrument steps need --workcell FILE (galago-tools servers,
+    via rhylthyme-galago). Tools run in galago's simulated mode unless you pass
+    --live, which lists the tools and commands and asks you to type 'live'
+    before anything is configured; --confirm-live answers for scripts.
     """
     run_program(
         program_file,
@@ -311,6 +354,9 @@ def run(
         history_file=history_file,
         use_history=not no_history,
         predict_context=predict_context,
+        workcell=workcell,
+        live=live,
+        confirm_live=confirm_live,
     )
 
 
@@ -324,7 +370,16 @@ def run(
 @click.option(
     "--verbose", "-v", is_flag=True, help="Show detailed planning information"
 )
-def plan(input_file, output_file, environment, verbose):
+@click.option(
+    "--workcell",
+    type=click.Path(exists=True, dir_okay=False),
+    default=None,
+    help=(
+        "Workcell file: estimate instrument steps that have no duration from "
+        "their tools' EstimateDuration"
+    ),
+)
+def plan(input_file, output_file, environment, verbose, workcell):
     """
     Optimize a program schedule to reduce resource contention.
 
@@ -333,9 +388,17 @@ def plan(input_file, output_file, environment, verbose):
     starts to reduce contention at critical junctures.
 
     The optimized program is saved to the specified output file.
+
+    Instrument steps without a duration get an estimated one (flagged in
+    metadata.durationEstimate): from the tool with --workcell, else from a
+    duration-like command param, else a default.
     """
     success = plan_program(
-        input_file, output_file, verbose, environment_file=environment
+        input_file,
+        output_file,
+        verbose,
+        environment_file=environment,
+        workcell=workcell,
     )
     if not success:
         sys.exit(1)

{rhylthyme_cli_runner-0.2.5a0 → rhylthyme_cli_runner-0.2.8a0}/src/rhylthyme_cli_runner/history/recorder.py

@@ -13,6 +13,8 @@ the events it emits are:
 ``step_aborted``     {step_id, time, reason}
 ``program_paused``   {time, wall_time}
 ``program_resumed``  {time, wall_time, paused_seconds}
+``program_aborted``  {time, reason}  (reason goes to ``context.abortReason``)
+``instrument_reply`` {step_id, time, ok, code, errorMessage, metadata}
 
 All ``time`` values are the runner's program clock (an epoch float that
 advances at ``time_scale``); the record stores them as seconds from the
@@ -217,6 +219,8 @@ class RunRecorder:
         self.context: Dict[str, Any] = self._build_context()
 
         self.actuals: Dict[str, Dict[str, Any]] = {}
+        # step id -> {tool, command, replies: [{attempt, at, code, ...}]}
+        self.instrument_log: Dict[str, Dict[str, Any]] = {}
         self.paused_seconds: Dict[str, float] = {sid: 0.0 for sid in self.step_order}
         self._pause_wall: Optional[float] = None
         self._paused_running: List[str] = []
@@ -271,6 +275,31 @@ class RunRecorder:
             entry.setdefault("start", data["time"])
             entry["end"] = data["time"]
             entry["endedBy"] = "abort"
+        elif event_type == "instrument_reply":
+            sid = data["step_id"]
+            step = getattr(self.runner, "steps", {}).get(sid)
+            instrument = (getattr(step, "instrument", None) or {}) if step else {}
+            log = self.instrument_log.setdefault(
+                sid,
+                {
+                    "tool": str(instrument.get("tool", "")),
+                    "command": str(instrument.get("command", "")),
+                    "replies": [],
+                },
+            )
+            reply: Dict[str, Any] = {
+                "attempt": getattr(step, "instrument_attempts", 0)
+                or len(log["replies"]) + 1,
+                "at": data["time"],
+                "code": str(data.get("code", "")),
+            }
+            if data.get("errorMessage"):
+                reply["errorMessage"] = str(data["errorMessage"])
+            if data.get("metadata"):
+                reply["metadata"] = copy.deepcopy(data["metadata"])
+            log["replies"].append(reply)
+        elif event_type == "program_aborted":
+            self.context["abortReason"] = data.get("reason") or "aborted"
         elif event_type == "program_paused":
             self._pause_wall = data.get("wall_time", time.time())
             self._paused_running = list(getattr(self.runner, "running_steps", []))
@@ -344,6 +373,13 @@ class RunRecorder:
                     entry["endedBy"] = actual.get("endedBy", "executor")
                 if "triggerFiredAt" in actual:
                     entry["triggerFiredAt"] = rel(actual["triggerFiredAt"])
+            log = self.instrument_log.get(sid)
+            if log:
+                entry["instrument"] = {
+                    "tool": log["tool"],
+                    "command": log["command"],
+                    "replies": [dict(r, at=rel(r["at"])) for r in log["replies"]],
+                }
             steps.append(entry)
 
         started_iso = _iso_utc(start_epoch) if start_epoch is not None else None

{rhylthyme_cli_runner-0.2.5a0 → rhylthyme_cli_runner-0.2.8a0}/src/rhylthyme_cli_runner/import_cli.py

@@ -74,6 +74,10 @@ def _import_one(importer, source: str, text: Optional[str]):
         if hasattr(importer, "allow_local_files"):
             importer.allow_local_files = True
         return importer.import_from_url(str(path))
+    if not source.startswith(("http://", "https://")) and (
+        path.suffix or "/" in source
+    ):
+        raise click.ClickException(f"No such file: {source}")
     return importer.import_from_url(source)
 
 
@@ -130,8 +134,21 @@ def _validation(program: dict):
 @click.option(
     "--no-validate", is_flag=True, help="Skip validation of the imported program."
 )
+@click.option(
+    "--review",
+    "do_review",
+    is_flag=True,
+    help="Have a model read the import against its source and report what looks wrong (needs `rhylthyme login`).",
+)
 def import_command(
-    source, importer_name, output, to_stdout, do_publish, open_url, no_validate
+    source,
+    importer_name,
+    output,
+    to_stdout,
+    do_publish,
+    open_url,
+    no_validate,
+    do_review,
 ):
     """Import a recipe, protocol or deck as a program.
 
@@ -141,6 +158,7 @@ def import_command(
     .cook or .pptx file. `-` reads the source text from stdin (with -i).
       rhylthyme import https://www.seriouseats.com/the-best-chili-recipe
       rhylthyme import 52772 -i themealdb --publish
+      rhylthyme import recipe.cook -i cooklang --review   # a second opinion on durations, order, gaps
       rhylthyme import https://raw.githubusercontent.com/Opentrons/Protocols/develop/protocols/007992/rna_isolation.ot2.apiv2.py
       rhylthyme importers          # what is installed
     """
@@ -153,8 +171,22 @@ def import_command(
             )
         text = sys.stdin.read()
     importer = _pick(registry, source, importer_name)
+    token = None
+    if do_review:
+        # Before any work: the review needs an account, say so now.
+        from .remote import auth
+
+        try:
+            token = auth.access_token()
+        except auth.AuthError as e:
+            raise click.ClickException(
+                f"{e} (--review sends the import to a model on the server, which needs your account.)"
+            )
     click.echo(f"Importing with {importer.name}…", err=True)
     result = _import_one(importer, source, text)
+    source_text = (
+        text if text is not None else _source_text_for_review(importer, source)
+    )
     if not result.success:
         raise click.ClickException(result.error or "import failed")
     program = result.program
@@ -163,9 +195,10 @@ def import_command(
         v = _validation(program)
         errors = v.get("errors") or v.get("logic_errors") or []
         if not v.get("is_valid", v.get("valid", True)):
-            for e in errors[:8]:
+            for finding in errors[:8]:
                 click.echo(
-                    f"  ✗ {e if isinstance(e, str) else e.get('message', e)}", err=True
+                    f"  ✗ {finding if isinstance(finding, str) else finding.get('message', finding)}",
+                    err=True,
                 )
             raise click.ClickException(
                 "The imported program does not validate; not published. Re-run with --no-validate to keep it anyway."
@@ -187,6 +220,14 @@ def import_command(
         target.write_text(payload + "\n")
         click.echo(f"Saved {target}", err=True)
 
+    if do_review:
+        _review(
+            program,
+            token,
+            source_text=source_text,
+            source_url=source if source.startswith(("http://", "https://")) else None,
+        )
+
     if do_publish:
         from .remote.cli import publish as publish_command
 
@@ -208,6 +249,67 @@ def import_command(
             Path(tmp_path).unlink(missing_ok=True)
 
 
+def _source_text_for_review(importer, source: str) -> Optional[str]:
+    """The text the import came from, when the CLI has it: a local file, or
+    a URL the CLI fetched for a text importer. Recipe-site imports do not
+    keep the page, so the reviewer gets the URL instead."""
+    path = Path(source)
+    if path.is_file() and path.suffix.lower() in (".cook", ".py", ".txt", ".md"):
+        try:
+            return path.read_text()
+        except OSError:
+            return None
+    if (
+        source.startswith(("http://", "https://"))
+        and hasattr(importer, "import_from_source")
+        and not getattr(importer, "supported_domains", None)
+    ):
+        try:
+            from .remote.cli import _fetch_bytes
+
+            return _fetch_bytes(source).decode("utf-8")
+        except Exception:  # noqa: BLE001
+            return None
+    return None
+
+
+def _review(
+    program: dict, token: str, *, source_text: Optional[str], source_url: Optional[str]
+) -> None:
+    from .remote import mcp_client as MC
+
+    click.echo("Reviewing…", err=True)
+    client = MC.McpClient(url=MC.endpoint_for(None))
+    args = {"program": program, "token": token}
+    if source_text:
+        args["source_text"] = source_text
+    elif source_url:
+        args["source_url"] = source_url
+    try:
+        result = client.call_tool("review_program", args, timeout=150)
+    except MC.ToolError as e:
+        raise click.ClickException(f"Review failed: {e.text}")
+    except MC.McpError as e:
+        raise click.ClickException(f"Review failed: {e}")
+    review = result.structured or {}
+    findings = review.get("findings") or []
+    mark = {"error": "✗", "warning": "!", "note": "·"}
+    click.echo("")
+    click.echo(
+        review.get("summary")
+        or ("Review: no problems found." if not findings else "Review:")
+    )
+    for f in findings:
+        where = f" [{f['stepId']}]" if f.get("stepId") else ""
+        click.echo(f"  {mark.get(f.get('severity'), '·')}{where} {f.get('message')}")
+        if f.get("suggestion"):
+            click.echo(f"      → {f['suggestion']}")
+    if findings:
+        click.echo(
+            "\nThe file is unchanged; edit it and `rhylthyme validate` again.", err=True
+        )
+
+
 @click.command("search")
 @click.argument("query")
 @click.option(