codebee 0.1.95 → 0.1.96

package/app/core/capability.py

@@ -1,144 +1,144 @@
-# -*- coding: utf-8 -*-
-"""能力维度（4D）：按任务类型（writing/coding/reasoning/vision）选模型。
-
-设计稿：docs/migration/05-model-seams.md §4D（按 CodeBee 实际架构落地：
-不改 modelhub.py——供应商声明可选 `strengths` 字段即可被识别；
-选择逻辑独立成模块，零侵入）。
-
-供应商声明示例（data/models.json 的 providers 条目）：
-  {"id": "p1", ..., "strengths": ["writing", "reasoning"]}
-未声明 strengths 的供应商视为无偏好（只做兜底）。
-"""
-from __future__ import annotations
-
-import re
-
-from .dispatch import TYPE_DIMENSIONS
-
-# 能力维度（先固化清单，schema 见设计稿）
-DIMS = ("writing", "coding", "reasoning", "vision")
-
-# 关键词分类表（覆盖 task type / 目标文本；可按需扩充）
-_KEYWORDS = {
-    "writing": ("写", "文案", "大纲", "连载", "章节", "小说", "营销", "总结", "润色",
-                "novel", "draft", "review"),
-    "coding": ("代码", "实现", "修复", "重构", "测试", "bug", "code", "fix",
-               "refactor", "test", "编译", "报错"),
-    "reasoning": ("推理", "分析", "调研", "对比", "规划", "拆解", "评审",
-                  "reason", "analyze", "plan", "orchestrate"),
-    "vision": ("图", "图片", "识别", "视觉", "ocr", "image", "vision", "截图"),
-}
-
-
-def classify_task_type(task) -> str:
-    """把任务分类到 DIMS 之一。task 显式带 task_type 时优先。"""
-    explicit = str((task or {}).get("task_type") or "").strip().lower()
-    if explicit in DIMS:
-        return explicit
-    preset = str((task or {}).get("type") or "").strip().lower()
-    if preset in TYPE_DIMENSIONS:
-        return TYPE_DIMENSIONS[preset]
-    text = "%s %s" % ((task or {}).get("type") or "",
-                      (task or {}).get("goal") or "")
-    scores = {}
-    for dim, kws in _KEYWORDS.items():
-        scores[dim] = sum(1 for kw in kws if kw in text)
-    best = max(scores, key=lambda d: scores[d])
-    if scores[best] > 0:
-        return best
-    return "coding"  # 默认兜底（CodeBee 主场景）
-
-
-def provider_strengths(prov):
-    """读供应商声明的能力维度（容错：非法值忽略）。"""
-    raw = (prov or {}).get("strengths")
-    if not isinstance(raw, list):
-        return []
-    return [s for s in raw if s in DIMS]
-
-
-def pick_by_strength(providers, task_type, *, enabled_only=True):
-    """按能力维度挑供应商。
-
-    规则：
-      1. 声明了该维度的可用供应商优先（保持原有顺序）；
-      2. 未声明的排后面（兜底）；
-      3. 都没有声明时返回原顺序（行为同现状）。
-    返回 (排序后的供应商列表, 分类依据说明)。
-    """
-    task_type = task_type if task_type in DIMS else classify_task_type({"goal": task_type})
-    pool = list(providers or [])
-    if enabled_only:
-        pool = [p for p in pool if p.get("enabled", True)]
-    strong = [p for p in pool if task_type in provider_strengths(p)]
-    rest = [p for p in pool if p not in strong]
-    ranked = strong + rest
-    reason = "%s：优先 %s" % (
-        task_type,
-        "、".join(p.get("id", "?") for p in strong) if strong else "（无声明，按原序兜底）")
-    return ranked, reason
-
-
-def resolve_binding_by_task(task, providers, bindings):
-    """任务 → 绑定解析（能力维度优先，回落 default）。
-
-    bindings 形如 modelhub 的 {"writing": {...}, "coding": {...}, "default": {...}}；
-    对应维度的绑定缺失/为空时回落 default。返回 (binding, task_type)。
-    """
-    tt = classify_task_type(task)
-    b = (bindings or {}).get(tt)
-    if not b:
-        b = (bindings or {}).get("default")
-    return b, tt
-
-
-# ---------------------------------------------------------------- §07 T3.1 级联
-
-TIER_ORDER = {"budget": 0, "standard": 1, "premium": 2}
-
-
-def cascade_reorder(agent, tier_of, *, providers=None, pricing=None,
-                    difficulty="easy", task_type="", role=""):
-    """FrugalGPT 式便宜优先：easy 任务把 call_chain 按 tier 升序稳定重排。
-
-    agent 来自 modelhub.bind_agent（可能带 call_chain）；tier_of(chain_entry)
-    返回该条目的档位串（"budget"/"standard"/"premium"或 None=standard）。
-    稳定排序保证同档内保持用户配置的原顺序。链长 <2 或非链式原样返回。
-    """
-    chain = (agent or {}).get("call_chain") or []
-    if len(chain) < 2:
-        return agent
-    if providers is not None and (task_type or role):
-        from .dispatch import rank_model_entries
-        ranked, _decisions = rank_model_entries(
-            chain, {p.get("id"): p for p in providers or []},
-            pricing or {}, difficulty, task_type, role)
-        out = dict(agent)
-        out["call_chain"] = ranked
-        return out
-
-    def key(entry):
-        return TIER_ORDER.get(tier_of(entry) or "standard", 1)
-
-    out = dict(agent)
-    out["call_chain"] = sorted(chain, key=key)
-    return out
-
-
-def make_tier_lookup(providers):
-    """由 providers 列表构造 chain_entry → tier 的查询函数。
-
-    tier 来源（按优先级）：链条目 model 在供应商 models[] 里的 tier 字段 →
-    供应商级 tier → None（按 standard 兜底）。缺什么都不抛。
-    """
-    by_id = {p.get("id"): p for p in (providers or []) if p.get("id")}
-
-    def tier_of(entry):
-        p = by_id.get((entry or {}).get("provider_id") or "")
-        if not p:
-            return None
-        for m in (p.get("models") or []):
-            if isinstance(m, dict) and m.get("name") == (entry or {}).get("model"):
-                return m.get("tier") or p.get("tier")
-        return p.get("tier")
-    return tier_of
+# -*- coding: utf-8 -*-
+"""能力维度（4D）：按任务类型（writing/coding/reasoning/vision）选模型。
+
+设计稿：docs/migration/05-model-seams.md §4D（按 CodeBee 实际架构落地：
+不改 modelhub.py——供应商声明可选 `strengths` 字段即可被识别；
+选择逻辑独立成模块，零侵入）。
+
+供应商声明示例（data/models.json 的 providers 条目）：
+  {"id": "p1", ..., "strengths": ["writing", "reasoning"]}
+未声明 strengths 的供应商视为无偏好（只做兜底）。
+"""
+from __future__ import annotations
+
+import re
+
+from .dispatch import TYPE_DIMENSIONS
+
+# 能力维度（先固化清单，schema 见设计稿）
+DIMS = ("writing", "coding", "reasoning", "vision")
+
+# 关键词分类表（覆盖 task type / 目标文本；可按需扩充）
+_KEYWORDS = {
+    "writing": ("写", "文案", "大纲", "连载", "章节", "小说", "营销", "总结", "润色",
+                "novel", "draft", "review"),
+    "coding": ("代码", "实现", "修复", "重构", "测试", "bug", "code", "fix",
+               "refactor", "test", "编译", "报错"),
+    "reasoning": ("推理", "分析", "调研", "对比", "规划", "拆解", "评审",
+                  "reason", "analyze", "plan", "orchestrate"),
+    "vision": ("图", "图片", "识别", "视觉", "ocr", "image", "vision", "截图"),
+}
+
+
+def classify_task_type(task) -> str:
+    """把任务分类到 DIMS 之一。task 显式带 task_type 时优先。"""
+    explicit = str((task or {}).get("task_type") or "").strip().lower()
+    if explicit in DIMS:
+        return explicit
+    preset = str((task or {}).get("type") or "").strip().lower()
+    if preset in TYPE_DIMENSIONS:
+        return TYPE_DIMENSIONS[preset]
+    text = "%s %s" % ((task or {}).get("type") or "",
+                      (task or {}).get("goal") or "")
+    scores = {}
+    for dim, kws in _KEYWORDS.items():
+        scores[dim] = sum(1 for kw in kws if kw in text)
+    best = max(scores, key=lambda d: scores[d])
+    if scores[best] > 0:
+        return best
+    return "coding"  # 默认兜底（CodeBee 主场景）
+
+
+def provider_strengths(prov):
+    """读供应商声明的能力维度（容错：非法值忽略）。"""
+    raw = (prov or {}).get("strengths")
+    if not isinstance(raw, list):
+        return []
+    return [s for s in raw if s in DIMS]
+
+
+def pick_by_strength(providers, task_type, *, enabled_only=True):
+    """按能力维度挑供应商。
+
+    规则：
+      1. 声明了该维度的可用供应商优先（保持原有顺序）；
+      2. 未声明的排后面（兜底）；
+      3. 都没有声明时返回原顺序（行为同现状）。
+    返回 (排序后的供应商列表, 分类依据说明)。
+    """
+    task_type = task_type if task_type in DIMS else classify_task_type({"goal": task_type})
+    pool = list(providers or [])
+    if enabled_only:
+        pool = [p for p in pool if p.get("enabled", True)]
+    strong = [p for p in pool if task_type in provider_strengths(p)]
+    rest = [p for p in pool if p not in strong]
+    ranked = strong + rest
+    reason = "%s：优先 %s" % (
+        task_type,
+        "、".join(p.get("id", "?") for p in strong) if strong else "（无声明，按原序兜底）")
+    return ranked, reason
+
+
+def resolve_binding_by_task(task, providers, bindings):
+    """任务 → 绑定解析（能力维度优先，回落 default）。
+
+    bindings 形如 modelhub 的 {"writing": {...}, "coding": {...}, "default": {...}}；
+    对应维度的绑定缺失/为空时回落 default。返回 (binding, task_type)。
+    """
+    tt = classify_task_type(task)
+    b = (bindings or {}).get(tt)
+    if not b:
+        b = (bindings or {}).get("default")
+    return b, tt
+
+
+# ---------------------------------------------------------------- §07 T3.1 级联
+
+TIER_ORDER = {"budget": 0, "standard": 1, "premium": 2}
+
+
+def cascade_reorder(agent, tier_of, *, providers=None, pricing=None,
+                    difficulty="easy", task_type="", role=""):
+    """FrugalGPT 式便宜优先：easy 任务把 call_chain 按 tier 升序稳定重排。
+
+    agent 来自 modelhub.bind_agent（可能带 call_chain）；tier_of(chain_entry)
+    返回该条目的档位串（"budget"/"standard"/"premium"或 None=standard）。
+    稳定排序保证同档内保持用户配置的原顺序。链长 <2 或非链式原样返回。
+    """
+    chain = (agent or {}).get("call_chain") or []
+    if len(chain) < 2:
+        return agent
+    if providers is not None and (task_type or role):
+        from .dispatch import rank_model_entries
+        ranked, _decisions = rank_model_entries(
+            chain, {p.get("id"): p for p in providers or []},
+            pricing or {}, difficulty, task_type, role)
+        out = dict(agent)
+        out["call_chain"] = ranked
+        return out
+
+    def key(entry):
+        return TIER_ORDER.get(tier_of(entry) or "standard", 1)
+
+    out = dict(agent)
+    out["call_chain"] = sorted(chain, key=key)
+    return out
+
+
+def make_tier_lookup(providers):
+    """由 providers 列表构造 chain_entry → tier 的查询函数。
+
+    tier 来源（按优先级）：链条目 model 在供应商 models[] 里的 tier 字段 →
+    供应商级 tier → None（按 standard 兜底）。缺什么都不抛。
+    """
+    by_id = {p.get("id"): p for p in (providers or []) if p.get("id")}
+
+    def tier_of(entry):
+        p = by_id.get((entry or {}).get("provider_id") or "")
+        if not p:
+            return None
+        for m in (p.get("models") or []):
+            if isinstance(m, dict) and m.get("name") == (entry or {}).get("model"):
+                return m.get("tier") or p.get("tier")
+        return p.get("tier")
+    return tier_of

package/app/core/chaptersafe.py

@@ -1,32 +1,32 @@
-# -*- coding: utf-8 -*-
-"""章节安全落盘（tmp+原子改名，inkos 安全章节工作区借鉴）。
-
-写一半崩溃/磁盘满不会留下半章正文冒充成稿——断点续跑按「文件够长」
-判定，半文件会被误当合法稿复用；.tmp 写完 os.replace 原子落位，
-失败清理残渣后原样抛出。路径守卫用 pathlib resolve+parents 惯用法
-（同 _ms_io/_inside 口径）。pipeline._write_chapter 委托此函数。"""
-from __future__ import annotations
-
-from pathlib import Path
-
-
-def atomic_write_chapter(workdir, i, text):
-    """第 i 章安全落盘：tmp 写入 → 原子改名。返回最终路径。"""
-    root = Path(workdir).resolve()
-    p = (root / ("chapter-%02d.md" % int(i))).resolve()
-    # 守卫：目标必须在 workdir 之内且不得是 workdir 本身（".." 作 workdir
-    # 时 resolve 到父目录，p 仍是其中一章——但那不是调用方的工作目录，
-    # 一并拒绝：workdir 必须是已存在的目录）
-    if root not in p.parents or not root.is_dir():
-        raise ValueError("章节路径越界: chapter-%02d.md" % int(i))
-    tmp = Path(str(p) + ".tmp")
-    try:
-        tmp.write_text(str(text), encoding="utf-8", errors="replace")
-        tmp.replace(p)
-    except BaseException:
-        try:
-            tmp.unlink(missing_ok=True)
-        except OSError:
-            pass
-        raise
-    return p
+# -*- coding: utf-8 -*-
+"""章节安全落盘（tmp+原子改名，inkos 安全章节工作区借鉴）。
+
+写一半崩溃/磁盘满不会留下半章正文冒充成稿——断点续跑按「文件够长」
+判定，半文件会被误当合法稿复用；.tmp 写完 os.replace 原子落位，
+失败清理残渣后原样抛出。路径守卫用 pathlib resolve+parents 惯用法
+（同 _ms_io/_inside 口径）。pipeline._write_chapter 委托此函数。"""
+from __future__ import annotations
+
+from pathlib import Path
+
+
+def atomic_write_chapter(workdir, i, text):
+    """第 i 章安全落盘：tmp 写入 → 原子改名。返回最终路径。"""
+    root = Path(workdir).resolve()
+    p = (root / ("chapter-%02d.md" % int(i))).resolve()
+    # 守卫：目标必须在 workdir 之内且不得是 workdir 本身（".." 作 workdir
+    # 时 resolve 到父目录，p 仍是其中一章——但那不是调用方的工作目录，
+    # 一并拒绝：workdir 必须是已存在的目录）
+    if root not in p.parents or not root.is_dir():
+        raise ValueError("章节路径越界: chapter-%02d.md" % int(i))
+    tmp = Path(str(p) + ".tmp")
+    try:
+        tmp.write_text(str(text), encoding="utf-8", errors="replace")
+        tmp.replace(p)
+    except BaseException:
+        try:
+            tmp.unlink(missing_ok=True)
+        except OSError:
+            pass
+        raise
+    return p

package/app/core/checkpoints.py

@@ -0,0 +1,143 @@
+# -*- coding: utf-8 -*-
+"""Append-only execution checkpoints with conservative replay semantics."""
+from __future__ import annotations
+
+import hashlib
+import json
+import secrets
+import threading
+import time
+from pathlib import Path
+
+from . import paths
+from .redact import scrub_text
+
+_DIR = paths.DATA_DIR / "checkpoints"
+_LOCK = threading.RLock()
+_TERMINAL = {"done", "failed", "cancelled", "timeout", "unknown"}
+
+
+def _file():
+    return _DIR / ("checkpoints-%s.jsonl" % time.strftime("%Y%m"))
+
+
+def _hash(value):
+    if isinstance(value, (dict, list, tuple)):
+        raw = json.dumps(value, ensure_ascii=False, sort_keys=True,
+                         separators=(",", ":"), default=str)
+    else:
+        raw = str(value or "")
+    return hashlib.sha256(raw.encode("utf-8")).hexdigest()
+
+
+def _append(row):
+    _DIR.mkdir(parents=True, exist_ok=True)
+    with _file().open("a", encoding="utf-8") as handle:
+        handle.write(json.dumps(row, ensure_ascii=False, sort_keys=True) + "\n")
+        handle.flush()
+
+
+def start(run_id, step, role, prompt="", *, input_data=None, attempt=1,
+          idempotency_key=""):
+    """Record a step start without persisting prompt contents."""
+    now = time.time()
+    try:
+        attempt = max(1, min(100, int(attempt)))
+    except (TypeError, ValueError):
+        attempt = 1
+    row = {"event_id": "cp-" + secrets.token_hex(10), "event": "start",
+           "run_id": str(run_id or "")[:80], "step": int(step),
+           "role": str(role or "")[:80], "status": "running",
+           "attempt": attempt, "idempotency_key": str(idempotency_key or "")[:160],
+           "prompt_sha256": _hash(prompt), "input_sha256": _hash(input_data),
+           "created_at": now}
+    with _LOCK:
+        try:
+            _append(row)
+        except OSError:
+            pass
+    return row
+
+
+def finish(run_id, step, status, *, error="", output=None, metadata=None):
+    status = str(status or "unknown").strip().lower()
+    if status not in _TERMINAL:
+        status = "unknown"
+    row = {"event_id": "cp-" + secrets.token_hex(10), "event": "finish",
+           "run_id": str(run_id or "")[:80], "step": int(step),
+           "status": status, "error": scrub_text(error, limit=500),
+           "output_sha256": _hash(output), "metadata": {
+               str(k)[:40]: v for k, v in (metadata or {}).items()
+               if isinstance(v, (str, int, float, bool))
+           }, "created_at": time.time()}
+    with _LOCK:
+        try:
+            _append(row)
+        except OSError:
+            pass
+    return row
+
+
+def _read(run_id=""):
+    rows = []
+    try:
+        files = sorted(_DIR.glob("checkpoints-*.jsonl"), reverse=True)
+    except OSError:
+        files = []
+    for path in files[:24]:
+        try:
+            if path.stat().st_size > 4 * 1024 * 1024:
+                continue
+            for line in path.read_text(encoding="utf-8").splitlines()[-50000:]:
+                try:
+                    row = json.loads(line)
+                except (TypeError, ValueError):
+                    continue
+                if isinstance(row, dict) and (not run_id or row.get("run_id") == run_id):
+                    rows.append(row)
+        except OSError:
+            continue
+    return rows
+
+
+def replay_preview(run_id):
+    """Return latest checkpoint per step and whether automatic replay is safe."""
+    with _LOCK:
+        rows = _read(str(run_id or "")[:80])
+    latest = {}
+    starts = {}
+    finishes = {}
+    for row in rows:
+        try:
+            key = int(row.get("step"))
+        except (TypeError, ValueError):
+            continue
+        if key < 0:
+            continue
+        latest[key] = dict(latest.get(key) or {}, **row)
+        if row.get("event") == "start":
+            starts[key] = row
+        elif row.get("event") == "finish":
+            finishes[key] = row
+    steps = []
+    for key in sorted(latest):
+        item = dict(latest[key])
+        if key in starts:
+            item.setdefault("prompt_sha256", starts[key].get("prompt_sha256"))
+            item.setdefault("attempt", starts[key].get("attempt", 1))
+        steps.append(item)
+    unknown = next((x for x in steps if x.get("status") in ("unknown", "running")
+                    or x.get("event") != "finish"
+                    or x.get("step") not in finishes
+                    or x.get("step") not in starts), None)
+    if not steps:
+        unknown = {"reason": "checkpoint_not_found"}
+    return {"run_id": str(run_id or ""), "steps": steps,
+            "replayable": unknown is None,
+            "blocked_reason": ("checkpoint_not_found" if not steps else
+                               "requires_reconciliation" if unknown else "")}
+
+
+def replay(run_id):
+    """Alias used by integrations; intentionally returns a preview only."""
+    return replay_preview(run_id)