lestash 0.1.0__py3-none-any.whl

lestash/__init__.py

@@ -0,0 +1,3 @@
+"""Le Stash - Personal knowledge base CLI."""
+
+__version__ = "0.1.0"

lestash/__main__.py

@@ -0,0 +1,6 @@
+"""Entry point for python -m lestash."""
+
+from lestash.cli.main import app
+
+if __name__ == "__main__":
+    app()

lestash/cli/__init__.py

@@ -0,0 +1 @@
+"""CLI module for Le Stash."""

lestash/cli/config.py

@@ -0,0 +1,85 @@
+"""Config commands for Le Stash CLI."""
+
+from typing import Annotated
+
+import typer
+from rich.console import Console
+
+from lestash.core.config import Config, get_config_path, init_config
+
+app = typer.Typer(help="Manage configuration.")
+console = Console()
+
+
+@app.command("show")
+def show_config() -> None:
+    """Show current configuration."""
+    config_path = get_config_path()
+
+    if not config_path.exists():
+        console.print(f"[dim]No config file at {config_path}[/dim]")
+        console.print("[dim]Run 'lestash config init' to create one.[/dim]")
+        return
+
+    config = Config.load()
+    console.print(f"[bold]Config file:[/bold] {config_path}")
+    console.print()
+
+    data = config.model_dump()
+    for section, values in data.items():
+        console.print(f"[bold][{section}][/bold]")
+        if isinstance(values, dict):
+            for key, value in values.items():
+                console.print(f"  {key} = {value}")
+        else:
+            console.print(f"  {values}")
+        console.print()
+
+
+@app.command("init")
+def init_config_cmd(
+    force: Annotated[bool, typer.Option("--force", "-f", help="Overwrite existing config")] = False,
+) -> None:
+    """Initialize configuration file with defaults."""
+    config_path = get_config_path()
+
+    if config_path.exists() and not force:
+        console.print(f"[yellow]Config already exists at {config_path}[/yellow]")
+        console.print("[dim]Use --force to overwrite.[/dim]")
+        raise typer.Exit(1)
+
+    init_config()
+    console.print(f"[green]Created config at {config_path}[/green]")
+
+
+@app.command("set")
+def set_config(
+    key: Annotated[str, typer.Argument(help="Config key (e.g., general.database_path)")],
+    value: Annotated[str, typer.Argument(help="Value to set")],
+) -> None:
+    """Set a configuration value."""
+    config = Config.load()
+
+    parts = key.split(".")
+    if len(parts) != 2:
+        console.print("[red]Key must be in format 'section.key'[/red]")
+        raise typer.Exit(1)
+
+    section, setting = parts
+
+    # Get current config as dict
+    data = config.model_dump()
+
+    if section not in data:
+        data[section] = {}
+
+    data[section][setting] = value
+
+    # Save updated config
+    try:
+        updated_config = Config(**data)
+        updated_config.save()
+        console.print(f"[green]Set {key} = {value}[/green]")
+    except Exception as e:
+        console.print(f"[red]Error: {e}[/red]")
+        raise typer.Exit(1) from None

lestash/cli/items.py

@@ -0,0 +1,191 @@
+"""Item commands for Le Stash CLI."""
+
+import json
+from typing import Annotated
+
+import typer
+from rich.console import Console
+from rich.table import Table
+
+from lestash.core.config import Config
+from lestash.core.database import get_connection
+from lestash.models.item import Item
+
+app = typer.Typer(help="Manage items in your knowledge base.")
+console = Console()
+
+
+@app.command("list")
+def list_items(
+    source: Annotated[
+        str | None, typer.Option("--source", "-s", help="Filter by source type")
+    ] = None,
+    own: Annotated[bool | None, typer.Option("--own", help="Show only your own content")] = None,
+    limit: Annotated[int, typer.Option("--limit", "-n", help="Limit results")] = 20,
+) -> None:
+    """List items in the knowledge base."""
+    config = Config.load()
+
+    with get_connection(config) as conn:
+        query = "SELECT * FROM items WHERE 1=1"
+        params: list = []
+
+        if source:
+            query += " AND source_type = ?"
+            params.append(source)
+
+        if own is not None:
+            query += " AND is_own_content = ?"
+            params.append(own)
+
+        query += " ORDER BY created_at DESC LIMIT ?"
+        params.append(limit)
+
+        cursor = conn.execute(query, params)
+        rows = cursor.fetchall()
+
+    if not rows:
+        console.print("[dim]No items found.[/dim]")
+        return
+
+    table = Table(show_header=True, header_style="bold")
+    table.add_column("ID", style="dim")
+    table.add_column("Source")
+    table.add_column("Title / Content Preview")
+    table.add_column("Author")
+    table.add_column("Created")
+
+    for row in rows:
+        item = Item.from_row(row)
+        preview = (
+            item.title or item.content[:50] + "..." if len(item.content) > 50 else item.content
+        )
+        created = item.created_at.strftime("%Y-%m-%d") if item.created_at else "-"
+        table.add_row(
+            str(item.id),
+            item.source_type,
+            preview,
+            item.author or "-",
+            created,
+        )
+
+    console.print(table)
+
+
+@app.command("search")
+def search_items(
+    query: Annotated[str, typer.Argument(help="Search query")],
+    limit: Annotated[int, typer.Option("--limit", "-n", help="Limit results")] = 20,
+) -> None:
+    """Search items using full-text search."""
+    config = Config.load()
+
+    with get_connection(config) as conn:
+        cursor = conn.execute(
+            """
+            SELECT items.* FROM items
+            JOIN items_fts ON items.id = items_fts.rowid
+            WHERE items_fts MATCH ?
+            ORDER BY rank
+            LIMIT ?
+            """,
+            (query, limit),
+        )
+        rows = cursor.fetchall()
+
+    if not rows:
+        console.print(f"[dim]No items found matching '{query}'.[/dim]")
+        return
+
+    table = Table(show_header=True, header_style="bold")
+    table.add_column("ID", style="dim")
+    table.add_column("Source")
+    table.add_column("Title / Content Preview")
+    table.add_column("Author")
+
+    for row in rows:
+        item = Item.from_row(row)
+        preview = (
+            item.title or item.content[:50] + "..." if len(item.content) > 50 else item.content
+        )
+        table.add_row(
+            str(item.id),
+            item.source_type,
+            preview,
+            item.author or "-",
+        )
+
+    console.print(table)
+
+
+@app.command("show")
+def show_item(
+    item_id: Annotated[int, typer.Argument(help="Item ID to show")],
+) -> None:
+    """Show details of a specific item."""
+    config = Config.load()
+
+    with get_connection(config) as conn:
+        cursor = conn.execute("SELECT * FROM items WHERE id = ?", (item_id,))
+        row = cursor.fetchone()
+
+    if not row:
+        console.print(f"[red]Item {item_id} not found.[/red]")
+        raise typer.Exit(1)
+
+    item = Item.from_row(row)
+
+    console.print(f"[bold]ID:[/bold] {item.id}")
+    console.print(f"[bold]Source:[/bold] {item.source_type}")
+    if item.source_id:
+        console.print(f"[bold]Source ID:[/bold] {item.source_id}")
+    if item.url:
+        console.print(f"[bold]URL:[/bold] {item.url}")
+    if item.title:
+        console.print(f"[bold]Title:[/bold] {item.title}")
+    console.print(f"[bold]Author:[/bold] {item.author or '-'}")
+    if item.created_at:
+        console.print(f"[bold]Created:[/bold] {item.created_at}")
+    console.print(f"[bold]Fetched:[/bold] {item.fetched_at}")
+    console.print(f"[bold]Own Content:[/bold] {item.is_own_content}")
+    console.print()
+    console.print("[bold]Content:[/bold]")
+    console.print(item.content)
+
+    if item.metadata:
+        console.print()
+        console.print("[bold]Metadata:[/bold]")
+        console.print(json.dumps(item.metadata, indent=2))
+
+
+@app.command("export")
+def export_items(
+    output: Annotated[
+        str, typer.Option("--output", "-o", help="Output file path")
+    ] = "lestash-export.json",
+    source: Annotated[
+        str | None, typer.Option("--source", "-s", help="Filter by source type")
+    ] = None,
+) -> None:
+    """Export items to JSON."""
+    config = Config.load()
+
+    with get_connection(config) as conn:
+        query = "SELECT * FROM items"
+        params: list = []
+
+        if source:
+            query += " WHERE source_type = ?"
+            params.append(source)
+
+        query += " ORDER BY created_at DESC"
+
+        cursor = conn.execute(query, params)
+        rows = cursor.fetchall()
+
+    items = [Item.from_row(row).model_dump(mode="json") for row in rows]
+
+    with open(output, "w") as f:
+        json.dump(items, f, indent=2, default=str)
+
+    console.print(f"[green]Exported {len(items)} items to {output}[/green]")

lestash/cli/main.py

@@ -0,0 +1,56 @@
+"""Main CLI for Le Stash."""
+
+import typer
+
+from lestash import __version__
+from lestash.cli import config, items, sources
+from lestash.core.database import init_database
+from lestash.core.logging import get_console, get_logger, setup_logging
+from lestash.plugins.loader import load_plugins
+
+app = typer.Typer(
+    name="lestash",
+    help="Le Stash - Personal knowledge base CLI.",
+    no_args_is_help=True,
+)
+console = get_console()
+logger = get_logger("cli.main")
+
+# Register core command groups
+app.add_typer(items.app, name="items")
+app.add_typer(sources.app, name="sources")
+app.add_typer(config.app, name="config")
+
+
+def register_plugin_commands() -> None:
+    """Discover and register plugin commands."""
+    plugins = load_plugins()
+    for name, plugin in plugins.items():
+        try:
+            plugin_app = plugin.get_commands()
+            app.add_typer(plugin_app, name=name)
+        except Exception as e:
+            logger.warning(f"Failed to register commands for '{name}': {e}")
+
+
+@app.callback()
+def main(
+    version: bool = typer.Option(False, "--version", "-v", help="Show version and exit."),
+) -> None:
+    """Le Stash - Personal knowledge base CLI."""
+    # Initialize logging first
+    setup_logging()
+
+    if version:
+        console.print(f"lestash {__version__}")
+        raise typer.Exit()
+
+    # Ensure database exists
+    init_database()
+
+
+# Register plugin commands at import time
+register_plugin_commands()
+
+if __name__ == "__main__":
+    app()

lestash/cli/sources.py

@@ -0,0 +1,222 @@
+"""Source commands for Le Stash CLI."""
+
+import json
+from datetime import datetime
+from typing import Annotated
+
+import typer
+from rich.console import Console
+from rich.table import Table
+
+from lestash.core.config import Config
+from lestash.core.database import get_connection
+from lestash.plugins.loader import load_plugins
+
+app = typer.Typer(help="Manage content sources.")
+console = Console()
+
+
+@app.command("list")
+def list_sources() -> None:
+    """List installed source plugins."""
+    plugins = load_plugins()
+
+    if not plugins:
+        console.print("[dim]No source plugins installed.[/dim]")
+        return
+
+    table = Table(show_header=True, header_style="bold")
+    table.add_column("Name")
+    table.add_column("Description")
+    table.add_column("Status")
+
+    config = Config.load()
+    with get_connection(config) as conn:
+        for name, plugin in plugins.items():
+            cursor = conn.execute(
+                "SELECT enabled, last_sync FROM sources WHERE source_type = ?",
+                (name,),
+            )
+            row = cursor.fetchone()
+
+            if row:
+                status = "enabled" if row["enabled"] else "disabled"
+                if row["last_sync"]:
+                    status += f" (last sync: {row['last_sync']})"
+            else:
+                status = "not configured"
+
+            table.add_row(name, plugin.description, status)
+
+    console.print(table)
+
+
+@app.command("sync")
+def sync_source(
+    source_name: Annotated[str | None, typer.Argument(help="Source to sync (omit for all)")] = None,
+    all_sources: Annotated[bool, typer.Option("--all", help="Sync all enabled sources")] = False,
+) -> None:
+    """Sync items from a source."""
+    plugins = load_plugins()
+
+    if not plugins:
+        console.print("[red]No source plugins installed.[/red]")
+        raise typer.Exit(1)
+
+    if source_name:
+        sources_to_sync = [source_name]
+    elif all_sources:
+        sources_to_sync = list(plugins.keys())
+    else:
+        console.print("[red]Specify a source name or use --all[/red]")
+        raise typer.Exit(1)
+
+    config = Config.load()
+
+    for name in sources_to_sync:
+        if name not in plugins:
+            console.print(f"[red]Unknown source: {name}[/red]")
+            continue
+
+        plugin = plugins[name]
+        plugin_config = config.get_plugin_config(name)
+
+        console.print(f"[bold]Syncing {name}...[/bold]")
+
+        with get_connection(config) as conn:
+            # Log sync start
+            started_at = datetime.now()
+            cursor = conn.execute(
+                "INSERT INTO sync_log (source_type, started_at, status) VALUES (?, ?, ?)",
+                (name, started_at, "running"),
+            )
+            sync_id = cursor.lastrowid
+            conn.commit()
+
+            items_added = 0
+            items_updated = 0
+            error_message = None
+
+            try:
+                for item in plugin.sync(plugin_config):
+                    # Try to insert, update on conflict
+                    metadata_json = json.dumps(item.metadata) if item.metadata else None
+                    cursor = conn.execute(
+                        """
+                        INSERT INTO items (
+                            source_type, source_id, url, title, content,
+                            author, created_at, is_own_content, metadata
+                        ) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?)
+                        ON CONFLICT(source_type, source_id) DO UPDATE SET
+                            url = excluded.url,
+                            title = excluded.title,
+                            content = excluded.content,
+                            author = excluded.author,
+                            is_own_content = excluded.is_own_content,
+                            metadata = excluded.metadata
+                        """,
+                        (
+                            item.source_type,
+                            item.source_id,
+                            item.url,
+                            item.title,
+                            item.content,
+                            item.author,
+                            item.created_at,
+                            item.is_own_content,
+                            metadata_json,
+                        ),
+                    )
+                    if cursor.rowcount > 0:
+                        items_added += 1
+
+                conn.commit()
+
+                # Update source last_sync
+                conn.execute(
+                    """
+                    INSERT INTO sources (source_type, last_sync)
+                    VALUES (?, ?)
+                    ON CONFLICT(source_type) DO UPDATE SET last_sync = excluded.last_sync
+                    """,
+                    (name, datetime.now()),
+                )
+                conn.commit()
+
+                status = "completed"
+            except Exception as e:
+                status = "failed"
+                error_message = str(e)
+                console.print(f"[red]Error syncing {name}: {e}[/red]")
+
+            # Update sync log
+            conn.execute(
+                """
+                UPDATE sync_log SET
+                    completed_at = ?,
+                    status = ?,
+                    items_added = ?,
+                    items_updated = ?,
+                    error_message = ?
+                WHERE id = ?
+                """,
+                (datetime.now(), status, items_added, items_updated, error_message, sync_id),
+            )
+            conn.commit()
+
+        if status == "completed":
+            console.print(f"[green]Synced {name}: {items_added} items added[/green]")
+
+
+@app.command("status")
+def source_status() -> None:
+    """Show sync status for all sources."""
+    config = Config.load()
+
+    with get_connection(config) as conn:
+        cursor = conn.execute(
+            """
+            SELECT source_type, started_at, completed_at, status,
+                   items_added, items_updated, error_message
+            FROM sync_log
+            ORDER BY started_at DESC
+            LIMIT 20
+            """
+        )
+        rows = cursor.fetchall()
+
+    if not rows:
+        console.print("[dim]No sync history.[/dim]")
+        return
+
+    table = Table(show_header=True, header_style="bold")
+    table.add_column("Source")
+    table.add_column("Started")
+    table.add_column("Status")
+    table.add_column("Items")
+    table.add_column("Error")
+
+    for row in rows:
+        started = row["started_at"][:16] if row["started_at"] else "-"
+        items = f"+{row['items_added']}" if row["items_added"] else "-"
+        error = (
+            row["error_message"][:30] + "..."
+            if row["error_message"] and len(row["error_message"]) > 30
+            else (row["error_message"] or "-")
+        )
+
+        status_style = {
+            "completed": "green",
+            "failed": "red",
+            "running": "yellow",
+        }.get(row["status"], "")
+
+        table.add_row(
+            row["source_type"],
+            started,
+            f"[{status_style}]{row['status']}[/{status_style}]" if status_style else row["status"],
+            items,
+            error,
+        )
+
+    console.print(table)

lestash/core/__init__.py

@@ -0,0 +1,10 @@
+"""Core module for Le Stash."""
+
+from lestash.core.logging import get_console, get_logger, get_plugin_logger, setup_logging
+
+__all__ = [
+    "get_console",
+    "get_logger",
+    "get_plugin_logger",
+    "setup_logging",
+]

lestash/core/config.py

@@ -0,0 +1,108 @@
+"""Configuration management for Le Stash."""
+
+from pathlib import Path
+from typing import Any, Literal
+
+import toml
+from pydantic import BaseModel
+
+
+def get_config_dir() -> Path:
+    """Get the configuration directory path."""
+    config_dir = Path.home() / ".config" / "lestash"
+    return config_dir
+
+
+def get_config_path() -> Path:
+    """Get the configuration file path."""
+    return get_config_dir() / "config.toml"
+
+
+def get_database_path() -> Path:
+    """Get the default database path."""
+    return get_config_dir() / "lestash.db"
+
+
+def get_log_path() -> Path:
+    """Get the default log file path."""
+    return get_config_dir() / "logs" / "lestash.log"
+
+
+class GeneralConfig(BaseModel):
+    """General configuration."""
+
+    database_path: str = ""
+
+    def model_post_init(self, __context: Any) -> None:
+        if not self.database_path:
+            self.database_path = str(get_database_path())
+
+
+class LoggingConfig(BaseModel):
+    """Logging configuration."""
+
+    # Global log level
+    level: Literal["DEBUG", "INFO", "WARNING", "ERROR", "CRITICAL"] = "INFO"
+
+    # Console settings (diagnostic output to stderr)
+    console_enabled: bool = True
+    console_level: Literal["DEBUG", "INFO", "WARNING", "ERROR", "CRITICAL"] = "INFO"
+    console_timestamps: bool = False
+
+    # File settings (persistent debug trail)
+    file_enabled: bool = True
+    file_level: Literal["DEBUG", "INFO", "WARNING", "ERROR", "CRITICAL"] = "DEBUG"
+    file_path: str = ""
+    max_bytes: int = 10 * 1024 * 1024  # 10MB
+    backup_count: int = 5
+    file_format: Literal["simple", "detailed", "json"] = "detailed"
+
+    # Database settings (optional, queryable history)
+    db_enabled: bool = False
+    db_level: Literal["DEBUG", "INFO", "WARNING", "ERROR", "CRITICAL"] = "INFO"
+
+    # Filter noisy third-party loggers
+    filters: dict[str, str] = {
+        "httpx": "WARNING",
+        "httpcore": "WARNING",
+        "urllib3": "WARNING",
+    }
+
+    def model_post_init(self, __context: Any) -> None:
+        if not self.file_path:
+            self.file_path = str(get_log_path())
+
+
+class Config(BaseModel):
+    """Application configuration."""
+
+    general: GeneralConfig = GeneralConfig()
+    logging: LoggingConfig = LoggingConfig()
+
+    @classmethod
+    def load(cls) -> "Config":
+        """Load configuration from file."""
+        config_path = get_config_path()
+        if config_path.exists():
+            data = toml.load(config_path)
+            return cls(**data)
+        return cls()
+
+    def save(self) -> None:
+        """Save configuration to file."""
+        config_path = get_config_path()
+        config_path.parent.mkdir(parents=True, exist_ok=True)
+        with open(config_path, "w") as f:
+            toml.dump(self.model_dump(), f)
+
+    def get_plugin_config(self, plugin_name: str) -> dict[str, Any]:
+        """Get configuration for a specific plugin."""
+        data = self.model_dump()
+        return data.get(plugin_name, {})
+
+
+def init_config() -> Config:
+    """Initialize configuration with defaults."""
+    config = Config()
+    config.save()
+    return config