@hupan56/wlkj 2.0.0

package/templates/qoder/scripts/common/search_engine.py

@@ -0,0 +1,205 @@
+# -*- coding: utf-8 -*-
+"""
+search_engine.py - 搜索倒排索引 + mtime 缓存 (性能优化 A2)
+
+把 search_keywords 的 O(n) 全扫描 3267 keys 降到 O(命中数)。
+
+设计:
+    - exact_index: {word_lower: [keyword_keys]} 精确匹配, O(1) 查找
+    - prefix/suffix 索引用 trigram (3-gram) 加速子串匹配
+    - 缓存序列化到 data/index/.inverted-cache.json, 含源 mtime
+    - 只在 keyword-index.json 变化时重建
+
+核心 API:
+    get_inverted_index(repo_root) -> dict   # 带缓存的倒排索引
+    search_keywords_fast(words, inverted, ki) -> {kw: files}  # 快速搜索
+"""
+
+import json
+import os
+import sys
+from typing import Dict, List, Optional, Set, Tuple
+
+_THIS_DIR = os.path.dirname(os.path.abspath(__file__))
+if _THIS_DIR not in sys.path:
+    sys.path.insert(0, _THIS_DIR)
+
+from atomicio import safe_read_json, atomic_write_json
+
+__all__ = [
+    "get_inverted_index",
+    "search_keywords_fast",
+    "build_inverted_index",
+    "MIN_FUZZY_LEN",
+]
+
+MIN_FUZZY_LEN = 4  # 与 search_index.py 保持一致
+
+
+def _trigrams(s: str) -> Set[str]:
+    """生成字符串的所有 3-gram (小写)。短于 3 字符则返回 {字符串本身}。"""
+    s = s.lower()
+    if len(s) < 3:
+        return {s}
+    return {s[i:i+3] for i in range(len(s) - 2)}
+
+
+def build_inverted_index(keyword_index: Dict[str, list]) -> dict:
+    """从 keyword_index 构建倒排索引。
+
+    Returns:
+        {
+            "exact": {word_lower: [keyword_keys]},      # 精确匹配
+            "trigram": {trigram: set(keyword_keys)},    # 3-gram → 含它的 keys
+            "keywords": [所有 keyword_keys 排序]         # 用于回退全扫描
+        }
+    """
+    exact = {}
+    trigram = {}
+    all_keys = sorted(keyword_index.keys())
+
+    for kw in all_keys:
+        kl = kw.lower()
+        # 精确索引
+        exact.setdefault(kl, []).append(kw)
+        # trigram 索引 (用于子串匹配的候选集缩小)
+        for tg in _trigrams(kl):
+            trigram.setdefault(tg, set()).add(kw)
+
+    # set 转 list 便于 JSON 序列化
+    trigram_serializable = {tg: sorted(keys) for tg, keys in trigram.items()}
+
+    return {
+        "exact": exact,
+        "trigram": trigram_serializable,
+        "keywords": all_keys,
+    }
+
+
+def get_inverted_index(repo_root: str) -> Optional[dict]:
+    """获取倒排索引 (带 mtime 缓存)。
+
+    缓存逻辑:
+    - 读 .inverted-cache.json 的 source_mtime
+    - 与 keyword-index.json 当前 mtime 比对
+    - 不一致或缓存缺失则重建 + 持久化
+
+    Returns:
+        倒排索引 dict, 或 None (keyword-index 不存在时)。
+    """
+    index_dir = os.path.join(repo_root, "data", "index")
+    ki_path = os.path.join(index_dir, "keyword-index.json")
+    cache_path = os.path.join(index_dir, ".inverted-cache.json")
+
+    if not os.path.isfile(ki_path):
+        return None
+
+    try:
+        ki_mtime = os.path.getmtime(ki_path)
+    except OSError:
+        return None
+
+    # 尝试读缓存
+    cached = safe_read_json(cache_path, default=None)
+    if cached and cached.get("source_mtime") == ki_mtime:
+        # 缓存命中 (trigram 的 set 反序列化为 list, 搜索时兼容)
+        return cached
+
+    # 缓存失效或缺失, 重建
+    ki = safe_read_json(ki_path, default=None)
+    if not ki:
+        return None
+
+    inverted = build_inverted_index(ki)
+    inverted["source_mtime"] = ki_mtime
+    inverted["built_at"] = os.path.getmtime(ki_path)
+
+    # 持久化 (best-effort, 失败不阻塞搜索)
+    try:
+        atomic_write_json(cache_path, inverted)
+    except Exception:
+        pass
+
+    return inverted
+
+
+def _candidate_keys(word: str, inverted: dict) -> List[str]:
+    """用倒排索引找到候选 keyword keys (缩小扫描集)。
+
+    策略:
+    - 用 trigram 交集找候选 (子串匹配的双方至少共享一个 trigram)
+    - 精确命中必然包含在 trigram 候选里 (相同字符串共享所有 trigram)
+    - 候选为空则回退全部 keys (兜底, 罕见)
+
+    关键: 不能在精确命中后短路 —— query "insurance" 还要匹配
+    "insurancepolicy" 等 (query 是 kw 的子串), 所以必须返回 trigram 候选集。
+    """
+    wl = word.lower()
+    tgs = _trigrams(wl)
+    trigram_index = inverted.get("trigram", {})
+    candidate_sets = []
+    for tg in tgs:
+        keys = trigram_index.get(tg)
+        if keys:
+            candidate_sets.append(set(keys))
+
+    if not candidate_sets:
+        # 词太短无 trigram (如 2 字符), 回退精确 + 全扫描兜底
+        exact = inverted.get("exact", {}).get(wl)
+        if exact:
+            return list(exact)
+        return inverted.get("keywords", [])
+
+    # 取并集: query 含 kw 或 kw 含 query, 至少一个 trigram 重叠
+    candidates = set()
+    for cs in candidate_sets:
+        candidates |= cs
+
+    return sorted(candidates)
+
+
+def search_keywords_fast(
+    words: List[str],
+    inverted: Optional[dict],
+    keyword_index: Dict[str, list],
+) -> Dict[str, list]:
+    """快速关键词搜索 (用倒排索引缩小候选集)。
+
+    Args:
+        words: 查询词列表 (已小写化、已 CN 扩展)。
+        inverted: 倒排索引 (None 则回退到全扫描)。
+        keyword_index: 原始 keyword-index (用于取 files)。
+
+    Returns:
+        {keyword_key: files} 匹配结果。
+    """
+    matches = {}
+
+    if inverted is None:
+        # 回退: 全扫描 (旧逻辑)
+        for word in words:
+            for kw, files in keyword_index.items():
+                if _match(word, kw):
+                    matches[kw] = files
+        return matches
+
+    for word in words:
+        candidates = _candidate_keys(word, inverted)
+        for kw in candidates:
+            files = keyword_index.get(kw)
+            if files and _match(word, kw):
+                matches[kw] = files
+
+    return matches
+
+
+def _match(query_word: str, kw: str) -> bool:
+    """与 search_index._match_keyword 一致的匹配逻辑。"""
+    w, k = query_word.lower(), kw.lower()
+    if w == k:
+        return True
+    if len(k) >= MIN_FUZZY_LEN and k in w:
+        return True
+    if len(w) >= MIN_FUZZY_LEN and w in k:
+        return True
+    return False

package/templates/qoder/scripts/common/task_utils.py

@@ -0,0 +1,342 @@
+#!/usr/bin/env python3
+# -*- coding: utf-8 -*-
+"""
+QODER Pipeline - 任务工具函数
+
+提供:
+- resolve_task_dir: 解析任务目录 (支持名称/相对路径/绝对路径)
+- run_task_hooks: 运行任务生命周期钩子
+- load_task_json: 加载 task.json
+- write_task_json: 写入 task.json
+
+参考: Trellis 的 common/task_utils.py 设计
+"""
+
+from __future__ import annotations
+
+import json
+import os
+import subprocess
+import sys
+from pathlib import Path
+
+from .paths import DIR_TASKS, FILE_TASK_JSON, get_repo_root, get_tasks_dir
+
+# 原子写 (解决半写损坏)
+try:
+    from .atomicio import atomic_write_json
+except ImportError:
+    def atomic_write_json(path, data, indent=2, ensure_ascii=False, sort_keys=True):
+        import json as _j
+        Path(path).write_text(_j.dumps(data, indent=indent, ensure_ascii=ensure_ascii,
+                                        sort_keys=sort_keys) + "\n", encoding="utf-8")
+
+
+# =============================================================================
+# 任务目录解析
+# =============================================================================
+
+def resolve_task_dir(task_input: str, repo_root: Path | None = None) -> Path:
+    """解析任务目录路径。
+
+    支持三种输入:
+    1. 纯名称/全名: "my-task" / "06-10-my-task" -> workspace/tasks/<name>
+    2. 相对路径: "workspace/tasks/06-10-my-task" -> 完整路径
+    3. 绝对路径: 直接使用
+
+    安全变更 (零信任): 不再做模糊子串匹配 (旧版 "a" 可能匹配到他人的
+    "06-10-alpha" 导致误操作)。现在要求精确名或唯一前缀。
+
+    Args:
+        task_input: 任务标识 (名称或路径)。
+        repo_root: 项目根目录, 默认自动检测。
+
+    Returns:
+        任务目录的绝对路径。
+
+    Raises:
+        FileNotFoundError: 找不到任务。
+        ValueError: 名称歧义 (多个候选)。
+    """
+    if repo_root is None:
+        repo_root = get_repo_root()
+
+    input_path = Path(task_input)
+
+    # 已经是绝对路径且存在
+    if input_path.is_absolute() and input_path.is_dir():
+        return input_path.resolve()
+
+    # 相对路径
+    full_from_root = (repo_root / task_input).resolve()
+    if full_from_root.is_dir():
+        return full_from_root
+
+    # 纯名称: 在 tasks 目录下精确匹配
+    tasks_dir = get_tasks_dir(repo_root)
+    direct_match = tasks_dir / task_input
+    if direct_match.is_dir():
+        return direct_match.resolve()
+
+    # 精确匹配失败 —— 查唯一前缀匹配 (不允许歧义)
+    if tasks_dir.is_dir():
+        candidates = [
+            d for d in tasks_dir.iterdir()
+            if d.is_dir() and (
+                d.name == task_input or           # 全名精确
+                d.name.endswith("-" + task_input) or  # "06-10-my-task".endswith("-my-task")
+                d.name.startswith(task_input + "-")   # "06-10".startswith("06-10-...")
+            )
+        ]
+        if len(candidates) == 1:
+            return candidates[0].resolve()
+        if len(candidates) > 1:
+            names = ", ".join(d.name for d in candidates[:5])
+            raise ValueError(
+                "任务名 '%s' 歧义, 匹配到 %d 个: %s。请用完整任务名。"
+                % (task_input, len(candidates), names)
+            )
+
+    # 不存在 —— 返回原始路径 (调用方决定怎么报错)
+    return tasks_dir / task_input
+
+
+# =============================================================================
+# 任务 JSON 读写
+# =============================================================================
+
+def load_task_json(task_dir: Path) -> dict | None:
+    """加载 task.json 文件。
+
+    Args:
+        task_dir: 任务目录路径。
+
+    Returns:
+        解析后的 dict, 文件不存在或解析失败返回 None。
+    """
+    task_json = task_dir / FILE_TASK_JSON
+    if not task_json.is_file():
+        return None
+
+    try:
+        return json.loads(task_json.read_text(encoding="utf-8"))
+    except (json.JSONDecodeError, OSError, IOError):
+        return None
+
+
+def write_task_json(task_dir: Path, data: dict) -> bool:
+    """原子写入 task.json 文件 (temp + os.replace, 写失败原文件不变)。
+
+    Args:
+        task_dir: 任务目录路径。
+        data: 要写入的数据。
+
+    Returns:
+        成功返回 True。
+    """
+    task_json = task_dir / FILE_TASK_JSON
+    try:
+        # 原子写: sort_keys=False 保留插入顺序 (task.json 字段顺序有意义)
+        atomic_write_json(
+            str(task_json), data,
+            indent=2, ensure_ascii=False, sort_keys=False,
+        )
+        return True
+    except (OSError, IOError) as e:
+        print(f"Warning: Failed to write task.json: {e}", file=sys.stderr)
+        return False
+
+
+# =============================================================================
+# ACL: 任务操作权限校验 (零信任)
+# =============================================================================
+
+def assert_can_modify_task(
+    task_dir: Path,
+    action: str,
+    repo_root: Path | None = None,
+) -> str:
+    """校验当前开发者是否有权修改该任务。
+
+    零信任 ACL: 只有 creator / assignee / admin 角色能修改。
+    其他人 start/finish/archive 别人的任务会被拒绝。
+
+    Args:
+        task_dir: 任务目录。
+        action: 动作名 (start/finish/archive/add-subtask/remove-subtask)。
+        repo_root: 项目根。
+
+    Returns:
+        当前开发者名 (校验通过)。
+
+    Raises:
+        PermissionError: 无权操作。
+    """
+    if repo_root is None:
+        repo_root = get_repo_root()
+    repo_root = Path(repo_root)  # 统一为 Path
+
+    # 读当前开发者
+    try:
+        from .paths import get_developer
+    except ImportError:
+        from paths import get_developer  # type: ignore
+    dev = get_developer(repo_root)
+    if not dev:
+        raise PermissionError(
+            "[authz] 拒绝 %s: 未设置开发者身份。先 /wl-init。" % action
+        )
+
+    task = load_task_json(task_dir)
+    if not task:
+        # 任务不存在 —— 让上层处理, 这里放行 (创建场景)
+        return dev
+
+    creator = (task.get("creator") or "").strip()
+    assignee = (task.get("assignee") or "").strip()
+    authorized = {creator, assignee}
+    authorized.discard("")
+
+    # admin 角色可操作任意任务
+    try:
+        from .identity import get_member
+        m = get_member(dev, repo_root)
+        if m and m.get("role") == "admin":
+            return dev
+    except Exception:
+        pass  # identity 模块不可用则退化为只看 creator/assignee
+
+    if dev not in authorized:
+        raise PermissionError(
+            "[authz] 拒绝 %s 任务 '%s': 当前开发者 '%s' 不是 creator(%s)/assignee(%s)。"
+            "只有任务负责人或 admin 可操作。"
+            % (action, task_dir.name, dev, creator or "?", assignee or "?")
+        )
+    return dev
+
+
+# =============================================================================
+# 生命周期钩子
+# =============================================================================
+
+def run_task_hooks(
+    hook_name: str,
+    task_json_path: Path,
+    repo_root: Path | None = None,
+) -> None:
+    """运行任务生命周期钩子。
+
+    从 config.yaml 读取钩子配置并执行。
+
+    Args:
+        hook_name: 钩子名称 (after_create/after_start/after_finish/after_archive)。
+        task_json_path: task.json 的路径。
+        repo_root: 项目根目录, 默认自动检测。
+    """
+    if repo_root is None:
+        repo_root = get_repo_root()
+
+    config_path = repo_root / ".qoder" / "config.yaml"
+    if not config_path.is_file():
+        return
+
+    # 简单的 YAML 解析 (不依赖 PyYAML)
+    try:
+        import yaml
+        with open(config_path, "r", encoding="utf-8") as f:
+            config = yaml.safe_load(f)
+    except ImportError:
+        # 没有 PyYAML, 用简单解析
+        config = _simple_yaml_parse(config_path)
+
+    if not config:
+        return
+
+    hooks = config.get("hooks", {})
+    commands = hooks.get(hook_name, [])
+    if not commands:
+        return
+
+    env = os.environ.copy()
+    env["TASK_JSON_PATH"] = str(task_json_path)
+
+    for cmd in commands:
+        try:
+            print(f"  Running hook [{hook_name}]: {cmd}")
+            result = subprocess.run(
+                cmd,
+                shell=True,
+                cwd=str(repo_root),
+                env=env,
+                capture_output=True,
+                text=True,
+                timeout=30,
+            )
+            if result.returncode != 0:
+                print(f"  Warning: Hook returned non-zero: {result.stderr}", file=sys.stderr)
+        except subprocess.TimeoutExpired:
+            print(f"  Warning: Hook timed out: {cmd}", file=sys.stderr)
+        except Exception as e:
+            print(f"  Warning: Hook error: {e}", file=sys.stderr)
+
+
+def _simple_yaml_parse(path: Path) -> dict:
+    """简单的 YAML 解析器 (不依赖外部库)。
+
+    只支持两级嵌套和列表。
+
+    Args:
+        path: YAML 文件路径。
+
+    Returns:
+        解析后的 dict。
+    """
+    result = {}
+    current_key = None
+    current_list = None
+
+    try:
+        lines = path.read_text(encoding="utf-8").splitlines()
+    except (OSError, IOError):
+        return result
+
+    for line in lines:
+        stripped = line.strip()
+        if not stripped or stripped.startswith("#"):
+            continue
+
+        indent = len(line) - len(line.lstrip())
+
+        if indent == 0 and ":" in stripped and not stripped.startswith("-"):
+            # 顶层 key
+            if current_key and current_list is not None:
+                result[current_key] = current_list
+            key, _, value = stripped.partition(":")
+            current_key = key.strip()
+            current_list = None
+            if value.strip():
+                result[current_key] = value.strip()
+                current_key = None
+
+        elif indent > 0 and stripped.startswith("- "):
+            # 列表项
+            if current_list is None:
+                current_list = []
+            item = stripped[2:].strip().strip("'\"")
+            current_list.append(item)
+
+        elif indent > 0 and ":" in stripped and current_key:
+            # 子键值对
+            if current_list is not None:
+                result[current_key] = current_list
+                current_list = None
+            key, _, value = stripped.partition(":")
+            if isinstance(result.get(current_key), dict):
+                result[current_key][key.strip()] = value.strip().strip("'\"")
+            else:
+                result[current_key] = {key.strip(): value.strip().strip("'\"")}
+
+    if current_key and current_list is not None:
+        result[current_key] = current_list
+
+    return result