Refactor AI daily report pipeline

ai_daily_report/env.py

@@ -0,0 +1,143 @@
+from __future__ import annotations
+
+import os
+import json
+from pathlib import Path
+
+
+PROJECT_ROOT = Path(__file__).resolve().parents[1]
+
+
+def read_env_file(env_path: Path) -> dict[str, str]:
+    env: dict[str, str] = {}
+    if not env_path.exists():
+        return env
+    text = env_path.read_text(encoding="utf-8", errors="ignore")
+    for line in text.splitlines():
+        line = line.strip()
+        if not line or line.startswith("#") or "=" not in line:
+            continue
+        key, value = line.split("=", 1)
+        env[key.strip()] = value.strip().strip('"').strip("'")
+    return env
+
+
+def load_env() -> dict[str, str]:
+    env: dict[str, str] = {}
+    env.update(read_env_file(PROJECT_ROOT / ".env"))
+    env.update(read_env_file(Path.home() / ".hermes" / ".env"))
+    env.update({key: value for key, value in os.environ.items() if value})
+    return env
+
+
+def first_env(env: dict[str, str], *names: str) -> str:
+    for name in names:
+        value = (env.get(name) or "").strip()
+        if value:
+            return value
+    return ""
+
+
+def _load_simple_yaml(path: Path) -> dict[str, object]:
+    if not path.exists():
+        return {}
+    root: dict[str, object] = {}
+    stack: list[tuple[int, dict[str, object]]] = [(-1, root)]
+    for raw_line in path.read_text(encoding="utf-8", errors="ignore").splitlines():
+        if not raw_line.strip() or raw_line.lstrip().startswith("#") or ":" not in raw_line:
+            continue
+        indent = len(raw_line) - len(raw_line.lstrip(" "))
+        key, value = raw_line.strip().split(":", 1)
+        key = key.strip()
+        value = value.strip().strip('"').strip("'")
+        while stack and indent <= stack[-1][0]:
+            stack.pop()
+        current = stack[-1][1]
+        if value:
+            current[key] = value
+        else:
+            child: dict[str, object] = {}
+            current[key] = child
+            stack.append((indent, child))
+    return root
+
+
+def _env_with_hermes(env: dict[str, str], hermes_dir: Path) -> dict[str, str]:
+    merged = dict(read_env_file(hermes_dir / ".env"))
+    merged.update(env)
+    return merged
+
+
+def _provider_env_names(provider: str) -> tuple[str, str, str]:
+    prefix = provider.upper().replace("-", "_")
+    return f"{prefix}_API_KEY", f"{prefix}_BASE_URL", f"{prefix}_MODEL"
+
+
+def _auth_json_key(env: dict[str, str], hermes_dir: Path, provider: str) -> str:
+    auth_path = hermes_dir / "auth.json"
+    if not auth_path.exists() or not provider:
+        return ""
+    try:
+        auth = json.loads(auth_path.read_text(encoding="utf-8"))
+    except Exception:
+        return ""
+    pool = auth.get("credential_pool", {}) or {}
+    provider_keys = [provider, provider.replace("-", "_")]
+    for key in provider_keys:
+        creds = pool.get(key, []) or []
+        if not creds:
+            continue
+        cred = creds[0]
+        source = str(cred.get("source") or "")
+        if source.startswith("env:"):
+            resolved = first_env(env, source[4:])
+            if resolved:
+                return resolved
+        token = str(cred.get("access_token") or "").strip()
+        if token:
+            return token
+    return ""
+
+
+def resolve_llm_config(env: dict[str, str], *, hermes_dir: Path | None = None) -> dict[str, str]:
+    hermes_dir = hermes_dir or Path.home() / ".hermes"
+    env = _env_with_hermes(env, hermes_dir)
+    hermes_config = _load_simple_yaml(hermes_dir / "config.yaml")
+    model_config = hermes_config.get("model", {}) if isinstance(hermes_config.get("model"), dict) else {}
+    provider = str(model_config.get("provider") or "").strip()
+    provider_key, provider_base_url, provider_model = _provider_env_names(provider) if provider else ("", "", "")
+
+    api_key = first_env(env, "LLM_API_KEY")
+    base_url = first_env(env, "LLM_BASE_URL")
+    model = first_env(env, "LLM_MODEL")
+
+    if not api_key and provider:
+        api_key = first_env(env, provider_key) or _auth_json_key(env, hermes_dir, provider)
+    if not base_url and provider:
+        base_url = first_env(env, provider_base_url) or str(model_config.get("base_url") or "").strip()
+    if not model and provider:
+        model = first_env(env, provider_model) or str(model_config.get("default") or "").strip()
+
+    if not api_key:
+        api_key = first_env(env, "SUB2API_API_KEY", "XIAOMI_API_KEY", "OPENROUTER_API_KEY")
+    if not base_url:
+        base_url = first_env(env, "SUB2API_BASE_URL", "XIAOMI_BASE_URL", "OPENROUTER_BASE_URL")
+    if not model:
+        model = first_env(env, "SUB2API_MODEL", "XIAOMI_MODEL")
+
+    missing = [
+        name
+        for name, value in (
+            ("LLM_API_KEY", api_key),
+            ("LLM_BASE_URL", base_url),
+            ("LLM_MODEL", model),
+        )
+        if not value
+    ]
+    if missing:
+        raise ValueError("missing_llm_config: " + ",".join(missing))
+    return {"api_key": api_key, "base_url": base_url, "model": model}
+
+
+def resolve_blog_token(env: dict[str, str]) -> str:
+    return first_env(env, "BLOG_SERVICE_TOKEN", "EPHRON_SERVICE_TOKEN")