runops 0.2.0__py3-none-any.whl

runops/cli/analyze.py

@@ -0,0 +1,222 @@
+"""CLI commands for analysis: summarize, collect, and plot."""
+
+from __future__ import annotations
+
+import json
+from pathlib import Path
+
+import typer
+
+from runops.cli.run_lookup import resolve_run_or_cwd
+from runops.core.actions import ActionStatus, execute_action
+from runops.core.analysis import (
+    list_survey_plot_recipes,
+    load_survey_plot_table,
+    render_survey_plot,
+    resolve_survey_plot_recipe,
+)
+from runops.core.exceptions import SimctlError
+
+
+def summarize(
+    run: str = typer.Argument(None, help="Run directory or run_id (defaults to cwd)."),
+) -> None:
+    """Generate or update analysis/summary.json for a run."""
+    run_dir = resolve_run_or_cwd(run, search_dir=Path.cwd())
+
+    try:
+        result = execute_action("summarize_run", run_dir=run_dir)
+    except (OSError, TypeError, json.JSONDecodeError, SimctlError) as e:
+        typer.echo(f"Error generating summary: {e}", err=True)
+        raise typer.Exit(code=1) from None
+
+    if result.status is not ActionStatus.SUCCESS:
+        typer.echo(f"Error generating summary: {result.message}", err=True)
+        raise typer.Exit(code=1)
+
+    script_path = str(result.data.get("script_path", ""))
+    if script_path:
+        typer.echo(f"  Applied script: {Path(script_path).name}")
+    for warning in result.data.get("warnings", []):
+        typer.echo(f"Warning: {warning}", err=True)
+
+    summary = result.data.get("summary", {})
+    run_id = result.data.get("run_id", "???")
+    typer.echo(f"Summary written: {result.data.get('summary_path', '')}")
+    typer.echo(f"  Run: {run_id}")
+    typer.echo(f"  Keys: {', '.join(sorted(summary.keys()))}")
+
+
+def collect(
+    survey_dir: Path = typer.Argument(None, help="Survey directory (defaults to cwd)."),
+) -> None:
+    """Collect summaries from all runs in a survey into aggregate artifacts."""
+    if survey_dir is None:
+        survey_dir = Path.cwd()
+    if not survey_dir.is_dir():
+        typer.echo(f"Error: directory not found: {survey_dir}", err=True)
+        raise typer.Exit(code=1)
+
+    try:
+        result = execute_action("collect_survey", survey_dir=survey_dir)
+    except (OSError, TypeError, json.JSONDecodeError, SimctlError) as e:
+        typer.echo(f"Error collecting summaries: {e}", err=True)
+        raise typer.Exit(code=1) from None
+
+    if result.status is not ActionStatus.SUCCESS:
+        typer.echo(f"Error collecting summaries: {result.message}", err=True)
+        raise typer.Exit(code=1)
+
+    typer.echo(f"Collected {result.message.removeprefix('Collected ').strip()}")
+    typer.echo(f"  CSV: {result.data.get('csv_path', '')}")
+    typer.echo(f"  JSON: {result.data.get('json_path', '')}")
+    typer.echo(f"  Figures: {result.data.get('figures_path', '')}")
+    typer.echo(f"  Report: {result.data.get('report_path', '')}")
+    generated_summaries = int(result.data.get("generated_summaries", 0))
+    if generated_summaries > 0:
+        typer.echo(
+            f"  Auto-summarized: {generated_summaries} completed runs during collect"
+        )
+    missing_summaries = int(result.data.get("missing_summaries", 0))
+    if missing_summaries > 0:
+        typer.echo(f"  ({missing_summaries} runs missing summary.json)")
+    for warning in result.data.get("warnings", []):
+        typer.echo(f"Warning: {warning}", err=True)
+
+
+def plot(
+    survey_dir: Path = typer.Argument(None, help="Survey directory (defaults to cwd)."),
+    x: str | None = typer.Option(None, "--x", help="Column for the x-axis."),
+    y: str | None = typer.Option(None, "--y", help="Column for the y-axis."),
+    recipe: str = typer.Option(
+        "",
+        "--recipe",
+        help="Adapter-aware plot recipe name.",
+    ),
+    kind: str = typer.Option(
+        "auto",
+        "--kind",
+        help="Plot kind: auto, line, scatter, or bar.",
+    ),
+    group_by: str = typer.Option(
+        "",
+        "--group",
+        help="Optional column used to split data into multiple series.",
+    ),
+    title: str = typer.Option("", "--title", help="Optional plot title."),
+    output: Path | None = typer.Option(
+        None,
+        "--output",
+        "-o",
+        help="Output image path (default: summary/plots/<y>_vs_<x>.png).",
+    ),
+    list_columns: bool = typer.Option(
+        False,
+        "--list-columns",
+        help="Print available plot columns and exit.",
+    ),
+    list_recipes: bool = typer.Option(
+        False,
+        "--list-recipes",
+        help="Print available adapter plot recipes and exit.",
+    ),
+) -> None:
+    """Render a survey plot from explicit columns or an adapter recipe."""
+    if survey_dir is None:
+        survey_dir = Path.cwd()
+    if not survey_dir.is_dir():
+        typer.echo(f"Error: directory not found: {survey_dir}", err=True)
+        raise typer.Exit(code=1)
+
+    if list_columns:
+        try:
+            table = load_survey_plot_table(survey_dir)
+        except (OSError, TypeError, json.JSONDecodeError, SimctlError) as e:
+            typer.echo(f"Error loading plot columns: {e}", err=True)
+            raise typer.Exit(code=1) from None
+
+        typer.echo("Available columns:")
+        for column in table.columns:
+            typer.echo(f"  {column}")
+        return
+
+    if list_recipes:
+        try:
+            recipes = list_survey_plot_recipes(survey_dir)
+        except (OSError, TypeError, json.JSONDecodeError, SimctlError) as e:
+            typer.echo(f"Error loading plot recipes: {e}", err=True)
+            raise typer.Exit(code=1) from None
+
+        if not recipes:
+            typer.echo("No adapter plot recipes available for this survey.")
+            return
+
+        typer.echo("Available plot recipes:")
+        for item in recipes:
+            x_candidates = ", ".join(item.x_candidates)
+            y_candidates = ", ".join(item.y_candidates)
+            group_candidates = (
+                ", ".join(item.group_by_candidates)
+                if item.group_by_candidates
+                else "(none)"
+            )
+            typer.echo(f"  {item.name} [{item.adapter}]")
+            if item.description:
+                typer.echo(f"    {item.description}")
+            typer.echo(f"    x: {x_candidates}")
+            typer.echo(f"    y: {y_candidates}")
+            typer.echo(f"    kind: {item.kind}")
+            typer.echo(f"    group_by: {group_candidates}")
+        return
+
+    resolved_recipe = None
+    if recipe:
+        try:
+            resolved_recipe = resolve_survey_plot_recipe(survey_dir, recipe)
+        except (OSError, TypeError, json.JSONDecodeError, SimctlError) as e:
+            typer.echo(f"Error resolving plot recipe: {e}", err=True)
+            raise typer.Exit(code=1) from None
+
+    if not x and resolved_recipe is not None:
+        x = resolved_recipe.x
+    if not y and resolved_recipe is not None:
+        y = resolved_recipe.y
+    if not group_by and resolved_recipe is not None:
+        group_by = resolved_recipe.group_by
+    if kind == "auto" and resolved_recipe is not None:
+        kind = resolved_recipe.recipe.kind
+    if not title and resolved_recipe is not None:
+        title = resolved_recipe.recipe.title
+
+    if not x or not y:
+        typer.echo(
+            "Error: --x and --y are required unless --recipe, --list-columns, "
+            "or --list-recipes is used.",
+            err=True,
+        )
+        raise typer.Exit(code=1)
+
+    try:
+        result = render_survey_plot(
+            survey_dir,
+            x=x,
+            y=y,
+            kind=kind,
+            group_by=group_by,
+            title=title,
+            output_path=output,
+        )
+    except (OSError, TypeError, json.JSONDecodeError, SimctlError) as e:
+        typer.echo(f"Error rendering plot: {e}", err=True)
+        raise typer.Exit(code=1) from None
+
+    typer.echo(f"Plot written: {result.output_path}")
+    if resolved_recipe is not None:
+        typer.echo(f"  Recipe: {resolved_recipe.recipe.name}")
+    typer.echo(f"  Kind: {result.kind}")
+    typer.echo(f"  Points: {result.points_plotted}")
+    if result.generated_summaries > 0:
+        typer.echo(
+            "  Auto-summarized:"
+            f" {result.generated_summaries} completed runs during plot"
+        )

runops/cli/clone.py

@@ -0,0 +1,104 @@
+"""CLI command for cloning and deriving runs."""
+
+from __future__ import annotations
+
+import shutil
+from pathlib import Path
+from typing import Optional
+
+import typer
+
+from runops.cli.run_lookup import resolve_run_or_cwd
+from runops.core.discovery import collect_existing_run_ids
+from runops.core.exceptions import SimctlError
+from runops.core.manifest import ManifestData, read_manifest, write_manifest
+from runops.core.run import next_run_id
+from runops.core.state import RunState
+
+
+def clone(
+    run: str = typer.Argument(None, help="Run directory or run_id (defaults to cwd)."),
+    dest: Optional[Path] = typer.Option(
+        None, "--dest", "-d", help="Destination directory (defaults to cwd)."
+    ),
+    set_params: Optional[list[str]] = typer.Option(
+        None, "--set", help="Override parameters as key=value."
+    ),
+) -> None:
+    """Clone a run, optionally modifying parameters."""
+    search_dir = Path.cwd()
+    source_dir = resolve_run_or_cwd(run, search_dir=search_dir)
+
+    try:
+        source_manifest = read_manifest(source_dir)
+    except SimctlError as e:
+        typer.echo(f"Error reading manifest: {e}", err=True)
+        raise typer.Exit(code=1) from None
+
+    # Determine destination parent directory
+    dest_parent = dest or source_dir.parent
+
+    # Generate new run_id, searching both cwd and dest for existing IDs
+    try:
+        existing_ids = collect_existing_run_ids(search_dir)
+        if dest_parent != search_dir:
+            existing_ids |= collect_existing_run_ids(dest_parent)
+        new_run_id = next_run_id(existing_ids)
+    except SimctlError as e:
+        typer.echo(f"Error generating run_id: {e}", err=True)
+        raise typer.Exit(code=1) from None
+
+    new_run_dir = dest_parent / new_run_id
+
+    try:
+        # Create run directory structure
+        new_run_dir.mkdir(parents=True)
+        for subdir in ("input", "submit", "work", "analysis", "status"):
+            (new_run_dir / subdir).mkdir(exist_ok=True)
+
+        # Copy input files from source
+        source_input = source_dir / "input"
+        if source_input.is_dir():
+            dest_input = new_run_dir / "input"
+            # Remove the empty dir we just created, then copy tree
+            dest_input.rmdir()
+            shutil.copytree(source_input, dest_input)
+
+        # Copy submit/ directory (including job.sh) from source
+        source_submit = source_dir / "submit"
+        if source_submit.is_dir():
+            dest_submit = new_run_dir / "submit"
+            dest_submit.rmdir()
+            shutil.copytree(source_submit, dest_submit)
+
+        # Build new manifest
+        source_run_id = source_manifest.run.get("id", "")
+        new_manifest = ManifestData.from_dict(source_manifest.to_dict())
+        new_manifest.run["id"] = new_run_id
+        new_manifest.run["status"] = RunState.CREATED.value
+        new_manifest.run["display_name"] = f"clone of {source_run_id}"
+        new_manifest.origin["parent_run"] = source_run_id
+
+        # Apply parameter overrides
+        if set_params:
+            for param in set_params:
+                if "=" not in param:
+                    typer.echo(
+                        f"Error: invalid --set format {param!r}, expected key=value",
+                        err=True,
+                    )
+                    raise typer.Exit(code=1)
+                key, value = param.split("=", 1)
+                new_manifest.params_snapshot[key.strip()] = value.strip()
+
+        write_manifest(new_run_dir, new_manifest)
+
+    except SimctlError as e:
+        typer.echo(f"Error creating clone: {e}", err=True)
+        raise typer.Exit(code=1) from None
+    except OSError as e:
+        typer.echo(f"Error creating clone directory: {e}", err=True)
+        raise typer.Exit(code=1) from None
+
+    typer.echo(f"Cloned {source_run_id} -> {new_run_id}")
+    typer.echo(f"  Path: {new_run_dir}")

runops/cli/config.py

@@ -0,0 +1,217 @@
+"""CLI commands for project configuration management."""
+
+from __future__ import annotations
+
+import io
+import logging
+import sys
+from pathlib import Path
+from typing import Annotated, Any, Optional
+
+import typer
+
+if sys.version_info >= (3, 11):
+    import tomllib
+else:
+    import tomli as tomllib
+
+try:
+    import tomli_w
+except ImportError:
+    tomli_w = None  # type: ignore[assignment]
+
+logger = logging.getLogger(__name__)
+
+config_app = typer.Typer(
+    name="config",
+    help="View and modify project configuration.",
+    no_args_is_help=True,
+)
+
+
+def _find_project_dir(path: Path | None) -> Path:
+    """Resolve and validate the project directory."""
+    project_dir = (path or Path.cwd()).resolve()
+    if not (project_dir / "runops.toml").exists():
+        typer.echo(f"Error: runops.toml not found in {project_dir}")
+        raise typer.Exit(code=1)
+    return project_dir
+
+
+def _load_toml(path: Path) -> dict[str, Any]:
+    """Load a TOML file."""
+    with open(path, "rb") as f:
+        return tomllib.load(f)
+
+
+def _write_toml(path: Path, data: dict[str, Any]) -> None:
+    """Write a TOML file."""
+    if tomli_w is None:
+        msg = "tomli_w is required to write TOML files"
+        raise RuntimeError(msg)
+    with open(path, "wb") as f:
+        tomli_w.dump(data, f)
+
+
+def _toml_to_str(data: dict[str, Any]) -> str:
+    """Serialize dict to TOML string."""
+    if tomli_w is None:
+        msg = "tomli_w is required to serialize TOML"
+        raise RuntimeError(msg)
+    buf = io.BytesIO()
+    tomli_w.dump(data, buf)
+    return buf.getvalue().decode("utf-8")
+
+
+@config_app.command("show")
+def show(
+    path: Annotated[
+        Optional[Path],
+        typer.Option("--path", "-p", help="Project directory."),
+    ] = None,
+) -> None:
+    """Display current project configuration."""
+    project_dir = _find_project_dir(path)
+
+    # runops.toml
+    typer.echo("=== runops.toml ===")
+    simproject = project_dir / "runops.toml"
+    typer.echo(simproject.read_text(encoding="utf-8"))
+
+    # simulators.toml
+    typer.echo("=== simulators.toml ===")
+    simulators = project_dir / "simulators.toml"
+    if simulators.exists():
+        typer.echo(simulators.read_text(encoding="utf-8"))
+    else:
+        typer.echo("(not found)\n")
+
+    # launchers.toml
+    typer.echo("=== launchers.toml ===")
+    launchers = project_dir / "launchers.toml"
+    if launchers.exists():
+        typer.echo(launchers.read_text(encoding="utf-8"))
+    else:
+        typer.echo("(not found)\n")
+
+
+@config_app.command("add-simulator")
+def add_simulator(
+    simulator: Annotated[
+        Optional[str],
+        typer.Argument(help="Simulator name (e.g. emses, beach)."),
+    ] = None,
+    path: Annotated[
+        Optional[Path],
+        typer.Option("--path", "-p", help="Project directory."),
+    ] = None,
+) -> None:
+    """Add a simulator to simulators.toml (interactive)."""
+    import runops.adapters  # noqa: F401
+    from runops.adapters.registry import get_global_registry
+
+    project_dir = _find_project_dir(path)
+    registry = get_global_registry()
+    available = registry.list_adapters()
+
+    # Select simulator
+    if not simulator:
+        typer.echo("\nAvailable simulators:")
+        for i, name in enumerate(available, 1):
+            typer.echo(f"  {i}. {name}")
+
+        selection = typer.prompt("\nSelect simulator (number or name)")
+        if selection.isdigit():
+            idx = int(selection) - 1
+            if 0 <= idx < len(available):
+                simulator = available[idx]
+            else:
+                typer.echo("Invalid selection.")
+                raise typer.Exit(code=1)
+        else:
+            simulator = selection
+
+    if simulator not in available:
+        typer.echo(
+            f"Unknown simulator: '{simulator}'. Available: {', '.join(available)}"
+        )
+        raise typer.Exit(code=1)
+
+    # Load existing config
+    sim_path = project_dir / "simulators.toml"
+    existing = _load_toml(sim_path) if sim_path.exists() else {"simulators": {}}
+
+    if "simulators" not in existing:
+        existing["simulators"] = {}
+
+    if simulator in existing["simulators"] and not typer.confirm(
+        f"'{simulator}' already exists. Overwrite?", default=False
+    ):
+        typer.echo("Cancelled.")
+        raise typer.Exit()
+
+    # Interactive config
+    adapter_cls = registry.get(simulator)
+    config = adapter_cls.interactive_config()
+
+    existing["simulators"][simulator] = config
+    _write_toml(sim_path, existing)
+
+    typer.echo(f"\nAdded simulator '{simulator}' to simulators.toml:")
+    typer.echo(_toml_to_str({"simulators": {simulator: config}}))
+
+
+@config_app.command("add-launcher")
+def add_launcher(
+    path: Annotated[
+        Optional[Path],
+        typer.Option("--path", "-p", help="Project directory."),
+    ] = None,
+) -> None:
+    """Add a launcher profile to launchers.toml (interactive)."""
+    project_dir = _find_project_dir(path)
+
+    typer.echo("\nAvailable launcher types:")
+    typer.echo("  1. srun (Slurm)")
+    typer.echo("  2. mpirun (OpenMPI)")
+    typer.echo("  3. mpiexec (MPICH)")
+
+    selection = typer.prompt("\nSelect launcher type (number or name)")
+    launcher_map = {"1": "srun", "2": "mpirun", "3": "mpiexec"}
+    launcher_type = launcher_map.get(selection.strip(), selection.strip())
+
+    if launcher_type not in ("srun", "mpirun", "mpiexec"):
+        typer.echo(f"Unknown launcher type: '{launcher_type}'")
+        raise typer.Exit(code=1)
+
+    launcher_name = typer.prompt("Launcher profile name", default="default")
+
+    config: dict[str, Any] = {"type": launcher_type}
+
+    extra_args = typer.prompt(
+        f"Extra {launcher_type} arguments (Enter to skip)", default=""
+    )
+    if extra_args:
+        config["args"] = extra_args
+
+    # Load existing
+    launcher_path = project_dir / "launchers.toml"
+    if launcher_path.exists():
+        existing = _load_toml(launcher_path)
+    else:
+        existing = {"launchers": {}}
+
+    if "launchers" not in existing:
+        existing["launchers"] = {}
+
+    if launcher_name in existing["launchers"] and not typer.confirm(
+        f"'{launcher_name}' already exists. Overwrite?", default=False
+    ):
+        typer.echo("Cancelled.")
+        raise typer.Exit()
+
+    existing["launchers"][launcher_name] = config
+    _write_toml(launcher_path, existing)
+
+    typer.echo(f"\nAdded launcher '{launcher_name}' to launchers.toml:")
+    typer.echo(_toml_to_str({"launchers": {launcher_name: config}}))

runops/cli/context.py

@@ -0,0 +1,56 @@
+"""CLI command: runops context — project context bundle for agents."""
+
+from __future__ import annotations
+
+import json
+from pathlib import Path
+
+import typer
+
+from runops.core.project import find_project_root
+
+
+def context(
+    directory: Path = typer.Argument(
+        Path("."),
+        help="Project directory (default: cwd).",
+        exists=True,
+    ),
+    output_json: bool = typer.Option(
+        True,
+        "--json/--no-json",
+        help="Output as JSON (default: true).",
+    ),
+) -> None:
+    """Show project context bundle (designed for AI agents)."""
+    from runops.core.context import build_project_context
+
+    root = find_project_root(directory)
+    ctx = build_project_context(root)
+
+    if output_json:
+        typer.echo(json.dumps(ctx, indent=2, ensure_ascii=False))
+    else:
+        # Simple text summary
+        proj = ctx.get("project", {})
+        typer.echo(f"Project: {proj.get('name', '?')}")
+        typer.echo(f"Root: {proj.get('root', '?')}")
+
+        camp = ctx.get("campaign", {})
+        if camp.get("hypothesis"):
+            typer.echo(f"Hypothesis: {camp['hypothesis']}")
+
+        sims = ctx.get("simulators", [])
+        if sims:
+            typer.echo(f"Simulators: {', '.join(sims)}")
+
+        runs = ctx.get("runs", {})
+        if runs.get("total", 0) > 0:
+            parts = [f"{k}={v}" for k, v in runs.items()]
+            typer.echo(f"Runs: {', '.join(parts)}")
+
+        failures = ctx.get("recent_failures", [])
+        if failures:
+            typer.echo(f"Recent failures ({len(failures)}):")
+            for f in failures:
+                typer.echo(f"  {f['run_id']}: {f['reason']}")