mcli-framework 7.0.4__tar.gz → 7.0.6__tar.gz

{mcli_framework-7.0.4 → mcli_framework-7.0.6}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: mcli-framework
-Version: 7.0.4
+Version: 7.0.6
 Summary: 🚀 High-performance CLI framework with Rust extensions, AI chat, and stunning visuals
 Author-email: Luis Fernandez de la Vara <luis@lefv.io>
 Maintainer-email: Luis Fernandez de la Vara <luis@lefv.io>

{mcli_framework-7.0.4 → mcli_framework-7.0.6}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "mcli-framework"
-version = "7.0.4"
+version = "7.0.6"
 description = "🚀 High-performance CLI framework with Rust extensions, AI chat, and stunning visuals"
 readme = "README.md"
 requires-python = ">=3.9"

{mcli_framework-7.0.4 → mcli_framework-7.0.6}/src/mcli/self/self_cmd.py

@@ -774,18 +774,15 @@ def logs(type: str, lines: int, follow: bool, date: str, grep: str, level: str):
     from datetime import datetime
     from pathlib import Path
 
-    # Find the logs directory
-    current_file = Path(__file__)
-    # Go up 5 levels: file -> self -> mcli -> src -> repo_root
-    project_root = current_file.parents[4]
-    logs_dir = project_root / "logs"
+    # Import get_logs_dir to get the correct logs directory
+    from mcli.lib.paths import get_logs_dir
 
-    # Alternative: try current working directory first
-    if not logs_dir.exists():
-        logs_dir = Path.cwd() / "logs"
+    # Get the logs directory (creates it if it doesn't exist)
+    logs_dir = get_logs_dir()
 
     if not logs_dir.exists():
         click.echo("❌ Logs directory not found", err=True)
+        click.echo(f"Expected location: {logs_dir}", err=True)
         return
 
     # Determine which log files to read
@@ -1275,16 +1272,33 @@ def update(check: bool, pre: bool, yes: bool, skip_ci_check: bool):
         # Install update
         console.print(f"[cyan]📦 Installing mcli {latest_version}...[/cyan]")
 
-        # Use pip to upgrade
-        cmd = [sys.executable, "-m", "pip", "install", "--upgrade", "mcli-framework"]
-        if pre:
-            cmd.append("--pre")
+        # Detect if we're running from a uv tool installation
+        # uv tool installations are typically in ~/.local/share/uv/tools/
+        is_uv_tool = ".local/share/uv/tools/" in sys.executable or \
+                     "\\AppData\\Local\\uv\\tools\\" in sys.executable
+
+        if is_uv_tool:
+            # Use uv tool install for uv tool environments
+            console.print("[dim]Detected uv tool installation, using 'uv tool install'[/dim]")
+            cmd = ["uv", "tool", "install", "--force", "mcli-framework"]
+            if pre:
+                # For pre-releases, we'd need to specify the version explicitly
+                # For now, --pre is not supported with uv tool install in this context
+                console.print("[yellow]⚠️  Pre-release flag not supported with uv tool install[/yellow]")
+        else:
+            # Use pip to upgrade for regular installations
+            cmd = [sys.executable, "-m", "pip", "install", "--upgrade", "mcli-framework"]
+            if pre:
+                cmd.append("--pre")
 
         result = subprocess.run(cmd, capture_output=True, text=True)
 
         if result.returncode == 0:
             console.print(f"[green]✅ Successfully updated to mcli {latest_version}![/green]")
-            console.print("[yellow]ℹ️  Restart your terminal or run 'hash -r' to use the new version[/yellow]")
+            if is_uv_tool:
+                console.print("[yellow]ℹ️  Run 'hash -r' to refresh your shell's command cache[/yellow]")
+            else:
+                console.print("[yellow]ℹ️  Restart your terminal or run 'hash -r' to use the new version[/yellow]")
         else:
             console.print(f"[red]❌ Update failed:[/red]")
             console.print(result.stderr)

{mcli_framework-7.0.4 → mcli_framework-7.0.6}/src/mcli_framework.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: mcli-framework
-Version: 7.0.4
+Version: 7.0.6
 Summary: 🚀 High-performance CLI framework with Rust extensions, AI chat, and stunning visuals
 Author-email: Luis Fernandez de la Vara <luis@lefv.io>
 Maintainer-email: Luis Fernandez de la Vara <luis@lefv.io>

mcli_framework-7.0.6/tests/test_self.py

@@ -0,0 +1,469 @@
+import pytest
+from click.testing import CliRunner
+from mcli.self.self_cmd import self_app
+
+
+def test_self_group_help():
+    runner = CliRunner()
+    result = runner.invoke(self_app, ['--help'])
+    assert result.exit_code == 0
+    assert 'Manage and extend the mcli application' in result.output
+
+
+def test_search_help():
+    runner = CliRunner()
+    result = runner.invoke(self_app, ['search', '--help'])
+    assert result.exit_code == 0
+    assert 'Usage:' in result.output
+
+
+def test_add_command_help():
+    runner = CliRunner()
+    result = runner.invoke(self_app, ['add-command', '--help'])
+    assert result.exit_code == 0
+    assert 'Generate a new command template' in result.output
+
+
+def test_add_command_missing_required():
+    runner = CliRunner()
+    result = runner.invoke(self_app, ['add-command'])
+    assert result.exit_code != 0
+    assert 'Missing argument' in result.output
+
+
+def test_plugin_help():
+    runner = CliRunner()
+    result = runner.invoke(self_app, ['plugin', '--help'])
+    assert result.exit_code == 0
+    assert 'Manage plugins for mcli' in result.output
+
+
+def test_plugin_add_help():
+    runner = CliRunner()
+    result = runner.invoke(self_app, ['plugin', 'add', '--help'])
+    assert result.exit_code == 0
+    assert 'PLUGIN_NAME' in result.output
+
+
+def test_plugin_add_missing_required():
+    runner = CliRunner()
+    result = runner.invoke(self_app, ['plugin', 'add'])
+    assert result.exit_code != 0
+    assert 'Missing argument' in result.output
+
+
+def test_plugin_remove_help():
+    runner = CliRunner()
+    result = runner.invoke(self_app, ['plugin', 'remove', '--help'])
+    assert result.exit_code == 0
+    assert 'PLUGIN_NAME' in result.output
+
+
+def test_plugin_remove_missing_required():
+    runner = CliRunner()
+    result = runner.invoke(self_app, ['plugin', 'remove'])
+    assert result.exit_code != 0
+    assert 'Missing argument' in result.output
+
+
+def test_plugin_update_help():
+    runner = CliRunner()
+    result = runner.invoke(self_app, ['plugin', 'update', '--help'])
+    assert result.exit_code == 0
+    assert 'PLUGIN_NAME' in result.output
+
+
+def test_plugin_update_missing_required():
+    runner = CliRunner()
+    result = runner.invoke(self_app, ['plugin', 'update'])
+    assert result.exit_code != 0
+    assert 'Missing argument' in result.output
+
+
+def test_logs_help():
+    """Test that logs command shows help text"""
+    runner = CliRunner()
+    result = runner.invoke(self_app, ['logs', '--help'])
+    assert result.exit_code == 0
+    assert 'Display runtime logs' in result.output
+
+
+def test_logs_uses_correct_directory():
+    """Test that logs command uses get_logs_dir() from mcli.lib.paths"""
+    from mcli.lib.paths import get_logs_dir
+    from pathlib import Path
+    import tempfile
+
+    runner = CliRunner()
+
+    # Get the expected logs directory
+    expected_logs_dir = get_logs_dir()
+
+    # The logs directory should be in ~/.mcli/logs
+    assert expected_logs_dir.exists()
+    assert str(expected_logs_dir).endswith('.mcli/logs') or str(expected_logs_dir).endswith('.mcli\\logs')
+
+    # Run the logs command - it should not error even if no log files exist
+    # (it will just show no logs, which is fine)
+    result = runner.invoke(self_app, ['logs'])
+
+    # Should not show "Logs directory not found" error
+    assert 'Logs directory not found' not in result.output
+
+
+def test_update_help():
+    """Test that update command shows help text"""
+    runner = CliRunner()
+    result = runner.invoke(self_app, ['update', '--help'])
+    assert result.exit_code == 0
+    assert 'Check for and install mcli updates' in result.output
+    assert '--check' in result.output
+    assert '--yes' in result.output
+    assert '--skip-ci-check' in result.output
+
+
+@pytest.fixture
+def mock_pypi_response():
+    """Mock PyPI API response"""
+    return {
+        "info": {
+            "version": "7.0.5",
+            "project_urls": {
+                "Changelog": "https://github.com/gwicho38/mcli/releases"
+            }
+        },
+        "releases": {
+            "7.0.4": [],
+            "7.0.5": []
+        }
+    }
+
+
+def test_update_check_already_latest(mock_pypi_response):
+    """Test update --check when already on latest version"""
+    from unittest.mock import patch, Mock
+
+    runner = CliRunner()
+
+    with patch('importlib.metadata.version') as mock_version, \
+         patch('requests.get') as mock_get:
+
+        # Mock current version same as latest
+        mock_version.return_value = "7.0.5"
+
+        # Mock PyPI response
+        mock_response = Mock()
+        mock_response.status_code = 200
+        mock_response.json.return_value = mock_pypi_response
+        mock_response.raise_for_status = Mock()
+        mock_get.return_value = mock_response
+
+        result = runner.invoke(self_app, ['update', '--check'])
+
+        assert result.exit_code == 0
+        assert "already on the latest version" in result.output.lower()
+
+
+def test_update_check_update_available(mock_pypi_response):
+    """Test update --check when update is available"""
+    from unittest.mock import patch, Mock
+
+    runner = CliRunner()
+
+    with patch('importlib.metadata.version') as mock_version, \
+         patch('requests.get') as mock_get:
+
+        # Mock current version older than latest
+        mock_version.return_value = "7.0.4"
+
+        # Mock PyPI response
+        mock_response = Mock()
+        mock_response.status_code = 200
+        mock_response.json.return_value = mock_pypi_response
+        mock_response.raise_for_status = Mock()
+        mock_get.return_value = mock_response
+
+        result = runner.invoke(self_app, ['update', '--check'])
+
+        assert result.exit_code == 0
+        assert "Update available" in result.output or "7.0.4" in result.output
+        assert "7.0.5" in result.output
+
+
+def test_update_install_with_yes_flag(mock_pypi_response):
+    """Test update installation with --yes flag"""
+    from unittest.mock import patch, Mock
+
+    runner = CliRunner()
+
+    with patch('importlib.metadata.version') as mock_version, \
+         patch('requests.get') as mock_get, \
+         patch('subprocess.run') as mock_subprocess, \
+         patch('mcli.self.self_cmd.check_ci_status') as mock_ci:
+
+        # Mock current version older than latest
+        mock_version.return_value = "7.0.4"
+
+        # Mock PyPI response
+        mock_response = Mock()
+        mock_response.status_code = 200
+        mock_response.json.return_value = mock_pypi_response
+        mock_response.raise_for_status = Mock()
+        mock_get.return_value = mock_response
+
+        # Mock CI passing
+        mock_ci.return_value = (True, None)
+
+        # Mock successful subprocess
+        mock_result = Mock()
+        mock_result.returncode = 0
+        mock_result.stderr = ""
+        mock_subprocess.return_value = mock_result
+
+        result = runner.invoke(self_app, ['update', '--yes'])
+
+        assert result.exit_code == 0
+        assert "Successfully updated" in result.output or "Installing" in result.output
+        mock_subprocess.assert_called_once()
+
+
+def test_update_cancelled_by_user(mock_pypi_response):
+    """Test update when user cancels at confirmation"""
+    from unittest.mock import patch, Mock
+
+    runner = CliRunner()
+
+    with patch('importlib.metadata.version') as mock_version, \
+         patch('requests.get') as mock_get, \
+         patch('mcli.self.self_cmd.check_ci_status') as mock_ci:
+
+        # Mock current version older than latest
+        mock_version.return_value = "7.0.4"
+
+        # Mock PyPI response
+        mock_response = Mock()
+        mock_response.status_code = 200
+        mock_response.json.return_value = mock_pypi_response
+        mock_response.raise_for_status = Mock()
+        mock_get.return_value = mock_response
+
+        # Mock CI passing
+        mock_ci.return_value = (True, None)
+
+        # User says no to update
+        result = runner.invoke(self_app, ['update'], input='n\n')
+
+        assert result.exit_code == 0
+        assert "cancelled" in result.output.lower()
+
+
+def test_update_ci_check_failing(mock_pypi_response):
+    """Test update blocked when CI is failing"""
+    from unittest.mock import patch, Mock
+
+    runner = CliRunner()
+
+    with patch('importlib.metadata.version') as mock_version, \
+         patch('requests.get') as mock_get, \
+         patch('mcli.self.self_cmd.check_ci_status') as mock_ci:
+
+        # Mock current version older than latest
+        mock_version.return_value = "7.0.4"
+
+        # Mock PyPI response
+        mock_response = Mock()
+        mock_response.status_code = 200
+        mock_response.json.return_value = mock_pypi_response
+        mock_response.raise_for_status = Mock()
+        mock_get.return_value = mock_response
+
+        # Mock CI failing
+        mock_ci.return_value = (False, "https://github.com/gwicho38/mcli/actions/runs/123")
+
+        result = runner.invoke(self_app, ['update', '--yes'])
+
+        assert result.exit_code == 0
+        assert "CI build is failing" in result.output or "blocked" in result.output.lower()
+
+
+def test_update_skip_ci_check(mock_pypi_response):
+    """Test update with --skip-ci-check flag"""
+    from unittest.mock import patch, Mock
+
+    runner = CliRunner()
+
+    with patch('importlib.metadata.version') as mock_version, \
+         patch('requests.get') as mock_get, \
+         patch('subprocess.run') as mock_subprocess, \
+         patch('mcli.self.self_cmd.check_ci_status') as mock_ci:
+
+        # Mock current version older than latest
+        mock_version.return_value = "7.0.4"
+
+        # Mock PyPI response
+        mock_response = Mock()
+        mock_response.status_code = 200
+        mock_response.json.return_value = mock_pypi_response
+        mock_response.raise_for_status = Mock()
+        mock_get.return_value = mock_response
+
+        # Mock successful subprocess
+        mock_result = Mock()
+        mock_result.returncode = 0
+        mock_result.stderr = ""
+        mock_subprocess.return_value = mock_result
+
+        result = runner.invoke(self_app, ['update', '--yes', '--skip-ci-check'])
+
+        assert result.exit_code == 0
+        # CI check should not be called when --skip-ci-check is used
+        mock_ci.assert_not_called()
+
+
+def test_update_pypi_connection_error(mock_pypi_response):
+    """Test update when PyPI connection fails"""
+    from unittest.mock import patch, Mock
+    import requests
+
+    runner = CliRunner()
+
+    with patch('importlib.metadata.version') as mock_version, \
+         patch('requests.get') as mock_get:
+
+        mock_version.return_value = "7.0.4"
+
+        # Mock connection error
+        mock_get.side_effect = requests.RequestException("Connection failed")
+
+        result = runner.invoke(self_app, ['update', '--check'])
+
+        assert result.exit_code == 0
+        assert "Error fetching version info" in result.output or "Error" in result.output
+
+
+def test_update_installation_failure(mock_pypi_response):
+    """Test update when pip installation fails"""
+    from unittest.mock import patch, Mock
+
+    runner = CliRunner()
+
+    with patch('importlib.metadata.version') as mock_version, \
+         patch('requests.get') as mock_get, \
+         patch('subprocess.run') as mock_subprocess, \
+         patch('mcli.self.self_cmd.check_ci_status') as mock_ci:
+
+        # Mock current version older than latest
+        mock_version.return_value = "7.0.4"
+
+        # Mock PyPI response
+        mock_response = Mock()
+        mock_response.status_code = 200
+        mock_response.json.return_value = mock_pypi_response
+        mock_response.raise_for_status = Mock()
+        mock_get.return_value = mock_response
+
+        # Mock CI passing
+        mock_ci.return_value = (True, None)
+
+        # Mock failed subprocess
+        mock_result = Mock()
+        mock_result.returncode = 1
+        mock_result.stderr = "Installation failed"
+        mock_subprocess.return_value = mock_result
+
+        result = runner.invoke(self_app, ['update', '--yes'])
+
+        assert result.exit_code == 0
+        assert "Update failed" in result.output or "failed" in result.output.lower()
+
+
+def test_update_uses_uv_tool_when_detected(mock_pypi_response):
+    """Test update uses 'uv tool install' when running from uv tool environment"""
+    from unittest.mock import patch, Mock
+    import sys
+
+    runner = CliRunner()
+
+    with patch('importlib.metadata.version') as mock_version, \
+         patch('requests.get') as mock_get, \
+         patch('subprocess.run') as mock_subprocess, \
+         patch('mcli.self.self_cmd.check_ci_status') as mock_ci, \
+         patch('sys.executable', '/Users/test/.local/share/uv/tools/mcli-framework/bin/python'):
+
+        # Mock current version older than latest
+        mock_version.return_value = "7.0.4"
+
+        # Mock PyPI response
+        mock_response = Mock()
+        mock_response.status_code = 200
+        mock_response.json.return_value = mock_pypi_response
+        mock_response.raise_for_status = Mock()
+        mock_get.return_value = mock_response
+
+        # Mock CI passing
+        mock_ci.return_value = (True, None)
+
+        # Mock successful subprocess
+        mock_result = Mock()
+        mock_result.returncode = 0
+        mock_result.stderr = ""
+        mock_subprocess.return_value = mock_result
+
+        result = runner.invoke(self_app, ['update', '--yes'])
+
+        assert result.exit_code == 0
+        assert "Successfully updated" in result.output
+
+        # Verify uv tool install was called
+        mock_subprocess.assert_called_once()
+        call_args = mock_subprocess.call_args[0][0]
+        assert call_args[0] == "uv"
+        assert call_args[1] == "tool"
+        assert call_args[2] == "install"
+        assert "--force" in call_args
+
+
+def test_update_uses_pip_when_not_uv_tool(mock_pypi_response):
+    """Test update uses pip when not running from uv tool environment"""
+    from unittest.mock import patch, Mock
+    import sys
+
+    runner = CliRunner()
+
+    with patch('importlib.metadata.version') as mock_version, \
+         patch('requests.get') as mock_get, \
+         patch('subprocess.run') as mock_subprocess, \
+         patch('mcli.self.self_cmd.check_ci_status') as mock_ci, \
+         patch('sys.executable', '/usr/local/bin/python3'):
+
+        # Mock current version older than latest
+        mock_version.return_value = "7.0.4"
+
+        # Mock PyPI response
+        mock_response = Mock()
+        mock_response.status_code = 200
+        mock_response.json.return_value = mock_pypi_response
+        mock_response.raise_for_status = Mock()
+        mock_get.return_value = mock_response
+
+        # Mock CI passing
+        mock_ci.return_value = (True, None)
+
+        # Mock successful subprocess
+        mock_result = Mock()
+        mock_result.returncode = 0
+        mock_result.stderr = ""
+        mock_subprocess.return_value = mock_result
+
+        result = runner.invoke(self_app, ['update', '--yes'])
+
+        assert result.exit_code == 0
+        assert "Successfully updated" in result.output
+
+        # Verify pip was called
+        mock_subprocess.assert_called_once()
+        call_args = mock_subprocess.call_args[0][0]
+        assert "-m" in call_args
+        assert "pip" in call_args
+        assert "install" in call_args
+        assert "--upgrade" in call_args

mcli_framework-7.0.4/tests/test_self.py

@@ -1,80 +0,0 @@
-import pytest
-from click.testing import CliRunner
-from mcli.self.self_cmd import self_app
-
-
-def test_self_group_help():
-    runner = CliRunner()
-    result = runner.invoke(self_app, ['--help'])
-    assert result.exit_code == 0
-    assert 'Manage and extend the mcli application' in result.output
-
-
-def test_search_help():
-    runner = CliRunner()
-    result = runner.invoke(self_app, ['search', '--help'])
-    assert result.exit_code == 0
-    assert 'Usage:' in result.output
-
-
-def test_add_command_help():
-    runner = CliRunner()
-    result = runner.invoke(self_app, ['add-command', '--help'])
-    assert result.exit_code == 0
-    assert 'Generate a new command template' in result.output
-
-
-def test_add_command_missing_required():
-    runner = CliRunner()
-    result = runner.invoke(self_app, ['add-command'])
-    assert result.exit_code != 0
-    assert 'Missing argument' in result.output
-
-
-def test_plugin_help():
-    runner = CliRunner()
-    result = runner.invoke(self_app, ['plugin', '--help'])
-    assert result.exit_code == 0
-    assert 'Manage plugins for mcli' in result.output
-
-
-def test_plugin_add_help():
-    runner = CliRunner()
-    result = runner.invoke(self_app, ['plugin', 'add', '--help'])
-    assert result.exit_code == 0
-    assert 'PLUGIN_NAME' in result.output
-
-
-def test_plugin_add_missing_required():
-    runner = CliRunner()
-    result = runner.invoke(self_app, ['plugin', 'add'])
-    assert result.exit_code != 0
-    assert 'Missing argument' in result.output
-
-
-def test_plugin_remove_help():
-    runner = CliRunner()
-    result = runner.invoke(self_app, ['plugin', 'remove', '--help'])
-    assert result.exit_code == 0
-    assert 'PLUGIN_NAME' in result.output
-
-
-def test_plugin_remove_missing_required():
-    runner = CliRunner()
-    result = runner.invoke(self_app, ['plugin', 'remove'])
-    assert result.exit_code != 0
-    assert 'Missing argument' in result.output
-
-
-def test_plugin_update_help():
-    runner = CliRunner()
-    result = runner.invoke(self_app, ['plugin', 'update', '--help'])
-    assert result.exit_code == 0
-    assert 'PLUGIN_NAME' in result.output
-
-
-def test_plugin_update_missing_required():
-    runner = CliRunner()
-    result = runner.invoke(self_app, ['plugin', 'update'])
-    assert result.exit_code != 0
-    assert 'Missing argument' in result.output