docsif 0.1.0__py3-none-any.whl

sif/cli/config.py

@@ -0,0 +1,206 @@
+"""Configuration management for SIF CLI."""
+
+import json
+from dataclasses import asdict, dataclass, field
+from pathlib import Path
+from typing import Any, Optional
+
+
+@dataclass
+class CollectionConfig:
+    """Configuration for a document collection."""
+
+    name: str
+    path: str
+    mask: Optional[str] = None
+    enabled: bool = True
+
+
+@dataclass
+class ContextConfig:
+    """Configuration for a document context."""
+
+    path: str
+    context: str
+
+
+@dataclass
+class EmbedConfig:
+    """Configuration for embedding settings."""
+
+    chunk_strategy: str = "auto"  # auto, regex
+    chunk_size: int = 512
+    chunk_overlap: int = 50
+    model: str = "default"
+
+
+@dataclass
+class SearchConfig:
+    """Configuration for search settings."""
+
+    default_limit: int = 10
+    min_score: float = 0.0
+    hybrid_weight: float = 0.5
+
+
+@dataclass
+class Config:
+    """Main configuration class for SIF."""
+
+    # Paths
+    index_path: str = field(default_factory=lambda: str(Path.home() / ".sif" / "index.db"))
+    config_path: str = field(default_factory=lambda: str(Path.home() / ".sif" / "config.json"))
+
+    # Collections and contexts
+    collections: dict[str, CollectionConfig] = field(default_factory=dict)
+    contexts: dict[str, ContextConfig] = field(default_factory=dict)
+
+    # Settings
+    embed: EmbedConfig = field(default_factory=EmbedConfig)
+    search: SearchConfig = field(default_factory=SearchConfig)
+
+    # MCP settings
+    mcp_port: int = 8080
+    mcp_http: bool = False
+
+    def to_dict(self) -> dict[str, Any]:
+        """Convert config to dictionary."""
+        return {
+            "index_path": self.index_path,
+            "config_path": self.config_path,
+            "collections": {name: asdict(coll) for name, coll in self.collections.items()},
+            "contexts": {path: asdict(ctx) for path, ctx in self.contexts.items()},
+            "embed": asdict(self.embed),
+            "search": asdict(self.search),
+            "mcp_port": self.mcp_port,
+            "mcp_http": self.mcp_http,
+        }
+
+    @classmethod
+    def from_dict(cls, data: dict[str, Any]) -> "Config":
+        """Create config from dictionary."""
+        config = cls()
+
+        if "index_path" in data:
+            config.index_path = data["index_path"]
+        if "config_path" in data:
+            config.config_path = data["config_path"]
+
+        # Load collections
+        if "collections" in data:
+            config.collections = {
+                name: CollectionConfig(**coll_data)
+                for name, coll_data in data["collections"].items()
+            }
+
+        # Load contexts
+        if "contexts" in data:
+            config.contexts = {
+                path: ContextConfig(**ctx_data) for path, ctx_data in data["contexts"].items()
+            }
+
+        # Load embed config
+        if "embed" in data:
+            config.embed = EmbedConfig(**data["embed"])
+
+        # Load search config
+        if "search" in data:
+            config.search = SearchConfig(**data["search"])
+
+        # Load MCP settings
+        if "mcp_port" in data:
+            config.mcp_port = data["mcp_port"]
+        if "mcp_http" in data:
+            config.mcp_http = data["mcp_http"]
+
+        return config
+
+    def save(self, path: Optional[str] = None) -> None:
+        """Save configuration to file."""
+        save_path = Path(path or self.config_path)
+        save_path.parent.mkdir(parents=True, exist_ok=True)
+
+        with open(save_path, "w") as f:
+            json.dump(self.to_dict(), f, indent=2)
+
+    @classmethod
+    def load(cls, path: Optional[str] = None) -> "Config":
+        """Load configuration from file."""
+        config_path = Path(path or cls().config_path)
+
+        if not config_path.exists():
+            # Return default config
+            config = cls()
+            config.config_path = str(config_path)
+            return config
+
+        with open(config_path) as f:
+            data = json.load(f)
+
+        config = cls.from_dict(data)
+        config.config_path = str(config_path)
+        return config
+
+    def add_collection(self, name: str, path: str, mask: Optional[str] = None) -> None:
+        """Add a new collection."""
+        self.collections[name] = CollectionConfig(name=name, path=path, mask=mask)
+
+    def remove_collection(self, name: str) -> bool:
+        """Remove a collection. Returns True if removed."""
+        if name in self.collections:
+            del self.collections[name]
+            return True
+        return False
+
+    def rename_collection(self, old_name: str, new_name: str) -> bool:
+        """Rename a collection. Returns True if renamed."""
+        if old_name in self.collections and new_name not in self.collections:
+            coll = self.collections.pop(old_name)
+            coll.name = new_name
+            self.collections[new_name] = coll
+            return True
+        return False
+
+    def add_context(self, path: str, context: str) -> None:
+        """Add a context for a path."""
+        self.contexts[path] = ContextConfig(path=path, context=context)
+
+    def remove_context(self, path: str) -> bool:
+        """Remove a context. Returns True if removed."""
+        if path in self.contexts:
+            del self.contexts[path]
+            return True
+        return False
+
+    def get_collection(self, name: str) -> Optional[CollectionConfig]:
+        """Get a collection by name."""
+        return self.collections.get(name)
+
+    def get_context(self, path: str) -> Optional[ContextConfig]:
+        """Get a context by path."""
+        return self.contexts.get(path)
+
+
+# Global config instance
+_config: Optional[Config] = None
+
+
+def get_config() -> Config:
+    """Get the global configuration instance."""
+    global _config
+    if _config is None:
+        _config = Config.load()
+    return _config
+
+
+def set_config(config: Config) -> None:
+    """Set the global configuration instance."""
+    global _config
+    _config = config
+
+
+def reload_config(path: Optional[str] = None) -> Config:
+    """Reload configuration from file."""
+    global _config
+    _config = Config.load(path)
+    return _config

sif/cli/formatters.py

@@ -0,0 +1,269 @@
+"""Output formatters for SIF CLI."""
+
+import csv
+import io
+import json
+from dataclasses import asdict, is_dataclass
+from typing import Any, Optional
+
+from rich import box
+from rich.console import Console
+from rich.panel import Panel
+from rich.syntax import Syntax
+from rich.table import Table
+from rich.tree import Tree
+
+
+# Global console instance
+console = Console()
+
+
+def format_json(data: Any, indent: int = 2) -> str:
+    """Format data as JSON string."""
+
+    def serialize(obj: Any) -> Any:
+        if is_dataclass(obj):
+            return asdict(obj)
+        if hasattr(obj, "to_dict"):
+            return obj.to_dict()
+        if hasattr(obj, "__dict__"):
+            return obj.__dict__
+        return str(obj)
+
+    return json.dumps(data, indent=indent, default=serialize, ensure_ascii=False)
+
+
+def format_csv(data: list[dict[str, Any]]) -> str:
+    """Format list of dictionaries as CSV string."""
+    if not data:
+        return ""
+
+    output = io.StringIO()
+    writer = csv.DictWriter(output, fieldnames=data[0].keys())
+    writer.writeheader()
+    writer.writerows(data)
+    return output.getvalue()
+
+
+def format_markdown_table(data: list[dict[str, Any]], title: Optional[str] = None) -> str:
+    """Format list of dictionaries as Markdown table."""
+    if not data:
+        return ""
+
+    lines = []
+    if title:
+        lines.append(f"## {title}\n")
+
+    # Header
+    headers = list(data[0].keys())
+    lines.append("| " + " | ".join(headers) + " |")
+    lines.append("| " + " | ".join(["---"] * len(headers)) + " |")
+
+    # Rows
+    for row in data:
+        values = [str(row.get(h, "")) for h in headers]
+        lines.append("| " + " | ".join(values) + " |")
+
+    return "\n".join(lines)
+
+
+def format_xml(data: Any, root_tag: str = "root") -> str:
+    """Format data as XML string."""
+
+    def to_xml(obj: Any, tag: str) -> str:
+        if isinstance(obj, dict):
+            children = "\n".join(to_xml(v, k) for k, v in obj.items())
+            return f"<{tag}>\n{children}\n</{tag}>"
+        if isinstance(obj, list):
+            children = "\n".join(to_xml(item, "item") for item in obj)
+            return f"<{tag}>\n{children}\n</{tag}>"
+        return f"<{tag}>{obj}</{tag}>"
+
+    return f'<?xml version="1.0" encoding="UTF-8"?>\n{to_xml(data, root_tag)}'
+
+
+def format_files_list(paths: list[str]) -> str:
+    """Format list of file paths."""
+    return "\n".join(paths)
+
+
+def print_json(data: Any, console: Optional[Console] = None) -> None:
+    """Print data as formatted JSON."""
+    cons = console or Console()
+    json_str = format_json(data)
+    syntax = Syntax(json_str, "json", theme="monokai", line_numbers=False)
+    cons.print(syntax)
+
+
+def print_csv(data: list[dict[str, Any]], console: Optional[Console] = None) -> None:
+    """Print data as CSV."""
+    cons = console or Console()
+    cons.print(format_csv(data))
+
+
+def print_markdown(
+    data: list[dict[str, Any]], title: Optional[str] = None, console: Optional[Console] = None
+) -> None:
+    """Print data as Markdown table."""
+    cons = console or Console()
+    cons.print(format_markdown_table(data, title))
+
+
+def print_xml(data: Any, root_tag: str = "root", console: Optional[Console] = None) -> None:
+    """Print data as XML."""
+    cons = console or Console()
+    xml_str = format_xml(data, root_tag)
+    syntax = Syntax(xml_str, "xml", theme="monokai", line_numbers=False)
+    cons.print(syntax)
+
+
+def print_files(paths: list[str], console: Optional[Console] = None) -> None:
+    """Print list of files."""
+    cons = console or Console()
+    for path in paths:
+        cons.print(path)
+
+
+def print_table(
+    data: list[dict[str, Any]], title: Optional[str] = None, console: Optional[Console] = None
+) -> None:
+    """Print data as a rich table."""
+    cons = console or Console()
+
+    if not data:
+        cons.print("[yellow]No data to display[/yellow]")
+        return
+
+    table = Table(title=title, box=box.ROUNDED)
+
+    # Add columns
+    for key in data[0].keys():
+        table.add_column(str(key), overflow="fold")
+
+    # Add rows
+    for row in data:
+        values = [str(row.get(k, "")) for k in data[0].keys()]
+        table.add_row(*values)
+
+    cons.print(table)
+
+
+def print_success(message: str, console: Optional[Console] = None) -> None:
+    """Print a success message."""
+    cons = console or Console()
+    cons.print(f"[green]✓[/green] {message}")
+
+
+def print_error(message: str, console: Optional[Console] = None) -> None:
+    """Print an error message."""
+    cons = console or Console()
+    cons.print(f"[red]✗[/red] {message}")
+
+
+def print_warning(message: str, console: Optional[Console] = None) -> None:
+    """Print a warning message."""
+    cons = console or Console()
+    cons.print(f"[yellow]⚠[/yellow] {message}")
+
+
+def print_info(message: str, console: Optional[Console] = None) -> None:
+    """Print an info message."""
+    cons = console or Console()
+    cons.print(f"[blue]ℹ[/blue] {message}")
+
+
+def print_panel(
+    content: str,
+    title: Optional[str] = None,
+    border_style: str = "blue",
+    console: Optional[Console] = None,
+) -> None:
+    """Print content in a panel."""
+    cons = console or Console()
+    panel = Panel(content, title=title, border_style=border_style)
+    cons.print(panel)
+
+
+def print_tree(
+    data: dict[str, Any], title: str = "Tree", console: Optional[Console] = None
+) -> None:
+    """Print data as a tree structure."""
+    cons = console or Console()
+    tree = Tree(f"[bold]{title}[/bold]")
+
+    def add_branch(node: Tree, obj: Any) -> None:
+        if isinstance(obj, dict):
+            for key, value in obj.items():
+                branch = node.add(f"[cyan]{key}[/cyan]")
+                add_branch(branch, value)
+        elif isinstance(obj, list):
+            for i, item in enumerate(obj):
+                branch = node.add(f"[dim][{i}][/dim]")
+                add_branch(branch, item)
+        else:
+            node.add(str(obj))
+
+    add_branch(tree, data)
+    cons.print(tree)
+
+
+def prepend_line_numbers(content: str) -> str:
+    """Prepend line numbers to each line of content."""
+    return "\n".join(f"{i + 1:4d}: {line}" for i, line in enumerate(content.split("\n")))
+
+
+def add_line_numbers_to_results(
+    results: list[dict[str, Any]], content_key: str = "content"
+) -> list[dict[str, Any]]:
+    """Add a 'line_numbers' field to each result dict based on content."""
+    formatted = []
+    for item in results:
+        row = dict(item)
+        content = row.get(content_key, "")
+        if content:
+            row["line_numbers"] = "\n".join(f"{i + 1}" for i in range(len(content.split("\n"))))
+        else:
+            row["line_numbers"] = ""
+        formatted.append(row)
+    return formatted
+
+
+class OutputFormatter:
+    """Handles output formatting based on format option."""
+
+    FORMATS = ["table", "json", "csv", "md", "xml", "files"]
+
+    def __init__(self, format_type: str = "table", console: Optional[Console] = None):
+        self.format_type = format_type
+        self.console = console or Console()
+
+    def print(self, data: Any, title: Optional[str] = None) -> None:  # noqa: PLR0912
+        """Print data in the specified format."""
+        if self.format_type == "json":
+            print_json(data, self.console)
+        elif self.format_type == "csv":
+            if isinstance(data, list) and data and isinstance(data[0], dict):
+                print_csv(data, self.console)
+            else:
+                print_json(data, self.console)
+        elif self.format_type == "md":
+            if isinstance(data, list) and data and isinstance(data[0], dict):
+                print_markdown(data, title, self.console)
+            else:
+                print_json(data, self.console)
+        elif self.format_type == "xml":
+            print_xml(data, title or "root", self.console)
+        elif self.format_type == "files":
+            if isinstance(data, list):
+                print_files(data, self.console)
+            else:
+                print_json(data, self.console)
+        elif isinstance(data, list) and data and isinstance(data[0], dict):
+            print_table(data, title, self.console)
+        else:
+            print_json(data, self.console)
+
+
+def get_formatter(format_type: str = "table", console: Optional[Console] = None) -> OutputFormatter:
+    """Get an output formatter instance."""
+    return OutputFormatter(format_type, console)

sif/cli/main.py

@@ -0,0 +1,205 @@
+#!/usr/bin/env python3
+"""SIF CLI - Main entry point."""
+
+from __future__ import annotations
+
+from pathlib import Path
+
+import click
+from rich.console import Console
+from rich.table import Table
+
+from sif import __version__
+from sif.config.settings import get_settings
+from sif.database.database import Database
+from sif.utils.logging import get_logger, setup_logging
+
+
+logger = get_logger(__name__)
+console = Console()
+
+# Default paths
+DEFAULT_INDEX_PATH = Path.home() / ".local" / "share" / "sif" / "sif.db"
+DEFAULT_CONFIG_PATH = Path.home() / ".config" / "sif"
+
+
+def _get_default_db_path() -> str:
+    """Get default database path from Settings."""
+    return str(get_settings().get_db_path())
+
+
+@click.group()
+@click.version_option(version=__version__, prog_name="sif")
+@click.option(
+    "--index",
+    "-i",
+    type=click.Path(),
+    default=_get_default_db_path,
+    help="Path to the index database",
+)
+@click.option(
+    "--config",
+    "-c",
+    type=click.Path(),
+    default=str(DEFAULT_CONFIG_PATH),
+    help="Path to the configuration file",
+)
+@click.option("--verbose", "-v", is_flag=True, help="Enable verbose output")
+@click.option("--quiet", "-q", is_flag=True, help="Suppress non-error output")
+@click.pass_context
+def cli(ctx: click.Context, index: str, config: str, verbose: bool, quiet: bool) -> None:
+    """SIF - Search / Index / Find - Local document search engine.
+
+    SIF indexes your documents and enables fast, intelligent search
+    using BM25, vector similarity, and hybrid approaches.
+    """
+    # Setup logging
+    log_level = "DEBUG" if verbose else ("WARNING" if quiet else "INFO")
+    setup_logging(log_level)
+
+    # Ensure context object exists
+    ctx.ensure_object(dict)
+
+    # Store options in context
+    ctx.obj["index_path"] = Path(index).expanduser()
+    ctx.obj["config_path"] = Path(config).expanduser()
+    ctx.obj["verbose"] = verbose
+    ctx.obj["quiet"] = quiet
+
+    # Create index directory if needed
+    ctx.obj["index_path"].parent.mkdir(parents=True, exist_ok=True)
+
+
+# Import and register subcommands
+from sif.cli.commands.bench import bench_cmd
+from sif.cli.commands.collection import collection_group
+from sif.cli.commands.context import context_group
+from sif.cli.commands.get import get_group
+from sif.cli.commands.index import index_group
+from sif.cli.commands.ls import ls_cmd
+from sif.cli.commands.mcp import mcp_group
+from sif.cli.commands.pull import pull_cmd
+from sif.cli.commands.search import search_group
+
+
+cli.add_command(collection_group)
+cli.add_command(context_group)
+cli.add_command(index_group)
+cli.add_command(search_group)
+cli.add_command(get_group)
+cli.add_command(mcp_group)
+cli.add_command(ls_cmd)
+cli.add_command(pull_cmd)
+cli.add_command(bench_cmd)
+
+
+@cli.command("status")
+@click.pass_context
+def status_cmd(ctx: click.Context) -> None:
+    """Show index status."""
+    ctx.ensure_object(dict)
+    index_path = ctx.obj.get("index_path")
+    if index_path is None:
+        index_path = get_settings().get_db_path()
+
+    if not index_path.exists():
+        console.print("[yellow]No index found. Run 'sif update' to create one.[/yellow]")
+        return
+
+    try:
+        db = Database(index_path)
+        db.init_schema()
+        stats = db.get_stats()
+
+        table = Table(title="Index Status")
+        table.add_column("Metric", style="cyan")
+        table.add_column("Value", style="green")
+
+        table.add_row("Index Path", str(index_path))
+        table.add_row("Collections", str(stats.get("collections", 0)))
+        table.add_row("Documents", str(stats.get("documents", 0)))
+        table.add_row("Chunks", str(stats.get("chunks", 0)))
+        table.add_row("Contexts", str(stats.get("contexts", 0)))
+
+        total_size = stats.get("total_size_bytes", 0)
+        if total_size > 0:
+            size_mb = total_size / (1024 * 1024)
+            table.add_row("Total Size", f"{size_mb:.2f} MB")
+
+        console.print(table)
+
+    except Exception as e:
+        console.print(f"[red]Error reading index: {e}[/red]")
+        raise click.ClickException(str(e)) from e
+
+
+@cli.command("cleanup")
+@click.confirmation_option(prompt="Are you sure you want to clean up the index?")
+@click.pass_context
+def cleanup_cmd(ctx: click.Context) -> None:
+    """Clean up the index (remove orphaned entries)."""
+    index_path = ctx.obj["index_path"]
+
+    if not index_path.exists():
+        console.print("[yellow]No index found.[/yellow]")
+        return
+
+    try:
+        db = Database(index_path)
+        db.init_schema()
+
+        with db.transaction() as conn:
+            # Clean up orphaned chunks
+            cursor = conn.execute("""
+                DELETE FROM document_chunks
+                WHERE document_id NOT IN (SELECT id FROM documents)
+            """)
+            chunks_removed = cursor.rowcount
+
+            # Clean up orphaned embeddings
+            try:
+                cursor = conn.execute("""
+                    DELETE FROM document_embeddings
+                    WHERE document_id NOT IN (SELECT id FROM documents)
+                """)
+                embeddings_removed = cursor.rowcount
+            except sqlite3.OperationalError:  # noqa: F821
+                embeddings_removed = 0
+
+            # Clean up expired LLM cache
+            from datetime import datetime, timezone  # noqa: PLC0415
+
+            cursor = conn.execute(
+                """
+                DELETE FROM llm_cache
+                WHERE expires_at IS NOT NULL AND expires_at <= ?
+            """,
+                (datetime.now(timezone.utc).isoformat(),),
+            )
+            cache_removed = cursor.rowcount
+
+        console.print("[green]Cleanup complete:[/green]")
+        console.print(f"  - Removed {chunks_removed} orphaned chunks")
+        console.print(f"  - Removed {embeddings_removed} orphaned embeddings")
+        console.print(f"  - Removed {cache_removed} expired cache entries")
+
+    except Exception as e:
+        console.print(f"[red]Error during cleanup: {e}[/red]")
+        raise click.ClickException(str(e)) from e
+
+
+def main() -> None:
+    """Main entry point."""
+    # Migrate old docsift model cache if present
+    old_model_dir = Path.home() / ".local" / "share" / "docsift" / "models"
+    new_model_dir = Path.home() / ".local" / "share" / "sif" / "models"
+    if old_model_dir.exists() and not new_model_dir.exists():
+        new_model_dir.parent.mkdir(parents=True, exist_ok=True)
+        old_model_dir.rename(new_model_dir)
+        console.print("[green]Migrated: ~/.local/share/docsift -> ~/.local/share/sif[/green]")
+
+    cli()
+
+
+if __name__ == "__main__":
+    main()