mcli-framework 8.0.50__tar.gz → 8.0.52__tar.gz

{mcli_framework-8.0.50/src/mcli_framework.egg-info → mcli_framework-8.0.52}/PKG-INFO

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

@@ -1,6 +1,6 @@
 [project]
 name = "mcli-framework"
-version = "8.0.50"
+version = "8.0.52"
 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.52/src/mcli/__main__.py

@@ -0,0 +1,14 @@
+# logger.info("I am in mcli.__init__.py")
+
+try:
+    from mcli.app.main import main as main_func
+
+    # from mcli.public import *
+    # from mcli.private import *
+except ImportError:
+    from .app.main import main as main_func
+
+__all__ = ["main_func"]
+
+if __name__ == "__main__":
+    main_func()

{mcli_framework-8.0.50 → mcli_framework-8.0.52}/src/mcli/app/sync_cmd.py

@@ -17,7 +17,7 @@ from typing import Optional
 import click
 from rich.table import Table
 
-from mcli.lib.constants import IpfsMessages, SyncMessages
+from mcli.lib.constants import FileNames, IpfsMessages, SyncMessages
 from mcli.lib.ipfs_utils import ipfs_daemon_running as _ipfs_daemon_running
 from mcli.lib.ipfs_utils import ipfs_initialized as _ipfs_initialized
 from mcli.lib.ipfs_utils import ipfs_installed as _ipfs_installed
@@ -423,7 +423,7 @@ def sync_push_command(global_mode: bool, description: str):
     from mcli.lib.ipns_manager import get_sync_key
 
     workflows_dir = get_custom_commands_dir(global_mode=global_mode)
-    lockfile_path = workflows_dir / "commands.lock.json"
+    lockfile_path = workflows_dir / FileNames.COMMANDS_LOCK_JSON
 
     if not lockfile_path.exists():
         error(SyncMessages.LOCKFILE_NOT_FOUND.format(path=lockfile_path))
@@ -448,10 +448,16 @@ def sync_push_command(global_mode: bool, description: str):
         console.print(SyncMessages.VIEW_BROWSER_HINT)
         console.print(SyncMessages.IPFS_GATEWAY_URL.format(cid=cid))
 
-        # Show IPNS info if published
+        # Report IPNS status honestly: only claim teammates can auto-resolve
+        # when the publish actually succeeded.
         if get_sync_key():
             console.print()
-            info("Teammates can pull latest with: mcli sync pull")
+            if ipfs.last_ipns_name:
+                success(SyncMessages.IPNS_PUBLISHED.format(name=ipfs.last_ipns_name))
+                info(SyncMessages.IPNS_TEAMMATE_PULL_HINT)
+            else:
+                warning(SyncMessages.IPNS_PUBLISH_FAILED)
+                info(SyncMessages.RETRIEVE_COMMAND.format(cid=cid))
     else:
         error(SyncMessages.FAILED_PUSH_IPFS)
 
@@ -798,7 +804,7 @@ def sync_info(is_global: bool):
     workflows_dir = get_custom_commands_dir(global_mode=is_global)
     console.print(f"  Workflows directory: {workflows_dir}")
 
-    lockfile = workflows_dir / "commands.lock.json"
+    lockfile = workflows_dir / FileNames.COMMANDS_LOCK_JSON
     console.print(f"  Lockfile: {lockfile} ({'exists' if lockfile.exists() else 'missing'})")
     console.print()
 

{mcli_framework-8.0.50 → mcli_framework-8.0.52}/src/mcli/lib/constants/messages.py

@@ -946,6 +946,7 @@ class SyncMessages:
     IPNS_RESOLVING = "Resolving latest via IPNS..."
     IPNS_RESOLVED = "Resolved IPNS to CID: {cid}"
     IPNS_RESOLVE_FAILED = "Could not resolve via IPNS"
+    IPNS_TEAMMATE_PULL_HINT = "Teammates can pull latest with: mcli sync pull"
     IPNS_NO_SYNC_KEY = "MCLI_SYNC_KEY not set — cannot use IPNS auto-resolve"
     IPNS_SYNC_KEY_HINT = (
         "[dim]Set MCLI_SYNC_KEY to enable IPNS. Share same key with teammates.[/dim]"

{mcli_framework-8.0.50 → mcli_framework-8.0.52}/src/mcli/lib/ipfs_sync.py

@@ -77,6 +77,8 @@ class IPFSSync:
         self.sync_history_path = self.data_dir / FileNames.IPFS_SYNC_HISTORY_JSON
         self.sync_history = self._load_sync_history()
         self._local_ipfs_available: Optional[bool] = None
+        # Set by push() to the IPNS name if (and only if) publish succeeded.
+        self.last_ipns_name: Optional[str] = None
 
     def _load_sync_history(self) -> list[dict]:
         """Load sync history from local storage."""
@@ -427,14 +429,17 @@ class IPFSSync:
                     self.sync_history = self.sync_history[-MAX_HISTORY:]
                 self._save_sync_history()
 
-                # Publish to IPNS if sync key is configured
+                # Publish to IPNS if sync key is configured. Record whether the
+                # publish actually succeeded so callers can report honestly
+                # instead of implying IPNS resolution works when it does not.
+                self.last_ipns_name = None
                 sync_key = get_sync_key()
                 if sync_key:
                     repo = get_repo_name()
                     key_info = derive_key_info(sync_key, repo, "global")
                     ipns_name = ensure_key_imported(key_info)
                     if ipns_name:
-                        publish_to_ipns(cid, key_info.key_name)
+                        self.last_ipns_name = publish_to_ipns(cid, key_info.key_name)
 
             return cid
 

{mcli_framework-8.0.50 → mcli_framework-8.0.52}/src/mcli/lib/paths.py

@@ -9,7 +9,7 @@ import os
 from pathlib import Path
 from typing import Optional
 
-from mcli.lib.constants.paths import DirNames
+from mcli.lib.constants.paths import DirNames, FileNames
 
 
 def get_mcli_home() -> Path:
@@ -248,8 +248,8 @@ def get_lockfile_path(global_mode: bool = False) -> Path:
         Path to the lockfile
     """
     workflows_dir = get_custom_commands_dir(global_mode=global_mode)
-    # Keep the old lockfile name for compatibility
-    return workflows_dir / "commands.lock.json"
+    # Canonical lockfile name, shared with ScriptLoader and the IPFS sync path.
+    return workflows_dir / FileNames.COMMANDS_LOCK_JSON
 
 
 def resolve_workspace(workspace_path: str) -> Optional[Path]:

{mcli_framework-8.0.50 → mcli_framework-8.0.52}/src/mcli/lib/script_loader.py

@@ -28,6 +28,7 @@ from typing import Any, Optional
 
 import click
 
+from mcli.lib.constants import FileNames
 from mcli.lib.logger.logger import get_logger, register_subprocess
 from mcli.lib.pyenv import PyEnvManager
 
@@ -140,7 +141,10 @@ class ScriptLoader:
             workflows_dir: Directory containing workflow scripts
         """
         self.workflows_dir = Path(workflows_dir).expanduser()
-        self.lockfile_path = self.workflows_dir / "workflows.lock.json"
+        # Canonical lockfile name shared with the IPFS sync path (push/pull) and
+        # the rest of the codebase. Must match FileNames.COMMANDS_LOCK_JSON,
+        # otherwise `sync update` writes a lockfile `sync push` cannot find.
+        self.lockfile_path = self.workflows_dir / FileNames.COMMANDS_LOCK_JSON
         self.loaded_commands: dict[str, click.Command] = {}
 
     def discover_scripts(self) -> list[Path]:
@@ -383,8 +387,17 @@ class ScriptLoader:
         except Exception:
             mtime = datetime.utcnow().isoformat() + "Z"
 
+        # Record the path relative to the workflows dir (POSIX, forward slashes)
+        # so the IPFS sync path can locate and reconstruct scripts living in
+        # group subdirectories. Falls back to the bare name if the script is
+        # somehow outside the workflows dir.
+        try:
+            relative_file = script_path.relative_to(self.workflows_dir).as_posix()
+        except ValueError:
+            relative_file = script_path.name
+
         return {
-            "file": script_path.name,
+            "file": relative_file,
             "language": language,
             "content_hash": content_hash,
             "version": metadata.get("version", "1.0.0"),

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

@@ -0,0 +1,121 @@
+"""Run `act` locally and classify the outcome for the PR gate."""
+
+from __future__ import annotations
+
+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",
+)
+
+# Backoff (seconds) between docker rate-limit retries; the last value repeats.
+_RETRY_BACKOFF = (15, 45)
+_MAX_RETRIES = 2
+
+
+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 act_available() -> bool:
+    return shutil.which("act") is not None
+
+
+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 build_act_command(event: str) -> list[str]:
+    cmd = ["act", event]
+    if Path(".secrets").exists():
+        cmd += ["--secret-file", ".secrets"]
+    return cmd
+
+
+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``) -> retry up to ``retries`` times with backoff;
+      if still rate-limited, return UNREACHABLE (cannot validate — an
+      environment problem, not a test failure, so the gate must not block).
+    - any other non-zero exit -> FAIL.
+
+    Output is captured (to detect the rate limit) and echoed so the user still
+    sees act's progress.
+    """
+    attempt = 0
+    while True:
+        proc = subprocess.run(build_act_command(event), 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
+
+        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
+
+        return PreflightResult.FAIL
+
+
+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.
+    """
+    if not probe():
+        return PreflightResult.UNREACHABLE
+    return run_act(event)

{mcli_framework-8.0.50 → mcli_framework-8.0.52}/src/mcli/workflow/ci/ci.py

@@ -143,7 +143,18 @@ def pr():
 
 PRE_PUSH_HOOK = """#!/usr/bin/env bash
 # mcli-ci pre-push gate: validate with act before pushing.
-exec mcli ci preflight
+# Blocks ONLY on a real act failure (exit 1). When act cannot validate locally
+# — e.g. Docker Hub rate-limit (toomanyrequests, retried first), no docker, or
+# an online runner will validate instead (exit 2/3) — the push is allowed so an
+# environment hiccup never wedges your workflow. Override a real failure with:
+#   git push --no-verify
+mcli ci preflight
+code=$?
+if [ "$code" -eq 1 ]; then
+  echo "mcli-ci: act reported failures — push blocked. Override: git push --no-verify" >&2
+  exit 1
+fi
+exit 0
 """
 
 

{mcli_framework-8.0.50 → mcli_framework-8.0.52/src/mcli_framework.egg-info}/PKG-INFO

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

@@ -12,6 +12,7 @@ mcli_rust/src/lib.rs
 mcli_rust/src/process_manager.rs
 mcli_rust/src/tfidf.rs
 src/mcli/__init__.py
+src/mcli/__main__.py
 src/mcli/config.toml
 src/mcli/app/__init__.py
 src/mcli/app/commands_cmd.py

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

@@ -1,61 +0,0 @@
-"""Run `act` locally and classify the outcome for the PR gate."""
-
-from __future__ import annotations
-
-import shutil
-import subprocess
-from enum import Enum
-from pathlib import Path
-
-
-class PreflightResult(Enum):
-    PASS = "pass"
-    FAIL = "fail"
-    UNREACHABLE = "unreachable"
-
-
-def act_available() -> bool:
-    return shutil.which("act") is not None
-
-
-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 build_act_command(event: str) -> list[str]:
-    cmd = ["act", event]
-    if Path(".secrets").exists():
-        cmd += ["--secret-file", ".secrets"]
-    return cmd
-
-
-def run_act(event: str = "pull_request") -> PreflightResult:
-    """Run act for `event`. PASS on exit 0, else FAIL. (Probe gates UNREACHABLE upstream.)"""
-    proc = subprocess.run(build_act_command(event))
-    return PreflightResult.PASS if proc.returncode == 0 else PreflightResult.FAIL
-
-
-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.
-    """
-    if not probe():
-        return PreflightResult.UNREACHABLE
-    return run_act(event)