mcli-framework 8.0.65__tar.gz → 8.0.67__tar.gz

{mcli_framework-8.0.65/src/mcli_framework.egg-info → mcli_framework-8.0.67}/PKG-INFO

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

@@ -1,6 +1,6 @@
 [project]
 name = "mcli-framework"
-version = "8.0.65"
+version = "8.0.67"
 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.65 → mcli_framework-8.0.67}/src/mcli/lib/script_loader.py

@@ -22,7 +22,7 @@ import stat
 import subprocess
 import sys
 import tempfile
-from datetime import datetime
+from datetime import datetime, timedelta
 from pathlib import Path
 from typing import Any, Optional
 
@@ -68,6 +68,9 @@ LANGUAGE_TO_SUFFIX: dict[str, str] = {
     "ipynb": "ipynb",
 }
 
+VOLATILE_COMMAND_FIELDS = frozenset({"last_modified"})
+LOCKFILE_SCHEMA_VERSION = "2.0"
+
 
 def parse_command_name(cmd_name: str) -> tuple[str, Optional[str]]:
     """Parse 'name:suffix' into (base_name, language_or_None).
@@ -187,7 +190,7 @@ class ScriptLoader:
 
             scripts.append(script_path)
 
-        return sorted(scripts, key=lambda p: p.stem)
+        return sorted(scripts, key=lambda path: path.relative_to(self.workflows_dir).as_posix())
 
     def find_scripts_by_stem(self, stem: str) -> list[Path]:
         """Return all discovered scripts whose stem matches the given name.
@@ -853,20 +856,70 @@ class ScriptLoader:
             Dictionary containing lockfile data with v2 schema
         """
         scripts = self.discover_scripts()
+        existing_lockfile = self.load_lockfile()
+        existing_commands_value = existing_lockfile.get("commands", {}) if existing_lockfile else {}
+        existing_commands = (
+            existing_commands_value if isinstance(existing_commands_value, dict) else {}
+        )
+        commands: dict[str, Any] = {}
+        can_reuse_entries = bool(
+            existing_lockfile
+            and existing_lockfile.get("version") == LOCKFILE_SCHEMA_VERSION
+            and isinstance(existing_commands_value, dict)
+        )
 
-        lockfile_data = {
-            "version": "2.0",
+        lockfile_data: dict[str, Any] = {
+            "version": LOCKFILE_SCHEMA_VERSION,
             "generated_at": datetime.utcnow().isoformat() + "Z",
-            "commands": {},
+            "commands": commands,
         }
 
         keys = self._assign_command_keys(scripts)
         for script_path in scripts:
             info = self.get_script_info(script_path)
-            lockfile_data["commands"][keys[script_path]] = info
+            command_key = keys[script_path]
+            existing_info = existing_commands.get(command_key)
+            if (
+                can_reuse_entries
+                and isinstance(existing_info, dict)
+                and self._is_valid_utc_timestamp(existing_info.get("last_modified"))
+                and self._semantic_command_info(existing_info) == self._semantic_command_info(info)
+            ):
+                commands[command_key] = existing_info
+            else:
+                commands[command_key] = info
+
+        if (
+            existing_lockfile
+            and existing_lockfile.get("version") == lockfile_data["version"]
+            and existing_commands == commands
+            and self._is_valid_utc_timestamp(existing_lockfile.get("generated_at"))
+        ):
+            lockfile_data["generated_at"] = existing_lockfile["generated_at"]
 
         return lockfile_data
 
+    @staticmethod
+    def _semantic_command_info(command_info: Any) -> Any:
+        """Return command metadata without filesystem-derived volatile fields."""
+        if not isinstance(command_info, dict):
+            return command_info
+        return {
+            key: value for key, value in command_info.items() if key not in VOLATILE_COMMAND_FIELDS
+        }
+
+    @staticmethod
+    def _is_valid_utc_timestamp(value: Any) -> bool:
+        """Return whether a value is an ISO timestamp with an explicit UTC offset."""
+        if not isinstance(value, str):
+            return False
+        try:
+            normalized = f"{value[:-1]}+00:00" if value.endswith("Z") else value
+            timestamp = datetime.fromisoformat(normalized)
+        except ValueError:
+            return False
+        return timestamp.tzinfo is not None and timestamp.utcoffset() == timedelta(0)
+
     def _assign_command_keys(self, scripts: list[Path]) -> dict[Path, str]:
         """Assign a unique lockfile/command key to every discovered script.
 
@@ -934,10 +987,17 @@ class ScriptLoader:
         """
         try:
             lockfile_data = self.generate_lockfile()
+            serialized_lockfile = json.dumps(lockfile_data, indent=2)
+            if (
+                self.lockfile_path.exists()
+                and self.lockfile_path.read_text() == serialized_lockfile
+            ):
+                logger.debug(f"Lockfile unchanged: {self.lockfile_path}")
+                return True
             with open(self.lockfile_path, "w") as f:
                 fcntl.flock(f, fcntl.LOCK_EX)
                 try:
-                    json.dump(lockfile_data, f, indent=2)
+                    f.write(serialized_lockfile)
                 finally:
                     fcntl.flock(f, fcntl.LOCK_UN)
             logger.info(f"Saved lockfile: {self.lockfile_path}")

{mcli_framework-8.0.65 → mcli_framework-8.0.67}/src/mcli/workflow/ci/act_runner.py

@@ -65,6 +65,36 @@ def act_available() -> bool:
     return shutil.which("act") is not None
 
 
+# Git exports these to every hook (`git rev-parse --local-env-vars`). They point
+# at the repo being pushed, so a tool inside the gate that runs git on its own
+# checkout reads the wrong repo: Flutter computes its SDK version with
+# `git describe` and reports the pushed commit, which then fails any
+# `environment: flutter:` constraint. The gate runs from the repo root, so
+# git finds the right repo without them.
+_GIT_HOOK_ENV = (
+    "GIT_ALTERNATE_OBJECT_DIRECTORIES",
+    "GIT_CONFIG",
+    "GIT_CONFIG_PARAMETERS",
+    "GIT_CONFIG_COUNT",
+    "GIT_OBJECT_DIRECTORY",
+    "GIT_DIR",
+    "GIT_WORK_TREE",
+    "GIT_IMPLICIT_WORK_TREE",
+    "GIT_GRAFT_FILE",
+    "GIT_INDEX_FILE",
+    "GIT_NO_REPLACE_OBJECTS",
+    "GIT_REPLACE_REF_BASE",
+    "GIT_PREFIX",
+    "GIT_SHALLOW_FILE",
+    "GIT_COMMON_DIR",
+)
+
+
+def _gate_env() -> dict[str, str]:
+    """The current environment without the repo-local variables git sets for hooks."""
+    return {k: v for k, v in os.environ.items() if k not in _GIT_HOOK_ENV}
+
+
 # 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
@@ -88,7 +118,7 @@ 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])
+    proc = subprocess.run(["make", _NATIVE_GATE], env=_gate_env())
     return PreflightResult.PASS if proc.returncode == 0 else PreflightResult.FAIL
 
 
@@ -220,7 +250,7 @@ def _run_with_retries(
     'no stages' no-op and decide whether to fall back)."""
     attempt = 0
     while True:
-        proc = subprocess.run(cmd, capture_output=True, text=True)
+        proc = subprocess.run(cmd, capture_output=True, text=True, env=_gate_env())
         output = (proc.stdout or "") + (proc.stderr or "")
         if output:
             sys.stdout.write(output if output.endswith("\n") else output + "\n")

{mcli_framework-8.0.65 → mcli_framework-8.0.67/src/mcli_framework.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: mcli-framework
-Version: 8.0.65
+Version: 8.0.67
 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>