slide-narrator 1.0.0__py3-none-any.whl → 1.0.2__py3-none-any.whl

narrator/__init__.py

@@ -8,7 +8,7 @@ from .models.thread import Thread
 from .models.message import Message
 from .models.attachment import Attachment
 
-__version__ = "1.0.0"
+__version__ = "1.0.2"
 __all__ = [
     "ThreadStore",
     "FileStore", 

narrator/database/cli.py

@@ -1,6 +1,12 @@
 """Database CLI for Tyler Stores"""
 import asyncio
+import os
 import click
+import functools
+import subprocess
+import tempfile
+import time
+from pathlib import Path
 from .thread_store import ThreadStore
 from ..utils.logging import get_logger
 
@@ -8,59 +14,209 @@ logger = get_logger(__name__)
 
 @click.group()
 def main():
-    """Tyler Stores Database CLI"""
+    """Narrator CLI - Database management commands"""
     pass
 
-@click.command()
+@main.command()
 @click.option('--database-url', help='Database URL for initialization')
-async def init(database_url):
+def init(database_url):
     """Initialize database tables"""
-    try:
-        if database_url:
-            store = await ThreadStore.create(database_url)
-        else:
-            # Use environment variables or default
-            store = await ThreadStore.create()
-        
-        logger.info("Database initialized successfully")
-        click.echo("Database initialized successfully")
-    except Exception as e:
-        logger.error(f"Failed to initialize database: {e}")
-        click.echo(f"Error: Failed to initialize database: {e}")
-        raise click.Abort()
+    async def _init():
+        try:
+            # Use provided URL or check environment variable
+            url = database_url or os.environ.get('NARRATOR_DATABASE_URL')
+            
+            if url:
+                store = await ThreadStore.create(url)
+            else:
+                # Use in-memory storage
+                store = await ThreadStore.create()
+            
+            logger.info("Database initialized successfully")
+            click.echo("Database initialized successfully")
+        except Exception as e:
+            logger.error(f"Failed to initialize database: {e}")
+            click.echo(f"Error: Failed to initialize database: {e}")
+            raise click.Abort()
+    
+    asyncio.run(_init())
 
-@click.command()
+@main.command()
 @click.option('--database-url', help='Database URL')
-async def status(database_url):
+def status(database_url):
     """Check database status"""
-    try:
-        if database_url:
-            store = await ThreadStore.create(database_url)
-        else:
-            store = await ThreadStore.create()
+    async def _status():
+        try:
+            # Use provided URL or check environment variable
+            url = database_url or os.environ.get('NARRATOR_DATABASE_URL')
+            
+            if url:
+                store = await ThreadStore.create(url)
+            else:
+                store = await ThreadStore.create()
+            
+            # Get some basic stats
+            threads = await store.list_recent(limit=5)
+            click.echo(f"Database connection: OK")
+            click.echo(f"Recent threads count: {len(threads)}")
+            
+        except Exception as e:
+            logger.error(f"Database status check failed: {e}")
+            click.echo(f"Error: Database status check failed: {e}")
+            raise click.Abort()
+    
+    asyncio.run(_status())
+
+@main.command()
+@click.option('--port', help='Port to expose PostgreSQL on (default: 5432 or NARRATOR_DB_PORT)')
+@click.option('--detach/--no-detach', default=True, help='Run container in background (default: True)')
+def docker_start(port, detach):
+    """Start a PostgreSQL container for Narrator"""
+    # Use environment variables with defaults matching docker-compose.yml
+    db_name = os.environ.get('NARRATOR_DB_NAME', 'narrator')
+    db_user = os.environ.get('NARRATOR_DB_USER', 'narrator')
+    db_password = os.environ.get('NARRATOR_DB_PASSWORD', 'narrator_dev')
+    db_port = port or os.environ.get('NARRATOR_DB_PORT', '5432')
+    
+    docker_compose_content = f"""services:
+  postgres:
+    image: postgres:16
+    container_name: narrator-postgres
+    environment:
+      POSTGRES_DB: {db_name}
+      POSTGRES_USER: {db_user}
+      POSTGRES_PASSWORD: {db_password}
+    ports:
+      - "{db_port}:5432"
+    volumes:
+      - narrator_postgres_data:/var/lib/postgresql/data
+    healthcheck:
+      test: ["CMD-SHELL", "pg_isready -U {db_user}"]
+      interval: 5s
+      timeout: 5s
+      retries: 5
+
+volumes:
+  narrator_postgres_data:
+"""
+    
+    # Create a temporary directory for docker-compose.yml
+    with tempfile.TemporaryDirectory() as tmpdir:
+        compose_file = Path(tmpdir) / "docker-compose.yml"
+        compose_file.write_text(docker_compose_content)
         
-        # Get some basic stats
-        threads = await store.list_recent(limit=5)
-        click.echo(f"Database connection: OK")
-        click.echo(f"Recent threads count: {len(threads)}")
+        # Check if docker is available
+        try:
+            subprocess.run(["docker", "--version"], capture_output=True, check=True)
+        except (subprocess.CalledProcessError, FileNotFoundError):
+            click.echo("❌ Docker is not installed or not available in PATH")
+            raise click.Abort()
         
-    except Exception as e:
-        logger.error(f"Database status check failed: {e}")
-        click.echo(f"Error: Database status check failed: {e}")
-        raise click.Abort()
-
-# Add async wrapper for commands
-def async_command(f):
-    def wrapper(*args, **kwargs):
-        return asyncio.run(f(*args, **kwargs))
-    return wrapper
+        # Check if docker-compose or docker compose is available
+        compose_cmd = None
+        try:
+            subprocess.run(["docker", "compose", "version"], capture_output=True, check=True)
+            compose_cmd = ["docker", "compose"]
+        except (subprocess.CalledProcessError, FileNotFoundError):
+            try:
+                subprocess.run(["docker-compose", "version"], capture_output=True, check=True)
+                compose_cmd = ["docker-compose"]
+            except (subprocess.CalledProcessError, FileNotFoundError):
+                click.echo("❌ Docker Compose is not installed")
+                raise click.Abort()
+        
+        # Start the container
+        click.echo("📦 Starting PostgreSQL container...")
+        cmd = compose_cmd + ["up"]
+        if detach:
+            cmd.append("-d")
+        
+        result = subprocess.run(cmd, cwd=tmpdir)
+        
+        if result.returncode != 0:
+            click.echo("❌ Failed to start PostgreSQL container")
+            raise click.Abort()
+        
+        if detach:
+            # Wait for PostgreSQL to be ready
+            click.echo("⏳ Waiting for PostgreSQL to be ready...")
+            for i in range(30):
+                result = subprocess.run(
+                    ["docker", "exec", "narrator-postgres", "pg_isready", "-U", db_user],
+                    capture_output=True
+                )
+                if result.returncode == 0:
+                    click.echo("✅ PostgreSQL is ready!")
+                    click.echo(f"\n🎉 Database available at:")
+                    click.echo(f"   postgresql+asyncpg://{db_user}:{db_password}@localhost:{db_port}/{db_name}")
+                    return
+                time.sleep(1)
+            
+            click.echo("❌ PostgreSQL failed to start after 30 seconds")
+            raise click.Abort()
 
-# Apply async wrapper to commands
-init = click.command()(async_command(init))
-status = click.command()(async_command(status))
+@main.command()
+@click.option('--remove-volumes', is_flag=True, help='Remove data volumes (destroys all data)')
+def docker_stop(remove_volumes):
+    """Stop the PostgreSQL container"""
+    # Check if docker is available
+    try:
+        subprocess.run(["docker", "--version"], capture_output=True, check=True)
+    except (subprocess.CalledProcessError, FileNotFoundError):
+        click.echo("❌ Docker is not installed or not available in PATH")
+        raise click.Abort()
+    
+    # Check if container exists
+    result = subprocess.run(
+        ["docker", "ps", "-a", "--format", "{{.Names}}"],
+        capture_output=True,
+        text=True
+    )
+    
+    if "narrator-postgres" not in result.stdout:
+        click.echo("ℹ️  No Narrator PostgreSQL container found")
+        return
+    
+    click.echo("🛑 Stopping PostgreSQL container...")
+    
+    # Stop the container
+    subprocess.run(["docker", "stop", "narrator-postgres"], check=False)
+    subprocess.run(["docker", "rm", "narrator-postgres"], check=False)
+    
+    if remove_volumes:
+        click.echo("🗑️  Removing data volume...")
+        subprocess.run(["docker", "volume", "rm", "narrator_postgres_data"], check=False)
+        click.echo("✅ Container and data removed")
+    else:
+        click.echo("✅ Container stopped (data preserved)")
 
-main.add_command(init)
-main.add_command(status)
+@main.command()
+@click.option('--port', help='Port to expose PostgreSQL on (default: 5432 or NARRATOR_DB_PORT)')
+def docker_setup(port):
+    """One-command Docker setup: start PostgreSQL and initialize tables"""
+    # Start PostgreSQL
+    ctx = click.get_current_context()
+    ctx.invoke(docker_start, port=port, detach=True)
+    
+    # Get database configuration from environment or defaults
+    db_name = os.environ.get('NARRATOR_DB_NAME', 'narrator')
+    db_user = os.environ.get('NARRATOR_DB_USER', 'narrator')
+    db_password = os.environ.get('NARRATOR_DB_PASSWORD', 'narrator_dev')
+    db_port = port or os.environ.get('NARRATOR_DB_PORT', '5432')
+    
+    # Set up database URL
+    database_url = f"postgresql+asyncpg://{db_user}:{db_password}@localhost:{db_port}/{db_name}"
+    os.environ['NARRATOR_DATABASE_URL'] = database_url
+    
+    # Initialize tables
+    click.echo("\n🔧 Initializing database tables...")
+    ctx.invoke(init, database_url=database_url)
+    
+    click.echo("\n🎉 Setup complete! Your database is ready.")
+    click.echo("\nTo use in your code:")
+    click.echo(f'export NARRATOR_DATABASE_URL="{database_url}"')
+    click.echo("\nTo stop the container: narrator docker-stop")
+    click.echo("To remove all data: narrator docker-stop --remove-volumes")
 
 if __name__ == '__main__':
     main() 

narrator/database/storage_backend.py

@@ -1,6 +1,7 @@
 """Storage backend implementations for ThreadStore."""
 from abc import ABC, abstractmethod
 from typing import List, Optional, Dict, Any, Union
+import re
 from datetime import datetime, UTC
 import json
 import os
@@ -20,6 +21,12 @@ from .models import Base, ThreadRecord, MessageRecord
 
 logger = get_logger(__name__)
 
+def _sanitize_key(component: str) -> str:
+    """Allow only alphanumeric and underscore for JSON path keys to avoid SQL injection."""
+    if not re.fullmatch(r"[A-Za-z0-9_]+", component):
+        raise ValueError(f"Invalid key component: {component}")
+    return component
+
 class StorageBackend(ABC):
     """Abstract base class for thread storage backends."""
     
@@ -149,28 +156,22 @@ class MemoryBackend(StorageBackend):
         Returns:
             List of messages matching the criteria (possibly empty)
         """
+        matches: List[Message] = []
         # Traverse all threads and messages
         for thread in self._threads.values():
             for message in thread.messages:
-                # Use the path to navigate to the target attribute
-                current = message.model_dump(mode="python")
-                
+                current: Any = message.model_dump(mode="python")
                 # Navigate the nested structure
-                parts = path.split('.')
+                parts = [p for p in path.split('.') if p]
                 for part in parts:
                     if isinstance(current, dict) and part in current:
                         current = current[part]
                     else:
                         current = None
                         break
-                
-                # Check if we found a match
                 if current == value:
-                    # For MemoryBackend, we can't return MessageRecord objects
-                    # Return a list containing the message data that the ThreadStore can handle
-                    return [message]
-        
-        return []
+                    matches.append(message)
+        return matches
 
 class SQLBackend(StorageBackend):
     """SQL storage backend supporting both SQLite and PostgreSQL with proper connection pooling."""
@@ -437,7 +438,17 @@ class SQLBackend(StorageBackend):
             for key, value in attributes.items():
                 if self.database_url.startswith('sqlite'):
                     # Use SQLite json_extract
-                    query = query.where(text(f"json_extract(attributes, '$.{key}') = :value").bindparams(value=str(value)))
+                    safe_key = _sanitize_key(key)
+                    if value is None:
+                        query = query.where(text(f"json_extract(attributes, '$.{safe_key}') IS NULL"))
+                    elif isinstance(value, bool):
+                        # SQLite stores booleans as 1/0
+                        num_val = 1 if value else 0
+                        query = query.where(text(f"json_extract(attributes, '$.{safe_key}') = {num_val}"))
+                    else:
+                        query = query.where(
+                            text(f"json_extract(attributes, '$.{safe_key}') = :value").bindparams(value=str(value))
+                        )
                 else:
                     # Use PostgreSQL JSONB operators via text() for direct SQL control
                     logger.info(f"Searching for attribute[{key}] = {value} (type: {type(value)})")
@@ -445,7 +456,8 @@ class SQLBackend(StorageBackend):
                     # Handle different value types appropriately
                     if value is None:
                         # Check for null/None values
-                        query = query.where(text(f"attributes->>'{key}' IS NULL"))
+                        safe_key = _sanitize_key(key)
+                        query = query.where(text(f"attributes->>'{safe_key}' IS NULL"))
                     else:
                         # Convert value to string for text comparison
                         str_value = str(value)
@@ -454,10 +466,11 @@ class SQLBackend(StorageBackend):
                             str_value = str(value).lower()
                         
                         # Use PostgreSQL's JSONB operators for direct string comparison
-                        param_name = f"attr_{key}"
+                        safe_key = _sanitize_key(key)
+                        param_name = f"attr_{safe_key}"
                         bp = bindparam(param_name, str_value)
                         query = query.where(
-                            text(f"attributes->>'{key}' = :{param_name}").bindparams(bp)
+                            text(f"attributes->>'{safe_key}' = :{param_name}").bindparams(bp)
                         )
             
             # Log the final query for debugging
@@ -481,28 +494,38 @@ class SQLBackend(StorageBackend):
             
             if self.database_url.startswith('sqlite'):
                 # Use SQLite json_extract for platform name
-                query = query.where(text(f"json_extract(platforms, '$.{platform_name}') IS NOT NULL"))
+                safe_platform = _sanitize_key(platform_name)
+                query = query.where(text(f"json_extract(platforms, '$.{safe_platform}') IS NOT NULL"))
                 # Add property conditions
                 for key, value in properties.items():
                     # Convert value to string for text comparison
-                    str_value = str(value)
-                    param_name = f"value_{platform_name}_{key}" # Ensure unique param name
-                    bp = bindparam(param_name, str_value)
-                    query = query.where(
-                        text(f"json_extract(platforms, '$.{platform_name}.{key}') = :{param_name}")
-                        .bindparams(bp)
-                    )
+                    safe_key = _sanitize_key(key)
+                    if value is None:
+                        query = query.where(text(f"json_extract(platforms, '$.{safe_platform}.{safe_key}') IS NULL"))
+                    elif isinstance(value, bool):
+                        num_val = 1 if value else 0
+                        query = query.where(text(f"json_extract(platforms, '$.{safe_platform}.{safe_key}') = {num_val}"))
+                    else:
+                        str_value = str(value)
+                        param_name = f"value_{safe_platform}_{safe_key}" # Ensure unique param name
+                        bp = bindparam(param_name, str_value)
+                        query = query.where(
+                            text(f"json_extract(platforms, '$.{safe_platform}.{safe_key}') = :{param_name}")
+                            .bindparams(bp)
+                        )
             else:
                 # Use PostgreSQL JSONB operators for platform checks
-                query = query.where(text(f"platforms ? '{platform_name}'"))
+                safe_platform = _sanitize_key(platform_name)
+                query = query.where(text(f"platforms ? '{safe_platform}'"))
                 
                 # Add property conditions with text() for proper PostgreSQL JSONB syntax
                 for key, value in properties.items():
                     str_value = str(value)
-                    param_name = f"value_{platform_name}_{key}"
+                    safe_key = _sanitize_key(key)
+                    param_name = f"value_{safe_platform}_{safe_key}"
                     bp = bindparam(param_name, str_value)
                     query = query.where(
-                        text(f"platforms->'{platform_name}'->>'{key}' = :{param_name}")
+                        text(f"platforms->'{safe_platform}'->>'{safe_key}' = :{param_name}")
                         .bindparams(bp)
                     )
             
@@ -540,16 +563,33 @@ class SQLBackend(StorageBackend):
         try:
             query = select(MessageRecord)
             
+            # Normalize and sanitize path parts
+            parts = [p for p in path.split('.') if p]
+            parts = [_sanitize_key(p) for p in parts]
+            if not parts:
+                return []
+            # Support paths prefixed with 'source.' by stripping the leading component
+            if parts and parts[0] == 'source':
+                parts = parts[1:]
+                if not parts:
+                    return []
             if self.database_url.startswith('sqlite'):
-                # Use SQLite json_extract
-                json_path = '$.' + path.replace('.', '.')
-                query = query.where(text(f"json_extract(source, '{json_path}') = :value").bindparams(value=str(value)))
+                # Use SQLite json_extract with a proper JSON path: $.a.b.c (safe due to sanitized parts)
+                json_path = '$.' + '.'.join(parts)
+                query = query.where(
+                    text(f"json_extract(source, '{json_path}') = :value").bindparams(value=str(value))
+                )
             else:
-                # Use PostgreSQL JSONB operators
-                # Convert dot notation to PostgreSQL JSON path
-                path_parts = path.split('.')
-                json_path = '->'.join([f"'{part}'" for part in path_parts[:-1]]) + f"->>'{path_parts[-1]}'"
-                query = query.where(text(f"source{json_path} = :value").bindparams(value=str(value)))
+                # Use PostgreSQL JSONB operators: source->'a'->'b'->>'c' (last part text)
+                if len(parts) == 1:
+                    pg_expr = f"source->>'{parts[0]}'"
+                else:
+                    head = parts[:-1]
+                    tail = parts[-1]
+                    pg_expr = "source" + ''.join([f"->'{h}'" for h in head]) + f"->>'{tail}'"
+                query = query.where(
+                    text(f"{pg_expr} = :value").bindparams(value=str(value))
+                )
             
             result = await session.execute(query)
             return result.scalars().all()

narrator/storage/file_store.py

@@ -494,13 +494,7 @@ class FileStore:
                 files.append(file_id)
         return files
 
-    def _handle_data_url(self, content: bytes) -> bytes:
-        """Handle data URLs"""
-        if self.content.startswith('data:'):
-            # Handle data URLs
-            header, encoded = self.content.split(",", 1)
-            return base64.b64decode(encoded)
-        return content
+    # Note: data URL handling is performed at the Attachment layer where the content type is known.
 
     @classmethod
     def get_base_path(cls) -> str:

narrator/utils/logging.py

@@ -3,36 +3,30 @@ import os
 import logging
 from typing import Optional
 
+class _NarratorNullHandler(logging.Handler):
+    def emit(self, record):
+        pass
+
 _is_configured = False
 
 def _ensure_logging_configured():
-    """Internal function to configure logging if not already configured."""
+    """Attach a NullHandler and optionally set level based on env without overriding app config."""
     global _is_configured
     if _is_configured:
         return
 
-    # Get log level from environment and convert to uppercase
-    log_level_str = os.getenv('NARRATOR_LOG_LEVEL', os.getenv('LOG_LEVEL', 'INFO')).upper()
-    
-    # Convert string to logging level constant
-    try:
-        log_level = getattr(logging, log_level_str)
-    except AttributeError:
-        print(f"Invalid LOG_LEVEL: {log_level_str}. Defaulting to INFO.")
-        log_level = logging.INFO
-    
-    # Configure the root logger with our format
-    logging.basicConfig(
-        level=log_level,
-        format='%(asctime)s - %(name)s - %(levelname)s - %(message)s',
-        datefmt='%H:%M:%S',
-        force=True  # Ensure we override any existing configuration
-    )
-    
-    # Get the root logger and set its level
-    root_logger = logging.getLogger()
-    root_logger.setLevel(log_level)
-    
+    logger = logging.getLogger('narrator')
+    # Avoid duplicate handlers
+    if not any(isinstance(h, _NarratorNullHandler) for h in logger.handlers):
+        logger.addHandler(_NarratorNullHandler())
+
+    # Respect env level but do not call basicConfig or force reconfigure
+    log_level_str = os.getenv('NARRATOR_LOG_LEVEL', os.getenv('LOG_LEVEL', '')).upper()
+    if log_level_str:
+        level = getattr(logging, log_level_str, None)
+        if isinstance(level, int):
+            logger.setLevel(level)
+
     _is_configured = True
 
 def get_logger(name: Optional[str] = None) -> logging.Logger:
@@ -55,4 +49,4 @@ def get_logger(name: Optional[str] = None) -> logging.Logger:
         logger.debug("Debug message")  # Will respect NARRATOR_LOG_LEVEL from .env
     """
     _ensure_logging_configured()
-    return logging.getLogger(name or '__name__') 
+    return logging.getLogger(name or 'narrator.unknown')

{slide_narrator-1.0.0.dist-info → slide_narrator-1.0.2.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: slide-narrator
-Version: 1.0.0
+Version: 1.0.2
 Summary: Thread and file storage components for conversational AI - the companion to Tyler AI framework
 Project-URL: Homepage, https://github.com/adamwdraper/slide
 Project-URL: Repository, https://github.com/adamwdraper/slide
@@ -15,6 +15,7 @@ Classifier: Operating System :: OS Independent
 Classifier: Programming Language :: Python :: 3
 Classifier: Programming Language :: Python :: 3.11
 Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
 Requires-Python: >=3.11
 Requires-Dist: aiosqlite>=0.21.0
 Requires-Dist: alembic>=1.14.1
@@ -25,7 +26,6 @@ Requires-Dist: pydantic>=2.10.4
 Requires-Dist: pypdf>=5.3.0
 Requires-Dist: python-magic>=0.4.0
 Requires-Dist: sqlalchemy>=2.0.36
-Requires-Dist: uuid-utils>=0.10.0
 Provides-Extra: dev
 Requires-Dist: coverage>=7.6.10; extra == 'dev'
 Requires-Dist: pytest-asyncio>=0.25.2; extra == 'dev'
@@ -74,19 +74,72 @@ pip install slide-narrator
 
 ## Setup
 
+### Docker Setup (Recommended for Development)
+
+For local development with PostgreSQL, Narrator includes built-in Docker commands:
+
+```bash
+# One-command setup: starts PostgreSQL and initializes tables
+uv run narrator docker-setup
+
+# This will:
+# 1. Start a PostgreSQL container
+# 2. Wait for it to be ready  
+# 3. Initialize the database tables
+# 4. Show you the connection string
+
+# The database will be available at:
+# postgresql+asyncpg://narrator:narrator_dev@localhost:5432/narrator
+```
+
+To manage the Docker container:
+
+```bash
+# Stop container (preserves data)
+uv run narrator docker-stop
+
+# Stop and remove all data
+uv run narrator docker-stop --remove-volumes
+
+# Start container again
+uv run narrator docker-start
+
+# Check database status
+uv run narrator status
+```
+
+For custom configurations, the Docker commands respect environment variables:
+
+```bash
+# Use a different port
+uv run narrator docker-setup --port 5433
+
+# Or set environment variables (matching docker-compose.yml)
+export NARRATOR_DB_NAME=mydb
+export NARRATOR_DB_USER=myuser
+export NARRATOR_DB_PASSWORD=mypassword
+export NARRATOR_DB_PORT=5433
+
+# Then run docker-setup
+uv run narrator docker-setup
+
+# This will create:
+# postgresql+asyncpg://myuser:mypassword@localhost:5433/mydb
+```
+
 ### Database Setup
 
 For production use with PostgreSQL or SQLite persistence, you'll need to initialize the database tables:
 
 ```bash
 # Initialize database tables (PostgreSQL)
-narrator-db init --database-url "postgresql+asyncpg://user:password@localhost/dbname"
+uv run narrator init --database-url "postgresql+asyncpg://user:password@localhost/dbname"
 
 # Initialize database tables (SQLite)
-narrator-db init --database-url "sqlite+aiosqlite:///path/to/your/database.db"
+uv run narrator init --database-url "sqlite+aiosqlite:///path/to/your/database.db"
 
 # Check database status
-narrator-db status --database-url "postgresql+asyncpg://user:password@localhost/dbname"
+uv run narrator status --database-url "postgresql+asyncpg://user:password@localhost/dbname"
 ```
 
 You can also use environment variables instead of passing the database URL:
@@ -96,8 +149,8 @@ You can also use environment variables instead of passing the database URL:
 export NARRATOR_DATABASE_URL="postgresql+asyncpg://user:password@localhost/dbname"
 
 # Then run without --database-url flag
-narrator-db init
-narrator-db status
+uv run narrator init
+uv run narrator status
 ```
 
 ### Environment Variables
@@ -382,22 +435,22 @@ The Narrator includes a CLI tool for database management:
 
 ```bash
 # Initialize database tables
-narrator-db init --database-url "postgresql+asyncpg://user:pass@localhost/dbname"
+uv run narrator init --database-url "postgresql+asyncpg://user:pass@localhost/dbname"
 
 # Initialize using environment variable
 export NARRATOR_DATABASE_URL="postgresql+asyncpg://user:pass@localhost/dbname"
-narrator-db init
+uv run narrator init
 
 # Check database status
-narrator-db status --database-url "postgresql+asyncpg://user:pass@localhost/dbname"
+uv run narrator status --database-url "postgresql+asyncpg://user:pass@localhost/dbname"
 
 # Check status using environment variable
-narrator-db status
+uv run narrator status
 ```
 
 Available commands:
-- `narrator-db init` - Initialize database tables
-- `narrator-db status` - Check database connection and basic statistics
+- `uv run narrator init` - Initialize database tables
+- `uv run narrator status` - Check database connection and basic statistics
 
 ## Key Design Principles
 
@@ -480,7 +533,7 @@ uv run pytest tests/ -v
 ### Test Requirements
 
 The test suite requires:
-- Python 3.12+
+- Python 3.13+
 - pytest with async support
 - Test coverage reporting
 - System dependencies (libmagic for file type detection)

{slide_narrator-1.0.0.dist-info → slide_narrator-1.0.2.dist-info}/RECORD

@@ -1,8 +1,8 @@
-narrator/__init__.py,sha256=3NsXekWzkpNumnCQ0AY0dHdpou_EaMJS_V4C7wZD2pg,403
+narrator/__init__.py,sha256=xNe6Xc5aX4gZbtgxEq8k93iUfr62z2dIFsrVScEDIAk,403
 narrator/database/__init__.py,sha256=UngOnFqImCeJiMZlMasm72mC4-UnJDDvfu1MNQLkRA8,189
-narrator/database/cli.py,sha256=Wi5kSXWFTkWBjZS1N9AuGEmTUrYjafUOTZUSO9cGfTM,1954
+narrator/database/cli.py,sha256=QvET17X5kLZ7GiOTw0b80-u4FuI-tOTu4SjAqCBkiSs,8355
 narrator/database/models.py,sha256=wsG_5GrPo41hAcojjZTZmSx6bijea-Skan-DwzHs8os,2607
-narrator/database/storage_backend.py,sha256=UeMgxW8h3ZNWORZNH_f-jZuHNjHpREBaOOAFPeEPlvA,25444
+narrator/database/storage_backend.py,sha256=y0bPNNHpIYInLTXwncY7LMU7B6zWQE3zcPanmQXa1XM,27481
 narrator/database/thread_store.py,sha256=vMIPDdwuSpTyPogEUmxGcILxM_r1wxoQBUOn8XJpdqM,11301
 narrator/database/migrations/__init__.py,sha256=IqoSL8eCcbcOtn96u2_TTrNG0KN1Jn1yreDZEO4RsnM,173
 narrator/models/__init__.py,sha256=J8Rsv2lmfGR5QmUjoAPEFTSQt5TGtyrBynnp17HdZnU,179
@@ -10,11 +10,11 @@ narrator/models/attachment.py,sha256=6fZnGla_Ahgc4Kro2bHBTWoF_Kr-mUBHzONizVH73oc
 narrator/models/message.py,sha256=-e0WzT5cJMrh7dDQgofHkHz0-z2KF4fHhe8nk9iG_OQ,21144
 narrator/models/thread.py,sha256=4HKnCW8MkF52vYA6FQga1awxMA7OPjxOZL4QBcXpYOo,19218
 narrator/storage/__init__.py,sha256=K4cxGITSQoQiw32QOWZsCBm11fwDTbsyzHGeAqcL6yY,101
-narrator/storage/file_store.py,sha256=-k1ZYzKYioCMiP7KfWuuCmCeAzDqRv38ndpuM75yISY,20047
+narrator/storage/file_store.py,sha256=m2btUQcbqpHbWm-htPe1_zwcGRmFXatmS_m9rB9ac2U,19858
 narrator/utils/__init__.py,sha256=P4BhLvBJbBvb8qha2tTZPlYbjCRXth_K97f4vNc77UI,109
-narrator/utils/logging.py,sha256=K9EWI7lP4CNQpPwggiqzMex7oF6oyL3wIVLik2iuXd4,1983
-slide_narrator-1.0.0.dist-info/METADATA,sha256=W5-QQVHN3pY6JF1lCCWsTse4gGlGa9eQqux6JT3Al54,15194
-slide_narrator-1.0.0.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
-slide_narrator-1.0.0.dist-info/entry_points.txt,sha256=EaFuawrdPNFByqzAb17gkkDyj4FgelJqmII6ioD-i_I,59
-slide_narrator-1.0.0.dist-info/licenses/LICENSE,sha256=g6cGasroU9sqSOjThWg14w0BMlwZhgmOQQVTiu036ks,1068
-slide_narrator-1.0.0.dist-info/RECORD,,
+narrator/utils/logging.py,sha256=Hm6D4VX03e28UCkNS1pCOXnYQKHQ2nz_PvZX8h-wLgg,1807
+slide_narrator-1.0.2.dist-info/METADATA,sha256=MBGv40hmJ_tUlCEWgjKogzQWEpef4u9G0gs5RjSIHjA,16514
+slide_narrator-1.0.2.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
+slide_narrator-1.0.2.dist-info/entry_points.txt,sha256=5Oa53AERvPVdrEvsdWbY85xfzAGayOqq_P4KEmf1khA,56
+slide_narrator-1.0.2.dist-info/licenses/LICENSE,sha256=g6cGasroU9sqSOjThWg14w0BMlwZhgmOQQVTiu036ks,1068
+slide_narrator-1.0.2.dist-info/RECORD,,

slide_narrator-1.0.2.dist-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+narrator = narrator.database.cli:main

slide_narrator-1.0.0.dist-info/entry_points.txt

@@ -1,2 +0,0 @@
-[console_scripts]
-narrator-db = narrator.database.cli:main