ata-coder 2.4.2__py3-none-any.whl

ata_coder/config.py

@@ -0,0 +1,257 @@
+"""
+Configuration management for ATA Coder.
+Loads from environment variables with sensible defaults.
+"""
+
+import logging
+import threading
+from dataclasses import dataclass, field
+from pathlib import Path
+from typing import Any
+
+logger = logging.getLogger(__name__)
+
+from dotenv import load_dotenv
+
+
+def _find_project_root() -> Path:
+    """Find the project root directory."""
+    return Path(__file__).parent.resolve()
+
+
+def _load_env():
+    """Load .env files: CWD first (lowest priority), then project root overrides."""
+    cwd_env = Path.cwd() / ".env"
+    project_env = _find_project_root() / ".env"
+    # Load CWD .env as baseline
+    if cwd_env.exists():
+        load_dotenv(cwd_env)
+    # Project-root .env takes precedence (overrides CWD values)
+    if project_env.exists() and project_env != cwd_env:
+        load_dotenv(project_env, override=True)
+
+
+# Defer env loading to first config access, not import time
+_env_loaded = False
+_env_lock = threading.Lock()
+
+
+def _ensure_env():
+    """Thread-safe lazy env loader."""
+    global _env_loaded
+    if _env_loaded:
+        return
+    with _env_lock:
+        if not _env_loaded:
+            _load_env()
+            _env_loaded = True
+
+
+@dataclass
+class LLMConfig:
+    """Configuration for the OpenAI-compatible LLM client."""
+
+    api_key: str = field(
+        default_factory=lambda: _settings_api_key()
+    )
+    base_url: str = field(
+        default_factory=lambda: _settings_base_url()
+    )
+    model: str = field(
+        default_factory=lambda: _settings_default_model()
+    )
+    temperature: float = field(
+        default_factory=lambda: _safe_temperature()
+    )
+    max_tokens: int = field(
+        default_factory=lambda: _settings_max_output_tokens()
+    )
+    thinking_strength: str = field(
+        default_factory=lambda: _settings_thinking_strength()
+    )  # "" = default, "off" = explicitly disabled, "low"|"medium"|"high"|"xhigh"|"max"
+    use_anthropic: bool = field(
+        default_factory=lambda: _from_settings("use_anthropic", False)
+    )
+
+    def __post_init__(self):
+        """Normalize model name: auto-strip [1m] suffix (DeepSeek Anthropic marker)."""
+        if self.model and self.model.endswith("[1m]"):
+            self.model = self.model[:-4].strip()
+            logger.info(
+                "Auto-stripped [1m] suffix from model: %s", self.model
+            )
+
+    def validate(self) -> list[str]:
+        """Validate configuration, returns list of errors."""
+        errors = []
+        if not self.api_key:
+            errors.append(
+                "OPENAI_API_KEY is not set. "
+                "Set it in .env file or as environment variable."
+            )
+        if not self.model:
+            errors.append("OPENAI_MODEL is not set.")
+        return errors
+
+
+@dataclass
+class AgentConfig:
+    """Configuration for the agent behavior."""
+
+    max_tool_calls: int = field(
+        default_factory=lambda: int(_from_settings("max_tool_calls", 999))
+    )
+    max_context_tokens: int = field(
+        default_factory=lambda: int(_from_settings("max_context_tokens", 1000000))
+    )
+    effective_context_tokens: int = field(
+        default_factory=lambda: int(_from_settings("effective_context_tokens", 200000))
+    )
+    max_message_output_chars: int = field(
+        default_factory=lambda: int(_from_settings("max_message_output_chars", 8000))
+    )
+    workspace_dir: str = field(
+        default_factory=lambda: _from_settings("workspace_dir", str(Path.cwd()))
+    )
+
+    # Extension & sub-agent settings
+    extension_dirs: list[str] = field(
+        default_factory=lambda: _from_settings("extension_dirs", [])
+    )
+    max_sub_agents: int = field(
+        default_factory=lambda: int(_from_settings("max_sub_agents", 5))
+    )
+    sub_agent_timeout: float = field(
+        default_factory=lambda: float(_from_settings("sub_agent_timeout", 300.0))
+    )
+
+    # Safety settings
+    allowed_commands: list[str] = field(
+        default_factory=lambda: [
+            "ls", "dir", "cat", "head", "tail", "wc", "find",
+            "git", "python", "python3", "node", "npm", "npx",
+            "pip", "poetry", "cargo", "go", "rustc", "javac", "java",
+            "make", "cmake", "gcc", "g++", "clang", "clang++",
+            "tsc", "eslint", "prettier", "pytest", "jest",
+            "mypy", "ruff", "black", "isort",
+            "echo", "mkdir", "touch", "cp", "mv", "rm",
+            "cd",  # harmless — cwd is already workspace; cd in compound commands just navigates within one shell invocation
+            "grep", "rg", "fd", "tree",
+            "docker", "docker-compose",
+            "cowsay", "fortune", "date", "whoami", "pwd",
+        ]
+    )
+
+    # Blocked commands for safety
+    blocked_commands: list[str] = field(
+        default_factory=lambda: [
+            "rm -rf /",
+            "mkfs.",
+            "dd if=",
+            ":(){ :|:& };:",  # fork bomb
+            "shutdown",
+            "reboot",
+            "chmod 777 /",
+            "> /dev/sda",
+        ]
+    )
+
+
+@dataclass
+class AppConfig:
+    """Top-level application configuration."""
+
+    llm: LLMConfig = field(default_factory=LLMConfig)
+    agent: AgentConfig = field(default_factory=AgentConfig)
+    effort: str = field(default_factory=lambda: _from_settings("effort_level", "medium"))
+
+    @classmethod
+    def load(cls) -> "AppConfig":
+        """Load and validate all configuration (errors logged by caller)."""
+        _ensure_env()
+        config = cls()
+        return config
+
+
+# Module-level config — initialised lazily via get_config().
+# Using a lazy pattern because AppConfig.load() references _from_settings()
+# which is defined after the dataclass body in this module.
+_config: AppConfig | None = None
+
+
+def get_config() -> AppConfig:
+    """Return the module-level config singleton (lazy init on first call).
+
+    After the first call the config is cached.  The codebase is
+    single-threaded by design so no lock is needed.
+    """
+    global _config
+    if _config is None:
+        _config = AppConfig.load()
+    return _config
+
+
+# ── Single config resolution helper ────────────────────────────────────────
+# All config values come from settings.json. CLI overrides (--model, --api-key)
+# are applied later via _apply_config_overrides() in main.py.
+# Environment variables are intentionally NOT read — settings.json is the
+# single source of truth for predictable, reproducible configuration.
+
+
+def _from_settings(attr: str, default: Any = "") -> Any:
+    """Read a config value from the Settings singleton.
+
+    Lazy import to avoid circular dependency with settings.py.
+    Always returns *default* when settings are unavailable (fail-safe),
+    but logs a warning for non-trivial failures so they don't go unnoticed.
+    """
+    try:
+        from .settings import get_settings
+    except ImportError:
+        return default
+    try:
+        settings = get_settings()
+        return getattr(settings, attr, default)
+    except AttributeError:
+        # settings object exists but attribute is missing — use default
+        logger = logging.getLogger(__name__)
+        logger.debug("Settings property %r not found, using default %r", attr, default)
+        return default
+    except Exception:
+        logger = logging.getLogger(__name__)
+        logger.warning(
+            "Failed to read settings.%s — using default %r. "
+            "Check your settings.json for corruption.", attr, default, exc_info=True
+        )
+        return default
+
+
+def _safe_temperature() -> float:
+    """Read temperature from settings, ensuring it's a numeric type."""
+    val = _from_settings("temperature", 0.1)
+    return val if isinstance(val, (int, float)) else 0.1
+
+
+def _settings_api_key() -> str:
+    return _from_settings("api_key", "")
+
+
+def _settings_base_url() -> str:
+    return _from_settings("api_base_url", "https://api.deepseek.com")
+
+
+def _settings_default_model() -> str:
+    return _from_settings("default_model", "deepseek-chat")
+
+
+def _settings_max_output_tokens() -> int:
+    return _from_settings("max_output_tokens", 16384)
+
+
+def _settings_thinking_strength() -> str:
+    return _from_settings("effort_level", "")
+
+
+# Use get_config() to obtain the global AppConfig instance.
+# Lazy-loading is handled inside get_config() itself.
+

ata_coder/core/__init__.py

@@ -0,0 +1,35 @@
+# -*- coding: utf-8 -*-
+"""
+Core agent modules — split from agent.py for maintainability.
+
+- events: AgentEvent dataclasses
+- state: AgentState dataclass
+"""
+
+from .events import (
+    AgentEvent,
+    TextDeltaEvent,
+    ToolCallEvent,
+    ToolResultEvent,
+    ToolStreamEvent,
+    ThinkingEvent,
+    ReasoningEvent,
+    SkillChangedEvent,
+    ErrorEvent,
+    CompleteEvent,
+)
+from .state import AgentState
+
+__all__ = [
+    "AgentEvent",
+    "TextDeltaEvent",
+    "ToolCallEvent",
+    "ToolResultEvent",
+    "ToolStreamEvent",
+    "ThinkingEvent",
+    "ReasoningEvent",
+    "SkillChangedEvent",
+    "ErrorEvent",
+    "CompleteEvent",
+    "AgentState",
+]

ata_coder/core/events.py

@@ -0,0 +1,73 @@
+# -*- coding: utf-8 -*-
+"""
+Agent event types — produced during CoderAgent.run() and consumed by UI.
+Extracted from agent.py to keep modules under 500 lines.
+"""
+
+from dataclasses import dataclass, field
+from typing import Any
+
+from ..tools import ToolResult
+
+
+# ── Event types ──────────────────────────────────────────────────────────────
+
+@dataclass
+class AgentEvent:
+    """Base event."""
+    pass
+
+
+@dataclass
+class TextDeltaEvent(AgentEvent):
+    text: str
+
+
+@dataclass
+class ToolCallEvent(AgentEvent):
+    tool_name: str
+    arguments: dict[str, Any]
+    source: str = "builtin"  # "builtin" or "mcp"
+
+
+@dataclass
+class ToolResultEvent(AgentEvent):
+    tool_name: str
+    result: ToolResult
+    source: str = "builtin"
+    arguments: dict[str, Any] = field(default_factory=dict)
+
+
+@dataclass
+class ThinkingEvent(AgentEvent):
+    pass
+
+
+@dataclass
+class ReasoningEvent(AgentEvent):
+    """The model is thinking/reasoning (DeepSeek R1/v4 thinking mode)."""
+    text: str
+
+
+@dataclass
+class SkillChangedEvent(AgentEvent):
+    skill_name: str
+
+
+@dataclass
+class ErrorEvent(AgentEvent):
+    error: str
+
+
+@dataclass
+class ToolStreamEvent(AgentEvent):
+    """Real-time streaming output chunk from a running tool (e.g. run_shell)."""
+    tool_name: str
+    chunk: str  # incremental output text
+
+
+@dataclass
+class CompleteEvent(AgentEvent):
+    total_tool_calls: int
+    total_time: float
+    estimated_tokens: int = 0  # current conversation window size

ata_coder/core/queue.py

@@ -0,0 +1,85 @@
+# -*- coding: utf-8 -*-
+"""Async event queue for agent→UI communication — part of the core infrastructure.
+
+Both agent and UI run as asyncio tasks on the same event loop.
+asyncio.Queue provides coroutine-safe FIFO semantics without locks.
+"""
+import asyncio
+from typing import Any, Optional
+
+logger = __import__("logging").getLogger(__name__)
+
+__all__ = ["EventQueue"]
+
+
+class EventQueue:
+    """Async event queue wrapping asyncio.Queue.
+
+    Usage:
+        eq = EventQueue()
+        # Agent task:
+        await eq.put(TextDeltaEvent("hello"))
+        # UI task:
+        async for event in eq.drain():
+            ui.on_event(event)
+    """
+
+    def __init__(self, maxsize: int = 0):
+        self._queue: asyncio.Queue = asyncio.Queue(maxsize=maxsize)
+        self._total_put = 0
+        self._total_get = 0
+
+    async def put(self, event: Any) -> None:
+        """Enqueue an event (coroutine-safe, called from agent task)."""
+        await self._queue.put(event)
+        self._total_put += 1
+
+    def put_nowait(self, event: Any) -> None:
+        """Enqueue an event without blocking."""
+        self._queue.put_nowait(event)
+        self._total_put += 1
+
+    async def get(self, timeout: Optional[float] = None) -> Optional[Any]:
+        """Get one event, blocking with optional timeout."""
+        try:
+            if timeout:
+                event = await asyncio.wait_for(self._queue.get(), timeout=timeout)
+            else:
+                event = await self._queue.get()
+            self._total_get += 1
+            return event
+        except asyncio.TimeoutError:
+            return None
+
+    async def drain(self) -> list[Any]:
+        """Get ALL pending events without blocking."""
+        events: list[Any] = []
+        while not self._queue.empty():
+            try:
+                events.append(self._queue.get_nowait())
+            except asyncio.QueueEmpty:
+                break
+        count = len(events)
+        self._total_get += count
+        return events
+
+    def count(self) -> int:
+        """Return number of pending events (exact — asyncio.Queue.qsize is precise)."""
+        return self._queue.qsize()
+
+    @property
+    def total_put(self) -> int:
+        return self._total_put
+
+    @property
+    def total_get(self) -> int:
+        return self._total_get
+
+    async def clear(self) -> None:
+        """Discard all pending events."""
+        while not self._queue.empty():
+            try:
+                self._queue.get_nowait()
+            except asyncio.QueueEmpty:
+                break
+        self._total_get = self._total_put

ata_coder/core/state.py

@@ -0,0 +1,17 @@
+# -*- coding: utf-8 -*-
+"""
+Agent state — holds conversation messages and metrics during a run.
+Extracted from agent.py.
+"""
+
+from dataclasses import dataclass, field
+
+from ..types import Message
+
+
+@dataclass
+class AgentState:
+    """Mutable state tracked across a single agent run."""
+    messages: list[Message] = field(default_factory=list)
+    tool_call_count: int = 0
+    start_time: float = 0.0

ata_coder/event_queue.py

@@ -0,0 +1,5 @@
+# -*- coding: utf-8 -*-
+"""Backward-compat re-export — EventQueue lives in core.queue now."""
+from .core.queue import EventQueue  # noqa: F401
+
+__all__ = ["EventQueue"]