docsif 0.1.0__py3-none-any.whl

sif/cli/commands/bench.py

@@ -0,0 +1,148 @@
+"""Benchmark commands."""
+
+from __future__ import annotations
+
+import json
+from pathlib import Path
+
+import click
+from rich.console import Console
+from rich.table import Table
+
+from sif.config.settings import get_settings
+from sif.database.database import Database
+from sif.database.repositories import CollectionRepository
+from sif.embedding.manager import EmbeddingManager
+from sif.search.benchmark import SearchEvaluator
+from sif.search.hybrid import SearchPipeline
+from sif.utils.logging import get_logger
+
+
+logger = get_logger(__name__)
+console = Console()
+
+
+@click.command("bench")
+@click.argument("fixture", type=click.Path(exists=True, path_type=Path))
+@click.option("-n", "--limit", default=10, help="Number of results per query")
+@click.option("-C", "--candidate-limit", default=20, help="Reranker candidate pool size")
+@click.option("-c", "--collection", multiple=True, help="Collection to search")
+@click.option("--all", "search_all", is_flag=True, help="Search all collections")
+@click.option(
+    "--model-type",
+    type=click.Choice(["sentence_transformers", "gguf", "openai", "modelscope"]),
+    help="Embedding model type override",
+)
+@click.option("--json", "output_json", is_flag=True, help="Output as JSON")
+@click.pass_context
+def bench_cmd(  # noqa: C901, PLR0913, PLR0915
+    ctx: click.Context,
+    fixture: Path,
+    limit: int,
+    candidate_limit: int,
+    collection: tuple,
+    search_all: bool,
+    model_type: str | None,
+    output_json: bool,
+) -> None:
+    """Run benchmark evaluation against a fixture file.
+
+    Fixture format (JSON):
+        {
+            "queries": [
+                {
+                    "query": "search terms",
+                    "relevant_docids": ["doc-id-1", "doc-id-2"],
+                    "collections": ["optional-collection-filter"]
+                }
+            ]
+        }
+    """
+    index_path = ctx.obj["index_path"]
+
+    if not index_path.exists():
+        console.print("[yellow]No index found. Run 'sif update' first.[/yellow]")
+        return
+
+    # Load fixture
+    with open(fixture) as f:
+        fixture_data = json.load(f)
+
+    db = Database(index_path)
+    db.init_schema()
+
+    # Build search function
+    settings = get_settings()
+    if model_type:
+        settings = settings.model_copy(update={"model_type": model_type})
+
+    # Load embedder
+    manager = None
+    embedding_dim = 384
+    try:
+        manager = EmbeddingManager.from_settings(settings)
+        manager.load_model()
+        embedding_dim = len(manager.embed_single("probe"))
+    except ImportError as e:
+        console.print(f"[yellow]Embedding backend not installed: {e}[/yellow]")
+    except Exception as e:
+        console.print(f"[yellow]Failed to load embedding model: {e}[/yellow]")
+
+    def search_fn(query: str):
+        from sif.core.models import SearchOptions  # noqa: PLC0415
+
+        options = SearchOptions(
+            limit=limit,
+            candidate_limit=candidate_limit,
+            include_content=False,
+            include_highlights=False,
+        )
+
+        # Get collection IDs if specified
+        if collection:
+            with db.connection:
+                repo = CollectionRepository(db.connection)
+                options.collection_ids = []
+                for name in collection:
+                    coll = repo.get_by_name(name)
+                    if coll:
+                        options.collection_ids.append(coll.id)
+        elif not search_all:
+            with db.connection:
+                repo = CollectionRepository(db.connection)
+                enabled = repo.list_enabled()
+                options.collection_ids = [c.id for c in enabled]
+
+        with db.connection:
+            pipeline = SearchPipeline(
+                db.connection,
+                embedder=manager._model if manager else None,  # noqa: SLF001
+                embedding_dim=embedding_dim,
+            )
+            return pipeline.search(query, options)
+
+    # Run evaluation
+    evaluator = SearchEvaluator(fixture_data)
+    try:
+        metrics = evaluator.evaluate(search_fn)
+    except Exception as e:
+        raise click.ClickException(f"Benchmark failed: {e}") from e
+
+    # Output results
+    if output_json:
+        console.print(json.dumps(metrics, indent=2))
+    else:
+        table = Table(title=f"Benchmark Results: {fixture.name}")
+        table.add_column("Metric", style="cyan")
+        table.add_column("Value", style="green", justify="right")
+
+        for key in sorted(metrics.keys()):
+            value = metrics[key]
+            if key == "num_queries":
+                table.add_row("Queries", f"{int(value)}")
+            elif key == "mrr":
+                table.add_row("MRR", f"{value:.4f}")
+            else:
+                table.add_row(key, f"{value:.4f}")
+
+        console.print(table)

sif/cli/commands/collection.py

@@ -0,0 +1,360 @@
+"""Collection management commands."""
+
+from __future__ import annotations
+
+from pathlib import Path
+
+import click
+from rich.console import Console
+from rich.table import Table
+from rich.tree import Tree
+
+from sif.core.models import Collection
+from sif.database.database import Database
+from sif.database.repositories import CollectionRepository
+
+
+console = Console()
+
+
+@click.group("collection")
+def collection_group() -> None:
+    """Manage document collections."""
+    pass
+
+
+@collection_group.command("add")
+@click.argument("path", type=click.Path(exists=True, file_okay=False, dir_okay=True))
+@click.option("--name", "-n", required=True, help="Collection name")
+@click.option("--pattern", "-p", default="**/*.md", help="File pattern to match")
+@click.option("--ignore", "-i", multiple=True, help="Patterns to ignore")
+@click.option("--description", "-d", help="Collection description")
+@click.option("--no-default", is_flag=True, help="Don't include in default searches")
+@click.pass_context
+def collection_add(  # noqa: PLR0913
+    ctx: click.Context,
+    path: str,
+    name: str,
+    pattern: str,
+    ignore: tuple,
+    description: str | None,
+    no_default: bool,
+) -> None:
+    """Add a new collection."""
+    index_path = ctx.obj["index_path"]
+
+    db = Database(index_path)
+    db.init_schema()
+
+    with db.transaction() as conn:
+        repo = CollectionRepository(conn)
+
+        # Check if collection already exists
+        if repo.exists(name):
+            raise click.ClickException(f"Collection '{name}' already exists")
+
+        # Create collection
+        collection = Collection(
+            name=name,
+            path=str(Path(path).resolve()),
+            pattern=pattern,
+            ignore_patterns=list(ignore),
+            include_by_default=not no_default,
+            description=description,
+        )
+
+        repo.create(collection)
+
+    console.print(f"[green]Collection '{name}' added successfully[/green]")
+
+
+@collection_group.command("remove")
+@click.argument("name")
+@click.confirmation_option(prompt="Are you sure you want to remove this collection?")
+@click.pass_context
+def collection_remove(ctx: click.Context, name: str) -> None:
+    """Remove a collection."""
+    index_path = ctx.obj["index_path"]
+
+    db = Database(index_path)
+    db.init_schema()
+
+    with db.transaction() as conn:
+        repo = CollectionRepository(conn)
+
+        collection = repo.get_by_name(name)
+        if not collection:
+            raise click.ClickException(f"Collection '{name}' not found")
+
+        # Delete documents first (cascade will handle chunks)
+        from sif.database.repositories import DocumentRepository  # noqa: PLC0415
+
+        doc_repo = DocumentRepository(conn)
+        doc_repo.delete_by_collection(collection.id)
+
+        # Delete collection
+        repo.delete(collection.id)
+
+    console.print(f"[green]Collection '{name}' removed[/green]")
+
+
+@collection_group.command("rename")
+@click.argument("old_name")
+@click.argument("new_name")
+@click.pass_context
+def collection_rename(ctx: click.Context, old_name: str, new_name: str) -> None:
+    """Rename a collection."""
+    index_path = ctx.obj["index_path"]
+
+    db = Database(index_path)
+    db.init_schema()
+
+    with db.transaction() as conn:
+        repo = CollectionRepository(conn)
+
+        collection = repo.get_by_name(old_name)
+        if not collection:
+            raise click.ClickException(f"Collection '{old_name}' not found")
+
+        # Check if new name already exists
+        if repo.exists(new_name):
+            raise click.ClickException(f"Collection '{new_name}' already exists")
+
+        collection.name = new_name
+        repo.update(collection)
+
+    console.print(f"[green]Collection renamed from '{old_name}' to '{new_name}'[/green]")
+
+
+@collection_group.command("list")
+@click.option("--verbose", "-v", is_flag=True, help="Show detailed information")
+@click.pass_context
+def collection_list(ctx: click.Context, verbose: bool) -> None:
+    """List all collections."""
+    index_path = ctx.obj["index_path"]
+
+    if not index_path.exists():
+        console.print("[yellow]No index found.[/yellow]")
+        return
+
+    db = Database(index_path)
+    db.init_schema()
+
+    with db.connection:
+        repo = CollectionRepository(db.connection)
+        collections = repo.list_all()
+
+    if not collections:
+        console.print("[yellow]No collections found.[/yellow]")
+        return
+
+    if verbose:
+        for collection in collections:
+            console.print(f"\n[bold cyan]{collection.name}[/bold cyan]")
+            console.print(f"  Path: {collection.path}")
+            console.print(f"  Pattern: {collection.pattern}")
+            console.print(f"  Documents: {collection.document_count}")
+            console.print(f"  Chunks: {collection.chunk_count}")
+            if collection.description:
+                console.print(f"  Description: {collection.description}")
+    else:
+        table = Table(title="Collections")
+        table.add_column("Name", style="cyan")
+        table.add_column("Path", style="green")
+        table.add_column("Documents", style="yellow", justify="right")
+        table.add_column("Default", style="blue")
+
+        for collection in collections:
+            table.add_row(
+                collection.name,
+                collection.path,
+                str(collection.document_count),
+                "✓" if collection.include_by_default else "✗",
+            )
+
+        console.print(table)
+
+
+@collection_group.command("show")
+@click.argument("name")
+@click.pass_context
+def collection_show(ctx: click.Context, name: str) -> None:
+    """Show collection details."""
+    index_path = ctx.obj["index_path"]
+
+    db = Database(index_path)
+    db.init_schema()
+
+    with db.connection:
+        repo = CollectionRepository(db.connection)
+        collection = repo.get_by_name(name)
+
+        if not collection:
+            raise click.ClickException(f"Collection '{name}' not found")
+
+        console.print(f"[bold cyan]{collection.name}[/bold cyan]")
+        console.print(f"  ID: {collection.id}")
+        console.print(f"  Path: {collection.path}")
+        console.print(f"  Pattern: {collection.pattern}")
+        console.print(f"  Ignore Patterns: {', '.join(collection.ignore_patterns) or 'None'}")
+        console.print(f"  Include by Default: {'Yes' if collection.include_by_default else 'No'}")
+        console.print(f"  Documents: {collection.document_count}")
+        console.print(f"  Chunks: {collection.chunk_count}")
+        console.print(f"  Created: {collection.created_at}")
+        console.print(f"  Updated: {collection.updated_at}")
+        if collection.last_indexed_at:
+            console.print(f"  Last Indexed: {collection.last_indexed_at}")
+        if collection.description:
+            console.print(f"  Description: {collection.description}")
+
+
+@collection_group.command("enable")
+@click.argument("name")
+@click.pass_context
+def collection_enable(ctx: click.Context, name: str) -> None:
+    """Enable a collection for default searches."""
+    index_path = ctx.obj["index_path"]
+
+    db = Database(index_path)
+    db.init_schema()
+
+    with db.transaction() as conn:
+        repo = CollectionRepository(conn)
+        collection = repo.get_by_name(name)
+
+        if not collection:
+            raise click.ClickException(f"Collection '{name}' not found")
+
+        collection.include_by_default = True
+        repo.update(collection)
+
+    console.print(f"[green]Collection '{name}' enabled[/green]")
+
+
+@collection_group.command("disable")
+@click.argument("name")
+@click.pass_context
+def collection_disable(ctx: click.Context, name: str) -> None:
+    """Disable a collection from default searches."""
+    index_path = ctx.obj["index_path"]
+
+    db = Database(index_path)
+    db.init_schema()
+
+    with db.transaction() as conn:
+        repo = CollectionRepository(conn)
+        collection = repo.get_by_name(name)
+
+        if not collection:
+            raise click.ClickException(f"Collection '{name}' not found")
+
+        collection.include_by_default = False
+        repo.update(collection)
+
+    console.print(f"[green]Collection '{name}' disabled[/green]")
+
+
+@collection_group.command("update-cmd")
+@click.argument("name")
+@click.option("--cmd", "-c", help="Shell command to run before indexing")
+@click.option("--clear", is_flag=True, help="Clear the pre-update command")
+@click.pass_context
+def collection_update_cmd(ctx: click.Context, name: str, cmd: str | None, clear: bool) -> None:
+    """Set or clear a pre-index shell command for a collection."""
+    index_path = ctx.obj["index_path"]
+    db = Database(index_path)
+    db.init_schema()
+    with db.transaction() as conn:
+        repo = CollectionRepository(conn)
+        collection = repo.get_by_name(name)
+        if not collection:
+            raise click.ClickException(f"Collection '{name}' not found")
+        if clear:
+            collection.pre_update_cmd = None
+        elif cmd is not None:
+            collection.pre_update_cmd = cmd
+        else:
+            raise click.ClickException("Provide --cmd or --clear")
+        repo.update(collection)
+    if clear:
+        console.print(f"[green]Cleared pre-update command for '{name}'[/green]")
+    else:
+        console.print(f"[green]Set pre-update command for '{name}': {cmd}[/green]")
+
+
+@collection_group.command("include")
+@click.argument("name")
+@click.pass_context
+def collection_include(ctx: click.Context, name: str) -> None:
+    """Include a collection in default searches."""
+    index_path = ctx.obj["index_path"]
+    db = Database(index_path)
+    db.init_schema()
+    with db.transaction() as conn:
+        repo = CollectionRepository(conn)
+        collection = repo.get_by_name(name)
+        if not collection:
+            raise click.ClickException(f"Collection '{name}' not found")
+        collection.include_by_default = True
+        repo.update(collection)
+    console.print(f"[green]Collection '{name}' included in default searches[/green]")
+
+
+@collection_group.command("exclude")
+@click.argument("name")
+@click.pass_context
+def collection_exclude(ctx: click.Context, name: str) -> None:
+    """Exclude a collection from default searches."""
+    index_path = ctx.obj["index_path"]
+    db = Database(index_path)
+    db.init_schema()
+    with db.transaction() as conn:
+        repo = CollectionRepository(conn)
+        collection = repo.get_by_name(name)
+        if not collection:
+            raise click.ClickException(f"Collection '{name}' not found")
+        collection.include_by_default = False
+        repo.update(collection)
+    console.print(f"[green]Collection '{name}' excluded from default searches[/green]")
+
+
+@collection_group.command("ls")
+@click.argument("name")
+@click.argument("subpath", required=False)
+@click.pass_context
+def collection_ls(ctx: click.Context, name: str, subpath: str | None) -> None:  # noqa: ARG001
+    """List files in a collection."""
+    index_path = ctx.obj["index_path"]
+
+    db = Database(index_path)
+    db.init_schema()
+
+    with db.connection:
+        repo = CollectionRepository(db.connection)
+        collection = repo.get_by_name(name)
+
+        if not collection:
+            raise click.ClickException(f"Collection '{name}' not found")
+
+        # Scan files
+        from sif.indexing.scanner import FileScanner  # noqa: PLC0415
+
+        scanner = FileScanner()
+        scan_result = scanner.scan(
+            Path(collection.path),
+            pattern=collection.pattern,
+            ignore_patterns=collection.ignore_patterns,
+        )
+
+        if not scan_result.files:
+            console.print("[yellow]No files found in collection.[/yellow]")
+            return
+
+        # Build tree
+        tree = Tree(f"[bold cyan]{collection.name}[/bold cyan]")
+
+        for file_path in sorted(scan_result.files):
+            rel_path = file_path.relative_to(collection.path)
+            tree.add(str(rel_path))
+
+        console.print(tree)

sif/cli/commands/context.py

@@ -0,0 +1,154 @@
+"""Context management commands."""
+
+from __future__ import annotations
+
+import click
+from rich.console import Console
+from rich.table import Table
+
+from sif.core.models import PathContext
+from sif.database.database import Database
+from sif.database.repositories import CollectionRepository, ContextRepository
+
+
+console = Console()
+
+
+@click.group("context")
+def context_group() -> None:
+    """Manage contextual descriptions for paths, collections, and global scope."""
+    pass
+
+
+@context_group.command("add")
+@click.argument("type", type=click.Choice(["path", "collection", "global"]))
+@click.argument("target")
+@click.argument("content")
+@click.pass_context
+def context_add(
+    ctx: click.Context,
+    type: str,  # noqa: A002
+    target: str,
+    content: str,
+) -> None:
+    """Add context for a path, collection, or global scope."""
+    index_path = ctx.obj["index_path"]
+    db = Database(index_path)
+    db.init_schema()
+
+    with db.transaction() as conn:
+        repo = ContextRepository(conn)
+
+        # Resolve target based on type
+        actual_target = target
+        if type == "collection":
+            coll_repo = CollectionRepository(conn)
+            coll = coll_repo.get_by_name(target)
+            if not coll:
+                # Fallback: treat target as collection ID
+                coll = coll_repo.get_by_id(target)
+            if not coll:
+                raise click.ClickException(f"Collection '{target}' not found")
+            actual_target = coll.id
+        elif type == "global":
+            actual_target = "global"
+        # For path type, actual_target = target (the path string)
+
+        # Upsert: update if exists for this target+type, else create
+        existing = repo.get_by_target(actual_target, type)
+        if existing:
+            existing.context = content
+            repo.update(existing)
+            console.print(f"[green]Context updated for {type} '{target}'[/green]")
+        else:
+            path_context = PathContext(
+                path=actual_target,
+                context=content,
+                context_type=type,
+            )
+            repo.create(path_context)
+            console.print(f"[green]Context added for {type} '{target}'[/green]")
+
+
+@context_group.command("remove")
+@click.argument("context_id")
+@click.pass_context
+def context_remove(ctx: click.Context, context_id: str) -> None:
+    """Remove a context by its ID."""
+    index_path = ctx.obj["index_path"]
+    db = Database(index_path)
+    db.init_schema()
+
+    with db.transaction() as conn:
+        repo = ContextRepository(conn)
+        deleted = repo.delete(context_id)
+        if not deleted:
+            raise click.ClickException(f"No context found with ID '{context_id}'")
+
+    console.print(f"[green]Context '{context_id}' removed[/green]")
+
+
+@context_group.command("list")
+@click.option(
+    "--type",
+    "context_type",
+    type=click.Choice(["path", "collection", "global"]),
+    help="Filter by context type",
+)
+@click.pass_context
+def context_list(ctx: click.Context, context_type: str | None) -> None:
+    """List all contexts."""
+    index_path = ctx.obj["index_path"]
+
+    if not index_path.exists():
+        console.print("[yellow]No index found.[/yellow]")
+        return
+
+    db = Database(index_path)
+    db.init_schema()
+
+    with db.connection:
+        repo = ContextRepository(db.connection)
+        contexts = repo.list_by_type(context_type) if context_type else repo.list_all()
+
+    if not contexts:
+        console.print("[yellow]No contexts found.[/yellow]")
+        return
+
+    table = Table(title="Contexts")
+    table.add_column("Type", style="magenta")
+    table.add_column("Target", style="cyan")
+    table.add_column("Content", style="green")
+
+    for ctx_item in contexts:
+        # Truncate long contexts for display
+        content_text = ctx_item.context
+        if len(content_text) > 50:
+            content_text = content_text[:47] + "..."
+        table.add_row(ctx_item.context_type, ctx_item.path, content_text)
+
+    console.print(table)
+
+
+@context_group.command("prune")
+@click.pass_context
+def context_prune(ctx: click.Context) -> None:
+    """Remove orphaned path contexts (whose target paths no longer exist in the index)."""
+    index_path = ctx.obj["index_path"]
+
+    if not index_path.exists():
+        console.print("[yellow]No index found.[/yellow]")
+        return
+
+    db = Database(index_path)
+    db.init_schema()
+
+    with db.transaction() as conn:
+        repo = ContextRepository(conn)
+        count = repo.delete_orphaned_paths()
+
+    console.print(f"[green]Pruned {count} orphaned path context(s).[/green]")
+
+
+# Register 'rm' as an alias for 'remove'
+context_group.add_command(context_remove, name="rm")