haiku.rag-slim 0.16.0__py3-none-any.whl → 0.24.0__py3-none-any.whl

haiku/rag/cli.py

@@ -1,6 +1,7 @@
 import asyncio
 import json
 import warnings
+from datetime import datetime
 from importlib.metadata import version
 from pathlib import Path
 from typing import Any
@@ -26,6 +27,10 @@ cli = typer.Typer(
     context_settings={"help_option_names": ["-h", "--help"]}, no_args_is_help=True
 )
 
+# Module-level flags set by callback
+_read_only: bool = False
+_before: datetime | None = None
+
 
 def create_app(db: Path | None = None) -> HaikuRAGApp:
     """Create HaikuRAGApp with loaded config and resolved database path.
@@ -38,7 +43,9 @@ def create_app(db: Path | None = None) -> HaikuRAGApp:
     """
     config = get_config()
     db_path = db if db else config.storage.data_dir / "haiku.rag.lancedb"
-    return HaikuRAGApp(db_path=db_path, config=config)
+    return HaikuRAGApp(
+        db_path=db_path, config=config, read_only=_read_only, before=_before
+    )
 
 
 async def check_version():
@@ -72,8 +79,33 @@ def main(
         "--config",
         help="Path to YAML configuration file",
     ),
+    read_only: bool = typer.Option(
+        False,
+        "--read-only",
+        help="Open database in read-only mode",
+    ),
+    before: str | None = typer.Option(
+        None,
+        "--before",
+        help="Query database as it existed before this datetime (implies --read-only). "
+        "Accepts ISO 8601 format (e.g., 2025-01-15T14:30:00) or date (e.g., 2025-01-15)",
+    ),
 ):
     """haiku.rag CLI - Vector database RAG system"""
+    global _read_only, _before
+    _read_only = read_only
+
+    # Parse and store before datetime
+    if before is not None:
+        from haiku.rag.utils import parse_datetime, to_utc
+
+        try:
+            _before = to_utc(parse_datetime(before))
+        except ValueError as e:
+            typer.echo(f"Error: {e}")
+            raise typer.Exit(1)
+    else:
+        _before = None
     # Load config from --config, local folder, or default directory
     config_path = find_config_file(cli_path=config)
     if config_path:
@@ -81,18 +113,24 @@ def main(
         loaded_config = AppConfig.model_validate(yaml_data)
         set_config(loaded_config)
 
-    # Configure logging minimally for CLI context
-    if get_config().environment == "development":
-        # Lazy import logfire only in development
-        try:
-            import logfire  # type: ignore
+    # Configure logging for CLI context
+    configure_cli_logging()
 
-            logfire.configure(send_to_logfire="if-token-present")
-            logfire.instrument_pydantic_ai()
-        except Exception:
-            pass
-    else:
-        configure_cli_logging()
+    # Configure logfire (only sends data if token is present)
+    try:
+        import logfire
+
+        is_production = get_config().environment != "development"
+        logfire.configure(
+            send_to_logfire="if-token-present",
+            console=False if is_production else None,
+        )
+        logfire.instrument_pydantic_ai()
+    except Exception:
+        pass
+
+    if get_config().environment != "development":
+        # Suppress warnings in production
         warnings.filterwarnings("ignore")
 
     # Run version check before any command
@@ -237,11 +275,11 @@ def search(
     query: str = typer.Argument(
         help="The search query to use",
     ),
-    limit: int = typer.Option(
-        5,
+    limit: int | None = typer.Option(
+        None,
         "--limit",
         "-l",
-        help="Maximum number of results to return",
+        help="Maximum number of results to return (default: config search.default_limit)",
     ),
     filter: str | None = typer.Option(
         None,
@@ -259,6 +297,21 @@ def search(
     asyncio.run(app.search(query=query, limit=limit, filter=filter))
 
 
+@cli.command("visualize", help="Show visual grounding for a chunk")
+def visualize(
+    chunk_id: str = typer.Argument(
+        help="The ID of the chunk to visualize",
+    ),
+    db: Path | None = typer.Option(
+        None,
+        "--db",
+        help="Path to the LanceDB database file",
+    ),
+):
+    app = create_app(db)
+    asyncio.run(app.visualize_chunk(chunk_id=chunk_id))
+
+
 @cli.command("ask", help="Ask a question using the QA agent")
 def ask(
     question: str = typer.Argument(
@@ -284,15 +337,24 @@ def ask(
         "--verbose",
         help="Show verbose progress output (only with --deep)",
     ),
+    filter: str | None = typer.Option(
+        None,
+        "--filter",
+        "-f",
+        help="SQL WHERE clause to filter documents (e.g., \"uri LIKE '%arxiv%'\")",
+    ),
 ):
     app = create_app(db)
-    asyncio.run(app.ask(question=question, cite=cite, deep=deep, verbose=verbose))
+    asyncio.run(
+        app.ask(question=question, cite=cite, deep=deep, verbose=verbose, filter=filter)
+    )
 
 
 @cli.command("research", help="Run multi-agent research and output a concise report")
 def research(
     question: str = typer.Argument(
-        help="The research question to investigate",
+        None,
+        help="The research question to investigate (required unless --interactive)",
     ),
     db: Path | None = typer.Option(
         None,
@@ -304,9 +366,42 @@ def research(
         "--verbose",
         help="Show planning, searching previews, evaluation summary, and stop reason",
     ),
+    filter: str | None = typer.Option(
+        None,
+        "--filter",
+        "-f",
+        help="SQL WHERE clause to filter documents (e.g., \"uri LIKE '%arxiv%'\")",
+    ),
+    interactive: bool = typer.Option(
+        False,
+        "--interactive",
+        "-i",
+        help="Start interactive research mode with human-in-the-loop",
+    ),
 ):
     app = create_app(db)
-    asyncio.run(app.research(question=question, verbose=verbose))
+
+    if interactive:
+        from haiku.rag.cli_chat import interactive_research
+        from haiku.rag.client import HaikuRAG
+
+        client = HaikuRAG(
+            db_path=app.db_path, config=app.config, read_only=_read_only, before=_before
+        )
+        try:
+            interactive_research(
+                client=client,
+                config=app.config,
+                search_filter=filter,
+                question=question,
+            )
+        finally:
+            client.close()
+    else:
+        if question is None:
+            typer.echo("Error: Question is required unless using --interactive mode")
+            raise typer.Exit(1)
+        asyncio.run(app.research(question=question, verbose=verbose, filter=filter))
 
 
 @cli.command("settings", help="Display current configuration settings")
@@ -358,9 +453,32 @@ def rebuild(
         "--db",
         help="Path to the LanceDB database file",
     ),
+    embed_only: bool = typer.Option(
+        False,
+        "--embed-only",
+        help="Only regenerate embeddings, keep existing chunks",
+    ),
+    rechunk: bool = typer.Option(
+        False,
+        "--rechunk",
+        help="Re-chunk from existing content without accessing source files",
+    ),
 ):
+    from haiku.rag.client import RebuildMode
+
+    if embed_only and rechunk:
+        typer.echo("Error: --embed-only and --rechunk are mutually exclusive")
+        raise typer.Exit(1)
+
+    if embed_only:
+        mode = RebuildMode.EMBED_ONLY
+    elif rechunk:
+        mode = RebuildMode.RECHUNK
+    else:
+        mode = RebuildMode.FULL
+
     app = create_app(db)
-    asyncio.run(app.rebuild())
+    asyncio.run(app.rebuild(mode=mode))
 
 
 @cli.command("vacuum", help="Optimize and clean up all tables to reduce disk usage")
@@ -375,7 +493,31 @@ def vacuum(
     asyncio.run(app.vacuum())
 
 
-@cli.command("info", help="Show read-only database info (no upgrades or writes)")
+@cli.command("create-index", help="Create vector index for efficient similarity search")
+def create_index(
+    db: Path | None = typer.Option(
+        None,
+        "--db",
+        help="Path to the LanceDB database file",
+    ),
+):
+    app = create_app(db)
+    asyncio.run(app.create_index())
+
+
+@cli.command("init", help="Initialize a new database")
+def init_db(
+    db: Path | None = typer.Option(
+        None,
+        "--db",
+        help="Path to the LanceDB database file",
+    ),
+):
+    app = create_app(db)
+    asyncio.run(app.init())
+
+
+@cli.command("info", help="Show database info")
 def info(
     db: Path | None = typer.Option(
         None,
@@ -387,18 +529,59 @@ def info(
     asyncio.run(app.info())
 
 
+@cli.command("history", help="Show version history for database tables")
+def history(
+    db: Path | None = typer.Option(
+        None,
+        "--db",
+        help="Path to the LanceDB database file",
+    ),
+    table: str | None = typer.Option(
+        None,
+        "--table",
+        "-t",
+        help="Specific table to show history for (documents, chunks, settings)",
+    ),
+    limit: int | None = typer.Option(
+        None,
+        "--limit",
+        "-l",
+        help="Maximum number of versions to show per table",
+    ),
+):
+    app = create_app(db)
+    asyncio.run(app.history(table=table, limit=limit))
+
+
 @cli.command("download-models", help="Download Docling and Ollama models per config")
 def download_models_cmd():
-    from haiku.rag.utils import prefetch_models
-
+    app = HaikuRAGApp(db_path=Path(), config=get_config())
     try:
-        prefetch_models()
-        typer.echo("Models downloaded successfully.")
+        asyncio.run(app.download_models())
     except Exception as e:
         typer.echo(f"Error downloading models: {e}")
         raise typer.Exit(1)
 
 
+@cli.command("inspect", help="Launch interactive TUI to inspect database contents")
+def inspect(
+    db: Path | None = typer.Option(
+        None,
+        "--db",
+        help="Path to the LanceDB database file",
+    ),
+):
+    """Launch the inspector TUI for browsing documents and chunks."""
+    try:
+        from haiku.rag.inspector import run_inspector
+    except ImportError as e:
+        typer.echo(f"Error: {e}", err=True)
+        raise typer.Exit(1) from e
+
+    db_path = db if db else get_config().storage.data_dir / "haiku.rag.lancedb"
+    run_inspector(db_path, read_only=_read_only, before=_before)
+
+
 @cli.command(
     "serve",
     help="Start haiku.rag server. Use --monitor, --mcp, and/or --agui to enable services.",