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

haiku/rag/inspector/widgets/info_modal.py

@@ -0,0 +1,209 @@
+import json
+from importlib.metadata import version as pkg_version
+from pathlib import Path
+from typing import TYPE_CHECKING
+
+from textual.app import ComposeResult
+from textual.binding import Binding
+from textual.containers import Vertical, VerticalScroll
+from textual.screen import ModalScreen
+from textual.widgets import Static
+
+from haiku.rag.utils import format_bytes
+
+if TYPE_CHECKING:
+    from haiku.rag.client import HaikuRAG
+
+
+class InfoModal(ModalScreen):  # pragma: no cover
+    """Modal screen for displaying database information."""
+
+    BINDINGS = [
+        Binding("escape", "dismiss", "Close", show=True),
+        Binding("i", "dismiss", "Close", show=True),
+    ]
+
+    CSS = """
+    InfoModal {
+        align: center middle;
+    }
+
+    #info-container {
+        width: 80;
+        height: auto;
+        max-height: 80%;
+        background: $surface;
+        border: solid $primary;
+        padding: 1 2;
+    }
+
+    #info-header {
+        height: auto;
+        margin-bottom: 1;
+    }
+
+    #info-content {
+        height: auto;
+        max-height: 100%;
+    }
+    """
+
+    def __init__(self, client: "HaikuRAG", db_path: Path):
+        super().__init__()
+        self.client = client
+        self.db_path = db_path
+        self._content_widget = Static("Loading...")
+
+    def compose(self) -> ComposeResult:
+        with Vertical(id="info-container"):
+            yield Static("[bold]Database Info[/bold]", id="info-header")
+            with VerticalScroll(id="info-content"):
+                yield self._content_widget
+
+    async def on_mount(self) -> None:
+        """Load and display database info."""
+        import lancedb
+
+        lines: list[str] = []
+
+        # Path
+        lines.append(f"[bold $accent]path[/bold $accent]: {self.db_path}")
+
+        if not self.db_path.exists():
+            lines.append("[red]Database path does not exist.[/red]")
+            self._content_widget.update("\n".join(lines))
+            return
+
+        # Connect to get table info
+        try:
+            db = lancedb.connect(self.db_path)
+            table_names = set(db.table_names())
+        except Exception as e:
+            lines.append(f"[red]Failed to open database: {e}[/red]")
+            self._content_widget.update("\n".join(lines))
+            return
+
+        # Get versions
+        try:
+            ldb_version = pkg_version("lancedb")
+        except Exception:
+            ldb_version = "unknown"
+        try:
+            hr_version = pkg_version("haiku.rag-slim")
+        except Exception:
+            hr_version = "unknown"
+        try:
+            docling_version = pkg_version("docling")
+        except Exception:
+            docling_version = "unknown"
+
+        # Get stats from store
+        table_stats = self.client.store.get_stats()
+
+        # Read settings
+        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))
+                embeddings = data.get("embeddings", {})
+                embed_model_obj = embeddings.get("model", {})
+                embed_provider = embed_model_obj.get("provider")
+                embed_model = embed_model_obj.get("name")
+                vector_dim = embed_model_obj.get("vector_dim")
+
+        num_docs = table_stats["documents"].get("num_rows", 0)
+        doc_bytes = table_stats["documents"].get("total_bytes", 0)
+
+        num_chunks = table_stats["chunks"].get("num_rows", 0)
+        chunk_bytes = table_stats["chunks"].get("total_bytes", 0)
+
+        has_vector_index = table_stats["chunks"].get("has_vector_index", False)
+        num_indexed_rows = table_stats["chunks"].get("num_indexed_rows", 0)
+        num_unindexed_rows = table_stats["chunks"].get("num_unindexed_rows", 0)
+
+        # Table versions
+        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
+        )
+
+        # Build output
+        lines.append(
+            f"[bold $accent]haiku.rag version (db)[/bold $accent]: {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"
+            lines.append(
+                f"[bold $accent]embeddings[/bold $accent]: "
+                f"{provider_part}/{model_part} (dim: {dim_part})"
+            )
+        else:
+            lines.append("[bold $accent]embeddings[/bold $accent]: unknown")
+
+        lines.append(
+            f"[bold $accent]documents[/bold $accent]: {num_docs} ({format_bytes(doc_bytes)})"
+        )
+        lines.append(
+            f"[bold $accent]chunks[/bold $accent]: {num_chunks} ({format_bytes(chunk_bytes)})"
+        )
+
+        # Vector index info
+        if has_vector_index:
+            lines.append("[bold $accent]vector index[/bold $accent]: ✓ exists")
+            lines.append(
+                f"[bold $accent]indexed chunks[/bold $accent]: {num_indexed_rows}"
+            )
+            if num_unindexed_rows > 0:
+                lines.append(
+                    f"[bold $accent]unindexed chunks[/bold $accent]: [yellow]{num_unindexed_rows}[/yellow]"
+                )
+            else:
+                lines.append(
+                    f"[bold $accent]unindexed chunks[/bold $accent]: {num_unindexed_rows}"
+                )
+        else:
+            if num_chunks >= 256:
+                lines.append(
+                    "[bold $accent]vector index[/bold $accent]: [yellow]✗ not created[/yellow]"
+                )
+            else:
+                lines.append(
+                    f"[bold $accent]vector index[/bold $accent]: ✗ not created "
+                    f"(need {256 - num_chunks} more chunks)"
+                )
+
+        lines.append(
+            f"[bold $accent]versions (documents)[/bold $accent]: {doc_versions}"
+        )
+        lines.append(
+            f"[bold $accent]versions (chunks)[/bold $accent]: {chunk_versions}"
+        )
+
+        lines.append("")
+        lines.append("[bold]Versions[/bold]")
+        lines.append(f"[bold $accent]haiku.rag[/bold $accent]: {hr_version}")
+        lines.append(f"[bold $accent]lancedb[/bold $accent]: {ldb_version}")
+        lines.append(f"[bold $accent]docling[/bold $accent]: {docling_version}")
+
+        self._content_widget.update("\n".join(lines))
+
+    async def action_dismiss(self, result=None) -> None:
+        self.app.pop_screen()

haiku/rag/inspector/widgets/search_modal.py

@@ -0,0 +1,183 @@
+from textual import on
+from textual.app import ComposeResult
+from textual.binding import Binding
+from textual.containers import Horizontal, Vertical, VerticalScroll
+from textual.message import Message
+from textual.screen import Screen
+from textual.widgets import Input, ListItem, ListView, Static
+
+from haiku.rag.client import HaikuRAG
+from haiku.rag.inspector.widgets.detail_view import DetailView
+from haiku.rag.store.models import Chunk, SearchResult
+
+
+class SearchModal(Screen):  # pragma: no cover
+    """Screen for searching chunks."""
+
+    BINDINGS = [
+        Binding("escape", "dismiss", "Close", show=True),
+        Binding("v", "show_visual", "Visual", show=True),
+    ]
+
+    CSS = """
+    SearchModal {
+        background: $surface;
+        layout: vertical;
+    }
+
+    #search-header {
+        dock: top;
+        height: auto;
+    }
+
+    #search-content {
+        height: 1fr;
+        width: 100%;
+    }
+
+    #search-results-container {
+        width: 1fr;
+        border: solid $primary;
+    }
+
+    #search-detail {
+        width: 2fr;
+        border: solid $accent;
+    }
+
+    ListItem {
+        overflow: hidden;
+    }
+
+    ListItem Static {
+        overflow: hidden;
+        text-overflow: ellipsis;
+    }
+    """
+
+    class ChunkSelected(Message):
+        """Message sent when a chunk is selected from search results."""
+
+        def __init__(self, chunk: Chunk) -> None:
+            super().__init__()
+            self.chunk = chunk
+
+    def __init__(self, client: HaikuRAG):
+        super().__init__()
+        self.client = client
+        self.chunks: list[Chunk] = []
+        self.search_results: list[SearchResult] = []
+
+    def compose(self) -> ComposeResult:
+        """Compose the search screen."""
+        with Vertical(id="search-header"):
+            yield Static("[bold]Search Chunks[/bold]")
+            yield Input(placeholder="Enter search query...", id="search-input")
+            yield Static("", id="status-label")
+        with Horizontal(id="search-content"):
+            with VerticalScroll(id="search-results-container"):
+                yield ListView(id="search-results")
+            yield DetailView(id="search-detail")
+
+    async def on_mount(self) -> None:
+        """Focus the search input when mounted."""
+        status_label = self.query_one("#status-label", Static)
+        status_label.update("Type query and press Enter to search")
+        search_input = self.query_one("#search-input", Input)
+        search_input.focus()
+
+    @on(Input.Submitted, "#search-input")
+    async def search_submitted(self, event: Input.Submitted) -> None:
+        """Handle search query submission."""
+        query = event.value.strip()
+        if query:
+            await self.run_search(query)
+
+    async def run_search(self, query: str) -> None:
+        """Perform the search."""
+        status_label = self.query_one("#status-label", Static)
+        list_view = self.query_one("#search-results", ListView)
+
+        status_label.update("Searching...")
+
+        try:
+            # Perform search using client API
+            self.search_results = await self.client.search(query=query, limit=50)
+
+            # Get chunks for the results
+            self.chunks = []
+            for result in self.search_results:
+                if result.chunk_id:
+                    chunk = await self.client.chunk_repository.get_by_id(
+                        result.chunk_id
+                    )
+                    if chunk:
+                        self.chunks.append(chunk)
+
+            # Clear and populate results
+            await list_view.clear()
+            for result in self.search_results:
+                first_line = result.content.split("\n")[0][:60]
+                score_str = f"{result.score:.2f}"
+                # Add page info if available
+                page_info = ""
+                if result.page_numbers:
+                    pages = ", ".join(str(p) for p in result.page_numbers[:3])
+                    page_info = f" (p.{pages})"
+                item = ListItem(Static(f"[{score_str}]{page_info} {first_line}"))
+                await list_view.append(item)
+
+            # Update status
+            status_label.update(f"Found {len(self.chunks)} results")
+
+            # Select first result, show in detail view, and focus list
+            if self.chunks and self.search_results:
+                list_view.index = 0
+                detail_view = self.query_one("#search-detail", DetailView)
+                await detail_view.show_search_result(
+                    self.chunks[0], self.search_results[0]
+                )
+                list_view.focus()
+        except Exception as e:
+            status_label.update(f"Error: {str(e)}")
+
+    async def on_list_view_highlighted(self, event: ListView.Highlighted) -> None:
+        """Handle chunk navigation (arrow keys)."""
+        list_view = self.query_one("#search-results", ListView)
+        if event.list_view != list_view or event.item is None:
+            return
+        idx = event.list_view.index
+        detail_view = self.query_one("#search-detail", DetailView)
+        await detail_view.show_search_result(self.chunks[idx], self.search_results[idx])  # type: ignore[index]
+
+    async def on_list_view_selected(self, event: ListView.Selected) -> None:
+        """Handle chunk selection (Enter key)."""
+        list_view = self.query_one("#search-results", ListView)
+        if event.list_view != list_view:
+            return
+        idx = event.list_view.index
+        self.post_message(self.ChunkSelected(self.chunks[idx]))  # type: ignore[index]
+        self.app.pop_screen()
+
+    async def action_dismiss(self, result=None) -> None:
+        self.app.pop_screen()
+
+    async def action_show_visual(self) -> None:
+        """Show visual grounding for the current chunk."""
+        list_view = self.query_one("#search-results", ListView)
+        idx = list_view.index
+        if idx is None or not self.chunks:
+            return
+
+        chunk = self.chunks[idx]
+
+        from haiku.rag.inspector.widgets.visual_modal import VisualGroundingModal
+
+        # Use app's _switch_modal to close this modal before opening visual
+        await self.app._switch_modal(  # type: ignore[attr-defined]
+            VisualGroundingModal(
+                chunk=chunk,
+                client=self.client,
+                document_uri=chunk.document_uri,
+            )
+        )

haiku/rag/inspector/widgets/visual_modal.py

@@ -0,0 +1,126 @@
+from typing import TYPE_CHECKING
+
+from textual.app import ComposeResult
+from textual.binding import Binding
+from textual.containers import Horizontal, Vertical
+from textual.screen import Screen
+from textual.widget import Widget
+from textual.widgets import Static
+from textual_image.widget import Image as TextualImage
+
+if TYPE_CHECKING:
+    from PIL.Image import Image as PILImage
+
+    from haiku.rag.client import HaikuRAG
+    from haiku.rag.store.models import Chunk
+
+
+class VisualGroundingModal(Screen):  # pragma: no cover
+    """Modal screen for displaying visual grounding with bounding boxes."""
+
+    BINDINGS = [
+        Binding("escape", "dismiss", "Close", show=True),
+        Binding("v", "dismiss", "Close", show=True),
+        Binding("left", "prev_page", "Previous Page"),
+        Binding("right", "next_page", "Next Page"),
+    ]
+
+    CSS = """
+    VisualGroundingModal {
+        background: $surface;
+        layout: vertical;
+    }
+
+    #visual-header {
+        dock: top;
+        height: auto;
+        padding: 1;
+    }
+
+    #visual-content {
+        height: 1fr;
+        width: 100%;
+        align: center middle;
+    }
+
+    #visual-content Image {
+        width: auto;
+        height: 100%;
+    }
+
+    #page-nav {
+        dock: bottom;
+        height: auto;
+        padding: 1;
+    }
+    """
+
+    def __init__(
+        self,
+        chunk: "Chunk",
+        client: "HaikuRAG",
+        document_uri: str | None = None,
+    ):
+        super().__init__()
+        self.chunk = chunk
+        self.client = client
+        self.document_uri = document_uri or chunk.document_uri
+        self.images: list[PILImage] = []
+        self.current_page_idx = 0
+        self._image_widget: Widget = Static("Loading...", id="image-display")
+        self._page_info = Static("", id="page-info")
+
+    def compose(self) -> ComposeResult:
+        uri_display = self.document_uri or "Document"
+        with Vertical(id="visual-header"):
+            yield Static(f"[bold]Visual Grounding[/bold] - {uri_display}")
+        with Horizontal(id="visual-content"):
+            yield self._image_widget
+        with Horizontal(id="page-nav"):
+            yield self._page_info
+
+    async def on_mount(self) -> None:
+        """Load images and display the first page."""
+        self.images = await self.client.visualize_chunk(self.chunk)
+        await self._render_current_page()
+
+    async def _render_current_page(self) -> None:
+        """Render the current page."""
+        if not self.images:
+            if isinstance(self._image_widget, Static):
+                self._image_widget.update(
+                    "[yellow]No page images available[/yellow]\n"
+                    "This document was converted without page images."
+                )
+            self._page_info.update("")
+            return
+
+        self._page_info.update(
+            f"Page {self.current_page_idx + 1}/{len(self.images)} - Use ←/→ to navigate"
+        )
+
+        try:
+            image = self.images[self.current_page_idx]
+            new_widget = TextualImage(image, id="rendered-image")
+            await self._image_widget.remove()
+            content = self.query_one("#visual-content", Horizontal)
+            await content.mount(new_widget)
+            self._image_widget = new_widget
+        except Exception as e:
+            if isinstance(self._image_widget, Static):
+                self._image_widget.update(f"[red]Error: {e}[/red]")
+
+    async def action_dismiss(self, result=None) -> None:
+        self.app.pop_screen()
+
+    async def action_prev_page(self) -> None:
+        """Navigate to the previous page."""
+        if self.current_page_idx > 0:
+            self.current_page_idx -= 1
+            await self._render_current_page()
+
+    async def action_next_page(self) -> None:
+        """Navigate to the next page."""
+        if self.current_page_idx < len(self.images) - 1:
+            self.current_page_idx += 1
+            await self._render_current_page()