mcli-framework 8.0.56__tar.gz → 8.0.58__tar.gz

{mcli_framework-8.0.56/src/mcli_framework.egg-info → mcli_framework-8.0.58}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: mcli-framework
-Version: 8.0.56
+Version: 8.0.58
 Summary: Portable workflow framework - transform any script into a versioned, schedulable command. Store in ~/.mcli/workflows/, version with lockfile, run as daemon or cron job.
 Author-email: Luis Fernandez de la Vara <luis@lefv.io>
 Maintainer-email: Luis Fernandez de la Vara <luis@lefv.io>

{mcli_framework-8.0.56 → mcli_framework-8.0.58}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "mcli-framework"
-version = "8.0.56"
+version = "8.0.58"
 description = "Portable workflow framework - transform any script into a versioned, schedulable command. Store in ~/.mcli/workflows/, version with lockfile, run as daemon or cron job."
 readme = "README.md"
  requires-python = ">=3.10"

{mcli_framework-8.0.56 → mcli_framework-8.0.58}/src/mcli/self/self_cmd.py

@@ -141,7 +141,7 @@ def restore_command_state(hash_value):
 
 
 # On CLI startup, check and update lockfile if needed
-# NOTE: The commands group has been moved to mcli.app.commands_cmd for better organization
+# NOTE: The commands group was removed in the v8.0.0 CLI simplification
 
 
 def check_and_update_command_lockfile():
@@ -217,7 +217,7 @@ def {name}_command(name: str = "World"):
     return template
 
 
-# NOTE: search command has been moved to mcli.app.commands_cmd for better organization
+# NOTE: search command was removed in the v8.0.0 CLI simplification
 
 
 def collect_commands() -> list[dict[str, Any]]:
@@ -471,7 +471,7 @@ logger = get_logger()
             pass
 
 
-# NOTE: extract-workflow-commands has been moved to mcli.app.commands_cmd for better organization
+# NOTE: extract-workflow-commands was removed in the v8.0.0 CLI simplification
 
 
 @self_app.command("version")
@@ -800,7 +800,7 @@ try:
 except ImportError as e:
     logger.debug(f"Could not load release-notes command: {e}")
 
-# NOTE: store command has been moved to mcli.app.commands_cmd for better organization
+# NOTE: store command was removed in the v8.0.0 CLI simplification
 
 # This part is important to make the command available to the CLI
 if __name__ == "__main__":

mcli_framework-8.0.58/src/mcli/workflow/ci/act_runner.py

@@ -0,0 +1,242 @@
+"""Run `act` locally and classify the outcome for the PR gate."""
+
+from __future__ import annotations
+
+import platform
+import shutil
+import subprocess
+import sys
+import time
+from enum import Enum
+from pathlib import Path
+
+# Docker Hub returns these when the unauthenticated image-pull rate limit is hit.
+# act surfaces them while pulling the runner image — this is an environment
+# problem, NOT a test failure, so it must not hard-block a push.
+_RATE_LIMIT_MARKERS = (
+    "toomanyrequests",
+    "you have reached your unauthenticated pull rate limit",
+    "pull rate limit",
+)
+
+# act emits this when no job matches the requested event (e.g. a
+# workflow_dispatch-only workflow queried for pull_request). That is a no-op,
+# not a failure, so the gate must treat it as PASS rather than block the push.
+_NO_STAGES_MARKERS = ("could not find any stages to run",)
+
+# Backoff (seconds) between docker rate-limit retries; the last value repeats.
+_RETRY_BACKOFF = (15, 45)
+_MAX_RETRIES = 2
+
+# Canonical CI entrypoint created by `mcli ci migrate`: ci.yml's `primary` job
+# runs on `workflow_dispatch` and calls the reusable `_ci-jobs.yml` with the
+# `runner_labels` input. The reusable workflow CANNOT run standalone (its
+# `runs-on: ${{ fromJSON(inputs.runner_labels) }}` has no value), so preflight
+# must drive it through this caller.
+_DISPATCH_WORKFLOW = Path(".github/workflows/ci.yml")
+_DISPATCH_JOB = "primary"
+
+
+class PreflightResult(Enum):
+    PASS = "pass"
+    FAIL = "fail"
+    UNREACHABLE = "unreachable"
+
+
+def _is_docker_rate_limited(output: str) -> bool:
+    low = (output or "").lower()
+    return any(marker in low for marker in _RATE_LIMIT_MARKERS)
+
+
+def _has_no_stages(output: str) -> bool:
+    low = (output or "").lower()
+    return any(marker in low for marker in _NO_STAGES_MARKERS)
+
+
+def act_available() -> bool:
+    return shutil.which("act") is not None
+
+
+# Preferred over act when present: a repo-defined `make ci-native` target runs
+# the same gates directly on the host toolchain. On Apple-silicon (and any host
+# without nested-virt) act's amd64 emulation under podman is flaky for heavy
+# jobs (container-vanish races, action-clone failures), so a native run is both
+# faster and more reliable. Repos opt in simply by defining the target.
+_NATIVE_GATE = "ci-native"
+
+
+def native_gate_available() -> bool:
+    """True if the repo defines a `make ci-native` target (preferred over act)."""
+    try:
+        proc = subprocess.run(
+            ["make", "-n", _NATIVE_GATE], capture_output=True, text=True, timeout=30
+        )
+        return proc.returncode == 0
+    except (FileNotFoundError, subprocess.TimeoutExpired):
+        return False
+
+
+def run_native() -> PreflightResult:
+    """Run the repo's native gate (`make ci-native`) on the host. PASS on exit 0,
+    FAIL otherwise. Output streams straight to the terminal (these runs are long;
+    no need to buffer)."""
+    proc = subprocess.run(["make", _NATIVE_GATE])
+    return PreflightResult.PASS if proc.returncode == 0 else PreflightResult.FAIL
+
+
+def docker_running() -> bool:
+    try:
+        proc = subprocess.run(["docker", "info"], capture_output=True, timeout=30)
+        return proc.returncode == 0
+    except (FileNotFoundError, subprocess.TimeoutExpired):
+        return False
+
+
+def probe() -> bool:
+    """Can act actually run here? Needs the binary, a live docker daemon, and `act -l`."""
+    if not act_available() or not docker_running():
+        return False
+    try:
+        proc = subprocess.run(["act", "-l"], capture_output=True, text=True, timeout=60)
+    except (FileNotFoundError, subprocess.TimeoutExpired):
+        return False
+    return proc.returncode == 0
+
+
+def default_container_arch() -> str | None:
+    """`--container-architecture` value for the host, or None to let act decide.
+
+    act's runner images are amd64. On Apple-silicon (darwin/arm64) act warns and
+    misbehaves unless told to emulate amd64, so force it; native amd64 Linux
+    needs nothing.
+    """
+    if sys.platform == "darwin" and platform.machine() in ("arm64", "aarch64"):
+        return "linux/amd64"
+    return None
+
+
+def dispatch_entrypoint() -> tuple[str, str] | None:
+    """The canonical (workflow, job) to drive via `workflow_dispatch`, or None."""
+    if _DISPATCH_WORKFLOW.exists():
+        return (str(_DISPATCH_WORKFLOW), _DISPATCH_JOB)
+    return None
+
+
+def build_act_command(
+    event: str,
+    workflow: str | None = None,
+    job: str | None = None,
+    arch: str | None = None,
+) -> list[str]:
+    cmd = ["act", event]
+    if workflow is not None:
+        cmd += ["-W", workflow]
+    if job is not None:
+        cmd += ["-j", job]
+    if arch is not None:
+        cmd += ["--container-architecture", arch]
+    if Path(".secrets").exists():
+        cmd += ["--secret-file", ".secrets"]
+    return cmd
+
+
+def _run_with_retries(
+    cmd: list[str], retries: int, backoff: tuple[int, ...]
+) -> tuple[PreflightResult, str]:
+    """Run one act command, retrying on Docker Hub rate limits. Returns the
+    classified result plus the combined output (so the caller can detect the
+    'no stages' no-op and decide whether to fall back)."""
+    attempt = 0
+    while True:
+        proc = subprocess.run(cmd, capture_output=True, text=True)
+        output = (proc.stdout or "") + (proc.stderr or "")
+        if output:
+            sys.stdout.write(output if output.endswith("\n") else output + "\n")
+
+        if proc.returncode == 0:
+            return PreflightResult.PASS, output
+
+        # No job matches this event (e.g. workflow_dispatch-only). PASS here is
+        # provisional — run_act decides whether a dispatch fallback exists.
+        if _has_no_stages(output):
+            return PreflightResult.PASS, output
+
+        if _is_docker_rate_limited(output):
+            if attempt < retries:
+                delay = backoff[min(attempt, len(backoff) - 1)]
+                sys.stdout.write(
+                    f"⚠️  Docker Hub rate limit (toomanyrequests); retrying in {delay}s "
+                    f"(attempt {attempt + 1}/{retries})…\n"
+                )
+                time.sleep(delay)
+                attempt += 1
+                continue
+            sys.stdout.write(
+                "⚠️  Docker Hub still rate-limited after retries — cannot validate "
+                "locally; allowing push (run `mcli ci preflight` again later).\n"
+            )
+            return PreflightResult.UNREACHABLE, output
+
+        return PreflightResult.FAIL, output
+
+
+def run_act(
+    event: str = "pull_request",
+    retries: int = _MAX_RETRIES,
+    backoff: tuple[int, ...] = _RETRY_BACKOFF,
+) -> PreflightResult:
+    """Run act for `event` and classify the outcome.
+
+    - exit 0 -> PASS.
+    - non-zero whose output shows a Docker Hub pull rate limit
+      (``toomanyrequests``) -> retried; if still limited, UNREACHABLE.
+    - any other non-zero exit -> FAIL.
+
+    Migrated repos are ``workflow_dispatch``-only, so the default
+    ``pull_request`` event matches no jobs. Rather than hollow-pass, fall back
+    to the canonical ``ci.yml`` ``primary`` job on ``workflow_dispatch`` (which
+    drives the reusable ``_ci-jobs.yml``) and validate for real.
+    """
+    arch = default_container_arch()
+    result, output = _run_with_retries(build_act_command(event, arch=arch), retries, backoff)
+
+    if result == PreflightResult.PASS and _has_no_stages(output):
+        entry = dispatch_entrypoint()
+        if entry is None:
+            sys.stdout.write(
+                "ℹ️  No act stages for this event and no ci.yml dispatch "
+                "entrypoint — nothing to validate; treating as pass.\n"
+            )
+            return PreflightResult.PASS
+        workflow, job = entry
+        sys.stdout.write(
+            f"ℹ️  No '{event}' stages (workflow_dispatch-only); running "
+            f"{workflow} -j {job} via workflow_dispatch…\n"
+        )
+        result, output = _run_with_retries(
+            build_act_command("workflow_dispatch", workflow=workflow, job=job, arch=arch),
+            retries,
+            backoff,
+        )
+        # If even the dispatch entrypoint has no stages, it's a genuine no-op.
+        if result == PreflightResult.PASS and _has_no_stages(output):
+            return PreflightResult.PASS
+
+    return result
+
+
+def preflight(repo_slug: str, event: str = "pull_request") -> PreflightResult:
+    """Primary gate. PASS/FAIL if act can run; UNREACHABLE if act can't start here.
+
+    `repo_slug` is accepted for symmetry and future use; the runner fallback is
+    orchestrated by the CLI layer based on runner_status.has_online_runner.
+
+    Prefers a repo-defined native gate (`make ci-native`) over act: it runs the
+    same checks on the host toolchain, avoiding act's flaky container emulation.
+    """
+    if native_gate_available():
+        sys.stdout.write("▶ Native CI gate found — running `make ci-native` (no act)…\n")
+        return run_native()
+    if not probe():
+        return PreflightResult.UNREACHABLE
+    return run_act(event)

{mcli_framework-8.0.56 → mcli_framework-8.0.58/src/mcli_framework.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: mcli-framework
-Version: 8.0.56
+Version: 8.0.58
 Summary: Portable workflow framework - transform any script into a versioned, schedulable command. Store in ~/.mcli/workflows/, version with lockfile, run as daemon or cron job.
 Author-email: Luis Fernandez de la Vara <luis@lefv.io>
 Maintainer-email: Luis Fernandez de la Vara <luis@lefv.io>

{mcli_framework-8.0.56 → mcli_framework-8.0.58}/src/mcli_framework.egg-info/SOURCES.txt

@@ -15,22 +15,17 @@ src/mcli/__init__.py
 src/mcli/__main__.py
 src/mcli/config.toml
 src/mcli/app/__init__.py
-src/mcli/app/commands_cmd.py
 src/mcli/app/completion_helpers.py
 src/mcli/app/context_cmd.py
-src/mcli/app/create_cmd.py
 src/mcli/app/delete_cmd.py
 src/mcli/app/edit_cmd.py
 src/mcli/app/import_cmd.py
 src/mcli/app/init_cmd.py
 src/mcli/app/list_cmd.py
 src/mcli/app/main.py
-src/mcli/app/migrate_cmd.py
 src/mcli/app/model_cmd.py
 src/mcli/app/mv_cmd.py
 src/mcli/app/new_cmd.py
-src/mcli/app/remove_cmd.py
-src/mcli/app/rm_cmd.py
 src/mcli/app/search_cmd.py
 src/mcli/app/services_cmd.py
 src/mcli/app/setup_cmd.py