remdb 0.3.14__py3-none-any.whl → 0.3.133__py3-none-any.whl

rem/cli/commands/schema.py

@@ -8,6 +8,7 @@ Usage:
 """
 
 import asyncio
+import importlib
 from pathlib import Path
 
 import click
@@ -15,68 +16,116 @@ from loguru import logger
 
 from ...settings import settings
 from ...services.postgres.schema_generator import SchemaGenerator
+from ...utils.sql_paths import get_package_sql_dir, get_package_migrations_dir
+
+
+def _import_model_modules() -> list[str]:
+    """
+    Import modules specified in MODELS__IMPORT_MODULES setting.
+
+    This ensures downstream models decorated with @rem.register_model
+    are registered before schema generation.
+
+    Returns:
+        List of successfully imported module names
+    """
+    imported = []
+    for module_name in settings.models.module_list:
+        try:
+            importlib.import_module(module_name)
+            imported.append(module_name)
+            logger.debug(f"Imported model module: {module_name}")
+        except ImportError as e:
+            logger.warning(f"Failed to import model module '{module_name}': {e}")
+            click.echo(
+                click.style(f"  ⚠ Could not import '{module_name}': {e}", fg="yellow"),
+                err=True,
+            )
+    return imported
 
 
 @click.command()
-@click.option(
-    "--models",
-    "-m",
-    required=True,
-    type=click.Path(exists=True, path_type=Path),
-    help="Directory containing Pydantic models",
-)
 @click.option(
     "--output",
     "-o",
     type=click.Path(path_type=Path),
-    default="install_models.sql",
-    help="Output SQL file (default: install_models.sql)",
+    default="002_install_models.sql",
+    help="Output SQL file (default: 002_install_models.sql)",
 )
 @click.option(
     "--output-dir",
     type=click.Path(path_type=Path),
     default=None,
-    help=f"Base output directory (default: {settings.sql_dir})",
+    help="Base output directory (default: package sql/migrations)",
 )
-def generate(models: Path, output: Path, output_dir: Path | None):
+def generate(output: Path, output_dir: Path | None):
     """
-    Generate database schema from Pydantic models.
+    Generate database schema from registered Pydantic models.
 
-    Scans the specified directory for Pydantic models and generates:
+    Uses the model registry (core models + user-registered models) to generate:
     - CREATE TABLE statements
     - Embeddings tables (embeddings_<table>)
     - KV_STORE triggers for cache maintenance
     - Indexes (foreground only)
 
-    Output is written to src/rem/sql/install_models.sql by default.
+    Output is written to src/rem/sql/migrations/002_install_models.sql by default.
 
     Example:
-        rem db schema generate --models src/rem/models/entities
+        rem db schema generate
+
+    To register custom models in downstream apps:
+
+    1. Create models with @rem.register_model decorator:
+
+        # models/__init__.py
+        import rem
+        from rem.models.core import CoreModel
+
+        @rem.register_model
+        class MyEntity(CoreModel):
+            name: str
+
+    2. Set MODELS__IMPORT_MODULES in your .env:
+
+        MODELS__IMPORT_MODULES=models
+
+    3. Run schema generation:
+
+        rem db schema generate
 
     This creates:
-    - src/rem/sql/install_models.sql - Entity tables and triggers
+    - src/rem/sql/migrations/002_install_models.sql - Entity tables and triggers
     - src/rem/sql/background_indexes.sql - HNSW indexes (apply after data load)
 
-    After generation, apply with:
-        rem db migrate
+    After generation, verify with:
+        rem db diff
     """
-    click.echo(f"Discovering models in {models}")
+    from ...registry import get_model_registry
+
+    # Import downstream model modules to trigger @rem.register_model decorators
+    imported_modules = _import_model_modules()
+    if imported_modules:
+        click.echo(f"Imported model modules: {', '.join(imported_modules)}")
+
+    registry = get_model_registry()
+    models = registry.get_models(include_core=True)
+    click.echo(f"Generating schema from {len(models)} registered models")
 
-    # Use settings.sql_dir if not provided
-    actual_output_dir = output_dir or Path(settings.sql_dir)
+    # Default to package migrations directory
+    actual_output_dir = output_dir or get_package_migrations_dir()
     generator = SchemaGenerator(output_dir=actual_output_dir)
 
-    # Generate schema
+    # Generate schema from registry
     try:
-        schema_sql = asyncio.run(generator.generate_from_directory(models, output_file=output.name))
+        schema_sql = asyncio.run(generator.generate_from_registry(output_file=output.name))
 
         click.echo(f"✓ Schema generated: {len(generator.schemas)} tables")
         click.echo(f"✓ Written to: {actual_output_dir / output.name}")
 
-        # Generate background indexes
+        # Generate background indexes in parent sql dir
         background_indexes = generator.generate_background_indexes()
         if background_indexes:
-            bg_file = actual_output_dir / "background_indexes.sql"
+            bg_file = get_package_sql_dir() / "background_indexes.sql"
             bg_file.write_text(background_indexes)
             click.echo(f"✓ Background indexes: {bg_file}")
 
@@ -94,48 +143,46 @@ def generate(models: Path, output: Path, output_dir: Path | None):
 
 
 @click.command()
-@click.option(
-    "--models",
-    "-m",
-    required=True,
-    type=click.Path(exists=True, path_type=Path),
-    help="Directory containing Pydantic models",
-)
-def validate(models: Path):
+def validate():
     """
-    Validate Pydantic models for schema generation.
+    Validate registered Pydantic models for schema generation.
 
     Checks:
-    - Models can be loaded
+    - Models can be loaded from registry
     - Models have suitable entity_key fields
     - Fields with embeddings are properly configured
+
+    Set MODELS__IMPORT_MODULES to include custom models from downstream apps.
     """
-    click.echo(f"Validating models in {models}")
+    from ...registry import get_model_registry
 
-    generator = SchemaGenerator()
-    discovered = generator.discover_models(models)
+    # Import downstream model modules to trigger @rem.register_model decorators
+    imported_modules = _import_model_modules()
+    if imported_modules:
+        click.echo(f"Imported model modules: {', '.join(imported_modules)}")
 
-    if not discovered:
-        click.echo("✗ No models found", err=True)
-        raise click.Abort()
+    registry = get_model_registry()
+    models = registry.get_models(include_core=True)
+
+    click.echo(f"Validating {len(models)} registered models")
 
-    click.echo(f"✓ Discovered {len(discovered)} models")
+    if not models:
+        click.echo("✗ No models found in registry", err=True)
+        raise click.Abort()
 
+    generator = SchemaGenerator()
     errors: list[str] = []
     warnings: list[str] = []
 
-    for model_name, model in discovered.items():
-        table_name = generator.infer_table_name(model)
-        entity_key = generator.infer_entity_key_field(model)
+    for model_name, ext in models.items():
+        model = ext.model
+        table_name = ext.table_name or generator.infer_table_name(model)
+        entity_key = ext.entity_key_field or generator.infer_entity_key_field(model)
 
         # Check for entity_key
         if entity_key == "id":
             warnings.append(f"{model_name}: No natural key field, using 'id'")
 
-        # Check for embeddable fields
-        # TODO: Implement should_embed_field check
-        embeddable: list[str] = []  # Placeholder - needs implementation
-
         click.echo(f"  {model_name} -> {table_name} (key: {entity_key})")
 
     if warnings:
@@ -158,7 +205,7 @@ def validate(models: Path):
     "-o",
     type=click.Path(path_type=Path),
     default=None,
-    help=f"Output file for background indexes (default: {settings.sql_dir}/background_indexes.sql)",
+    help="Output file for background indexes (default: package sql/background_indexes.sql)",
 )
 def indexes(output: Path):
     """

rem/cli/main.py

@@ -22,17 +22,30 @@ 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."""
-    if verbose:
-        logger.remove()
-        logger.add(sys.stderr, level="DEBUG")
-    else:
-        logger.remove()
-        logger.add(sys.stderr, level="INFO")
+    _configure_logger("DEBUG" if verbose else "INFO")
 
 
 @cli.group()
@@ -65,6 +78,12 @@ def dreaming():
     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
@@ -76,11 +95,13 @@ 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
 
 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)

rem/config.py

@@ -15,7 +15,7 @@ File Format (~/.rem/config.yaml):
       pool_max_size: 20
 
     llm:
-      default_model: anthropic:claude-sonnet-4-5-20250929
+      default_model: openai:gpt-4.1
       openai_api_key: sk-...
       anthropic_api_key: sk-ant-...
 
@@ -95,9 +95,16 @@ def load_config() -> dict[str, Any]:
     """
     Load configuration from ~/.rem/config.yaml.
 
+    Set REM_SKIP_CONFIG=1 to skip loading the config file (useful when using .env files).
+
     Returns:
-        Configuration dictionary (empty if file doesn't exist)
+        Configuration dictionary (empty if file doesn't exist or skipped)
     """
+    # Allow skipping config file via environment variable
+    if os.environ.get("REM_SKIP_CONFIG", "").lower() in ("1", "true", "yes"):
+        logger.debug("Skipping config file (REM_SKIP_CONFIG is set)")
+        return {}
+
     config_path = get_config_path()
 
     if not config_path.exists():
@@ -216,7 +223,7 @@ def get_default_config() -> dict[str, Any]:
             "pool_max_size": 20,
         },
         "llm": {
-            "default_model": "anthropic:claude-sonnet-4-5-20250929",
+            "default_model": "openai:gpt-4.1",
             "default_temperature": 0.5,
             # API keys will be prompted for in wizard
             # "openai_api_key": "",

rem/models/core/core_model.py

@@ -52,7 +52,13 @@ class CoreModel(BaseModel):
         default=None, description="Tenant identifier for multi-tenancy isolation"
     )
     user_id: Optional[str] = Field(
-        default=None, description="Owner user identifier (tenant-scoped)"
+        default=None,
+        description=(
+            "Owner user identifier (tenant-scoped). This is a VARCHAR(256), not a UUID, "
+            "to allow flexibility for external identity providers. Typically generated as "
+            "a hash of the user's email address. In future, other strong unique claims "
+            "(e.g., OAuth sub, verified phone) could also be used for generation."
+        ),
     )
     graph_edges: list[dict] = Field(
         default_factory=list,

rem/models/core/experiment.py

@@ -318,6 +318,15 @@ class ExperimentConfig(BaseModel):
         )
     )
 
+    task: str = Field(
+        default="general",
+        description=(
+            "Task name for organizing experiments by purpose.\n"
+            "Used with agent name to form directory: {agent}/{task}/\n"
+            "Examples: 'risk-assessment', 'classification', 'general'"
+        )
+    )
+
     description: str = Field(
         description="Human-readable description of experiment purpose and goals"
     )
@@ -410,6 +419,24 @@ class ExperimentConfig(BaseModel):
 
         return v
 
+    @field_validator("task")
+    @classmethod
+    def validate_task(cls, v: str) -> str:
+        """Validate task name follows conventions."""
+        if not v:
+            return "general"  # Default value
+
+        if not v.islower():
+            raise ValueError("Task name must be lowercase")
+
+        if " " in v:
+            raise ValueError("Task name cannot contain spaces (use hyphens)")
+
+        if not all(c.isalnum() or c == "-" for c in v):
+            raise ValueError("Task name can only contain lowercase letters, numbers, and hyphens")
+
+        return v
+
     @field_validator("tags")
     @classmethod
     def validate_tags(cls, v: list[str]) -> list[str]:
@@ -420,6 +447,15 @@ class ExperimentConfig(BaseModel):
         """Get the experiment directory path."""
         return Path(base_path) / self.name
 
+    def get_agent_task_dir(self, base_path: str = ".experiments") -> Path:
+        """
+        Get the experiment directory path organized by agent/task.
+
+        Returns: Path like .experiments/{agent}/{task}/
+        This is the recommended structure for S3 export compatibility.
+        """
+        return Path(base_path) / self.agent_schema_ref.name / self.task
+
     def get_config_path(self, base_path: str = ".experiments") -> Path:
         """Get the path to experiment.yaml file."""
         return self.get_experiment_dir(base_path) / "experiment.yaml"
@@ -428,6 +464,22 @@ class ExperimentConfig(BaseModel):
         """Get the path to README.md file."""
         return self.get_experiment_dir(base_path) / "README.md"
 
+    def get_evaluator_filename(self) -> str:
+        """
+        Get the evaluator filename with task prefix.
+
+        Returns: {agent_name}-{task}.yaml (e.g., siggy-risk-assessment.yaml)
+        """
+        return f"{self.agent_schema_ref.name}-{self.task}.yaml"
+
+    def get_s3_export_path(self, bucket: str, version: str = "v0") -> str:
+        """
+        Get the S3 path for exporting this experiment.
+
+        Returns: s3://{bucket}/{version}/datasets/calibration/experiments/{agent}/{task}/
+        """
+        return f"s3://{bucket}/{version}/datasets/calibration/experiments/{self.agent_schema_ref.name}/{self.task}"
+
     def to_yaml(self) -> str:
         """Export configuration as YAML string."""
         import yaml
@@ -483,6 +535,7 @@ class ExperimentConfig(BaseModel):
 ## Configuration
 
 **Status**: `{self.status.value}`
+**Task**: `{self.task}`
 **Tags**: {', '.join(f'`{tag}`' for tag in self.tags) if self.tags else 'None'}
 
 ## Agent Schema
@@ -494,6 +547,7 @@ class ExperimentConfig(BaseModel):
 ## Evaluator Schema
 
 - **Name**: `{self.evaluator_schema_ref.name}`
+- **File**: `{self.get_evaluator_filename()}`
 - **Type**: `{self.evaluator_schema_ref.type}`
 
 ## Datasets

rem/models/core/rem_query.py

@@ -112,7 +112,7 @@ class SearchParameters(BaseModel):
     table_name: str = Field(..., description="Table to search (resources, moments, etc.)")
     limit: int = Field(default=10, gt=0, description="Maximum results")
     min_similarity: float = Field(
-        default=0.7, ge=0.0, le=1.0, description="Minimum similarity score"
+        default=0.3, ge=0.0, le=1.0, description="Minimum similarity score (0.3 recommended for general queries)"
     )
 
 
@@ -198,7 +198,10 @@ class RemQuery(BaseModel):
         | SQLParameters
         | TraverseParameters
     ) = Field(..., description="Query parameters")
-    user_id: str = Field(..., description="User identifier for isolation")
+    user_id: Optional[str] = Field(
+        default=None,
+        description="User identifier (UUID5 hash of email). None = anonymous (shared/public data only)"
+    )
 
 
 class TraverseStage(BaseModel):

rem/models/entities/__init__.py

@@ -5,6 +5,9 @@ Core entity types for the REM system:
 - Resources: Base content units (documents, conversations, artifacts)
 - ImageResources: Image-specific resources with CLIP embeddings
 - Messages: Communication content
+- Sessions: Conversation sessions (normal or evaluation mode)
+- SharedSessions: Session sharing between users for collaboration
+- Feedback: User feedback on messages/sessions with trace integration
 - Users: User entities
 - Files: File metadata and tracking
 - Moments: Temporal narratives (meetings, coding sessions, conversations)
@@ -19,6 +22,8 @@ All entities inherit from CoreModel and support:
 - Natural language labels for conversational queries
 """
 
+from .domain_resource import DomainResource
+from .feedback import Feedback, FeedbackCategory
 from .file import File
 from .image_resource import ImageResource
 from .message import Message
@@ -27,12 +32,28 @@ from .ontology import Ontology
 from .ontology_config import OntologyConfig
 from .resource import Resource
 from .schema import Schema
+from .session import Session, SessionMode
+from .shared_session import (
+    SharedSession,
+    SharedSessionCreate,
+    SharedWithMeResponse,
+    SharedWithMeSummary,
+)
 from .user import User, UserTier
 
 __all__ = [
     "Resource",
+    "DomainResource",
     "ImageResource",
     "Message",
+    "Session",
+    "SessionMode",
+    "SharedSession",
+    "SharedSessionCreate",
+    "SharedWithMeResponse",
+    "SharedWithMeSummary",
+    "Feedback",
+    "FeedbackCategory",
     "User",
     "UserTier",
     "File",

rem/models/entities/domain_resource.py

@@ -0,0 +1,38 @@
+"""
+DomainResource - Curated internal knowledge in REM.
+
+DomainResources are a specialized subclass of Resource for storing curated,
+domain-specific internal knowledge that is not part of general knowledge.
+This includes proprietary information, internal documentation, institutional
+knowledge, and other content that requires more careful curation.
+
+Key Differences from Resource:
+- Intended for curated, internal knowledge (not raw ingested content)
+- Higher quality bar - content is reviewed/vetted before ingestion
+- May contain proprietary or sensitive information
+- Subject to different retention/governance policies
+
+Use Cases:
+- Internal documentation and procedures
+- Proprietary research and analysis
+- Institutional knowledge bases
+- Domain-specific ontologies and taxonomies
+- Curated best practices and guidelines
+"""
+
+from .resource import Resource
+
+
+class DomainResource(Resource):
+    """
+    Curated domain-specific knowledge resource.
+
+    Inherits all fields from Resource but stored in a separate table
+    (domain_resources) to distinguish curated internal knowledge from
+    general ingested content.
+
+    The schema is identical to Resource, allowing seamless migration
+    of content between tables as curation status changes.
+    """
+
+    pass

rem/models/entities/feedback.py

@@ -0,0 +1,123 @@
+"""
+Feedback - User feedback on chat messages and sessions.
+
+Feedback allows users to rate and categorize responses, providing
+data for evaluation and model improvement. Feedback can be attached
+to specific messages or entire sessions.
+
+Trace Integration:
+- Feedback references trace_id/span_id for OTEL/Phoenix integration
+- Can attach annotations to Phoenix spans for unified observability
+
+Predefined Categories (system-defined, extensible):
+- INCOMPLETE: Response lacks expected information
+- INACCURATE: Response contains factual errors
+- POOR_TONE: Inappropriate or unprofessional tone
+- OFF_TOPIC: Response doesn't address the question
+- TOO_VERBOSE: Unnecessarily long response
+- TOO_BRIEF: Insufficiently detailed response
+- HELPFUL: Positive feedback marker
+- EXCELLENT: Exceptionally good response
+"""
+
+from enum import Enum
+from typing import Any
+
+from pydantic import Field
+
+from ..core import CoreModel
+
+
+class FeedbackCategory(str, Enum):
+    """Predefined feedback categories (system-defined)."""
+
+    # Negative categories
+    INCOMPLETE = "incomplete"
+    INACCURATE = "inaccurate"
+    POOR_TONE = "poor_tone"
+    OFF_TOPIC = "off_topic"
+    TOO_VERBOSE = "too_verbose"
+    TOO_BRIEF = "too_brief"
+    CONFUSING = "confusing"
+    UNSAFE = "unsafe"
+
+    # Positive categories
+    HELPFUL = "helpful"
+    EXCELLENT = "excellent"
+    ACCURATE = "accurate"
+    WELL_WRITTEN = "well_written"
+
+    # Neutral/Other
+    OTHER = "other"
+
+
+class Feedback(CoreModel):
+    """
+    User feedback on a message or session.
+
+    Captures structured feedback including:
+    - Rating (1-5 scale or thumbs up/down)
+    - Categories (predefined or custom)
+    - Free-text comment
+    - Trace reference for OTEL/Phoenix integration
+
+    The feedback can be attached to:
+    - A specific message (message_id set)
+    - An entire session (session_id set, message_id null)
+    """
+
+    # Target reference (at least one required)
+    session_id: str = Field(
+        ...,
+        description="Session ID this feedback relates to",
+    )
+    message_id: str | None = Field(
+        default=None,
+        description="Specific message ID (null for session-level feedback)",
+    )
+
+    # Rating (flexible: 1-5, or -1/1 for thumbs)
+    rating: int | None = Field(
+        default=None,
+        ge=-1,
+        le=5,
+        description="Rating: -1 (thumbs down), 1 (thumbs up), or 1-5 scale",
+    )
+
+    # Categories (can select multiple)
+    categories: list[str] = Field(
+        default_factory=list,
+        description="Selected feedback categories (from FeedbackCategory or custom)",
+    )
+
+    # Free-text comment
+    comment: str | None = Field(
+        default=None,
+        description="Optional free-text feedback comment",
+    )
+
+    # Trace reference for OTEL/Phoenix integration
+    trace_id: str | None = Field(
+        default=None,
+        description="OTEL trace ID for linking to observability",
+    )
+    span_id: str | None = Field(
+        default=None,
+        description="OTEL span ID for specific span feedback",
+    )
+
+    # Phoenix annotation status
+    phoenix_synced: bool = Field(
+        default=False,
+        description="Whether feedback has been synced to Phoenix as annotation",
+    )
+    phoenix_annotation_id: str | None = Field(
+        default=None,
+        description="Phoenix annotation ID after sync",
+    )
+
+    # Annotator info
+    annotator_kind: str = Field(
+        default="HUMAN",
+        description="Annotator type: HUMAN, LLM, CODE",
+    )