remdb 0.2.6__py3-none-any.whl → 0.3.103__py3-none-any.whl

rem/cli/commands/ask.py

@@ -89,8 +89,8 @@ async def run_agent_streaming(
         context: Optional AgentContext for session persistence
         max_iterations: Maximum iterations/requests (from agent schema or settings)
     """
-    from datetime import datetime, timezone
     from pydantic_ai import UsageLimits
+    from rem.utils.date_utils import to_iso_with_z, utc_now
 
     logger.info("Running agent in streaming mode...")
 
@@ -151,13 +151,13 @@ async def run_agent_streaming(
             user_message = {
                 "role": "user",
                 "content": user_message_content,
-                "timestamp": datetime.now(timezone.utc).isoformat(),
+                "timestamp": to_iso_with_z(utc_now()),
             }
 
             assistant_message = {
                 "role": "assistant",
                 "content": "".join(assistant_response_parts),
-                "timestamp": datetime.now(timezone.utc).isoformat(),
+                "timestamp": to_iso_with_z(utc_now()),
             }
 
             # Store messages with compression
@@ -200,8 +200,8 @@ async def run_agent_non_streaming(
     Returns:
         Output data if successful, None otherwise
     """
-    from datetime import datetime, timezone
     from pydantic_ai import UsageLimits
+    from rem.utils.date_utils import to_iso_with_z, utc_now
 
     logger.info("Running agent in non-streaming mode...")
 
@@ -248,13 +248,13 @@ async def run_agent_non_streaming(
             user_message = {
                 "role": "user",
                 "content": user_message_content,
-                "timestamp": datetime.now(timezone.utc).isoformat(),
+                "timestamp": to_iso_with_z(utc_now()),
             }
 
             assistant_message = {
                 "role": "assistant",
                 "content": assistant_content,
-                "timestamp": datetime.now(timezone.utc).isoformat(),
+                "timestamp": to_iso_with_z(utc_now()),
             }
 
             # Store messages with compression
@@ -357,8 +357,8 @@ async def _save_output_file(file_path: Path, data: dict[str, Any]) -> None:
 )
 @click.option(
     "--user-id",
-    default="test-user",
-    help="User ID for context (default: test-user)",
+    default=None,
+    help="User ID for context (default: from settings.test.effective_user_id)",
 )
 @click.option(
     "--session-id",
@@ -393,7 +393,7 @@ def ask(
     max_turns: int,
     version: str | None,
     stream: bool,
-    user_id: str,
+    user_id: str | None,
     session_id: str | None,
     input_file: Path | None,
     output_file: Path | None,
@@ -434,6 +434,9 @@ def ask(
         # Two arguments provided
         name = name_or_query
 
+    # Resolve user_id from settings if not provided
+    effective_user_id = user_id or settings.test.effective_user_id
+
     asyncio.run(
         _ask_async(
             name=name,
@@ -443,7 +446,7 @@ def ask(
             max_turns=max_turns,
             version=version,
             stream=stream,
-            user_id=user_id,
+            user_id=effective_user_id,
             session_id=session_id,
             input_file=input_file,
             output_file=output_file,
@@ -486,9 +489,10 @@ async def _ask_async(
 
     # Load schema using centralized utility
     # Handles both file paths and schema names automatically
+    # Falls back to database LOOKUP if not found in filesystem
     logger.info(f"Loading schema: {name} (version: {version or 'latest'})")
     try:
-        schema = load_agent_schema(name)
+        schema = load_agent_schema(name, user_id=user_id)
     except FileNotFoundError as e:
         logger.error(str(e))
         sys.exit(1)

rem/cli/commands/configure.py

@@ -28,10 +28,13 @@ from rem.config import (
 )
 
 
-def prompt_postgres_config() -> dict:
+def prompt_postgres_config(use_defaults: bool = False) -> dict:
     """
     Prompt user for PostgreSQL configuration.
 
+    Args:
+        use_defaults: If True, use all default values without prompting
+
     Returns:
         PostgreSQL configuration dictionary
     """
@@ -44,28 +47,45 @@ def prompt_postgres_config() -> dict:
         "POSTGRES__CONNECTION_STRING", "postgresql://rem:rem@localhost:5051/rem"
     )
 
-    # Prompt for components
-    click.echo(
-        "\nEnter PostgreSQL connection details (press Enter to use default):"
-    )
-    click.echo("Default: Package users on port 5051 (docker compose -f docker-compose.prebuilt.yml up -d)")
-    click.echo("Developers: Change port to 5050 if using docker-compose.yml (local build)")
-    click.echo("Custom DB: Enter your own host/port below")
+    # Default values
+    host = "localhost"
+    port = 5051
+    database = "rem"
+    username = "rem"
+    password = "rem"
+    pool_min_size = 5
+    pool_max_size = 20
+
+    if use_defaults:
+        click.echo("\nUsing default PostgreSQL configuration:")
+        click.echo(f"  Host: {host}")
+        click.echo(f"  Port: {port}")
+        click.echo(f"  Database: {database}")
+        click.echo(f"  Username: {username}")
+        click.echo(f"  Pool: {pool_min_size}-{pool_max_size} connections")
+    else:
+        # Prompt for components
+        click.echo(
+            "\nEnter PostgreSQL connection details (press Enter to use default):"
+        )
+        click.echo("Default: Package users on port 5051 (docker compose -f docker-compose.prebuilt.yml up -d)")
+        click.echo("Developers: Change port to 5050 if using docker-compose.yml (local build)")
+        click.echo("Custom DB: Enter your own host/port below")
 
-    host = click.prompt("Host", default="localhost")
-    port = click.prompt("Port", default=5051, type=int)
-    database = click.prompt("Database name", default="rem")
-    username = click.prompt("Username", default="rem")
-    password = click.prompt("Password", default="rem", hide_input=True)
+        host = click.prompt("Host", default=host)
+        port = click.prompt("Port", default=port, type=int)
+        database = click.prompt("Database name", default=database)
+        username = click.prompt("Username", default=username)
+        password = click.prompt("Password", default=password, hide_input=True)
+
+        # Additional pool settings
+        click.echo("\nConnection pool settings:")
+        pool_min_size = click.prompt("Pool minimum size", default=pool_min_size, type=int)
+        pool_max_size = click.prompt("Pool maximum size", default=pool_max_size, type=int)
 
     # Build connection string
     connection_string = f"postgresql://{username}:{password}@{host}:{port}/{database}"
 
-    # Additional pool settings
-    click.echo("\nConnection pool settings:")
-    pool_min_size = click.prompt("Pool minimum size", default=5, type=int)
-    pool_max_size = click.prompt("Pool maximum size", default=20, type=int)
-
     return {
         "connection_string": connection_string,
         "pool_min_size": pool_min_size,
@@ -73,10 +93,13 @@ def prompt_postgres_config() -> dict:
     }
 
 
-def prompt_llm_config() -> dict:
+def prompt_llm_config(use_defaults: bool = False) -> dict:
     """
     Prompt user for LLM provider configuration.
 
+    Args:
+        use_defaults: If True, use all default values without prompting
+
     Returns:
         LLM configuration dictionary
     """
@@ -86,40 +109,55 @@ def prompt_llm_config() -> dict:
 
     config = {}
 
-    # Default model
-    click.echo("\nDefault LLM model (format: provider:model-id)")
-    click.echo("Examples:")
-    click.echo("  - anthropic:claude-sonnet-4-5-20250929")
-    click.echo("  - openai:gpt-4o")
-    click.echo("  - openai:gpt-4o-mini")
-
-    config["default_model"] = click.prompt(
-        "Default model", default="anthropic:claude-sonnet-4-5-20250929"
-    )
+    # Default values
+    default_model = "anthropic:claude-sonnet-4-5-20250929"
+    default_temperature = 0.5
+
+    if use_defaults:
+        click.echo("\nUsing default LLM configuration:")
+        click.echo(f"  Model: {default_model}")
+        click.echo(f"  Temperature: {default_temperature}")
+        click.echo("  API Keys: Not configured (set via environment variables)")
+        config["default_model"] = default_model
+        config["default_temperature"] = default_temperature
+    else:
+        # Default model
+        click.echo("\nDefault LLM model (format: provider:model-id)")
+        click.echo("Examples:")
+        click.echo("  - anthropic:claude-sonnet-4-5-20250929")
+        click.echo("  - openai:gpt-4o")
+        click.echo("  - openai:gpt-4o-mini")
+
+        config["default_model"] = click.prompt(
+            "Default model", default=default_model
+        )
 
-    # Temperature
-    config["default_temperature"] = click.prompt(
-        "Default temperature (0.0-1.0)", default=0.5, type=float
-    )
+        # Temperature
+        config["default_temperature"] = click.prompt(
+            "Default temperature (0.0-1.0)", default=default_temperature, type=float
+        )
 
-    # API keys
-    click.echo("\nAPI Keys (optional - leave empty to skip):")
+        # API keys
+        click.echo("\nAPI Keys (optional - leave empty to skip):")
 
-    openai_key = click.prompt("OpenAI API key", default="", show_default=False)
-    if openai_key:
-        config["openai_api_key"] = openai_key
+        openai_key = click.prompt("OpenAI API key", default="", show_default=False)
+        if openai_key:
+            config["openai_api_key"] = openai_key
 
-    anthropic_key = click.prompt("Anthropic API key", default="", show_default=False)
-    if anthropic_key:
-        config["anthropic_api_key"] = anthropic_key
+        anthropic_key = click.prompt("Anthropic API key", default="", show_default=False)
+        if anthropic_key:
+            config["anthropic_api_key"] = anthropic_key
 
     return config
 
 
-def prompt_s3_config() -> dict:
+def prompt_s3_config(use_defaults: bool = False) -> dict:
     """
     Prompt user for S3 storage configuration.
 
+    Args:
+        use_defaults: If True, skip S3 configuration (optional feature)
+
     Returns:
         S3 configuration dictionary
     """
@@ -129,8 +167,12 @@ def prompt_s3_config() -> dict:
 
     config = {}
 
+    if use_defaults:
+        click.echo("\nSkipping S3 configuration (optional - configure later if needed)")
+        return {}
+
     click.echo("\nS3 storage is used for file uploads and processed content.")
-    use_s3 = click.confirm("Configure S3 storage?", default=True)
+    use_s3 = click.confirm("Configure S3 storage?", default=False)
 
     if not use_s3:
         return {}
@@ -154,10 +196,13 @@ def prompt_s3_config() -> dict:
     return config
 
 
-def prompt_additional_env_vars() -> dict:
+def prompt_additional_env_vars(use_defaults: bool = False) -> dict:
     """
     Prompt user for additional environment variables.
 
+    Args:
+        use_defaults: If True, skip additional env vars (optional feature)
+
     Returns:
         Dictionary of custom environment variables
     """
@@ -167,6 +212,10 @@ def prompt_additional_env_vars() -> dict:
 
     env_vars: dict[str, str] = {}
 
+    if use_defaults:
+        click.echo("\nSkipping additional environment variables (configure later if needed)")
+        return env_vars
+
     add_env = click.confirm(
         "Add custom environment variables?", default=False
     )
@@ -207,7 +256,13 @@ def prompt_additional_env_vars() -> dict:
     is_flag=True,
     help="Open configuration file in editor",
 )
-def configure_command(install: bool, claude_desktop: bool, show: bool, edit: bool):
+@click.option(
+    "--yes",
+    "-y",
+    is_flag=True,
+    help="Accept all defaults without prompting (non-interactive mode)",
+)
+def configure_command(install: bool, claude_desktop: bool, show: bool, edit: bool, yes: bool):
     """
     Configure REM installation.
 
@@ -215,10 +270,12 @@ def configure_command(install: bool, claude_desktop: bool, show: bool, edit: boo
     Configuration is saved to ~/.rem/config.yaml and merged with environment variables.
 
     Examples:
-        rem configure               # Run interactive wizard
-        rem configure --install     # Run wizard + install database tables
-        rem configure --show        # Show current configuration
-        rem configure --edit        # Open config in $EDITOR
+        rem configure                    # Run interactive wizard
+        rem configure --yes              # Accept all defaults (non-interactive)
+        rem configure --yes --install    # Quick setup with defaults + install tables
+        rem configure --install          # Run wizard + install database tables
+        rem configure --show             # Show current configuration
+        rem configure --edit             # Open config in $EDITOR
     """
     config_path = get_config_path()
 
@@ -258,57 +315,74 @@ def configure_command(install: bool, claude_desktop: bool, show: bool, edit: boo
     click.echo("\n" + "=" * 60)
     click.echo("REM Configuration Wizard")
     click.echo("=" * 60)
-    click.echo("\nThis wizard will help you configure REM for first-time use.")
+
+    if yes:
+        click.echo("\nRunning in non-interactive mode (--yes flag)")
+        click.echo("Using default configuration values...")
+    else:
+        click.echo("\nThis wizard will help you configure REM for first-time use.")
+
     click.echo(f"Configuration will be saved to: {config_path}")
 
     # Check if config already exists
     if config_exists():
         click.echo(f"\nConfiguration file already exists at {config_path}")
-        if not click.confirm("Overwrite existing configuration?", default=False):
+        if yes:
+            # In non-interactive mode, skip configuration creation
+            click.echo("Skipping configuration creation (file already exists)")
+            config = None  # Will not save/validate
+        elif not click.confirm("Overwrite existing configuration?", default=False):
             click.echo("Configuration unchanged.")
-            return
-
-    # Build configuration
-    config = {}
-
-    # PostgreSQL (required)
-    config["postgres"] = prompt_postgres_config()
-
-    # LLM providers
-    config["llm"] = prompt_llm_config()
-
-    # S3 storage (optional)
-    s3_config = prompt_s3_config()
-    if s3_config:
-        config["s3"] = s3_config
-
-    # Additional environment variables
-    env_vars = prompt_additional_env_vars()
-    if env_vars:
-        config["env"] = env_vars
-
-    # Validate configuration
-    click.echo("\n" + "=" * 60)
-    click.echo("Validating Configuration")
-    click.echo("=" * 60)
+            config = None  # Will not save/validate
+        else:
+            # User confirmed overwrite - create new config
+            config = {}
+            config["postgres"] = prompt_postgres_config(use_defaults=yes)
+            config["llm"] = prompt_llm_config(use_defaults=yes)
+            s3_config = prompt_s3_config(use_defaults=yes)
+            if s3_config:
+                config["s3"] = s3_config
+            env_vars = prompt_additional_env_vars(use_defaults=yes)
+            if env_vars:
+                config["env"] = env_vars
+    else:
+        # No existing config - create new one
+        config = {}
+        config["postgres"] = prompt_postgres_config(use_defaults=yes)
+        config["llm"] = prompt_llm_config(use_defaults=yes)
+        s3_config = prompt_s3_config(use_defaults=yes)
+        if s3_config:
+            config["s3"] = s3_config
+        env_vars = prompt_additional_env_vars(use_defaults=yes)
+        if env_vars:
+            config["env"] = env_vars
+
+    # Validate and save configuration (only if we created one)
+    if config is not None:
+        click.echo("\n" + "=" * 60)
+        click.echo("Validating Configuration")
+        click.echo("=" * 60)
 
-    errors = validate_config(config)
-    if errors:
-        click.echo("\nConfiguration validation failed:")
-        for error in errors:
-            click.echo(f"  ❌ {error}", err=True)
-        click.echo("\nPlease fix these errors and try again.")
-        return
+        errors = validate_config(config)
+        if errors:
+            click.echo("\nConfiguration validation failed:")
+            for error in errors:
+                click.echo(f"  ❌ {error}", err=True)
+            click.echo("\nPlease fix these errors and try again.")
+            return
 
-    click.echo("✅ Configuration is valid")
+        click.echo("✅ Configuration is valid")
 
-    # Save configuration
-    try:
-        save_config(config)
-        click.echo(f"\n✅ Configuration saved to {config_path}")
-    except Exception as e:
-        click.echo(f"\n❌ Failed to save configuration: {e}", err=True)
-        return
+        # Save configuration
+        try:
+            save_config(config)
+            click.echo(f"\n✅ Configuration saved to {config_path}")
+        except Exception as e:
+            click.echo(f"\n❌ Failed to save configuration: {e}", err=True)
+            return
+    else:
+        # Load existing config for use in install step
+        config = load_config() if config_exists() else {}
 
     # Install database tables if requested
     if install:
@@ -316,7 +390,7 @@ def configure_command(install: bool, claude_desktop: bool, show: bool, edit: boo
         click.echo("Database Installation")
         click.echo("=" * 60)
 
-        if click.confirm("\nInstall database tables?", default=True):
+        if yes or click.confirm("\nInstall database tables?", default=True):
             try:
                 # Import here to ensure config is loaded first
                 from rem.config import merge_config_to_env
@@ -357,8 +431,9 @@ def configure_command(install: bool, claude_desktop: bool, show: bool, edit: boo
             if os.name == "nt":  # Windows
                 config_dir = Path.home() / "AppData/Roaming/Claude"
             elif os.name == "posix":
-                if Path.home() / "Library/Application Support/Claude":
-                    config_dir = Path.home() / "Library/Application Support/Claude"
+                macos_path = Path.home() / "Library/Application Support/Claude"
+                if macos_path.exists():
+                    config_dir = macos_path
                 else:
                     config_dir = Path.home() / ".config/Claude"
             else:

rem/cli/commands/db.py

@@ -382,9 +382,9 @@ def rebuild_cache(connection: str | None):
 
 @click.command()
 @click.argument("file_path", type=click.Path(exists=True, path_type=Path))
-@click.option("--user-id", default="test-user", help="User ID for loaded data")
+@click.option("--user-id", default=None, help="User ID for loaded data (default: from settings)")
 @click.option("--dry-run", is_flag=True, help="Show what would be loaded without loading")
-def load(file_path: Path, user_id: str, dry_run: bool):
+def load(file_path: Path, user_id: str | None, dry_run: bool):
     """
     Load data from YAML file into database.
 
@@ -400,14 +400,18 @@ def load(file_path: Path, user_id: str, dry_run: bool):
         rem db load data.yaml --user-id my-user
         rem db load data.yaml --dry-run
     """
-    asyncio.run(_load_async(file_path, user_id, dry_run))
+    from ...settings import settings
+
+    # Resolve user_id from settings if not provided
+    effective_user_id = user_id or settings.test.effective_user_id
+    asyncio.run(_load_async(file_path, effective_user_id, dry_run))
 
 
 async def _load_async(file_path: Path, user_id: str, dry_run: bool):
     """Async implementation of load command."""
     import yaml
     from ...models.core.inline_edge import InlineEdge
-    from ...models.entities import Resource, Moment, User
+    from ...models.entities import Resource, Moment, User, Message, SharedSession, Schema
     from ...services.postgres import get_postgres_service
 
     logger.info(f"Loading data from: {file_path}")
@@ -427,12 +431,18 @@ async def _load_async(file_path: Path, user_id: str, dry_run: bool):
         return
 
     # Map table names to model classes
+    # CoreModel subclasses use Repository.upsert()
     MODEL_MAP = {
         "users": User,
         "moments": Moment,
         "resources": Resource,
+        "messages": Message,
+        "schemas": Schema,
     }
 
+    # Non-CoreModel tables that need direct SQL insertion
+    DIRECT_INSERT_TABLES = {"shared_sessions"}
+
     # Connect to database
     pg = get_postgres_service()
     if not pg:
@@ -449,6 +459,29 @@ async def _load_async(file_path: Path, user_id: str, dry_run: bool):
             key_field = table_def.get("key_field", "id")
             rows = table_def.get("rows", [])
 
+            # Handle direct insert tables (non-CoreModel)
+            if table_name in DIRECT_INSERT_TABLES:
+                for row_data in rows:
+                    # Add tenant_id if not present
+                    if "tenant_id" not in row_data:
+                        row_data["tenant_id"] = "default"
+
+                    if table_name == "shared_sessions":
+                        # Insert shared_session directly
+                        await pg.fetch(
+                            """INSERT INTO shared_sessions
+                               (session_id, owner_user_id, shared_with_user_id, tenant_id)
+                               VALUES ($1, $2, $3, $4)
+                               ON CONFLICT DO NOTHING""",
+                            row_data["session_id"],
+                            row_data["owner_user_id"],
+                            row_data["shared_with_user_id"],
+                            row_data["tenant_id"],
+                        )
+                        total_loaded += 1
+                        logger.success(f"Loaded shared_session: {row_data['owner_user_id']} -> {row_data['shared_with_user_id']}")
+                continue
+
             if table_name not in MODEL_MAP:
                 logger.warning(f"Unknown table: {table_name}, skipping")
                 continue
@@ -456,9 +489,12 @@ async def _load_async(file_path: Path, user_id: str, dry_run: bool):
             model_class = MODEL_MAP[table_name]  # Type is inferred from MODEL_MAP
 
             for row_data in rows:
-                # Add user_id and tenant_id (set to user_id for backward compat)
-                row_data["user_id"] = user_id
-                row_data["tenant_id"] = user_id
+                # Add user_id and tenant_id if not already present
+                # This allows seed files to specify explicit owners
+                if "user_id" not in row_data:
+                    row_data["user_id"] = user_id
+                if "tenant_id" not in row_data:
+                    row_data["tenant_id"] = row_data.get("user_id", user_id)
 
                 # Convert graph_edges to InlineEdge format if present
                 if "graph_edges" in row_data:
@@ -467,6 +503,16 @@ async def _load_async(file_path: Path, user_id: str, dry_run: bool):
                         for edge in row_data["graph_edges"]
                     ]
 
+                # Convert any ISO timestamp strings with Z suffix to naive datetime
+                # This handles fields like starts_timestamp, ends_timestamp, etc.
+                from ...utils.date_utils import parse_iso
+                for key, value in list(row_data.items()):
+                    if isinstance(value, str) and (key.endswith("_timestamp") or key.endswith("_at")):
+                        try:
+                            row_data[key] = parse_iso(value)
+                        except (ValueError, TypeError):
+                            pass  # Not a valid datetime string, leave as-is
+
                 # Create model instance and upsert via repository
                 from ...services.postgres.repository import Repository