tagword-codeagent 1.1.6__py3-none-any.whl

codeagent/core/default_presets.py

@@ -0,0 +1,159 @@
+"""Per-use-type default preset IDs.
+
+Extends seed's `get_default_preset_id()` (which is a single chat-only default)
+with a multi-slot default map: ``{chat: 'preset-abc', vision: 'preset-xyz', ...}``.
+
+Storage:
+- Primary: ``<config_dir>/default_presets.json`` (a JSON object)
+- Legacy fallback: ``<config_dir>/codeagent.default_preset_ids.json``
+- Ultimate fallback: seed's ``seed.default_model`` (chat only)
+
+Slots: ``chat``, ``vision``, ``image_gen``, ``audio``, ``music``, ``video_gen``.
+"""
+
+from __future__ import annotations
+
+import json
+import logging
+from pathlib import Path
+from typing import Dict
+
+logger = logging.getLogger(__name__)
+
+# Ordered list of supported slots. "chat" must come first for legacy compat.
+SLOTS: tuple[str, ...] = (
+    "chat",
+    "vision",
+    "image_gen",
+    "audio",
+    "music",
+    "video_gen",
+)
+
+DEFAULT_PRESET_IDS_FILENAME = "default_presets.json"
+LEGACY_PRESET_IDS_FILENAME = "codeagent.default_preset_ids.json"
+
+
+def _config_dir() -> Path:
+    """Resolve the same config dir seed.core.llm_presets uses."""
+    try:
+        from seed.core.llm_presets import _config_dir as _seed_config_dir  # type: ignore
+        return _seed_config_dir()
+    except Exception:
+        # Fallback (shouldn't normally trigger): SEED_PROJECT_ROOT/config
+        import os
+        root = os.environ.get("SEED_PROJECT_ROOT", "").strip() or "."
+        return Path(root) / "config"
+
+
+def _new_path() -> Path:
+    return _config_dir() / DEFAULT_PRESET_IDS_FILENAME
+
+
+def _legacy_path() -> Path | None:
+    """Path of the legacy single-id file from seed, if any."""
+    try:
+        from seed.core.llm_presets import _default_id_read_path  # type: ignore
+        p = _default_id_read_path()
+        return p if p is not None else None
+    except Exception:
+        return None
+
+
+def _read_legacy_single_id() -> str:
+    p = _legacy_path()
+    if p is None or not p.is_file():
+        return ""
+    try:
+        return p.read_text(encoding="utf-8").strip()
+    except OSError:
+        return ""
+
+
+def get_default_preset_ids() -> Dict[str, str]:
+    """Return a mapping ``{slot: preset_id}`` for every slot that has a default.
+
+    Reads the new JSON map first; falls back to ``codeagent.default_preset_ids.json``
+    (legacy), then the seed single-id file (assigned to ``chat``).
+    """
+    p = _new_path()
+    if p.is_file():
+        try:
+            data = json.loads(p.read_text(encoding="utf-8") or "{}")
+        except (json.JSONDecodeError, OSError):
+            data = {}
+        if isinstance(data, dict):
+            out: Dict[str, str] = {}
+            for slot in SLOTS:
+                v = data.get(slot)
+                if isinstance(v, str) and v.strip():
+                    out[slot] = v.strip()
+            return out
+    # Legacy fallback 1: old codeagent.default_preset_ids.json
+    leg = _config_dir() / LEGACY_PRESET_IDS_FILENAME
+    if leg.is_file():
+        try:
+            data = json.loads(leg.read_text(encoding="utf-8") or "{}")
+        except (json.JSONDecodeError, OSError):
+            data = {}
+        if isinstance(data, dict):
+            out: Dict[str, str] = {}
+            for slot in SLOTS:
+                v = data.get(slot)
+                if isinstance(v, str) and v.strip():
+                    out[slot] = v.strip()
+            if out:
+                return out
+    # Legacy fallback 2: single id assigned to "chat"
+    legacy = _read_legacy_single_id()
+    if legacy:
+        return {"chat": legacy}
+    return {}
+
+
+def set_default_preset_id_for_slot(slot: str, preset_id: str) -> None:
+    """Set/clear the default for a single slot. Empty string clears."""
+    if slot not in SLOTS:
+        raise ValueError(f"unknown slot: {slot!r}")
+    cur = get_default_preset_ids()
+    pid = (preset_id or "").strip()
+    if pid:
+        cur[slot] = pid
+    else:
+        cur.pop(slot, None)
+    _write_default_preset_ids(cur)
+
+
+def set_default_preset_ids(mapping: Dict[str, str]) -> None:
+    """Bulk-replace the entire default map (ignoring unknown slots)."""
+    out: Dict[str, str] = {}
+    for slot in SLOTS:
+        if slot in mapping:
+            v = mapping[slot]
+            if isinstance(v, str) and v.strip():
+                out[slot] = v.strip()
+    _write_default_preset_ids(out)
+
+
+def _write_default_preset_ids(mapping: Dict[str, str]) -> None:
+    p = _new_path()
+    p.parent.mkdir(parents=True, exist_ok=True)
+    try:
+        p.write_text(json.dumps(mapping, ensure_ascii=False, indent=2) + "\n", encoding="utf-8")
+    except OSError as e:
+        logger.error("Failed to save default preset ids: %s", e)
+
+
+# ---------------------------------------------------------------------------
+# Backward-compat shim — keep `get_default_preset_id` and `set_default_preset_id`
+# behaving as before for any in-process callers that still import them.
+# ---------------------------------------------------------------------------
+
+def get_default_preset_id() -> str:
+    """Legacy single-id shim → returns the 'chat' default (or '' if none)."""
+    return get_default_preset_ids().get("chat", "")
+
+
+def set_default_preset_id(preset_id: str) -> None:
+    """Legacy single-id shim → sets the 'chat' default."""
+    set_default_preset_id_for_slot("chat", preset_id)

codeagent/core/env.py

@@ -0,0 +1,106 @@
+"""Code Agent product environment variables (``CODEAGENT_*`` only)."""
+
+from __future__ import annotations
+
+import os
+from pathlib import Path
+
+# --- Product data root (Code Agent home, not Seed generic ``~/.seed``) ---
+
+HOME = "CODEAGENT_HOME"
+PROJECT_ROOT = "CODEAGENT_PROJECT_ROOT"
+
+# --- Product keys (not read by Seed) ---
+
+AGENT_ID = "CODEAGENT_AGENT_ID"
+LOG_LEVEL = "CODEAGENT_LOG_LEVEL"
+SKILLS_AUTO = "CODEAGENT_SKILLS_AUTO"
+SKILLS_TOP_K = "CODEAGENT_SKILLS_TOP_K"
+DIARY = "CODEAGENT_DIARY"
+DIARY_KEEP_DAYS = "CODEAGENT_DIARY_KEEP_DAYS"
+CHAT_USER_ROUNDS = "CODEAGENT_CHAT_USER_ROUNDS"
+MAX_TOOL_ROUNDS = "CODEAGENT_MAX_TOOL_ROUNDS"
+CHAT_AUTO_CONTINUE_ON_LIMIT = "CODEAGENT_CHAT_AUTO_CONTINUE_ON_LIMIT"
+CHAT_AUTO_CONTINUE_MAX_SEGMENTS = "CODEAGENT_CHAT_AUTO_CONTINUE_MAX_SEGMENTS"
+CHAT_MAX_TOOL_ROUNDS_DEFAULT = "CODEAGENT_CHAT_MAX_TOOL_ROUNDS_DEFAULT"
+CONTEXT_COMPACT = "CODEAGENT_CONTEXT_COMPACT"
+CONTEXT_COMPACT_MIN_TOKENS = "CODEAGENT_CONTEXT_COMPACT_MIN_TOKENS"
+CONTEXT_COMPACT_KEEP_USER_ROUNDS = "CODEAGENT_CONTEXT_COMPACT_KEEP_USER_ROUNDS"
+CONTEXT_COMPACT_MID_LOOP = "CODEAGENT_CONTEXT_COMPACT_MID_LOOP"
+CONTEXT_COMPACT_ADAPTIVE_KEEP = "CODEAGENT_CONTEXT_COMPACT_ADAPTIVE_KEEP"
+CONTEXT_COMPACT_SUMMARIZER_PROMPT_FILE = "CODEAGENT_CONTEXT_COMPACT_SUMMARIZER_PROMPT_FILE"
+CONTEXT_COMPACT_SUMMARIZER_BASEURL = "CODEAGENT_CONTEXT_COMPACT_SUMMARIZER_BASEURL"
+CONTEXT_COMPACT_SUMMARIZER_MODEL = "CODEAGENT_CONTEXT_COMPACT_SUMMARIZER_MODEL"
+CONTEXT_COMPACT_SUMMARIZER_MAX_TOKENS = "CODEAGENT_CONTEXT_COMPACT_SUMMARIZER_MAX_TOKENS"
+CHAT_MAX_TOKENS = "CODEAGENT_CHAT_MAX_TOKENS"
+LLM_CONTEXT_SIZE = "CODEAGENT_LLM_CONTEXT_SIZE"
+WEBUI_SESSION_HISTORY_MAX_CHARS = "CODEAGENT_WEBUI_SESSION_HISTORY_MAX_CHARS"
+WEBUI_SESSION_HISTORY_USER_BLOCKS = "CODEAGENT_WEBUI_SESSION_HISTORY_USER_BLOCKS"
+WEBUI_SESSION_HISTORY_MAX_MESSAGES = "CODEAGENT_WEBUI_SESSION_HISTORY_MAX_MESSAGES"
+WEBUI_SESSION_HISTORY_REASONING_MAX_CHARS = "CODEAGENT_WEBUI_SESSION_HISTORY_REASONING_MAX_CHARS"
+WEBUI_TOKEN = "CODEAGENT_WEBUI_TOKEN"
+SKIP_FOLDER_PICKER = "CODEAGENT_SKIP_FOLDER_PICKER"
+AGENT_TOOLS_NO_CACHE = "CODEAGENT_AGENT_TOOLS_NO_CACHE"
+AGENT_TOOLS_MODE = "CODEAGENT_AGENT_TOOLS_MODE"
+ORCHESTRATOR_AUTO_SPLIT = "CODEAGENT_ORCHESTRATOR_AUTO_SPLIT"
+
+
+def pick_default(default: str, key: str) -> str:
+    if key in os.environ:
+        return os.environ[key]
+    return default
+
+
+def pick_nonempty(key: str) -> str:
+    raw = os.environ.get(key)
+    if raw is not None and str(raw).strip():
+        return str(raw).strip()
+    return ""
+
+
+def pick_int(default: int, key: str) -> int:
+    raw = pick_default(str(default), key).strip()
+    try:
+        return int(raw)
+    except (TypeError, ValueError):
+        return default
+
+
+
+
+def env_truthy(key: str, default: str = "0") -> bool:
+    val = pick_default(default, key).strip().lower()
+    return val in ("1", "true", "yes", "on")
+
+
+def env_falsy(key: str, default: str = "1") -> bool:
+    val = pick_default(default, key).strip().lower()
+    return val in ("0", "false", "no", "off")
+
+
+def default_agent_id() -> str:
+    return pick_default("default", AGENT_ID).strip() or "default"
+
+
+def product_home() -> Path:
+    """Default ``~/.codeagent``; override with ``CODEAGENT_HOME`` or ``CODEAGENT_PROJECT_ROOT``."""
+    raw = pick_nonempty(PROJECT_ROOT) or pick_nonempty(HOME)
+    if raw:
+        return Path(raw).expanduser().resolve()
+    return (Path.home() / ".codeagent").resolve()
+
+
+def apply_default_product_home() -> Path:
+    """
+    Ensure product home exists and set ``SEED_PROJECT_ROOT`` for the Seed kernel.
+
+    Other products (e.g. designagent) should use their own ``~/.<product>`` and set
+    ``SEED_PROJECT_ROOT`` the same way in their bootstrap.
+    """
+    home = product_home()
+    os.environ.setdefault(HOME, str(home))
+    if "SEED_PROJECT_ROOT" not in os.environ:
+        os.environ["SEED_PROJECT_ROOT"] = str(home)
+    home.mkdir(parents=True, exist_ok=True)
+    (home / "config").mkdir(parents=True, exist_ok=True)
+    return home

codeagent/core/folder_picker.py

@@ -0,0 +1,151 @@
+"""Native folder picker (macOS / Windows / Linux desktop)."""
+
+from __future__ import annotations
+
+import os
+import subprocess
+import sys
+from pathlib import Path
+from typing import Optional, Tuple
+
+
+def has_graphical_session() -> bool:
+    if sys.platform == "win32":
+        return True
+    if sys.platform == "darwin":
+        return True
+    return bool(
+        os.environ.get("DISPLAY", "").strip()
+        or os.environ.get("WAYLAND_DISPLAY", "").strip()
+    )
+
+
+def pick_directory_sync() -> Tuple[str, bool, str]:
+    """
+    Blocking folder picker.
+
+    Returns ``(path, skipped, hint)``:
+    - *path*: chosen directory or ``""``
+    - *skipped*: env/disabled/no GUI tool
+    - *hint*: user-facing reason when *path* is empty
+    """
+    if sys.platform == "darwin":
+        return _pick_darwin()
+    if sys.platform == "win32":
+        return _pick_windows()
+    return _pick_linux()
+
+
+def _pick_darwin() -> Tuple[str, bool, str]:
+    script = (
+        'POSIX path of (choose folder with prompt '
+        '"选择目录" default location (path to desktop folder))'
+    )
+    try:
+        cp = subprocess.run(
+            ["osascript", "-e", script],
+            check=False,
+            capture_output=True,
+            text=True,
+            encoding="utf-8",
+            errors="replace",
+            timeout=120,
+        )
+    except FileNotFoundError:
+        return "", True, "osascript not found"
+    except subprocess.TimeoutExpired:
+        return "", False, "folder picker timed out"
+    cand = (cp.stdout or "").strip()
+    if cand and Path(cand).is_dir():
+        return cand, False, ""
+    if cp.returncode != 0:
+        return "", False, "folder picker cancelled"
+    return "", False, ""
+
+
+def _pick_windows() -> Tuple[str, bool, str]:
+    ps = r"""
+Add-Type -AssemblyName System.Windows.Forms
+$top = New-Object System.Windows.Forms.Form
+$top.TopMost = $true
+$top.WindowState = [System.Windows.Forms.FormWindowState]::Minimized
+$top.ShowInTaskbar = $false
+$top.Size = New-Object System.Drawing.Size(0, 0)
+$top.StartPosition = "Manual"
+$top.Location = New-Object System.Drawing.Point(-32000, -32000)
+$null = $top.Show()
+[System.Windows.Forms.Application]::DoEvents()
+try {
+  $d = New-Object System.Windows.Forms.FolderBrowserDialog
+  $d.Description = "选择项目目录"
+  $d.ShowNewFolderButton = $true
+  if ($d.ShowDialog($top) -eq "OK") { Write-Output $d.SelectedPath }
+} finally { $top.Close(); $top.Dispose() }
+"""
+    for exe in ("powershell", "pwsh"):
+        if not _which(exe):
+            continue
+        try:
+            cp = subprocess.run(
+                [exe, "-NoProfile", "-Command", ps],
+                check=False,
+                capture_output=True,
+                text=True,
+                encoding="utf-8",
+                errors="replace",
+                timeout=120,
+            )
+        except subprocess.TimeoutExpired:
+            return "", False, "folder picker timed out"
+        cand = (cp.stdout or "").strip()
+        if cand and Path(cand).is_dir():
+            return cand, False, ""
+    return "", True, "PowerShell not found for folder picker"
+
+
+def _pick_linux() -> Tuple[str, bool, str]:
+    if not has_graphical_session():
+        return (
+            "",
+            True,
+            "no DISPLAY/WAYLAND_DISPLAY; set project path manually or install zenity on a desktop session",
+        )
+
+    tools = (
+        (["zenity", "--file-selection", "--directory"], "zenity"),
+        (["kdialog", "--getexistingdirectory"], "kdialog"),
+        (["yad", "--file", "--directory"], "yad"),
+    )
+    missing: list[str] = []
+    for cmd, name in tools:
+        if not _which(cmd[0]):
+            missing.append(name)
+            continue
+        try:
+            cp = subprocess.run(
+                cmd,
+                check=False,
+                capture_output=True,
+                text=True,
+                encoding="utf-8",
+                errors="replace",
+                timeout=120,
+            )
+        except subprocess.TimeoutExpired:
+            return "", False, "folder picker timed out"
+        cand = (cp.stdout or "").strip()
+        if cand and Path(cand).is_dir():
+            return cand, False, ""
+        if cp.returncode != 0 and cp.returncode != 1:
+            continue
+    hint = (
+        "install zenity, kdialog, or yad for GUI folder selection "
+        f"(missing: {', '.join(missing) or 'unknown'})"
+    )
+    return "", True, hint
+
+
+def _which(name: str) -> Optional[str]:
+    from shutil import which as _w
+
+    return _w(name)

codeagent/core/image_understanding.py

@@ -0,0 +1,90 @@
+"""Image understanding: vision LLM presets or MiniMax Token Plan MCP."""
+
+from __future__ import annotations
+
+from pathlib import Path
+from typing import Any, Optional
+
+from seed.integrations.mcp_config import MINIMAX_MCP_SERVER_ID, get_server_config
+
+MCP_VISION_SENTINEL = "__mcp_minimax__"
+MINIMAX_UNDERSTAND_IMAGE_TOOL = "understand_image"
+MCP_QUALIFIED_UNDERSTAND_IMAGE = f"mcp__{MINIMAX_MCP_SERVER_ID}__{MINIMAX_UNDERSTAND_IMAGE_TOOL}"
+
+
+def minimax_mcp_configured(base: Optional[Path] = None) -> bool:
+    """MiniMax MCP server enabled in config with a non-empty API key."""
+    from seed.integrations.mcp_client import mcp_globally_enabled
+
+    if not mcp_globally_enabled():
+        return False
+    cfg = get_server_config(MINIMAX_MCP_SERVER_ID, base)
+    if not cfg or not cfg.enabled or not cfg.command.strip():
+        return False
+    key = (cfg.env or {}).get("MINIMAX_API_KEY") or ""
+    return bool(str(key).strip())
+
+
+def minimax_mcp_understand_image_ready(
+    base: Optional[Path] = None,
+    *,
+    probe: bool = False,
+    servers_status: Optional[list[dict[str, Any]]] = None,
+) -> bool:
+    """True when MiniMax MCP can run ``understand_image`` (configured; optionally probed)."""
+    if not minimax_mcp_configured(base):
+        return False
+    if not probe:
+        return True
+    rows = servers_status
+    if rows is None:
+        from seed.integrations.mcp_client import get_mcp_manager
+
+        rows = get_mcp_manager().list_servers_status(probe=True)
+    for row in rows or []:
+        if str(row.get("id") or "") != MINIMAX_MCP_SERVER_ID:
+            continue
+        if not row.get("connected"):
+            return False
+        tools = row.get("tools") or []
+        return MINIMAX_UNDERSTAND_IMAGE_TOOL in tools
+    return False
+
+
+def image_attachment_allowed(vision_llm_id: str, base: Optional[Path] = None) -> bool:
+    """User may send image attachments when a vision preset or MiniMax MCP is available."""
+    vid = (vision_llm_id or "").strip()
+    if vid == MCP_VISION_SENTINEL:
+        return minimax_mcp_configured(base)
+    if vid:
+        from codeagent.core.vision_models import preset_supports_vision_id
+
+        return preset_supports_vision_id(vid)
+    return minimax_mcp_configured(base)
+
+
+def video_attachment_allowed(vision_llm_id: str) -> bool:
+    """Video analysis still requires a vision-capable LLM preset."""
+    from codeagent.core.vision_models import preset_supports_vision_id
+
+    vid = (vision_llm_id or "").strip()
+    return bool(vid) and preset_supports_vision_id(vid)
+
+
+def image_understanding_status(
+    base: Optional[Path] = None,
+    *,
+    probe: bool = False,
+    servers_status: Optional[list[dict[str, Any]]] = None,
+) -> dict[str, Any]:
+    configured = minimax_mcp_configured(base)
+    ready = minimax_mcp_understand_image_ready(
+        base, probe=probe, servers_status=servers_status
+    )
+    return {
+        "configured": configured,
+        "ready": ready,
+        "sentinel": MCP_VISION_SENTINEL,
+        "mcp_tool": MCP_QUALIFIED_UNDERSTAND_IMAGE,
+        "minimax_server_id": MINIMAX_MCP_SERVER_ID,
+    }

codeagent/core/models.py

@@ -0,0 +1,6 @@
+"""Core models (compat wrapper)."""
+
+from __future__ import annotations
+
+from seed.models import *  # noqa: F403
+