remdb 0.3.242__py3-none-any.whl

rem/cli/dreaming.py

@@ -0,0 +1,363 @@
+"""
+REM Dreaming CLI - Memory indexing and insight extraction.
+
+Command-line interface for running dreaming workers to build the
+REM knowledge graph through user model updates, moment construction,
+and resource affinity operations.
+
+Commands:
+- user-model: Update user profiles from activity
+- moments: Extract temporal narratives from resources
+- affinity: Build semantic relationships between resources
+- custom: Run custom extractors on user's resources/sessions
+- full: Run complete dreaming workflow (all operations)
+
+Usage Examples:
+```bash
+# Update user model for specific user
+rem-dreaming user-model --user-id=user-123
+
+# Extract moments with custom lookback
+rem-dreaming moments --user-id=user-123 --lookback-hours=48
+
+# Build resource affinity (semantic mode, fast)
+rem-dreaming affinity --user-id=user-123
+
+# Build resource affinity (LLM mode, intelligent but expensive)
+rem-dreaming affinity --user-id=user-123 --use-llm --limit=100
+
+# Run custom extractor on user's data
+rem-dreaming custom --user-id=user-123 --extractor cv-parser-v1
+rem-dreaming custom --user-id=user-123 --extractor contract-analyzer-v1 --lookback-hours=168
+
+# Run full workflow for user
+rem-dreaming full --user-id=user-123
+
+# Process all active users (daily cron)
+rem-dreaming full --all-users
+
+# Process with custom REM API endpoint
+rem-dreaming full --user-id=user-123 --rem-api-url=http://localhost:8000
+```
+
+Environment Variables:
+- REM_API_URL: REM API endpoint (default: http://rem-api:8000)
+- REM_EMBEDDING_PROVIDER: Embedding provider (default: text-embedding-3-small)
+- REM_DEFAULT_MODEL: LLM model (default: gpt-4.1)
+- REM_LOOKBACK_HOURS: Default lookback window (default: 24)
+- OPENAI_API_KEY: OpenAI API key
+
+Exit Codes:
+- 0: Success
+- 1: Validation error (missing required args)
+- 2: Execution error (worker failed)
+"""
+
+import asyncio
+import os
+import sys
+from typing import Optional
+
+import typer
+from rich.console import Console
+from rich.progress import Progress, SpinnerColumn, TextColumn
+
+from rem.workers.dreaming import (
+    AffinityMode,
+    DreamingWorker,
+    TaskType,
+)
+
+app = typer.Typer(
+    name="rem-dreaming",
+    help="REM dreaming worker for memory indexing",
+    add_completion=False,
+)
+console = Console()
+
+
+def get_worker() -> DreamingWorker:
+    """Create dreaming worker from environment."""
+    return DreamingWorker(
+        rem_api_url=os.getenv("REM_API_URL", "http://rem-api:8000"),
+        embedding_provider=os.getenv(
+            "REM_EMBEDDING_PROVIDER", "text-embedding-3-small"
+        ),
+        default_model=os.getenv("REM_DEFAULT_MODEL", "gpt-4.1"),
+        lookback_hours=int(os.getenv("REM_LOOKBACK_HOURS", "24")),
+    )
+
+
+@app.command()
+def user_model(
+    user_id: str = typer.Option(..., help="User ID to process"),
+    max_sessions: int = typer.Option(100, help="Max sessions to analyze"),
+    max_moments: int = typer.Option(20, help="Max moments to include"),
+    max_resources: int = typer.Option(20, help="Max resources to include"),
+):
+    """
+    Update user model from recent activity.
+
+    Reads recent sessions, moments, and resources to generate
+    a comprehensive user profile summary using LLM analysis.
+    """
+
+    async def run():
+        worker = get_worker()
+        try:
+            with Progress(
+                SpinnerColumn(),
+                TextColumn("[progress.description]{task.description}"),
+                console=console,
+            ) as progress:
+                task = progress.add_task(
+                    f"Updating user model for {user_id}...", total=None
+                )
+
+                result = await worker.update_user_model(
+                    user_id=user_id,
+                    max_sessions=max_sessions,
+                    max_moments=max_moments,
+                    max_resources=max_resources,
+                )
+
+                progress.update(task, completed=True)
+                console.print(f"[green]✓[/green] User model updated")
+                console.print(result)
+        except Exception as e:
+            console.print(f"[red]✗[/red] Failed: {e}", style="red")
+            sys.exit(2)
+        finally:
+            await worker.close()
+
+    asyncio.run(run())
+
+
+@app.command()
+def moments(
+    user_id: str = typer.Option(..., help="User ID to process"),
+    lookback_hours: Optional[int] = typer.Option(
+        None, help="Hours to look back (default: from env)"
+    ),
+    limit: Optional[int] = typer.Option(None, help="Max resources to process"),
+):
+    """
+    Extract moments from resources.
+
+    Analyzes recent resources to identify temporal narratives
+    (meetings, coding sessions, conversations) and creates
+    Moment entities with temporal boundaries and metadata.
+    """
+
+    async def run():
+        worker = get_worker()
+        try:
+            with Progress(
+                SpinnerColumn(),
+                TextColumn("[progress.description]{task.description}"),
+                console=console,
+            ) as progress:
+                task = progress.add_task(
+                    f"Constructing moments for {user_id}...", total=None
+                )
+
+                result = await worker.construct_moments(
+                    user_id=user_id,
+                    lookback_hours=lookback_hours,
+                    limit=limit,
+                )
+
+                progress.update(task, completed=True)
+                console.print(f"[green]✓[/green] Moments constructed")
+                console.print(result)
+        except Exception as e:
+            console.print(f"[red]✗[/red] Failed: {e}", style="red")
+            sys.exit(2)
+        finally:
+            await worker.close()
+
+    asyncio.run(run())
+
+
+@app.command()
+def affinity(
+    user_id: str = typer.Option(..., help="User ID to process"),
+    use_llm: bool = typer.Option(
+        False, "--use-llm", help="Use LLM mode (expensive, use --limit)"
+    ),
+    lookback_hours: Optional[int] = typer.Option(
+        None, help="Hours to look back (default: from env)"
+    ),
+    limit: Optional[int] = typer.Option(
+        None, help="Max resources to process (REQUIRED for LLM mode)"
+    ),
+):
+    """
+    Build resource affinity graph.
+
+    Creates semantic relationships between resources using either
+    vector similarity (fast, default) or LLM analysis (intelligent but expensive).
+
+    Semantic Mode (default):
+    - Fast vector similarity search
+    - No LLM calls, just embedding cosine similarity
+    - Good for frequent updates
+
+    LLM Mode (--use-llm):
+    - Intelligent relationship assessment
+    - Expensive: ALWAYS use --limit to control costs
+    - Good for deep analysis (weekly or monthly)
+
+    Example:
+        # Semantic mode (fast, cheap)
+        rem-dreaming affinity --user-id=user-123
+
+        # LLM mode (intelligent, expensive)
+        rem-dreaming affinity --user-id=user-123 --use-llm --limit=100
+    """
+    if use_llm and not limit:
+        console.print(
+            "[red]Error:[/red] --limit is REQUIRED when using --use-llm to control costs",
+            style="red",
+        )
+        sys.exit(1)
+
+    async def run():
+        worker = get_worker()
+        try:
+            mode = AffinityMode.LLM if use_llm else AffinityMode.SEMANTIC
+            mode_str = "LLM" if use_llm else "semantic"
+
+            with Progress(
+                SpinnerColumn(),
+                TextColumn("[progress.description]{task.description}"),
+                console=console,
+            ) as progress:
+                task = progress.add_task(
+                    f"Building {mode_str} affinity for {user_id}...", total=None
+                )
+
+                result = await worker.build_affinity(
+                    user_id=user_id,
+                    mode=mode,
+                    lookback_hours=lookback_hours,
+                    limit=limit,
+                )
+
+                progress.update(task, completed=True)
+                console.print(f"[green]✓[/green] Resource affinity built ({mode_str} mode)")
+                console.print(result)
+        except Exception as e:
+            console.print(f"[red]✗[/red] Failed: {e}", style="red")
+            sys.exit(2)
+        finally:
+            await worker.close()
+
+    asyncio.run(run())
+
+
+@app.command()
+def full(
+    user_id: Optional[str] = typer.Option(None, help="User ID (or --all-users)"),
+    all_users: bool = typer.Option(
+        False, "--all-users", help="Process all active users"
+    ),
+    use_llm_affinity: bool = typer.Option(
+        False, "--use-llm-affinity", help="Use LLM mode for affinity (expensive)"
+    ),
+    lookback_hours: Optional[int] = typer.Option(
+        None, help="Hours to look back (default: from env)"
+    ),
+):
+    """
+    Run complete dreaming workflow.
+
+    Executes all dreaming operations in sequence:
+    1. Update user model
+    2. Construct moments
+    3. Build resource affinity
+
+    Recommended for daily cron execution.
+
+    Examples:
+        # Process single user
+        rem-dreaming full --user-id=user-123
+
+        # Process all active users (daily cron)
+        rem-dreaming full --all-users
+
+        # Use LLM affinity mode (expensive)
+        rem-dreaming full --user-id=user-123 --use-llm-affinity
+    """
+    if not user_id and not all_users:
+        console.print(
+            "[red]Error:[/red] Either --user-id or --all-users is required",
+            style="red",
+        )
+        sys.exit(1)
+
+    if user_id and all_users:
+        console.print(
+            "[red]Error:[/red] Cannot use both --user-id and --all-users",
+            style="red",
+        )
+        sys.exit(1)
+
+    async def run():
+        worker = get_worker()
+        try:
+            if all_users:
+                with Progress(
+                    SpinnerColumn(),
+                    TextColumn("[progress.description]{task.description}"),
+                    console=console,
+                ) as progress:
+                    task = progress.add_task("Processing all users...", total=None)
+
+                    results = await worker.process_all_users(
+                        task_type=TaskType.FULL,
+                        use_llm_affinity=use_llm_affinity,
+                        lookback_hours=lookback_hours,
+                    )
+
+                    progress.update(task, completed=True)
+                    console.print(
+                        f"[green]✓[/green] Processed {len(results)} users"
+                    )
+                    for result in results:
+                        console.print(result)
+            else:
+                with Progress(
+                    SpinnerColumn(),
+                    TextColumn("[progress.description]{task.description}"),
+                    console=console,
+                ) as progress:
+                    task = progress.add_task(
+                        f"Running full workflow for {user_id}...", total=None
+                    )
+
+                    result = await worker.process_full(
+                        user_id=user_id,
+                        use_llm_affinity=use_llm_affinity,
+                        lookback_hours=lookback_hours,
+                    )
+
+                    progress.update(task, completed=True)
+                    console.print(f"[green]✓[/green] Full workflow completed")
+                    console.print(result)
+        except Exception as e:
+            console.print(f"[red]✗[/red] Failed: {e}", style="red")
+            sys.exit(2)
+        finally:
+            await worker.close()
+
+    asyncio.run(run())
+
+
+def main():
+    """Entry point."""
+    app()
+
+
+if __name__ == "__main__":
+    main()

rem/cli/main.py

@@ -0,0 +1,123 @@
+"""
+REM CLI entry point.
+
+Usage:
+    rem db schema generate --models src/rem/models/entities
+    rem db schema validate
+    rem db migrate up
+    rem dev run-server
+"""
+
+import sys
+from pathlib import Path
+
+import click
+from loguru import logger
+
+# Import version from package
+try:
+    from importlib.metadata import version
+    __version__ = version("remdb")
+except Exception:
+    __version__ = "unknown"
+
+
+def _configure_logger(level: str):
+    """Configure loguru with custom level icons."""
+    logger.remove()
+
+    # Configure level icons - only warnings and errors get visual indicators
+    logger.level("DEBUG", icon=" ")
+    logger.level("INFO", icon=" ")
+    logger.level("WARNING", icon="🟠")
+    logger.level("ERROR", icon="🔴")
+    logger.level("CRITICAL", icon="🔴")
+
+    logger.add(
+        sys.stderr,
+        level=level,
+        format="<green>{time:HH:mm:ss}</green> | {level.icon} <level>{level: <8}</level> | <level>{message}</level>",
+    )
+
+
+@click.group()
+@click.option("--verbose", "-v", is_flag=True, help="Enable verbose logging")
+@click.version_option(version=__version__, prog_name="rem")
+def cli(verbose: bool):
+    """REM - Resources Entities Moments system CLI."""
+    _configure_logger("DEBUG" if verbose else "INFO")
+
+
+@cli.group()
+def db():
+    """Database operations (schema, migrate, status, etc.)."""
+    pass
+
+
+@db.group()
+def schema():
+    """Database schema management commands."""
+    pass
+
+
+@cli.group()
+def dev():
+    """Development utilities."""
+    pass
+
+
+@cli.group()
+def process():
+    """File processing commands."""
+    pass
+
+
+@cli.group()
+def dreaming():
+    """Memory indexing and knowledge extraction."""
+    pass
+
+
+@cli.group()
+def cluster():
+    """Kubernetes cluster deployment and management."""
+    pass
+
+
+# Register commands
+from .commands.schema import register_commands as register_schema_commands
+from .commands.db import register_commands as register_db_commands
+from .commands.process import register_commands as register_process_commands
+from .commands.ask import register_command as register_ask_command
+from .commands.dreaming import register_commands as register_dreaming_commands
+from .commands.experiments import experiments as experiments_group
+from .commands.configure import register_command as register_configure_command
+from .commands.serve import register_command as register_serve_command
+from .commands.mcp import register_command as register_mcp_command
+from .commands.scaffold import scaffold as scaffold_command
+from .commands.cluster import register_commands as register_cluster_commands
+from .commands.session import register_command as register_session_command
+from .commands.query import register_command as register_query_command
+
+register_schema_commands(schema)
+register_db_commands(db)
+register_process_commands(process)
+register_dreaming_commands(dreaming)
+register_cluster_commands(cluster)
+register_ask_command(cli)
+register_configure_command(cli)
+register_serve_command(cli)
+register_mcp_command(cli)
+register_query_command(cli)
+cli.add_command(experiments_group)
+cli.add_command(scaffold_command)
+register_session_command(cli)
+
+
+def main():
+    """Main entry point for CLI."""
+    cli()
+
+
+if __name__ == "__main__":
+    main()