onesearch-cli 0.12.1__py3-none-any.whl

onesearch/commands/search.py

@@ -0,0 +1,142 @@
+# Copyright (C) 2025 demigodmode
+# SPDX-License-Identifier: AGPL-3.0-only
+
+"""Search command."""
+
+import json
+
+import click
+from rich.markup import escape
+from rich.text import Text
+
+from onesearch.api import APIError
+from onesearch.context import Context, console, err_console, pass_context
+from onesearch.main import cli
+
+
+def format_size(size_bytes: int | None) -> str:
+    """Format bytes as human-readable size."""
+    if size_bytes is None:
+        return "-"
+    size: float = float(size_bytes)
+    for unit in ["B", "KB", "MB", "GB"]:
+        if abs(size) < 1024:
+            return f"{size:.1f} {unit}"
+        size /= 1024
+    return f"{size:.1f} TB"
+
+
+def highlight_snippet(text: str, query: str) -> Text:
+    """Create a Rich Text with query terms highlighted."""
+    result = Text()
+    text_lower = text.lower()
+    query_terms = query.lower().split()
+
+    i = 0
+    while i < len(text):
+        matched = False
+        for term in query_terms:
+            if text_lower[i:].startswith(term):
+                result.append(text[i:i + len(term)], style="bold yellow")
+                i += len(term)
+                matched = True
+                break
+        if not matched:
+            result.append(text[i])
+            i += 1
+
+    return result
+
+
+@cli.command()
+@click.argument("query")
+@click.option("--source", "-s", "source_id", help="Filter by source ID.")
+@click.option("--type", "-t", "file_type", type=click.Choice(["text", "markdown", "pdf"]), help="Filter by file type.")
+@click.option("--limit", "-l", default=20, help="Max results to return.", show_default=True)
+@click.option("--offset", "-o", default=0, help="Result offset for pagination.")
+@click.option("--json", "as_json", is_flag=True, help="Output as JSON for scripting.")
+@pass_context
+def search(
+    ctx: Context,
+    query: str,
+    source_id: str | None,
+    file_type: str | None,
+    limit: int,
+    offset: int,
+    as_json: bool,
+):
+    """Search indexed documents.
+
+    \b
+    Arguments:
+      QUERY  Search query string
+
+    \b
+    Examples:
+      onesearch search "kubernetes deployment"
+      onesearch search "python" --source 1 --type pdf --limit 10
+      onesearch search "error" --json | jq '.results[].path'
+    """
+    api = ctx.get_api()
+    try:
+        result = api.search(
+            query=query,
+            source_id=source_id,
+            file_type=file_type,
+            limit=limit,
+            offset=offset,
+        )
+
+        out = ctx.get_console()
+
+        if as_json:
+            console.print(json.dumps(result, indent=2))
+            return
+
+        # Backend returns: {results, total, limit, offset, processing_time_ms}
+        results = result.get("results", [])
+        total = result.get("total", len(results))
+        processing_time = result.get("processing_time_ms", 0)
+
+        if not results:
+            out.print(f"[dim]No results found for:[/dim] [cyan]{escape(query)}[/cyan]")
+            return
+
+        out.print(f"\nFound [green]{total}[/green] results in [dim]{processing_time}ms[/dim]\n")
+
+        for i, hit in enumerate(results, start=offset + 1):
+            # Title line - backend returns: basename, source_name
+            filename = hit.get("basename", hit.get("path", "Unknown").split("/")[-1])
+            source_name = hit.get("source_name", "Unknown")
+            console.print(f"[bold][{i}][/bold] [cyan]{escape(filename)}[/cyan] [dim]({source_name})[/dim]")
+
+            # Metadata line - backend returns: type, size_bytes, modified_at
+            file_type_display = hit.get("type", "unknown")
+            size = format_size(hit.get("size_bytes"))
+            modified = hit.get("modified_at", "-")
+            # modified_at is Unix timestamp
+            if isinstance(modified, int):
+                from datetime import datetime
+                modified = datetime.fromtimestamp(modified).strftime("%Y-%m-%d")
+            console.print(f"    Path: {escape(hit.get('path', '-'))}")
+            console.print(f"    Type: {file_type_display} | Size: {size} | Modified: {modified}")
+
+            # Snippet - backend returns pre-formatted snippet
+            snippet = hit.get("snippet", "")
+            if snippet:
+                snippet = snippet.replace("\n", " ").strip()
+                highlighted = highlight_snippet(snippet, query)
+                console.print("    ", end="")
+                console.print(highlighted)
+
+            console.print()
+
+        # Pagination hint (only in non-quiet mode)
+        if offset + len(results) < total:
+            next_offset = offset + limit
+            out.print(f"[dim]Showing {offset + 1}-{offset + len(results)} of {total}. ")
+            out.print(f"Use --offset {next_offset} for more results.[/dim]")
+
+    except APIError as e:
+        err_console.print(f"[red]Error:[/red] {e.message}")
+        raise SystemExit(1) from e

onesearch/commands/source.py

@@ -0,0 +1,232 @@
+# Copyright (C) 2025 demigodmode
+# SPDX-License-Identifier: AGPL-3.0-only
+
+"""Source management commands."""
+
+import click
+from rich.table import Table
+
+from onesearch.api import APIError
+from onesearch.context import Context, console, err_console, pass_context
+from onesearch.main import cli
+
+
+def parse_patterns(patterns: str | None) -> list[str] | None:
+    """Parse comma-separated patterns into a list."""
+    if not patterns:
+        return None
+    return [p.strip() for p in patterns.split(",") if p.strip()]
+
+
+def format_patterns(patterns: list[str] | None) -> str:
+    """Format a list of patterns for display."""
+    if not patterns:
+        return "*"
+    return ", ".join(patterns)
+
+
+@cli.group()
+def source():
+    """Manage search sources.
+
+    \b
+    Examples:
+      onesearch source list
+      onesearch source add "Documents" /data/docs
+      onesearch source show 1
+      onesearch source reindex 1
+      onesearch source delete 1
+    """
+    pass
+
+
+@source.command("list")
+@pass_context
+def source_list(ctx: Context):
+    """List all configured sources."""
+    api = ctx.get_api()
+    try:
+        sources = api.list_sources()
+
+        if not sources:
+            console.print("[dim]No sources configured.[/dim]")
+            console.print("\nAdd a source with: [cyan]onesearch source add <name> <path>[/cyan]")
+            return
+
+        table = Table(title="Sources")
+        table.add_column("ID", style="cyan", no_wrap=True)
+        table.add_column("Name", style="green")
+        table.add_column("Root Path")
+        table.add_column("Include Patterns", style="dim")
+        table.add_column("Exclude Patterns", style="dim")
+
+        for s in sources:
+            table.add_row(
+                str(s["id"]),
+                s["name"],
+                s["root_path"],
+                format_patterns(s.get("include_patterns")),
+                format_patterns(s.get("exclude_patterns")) if s.get("exclude_patterns") else "-",
+            )
+
+        console.print(table)
+    except APIError as e:
+        err_console.print(f"[red]Error:[/red] {e.message}")
+        raise SystemExit(1) from e
+
+
+@source.command("add")
+@click.argument("name")
+@click.argument("path", type=click.Path())
+@click.option("--include", "-i", help="Include patterns (comma-separated globs).")
+@click.option("--exclude", "-e", help="Exclude patterns (comma-separated globs).")
+@click.option("--no-validate", is_flag=True, help="Skip path validation (for remote/container paths).")
+@pass_context
+def source_add(ctx: Context, name: str, path: str, include: str | None, exclude: str | None, no_validate: bool):
+    """Add a new source.
+
+    \b
+    Arguments:
+      NAME  Friendly name for the source
+      PATH  Root path to index
+
+    \b
+    Examples:
+      onesearch source add "Documents" /data/docs
+      onesearch source add "Notes" /data/notes --include "**/*.md,**/*.txt"
+      onesearch source add "Code" /data/code --exclude "**/node_modules/**,**/.git/**"
+
+    \b
+    Note: Use --no-validate for paths that exist only inside Docker containers.
+    """
+    # Validate path exists locally (unless skipped)
+    if not no_validate:
+        from pathlib import Path as PathLib
+        path_obj = PathLib(path)
+        if not path_obj.exists():
+            err_console.print(f"[yellow]Warning:[/yellow] Path does not exist locally: {path}")
+            err_console.print("[dim]If this path exists inside a Docker container, use --no-validate[/dim]")
+            if not click.confirm("Continue anyway?"):
+                err_console.print("[dim]Aborted.[/dim]")
+                raise SystemExit(1)
+        elif not path_obj.is_dir():
+            err_console.print(f"[red]Error:[/red] Path is not a directory: {path}")
+            raise SystemExit(1)
+
+    api = ctx.get_api()
+    try:
+        result = api.create_source(
+            name=name,
+            root_path=path,
+            include_patterns=parse_patterns(include),
+            exclude_patterns=parse_patterns(exclude),
+        )
+        out = ctx.get_console()
+        out.print(f"[green]✓[/green] Created source [cyan]{result['name']}[/cyan] (ID: {result['id']})")
+        out.print(f"  Path: {result['root_path']}")
+        if result.get("include_patterns"):
+            out.print(f"  Include: {format_patterns(result['include_patterns'])}")
+        if result.get("exclude_patterns"):
+            out.print(f"  Exclude: {format_patterns(result['exclude_patterns'])}")
+        out.print("\nRun [cyan]onesearch source reindex {id}[/cyan] to start indexing.".format(id=result['id']))
+    except APIError as e:
+        err_console.print(f"[red]Error:[/red] {e.message}")
+        raise SystemExit(1) from e
+
+
+@source.command("show")
+@click.argument("source_id")
+@pass_context
+def source_show(ctx: Context, source_id: str):
+    """Show details for a source.
+
+    \b
+    Arguments:
+      SOURCE_ID  The source ID to show
+    """
+    api = ctx.get_api()
+    try:
+        s = api.get_source(source_id)
+        console.print(f"\n[bold cyan]{s['name']}[/bold cyan] (ID: {s['id']})")
+        console.print(f"  Root Path:        {s['root_path']}")
+        console.print(f"  Include Patterns: {format_patterns(s.get('include_patterns'))}")
+        console.print(f"  Exclude Patterns: {format_patterns(s.get('exclude_patterns')) if s.get('exclude_patterns') else '-'}")
+        if s.get("created_at"):
+            console.print(f"  Created:          {s['created_at']}")
+        if s.get("updated_at"):
+            console.print(f"  Updated:          {s['updated_at']}")
+    except APIError as e:
+        err_console.print(f"[red]Error:[/red] {e.message}")
+        raise SystemExit(1) from e
+
+
+@source.command("delete")
+@click.argument("source_id")
+@click.option("--yes", "-y", is_flag=True, help="Skip confirmation prompt.")
+@pass_context
+def source_delete(ctx: Context, source_id: str, yes: bool):
+    """Delete a source.
+
+    \b
+    Arguments:
+      SOURCE_ID  The source ID to delete
+
+    This will remove the source configuration and all indexed documents
+    from this source.
+    """
+    api = ctx.get_api()
+    try:
+        # Get source info for confirmation
+        s = api.get_source(source_id)
+
+        if not yes:
+            console.print(f"[yellow]Warning:[/yellow] This will delete source [cyan]{s['name']}[/cyan] (ID: {source_id})")
+            console.print(f"  Path: {s['root_path']}")
+            console.print("\nAll indexed documents from this source will be removed.")
+            if not click.confirm("Are you sure?"):
+                console.print("[dim]Aborted.[/dim]")
+                return
+
+        api.delete_source(source_id)
+        ctx.get_console().print(f"[green]✓[/green] Deleted source [cyan]{s['name']}[/cyan]")
+    except APIError as e:
+        err_console.print(f"[red]Error:[/red] {e.message}")
+        raise SystemExit(1) from e
+
+
+@source.command("reindex")
+@click.argument("source_id")
+@pass_context
+def source_reindex(ctx: Context, source_id: str):
+    """Trigger reindex for a source.
+
+    \b
+    Arguments:
+      SOURCE_ID  The source ID to reindex
+
+    This will scan the source path and index all matching files.
+    """
+    api = ctx.get_api()
+    out = ctx.get_console()
+    try:
+        s = api.get_source(source_id)
+        out.print(f"[dim]Reindexing source [cyan]{s['name']}[/cyan]...[/dim]")
+
+        result = api.reindex_source(source_id)
+
+        # Backend returns: {"message": ..., "stats": {...}}
+        stats = result.get("stats", {})
+
+        out.print(f"\n[green]✓[/green] Reindex completed for [cyan]{s['name']}[/cyan]")
+        out.print(f"  Files scanned:  {stats.get('total_scanned', 0)}")
+        out.print(f"  New files:      {stats.get('new_files', 0)}")
+        out.print(f"  Modified:       {stats.get('modified_files', 0)}")
+        out.print(f"  Unchanged:      {stats.get('unchanged_files', 0)}")
+        out.print(f"  [green]Successful:   {stats.get('successful', 0)}[/green]")
+        if stats.get("failed", 0) > 0:
+            out.print(f"  [yellow]Failed:       {stats.get('failed', 0)}[/yellow]")
+        if stats.get("skipped", 0) > 0:
+            out.print(f"  Skipped:      {stats.get('skipped', 0)}")
+    except APIError as e:
+        err_console.print(f"[red]Error:[/red] {e.message}")
+        raise SystemExit(1) from e

onesearch/commands/status.py

@@ -0,0 +1,221 @@
+# Copyright (C) 2025 demigodmode
+# SPDX-License-Identifier: AGPL-3.0-only
+
+"""Status and health commands."""
+
+import json
+from datetime import datetime
+
+import click
+from rich.table import Table
+
+from onesearch.api import APIError
+from onesearch.config import get_config_path
+from onesearch.context import Context, console, err_console, pass_context
+from onesearch.main import cli
+
+
+def format_timestamp(ts) -> str:
+    """Format a timestamp for display."""
+    if not ts:
+        return "-"
+    if isinstance(ts, str):
+        # ISO format string
+        if "T" in ts:
+            return ts.replace("T", " ").split(".")[0]
+        return ts
+    if isinstance(ts, (int, float)):
+        # Unix timestamp
+        return datetime.fromtimestamp(ts).strftime("%Y-%m-%d %H:%M")
+    return str(ts)
+
+
+@cli.command()
+@click.argument("source_id", required=False)
+@click.option("--json", "as_json", is_flag=True, help="Output as JSON for scripting.")
+@pass_context
+def status(ctx: Context, source_id: str | None, as_json: bool):
+    """Show indexing status for sources.
+
+    \b
+    Arguments:
+      SOURCE_ID  Optional source ID for detailed status
+
+    \b
+    Examples:
+      onesearch status           # All sources
+      onesearch status my-docs   # Specific source
+      onesearch status --json    # JSON output
+    """
+    api = ctx.get_api()
+    try:
+        if source_id is not None:
+            # Detailed status for specific source
+            # Backend returns flat: {source_id, source_name, total_files, successful, failed, skipped, last_indexed_at, failed_files}
+            result = api.source_status(source_id)
+            if as_json:
+                console.print(json.dumps(result, indent=2, default=str))
+                return
+
+            console.print(f"\n[bold cyan]{result.get('source_name', 'Unknown')}[/bold cyan] (ID: {result.get('source_id', source_id)})")
+            console.print()
+
+            console.print("[bold]Indexing Statistics:[/bold]")
+            console.print(f"  Total Files:  {result.get('total_files', 0)}")
+            console.print(f"  [green]Successful: {result.get('successful', 0)} ✓[/green]")
+
+            failed = result.get("failed", 0)
+            if failed > 0:
+                console.print(f"  [red]Failed:     {failed} ✗[/red]")
+            else:
+                console.print("  Failed:     0")
+
+            skipped = result.get("skipped", 0)
+            if skipped > 0:
+                console.print(f"  [yellow]Skipped:    {skipped}[/yellow]")
+
+            last_indexed = format_timestamp(result.get("last_indexed_at"))
+            console.print(f"  Last Index: {last_indexed}")
+
+            # Show failed files if any
+            failed_files = result.get("failed_files", [])
+            if failed_files:
+                console.print(f"\n[bold red]Failed Files ({len(failed_files)}):[/bold red]")
+                for f in failed_files[:10]:  # Show first 10
+                    console.print(f"  • {f.get('path', 'Unknown')}")
+                    if f.get("error"):
+                        console.print(f"    [dim]{f['error']}[/dim]")
+                if len(failed_files) > 10:
+                    console.print(f"  [dim]... and {len(failed_files) - 10} more[/dim]")
+        else:
+            # Overview status for all sources
+            # Backend returns: {sources: [{source_id, source_name, total_files, successful, failed, skipped, last_indexed_at, ...}]}
+            result = api.status()
+            if as_json:
+                console.print(json.dumps(result, indent=2, default=str))
+                return
+
+            sources = result.get("sources", [])
+            if not sources:
+                console.print("[dim]No sources configured.[/dim]")
+                console.print("\nAdd a source with: [cyan]onesearch source add <name> <path>[/cyan]")
+                return
+
+            table = Table(title="Source Status")
+            table.add_column("Source", style="cyan")
+            table.add_column("Total", justify="right")
+            table.add_column("Success", justify="right", style="green")
+            table.add_column("Failed", justify="right")
+            table.add_column("Skipped", justify="right")
+            table.add_column("Last Indexed")
+
+            for s in sources:
+                # Check for error status
+                if s.get("error"):
+                    table.add_row(
+                        f"{s.get('source_name', 'Unknown')} ({s.get('source_id', '?')})",
+                        "-",
+                        "-",
+                        "[red]Error[/red]",
+                        "-",
+                        "-",
+                    )
+                    continue
+
+                failed = s.get("failed", 0)
+                failed_str = f"[red]{failed} ✗[/red]" if failed > 0 else "0"
+
+                last_indexed = format_timestamp(s.get("last_indexed_at"))
+
+                table.add_row(
+                    f"{s.get('source_name', 'Unknown')} ({s.get('source_id', '?')})",
+                    str(s.get("total_files", 0)),
+                    f"{s.get('successful', 0)} ✓",
+                    failed_str,
+                    str(s.get("skipped", 0)),
+                    last_indexed,
+                )
+
+            console.print()
+            console.print(table)
+            console.print()
+
+    except APIError as e:
+        err_console.print(f"[red]Error:[/red] {e.message}")
+        raise SystemExit(1) from e
+
+
+@cli.command()
+@click.option("--json", "as_json", is_flag=True, help="Output as JSON for scripting.")
+@pass_context
+def health(ctx: Context, as_json: bool):
+    """Check system health.
+
+    Verifies connectivity to the backend and Meilisearch,
+    and displays current configuration.
+
+    \b
+    Examples:
+      onesearch health
+      onesearch health --json
+    """
+    api = ctx.get_api()
+    config_path = get_config_path()
+
+    try:
+        result = api.health()
+
+        if as_json:
+            # Include config info in JSON output
+            result["config"] = {
+                "config_file": str(config_path),
+                "config_exists": config_path.exists(),
+                "backend_url": ctx.url,
+            }
+            console.print(json.dumps(result, indent=2))
+            return
+
+        # Essential status always shown (even in quiet mode)
+        overall = result.get("status", "unknown")
+        if overall == "healthy":
+            console.print("[bold green]✓ System Healthy[/bold green]")
+        else:
+            console.print(f"[bold yellow]⚠ System Status: {overall}[/bold yellow]")
+
+        # Detailed info only in non-quiet mode
+        out = ctx.get_console()
+        out.print()
+        out.print("[bold]Services:[/bold]")
+        out.print(f"  Backend:     {ctx.url} [green]✓[/green]")
+        out.print(f"  Service:     {result.get('service', 'onesearch-backend')} v{result.get('version', '?')}")
+
+        # Meilisearch status - backend returns {status: "available"|"degraded"|...}
+        meili = result.get("meilisearch", {})
+        meili_status = meili.get("status", "unknown")
+        if meili_status in ("available", "healthy"):
+            out.print("  Meilisearch: Connected [green]✓[/green]")
+        else:
+            out.print(f"  Meilisearch: [yellow]{meili_status}[/yellow]")
+
+        out.print()
+        out.print("[bold]Configuration:[/bold]")
+        out.print(f"  Config file: {config_path}")
+        if config_path.exists():
+            out.print("  Config:      [green]Loaded[/green]")
+        else:
+            out.print("  Config:      [dim]Using defaults[/dim]")
+        out.print()
+
+    except APIError as e:
+        err_console.print("[red]✗ System Unhealthy[/red]")
+        err_console.print(f"\n  Backend: {ctx.url} [red]✗[/red]")
+        err_console.print(f"  Error: {e.message}")
+        err_console.print()
+        err_console.print("[bold]Configuration:[/bold]")
+        err_console.print(f"  Config file: {config_path}")
+        if config_path.exists():
+            err_console.print("  Config:      [green]Loaded[/green]")
+        else:
+            err_console.print("  Config:      [dim]Using defaults[/dim]")
+        console.print()
+        raise SystemExit(1) from e