sqlsaber 0.30.1__py3-none-any.whl → 0.31.0__py3-none-any.whl

sqlsaber/cli/models.py

@@ -11,9 +11,11 @@ from rich.table import Table
 from sqlsaber.config import providers
 from sqlsaber.config.settings import Config
 from sqlsaber.theme.manager import create_console
+from sqlsaber.config.logging import get_logger
 
 # Global instances for CLI commands
 console = create_console()
+logger = get_logger(__name__)
 
 # Create the model management CLI app
 models_app = cyclopts.App(
@@ -104,9 +106,11 @@ class ModelManager:
 
                 # Sort by provider then by name
                 results.sort(key=lambda x: (x["provider"], x["name"]))
+                logger.info("models.fetch.success", count=len(results))
                 return results
         except Exception as e:
             console.print(f"[error]Error fetching models: {e}[/error]")
+            logger.warning("models.fetch.error", error=str(e))
             return []
 
     def get_current_model(self) -> str:
@@ -119,9 +123,11 @@ class ModelManager:
         try:
             config = Config()
             config.set_model(model_id)
+            logger.info("models.set.success", model=model_id)
             return True
         except Exception as e:
             console.print(f"[error]Error setting model: {e}[/error]")
+            logger.error("models.set.error", model=model_id, error=str(e))
             return False
 
     def reset_model(self) -> bool:
@@ -135,6 +141,7 @@ model_manager = ModelManager()
 @models_app.command
 def list():
     """List available AI models."""
+    logger.info("models.list.start")
 
     async def fetch_and_display():
         console.print("[blue]Fetching available models...[/blue]")
@@ -144,6 +151,7 @@ def list():
             console.print(
                 "[warning]No models available or failed to fetch models[/warning]"
             )
+            logger.info("models.list.empty")
             return
 
         table = Table(title="Available Models")
@@ -180,6 +188,7 @@ def list():
 
         console.print(table)
         console.print(f"\n[dim]Current model: {current_model}[/dim]")
+        logger.info("models.list.complete", current=current_model, count=len(models))
 
     asyncio.run(fetch_and_display())
 
@@ -187,6 +196,7 @@ def list():
 @models_app.command
 def set():
     """Set the AI model to use."""
+    logger.info("models.set.start")
 
     async def interactive_set():
         from sqlsaber.application.model_selection import choose_model, fetch_models
@@ -197,6 +207,7 @@ def set():
 
         if not models:
             console.print("[error]Failed to fetch models. Cannot set model.[/error]")
+            logger.error("models.set.no_models")
             sys.exit(1)
 
         prompter = AsyncPrompter()
@@ -207,11 +218,14 @@ def set():
         if selected_model:
             if model_manager.set_model(selected_model):
                 console.print(f"[green]✓ Model set to: {selected_model}[/green]")
+                logger.info("models.set.done", model=selected_model)
             else:
                 console.print("[error]✗ Failed to set model[/error]")
+                logger.error("models.set.failed", model=selected_model)
                 sys.exit(1)
         else:
             console.print("[warning]Operation cancelled[/warning]")
+            logger.info("models.set.cancelled")
 
     asyncio.run(interactive_set())
 
@@ -221,11 +235,13 @@ def current():
     """Show the currently configured model."""
     current = model_manager.get_current_model()
     console.print(f"Current model: [cyan]{current}[/cyan]")
+    logger.info("models.current", model=current)
 
 
 @models_app.command
 def reset():
     """Reset to the default model."""
+    logger.info("models.reset.start")
 
     async def interactive_reset():
         if await questionary.confirm(
@@ -235,11 +251,14 @@ def reset():
                 console.print(
                     f"[green]✓ Model reset to default: {ModelManager.DEFAULT_MODEL}[/green]"
                 )
+                logger.info("models.reset.done", model=ModelManager.DEFAULT_MODEL)
             else:
                 console.print("[error]✗ Failed to reset model[/error]")
+                logger.error("models.reset.failed")
                 sys.exit(1)
         else:
             console.print("[warning]Operation cancelled[/warning]")
+            logger.info("models.reset.cancelled")
 
     asyncio.run(interactive_reset())
 

sqlsaber/cli/streaming.py

@@ -25,6 +25,7 @@ from pydantic_ai.messages import (
 from rich.console import Console
 
 from sqlsaber.cli.display import DisplayManager
+from sqlsaber.config.logging import get_logger
 
 if TYPE_CHECKING:
     from sqlsaber.agents.pydantic_ai_agent import SQLSaberAgent
@@ -40,6 +41,7 @@ class StreamingQueryHandler:
     def __init__(self, console: Console):
         self.console = console
         self.display = DisplayManager(console)
+        self.log = get_logger(__name__)
 
     async def _event_stream_handler(
         self, ctx: RunContext, event_stream: AsyncIterable[AgentStreamEvent]
@@ -140,6 +142,7 @@ class StreamingQueryHandler:
         # Prepare nicer code block rendering for Markdown
         self.display.live.prepare_code_blocks()
         try:
+            self.log.info("streaming.execute.start")
             # If Anthropic OAuth, inject SQLsaber instructions before the first user prompt
             prepared_prompt: str | list[str] = user_query
             no_history = not message_history
@@ -157,11 +160,13 @@ class StreamingQueryHandler:
                 message_history=message_history,
                 event_stream_handler=self._event_stream_handler,
             )
+            self.log.info("streaming.execute.end")
             return run
         except asyncio.CancelledError:
             # Show interruption message outside of Live
             self.display.show_newline()
             self.console.print("[warning]Query interrupted[/warning]")
+            self.log.info("streaming.execute.cancelled")
             return None
         finally:
             # End any active status and live markdown segments

sqlsaber/cli/theme.py

@@ -12,8 +12,10 @@ from platformdirs import user_config_dir
 from pygments.styles import get_all_styles
 
 from sqlsaber.theme.manager import DEFAULT_THEME_NAME, create_console
+from sqlsaber.config.logging import get_logger
 
 console = create_console()
+logger = get_logger(__name__)
 
 # Create the theme management CLI app
 theme_app = cyclopts.App(
@@ -71,6 +73,7 @@ class ThemeManager:
             return True
         except Exception as e:
             console.print(f"[error]Error setting theme: {e}[/error]")
+            logger.error("theme.set.error", theme=theme_name, error=str(e))
             return False
 
     def reset_theme(self) -> bool:
@@ -81,6 +84,7 @@ class ThemeManager:
             return True
         except Exception as e:
             console.print(f"[error]Error resetting theme: {e}[/error]")
+            logger.error("theme.reset.error", error=str(e))
             return False
 
     def get_available_themes(self) -> list[str]:
@@ -94,6 +98,7 @@ theme_manager = ThemeManager()
 @theme_app.command
 def set():
     """Set the theme to use for syntax highlighting."""
+    logger.info("theme.set.start")
 
     async def interactive_set():
         themes = theme_manager.get_available_themes()
@@ -119,11 +124,13 @@ def set():
         if selected_theme:
             if theme_manager.set_theme(selected_theme):
                 console.print(f"[success]✓ Theme set to: {selected_theme}[/success]")
+                logger.info("theme.set.done", theme=selected_theme)
             else:
                 console.print("[error]✗ Failed to set theme[/error]")
                 sys.exit(1)
         else:
             console.print("[warning]Operation cancelled[/warning]")
+            logger.info("theme.set.cancelled")
 
     asyncio.run(interactive_set())
 
@@ -136,6 +143,7 @@ def reset():
         console.print(
             f"[success]✓ Theme reset to default: {DEFAULT_THEME_NAME}[/success]"
         )
+        logger.info("theme.reset.done", theme=DEFAULT_THEME_NAME)
     else:
         console.print("[error]✗ Failed to reset theme[/error]")
         sys.exit(1)

sqlsaber/cli/threads.py

@@ -12,12 +12,14 @@ from rich.markdown import Markdown
 from rich.panel import Panel
 from rich.table import Table
 
+from sqlsaber.config.logging import get_logger
 from sqlsaber.theme.manager import create_console, get_theme_manager
 from sqlsaber.threads import ThreadStorage
 
 # Globals consistent with other CLI modules
 console = create_console()
 tm = get_theme_manager()
+logger = get_logger(__name__)
 
 
 threads_app = cyclopts.App(
@@ -219,10 +221,12 @@ def list_threads(
     ] = 50,
 ):
     """List threads (optionally filtered by database)."""
+    logger.info("threads.cli.list.start", database=database, limit=limit)
     store = ThreadStorage()
     threads = asyncio.run(store.list_threads(database_name=database, limit=limit))
     if not threads:
         console.print("No threads found.")
+        logger.info("threads.cli.list.empty")
         return
     table = Table(title="Threads")
     table.add_column("ID", style=tm.style("info"))
@@ -239,6 +243,7 @@ def list_threads(
             t.model_name or "-",
         )
     console.print(table)
+    logger.info("threads.cli.list.complete", count=len(threads))
 
 
 @threads_app.command
@@ -246,10 +251,12 @@ def show(
     thread_id: Annotated[str, cyclopts.Parameter(help="Thread ID")],
 ):
     """Show thread metadata and render the full transcript."""
+    logger.info("threads.cli.show.start", thread_id=thread_id)
     store = ThreadStorage()
     thread = asyncio.run(store.get_thread(thread_id))
     if not thread:
         console.print(f"[error]Thread not found:[/error] {thread_id}")
+        logger.error("threads.cli.show.not_found", thread_id=thread_id)
         return
     msgs = asyncio.run(store.get_thread_messages(thread_id))
     console.print(f"[bold]Thread: {thread.id}[/bold]")
@@ -261,6 +268,7 @@ def show(
     console.print("")
 
     _render_transcript(console, msgs, None)
+    logger.info("threads.cli.show.complete", thread_id=thread_id)
 
 
 @threads_app.command
@@ -272,6 +280,7 @@ def resume(
     ] = None,
 ):
     """Render transcript, then resume thread in interactive mode."""
+    logger.info("threads.cli.resume.start", thread_id=thread_id, database=database)
     store = ThreadStorage()
 
     async def _run() -> None:
@@ -288,12 +297,14 @@ def resume(
         thread = await store.get_thread(thread_id)
         if not thread:
             console.print(f"[error]Thread not found:[/error] {thread_id}")
+            logger.error("threads.cli.resume.not_found", thread_id=thread_id)
             return
         db_selector = database or thread.database_name
         if not db_selector:
             console.print(
                 "[error]No database specified or stored with this thread.[/error]"
             )
+            logger.error("threads.cli.resume.no_database", thread_id=thread_id)
             return
         try:
             config_manager = DatabaseConfigManager()
@@ -302,6 +313,9 @@ def resume(
             db_name = resolved.name
         except DatabaseResolutionError as e:
             console.print(f"[error]Database resolution error:[/error] {e}")
+            logger.error(
+                "threads.cli.resume.resolve_failed", thread_id=thread_id, error=str(e)
+            )
             return
 
         db_conn = DatabaseConnection(connection_string)
@@ -330,6 +344,7 @@ def resume(
         finally:
             await db_conn.close()
             console.print("\n[success]Goodbye![/success]")
+            logger.info("threads.cli.resume.closed")
 
     asyncio.run(_run())
 
@@ -344,11 +359,13 @@ def prune(
     ] = 30,
 ):
     """Prune old threads by last activity timestamp."""
+    logger.info("threads.cli.prune.start", days=days)
     store = ThreadStorage()
 
     async def _run() -> None:
         deleted = await store.prune_threads(older_than_days=days)
         console.print(f"[success]✓ Pruned {deleted} thread(s).[/success]")
+        logger.info("threads.cli.prune.complete", deleted=deleted)
 
     asyncio.run(_run())
 

sqlsaber/config/logging.py

@@ -0,0 +1,196 @@
+"""Central logging configuration for SQLSaber using structlog.
+
+This module provides a single entry point `setup_logging()` to configure
+structured logging across the project, plus a helper `get_logger()` to
+retrieve namespaced loggers.
+
+Defaults:
+- JSON logs to a rotating file under the user log directory.
+- Optional pretty console logs when `SQLSABER_DEBUG=1` or
+  `SQLSABER_LOG_TO_STDERR=1`.
+
+Environment variables:
+- `SQLSABER_LOG_LEVEL` (default: INFO)
+- `SQLSABER_LOG_FILE` (default: <user_log_dir>/sqlsaber.log)
+- `SQLSABER_LOG_TO_STDERR` (0/1, default: 0)
+- `SQLSABER_LOG_ROTATION` ("time" or "size", default: "time")
+- `SQLSABER_LOG_WHEN` (Timed rotation unit, default: "midnight")
+- `SQLSABER_LOG_INTERVAL` (Timed rotation interval, default: 1)
+- `SQLSABER_LOG_BACKUP_COUNT` (number of rotated files to keep, default: 14)
+- `SQLSABER_LOG_MAX_BYTES` (for size rotation, default: 10485760)
+"""
+
+from __future__ import annotations
+
+import logging
+import os
+from logging import Handler
+from logging.handlers import RotatingFileHandler, TimedRotatingFileHandler
+from pathlib import Path
+from typing import Optional
+
+import platformdirs
+import structlog
+
+_CONFIGURED = False
+
+
+def _to_bool(value: str | None, default: bool = False) -> bool:
+    if value is None:
+        return default
+    return value.strip().lower() in {"1", "true", "yes", "on"}
+
+
+def default_log_dir() -> Path:
+    return Path(platformdirs.user_log_dir("sqlsaber", "sqlsaber"))
+
+
+def default_log_file() -> Path:
+    return default_log_dir() / "sqlsaber.log"
+
+
+def get_logger(name: Optional[str] = None) -> structlog.BoundLogger:
+    """Return a structlog logger bound to `name`.
+
+    Prefer using this over the stdlib `logging.getLogger` in new code.
+    """
+    return structlog.get_logger(name)
+
+
+def _build_file_handler(log_path: Path, level: int) -> Handler:
+    rotation = os.getenv("SQLSABER_LOG_ROTATION", "time").strip().lower()
+
+    # Formatter that renders as JSON for files
+    json_formatter = structlog.stdlib.ProcessorFormatter(
+        processors=[
+            structlog.stdlib.ProcessorFormatter.remove_processors_meta,
+            structlog.processors.dict_tracebacks,
+            structlog.processors.JSONRenderer(sort_keys=True),
+        ],
+        foreign_pre_chain=[
+            structlog.processors.add_log_level,
+            structlog.processors.TimeStamper(fmt="iso", utc=True),
+        ],
+    )
+
+    if rotation == "size":
+        max_bytes = int(os.getenv("SQLSABER_LOG_MAX_BYTES", str(10 * 1024 * 1024)))
+        backup_count = int(os.getenv("SQLSABER_LOG_BACKUP_COUNT", "5"))
+        handler: Handler = RotatingFileHandler(
+            log_path, maxBytes=max_bytes, backupCount=backup_count, encoding="utf-8"
+        )
+    else:
+        when = os.getenv("SQLSABER_LOG_WHEN", "midnight")
+        interval = int(os.getenv("SQLSABER_LOG_INTERVAL", "1"))
+        backup_count = int(os.getenv("SQLSABER_LOG_BACKUP_COUNT", "14"))
+        handler = TimedRotatingFileHandler(
+            log_path,
+            when=when,
+            interval=interval,
+            backupCount=backup_count,
+            encoding="utf-8",
+            utc=True,
+        )
+
+    handler.setLevel(level)
+    handler.setFormatter(json_formatter)
+    return handler
+
+
+def _build_console_handler(level: int) -> Handler:
+    console_formatter = structlog.stdlib.ProcessorFormatter(
+        processors=[
+            structlog.stdlib.ProcessorFormatter.remove_processors_meta,
+            structlog.dev.ConsoleRenderer(colors=True),
+        ],
+        foreign_pre_chain=[
+            structlog.processors.add_log_level,
+            structlog.processors.TimeStamper(fmt="iso", utc=True),
+        ],
+    )
+
+    ch = logging.StreamHandler()
+    ch.setLevel(level)
+    ch.setFormatter(console_formatter)
+    return ch
+
+
+def setup_logging(*, force: bool = False) -> None:
+    """Configure structlog + stdlib logging with sensible defaults.
+
+    Call this early in the CLI startup. It's safe to call multiple times.
+    """
+    global _CONFIGURED
+    if _CONFIGURED and not force:
+        return
+
+    # Resolve level
+    level_name = os.getenv("SQLSABER_LOG_LEVEL", "INFO").upper()
+    level = getattr(logging, level_name, logging.INFO)
+
+    # Log file path
+    log_file_env = os.getenv("SQLSABER_LOG_FILE")
+    log_path = Path(log_file_env) if log_file_env else default_log_file()
+    log_path.parent.mkdir(parents=True, exist_ok=True)
+
+    # Whether to also log to console (stderr)
+    to_console = _to_bool(os.getenv("SQLSABER_LOG_TO_STDERR")) or _to_bool(
+        os.getenv("SQLSABER_DEBUG")
+    )
+
+    # Configure structlog to hand off to stdlib formatting
+    structlog.configure(
+        processors=[
+            structlog.contextvars.merge_contextvars,
+            structlog.stdlib.add_logger_name,
+            structlog.stdlib.add_log_level,
+            structlog.processors.TimeStamper(fmt="iso", utc=True),
+            structlog.processors.StackInfoRenderer(),
+            structlog.processors.format_exc_info,
+            structlog.stdlib.ProcessorFormatter.wrap_for_formatter,
+        ],
+        logger_factory=structlog.stdlib.LoggerFactory(),
+        wrapper_class=structlog.stdlib.BoundLogger,
+        cache_logger_on_first_use=True,
+    )
+
+    # Build handlers
+    handlers: list[Handler] = []
+    handlers.append(_build_file_handler(log_path, level))
+    if to_console:
+        handlers.append(_build_console_handler(level))
+
+    # Install handlers on root logger
+    root = logging.getLogger()
+    root.setLevel(level)
+    for h in list(root.handlers):
+        root.removeHandler(h)
+    for h in handlers:
+        root.addHandler(h)
+
+    # Capture warnings too
+    logging.captureWarnings(True)
+
+    # Pre-bind useful context
+    try:
+        from importlib.metadata import PackageNotFoundError, version  # type: ignore
+
+        try:
+            ver = version("sqlsaber")
+        except PackageNotFoundError:  # during dev
+            ver = "dev"
+    except Exception:
+        ver = "unknown"
+
+    structlog.contextvars.bind_contextvars(app="sqlsaber", version=ver)
+
+    _CONFIGURED = True
+
+
+__all__ = [
+    "setup_logging",
+    "get_logger",
+    "default_log_dir",
+    "default_log_file",
+]
+

sqlsaber/config/oauth_flow.py

@@ -2,7 +2,6 @@
 
 import base64
 import hashlib
-import logging
 import secrets
 import urllib.parse
 import webbrowser
@@ -12,12 +11,13 @@ import httpx
 import questionary
 from rich.progress import Progress, SpinnerColumn, TextColumn
 
+from sqlsaber.config.logging import get_logger
 from sqlsaber.theme.manager import create_console
 
 from .oauth_tokens import OAuthToken, OAuthTokenManager
 
 console = create_console()
-logger = logging.getLogger(__name__)
+logger = get_logger(__name__)
 
 
 CLIENT_ID = "9d1c250a-e61b-44d9-88ed-5944d1962f5e"
@@ -60,6 +60,7 @@ class AnthropicOAuthFlow:
         }
 
         url = "https://claude.ai/oauth/authorize?" + urllib.parse.urlencode(params)
+        logger.debug("oauth.auth_url.created")
         return url, verifier
 
     def _exchange_code_for_tokens(self, code: str, verifier: str) -> dict[str, str]:
@@ -86,11 +87,13 @@ class AnthropicOAuthFlow:
             )
 
             if not response.is_success:
-                error_msg = (
+                logger.error(
+                    "oauth.token_exchange.failed",
+                    status_code=response.status_code,
+                )
+                raise Exception(
                     f"Token exchange failed: {response.status_code} {response.text}"
                 )
-                logger.error(error_msg)
-                raise Exception(error_msg)
 
             return response.json()
 
@@ -110,11 +113,13 @@ class AnthropicOAuthFlow:
             )
 
             if not response.is_success:
-                error_msg = (
+                logger.error(
+                    "oauth.token_refresh.failed",
+                    status_code=response.status_code,
+                )
+                raise Exception(
                     f"Token refresh failed: {response.status_code} {response.text}"
                 )
-                logger.error(error_msg)
-                raise Exception(error_msg)
 
             return response.json()
 
@@ -132,6 +137,7 @@ class AnthropicOAuthFlow:
             "Continue with browser-based authentication?", default=True
         ).ask():
             console.print("[warning]Authentication cancelled.[/warning]")
+            logger.info("oauth.authenticate.cancelled_at_prompt")
             return False
 
         try:
@@ -169,6 +175,7 @@ class AnthropicOAuthFlow:
 
             if not auth_code:
                 console.print("[warning]Authentication cancelled.[/warning]")
+                logger.info("oauth.authenticate.cancelled_no_code")
                 return False
 
             # Step 2: Exchange code for tokens
@@ -202,18 +209,21 @@ class AnthropicOAuthFlow:
                     console.print(
                         "Your Claude Pro/Max subscription is now configured for SQLSaber."
                     )
+                    logger.info("oauth.authenticate.success")
                     return True
                 else:
                     console.print(
                         "[error]✗ Failed to store authentication tokens.[/error]"
                     )
+                    logger.error("oauth.authenticate.store_failed")
                     return False
 
         except KeyboardInterrupt:
             console.print("\n[warning]Authentication cancelled by user.[/warning]")
+            logger.info("oauth.authenticate.cancelled_keyboard")
             return False
         except Exception as e:
-            logger.error(f"OAuth authentication failed: {e}")
+            logger.exception("oauth.authenticate.error", error=str(e))
             console.print(f"[error]✗ Authentication failed: {str(e)}[/error]")
             return False
 
@@ -253,13 +263,15 @@ class AnthropicOAuthFlow:
             # Store the refreshed token
             if self.token_manager.store_oauth_token("anthropic", refreshed_token):
                 console.print("OAuth token refreshed successfully", style="green")
+                logger.info("oauth.token_refresh.success")
                 return refreshed_token
             else:
                 console.print("Failed to store refreshed token", style="warning")
+                logger.warning("oauth.token_refresh.store_failed")
                 return current_token
 
         except Exception as e:
-            logger.warning(f"Token refresh failed: {e}")
+            logger.warning("oauth.token_refresh.error", error=str(e))
             console.print(
                 "Token refresh failed. You may need to re-authenticate.",
                 style="warning",