oghma 0.0.1__py3-none-any.whl → 0.3.0__py3-none-any.whl

oghma/__init__.py

@@ -1,3 +1 @@
-"""Oghma — Unified AI memory layer."""
-
-__version__ = "0.0.1"
+__version__ = "0.3.0"

oghma/cli.py

@@ -0,0 +1,342 @@
+import os
+import signal
+import time
+from pathlib import Path
+
+import click
+from rich.console import Console
+from rich.table import Table
+
+from oghma import __version__
+from oghma.config import (
+    create_default_config,
+    get_config_path,
+    load_config,
+    validate_config,
+)
+from oghma.daemon import Daemon, get_daemon_pid
+from oghma.embedder import EmbedConfig, create_embedder
+from oghma.exporter import Exporter, ExportOptions
+from oghma.migration import EmbeddingMigration
+from oghma.storage import Storage
+
+console = Console()
+
+
+@click.group()
+@click.version_option(version=__version__, prog_name="oghma")
+def cli() -> None:
+    pass
+
+
+@cli.command()
+def init() -> None:
+    config_path = get_config_path()
+
+    if config_path.exists():
+        console.print(f"[yellow]Config already exists at {config_path}[/yellow]")
+        if not click.confirm("Overwrite existing config?"):
+            console.print("[green]Init cancelled[/green]")
+            return
+
+    console.print("[blue]Creating Oghma configuration...[/blue]")
+    config = create_default_config()
+    console.print(f"[green]Config created at {config_path}[/green]")
+    console.print(f"[cyan]Database path: {config['storage']['db_path']}[/cyan]")
+    console.print("\n[yellow]Run 'oghma status' to verify setup[/yellow]")
+
+
+@cli.command()
+def status() -> None:
+    try:
+        config_path = get_config_path()
+        config = load_config()
+        db_path = config["storage"]["db_path"]
+        pid_file = config["daemon"]["pid_file"]
+
+        table = Table(title="Oghma Status", show_header=True, header_style="bold magenta")
+        table.add_column("Property", style="cyan")
+        table.add_column("Value", style="green")
+
+        table.add_row("Config Path", str(config_path))
+
+        pid = get_daemon_pid(pid_file)
+        if pid:
+            table.add_row("Daemon Status", f"[green]Running (PID: {pid})[/green]")
+        else:
+            table.add_row("Daemon Status", "[red]Stopped[/red]")
+
+        table.add_row("Database Path", db_path)
+
+        if Path(db_path).exists():
+            storage = Storage(db_path, config)
+            memory_count = storage.get_memory_count()
+            table.add_row("Memory Count", str(memory_count))
+
+            logs = storage.get_recent_extraction_logs(limit=1)
+            if logs:
+                last_extraction = logs[0]["created_at"]
+                table.add_row("Last Extraction", last_extraction)
+            else:
+                table.add_row("Last Extraction", "Never")
+
+            table.add_row("Database Status", "[green]Exists[/green]")
+
+            from oghma.watcher import Watcher
+
+            watcher = Watcher(config, storage)
+            watched_files = watcher.discover_files()
+            table.add_row("Watched Files", str(len(watched_files)))
+        else:
+            table.add_row("Memory Count", "0")
+            table.add_row("Last Extraction", "Never")
+            table.add_row("Database Status", "[yellow]Not created yet[/yellow]")
+            table.add_row("Watched Files", "0")
+
+        console.print(table)
+
+        errors = validate_config(config)
+        if errors:
+            console.print("\n[red]Configuration errors:[/red]")
+            for error in errors:
+                console.print(f"  [red]- {error}[/red]")
+
+    except FileNotFoundError:
+        console.print("[red]Config not found. Run 'oghma init' first.[/red]")
+    except Exception as e:
+        console.print(f"[red]Error: {e}[/red]")
+
+
+@cli.command()
+@click.option("--foreground", "-f", is_flag=True, help="Run in foreground (don't daemonize)")
+def start(foreground: bool) -> None:
+    try:
+        config = load_config()
+        pid_file = config["daemon"]["pid_file"]
+
+        pid = get_daemon_pid(pid_file)
+        if pid:
+            console.print(f"[red]Daemon already running (PID: {pid})[/red]")
+            console.print("Use 'oghma stop' to stop it first.")
+            raise SystemExit(1)
+
+        console.print("[blue]Starting Oghma daemon...[/blue]")
+
+        if not foreground:
+            try:
+                pid = os.fork()
+                if pid > 0:
+                    console.print(f"[green]Daemon started in background (PID: {pid})[/green]")
+                    return
+            except OSError as e:
+                console.print(f"[yellow]Fork failed: {e}. Running in foreground.[/yellow]")
+
+        daemon = Daemon(config)
+        daemon.start()
+
+    except FileNotFoundError:
+        console.print("[red]Config not found. Run 'oghma init' first.[/red]")
+        raise SystemExit(1) from None
+    except Exception as e:
+        console.print(f"[red]Error starting daemon: {e}[/red]")
+        raise SystemExit(1) from None
+
+
+@cli.command()
+def stop() -> None:
+    try:
+        config = load_config()
+        pid_file = config["daemon"]["pid_file"]
+
+        pid = get_daemon_pid(pid_file)
+        if not pid:
+            console.print("[yellow]Daemon is not running[/yellow]")
+            return
+
+        console.print(f"[blue]Stopping daemon (PID: {pid})...[/blue]")
+
+        try:
+            os.kill(pid, signal.SIGTERM)
+        except ProcessLookupError:
+            console.print("[yellow]Daemon process not found. Cleaning up PID file.[/yellow]")
+            Path(pid_file).unlink(missing_ok=True)
+            return
+
+        for _ in range(10):
+            time.sleep(0.5)
+            if not get_daemon_pid(pid_file):
+                console.print("[green]Daemon stopped successfully[/green]")
+                return
+
+        console.print("[yellow]Daemon did not stop gracefully. Sending SIGKILL...[/yellow]")
+        try:
+            os.kill(pid, signal.SIGKILL)
+        except ProcessLookupError:
+            pass
+
+        Path(pid_file).unlink(missing_ok=True)
+        console.print("[green]Daemon force stopped[/green]")
+
+    except FileNotFoundError:
+        console.print("[red]Config not found. Run 'oghma init' first.[/red]")
+        raise SystemExit(1) from None
+    except Exception as e:
+        console.print(f"[red]Error stopping daemon: {e}[/red]")
+        raise SystemExit(1) from None
+
+
+@cli.command()
+@click.argument("query")
+@click.option("--limit", "-n", default=10, help="Max results")
+@click.option("--category", "-c", help="Filter by category")
+@click.option(
+    "--mode",
+    type=click.Choice(["keyword", "vector", "hybrid"]),
+    default="keyword",
+    show_default=True,
+    help="Search strategy",
+)
+def search(query: str, limit: int, category: str | None, mode: str) -> None:
+    try:
+        config = load_config()
+        storage = Storage(config=config)
+        query_embedding: list[float] | None = None
+
+        if mode in {"vector", "hybrid"}:
+            embed_config = config.get("embedding", {})
+            embedder = create_embedder(EmbedConfig.from_dict(embed_config))
+            query_embedding = embedder.embed(query)
+
+        results = storage.search_memories_hybrid(
+            query=query,
+            query_embedding=query_embedding,
+            limit=limit,
+            category=category,
+            search_mode=mode,
+        )
+
+        if not results:
+            console.print(f"[yellow]No memories found matching: {query}[/yellow]")
+            return
+
+        console.print(f"[cyan]Found {len(results)} memories matching: {query}[/cyan]\n")
+
+        for idx, memory in enumerate(results, 1):
+            table = Table(show_header=False, box=None, padding=(0, 0))
+            table.add_column("", style="cyan")
+            table.add_column("")
+
+            table.add_row(f"[bold]#{idx}[/bold]", f"[dim]{memory['created_at']}[/dim]")
+            table.add_row("Category", f"[green]{memory['category']}[/green]")
+            table.add_row("Source", f"{memory['source_tool']} ({Path(memory['source_file']).name})")
+            table.add_row("Confidence", f"{memory['confidence']:.0%}")
+            table.add_row("Content", memory["content"])
+
+            console.print(table)
+            console.print()
+
+    except FileNotFoundError:
+        console.print("[red]Config not found. Run 'oghma init' first.[/red]")
+        raise SystemExit(1) from None
+    except Exception as e:
+        console.print(f"[red]Error searching memories: {e}[/red]")
+        raise SystemExit(1) from None
+
+
+@cli.command("migrate-embeddings")
+@click.option("--batch-size", default=100, show_default=True, help="Batch size")
+@click.option("--dry-run", is_flag=True, help="Preview migration without writing embeddings")
+def migrate_embeddings(batch_size: int, dry_run: bool) -> None:
+    try:
+        config = load_config()
+        storage = Storage(config=config)
+
+        done_before, total = storage.get_embedding_progress()
+        console.print(
+            f"[blue]Embedding progress before migration:[/blue] {done_before}/{total} memories"
+        )
+
+        if done_before == total and total > 0:
+            console.print("[green]All active memories already have embeddings.[/green]")
+            return
+
+        embed_config = config.get("embedding", {})
+        embedder = create_embedder(EmbedConfig.from_dict(embed_config, batch_size=batch_size))
+
+        migration = EmbeddingMigration(
+            storage=storage,
+            embedder=embedder,
+            batch_size=batch_size,
+        )
+        result = migration.run(dry_run=dry_run)
+
+        done_after, total_after = storage.get_embedding_progress()
+        if dry_run:
+            console.print(
+                f"[yellow]Dry run complete.[/yellow] "
+                f"Would process {result.processed} memories."
+            )
+            return
+
+        console.print(
+            "[green]Migration complete.[/green] "
+            f"Processed={result.processed}, migrated={result.migrated}, "
+            f"failed={result.failed}, skipped={result.skipped}"
+        )
+        console.print(
+            f"[cyan]Embedding progress after migration:[/cyan] {done_after}/{total_after} memories"
+        )
+    except FileNotFoundError:
+        console.print("[red]Config not found. Run 'oghma init' first.[/red]")
+        raise SystemExit(1) from None
+    except Exception as e:
+        console.print(f"[red]Error migrating embeddings: {e}[/red]")
+        raise SystemExit(1) from None
+
+
+@cli.command()
+@click.option("--output", "-o", type=click.Path(), help="Output directory")
+@click.option("--format", "-f", type=click.Choice(["markdown", "json"]), default="markdown")
+@click.option(
+    "--group-by", "-g", type=click.Choice(["category", "date", "source"]), default="category"
+)
+@click.option("--category", "-c", help="Export only this category")
+def export(output: str | None, format: str, group_by: str, category: str | None) -> None:
+    """Export memories to files."""
+    try:
+        config = load_config()
+        storage = Storage(config=config)
+
+        output_dir = Path(output or config["export"]["output_dir"])
+
+        options = ExportOptions(output_dir=output_dir, format=format, group_by=group_by)
+        exporter = Exporter(storage, options)
+
+        if category:
+            console.print(f"[blue]Exporting memories for category: {category}[/blue]")
+            file_path = exporter.export_category(category)
+            console.print(f"[green]Exported to: {file_path}[/green]")
+        else:
+            console.print(f"[blue]Exporting memories (grouped by {group_by})...[/blue]")
+            files = exporter.export()
+
+            if not files:
+                console.print("[yellow]No memories found to export[/yellow]")
+                return
+
+            for file_path in files:
+                console.print(f"[green]Exported to: {file_path}[/green]")
+
+    except ValueError as e:
+        console.print(f"[red]Error: {e}[/red]")
+        raise SystemExit(1) from None
+    except FileNotFoundError:
+        console.print("[red]Config not found. Run 'oghma init' first.[/red]")
+        raise SystemExit(1) from None
+    except Exception as e:
+        console.print(f"[red]Error exporting memories: {e}[/red]")
+        raise SystemExit(1) from None
+
+
+def main() -> None:
+    cli()

oghma/config.py

@@ -0,0 +1,262 @@
+import os
+from pathlib import Path
+from typing import TypedDict
+
+import yaml
+
+
+class StorageConfig(TypedDict):
+    db_path: str
+    backup_enabled: bool
+    backup_dir: str
+    backup_retention_days: int
+
+
+class DaemonConfig(TypedDict):
+    poll_interval: int
+    log_level: str
+    log_file: str
+    pid_file: str
+    min_messages: int
+
+
+class ExtractionConfig(TypedDict):
+    model: str
+    max_content_chars: int
+    categories: list[str]
+    confidence_threshold: float
+
+
+class ExportConfig(TypedDict):
+    output_dir: str
+    format: str
+
+
+class EmbeddingConfig(TypedDict):
+    provider: str
+    model: str
+    dimensions: int
+    batch_size: int
+    rate_limit_delay: float
+    max_retries: int
+
+
+class ToolConfig(TypedDict, total=False):
+    enabled: bool
+    paths: list[str]
+
+
+class ToolsConfig(TypedDict, total=False):
+    claude_code: ToolConfig
+    codex: ToolConfig
+    openclaw: ToolConfig
+    opencode: ToolConfig
+    cursor: ToolConfig
+
+
+class Config(TypedDict):
+    storage: StorageConfig
+    daemon: DaemonConfig
+    extraction: ExtractionConfig
+    embedding: EmbeddingConfig
+    export: ExportConfig
+    tools: ToolsConfig
+
+
+DEFAULT_CONFIG: Config = {
+    "storage": {
+        "db_path": "~/.oghma/oghma.db",
+        "backup_enabled": True,
+        "backup_dir": "~/.oghma/backups",
+        "backup_retention_days": 30,
+    },
+    "daemon": {
+        "poll_interval": 300,
+        "log_level": "INFO",
+        "log_file": "~/.oghma/oghma.log",
+        "pid_file": "~/.oghma/oghma.pid",
+        "min_messages": 6,
+    },
+    "extraction": {
+        "model": "gpt-4o-mini",
+        "max_content_chars": 4000,
+        "categories": ["learning", "preference", "project_context", "gotcha", "workflow"],
+        "confidence_threshold": 0.5,
+    },
+    "embedding": {
+        "provider": "openai",
+        "model": "text-embedding-3-small",
+        "dimensions": 1536,
+        "batch_size": 100,
+        "rate_limit_delay": 0.1,
+        "max_retries": 3,
+    },
+    "export": {
+        "output_dir": "~/.oghma/export",
+        "format": "markdown",
+    },
+    "tools": {
+        "claude_code": {"enabled": True, "paths": ["~/.claude/projects/-Users-*/*.jsonl"]},
+        "codex": {"enabled": True, "paths": ["~/.codex/sessions/**/rollout-*.jsonl"]},
+        "openclaw": {"enabled": True, "paths": ["~/.openclaw/agents/*/sessions/*.jsonl"]},
+        "opencode": {"enabled": True, "paths": ["~/.local/share/opencode/storage/message/ses_*"]},
+        "cursor": {"enabled": False, "paths": []},
+    },
+}
+
+
+def expand_path(path: str) -> str:
+    return str(Path(path).expanduser())
+
+
+def get_config_path() -> Path:
+    return Path.home() / ".oghma" / "config.yaml"
+
+
+def load_config() -> Config:
+    config_path = get_config_path()
+
+    if not config_path.exists():
+        return create_default_config()
+
+    with open(config_path) as f:
+        loaded = yaml.safe_load(f)
+
+    if not loaded:
+        return create_default_config()
+
+    from typing import cast
+
+    merged = _merge_defaults(cast(dict, DEFAULT_CONFIG), loaded)
+    merged = _apply_env_overrides(merged)
+    _expand_paths_inplace(merged)
+
+    return merged
+
+
+def create_default_config() -> Config:
+    from typing import cast
+
+    config_path = get_config_path()
+    config_path.parent.mkdir(parents=True, exist_ok=True)
+
+    config = _apply_env_overrides(cast(Config, DEFAULT_CONFIG.copy()))
+    _expand_paths_inplace(config)
+
+    with open(config_path, "w") as f:
+        yaml.dump(DEFAULT_CONFIG, f, default_flow_style=False)
+
+    return config
+
+
+def _merge_defaults(defaults: dict, loaded: dict) -> Config:
+    from typing import cast
+
+    merged = defaults.copy()
+    for key, value in loaded.items():
+        if key in merged and isinstance(merged[key], dict) and isinstance(value, dict):
+            merged[key] = {**merged[key], **value}
+        else:
+            merged[key] = value
+    return cast(Config, merged)
+
+
+def _apply_env_overrides(config: Config) -> Config:
+    overrides = {
+        "OGHMA_DB_PATH": ("storage", "db_path"),
+        "OGHMA_BACKUP_DIR": ("storage", "backup_dir"),
+        "OGHMA_POLL_INTERVAL": ("daemon", "poll_interval"),
+        "OGHMA_LOG_LEVEL": ("daemon", "log_level"),
+        "OGHMA_LOG_FILE": ("daemon", "log_file"),
+        "OGHMA_PID_FILE": ("daemon", "pid_file"),
+        "OGHMA_EXPORT_DIR": ("export", "output_dir"),
+        "OGHMA_EXPORT_FORMAT": ("export", "format"),
+        "OGHMA_EXTRACTION_MODEL": ("extraction", "model"),
+        "OGHMA_EMBEDDING_PROVIDER": ("embedding", "provider"),
+        "OGHMA_EMBEDDING_MODEL": ("embedding", "model"),
+        "OGHMA_EMBEDDING_DIMENSIONS": ("embedding", "dimensions"),
+    }
+
+    for env_var, (section, key) in overrides.items():
+        value = os.environ.get(env_var)
+        if value is not None:
+            if key in [
+                "poll_interval",
+                "backup_retention_days",
+                "dimensions",
+                "batch_size",
+                "max_retries",
+            ]:
+                config[section][key] = int(value)
+            elif key in ["backup_enabled"]:
+                config[section][key] = value.lower() in ("true", "1", "yes")
+            elif key in ["confidence_threshold", "rate_limit_delay"]:
+                config[section][key] = float(value)
+            else:
+                config[section][key] = value
+
+    return config
+
+
+def _expand_paths_inplace(config: Config) -> None:
+    path_keys = [
+        ("storage", "db_path"),
+        ("storage", "backup_dir"),
+        ("daemon", "log_file"),
+        ("daemon", "pid_file"),
+        ("export", "output_dir"),
+    ]
+
+    for section, key in path_keys:
+        if section in config and key in config[section]:
+            config[section][key] = expand_path(config[section][key])
+
+
+def validate_config(config: Config) -> list[str]:
+    errors: list[str] = []
+
+    required_sections = ["storage", "daemon", "extraction", "embedding", "export"]
+    for section in required_sections:
+        if section not in config:
+            errors.append(f"Missing required section: {section}")
+
+    if "storage" in config:
+        storage = config["storage"]
+        if "db_path" not in storage or not storage["db_path"]:
+            errors.append("storage.db_path is required")
+
+    if "daemon" in config:
+        daemon = config["daemon"]
+        if "poll_interval" not in daemon or daemon["poll_interval"] <= 0:
+            errors.append("daemon.poll_interval must be positive")
+        if "log_level" not in daemon or daemon["log_level"] not in [
+            "DEBUG",
+            "INFO",
+            "WARNING",
+            "ERROR",
+        ]:
+            errors.append("daemon.log_level must be DEBUG, INFO, WARNING, or ERROR")
+
+    if "extraction" in config:
+        extraction = config["extraction"]
+        if "model" not in extraction or not extraction["model"]:
+            errors.append("extraction.model is required")
+        if "categories" not in extraction or not extraction["categories"]:
+            errors.append("extraction.categories must not be empty")
+
+    if "embedding" in config:
+        embedding = config["embedding"]
+        if "provider" not in embedding or not embedding["provider"]:
+            errors.append("embedding.provider is required")
+        if "model" not in embedding or not embedding["model"]:
+            errors.append("embedding.model is required")
+        if "dimensions" not in embedding or embedding["dimensions"] <= 0:
+            errors.append("embedding.dimensions must be positive")
+
+    return errors
+
+
+def get_db_path(config: Config | None = None) -> str:
+    if config is None:
+        config = load_config()
+    return config["storage"]["db_path"]