codebee 0.1.29 → 0.1.31

package/app/core/store.py

@@ -104,12 +104,12 @@ def create_task(payload):
     if not wd.is_dir():
         raise ValueError("工作目录不存在: %s" % workdir)
     mode = payload.get("mode")
-    if mode not in ("auto", "manual"):
-        mode = "manual" if payload.get("implementer") else "auto"
+    if mode not in ("auto", "fast", "expert", "manual"):
+        mode = "manual" if payload.get("implementer") else "auto"
     difficulty = payload.get("difficulty")
     if difficulty not in ("auto", "easy", "hard", "default"):
         difficulty = "auto"
-    task = {
+    task = {
         "id": _new_id("t"), "type": flow["id"], "engine": flow["engine"],
         "title": title, "goal": goal,
         "context": _text(payload.get("context"), "context"),
@@ -119,8 +119,16 @@ def create_task(payload):
         "implementer": payload.get("implementer") or "",
         "attachments": [],
         "created_at": time.strftime("%Y-%m-%d %H:%M:%S"),
-        "status": "created",
-    }
+        "status": "created",
+    }
+    thinking = str(payload.get("thinking") or "standard").strip().lower()
+    task["thinking"] = thinking if thinking in ("auto", "low", "standard", "high") else "auto"
+    if flow["engine"] == "direct":
+        task["direct_provider_id"] = _text(payload.get("direct_provider_id"),
+                                            "direct_provider_id")[:80]
+        task["direct_model"] = _text(payload.get("direct_model"), "direct_model")[:160]
+        if task["direct_model"] and not task["direct_provider_id"]:
+            raise ValueError("指定对话模型时必须同时指定厂商")
     # 代码版本：仅当引用合法才固化（流水线执行前据此检出任务分支）
     from . import gitmod
     git_rev = _text(payload.get("git_rev"), "git_rev")
@@ -133,8 +141,8 @@ def create_task(payload):
         task["git_rev"] = git_rev
     if flow["engine"] == "code":
         task["verify_command"] = _text(payload.get("verify_command"), "verify_command")
-    elif flow["engine"] == "direct":
-        pass  # 直连任务：无验证命令也无评审参数，目标+附件即全部输入
+    elif flow["engine"] == "direct":
+        pass  # 直连任务：无验证命令也无评审参数，目标+附件即全部输入
     else:
         ms = _text(payload.get("manuscript") or flow.get("manuscript") or "manuscript.md",
                    "manuscript")
@@ -478,7 +486,7 @@ def load_all():
 
 # ---------------------------------------------------------------- 运行（含管理操作）
 
-def create_run(kind, title, task_id=None, entry_id=None, op=None):
+def create_run(kind, title, task_id=None, entry_id=None, op=None):
     run = {
         "id": _new_id("r" if kind == "orchestration" else "m"),
         "kind": kind,  # orchestration | mgmt
@@ -488,8 +496,21 @@ def create_run(kind, title, task_id=None, entry_id=None, op=None):
         "created_at": time.strftime("%Y-%m-%d %H:%M:%S"),
         "started_at": None, "ended_at": None,
         "cost_usd": 0.0, "tokens": 0, "error": "",
-        "verdict": None, "summary": "",
-    }
+        "verdict": None, "summary": "",
+    }
+    if kind == "orchestration" and task_id:
+        task = get_task(task_id) or {}
+        try:
+            from . import usage
+            eta = usage.estimate(
+                task_type=task.get("type") or "", mode=task.get("mode") or "auto",
+                thinking=task.get("thinking") or "standard",
+                rounds=task.get("rounds"))
+            run["estimated_duration_s"] = eta.get("estimated_duration_s")
+            run["estimated_p90_s"] = eta.get("p90_duration_s")
+            run["estimate_source"] = eta.get("duration_source")
+        except Exception:
+            pass
     rdir = paths.RUNS_DIR / run["id"]
     (rdir / "steps").mkdir(parents=True, exist_ok=True)
     with LOCK:
@@ -814,12 +835,36 @@ def run_workdir(run_id):
 _SKIP_DIRS = {".git", "node_modules", "__pycache__", ".venv", "venv", ".idea", ".vscode"}
 
 # 构建产物/依赖缓存目录：里面的文件是工具链再生成的，不是任务成品
-_BUILD_DIRS = {
+_BUILD_DIRS = {
     "target", "build", "dist", "out", "bin", "obj",           # 通用构建输出
     "surefire", "failsafe-reports", "test-output", "reports",  # 测试/报告输出
     ".next", ".nuxt", ".output", ".gradle", ".gradle-home",    # 前端/Gradle
     "__MACOSX",
-}
+}
+
+# CLI 自身的历史/评审中间件不属于用户成果。它们通常落在工作目录根部，
+# 只按隐藏目录过滤会漏掉 Aider 的 .aider.* 与流程生成的 *_review.json。
+_PROCESS_ARTIFACT_NAMES = {
+    ".aider.chat.history.md", ".aider.input.history", ".aider.input.history.md",
+    ".aider.tags.cache.v4", ".aider.tags.cache.v3", ".aider.conf.yml",
+}
+_PROCESS_ARTIFACT_SUFFIXES = ("_review.json", ".review.json")
+_PROCESS_ARTIFACT_PREFIXES = ("tutti_prompt_", "_tutti_prompt_")
+
+
+def _is_process_artifact(rel_name):
+    """判断工作目录文件是否为 CLI/评审过程产物，而非可交付成果。"""
+    name = str(rel_name or "").replace("\\", "/")
+    base = name.rsplit("/", 1)[-1].lower()
+    if base in _PROCESS_ARTIFACT_NAMES:
+        return True
+    if base.startswith(".") and base.startswith(".aider"):
+        return True
+    if base.endswith(_PROCESS_ARTIFACT_SUFFIXES):
+        return True
+    if base.startswith(_PROCESS_ARTIFACT_PREFIXES):
+        return True
+    return False
 
 
 def task_first_start(task_id, fallback=""):
@@ -880,7 +925,10 @@ def run_artifacts(run_id, limit=200):
                 continue
             if st.st_mtime < t0:
                 continue
-            files.append({"name": str(p.relative_to(root)).replace("\\", "/"),
+            rel_name = str(p.relative_to(root)).replace("\\", "/")
+            if _is_process_artifact(rel_name):
+                continue
+            files.append({"name": rel_name,
                           "size": st.st_size, "mtime": int(st.st_mtime)})
             if len(files) >= 800:  # 防超大目录拖垮接口；截断后再排序取最新
                 break

package/app/core/task_compile.py

@@ -69,6 +69,9 @@ def compile_task(task):
         "dimension": dimension,
         "difficulty": difficulty,
         "difficulty_reason": difficulty_reason,
+        "thinking": (str(raw.get("thinking") or "standard").lower()
+                     if str(raw.get("thinking") or "standard").lower()
+                     in ("auto", "low", "standard", "high") else "auto"),
         "capabilities": _capabilities(raw, dimension, engine),
         "deliverable": deliverable,
         "quality_dimensions": rubric,
@@ -97,26 +100,38 @@ def code_workflow(task, difficulty, plan=None, mode="auto", planned=True):
     rec = (plan or {}).get("workflow") if isinstance(plan, Mapping) else None
     rec = rec if isinstance(rec, Mapping) else {}
     has_verify = bool(str(task.get("verify_command") or "").strip())
-    easy_auto = mode == "auto" and difficulty == "easy"
+    risk_text = " ".join(str(task.get(k) or "") for k in ("title", "goal", "context")).lower()
+    high_risk = bool(any(k in risk_text for k in (
+        "安全", "权限", "鉴权", "认证", "加密", "密钥", "注入", "迁移", "数据库",
+        "并发", "竞态", "支付", "架构", "公共接口", "public api", "公共 api",
+        "breaking change", "security", "permission", "auth", "migration",
+        "concurrency", "architecture")))
+    fast_mode = mode == "fast"
+    expert_mode = mode == "expert"
+    easy_auto = (mode == "auto" and difficulty == "easy") or fast_mode
 
     review_required = True
     max_repairs = 2
     allow_switch = True
     reason = "复杂或手动任务使用完整质量门禁"
     if easy_auto:
-        review_required = not has_verify
+        review_required = high_risk or not has_verify
         max_repairs = 1
         allow_switch = False
         reason = ("低风险任务以确定性验证代替模型评审"
                   if has_verify else "低风险任务无验证命令，保留一次模型评审")
         if isinstance(rec.get("review_required"), bool):
-            review_required = rec["review_required"] or not has_verify
+            review_required = high_risk or rec["review_required"] or not has_verify
         try:
             if "max_repair_rounds" in rec:
-                max_repairs = max(0, min(1, int(rec["max_repair_rounds"])))
+                max_repairs = max(1 if not has_verify else 0,
+                                  min(1, int(rec["max_repair_rounds"])))
         except (TypeError, ValueError):
             pass
-    elif mode == "auto" and difficulty == "hard":
+    elif expert_mode or (mode == "auto" and difficulty == "hard"):
+        review_required = True
+        max_repairs = 2
+        allow_switch = True
         try:
             if "max_repair_rounds" in rec:
                 max_repairs = max(1, min(2, int(rec["max_repair_rounds"])))
@@ -148,6 +163,13 @@ def content_workflow(task, difficulty, plan=None, mode="auto"):
     light_types = {"email", "weekly_report", "translation"}
     deep_types = {"novel", "research", "tech_proposal"}
 
+    if mode == "fast":
+        return {"outline": False, "reviewers": 1, "review_rounds": 1,
+                "reason": "快速模式省略独立大纲，仅保留一次快速评审"}
+    if mode == "expert":
+        return {"outline": True, "reviewers": 2,
+                "review_rounds": min(requested_rounds, 3),
+                "reason": "专家模式启用完整大纲、多评审与修订门禁"}
     if mode != "auto":
         return {"outline": True, "reviewers": 0,
                 "review_rounds": requested_rounds,

package/app/core/usage.py

@@ -655,11 +655,19 @@ def summary(days=30, recent_limit=30):
     }
 
 
-def estimate(task_type="", days=90):
-    """同类任务开跑前成本预估（借鉴 omnigent 的 pre-run estimate；数据源就是本台账）。
-
-    同一 run 的多条步骤记录加总为一个样本，优先用成功 run，给中位数/平均/P90。
-    task_type 为空=全类型。无样本时 samples=0，前端不展示。"""
+_DURATION_BASELINES = {
+    "direct": 90, "rank_scan": 240, "email": 180, "weekly_report": 240,
+    "translation": 240, "speech": 360, "video_script": 360, "article": 480,
+    "doc": 480, "resume": 420, "code": 600, "tech_proposal": 720,
+    "research": 900, "novel": 720, "serial_novel": 2400,
+}
+
+
+def estimate(task_type="", days=90, mode="auto", thinking="standard", rounds=None):
+    """同类任务开跑前成本与耗时预估（数据源为本地用量台账）。
+
+    同一 run 的多条步骤记录加总为一个样本，优先用成功 run，给中位数/平均/P90。
+    无历史样本时使用流程级保守基线；模式与思考程度只做透明倍率修正。"""
     span = max(1, min(3650, int(days or 90)))
     with LOCK:
         records = _iter_records(span)
@@ -671,24 +679,53 @@ def estimate(task_type="", days=90):
         rid = str(r.get("run_id") or "")
         if not rid:
             continue
-        g = runs.setdefault(rid, {"tokens": 0, "cost": 0.0, "ok": False})
-        g["tokens"] += _num(r, "total")
-        g["cost"] += _parse_float(r.get("cost_usd"))
+        g = runs.setdefault(rid, {"tokens": 0, "cost": 0.0,
+                                  "duration": 0.0, "ok": False})
+        g["tokens"] += _num(r, "total")
+        g["cost"] += _parse_float(r.get("cost_usd"))
+        g["duration"] += max(0.0, _parse_float(r.get("duration_s")))
         if r.get("ok"):
             g["ok"] = True
     ok_runs = [g for g in runs.values() if g["ok"]]
     basis = ok_runs or list(runs.values())
-    if not basis:
-        return {"task_type": task_type or "", "days": span, "samples": 0}
+    mode_factor = {"fast": 0.60, "auto": 1.0, "expert": 1.65,
+                   "manual": 1.0}.get(str(mode or "auto"), 1.0)
+    thinking_factor = {"low": 0.78, "standard": 1.0, "high": 1.45,
+                       "auto": 1.0}.get(str(thinking or "standard"), 1.0)
+    factor = mode_factor * thinking_factor
+    try:
+        if rounds is not None and int(rounds) > 2:
+            factor *= 1.0 + min(3, int(rounds) - 2) * 0.18
+    except (TypeError, ValueError):
+        pass
+    if not basis:
+        baseline = _DURATION_BASELINES.get(task_type, 480)
+        median_s = max(30, int(baseline * factor))
+        return {"task_type": task_type or "", "days": span, "samples": 0,
+                "estimated_duration_s": median_s,
+                "p90_duration_s": max(median_s + 30, int(median_s * 1.7)),
+                "duration_source": "baseline"}
     toks = sorted(g["tokens"] for g in basis)
-    costs = sorted(g["cost"] for g in basis)
+    costs = sorted(g["cost"] for g in basis)
+    durations = sorted(g["duration"] for g in basis if g["duration"] > 0)
     n = len(toks)
     mid = n // 2
     med = toks[mid] if n % 2 else (toks[mid - 1] + toks[mid]) / 2.0
     med_c = costs[mid] if n % 2 else (costs[mid - 1] + costs[mid]) / 2.0
     import datetime
-    import math
-    return {
+    import math
+    if durations:
+        dn = len(durations)
+        dmid = dn // 2
+        dmed = (durations[dmid] if dn % 2
+                else (durations[dmid - 1] + durations[dmid]) / 2.0)
+        dp90 = durations[max(0, min(dn - 1, math.ceil(0.9 * dn) - 1))]
+        duration_source = "history"
+    else:
+        dmed = _DURATION_BASELINES.get(task_type, 480)
+        dp90 = dmed * 1.7
+        duration_source = "baseline"
+    return {
         "task_type": task_type or "",
         "days": span,
         "samples": n,
@@ -697,6 +734,10 @@ def estimate(task_type="", days=90):
         "median_tokens": int(med),
         "p90_tokens": toks[max(0, min(n - 1, math.ceil(0.9 * n) - 1))],
         "avg_cost_usd": round(sum(costs) / n, 4),
-        "median_cost_usd": round(med_c, 4),
+        "median_cost_usd": round(med_c, 4),
+        "estimated_duration_s": max(30, int(dmed * factor)),
+        "p90_duration_s": max(60, int(dp90 * factor)),
+        "duration_samples": len(durations),
+        "duration_source": duration_source,
         "since": (datetime.date.today() - datetime.timedelta(days=span - 1)).isoformat(),
     }

package/app/core/wxdigest.py

@@ -20,6 +20,7 @@ import json
 import logging
 import os
 import re
+import subprocess
 import threading
 import time
 from datetime import datetime, timedelta
@@ -708,3 +709,142 @@ def _test_reset():
         _STATE["groups_cache"] = []
         _STATE["last_scan"] = _STATE["next_scan"] = _STATE["last_error"] = ""
         globals()["_LOADED"] = True
+
+
+# ---- 64 位 Python 自动扫描 + wechatauto-replica 一键安装（2026-09-21 用户诉求：
+#      别让用户手填解释器路径、别让用户自己开 conda 装依赖）----
+
+_PY_SCAN = {"scanning": False, "done": True, "results": []}
+_PY_INSTALL = {"running": False, "ok": None, "python": "", "log": []}
+_REPLICA_PKG = "wechatauto-replica"
+
+
+def _candidate_pythons():
+    """收集本机候选解释器路径（去重、存在性过滤）。只列不判，位数/依赖交给探测。"""
+    import glob
+    cands = []
+
+    def _add(p):
+        p = str(p).strip().strip('"')
+        if p and os.path.isfile(p) and p.lower().endswith((".exe",)) is not False:
+            if p not in cands and "python" in os.path.basename(p).lower():
+                cands.append(p)
+
+    if os.name == "nt":
+        home = os.environ.get("USERPROFILE") or ""
+        patterns = [
+            os.path.join(home, "anaconda3", "envs", "*", "python.exe"),
+            os.path.join(home, "miniconda3", "envs", "*", "python.exe"),
+            os.path.join(home, ".conda", "envs", "*", "python.exe"),
+            os.path.join(os.environ.get("LOCALAPPDATA") or "", "Programs",
+                         "Python", "*", "python.exe"),
+            r"C:\Python*\python.exe",
+            os.path.join(home, "AppData", "Local", "anaconda3", "python.exe"),
+            os.path.join(home, "anaconda3", "python.exe"),
+            os.path.join(home, "miniconda3", "python.exe"),
+        ]
+        for pat in patterns:
+            for p in glob.glob(pat):
+                _add(p)
+        try:
+            r = subprocess.run(["cmd", "/c", "where", "python"],
+                               capture_output=True, timeout=15)
+            for ln in r.stdout.decode("utf-8", "replace").splitlines():
+                _add(ln)
+        except Exception:
+            pass
+    else:
+        import glob as _g
+        for pat in ("/usr/bin/python3*", "/usr/local/bin/python3*",
+                    os.path.expanduser("~/.conda/envs/*/bin/python3"),
+                    os.path.expanduser("~/miniconda3/envs/*/bin/python3"),
+                    os.path.expanduser("~/anaconda3/envs/*/bin/python3")):
+            for p in _g.glob(pat):
+                _add(p)
+    return cands[:24]
+
+
+def _probe_python(py):
+    """探测解释器：返回 {path, version, bits} 或 None（跑不动/不是 python）。"""
+    try:
+        r = subprocess.run(
+            [py, "-c", "import sys,struct;print('%d.%d'%sys.version_info[:2],"
+                       "struct.calcsize('P')*8)"],
+            capture_output=True, timeout=20,
+            creationflags=CREATE_NO_WINDOW if os.name == "nt" else 0)
+        out = (r.stdout or b"").decode("utf-8", "replace").strip()
+        ver, bits = out.split()
+        return {"path": py, "version": ver, "bits": int(bits)}
+    except Exception:
+        return None
+
+
+def _has_replica(py):
+    """该环境是否已装 wechatauto-replica（pip show 探测，失败视为未装）。"""
+    try:
+        r = subprocess.run([py, "-m", "pip", "show", _REPLICA_PKG],
+                           capture_output=True, timeout=60,
+                           creationflags=CREATE_NO_WINDOW if os.name == "nt" else 0)
+        return r.returncode == 0
+    except Exception:
+        return False
+
+
+def scan_pythons():
+    """启动后台扫描（幂等：扫描中重复调用直接忽略）。返回当前状态。"""
+    if _PY_SCAN["scanning"]:
+        return dict(_PY_SCAN)
+
+    def _run():
+        _PY_SCAN.update(scanning=True, done=False, results=[])
+        found = []
+        for py in _candidate_pythons():
+            info = _probe_python(py)
+            if not info:
+                continue
+            info["has_replica"] = _has_replica(py)
+            found.append(info)
+        # 排序：64 位优先 → 已装 replica 优先 → 版本新优先 → 路径短优先
+        found.sort(key=lambda x: (x["bits"] < 64, not x["has_replica"],
+                                  x["version"], len(x["path"])), reverse=False)
+        found.sort(key=lambda x: (x["bits"] >= 64, x["has_replica"]))
+        _PY_SCAN.update(scanning=False, done=True, results=found)
+
+    threading.Thread(target=_run, name="wx-py-scan", daemon=True).start()
+    return dict(_PY_SCAN)
+
+
+def pythons_status():
+    return dict(_PY_SCAN)
+
+
+def install_replica(py):
+    """一键安装 wechatauto-replica 到指定解释器（后台 pip，状态可轮询）。"""
+    py = str(py or "").strip()
+    if not py or not os.path.isfile(py):
+        return {"ok": False, "error": "解释器路径无效"}
+    if _PY_INSTALL["running"]:
+        return {"ok": False, "error": "已有安装在跑，请等它结束"}
+
+    def _run():
+        _PY_INSTALL.update(running=True, ok=None, python=py, log=[])
+        try:
+            r = subprocess.run(
+                [py, "-m", "pip", "install", _REPLICA_PKG],
+                capture_output=True, timeout=900,
+                creationflags=CREATE_NO_WINDOW if os.name == "nt" else 0)
+            ok = r.returncode == 0
+            tail = ((r.stderr or b"").decode("utf-8", "replace")
+                    or (r.stdout or b"").decode("utf-8", "replace"))[-1500:]
+        except Exception as e:
+            ok, tail = False, str(e)[:500]
+        _PY_INSTALL.update(running=False, ok=ok, log=tail.strip().splitlines()[-25:])
+        if ok:
+            scan_pythons()   # 装完自动重扫，has_replica 标记即时生效
+
+    threading.Thread(target=_run, name="wx-replica-install", daemon=True).start()
+    return {"ok": True}
+
+
+def install_status():
+    return dict(_PY_INSTALL)

package/app/main.py

@@ -284,7 +284,12 @@ class Handler(BaseHTTPRequestHandler):
                     edays = max(1, min(3650, int((q.get("days") or ["90"])[0])))
                 except ValueError:
                     edays = 90
-                return self._json(200, usage.estimate(task_type=ttype, days=edays))
+                mode = (q.get("mode") or ["auto"])[0][:16]
+                thinking = (q.get("thinking") or ["standard"])[0][:16]
+                rounds = (q.get("rounds") or [None])[0]
+                return self._json(200, usage.estimate(
+                    task_type=ttype, days=edays, mode=mode,
+                    thinking=thinking, rounds=rounds))
             if path == "/api/dispatch/replay":
                 from core import dispatch_log
                 q = parse_qs(urlparse(self.path).query)
@@ -313,6 +318,13 @@ class Handler(BaseHTTPRequestHandler):
                 # 偏好记忆：上次创建任务的类型/参数（新建表单预填用）
                 from core import prefs
                 return self._json(200, {"prefs": prefs.load()})
+            if path == "/api/wxdigest/pythons":
+                # 64 位 Python 候选（蜜蜂坞微信直连配置）：扫描后台跑，此端点轮询
+                from core import wxdigest
+                return self._json(200, wxdigest.pythons_status())
+            if path == "/api/wxdigest/replica/status":
+                from core import wxdigest
+                return self._json(200, wxdigest.install_status())
             if path == "/api/ports":
                 # 端口占用诊断（借鉴 leftopen）：谁在听、PID/进程/项目归属、
                 # 是否仅本机。?port=N 只看单端口。只读，不碰任何进程。
@@ -1080,6 +1092,15 @@ class Handler(BaseHTTPRequestHandler):
             from core import wxdigest
             res = wxdigest.scan_now()    # 含模型调用，同步做（ThreadingHTTPServer 不堵别的请求）
             return self._json(200, dict(res, ok=bool(res.get("ok"))))
+        if path == "/api/wxdigest/pythons/scan":
+            # 64 位 Python 自动扫描（后台线程，GET /api/wxdigest/pythons 轮询）
+            from core import wxdigest
+            return self._json(200, wxdigest.scan_pythons())
+        if path == "/api/wxdigest/replica/install":
+            # 一键安装 wechatauto-replica 到指定解释器（后台 pip，状态可轮询）
+            from core import wxdigest
+            res = wxdigest.install_replica(self._body().get("python"))
+            return self._json(200 if res.get("ok") else 400, res)
         if path == "/api/wxdigest/seen":
             from core import wxdigest
             return self._json(200, {"ok": True, "view": wxdigest.seen_clear()})