mcli-framework 8.0.41__tar.gz → 8.0.43__tar.gz

{mcli_framework-8.0.41 → mcli_framework-8.0.43}/PKG-INFO

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

@@ -1,6 +1,6 @@
 [project]
 name = "mcli-framework"
-version = "8.0.41"
+version = "8.0.43"
 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.41 → mcli_framework-8.0.43}/src/mcli/app/init_cmd.py

@@ -252,7 +252,12 @@ Thumbs.db
     if git_root:
         table.add_row("Git Repository", str(git_root))
     table.add_row("Lockfile", str(lockfile_path))
-    table.add_row("Git Initialized", "Yes" if git and (workflows_dir / ".git").exists() else "No")
+    table.add_row("Git Tracked", "Yes" if in_git_repo else "No")
+    if git:
+        table.add_row(
+            "Workflows Git",
+            "Yes" if (workflows_dir / ".git").exists() else "No",
+        )
 
     console.print(table)
     console.print()

{mcli_framework-8.0.41 → mcli_framework-8.0.43}/src/mcli/app/new_cmd.py

@@ -12,8 +12,9 @@ Example:
 import json
 import os
 import re
+import shutil
 import stat
-import subprocess
+import subprocess  # nosec B404
 import sys
 import tempfile
 from pathlib import Path
@@ -269,7 +270,7 @@ def restructure_file_as_command(
         click.ClickException: If file cannot be read
     """
     try:
-        with open(file_path, "r", encoding="utf-8", errors="ignore") as f:
+        with open(file_path, encoding="utf-8", errors="ignore") as f:
             content = f.read()
     except OSError as e:
         logger.error(f"Failed to read file {file_path}: {e}")
@@ -329,9 +330,12 @@ def _get_python_template(t: ScriptTemplate) -> str:
 import click
 from typing import Optional, List
 from pathlib import Path
-from mcli.lib.logger.logger import get_logger
 
-logger = get_logger()
+try:
+    from mcli.lib.logger.logger import get_logger
+    logger = get_logger()
+except ImportError:
+    logger = None
 
 
 @click.group(name="{t.name}")
@@ -346,8 +350,13 @@ def app():
 @click.argument("name", default="World")
 def hello(name: str):
     """Example subcommand."""
-    logger.info(f"Hello, {{name}}!")
+    if logger:
+        logger.info(f"Hello, {{name}}!")
     click.echo(f"Hello, {{name}}!")
+
+
+if __name__ == "__main__":
+    app()
 '''
     else:
         return f'''#!/usr/bin/env python3
@@ -361,9 +370,12 @@ def hello(name: str):
 import click
 from typing import Optional, List
 from pathlib import Path
-from mcli.lib.logger.logger import get_logger
 
-logger = get_logger()
+try:
+    from mcli.lib.logger.logger import get_logger
+    logger = get_logger()
+except ImportError:
+    logger = None
 
 
 @click.command(name="{t.name}")
@@ -372,8 +384,13 @@ def {t.name}_command(name: str):
     """
     {t.description}
     """
-    logger.info(f"Hello, {{name}}! This is the {t.name} command.")
+    if logger:
+        logger.info(f"Hello, {{name}}! This is the {t.name} command.")
     click.echo(f"Hello, {{name}}! This is the {t.name} command.")
+
+
+if __name__ == "__main__":
+    {t.name}_command()
 '''
 
 
@@ -505,7 +522,7 @@ if (args.length > 0) {{
 
 def _get_ipynb_template(t: ScriptTemplate) -> str:
     """Generate Jupyter notebook template."""
-    notebook: Dict[str, Any] = {
+    notebook: dict[str, Any] = {
         "cells": [
             {
                 "cell_type": "markdown",
@@ -609,13 +626,13 @@ def open_editor_for_script(
         click.echo("Write your code and save the file to continue.")
         click.echo("Press Ctrl+C to cancel.")
 
-        result = subprocess.run([editor, temp_file_path], check=False)
+        result = subprocess.run([editor, temp_file_path], check=False)  # nosec B603
 
         if result.returncode != 0:
             click.echo("Editor exited with error. Command creation cancelled.")
             return None
 
-        with open(temp_file_path, "r") as f:
+        with open(temp_file_path) as f:
             edited_code = f.read()
 
         if not edited_code.strip():
@@ -642,8 +659,7 @@ def _find_editor() -> Optional[str]:
         return editor
 
     for common_editor in ["vim", "nano", "code", "subl", "atom", "emacs"]:
-        result = subprocess.run(["which", common_editor], capture_output=True)
-        if result.returncode == 0:
+        if shutil.which(common_editor):
             return common_editor
 
     return None
@@ -783,7 +799,7 @@ def new(
             description=description,
             cmd_version=cmd_version,
             template=template,
-            shell=shell,
+            shell=shell,  # nosec B604
             is_global=is_global,
             source_file=source_file,
         )
@@ -892,7 +908,7 @@ def _execute_new_command(
             cmd_version=cmd_version,
             language=language,
             command_type=command_type,
-            shell=shell,
+            shell=shell,  # nosec B604
             template=template,
             script_path=script_path,
         )
@@ -913,7 +929,7 @@ def _execute_new_command(
     _display_success_message(
         command_name=command_name,
         language=language,
-        shell=shell,
+        shell=shell,  # nosec B604
         saved_path=saved_path,
         command_group=command_group,
         is_global=is_global,
@@ -948,7 +964,7 @@ def _generate_or_edit_code(
         version=cmd_version,
         language=language,
         command_type=command_type,
-        shell=shell,
+        shell=shell,  # nosec B604
     )
 
     try:

{mcli_framework-8.0.41 → mcli_framework-8.0.43}/src/mcli/lib/constants/messages.py

@@ -1095,19 +1095,25 @@ class VenvMessages:
 
     # Info
     DETECTING_VENV = "Detecting Python environment..."
+    USING_OVERRIDE_VENV = "Using override venv: {path}"
     USING_LOCAL_VENV = "Using local venv: {path}"
-    USING_GLOBAL_VENV = "Using global MCLI venv: {path}"
+    USING_GLOBAL_VENV = "Using global venv: {path}"
     USING_SYSTEM_PYTHON = "Using system Python: {path}"
+    USING_SYSTEM_PYTHON_ENV_SET = "Using system Python (MCLI_USE_SYSTEM_PYTHON set)"
     CREATING_GLOBAL_VENV = "Creating global MCLI venv at {path}..."
     GLOBAL_VENV_CREATED = "Created global MCLI venv at {path}"
 
     # Dependency messages
+    NO_DEPS_SPECIFIED = "No dependencies specified"
     CHECKING_DEPS = "Checking dependencies for {script}..."
     DEPS_SATISFIED = "All dependencies satisfied"
     MISSING_DEPS = "Missing dependencies: {packages}"
     INSTALLING_DEPS = "Installing dependencies: {packages}"
     DEPS_INSTALLED = "Dependencies installed successfully"
 
+    # Non-interactive
+    NON_INTERACTIVE_AUTO_INSTALL = "Non-interactive mode detected, auto-installing dependencies"
+
     # Prompts
     PROMPT_INSTALL_DEPS = "Install missing dependencies to {venv}? [{packages}]"
 

{mcli_framework-8.0.41 → mcli_framework-8.0.43}/src/mcli/lib/pyenv/manager.py

@@ -5,7 +5,7 @@ including environment detection, dependency checking, and script execution.
 """
 
 import os
-import subprocess
+import subprocess  # nosec B404
 import sys
 from pathlib import Path
 from typing import Dict, List, Optional, Tuple
@@ -42,7 +42,7 @@ class PyEnvManager:
         self._resolved_venv: Optional[Path] = None
         self._resolved_source: Optional[str] = None
 
-    def resolve_environment(self) -> Tuple[Optional[Path], str]:
+    def resolve_environment(self) -> tuple[Optional[Path], str]:
         """Resolve which virtual environment to use.
 
         Resolution order:
@@ -65,14 +65,14 @@ class PyEnvManager:
             if venv_path.is_dir():
                 self._resolved_venv = venv_path
                 self._resolved_source = "override"
-                logger.debug(f"Using override venv: {venv_path}")
+                logger.debug(VenvMessages.USING_OVERRIDE_VENV.format(path=venv_path))
                 return venv_path, "override"
 
         # Check if user wants system Python
         if os.getenv(EnvVars.MCLI_USE_SYSTEM_PYTHON, "").lower() in ("true", "1", "yes"):
             self._resolved_venv = None
             self._resolved_source = "system"
-            logger.debug("Using system Python (MCLI_USE_SYSTEM_PYTHON set)")
+            logger.debug(VenvMessages.USING_SYSTEM_PYTHON_ENV_SET)
             return None, "system"
 
         # Try to find local venv
@@ -80,14 +80,14 @@ class PyEnvManager:
         if local_venv:
             self._resolved_venv = local_venv
             self._resolved_source = "local"
-            logger.debug(f"Using local venv: {local_venv}")
+            logger.debug(VenvMessages.USING_LOCAL_VENV.format(path=local_venv))
             return local_venv, "local"
 
         # Fall back to global venv
         global_venv = self.venv_manager.get_global_venv_path()
         self._resolved_venv = global_venv
         self._resolved_source = "global"
-        logger.debug(f"Using global venv: {global_venv}")
+        logger.debug(VenvMessages.USING_GLOBAL_VENV.format(path=global_venv))
         return global_venv, "global"
 
     def get_python_executable(self) -> Path:
@@ -105,7 +105,7 @@ class PyEnvManager:
 
     def check_and_install_deps(
         self,
-        requires: List[str],
+        requires: list[str],
         script_name: str,
         auto_install: bool = False,
     ) -> bool:
@@ -120,7 +120,7 @@ class PyEnvManager:
             True if all dependencies are satisfied or installed.
         """
         if not requires:
-            logger.debug("No dependencies specified")
+            logger.debug(VenvMessages.NO_DEPS_SPECIFIED)
             return True
 
         venv_path, source = self.resolve_environment()
@@ -155,6 +155,10 @@ class PyEnvManager:
 
         if auto_install or env_auto_install:
             should_install = True
+        elif not sys.stdin.isatty():
+            # Non-interactive context (piped input, CI, subprocess) — auto-install
+            logger.info(VenvMessages.NON_INTERACTIVE_AUTO_INSTALL)
+            should_install = True
         else:
             # Prompt user
             venv_display = str(venv_path) if venv_path else "system"
@@ -177,11 +181,14 @@ class PyEnvManager:
     def execute_in_venv(
         self,
         script_path: Path,
-        args: List[str],
-        env: Optional[Dict[str, str]] = None,
+        args: list[str],
+        env: Optional[dict[str, str]] = None,
     ) -> subprocess.CompletedProcess:
         """Execute a Python script in the resolved virtual environment.
 
+        When running in a TTY, stdio is inherited so interactive/TUI apps
+        (e.g. Textual, curses) work correctly. Otherwise output is captured.
+
         Args:
             script_path: Path to the Python script.
             args: Command line arguments for the script.
@@ -203,15 +210,21 @@ class PyEnvManager:
             exec_env.update(env)
 
         python_exe = self.get_python_executable()
+        cmd = [str(python_exe), str(script_path)] + args
 
-        return subprocess.run(
-            [str(python_exe), str(script_path)] + args,
-            env=exec_env,
-            capture_output=True,
-            text=True,
-        )
+        if sys.stdout.isatty():
+            # Interactive: inherit stdio so TUI frameworks work
+            return subprocess.run(cmd, env=exec_env)  # nosec B603
+        else:
+            # Non-interactive: capture output for piping
+            return subprocess.run(  # nosec B603
+                cmd,
+                env=exec_env,
+                capture_output=True,
+                text=True,
+            )
 
-    def get_status(self) -> Dict[str, str]:
+    def get_status(self) -> dict[str, str]:
         """Get the current environment status for display.
 
         Returns:

{mcli_framework-8.0.41 → mcli_framework-8.0.43}/src/mcli/lib/script_loader.py

@@ -518,7 +518,7 @@ class ScriptLoader:
                     ctx.exit(1)
                     return
 
-                # Execute in venv
+                # Execute in venv (inherits stdio when TTY, captures otherwise)
                 logger.info(f"Executing Python command in venv: {name}")
                 result = env_manager.execute_in_venv(
                     script_path,
@@ -526,6 +526,7 @@ class ScriptLoader:
                     env={"MCLI_COMMAND": name},
                 )
 
+                # Only echo captured output (non-TTY mode)
                 if result.stdout:
                     click.echo(result.stdout, nl=False)
                 if result.stderr:

{mcli_framework-8.0.41 → mcli_framework-8.0.43}/src/mcli_framework.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: mcli-framework
-Version: 8.0.41
+Version: 8.0.43
 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.41 → mcli_framework-8.0.43}/tests/unit/test_new_cmd.py

@@ -328,6 +328,35 @@ class TestGetTemplate:
         assert "def mycommand_command" in result
         assert "@click.command" in result
 
+    def test_python_template_standalone_has_main_guard(self):
+        """Standalone template includes if __name__ == '__main__' for subprocess compat."""
+        template = ScriptTemplate(
+            name="mycommand",
+            description="My command",
+            group="utils",
+            version="1.0.0",
+            language=ScriptLanguages.PYTHON,
+            command_type=CommandTypes.COMMAND,
+        )
+        result = get_template(template)
+        assert 'if __name__ == "__main__":' in result
+        assert "mycommand_command()" in result
+
+    def test_python_template_standalone_safe_logger_import(self):
+        """Standalone template uses try/except for mcli logger import."""
+        template = ScriptTemplate(
+            name="mycommand",
+            description="My command",
+            group="utils",
+            version="1.0.0",
+            language=ScriptLanguages.PYTHON,
+            command_type=CommandTypes.COMMAND,
+        )
+        result = get_template(template)
+        assert "try:" in result
+        assert "except ImportError:" in result
+        assert "from mcli.lib.logger.logger import get_logger" in result
+
     def test_python_template_group(self):
         """Generate Python command group template."""
         template = ScriptTemplate(
@@ -345,6 +374,34 @@ class TestGetTemplate:
         assert "def app():" in result
         assert "@app.command" in result
 
+    def test_python_template_group_has_main_guard(self):
+        """Group template includes if __name__ == '__main__' for subprocess compat."""
+        template = ScriptTemplate(
+            name="mygroup",
+            description="My group",
+            group="utils",
+            version="1.0.0",
+            language=ScriptLanguages.PYTHON,
+            command_type=CommandTypes.GROUP,
+        )
+        result = get_template(template)
+        assert 'if __name__ == "__main__":' in result
+        assert "app()" in result
+
+    def test_python_template_group_safe_logger_import(self):
+        """Group template uses try/except for mcli logger import."""
+        template = ScriptTemplate(
+            name="mygroup",
+            description="My group",
+            group="utils",
+            version="1.0.0",
+            language=ScriptLanguages.PYTHON,
+            command_type=CommandTypes.GROUP,
+        )
+        result = get_template(template)
+        assert "try:" in result
+        assert "except ImportError:" in result
+
     def test_shell_template(self):
         """Generate shell template."""
         template = ScriptTemplate(

{mcli_framework-8.0.41 → mcli_framework-8.0.43}/tests/unit/test_pyenv.py

@@ -339,6 +339,68 @@ class TestPyEnvManager:
                 assert status["source"] == "system"
 
 
+class TestCheckAndInstallDeps:
+    """Tests for PyEnvManager.check_and_install_deps non-interactive behavior."""
+
+    def test_auto_installs_when_stdin_not_tty(self):
+        """Auto-install deps when stdin is not a TTY (non-interactive)."""
+        from mcli.lib.pyenv import PyEnvManager
+
+        with tempfile.TemporaryDirectory() as tmpdir:
+            workspace = Path(tmpdir)
+
+            with patch.dict(os.environ, {"MCLI_USE_SYSTEM_PYTHON": "true"}):
+                manager = PyEnvManager(workspace_dir=workspace)
+
+                with (
+                    patch.object(manager, "resolve_environment", return_value=(None, "system")),
+                    patch.object(
+                        manager, "get_python_executable", return_value=Path(sys.executable)
+                    ),
+                    patch("mcli.lib.pyenv.manager.DependencyChecker") as mock_checker_cls,
+                    patch("sys.stdin") as mock_stdin,
+                ):
+                    mock_stdin.isatty.return_value = False
+                    mock_checker = mock_checker_cls.return_value
+                    mock_checker.parse_requires.return_value = ["fake-pkg"]
+                    mock_checker.check_installed.return_value = ([], ["fake-pkg"])
+                    mock_checker.install_packages.return_value = None
+
+                    result = manager.check_and_install_deps(["fake-pkg"], "test_script")
+
+                    assert result is True
+                    mock_checker.install_packages.assert_called_once()
+
+    def test_prompts_when_stdin_is_tty(self):
+        """Prompt user when stdin IS a TTY (interactive)."""
+        from mcli.lib.pyenv import PyEnvManager
+
+        with tempfile.TemporaryDirectory() as tmpdir:
+            workspace = Path(tmpdir)
+
+            with patch.dict(os.environ, {"MCLI_USE_SYSTEM_PYTHON": "true"}):
+                manager = PyEnvManager(workspace_dir=workspace)
+
+                with (
+                    patch.object(manager, "resolve_environment", return_value=(None, "system")),
+                    patch.object(
+                        manager, "get_python_executable", return_value=Path(sys.executable)
+                    ),
+                    patch("mcli.lib.pyenv.manager.DependencyChecker") as mock_checker_cls,
+                    patch("sys.stdin") as mock_stdin,
+                    patch("click.confirm", return_value=False) as mock_confirm,
+                ):
+                    mock_stdin.isatty.return_value = True
+                    mock_checker = mock_checker_cls.return_value
+                    mock_checker.parse_requires.return_value = ["fake-pkg"]
+                    mock_checker.check_installed.return_value = ([], ["fake-pkg"])
+
+                    result = manager.check_and_install_deps(["fake-pkg"], "test_script")
+
+                    assert result is False
+                    mock_confirm.assert_called_once()
+
+
 class TestPyEnvIntegration:
     """Integration tests for pyenv module."""