tagword-codeagent 1.1.6__py3-none-any.whl

codeagent/core/paths.py

@@ -0,0 +1,238 @@
+"""CodeAgent filesystem layout — re-exports kernel paths + CodeAgent default persona files."""
+
+from __future__ import annotations
+
+import contextlib
+import logging
+from pathlib import Path
+
+from codeagent.core.env import product_home
+from seed.core.config_plane import project_root as _kernel_project_root
+
+logger = logging.getLogger(__name__)
+
+
+def codeagent_home() -> Path:
+    """Product data root (``~/.codeagent``). Same as ``project_root()`` after bootstrap."""
+    return product_home()
+from seed.core.paths import (
+    agent_archive_dir,
+    agent_daily_dir,
+    agent_home,
+    agent_id_default,
+    agent_memory_dir,
+    agent_persona_dir,
+    agent_persona_memory_path,
+    agent_project_archive_dir,
+    agent_project_daily_dir,
+    agent_project_data_dir,
+    agent_project_data_subdir,
+    agent_projects_data_dir,
+    agent_projects_registry_dir,
+    agent_skills_dir,
+    ensure_agent_dirs,
+)
+
+
+# ---------------------------------------------------------------------------
+# Project-level working directories (.codeagent/{agent_id}/)
+# ---------------------------------------------------------------------------
+
+_PROJECT_SUBDIRS = ("docs", "plans", "scripts", "sessions", "cache", "tmp")
+
+
+def _codeagent_dir(root: Path | None = None) -> Path:
+    """Return the ``.codeagent/`` directory under the given root (default: cwd)."""
+    base = Path(root).resolve() if root is not None else Path.cwd().resolve()
+    return base / ".codeagent"
+
+
+def _agent_work_dir(agent_id: str, root: Path | None = None) -> Path:
+    """Return the agent work directory ``.codeagent/{agent_id}/``."""
+    return _codeagent_dir(root) / agent_id
+
+
+def ensure_project_dirs(
+    agent_id: str | None = None,
+    root: Path | None = None,
+) -> Path:
+    """Create ``.codeagent/{agent_id}/*`` working directories under *root*.
+
+    Creates the full structure including global ``rules.md``, per-agent
+    ``rules.md`` and ``state.md``, and sub-directories for docs, plans,
+    scripts, sessions, cache, and tmp.
+
+    Also appends ``.codeagent/`` to the project root ``.gitignore`` if not
+    already present.
+
+    Returns the ``.codeagent/`` path.
+    """
+    from seed.core.paths import agent_id_default
+
+    base = Path(root).resolve() if root is not None else Path.cwd().resolve()
+    aid = (agent_id or "").strip() or agent_id_default()
+
+    ca_root = _codeagent_dir(base)
+    ca_root.mkdir(parents=True, exist_ok=True)
+
+    # Global rules placeholder
+    (ca_root / "rules.md").touch(exist_ok=True)
+
+    # Per-agent dirs
+    agent_dir = ca_root / aid
+    for sub in _PROJECT_SUBDIRS:
+        (agent_dir / sub).mkdir(parents=True, exist_ok=True)
+    (agent_dir / "rules.md").touch(exist_ok=True)
+    (agent_dir / "state.md").touch(exist_ok=True)
+
+    # Ensure project root .gitignore has .codeagent/ entry
+    _append_gitignore_entry(base)
+
+    return ca_root
+
+
+def read_state_file(agent_id: str, root: Path | None = None) -> str:
+    """Read ``.codeagent/{agent_id}/state.md``, return empty string if missing."""
+    p = _agent_work_dir(agent_id, root) / "state.md"
+    if p.is_file():
+        return p.read_text(encoding="utf-8").strip()
+    return ""
+
+
+def write_state_file(
+    content: str,
+    agent_id: str,
+    root: Path | None = None,
+) -> None:
+    """Write ``.codeagent/{agent_id}/state.md`` with the given content."""
+    p = _agent_work_dir(agent_id, root) / "state.md"
+    p.parent.mkdir(parents=True, exist_ok=True)
+    p.write_text(content.strip(), encoding="utf-8")
+
+
+def read_global_rules(root: Path | None = None) -> str:
+    """Read ``.codeagent/rules.md``, return empty string if missing."""
+    p = _codeagent_dir(root) / "rules.md"
+    if p.is_file():
+        return p.read_text(encoding="utf-8").strip()
+    return ""
+
+
+def read_agent_rules(agent_id: str, root: Path | None = None) -> str:
+    """Read ``.codeagent/{agent_id}/rules.md``, return empty string if missing."""
+    p = _agent_work_dir(agent_id, root) / "rules.md"
+    if p.is_file():
+        return p.read_text(encoding="utf-8").strip()
+    return ""
+
+
+def _append_gitignore_entry(root: Path) -> None:
+    """Append ``.codeagent/`` to project root ``.gitignore`` if not already present."""
+    gi = root / ".gitignore"
+    line = ".codeagent/"
+    if gi.is_file():
+        content = gi.read_text(encoding="utf-8")
+        if line not in content:
+            gi.write_text(content.rstrip() + "\n" + line + "\n", encoding="utf-8")
+    else:
+        gi.write_text(line + "\n", encoding="utf-8")
+
+# Default persona Markdown filenames (same as CONFIG_FILENAMES in config_plane).
+_DEFAULT_PERSONA_FILENAMES = [
+    "agent.md",
+    "identity.md",
+    "soul.md",
+    "tools.md",
+    "skills.md",
+    "user.md",
+]
+# memory.md is appended separately in fresh_system_prompt, not in CONFIG_FILENAMES.
+_PERSONA_INIT_FILENAMES = (*_DEFAULT_PERSONA_FILENAMES, "memory.md")
+
+_BUNDLED_PERSONA_DIR = Path(__file__).resolve().parent.parent / "persona_defaults"
+
+
+def _bundled_persona_defaults_dir() -> Path | None:
+    """Return the shipped default persona template directory inside the package."""
+    if _BUNDLED_PERSONA_DIR.is_dir() and any(_BUNDLED_PERSONA_DIR.glob("*.md")):
+        return _BUNDLED_PERSONA_DIR
+    return None
+
+
+def _read_bundled_persona_file(fname: str) -> str | None:
+    """Read one bundled persona markdown file (wheel-safe via importlib.resources)."""
+    try:
+        from importlib.resources import files as pkg_files
+
+        ref = pkg_files("codeagent") / "persona_defaults" / fname
+        if ref.is_file():
+            return ref.read_text(encoding="utf-8")
+    except Exception:
+        pass
+    bundled = _bundled_persona_defaults_dir()
+    if bundled is None:
+        return None
+    src = bundled / fname
+    if not src.is_file():
+        return None
+    try:
+        return src.read_text(encoding="utf-8")
+    except OSError:
+        return None
+
+
+def _ensure_default_persona_files(persona_dir: Path) -> None:
+    """Create default persona *.md from bundled template if they do not exist."""
+    if _bundled_persona_defaults_dir() is None:
+        logger.warning(
+            "Bundled persona defaults missing; skipping persona init for %s",
+            persona_dir,
+        )
+        return
+    for fname in _PERSONA_INIT_FILENAMES:
+        p = persona_dir / fname
+        if p.is_file():
+            continue
+        body = _read_bundled_persona_file(fname)
+        if not body:
+            logger.warning("Bundled persona file missing: %s", fname)
+            continue
+        with contextlib.suppress(OSError):
+            p.write_text(body, encoding="utf-8")
+
+
+def ensure_agent_scaffold(agent_id: str, base: Path | None = None) -> Path:
+    """Ensure agent dirs exist, persona files, and project working directories."""
+    root = Path(base).resolve() if base is not None else _kernel_project_root()
+    aid = (agent_id or "").strip() or agent_id_default()
+    home = ensure_agent_dirs(aid, base=root)
+    _ensure_default_persona_files(home / "persona")
+    ensure_project_dirs(aid, root=root)
+    return home
+
+
+__all__ = [
+    "codeagent_home",
+    "agent_archive_dir",
+    "agent_daily_dir",
+    "agent_home",
+    "agent_id_default",
+    "agent_memory_dir",
+    "agent_persona_dir",
+    "agent_persona_memory_path",
+    "agent_project_archive_dir",
+    "agent_project_daily_dir",
+    "agent_project_data_dir",
+    "agent_project_data_subdir",
+    "agent_projects_data_dir",
+    "agent_projects_registry_dir",
+    "agent_skills_dir",
+    "ensure_agent_dirs",
+    "ensure_agent_scaffold",
+    # Project-level working directories
+    "ensure_project_dirs",
+    "read_state_file",
+    "write_state_file",
+    "read_global_rules",
+    "read_agent_rules",
+]

codeagent/core/pricing.py

@@ -0,0 +1,107 @@
+"""
+DeepSeek 模型定价表 & 费用计算。
+
+定价数据来源：https://api-docs.deepseek.com/zh-cn/quick_start/pricing
+当前 deepseek-v4-pro 模型 2.5 折，优惠期至 2026-05-31 23:59 (UTC+8)。
+"""
+
+from __future__ import annotations
+
+from typing import Any
+
+# ── 定价表（元/百万 tokens） ─────────────────────────────────
+# 模型名统一映射到标准化名称
+# deepseek-v4-flash = 之前 deepseek-chat（非思考） / deepseek-reasoner（思考）
+# deepseek-v4-pro   = 新旗舰模型
+
+PRICING_TABLE: dict[str, dict[str, float]] = {
+    "deepseek-v4-flash": {
+        "input_cache_hit": 0.02,
+        "input_cache_miss": 1.0,
+        "output": 2.0,
+    },
+    "deepseek-v4-pro": {
+        "input_cache_hit": 0.025,
+        "input_cache_miss": 3.0,
+        "output": 6.0,
+    },
+}
+
+# 别名映射（旧模型名 → 标准化名）
+_MODEL_ALIASES: dict[str, str] = {
+    "deepseek-chat": "deepseek-v4-flash",
+    "deepseek-reasoner": "deepseek-v4-flash",
+    "deepseek-v4-flash": "deepseek-v4-flash",
+    "deepseek-v4-pro": "deepseek-v4-pro",
+}
+
+
+def normalize_model(model: str) -> str | None:
+    """将模型名标准化为定价表中的 key。未知模型返回 None。"""
+    key = model.strip().lower()
+    return _MODEL_ALIASES.get(key)
+
+
+def calculate_cost(model: str, usage: dict[str, Any]) -> dict[str, Any]:
+    """根据模型和 usage 计算费用（人民币元）。
+
+    Args:
+        model: 模型名（自动匹配别名）
+        usage: DeepSeek API 返回的 usage 对象，包含：
+            - prompt_cache_hit_tokens (int): 缓存命中的输入 tokens
+            - prompt_cache_miss_tokens (int): 缓存未命中的输入 tokens
+            - completion_tokens (int): 输出 tokens
+            - total_tokens (int): 总计
+
+    Returns:
+        {
+            "total_cost": float,       # 总费用（元）
+            "cache_hit_cost": float,   # 缓存命中费用
+            "cache_miss_cost": float,  # 缓存未命中费用
+            "output_cost": float,      # 输出费用
+            "currency": "CNY",
+            "model": str,              # 标准化模型名
+        }
+        如果模型不在定价表中或 usage 为空，所有费用返回 0。
+    """
+    std_model = normalize_model(model)
+    if not std_model or not usage:
+        return {
+            "total_cost": 0.0,
+            "cache_hit_cost": 0.0,
+            "cache_miss_cost": 0.0,
+            "output_cost": 0.0,
+            "currency": "CNY",
+            "model": model,
+        }
+
+    prices = PRICING_TABLE[std_model]
+
+    cache_hit = int(usage.get("prompt_cache_hit_tokens", 0) or 0)
+    cache_miss = int(usage.get("prompt_cache_miss_tokens", 0) or 0)
+    output = int(usage.get("completion_tokens", 0) or 0)
+
+    cache_hit_cost = cache_hit * prices["input_cache_hit"] / 1_000_000
+    cache_miss_cost = cache_miss * prices["input_cache_miss"] / 1_000_000
+    output_cost = output * prices["output"] / 1_000_000
+    total = cache_hit_cost + cache_miss_cost + output_cost
+
+    return {
+        "total_cost": round(total, 6),
+        "cache_hit_cost": round(cache_hit_cost, 6),
+        "cache_miss_cost": round(cache_miss_cost, 6),
+        "output_cost": round(output_cost, 6),
+        "currency": "CNY",
+        "model": std_model,
+    }
+
+
+def format_cost(cost: float, currency: str = "CNY") -> str:
+    """将费用格式化为可读字符串。"""
+    if cost <= 0:
+        return "¥0"
+    if cost < 0.01:
+        return f"¥{cost:.4f}"
+    if cost < 1:
+        return f"¥{cost:.3f}"
+    return f"¥{cost:.2f}"

codeagent/core/process_ports.py

@@ -0,0 +1,258 @@
+"""Cross-platform helpers to find and stop processes listening on a TCP port."""
+
+from __future__ import annotations
+
+import os
+import re
+import signal
+import subprocess
+import time
+from shutil import which
+from typing import Callable, Optional, Set
+
+
+def _win_no_window_kwargs() -> dict:
+    if os.name != "nt":
+        return {}
+    si = subprocess.STARTUPINFO()  # type: ignore[attr-defined]
+    si.dwFlags |= subprocess.STARTF_USESHOWWINDOW  # type: ignore[attr-defined]
+    si.wShowWindow = 0
+    return {"startupinfo": si, "creationflags": 0x08000000}
+
+
+def pids_listening_on_port(port: int) -> Set[int]:
+    """Return PIDs with a TCP listener on *port* (best effort)."""
+    if os.name == "nt":
+        return _pids_listening_on_port_windows(port)
+    return _pids_listening_on_port_posix(port)
+
+
+def kill_pid(pid: int) -> bool:
+    if pid <= 0 or pid == os.getpid():
+        return False
+    if os.name == "nt":
+        return _kill_pid_windows(pid)
+    try:
+        os.kill(pid, signal.SIGTERM)
+        return True
+    except (ProcessLookupError, PermissionError, OSError):
+        return False
+
+
+def force_kill_pid(pid: int) -> bool:
+    if pid <= 0 or pid == os.getpid():
+        return False
+    if os.name == "nt":
+        return _kill_pid_windows(pid)
+    try:
+        os.kill(pid, signal.SIGKILL)
+        return True
+    except (ProcessLookupError, PermissionError, OSError):
+        return False
+
+
+def wait_port_released(port: int, timeout_sec: float) -> bool:
+    deadline = time.time() + max(0.1, float(timeout_sec))
+    while time.time() < deadline:
+        if not pids_listening_on_port(port):
+            return True
+        time.sleep(0.15)
+    return not pids_listening_on_port(port)
+
+
+def stop_listeners_on_port(
+    port: int,
+    *,
+    timeout_sec: float = 5.0,
+    exclude_pid: Optional[int] = None,
+    log: Optional[Callable[[str], None]] = None,
+) -> Set[int]:
+    """
+    SIGTERM listeners on *port*, wait for release, then SIGKILL stragglers.
+    Returns PIDs that were targeted (excluding *exclude_pid*).
+    """
+    pids = pids_listening_on_port(port)
+    if exclude_pid is not None:
+        pids.discard(int(exclude_pid))
+    if not pids:
+        return set()
+
+    def _say(msg: str) -> None:
+        if log:
+            log(msg)
+
+    _say(f"Stopping listener(s) on port {port}: {sorted(pids)}")
+    for pid in sorted(pids):
+        kill_pid(pid)
+
+    if wait_port_released(port, timeout_sec):
+        return pids
+
+    remaining = pids_listening_on_port(port)
+    if exclude_pid is not None:
+        remaining.discard(int(exclude_pid))
+    for pid in sorted(remaining):
+        _say(f"Force-stopping pid {pid} on port {port}")
+        force_kill_pid(pid)
+    wait_port_released(port, min(2.0, timeout_sec))
+    return pids
+
+
+def _pids_listening_on_port_windows(port: int) -> Set[int]:
+    try:
+        cp = subprocess.run(
+            ["netstat", "-ano"],
+            check=False,
+            capture_output=True,
+            text=True,
+            encoding="utf-8",
+            errors="replace",
+            **_win_no_window_kwargs(),
+        )
+    except Exception:
+        return set()
+    pids: Set[int] = set()
+    needle = f":{int(port)}"
+    for line in (cp.stdout or "").splitlines():
+        line = line.strip()
+        if not line or "LISTENING" not in line.upper() or needle not in line:
+            continue
+        parts = line.split()
+        try:
+            pid = int(parts[-1])
+        except (ValueError, IndexError):
+            continue
+        if pid > 0:
+            pids.add(pid)
+    return pids
+
+
+def _kill_pid_windows(pid: int) -> bool:
+    try:
+        cp = subprocess.run(
+            ["taskkill", "/PID", str(int(pid)), "/F"],
+            check=False,
+            capture_output=True,
+            text=True,
+            encoding="utf-8",
+            errors="replace",
+            **_win_no_window_kwargs(),
+        )
+        return cp.returncode == 0
+    except Exception:
+        return False
+
+
+def _pids_listening_on_port_posix(port: int) -> Set[int]:
+    p = int(port)
+    pids = _pids_via_lsof(p)
+    if pids:
+        return {x for x in pids if _pid_listens_on_port(x, p)}
+    pids = _pids_via_ss(p)
+    if pids:
+        return pids
+    return _pids_via_fuser(p)
+
+
+def _pids_via_lsof(port: int) -> Set[int]:
+    if not which("lsof"):
+        return set()
+    try:
+        cp = subprocess.run(
+            ["lsof", "-nP", f"-iTCP:{port}", "-sTCP:LISTEN", "-t"],
+            check=False,
+            capture_output=True,
+            text=True,
+            encoding="utf-8",
+            errors="replace",
+            timeout=10,
+        )
+    except Exception:
+        return set()
+    out: Set[int] = set()
+    for line in (cp.stdout or "").splitlines():
+        line = line.strip()
+        if not line:
+            continue
+        try:
+            out.add(int(line))
+        except ValueError:
+            continue
+    return out
+
+
+_SS_PID_RE = re.compile(r"pid=(\d+)", re.I)
+
+
+def _pids_via_ss(port: int) -> Set[int]:
+    if not which("ss"):
+        return set()
+    try:
+        cp = subprocess.run(
+            ["ss", "-lptn", f"sport = :{port}"],
+            check=False,
+            capture_output=True,
+            text=True,
+            encoding="utf-8",
+            errors="replace",
+            timeout=10,
+        )
+    except Exception:
+        return set()
+    pids: Set[int] = set()
+    for line in (cp.stdout or "").splitlines():
+        for m in _SS_PID_RE.finditer(line):
+            try:
+                pids.add(int(m.group(1)))
+            except ValueError:
+                continue
+    return pids
+
+
+def _pids_via_fuser(port: int) -> Set[int]:
+    if not which("fuser"):
+        return set()
+    try:
+        cp = subprocess.run(
+            ["fuser", "-n", "tcp", str(port)],
+            check=False,
+            capture_output=True,
+            text=True,
+            encoding="utf-8",
+            errors="replace",
+            timeout=10,
+        )
+    except Exception:
+        return set()
+    pids: Set[int] = set()
+    spec = f"{port}/tcp"
+    for part in (cp.stdout or "").split():
+        part = part.strip()
+        if part.endswith(spec):
+            part = part[: -len(spec)]
+        part = part.rstrip(":").strip()
+        if not part:
+            continue
+        try:
+            pids.add(int(part))
+        except ValueError:
+            continue
+    return pids
+
+
+def _pid_listens_on_port(pid: int, port: int) -> bool:
+    if not which("lsof"):
+        return True
+    try:
+        cp = subprocess.run(
+            ["lsof", "-nP", f"-iTCP:{port}", "-sTCP:LISTEN", "-a", "-p", str(pid), "-t"],
+            check=False,
+            capture_output=True,
+            text=True,
+            encoding="utf-8",
+            errors="replace",
+            timeout=5,
+        )
+    except Exception:
+        return True
+    return bool((cp.stdout or "").strip())

codeagent/core/seed_bridge.py

@@ -0,0 +1,21 @@
+"""Bridge ``CODEAGENT_*`` process env into ``SEED_*`` for the Seed kernel."""
+
+from __future__ import annotations
+
+import os
+
+
+def bridge_codeagent_env_to_seed() -> None:
+    """
+    For each ``CODEAGENT_<SUFFIX>`` set in ``os.environ``, copy to ``SEED_<SUFFIX>``
+    when the latter is not already defined.
+
+    Call after loading ``config/env`` (or legacy ``config/seed.env`` / ``codeagent.env``) and before
+    invoking Seed / seed-tools. Does not remove ``CODEAGENT_*`` keys.
+    """
+    for key, value in list(os.environ.items()):
+        if not key.startswith("CODEAGENT_"):
+            continue
+        seed_key = "SEED_" + key[len("CODEAGENT_") :]
+        if seed_key not in os.environ:
+            os.environ[seed_key] = value