onesearch-cli 0.12.1__py3-none-any.whl

onesearch/__init__.py

@@ -0,0 +1,6 @@
+# Copyright (C) 2025 demigodmode
+# SPDX-License-Identifier: AGPL-3.0-only
+
+"""OneSearch CLI - Command-line interface for OneSearch."""
+
+__version__ = "0.12.1"

onesearch/api.py

@@ -0,0 +1,247 @@
+# Copyright (C) 2025 demigodmode
+# SPDX-License-Identifier: AGPL-3.0-only
+
+"""API client wrapper for OneSearch backend."""
+
+from typing import Any
+from urllib.parse import urljoin
+
+import requests
+
+
+class APIError(Exception):
+    """Exception raised for API errors."""
+
+    def __init__(self, message: str, status_code: int | None = None, details: Any = None):
+        self.message = message
+        self.status_code = status_code
+        self.details = details
+        super().__init__(self.message)
+
+
+class OneSearchAPI:
+    """Client for the OneSearch backend API."""
+
+    def __init__(self, base_url: str = "http://localhost:8000", timeout: int = 30, token: str | None = None):
+        """Initialize the API client.
+
+        Args:
+            base_url: Backend API base URL.
+            timeout: Request timeout in seconds.
+            token: Optional bearer token.
+        """
+        self.base_url = base_url.rstrip("/")
+        self.timeout = timeout
+        self.session = requests.Session()
+        if token:
+            self.session.headers.update({"Authorization": f"Bearer {token}"})
+
+    def _url(self, endpoint: str) -> str:
+        """Build full URL for an endpoint."""
+        return urljoin(self.base_url + "/", endpoint.lstrip("/"))
+
+    def _request(
+        self,
+        method: str,
+        endpoint: str,
+        params: dict | None = None,
+        json: dict | None = None,
+        allow_status_codes: set[int] | None = None,
+    ) -> Any:
+        """Make an API request.
+
+        Args:
+            method: HTTP method (GET, POST, PUT, DELETE).
+            endpoint: API endpoint path.
+            params: Query parameters.
+            json: JSON body data.
+
+        Returns:
+            Response JSON data.
+
+        Raises:
+            APIError: If the request fails.
+        """
+        url = self._url(endpoint)
+        try:
+            response = self.session.request(
+                method=method,
+                url=url,
+                params=params,
+                json=json,
+                timeout=self.timeout,
+            )
+            if allow_status_codes and response.status_code in allow_status_codes:
+                if response.content:
+                    return response.json()
+                return None
+
+            response.raise_for_status()
+            if response.content:
+                return response.json()
+            return None
+        except requests.exceptions.ConnectionError as err:
+            raise APIError(
+                f"Could not connect to OneSearch at {self.base_url}. "
+                "Is the server running?"
+            ) from err
+        except requests.exceptions.Timeout as err:
+            raise APIError(f"Request to {url} timed out after {self.timeout}s") from err
+        except requests.exceptions.HTTPError as e:
+            status_code = e.response.status_code
+            try:
+                details = e.response.json()
+                message = details.get("detail", str(e))
+            except Exception:
+                details = None
+                message = str(e)
+
+            if status_code in (401, 403):
+                message = f"{message}. Run 'onesearch login' or set ONESEARCH_TOKEN."
+
+            raise APIError(message, status_code=status_code, details=details) from e
+
+    def login(self, username: str, password: str) -> dict:
+        """Authenticate and return token payload."""
+        return self._request(
+            "POST",
+            "/api/auth/login",
+            json={"username": username, "password": password},
+        )
+
+    def logout(self) -> dict:
+        """Logout current user."""
+        return self._request("POST", "/api/auth/logout")
+
+    def whoami(self) -> dict:
+        """Return current user info."""
+        return self._request("GET", "/api/auth/me")
+
+    def auth_status(self) -> dict:
+        """Return auth setup status."""
+        return self._request("GET", "/api/auth/status")
+
+    # Health endpoints
+    def health(self, allow_degraded: bool = False) -> dict:
+        """Check system health."""
+        allowed = {503} if allow_degraded else None
+        return self._request("GET", "/api/health", allow_status_codes=allowed)
+
+    def status(self) -> dict:
+        """Get system status."""
+        return self._request("GET", "/api/status")
+
+    def source_status(self, source_id: str) -> dict:
+        """Get status for a specific source."""
+        return self._request("GET", f"/api/status/{source_id}")
+
+    # Source endpoints
+    def list_sources(self) -> list[dict]:
+        """List all sources."""
+        return self._request("GET", "/api/sources")
+
+    def get_source(self, source_id: str) -> dict:
+        """Get a specific source."""
+        return self._request("GET", f"/api/sources/{source_id}")
+
+    def create_source(
+        self,
+        name: str,
+        root_path: str,
+        include_patterns: list[str] | None = None,
+        exclude_patterns: list[str] | None = None,
+    ) -> dict:
+        """Create a new source.
+
+        Args:
+            name: Source display name.
+            root_path: Root path to index.
+            include_patterns: List of glob patterns to include.
+            exclude_patterns: List of glob patterns to exclude.
+
+        Returns:
+            Created source data.
+        """
+        data = {
+            "name": name,
+            "root_path": root_path,
+        }
+        if include_patterns:
+            data["include_patterns"] = include_patterns
+        if exclude_patterns:
+            data["exclude_patterns"] = exclude_patterns
+        return self._request("POST", "/api/sources", json=data)
+
+    def update_source(
+        self,
+        source_id: str,
+        name: str | None = None,
+        include_patterns: list[str] | None = None,
+        exclude_patterns: list[str] | None = None,
+    ) -> dict:
+        """Update a source.
+
+        Args:
+            source_id: Source ID.
+            name: New source name.
+            include_patterns: New include patterns (list of globs).
+            exclude_patterns: New exclude patterns (list of globs).
+
+        Returns:
+            Updated source data.
+        """
+        data = {}
+        if name is not None:
+            data["name"] = name
+        if include_patterns is not None:
+            data["include_patterns"] = include_patterns
+        if exclude_patterns is not None:
+            data["exclude_patterns"] = exclude_patterns
+        return self._request("PUT", f"/api/sources/{source_id}", json=data)
+
+    def delete_source(self, source_id: str) -> None:
+        """Delete a source."""
+        self._request("DELETE", f"/api/sources/{source_id}")
+
+    def reindex_source(self, source_id: str) -> dict:
+        """Trigger reindex for a source.
+
+        Args:
+            source_id: Source ID.
+
+        Returns:
+            Reindex result with statistics.
+        """
+        return self._request("POST", f"/api/sources/{source_id}/reindex")
+
+    # Search endpoints
+    def search(
+        self,
+        query: str,
+        source_id: str | None = None,
+        file_type: str | None = None,
+        limit: int = 20,
+        offset: int = 0,
+    ) -> dict:
+        """Search indexed documents.
+
+        Args:
+            query: Search query string.
+            source_id: Filter by source ID.
+            file_type: Filter by file type (text, markdown, pdf).
+            limit: Maximum results to return.
+            offset: Result offset for pagination.
+
+        Returns:
+            Search results with metadata.
+        """
+        data: dict = {
+            "q": query,
+            "limit": limit,
+            "offset": offset,
+        }
+        if source_id is not None:
+            data["source_id"] = source_id
+        if file_type is not None:
+            data["type"] = file_type
+        return self._request("POST", "/api/search", json=data)

onesearch/banner.py

@@ -0,0 +1,84 @@
+# Copyright (C) 2025 demigodmode
+# SPDX-License-Identifier: AGPL-3.0-only
+
+"""Startup banner rendering for the OneSearch CLI."""
+
+from __future__ import annotations
+
+from rich.console import Group
+from rich.panel import Panel
+from rich.text import Text
+
+
+def _version_tuple(version: str | None) -> tuple[int, ...]:
+    if not version:
+        return ()
+    parts = []
+    for chunk in version.split("."):
+        digits = "".join(ch for ch in chunk if ch.isdigit())
+        if not digits:
+            break
+        parts.append(int(digits))
+    return tuple(parts)
+
+
+def build_startup_panel(
+    *,
+    configured: bool,
+    backend_url: str | None,
+    server_status: str | None = None,
+    auth_state: str | None = None,
+    cli_version: str | None = None,
+    server_version: str | None = None,
+    error_message: str | None = None,
+):
+    """Build the startup banner panel."""
+    lines: list[str] = []
+    title = Text("OneSearch", style="bold cyan")
+
+    if cli_version:
+        lines.append(f"CLI: {cli_version}")
+    if server_version:
+        lines.append(f"Server: {server_version}")
+    if backend_url:
+        lines.append(f"Backend: {backend_url}")
+
+    if not configured:
+        lines.extend(
+            [
+                "",
+                "No backend configured.",
+                "Run: onesearch config set backend_url http://host:8000",
+                "Then: onesearch login",
+            ]
+        )
+        return Panel("\n".join(lines), title=title)
+
+    if auth_state:
+        lines.append(f"Auth: {auth_state}")
+    if server_status:
+        lines.append(f"Status: {server_status}")
+
+    if error_message:
+        lines.extend(["", f"Error: {error_message}"])
+
+    if _version_tuple(server_version) > _version_tuple(cli_version):
+        lines.extend(
+            [
+                "",
+                "Update available: server is newer than this CLI. Consider updating onesearch-cli.",
+            ]
+        )
+
+    if not error_message:
+        lines.extend(
+            [
+                "",
+                "Try:",
+                '  onesearch search "compose"',
+                "  onesearch source list",
+                "  onesearch status",
+            ]
+        )
+
+    return Panel(Group(*lines), title=title)

onesearch/commands/__init__.py

@@ -0,0 +1,4 @@
+# Copyright (C) 2025 demigodmode
+# SPDX-License-Identifier: AGPL-3.0-only
+
+"""CLI command modules."""

onesearch/commands/auth.py

@@ -0,0 +1,64 @@
+# Copyright (C) 2025 demigodmode
+# SPDX-License-Identifier: AGPL-3.0-only
+
+"""Authentication commands."""
+
+import click
+
+from onesearch.api import APIError
+from onesearch.config import delete_config_value, set_config_value
+from onesearch.context import Context, console, err_console, pass_context
+from onesearch.main import cli
+
+
+@cli.command()
+@click.option("--token", "use_token", is_flag=True, help="Prompt for a bearer token instead of username/password.")
+@pass_context
+def login(ctx: Context, use_token: bool):
+    """Authenticate and store a CLI token."""
+    if use_token:
+        token = click.prompt("Token", hide_input=False)
+        set_config_value("auth.token", token)
+        ctx.reset_api()
+        console.print("[green]✓[/green] Token stored for OneSearch CLI")
+        return
+
+    username = click.prompt("Username")
+    password = click.prompt("Password", hide_input=True)
+
+    api = ctx.get_api()
+    try:
+        result = api.login(username, password)
+        token = result.get("access_token")
+        if not token:
+            raise click.ClickException("Login succeeded but no access token was returned.")
+
+        set_config_value("auth.token", token)
+        ctx.reset_api()
+        console.print(f"[green]✓[/green] Logged in as [cyan]{username}[/cyan]")
+    except APIError as e:
+        err_console.print(f"[red]Error:[/red] {e.message}")
+        raise SystemExit(1) from e
+
+
+@cli.command()
+@pass_context
+def logout(ctx: Context):
+    """Remove the stored CLI token."""
+    delete_config_value("auth.token")
+    ctx.reset_api()
+    console.print("[green]✓[/green] Logged out")
+
+
+@cli.command()
+@pass_context
+def whoami(ctx: Context):
+    """Show the current authenticated user."""
+    api = ctx.get_api()
+    try:
+        user = api.whoami()
+        console.print(f"Logged in as [cyan]{user.get('username', 'unknown')}[/cyan]")
+        console.print(f"Backend: [dim]{ctx.url}[/dim]")
+    except APIError as e:
+        err_console.print(f"[red]Error:[/red] {e.message}")
+        raise SystemExit(1) from e

onesearch/commands/config.py

@@ -0,0 +1,166 @@
+# Copyright (C) 2025 demigodmode
+# SPDX-License-Identifier: AGPL-3.0-only
+
+"""Configuration management commands."""
+
+import click
+import yaml
+
+from onesearch.config import (
+    DEFAULT_CONFIG,
+    delete_config_value,
+    get_config_path,
+    get_config_value,
+    load_config,
+    set_config_value,
+)
+from onesearch.context import console, err_console
+from onesearch.main import cli
+
+
+@cli.group()
+def config():
+    """Manage CLI configuration.
+
+    \b
+    Configuration priority (highest to lowest):
+    1. CLI flags (--url)
+    2. Environment variables (ONESEARCH_URL)
+    3. Config file (~/.config/onesearch/config.yml)
+    4. Defaults
+
+    \b
+    Examples:
+      onesearch config show
+      onesearch config set backend_url http://onesearch.local:8000
+      onesearch config get backend_url
+      onesearch config path
+    """
+    pass
+
+
+@config.command("show")
+@click.option("--path", is_flag=True, help="Show config file path only.")
+def config_show(path: bool):
+    """Show current configuration."""
+    config_path = get_config_path()
+
+    if path:
+        console.print(str(config_path))
+        return
+
+    console.print(f"\n[dim]Config file:[/dim] {config_path}")
+    console.print(f"[dim]Exists:[/dim] {config_path.exists()}\n")
+
+    config_data = load_config()
+    if not config_data:
+        console.print("[dim]No configuration set.[/dim]")
+        console.print("\nCreate a config with: [cyan]onesearch config set <key> <value>[/cyan]")
+        console.print("Or initialize defaults: [cyan]onesearch config init[/cyan]")
+        return
+
+    # Pretty print config
+    console.print("[bold]Current Configuration:[/bold]")
+    yaml_str = yaml.safe_dump(config_data, default_flow_style=False, sort_keys=False)
+    for line in yaml_str.strip().split("\n"):
+        if ":" in line and not line.strip().startswith("#"):
+            key, _, value = line.partition(":")
+            console.print(f"  [cyan]{key}[/cyan]:{value}")
+        else:
+            console.print(f"  {line}")
+
+
+@config.command("get")
+@click.argument("key")
+def config_get(key: str):
+    """Get a configuration value.
+
+    \b
+    Arguments:
+      KEY  Configuration key (e.g., backend_url, output.colors)
+    """
+    value = get_config_value(key)
+    if value is None:
+        err_console.print(f"[yellow]Key not found:[/yellow] {key}")
+        raise SystemExit(1)
+
+    if isinstance(value, (dict, list)):
+        console.print(yaml.safe_dump(value, default_flow_style=False))
+    else:
+        console.print(str(value))
+
+
+@config.command("set")
+@click.argument("key")
+@click.argument("value")
+def config_set(key: str, value: str):
+    """Set a configuration value.
+
+    \b
+    Arguments:
+      KEY    Configuration key (e.g., backend_url, output.colors)
+      VALUE  Value to set
+
+    \b
+    Examples:
+      onesearch config set backend_url http://onesearch.local:8000
+      onesearch config set output.colors false
+      onesearch config set defaults.search_limit 50
+    """
+    # Try to parse value as YAML for proper types
+    try:
+        parsed_value = yaml.safe_load(value)
+    except Exception:
+        parsed_value = value
+
+    set_config_value(key, parsed_value)
+    console.print(f"[green]✓[/green] Set [cyan]{key}[/cyan] = {parsed_value}")
+
+
+@config.command("unset")
+@click.argument("key")
+def config_unset(key: str):
+    """Remove a configuration value.
+
+    \b
+    Arguments:
+      KEY  Configuration key to remove
+    """
+    if delete_config_value(key):
+        console.print(f"[green]✓[/green] Removed [cyan]{key}[/cyan]")
+    else:
+        err_console.print(f"[yellow]Key not found:[/yellow] {key}")
+        raise SystemExit(1)
+
+
+@config.command("init")
+@click.option("--force", "-f", is_flag=True, help="Overwrite existing config.")
+def config_init(force: bool):
+    """Initialize configuration file with defaults.
+
+    Creates a config file at ~/.config/onesearch/config.yml (Linux/Mac)
+    or %APPDATA%/onesearch/config.yml (Windows).
+    """
+    config_path = get_config_path()
+
+    if config_path.exists() and not force:
+        console.print(f"[yellow]Config file already exists:[/yellow] {config_path}")
+        console.print("\nUse [cyan]--force[/cyan] to overwrite.")
+        return
+
+    # Create config directory
+    config_path.parent.mkdir(parents=True, exist_ok=True)
+
+    # Write default config
+    default_content = DEFAULT_CONFIG.format(config_path=config_path)
+    with open(config_path, "w") as f:
+        f.write(default_content)
+
+    console.print(f"[green]✓[/green] Created config file: {config_path}")
+    console.print("\nEdit this file or use [cyan]onesearch config set <key> <value>[/cyan]")
+
+
+@config.command("path")
+def config_path_command():
+    """Show the configuration file path."""
+    console.print(str(get_config_path()))