yaping-aether 0.9.0__py3-none-any.whl

aether/__init__.py

@@ -0,0 +1,3 @@
+"""Aether — 1+N 多模态 Agent 框架"""
+
+__version__ = "0.9.0"

aether/agents/create_agent.py

@@ -0,0 +1,28 @@
+"""内容创作专家 Agent"""
+
+from smolagents import CodeAgent, LiteLLMModel
+
+from ..config import WorkerConfig
+from ..tools.create_tools import write_article, generate_code, summarize_text
+from ..tools.file_tools import write_file
+from ..tools.project_tools import edit_file
+
+
+def create_create_agent(config: WorkerConfig) -> CodeAgent:
+    """创建内容创作专家 Agent。支持独立模型（CREATE_MODEL），否则用默认。"""
+    mc = config.create_model or config.model
+    model = LiteLLMModel(model_id=mc.model_id, api_key=mc.api_key, temperature=mc.temperature)
+
+    agent = CodeAgent(
+        name="create_agent",
+        description=(
+            "内容创作专家。能写文章、生成代码、摘要文本。"
+            "当任务涉及创作内容（写文章、写代码、做摘要、生成文档）时调用我。"
+        ),
+        tools=[write_article, generate_code, summarize_text, write_file, edit_file],
+        model=model,
+        provide_run_summary=True,
+        max_steps=12,
+    )
+
+    return agent

aether/agents/file_agent.py

@@ -0,0 +1,27 @@
+"""文件管理专家 Agent"""
+
+from smolagents import CodeAgent, LiteLLMModel
+
+from ..config import WorkerConfig
+from ..tools.file_tools import read_file, write_file, list_directory, search_files
+from ..tools.project_tools import project_map
+
+
+def create_file_agent(config: WorkerConfig) -> CodeAgent:
+    """创建文件管理专家 Agent。支持独立模型（FILE_MODEL），否则用默认。"""
+    mc = config.file_model or config.model
+    model = LiteLLMModel(model_id=mc.model_id, api_key=mc.api_key, temperature=mc.temperature)
+
+    agent = CodeAgent(
+        name="file_agent",
+        description=(
+            "文件管理专家。能搜索、读取、写入、整理本地文件和目录，扫描项目结构。"
+            "当任务涉及文件操作（读文件、写文件、整理文件夹、搜索文件、了解项目结构）时调用我。"
+        ),
+        tools=[read_file, write_file, list_directory, search_files, project_map],
+        model=model,
+        provide_run_summary=True,
+        max_steps=10,
+    )
+
+    return agent

aether/agents/search_agent.py

@@ -0,0 +1,26 @@
+"""搜索专家 Agent"""
+
+from smolagents import CodeAgent, LiteLLMModel
+
+from ..config import WorkerConfig
+from ..tools.search_tools import web_search, fetch_url
+
+
+def create_search_agent(config: WorkerConfig) -> CodeAgent:
+    """创建搜索专家 Agent。支持独立模型（SEARCH_MODEL），否则用默认。"""
+    mc = config.search_model or config.model
+    model = LiteLLMModel(model_id=mc.model_id, api_key=mc.api_key, temperature=mc.temperature)
+
+    agent = CodeAgent(
+        name="search_agent",
+        description=(
+            "搜索专家。能搜索网页、抓取 URL 内容、聚合资讯。"
+            "当任务涉及在网上查找信息、搜索资料、获取最新资讯时调用我。"
+        ),
+        tools=[web_search, fetch_url],
+        model=model,
+        provide_run_summary=True,
+        max_steps=8,
+    )
+
+    return agent

aether/cache/semantic_cache.py

@@ -0,0 +1,140 @@
+"""语义缓存层
+
+对相似的任务/查询进行缓存，避免重复调用 LLM。
+
+核心思路：
+1. 将用户任务文本做 embedding
+2. 与缓存中的历史任务做余弦相似度匹配
+3. 相似度超过阈值 → 直接返回缓存结果
+4. 否则执行任务 → 结果存入缓存
+
+MVP 阶段使用简单的文本 hash + 模糊匹配，
+后续可升级为向量数据库方案。
+"""
+
+import hashlib
+import time
+from dataclasses import dataclass, field
+from typing import Any
+
+
+@dataclass
+class CacheEntry:
+    """单条缓存记录"""
+    task_hash: str
+    task: str
+    result: Any
+    timestamp: float = field(default_factory=time.time)
+    hit_count: int = 0
+
+
+class SemanticCache:
+    """语义缓存管理器。
+
+    MVP 版本使用以下策略：
+    - 精确匹配：相同任务文本 → 直接命中
+    - 规范化匹配：去空白、小写后相同 → 命中
+    - 前缀匹配：新任务是缓存任务的子串 → 命中
+
+    未来可升级为 embedding + 向量相似度匹配。
+    """
+
+    def __init__(
+        self,
+        max_entries: int = 100,
+        ttl_seconds: int = 3600,
+        similarity_threshold: float = 0.92,
+    ):
+        self._cache: dict[str, CacheEntry] = {}
+        self._max_entries = max_entries
+        self._ttl_seconds = ttl_seconds
+        self._similarity_threshold = similarity_threshold
+
+    def _normalize(self, text: str) -> str:
+        """规范化文本：去除所有空白、转小写。
+        
+        中英文混排场景下，空格不是可靠的词边界（"Python协程" vs "Python 协程"），
+        因此直接去掉所有空白后做哈希，确保语义等价文本命中同一缓存。
+        """
+        # 去掉所有空白字符（空格、换行、制表等）
+        import re
+        return re.sub(r"\s+", "", text.lower())
+
+    def _hash(self, task: str) -> str:
+        """计算任务的哈希"""
+        return hashlib.md5(self._normalize(task).encode()).hexdigest()
+
+    def get(self, task: str) -> Any | None:
+        """查找缓存。返回结果或 None。"""
+        # 1. 精确匹配
+        task_hash = self._hash(task)
+        entry = self._cache.get(task_hash)
+        if entry:
+            # 检查是否过期
+            if time.time() - entry.timestamp > self._ttl_seconds:
+                del self._cache[task_hash]
+                return None
+            entry.hit_count += 1
+            return entry.result
+
+        # 2. 规范化匹配（遍历缓存查找）
+        normalized = self._normalize(task)
+        for cached_hash, cached_entry in self._cache.items():
+            cached_normalized = self._normalize(cached_entry.task)
+            # 完全相同
+            if normalized == cached_normalized:
+                if time.time() - cached_entry.timestamp < self._ttl_seconds:
+                    cached_entry.hit_count += 1
+                    # 将新 hash 也指向同一结果
+                    self._cache[task_hash] = cached_entry
+                    return cached_entry.result
+            # 新任务是缓存任务的子串（更具体的追问可能命中之前的大任务）
+            if normalized in cached_normalized and len(normalized) > 20:
+                if time.time() - cached_entry.timestamp < self._ttl_seconds:
+                    cached_entry.hit_count += 1
+                    return cached_entry.result
+
+        return None
+
+    def set(self, task: str, result: Any) -> None:
+        """存入缓存"""
+        # 清理过期条目
+        self._evict_expired()
+
+        # 超出容量时淘汰命中次数最少的
+        if len(self._cache) >= self._max_entries:
+            min_entry = min(self._cache.values(), key=lambda e: e.hit_count)
+            del self._cache[min_entry.task_hash]
+
+        task_hash = self._hash(task)
+        self._cache[task_hash] = CacheEntry(
+            task_hash=task_hash,
+            task=task,
+            result=result,
+        )
+
+    def _evict_expired(self) -> None:
+        """清理过期缓存"""
+        now = time.time()
+        expired = [
+            h for h, e in self._cache.items()
+            if now - e.timestamp > self._ttl_seconds
+        ]
+        for h in expired:
+            del self._cache[h]
+
+    def clear(self) -> None:
+        """清空所有缓存"""
+        self._cache.clear()
+
+    @property
+    def stats(self) -> dict:
+        """缓存统计信息"""
+        total = len(self._cache)
+        hits = sum(e.hit_count for e in self._cache.values())
+        return {
+            "entries": total,
+            "total_hits": hits,
+            "max_entries": self._max_entries,
+            "ttl_seconds": self._ttl_seconds,
+        }

aether/checkpoint.py

@@ -0,0 +1,103 @@
+"""Checkpoint 轻量快照
+
+工具调用前自动备份文件 → /rewind 秒级回滚，不依赖 Git。
+
+结构:
+    .aether/checkpoints/
+        2026-07-02-15-30-01/
+            src/aether/main.py    ← 修改前的副本
+            src/aether/config.py
+"""
+
+import shutil
+from datetime import datetime
+from pathlib import Path
+
+
+class CheckpointStore:
+    """管理文件快照的创建和回滚"""
+
+    def __init__(self, base_dir: Path | None = None):
+        self._base = base_dir or Path(".aether") / "checkpoints"
+        self._base.mkdir(parents=True, exist_ok=True)
+
+    def snapshot(self, files: list[str]) -> str | None:
+        """备份指定文件，返回快照 ID（时间戳）"""
+        ts = datetime.now().strftime("%Y-%m-%d-%H-%M-%S")
+        snap_dir = self._base / ts
+        snap_dir.mkdir(parents=True)
+
+        backed = 0
+        for f in files:
+            src = Path(f)
+            if not src.exists():
+                continue
+            dst = snap_dir / f
+            dst.parent.mkdir(parents=True, exist_ok=True)
+            shutil.copy2(src, dst)
+            backed += 1
+
+        return ts if backed > 0 else None
+
+    def rewind(self, checkpoint_id: str | None = None) -> str:
+        """回滚到指定快照（默认回滚到最新）"""
+        snap_dirs = sorted(self._base.iterdir(), key=lambda p: p.name, reverse=True)
+
+        if checkpoint_id:
+            target = self._base / checkpoint_id
+            if not target.exists():
+                return f"[错误] 快照不存在: {checkpoint_id}"
+        elif snap_dirs:
+            target = snap_dirs[0]
+        else:
+            return "没有可用的快照。"
+
+        # 还原所有文件
+        restored = 0
+        for bak in target.rglob("*"):
+            if bak.is_dir():
+                continue
+            rel = bak.relative_to(target)
+            src = Path(rel)
+            src.parent.mkdir(parents=True, exist_ok=True)
+            shutil.copy2(bak, src)
+            restored += 1
+
+        return f"✅ 已回滚到 {target.name}，还原 {restored} 个文件。"
+
+    def list_checkpoints(self) -> list[str]:
+        """列出所有快照"""
+        if not self._base.exists():
+            return []
+        return sorted(
+            [d.name for d in self._base.iterdir() if d.is_dir()],
+            reverse=True,
+        )
+
+    def cleanup(self, keep: int = 10) -> int:
+        """清理旧快照，保留最近 N 个"""
+        all_dirs = sorted(
+            [d for d in self._base.iterdir() if d.is_dir()],
+            key=lambda p: p.name,
+        )
+        deleted = 0
+        for d in all_dirs[:-keep]:
+            shutil.rmtree(d)
+            deleted += 1
+        return deleted
+
+
+# 全局实例
+_checkpoint: CheckpointStore | None = None
+
+
+def get_checkpoint() -> CheckpointStore:
+    global _checkpoint
+    if _checkpoint is None:
+        _checkpoint = CheckpointStore()
+    return _checkpoint
+
+
+def auto_snapshot(file_path: str) -> str | None:
+    """工具写文件前自动快照"""
+    return get_checkpoint().snapshot([file_path])

aether/compact.py

@@ -0,0 +1,112 @@
+"""上下文压缩
+
+长对话自动压缩，避免 Token 消耗线性增长。
+
+策略：
+  1. 每次执行后检查上下文长度
+  2. 超过阈值时，用便宜模型摘要历史对话
+  3. 摘要注入系统提示词，释放上下文空间
+"""
+
+from smolagents import CodeAgent
+
+
+def estimate_tokens(text: str) -> int:
+    """粗略估算 Token 数（中文 ~1.5 字/token，英文 ~0.75 词/token）"""
+    chinese_chars = sum(1 for c in text if '\u4e00' <= c <= '\u9fff')
+    other_chars = len(text) - chinese_chars
+    return int(chinese_chars / 1.5 + other_chars / 4)
+
+
+# 常见模型的上下文窗口大小（Token）
+MODEL_CONTEXT_SIZES = {
+    "qwen-max": 32_768,
+    "qwen-plus": 131_072,
+    "qwen-turbo": 1_000_000,
+    "deepseek-chat": 128_000,
+    "deepseek-v4": 128_000,
+    "deepseek-reasoner": 64_000,
+    "glm-4": 128_000,
+    "glm-4v": 128_000,
+    "moonshot": 128_000,
+    "doubao-pro": 128_000,
+    "doubao-2.0": 256_000,
+    "gpt-4o": 128_000,
+    "claude": 200_000,
+}
+DEFAULT_CONTEXT_SIZE = 128_000  # 2026 年主流模型默认 128K
+
+
+def get_model_context_size(model_id: str) -> int:
+    """根据 model_id 猜测上下文窗口大小"""
+    model_lower = model_id.lower()
+    for key, size in MODEL_CONTEXT_SIZES.items():
+        if key in model_lower:
+            return size
+    return DEFAULT_CONTEXT_SIZE
+
+
+def compact_agent_memory(agent: CodeAgent, ratio: float = 0.8) -> bool:
+    """压缩 Agent 的对话记忆。
+
+    如果记忆中总 Token 超过 模型上下文窗口 × ratio，压缩早期对话。
+
+    ratio=0.8 意味着用满 80% 的上下文窗口后才触发压缩。
+    ratio=1.0 意味着永不自动压缩。
+
+    Returns:
+        True 如果执行了压缩
+    """
+    if ratio >= 1.0:
+        return False  # 永不压缩
+
+    steps = agent.memory.steps
+    if len(steps) < 6:
+        return False  # 太少不必压
+
+    # 估算当前上下文
+    total_text = ""
+    for step in steps:
+        if hasattr(step, "task") and step.task:
+            total_text += str(step.task) + "\n"
+        if hasattr(step, "action_output") and step.action_output:
+            total_text += str(step.action_output) + "\n"
+
+    estimated = estimate_tokens(total_text)
+
+    # 根据模型上下文窗口计算阈值
+    model_id = ""
+    if hasattr(agent, "model") and hasattr(agent.model, "model_id"):
+        model_id = agent.model.model_id or ""
+    context_size = get_model_context_size(model_id)
+    threshold = int(context_size * ratio)
+
+    if estimated < threshold:
+        return False
+
+    # 需要压缩：保留最近 2 步，其余摘要
+    # smolagents 的 memory 支持 write_memory_to_messages 和 summary_mode
+    # 这里简单标记——实际压缩依赖 smolagents 内置机制
+    try:
+        # 触发 smolagents 的 summary_mode
+        agent.memory.steps = agent.memory.steps[-3:]  # 只保留最近 3 步
+        return True
+    except Exception:
+        return False
+
+
+def get_context_stats(agent: CodeAgent) -> dict:
+    """获取当前上下文的使用统计"""
+    steps = agent.memory.steps
+    total_text = ""
+    for step in steps:
+        if hasattr(step, "task") and step.task:
+            total_text += str(step.task) + "\n"
+        if hasattr(step, "action_output") and step.action_output:
+            total_text += str(step.action_output) + "\n"
+
+    return {
+        "steps": len(steps),
+        "estimated_tokens": estimate_tokens(total_text),
+        "estimated_chars": len(total_text),
+    }

aether/config.py

@@ -0,0 +1,244 @@
+"""
+Aether 配置管理 — 三层加载：全局 > 项目 > 命令行
+
+加载优先级（越高越优先）：
+  1. 系统环境变量（命令行 set/export）
+  2. 项目级 .env（当前目录）
+  3. 全局 ~/.aether/config.env（用户级默认）
+
+用法：
+    config = load_config()
+    config = load_config(overrides={"supervisor_model": "deepseek/chat"})
+"""
+
+import os
+from dataclasses import dataclass, field
+from pathlib import Path
+
+from dotenv import load_dotenv
+
+# 全局配置目录
+_AETHER_HOME = Path.home() / ".aether"
+_GLOBAL_ENV = _AETHER_HOME / "config.env"
+
+# 加载全局配置（优先级最低）
+if _GLOBAL_ENV.exists():
+    load_dotenv(_GLOBAL_ENV)
+
+# 项目根目录
+_project_root = Path(__file__).resolve().parent.parent.parent
+_env_file = _project_root / ".env"
+if _env_file.exists():
+    load_dotenv(_env_file, override=True)  # 项目覆盖全局
+
+
+# ============================================================
+# 数据类
+# ============================================================
+
+@dataclass
+class ModelConfig:
+    """单个模型的配置"""
+    model_id: str
+    api_key: str = ""
+    temperature: float = 0.2
+    max_tokens: int = 4096
+
+
+@dataclass
+class SupervisorConfig:
+    """主管 Agent 配置"""
+    model: ModelConfig           # 执行模型
+    plan_model: ModelConfig | None = None  # 计划模型（可选，不设则用 model）
+    max_steps: int = 20
+
+
+@dataclass
+class WorkerConfig:
+    """专家 Agent 配置"""
+    model: ModelConfig             # 默认模型
+    file_model: ModelConfig | None = None    # 文件专家专用
+    search_model: ModelConfig | None = None  # 搜索专家专用
+    create_model: ModelConfig | None = None  # 创作专家专用
+
+
+@dataclass
+class MemoryConfig:
+    """记忆系统配置"""
+    enabled: bool = True
+    max_entries: int = 50
+
+
+@dataclass
+class CacheConfig:
+    """缓存配置"""
+    enabled: bool = False
+    ttl_seconds: int = 3600
+    similarity_threshold: float = 0.92
+
+
+@dataclass
+class AetherConfig:
+    """Aether 全局配置"""
+    supervisor: SupervisorConfig
+    worker: WorkerConfig
+    memory: MemoryConfig
+    cache: CacheConfig
+    log_level: str = "INFO"
+    default_mode: str = "auto"
+
+
+# ============================================================
+# 加载逻辑
+# ============================================================
+
+def load_config(overrides: dict | None = None) -> AetherConfig:
+    """
+    加载 Aether 配置。
+
+    参数:
+        overrides: 命令行覆盖项，如 {"supervisor_model": "...", "api_key": "..."}
+    """
+    ov = overrides or {}
+
+    def _get(key: str, default: str = "") -> str:
+        """按优先级读取: 命令行 > 环境变量 > 默认"""
+        return ov.get(key, os.getenv(key, default))
+
+    # 主管模型
+    supervisor_model_id = _get("SUPERVISOR_MODEL", _get("DEFAULT_MODEL", ""))
+    supervisor_api_key = _get("SUPERVISOR_API_KEY", _get("DEFAULT_API_KEY", ""))
+
+    if not supervisor_model_id:
+        raise ValueError(
+            "未配置模型！请在 .env 或 ~/.aether/config.env 中设置 "
+            "SUPERVISOR_MODEL 和 SUPERVISOR_API_KEY。"
+        )
+
+    # 计划模型（可选，不设则共用主管模型）
+    plan_model_id = _get("PLAN_MODEL", "")
+    plan_api_key = _get("PLAN_API_KEY", supervisor_api_key)
+
+    # 专家模型（可按专家分别配置）
+    worker_model_id = _get("WORKER_MODEL", supervisor_model_id)
+    worker_api_key = _get("WORKER_API_KEY", supervisor_api_key)
+
+    file_model_id = _get("FILE_MODEL", "")
+    search_model_id = _get("SEARCH_MODEL", "")
+    create_model_id = _get("CREATE_MODEL", "")
+
+    # 缓存
+    cache_enabled = _get("CACHE_ENABLED", "false").lower() in ("true", "1", "yes")
+
+    return AetherConfig(
+        supervisor=SupervisorConfig(
+            model=ModelConfig(
+                model_id=supervisor_model_id,
+                api_key=supervisor_api_key,
+                temperature=0.2,
+            ),
+            plan_model=ModelConfig(
+                model_id=plan_model_id,
+                api_key=plan_api_key,
+                temperature=0.1,
+            ) if plan_model_id else None,
+            max_steps=int(_get("MAX_STEPS", "20")),
+        ),
+        worker=WorkerConfig(
+            model=ModelConfig(
+                model_id=worker_model_id,
+                api_key=worker_api_key,
+                temperature=0.0,
+            ),
+            file_model=ModelConfig(model_id=file_model_id, api_key=worker_api_key, temperature=0.0) if file_model_id else None,
+            search_model=ModelConfig(model_id=search_model_id, api_key=worker_api_key, temperature=0.0) if search_model_id else None,
+            create_model=ModelConfig(model_id=create_model_id, api_key=worker_api_key, temperature=0.0) if create_model_id else None,
+        ),
+        memory=MemoryConfig(
+            enabled=_get("MEMORY_ENABLED", "true").lower() in ("true", "1", "yes"),
+        ),
+        cache=CacheConfig(enabled=cache_enabled),
+        log_level=_get("LOG_LEVEL", "INFO").upper(),
+        default_mode=_get("DEFAULT_MODE", "auto").lower(),
+    )
+
+
+def validate_config(config: AetherConfig) -> list[str]:
+    """验证配置，返回警告列表"""
+    warnings = []
+    if "your_" in config.supervisor.model.api_key.lower():
+        warnings.append("⚠️  API Key 看起来是占位符，请在 .env 中填入真实 Key")
+    if config.supervisor.plan_model is None:
+        warnings.append("💡 未配置 PLAN_MODEL，计划阶段将共用主管模型。设置 PLAN_MODEL 可指定更便宜的模型做计划。")
+    return warnings
+
+
+def config_exists() -> bool:
+    """检查是否有有效配置"""
+    if _env_file.exists() or _GLOBAL_ENV.exists():
+        try:
+            config = load_config()
+            return "your_" not in config.supervisor.model.api_key.lower()
+        except ValueError:
+            pass
+    return False
+
+
+# ============================================================
+# 配置向导 + 写入
+# ============================================================
+
+KNOWN_PROVIDERS = {
+    "1": {"name": "DeepSeek (V3/R1/V4)", "model": "deepseek/deepseek-chat", "url": "https://platform.deepseek.com"},
+    "2": {"name": "通义千问 Qwen (Max/Plus/Turbo)", "model": "dashscope/qwen-max", "url": "https://dashscope.console.aliyun.com"},
+    "3": {"name": "智谱 GLM (4/5.x)", "model": "zhipuai/glm-4", "url": "https://open.bigmodel.cn"},
+    "4": {"name": "Moonshot Kimi", "model": "moonshot/moonshot-v1-8k", "url": "https://platform.moonshot.cn"},
+    "5": {"name": "豆包 Doubao (字节)", "model": "volcengine/doubao-pro-32k", "url": "https://console.volcengine.com"},
+    "6": {"name": "本地 Ollama", "model": "ollama/qwen2.5:7b", "url": "http://localhost:11434"},
+    "0": {"name": "自定义", "model": "", "url": "手动输入 model_id（如 deepseek/deepseek-v4-pro）"},
+}
+
+# LiteLLM 支持的常见 model_id 格式参考
+MODEL_ID_EXAMPLES = {
+    "deepseek-v3": "deepseek/deepseek-chat",
+    "deepseek-r1": "deepseek/deepseek-reasoner",
+    "deepseek-v4": "deepseek/deepseek-v4-pro",
+    "qwen-max": "dashscope/qwen-max",
+    "qwen-plus": "dashscope/qwen-plus",
+    "qwen-turbo": "dashscope/qwen-turbo",
+    "glm-4": "zhipuai/glm-4",
+    "glm-4v": "zhipuai/glm-4v",
+    "kimi": "moonshot/moonshot-v1-8k",
+    "doubao-pro": "volcengine/doubao-pro-32k",
+    "doubao-2.0": "volcengine/doubao-2.0-pro",
+    "openai": "openai/gpt-4o",
+    "ollama": "ollama/qwen2.5:7b",
+    "vllm": "openai/your-model-name",
+}
+
+
+def write_env(provider_id: str, api_key: str, default_mode: str = "plan",
+              custom_model: str = "") -> None:
+    """写入项目 .env 配置文件"""
+    provider = KNOWN_PROVIDERS.get(provider_id)
+    if not provider:
+        raise ValueError(f"未知提供商: {provider_id}")
+
+    model_id = custom_model or provider["model"]
+
+    content = f"""# Aether 配置 — {provider['name']}
+SUPERVISOR_MODEL={model_id}
+SUPERVISOR_API_KEY={api_key}
+WORKER_MODEL={model_id}
+WORKER_API_KEY={api_key}
+# PLAN_MODEL=dashscope/qwen-turbo   ← 可选：计划用便宜模型，省 Token
+DEFAULT_MODE={default_mode}
+MAX_STEPS=20
+LOG_LEVEL=INFO
+CACHE_ENABLED=false
+MEMORY_ENABLED=true
+"""
+    _AETHER_HOME.mkdir(parents=True, exist_ok=True)
+    env_path = _project_root / ".env"
+    env_path.write_text(content, encoding="utf-8")
+    load_dotenv(env_path, override=True)