mcli-framework 8.0.60__tar.gz → 8.0.62__tar.gz

{mcli_framework-8.0.60/src/mcli_framework.egg-info → mcli_framework-8.0.62}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: mcli-framework
-Version: 8.0.60
+Version: 8.0.62
 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.60 → mcli_framework-8.0.62}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "mcli-framework"
-version = "8.0.60"
+version = "8.0.62"
 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.60 → mcli_framework-8.0.62}/src/mcli/lib/constants/defaults.py

@@ -39,6 +39,7 @@ class URLs:
     GITHUB_API = "https://api.github.com"
     GITHUB_API_MCLI = "https://api.github.com/repos/gwicho38/mcli"
     GITHUB_API_ACTIONS = "https://api.github.com/repos/gwicho38/mcli/actions/runs"
+    GITHUB_ISSUES_MCLI = "https://github.com/gwicho38/mcli/issues"
 
     # PyPI
     PYPI_API = "https://pypi.org/pypi"

{mcli_framework-8.0.60 → mcli_framework-8.0.62}/src/mcli/lib/constants/messages.py

@@ -17,6 +17,7 @@ class ErrorMessages:
     )
     COMMAND_NOT_FOUND = "Command '{name}' not found"
     COMMAND_NOT_AVAILABLE = "Command {name} is not available"
+    WORKFLOW_CRASHED = "Workflow '{name}' crashed: {error}"
     GIT_COMMAND_FAILED = "Git command failed: {error}"
     FILE_NOT_FOUND = "File not found: {path}"
     DIRECTORY_NOT_FOUND = "Directory not found: {path}"
@@ -66,6 +67,9 @@ class InfoMessages:
 
     COPYING_COMMANDS = "Copying commands from {source} to {dest}..."
     NO_CHANGES_TO_COMMIT = "No changes to commit"
+    WORKFLOW_CRASH_LOCATION = "  in {location}"
+    WORKFLOW_CRASH_TRACE_HINT = "  Set MCLI_TRACE_LEVEL=1 (or MCLI_DEBUG=1) for the full traceback."
+    WORKFLOW_CRASH_REPORT = "  Report this: {url}"
     LOADING = "Loading {item}..."
     PROCESSING = "Processing {item}..."
     CONNECTING = "Connecting to {service}..."

mcli_framework-8.0.62/src/mcli/lib/workflow_runtime.py

@@ -0,0 +1,100 @@
+"""Runtime helpers for executing user workflow scripts safely.
+
+When a dynamically-loaded workflow script raises an unhandled exception at
+*invoke* time (i.e. it loads fine but crashes while running), Click/Python
+would dump a raw traceback at the user. That tells them little about which
+script failed or what to do next.
+
+``wrap_command_invoke`` wraps a loaded command so such crashes are rendered as
+a concise, actionable message — which workflow crashed, the error, the script
+location, and how to report it. The full traceback stays one env var away
+(``MCLI_TRACE_LEVEL`` / ``MCLI_DEBUG``) for debugging.
+
+Click usage errors, ``Abort`` and ``SystemExit`` are deliberately *not*
+swallowed — those are normal control flow, not script crashes.
+"""
+
+from __future__ import annotations
+
+import os
+import sys
+import traceback
+from pathlib import Path
+
+import click
+from rich.console import Console
+
+from mcli.lib.constants.defaults import URLs
+from mcli.lib.constants.env import EnvVars
+from mcli.lib.constants.messages import ErrorMessages, InfoMessages
+
+# Module-level so tests can redirect it to a buffer.
+_console = Console(stderr=True)
+
+
+def _wants_traceback() -> bool:
+    """Whether to print the full traceback (debug/trace modes)."""
+    trace = os.environ.get(EnvVars.MCLI_TRACE_LEVEL, "").strip()
+    if trace and trace != "0":
+        return True
+    debug = os.environ.get(EnvVars.MCLI_DEBUG, "").strip().lower()
+    return debug in ("1", "true", "yes", "on")
+
+
+def _deepest_script_line(script_path: Path, exc: BaseException) -> int | None:
+    """Return the deepest line number within the user's script, if any."""
+    target = str(script_path)
+    line: int | None = None
+    for frame, lineno in traceback.walk_tb(exc.__traceback__):
+        if frame.f_code.co_filename == target:
+            line = lineno
+    return line
+
+
+def render_script_error(name: str, script_path: str | Path, exc: BaseException) -> None:
+    """Print a concise, actionable crash summary for a workflow script."""
+    script_path = Path(script_path)
+    line = _deepest_script_line(script_path, exc)
+    location = str(script_path) if line is None else f"{script_path}:{line}"
+
+    summary = ErrorMessages.WORKFLOW_CRASHED.format(name=name, error=f"{type(exc).__name__}: {exc}")
+    _console.print(f"[bold red]✗[/bold red] {summary}", soft_wrap=True, highlight=False)
+    _console.print(
+        InfoMessages.WORKFLOW_CRASH_LOCATION.format(location=location),
+        soft_wrap=True,
+        highlight=False,
+    )
+    _console.print(InfoMessages.WORKFLOW_CRASH_TRACE_HINT, soft_wrap=True, highlight=False)
+    _console.print(
+        InfoMessages.WORKFLOW_CRASH_REPORT.format(url=URLs.GITHUB_ISSUES_MCLI),
+        soft_wrap=True,
+        highlight=False,
+    )
+
+    if _wants_traceback():
+        traceback.print_exception(type(exc), exc, exc.__traceback__, file=sys.stderr)
+
+
+def wrap_command_invoke(command: click.BaseCommand, script_path: str | Path):
+    """Wrap a loaded command so runtime crashes render a friendly message.
+
+    Returns the same command (mutated in place). ``None`` passes through so
+    callers don't need to guard.
+    """
+    if command is None:
+        return command
+
+    path = Path(script_path)
+    original_invoke = command.invoke
+
+    def safe_invoke(ctx):
+        try:
+            return original_invoke(ctx)
+        except (click.ClickException, click.Abort, SystemExit, KeyboardInterrupt):
+            raise
+        except Exception as exc:  # noqa: BLE001 - intentional catch-all for user scripts
+            render_script_error(command.name or path.stem, path, exc)
+            raise SystemExit(1) from exc
+
+    command.invoke = safe_invoke  # type: ignore[method-assign]
+    return command

{mcli_framework-8.0.60 → mcli_framework-8.0.62}/src/mcli/workflow/ci/act_runner.py

@@ -28,13 +28,14 @@ _NO_STAGES_MARKERS = ("could not find any stages to run",)
 _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.
+# Canonical CI entrypoint created by `mcli ci migrate`: ci.yml runs on
+# `workflow_dispatch`. The job id is NOT fixed (`mcli ci migrate` keeps the
+# repo's original job name, e.g. `test`) — so preflight discovers the real job
+# id(s) from `act --list` rather than assuming a hardcoded name.
 _DISPATCH_WORKFLOW = Path(".github/workflows/ci.yml")
-_DISPATCH_JOB = "primary"
+
+# Header label of the job-id column in `act --list` table output.
+_JOB_ID_HEADER = "Job ID"
 
 
 class PreflightResult(Enum):
@@ -115,13 +116,53 @@ def default_container_arch() -> str | None:
     return None
 
 
-def dispatch_entrypoint() -> tuple[str, str] | None:
-    """The canonical (workflow, job) to drive via `workflow_dispatch`, or None."""
+def dispatch_workflow() -> str | None:
+    """The canonical workflow file to drive via `workflow_dispatch`, or None."""
     if _DISPATCH_WORKFLOW.exists():
-        return (str(_DISPATCH_WORKFLOW), _DISPATCH_JOB)
+        return str(_DISPATCH_WORKFLOW)
     return None
 
 
+def list_jobs(event: str, workflow: str | None = None) -> list[str]:
+    """Real job ids act would run for `event`, parsed from the `act --list` table.
+
+    `act --list` prints a table whose first row is a header containing a `Job ID`
+    column; each subsequent row is a runnable job. Returns job ids in table order
+    (deduplicated). Returns ``[]`` when act lists no jobs for the event (including
+    the "could not find any stages" no-op) or when act can't be invoked — never
+    raises, so callers can treat an empty result as "nothing to run".
+    """
+    cmd = ["act", event, "--list"]
+    if workflow is not None:
+        cmd += ["-W", workflow]
+    try:
+        proc = subprocess.run(cmd, capture_output=True, text=True, timeout=120)
+    except (FileNotFoundError, subprocess.TimeoutExpired):
+        return []
+    return _parse_job_ids(proc.stdout or "")
+
+
+def _parse_job_ids(listing: str) -> list[str]:
+    """Extract the `Job ID` column from `act --list` table output."""
+    lines = [ln for ln in listing.splitlines() if ln.strip()]
+    if not lines:
+        return []
+    header = lines[0]
+    if _JOB_ID_HEADER not in header:
+        return []
+    # Columns are whitespace-separated; the job id is the second field in act's
+    # fixed-order table (Stage, Job ID, Job name, ...).
+    col = header.split().index(_JOB_ID_HEADER.split()[1]) - 1
+    job_ids: list[str] = []
+    for row in lines[1:]:
+        fields = row.split()
+        if len(fields) > col:
+            jid = fields[col]
+            if jid not in job_ids:
+                job_ids.append(jid)
+    return job_ids
+
+
 def build_act_command(
     event: str,
     workflow: str | None = None,
@@ -194,35 +235,57 @@ def run_act(
 
     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.
+    to the canonical ``ci.yml`` on ``workflow_dispatch``: discover its real job
+    id(s) via ``act --list`` (the job name is NOT fixed — ``mcli ci migrate``
+    keeps the repo's original name) and run each so the gate validates for real.
+
+    A green result means act actually executed ≥1 job and every job passed. If
+    ``act --list`` shows jobs but a run reports "could not find any stages"
+    (i.e. act ran nothing), that is a FAILURE, not a no-op — never a hollow pass.
     """
     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
+    if not (result == PreflightResult.PASS and _has_no_stages(output)):
+        return result
+
+    # No stages for the requested event — try the workflow_dispatch entrypoint.
+    workflow = dispatch_workflow()
+    if workflow is None:
         sys.stdout.write(
-            f"ℹ️  No '{event}' stages (workflow_dispatch-only); running "
-            f"{workflow} -j {job} via workflow_dispatch…\n"
+            "ℹ️  No act stages for this event and no ci.yml dispatch "
+            "entrypoint — nothing to validate; treating as pass.\n"
         )
+        return PreflightResult.PASS
+
+    jobs = list_jobs("workflow_dispatch", workflow)
+    if not jobs:
+        # The dispatch entrypoint genuinely has no jobs — a real no-op.
+        sys.stdout.write(
+            f"ℹ️  {workflow} has no workflow_dispatch jobs — nothing to "
+            "validate; treating as pass.\n"
+        )
+        return PreflightResult.PASS
+
+    targets = f"{workflow} {jobs}"
+    sys.stdout.write(
+        f"ℹ️  No '{event}' stages (workflow_dispatch-only); running "
+        f"{targets} via workflow_dispatch…\n"
+    )
+    for job in jobs:
         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
+        if result == PreflightResult.UNREACHABLE:
+            return PreflightResult.UNREACHABLE
+        # We KNOW this job exists (it came from `act --list`), so "no stages"
+        # here means act ran nothing — a failure, not a no-op. Do not pass.
+        if result != PreflightResult.PASS or _has_no_stages(output):
+            return PreflightResult.FAIL
+
+    return PreflightResult.PASS
 
 
 def preflight(repo_slug: str, event: str = "pull_request") -> PreflightResult:

{mcli_framework-8.0.60 → mcli_framework-8.0.62}/src/mcli/workflow/workflow.py

@@ -140,6 +140,7 @@ class ScopedWorkflowsGroup(click.Group):
         from mcli.lib.constants.messages import WarningMessages
         from mcli.lib.logger.logger import get_logger
         from mcli.lib.script_loader import LANGUAGE_TO_SUFFIX, ScriptLoader, parse_command_name
+        from mcli.lib.workflow_runtime import wrap_command_invoke
 
         logger = get_logger()
 
@@ -171,7 +172,7 @@ class ScopedWorkflowsGroup(click.Group):
                     command = loader.load_command(matches[0])
                     if command:
                         logger.debug(f"Loaded native script command: {cmd_name}")
-                        return command
+                        return wrap_command_invoke(command, matches[0])
                 except Exception as e:
                     logger.debug(f"Failed to load script '{cmd_name}': {e}")
             elif len(matches) > 1 and not lang_filter:
@@ -185,7 +186,7 @@ class ScopedWorkflowsGroup(click.Group):
                     command = loader.load_command(matches[0])
                     if command:
                         logger.debug(f"Loaded first match for ambiguous command: {base_name}")
-                        return command
+                        return wrap_command_invoke(command, matches[0])
                 except Exception as e:
                     logger.debug(f"Failed to load script '{base_name}': {e}")
 

{mcli_framework-8.0.60 → mcli_framework-8.0.62/src/mcli_framework.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: mcli-framework
-Version: 8.0.60
+Version: 8.0.62
 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.60 → mcli_framework-8.0.62}/src/mcli_framework.egg-info/SOURCES.txt

@@ -52,6 +52,7 @@ src/mcli/lib/script_watcher.py
 src/mcli/lib/sync_key_store.py
 src/mcli/lib/types.py
 src/mcli/lib/workflow_models.py
+src/mcli/lib/workflow_runtime.py
 src/mcli/lib/workspace_registry.py
 src/mcli/lib/api/__init__.py
 src/mcli/lib/api/api.py