sanityops-cli 0.1.3__py3-none-any.whl

sanityops_cli/commands/config.py

@@ -0,0 +1,312 @@
+# Copyright 2026 zipsonken
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+#
+
+"""config command — Get and set sanityops configuration.
+
+Config keys use dot notation, e.g. ``server.base_url``. They correspond to
+the sanityops SaaS backend (NOT the LLM model config, which lives under
+``model.*``). Precedence: project-level > global > env var > default.
+"""
+
+from __future__ import annotations
+
+import getpass
+import os
+import sys
+from typing import Any
+
+import typer
+from rich.console import Console
+from rich.table import Table
+
+from sanityops_cli.constants.config_defaults import DEFAULT_SERVER_BASE_URL
+from sanityops_cli.constants.exit_codes import EXIT_FAILURE
+from sanityops_cli.utils.config_resolver import ConfigResolver
+
+console = Console()
+
+# Create a Typer app for config subcommand
+config_app = typer.Typer(
+    name="config",
+    help="Get and set sanityops configuration (server base URL, API key, etc.)",
+    no_args_is_help=False,  # We handle help ourselves to add usage panel
+    add_help_option=False,  # We handle --help ourselves to add usage panel
+    context_settings={"allow_interspersed_args": True},
+)
+
+# Registry of known config keys: metadata for reading defaults / masking.
+# New config keys can be added here without touching resolve logic.
+CONFIG_SCHEMA: dict[str, dict[str, Any]] = {
+    "server.base_url": {
+        "env": "SANITYOPS_BASE_URL",
+        "default": DEFAULT_SERVER_BASE_URL,
+        "sensitive": False,
+    },
+    "server.api_key": {
+        "env": "SANITYOPS_API_KEY",
+        "default": None,
+        "sensitive": True,
+    },
+}
+
+
+def _is_sensitive_key(key: str) -> bool:
+    """Check if a key holds a sensitive value (masked on display)."""
+    return bool(CONFIG_SCHEMA.get(key, {}).get("sensitive"))
+
+
+def _mask_sensitive_value(value: Any) -> str:
+    """Mask a sensitive value for display: first 3 + '***' + last 4 chars.
+
+    Short values (< 8 chars) are fully masked.
+    Non-string values are converted to string first.
+    This function is called from _display_value which handles None before calling.
+    """
+    # Defensive: handle non-string values from manually-edited YAML
+    if not isinstance(value, str):
+        value = str(value)
+    if len(value) <= 7:
+        return "***"
+    return f"{value[:3]}***{value[-4:]}"
+
+
+def _display_value(key: str, value: Any) -> str:
+    """Return the value as it should be shown, masking sensitive keys."""
+    if value is None:
+        return ""
+    if _is_sensitive_key(key):
+        return _mask_sensitive_value(value)
+    return str(value)
+
+
+def _flatten_config(data: dict[str, Any], prefix: str = "") -> list[tuple[str, Any]]:
+    """Flatten a nested config dict into (dot.key, value) tuples."""
+    result: list[tuple[str, Any]] = []
+    for key, value in data.items():
+        full_key = f"{prefix}.{key}" if prefix else key
+        if isinstance(value, dict):
+            result.extend(_flatten_config(value, full_key))
+        else:
+            result.append((full_key, value))
+    return result
+
+
+def _get_config_usage_panel():
+    """Build the advanced usage panel for config --help."""
+    from rich.panel import Panel
+    from rich.text import Text
+
+    usage_text = f"""\
+Configuration Priority:
+  Project-level (.sanityops/inspect_config.yaml) > Global (~/.sanityops/config)
+  > Environment Variables > Default
+
+Available Keys:
+  server.base_url  Sanityops SaaS backend URL (default: {DEFAULT_SERVER_BASE_URL})
+  server.api_key   API key for authentication (sensitive, masked on display)
+
+Environment Variables:
+  SANITYOPS_BASE_URL  Override server.base_url
+  SANITYOPS_API_KEY   Override server.api_key
+
+Commands:
+  config <key>                      Read a config value
+  config <key> <value>              Set a value (global, default)
+  config <key> <value> --local      Set a project-level value
+  config --list                     List all config values
+  config --unset <key>              Remove a config key
+
+Examples:
+  sanityops-cli config server.base_url               # Read value
+  sanityops-cli config server.base_url https://...   # Set global
+  sanityops-cli config server.base_url https://... --local  # Set project-level
+  sanityops-cli config server.api_key                # Prompt (masked input)
+  sanityops-cli config --list                         # List all values
+  sanityops-cli config --unset server.base_url        # Remove key\
+"""
+    return Panel(
+        Text(usage_text, justify="left"),
+        title="Config Usage",
+        border_style="cyan",
+        padding=(0, 1),
+    )
+
+
+def _help_callback(help_requested: bool) -> None:
+    """Custom help callback placeholder - actual handling in callback body."""
+    # This is a placeholder to enable -h flag; the actual help display is in config_callback
+    pass
+
+
+@config_app.callback(invoke_without_command=True)
+def config_callback(
+    ctx: typer.Context,
+    help_flag: bool = typer.Option(
+        False,
+        "--help",
+        "-h",
+        is_eager=True,
+        callback=_help_callback,
+        help="Show this message and exit",
+    ),
+    key: str = typer.Argument(None, help="Config key, e.g. server.base_url"),
+    value: str = typer.Argument(None, help="Config value (omit to read)"),
+    list_all: bool = typer.Option(False, "--list", "-l", help="List all config values"),
+    unset: str = typer.Option(None, "--unset", help="Remove a config key"),
+    global_config: bool = typer.Option(
+        False,
+        "--global",
+        help="Operate on global config (default behavior)",
+    ),
+    local_config: bool = typer.Option(
+        False,
+        "--local",
+        help="Operate on project-level config",
+    ),
+) -> None:
+    """Get, set, or list sanityops configuration values."""
+    # --global and --local are mutually exclusive scope selectors.
+    # --global is the default (and is explicit); --local targets project config.
+    if global_config and local_config:
+        console.print("[red]Error: --global and --local are mutually exclusive[/red]")
+        raise typer.Exit(code=EXIT_FAILURE)
+
+    use_local = local_config  # --local overrides; default is global
+
+    # Handle --help/-h
+    if help_flag:
+        console.print(ctx.get_help())
+        console.print(_get_config_usage_panel())
+        raise typer.Exit()
+
+    if list_all:
+        _list_config()
+        return
+
+    if unset:
+        _unset_config(unset, local=use_local)
+        return
+
+    if not key:
+        # Show help with additional usage documentation
+        console.print(ctx.get_help())
+        console.print(_get_config_usage_panel())
+        raise typer.Exit()
+
+    if value is None:
+        # Interactive masked input for sensitive keys on a TTY.
+        if _is_sensitive_key(key) and sys.stdin.isatty():
+            entered = getpass.getpass(f"Enter {key}: ")
+            _write_config(key, entered, local=use_local)
+        else:
+            _read_config(key)
+    else:
+        _write_config(key, value, local=use_local)
+
+
+def _read_config(key: str) -> None:
+    """Read and display a config value."""
+    schema = CONFIG_SCHEMA.get(key, {})
+    resolver = ConfigResolver(
+        config_key=key,
+        env_var=schema.get("env"),
+        default=schema.get("default"),
+    )
+    resolved = resolver.resolve()
+
+    if resolved is None:
+        console.print(f"[yellow]{key} is not set[/yellow]")
+        raise typer.Exit()
+
+    console.print(_display_value(key, resolved))
+
+
+def _write_config(key: str, value: str, local: bool = False) -> None:
+    """Write a config value to the global or project config file."""
+    try:
+        if local:
+            ConfigResolver.set_project(key, value)
+            console.print(f"[green]✓[/green] Set {key} in project config")
+        else:
+            ConfigResolver.set_global(key, value)
+            console.print(f"[green]✓[/green] Set {key} in global config")
+    except Exception as e:
+        console.print(f"[red]✗ Failed to write config: {e}[/red]")
+        raise typer.Exit(code=EXIT_FAILURE) from None
+
+
+def _unset_config(key: str, local: bool = False) -> None:
+    """Remove a config key from the global or project config file."""
+    try:
+        removed = ConfigResolver.unset_project(key) if local else ConfigResolver.unset_global(key)
+        if removed:
+            location = "project config" if local else "global config"
+            console.print(f"[green]✓[/green] Removed {key} from {location}")
+        else:
+            console.print(f"[yellow]{key} was not set[/yellow]")
+    except Exception as e:
+        console.print(f"[red]✗ Failed to unset config: {e}[/red]")
+        raise typer.Exit(code=EXIT_FAILURE) from None
+
+
+def _list_config() -> None:
+    """List all config values from global and project configs."""
+    global_config = ConfigResolver.list_global()
+    project_config = ConfigResolver.list_project()
+
+    if not global_config and not project_config:
+        console.print("[yellow]No configuration found[/yellow]")
+        console.print("\n  Run: sanityops-cli config server.base_url <url>")
+        console.print("  Run: sanityops-cli config server.api_key <key>")
+        return
+
+    table = Table(title="[bold]Sanityops Configuration[/]", border_style="blue")
+    table.add_column("Key", style="cyan", no_wrap=True)
+    table.add_column("Global", style="white")
+    table.add_column("Project", style="green")
+
+    # Merge keys from both configs.
+    items: dict[str, tuple[Any, Any]] = {}
+    for k, v in _flatten_config(global_config):
+        items.setdefault(k, (None, None))
+        items[k] = (v, items[k][1])
+    for k, v in _flatten_config(project_config):
+        items.setdefault(k, (None, None))
+        items[k] = (items[k][0], v)
+
+    for key in sorted(items):
+        global_val, project_val = items[key]
+        table.add_row(
+            key,
+            _display_value(key, global_val),
+            _display_value(key, project_val),
+        )
+
+    console.print(table)
+
+    # Report which known env vars are set.
+    env_set: list[tuple[str, str]] = []
+    for config_key, schema in CONFIG_SCHEMA.items():
+        env_name = schema.get("env")
+        if not env_name:
+            continue
+        os_val = os.environ.get(env_name)
+        if os_val:
+            env_set.append((env_name, _display_value(config_key, os_val)))
+
+    if env_set:
+        console.print("\n[dim]Environment variables set:[/dim]")
+        for env_name, val in env_set:
+            console.print(f"  [dim]{env_name}={val}[/dim]")

sanityops_cli/commands/init.py

@@ -0,0 +1,132 @@
+# Copyright 2026 zipsonken
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+#
+
+"""Init command — Initialize inspect configuration."""
+
+from pathlib import Path
+
+import typer
+from rich.console import Console
+
+from sanityops_cli.commands.inspect import inspect_app
+from sanityops_cli.constants.exit_codes import EXIT_FAILURE
+
+console = Console()
+
+# Default paths
+DEFAULT_CONFIG_DIR = ".sanityops"
+DEFAULT_CONFIG_FILE = "inspect_config.yaml"
+
+
+@inspect_app.command("init")
+def init_config() -> None:
+    """Initialize .sanityops/inspect_config.yaml with a template.
+
+    Creates a new config file with a placeholder project UUID. The project
+    stays unbound until the first inspect upload auto-creates it and writes
+    the real project id/name back to this file.
+    If a config already exists, prompts to backup and replace.
+    """
+    from datetime import datetime
+
+    config_dir = Path.cwd() / DEFAULT_CONFIG_DIR
+    config_file = config_dir / DEFAULT_CONFIG_FILE
+
+    # Handle existing config file
+    if config_file.exists():
+        console.print(
+            f"[yellow]![/yellow] Config file already exists at {config_file}"
+        )
+        if not typer.confirm("Backup and create new?", default=False):
+            console.print("[red]✗[/red] Operation cancelled. Existing config preserved.")
+            return  # Using return instead of typer.Exit(0) for test compatibility
+
+        # Backup existing file
+        timestamp = datetime.now().strftime("%Y%m%d_%H%M%S")
+        backup_file = config_dir / f"inspect_config.yaml.bak.{timestamp}"
+        try:
+            config_file.rename(backup_file)
+            console.print(f"[green]✓[/green] Backed up to {backup_file}")
+        except OSError as e:
+            console.print(f"[red]✗ Cannot backup existing config: {e}[/red]")
+            raise typer.Exit(code=EXIT_FAILURE) from None
+
+    # Ensure directory exists
+    try:
+        config_dir.mkdir(parents=True, exist_ok=True)
+    except OSError as e:
+        console.print(f"[red]✗ Cannot create .sanityops directory: {e}[/red]")
+        raise typer.Exit(code=EXIT_FAILURE) from None
+
+    # Load template and generate UUID
+    try:
+        template_content = _load_template()
+    except (FileNotFoundError, ModuleNotFoundError, OSError) as e:
+        console.print(f"[red]✗ Internal error: template not found ({e})[/red]")
+        raise typer.Exit(code=EXIT_FAILURE) from None
+
+    # The placeholder UUID is intentionally left as-is so that the first
+    # inspect upload auto-creates the project and writes the real id/name
+    # back to this config file.
+
+    # Write config file
+    try:
+        with open(config_file, "w", encoding="utf-8") as f:
+            f.write(template_content)
+    except OSError as e:
+        console.print(f"[red]✗ Cannot write config file: {e}[/red]")
+        raise typer.Exit(code=EXIT_FAILURE) from None
+
+    # Keep secrets out of git: the config file holds the API key and the
+    # results directory holds scanned source artifacts. A nested .gitignore
+    # inside the generated directory covers both without touching the
+    # user's repository root .gitignore.
+    try:
+        (config_dir / ".gitignore").write_text("*\n", encoding="utf-8")
+    except OSError as e:
+        console.print(f"[yellow]⚠ Could not write {config_dir / '.gitignore'}: {e}[/yellow]")
+
+    console.print("[green]✓[/green] Created .sanityops/inspect_config.yaml")
+    console.print("Before running inspect, you need:")
+    console.print("- Edit this file to add your prompts, tools, and skills.")
+    console.print(
+        "- Edit this file to add your provider, api_key, model_id and base_url "
+        "(optional. If omitted, the CLI uses LLM_* environment variables)."
+    )
+    console.print("- To connect to the Sanityops service, configure the server URL and API key:")
+    console.print('sanityops-cli config server.base_url "<your-server-url>"')
+    console.print('sanityops-cli config server.api_key "<your-api-key>"')
+
+
+def _load_template() -> str:
+    """Load the inspect_config.yaml template as a string.
+
+    Returns:
+        Template content with placeholder UUID. Returns as string
+        to preserve YAML comments.
+    """
+    import sys
+
+    # PyInstaller bundles resources in sys._MEIPASS
+    if hasattr(sys, "_MEIPASS"):
+        template_path = Path(sys._MEIPASS) / "sanityops_cli" / "templates" / "inspect_config.yaml"
+    else:
+        # Standard importlib.resources for normal Python environments
+        import importlib.resources
+
+        template_path = importlib.resources.files("sanityops_cli.templates") / "inspect_config.yaml"
+        return template_path.read_text(encoding="utf-8")
+
+    return template_path.read_text(encoding="utf-8")