mcli-framework 8.0.36__tar.gz → 8.0.38__tar.gz

{mcli_framework-8.0.36 → mcli_framework-8.0.38}/PKG-INFO

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

@@ -1,6 +1,6 @@
 [project]
 name = "mcli-framework"
-version = "8.0.36"
+version = "8.0.38"
 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.36 → mcli_framework-8.0.38}/src/mcli/app/list_cmd.py

@@ -111,6 +111,25 @@ def _list_workspaces(as_json: bool):
     console.print(f"\n[dim]Total: {len(workspaces)} workspace(s)[/dim]")
 
 
+def _apply_display_names(workflows: list[dict]) -> None:
+    """Add 'display_name' key to workflows, using suffixed names for duplicate stems.
+
+    When multiple workflows share the same base name (e.g. backup.py and backup.sh),
+    their display names become 'backup:py' and 'backup:sh'. Unique names stay bare.
+    """
+    from collections import Counter
+
+    from mcli.lib.script_loader import LANGUAGE_TO_SUFFIX
+
+    stem_counts = Counter(wf["name"] for wf in workflows)
+    for wf in workflows:
+        if stem_counts[wf["name"]] > 1:
+            suffix = LANGUAGE_TO_SUFFIX.get(wf.get("language", ""), "?")
+            wf["display_name"] = f"{wf['name']}:{suffix}"
+        else:
+            wf["display_name"] = wf["name"]
+
+
 def _list_all_workflows(as_json: bool):
     """List workflows from all registered workspaces."""
     from rich.panel import Panel
@@ -122,6 +141,7 @@ def _list_all_workflows(as_json: bool):
         # Flatten for JSON output
         flat_workflows = []
         for workspace_name, workflows in all_workflows.items():
+            _apply_display_names(workflows)
             for wf in workflows:
                 wf["workspace"] = workspace_name
                 flat_workflows.append(wf)
@@ -142,6 +162,8 @@ def _list_all_workflows(as_json: bool):
         if not workflows:
             continue
 
+        _apply_display_names(workflows)
+
         table = Table(show_header=True, header_style="bold")
         table.add_column("Name", style="cyan")
         table.add_column("Description", style="white")
@@ -153,7 +175,7 @@ def _list_all_workflows(as_json: bool):
             if len(desc) > 50:
                 desc = desc[:47] + "..."
             table.add_row(
-                wf["name"],
+                wf["display_name"],
                 desc,
                 wf.get("language", "?"),
                 wf.get("version", "1.0.0"),
@@ -202,6 +224,8 @@ def _list_scope_workflows(is_global: bool, as_json: bool):
         except Exception as e:
             logger.debug(f"Failed to get info for {script_path}: {e}")
 
+    _apply_display_names(workflows)
+
     if as_json:
         click.echo(json.dumps({"workflows": workflows, "total": len(workflows)}, indent=2))
         return
@@ -226,7 +250,7 @@ def _list_scope_workflows(is_global: bool, as_json: bool):
         if len(desc) > 50:
             desc = desc[:47] + "..."
         table.add_row(
-            wf["name"],
+            wf["display_name"],
             desc,
             wf.get("language", "?"),
             wf.get("version", "1.0.0"),

{mcli_framework-8.0.36 → mcli_framework-8.0.38}/src/mcli/app/services_cmd.py

@@ -37,7 +37,10 @@ def _get_config_from_state(name: str) -> ServiceConfig:
     )
 
 
-@click.group("services", help="Manage long-running services (start/stop/restart, health, logs).")
+@click.group(
+    "services",
+    help="\U0001f6e0\ufe0f Manage long-running services (start/stop/restart, health, logs).",
+)
 def services():
     """Service lifecycle management."""
     pass

{mcli_framework-8.0.36 → mcli_framework-8.0.38}/src/mcli/lib/logger/logger.py

@@ -25,9 +25,9 @@ class McliLogger:
     _runtime_tracing_enabled: bool = False
     _system_tracing_enabled: bool = False
     _system_trace_interval: int = 5  # Default to check every 5 seconds
-    _system_trace_process_ids: Set[int] = set()  # Process IDs to monitor
+    _system_trace_process_ids: set[int] = set()  # Process IDs to monitor
     _system_trace_thread: Optional[threading.Thread] = None
-    _excluded_modules: Set[str] = set()
+    _excluded_modules: set[str] = set()
     _trace_level: int = 0  # 0=off, 1=function calls, 2=line by line, 3=verbose
     _system_trace_level: int = 0  # 0=off, 1=basic, 2=detailed
 
@@ -54,7 +54,7 @@ class McliLogger:
 
     @classmethod
     def enable_runtime_tracing(
-        cls, level: int = 1, excluded_modules: Optional[List[str]] = None
+        cls, level: int = 1, excluded_modules: Optional[list[str]] = None
     ) -> None:
         """
         Enable Python interpreter runtime tracing.
@@ -279,7 +279,7 @@ class McliLogger:
 
         return True
 
-    def _get_process_info(self, pid: int, detailed: bool = False) -> Dict[str, Any]:
+    def _get_process_info(self, pid: int, detailed: bool = False) -> dict[str, Any]:
         """Get information about a process given its PID."""
         try:
             # Check if process exists
@@ -339,7 +339,7 @@ class McliLogger:
         except Exception as e:
             return {"pid": pid, "status": "ERROR", "error": str(e)}
 
-    def _format_process_info(self, info: Dict[str, Any]) -> str:
+    def _format_process_info(self, info: dict[str, Any]) -> str:
         """Format process information for logging."""
         if info.get("status") == "NOT_FOUND":
             return f"Process {info['pid']} no longer exists"
@@ -475,7 +475,7 @@ class McliLogger:
                 if self._trace_level >= 3:
                     # Include source line in verbose mode
                     try:
-                        with open(filename, "r") as f:
+                        with open(filename) as f:
                             lines = f.readlines()
                             source = (
                                 lines[lineno - 1].strip()
@@ -543,7 +543,7 @@ def get_system_trace_logger() -> logging.Logger:
     return McliLogger.get_system_trace_logger()
 
 
-def enable_runtime_tracing(level: int = 1, excluded_modules: Optional[List[str]] = None) -> None:
+def enable_runtime_tracing(level: int = 1, excluded_modules: Optional[list[str]] = None) -> None:
     """
     Enable Python interpreter runtime tracing.
 

{mcli_framework-8.0.36 → mcli_framework-8.0.38}/src/mcli/lib/script_loader.py

@@ -43,6 +43,54 @@ SUPPORTED_EXTENSIONS: dict[str, str] = {
     ".ipynb": "ipynb",
 }
 
+# Maps user-facing suffixes to canonical language names
+LANGUAGE_SUFFIXES: dict[str, str] = {
+    "py": "python",
+    "python": "python",
+    "sh": "shell",
+    "shell": "shell",
+    "bash": "shell",
+    "js": "javascript",
+    "javascript": "javascript",
+    "ts": "typescript",
+    "typescript": "typescript",
+    "ipynb": "ipynb",
+}
+
+# Reverse map: canonical language name → short suffix for display
+LANGUAGE_TO_SUFFIX: dict[str, str] = {
+    "python": "py",
+    "shell": "sh",
+    "javascript": "js",
+    "typescript": "ts",
+    "ipynb": "ipynb",
+}
+
+
+def parse_command_name(cmd_name: str) -> tuple[str, Optional[str]]:
+    """Parse 'name:suffix' into (base_name, language_or_None).
+
+    Uses rsplit so that names containing colons still work correctly.
+    Unknown suffixes are treated as part of the base name (no language filter).
+
+    Examples:
+        >>> parse_command_name("backup:py")
+        ("backup", "python")
+        >>> parse_command_name("backup")
+        ("backup", None)
+        >>> parse_command_name("my:cmd:sh")
+        ("my:cmd", "shell")
+        >>> parse_command_name("backup:xyz")
+        ("backup:xyz", None)
+    """
+    if ":" in cmd_name:
+        base, suffix = cmd_name.rsplit(":", 1)
+        language = LANGUAGE_SUFFIXES.get(suffix.lower())
+        if language:
+            return base, language
+    return cmd_name, None
+
+
 # Shebang patterns for language detection
 SHEBANG_PATTERNS: dict[str, re.Pattern] = {
     "python": re.compile(r"#!/.*python"),
@@ -136,6 +184,17 @@ class ScriptLoader:
 
         return sorted(scripts, key=lambda p: p.stem)
 
+    def find_scripts_by_stem(self, stem: str) -> list[Path]:
+        """Return all discovered scripts whose stem matches the given name.
+
+        Args:
+            stem: The base name (without extension) to search for
+
+        Returns:
+            List of matching script paths, sorted by name
+        """
+        return [p for p in self.discover_scripts() if p.stem == stem]
+
     def detect_language(self, script_path: Path) -> str:
         """
         Detect script language from shebang or extension.

{mcli_framework-8.0.36 → mcli_framework-8.0.38}/src/mcli/lib/shell/shell.py

@@ -39,7 +39,7 @@ logger = get_logger(__name__)
 MAX_COMMAND_LENGTH = 100000
 
 
-def shell_exec(script_path: str, function_name: str, *args) -> Optional[Dict[str, Any]]:
+def shell_exec(script_path: str, function_name: str, *args) -> Optional[dict[str, Any]]:
     """Execute a shell script function with security checks and better error handling.
 
     Args:
@@ -176,7 +176,7 @@ def fatal_error(msg: str) -> None:
 
 
 def execute_os_command(
-    command: Union[str, List[str]],
+    command: Union[str, list[str]],
     fail_on_error: bool = True,
     stdin: Optional[str] = None,
     timeout: Optional[int] = None,
@@ -294,12 +294,12 @@ def execute_os_command(
 
 
 def execute_command_safe(
-    args: List[str],
+    args: list[str],
     fail_on_error: bool = True,
     stdin: Optional[str] = None,
     timeout: Optional[int] = None,
     cwd: Optional[str] = None,
-    env: Optional[Dict[str, str]] = None,
+    env: Optional[dict[str, str]] = None,
     check_executable: bool = True,
 ) -> str:
     """Execute a command safely without shell interpolation.
@@ -414,11 +414,11 @@ def execute_command_safe(
 
 
 def execute_command_with_result(
-    args: List[str],
+    args: list[str],
     stdin: Optional[str] = None,
     timeout: Optional[int] = None,
     cwd: Optional[str] = None,
-    env: Optional[Dict[str, str]] = None,
+    env: Optional[dict[str, str]] = None,
 ) -> CommandResult:
     """Execute a command and return structured result (never raises on non-zero exit).
 

{mcli_framework-8.0.36 → mcli_framework-8.0.38}/src/mcli/lib/toml/toml.py

@@ -26,7 +26,7 @@ def read_from_toml(file_path: str, key: str) -> Optional[Any]:
         # Fall back to the third-party 'toml' package for earlier Python versions.
         import toml
 
-        with open(file_path, "r", encoding="utf-8") as file:
+        with open(file_path, encoding="utf-8") as file:
             config_data = toml.load(file)
 
     # Return the value for the provided key, or None if the key is not found.

{mcli_framework-8.0.36 → mcli_framework-8.0.38}/src/mcli/workflow/workflow.py

@@ -40,10 +40,17 @@ class ScopedWorkflowsGroup(click.Group):
         return get_custom_commands_dir(global_mode=is_global)
 
     def list_commands(self, ctx):
-        """List available commands based on scope."""
+        """List available commands based on scope.
+
+        When multiple scripts share a stem (e.g. backup.py and backup.sh),
+        emits suffixed names like backup:py and backup:sh so that tab completion
+        offers distinct entries for each language variant.
+        """
+
+        from collections import Counter
 
         from mcli.lib.logger.logger import get_logger
-        from mcli.lib.script_loader import ScriptLoader
+        from mcli.lib.script_loader import LANGUAGE_TO_SUFFIX, ScriptLoader
 
         logger = get_logger()
 
@@ -60,17 +67,26 @@ class ScopedWorkflowsGroup(click.Group):
 
         # Load native script commands
         script_commands = []
+        script_stems = set()
         if workflows_dir.exists():
             loader = ScriptLoader(workflows_dir)
             scripts = loader.discover_scripts()
 
+            # Count how many scripts share each stem
+            stem_counts = Counter(sp.stem for sp in scripts)
+
             for script_path in scripts:
                 name = script_path.stem
-                # Validate the command can be loaded
                 try:
                     command = loader.load_command(script_path)
                     if command:
-                        script_commands.append(name)
+                        if stem_counts[name] > 1:
+                            lang = loader.detect_language(script_path)
+                            suffix = LANGUAGE_TO_SUFFIX.get(lang, script_path.suffix.lstrip("."))
+                            script_commands.append(f"{name}:{suffix}")
+                        else:
+                            script_commands.append(name)
+                        script_stems.add(name)
                     else:
                         logger.debug(f"Script '{name}' could not be loaded as a command")
                 except Exception as e:
@@ -91,7 +107,7 @@ class ScopedWorkflowsGroup(click.Group):
 
                 cmd_name = cmd_data.get("name")
                 # Skip if already loaded as native script
-                if cmd_name in script_commands:
+                if cmd_name in script_stems:
                     continue
 
                 # Validate the command can be loaded
@@ -112,14 +128,18 @@ class ScopedWorkflowsGroup(click.Group):
             logger.debug(f"Could not load legacy JSON commands: {e}")
 
         # Only return user-defined workflows (scripts + legacy JSON)
-        # This matches the behavior of `mcli list`.
-
         return sorted(set(script_commands + legacy_commands))
 
     def get_command(self, ctx, cmd_name):
-        """Get a command by name, loading from appropriate scope."""
+        """Get a command by name, loading from appropriate scope.
+
+        Supports language suffix disambiguation: 'backup:py' loads the Python
+        version, 'backup:sh' loads the shell version. Bare names work when
+        unambiguous; when ambiguous, a warning is shown and the first match runs.
+        """
+        from mcli.lib.constants.messages import WarningMessages
         from mcli.lib.logger.logger import get_logger
-        from mcli.lib.script_loader import ScriptLoader
+        from mcli.lib.script_loader import LANGUAGE_TO_SUFFIX, ScriptLoader, parse_command_name
 
         logger = get_logger()
 
@@ -134,24 +154,43 @@ class ScopedWorkflowsGroup(click.Group):
             logger.warning(f"Workspace not found: {workspace}")
             return None
 
+        # Parse language suffix (e.g. "backup:py" → base="backup", lang="python")
+        base_name, lang_filter = parse_command_name(cmd_name)
+
         # Try to load as native script first
         if workflows_dir.exists():
             loader = ScriptLoader(workflows_dir)
-            scripts = loader.discover_scripts()
+            matches = loader.find_scripts_by_stem(base_name)
 
-            # Find matching script
-            for script_path in scripts:
-                if script_path.stem == cmd_name:
-                    try:
-                        command = loader.load_command(script_path)
-                        if command:
-                            logger.debug(f"Loaded native script command: {cmd_name}")
-                            return command
-                    except Exception as e:
-                        logger.debug(f"Failed to load script '{cmd_name}': {e}")
-                    break
-
-        # Fall back to legacy JSON commands
+            if lang_filter:
+                # Filter to requested language
+                matches = [p for p in matches if loader.detect_language(p) == lang_filter]
+
+            if len(matches) == 1:
+                try:
+                    command = loader.load_command(matches[0])
+                    if command:
+                        logger.debug(f"Loaded native script command: {cmd_name}")
+                        return command
+                except Exception as e:
+                    logger.debug(f"Failed to load script '{cmd_name}': {e}")
+            elif len(matches) > 1 and not lang_filter:
+                # Ambiguous — show hint, pick first
+                from mcli.lib.ui.styling import warning
+
+                suffixes = [LANGUAGE_TO_SUFFIX.get(loader.detect_language(p), "?") for p in matches]
+                options = ", ".join(f"{base_name}:{s}" for s in suffixes)
+                warning(WarningMessages.AMBIGUOUS_COMMAND.format(name=base_name, options=options))
+                try:
+                    command = loader.load_command(matches[0])
+                    if command:
+                        logger.debug(f"Loaded first match for ambiguous command: {base_name}")
+                        return command
+                except Exception as e:
+                    logger.debug(f"Failed to load script '{base_name}': {e}")
+
+        # Fall back to legacy JSON commands (use base_name for lookup)
+        lookup_name = base_name if lang_filter else cmd_name
         try:
             from mcli.lib.custom_commands import get_command_manager
 
@@ -161,7 +200,7 @@ class ScopedWorkflowsGroup(click.Group):
             # Find the workflow command
             for command_data in commands:
                 # Accept both "workflow" and "workflows" for backward compatibility
-                if command_data.get("name") == cmd_name and command_data.get("group") in [
+                if command_data.get("name") == lookup_name and command_data.get("group") in [
                     "workflow",
                     "workflows",
                 ]:
@@ -174,9 +213,9 @@ class ScopedWorkflowsGroup(click.Group):
                     else:
                         manager.register_command_with_click(command_data, temp_group)
 
-                    cmd = temp_group.commands.get(cmd_name)
+                    cmd = temp_group.commands.get(lookup_name)
                     if cmd:
-                        logger.debug(f"Loaded legacy JSON command: {cmd_name}")
+                        logger.debug(f"Loaded legacy JSON command: {lookup_name}")
                         return cmd
         except Exception as e:
             logger.debug(f"Could not load legacy command '{cmd_name}': {e}")

{mcli_framework-8.0.36 → mcli_framework-8.0.38}/src/mcli_framework.egg-info/PKG-INFO

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

@@ -431,6 +431,7 @@ tests/unit/test_git_commit_workflow.py
 tests/unit/test_health_cmd.py
 tests/unit/test_init_mv_cmd.py
 tests/unit/test_ipfs_retry.py
+tests/unit/test_language_suffix.py
 tests/unit/test_lib_auth.py
 tests/unit/test_lib_files.py
 tests/unit/test_lib_utils.py

{mcli_framework-8.0.36 → mcli_framework-8.0.38}/tests/cli/test_self_cmd_utilities.py

@@ -69,7 +69,7 @@ class TestLockfileUtilities:
                 json.dumps(test_data).splitlines()
             )
 
-            with open(temp_path, "r") as f:
+            with open(temp_path) as f:
                 result = json.load(f)
 
         assert result == test_data

{mcli_framework-8.0.36 → mcli_framework-8.0.38}/tests/fixtures/command_fixtures.py

@@ -29,7 +29,7 @@ class MockCommandResponse:
     duration_ms: float = 10.0
     exception: Optional[Exception] = None
 
-    def to_result(self, command: Optional[List[str]] = None) -> CommandResult:
+    def to_result(self, command: Optional[list[str]] = None) -> CommandResult:
         """Convert to a CommandResult object."""
         return CommandResult(
             returncode=self.returncode,
@@ -299,7 +299,7 @@ def capture_commands():
 
     class CommandCapture:
         def __init__(self):
-            self.commands: List[List[str]] = []
+            self.commands: list[list[str]] = []
             self._patches = []
 
         def _capture(self, args, **kwargs):

{mcli_framework-8.0.36 → mcli_framework-8.0.38}/tests/unit/test_custom_commands.py

@@ -63,7 +63,7 @@ class TestCustomCommandManager:
         assert path.name == "test_cmd.json"
 
         # Verify content
-        with open(path, "r") as f:
+        with open(path) as f:
             data = json.load(f)
 
         assert data["name"] == "test_cmd"
@@ -156,7 +156,7 @@ class TestCustomCommandManager:
         assert self.manager.lockfile_path.exists()
 
         # Load and verify
-        with open(self.manager.lockfile_path, "r") as f:
+        with open(self.manager.lockfile_path) as f:
             lockfile = json.load(f)
 
         assert "test_cmd" in lockfile["commands"]
@@ -241,7 +241,7 @@ class TestCustomCommandManager:
         assert export_path.exists()
 
         # Verify exported data
-        with open(export_path, "r") as f:
+        with open(export_path) as f:
             exported = json.load(f)
 
         assert len(exported) == 2
@@ -293,7 +293,7 @@ class TestCustomCommandManager:
         assert results["existing_cmd"] is False
 
         # Verify original code is unchanged
-        with open(self.commands_dir / "existing_cmd.json", "r") as f:
+        with open(self.commands_dir / "existing_cmd.json") as f:
             data = json.load(f)
         assert data["code"] == "original"
 
@@ -322,7 +322,7 @@ class TestCustomCommandManager:
         assert results["existing_cmd"] is True
 
         # Verify code is updated
-        with open(self.commands_dir / "existing_cmd.json", "r") as f:
+        with open(self.commands_dir / "existing_cmd.json") as f:
             data = json.load(f)
         assert data["code"] == "new code"