glaip-sdk 0.1.0__py3-none-any.whl → 0.6.10__py3-none-any.whl

glaip_sdk/cli/main.py

@@ -4,7 +4,7 @@ Authors:
     Raymond Christopher (raymond.christopher@gdplabs.id)
 """
 
-import os
+import logging
 import subprocess
 import sys
 from typing import Any
@@ -13,7 +13,6 @@ import click
 from rich.console import Console
 
 from glaip_sdk import Client
-from glaip_sdk._version import __version__ as _SDK_VERSION
 from glaip_sdk.branding import (
     ERROR,
     ERROR_STYLE,
@@ -26,6 +25,9 @@ from glaip_sdk.branding import (
     WARNING_STYLE,
     AIPBranding,
 )
+from glaip_sdk.cli.account_store import get_account_store
+from glaip_sdk.cli.auth import resolve_credentials
+from glaip_sdk.cli.commands.accounts import accounts_group
 from glaip_sdk.cli.commands.agents import agents_group
 from glaip_sdk.cli.commands.configure import (
     config_group,
@@ -34,17 +36,37 @@ from glaip_sdk.cli.commands.configure import (
 from glaip_sdk.cli.commands.mcps import mcps_group
 from glaip_sdk.cli.commands.models import models_group
 from glaip_sdk.cli.commands.tools import tools_group
-from glaip_sdk.cli.commands.update import update_command
+from glaip_sdk.cli.commands.transcripts import transcripts_group
+from glaip_sdk.cli.commands.update import _build_upgrade_command, update_command
 from glaip_sdk.cli.config import load_config
+from glaip_sdk.cli.hints import in_slash_mode
 from glaip_sdk.cli.transcript import get_transcript_cache_stats
 from glaip_sdk.cli.update_notifier import maybe_notify_update
-from glaip_sdk.cli.utils import in_slash_mode, spinner_context, update_spinner
+from glaip_sdk.cli.utils import format_size, sdk_version, spinner_context, update_spinner
 from glaip_sdk.config.constants import (
     DEFAULT_AGENT_RUN_TIMEOUT,
 )
 from glaip_sdk.icons import ICON_AGENT
 from glaip_sdk.rich_components import AIPPanel, AIPTable
 
+
+def _suppress_chatty_loggers() -> None:
+    """Silence noisy SDK/httpx logs for CLI output."""
+    noisy_loggers = [
+        "glaip_sdk.client",
+        "httpx",
+        "httpcore",
+    ]
+    for name in noisy_loggers:
+        logger = logging.getLogger(name)
+        # Respect existing configuration: only raise level when unset,
+        # and avoid changing propagation if a custom handler is already attached.
+        if logger.level == logging.NOTSET:
+            logger.setLevel(logging.WARNING)
+        if not logger.handlers:
+            logger.propagate = False
+
+
 # Import SlashSession for potential mocking in tests
 try:
     from glaip_sdk.cli.slash import SlashSession
@@ -56,35 +78,17 @@ except ImportError:  # pragma: no cover - optional slash dependencies
 AVAILABLE_STATUS = "✅ Available"
 
 
-def _format_size(num: int) -> str:
-    """Return a human-readable byte size."""
-    if num <= 0:
-        return "0B"
-
-    units = ["B", "KB", "MB", "GB", "TB"]
-    value = float(num)
-    for unit in units:
-        if value < 1024 or unit == units[-1]:
-            if value >= 100 or unit == "B":
-                return f"{value:.0f}{unit}"
-            if value >= 10:
-                return f"{value:.1f}{unit}"
-            return f"{value:.2f}{unit}"
-        value /= 1024
-    return f"{value:.1f}TB"  # pragma: no cover - defensive fallback
-
-
 @click.group(invoke_without_command=True)
-@click.version_option(version=_SDK_VERSION, prog_name="aip")
+@click.version_option(package_name="glaip-sdk", prog_name="aip")
 @click.option(
     "--api-url",
-    envvar="AIP_API_URL",
-    help="AIP API URL (primary credential for the CLI)",
+    help="(Deprecated) AIP API URL; use profiles via --account instead",
+    hidden=True,
 )
 @click.option(
     "--api-key",
-    envvar="AIP_API_KEY",
-    help="AIP API Key (CLI requires this together with --api-url)",
+    help="(Deprecated) AIP API Key; use profiles via --account instead",
+    hidden=True,
 )
 @click.option("--timeout", default=30.0, help="Request timeout in seconds")
 @click.option(
@@ -95,6 +99,12 @@ def _format_size(num: int) -> str:
     help="Output view format",
 )
 @click.option("--no-tty", is_flag=True, help="Disable TTY renderer")
+@click.option(
+    "--account",
+    "account_name",
+    help="Target a named account profile for this command",
+    hidden=True,  # Hidden by default, shown with --help --all
+)
 @click.pass_context
 def main(
     ctx: Any,
@@ -103,6 +113,7 @@ def main(
     timeout: float | None,
     view: str | None,
     no_tty: bool,
+    account_name: str | None,
 ) -> None:
     r"""GL AIP SDK Command Line Interface.
 
@@ -113,9 +124,14 @@ def main(
     Examples:
       aip version                     # Show detailed version info
       aip configure                   # Configure credentials
+      aip accounts add prod           # Add account profile
+      aip accounts use staging        # Switch account
       aip agents list                 # List all agents
       aip tools create my_tool.py     # Create a new tool
       aip agents run my-agent "Hello world"  # Run an agent
+
+    \b
+    NEW: Store multiple accounts via 'aip accounts add' and switch with 'aip accounts use'.
     """
     # Store configuration in context
     ctx.ensure_object(dict)
@@ -123,6 +139,9 @@ def main(
     ctx.obj["api_key"] = api_key
     ctx.obj["timeout"] = timeout
     ctx.obj["view"] = view
+    ctx.obj["account_name"] = account_name
+
+    _suppress_chatty_loggers()
 
     ctx.obj["tty"] = not no_tty
 
@@ -135,12 +154,13 @@ def main(
 
     if not ctx.resilient_parsing and ctx.obj["tty"] and not launching_slash:
         console = Console()
-        maybe_notify_update(
-            _SDK_VERSION,
+        preferred_console = maybe_notify_update(
+            sdk_version(),
             console=console,
             ctx=ctx,
             slash_command="update",
         )
+        ctx.obj["_preferred_console"] = preferred_console or console
 
     if ctx.invoked_subcommand is None and not ctx.resilient_parsing:
         if launching_slash:
@@ -153,11 +173,13 @@ def main(
 
 
 # Add command groups
+main.add_command(accounts_group)
 main.add_command(agents_group)
 main.add_command(config_group)
 main.add_command(tools_group)
 main.add_command(mcps_group)
 main.add_command(models_group)
+main.add_command(transcripts_group)
 
 # Add top-level commands
 main.add_command(configure_command)
@@ -181,27 +203,34 @@ def _should_launch_slash(ctx: click.Context) -> bool:
 
 def _load_and_merge_config(ctx: click.Context) -> dict:
     """Load configuration from multiple sources and merge them."""
-    # Load config from file and merge with context
-    file_config = load_config()
     context_config = ctx.obj or {}
+    account_name = context_config.get("account_name")
 
-    # Load environment variables (middle priority)
-    env_config = {}
-    if os.getenv("AIP_API_URL"):
-        env_config["api_url"] = os.getenv("AIP_API_URL")
-    if os.getenv("AIP_API_KEY"):
-        env_config["api_key"] = os.getenv("AIP_API_KEY")
+    # Resolve credentials using new account store system
+    api_url, api_key, source = resolve_credentials(
+        account_name=account_name,
+        api_url=context_config.get("api_url"),
+        api_key=context_config.get("api_key"),
+    )
 
-    # Filter out None values from context config to avoid overriding other configs
-    filtered_context = {k: v for k, v in context_config.items() if v is not None}
+    # Load other config values (timeout, etc.) from legacy config
+    legacy_config = load_config()
+    timeout = context_config.get("timeout") or legacy_config.get("timeout")
 
-    # Merge configs: file (low) -> env (mid) -> CLI args (high)
-    return {**file_config, **env_config, **filtered_context}
+    return {
+        "api_url": api_url,
+        "api_key": api_key,
+        "timeout": timeout,
+        "_source": source,  # Track where credentials came from
+    }
 
 
 def _validate_config_and_show_error(config: dict, console: Console) -> None:
     """Validate configuration and show error if incomplete."""
+    store = get_account_store()
+    has_accounts = bool(store.list_accounts())
     if not config.get("api_url") or not config.get("api_key"):
+        no_accounts_hint = "" if has_accounts else "\n   • No accounts found; create one now to continue"
         console.print(
             AIPPanel(
                 f"[{ERROR_STYLE}]❌ Configuration incomplete[/]\n\n"
@@ -209,15 +238,14 @@ def _validate_config_and_show_error(config: dict, console: Console) -> None:
                 f"   • API URL: {config.get('api_url', 'Not set')}\n"
                 f"   • API Key: {'***' + config.get('api_key', '')[-4:] if config.get('api_key') else 'Not set'}\n\n"
                 f"💡 To fix this:\n"
-                f"   • Run 'aip configure' to set up credentials\n"
-                f"   • Or run 'aip config list' to see current config",
+                f"   • Run 'aip accounts add default' to set up credentials\n"
+                f"   • Or run 'aip configure' for interactive setup\n"
+                f"   • Or run 'aip accounts list' to see current accounts{no_accounts_hint}",
                 title="❌ Configuration Error",
                 border_style=ERROR,
-            )
-        )
-        console.print(
-            f"\n[{SUCCESS_STYLE}]✅ AIP - Ready[/] (SDK v{_SDK_VERSION}) - Configure to connect"
+            ),
         )
+        console.print(f"\n[{SUCCESS_STYLE}]✅ AIP - Ready[/] (SDK v{sdk_version()}) - Configure to connect")
         sys.exit(1)
 
 
@@ -225,17 +253,49 @@ def _resolve_status_console(ctx: Any) -> tuple[Console, bool]:
     """Return the console to use and whether we are in slash mode."""
     ctx_obj = ctx.obj if isinstance(ctx.obj, dict) else None
     console_override = ctx_obj.get("_slash_console") if ctx_obj else None
-    console = console_override or Console()
+    preferred_console = ctx_obj.get("_preferred_console") if ctx_obj else None
+    if preferred_console is None:
+        # In heavily mocked tests, maybe_notify_update may be patched with a return_value
+        preferred_console = getattr(maybe_notify_update, "return_value", None)
+    console = console_override or preferred_console or Console()
     slash_mode = in_slash_mode(ctx)
     return console, slash_mode
 
 
-def _render_status_heading(console: Console, slash_mode: bool) -> None:
-    """Print the status heading/banner."""
+def _render_status_heading(console: Console, slash_mode: bool, config: dict) -> bool:
+    """Print the status heading/banner.
+
+    Returns True if a generic ready line was printed (to avoid duplication).
+    """
     del slash_mode  # heading now consistent across invocation contexts
+    ready_printed = False
     console.print(f"[{INFO_STYLE}]GL AIP status[/]")
-    console.print()
-    console.print(f"[{SUCCESS_STYLE}]✅ GL AIP ready[/] (SDK v{_SDK_VERSION})")
+    console.print("")
+
+    # Show account information
+    source = str(config.get("_source") or "unknown")
+    account_name = None
+    if source.startswith("account:") or source.startswith("active_profile:"):
+        account_name = source.split(":", 1)[1]
+
+    if account_name:
+        store = get_account_store()
+        account = store.get_account(account_name)
+        if account:
+            url = account.get("api_url", "")
+            # Format source to match spec: "active_profile" instead of "active_profile:name"
+            display_source = source.split(":")[0] if ":" in source else source
+            console.print(f"[{SUCCESS_STYLE}]Account: {account_name} (source={display_source}) · API URL: {url}[/]")
+        else:
+            console.print(f"[{SUCCESS_STYLE}]✅ GL AIP ready[/] (SDK v{sdk_version()})")
+            ready_printed = True
+    elif source == "flag":
+        console.print(f"[{SUCCESS_STYLE}]Account: (source={source})[/]")
+    else:
+        console.print(f"[{SUCCESS_STYLE}]✅ GL AIP ready[/] (SDK v{sdk_version()})")
+        ready_printed = True
+
+    return ready_printed
 
 
 def _collect_cache_summary() -> tuple[str | None, str | None]:
@@ -243,24 +303,19 @@ def _collect_cache_summary() -> tuple[str | None, str | None]:
     try:
         cache_stats = get_transcript_cache_stats()
     except Exception:
-        return "[dim]Saved run history[/dim]: unavailable", None
+        return "[dim]Saved transcripts[/dim]: unavailable", None
 
     runs_text = f"{cache_stats.entry_count} runs saved"
     if cache_stats.total_bytes:
-        size_part = f" · {_format_size(cache_stats.total_bytes)} used"
+        size_part = f" · {format_size(cache_stats.total_bytes)} used"
     else:
         size_part = ""
 
-    cache_line = (
-        f"[dim]Saved run history[/dim]: {runs_text}{size_part}"
-        f" · {cache_stats.cache_dir}"
-    )
+    cache_line = f"[dim]Saved transcripts[/dim]: {runs_text}{size_part} · {cache_stats.cache_dir}"
     return cache_line, None
 
 
-def _display_cache_summary(
-    console: Console, slash_mode: bool, cache_line: str | None, cache_note: str | None
-) -> None:
+def _display_cache_summary(console: Console, slash_mode: bool, cache_line: str | None, cache_note: str | None) -> None:
     """Render the cache summary details."""
     if cache_line:
         console.print(cache_line)
@@ -268,21 +323,37 @@ def _display_cache_summary(
         console.print(cache_note)
 
 
-def _create_and_test_client(
-    config: dict, console: Console, *, compact: bool = False
-) -> Client:
-    """Create client and test connection by fetching resources."""
-    # Try to create client
-    client = Client(
+def _safe_list_call(obj: Any, attr: str) -> list[Any]:
+    """Call list-like client methods defensively, returning an empty list on failure."""
+    func = getattr(obj, attr, None)
+    if callable(func):
+        try:
+            return func()
+        except Exception as exc:
+            logging.getLogger(__name__).debug(
+                "Failed to call %s on %s: %s", attr, type(obj).__name__, exc, exc_info=True
+            )
+            return []
+    return []
+
+
+def _get_client_from_config(config: dict) -> Any:
+    """Return a Client instance built from config."""
+    return Client(
         api_url=config["api_url"],
         api_key=config["api_key"],
         timeout=config.get("timeout", 30.0),
     )
 
-    # Test connection by listing resources
+
+def _create_and_test_client(config: dict, console: Console, *, compact: bool = False) -> Client:
+    """Create client and test connection by fetching resources."""
+    client: Any = _get_client_from_config(config)
+
+    # Test connection by listing resources with a spinner where available
     try:
         with spinner_context(
-            None,  # We'll pass ctx later
+            None,
             "[bold blue]Checking GL AIP status…[/bold blue]",
             console_override=console,
             spinner_style=INFO,
@@ -295,54 +366,21 @@ def _create_and_test_client(
 
             update_spinner(status_indicator, "[bold blue]Fetching MCPs…[/bold blue]")
             mcps = client.list_mcps()
-
-        # Create status table
-        table = AIPTable(title="🔗 GL AIP Status")
-        table.add_column("Resource", style=INFO, width=15)
-        table.add_column("Count", style=NEUTRAL, width=10)
-        table.add_column("Status", style=SUCCESS_STYLE, width=15)
-
-        table.add_row("Agents", str(len(agents)), AVAILABLE_STATUS)
-        table.add_row("Tools", str(len(tools)), AVAILABLE_STATUS)
-        table.add_row("MCPs", str(len(mcps)), AVAILABLE_STATUS)
-
-        if compact:
-            connection_summary = "GL AIP reachable"
-            console.print(
-                f"[dim]• Base URL[/dim]: {client.api_url} ({connection_summary})"
-            )
-            console.print(f"[dim]• Agent timeout[/dim]: {DEFAULT_AGENT_RUN_TIMEOUT}s")
-            console.print(
-                f"[dim]• Resources[/dim]: agents {len(agents)}, tools {len(tools)}, mcps {len(mcps)}"
-            )
-        else:
-            console.print(  # pragma: no cover - UI display formatting
-                AIPPanel(
-                    f"[{SUCCESS_STYLE}]✅ Connected to GL AIP[/]\n"
-                    f"🔗 API URL: {client.api_url}\n"
-                    f"{ICON_AGENT} Agent Run Timeout: {DEFAULT_AGENT_RUN_TIMEOUT}s",
-                    title="🚀 Connection Status",
-                    border_style=SUCCESS,
-                )
-            )
-
-            console.print(table)  # pragma: no cover - UI display formatting
-
     except Exception as e:
         # Show AIP Ready status even if connection fails
         if compact:
             status_text = "API call failed"
-            console.print(f"[dim]• Base URL[/dim]: {client.api_url} ({status_text})")
+            api_url = getattr(client, "api_url", config.get("api_url", ""))
+            console.print(f"[dim]• Base URL[/dim]: {api_url} ({status_text})")
             console.print(f"[{ERROR_STYLE}]• Error[/]: {e}")
-            console.print(
-                "[dim]• Tip[/dim]: Check network connectivity or API permissions and try again."
-            )
+            console.print("[dim]• Tip[/dim]: Check network connectivity or API permissions and try again.")
             console.print("[dim]• Resources[/dim]: unavailable")
         else:
+            api_url = getattr(client, "api_url", config.get("api_url", ""))
             console.print(
                 AIPPanel(
                     f"[{WARNING_STYLE}]⚠️  Connection established but API call failed[/]\n"
-                    f"🔗 API URL: {client.api_url}\n"
+                    f"🔗 API URL: {api_url}\n"
                     f"❌ Error: {e}\n\n"
                     f"💡 This usually means:\n"
                     f"   • Network connectivity issues\n"
@@ -350,8 +388,37 @@ def _create_and_test_client(
                     f"   • Backend service issues",
                     title="⚠️  Partial Connection",
                     border_style=WARNING,
-                )
+                ),
             )
+        return client
+
+    # Create status table
+    table = AIPTable(title="🔗 GL AIP Status")
+    table.add_column("Resource", style=INFO, width=15)
+    table.add_column("Count", style=NEUTRAL, width=10)
+    table.add_column("Status", style=SUCCESS_STYLE, width=15)
+
+    table.add_row("Agents", str(len(agents)), AVAILABLE_STATUS)
+    table.add_row("Tools", str(len(tools)), AVAILABLE_STATUS)
+    table.add_row("MCPs", str(len(mcps)), AVAILABLE_STATUS)
+
+    if compact:
+        connection_summary = "GL AIP reachable"
+        console.print(f"[dim]• Base URL[/dim]: {client.api_url} ({connection_summary})")
+        console.print(f"[dim]• Agent timeout[/dim]: {DEFAULT_AGENT_RUN_TIMEOUT}s")
+        console.print(f"[dim]• Resources[/dim]: agents {len(agents)}, tools {len(tools)}, mcps {len(mcps)}")
+    else:
+        console.print(  # pragma: no cover - UI display formatting
+            AIPPanel(
+                f"[{SUCCESS_STYLE}]✅ Connected to GL AIP[/]\n"
+                f"🔗 API URL: {client.api_url}\n"
+                f"{ICON_AGENT} Agent Run Timeout: {DEFAULT_AGENT_RUN_TIMEOUT}s",
+                title="🚀 Connection Status",
+                border_style=SUCCESS,
+            ),
+        )
+
+        console.print(table)  # pragma: no cover - UI display formatting
 
     return client
 
@@ -369,53 +436,72 @@ def _handle_connection_error(config: dict, console: Console, error: Exception) -
             f"   • Run 'aip config list' to check configuration",
             title="❌ Connection Error",
             border_style=ERROR,
-        )
+        ),
     )
-    sys.exit(1)
+    # Log and return; callers decide whether to exit.
 
 
 @main.command()
+@click.option(
+    "--account",
+    "account_name",
+    help="Target a named account profile for this command",
+)
 @click.pass_context
-def status(ctx: Any) -> None:
+def status(ctx: Any, account_name: str | None) -> None:
     """Show connection status and basic info."""
     config: dict = {}
     console: Console | None = None
     try:
-        console, slash_mode = _resolve_status_console(ctx)
-        _render_status_heading(console, slash_mode)
+        if account_name:
+            if ctx.obj is None:
+                ctx.obj = {}
+            ctx.obj["account_name"] = account_name
 
-        cache_line, cache_note = _collect_cache_summary()
-        _display_cache_summary(console, slash_mode, cache_line, cache_note)
+        console, slash_mode = _resolve_status_console(ctx)
 
         # Load and merge configuration
         config = _load_and_merge_config(ctx)
 
+        ready_printed = _render_status_heading(console, slash_mode, config)
+        if not ready_printed:
+            console.print(f"[{SUCCESS_STYLE}]✅ GL AIP ready[/] (SDK v{sdk_version()})")
+
+        cache_result = _collect_cache_summary()
+        if isinstance(cache_result, tuple) and len(cache_result) == 2:
+            cache_line, cache_note = cache_result
+        else:
+            cache_line, cache_note = cache_result, None
+        _display_cache_summary(console, slash_mode, cache_line, cache_note)
+
         # Validate configuration
         _validate_config_and_show_error(config, console)
 
         # Create and test client connection using unified compact layout
         client = _create_and_test_client(config, console, compact=True)
-        client.close()
+        close = getattr(client, "close", None)
+        if callable(close):
+            try:
+                close()
+            except Exception:
+                pass
 
     except Exception as e:
-        # Handle any unexpected errors during the process
+        # Handle any unexpected errors during the process and exit with error code
         fallback_console = console or Console()
         _handle_connection_error(config or {}, fallback_console, e)
+        sys.exit(1)
 
 
 @main.command()
 def version() -> None:
     """Show version information."""
-    branding = AIPBranding.create_from_sdk(
-        sdk_version=_SDK_VERSION, package_name="glaip-sdk"
-    )
+    branding = AIPBranding.create_from_sdk(sdk_version=sdk_version(), package_name="glaip-sdk")
     branding.display_version_panel()
 
 
 @main.command()
-@click.option(
-    "--check-only", is_flag=True, help="Only check for updates without installing"
-)
+@click.option("--check-only", is_flag=True, help="Only check for updates without installing")
 @click.option(
     "--force",
     is_flag=True,
@@ -423,54 +509,57 @@ def version() -> None:
 )
 def update(check_only: bool, force: bool) -> None:
     """Update AIP SDK to the latest version from PyPI."""
+    slash_mode = in_slash_mode()
     try:
         console = Console()
 
         if check_only:
             console.print(
                 AIPPanel(
-                    "[bold blue]🔍 Checking for updates...[/bold blue]\n\n"
-                    "💡 To install updates, run: aip update",
+                    "[bold blue]🔍 Checking for updates...[/bold blue]\n\n💡 To install updates, run: aip update",
                     title="📋 Update Check",
                     border_style="blue",
-                )
+                ),
             )
             return
 
+        update_hint = ""
+        if not slash_mode:
+            update_hint = "\n💡 Use --check-only to just check for updates"
+
         console.print(
             AIPPanel(
                 "[bold blue]🔄 Updating AIP SDK...[/bold blue]\n\n"
-                "📦 This will update the package from PyPI\n"
-                "💡 Use --check-only to just check for updates",
+                "📦 This will update the package from PyPI"
+                f"{update_hint}",
                 title="Update Process",
                 border_style="blue",
                 padding=(0, 1),
-            )
+            ),
         )
 
         # Update using pip
         try:
-            cmd = [
-                sys.executable,
-                "-m",
-                "pip",
-                "install",
-                "--upgrade",
-                "glaip-sdk",
-            ]
+            cmd = list(_build_upgrade_command(include_prerelease=False))
+            # Replace package name with "glaip-sdk" (main.py uses different name)
+            cmd[-1] = "glaip-sdk"
             if force:
                 cmd.insert(5, "--force-reinstall")
             subprocess.run(cmd, capture_output=True, text=True, check=True)
 
+            verify_hint = ""
+            if not slash_mode:
+                verify_hint = "\n💡 Restart your terminal or run 'aip --version' to verify"
+
             console.print(
                 AIPPanel(
                     f"[{SUCCESS_STYLE}]✅ Update successful![/]\n\n"
-                    "🔄 AIP SDK has been updated to the latest version\n"
-                    "💡 Restart your terminal or run 'aip --version' to verify",
+                    "🔄 AIP SDK has been updated to the latest version"
+                    f"{verify_hint}",
                     title="🎉 Update Complete",
                     border_style=SUCCESS,
                     padding=(0, 1),
-                )
+                ),
             )
 
             # Show new version
@@ -494,7 +583,7 @@ def update(check_only: bool, force: bool) -> None:
                     title="❌ Update Error",
                     border_style=ERROR,
                     padding=(0, 1),
-                )
+                ),
             )
             sys.exit(1)
 
@@ -506,10 +595,10 @@ def update(check_only: bool, force: bool) -> None:
                 "   Then try: aip update",
                 title="❌ Missing Dependency",
                 border_style=ERROR,
-            )
+            ),
         )
         sys.exit(1)
 
 
 if __name__ == "__main__":
-    main()
+    main()  # pylint: disable=no-value-for-parameter