pkmrag 0.9.0__py3-none-any.whl

pkmrag/__init__.py

@@ -0,0 +1,5 @@
+"""PKMRAG: Embedded Hybrid GraphRAG Context Engine & MCP Server."""
+
+from __future__ import annotations
+
+__version__ = "0.9.0"

pkmrag/cache/__init__.py

@@ -0,0 +1,8 @@
+"""Query cache package for Project Orbit."""
+
+from __future__ import annotations
+
+from pkmrag.cache.manager import CacheManager
+from pkmrag.cache.sqlite_cache import SQLiteQueryCache
+
+__all__ = ["CacheManager", "SQLiteQueryCache"]

pkmrag/cache/manager.py

@@ -0,0 +1,98 @@
+"""High-level query cache manager coordinating cache lookup and invalidation."""
+
+from __future__ import annotations
+
+from pathlib import Path
+from typing import Optional
+
+from pkmrag.cache.sqlite_cache import SQLiteQueryCache
+from pkmrag.config import settings
+from pkmrag.models import CacheStats, SearchResult
+
+
+class CacheManager:
+    """Manages query caching lifecycle, key generation, and dependency invalidation."""
+
+    def __init__(
+        self,
+        vault_path: Path | str,
+        enabled: Optional[bool] = None,
+        max_entries: Optional[int] = None,
+        ttl_seconds: Optional[int] = None,
+        db_path: Optional[Path | str] = None,
+    ) -> None:
+        self.vault_path = Path(vault_path).resolve()
+        self.enabled = settings.cache_enabled if enabled is None else enabled
+        self.max_entries = settings.cache_max_entries if max_entries is None else max_entries
+        self.ttl_seconds = settings.cache_ttl_seconds if ttl_seconds is None else ttl_seconds
+
+        target_db = Path(db_path) if db_path else settings.get_cache_db_path(self.vault_path)
+        self._cache = (
+            SQLiteQueryCache(
+                db_path=target_db,
+                max_entries=self.max_entries,
+                ttl_seconds=self.ttl_seconds,
+            )
+            if self.enabled
+            else None
+        )
+
+    def get(
+        self,
+        query: str,
+        mode: str = "hybrid",
+        near: Optional[str] = None,
+        limit: int = 5,
+        folder: Optional[str] = None,
+        tags: Optional[list[str]] = None,
+    ) -> Optional[list[SearchResult]]:
+        """Look up cached search results for the given query and filter parameters."""
+        if not self.enabled or self._cache is None:
+            return None
+        key = SQLiteQueryCache.compute_key(
+            query=query, mode=mode, near=near, limit=limit, folder=folder, tags=tags
+        )
+        return self._cache.get(key)
+
+    def put(
+        self,
+        query: str,
+        mode: str,
+        results: list[SearchResult],
+        near: Optional[str] = None,
+        limit: int = 5,
+        folder: Optional[str] = None,
+        tags: Optional[list[str]] = None,
+    ) -> None:
+        """Store search results and associated note path dependencies in the cache."""
+        if not self.enabled or self._cache is None or not results:
+            return
+        key = SQLiteQueryCache.compute_key(
+            query=query, mode=mode, near=near, limit=limit, folder=folder, tags=tags
+        )
+        note_paths = list({r.note_path for r in results})
+        if near:
+            note_paths.append(near)
+        self._cache.put(key, query=query, results=results, note_paths=note_paths)
+
+    def invalidate_notes(self, note_paths: list[str]) -> int:
+        """Evict cached queries that returned any of the specified notes."""
+        if not self.enabled or self._cache is None or not note_paths:
+            return 0
+        return self._cache.evict_for_notes(note_paths)
+
+    def invalidate_all(self) -> None:
+        """Purge the entire query cache."""
+        if self._cache is not None:
+            self._cache.clear()
+
+    def get_stats(self) -> CacheStats:
+        """Fetch current cache metrics."""
+        if self._cache is None:
+            return CacheStats()
+        return self._cache.get_stats()
+
+    def close(self) -> None:
+        """Clean up cache resources."""
+        if self._cache is not None:
+            self._cache.close()

pkmrag/cache/sqlite_cache.py

@@ -0,0 +1,264 @@
+"""SQLite-backed L1 query cache with composite hashing and dependency tracking."""
+
+from __future__ import annotations
+
+import hashlib
+import json
+import logging
+import sqlite3
+import threading
+import time
+from pathlib import Path
+from typing import Optional
+
+from pkmrag.models import CacheStats, SearchResult
+
+logger = logging.getLogger("pkmrag.cache")
+
+SCHEMA_DDL = """
+PRAGMA journal_mode = WAL;
+PRAGMA synchronous = NORMAL;
+PRAGMA busy_timeout = 5000;
+
+CREATE TABLE IF NOT EXISTS query_cache (
+    cache_key TEXT PRIMARY KEY,
+    query_text TEXT NOT NULL,
+    result_json TEXT NOT NULL,
+    created_at REAL NOT NULL,
+    last_accessed_at REAL NOT NULL
+);
+
+CREATE TABLE IF NOT EXISTS cache_dependencies (
+    cache_key TEXT NOT NULL,
+    note_path TEXT NOT NULL,
+    PRIMARY KEY (cache_key, note_path)
+);
+
+CREATE INDEX IF NOT EXISTS idx_cache_deps_note ON cache_dependencies(note_path);
+
+CREATE TABLE IF NOT EXISTS cache_counters (
+    metric TEXT PRIMARY KEY,
+    val INTEGER NOT NULL DEFAULT 0
+);
+"""
+
+
+class SQLiteQueryCache:
+    """Thread-safe SQLite query cache with LRU eviction and reverse dependency tracking."""
+
+    def __init__(
+        self,
+        db_path: Path | str,
+        max_entries: int = 1000,
+        ttl_seconds: Optional[int] = None,
+    ) -> None:
+        self.db_path = Path(db_path).resolve()
+        self.db_path.parent.mkdir(parents=True, exist_ok=True)
+        self.max_entries = max(1, max_entries)
+        self.ttl_seconds = ttl_seconds
+        self._lock = threading.Lock()
+        self._conn = sqlite3.connect(str(self.db_path), check_same_thread=False)
+        self._init_db()
+
+    def _init_db(self) -> None:
+        """Run DDL and initialize counter metrics."""
+        with self._lock:
+            self._conn.executescript(SCHEMA_DDL)
+            for m in ("hits", "misses", "evictions"):
+                self._conn.execute(
+                    "INSERT OR IGNORE INTO cache_counters (metric, val) VALUES (?, 0);", (m,)
+                )
+            self._conn.commit()
+
+    @staticmethod
+    def compute_key(
+        query: str,
+        mode: str = "hybrid",
+        near: Optional[str] = None,
+        limit: int = 5,
+        folder: Optional[str] = None,
+        tags: Optional[list[str]] = None,
+    ) -> str:
+        """Build canonical composite cache key from query and all filter parameters."""
+        norm_q = " ".join(query.strip().lower().split())
+        norm_mode = mode.strip().lower()
+        norm_near = (near or "").strip().lower()
+        norm_folder = (folder or "").strip("/").lower()
+        tag_parts = [t.strip().lstrip("#").lower() for t in (tags or []) if t.strip()]
+        norm_tags = ",".join(sorted(tag_parts))
+        raw_repr = f"{norm_q}|{norm_mode}|{norm_near}|{limit}|{norm_folder}|{norm_tags}"
+        return hashlib.sha256(raw_repr.encode("utf-8")).hexdigest()
+
+    def get(self, cache_key: str) -> Optional[list[SearchResult]]:
+        """Retrieve cached search results if present and not expired."""
+        try:
+            with self._lock:
+                cursor = self._conn.cursor()
+                cursor.execute(
+                    "SELECT result_json, created_at FROM query_cache WHERE cache_key = ?;",
+                    (cache_key,),
+                )
+                row = cursor.fetchone()
+                if not row:
+                    self._increment_counter("misses")
+                    return None
+
+                res_json, created_at = row[0], float(row[1])
+                now = time.time()
+                if self.ttl_seconds is not None and (now - created_at) > self.ttl_seconds:
+                    cursor.execute("DELETE FROM query_cache WHERE cache_key = ?;", (cache_key,))
+                    cursor.execute(
+                        "DELETE FROM cache_dependencies WHERE cache_key = ?;", (cache_key,)
+                    )
+                    self._conn.commit()
+                    self._increment_counter("misses")
+                    return None
+
+                cursor.execute(
+                    "UPDATE query_cache SET last_accessed_at = ? WHERE cache_key = ?;",
+                    (now, cache_key),
+                )
+                self._increment_counter("hits")
+                self._conn.commit()
+
+            raw_list = json.loads(res_json)
+            return [SearchResult.model_validate(item) for item in raw_list]
+        except Exception as e:
+            logger.warning("Cache get error: %s", e)
+            return None
+
+    def put(
+        self,
+        cache_key: str,
+        query: str,
+        results: list[SearchResult],
+        note_paths: list[str],
+    ) -> None:
+        """Persist search results and inverted note dependencies into cache."""
+        try:
+            raw_json = json.dumps([r.model_dump() for r in results])
+            now = time.time()
+            clean_paths = sorted({p.strip() for p in note_paths if p.strip()})
+
+            with self._lock:
+                cursor = self._conn.cursor()
+                cursor.execute(
+                    "INSERT OR REPLACE INTO query_cache "
+                    "(cache_key, query_text, result_json, created_at, last_accessed_at) "
+                    "VALUES (?, ?, ?, ?, ?);",
+                    (cache_key, query, raw_json, now, now),
+                )
+                cursor.execute("DELETE FROM cache_dependencies WHERE cache_key = ?;", (cache_key,))
+                if clean_paths:
+                    cursor.executemany(
+                        "INSERT OR IGNORE INTO cache_dependencies (cache_key, note_path) "
+                        "VALUES (?, ?);",
+                        [(cache_key, p) for p in clean_paths],
+                    )
+
+                self._prune_lru(cursor)
+                self._conn.commit()
+        except Exception as e:
+            logger.warning("Cache put error: %s", e)
+
+    def _prune_lru(self, cursor: sqlite3.Cursor) -> None:
+        """Prune oldest entries when cache exceeds capacity."""
+        cursor.execute("SELECT COUNT(*) FROM query_cache;")
+        count = cursor.fetchone()[0]
+        if count > self.max_entries:
+            prune_count = max(1, count - self.max_entries + int(self.max_entries * 0.1))
+            cursor.execute(
+                "DELETE FROM query_cache WHERE cache_key IN ("
+                "SELECT cache_key FROM query_cache ORDER BY last_accessed_at ASC LIMIT ?);",
+                (prune_count,),
+            )
+            cursor.execute(
+                "DELETE FROM cache_dependencies WHERE cache_key NOT IN "
+                "(SELECT cache_key FROM query_cache);"
+            )
+            self._increment_counter("evictions", count=prune_count)
+
+    def evict_for_notes(self, note_paths: list[str]) -> int:
+        """Evict all cached queries referencing the specified note paths."""
+        if not note_paths:
+            return 0
+        try:
+            with self._lock:
+                cursor = self._conn.cursor()
+                placeholders = ",".join("?" for _ in note_paths)
+                cursor.execute(
+                    f"SELECT DISTINCT cache_key FROM cache_dependencies "
+                    f"WHERE note_path IN ({placeholders});",
+                    note_paths,
+                )
+                matching = [row[0] for row in cursor.fetchall()]
+                if not matching:
+                    return 0
+
+                key_ph = ",".join("?" for _ in matching)
+                cursor.execute(f"DELETE FROM query_cache WHERE cache_key IN ({key_ph});", matching)
+                cursor.execute(
+                    f"DELETE FROM cache_dependencies WHERE cache_key IN ({key_ph});", matching
+                )
+                self._increment_counter("evictions", count=len(matching))
+                self._conn.commit()
+                return len(matching)
+        except Exception as e:
+            logger.warning("Cache eviction error: %s", e)
+            return 0
+
+    def clear(self) -> None:
+        """Purge all entries and dependencies from cache."""
+        try:
+            with self._lock:
+                cursor = self._conn.cursor()
+                cursor.execute("DELETE FROM query_cache;")
+                cursor.execute("DELETE FROM cache_dependencies;")
+                cursor.execute("UPDATE cache_counters SET val = 0;")
+                self._conn.commit()
+        except Exception as e:
+            logger.warning("Cache clear error: %s", e)
+
+    def _increment_counter(self, metric: str, count: int = 1) -> None:
+        self._conn.execute(
+            "UPDATE cache_counters SET val = val + ? WHERE metric = ?;",
+            (count, metric),
+        )
+
+    def get_stats(self) -> CacheStats:
+        """Compute live cache statistics and hit rate."""
+        try:
+            with self._lock:
+                cursor = self._conn.cursor()
+                cursor.execute("SELECT COUNT(*) FROM query_cache;")
+                total = cursor.fetchone()[0]
+
+                cursor.execute("SELECT metric, val FROM cache_counters;")
+                counters = dict(cursor.fetchall())
+                hits = counters.get("hits", 0)
+                misses = counters.get("misses", 0)
+                evictions = counters.get("evictions", 0)
+
+            total_reqs = hits + misses
+            hit_rate = round(hits / total_reqs, 4) if total_reqs > 0 else 0.0
+            size_bytes = self.db_path.stat().st_size if self.db_path.exists() else 0
+
+            return CacheStats(
+                total_entries=total,
+                hits=hits,
+                misses=misses,
+                hit_rate=hit_rate,
+                evictions=evictions,
+                db_size_bytes=size_bytes,
+            )
+        except Exception as e:
+            logger.warning("Cache get_stats error: %s", e)
+            return CacheStats()
+
+    def close(self) -> None:
+        """Safely close SQLite connection."""
+        with self._lock:
+            try:
+                self._conn.close()
+            except Exception:
+                pass

pkmrag/cli.py

@@ -0,0 +1,294 @@
+"""Command Line Interface for PKMRAG."""
+
+from __future__ import annotations
+
+import json
+import sys
+from pathlib import Path
+from typing import Optional
+
+import typer
+from rich.console import Console
+from rich.progress import BarColumn, Progress, SpinnerColumn, TextColumn, TimeElapsedColumn
+
+from pkmrag import __version__
+from pkmrag.cli_views import (
+    render_discovery_results,
+    render_doctor_report,
+    render_ingest_report,
+    render_mcp_config,
+    render_search_results,
+)
+from pkmrag.doctor import run_diagnostics
+from pkmrag.ingest import IngestPipeline
+from pkmrag.plugin import register_plugin_command
+from pkmrag.search import SearchService
+
+app = typer.Typer(
+    name="pkmrag",
+    help="🛰️ PKMRAG: In-process Hybrid GraphRAG Retrieval Engine & MCP Server.",
+    no_args_is_help=True,
+)
+register_plugin_command(app)
+
+console = Console()
+
+
+def version_callback(value: bool) -> None:
+    """Print the version of PKMRAG and exit."""
+    if value:
+        console.print(f"[bold cyan]PKMRAG[/bold cyan] version [green]{__version__}[/green]")
+        raise typer.Exit()
+
+
+def _make_progress() -> Progress:
+    return Progress(
+        SpinnerColumn(),
+        TextColumn("[progress.description]{task.description}"),
+        BarColumn(),
+        TextColumn("{task.completed}/{task.total}"),
+        TimeElapsedColumn(),
+        console=console,
+    )
+
+
+def _display_trace_if_active() -> None:
+    from pkmrag.telemetry import get_memory_collector, render_trace_tree
+
+    collector = get_memory_collector()
+    if collector:
+        render_trace_tree(collector.get_spans(), console)
+
+
+@app.callback()
+def main(
+    version: Optional[bool] = typer.Option(
+        None, "--version", "-v", help="Show version.", callback=version_callback, is_eager=True
+    ),
+) -> None:
+    """PKMRAG CLI root callback."""
+
+
+@app.command()
+def doctor(
+    json_output: bool = typer.Option(False, "--json", help="Output diagnostics in raw JSON."),
+) -> None:
+    """Verify system requirements and embedded in-process storage engines (LadybugDB & LanceDB)."""
+    with console.status("[bold blue]Running PKMRAG diagnostics...[/bold blue]"):
+        report = run_diagnostics()
+
+    if json_output:
+        console.print_json(report.model_dump_json())
+    else:
+        render_doctor_report(report, console)
+    sys.exit(0 if report.all_passed else 1)
+
+
+@app.command()
+def ingest(
+    vault_path: Path = typer.Argument(..., help="Path to vault.", exists=True, resolve_path=True),
+    target: str = typer.Option("all", "--target", "-t", help="Target: all, graph, or vector."),
+    db_dir: Optional[Path] = typer.Option(None, "--db-dir", "-d", help="Custom LadybugDB dir."),
+    vector_dir: Optional[Path] = typer.Option(None, "--vector-dir", help="Custom LanceDB dir."),
+    rebuild: bool = typer.Option(False, "--rebuild", help="Rebuild indices from scratch."),
+    clear_cache: bool = typer.Option(False, "--clear-cache", help="Purge cached search queries."),
+    dialect: str = typer.Option("auto", "--dialect", "-m", help="Source dialect (auto, obsidian)."),
+    trace: bool = typer.Option(False, "--trace", help="Display visual execution trace tree."),
+    json_output: bool = typer.Option(False, "--json", help="Output metrics in raw JSON format."),
+) -> None:
+    """Ingest notes, links, tags, and semantic vectors from a knowledge base."""
+    if trace:
+        from pkmrag.telemetry import setup_telemetry
+
+        setup_telemetry(enable_memory_collector=True)
+
+    if rebuild or clear_cache:
+        from pkmrag.cache import CacheManager
+
+        CacheManager(vault_path).invalidate_all()
+
+    pipeline = IngestPipeline(
+        vault_path=vault_path,
+        db_path=db_dir,
+        vector_dir=vector_dir,
+        rebuild=rebuild,
+        dialect=dialect,
+        target=target,
+    )
+
+    if json_output:
+        console.print_json(pipeline.run().model_dump_json())
+        sys.exit(0)
+
+    if rebuild:
+        console.print("[yellow]Rebuild mode enabled: existing indices and cache wiped.[/yellow]")
+
+    with _make_progress() as progress:
+        task_id = progress.add_task("[cyan]Ingesting vault...", total=100)
+
+        def on_prog(phase: str, cur: int, tot: int) -> None:
+            progress.update(
+                task_id, description=f"[cyan]{phase}...", total=max(tot, 1), completed=cur
+            )
+
+        stats = pipeline.run(progress_callback=on_prog)
+        progress.update(task_id, description="[bold green]Ingestion complete!")
+
+    render_ingest_report(stats, console)
+
+    if trace:
+        _display_trace_if_active()
+
+
+@app.command()
+def search(
+    query: str = typer.Argument(..., help="Search query string."),
+    vault_path: Path = typer.Option(Path.cwd(), "--vault", "-v", help="Vault directory."),
+    near: Optional[str] = typer.Option(None, "--near", "-n", help="Note for graph bias."),
+    mode: str = typer.Option("hybrid", "--mode", "-m", help="Search mode: hybrid, dense, sparse."),
+    limit: int = typer.Option(5, "--limit", "-l", help="Maximum number of search results."),
+    trace: bool = typer.Option(False, "--trace", help="Display visual execution trace tree."),
+    json_output: bool = typer.Option(False, "--json", help="Output raw JSON results."),
+) -> None:
+    """Search knowledge base chunks using dense vectors, BM25, and optional graph proximity."""
+    if trace:
+        from pkmrag.telemetry import setup_telemetry
+
+        setup_telemetry(enable_memory_collector=True)
+
+    with SearchService(vault_path=vault_path) as service:
+        results = service.search(query=query, near=near, mode=mode, limit=limit)
+
+    if json_output:
+        typer.echo(json.dumps([r.model_dump() for r in results], indent=2))
+        sys.exit(0)
+
+    render_search_results(results, query=query, near=near, mode=mode, console=console)
+    if trace:
+        _display_trace_if_active()
+
+
+@app.command()
+def serve(
+    vault_path: Path = typer.Argument(..., help="Vault directory.", exists=True, resolve_path=True),
+    transport: str = typer.Option("stdio", "--transport", "-t", help="Transport (stdio/http/sse)."),
+    host: str = typer.Option("127.0.0.1", "--host", "-h", help="Bind address for HTTP/SSE."),
+    port: int = typer.Option(3747, "--port", "-p", help="Port for HTTP/SSE."),
+    token: Optional[str] = typer.Option(None, "--token", help="Bearer auth token."),
+    no_auth: bool = typer.Option(False, "--no-auth", help="Disable token authentication."),
+) -> None:
+    """Start an MCP server exposing PKMRAG tools over stdio or HTTP/SSE."""
+    from pkmrag.mcp import run_server
+
+    try:
+        run_server(
+            vault_path, transport=transport, host=host, port=port, token=token, no_auth=no_auth
+        )
+    except ValueError as e:
+        console.print(f"[bold red]{e}[/bold red]")
+        sys.exit(1)
+
+
+@app.command(name="mcp-config")
+def mcp_config(
+    vault_path: Path = typer.Argument(..., help="Vault directory.", exists=True, resolve_path=True),
+    transport: str = typer.Option("stdio", "--transport", "-t", help="Transport (stdio, sse)."),
+    port: int = typer.Option(3747, "--port", "-p", help="Port for SSE server."),
+) -> None:
+    """Generate ready-to-use MCP configuration snippets for Claude Desktop and Cursor."""
+    render_mcp_config(vault_path, console, transport=transport, port=port)
+
+
+@app.command()
+def eval(
+    vault_path: Optional[Path] = typer.Argument(
+        None, help="Vault dir (defaults to benchmarks/vault)."
+    ),
+    benchmark: Optional[Path] = typer.Option(
+        None, "-b", "--benchmark", help="Benchmark JSON file."
+    ),
+    min_mrr: float = typer.Option(0.80, "--min-mrr", help="Minimum required MRR score."),
+    min_recall: float = typer.Option(0.80, "--min-recall", help="Minimum required Recall@5."),
+    json_output: bool = typer.Option(False, "--json", help="Output raw JSON evaluation report."),
+) -> None:
+    """Evaluate retrieval engine accuracy against ground truth benchmarks."""
+    from pkmrag.eval import EvaluationHarness, render_eval_report
+
+    harness = EvaluationHarness(vault_path=vault_path, benchmark_path=benchmark)
+    report = harness.run(min_mrr=min_mrr, min_recall=min_recall)
+
+    if json_output:
+        console.print_json(report.model_dump_json())
+    else:
+        render_eval_report(report, console, min_mrr=min_mrr, min_recall=min_recall)
+
+    sys.exit(0 if report.passed else 1)
+
+
+@app.command()
+def discover(
+    vault_path: Path = typer.Argument(..., help="Vault directory.", exists=True, resolve_path=True),
+    threshold: float = typer.Option(0.80, "--threshold", "-t", help="Cosine similarity threshold."),
+    limit: int = typer.Option(20, "--limit", "-l", help="Maximum candidate pairs to classify."),
+    provider: Optional[str] = typer.Option(None, "--provider", "-p", help="Provider type."),
+    model: Optional[str] = typer.Option(None, "--model", help="Inference model name."),
+    rpm: Optional[int] = typer.Option(None, "--rpm", help="Rate limit: max requests per minute."),
+    tpm: Optional[int] = typer.Option(None, "--tpm", help="Rate limit: max tokens per minute."),
+    dry_run: bool = typer.Option(False, "--dry-run", help="Scan candidates without invoking LLM."),
+    trace: bool = typer.Option(False, "--trace", help="Display visual execution trace tree."),
+    json_output: bool = typer.Option(False, "--json", help="Output raw JSON results."),
+) -> None:
+    """Discover semantic gaps between notes and infer conceptual relationships."""
+    if trace:
+        from pkmrag.telemetry import setup_telemetry
+
+        setup_telemetry(enable_memory_collector=True)
+
+    from pkmrag.discovery import GapDiscoveryEngine
+
+    engine = GapDiscoveryEngine(vault_path)
+    try:
+        on_prog = None
+        progress = None
+        if not (dry_run or json_output):
+            progress = _make_progress()
+            progress.start()
+            t_id = progress.add_task("[cyan]Scanning for semantic gaps...", total=limit)
+
+            def _cb(cur: int, tot: int, desc: str) -> None:
+                style = "yellow" if cur < 0 else "cyan"
+                if progress:
+                    progress.update(
+                        t_id,
+                        description=f"[{style}]{desc}[/{style}]",
+                        total=max(tot, 1) if tot > 0 else limit,
+                        completed=max(cur, 0),
+                    )
+
+            on_prog = _cb
+
+        candidates, inferred, stats = engine.discover(
+            similarity_threshold=threshold,
+            limit=limit,
+            dry_run=dry_run,
+            provider_type=provider,
+            model=model,
+            rpm=rpm,
+            tpm=tpm,
+            on_progress=on_prog,
+        )
+
+        if progress:
+            progress.stop()
+    finally:
+        engine.close()
+
+    render_discovery_results(
+        candidates, inferred, stats, dry_run=dry_run, json_output=json_output, console=console
+    )
+    if trace:
+        _display_trace_if_active()
+
+
+if __name__ == "__main__":
+    app()