haiku.rag 0.10.1__tar.gz → 0.10.2__tar.gz

{haiku_rag-0.10.1 → haiku_rag-0.10.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: haiku.rag
-Version: 0.10.1
+Version: 0.10.2
 Summary: Agentic Retrieval Augmented Generation (RAG) with LanceDB
 Author-email: Yiorgis Gozadinos <ggozadinos@gmail.com>
 License: MIT
@@ -66,7 +66,8 @@ uv pip install haiku.rag
 
 # Add documents
 haiku-rag add "Your content here"
-haiku-rag add-src document.pdf
+haiku-rag add "Your content here" --meta author=alice --meta topic=notes
+haiku-rag add-src document.pdf --meta source=manual
 
 # Search
 haiku-rag search "query"

{haiku_rag-0.10.1 → haiku_rag-0.10.2}/README.md

@@ -28,7 +28,8 @@ uv pip install haiku.rag
 
 # Add documents
 haiku-rag add "Your content here"
-haiku-rag add-src document.pdf
+haiku-rag add "Your content here" --meta author=alice --meta topic=notes
+haiku-rag add-src document.pdf --meta source=manual
 
 # Search
 haiku-rag search "query"

{haiku_rag-0.10.1 → haiku_rag-0.10.2}/docs/cli.md

@@ -27,6 +27,9 @@ haiku-rag list
 From text:
 ```bash
 haiku-rag add "Your document content here"
+
+# Attach metadata (repeat --meta for multiple entries)
+haiku-rag add "Your document content here" --meta author=alice --meta topic=notes
 ```
 
 From file or URL:
@@ -36,6 +39,10 @@ haiku-rag add-src https://example.com/article.html
 
 # Optionally set a human‑readable title stored in the DB schema
 haiku-rag add-src /mnt/data/doc1.pdf --title "Q3 Financial Report"
+
+# Optionally attach metadata (repeat --meta). Values use JSON parsing if possible:
+# numbers, booleans, null, arrays/objects; otherwise kept as strings.
+haiku-rag add-src /mnt/data/doc1.pdf --meta source=manual --meta page_count=12 --meta published=true
 ```
 
 !!! note
@@ -126,6 +133,26 @@ haiku-rag settings
 
 ## Maintenance
 
+### Info (Read-only)
+
+Display database metadata without upgrading or modifying it:
+
+```bash
+haiku-rag info [--db /path/to/your.lancedb]
+```
+
+Shows:
+- path to the database
+- stored haiku.rag version (from settings)
+- embeddings provider/model and vector dimension
+- number of documents
+- table versions per table (documents, chunks)
+
+At the end, a separate “Versions” section lists runtime package versions:
+- haiku.rag
+- lancedb
+- docling
+
 ### Vacuum (Optimize and Cleanup)
 
 Reduce disk usage by optimizing and pruning old table versions across all tables:
@@ -143,6 +170,18 @@ when want to switch embeddings provider or model:
 haiku-rag rebuild
 ```
 
+### Download Models
+
+Download required runtime models:
+
+```bash
+haiku-rag download-models
+```
+
+This command:
+- Downloads Docling OCR/conversion models (no-op if already present).
+- Pulls Ollama models referenced in your configuration (embeddings, QA, research, rerank).
+
 ## Migration
 
 ### Migrate from SQLite to LanceDB

{haiku_rag-0.10.1 → haiku_rag-0.10.2}/docs/index.md

@@ -43,7 +43,8 @@ async with HaikuRAG("database.lancedb") as client:
 Or use the CLI:
 ```bash
 haiku-rag add "Your document content"
-haiku-rag add-src /path/to/document.pdf --title "Q3 Financial Report"
+haiku-rag add "Your document content" --meta author=alice
+haiku-rag add-src /path/to/document.pdf --title "Q3 Financial Report" --meta source=manual
 haiku-rag search "query"
 haiku-rag ask "Who is the author of haiku.rag?"
 haiku-rag migrate old_database.sqlite  # Migrate from SQLite

{haiku_rag-0.10.1 → haiku_rag-0.10.2}/docs/installation.md

@@ -72,3 +72,13 @@ VLLM_RERANK_BASE_URL="http://localhost:8001"
 - Python 3.10+
 - Ollama (for default embeddings)
 - vLLM server (for vLLM provider)
+
+## Pre-download Models (Optional)
+
+You can prefetch all required runtime models before first use:
+
+```bash
+haiku-rag download-models
+```
+
+This will download Docling models and pull any Ollama models referenced by your current configuration.

{haiku_rag-0.10.1 → haiku_rag-0.10.2}/pyproject.toml

@@ -2,7 +2,7 @@
 
 name = "haiku.rag"
 description = "Agentic Retrieval Augmented Generation (RAG) with LanceDB"
-version = "0.10.1"
+version = "0.10.2"
 authors = [{ name = "Yiorgis Gozadinos", email = "ggozadinos@gmail.com" }]
 license = { text = "MIT" }
 readme = { file = "README.md", content-type = "text/markdown" }

{haiku_rag-0.10.1 → haiku_rag-0.10.2}/src/haiku/rag/app.py

@@ -1,4 +1,6 @@
 import asyncio
+import json
+from importlib.metadata import version as pkg_version
 from pathlib import Path
 
 from rich.console import Console
@@ -25,26 +27,141 @@ class HaikuRAGApp:
         self.db_path = db_path
         self.console = Console()
 
+    async def info(self):
+        """Display read-only information about the database without modifying it."""
+
+        import lancedb
+
+        # Basic: show path
+        self.console.print("[bold]haiku.rag database info[/bold]")
+        self.console.print(
+            f"  [repr.attrib_name]path[/repr.attrib_name]: {self.db_path}"
+        )
+
+        if not self.db_path.exists():
+            self.console.print("[red]Database path does not exist.[/red]")
+            return
+
+        # Connect without going through Store to avoid upgrades/validation writes
+        try:
+            db = lancedb.connect(self.db_path)
+            table_names = set(db.table_names())
+        except Exception as e:
+            self.console.print(f"[red]Failed to open database: {e}[/red]")
+            return
+
+        try:
+            ldb_version = pkg_version("lancedb")
+        except Exception:
+            ldb_version = "unknown"
+        try:
+            hr_version = pkg_version("haiku.rag")
+        except Exception:
+            hr_version = "unknown"
+        try:
+            docling_version = pkg_version("docling")
+        except Exception:
+            docling_version = "unknown"
+
+        # Read settings (if present) to find stored haiku.rag version and embedding config
+        stored_version = "unknown"
+        embed_provider: str | None = None
+        embed_model: str | None = None
+        vector_dim: int | None = None
+
+        if "settings" in table_names:
+            settings_tbl = db.open_table("settings")
+            arrow = settings_tbl.search().where("id = 'settings'").limit(1).to_arrow()
+            rows = arrow.to_pylist() if arrow is not None else []
+            if rows:
+                raw = rows[0].get("settings") or "{}"
+                data = json.loads(raw) if isinstance(raw, str) else (raw or {})
+                stored_version = str(data.get("version", stored_version))
+                embed_provider = data.get("EMBEDDINGS_PROVIDER")
+                embed_model = data.get("EMBEDDINGS_MODEL")
+                vector_dim = (
+                    int(data.get("EMBEDDINGS_VECTOR_DIM"))  # pyright: ignore[reportArgumentType]
+                    if data.get("EMBEDDINGS_VECTOR_DIM") is not None
+                    else None
+                )
+
+        num_docs = 0
+        if "documents" in table_names:
+            docs_tbl = db.open_table("documents")
+            num_docs = int(docs_tbl.count_rows())  # type: ignore[attr-defined]
+
+        # Table versions per table (direct API)
+        doc_versions = (
+            len(list(db.open_table("documents").list_versions()))
+            if "documents" in table_names
+            else 0
+        )
+        chunk_versions = (
+            len(list(db.open_table("chunks").list_versions()))
+            if "chunks" in table_names
+            else 0
+        )
+
+        self.console.print(
+            f"  [repr.attrib_name]haiku.rag version (db)[/repr.attrib_name]: {stored_version}"
+        )
+        if embed_provider or embed_model or vector_dim:
+            provider_part = embed_provider or "unknown"
+            model_part = embed_model or "unknown"
+            dim_part = f"{vector_dim}" if vector_dim is not None else "unknown"
+            self.console.print(
+                "  [repr.attrib_name]embeddings[/repr.attrib_name]: "
+                f"{provider_part}/{model_part} (dim: {dim_part})"
+            )
+        else:
+            self.console.print(
+                "  [repr.attrib_name]embeddings[/repr.attrib_name]: unknown"
+            )
+        self.console.print(
+            f"  [repr.attrib_name]documents[/repr.attrib_name]: {num_docs}"
+        )
+        self.console.print(
+            f"  [repr.attrib_name]versions (documents)[/repr.attrib_name]: {doc_versions}"
+        )
+        self.console.print(
+            f"  [repr.attrib_name]versions (chunks)[/repr.attrib_name]: {chunk_versions}"
+        )
+        self.console.rule()
+        self.console.print("[bold]Versions[/bold]")
+        self.console.print(
+            f"  [repr.attrib_name]haiku.rag[/repr.attrib_name]: {hr_version}"
+        )
+        self.console.print(
+            f"  [repr.attrib_name]lancedb[/repr.attrib_name]: {ldb_version}"
+        )
+        self.console.print(
+            f"  [repr.attrib_name]docling[/repr.attrib_name]: {docling_version}"
+        )
+
     async def list_documents(self):
         async with HaikuRAG(db_path=self.db_path) as self.client:
             documents = await self.client.list_documents()
             for doc in documents:
                 self._rich_print_document(doc, truncate=True)
 
-    async def add_document_from_text(self, text: str):
+    async def add_document_from_text(self, text: str, metadata: dict | None = None):
         async with HaikuRAG(db_path=self.db_path) as self.client:
-            doc = await self.client.create_document(text)
+            doc = await self.client.create_document(text, metadata=metadata)
             self._rich_print_document(doc, truncate=True)
             self.console.print(
-                f"[b]Document with id [cyan]{doc.id}[/cyan] added successfully.[/b]"
+                f"[bold green]Document {doc.id} added successfully.[/bold green]"
             )
 
-    async def add_document_from_source(self, source: str, title: str | None = None):
+    async def add_document_from_source(
+        self, source: str, title: str | None = None, metadata: dict | None = None
+    ):
         async with HaikuRAG(db_path=self.db_path) as self.client:
-            doc = await self.client.create_document_from_source(source, title=title)
+            doc = await self.client.create_document_from_source(
+                source, title=title, metadata=metadata
+            )
             self._rich_print_document(doc, truncate=True)
             self.console.print(
-                f"[b]Document with id [cyan]{doc.id}[/cyan] added successfully.[/b]"
+                f"[bold green]Document {doc.id} added successfully.[/bold green]"
             )
 
     async def get_document(self, doc_id: str):
@@ -59,7 +176,9 @@ class HaikuRAGApp:
         async with HaikuRAG(db_path=self.db_path) as self.client:
             deleted = await self.client.delete_document(doc_id)
             if deleted:
-                self.console.print(f"[b]Document {doc_id} deleted successfully.[/b]")
+                self.console.print(
+                    f"[bold green]Document {doc_id} deleted successfully.[/bold green]"
+                )
             else:
                 self.console.print(
                     f"[yellow]Document with id {doc_id} not found.[/yellow]"
@@ -69,7 +188,7 @@ class HaikuRAGApp:
         async with HaikuRAG(db_path=self.db_path) as self.client:
             results = await self.client.search(query, limit=limit)
             if not results:
-                self.console.print("[red]No results found.[/red]")
+                self.console.print("[yellow]No results found.[/yellow]")
                 return
             for chunk, score in results:
                 self._rich_print_search_result(chunk, score)
@@ -202,14 +321,16 @@ class HaikuRAGApp:
                     return
 
                 self.console.print(
-                    f"[b]Rebuilding database with {total_docs} documents...[/b]"
+                    f"[bold cyan]Rebuilding database with {total_docs} documents...[/bold cyan]"
                 )
                 with Progress() as progress:
                     task = progress.add_task("Rebuilding...", total=total_docs)
                     async for _ in client.rebuild_database():
                         progress.update(task, advance=1)
 
-                self.console.print("[b]Database rebuild completed successfully.[/b]")
+                self.console.print(
+                    "[bold green]Database rebuild completed successfully.[/bold green]"
+                )
             except Exception as e:
                 self.console.print(f"[red]Error rebuilding database: {e}[/red]")
 
@@ -218,7 +339,9 @@ class HaikuRAGApp:
         try:
             async with HaikuRAG(db_path=self.db_path, skip_validation=True) as client:
                 await client.vacuum()
-            self.console.print("[b]Vacuum completed successfully.[/b]")
+            self.console.print(
+                "[bold green]Vacuum completed successfully.[/bold green]"
+            )
         except Exception as e:
             self.console.print(f"[red]Error during vacuum: {e}[/red]")
 
@@ -240,7 +363,9 @@ class HaikuRAGApp:
             else:
                 display_value = field_value
 
-            self.console.print(f"  [cyan]{field_name}[/cyan]: {display_value}")
+            self.console.print(
+                f"  [repr.attrib_name]{field_name}[/repr.attrib_name]: {display_value}"
+            )
 
     def _rich_print_document(self, doc: Document, truncate: bool = False):
         """Format a document for display."""

{haiku_rag-0.10.1 → haiku_rag-0.10.2}/src/haiku/rag/cli.py

@@ -1,7 +1,9 @@
 import asyncio
+import json
 import warnings
 from importlib.metadata import version
 from pathlib import Path
+from typing import Any
 
 import typer
 
@@ -137,11 +139,41 @@ def list_documents(
     asyncio.run(app.list_documents())
 
 
+def _parse_meta_options(meta: list[str] | None) -> dict[str, Any]:
+    """Parse repeated --meta KEY=VALUE options into a dictionary.
+
+    Raises a Typer error if any entry is malformed.
+    """
+    result: dict[str, Any] = {}
+    if not meta:
+        return result
+    for item in meta:
+        if "=" not in item:
+            raise typer.BadParameter("--meta must be in KEY=VALUE format")
+        key, value = item.split("=", 1)
+        if not key:
+            raise typer.BadParameter("--meta key cannot be empty")
+        # Best-effort JSON coercion: numbers, booleans, null, arrays/objects
+        try:
+            parsed = json.loads(value)
+            result[key] = parsed
+        except Exception:
+            # Leave as string if not valid JSON literal
+            result[key] = value
+    return result
+
+
 @cli.command("add", help="Add a document from text input")
 def add_document_text(
     text: str = typer.Argument(
         help="The text content of the document to add",
     ),
+    meta: list[str] | None = typer.Option(
+        None,
+        "--meta",
+        help="Metadata entries as KEY=VALUE (repeatable)",
+        metavar="KEY=VALUE",
+    ),
     db: Path = typer.Option(
         Config.DEFAULT_DATA_DIR / "haiku.rag.lancedb",
         "--db",
@@ -151,7 +183,8 @@ def add_document_text(
     from haiku.rag.app import HaikuRAGApp
 
     app = HaikuRAGApp(db_path=db)
-    asyncio.run(app.add_document_from_text(text=text))
+    metadata = _parse_meta_options(meta)
+    asyncio.run(app.add_document_from_text(text=text, metadata=metadata or None))
 
 
 @cli.command("add-src", help="Add a document from a file path or URL")
@@ -165,6 +198,12 @@ def add_document_src(
         "--title",
         help="Optional human-readable title to store with the document",
     ),
+    meta: list[str] | None = typer.Option(
+        None,
+        "--meta",
+        help="Metadata entries as KEY=VALUE (repeatable)",
+        metavar="KEY=VALUE",
+    ),
     db: Path = typer.Option(
         Config.DEFAULT_DATA_DIR / "haiku.rag.lancedb",
         "--db",
@@ -174,7 +213,12 @@ def add_document_src(
     from haiku.rag.app import HaikuRAGApp
 
     app = HaikuRAGApp(db_path=db)
-    asyncio.run(app.add_document_from_source(source=source, title=title))
+    metadata = _parse_meta_options(meta)
+    asyncio.run(
+        app.add_document_from_source(
+            source=source, title=title, metadata=metadata or None
+        )
+    )
 
 
 @cli.command("get", help="Get and display a document by its ID")
@@ -347,6 +391,32 @@ def vacuum(
     asyncio.run(app.vacuum())
 
 
+@cli.command("info", help="Show read-only database info (no upgrades or writes)")
+def info(
+    db: Path = typer.Option(
+        Config.DEFAULT_DATA_DIR / "haiku.rag.lancedb",
+        "--db",
+        help="Path to the LanceDB database file",
+    ),
+):
+    from haiku.rag.app import HaikuRAGApp
+
+    app = HaikuRAGApp(db_path=db)
+    asyncio.run(app.info())
+
+
+@cli.command("download-models", help="Download Docling and Ollama models per config")
+def download_models_cmd():
+    from haiku.rag.utils import prefetch_models
+
+    try:
+        prefetch_models()
+        typer.echo("Models downloaded successfully.")
+    except Exception as e:
+        typer.echo(f"Error downloading models: {e}")
+        raise typer.Exit(1)
+
+
 @cli.command(
     "serve", help="Start the haiku.rag MCP server (by default in streamable HTTP mode)"
 )

{haiku_rag-0.10.1 → haiku_rag-0.10.2}/src/haiku/rag/migration.py

@@ -51,7 +51,7 @@ class SQLiteToLanceDBMigrator:
 
                 sqlite_conn.enable_load_extension(True)
                 sqlite_vec.load(sqlite_conn)
-                self.console.print("[blue]Loaded sqlite-vec extension[/blue]")
+                self.console.print("[cyan]Loaded sqlite-vec extension[/cyan]")
             except Exception as e:
                 self.console.print(
                     f"[yellow]Warning: Could not load sqlite-vec extension: {e}[/yellow]"
@@ -92,7 +92,7 @@ class SQLiteToLanceDBMigrator:
             sqlite_conn.close()
 
             # Optimize and cleanup using centralized vacuum
-            self.console.print("[blue]Optimizing LanceDB...[/blue]")
+            self.console.print("[cyan]Optimizing LanceDB...[/cyan]")
             try:
                 lance_store.vacuum()
                 self.console.print("[green]✅ Optimization completed[/green]")

{haiku_rag-0.10.1 → haiku_rag-0.10.2}/src/haiku/rag/store/__init__.py

@@ -1,4 +1,4 @@
 from .engine import Store
 from .models import Chunk, Document
 
-__all__ = ["Store", "Chunk", "Document"]
+__all__ = ["Store", "Chunk", "Document"]

{haiku_rag-0.10.1 → haiku_rag-0.10.2}/src/haiku/rag/store/models/__init__.py

@@ -1,4 +1,4 @@
 from .chunk import Chunk
 from .document import Document
 
-__all__ = ["Chunk", "Document"]
+__all__ = ["Chunk", "Document"]

{haiku_rag-0.10.1 → haiku_rag-0.10.2}/src/haiku/rag/utils.py

@@ -163,3 +163,37 @@ def load_callable(path: str):
             f"Attribute '{func_name}' in module '{module_part}' is not callable"
         )
     return func
+
+
+def prefetch_models():
+    """Prefetch runtime models (Docling + Ollama as configured)."""
+    import httpx
+    from docling.utils.model_downloader import download_models
+
+    from haiku.rag.config import Config
+
+    download_models()
+
+    # Collect Ollama models from config
+    required_models: set[str] = set()
+    if Config.EMBEDDINGS_PROVIDER == "ollama":
+        required_models.add(Config.EMBEDDINGS_MODEL)
+    if Config.QA_PROVIDER == "ollama":
+        required_models.add(Config.QA_MODEL)
+    if Config.RESEARCH_PROVIDER == "ollama":
+        required_models.add(Config.RESEARCH_MODEL)
+    if Config.RERANK_PROVIDER == "ollama":
+        required_models.add(Config.RERANK_MODEL)
+
+    if not required_models:
+        return
+
+    base_url = Config.OLLAMA_BASE_URL
+
+    with httpx.Client(timeout=None) as client:
+        for model in sorted(required_models):
+            with client.stream(
+                "POST", f"{base_url}/api/pull", json={"model": model}
+            ) as r:
+                for _ in r.iter_lines():
+                    pass

{haiku_rag-0.10.1 → haiku_rag-0.10.2}/tests/test_app.py

@@ -54,10 +54,13 @@ async def test_add_document_from_text(app: HaikuRAGApp, monkeypatch):
     with patch("haiku.rag.app.HaikuRAG", return_value=mock_client):
         await app.add_document_from_text("test document")
 
-    mock_client.create_document.assert_called_once_with("test document")
+    mock_client.create_document.assert_called_once()
+    args, kwargs = mock_client.create_document.call_args
+    assert args[0] == "test document"
+    assert kwargs.get("metadata") is None
     mock_rich_print.assert_called_once_with(mock_doc, truncate=True)
     mock_print.assert_called_once_with(
-        "[b]Document with id [cyan]1[/cyan] added successfully.[/b]"
+        "[bold green]Document 1 added successfully.[/bold green]"
     )
 
 
@@ -78,12 +81,14 @@ async def test_add_document_from_source(app: HaikuRAGApp, monkeypatch):
     with patch("haiku.rag.app.HaikuRAG", return_value=mock_client):
         await app.add_document_from_source(file_path)
 
-    mock_client.create_document_from_source.assert_called_once_with(
-        file_path, title=None
-    )
+    mock_client.create_document_from_source.assert_called_once()
+    args, kwargs = mock_client.create_document_from_source.call_args
+    assert args[0] == file_path
+    assert kwargs.get("title") is None
+    assert kwargs.get("metadata") is None
     mock_rich_print.assert_called_once_with(mock_doc, truncate=True)
     mock_print.assert_called_once_with(
-        "[b]Document with id [cyan]1[/cyan] added successfully.[/b]"
+        "[bold green]Document 1 added successfully.[/bold green]"
     )
 
 
@@ -135,7 +140,9 @@ async def test_delete_document(app: HaikuRAGApp, monkeypatch):
         await app.delete_document("1")
 
     mock_client.delete_document.assert_called_once_with("1")
-    mock_print.assert_called_once_with("[b]Document 1 deleted successfully.[/b]")
+    mock_print.assert_called_once_with(
+        "[bold green]Document 1 deleted successfully.[/bold green]"
+    )
 
 
 @pytest.mark.asyncio
@@ -170,7 +177,7 @@ async def test_search_no_results(app: HaikuRAGApp, monkeypatch):
         await app.search("query")
 
     mock_client.search.assert_called_once_with("query", limit=5)
-    mock_print.assert_called_once_with("[red]No results found.[/red]")
+    mock_print.assert_called_once_with("[yellow]No results found.[/yellow]")
 
 
 @pytest.mark.asyncio

{haiku_rag-0.10.1 → haiku_rag-0.10.2}/tests/test_cli.py

@@ -28,9 +28,10 @@ def test_add_document_text():
         result = runner.invoke(cli, ["add", "test document"])
 
         assert result.exit_code == 0
-        mock_app_instance.add_document_from_text.assert_called_once_with(
-            text="test document"
-        )
+        mock_app_instance.add_document_from_text.assert_called_once()
+        _, kwargs = mock_app_instance.add_document_from_text.call_args
+        assert kwargs.get("text") == "test document"
+        assert kwargs.get("metadata") is None
 
 
 def test_add_document_src():
@@ -57,8 +58,83 @@ def test_add_document_src_with_title():
         mock_app_instance.add_document_from_source.assert_called_once()
         # Verify title is forwarded (inspect call kwargs)
         _, kwargs = mock_app_instance.add_document_from_source.call_args
-        assert kwargs.get("title") == "Nice Name"
+    assert kwargs.get("title") == "Nice Name"
+    assert kwargs.get("source") == "test.txt"
+
+
+def test_add_document_text_with_meta():
+    with patch("haiku.rag.app.HaikuRAGApp") as mock_app:
+        mock_app_instance = MagicMock()
+        mock_app_instance.add_document_from_text = AsyncMock()
+        mock_app.return_value = mock_app_instance
+
+        result = runner.invoke(
+            cli,
+            [
+                "add",
+                "some text",
+                "--meta",
+                "author=alice",
+                "--meta",
+                "topic=notes",
+            ],
+        )
+
+        assert result.exit_code == 0
+        mock_app_instance.add_document_from_text.assert_called_once()
+        _, kwargs = mock_app_instance.add_document_from_text.call_args
+        assert kwargs.get("text") == "some text"
+        assert kwargs.get("metadata") == {"author": "alice", "topic": "notes"}
+
+
+def test_add_document_src_with_meta():
+    with patch("haiku.rag.app.HaikuRAGApp") as mock_app:
+        mock_app_instance = MagicMock()
+        mock_app_instance.add_document_from_source = AsyncMock()
+        mock_app.return_value = mock_app_instance
+
+        result = runner.invoke(
+            cli,
+            [
+                "add-src",
+                "test.txt",
+                "--meta",
+                "source=manual",
+                "--meta",
+                "lang=en",
+            ],
+        )
+
+        assert result.exit_code == 0
+        mock_app_instance.add_document_from_source.assert_called_once()
+        _, kwargs = mock_app_instance.add_document_from_source.call_args
         assert kwargs.get("source") == "test.txt"
+        assert kwargs.get("metadata") == {"source": "manual", "lang": "en"}
+
+
+def test_add_document_text_with_numeric_meta():
+    with patch("haiku.rag.app.HaikuRAGApp") as mock_app:
+        mock_app_instance = MagicMock()
+        mock_app_instance.add_document_from_text = AsyncMock()
+        mock_app.return_value = mock_app_instance
+
+        result = runner.invoke(
+            cli,
+            [
+                "add",
+                "some text",
+                "--meta",
+                "version=3",
+                "--meta",
+                "published=true",
+            ],
+        )
+
+        assert result.exit_code == 0
+        mock_app_instance.add_document_from_text.assert_called_once()
+        _, kwargs = mock_app_instance.add_document_from_text.call_args
+        assert kwargs.get("text") == "some text"
+        assert kwargs.get("metadata") == {"version": 3, "published": True}
 
 
 def test_get_document():
@@ -144,6 +220,16 @@ def test_ask_with_cite():
         result = runner.invoke(cli, ["ask", "What is Python?", "--cite"])
 
         assert result.exit_code == 0
-        mock_app_instance.ask.assert_called_once_with(
-            question="What is Python?", cite=True
-        )
+    mock_app_instance.ask.assert_called_once_with(question="What is Python?", cite=True)
+
+
+def test_info():
+    with patch("haiku.rag.app.HaikuRAGApp") as mock_app:
+        mock_app_instance = MagicMock()
+        mock_app_instance.info = AsyncMock()
+        mock_app.return_value = mock_app_instance
+
+        result = runner.invoke(cli, ["info"])
+
+        assert result.exit_code == 0
+        mock_app_instance.info.assert_called_once()

haiku_rag-0.10.2/tests/test_info.py

@@ -0,0 +1,79 @@
+import json
+
+import pytest
+
+from haiku.rag.app import HaikuRAGApp
+
+
+@pytest.mark.asyncio
+async def test_app_info_outputs_and_read_only(temp_db_path, capsys):
+    # Build a minimal LanceDB with settings, documents, and chunks without using Store
+    import lancedb
+    from lancedb.pydantic import LanceModel, Vector
+    from pydantic import Field
+
+    db = lancedb.connect(temp_db_path)
+
+    class SettingsRecord(LanceModel):
+        id: str = Field(default="settings")
+        settings: str = Field(default="{}")
+
+    class DocumentRecord(LanceModel):
+        id: str
+        content: str
+
+    class ChunkRecord(LanceModel):
+        id: str
+        document_id: str
+        content: str
+        vector: Vector(3)  # type: ignore
+
+    settings_tbl = db.create_table("settings", schema=SettingsRecord)
+    docs_tbl = db.create_table("documents", schema=DocumentRecord)
+    chunks_tbl = db.create_table("chunks", schema=ChunkRecord)
+
+    # Insert one of each
+    settings_tbl.add(
+        [
+            SettingsRecord(
+                id="settings",
+                settings=json.dumps(
+                    {
+                        "version": "1.2.3",
+                        "EMBEDDINGS_PROVIDER": "openai",
+                        "EMBEDDINGS_MODEL": "text-embedding-3-small",
+                        "EMBEDDINGS_VECTOR_DIM": 3,
+                    }
+                ),
+            )
+        ]
+    )
+    docs_tbl.add([DocumentRecord(id="doc-1", content="hello")])
+    chunks_tbl.add(
+        [ChunkRecord(id="c1", document_id="doc-1", content="c", vector=[0.1, 0.2, 0.3])]
+    )
+
+    # Capture versions before
+    before_versions = {
+        "settings": int(settings_tbl.version),
+        "documents": int(docs_tbl.version),
+        "chunks": int(chunks_tbl.version),
+    }
+
+    app = HaikuRAGApp(db_path=temp_db_path)
+    await app.info()
+
+    out = capsys.readouterr().out
+    # Validate expected content substrings
+    assert f"path: \n{temp_db_path}" in out
+    assert "haiku.rag version (db): 1.2.3" in out
+    assert "embeddings: openai/text-embedding-3-small (dim: 3)" in out
+    assert "lancedb:" in out
+    assert "documents: 1" in out
+
+    # Verify no versions changed (read-only)
+    # Re-open to ensure fresh view
+    db2 = lancedb.connect(temp_db_path)
+    assert int(db2.open_table("settings").version) == before_versions["settings"]
+    assert int(db2.open_table("documents").version) == before_versions["documents"]
+    assert int(db2.open_table("chunks").version) == before_versions["chunks"]

{haiku_rag-0.10.1 → haiku_rag-0.10.2}/uv.lock

@@ -1111,7 +1111,7 @@ wheels = [
 
 [[package]]
 name = "haiku-rag"
-version = "0.10.1"
+version = "0.10.2"
 source = { editable = "." }
 dependencies = [
     { name = "docling" },