cade-cli 0.3.3__py3-none-any.whl

cadecoder/core/errors.py

@@ -0,0 +1,145 @@
+"""Custom error types for CadeCoder.
+
+This module defines a comprehensive exception hierarchy for the application.
+All custom exceptions inherit from CadeCoderError, allowing for consistent
+error handling throughout the codebase.
+
+Error Hierarchy:
+    CadeCoderError (base)
+    ├── CadeCoderFileNotFoundError
+    ├── FileSystemError
+    ├── FileOpsError
+    ├── AnalysisError
+    │   └── DependencyError
+    ├── ExecutionError
+    ├── ConfigError
+    ├── AuthError
+    ├── AIError
+    ├── StorageError
+    ├── AgentExecutionError
+    └── PlanningError
+        ├── PlanValidationError
+        └── PlanCreationError
+"""
+
+
+class CadeCoderError(Exception):
+    """Base class for all CadeCoder-specific errors.
+
+    All custom exceptions should inherit from this class to enable
+    consistent error handling and filtering.
+    """
+
+    pass
+
+
+class CadeCoderFileNotFoundError(CadeCoderError):
+    """Raised when a required file or directory is not found."""
+
+    pass
+
+
+# Backwards compatibility alias
+FileNotFoundError = CadeCoderFileNotFoundError
+
+
+class FileSystemError(CadeCoderError):
+    """Raised for general file system operations errors."""
+
+    pass
+
+
+class FileOpsError(CadeCoderError):
+    """Raised for errors during file operations like diffing or patching."""
+
+    pass
+
+
+class AnalysisError(CadeCoderError):
+    """Raised when an error occurs during codebase analysis or search."""
+
+    pass
+
+
+class DependencyError(AnalysisError):
+    """Raised when an error occurs during dependency parsing."""
+
+    pass
+
+
+class ExecutionError(CadeCoderError):
+    """Raised when running an external command fails."""
+
+    pass
+
+
+class ConfigError(CadeCoderError):
+    """Raised for configuration loading, validation, or saving errors."""
+
+    pass
+
+
+class AuthError(CadeCoderError):
+    """Raised for authentication or API key related errors."""
+
+    pass
+
+
+class AIError(CadeCoderError):
+    """Raised for errors during interaction with the AI service."""
+
+    pass
+
+
+class StorageError(CadeCoderError):
+    """Raised for errors during storage operations."""
+
+    pass
+
+
+class AgentExecutionError(CadeCoderError):
+    """Raised when an agent fails to execute properly."""
+
+    pass
+
+
+class PlanningError(CadeCoderError):
+    """Base class for planning-related errors."""
+
+    pass
+
+
+class PlanValidationError(PlanningError):
+    """Raised when a plan fails schema validation.
+
+    Attributes:
+        schema_errors: List of specific schema validation error messages
+    """
+
+    def __init__(self, message: str, schema_errors: list[str] | None = None):
+        """Initialize with error message and optional schema error details.
+
+        Args:
+            message: Main error message
+            schema_errors: List of specific schema validation errors
+        """
+        super().__init__(message)
+        self.schema_errors = schema_errors or []
+
+    def __str__(self) -> str:
+        """Format error message with schema details.
+
+        Returns:
+            Formatted error message including schema errors if present
+        """
+        base_msg = super().__str__()
+        if self.schema_errors:
+            errors = "\n  - ".join(self.schema_errors)
+            return f"{base_msg}\nSchema errors:\n  - {errors}"
+        return base_msg
+
+
+class PlanCreationError(PlanningError):
+    """Raised when plan creation fails after retries."""
+
+    pass

cadecoder/core/logging.py

@@ -0,0 +1,148 @@
+"""Basic logging setup for CadeCoder.
+
+This module provides structured logging with:
+    - File-based logging (rotating file handler)
+    - Chat thread context injection
+    - No console output (file-only)
+
+The logging is initialized on import to ensure logs are captured
+even before CLI arguments are parsed.
+"""
+
+import os
+
+# Set environment variable to disable tokenizers parallelism warning
+# This must be set before any imports that use tokenizers
+os.environ.setdefault("TOKENIZERS_PARALLELISM", "false")
+
+import logging
+from contextvars import ContextVar
+from logging.handlers import RotatingFileHandler
+from pathlib import Path
+
+from .config import config
+
+# Get the logger instance first
+log = logging.getLogger("cadecoder")
+
+
+# --- Chat Thread Context ---
+
+
+chat_thread_ctx: ContextVar[str] = ContextVar("chat_thread_ctx", default="-")
+
+
+class ChatThreadFilter(logging.Filter):
+    """Inject chat thread name/id into log records as 'chat_thread'.
+
+    This filter adds thread context to all log records, enabling
+    filtering and searching logs by conversation thread.
+    """
+
+    def filter(self, record: logging.LogRecord) -> bool:
+        """Filter log records to inject chat thread context.
+
+        Args:
+            record: The log record to filter
+
+        Returns:
+            Always True (all records pass through, context is injected)
+        """
+        try:
+            record.chat_thread = chat_thread_ctx.get()
+        except Exception:
+            record.chat_thread = "-"
+        return True
+
+
+# --- Log File Path ---
+
+
+def get_log_file_path() -> Path:
+    """Get the path to the log file in the cadecoder app directory.
+
+    Returns:
+        Path to the log file (creates parent directory if needed)
+    """
+    app_dir = Path(config.app_dir)
+    app_dir.mkdir(parents=True, exist_ok=True)
+    return app_dir / "cadecoder.log"
+
+
+# --- Logging Setup ---
+
+
+def _create_file_handler(log_file: Path) -> RotatingFileHandler:
+    """Create and configure rotating file handler.
+
+    Args:
+        log_file: Path to log file
+
+    Returns:
+        Configured RotatingFileHandler
+    """
+    handler = RotatingFileHandler(
+        log_file,
+        maxBytes=10 * 1024 * 1024,  # 10MB
+        backupCount=3,  # Keep 3 backup files
+        encoding="utf-8",
+    )
+    handler.setLevel(logging.DEBUG)  # Always capture DEBUG in file
+    handler.addFilter(ChatThreadFilter())
+
+    # Detailed formatter for file logs
+    formatter = logging.Formatter(
+        "%(asctime)s - %(name)s - %(levelname)s - "
+        "[%(filename)s:%(lineno)d] - chat=%(chat_thread)s - %(message)s",
+        datefmt="%Y-%m-%d %H:%M:%S",
+    )
+    handler.setFormatter(formatter)
+
+    return handler
+
+
+def _configure_root_logger() -> None:
+    """Configure root logger to prevent console output from other libraries.
+
+    Sets root logger to WARNING level and removes all handlers to prevent
+    other libraries from outputting to console.
+    """
+    root_logger = logging.getLogger()
+    root_logger.setLevel(logging.WARNING)  # Only warnings and above
+    # Remove all handlers from root logger
+    for handler in root_logger.handlers[:]:
+        root_logger.removeHandler(handler)
+
+
+def setup_logging(verbose: bool = False) -> None:
+    """Set up file-only logging with no console output.
+
+    Side effect: configures logging system.
+
+    Args:
+        verbose: If True, sets log level to DEBUG, otherwise INFO
+    """
+    # Remove any existing handlers to avoid duplicates
+    for handler in log.handlers[:]:
+        log.removeHandler(handler)
+
+    log_level = logging.DEBUG if verbose else logging.INFO
+    log.setLevel(log_level)
+
+    # Create and add file handler
+    log_file = get_log_file_path()
+    file_handler = _create_file_handler(log_file)
+    log.addHandler(file_handler)
+
+    # Prevent propagation to root logger to avoid duplicate logs
+    log.propagate = False
+
+    # Configure root logger to prevent console output
+    _configure_root_logger()
+
+    log.debug(f"Logging initialized. Log file: {log_file}")
+
+
+# Initialize logging with default settings on import
+# This ensures logs go to file even before CLI args are parsed
+setup_logging(verbose=False)

cadecoder/core/types.py

@@ -0,0 +1,235 @@
+"""Core shared types, enums, and message definitions for the entire codebase.
+
+This module consolidates:
+- Type enums (Role, ToolCallType, ExecutionEventType)
+- TypedDict definitions for messages and tool calls
+- Pydantic models for message structures
+- Type aliases for common patterns
+"""
+
+from enum import Enum
+from typing import Any, Literal
+
+from pydantic import BaseModel, Field
+from typing_extensions import TypedDict
+
+# ============================================================================
+# Type Aliases
+# ============================================================================
+
+# Tool-related type aliases
+ToolCallList = list[dict[str, Any]]
+ToolResultTuple = tuple[str, str, str]  # (call_id, tool_name, content)
+ToolResultList = list[ToolResultTuple]
+
+# Message-related type aliases
+MessageDict = dict[str, Any]
+MessageList = list[MessageDict]
+ConversationHistory = list[MessageDict]
+
+# Resource tracking for parallel execution
+ResourceSet = set[str]
+ToolGroup = list[dict[str, Any]]
+ToolGroups = list[ToolGroup]
+
+# ============================================================================
+# Enums
+# ============================================================================
+
+
+class Role(str, Enum):
+    """Message role types."""
+
+    USER = "user"
+    ASSISTANT = "assistant"
+    TOOL = "tool"
+    SYSTEM = "system"
+
+
+class ToolCallType(str, Enum):
+    """Tool call type."""
+
+    FUNCTION = "function"
+
+
+class ExecutionEventType(str, Enum):
+    """Event types for execution flow.
+
+    Values:
+        CONTENT: Text content from agent
+        TOOL_CALL: Tool call request
+        TOOL_EXECUTION_START: Tool execution started
+        TOOL_RESULT: Tool execution result
+        WARNING: Warning message
+        ERROR: Error message
+        COMPLETE: Execution complete
+        CONTEXT_COMPACTION: Context window was compacted
+    """
+
+    CONTENT = "content"
+    TOOL_CALL = "tool_call"
+    TOOL_EXECUTION_START = "tool_execution_start"
+    TOOL_RESULT = "tool_result"
+    WARNING = "warning"
+    ERROR = "error"
+    COMPLETE = "complete"
+    CONTEXT_COMPACTION = "context_compaction"
+
+
+# ============================================================================
+# Constants
+# ============================================================================
+
+# Prefixes for context/system scaffolding that should be excluded from user content
+CONTEXT_PREFIXES: tuple[str, ...] = ("[Context:", "[Git Init")
+
+
+# ============================================================================
+# TypedDict Definitions (for compatibility)
+# ============================================================================
+
+
+class ToolFunctionDict(TypedDict, total=False):
+    """Tool function call structure."""
+
+    name: str
+    arguments: str
+
+
+class ToolCallShape(TypedDict, total=False):
+    """Tool call shape structure."""
+
+    id: str
+    tool_call_id: str
+    type: str
+    function: ToolFunctionDict
+
+
+class BaseMessageDict(TypedDict, total=False):
+    """Base message structure as TypedDict.
+
+    Used for compatibility with existing dict-based code.
+    """
+
+    role: Literal["system", "user", "assistant", "tool"]
+    content: str | None
+
+
+class ToolCallDict(TypedDict):
+    """Tool call structure as TypedDict."""
+
+    id: str
+    type: Literal["function"]
+    function: dict[str, Any]
+
+
+class AssistantMessageDict(BaseMessageDict):
+    """Assistant message with optional tool calls."""
+
+    tool_calls: list[ToolCallDict] | None
+    structured_state_json: str | None
+
+
+class ToolMessageDict(BaseMessageDict):
+    """Tool response message."""
+
+    tool_call_id: str
+    name: str | None
+
+
+class ConversationMessageDict(TypedDict, total=False):
+    """Union type for all message types in conversations."""
+
+    role: Literal["system", "user", "assistant", "tool"]
+    content: str | None
+    tool_calls: list[ToolCallDict] | None
+    tool_call_id: str | None
+    name: str | None
+    structured_state_json: str | None
+
+
+# ============================================================================
+# Pydantic Models
+# ============================================================================
+
+
+class ToolExecutionResult(BaseModel):
+    """Result from executing a single tool.
+
+    Attributes:
+        tool_call_id: ID of the tool call
+        name: Name of the tool that was executed
+        content: Result content or error message
+        status: Execution status (success or error)
+        error: Error message if status is error
+        authorization_url: Authorization URL if authorization is required
+    """
+
+    tool_call_id: str = Field(..., description="ID of the tool call")
+    name: str = Field(..., description="Name of the tool that was executed")
+    content: str = Field(..., description="Result content or error message")
+    status: Literal["success", "error"] = Field(..., description="Execution status")
+    error: str | None = Field(None, description="Error message if status is error")
+    authorization_url: str | None = Field(
+        None, description="Authorization URL if authorization is required"
+    )
+
+
+class SingleMessageExitReason(str, Enum):
+    """Exit reasons for single message mode.
+
+    Values:
+        COMPLETED: Task completed successfully
+        NEEDS_INPUT: Agent needs user input to continue
+        NEEDS_AUTH: Tool requires authorization
+        ERROR: Execution error occurred
+    """
+
+    COMPLETED = "completed"
+    NEEDS_INPUT = "needs_input"
+    NEEDS_AUTH = "needs_auth"
+    ERROR = "error"
+
+
+class SingleMessageResult(BaseModel):
+    """Result from single message mode execution.
+
+    Attributes:
+        exit_reason: Why execution stopped
+        content: Final accumulated content
+        needs_interactive: Whether to transition to interactive mode
+        authorization_url: URL if auth is required
+        error_message: Error message if error occurred
+    """
+
+    exit_reason: SingleMessageExitReason
+    content: str = ""
+    needs_interactive: bool = False
+    authorization_url: str | None = None
+    error_message: str | None = None
+
+
+# ============================================================================
+# Utility Functions
+# ============================================================================
+
+
+def extract_tool_output_content(result: Any) -> str:
+    """Extract content from tool execution result.
+
+    Handles various result formats:
+    - Objects with output.value attribute (Arcade response)
+    - Dicts with 'output' key
+    - Raw values (converted to string)
+
+    Args:
+        result: Raw tool execution result
+
+    Returns:
+        Extracted content as string
+    """
+    if hasattr(result, "output") and hasattr(result.output, "value"):
+        return str(result.output.value)
+    if isinstance(result, dict) and "output" in result:
+        return str(result.get("output", result))
+    return str(result)