sciogen 0.1.0__py3-none-any.whl

sciogen/cli/main.py

@@ -0,0 +1,322 @@
+"""sciogen CLI — Typer for command routing, Rich for all terminal output.
+
+Only `sciogen index` shows the banner + progress flow; every other command
+prints its output and nothing else. Heavier modules (stores, pipeline) import
+inside command bodies so `sciogen --help` stays instant.
+"""
+
+from __future__ import annotations
+
+from pathlib import Path
+from typing import Optional
+
+import typer
+
+from sciogen import __version__
+from sciogen.cli.banner import banner_text
+from sciogen.cli.console import console
+
+app = typer.Typer(
+    name="sciogen",
+    help="Codebase intelligence layer — a queryable knowledge graph over your code.",
+    add_completion=False,
+    rich_markup_mode="rich",
+)
+
+
+def _version_callback(value: bool) -> None:
+    if value:
+        console.print(f"sciogen {__version__}")
+        raise typer.Exit()
+
+
+@app.callback(invoke_without_command=True)
+def _main(
+    ctx: typer.Context,
+    version: Optional[bool] = typer.Option(
+        None, "--version", callback=_version_callback, is_eager=True, help="Show version and exit."
+    ),
+) -> None:
+    """sciogen — index once, query forever.
+
+    Bare `sciogen` indexes the current directory: banner, pipeline progress,
+    then the completion summary. Agents read that output directly; querying
+    goes through the subcommands or the MCP server (`sciogen mcp`).
+    """
+    if ctx.invoked_subcommand is None:
+        index(Path("."), rebuild=False)
+
+
+def _open_graph(path: Path):
+    from sciogen.api import SciogenGraph
+
+    return SciogenGraph(path)
+
+
+def _fail(message: str) -> None:
+    console.print(f"  ⚠ {message}")
+    raise typer.Exit(code=1)
+
+
+class _RichReporter:
+    """Adapts pipeline progress onto rich.progress.Progress: one row per step,
+    Braille spinner while running, replaced in place with ✓ when done."""
+
+    def __init__(self, progress) -> None:
+        self.progress = progress
+        self.tasks: dict[str, int] = {}
+
+    def start(self, step: str, text: str) -> None:
+        self.tasks[step] = self.progress.add_task(text, total=1)
+
+    def finish(self, step: str) -> None:
+        self.progress.update(self.tasks[step], completed=1)
+
+    def warn(self, message: str) -> None:
+        # print above the live display, keeping the ⚠ single-line error format
+        self.progress.console.print(f"  ⚠ {message}")
+
+
+# ------------------------------------------------------------------- index
+
+@app.command()
+def index(
+    path: Path = typer.Argument(Path("."), help="Project directory to index."),
+    rebuild: bool = typer.Option(False, "--rebuild", help="Discard the existing index and rebuild from scratch."),
+) -> None:
+    """Build or incrementally update the knowledge graph for a codebase."""
+    from rich.progress import Progress, SpinnerColumn, TextColumn
+
+    console.print(banner_text(__version__))
+    graph = _open_graph(path)
+    try:
+        with Progress(
+            SpinnerColumn(spinner_name="dots", finished_text="✓"),
+            TextColumn("{task.description}"),
+            console=console,
+        ) as progress:
+            stats = graph.index(reporter=_RichReporter(progress), rebuild=rebuild)
+        console.print(
+            f"✓ Done! {stats.nodes:,} nodes · {stats.edges:,} edges · indexed in {stats.seconds:.1f}s"
+        )
+        console.print("  Ready. Your codebase is now queryable.", style="dim")
+    except Exception:
+        console.print_exception()
+        raise typer.Exit(code=1)
+    finally:
+        graph.close()
+
+
+# ----------------------------------------------------------------- queries
+
+@app.command()
+def search(
+    query: str = typer.Argument(..., help="Natural-language query."),
+    path: Path = typer.Option(Path("."), "--path", "-p", help="Indexed project directory."),
+    mode: str = typer.Option("semantic", "--mode", "-m", help="semantic | hybrid"),
+    granularity: Optional[str] = typer.Option(None, "--granularity", "-g", help="file | class | function | chunk"),
+    k: int = typer.Option(10, "--top", "-k", help="Number of results."),
+) -> None:
+    """Semantic or hybrid search over the indexed codebase."""
+    from rich.table import Table
+
+    graph = _open_graph(path)
+    try:
+        results = graph.search(query, mode=mode, granularity=granularity, k=k)
+        if not results.hits:
+            console.print("  No results.", style="dim")
+            return
+        table = Table(box=None, pad_edge=False, header_style="bold")
+        table.add_column("score", justify="right", style="cyan")
+        table.add_column("kind", style="dim")
+        table.add_column("symbol")
+        table.add_column("location", style="dim")
+        for hit in results.hits:
+            location = f"{hit.node.file}:{hit.node.line_start}" if hit.node.file else "—"
+            via = "" if hit.via == "semantic" else " [dim](via graph)[/dim]"
+            table.add_row(f"{hit.score:.2f}", hit.node.kind, f"{hit.node.name}{via}", location)
+        console.print(table)
+    except Exception as exc:
+        _handle_query_error(exc)
+    finally:
+        graph.close()
+
+
+@app.command()
+def callers(
+    symbol: str = typer.Argument(..., help="Symbol name, e.g. AuthService.login"),
+    path: Path = typer.Option(Path("."), "--path", "-p"),
+    depth: int = typer.Option(1, "--depth", "-d", help="Hops up the call chain."),
+    min_confidence: float = typer.Option(0.0, "--min-confidence", "-c"),
+) -> None:
+    """Who calls a symbol, up to N hops."""
+    _print_impact_table(path, symbol, depth, min_confidence, callers_only=True)
+
+
+@app.command()
+def impact(
+    symbol: str = typer.Argument(..., help="Symbol name, e.g. UserModel.find_by_email"),
+    path: Path = typer.Option(Path("."), "--path", "-p"),
+    depth: int = typer.Option(5, "--depth", "-d"),
+    min_confidence: float = typer.Option(0.0, "--min-confidence", "-c"),
+) -> None:
+    """What breaks if a symbol changes (callers, subclasses, tests, mutators)."""
+    _print_impact_table(path, symbol, depth, min_confidence, callers_only=False)
+
+
+def _print_impact_table(path: Path, symbol: str, depth: int, min_confidence: float, callers_only: bool) -> None:
+    from rich.table import Table
+
+    graph = _open_graph(path)
+    try:
+        if callers_only:
+            result = graph.get_callers(symbol, depth, min_confidence)
+        else:
+            result = graph.analyze_impact(symbol, depth, min_confidence)
+        target_names = ", ".join(t.name for t in result.targets)
+        if not result.impacted:
+            console.print(f"  Nothing reaches [bold]{target_names}[/bold] within {depth} hops.", style="dim")
+            return
+        table = Table(box=None, pad_edge=False, header_style="bold",
+                      title=f"{len(result.impacted)} symbols → {target_names}", title_justify="left")
+        table.add_column("hops", justify="right", style="cyan")
+        table.add_column("conf", justify="right")
+        table.add_column("via", style="dim")
+        table.add_column("symbol")
+        table.add_column("location", style="dim")
+        for item in result.impacted:
+            style = "" if item.confidence >= 0.8 else ("yellow" if item.confidence >= 0.5 else "red")
+            location = f"{item.node.file}:{item.node.line_start}" if item.node.file else "—"
+            table.add_row(
+                str(item.hops), f"[{style}]{item.confidence:.2f}[/{style}]" if style else f"{item.confidence:.2f}",
+                item.relation, item.node.name, location,
+            )
+        console.print(table)
+    except Exception as exc:
+        _handle_query_error(exc)
+    finally:
+        graph.close()
+
+
+@app.command()
+def deps(
+    file: str = typer.Argument(..., help="Project-relative file path."),
+    path: Path = typer.Option(Path("."), "--path", "-p"),
+) -> None:
+    """All imports and transitive dependencies of a file."""
+    graph = _open_graph(path)
+    try:
+        info = graph.get_dependencies(file)
+        for title, items in (
+            ("direct", info.direct_files),
+            ("transitive", info.transitive_files),
+            ("external", info.external_modules),
+        ):
+            console.print(f"[bold]{title}[/bold] ({len(items)})")
+            for item in items:
+                console.print(f"  {item}")
+    except Exception as exc:
+        _handle_query_error(exc)
+    finally:
+        graph.close()
+
+
+@app.command()
+def symbol(
+    name: str = typer.Argument(..., help="Symbol name to look up."),
+    path: Path = typer.Option(Path("."), "--path", "-p"),
+    file: Optional[str] = typer.Option(None, "--file", "-f", help="Narrow to a defining file."),
+) -> None:
+    """Typed node info for a named symbol."""
+    graph = _open_graph(path)
+    try:
+        info = graph.get_symbol(name, file)
+        n = info.node
+        console.print(f"[bold]{n.name}[/bold]  [dim]{n.kind}[/dim]")
+        console.print(f"  {n.file}:{n.line_start}-{n.line_end}" if n.file else "  (no source location)")
+        if n.params:
+            console.print(f"  params: {', '.join(n.params)}")
+        if n.return_type:
+            console.print(f"  returns: {n.return_type}")
+        if n.extends:
+            console.print(f"  extends: {', '.join(n.extends)}")
+        if n.complexity:
+            console.print(f"  complexity: {n.complexity}")
+        if n.docstring:
+            console.print(f"  [dim]{n.docstring}[/dim]")
+        if info.relations:
+            console.print(f"  [bold]relations[/bold] ({len(info.relations)})")
+            for rel in info.relations[:30]:
+                arrow = "→" if rel.direction == "out" else "←"
+                console.print(f"    {arrow} {rel.kind} {rel.other}  [dim]{rel.confidence:.2f}[/dim]")
+            if len(info.relations) > 30:
+                console.print(f"    [dim]… {len(info.relations) - 30} more[/dim]")
+    except Exception as exc:
+        _handle_query_error(exc)
+    finally:
+        graph.close()
+
+
+# ----------------------------------------------------------------- explore
+
+@app.command()
+def explore(
+    path: Path = typer.Argument(Path("."), help="Indexed project directory (or a subdirectory to scope the view)."),
+) -> None:
+    """Open an interactive visual view of the knowledge graph in the browser."""
+    import webbrowser
+
+    target = path.resolve()
+    root, prefix = target, ""
+    # Allow scoping to a subdirectory: find the enclosing indexed project.
+    while not (root / ".sciogen").exists() and root.parent != root:
+        root = root.parent
+    if (root / ".sciogen").exists() and root != target:
+        prefix = target.relative_to(root).as_posix() + "/"
+    elif not (root / ".sciogen").exists():
+        _fail(f"No sciogen index found at or above {target} — run `sciogen index` first.")
+
+    from sciogen.cli.explore import generate_html
+
+    graph = _open_graph(root)
+    try:
+        snapshot = graph.snapshot(prefix)
+        if not snapshot["nodes"]:
+            _fail("The index is empty — run `sciogen index` first.")
+        out = generate_html(snapshot, root.name, graph.config.data_dir / "explore.html")
+        console.print(f"  Graph written to {out}")
+        console.print("  Snapshot view — re-run [bold]sciogen index[/bold] then "
+                      "[bold]sciogen explore[/bold] after code changes.", style="dim")
+        webbrowser.open(out.resolve().as_uri())
+    except Exception as exc:
+        _handle_query_error(exc)
+    finally:
+        graph.close()
+
+
+# --------------------------------------------------------------------- mcp
+
+@app.command()
+def mcp(
+    path: Path = typer.Argument(Path("."), help="Project directory the MCP server exposes."),
+) -> None:
+    """Run the MCP server (stdio) for agent integration."""
+    from sciogen.mcp.server import serve
+
+    serve(path)
+
+
+# ------------------------------------------------------------------ errors
+
+def _handle_query_error(exc: Exception) -> None:
+    from sciogen.query.engine import SymbolNotFound
+    from sciogen.stores.vectors import EmbedderMismatch
+
+    if isinstance(exc, (SymbolNotFound, EmbedderMismatch, FileNotFoundError)):
+        _fail(str(exc))
+    console.print_exception()
+    raise typer.Exit(code=1)
+
+
+if __name__ == "__main__":
+    app()

sciogen/config.py

@@ -0,0 +1,82 @@
+"""Runtime configuration.
+
+All knobs have working defaults; nothing requires a config file. Environment
+variables override defaults so CI and agents can tune behavior without code:
+
+===========================  =================================================
+``SCIOGEN_EMBEDDER``         ``nomic`` (default) or ``hash``. ``nomic`` falls
+                             back to ``hash`` automatically when
+                             sentence-transformers is not installed.
+``SCIOGEN_WORKERS``          Parse worker processes. Default: ``os.cpu_count()``.
+                             ``0``/``1`` disables multiprocessing.
+``SCIOGEN_DATA_DIR``         Index location, default ``<project>/.sciogen``.
+===========================  =================================================
+"""
+
+from __future__ import annotations
+
+import os
+from dataclasses import dataclass, field
+from pathlib import Path
+
+#: Directories never worth indexing. Discovery also honors .gitignore-style
+#: hidden-dir skipping (any path segment starting with ".").
+DEFAULT_IGNORED_DIRS = frozenset(
+    {
+        "node_modules", "__pycache__", "venv", ".venv", "env", "dist", "build",
+        "target", "vendor", "coverage", "htmlcov", ".sciogen", "site-packages",
+        ".git", ".hg", ".svn", ".tox", ".mypy_cache", ".ruff_cache", ".pytest_cache",
+    }
+)
+
+#: Functions longer than this many lines are additionally split into
+#: chunk-level embedding units (ChunkNode).
+CHUNK_THRESHOLD_LINES = 40
+CHUNK_SIZE_LINES = 30
+
+SCHEMA_VERSION = 1
+
+
+@dataclass(slots=True)
+class Config:
+    """Resolved configuration for one project index."""
+
+    project_root: Path
+    data_dir: Path
+    embedder: str = "nomic"
+    workers: int = 0  # 0 = auto (cpu_count), 1 = serial
+    min_files_for_parallel: int = 32  # below this, process-pool startup costs more than it saves
+    embed_batch_size: int = 64
+    ignored_dirs: frozenset[str] = field(default_factory=lambda: DEFAULT_IGNORED_DIRS)
+
+    @classmethod
+    def for_project(cls, project_root: str | Path) -> "Config":
+        root = Path(project_root).resolve()
+        data_dir = Path(os.environ.get("SCIOGEN_DATA_DIR", root / ".sciogen"))
+        workers_env = os.environ.get("SCIOGEN_WORKERS", "")
+        return cls(
+            project_root=root,
+            data_dir=data_dir,
+            embedder=os.environ.get("SCIOGEN_EMBEDDER", "nomic"),
+            workers=int(workers_env) if workers_env.isdigit() else 0,
+        )
+
+    @property
+    def graph_dir(self) -> Path:
+        return self.data_dir / "graph.kuzu"
+
+    @property
+    def vector_dir(self) -> Path:
+        return self.data_dir / "vectors"
+
+    @property
+    def meta_path(self) -> Path:
+        return self.data_dir / "meta.db"
+
+    def effective_workers(self, n_files: int) -> int:
+        """Parallelism actually used for a batch of ``n_files``."""
+        if n_files < self.min_files_for_parallel:
+            return 1
+        if self.workers >= 1:
+            return self.workers
+        return max(1, min(os.cpu_count() or 1, 8))

sciogen/discovery.py

@@ -0,0 +1,125 @@
+"""File discovery and two-tier change detection.
+
+Discovery walks the project tree once, skipping ignored/hidden directories,
+and returns every file whose extension maps to a supported language.
+
+Change detection is deliberately two-tier — this is the hot path of
+incremental re-indexing on large repos:
+
+1. **Fast path (stat only):** if a file's ``(size, mtime_ns)`` pair matches
+   what SQLite recorded last time, the file is assumed unchanged and never
+   opened. A 100k-file repo re-index costs 100k ``stat`` calls, not 100k
+   reads + hashes.
+2. **Slow path (content hash):** only files whose stat signature changed are
+   read and SHA256-hashed. If the hash still matches (e.g. ``touch``,
+   checkout that restored content), the stored stat signature is refreshed
+   but the file is *not* re-parsed.
+
+SHA256 remains the source of truth — mtime alone is never trusted to declare
+a file changed, and stat matching is never trusted across schema migrations
+(the pipeline forces a full rebuild in that case).
+"""
+
+from __future__ import annotations
+
+import hashlib
+import os
+from dataclasses import dataclass
+from pathlib import Path
+
+from sciogen.config import Config
+from sciogen.parsing.languages import language_for_path
+
+
+@dataclass(slots=True)
+class DiscoveredFile:
+    path: str  # project-relative, "/" separators
+    abs_path: str
+    language: str
+    size: int
+    mtime: float
+    mtime_ns: int
+
+
+@dataclass(slots=True)
+class ChangeSet:
+    """Result of diffing the working tree against the stored index state."""
+
+    changed: list[DiscoveredFile]  # new or content-changed -> re-parse
+    unchanged: list[DiscoveredFile]  # skipped entirely
+    deleted: list[str]  # relative paths present in the index but gone on disk
+    stat_refreshed: list[DiscoveredFile]  # content identical, stat signature updated
+
+
+def discover(config: Config) -> list[DiscoveredFile]:
+    """Walk the project and return all indexable source files."""
+    root = config.project_root
+    found: list[DiscoveredFile] = []
+    for dirpath, dirnames, filenames in os.walk(root):
+        # Prune in place: os.walk never descends into removed entries.
+        dirnames[:] = [
+            d for d in dirnames if d not in config.ignored_dirs and not d.startswith(".")
+        ]
+        for fname in filenames:
+            language = language_for_path(fname)
+            if language is None:
+                continue
+            abs_path = os.path.join(dirpath, fname)
+            try:
+                st = os.stat(abs_path)
+            except OSError:
+                continue
+            rel = os.path.relpath(abs_path, root).replace(os.sep, "/")
+            found.append(
+                DiscoveredFile(
+                    path=rel,
+                    abs_path=abs_path,
+                    language=language,
+                    size=st.st_size,
+                    mtime=st.st_mtime,
+                    mtime_ns=st.st_mtime_ns,
+                )
+            )
+    found.sort(key=lambda f: f.path)
+    return found
+
+
+def sha256_file(abs_path: str) -> str:
+    h = hashlib.sha256()
+    with open(abs_path, "rb") as fh:
+        for block in iter(lambda: fh.read(1 << 20), b""):
+            h.update(block)
+    return h.hexdigest()
+
+
+def compute_changes(
+    files: list[DiscoveredFile],
+    stored: dict[str, tuple[str, int, int]],
+) -> ChangeSet:
+    """Diff discovered files against stored state.
+
+    ``stored`` maps relative path -> ``(sha256, size, mtime_ns)`` as recorded
+    by the metadata store after the previous index run.
+    """
+    changed: list[DiscoveredFile] = []
+    unchanged: list[DiscoveredFile] = []
+    stat_refreshed: list[DiscoveredFile] = []
+    seen: set[str] = set()
+
+    for f in files:
+        seen.add(f.path)
+        record = stored.get(f.path)
+        if record is not None:
+            old_sha, old_size, old_mtime_ns = record
+            if f.size == old_size and f.mtime_ns == old_mtime_ns:
+                unchanged.append(f)  # fast path: stat signature identical
+                continue
+            if sha256_file(f.abs_path) == old_sha:
+                stat_refreshed.append(f)  # touched but content identical
+                continue
+        changed.append(f)
+
+    deleted = sorted(path for path in stored if path not in seen)
+    return ChangeSet(
+        changed=changed, unchanged=unchanged, deleted=deleted, stat_refreshed=stat_refreshed
+    )

sciogen/embed/__init__.py

@@ -0,0 +1,51 @@
+"""Embedders — pluggable text -> vector functions.
+
+sciogen computes embeddings itself and hands raw vectors to ChromaDB (rather
+than registering an embedding function with the collection). That keeps the
+embedder swappable without ChromaDB persistence-config coupling, and lets the
+pipeline batch + deduplicate embedding work.
+
+Two implementations:
+
+- :class:`~sciogen.embed.nomic.NomicEmbedder` — the documented default,
+  local nomic-embed-code via sentence-transformers (optional install:
+  ``pip install sciogen[embeddings]``).
+- :class:`~sciogen.embed.hashing.HashingEmbedder` — deterministic feature
+  hashing. Zero dependencies, instant, no model download. Used automatically
+  when sentence-transformers is unavailable, and always in tests. Retrieval
+  quality is keyword-level rather than semantic; fine for structural work,
+  not a substitute for real embeddings.
+
+The embedder's identity is recorded in the vector store's metadata; mixing
+vectors from different embedders in one index is refused at open time.
+"""
+
+from __future__ import annotations
+
+from typing import Protocol
+
+
+class Embedder(Protocol):
+    """Anything that maps a batch of texts to fixed-dimension vectors."""
+
+    #: Stable identity string persisted with the index (name@dim).
+    identity: str
+    dimension: int
+
+    def embed(self, texts: list[str]) -> list[list[float]]: ...
+
+
+def get_embedder(preference: str = "nomic") -> "Embedder":
+    """Return the configured embedder, falling back to hashing if the
+    semantic model stack is not installed."""
+    from sciogen.embed.hashing import HashingEmbedder
+
+    if preference == "hash":
+        return HashingEmbedder()
+    try:
+        import sentence_transformers  # noqa: F401
+    except ImportError:
+        return HashingEmbedder()
+    from sciogen.embed.nomic import NomicEmbedder
+
+    return NomicEmbedder()

sciogen/embed/hashing.py

@@ -0,0 +1,53 @@
+"""Deterministic feature-hashing embedder (fallback / test embedder).
+
+Hashes word unigrams and bigrams into a fixed-size vector, L2-normalized so
+cosine similarity behaves. Shares vocabulary-free robustness with the classic
+hashing trick: identical texts always produce identical vectors, similar
+keyword sets produce nearby vectors. No model download, no native deps,
+microseconds per text.
+"""
+
+from __future__ import annotations
+
+import hashlib
+import math
+import re
+
+_TOKEN_RE = re.compile(r"[A-Za-z_][A-Za-z0-9_]+|\d+")
+
+
+def _tokens(text: str) -> list[str]:
+    words = _TOKEN_RE.findall(text.lower())
+    # split snake_case / camelCase-ish compounds into subtokens too
+    out: list[str] = []
+    for w in words:
+        out.append(w)
+        if "_" in w:
+            out.extend(p for p in w.split("_") if p)
+    return out
+
+
+class HashingEmbedder:
+    identity: str
+    dimension: int
+
+    def __init__(self, dimension: int = 256) -> None:
+        self.dimension = dimension
+        self.identity = f"hashing@{dimension}"
+
+    def embed(self, texts: list[str]) -> list[list[float]]:
+        return [self._one(t) for t in texts]
+
+    def _one(self, text: str) -> list[float]:
+        vec = [0.0] * self.dimension
+        toks = _tokens(text)
+        grams = toks + [f"{a} {b}" for a, b in zip(toks, toks[1:])]
+        for gram in grams:
+            digest = hashlib.blake2b(gram.encode("utf-8"), digest_size=8).digest()
+            bucket = int.from_bytes(digest[:4], "little") % self.dimension
+            sign = 1.0 if digest[4] & 1 else -1.0
+            vec[bucket] += sign
+        norm = math.sqrt(sum(v * v for v in vec))
+        if norm > 0:
+            vec = [v / norm for v in vec]
+        return vec

sciogen/embed/nomic.py

@@ -0,0 +1,34 @@
+"""nomic-embed-code embedder (default when sentence-transformers is installed).
+
+Loads lazily on first use — importing sciogen never pays the model-load cost.
+The model runs fully locally; nothing leaves the machine.
+"""
+
+from __future__ import annotations
+
+_MODEL_NAME = "nomic-ai/nomic-embed-code"
+
+
+class NomicEmbedder:
+    identity: str
+    dimension: int
+
+    def __init__(self, model_name: str = _MODEL_NAME) -> None:
+        self._model_name = model_name
+        self._model = None
+        self.identity = f"{model_name}@pending"
+        self.dimension = 0
+
+    def _ensure_model(self):
+        if self._model is None:
+            from sentence_transformers import SentenceTransformer
+
+            self._model = SentenceTransformer(self._model_name, trust_remote_code=True)
+            self.dimension = int(self._model.get_sentence_embedding_dimension() or 0)
+            self.identity = f"{self._model_name}@{self.dimension}"
+        return self._model
+
+    def embed(self, texts: list[str]) -> list[list[float]]:
+        model = self._ensure_model()
+        vectors = model.encode(texts, normalize_embeddings=True, show_progress_bar=False)
+        return [v.tolist() for v in vectors]

sciogen/index/__init__.py

@@ -0,0 +1,5 @@
+"""Indexing pipeline (phase 1). See :mod:`sciogen.index.pipeline`."""
+
+from sciogen.index.pipeline import IndexStats, Pipeline, ProgressReporter
+
+__all__ = ["IndexStats", "Pipeline", "ProgressReporter"]