fix: P2 Issue 20 Implementation Complete: Exit Code Handling

Signed-off-by: habeck <habeck@us.ibm.com>

Author: tedhabeck

cpex/tools/cli.py

@@ -31,8 +31,7 @@
 import os
 import shutil
 import subprocess  # nosec B404 # Safe: Used only for git commands with hardcoded args
-
-# import sys
+import sys
 from pathlib import Path
 from typing import List, Optional
 
@@ -41,6 +40,13 @@
 from rich.console import Console
 from typing_extensions import Annotated
 
+# Exit codes for CLI commands
+EXIT_SUCCESS = 0
+EXIT_GENERAL_ERROR = 1
+EXIT_INVALID_ARGS = 2
+EXIT_NOT_FOUND = 3
+EXIT_OPERATION_FAILED = 4
+
 # First-Party
 from cpex.framework.loader.config import ConfigLoader, ConfigSaver
 from cpex.framework.models import (
@@ -237,11 +243,14 @@ def bootstrap(
                 extra_context=extra_context,
             )
         else:
-            logger.warning("No local templates found and git is not available to fetch remote template.")
+            logger.error("No local templates found and git is not available to fetch remote template.")
+            raise typer.Exit(EXIT_OPERATION_FAILED)
     except (SystemExit, typer.Exit):
         raise
-    except Exception:
+    except Exception as e:
         logger.exception("An error was caught while copying template.")
+        console.print(f":x: Failed to create plugin project: {str(e)}")
+        raise typer.Exit(EXIT_OPERATION_FAILED)
 
 
 def list(type: str, fmt: str = "text") -> None:
@@ -590,15 +599,20 @@ def install(source: str, install_type: str | None, catalog: PluginCatalog, assum
         assume_yes: Skip interactive selection prompt for monorepo installs.
 
     Raises:
-        ValueError: If install_type is not supported.
-        NotImplementedError: If the installation type is not yet implemented.
+        typer.Exit: With EXIT_INVALID_ARGS if install_type is not supported.
+        typer.Exit: With EXIT_OPERATION_FAILED if installation fails.
     """
     if install_type is None:
         install_type = "monorepo"
 
     if install_type == "monorepo":
-        _install_from_monorepo(source, catalog, assume_yes=assume_yes)
-        return
+        try:
+            _install_from_monorepo(source, catalog, assume_yes=assume_yes)
+            return
+        except Exception as e:
+            console.print(f":x: Installation failed: {str(e)}")
+            logger.error("Install error: %s", str(e), exc_info=True)
+            raise typer.Exit(EXIT_OPERATION_FAILED)
 
     handlers = {
         "git": _install_from_git,
@@ -609,9 +623,15 @@ def install(source: str, install_type: str | None, catalog: PluginCatalog, assum
 
     handler = handlers.get(install_type)
     if handler is None:
-        raise ValueError(f"Unsupported installation type: {install_type}. Must be one of: {', '.join(handlers.keys())}")
+        console.print(f":x: Unsupported installation type: {install_type}. Must be one of: {', '.join(handlers.keys())}")
+        raise typer.Exit(EXIT_INVALID_ARGS)
 
-    handler(source, catalog, use_test=True if install_type == "test-pypi" else False)
+    try:
+        handler(source, catalog, use_test=True if install_type == "test-pypi" else False)
+    except Exception as e:
+        console.print(f":x: Installation failed: {str(e)}")
+        logger.error("Install error: %s", str(e), exc_info=True)
+        raise typer.Exit(EXIT_OPERATION_FAILED)
 
 
 def versions(plugin_name: str | None, catalog: PluginCatalog, fmt: str = "text"):
@@ -717,7 +737,7 @@ def uninstall(plugin_name: str, catalog: PluginCatalog, assume_yes: bool = False
 
     if installed_plugin is None:
         console.print(f":x: Plugin '{plugin_name}' is not installed.")
-        return
+        raise typer.Exit(EXIT_NOT_FOUND)
 
     # Confirm uninstallation
     console.print(f"Found plugin: {installed_plugin.name} (version {installed_plugin.version})")
@@ -751,18 +771,27 @@ def uninstall(plugin_name: str, catalog: PluginCatalog, assume_yes: bool = False
                 plugin_registry.remove(plugin_name)
             else:
                 console.print(f":x: Plugin {plugin_name} not found in catalog.")
-                return
+                raise typer.Exit(EXIT_NOT_FOUND)
 
         console.print(f":white_heavy_check_mark: {plugin_name} uninstalled successfully.")
 
+    except typer.Exit:
+        raise
     except Exception as e:
         console.print(f":x: Failed to uninstall {plugin_name}: {str(e)}")
         logger.error("Uninstall error: %s", str(e), exc_info=True)
+        raise typer.Exit(EXIT_OPERATION_FAILED)
 
 
 @app.command(
     help="List, search, install or uninstall plugins.\n\n"
-    "\ndefault install type is monorepo\n"
+    "Exit Codes:\n"
+    "  0 - Success\n"
+    "  1 - General error\n"
+    "  2 - Invalid arguments\n"
+    "  3 - Plugin not found\n"
+    "  4 - Operation failed\n\n"
+    "Default install type is monorepo\n\n"
     "Examples:\n"
     "python cpex/tools/cli.py plugin info pii\n"
     "python cpex/tools/cli.py plugin search pii\n"
@@ -810,7 +839,7 @@ def plugin(
     if cmd_action == "uninstall":
         if source is None:
             console.print(":x: Please specify a plugin name to uninstall.")
-            return
+            raise typer.Exit(EXIT_INVALID_ARGS)
         pc = PluginCatalog()
         return uninstall(source, catalog=pc, assume_yes=assume_yes)
     if cmd_action == "install" and source is not None:

tests/unit/cpex/tools/test_cli.py

@@ -395,10 +395,12 @@ def test_warns_when_no_local_and_no_git(self):
             patch("cpex.tools.cli.command_exists", return_value=False),
             patch(_CC_PATCH_TARGET) as mock_cc,
             patch("cpex.tools.cli.logger") as mock_logger,
+            patch("cpex.tools.cli.console") as mock_console,
         ):
-            runner.invoke(app, ["bootstrap", "-d", "/tmp/test_nogit", "--no_input"])
+            result = runner.invoke(app, ["bootstrap", "-d", "/tmp/test_nogit", "--no_input"])
+            assert result.exit_code == 4  # EXIT_OPERATION_FAILED
             mock_cc.assert_not_called()
-            mock_logger.warning.assert_called_once()
+            mock_logger.error.assert_called_once()
 
 
 class TestBootstrapErrorHandling:
@@ -408,9 +410,10 @@ def test_logs_exception_on_cookiecutter_error(self):
         with (
             patch(_CC_PATCH_TARGET, side_effect=RuntimeError("template error")),
             patch("cpex.tools.cli.logger") as mock_logger,
+            patch("cpex.tools.cli.console") as mock_console,
         ):
             result = runner.invoke(app, ["bootstrap", "-d", "/tmp/test_err", "--no_input"])
-            assert result.exit_code == 0  # error is caught and logged
+            assert result.exit_code == 4  # EXIT_OPERATION_FAILED
             mock_logger.exception.assert_called_once()
 
 
@@ -845,10 +848,14 @@ def test_install_monorepo_with_available_plugins(self, temp_registry_dir):
             mock_catalog.install_folder_via_pip.assert_called_once()
 
     def test_install_requires_type_parameter(self):
-        """Test that install raises ValueError for unsupported type."""
+        """Test that install raises typer.Exit for unsupported type."""
         mock_catalog = Mock()
-        with pytest.raises(ValueError, match="Unsupported installation type"):
+        with (
+            patch("cpex.tools.cli.console") as mock_console,
+            pytest.raises(click.exceptions.Exit) as exc_info,
+        ):
             install("source", "", mock_catalog)
+        assert exc_info.value.exit_code == 2  # EXIT_INVALID_ARGS
 
 
 class TestSearchFunction:
@@ -1110,9 +1117,13 @@ def test_uninstall_plugin_not_found(self, temp_registry_dir):
         """Test uninstalling a plugin that is not installed."""
         mock_catalog = Mock()
 
-        with patch("cpex.tools.cli.console") as mock_console:
+        with (
+            patch("cpex.tools.cli.console") as mock_console,
+            pytest.raises(click.exceptions.Exit) as exc_info,
+        ):
             uninstall("nonexistent_plugin", mock_catalog)
-            mock_console.print.assert_called_with(":x: Plugin 'nonexistent_plugin' is not installed.")
+        assert exc_info.value.exit_code == 3  # EXIT_NOT_FOUND
+        mock_console.print.assert_called_with(":x: Plugin 'nonexistent_plugin' is not installed.")
 
     def test_uninstall_cancelled_by_user(self, temp_registry_dir):
         """Test uninstall cancelled by user."""
@@ -1211,33 +1222,35 @@ def test_uninstall_handles_exception(self, temp_registry_dir):
             ]
         }
         registry_file.write_text(json.dumps(registry_data))
-        
+
         mock_catalog = Mock()
-        
+
         # Create a manifest to return from find
         test_manifest = create_test_manifest(name="test_plugin", kind="native")
-        
+
         with (
             patch("cpex.tools.cli.inquirer.prompt", return_value={"confirm": True}),
             patch("cpex.tools.cli.console") as mock_console,
             patch("cpex.tools.cli.logger") as mock_logger,
             patch("cpex.tools.cli.PluginCatalog") as mock_catalog_class,
+            pytest.raises(click.exceptions.Exit) as exc_info,
         ):
             # Mock the catalog instance created inside uninstall()
             mock_catalog_instance = Mock()
             mock_catalog_instance.find = Mock(return_value=test_manifest)
             mock_catalog_instance.uninstall_package = Mock(side_effect=RuntimeError("Uninstall failed"))
             mock_catalog_class.return_value = mock_catalog_instance
-            
+
             mock_status = Mock()
             mock_status.__enter__ = Mock(return_value=mock_status)
             mock_status.__exit__ = Mock(return_value=False)
             mock_console.status = Mock(return_value=mock_status)
-            
+
             uninstall("test_plugin", mock_catalog)
-            
-            mock_console.print.assert_any_call(":x: Failed to uninstall test_plugin: Uninstall failed")
-            mock_logger.error.assert_called_once()
+
+        assert exc_info.value.exit_code == 4  # EXIT_OPERATION_FAILED
+        mock_console.print.assert_any_call(":x: Failed to uninstall test_plugin: Uninstall failed")
+        mock_logger.error.assert_called_once()
 
 
 class TestPluginUninstallCommand:
@@ -1251,9 +1264,9 @@ def test_plugin_uninstall_command_without_plugin_name(self, temp_registry_dir):
         ):
             mock_catalog = Mock()
             mock_catalog_class.return_value = mock_catalog
-            
+
             result = runner.invoke(app, ["plugin", "uninstall"])
-            assert result.exit_code == 0
+            assert result.exit_code == 2  # EXIT_INVALID_ARGS
             mock_console.print.assert_called_with(":x: Please specify a plugin name to uninstall.")
 
     def test_plugin_uninstall_command_success(self, temp_registry_dir):
@@ -1308,9 +1321,9 @@ def test_plugin_uninstall_command_not_found(self, temp_registry_dir):
         ):
             mock_catalog = Mock()
             mock_catalog_class.return_value = mock_catalog
-            
+
             result = runner.invoke(app, ["plugin", "uninstall", "nonexistent_plugin"])
-            assert result.exit_code == 0
+            assert result.exit_code == 3  # EXIT_NOT_FOUND
             mock_console.print.assert_called_with(":x: Plugin 'nonexistent_plugin' is not installed.")
 
 
@@ -1800,14 +1813,18 @@ class TestInstallFunctionAdditional:
     """Additional tests for install() function."""
 
     def test_install_with_unsupported_type_raises_error(self):
-        """Test that install raises ValueError for unsupported installation type."""
+        """Test that install raises typer.Exit for unsupported installation type."""
         from cpex.tools.cli import install
         from cpex.tools.catalog import PluginCatalog
 
         mock_catalog = Mock(spec=PluginCatalog)
 
-        with pytest.raises(ValueError, match="Unsupported installation type"):
+        with (
+            patch("cpex.tools.cli.console") as mock_console,
+            pytest.raises(click.exceptions.Exit) as exc_info,
+        ):
             install("test_plugin", "unsupported_type", mock_catalog)
+        assert exc_info.value.exit_code == 2  # EXIT_INVALID_ARGS
 
 
 class TestVersionsFunction:
@@ -1934,6 +1951,7 @@ def test_uninstall_when_manifest_not_found(self, temp_registry_dir):
             patch("cpex.tools.cli.inquirer.prompt", return_value={"confirm": True}),
             patch("cpex.tools.cli.console") as mock_console,
             patch("cpex.tools.cli.PluginCatalog") as mock_catalog_class,
+            pytest.raises(click.exceptions.Exit) as exc_info,
         ):
             # Mock the catalog.find method to return None (manifest not found)
             mock_catalog_instance = Mock()
@@ -1946,11 +1964,12 @@ def test_uninstall_when_manifest_not_found(self, temp_registry_dir):
             mock_console.status = Mock(return_value=mock_status)
 
             uninstall("test_plugin", mock_catalog)
-            
-            # When manifest is not found, uninstall should print error and return early
-            # So uninstall_package should NOT be called
-            mock_catalog_instance.uninstall_package.assert_not_called()
-            mock_console.print.assert_any_call(":x: Plugin test_plugin not found in catalog.")
+        
+        assert exc_info.value.exit_code == 3  # EXIT_NOT_FOUND
+        # When manifest is not found, uninstall should print error and exit
+        # So uninstall_package should NOT be called
+        mock_catalog_instance.uninstall_package.assert_not_called()
+        mock_console.print.assert_any_call(":x: Plugin test_plugin not found in catalog.")