synth-ai 0.2.2.dev0__py3-none-any.whl → 0.2.3__py3-none-any.whl

synth_ai/tracing_v3/db_config.py

@@ -18,7 +18,7 @@ class DatabaseConfig:
     """Centralized database configuration management."""
 
     # Default values from serve.sh
-    DEFAULT_DB_FILE = "synth_ai.db"
+    DEFAULT_DB_FILE = "traces/v3/synth_ai.db"
     DEFAULT_HTTP_PORT = 8080
 
     def __init__(
@@ -58,15 +58,15 @@ class DatabaseConfig:
 
         if os.path.exists(sqld_data_path):
             # sqld is managing the database
-            logger.info(f"✅ Using sqld-managed database at: {sqld_data_path}")
+            logger.debug(f"✅ Using sqld-managed database at: {sqld_data_path}")
             actual_db_path = sqld_data_path
         else:
             # Direct SQLite file
             if not os.path.exists(abs_path):
-                logger.warning(f"⚠️  Database file not found at: {abs_path}")
-                logger.warning("🔧 Make sure to run './serve.sh' to start the turso/sqld service")
+                logger.debug(f"⚠️  Database file not found at: {abs_path}")
+                logger.debug("🔧 Make sure to run './serve.sh' to start the turso/sqld service")
             else:
-                logger.info(f"📁 Using direct SQLite file at: {abs_path}")
+                logger.debug(f"📁 Using direct SQLite file at: {abs_path}")
             actual_db_path = abs_path
 
         # SQLite URLs need 3 slashes for absolute paths
@@ -147,7 +147,7 @@ def get_default_db_config() -> DatabaseConfig:
                 # sqld is already running, don't start a new one
                 sqld_running = True
                 use_sqld = False
-                logger.info(f"✅ Detected sqld already running on port {sqld_port}")
+                logger.debug(f"✅ Detected sqld already running on port {sqld_port}")
         except Exception as e:
             logger.debug(f"Could not check for sqld process: {e}")
 

synth_ai/tracing_v3/turso/manager.py

@@ -91,7 +91,7 @@ class AsyncSQLTraceManager:
         concurrent scenarios.
         """
         if self.engine is None:
-            logger.info(f"🔗 Initializing database connection to: {self.db_url}")
+            logger.debug(f"🔗 Initializing database connection to: {self.db_url}")
 
             # For SQLite, use NullPool to avoid connection pool issues
             # SQLite doesn't handle concurrent connections well, so we create
@@ -103,12 +103,12 @@ class AsyncSQLTraceManager:
 
                 # Check if database file exists
                 if not os.path.exists(db_path):
-                    logger.warning(f"⚠️  Database file not found: {db_path}")
-                    logger.warning(
+                    logger.debug(f"⚠️  Database file not found: {db_path}")
+                    logger.debug(
                         "🔧 Make sure './serve.sh' is running to start the turso/sqld service"
                     )
                 else:
-                    logger.info(f"✅ Found database file: {db_path}")
+                    logger.debug(f"✅ Found database file: {db_path}")
 
                 # Set a high busy timeout to handle concurrent access
                 # This allows SQLite to wait instead of immediately failing
@@ -145,7 +145,7 @@ class AsyncSQLTraceManager:
             if self._schema_ready:
                 return
 
-            logger.info("📊 Initializing database schema...")
+            logger.debug("📊 Initializing database schema...")
 
             async with self.engine.begin() as conn:
                 # Use a transaction to ensure atomic schema creation
@@ -154,14 +154,14 @@ class AsyncSQLTraceManager:
                     await conn.run_sync(
                         lambda sync_conn: Base.metadata.create_all(sync_conn, checkfirst=True)
                     )
-                    logger.info("✅ Database schema created/verified successfully")
+                    #logger.info("✅ Database schema created/verified successfully")
                 except Exception as e:
                     # If tables already exist, that's fine - another worker created them
                     if "already exists" not in str(e):
                         logger.error(f"❌ Failed to create database schema: {e}")
                         raise
                     else:
-                        logger.info("✅ Database schema already exists")
+                        logger.debug("✅ Database schema already exists")
 
                 # Enable foreign keys for SQLite - critical for data integrity
                 # This must be done for each connection in SQLite
@@ -183,7 +183,7 @@ class AsyncSQLTraceManager:
                             logger.warning(f"Could not create view {view_name}: {e}")
 
             self._schema_ready = True
-            logger.info("🎯 Database ready for use!")
+            #logger.debug("🎯 Database ready for use!")
 
     @asynccontextmanager
     async def session(self):

synth_ai/tui/__main__.py

@@ -0,0 +1,13 @@
+#!/usr/bin/env python3
+"""
+Entry point for Synth AI TUI dashboard.
+
+Usage:
+    python -m synth_ai.tui
+    python -m synth_ai.tui --url sqlite+aiosqlite:///path/to/db
+"""
+
+from .dashboard import main
+
+if __name__ == "__main__":
+    main()

synth_ai/tui/dashboard.py

@@ -0,0 +1,329 @@
+#!/usr/bin/env python3
+"""
+Interactive TUI Dashboard for Synth AI experiments.
+
+Launch with: python -m synth_ai.tui.dashboard
+"""
+
+import asyncio
+import logging
+from datetime import datetime
+from typing import List, Optional, Dict, Any
+from urllib.parse import urlparse
+
+from textual.app import App, ComposeResult
+from textual.containers import Container, Horizontal, Vertical
+from textual.widgets import (
+    Header, Footer, DataTable, Static, Input, Button, 
+    TabbedContent, TabPane, Label, ProgressBar
+)
+from textual.reactive import reactive
+from textual.binding import Binding
+from textual import on
+from textual.timer import Timer
+
+from ..tracing_v3.turso.manager import AsyncSQLTraceManager
+
+class ExperimentRow:
+    """Data structure for experiment display."""
+    def __init__(self, exp_id: str, name: str, description: str, 
+                 created_at: datetime, sessions: int, events: int, 
+                 messages: int, cost: float, tokens: int):
+        self.exp_id = exp_id
+        self.name = name or "Unnamed"
+        self.description = description or ""
+        self.created_at = created_at
+        self.sessions = sessions
+        self.events = events  
+        self.messages = messages
+        self.cost = cost
+        self.tokens = tokens
+        
+    def to_row(self) -> List[str]:
+        """Convert to table row format."""
+        return [
+            self.exp_id[:8],  # Shortened ID
+            self.name[:20],   # Truncated name
+            str(self.sessions),
+            str(self.events),
+            str(self.messages),
+            f"${self.cost:.4f}",
+            f"{self.tokens:,}",
+            self.created_at.strftime("%H:%M")
+        ]
+
+class ExperimentTable(DataTable):
+    """Custom DataTable for experiments with refresh capability."""
+    
+    def __init__(self, **kwargs):
+        super().__init__(**kwargs)
+        self.experiments: List[ExperimentRow] = []
+        self.selected_exp_id: Optional[str] = None
+        
+    def setup_table(self):
+        """Initialize table columns."""
+        self.add_columns(
+            "ID", "Name", "Sessions", "Events", 
+            "Messages", "Cost", "Tokens", "Time"
+        )
+        
+    async def refresh_data(self, db_manager: AsyncSQLTraceManager):
+        """Refresh experiment data from database."""
+        try:
+            # Get experiment list with stats using raw query
+            df = await db_manager.query_traces("""
+                SELECT 
+                    e.experiment_id,
+                    e.name,
+                    e.description,
+                    e.created_at,
+                    COUNT(DISTINCT st.session_id) as num_sessions,
+                    COUNT(DISTINCT ev.id) as num_events,
+                    COUNT(DISTINCT m.id) as num_messages,
+                    SUM(CASE WHEN ev.event_type = 'cais' THEN ev.cost_usd ELSE 0 END) / 100.0 as total_cost,
+                    SUM(CASE WHEN ev.event_type = 'cais' THEN ev.total_tokens ELSE 0 END) as total_tokens
+                FROM experiments e
+                LEFT JOIN session_traces st ON e.experiment_id = st.experiment_id
+                LEFT JOIN events ev ON st.session_id = ev.session_id
+                LEFT JOIN messages m ON st.session_id = m.session_id
+                GROUP BY e.experiment_id, e.name, e.description, e.created_at
+                ORDER BY e.created_at DESC
+            """)
+            
+            self.experiments.clear()
+            self.clear()
+            
+            if not df.empty:
+                for _, row in df.iterrows():
+                    exp_row = ExperimentRow(
+                        exp_id=row['experiment_id'],
+                        name=row['name'],
+                        description=row['description'],
+                        created_at=row['created_at'],
+                        sessions=int(row['num_sessions'] or 0),
+                        events=int(row['num_events'] or 0),
+                        messages=int(row['num_messages'] or 0),
+                        cost=float(row['total_cost'] or 0.0),
+                        tokens=int(row['total_tokens'] or 0)
+                    )
+                    self.experiments.append(exp_row)
+                    self.add_row(*exp_row.to_row(), key=exp_row.exp_id)
+                
+        except Exception as e:
+            logging.error(f"Failed to refresh experiments: {e}")
+            
+    def get_selected_experiment(self) -> Optional[ExperimentRow]:
+        """Get currently selected experiment."""
+        if self.cursor_row >= 0 and self.cursor_row < len(self.experiments):
+            return self.experiments[self.cursor_row]
+        return None
+
+class ExperimentDetail(Static):
+    """Detailed view of selected experiment."""
+    
+    def __init__(self, **kwargs):
+        super().__init__(**kwargs)
+        self.current_experiment: Optional[ExperimentRow] = None
+        
+    def update_experiment(self, experiment: Optional[ExperimentRow]):
+        """Update the displayed experiment details."""
+        self.current_experiment = experiment
+        if experiment:
+            details = f"""
+🔬 **{experiment.name}**
+ID: {experiment.exp_id}
+Description: {experiment.description or 'No description'}
+
+📊 **Statistics**
+Sessions: {experiment.sessions}
+Events: {experiment.events}  
+Messages: {experiment.messages}
+Cost: ${experiment.cost:.4f}
+Tokens: {experiment.tokens:,}
+
+🕒 **Created**: {experiment.created_at.strftime('%Y-%m-%d %H:%M:%S')}
+            """.strip()
+        else:
+            details = "Select an experiment to view details"
+            
+        self.update(details)
+
+class DatabaseStatus(Static):
+    """Display database connection status."""
+    
+    connection_status = reactive("🔴 Disconnected")
+    
+    def __init__(self, **kwargs):
+        super().__init__(**kwargs)
+        
+    def render(self) -> str:
+        return f"Database: {self.connection_status}"
+        
+    def set_connected(self, url: str):
+        parsed = urlparse(url)
+        host_info = f"{parsed.hostname}:{parsed.port}" if parsed.port else str(parsed.hostname)
+        self.connection_status = f"🟢 Connected ({host_info})"
+        
+    def set_disconnected(self, error: str = ""):
+        error_text = f" - {error}" if error else ""
+        self.connection_status = f"🔴 Disconnected{error_text}"
+
+class SynthDashboard(App):
+    """Main Synth AI TUI Dashboard application."""
+    
+    CSS = """
+    Screen {
+        layout: grid;
+        grid-size: 2 3;
+        grid-gutter: 1;
+    }
+    
+    #header {
+        column-span: 2;
+        height: 3;
+    }
+    
+    #experiments-table {
+        row-span: 2;
+    }
+    
+    #experiment-detail {
+        height: 1fr;
+    }
+    
+    #status-bar {
+        column-span: 2;
+        height: 3;
+    }
+    
+    ExperimentTable {
+        height: 100%;
+    }
+    
+    ExperimentDetail {
+        border: solid $primary;
+        padding: 1;
+        height: 100%;
+    }
+    
+    DatabaseStatus {
+        height: 1;
+        padding: 0 1;
+    }
+    """
+    
+    BINDINGS = [
+        Binding("q", "quit", "Quit"),
+        Binding("r", "refresh", "Refresh"),
+        Binding("d", "toggle_debug", "Debug"),
+        ("ctrl+c", "quit", "Quit"),
+    ]
+    
+    def __init__(self, db_url: str = "sqlite+aiosqlite:///./synth_ai.db/dbs/default/data"):
+        super().__init__()
+        self.db_url = db_url
+        self.db_manager: Optional[AsyncSQLTraceManager] = None
+        self.refresh_timer: Optional[Timer] = None
+        
+    def compose(self) -> ComposeResult:
+        """Create the UI layout."""
+        yield Header(show_clock=True)
+        
+        with Container(id="experiments-table"):
+            yield Static("🧪 Experiments", classes="section-title")
+            yield ExperimentTable(id="experiments")
+            
+        with Container(id="experiment-detail"):
+            yield Static("📋 Details", classes="section-title")  
+            yield ExperimentDetail(id="detail")
+            
+        with Container(id="status-bar"):
+            yield DatabaseStatus(id="db-status")
+            yield Footer()
+            
+    async def on_mount(self) -> None:
+        """Initialize the app when mounted."""
+        # Setup database connection
+        try:
+            self.db_manager = AsyncSQLTraceManager(self.db_url)
+            await self.db_manager.initialize()
+            
+            db_status = self.query_one("#db-status", DatabaseStatus)
+            db_status.set_connected(self.db_url)
+            
+        except Exception as e:
+            logging.error(f"Failed to connect to database: {e}")
+            db_status = self.query_one("#db-status", DatabaseStatus)
+            db_status.set_disconnected(str(e))
+            
+        # Setup experiment table
+        exp_table = self.query_one("#experiments", ExperimentTable)
+        exp_table.setup_table()
+        
+        # Initial data load
+        await self.action_refresh()
+        
+        # Start auto-refresh timer (every 5 seconds)
+        self.refresh_timer = self.set_interval(5.0, self._auto_refresh)
+        
+    async def _auto_refresh(self) -> None:
+        """Auto-refresh data periodically."""
+        if self.db_manager:
+            exp_table = self.query_one("#experiments", ExperimentTable)
+            await exp_table.refresh_data(self.db_manager)
+            
+    async def action_refresh(self) -> None:
+        """Manual refresh action."""
+        if self.db_manager:
+            exp_table = self.query_one("#experiments", ExperimentTable)
+            await exp_table.refresh_data(self.db_manager)
+            
+    async def action_quit(self) -> None:
+        """Quit the application."""
+        if self.refresh_timer:
+            self.refresh_timer.stop()
+        if self.db_manager:
+            await self.db_manager.close()
+        self.exit()
+        
+    def action_toggle_debug(self) -> None:
+        """Toggle debug mode."""
+        # Could add debug panel or logging level toggle
+        pass
+        
+    @on(DataTable.RowHighlighted, "#experiments")
+    def on_experiment_selected(self, event: DataTable.RowHighlighted) -> None:
+        """Handle experiment selection."""
+        exp_table = self.query_one("#experiments", ExperimentTable)
+        selected_exp = exp_table.get_selected_experiment()
+        
+        detail_panel = self.query_one("#detail", ExperimentDetail)
+        detail_panel.update_experiment(selected_exp)
+
+def main():
+    """Main entry point for the dashboard."""
+    import argparse
+    
+    parser = argparse.ArgumentParser(description="Synth AI Interactive Dashboard")
+    parser.add_argument(
+        "-u", "--url", 
+        default="sqlite+libsql://http://127.0.0.1:8080",
+        help="Database URL (default: sqlite+libsql://http://127.0.0.1:8080)"
+    )
+    parser.add_argument(
+        "--debug",
+        action="store_true",
+        help="Enable debug logging"
+    )
+    
+    args = parser.parse_args()
+    
+    if args.debug:
+        logging.basicConfig(level=logging.DEBUG)
+        
+    # Run the dashboard
+    app = SynthDashboard(db_url=args.url)
+    app.run()
+
+if __name__ == "__main__":
+    main()

synth_ai/{tracing → v0/tracing}/base_client.py

@@ -4,9 +4,9 @@ from abc import ABC, abstractmethod
 from dataclasses import dataclass
 from typing import Any, Dict, Optional
 
-from synth_ai.tracing.abstractions import Event
-from synth_ai.tracing.config import TracingConfig
-from synth_ai.tracing.events.store import event_store
+from .abstractions import Event
+from .config import TracingConfig
+from .events.store import event_store
 
 logger = logging.getLogger(__name__)
 

synth_ai/{tracing → v0/tracing}/client_manager.py

@@ -6,7 +6,7 @@ from typing import ClassVar, Dict, Optional
 
 import httpx
 
-from synth_ai.tracing.config import TracingConfig
+from .config import TracingConfig
 
 
 class ClientManager:

synth_ai/{tracing → v0/tracing}/context.py

@@ -3,7 +3,7 @@ import logging
 from contextlib import contextmanager
 from typing import Any, Dict, Generic, Optional, TypeVar
 
-from synth_ai.tracing.local import (
+from .local import (
     _local,
     active_events_var,
     system_id_var,

synth_ai/{tracing → v0/tracing}/decorators.py

@@ -7,9 +7,9 @@ from functools import wraps
 from typing import TYPE_CHECKING, Any, Callable, Dict, List, Literal, ParamSpec, TypeVar, Union
 
 if TYPE_CHECKING:
-    from synth_ai.tracing.trackers import SynthTrackerAsync, SynthTrackerSync
+    from .trackers import SynthTrackerAsync, SynthTrackerSync
 
-from synth_ai.tracing.abstractions import (
+from .abstractions import (
     AgentComputeStep,
     ArbitraryInputs,
     ArbitraryOutputs,
@@ -18,28 +18,28 @@ from synth_ai.tracing.abstractions import (
     MessageInputs,
     MessageOutputs,
 )
-from synth_ai.tracing.config import EventManagement, LoggingMode, Origin, TracingConfig
-from synth_ai.tracing.context import (
+from .config import EventManagement, LoggingMode, Origin, TracingConfig
+from .context import (
     get_current_context,
     trace_context,
 )
-from synth_ai.tracing.events.manage import set_current_event
-from synth_ai.tracing.events.store import event_store
-from synth_ai.tracing.immediate_client import (
+from .events.manage import set_current_event
+from .events.store import event_store
+from .immediate_client import (
     AsyncImmediateLogClient,
     ImmediateLogClient,
 )
-from synth_ai.tracing.local import (
+from .local import (
     _local,
     active_events_var,
     logger,
 )
-from synth_ai.tracing.retry_queue import initialize_retry_queue, retry_queue
-from synth_ai.tracing.trackers import (
+from .retry_queue import initialize_retry_queue, retry_queue
+from .trackers import (
     synth_tracker_async,
     synth_tracker_sync,
 )
-from synth_ai.tracing.utils import get_system_id
+from .utils import get_system_id
 
 logger = logging.getLogger(__name__)
 

synth_ai/{tracing → v0/tracing}/events/manage.py

@@ -1,9 +1,9 @@
 import time
 from typing import Literal, Optional
 
-from synth_ai.tracing.abstractions import Event
-from synth_ai.tracing.events.store import event_store
-from synth_ai.tracing.local import _local, logger
+from ..abstractions import Event
+from ..events.store import event_store
+from ..local import _local, logger
 
 
 def get_current_event(event_type: str) -> "Event":
@@ -75,7 +75,7 @@ def set_current_event(event: Optional["Event"], decorator_type: Literal["sync",
             _local.active_events[unique_key] = event  # Unique key for async
 
     else:
-        from synth_ai.tracing.local import (
+        from ..local import (
             active_events_var,
             system_id_var,
             system_instance_id_var,

synth_ai/{tracing → v0/tracing}/events/scope.py

@@ -1,20 +1,20 @@
 import time
 from contextlib import contextmanager
 
-from synth_ai.tracing.abstractions import Event
-from synth_ai.tracing.config import LoggingMode
-from synth_ai.tracing.decorators import (
+from ..abstractions import Event
+from ..config import LoggingMode
+from ..decorators import (
     _local,
     clear_current_event,
     get_tracing_config,
     set_current_event,
 )
-from synth_ai.tracing.events.store import event_store
-from synth_ai.tracing.immediate_client import (
+from ..events.store import event_store
+from ..immediate_client import (
     AsyncImmediateLogClient,
     ImmediateLogClient,
 )
-from synth_ai.tracing.local import (
+from ..local import (
     system_id_var,
     system_instance_id_var,
     system_name_var,

synth_ai/{tracing → v0/tracing}/events/store.py

@@ -4,8 +4,8 @@ import time
 from threading import RLock  # Change this import
 from typing import Any, Dict, List
 
-from synth_ai.tracing.abstractions import Event, EventPartitionElement, SystemTrace
-from synth_ai.tracing.local import (  # Import context variables
+from ..abstractions import Event, EventPartitionElement, SystemTrace
+from ..local import (  # Import context variables
     _local,
     active_events_var,
 )
@@ -36,7 +36,7 @@ class EventStore:
                 # Get system_instance_metadata from context if available
                 system_instance_metadata = {}
                 try:
-                    from synth_ai.tracing.context import get_current_context
+                    from ..context import get_current_context
 
                     context = get_current_context()
                     if (

synth_ai/{tracing → v0/tracing}/immediate_client.py

@@ -5,10 +5,10 @@ from typing import Dict
 
 import httpx
 
-from synth_ai.tracing.abstractions import Event
-from synth_ai.tracing.client_manager import ClientManager
-from synth_ai.tracing.config import TracingConfig
-from synth_ai.tracing.log_client_base import BaseAsyncLogClient, BaseLogClient
+from .abstractions import Event
+from .client_manager import ClientManager
+from .config import TracingConfig
+from .log_client_base import BaseAsyncLogClient, BaseLogClient
 
 logger = logging.getLogger(__name__)
 
@@ -22,7 +22,7 @@ class ImmediateLogClient(BaseLogClient):
 
     def send_event(self, event: Event, system_info: Dict[str, str]) -> bool:
         """Send a single event with retries and fallback"""
-        from synth_ai.tracing.retry_queue import (
+        from .retry_queue import (
             retry_queue,  # Import here to avoid circular import
         )
 
@@ -73,7 +73,7 @@ class AsyncImmediateLogClient(BaseAsyncLogClient):
 
     async def send_event(self, event: Event, system_info: Dict[str, str]) -> bool:
         """Send a single event with retries and fallback (async version)"""
-        from synth_ai.tracing.retry_queue import retry_queue
+        from .retry_queue import retry_queue
 
         if not self.config.api_key:
             logger.error("No API key provided")

synth_ai/{tracing → v0/tracing}/log_client_base.py

@@ -1,7 +1,7 @@
 from typing import Dict
 
-from synth_ai.tracing.abstractions import Event
-from synth_ai.tracing.config import TracingConfig
+from .abstractions import Event
+from .config import TracingConfig
 
 
 class BaseLogClient:

synth_ai/{tracing → v0/tracing}/retry_queue.py

@@ -5,8 +5,8 @@ from collections import deque
 from dataclasses import dataclass
 from typing import Dict, List, Optional, Tuple
 
-from synth_ai.tracing.abstractions import Event
-from synth_ai.tracing.config import TracingConfig
+from .abstractions import Event
+from .config import TracingConfig
 
 logger = logging.getLogger(__name__)
 
@@ -88,7 +88,7 @@ class RetryQueue:
         failure_count = 0
 
         try:
-            from synth_ai.tracing.immediate_client import (
+            from .immediate_client import (
                 ImmediateLogClient,  # Import here to avoid circular import
             )
 

synth_ai/{tracing → v0/tracing}/trackers.py

@@ -4,8 +4,8 @@ from typing import Any, Dict, List, Literal, Optional, Tuple, Union
 
 from pydantic import BaseModel
 
-from synth_ai.tracing.config import VALID_TYPES, Message, ModelParams
-from synth_ai.tracing.local import _local
+from .config import VALID_TYPES, Message, ModelParams
+from .local import _local
 
 # Existing SynthTrackerSync and SynthTrackerAsync classes...