codebee 0.1.103 → 0.1.105

package/app/core/artifacts.py

@@ -1,148 +1,148 @@
-"""工作目录成品扫描：剪枝遍历 + 短 TTL 缓存 + 在飞合并。
-
-历史实现用 Path.rglob("*") 全量展开再逐文件 is_file()/stat() 过滤，几万文件的
-工作目录单次要 1.6~4 秒；而详情页/侧栏在任务运行中是轮询调用——每次轮询都是
-一次全仓扫描，UI 整体被拖卡（2026-09-24 详情页卡顿案）。这里改为 os.walk
-剪枝（跳过类目录整个不进入），并给重复轮询加 (workdir, t0, 任务状态) 键的短 TTL 缓存
-与在飞合并：并发同键只扫一次，后到者等结果。
-"""
-from __future__ import annotations
-
-import os
-import threading
-import time
-
-# 过滤语义与历史 rglob 版逐条对齐：
-# - SKIP_DIRS：任意路径段（含文件名本身）命中即剔除；
-# - BUILD_DIRS：仅祖先目录命中即剔除（文件名叫 dist 不受影响）；
-# - 点开头：仅祖先目录算「隐藏」（根下的 .gitignore 这类隐藏文件仍是候选）。
-SKIP_DIRS = {".git", "node_modules", "__pycache__", ".venv", "venv", ".idea", ".vscode"}
-
-# 构建产物/依赖缓存目录：里面的文件是工具链再生成的，不是任务成品
-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_")
-
-SCAN_CAP = 800             # 防超大目录拖垮接口；截断后再排序取最新
-CACHE_TTL_RUNNING = 2.0    # 任务在跑：轮询热，新鲜期要短
-CACHE_TTL_IDLE = 10.0      # 终态任务：详情反复开关/检查器同刷，可稍长
-_CACHE_KEEP = 128          # 缓存条目上限（按时间淘汰最旧）
-
-_now = time.monotonic      # 模块级别名，测试可替换时钟
-
-_LOCK = threading.Lock()
-_CACHE = {}     # (root, t0, running) -> (时间戳, files)；files 恒为全量候选
-_INFLIGHT = {}  # (root, t0, running) -> Lock；同键并发只跑一次扫描
-
-
-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 _walk_files(root, t0):
-    """剪枝遍历：跳过类目录整个不进入；返回 mtime>=t0 的候选（无序）。"""
-    files = []
-    for dp, dirnames, filenames in os.walk(root):
-        dirnames[:] = [d for d in dirnames
-                       if d not in SKIP_DIRS and d not in BUILD_DIRS
-                       and not d.startswith(".")]
-        done = False
-        for name in filenames:
-            if name in SKIP_DIRS:   # 历史语义：文件名本身命中也剔除
-                continue
-            try:
-                st = os.stat(os.path.join(dp, name))
-            except OSError:
-                continue
-            if st.st_mtime < t0:
-                continue
-            rel_dir = os.path.relpath(dp, root)
-            rel = name if rel_dir == "." else \
-                rel_dir.replace("\\", "/") + "/" + name
-            if _is_process_artifact(rel):
-                continue
-            files.append({"name": rel,
-                          "size": st.st_size, "mtime": int(st.st_mtime)})
-            if len(files) >= SCAN_CAP:
-                done = True
-                break
-        if done:
-            break
-    return files
-
-
-def _cache_get(key, ttl):
-    with _LOCK:
-        ent = _CACHE.get(key)
-        if ent and _now() - ent[0] < ttl:
-            return ent[1]
-    return None
-
-
-def _cache_put(key, files):
-    with _LOCK:
-        _CACHE[key] = (_now(), files)
-        while len(_CACHE) > _CACHE_KEEP:
-            _CACHE.pop(min(_CACHE, key=lambda k: _CACHE[k][0]), None)
-
-
-def _inflight_lock(key):
-    with _LOCK:
-        lock = _INFLIGHT.get(key)
-        if lock is None:
-            lock = _INFLIGHT[key] = threading.Lock()
-        return lock
-
-
-def scan(root, t0, limit=200, running=False, cache=False):
-    """扫工作目录成品，按 mtime 新→旧取前 limit 条，返回文件字典列表。
-
-    cache=True 时同键 (root, t0, running) 在 TTL 内直接复用上次结果，运行中
-    任务用短 TTL；无论是否缓存，同键在飞扫描都会合并——轮询方只会等一次扫描。
-    """
-    # 运行态和终态必须分开缓存：任务刚结束时不能沿用运行中缓存里的旧
-    # 文件列表，否则终态较长 TTL 会把最后写入的产物遮住。
-    key = (str(root), t0, bool(running))
-    ttl = CACHE_TTL_RUNNING if running else CACHE_TTL_IDLE
-    if cache:
-        hit = _cache_get(key, ttl)
-        if hit is not None:
-            return hit[:limit]
-    klock = _inflight_lock(key)
-    try:
-        with klock:
-            if cache:   # 排到锁时他人可能已扫完入缓存
-                hit = _cache_get(key, ttl)
-                if hit is not None:
-                    return hit[:limit]
-            files = sorted(_walk_files(root, t0), key=lambda f: -f["mtime"])
-            if cache:
-                _cache_put(key, files)
-    finally:
-        with _LOCK:
-            if _INFLIGHT.get(key) is klock:
-                _INFLIGHT.pop(key, None)
-    return files[:limit]
+"""工作目录成品扫描：剪枝遍历 + 短 TTL 缓存 + 在飞合并。
+
+历史实现用 Path.rglob("*") 全量展开再逐文件 is_file()/stat() 过滤，几万文件的
+工作目录单次要 1.6~4 秒；而详情页/侧栏在任务运行中是轮询调用——每次轮询都是
+一次全仓扫描，UI 整体被拖卡（2026-09-24 详情页卡顿案）。这里改为 os.walk
+剪枝（跳过类目录整个不进入），并给重复轮询加 (workdir, t0, 任务状态) 键的短 TTL 缓存
+与在飞合并：并发同键只扫一次，后到者等结果。
+"""
+from __future__ import annotations
+
+import os
+import threading
+import time
+
+# 过滤语义与历史 rglob 版逐条对齐：
+# - SKIP_DIRS：任意路径段（含文件名本身）命中即剔除；
+# - BUILD_DIRS：仅祖先目录命中即剔除（文件名叫 dist 不受影响）；
+# - 点开头：仅祖先目录算「隐藏」（根下的 .gitignore 这类隐藏文件仍是候选）。
+SKIP_DIRS = {".git", "node_modules", "__pycache__", ".venv", "venv", ".idea", ".vscode"}
+
+# 构建产物/依赖缓存目录：里面的文件是工具链再生成的，不是任务成品
+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_")
+
+SCAN_CAP = 800             # 防超大目录拖垮接口；截断后再排序取最新
+CACHE_TTL_RUNNING = 2.0    # 任务在跑：轮询热，新鲜期要短
+CACHE_TTL_IDLE = 10.0      # 终态任务：详情反复开关/检查器同刷，可稍长
+_CACHE_KEEP = 128          # 缓存条目上限（按时间淘汰最旧）
+
+_now = time.monotonic      # 模块级别名，测试可替换时钟
+
+_LOCK = threading.Lock()
+_CACHE = {}     # (root, t0, running) -> (时间戳, files)；files 恒为全量候选
+_INFLIGHT = {}  # (root, t0, running) -> Lock；同键并发只跑一次扫描
+
+
+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 _walk_files(root, t0):
+    """剪枝遍历：跳过类目录整个不进入；返回 mtime>=t0 的候选（无序）。"""
+    files = []
+    for dp, dirnames, filenames in os.walk(root):
+        dirnames[:] = [d for d in dirnames
+                       if d not in SKIP_DIRS and d not in BUILD_DIRS
+                       and not d.startswith(".")]
+        done = False
+        for name in filenames:
+            if name in SKIP_DIRS:   # 历史语义：文件名本身命中也剔除
+                continue
+            try:
+                st = os.stat(os.path.join(dp, name))
+            except OSError:
+                continue
+            if st.st_mtime < t0:
+                continue
+            rel_dir = os.path.relpath(dp, root)
+            rel = name if rel_dir == "." else \
+                rel_dir.replace("\\", "/") + "/" + name
+            if _is_process_artifact(rel):
+                continue
+            files.append({"name": rel,
+                          "size": st.st_size, "mtime": int(st.st_mtime)})
+            if len(files) >= SCAN_CAP:
+                done = True
+                break
+        if done:
+            break
+    return files
+
+
+def _cache_get(key, ttl):
+    with _LOCK:
+        ent = _CACHE.get(key)
+        if ent and _now() - ent[0] < ttl:
+            return ent[1]
+    return None
+
+
+def _cache_put(key, files):
+    with _LOCK:
+        _CACHE[key] = (_now(), files)
+        while len(_CACHE) > _CACHE_KEEP:
+            _CACHE.pop(min(_CACHE, key=lambda k: _CACHE[k][0]), None)
+
+
+def _inflight_lock(key):
+    with _LOCK:
+        lock = _INFLIGHT.get(key)
+        if lock is None:
+            lock = _INFLIGHT[key] = threading.Lock()
+        return lock
+
+
+def scan(root, t0, limit=200, running=False, cache=False):
+    """扫工作目录成品，按 mtime 新→旧取前 limit 条，返回文件字典列表。
+
+    cache=True 时同键 (root, t0, running) 在 TTL 内直接复用上次结果，运行中
+    任务用短 TTL；无论是否缓存，同键在飞扫描都会合并——轮询方只会等一次扫描。
+    """
+    # 运行态和终态必须分开缓存：任务刚结束时不能沿用运行中缓存里的旧
+    # 文件列表，否则终态较长 TTL 会把最后写入的产物遮住。
+    key = (str(root), t0, bool(running))
+    ttl = CACHE_TTL_RUNNING if running else CACHE_TTL_IDLE
+    if cache:
+        hit = _cache_get(key, ttl)
+        if hit is not None:
+            return hit[:limit]
+    klock = _inflight_lock(key)
+    try:
+        with klock:
+            if cache:   # 排到锁时他人可能已扫完入缓存
+                hit = _cache_get(key, ttl)
+                if hit is not None:
+                    return hit[:limit]
+            files = sorted(_walk_files(root, t0), key=lambda f: -f["mtime"])
+            if cache:
+                _cache_put(key, files)
+    finally:
+        with _LOCK:
+            if _INFLIGHT.get(key) is klock:
+                _INFLIGHT.pop(key, None)
+    return files[:limit]

package/app/core/assets.py

@@ -1,110 +1,110 @@
-# -*- coding: utf-8 -*-
-"""Content-addressed asset index.
-
-The index owns references and revisions, not file contents.  Files stay in the
-task workspace; projects/runs can safely point to ``asset_id + revision_id``
-without making a second copy of a document.
-"""
-from __future__ import annotations
-
-import json
-import hashlib
-import mimetypes
-import threading
-import time
-from pathlib import Path
-
-from . import paths
-
-LOCK = threading.RLock()
-
-
-def _path():
-    return paths.DATA_DIR / "assets.json"
-
-
-def _load():
-    try:
-        value = json.loads(_path().read_text(encoding="utf-8"))
-        return value if isinstance(value, dict) else {"assets": {}}
-    except (OSError, ValueError):
-        return {"assets": {}}
-
-
-def _save(data):
-    path = _path()
-    path.parent.mkdir(parents=True, exist_ok=True)
-    tmp = path.with_suffix(".tmp")
-    tmp.write_text(json.dumps(data, ensure_ascii=False, indent=2), encoding="utf-8")
-    tmp.replace(path)
-
-
-def register(workdir, relative_path, *, owner_type="", owner_id="", name="", mime=""):
-    """Index a workspace file and return its reference, or ``None`` if absent."""
-    root = Path(str(workdir or "")).resolve()
-    rel = str(relative_path or "").replace("\\", "/").lstrip("/")
-    if not rel or rel.startswith("../") or "/../" in rel:
-        return None
-    fp = (root / rel).resolve()
-    try:
-        if root not in fp.parents or not fp.is_file():
-            return None
-        digest_builder = hashlib.sha256()
-        size = 0
-        with fp.open("rb") as handle:
-            for chunk in iter(lambda: handle.read(1024 * 1024), b""):
-                digest_builder.update(chunk)
-                size += len(chunk)
-        digest = digest_builder.hexdigest()
-        asset_id = "asset-" + digest[:16]
-        revision_id = "assetrev-" + digest[:16]
-        ref = {"asset_id": asset_id, "revision_id": revision_id,
-               "content_sha256": digest, "path": rel,
-               "name": str(name or fp.name)[:120],
-               "mime": str(mime or mimetypes.guess_type(fp.name)[0]
-                           or "application/octet-stream")[:120],
-               "size": size, "updated_at": time.time()}
-        with LOCK:
-            data = _load()
-            assets = data.setdefault("assets", {})
-            row = assets.setdefault(asset_id, ref)
-            # The content hash identifies one immutable revision.  Keep the
-            # first source path/name as canonical metadata so registering the
-            # same bytes from another workspace cannot rewrite an existing
-            # reference's path semantics.
-            row.update({k: ref[k] for k in
-                        ("revision_id", "content_sha256", "size", "updated_at")})
-            for key in ("path", "name", "mime"):
-                if not row.get(key):
-                    row[key] = ref[key]
-            owners = row.setdefault("owners", [])
-            owner = {"type": str(owner_type or "")[:40], "id": str(owner_id or "")[:100]}
-            if owner["id"] and owner not in owners:
-                owners.append(owner)
-                row["owners"] = owners[-50:]
-            _save(data)
-            return dict(row)
-    except (OSError, ValueError):
-        return None
-
-
-def get(asset_id, revision_id=""):
-    with LOCK:
-        row = (_load().get("assets") or {}).get(str(asset_id or ""))
-    if not isinstance(row, dict):
-        return None
-    if revision_id and str(row.get("revision_id") or "") != str(revision_id):
-        return None
-    return dict(row)
-
-
-def list_assets(*, owner_type="", owner_id="", limit=200):
-    with LOCK:
-        rows = list((_load().get("assets") or {}).values())
-    if owner_type or owner_id:
-        rows = [row for row in rows if any(
-            (not owner_type or owner_type == item.get("type")) and
-            (not owner_id or owner_id == item.get("id"))
-            for item in (row.get("owners") or []))]
-    rows.sort(key=lambda row: float(row.get("updated_at") or 0), reverse=True)
-    return [dict(row) for row in rows[:max(1, min(1000, int(limit or 200)))]]
+# -*- coding: utf-8 -*-
+"""Content-addressed asset index.
+
+The index owns references and revisions, not file contents.  Files stay in the
+task workspace; projects/runs can safely point to ``asset_id + revision_id``
+without making a second copy of a document.
+"""
+from __future__ import annotations
+
+import json
+import hashlib
+import mimetypes
+import threading
+import time
+from pathlib import Path
+
+from . import paths
+
+LOCK = threading.RLock()
+
+
+def _path():
+    return paths.DATA_DIR / "assets.json"
+
+
+def _load():
+    try:
+        value = json.loads(_path().read_text(encoding="utf-8"))
+        return value if isinstance(value, dict) else {"assets": {}}
+    except (OSError, ValueError):
+        return {"assets": {}}
+
+
+def _save(data):
+    path = _path()
+    path.parent.mkdir(parents=True, exist_ok=True)
+    tmp = path.with_suffix(".tmp")
+    tmp.write_text(json.dumps(data, ensure_ascii=False, indent=2), encoding="utf-8")
+    tmp.replace(path)
+
+
+def register(workdir, relative_path, *, owner_type="", owner_id="", name="", mime=""):
+    """Index a workspace file and return its reference, or ``None`` if absent."""
+    root = Path(str(workdir or "")).resolve()
+    rel = str(relative_path or "").replace("\\", "/").lstrip("/")
+    if not rel or rel.startswith("../") or "/../" in rel:
+        return None
+    fp = (root / rel).resolve()
+    try:
+        if root not in fp.parents or not fp.is_file():
+            return None
+        digest_builder = hashlib.sha256()
+        size = 0
+        with fp.open("rb") as handle:
+            for chunk in iter(lambda: handle.read(1024 * 1024), b""):
+                digest_builder.update(chunk)
+                size += len(chunk)
+        digest = digest_builder.hexdigest()
+        asset_id = "asset-" + digest[:16]
+        revision_id = "assetrev-" + digest[:16]
+        ref = {"asset_id": asset_id, "revision_id": revision_id,
+               "content_sha256": digest, "path": rel,
+               "name": str(name or fp.name)[:120],
+               "mime": str(mime or mimetypes.guess_type(fp.name)[0]
+                           or "application/octet-stream")[:120],
+               "size": size, "updated_at": time.time()}
+        with LOCK:
+            data = _load()
+            assets = data.setdefault("assets", {})
+            row = assets.setdefault(asset_id, ref)
+            # The content hash identifies one immutable revision.  Keep the
+            # first source path/name as canonical metadata so registering the
+            # same bytes from another workspace cannot rewrite an existing
+            # reference's path semantics.
+            row.update({k: ref[k] for k in
+                        ("revision_id", "content_sha256", "size", "updated_at")})
+            for key in ("path", "name", "mime"):
+                if not row.get(key):
+                    row[key] = ref[key]
+            owners = row.setdefault("owners", [])
+            owner = {"type": str(owner_type or "")[:40], "id": str(owner_id or "")[:100]}
+            if owner["id"] and owner not in owners:
+                owners.append(owner)
+                row["owners"] = owners[-50:]
+            _save(data)
+            return dict(row)
+    except (OSError, ValueError):
+        return None
+
+
+def get(asset_id, revision_id=""):
+    with LOCK:
+        row = (_load().get("assets") or {}).get(str(asset_id or ""))
+    if not isinstance(row, dict):
+        return None
+    if revision_id and str(row.get("revision_id") or "") != str(revision_id):
+        return None
+    return dict(row)
+
+
+def list_assets(*, owner_type="", owner_id="", limit=200):
+    with LOCK:
+        rows = list((_load().get("assets") or {}).values())
+    if owner_type or owner_id:
+        rows = [row for row in rows if any(
+            (not owner_type or owner_type == item.get("type")) and
+            (not owner_id or owner_id == item.get("id"))
+            for item in (row.get("owners") or []))]
+    rows.sort(key=lambda row: float(row.get("updated_at") or 0), reverse=True)
+    return [dict(row) for row in rows[:max(1, min(1000, int(limit or 200)))]]