pysfi 0.1.11__py3-none-any.whl → 0.1.13__py3-none-any.whl

sfi/makepython/makepython.py

@@ -1,14 +1,28 @@
+"""MakePython: Automated Python project building and management tool.
+
+This module provides a command-line interface for common Python development tasks
+including building, testing, publishing, and version management.
+"""
+
 from __future__ import annotations
 
+__version__ = "0.2.0"
+__author__ = "pysfi Developers"
+__email__ = "developers@pysfi.org"
 import argparse
+import atexit
+import contextlib
+import json
 import logging
 import os
 import shutil
 import subprocess
 import sys
 from dataclasses import dataclass
+from enum import Enum
+from functools import cached_property
 from pathlib import Path
-from typing import Any, Callable
+from typing import Any, Callable, Final, Protocol
 
 if sys.version_info >= (3, 11):
     import tomllib
@@ -16,151 +30,417 @@ else:
     import tomli as tomllib  # type: ignore
 
 
-is_windows = sys.platform == "win32"
-is_linux = sys.platform == "linux"
-is_macos = sys.platform == "darwin"
+# Platform detection
+IS_WINDOWS: Final[bool] = sys.platform == "win32"
+IS_LINUX: Final[bool] = sys.platform == "linux"
+IS_MACOS: Final[bool] = sys.platform == "darwin"
 
-logging.basicConfig(level=logging.INFO, format="%(message)s")
+# Logging setup
+logging.basicConfig(
+    level=logging.INFO, format="%(asctime)s - %(name)s - %(levelname)s - %(message)s"
+)
 logger = logging.getLogger(__name__)
-cwd = Path.cwd()
+CURRENT_WORKING_DIR: Final[Path] = Path.cwd()
 
-_BUILD_COMMANDS = ["uv", "poetry", "hatch"]
+# Supported build tools
+_BUILD_COMMANDS: Final[list[str]] = ["uv", "poetry", "hatch"]
+CONFIG_FILE: Final[Path] = Path.home() / ".pysfi" / "makepython.json"
 
 
-def parse_pyproject_toml(directory: Path) -> dict:
-    """Parse pyproject.toml file in directory and return project data."""
-    project_toml = directory / "pyproject.toml"
-    if not project_toml.is_file():
-        logger.error(f"No pyproject.toml found in {directory}")
-        return {}
+class BuildTool(Enum):
+    """Enumeration of supported build tools."""
+
+    UV = "uv"
+    POETRY = "poetry"
+    HATCH = "hatch"
+
+
+class CommandType(Enum):
+    """Enumeration of command types."""
+
+    BUILD = "build"
+    CLEAN = "clean"
+    TEST = "test"
+    PUBLISH = "publish"
+    BUMP_VERSION = "bumpversion"
+    TOKEN = "token"
 
-    try:
-        with project_toml.open("rb") as f:
-            return tomllib.load(f)
-    except Exception as e:
-        logger.error(f"Error parsing pyproject.toml: {e}")
-        return {}
+
+@dataclass
+class ProjectInfo:
+    """Information about the current Python project."""
+
+    name: str
+    version: str
+    build_tool: BuildTool | None = None
+    has_tests: bool = False
+    has_benchmarks: bool = False
+
+    @classmethod
+    def from_pyproject(cls, directory: Path) -> ProjectInfo | None:
+        """Create ProjectInfo from pyproject.toml file."""
+        pyproject_path = directory / "pyproject.toml"
+        if not pyproject_path.exists():
+            return None
+
+        try:
+            with pyproject_path.open("rb") as f:
+                data = tomllib.load(f)
+
+            project_data = data.get("project", {})
+            name = project_data.get("name", directory.name)
+            version = project_data.get("version", "0.1.0")
+
+            # Detect build tool
+            build_tool = None
+            if "build-system" in data:
+                backend = data["build-system"].get("build-backend", "")
+                if backend.startswith("poetry."):
+                    build_tool = BuildTool.POETRY
+                elif backend.startswith("hatchling."):
+                    build_tool = BuildTool.HATCH
+                else:
+                    build_tool = BuildTool.UV
+
+            # Check for tests and benchmarks
+            tests_dir = directory / "tests"
+            has_tests = tests_dir.exists() and tests_dir.is_dir()
+
+            benchmarks_dir = directory / "tests" / "benchmarks"
+            has_benchmarks = benchmarks_dir.exists() and benchmarks_dir.is_dir()
+
+            return cls(
+                name=name,
+                version=version,
+                build_tool=build_tool,
+                has_tests=has_tests,
+                has_benchmarks=has_benchmarks,
+            )
+        except Exception as e:
+            logger.warning(f"Failed to parse pyproject.toml: {e}")
+            return None
+
+
+@dataclass
+class MakePythonConfig:
+    """Configuration for MakePython tool."""
+
+    default_build_tool: BuildTool = BuildTool.UV
+    auto_detect_tool: bool = True
+    verbose_output: bool = False
+    max_retries: int = 3
+    timeout_seconds: int = 300
+
+    def __post_init__(self) -> None:
+        """Initialize configuration after creation."""
+        self._load_from_file()
+        atexit.register(self.save)
+
+    def _load_from_file(self) -> None:
+        """Load configuration from file if it exists."""
+        if not CONFIG_FILE.exists():
+            return
+
+        try:
+            config_data = json.loads(CONFIG_FILE.read_text(encoding="utf-8"))
+            for key, value in config_data.items():
+                if hasattr(self, key):
+                    if key == "default_build_tool":
+                        setattr(self, key, BuildTool(value))
+                    else:
+                        setattr(self, key, value)
+        except (json.JSONDecodeError, TypeError, AttributeError) as e:
+            logger.warning(f"Could not load config from {CONFIG_FILE}: {e}")
+
+    def save(self) -> None:
+        """Save current configuration to file."""
+        try:
+            CONFIG_FILE.parent.mkdir(parents=True, exist_ok=True)
+            config_dict = {
+                "default_build_tool": self.default_build_tool.value,
+                "auto_detect_tool": self.auto_detect_tool,
+                "verbose_output": self.verbose_output,
+                "max_retries": self.max_retries,
+                "timeout_seconds": self.timeout_seconds,
+            }
+            CONFIG_FILE.write_text(json.dumps(config_dict, indent=4), encoding="utf-8")
+            logger.debug(f"Configuration saved to {CONFIG_FILE}")
+        except OSError as e:
+            logger.error(f"Failed to save configuration: {e}")
+
+    @cached_property
+    def supported_tools(self) -> list[BuildTool]:
+        """Get list of available build tools."""
+        available_tools = []
+        for tool in BuildTool:
+            if shutil.which(tool.value):
+                available_tools.append(tool)
+        return available_tools
+
+
+class CommandExecutor(Protocol):
+    """Protocol for command execution."""
+
+    def execute(
+        self, command: list[str], cwd: Path
+    ) -> subprocess.CompletedProcess[str]: ...
+
+
+class SubprocessExecutor:
+    """Execute commands using subprocess."""
+
+    def __init__(self, config: MakePythonConfig):
+        self.config = config
+
+    def execute(
+        self, command: list[str], cwd: Path
+    ) -> subprocess.CompletedProcess[str]:
+        """Execute command with proper error handling."""
+        logger.debug(f"Executing command: {' '.join(command)} in {cwd}")
+
+        try:
+            result = subprocess.run(
+                command,
+                cwd=cwd,
+                capture_output=True,
+                text=True,
+                encoding="utf-8",
+                errors="replace",
+                timeout=self.config.timeout_seconds,
+                check=True,
+            )
+            return result
+        except subprocess.TimeoutExpired:
+            logger.error(
+                f"Command timed out after {self.config.timeout_seconds} seconds"
+            )
+            raise
+        except subprocess.CalledProcessError as e:
+            logger.error(f"Command failed with exit code {e.returncode}")
+            if e.stdout:
+                logger.error(f"STDOUT: {e.stdout}")
+            if e.stderr:
+                logger.error(f"STDERR: {e.stderr}")
+            raise
+        except Exception as e:
+            logger.error(f"Unexpected error executing command: {e}")
+            raise
 
 
 def _get_build_command_from_toml(directory: Path) -> str | None:
     """Get build command from pyproject.toml."""
     logger.debug(f"Parsing pyproject.toml in {directory}")
 
-    project_data = parse_pyproject_toml(directory)
-    if not project_data:
+    project_info = ProjectInfo.from_pyproject(directory)
+    if not project_info or not project_info.build_tool:
         return None
 
-    if "build-system" in project_data:
-        build_system = project_data["build-system"]
-        if "build-backend" in build_system:
-            build_backend = build_system["build-backend"]
-            if build_backend.startswith("poetry."):
-                return "poetry"
-            elif build_backend.startswith("hatchling."):
-                return "hatch"
-            else:
-                logger.error(f"Unknown build-backend: {build_backend}")
-                return None
-
-    logger.error("No `build-system` or `build-backend` found in pyproject.toml")
-    return None
+    return project_info.build_tool.value
+
 
+def _get_build_command(directory: Path, config: MakePythonConfig) -> str | None:
+    """Get build command from directory using configuration.
 
-def _get_build_command(directory: Path) -> str | None:
-    """Get build command from directory."""
-    project_path = directory / "pyproject.toml"
-    if project_path.is_file():
-        logger.debug(f"Found pyproject.toml in {directory}")
-        return _get_build_command_from_toml(directory)
+    Args:
+        directory: Directory to search for project configuration
+        config: MakePython configuration object
+
+    Returns:
+        Build command string or None if not found
+    """
+    project_info = ProjectInfo.from_pyproject(directory)
+    if project_info and project_info.build_tool:
+        logger.debug(f"Detected build tool: {project_info.build_tool.value}")
+        return project_info.build_tool.value
+
+    # Fallback to available tools
+    if config.supported_tools:
+        selected_tool = config.supported_tools[0]
+        logger.debug(f"Using available build tool: {selected_tool.value}")
+        return selected_tool.value
 
-    for command in _BUILD_COMMANDS:
-        if shutil.which(command):
-            logger.debug(f"Found build command: {command}")
-            return command
     logger.error(f"No build command found in {directory}")
+    logger.error("Please install uv, poetry, or hatch")
     sys.exit(1)
     return None
 
 
 @dataclass
 class Command:
+    """Represents a command that can be executed."""
+
     name: str
     alias: str
+    command_type: CommandType
     cmds: list[str] | Callable[..., Any] | None = None
+    description: str = ""
 
 
-def _clean(root_dir: Path = cwd):
-    _run_command(["rm", "-rf", "dist", "build", "*.egg-info"], root_dir)
+def _clean(root_dir: Path = CURRENT_WORKING_DIR) -> None:
+    """Clean build artifacts and temporary files."""
+    clean_commands = [
+        ["rm", "-rf", "dist"],
+        ["rm", "-rf", "build"],
+        ["rm", "-rf", "*.egg-info"],
+    ]
+
+    for cmd in clean_commands:
+        with contextlib.suppress(subprocess.CalledProcessError):
+            subprocess.run(cmd, cwd=root_dir, capture_output=True, check=True)
 
 
 def main() -> None:
+    """Main entry point for MakePython tool."""
+    # Initialize configuration
+    config = MakePythonConfig()
+
     # Get build command
-    build_command = _get_build_command(cwd) or ""
+    build_command = _get_build_command(CURRENT_WORKING_DIR, config) or ""
+    # Create commands with proper structure
     commands = [
-        Command(name="build", alias="b", cmds=[build_command, "build"]),
-        Command(name="bumpversion", alias="bump", cmds=["bumpversion", "patch", "--tag"]),
-        Command(name="clean", alias="c", cmds=_clean),
-        Command(name="publish", alias="p"),  # No preset commands
-        Command(name="test", alias="t", cmds=lambda: os.system("pytest")),
-        Command(name="test-benchmark", alias="tb", cmds=lambda: os.system("pytest -m benchmark")),
-        Command(name="test-coverage", alias="tc", cmds=lambda: os.system("pytest --cov=sfi")),
-        Command(name="token", alias="tk", cmds=lambda: _set_token(build_command)),
+        Command(
+            name="build",
+            alias="b",
+            command_type=CommandType.BUILD,
+            cmds=[build_command, "build"],
+            description="Build the project",
+        ),
+        Command(
+            name="bumpversion",
+            alias="bump",
+            command_type=CommandType.BUMP_VERSION,
+            cmds=["bumpversion", "patch", "--tag"],
+            description="Bump project version",
+        ),
+        Command(
+            name="clean",
+            alias="c",
+            command_type=CommandType.CLEAN,
+            cmds=_clean,
+            description="Clean build artifacts",
+        ),
+        Command(
+            name="publish",
+            alias="p",
+            command_type=CommandType.PUBLISH,
+            description="Publish package to PyPI",
+        ),
+        Command(
+            name="test",
+            alias="t",
+            command_type=CommandType.TEST,
+            cmds=lambda: os.system("pytest"),
+            description="Run tests",
+        ),
+        Command(
+            name="test-benchmark",
+            alias="tb",
+            command_type=CommandType.TEST,
+            cmds=lambda: os.system("pytest -m benchmark"),
+            description="Run benchmark tests",
+        ),
+        Command(
+            name="test-coverage",
+            alias="tc",
+            command_type=CommandType.TEST,
+            cmds=lambda: os.system("pytest --cov=sfi"),
+            description="Run tests with coverage",
+        ),
+        Command(
+            name="token",
+            alias="tk",
+            command_type=CommandType.TOKEN,
+            cmds=lambda: _set_token(build_command),
+            description="Set PyPI token",
+        ),
     ]
     command_dict = {command.name: command for command in commands}
     command_dict.update({command.alias: command for command in commands})
     choices = [command.alias for command in commands]
     choices.extend([command.name for command in commands])
 
-    # Parse args
-    parser = argparse.ArgumentParser(description="Make Python")
-    parser.add_argument("--debug", "-d", action="store_true", help="Enable debug mode")
-    parser.add_argument("command", type=str, choices=choices, help=f"Command to run, options: {choices}")
+    # Parse arguments
+    parser = argparse.ArgumentParser(
+        prog="makepython",
+        description="Automated Python project building and management tool",
+    )
+    parser.add_argument(
+        "--debug",
+        "-d",
+        action="store_true",
+        help="Enable debug mode with verbose output",
+    )
+    parser.add_argument(
+        "--verbose", "-v", action="store_true", help="Enable verbose output"
+    )
+    parser.add_argument(
+        "command",
+        type=str,
+        choices=choices,
+        help=f"Command to run. Options: {', '.join(choices)}",
+    )
     args = parser.parse_args()
+
+    # Set logging level
     if args.debug:
         logger.setLevel(logging.DEBUG)
+        config.verbose_output = True
+    elif args.verbose:
+        logger.setLevel(logging.INFO)
+        config.verbose_output = True
 
     logger.debug(f"Using build command: {build_command}")
+
+    # Execute command
     command = command_dict.get(args.command)
     if command:
         if callable(command.cmds):
             command.cmds()
         elif isinstance(command.cmds, list):
-            _run_command(command.cmds, cwd)
+            _run_command(command.cmds, CURRENT_WORKING_DIR)
         else:
-            logger.debug("No preset commands found")
+            logger.debug("No preset commands found for this command type")
     else:
         logger.error(f"Unknown command: {args.command}")
         sys.exit(1)
 
+    # Special handling for publish command
     if args.command in {"publish", "p"}:
         if not _check_pypi_token(build_command):
             _set_token(build_command)
-        _run_command([build_command, "publish"], cwd)
+        _run_command([build_command, "publish"], CURRENT_WORKING_DIR)
 
 
 def _set_token(build_command: str, show_header: bool = True) -> None:
-    """Set PyPI token for the specified build command."""
+    """Set PyPI token for the specified build command.
+
+    Args:
+        build_command: The build tool to configure (uv, poetry, hatch)
+        show_header: Whether to show the header message
+    """
     if show_header:
         logger.info(f"Setting PyPI token for {build_command}...")
 
-    if build_command.lower() not in _BUILD_COMMANDS:
+    if build_command.lower() not in [tool.value for tool in BuildTool]:
         logger.error(f"Unknown build command: {build_command}")
-        logger.error(f"Please use `{'/'.join(_BUILD_COMMANDS)}`")
+        logger.error(f"Please use one of: {[tool.value for tool in BuildTool]}")
         sys.exit(1)
 
     token = input("Enter your PyPI token (leave empty to cancel): ").strip()
     if not token:
-        logger.info("Invalid token, cancelled.")
+        logger.info("Operation cancelled - no token provided.")
         return
 
-    if build_command == "uv":
-        _set_uv_token(token)
-    elif build_command == "poetry":
-        _set_poetry_token(token)
-    elif build_command == "hatch":
-        _set_hatch_token(token)
-    else:
-        logger.error(f"Unknown build command: {build_command}")
+    try:
+        if build_command == BuildTool.UV.value:
+            _set_uv_token(token)
+        elif build_command == BuildTool.POETRY.value:
+            _set_poetry_token(token)
+        elif build_command == BuildTool.HATCH.value:
+            _set_hatch_token(token)
+        logger.info("PyPI token configured successfully!")
+    except Exception as e:
+        logger.error(f"Failed to set token: {e}")
         sys.exit(1)
 
 
@@ -181,7 +461,7 @@ token = "{token}"
 def _set_poetry_token(token: str) -> None:
     """Set PyPI token for poetry."""
     _write_to_env_file("POETRY_PYPI_TOKEN_PYPI", token)
-    _run_command(["poetry", "config", "pypi-token.pypi", token], cwd)
+    _run_command(["poetry", "config", "pypi-token.pypi", token], CURRENT_WORKING_DIR)
     logger.info("Token saved to Poetry configuration.")
 
 
@@ -197,71 +477,168 @@ password = {token}
     logger.info(f"Token saved to {pypirc_path}")
 
 
-def _check_pypi_token(build_command: str) -> bool:
-    """Check if PyPI token is configured before publishing."""
-    logger.info("Checking PyPI token configuration...")
+def _check_uv_token() -> bool:
+    """Check if PyPI token is configured for uv."""
+    # Check environment variables
+    token_env_vars = ["UV_PUBLISH_TOKEN", "PYPI_API_TOKEN"]
+    for var in token_env_vars:
+        if os.getenv(var):
+            logger.info(f"Found PyPI token in environment variable: {var}")
+            return True
+
+    # Check config file
+    config_path = Path.home() / ".config" / "uv" / "uv.toml"
+    if config_path.exists():
+        logger.info(f"Found uv config file: {config_path}")
+        return True
+
+    return False
+
 
-    token_found = False
-    if build_command == "uv":
-        # Check for uv publish token
-        token_env_vars = ["UV_PUBLISH_TOKEN", "PYPI_API_TOKEN"]
-        for var in token_env_vars:
-            if os.getenv(var):
-                logger.info(f"Found PyPI token in environment variable: {var}")
-                token_found = True
-                break
-
-        # Check for config file
-        config_path = Path.home() / ".config" / "uv" / "uv.toml"
-        if config_path.exists():
-            logger.info(f"Found uv config file: {config_path}")
-            token_found = True
-
-    elif build_command == "poetry":
-        # Check for poetry token
-        if os.getenv("POETRY_PYPI_TOKEN_PYPI"):
-            logger.info("Found PyPI token in POETRY_PYPI_TOKEN_PYPI environment variable")
-            token_found = True
-
-        # Check for poetry config
+def _check_poetry_token() -> bool:
+    """Check if PyPI token is configured for poetry."""
+    # Check environment variable
+    if os.getenv("POETRY_PYPI_TOKEN_PYPI"):
+        logger.info("Found PyPI token in POETRY_PYPI_TOKEN_PYPI environment variable")
+        return True
+
+    # Check poetry config
+    try:
         result = subprocess.run(
             ["poetry", "config", "pypi-token.pypi"],
             capture_output=True,
             text=True,
+            encoding="utf-8",
+            errors="replace",
+            check=True,
         )
         if result.stdout.strip() and result.stdout.strip() != "None":
             logger.info("Found PyPI token in Poetry configuration")
-            token_found = True
+            return True
+    except (subprocess.CalledProcessError, Exception) as e:
+        logger.error(f"Error checking Poetry token: {e}")
 
-    elif build_command == "hatch":
-        # Check for .pypirc
-        pypirc_path = Path.home() / ".pypirc"
-        if pypirc_path.exists():
-            logger.info(f"Found .pypirc file: {pypirc_path}")
-            token_found = True
+    return False
 
-    return token_found
 
+def _check_hatch_token() -> bool:
+    """Check if PyPI token is configured for hatch."""
+    pypirc_path = Path.home() / ".pypirc"
+    if pypirc_path.exists():
+        logger.info(f"Found .pypirc file: {pypirc_path}")
+        return True
+    return False
 
-def _run_command(cmd: list[str], directory: Path) -> None:
-    """Run a command in the specified directory."""
-    logger.debug(f"Running command: {' '.join(cmd)}")
-    try:
-        result = subprocess.run(cmd, cwd=directory, capture_output=True, text=True)
-    except subprocess.CalledProcessError as e:
-        logger.error(f"Command failed with exit code {e.returncode}")
-        sys.exit(e.returncode)
 
+def _check_pypi_token(build_command: str) -> bool:
+    """Check if PyPI token is configured before publishing."""
+    logger.info("Checking PyPI token configuration...")
+
+    # Map build commands to their respective check functions
+    checker_map = {
+        "uv": _check_uv_token,
+        "poetry": _check_poetry_token,
+        "hatch": _check_hatch_token,
+    }
+
+    checker = checker_map.get(build_command.lower())
+    if not checker:
+        logger.error(f"Unknown build command for token checking: {build_command}")
+        return False
+
+    return checker()
+
+
+def _execute_subprocess(
+    cmd: list[str], directory: Path, encoding: str = "utf-8"
+) -> subprocess.CompletedProcess[str]:
+    """Execute subprocess with specified encoding."""
+    return subprocess.run(
+        cmd,
+        cwd=directory,
+        capture_output=True,
+        text=True,
+        encoding=encoding,
+        errors="replace",
+        check=True,
+    )
+
+
+def _handle_command_result(result: subprocess.CompletedProcess[str]) -> None:
+    """Handle and output command results."""
     if result.stdout:
         print(result.stdout)
     if result.stderr:
         print(result.stderr, file=sys.stderr)
 
 
+def _handle_called_process_error(e: subprocess.CalledProcessError) -> None:
+    """Handle CalledProcessError and exit."""
+    logger.error(f"Command failed with exit code {e.returncode}")
+    if e.stdout:
+        logger.error(f"STDOUT: {e.stdout}")
+    if e.stderr:
+        logger.error(f"STDERR: {e.stderr}")
+    sys.exit(e.returncode)
+
+
+def _handle_unicode_decode_error(
+    cmd: list[str], directory: Path, error: UnicodeDecodeError
+) -> None:
+    """Handle UnicodeDecodeError with fallback encoding."""
+    logger.error(f"Encoding error while processing command output: {error}")
+    try:
+        result = _execute_subprocess(cmd, directory, "gbk" if IS_WINDOWS else "utf-8")
+        _handle_command_result(result)
+    except Exception as fallback_error:
+        logger.error(f"Fallback encoding also failed: {fallback_error}")
+        sys.exit(1)
+
+
+def _run_command(cmd: list[str], directory: Path) -> None:
+    """Run a command in the specified directory with proper error handling.
+
+    Args:
+        cmd: Command to execute as list of arguments
+        directory: Directory to run the command in
+
+    Raises:
+        SystemExit: If command fails to execute
+    """
+    logger.debug(f"Running command: {' '.join(cmd)} in {directory}")
+
+    try:
+        result = _execute_subprocess(cmd, directory)
+        _handle_command_result(result)
+    except subprocess.CalledProcessError as e:
+        _handle_called_process_error(e)
+    except UnicodeDecodeError as e:
+        _handle_unicode_decode_error(cmd, directory, e)
+    except Exception as e:
+        logger.error(f"Unexpected error executing command: {e}")
+        sys.exit(1)
+
+
 def _write_to_env_file(key: str, value: str) -> None:
-    """Write key-value pair to environment file."""
-    if is_windows:
-        subprocess.run(["setx", key, value], shell=True)
+    """Write key-value pair to environment file.
+
+    Args:
+        key: Environment variable name
+        value: Environment variable value
+    """
+    if IS_WINDOWS:
+        try:
+            subprocess.run(
+                ["setx", key, value],
+                shell=True,
+                encoding="utf-8",
+                errors="replace",
+                check=True,
+            )
+            logger.info(f"Environment variable {key} set successfully")
+        except Exception as e:
+            logger.warning(f"Failed to set environment variable {key}: {e}")
+            logger.info("You may need to restart your shell for changes to take effect")
     else:
         _write_to_shell_config(f"export {key}='{value}'")
 
@@ -296,7 +673,9 @@ def _write_to_shell_config(content: str) -> None:
             break
 
     if not var_name:
-        logger.error("Invalid export statement format. Expected: export VARIABLE_NAME=value")
+        logger.error(
+            "Invalid export statement format. Expected: export VARIABLE_NAME=value"
+        )
         return
 
     # Read existing content
@@ -307,7 +686,9 @@ def _write_to_shell_config(content: str) -> None:
     found_existing = False
     for line in existing_lines:
         # Check if this line exports the same variable
-        if line.strip().startswith(f"export {var_name}=") or line.strip().startswith(f"export {var_name} ="):
+        if line.strip().startswith(f"export {var_name}=") or line.strip().startswith(
+            f"export {var_name} ="
+        ):
             found_existing = True
             continue
         new_lines.append(line)
@@ -324,4 +705,6 @@ def _write_to_shell_config(content: str) -> None:
     logger.info(f"Content written to {config_path}")
     logger.info(f"Run `source {config_path}` to apply the changes")
     logger.info(f"Run `cat {config_path}` to view the content")
-    logger.info(f"Run `cat {config_path} | grep 'export'` to view the exported variables")
+    logger.info(
+        f"Run `cat {config_path} | grep 'export'` to view the exported variables"
+    )