ata-coder 2.4.2__py3-none-any.whl

ata_coder/settings.py

@@ -0,0 +1,439 @@
+"""
+Central settings management for ATA Coder.
+
+Stores all persistent configuration in ~/.ata_coder/settings.json.
+The ``env`` section is the canonical source for provider configuration
+(base URL, API key, model mapping, tokens, effort level) — it mirrors
+the Claude Code settings format so a single file works for both tools.
+
+Legacy ``api`` / ``model`` / ``vision`` top-level keys are still
+respected as fallbacks, but new config should go into ``env``.
+
+Usage:
+    from .settings import get_settings
+    s = get_settings()
+    model = s.model_for(task)  # auto-route based on complexity
+"""
+
+import json
+import logging
+import os
+import shutil
+import sysconfig
+from dataclasses import dataclass, field
+from pathlib import Path
+from typing import Any
+
+logger = logging.getLogger(__name__)
+
+# ── Default settings ──────────────────────────────────────────────────────────
+
+DEFAULT_SETTINGS: dict[str, Any] = {
+    "env": {
+        # Provider-agnostic configuration (Claude Code compatible).
+        # These are the canonical keys — everything else falls back here.
+        "ATA_CODER_BASE_URL": "https://api.deepseek.com",
+        "ATA_CODER_API_KEY": "",
+        "ATA_CODER_DEFAULT_MODEL": "deepseek-v4-pro",
+        "ATA_CODER_DEFAULT_OPUS_MODEL": "deepseek-v4-pro",
+        "ATA_CODER_DEFAULT_SONNET_MODEL": "deepseek-v4-pro",
+        "ATA_CODER_DEFAULT_HAIKU_MODEL": "deepseek-v4-flash",
+        "ATA_CODER_SUBAGENT_MODEL": "deepseek-v4-flash",
+        "ATA_CODER_MAX_OUTPUT_TOKENS": "16384",
+        "ATA_CODER_EFFORT_LEVEL": "",
+        # Vision config (empty = inherit from main model/API)
+        "ATA_CODER_VISION_MODEL": "",
+        "ATA_CODER_VISION_API_BASE": "",
+        "ATA_CODER_VISION_API_KEY": "",
+    },
+    "vision": {
+        # Override vision-specific provider/model (empty = inherit from env).
+        "model": "",
+        "api_base": "",
+        "api_key": "",
+    },
+    "complexity": {
+        "auto_detect": True,
+        "simple_max_chars": 60,
+        "complex_min_chars": 500,
+    },
+    "paths": {
+        "data": "~/.ata_coder",
+        "skills": "~/.ata_coder/skills",
+        "sessions": "~/.ata_coder/sessions",
+        "memory": "~/.ata_coder/memory",
+        "changes": "~/.ata_coder/changes",
+    },
+}
+
+
+# ── Settings class ────────────────────────────────────────────────────────────
+
+@dataclass
+class Settings:
+    """Singleton settings manager backed by ~/.ata_coder/settings.json."""
+
+    _data: dict[str, Any] = field(default_factory=dict)
+    _file: Path | None = None
+
+    # ── Init / Load / Save ──────────────────────────────────────────────────
+
+    def load(self, file_path: str | Path | None = None) -> "Settings":
+        """Load settings from disk, creating defaults if needed."""
+        if file_path:
+            self._file = Path(file_path)
+        else:
+            self._file = Path.home() / ".ata_coder" / "settings.json"
+
+        self._file.parent.mkdir(parents=True, exist_ok=True)
+
+        if self._file.exists():
+            try:
+                with open(self._file, "r", encoding="utf-8") as f:
+                    loaded = json.load(f)
+                self._data = self._deep_merge(DEFAULT_SETTINGS, loaded)
+                logger.debug("Loaded settings from %s", self._file)
+            except Exception as e:
+                logger.warning("Failed to load %s, using defaults: %s", self._file, e)
+                self._data = dict(DEFAULT_SETTINGS)
+                self.save()
+        else:
+            self._data = dict(DEFAULT_SETTINGS)
+            self.save()
+            logger.info("Created default settings at %s", self._file)
+
+        return self
+
+    def save(self) -> None:
+        """Persist current settings to disk.
+
+        Only writes keys that are in DEFAULT_SETTINGS — extra fields that
+        were merged in from disk (e.g. Claude Code hooks, plugins) are
+        carried forward because ``_deep_merge`` preserves them in ``_data``,
+        but ``save()`` writes the full ``_data`` dict.  If you want to
+        strip unknown keys, delete them via ``set(key, None)`` first.
+        """
+        if not self._file:
+            return
+        try:
+            with open(self._file, "w", encoding="utf-8") as f:
+                json.dump(self._data, f, indent=2, ensure_ascii=False)
+            # Restrict permissions: owner-only read/write (protects API keys)
+            os.chmod(self._file, 0o600)
+        except Exception as e:
+            logger.error("Failed to save settings: %s", e)
+
+    def reload(self) -> None:
+        """Reload settings from disk."""
+        self.load(self._file)
+
+    # ── Access ──────────────────────────────────────────────────────────────
+
+    def get(self, *keys: str, default: Any = None) -> Any:
+        """Get a nested key, e.g. settings.get('model', 'default')."""
+        node = self._data
+        for k in keys:
+            if isinstance(node, dict):
+                node = node.get(k)
+            else:
+                return default
+            if node is None:
+                return default
+        return node
+
+    def set(self, *keys: str, value: Any, save: bool = True) -> None:
+        """Set a nested key, e.g. settings.set('model', 'default', 'gpt-4o')."""
+        node = self._data
+        for k in keys[:-1]:
+            if k not in node:
+                node[k] = {}
+            node = node[k]
+        node[keys[-1]] = value
+        if save:
+            self.save()
+
+    @property
+    def data(self) -> dict:
+        return self._data
+
+    # ── Path helpers ────────────────────────────────────────────────────────
+
+    def resolve_path(self, key: str) -> Path:
+        """Resolve a path from settings (expanding ~)."""
+        raw = self.get("paths", key, default=f"~/.ata_coder/{key}")
+        return Path(raw).expanduser().resolve()
+
+    # ── env section (canonical) ─────────────────────────────────────────────
+    # Every provider-adjacent property reads ``env`` FIRST, then falls back
+    # to the legacy ``api`` / ``model`` / ``vision`` sections, then to a
+    # hardcoded default.  This way a single ``env`` block is sufficient, but
+    # old settings files without ``env`` still work.
+
+    def _env_val(self, key: str, default: str = "") -> str:
+        """Read a value from the ``env`` section."""
+        return self.get("env", key, default=default)
+
+    # ── API ─────────────────────────────────────────────────────────────────
+
+    @property
+    def api_base_url(self) -> str:
+        return (
+            self._env_val("ATA_CODER_BASE_URL")
+            or self.get("api", "base_url", default="")       # legacy
+            or "https://api.deepseek.com"
+        )
+
+    @property
+    def api_key(self) -> str:
+        return (
+            self._env_val("ATA_CODER_API_KEY")
+            or self.get("api", "api_key", default="")        # legacy
+        )
+
+    # ── Model routing ───────────────────────────────────────────────────────
+
+    @property
+    def default_model(self) -> str:
+        return (
+            self._env_val("ATA_CODER_DEFAULT_MODEL")
+            or self.get("model", "default", default="")      # legacy
+            or "deepseek-v4-pro"
+        )
+
+    @property
+    def model_opus(self) -> str:
+        return (
+            self._env_val("ATA_CODER_DEFAULT_OPUS_MODEL")
+            or self.get("model", "mapping", "opus", default="")  # legacy
+            or self.default_model
+        )
+
+    @property
+    def model_sonnet(self) -> str:
+        return (
+            self._env_val("ATA_CODER_DEFAULT_SONNET_MODEL")
+            or self.get("model", "mapping", "sonnet", default="")
+            or self.default_model
+        )
+
+    @property
+    def model_haiku(self) -> str:
+        return (
+            self._env_val("ATA_CODER_DEFAULT_HAIKU_MODEL")
+            or self.get("model", "mapping", "haiku", default="")
+            or self.default_model
+        )
+
+    @property
+    def model_subagent(self) -> str:
+        return (
+            self._env_val("ATA_CODER_SUBAGENT_MODEL")
+            or self.get("model", "mapping", "subagent", default="")
+            or self.default_model
+        )
+
+    @property
+    def max_output_tokens(self) -> int:
+        try:
+            return int(self._env_val("ATA_CODER_MAX_OUTPUT_TOKENS", "16384"))
+        except (ValueError, TypeError):
+            return 16384
+
+    @property
+    def effort_level(self) -> str:
+        return self._env_val("ATA_CODER_EFFORT_LEVEL")
+
+    @property
+    def use_anthropic(self) -> bool:
+        """Whether to use Anthropic Messages API format (instead of OpenAI)."""
+        return self._env_val("ATA_CODER_USE_ANTHROPIC") == "1"
+
+    # ── Vision (still uses dedicated section — optional override) ───────────
+
+    @property
+    def vision_model(self) -> str:
+        """Vision model override (empty = use main model from ATA_CODER_DEFAULT_MODEL)."""
+        return self._env_val("ATA_CODER_VISION_MODEL") or self.get("vision", "model", default="")
+
+    @property
+    def vision_api_base(self) -> str:
+        """Vision API base override (empty = use main ATA_CODER_BASE_URL)."""
+        return self._env_val("ATA_CODER_VISION_API_BASE") or self.get("vision", "api_base", default="")
+
+    @property
+    def vision_api_key(self) -> str:
+        """Vision API key override (empty = use main ATA_CODER_API_KEY)."""
+        return self._env_val("ATA_CODER_VISION_API_KEY") or self.get("vision", "api_key", default="")
+
+    # ── Directories ─────────────────────────────────────────────────────────
+
+    @property
+    def data_dir(self) -> Path:
+        return self.resolve_path("data")
+
+    @property
+    def skills_dir(self) -> Path:
+        return self.resolve_path("skills")
+
+    @property
+    def sessions_dir(self) -> Path:
+        return self.resolve_path("sessions")
+
+    @property
+    def memory_dir(self) -> Path:
+        return self.resolve_path("memory")
+
+    @property
+    def changes_dir(self) -> Path:
+        return self.resolve_path("changes")
+
+    def ensure_dirs(self) -> None:
+        """Create all configured directories."""
+        for key in ("data", "skills", "sessions", "memory", "changes"):
+            d = self.resolve_path(key)
+            d.mkdir(parents=True, exist_ok=True)
+
+    # ── Complexity ──────────────────────────────────────────────────────────
+
+    def shortcut_classify(self, task: str) -> str | None:
+        """
+        Quick length-based shortcut — skip AI classify for obvious cases.
+        Returns 'simple', 'complex', or None (None = need AI classify).
+        """
+        if not self.get("complexity", "auto_detect", default=True):
+            return "normal"
+
+        task_len = len(task.strip())
+        simple_max = self.get("complexity", "simple_max_chars", default=60)
+        complex_min = self.get("complexity", "complex_min_chars", default=500)
+
+        if task_len <= simple_max:
+            return "simple"
+        if task_len >= complex_min:
+            return "complex"
+        return None  # middle ground → let AI decide
+
+    # ── Internal ────────────────────────────────────────────────────────────
+
+    @staticmethod
+    def _deep_merge(base: dict, override: dict) -> dict:
+        """Recursively merge override into base.
+
+        Dict values are recursively merged; lists and scalars are replaced
+        wholesale (no append).  This is intentional — lists like
+        ``allowed_commands`` represent the user's explicit choice, not a
+        cumulative set.
+        """
+        result = dict(base)
+        for k, v in override.items():
+            if k in result and isinstance(result[k], dict) and isinstance(v, dict):
+                result[k] = Settings._deep_merge(result[k], v)
+            elif k in result and isinstance(result[k], list) and isinstance(v, list):
+                # List override: user's values replace defaults (explicit choice)
+                result[k] = v
+            else:
+                result[k] = v
+        return result
+
+
+# ── Global singleton ──────────────────────────────────────────────────────────
+
+_settings: Settings | None = None
+
+
+def get_settings(file_path: str | Path | None = None) -> Settings:
+    """Get or create the global Settings singleton."""
+    global _settings
+    if _settings is None:
+        _settings = Settings().load(file_path)
+    return _settings
+
+
+def init_settings(file_path: str | Path | None = None) -> Settings:
+    """Initialize settings, seeding skills from project source if needed."""
+    settings = get_settings(file_path)
+
+    # Ensure all directories exist
+    settings.ensure_dirs()
+
+    # Seed default skills from project source → ~/.ata_coder/skills/
+    _seed_skills(settings)
+
+    # Seed default memories from project source → ~/.ata_coder/memory/
+    _seed_memories(settings)
+
+    return settings
+
+
+def _find_source_dir(name: str) -> Path | None:
+    """Find a data directory (skills, memory, prompts) in various locations."""
+    # 1. Development: next to this file (project root)
+    candidate = Path(__file__).parent / name
+    if candidate.is_dir():
+        return candidate
+    # 2. pip install: site-packages data_files
+    data_path = Path(sysconfig.get_path("data"))
+    candidate = data_path / name
+    if candidate.is_dir():
+        return candidate
+    # 3. pip install (user): user site data
+    user_data = Path(sysconfig.get_path("data", scheme="nt_user" if os.name == "nt" else "posix_user"))
+    candidate = user_data / name
+    if candidate.is_dir():
+        return candidate
+    return None
+
+
+def _seed_skills(settings: Settings) -> None:
+    """Copy skill folders from project source to ~/.ata_coder/skills/ if empty."""
+    target = settings.skills_dir
+
+    # Check if skills already exist (folder-based or flat legacy)
+    has_skills = any(
+        (d / "SKILL.md").exists() or (d / "manifest.json").exists()
+        for d in target.iterdir() if d.is_dir()
+    )
+    if has_skills:
+        return
+
+    source = _find_source_dir("skills")
+    if not source:
+        logger.debug("No skills source dir found, skipping seed")
+        return
+
+    target.mkdir(parents=True, exist_ok=True)
+    for d in source.iterdir():
+        if d.is_dir() and not d.name.startswith("."):
+            dest = target / d.name
+            if not dest.exists():
+                shutil.copytree(d, dest)
+                logger.info("Seeded skill folder: %s", d.name)
+    for fp in source.glob("*.md"):
+        dest = target / fp.name
+        if not dest.exists():
+            shutil.copy2(fp, dest)
+            logger.info("Seeded skill: %s", fp.name)
+    for fp in source.glob("*.json"):
+        dest = target / fp.name
+        if not dest.exists():
+            shutil.copy2(fp, dest)
+
+
+def _seed_memories(settings: Settings) -> None:
+    """Copy default memory files from project source to ~/.ata_coder/memory/ if empty."""
+    target = settings.memory_dir
+    if list(target.glob("*.md")):
+        return
+
+    source = _find_source_dir("memory")
+    if not source:
+        logger.debug("No memory source dir found, skipping seed")
+        return
+
+    target.mkdir(parents=True, exist_ok=True)
+    for fp in source.glob("*"):
+        if fp.name == "__pycache__":
+            continue
+        if fp.is_file():
+            shutil.copy2(fp, target / fp.name)
+            logger.info("Seeded memory: %s → %s", fp.name, target / fp.name)

ata_coder/setup_wizard.py

@@ -0,0 +1,136 @@
+"""First-run interactive configuration wizard — extracted from main.py."""
+import os
+import sys
+from pathlib import Path
+
+
+def is_configured() -> bool:
+    """Check if settings.json exists and has an API key."""
+    settings_file = Path.home() / ".ata_coder" / "settings.json"
+    if not settings_file.exists():
+        return False
+    try:
+        import json as _json
+        data = _json.loads(settings_file.read_text(encoding="utf-8"))
+        legacy_key = data.get("api", {}).get("api_key", "").strip()
+        env_key = data.get("env", {}).get("ATA_CODER_API_KEY", "").strip()
+        return bool(legacy_key or env_key)
+    except Exception:
+        return False
+
+
+def run_setup_wizard() -> None:
+    """Interactive API configuration wizard."""
+    settings_dir = Path.home() / ".ata_coder"
+    settings_file = settings_dir / "settings.json"
+
+    print("  检测到首次运行，开始初始化配置...")
+    print()
+
+    # ── API Base URL ────────────────────────────────────
+    default_url = "https://api.deepseek.com"
+    print(f"  API Base URL [默认: {default_url}]:")
+    try:
+        base_url = input("  > ").strip()
+    except (KeyboardInterrupt, EOFError):
+        print("\n  配置取消。")
+        sys.exit(0)
+    if not base_url:
+        base_url = default_url
+
+    # ── API Key ─────────────────────────────────────────
+    print()
+    print("  API Key (输入会隐藏):")
+    try:
+        if os.name == "nt":
+            import msvcrt
+            api_key_parts: list[str] = []
+            while True:
+                ch = msvcrt.getch()
+                if ch in (b"\r", b"\n"):
+                    break
+                if ch == b"\x08":
+                    if api_key_parts:
+                        api_key_parts.pop()
+                elif ch == b"\x03":
+                    print("\n  配置取消。")
+                    sys.exit(0)
+                else:
+                    api_key_parts.append(ch.decode("utf-8", errors="replace"))
+            api_key = "".join(api_key_parts)
+        else:
+            import tty
+            import termios
+            fd = sys.stdin.fileno()
+            old = termios.tcgetattr(fd)
+            try:
+                tty.setraw(fd)
+                api_key = ""
+                while True:
+                    ch = sys.stdin.read(1)
+                    if ch in ("\r", "\n"):
+                        break
+                    if ch == "\x03":
+                        print("\n  配置取消。")
+                        sys.exit(0)
+                    api_key += ch
+            finally:
+                termios.tcsetattr(fd, termios.TCSADRAIN, old)
+    except (KeyboardInterrupt, EOFError):
+        print("\n  配置取消。")
+        sys.exit(0)
+    print()
+
+    if not api_key.strip():
+        print("  ⚠ 未输入 API Key。可稍后编辑 ~/.ata_coder/settings.json")
+        print()
+
+    # ── Write settings ──────────────────────────────────
+    settings_dir.mkdir(parents=True, exist_ok=True)
+    from .settings import Settings
+    s = Settings().load(settings_file)
+    s.set("env", "ATA_CODER_BASE_URL", base_url, save=False)
+    s.set("env", "ATA_CODER_API_KEY", api_key.strip(), save=False)
+    s.save()
+    print(f"  ✓ 配置已保存到 {settings_file}")
+    print()
+
+
+__version__ = "2.4.2"
+
+
+def print_banner() -> None:
+    """Startup banner — project identity in 0.1 seconds."""
+    try:
+        test_dir = Path(__file__).parent / "tests"
+        test_files = list(test_dir.glob("test_*.py"))
+        test_count = sum(
+            len([l for l in f.read_text(encoding="utf-8").splitlines()
+                 if l.strip().startswith("def test_")])
+            for f in test_files
+        )
+    except Exception:
+        test_count = "?"
+
+    print(fr"""
+┌─ ATA Coder v{__version__} ────────────┐
+│  🤖 Self-Bootstrapped AI Assistant  │
+│  📦 {test_count} tests passed               {' ' if len(str(test_count)) < 3 else ''} │
+│  🔒 Security-hardened by self-audit │
+└─────────────────────────────────────┘
+""")
+
+
+def ensure_first_run(force: bool = False) -> None:
+    """Check config; if not configured (or force=True), run setup wizard.
+
+    Scenarios:
+      A) No config  → banner + setup wizard
+      B) ata init   → force setup wizard (overwrite)
+      C) Has config → silent pass, straight to REPL
+    """
+    if not force and is_configured():
+        return
+    if not force:
+        print_banner()
+    run_setup_wizard()

ata_coder/skill_extension.py

@@ -0,0 +1,92 @@
+# -*- coding: utf-8 -*-
+"""
+SkillExtension — adapter that wraps a Skill as an Extension.
+
+Lets the ExtensionManager manage Skills and non-Skill extensions
+uniformly, enabling multi-skill + extension coexistence.
+"""
+
+import logging
+from typing import TYPE_CHECKING
+
+from .extension import Extension, ExtensionMeta
+
+if TYPE_CHECKING:
+    from .skills import Skill
+
+logger = logging.getLogger(__name__)
+
+__all__ = ["SkillExtension"]
+
+
+class SkillExtension(Extension):
+    """
+    Adapter: wraps a Skill (from skills.py) as an Extension.
+
+    Skill.system_prompt → get_prompt()
+    Skill.tools (list[str]) → get_tools() (list of tool names)
+    Skill.triggers are NOT mapped (SkillManager handles detection separately).
+
+    Usage:
+        from .skills import Skill
+        from .skill_extension import SkillExtension
+
+        skill = Skill(name="debugger", ...)
+        ext = SkillExtension(skill)
+        manager.register(ext)
+        manager.activate("skill:debugger")
+    """
+
+    def __init__(self, skill: "Skill"):
+        """
+        Args:
+            skill: skills.Skill instance
+        """
+        self._skill = skill
+        self.meta = ExtensionMeta(
+            name=f"skill:{skill.name}",
+            version="1.0.0",
+            description=skill.description or f"Skill: {skill.name}",
+            tags=["skill", skill.name],
+            priority=80,  # Skills have higher priority than general extensions (default 100)
+        )
+        # Skill-to-skill dependencies (Python packages go in requirements.txt instead)
+        if hasattr(skill, "dependencies") and skill.dependencies:
+            self.meta.dependencies = list(skill.dependencies)
+
+    @property
+    def skill_name(self) -> str:
+        """The raw skill name (without the 'skill:' prefix)."""
+        return self._skill.name
+
+    # ── Extension interface ─────────────────────────────────────────────────
+
+    def get_prompt(self) -> str:
+        """返回 skill 的 system prompt（含 @include 解析）。"""
+        return self._skill.resolve_includes(self._skill.system_prompt or "")
+
+    def get_tools(self) -> list[str]:
+        """
+        返回 skill 限制的工具名称列表。
+        空列表 = 允许所有工具。
+        """
+        if hasattr(self._skill, "tools") and self._skill.tools:
+            return list(self._skill.tools)
+        return []
+
+    def on_activate(self) -> None:
+        """Skill 被激活时的回调。"""
+        logger.info("Skill activated via extension: %s", self._skill.name)
+
+    def on_deactivate(self) -> None:
+        """Skill 被停用时的回调。"""
+        logger.info("Skill deactivated via extension: %s", self._skill.name)
+
+    def validate(self) -> tuple[bool, str]:
+        """验证 skill 是否可用。"""
+        if not self._skill.system_prompt:
+            return False, "Skill has no system_prompt"
+        return True, "OK"
+
+    def __repr__(self) -> str:
+        return f"SkillExtension(name={self._skill.name!r})"