codebee 0.1.71 → 0.1.72

package/app/core/quality_gate.py

@@ -0,0 +1,194 @@
+# -*- coding: utf-8 -*-
+"""Deterministic quality and release gates for generated fiction.
+
+LLM reviewers provide judgements; this module decides whether the evidence is
+valid enough to support a release action.  It deliberately treats missing,
+malformed, out-of-range and non-consensus scores as unevaluated.
+"""
+from __future__ import annotations
+
+import math
+import re
+from pathlib import Path
+
+
+MIN_REVIEWERS = 2
+DEFAULT_MAX_SPREAD = 2.0
+_CHAPTER_RE = re.compile(r"^chapter-(\d{1,4})\.(?:md|txt)$", re.I)
+
+
+def normalize_scores(raw, dimensions):
+    """Return (scores, errors); incomplete scores are invalid as a set."""
+    raw = raw if isinstance(raw, dict) else {}
+    scores, errors = {}, {}
+    for dim in dimensions or []:
+        value = raw.get(dim)
+        try:
+            number = float(value)
+        except (TypeError, ValueError):
+            errors[dim] = "非数字"
+            continue
+        if not math.isfinite(number) or number < 1.0 or number > 10.0:
+            errors[dim] = "必须在 1-10 之间"
+            continue
+        scores[dim] = round(number, 2)
+    if errors or len(scores) != len(list(dimensions or [])):
+        return {}, errors or {str(d): "缺失" for d in dimensions or [] if d not in scores}
+    return scores, {}
+
+
+def aggregate_reviews(reviews, dimensions, threshold=7.0,
+                      min_reviewers=MIN_REVIEWERS,
+                      max_spread=DEFAULT_MAX_SPREAD):
+    """Validate reviewers, calculate means, and require reviewer consensus."""
+    dims = list(dimensions or [])
+    valid = []
+    invalid = []
+    seen = set()
+    for idx, review in enumerate(reviews or []):
+        review = review if isinstance(review, dict) else {}
+        reviewer_id = str(review.get("id") or "reviewer-%d" % idx)
+        if reviewer_id in seen:
+            continue
+        seen.add(reviewer_id)
+        scores, errors = normalize_scores(review.get("scores"), dims)
+        if errors:
+            invalid.append({"id": reviewer_id, "errors": errors})
+        else:
+            valid.append({"id": reviewer_id, "scores": scores})
+
+    reasons = []
+    eligible = len(valid) >= int(min_reviewers)
+    if not eligible:
+        reasons.append("至少需要 %d 名有效评审，当前 %d 名" %
+                       (int(min_reviewers), len(valid)))
+    means = {}
+    spreads = {}
+    for dim in dims:
+        values = [r["scores"][dim] for r in valid]
+        if values:
+            means[dim] = round(sum(values) / len(values), 1)
+            spreads[dim] = round(max(values) - min(values), 1)
+
+    consensus = bool(eligible and means and
+                     all(spreads.get(dim, float("inf")) <= float(max_spread)
+                         for dim in dims))
+    if eligible and not consensus:
+        bad = [dim for dim in dims if spreads.get(dim, float("inf")) > float(max_spread)]
+        reasons.append("评审分歧超过 %.1f 分：%s" % (float(max_spread), "、".join(bad)))
+    passed = bool(consensus and means and
+                  all(value >= float(threshold) for value in means.values()))
+    if consensus and not passed:
+        reasons.append("综合分存在低于 %.1f 的维度" % float(threshold))
+    return {
+        "eligible": eligible,
+        "consensus": consensus,
+        "passed": passed,
+        "means": means,
+        "spreads": spreads,
+        "valid_reviewers": valid,
+        "invalid_reviewers": invalid,
+        "reviewer_count": len(valid),
+        "reasons": reasons,
+    }
+
+
+def local_version(workdir):
+    """Return the local manuscript version used for a release decision."""
+    root = Path(workdir or "")
+    rows = []
+    if root.is_dir():
+        for path in root.iterdir():
+            match = _CHAPTER_RE.match(path.name)
+            if not match or not path.is_file():
+                continue
+            try:
+                text = path.read_text(encoding="utf-8", errors="replace")
+            except OSError:
+                continue
+            rows.append((int(match.group(1)), len(re.sub(r"\s", "", text))))
+    return {
+        "local_total": len(rows),
+        "local_latest": max((n for n, _ in rows), default=0),
+        "local_words": sum(words for _, words in rows),
+    }
+
+
+def evaluate_release(verdict, action="publish", target_chapter=None,
+                     platform_version=None, force=False,
+                     force_confirmed=False, force_reason=""):
+    """Decide whether a publish/signing action is allowed.
+
+    ``continue`` is intentionally separate: writers may continue improving an
+    unready manuscript, while publishing and signing remain gated.
+    """
+    verdict = verdict if isinstance(verdict, dict) else {}
+    action = str(action or "publish").strip().lower()
+    if action == "continue":
+        return {"allowed": True, "status": "continue_only", "forced": False,
+                "blockers": [], "warnings": []}
+
+    blockers = []
+    warnings = []
+    if verdict.get("publishable") is not True:
+        blockers.append("最近一次质量评审未达标")
+    if verdict.get("global_pass") is False:
+        blockers.append("全局一致性评审未通过")
+    if verdict.get("global_reviewer_count", 0) < MIN_REVIEWERS:
+        blockers.append("有效全局评审不足 %d 名" % MIN_REVIEWERS)
+    if verdict.get("global_reviewer_consensus") is False:
+        blockers.append("全局评审未形成共识")
+    chapter_scores = verdict.get("chapter_scores") or []
+    if target_chapter is not None:
+        try:
+            target = int(target_chapter)
+        except (TypeError, ValueError):
+            target = 0
+        try:
+            reviewed_end = int(verdict.get("end_chapter") or 0)
+        except (TypeError, ValueError):
+            reviewed_end = 0
+        if target > 0 and reviewed_end < target:
+            blockers.append("目标章节超出最近评审版本（目标第 %d 章，评审至第 %d 章）" %
+                            (target, reviewed_end))
+    if chapter_scores and any(c.get("passed") is not True for c in chapter_scores):
+        blockers.append("存在未达标章节")
+    if any(c.get("reviewer_count", MIN_REVIEWERS) < MIN_REVIEWERS or
+           c.get("reviewer_consensus") is False for c in chapter_scores):
+        blockers.append("存在评审人数不足或无共识章节")
+    majors = [x for x in (verdict.get("major_issues") or [])
+              if isinstance(x, dict) and x.get("severity") == "major"]
+    if majors:
+        blockers.append("存在 major 问题（共 %d 条）" % len(majors))
+
+    if action == "signing":
+        checkpoint = verdict.get("signing_checkpoint") or {}
+        if checkpoint.get("passed") is not True:
+            blockers.append("2 万字签约检查点未通过")
+        if checkpoint.get("reviewer_count", MIN_REVIEWERS) < MIN_REVIEWERS:
+            blockers.append("签约检查点有效评审不足 %d 名" % MIN_REVIEWERS)
+        if checkpoint.get("reviewer_consensus") is False:
+            blockers.append("签约检查点评审未形成共识")
+        remote = platform_version if isinstance(platform_version, dict) else {}
+        remote_n = remote.get("remote_published")
+        if remote_n is None:
+            remote_n = remote.get("remote_total")
+        end_chapter = int(target_chapter or verdict.get("end_chapter") or 0)
+        if end_chapter and (remote_n is None or int(remote_n or 0) < end_chapter):
+            blockers.append("平台版本与申请评审版本不一致（本地第 %d 章，平台已发布第 %d 章）" %
+                            (end_chapter, int(remote_n or 0)))
+
+    forced = bool(force)
+    if blockers and forced:
+        if not force_confirmed:
+            blockers.append("强制放行必须二次确认")
+        if not str(force_reason or "").strip():
+            blockers.append("强制放行必须填写人工复核原因")
+        if force_confirmed and str(force_reason or "").strip() and \
+                all("强制放行必须" not in x for x in blockers):
+            warnings = list(blockers)
+            blockers = []
+    allowed = not blockers
+    return {"allowed": allowed, "status": "allowed" if allowed else "blocked",
+            "forced": bool(allowed and forced), "blockers": blockers,
+            "warnings": warnings}

package/app/core/redact.py

@@ -1,38 +1,38 @@
-# -*- coding: utf-8 -*-
-"""自由文本脱敏基础函数；不依赖业务模块，供各类本地台账复用。"""
-from __future__ import annotations
-
-import re
-
-
-_KEY_PATTERNS = (
-    (re.compile(r"\bsk-[A-Za-z0-9_-]{8,}"), "[key]"),
-    (re.compile(r"\b(?:Bearer|bearer)\s+\S+"), "Bearer [key]"),
-    (re.compile(r"(?i)\b((?:api[_-]?|access[_-]?|secret[_-]?|auth[_-]?)(?:key|token|secret))"
-                r"""["']?\s*[:=，,]\s*["']?[A-Za-z0-9._~+/=-]{8,}"""), r"\1[key]"),
-    (re.compile(r"\b[0-9a-fA-F]{40,}\b"), "[token]"),
-)
-
-_PATH_PATTERNS = (
-    (re.compile(r"(?i)\b[A-Z]:\\(?:[^\\/:*?\"<>|\r\n]+\\)*[^\\/:*?\"<>|\r\n]*"),
-     lambda m: "[path]" + m.group(0).split("\\")[-1]),
-    (re.compile(r"(?i)\b(?:\\\\[^\\\s]+\\[^\s]+)"), "[path]"),
-    (re.compile(r"(?:/Users/|/home/|~)[^\s\"':]+"),
-     lambda m: "[path]" + m.group(0).rsplit("/", 1)[-1]),
-)
-
-
-def scrub_text(text, limit=600):
-    """剥离常见密钥、令牌和绝对路径，再按字符上限截断。"""
-    if not isinstance(text, str):
-        text = "" if text is None else str(text)
-    out = text
-    for pattern, replacement in _KEY_PATTERNS:
-        out = pattern.sub(replacement, out)
-    for pattern, replacement in _PATH_PATTERNS:
-        try:
-            out = pattern.sub(replacement, out)
-        except Exception:
-            pass
-    out = out.strip()
-    return out[:limit] + "…" if len(out) > limit else out
+# -*- coding: utf-8 -*-
+"""自由文本脱敏基础函数；不依赖业务模块，供各类本地台账复用。"""
+from __future__ import annotations
+
+import re
+
+
+_KEY_PATTERNS = (
+    (re.compile(r"\bsk-[A-Za-z0-9_-]{8,}"), "[key]"),
+    (re.compile(r"\b(?:Bearer|bearer)\s+\S+"), "Bearer [key]"),
+    (re.compile(r"(?i)\b((?:api[_-]?|access[_-]?|secret[_-]?|auth[_-]?)(?:key|token|secret))"
+                r"""["']?\s*[:=，,]\s*["']?[A-Za-z0-9._~+/=-]{8,}"""), r"\1[key]"),
+    (re.compile(r"\b[0-9a-fA-F]{40,}\b"), "[token]"),
+)
+
+_PATH_PATTERNS = (
+    (re.compile(r"(?i)\b[A-Z]:\\(?:[^\\/:*?\"<>|\r\n]+\\)*[^\\/:*?\"<>|\r\n]*"),
+     lambda m: "[path]" + m.group(0).split("\\")[-1]),
+    (re.compile(r"(?i)\b(?:\\\\[^\\\s]+\\[^\s]+)"), "[path]"),
+    (re.compile(r"(?:/Users/|/home/|~)[^\s\"':]+"),
+     lambda m: "[path]" + m.group(0).rsplit("/", 1)[-1]),
+)
+
+
+def scrub_text(text, limit=600):
+    """剥离常见密钥、令牌和绝对路径，再按字符上限截断。"""
+    if not isinstance(text, str):
+        text = "" if text is None else str(text)
+    out = text
+    for pattern, replacement in _KEY_PATTERNS:
+        out = pattern.sub(replacement, out)
+    for pattern, replacement in _PATH_PATTERNS:
+        try:
+            out = pattern.sub(replacement, out)
+        except Exception:
+            pass
+    out = out.strip()
+    return out[:limit] + "…" if len(out) > limit else out

package/app/core/repeat_guard.py

@@ -1,129 +1,129 @@
-# -*- coding: utf-8 -*-
-"""重复 CLI 调用检测：防止编排者用同一份 prompt 反复调同一 CLI 死循环。
-
-设计稿：docs/migration/01-defense-patterns.md §5C。
-参考 dsh packages/guard/repeat-tool-reminder/src/index.ts：
-  监听 tools/post-execute，按 (tool, canonical_args) 跟踪，3/5/8 阈值注入 user-message 提醒。
-
-Tutti 的 "tool" 对应到 step role + 执行者身份，"canonical_args" 对应到 prompt
-模板指纹。不同 CLI 间的换将是有效的回退，不能共享同一个重复预算。步骤级调用
-代价远高于普通工具调用，因此第 3 次提醒、第 5 次强制停止。
-"""
-from __future__ import annotations
-
-import hashlib
-import logging
-import threading
-import time
-
-log = logging.getLogger(__name__)
-
-# 渐进阈值：第 N 次命中时给提醒；最后一次及以上时强制停止。
-DEFAULT_THRESHOLDS = (3, 5)
-
-REMINDER_TEMPLATE = (
-    "⚠️ 提醒：上一步使用了几乎相同的输入（已连续 {count} 次调用 {role}）。"
-    "请换一种方法：读不同的文件、用更具体的指令、或明确询问用户澄清。"
-)
-
-STOP_TEMPLATE = (
-    "已连续 {count} 次使用相同输入调用 {role}，超过 {last_thr} 次阈值，"
-    "强制停止本 step 以防止无限循环。请用户检查输入或调整 prompt 模板。"
-)
-
-
-def _prompt_fingerprint(prompt: str, identity: str = "") -> str:
-    """prompt 指纹：用前 200 字符 + 总长度（CLI prompt 头几行通常是模板部分）。
-
-    不做严格 canonical args 比对（CLI prompt 通常很长，且 dsh 也用 JSON.stringify）；
-    指纹命中说明是同一个模板路径走过多次，已经够分辨。
-
-    用 SHA-256 取前 12 字符（96 bit）：48 亿分之一碰撞概率对去重足够；不追求密码学强度。
-    """
-    head = (prompt or "")[:200]
-    return hashlib.sha256(
-        f"{identity}\0{head}|{len(prompt or '')}".encode("utf-8")).hexdigest()[:12]
-
-
-class RepeatGuard:
-    """每 (run_id, step_role) 的最近执行链独立计数；指纹包含执行者身份。
-
-    计数仅统计相同 key 连续出现；新 prompt 会重置。
-    """
-
-    def __init__(self, thresholds=DEFAULT_THRESHOLDS, *, max_history=50):
-        self.thresholds = tuple(sorted(set(thresholds)))
-        self.max_history = max_history
-        self._lock = threading.Lock()
-        # chain[(run_id, role)] = [(ts, fingerprint)]
-        self._chains: dict = {}
-
-    def check(self, run_id: str, role: str, prompt: str, *, identity: str = "") -> dict:
-        """检查并更新 (run_id, role) 的连续计数。
-
-        identity 标识实际执行 CLI/agent。相同 prompt 换到其他执行者属于回退，
-        会从新的连续链计数；同一执行者重复相同调用仍按阈值停止。
-
-        Returns:
-            {"count": int, "reminder": str | None, "should_stop": bool}
-        """
-        fp = _prompt_fingerprint(prompt, str(identity or ""))
-        chain_key = (run_id, role)
-        with self._lock:
-            chain = self._chains.setdefault(chain_key, [])
-            chain.append((time.time(), fp))
-            # 仅统计相同 fp 连续出现
-            count = 1
-            for _, prev_fp in reversed(chain[:-1]):
-                if prev_fp == fp:
-                    count += 1
-                else:
-                    break
-            # 截尾避免内存膨胀
-            if len(chain) > self.max_history:
-                self._chains[chain_key] = chain[-self.max_history:]
-
-        reminder = None
-        stop = False
-        last_thr = self.thresholds[-1]
-        if count >= last_thr:
-            stop = True
-            reminder = STOP_TEMPLATE.format(count=count, role=role, last_thr=last_thr)
-        elif count in self.thresholds:
-            reminder = REMINDER_TEMPLATE.format(count=count, role=role)
-
-        if reminder:
-            log.warning("repeat-guard %s/%s count=%d stop=%s reminder=%s",
-                        run_id, role, count, stop, reminder[:80])
-        return {"count": count, "reminder": reminder, "should_stop": stop}
-
-    def reset(self, run_id: str) -> int:
-        """重置某 run_id 的所有 (run_id, *) 链。返回清除的链条数。"""
-        with self._lock:
-            cleared = 0
-            for k in list(self._chains.keys()):
-                if k[0] == run_id:
-                    del self._chains[k]
-                    cleared += 1
-            return cleared
-
-    def stats(self, run_id: str, role: str) -> dict:
-        """读取 (run_id, role) 当前状态（不更新）。用于 UI 调试。"""
-        chain_key = (run_id, role)
-        with self._lock:
-            chain = self._chains.get(chain_key, [])
-            if not chain:
-                return {"chain_len": 0, "last_fp": ""}
-            # 当前连续计数
-            last_fp = chain[-1][1]
-            count = 1
-            for _, fp in reversed(chain[:-1]):
-                if fp == last_fp:
-                    count += 1
-                else:
-                    break
-            return {"chain_len": len(chain), "last_fp": last_fp, "count": count}
-
-
-# 模块级默认实例（pipeline 接线用；run_id 入键天然隔离多任务，测试无需替换）
-guard = RepeatGuard()
+# -*- coding: utf-8 -*-
+"""重复 CLI 调用检测：防止编排者用同一份 prompt 反复调同一 CLI 死循环。
+
+设计稿：docs/migration/01-defense-patterns.md §5C。
+参考 dsh packages/guard/repeat-tool-reminder/src/index.ts：
+  监听 tools/post-execute，按 (tool, canonical_args) 跟踪，3/5/8 阈值注入 user-message 提醒。
+
+Tutti 的 "tool" 对应到 step role + 执行者身份，"canonical_args" 对应到 prompt
+模板指纹。不同 CLI 间的换将是有效的回退，不能共享同一个重复预算。步骤级调用
+代价远高于普通工具调用，因此第 3 次提醒、第 5 次强制停止。
+"""
+from __future__ import annotations
+
+import hashlib
+import logging
+import threading
+import time
+
+log = logging.getLogger(__name__)
+
+# 渐进阈值：第 N 次命中时给提醒；最后一次及以上时强制停止。
+DEFAULT_THRESHOLDS = (3, 5)
+
+REMINDER_TEMPLATE = (
+    "⚠️ 提醒：上一步使用了几乎相同的输入（已连续 {count} 次调用 {role}）。"
+    "请换一种方法：读不同的文件、用更具体的指令、或明确询问用户澄清。"
+)
+
+STOP_TEMPLATE = (
+    "已连续 {count} 次使用相同输入调用 {role}，超过 {last_thr} 次阈值，"
+    "强制停止本 step 以防止无限循环。请用户检查输入或调整 prompt 模板。"
+)
+
+
+def _prompt_fingerprint(prompt: str, identity: str = "") -> str:
+    """prompt 指纹：用前 200 字符 + 总长度（CLI prompt 头几行通常是模板部分）。
+
+    不做严格 canonical args 比对（CLI prompt 通常很长，且 dsh 也用 JSON.stringify）；
+    指纹命中说明是同一个模板路径走过多次，已经够分辨。
+
+    用 SHA-256 取前 12 字符（96 bit）：48 亿分之一碰撞概率对去重足够；不追求密码学强度。
+    """
+    head = (prompt or "")[:200]
+    return hashlib.sha256(
+        f"{identity}\0{head}|{len(prompt or '')}".encode("utf-8")).hexdigest()[:12]
+
+
+class RepeatGuard:
+    """每 (run_id, step_role) 的最近执行链独立计数；指纹包含执行者身份。
+
+    计数仅统计相同 key 连续出现；新 prompt 会重置。
+    """
+
+    def __init__(self, thresholds=DEFAULT_THRESHOLDS, *, max_history=50):
+        self.thresholds = tuple(sorted(set(thresholds)))
+        self.max_history = max_history
+        self._lock = threading.Lock()
+        # chain[(run_id, role)] = [(ts, fingerprint)]
+        self._chains: dict = {}
+
+    def check(self, run_id: str, role: str, prompt: str, *, identity: str = "") -> dict:
+        """检查并更新 (run_id, role) 的连续计数。
+
+        identity 标识实际执行 CLI/agent。相同 prompt 换到其他执行者属于回退，
+        会从新的连续链计数；同一执行者重复相同调用仍按阈值停止。
+
+        Returns:
+            {"count": int, "reminder": str | None, "should_stop": bool}
+        """
+        fp = _prompt_fingerprint(prompt, str(identity or ""))
+        chain_key = (run_id, role)
+        with self._lock:
+            chain = self._chains.setdefault(chain_key, [])
+            chain.append((time.time(), fp))
+            # 仅统计相同 fp 连续出现
+            count = 1
+            for _, prev_fp in reversed(chain[:-1]):
+                if prev_fp == fp:
+                    count += 1
+                else:
+                    break
+            # 截尾避免内存膨胀
+            if len(chain) > self.max_history:
+                self._chains[chain_key] = chain[-self.max_history:]
+
+        reminder = None
+        stop = False
+        last_thr = self.thresholds[-1]
+        if count >= last_thr:
+            stop = True
+            reminder = STOP_TEMPLATE.format(count=count, role=role, last_thr=last_thr)
+        elif count in self.thresholds:
+            reminder = REMINDER_TEMPLATE.format(count=count, role=role)
+
+        if reminder:
+            log.warning("repeat-guard %s/%s count=%d stop=%s reminder=%s",
+                        run_id, role, count, stop, reminder[:80])
+        return {"count": count, "reminder": reminder, "should_stop": stop}
+
+    def reset(self, run_id: str) -> int:
+        """重置某 run_id 的所有 (run_id, *) 链。返回清除的链条数。"""
+        with self._lock:
+            cleared = 0
+            for k in list(self._chains.keys()):
+                if k[0] == run_id:
+                    del self._chains[k]
+                    cleared += 1
+            return cleared
+
+    def stats(self, run_id: str, role: str) -> dict:
+        """读取 (run_id, role) 当前状态（不更新）。用于 UI 调试。"""
+        chain_key = (run_id, role)
+        with self._lock:
+            chain = self._chains.get(chain_key, [])
+            if not chain:
+                return {"chain_len": 0, "last_fp": ""}
+            # 当前连续计数
+            last_fp = chain[-1][1]
+            count = 1
+            for _, fp in reversed(chain[:-1]):
+                if fp == last_fp:
+                    count += 1
+                else:
+                    break
+            return {"chain_len": len(chain), "last_fp": last_fp, "count": count}
+
+
+# 模块级默认实例（pipeline 接线用；run_id 入键天然隔离多任务，测试无需替换）
+guard = RepeatGuard()