@hupan56/wlkj 2.6.0 → 2.7.1

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

@@ -0,0 +1,144 @@
+# -*- coding: utf-8 -*-
+"""pip_install.py - 带镜像兜底的 pip 安装 (跨环境下载健壮性)
+
+为什么需要它:
+  国内网络下 pip install 连 PyPI 默认源经常超时/失败。
+  新同事第一次 wlkj init 就卡在装包 → 知识图谱/MCP 全崩 → 以为工作流坏了。
+  本模块: 默认源失败 → 自动切国内镜像重试 → 仍失败 → 返回清晰错误。
+
+策略 (用户选定: 失败时才切):
+  1. 先用默认源装 (不动用户环境)
+  2. 失败 → 逐个试国内镜像 (清华/阿里/腾讯), 每个带超时
+  3. 仍失败 → 返回 (False, 缺失包列表, 手动命令), 不静默吞掉
+
+不修改用户全局 pip 配置, 只在本次安装命令里加 -i 参数。
+"""
+
+import subprocess
+import sys
+
+# 国内镜像源 (按速度/稳定性排序, 清华最稳)
+MIRRORS = [
+    ('清华', 'https://pypi.tuna.tsinghua.edu.cn/simple'),
+    ('阿里', 'https://mirrors.aliyun.com/pypi/simple/'),
+    ('腾讯', 'https://mirrors.cloud.tencent.com/pypi/simple'),
+]
+
+# 单次安装超时 (秒), 避免卡死
+INSTALL_TIMEOUT = 300
+
+
+def _run_pip(args, index_url=None, timeout=INSTALL_TIMEOUT):
+    """跑一次 pip, 返回 (returncode, stdout, stderr)。
+    index_url 非 None 时加 -i 指定镜像源。
+    用 trusted-host 避免某些镜像的 SSL 证书警告阻断。
+    """
+    cmd = [sys.executable, '-m', 'pip', 'install'] + args
+    if index_url:
+        cmd += ['-i', index_url,
+                '--trusted-host', _host_of(index_url)]
+    try:
+        r = subprocess.run(cmd, capture_output=True, text=True,
+                           encoding='utf-8', errors='replace', timeout=timeout)
+        return r.returncode, r.stdout or '', r.stderr or ''
+    except subprocess.TimeoutExpired:
+        return 1, '', '安装超时 (%ds)' % timeout
+    except Exception as e:
+        return 1, '', str(e)
+
+
+def _host_of(url):
+    """从 https://pypi.tuna.tsinghua.edu.cn/simple 提取 pypi.tuna.tsinghua.edu.cn"""
+    s = url.replace('https://', '').replace('http://', '')
+    return s.split('/')[0]
+
+
+def install_with_fallback(args):
+    """带镜像兜底的安装。
+
+    args: pip install 的参数 (如 ['-r', 'requirements.txt'] 或 ['duckdb'])
+    返回 dict:
+      ok: True=全部装上 / False=仍有缺失
+      source: 最终成功用的源 ('default' / '清华' / None)
+      missing: 仍缺失的包 (ok=True 时为空)
+      tried: 尝试过的源列表 [(name, success)]
+      hint: 失败时的手动命令
+    """
+    tried = []
+
+    # 1. 默认源
+    rc, out, err = _run_pip(args)
+    tried.append(('默认源(PyPI)', rc == 0))
+    if rc == 0:
+        return {'ok': True, 'source': 'default', 'missing': [], 'tried': tried,
+                'hint': None}
+
+    # 2. 逐个国内镜像重试
+    for name, url in MIRRORS:
+        rc, out, err = _run_pip(args, index_url=url)
+        tried.append((name, rc == 0))
+        if rc == 0:
+            return {'ok': True, 'source': name, 'missing': [], 'tried': tried,
+                    'hint': None}
+
+    # 3. 全失败 —— 解析出哪些包没装上 (用 import 验证, 比 parse pip 输出可靠)
+    missing = _verify_packages(args)
+    hint = _build_manual_hint(missing, tried)
+    return {'ok': False, 'source': None, 'missing': missing,
+            'tried': tried, 'hint': hint}
+
+
+def _verify_packages(args):
+    """从 args 里提取要装的核心包, 用 import 验证真正装上了没。
+    只处理 -r requirements.txt 和直接包名两种情况。
+    返回仍 import 失败的 pip 包名列表。
+    """
+    # 直接包名: args 里不带 - 开头的项
+    pkg_names = [a for a in args if not a.startswith('-')]
+    if '-r' in args:
+        # 从 requirements.txt 读包名 (取每行第一个 token, 去 >= 等版本约束)
+        try:
+            i = args.index('-r')
+            req_path = args[i + 1]
+            with open(req_path, encoding='utf-8') as f:
+                for line in f:
+                    line = line.strip()
+                    if line and not line.startswith('#'):
+                        pkg_names.append(line.split('>=')[0].split('==')[0]
+                                         .split('~=')[0].split('>')[0]
+                                         .split('<')[0].strip())
+        except (OSError, IndexError, ValueError):
+            pass
+
+    # 包名 → import 名映射 (名字不一样的)
+    import_map = {
+        'PyYAML': 'yaml',
+        'tree-sitter': 'tree_sitter',
+        'tree-sitter-typescript': 'tree_sitter_typescript',
+    }
+    still_missing = []
+    for pkg in pkg_names:
+        mod = import_map.get(pkg, pkg.replace('-', '_'))
+        try:
+            __import__(mod)
+        except ImportError:
+            still_missing.append(pkg)
+    return still_missing
+
+
+def _build_manual_hint(missing, tried):
+    """失败时给用户的手动命令。"""
+    src_hint = '、'.join('%s(%s)' % (n, '✓' if ok else '✗') for n, ok in tried)
+    lines = [
+        'pip 安装失败, 尝试过的源: ' + src_hint,
+        '可能原因: 网络/防火墙/公司代理拦截 PyPI。',
+    ]
+    if missing:
+        lines.append('仍缺失: ' + ', '.join(missing))
+        lines.append('手动装 (用清华镜像):')
+        lines.append('  pip install -i https://pypi.tuna.tsinghua.edu.cn/simple '
+                     + ' '.join(missing))
+        lines.append('或配全局镜像 (一劳永逸):')
+        lines.append('  pip config set global.index-url '
+                     'https://pypi.tuna.tsinghua.edu.cn/simple')
+    return '\n       '.join(lines)

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

@@ -0,0 +1,61 @@
+# -*- coding: utf-8 -*-
+"""platform_guard.py - 平台守卫 (代码级硬墙, 替代靠大写喊话)
+
+为什么需要它:
+  AGENTS.md 的 CRITICAL RULE #1 用 "DO NOT / VIOLATION" 威胁 AI 必须先问平台。
+  但把正确性押在 LLM 服从性上不靠谱 —— AI 会被长上下文稀释、会忘。
+  这层守卫把"建议"变成"硬墙": AI 不带 --platform 调用 PRD 链路脚本时直接 exit。
+
+设计:
+  守卫不依赖 args.platform (因为 fill_prototype.py 的 --platform default='web',
+  永远非 None 会绕过守卫)。改为查 sys.argv 是否【显式】包含 --platform。
+  这样 context_pack (platform 初始 None) 和 fill_prototype (default web) 逻辑统一。
+
+  违规时不只是 exit, 还主动上报一条 rule_violation 事件到当前 dev 的 journal,
+  让 /wl-status 看板能统计"本周违规几次" —— 闭环可观测。
+"""
+
+import sys
+
+
+def _platform_explicitly_passed(argv=None):
+    """用户是否在命令行显式传了 --platform。
+    查 argv 而非 args 对象, 绕开 default 值的干扰。
+    """
+    argv = argv if argv is not None else sys.argv
+    return '--platform' in argv
+
+
+def assert_platform_selected(skill='wl-prd-full', argv=None):
+    """硬墙: 没显式传 --platform 就调用 PRD 链路脚本 = 违规。
+
+    1. best-effort 上报 rule_violation 事件 (不阻塞, 失败静默)
+    2. sys.exit 并提示 (硬墙)
+
+    正常调用 (带 --platform) 直接返回, 零开销。
+    """
+    if _platform_explicitly_passed(argv):
+        return
+
+    # 1. 上报违规 (best-effort, 任何失败都不影响拦截)
+    try:
+        import os
+        sys.path.insert(0, os.path.dirname(os.path.dirname(os.path.abspath(__file__))))
+        from learn import record_feedback
+        record_feedback('rule_violation', {
+            'rule': 'ask_platform_first',
+            'skill': skill,
+            'detail': '脚本被调用但未显式传 --platform',
+        })
+    except SystemExit:
+        raise
+    except Exception:
+        pass  # 上报失败不影响拦截本身
+
+    # 2. 硬墙
+    print('【平台守卫】调用 %s 链路的脚本前必须先问用户选哪个平台 (web/app)。' % skill,
+          file=sys.stderr)
+    print('参考 AGENTS.md CRITICAL RULE #1: 先问平台, 不自动判断, 不跳过。',
+          file=sys.stderr)
+    print('已记录一次规则违规到 /wl-status 健康度看板。', file=sys.stderr)
+    sys.exit(2)

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

@@ -1,205 +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
+# -*- 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
+    - 只在 code-keyword.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
+    - 与 code-keyword.json 当前 mtime 比对
+    - 不一致或缓存缺失则重建 + 持久化
+
+    Returns:
+        倒排索引 dict, 或 None (keyword-index 不存在时)。
+    """
+    index_dir = os.path.join(repo_root, "data", "index")
+    ki_path = os.path.join(index_dir, "code-keyword.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