codenaut 0.1.0__py3-none-any.whl

config/config.py

@@ -0,0 +1,173 @@
+from __future__ import annotations
+
+from enum import Enum
+import os
+from pathlib import Path
+from typing import Any
+
+from pydantic import BaseModel, Field, model_validator
+
+
+class ModelConfig(BaseModel):
+    name: str = "openai/gpt-oss-120b"
+    temperature: float = Field(default=1, ge=0.0, le=2.0)
+    context_window: int = 512_000
+
+
+class ShellEnvironmentPolicy(BaseModel):
+    ignore_default_excludes: bool = False
+    exclude_patterns: list[str] = Field(
+        default_factory=lambda: ["*KEY*", "*TOKEN*", "*SECRET*"]
+    )
+    set_vars: dict[str, str] = Field(default_factory=dict)
+
+
+class MCPServerConfig(BaseModel):
+    enabled: bool = True
+    startup_timeout_sec: float = 10
+
+    command: str | None = None
+    args: list[str] = Field(default_factory=list)
+    env: dict[str, str] = Field(default_factory=dict)
+    cwd: Path | None = None
+    url: str | None = None
+
+    @model_validator(mode="after")
+    def validate_transport(self) -> MCPServerConfig:
+        has_command = self.command is not None
+        has_url = self.url is not None
+
+        if not has_command and not has_url:
+            raise ValueError(
+                "MCP Server must have either 'command' (stdio) or 'url' (http/sse)"
+            )
+
+        if has_command and has_url:
+            raise ValueError(
+                "MCP Server cannot have both 'command' (stdio) and 'url' (http/sse)"
+            )
+
+        return self
+
+
+class ApprovalPolicy(str, Enum):
+    ON_REQUEST = "on-request"
+    ON_FAILURE = "on-failure"
+    AUTO = "auto"
+    AUTO_EDIT = "auto-editt"
+    NEVER = "never"
+    YOLO = "yolo"
+
+
+class HookTrigger(str, Enum):
+    BEFORE_AGENT = "before_agent"
+    AFTER_AGENT = "after_agent"
+    BEFORE_TOOL = "before_tool"
+    AFTER_TOOL = "after_tool"
+    ON_ERROR = "on_error"
+
+
+class HookConfig(BaseModel):
+    name: str
+    trigger: HookTrigger
+    command: str | None = None
+    script: str | None = None
+    timeout_sec: float = 30
+    enabled: bool = True
+
+    @model_validator(mode="after")
+    def validate_hook(self) -> HookConfig:
+        if not self.command and not self.script:
+            raise ValueError("Hook must either have 'command' or 'script'")
+        return self
+
+
+class Config(BaseModel):
+    model: ModelConfig = Field(default_factory=ModelConfig)
+    cwd: Path = Field(default_factory=Path.cwd)
+    shell_environment: ShellEnvironmentPolicy = Field(
+        default_factory=ShellEnvironmentPolicy
+    )
+    hooks_enabled: bool = True
+    hooks: list[HookConfig] = Field(default_factory=list)
+    approval: ApprovalPolicy = ApprovalPolicy.ON_REQUEST
+    max_turns: int = 100
+    mcp_servers: dict[str, MCPServerConfig] = Field(default_factory=dict)
+    api_key_value: str | None = Field(
+        default=None,
+        alias="api_key",
+        exclude=True,
+        repr=False,
+    )
+    base_url_value: str | None = Field(
+        default=None,
+        alias="base_url",
+        exclude=True,
+        repr=False,
+    )
+
+    allowed_tools: list[str] | None = Field(
+        None,
+        description="If set, only these tools will be available to the agent",
+    )
+    skills_enabled: bool = True
+    extra_skill_dirs: list[Path] = Field(default_factory=list)
+    allowed_skills: list[str] | None = Field(
+        None,
+        description="If set, only these skills will be available to the agent",
+    )
+    always_loaded_skills: list[str] = Field(default_factory=list)
+
+    developer_instructions: str | None = None
+    user_instructions: str | None = None
+
+    debug: bool = False
+
+    @property
+    def api_key(self) -> str | None:
+        return self.api_key_value or os.environ.get("API_KEY")
+
+    @property
+    def base_url(self) -> str | None:
+        return self.base_url_value or os.environ.get("BASE_URL")
+
+    @property
+    def model_name(self) -> str:
+        return self.model.name
+
+    @model_name.setter
+    def model_name(self, value: str) -> None:
+        self.model.name = value
+
+    @property
+    def temperature(self) -> float:
+        return self.model.temperature
+
+    @temperature.setter
+    def temperature(self, value: float) -> None:
+        self.model.temperature = value
+
+    def set_credentials(self, api_key: str, base_url: str | None = None) -> None:
+        self.api_key_value = api_key
+        self.base_url_value = base_url or None
+
+    def validate(self) -> list[str]:
+        errors: list[str] = []
+
+        if not self.api_key:
+            errors.append(
+                "No API key found. Run `code-it --configure` or set API_KEY."
+            )
+
+        if not self.cwd.exists():
+            errors.append(f"Working directory does not exist: {self.cwd}")
+
+        return errors
+
+    def to_dict(self) -> dict[str, Any]:
+        data = self.model_dump(mode="json", by_alias=True)
+        if self.api_key_value:
+            data["api_key"] = self.api_key_value
+        if self.base_url_value:
+            data["base_url"] = self.base_url_value
+        return data

config/loader.py

@@ -0,0 +1,173 @@
+from pathlib import Path
+from typing import Any
+import logging
+
+from dotenv import load_dotenv
+from platformdirs import user_config_dir, user_data_dir
+
+try:
+    import tomllib as tomli
+except ModuleNotFoundError:  # pragma: no cover
+    import tomli
+
+from config.config import Config
+from utils.errors import ConfigError
+
+logger = logging.getLogger(__name__)
+
+APP_NAME = "code-it"
+CONFIG_FILE_NAME = "config.toml"
+AGENT_MD_FILE = "AGENT.MD"
+PROJECT_CONFIG_DIR_NAME = ".ai-agent"
+
+
+def get_config_dir() -> Path:
+    return Path(user_config_dir(APP_NAME))
+
+
+def get_data_dir() -> Path:
+    return Path(user_data_dir(APP_NAME))
+
+
+def ensure_config_dir() -> Path:
+    config_dir = get_config_dir()
+    config_dir.mkdir(parents=True, exist_ok=True)
+    return config_dir
+
+
+def get_system_config_path() -> Path:
+    return get_config_dir() / CONFIG_FILE_NAME
+
+
+def _parse_toml(path: Path) -> dict[str, Any]:
+    try:
+        with open(path, "rb") as file_obj:
+            data = tomli.load(file_obj)
+            return data if isinstance(data, dict) else {}
+    except tomli.TOMLDecodeError as error:
+        raise ConfigError(
+            f"Invalid TOML in {path}: {error}",
+            config_file=str(path),
+        ) from error
+    except (OSError, IOError) as error:
+        raise ConfigError(
+            f"Failed to read config file {path}: {error}",
+            config_file=str(path),
+        ) from error
+
+
+def _get_project_config(cwd: Path) -> Path | None:
+    agent_dir = cwd.resolve() / PROJECT_CONFIG_DIR_NAME
+    config_file = agent_dir / CONFIG_FILE_NAME
+    if config_file.is_file():
+        return config_file
+    return None
+
+
+def _get_agent_md_files(cwd: Path) -> str | None:
+    agent_md_file = cwd.resolve() / AGENT_MD_FILE
+    if agent_md_file.is_file():
+        return agent_md_file.read_text(encoding="utf-8")
+    return None
+
+
+def _merge_dicts(base: dict[str, Any], override: dict[str, Any]) -> dict[str, Any]:
+    result = base.copy()
+    for key, value in override.items():
+        if key in result and isinstance(result[key], dict) and isinstance(value, dict):
+            result[key] = _merge_dicts(result[key], value)
+        else:
+            result[key] = value
+    return result
+
+
+def _format_toml_value(value: Any) -> str:
+    if isinstance(value, bool):
+        return "true" if value else "false"
+    if isinstance(value, (int, float)):
+        return str(value)
+    if isinstance(value, str):
+        escaped = value.replace("\\", "\\\\").replace('"', '\\"')
+        return f'"{escaped}"'
+    if isinstance(value, list):
+        return "[" + ", ".join(_format_toml_value(item) for item in value) + "]"
+    raise TypeError(f"Unsupported TOML value: {type(value)!r}")
+
+
+def _dumps_toml(data: dict[str, Any]) -> str:
+    lines: list[str] = []
+
+    scalars = {
+        key: value
+        for key, value in data.items()
+        if not isinstance(value, dict) and value is not None
+    }
+    tables = {
+        key: value
+        for key, value in data.items()
+        if isinstance(value, dict) and value
+    }
+
+    for key, value in scalars.items():
+        lines.append(f"{key} = {_format_toml_value(value)}")
+
+    for table_name, table_values in tables.items():
+        if lines:
+            lines.append("")
+        lines.append(f"[{table_name}]")
+        for key, value in table_values.items():
+            if isinstance(value, dict):
+                raise TypeError("Nested TOML tables beyond one level are not supported")
+            if value is None:
+                continue
+            lines.append(f"{key} = {_format_toml_value(value)}")
+
+    return "\n".join(lines) + "\n"
+
+
+def save_system_config(updates: dict[str, Any]) -> Path:
+    config_dir = ensure_config_dir()
+    config_path = config_dir / CONFIG_FILE_NAME
+    current: dict[str, Any] = {}
+
+    if config_path.is_file():
+        current = _parse_toml(config_path)
+
+    merged = _merge_dicts(current, updates)
+    config_path.write_text(_dumps_toml(merged), encoding="utf-8")
+    return config_path
+
+
+def load_config(cwd: Path | None) -> Config:
+    cwd = cwd or Path.cwd()
+    load_dotenv(cwd / ".env")
+
+    system_path = get_system_config_path()
+    config_dict: dict[str, Any] = {}
+
+    if system_path.is_file():
+        try:
+            config_dict = _parse_toml(system_path)
+        except ConfigError:
+            logger.warning("Skipping invalid system config: %s", system_path)
+
+    project_path = _get_project_config(cwd)
+    if project_path:
+        try:
+            project_config_dict = _parse_toml(project_path)
+            config_dict = _merge_dicts(config_dict, project_config_dict)
+        except ConfigError:
+            logger.warning("Skipping invalid project config: %s", project_path)
+
+    if "cwd" not in config_dict:
+        config_dict["cwd"] = cwd
+
+    if "developer_instructions" not in config_dict:
+        agent_md_content = _get_agent_md_files(cwd)
+        if agent_md_content:
+            config_dict["developer_instructions"] = agent_md_content
+
+    try:
+        return Config(**config_dict)
+    except Exception as error:
+        raise ConfigError(f"Invalid configuration: {error}") from error

context/__init__.py

@@ -0,0 +1 @@
+"""Conversation context management."""

context/compaction.py

@@ -0,0 +1,96 @@
+from typing import Any
+from client.llm_client import LLMClient
+from client.response import StreamEventType, TokenUsage
+from context.manager import ContextManager
+from prompts.system import get_compression_prompt
+
+
+class ChatCompactor:
+    def __init__(self, client: LLMClient):
+        self.client = client
+        self.last_error: str | None = None
+
+    def _format_history_for_compaction(self, messages: list[dict[str, Any]]) -> str:
+        output = ["Here is the conversation that needs to be continue: \n"]
+
+        for msg in messages:
+            role = msg.get("role", "")
+            content = msg.get("content", "")
+
+            if role == "system":
+                continue
+
+            if role == "tool":
+                tool_id = msg.get("tool_call_id", "unknown")
+
+                truncated = content[:2000] if len(content) > 2000 else content
+                if len(content) > 2000:
+                    truncated += "\n... [tool output truncated]"
+
+                output.append(f"[Tool Result ({tool_id})]:\n{truncated}")
+            elif role == "assistant":
+                tool_details = []
+                if content:
+                    truncated = content[:3000] if len(content) > 3000 else content
+                    if len(content) > 3000:
+                        truncated += "\n... [response truncated]"
+                    output.append(f"Assistant:\n{truncated}")
+
+                if msg.get("tool_calls"):
+                    for tc in msg["tool_calls"]:
+                        func = tc.get("function", {})
+                        name = func.get("name", "unknown")
+                        args = func.get("arguments", "{}")
+
+                        if len(args) > 500:
+                            args = args[:500]
+                        tool_details.append(f"  - {name}({args})")
+
+                    output.append("Assistant called tools:\n" + "\n".join(tool_details))
+            else:
+                truncated = content[:1500] if len(content) > 1500 else content
+                if len(content) > 1500:
+                    truncated += "\n... [message truncated]"
+                output.append(f"User:\n{truncated}")
+
+        return "\n\n---\n\n".join(output)
+
+    async def compress(
+        self, context_manager: ContextManager
+    ) -> tuple[str | None, TokenUsage | None]:
+        self.last_error = None
+        messages = context_manager.get_messages()
+
+        if len(messages) < 3:
+            return None, None
+
+        compression_messages = [
+            {
+                "role": "system",
+                "content": get_compression_prompt(),
+            },
+            {
+                "role": "user",
+                "content": self._format_history_for_compaction(messages),
+            },
+        ]
+
+        try:
+            summary = ""
+            usage = None
+            async for event in self.client.chat_completion(
+                compression_messages,
+                stream=False,
+            ):
+                if event.type == StreamEventType.MESSAGE_COMPLETE:
+                    usage = event.usage
+                    summary += event.text_delta.content
+
+            if not summary or not usage:
+                self.last_error = "Compaction returned no summary."
+                return None, None
+
+            return summary, usage
+        except Exception as error:
+            self.last_error = str(error) or error.__class__.__name__
+            return None, None

context/loop_detector.py

@@ -0,0 +1,49 @@
+from collections import deque
+from typing import Any
+
+
+class LoopDetector:
+    def __init__(self):
+        self.max_exact_repeats = 10
+        self.max_cycle_length = 10
+        self._history: deque[str] = deque(maxlen=20)
+
+    def record_action(self, action_type: str, **details: Any):
+        output = [action_type]
+
+        if action_type == "tool_call":
+            output.append(details.get("tool_name", ""))
+            args = details.get("args", {})
+
+            if isinstance(args, dict):
+                for k in sorted(args.keys()):
+                    output.append(f"{k}={str(args[k])}")
+        elif action_type == "response":
+            output.append(details.get("text", ""))
+
+        signature = "|".join(output)
+        self._history.append(signature)
+
+    def check_for_loop(self) -> str | None:
+        if len(self._history) < 2:
+            return None
+
+        if len(self._history) >= self.max_exact_repeats:
+            recent = list(self._history)[-self.max_exact_repeats :]
+            if len(set(recent)) == 1:
+                return f"Same action repeated {self.max_exact_repeats} tiems"
+
+        if len(self._history) >= self.max_cycle_length * 2:
+            history = list(self._history)
+
+            for cycle_len in range(
+                2, min(self.max_cycle_length + 1, len(history) // 2 + 1)
+            ):
+                recent = history[-cycle_len * 2 :]
+                if recent[:cycle_len] == recent[cycle_len:]:
+                    return f"Detected repeating cycle of length {cycle_len}"
+
+        return None
+
+    def clear(self) -> None:
+        self._history.clear()