refactor: code review changes

Author: dori

.gitignore

@@ -159,5 +159,3 @@ Thumbs.db
 *.db
 *.sqlite
 *.sqlite3
-conversations.db
-test.db

judge_mcp_flow.md

@@ -7,13 +7,13 @@
 3. Managing session-based conversation history
 """
 
-import logging
+from mcp_as_a_judge.config import Config
+from mcp_as_a_judge.logging_config import get_logger
 
-from ..config import Config
 from . import ConversationHistoryDB, ConversationRecord, create_database_provider
 
 # Set up logger
-logger = logging.getLogger(__name__)
+logger = get_logger(__name__)
 
 
 class ConversationHistoryService:
@@ -129,6 +129,32 @@ def format_context_for_llm(self, context_records: list[ConversationRecord]) -> s
 
         return formatted_context
 
+    async def enrich_with_context(self, session_id: str, base_prompt: str) -> str:
+        """
+        Enrich a base prompt with conversation history context.
+
+        Args:
+            session_id: Session identifier
+            base_prompt: Original prompt to enrich
+
+        Returns:
+            Enriched prompt with conversation history context
+        """
+        logger.info(
+            f"🔄 Starting context enrichment for session {session_id}, base_prompt: {base_prompt}"
+        )
+
+        context_records = await self.load_context_for_enrichment(session_id)
+        context_text = self.format_context_for_llm(context_records)
+
+        enriched_prompt = f"{context_text}\n## Current Request\n{base_prompt}"
+
+        logger.info(
+            f"🎯 Context enrichment completed for session {session_id}, enriched_prompt: {enriched_prompt}"
+        )
+
+        return enriched_prompt
+
     ### TEST-ONLY METHODS
     async def get_session_summary(self, session_id: str) -> dict:
         """
@@ -157,36 +183,3 @@ async def get_session_summary(self, session_id: str) -> dict:
             "context_enrichment_count": self.config.database.context_enrichment_count,
             "max_context_records": self.config.database.max_context_records,
         }
-
-
-# Convenience functions for easy integration with existing tools
-
-
-async def enrich_with_context(
-    service: ConversationHistoryService, session_id: str, base_prompt: str
-) -> str:
-    """
-    Enrich a base prompt with conversation history context.
-
-    Args:
-        service: ConversationHistoryService instance
-        session_id: Session identifier
-        base_prompt: Original prompt to enrich
-
-    Returns:
-        Enriched prompt with conversation history context
-    """
-    logger.info(
-        f"🔄 Starting context enrichment for session {session_id}, base_prompt: {base_prompt}"
-    )
-
-    context_records = await service.load_context_for_enrichment(session_id)
-    context_text = service.format_context_for_llm(context_records)
-
-    enriched_prompt = f"{context_text}\n## Current Request\n{base_prompt}"
-
-    logger.info(
-        f"🎯 Context enrichment completed for session {session_id}, enriched_prompt: {enriched_prompt}"
-    )
-
-    return enriched_prompt

src/mcp_as_a_judge/db/conversation_history_service.py

@@ -5,17 +5,18 @@
 It supports both in-memory (:memory:) and file-based SQLite storage.
 """
 
-import logging
 import uuid
 from datetime import datetime, timedelta
 
 from sqlalchemy import create_engine
 from sqlmodel import Session, SQLModel, asc, desc, select
 
+from mcp_as_a_judge.logging_config import get_logger
+
 from ..interface import ConversationHistoryDB, ConversationRecord
 
 # Set up logger
-logger = logging.getLogger(__name__)
+logger = get_logger(__name__)
 
 
 class SQLiteProvider(ConversationHistoryDB):

src/mcp_as_a_judge/db/providers/sqlite.py

@@ -0,0 +1,181 @@
+"""
+Central logging configuration for MCP as a Judge.
+
+This module provides centralized logging setup with colored output and
+consistent formatting across the entire application.
+"""
+
+import logging
+import sys
+from datetime import datetime
+from typing import Any, ClassVar
+
+
+class ColoredFormatter(logging.Formatter):
+    """Custom formatter that adds colors to log levels and formats messages."""
+
+    # ANSI color codes
+    COLORS: ClassVar[dict[str, str]] = {
+        "DEBUG": "\033[36m",  # Cyan
+        "INFO": "\033[32m",  # Green
+        "WARNING": "\033[33m",  # Yellow
+        "ERROR": "\033[31m",  # Red
+        "CRITICAL": "\033[35m",  # Magenta
+    }
+    RESET = "\033[0m"  # Reset color
+
+    def format(self, record: logging.LogRecord) -> str:
+        """Format log record with colors and custom format."""
+        # Get color for log level
+        level_color = self.COLORS.get(record.levelname, "")
+
+        # Format: [level_with_color] [module:linenumber] [iso-date] [message]
+        colored_level = f"{level_color}{record.levelname}{self.RESET}"
+
+        # Get module name (remove package prefix for cleaner output)
+        module_name = record.name
+        if module_name.startswith("mcp_as_a_judge."):
+            module_name = module_name[len("mcp_as_a_judge.") :]
+
+        # Format timestamp as ISO date
+        timestamp = datetime.fromtimestamp(record.created).isoformat()
+
+        # Build the formatted message
+        formatted_message = f"[{colored_level}] [{module_name}:{record.lineno}] [{timestamp}] {record.getMessage()}"
+
+        # Handle exceptions
+        if record.exc_info:
+            formatted_message += "\n" + self.formatException(record.exc_info)
+
+        return formatted_message
+
+
+def setup_logging(level: int = logging.INFO) -> None:
+    """
+    Set up centralized logging configuration for the entire application.
+
+    Args:
+        level: Logging level (default: INFO)
+    """
+    # Create custom formatter
+    formatter = ColoredFormatter()
+
+    # Create handler for stderr (so it's visible in development tools like Cursor)
+    handler = logging.StreamHandler(sys.stderr)
+    handler.setFormatter(formatter)
+
+    # Configure root logger
+    root_logger = logging.getLogger()
+    root_logger.setLevel(level)
+
+    # Clear any existing handlers to avoid duplicates
+    root_logger.handlers.clear()
+
+    # Add our custom handler
+    root_logger.addHandler(handler)
+
+    # Configure specific loggers for our application
+    configure_application_loggers(level)
+
+
+def configure_application_loggers(level: int = logging.INFO) -> None:
+    """
+    Configure specific loggers for MCP as a Judge application components.
+
+    Args:
+        level: Logging level to set for application loggers
+    """
+    # List of application-specific loggers to configure
+    app_loggers = [
+        "mcp_as_a_judge.server",
+        "mcp_as_a_judge.conversation_history_service",
+        "mcp_as_a_judge.db.conversation_history_service",
+        "mcp_as_a_judge.db.providers.in_memory",
+        "mcp_as_a_judge.db.providers.sqlite",
+        "mcp_as_a_judge.messaging",
+        "mcp_as_a_judge.llm_client",
+        "mcp_as_a_judge.config",
+    ]
+
+    # Set level for each application logger
+    for logger_name in app_loggers:
+        logger = logging.getLogger(logger_name)
+        logger.setLevel(level)
+
+
+def get_logger(name: str) -> logging.Logger:
+    """
+    Get a logger instance with the given name.
+
+    This is a convenience function that ensures consistent logger naming
+    across the application.
+
+    Args:
+        name: Logger name (typically __name__ from the calling module)
+
+    Returns:
+        Configured logger instance
+    """
+    return logging.getLogger(name)
+
+
+def log_startup_message(config: Any) -> None:
+    """
+    Log application startup message with configuration details.
+
+    Args:
+        config: Application configuration object
+    """
+    logger = get_logger("mcp_as_a_judge.server")
+    logger.info(
+        "🚀 MCP Judge server starting with conversation history logging enabled"
+    )
+    logger.info(
+        f"📊 Configuration: max_context_records={config.database.max_context_records}, "
+        f"context_enrichment_count={config.database.context_enrichment_count}"
+    )
+
+
+def log_tool_execution(
+    tool_name: str, session_id: str, additional_info: str = ""
+) -> None:
+    """
+    Log tool execution start with consistent formatting.
+
+    Args:
+        tool_name: Name of the tool being executed
+        session_id: Session identifier
+        additional_info: Additional information to log
+    """
+    logger = get_logger("mcp_as_a_judge.server")
+
+    # Map tool names to emojis for better visibility
+    tool_emojis = {
+        "build_workflow": "🔧",
+        "judge_coding_plan": "⚖️",
+        "judge_code_change": "🔍",
+        "raise_obstacle": "🚧",
+        "raise_missing_requirements": "❓",
+    }
+
+    emoji = tool_emojis.get(tool_name, "🛠️")
+    logger.info(f"{emoji} {tool_name} called for session {session_id}")
+
+    if additional_info:
+        logger.info(f"   {additional_info}")
+
+
+def log_error(error: Exception, context: str = "") -> None:
+    """
+    Log error with consistent formatting and context.
+
+    Args:
+        error: Exception that occurred
+        context: Additional context about where the error occurred
+    """
+    logger = get_logger("mcp_as_a_judge.server")
+
+    if context:
+        logger.error(f"❌ Error in {context}: {error!s}")
+    else:
+        logger.error(f"❌ Error: {error!s}")