@hupan56/wlkj 3.3.7 → 3.3.9

package/templates/qoder/scripts/domain/kg/server/perf_bench.py

@@ -1,197 +0,0 @@
-# -*- coding: utf-8 -*-
-# v3.0 路径自举: 引导到 common/bootstrap, 统一 sys.path 逻辑
-import os as _o, sys as _s
-_f = _o.path.abspath(__file__)
-for _ in range(10):
-    _f = _o.path.dirname(_f)
-    _cp = _o.path.join(_f, 'foundation')
-    if _o.path.isfile(_o.path.join(_cp, 'bootstrap.py')):
-        break
-if _cp not in _s.path: _s.path.insert(0, _cp)
-from bootstrap import setup; setup()
-from foundation.core.paths import get_repo_root
-
-"""
-perf_bench.py — 知识图谱关键路径性能基准
-
-诊断"用了工作流反而更慢"的根因, 并验证常驻化(daemon)加速层的效果。
-
-两种测量模式:
-  1. 冷启动 (subprocess 跑 kg.py) — 模拟真实用户体验: 起进程→import→连库→跑
-  2. daemon 热路径 (kgd_client)   — daemon 常驻时的 IPC 调用, 模型/连接已就绪
-
-用法:
-  python perf_bench.py                # 默认: 测冷启动 (--no-daemon)
-  python perf_bench.py --with-daemon  # 同时测 daemon 热路径 (需先 kgd.py start)
-  python perf_bench.py --quick        # 跳过 semantic (26s), 只测轻量路径
-"""
-import io
-import os
-import subprocess
-import sys
-import time
-
-# UTF-8 输出 (Windows 终端默认 GBK 会乱码)
-try:
-    sys.stdout.reconfigure(encoding='utf-8', errors='replace')
-except Exception:
-    pass
-
-KG_PY = os.path.join(os.path.dirname(os.path.abspath(__file__)), 'kg.py')
-REPO_ROOT = get_repo_root()
-
-# ── 测试用例 (覆盖四层) ──────────────────────────────────────────────
-# (名称, kg子命令, 参数列表, 预期层)
-CASES = [
-    ('search-考勤(web)',    'search',    ['考勤', '--platform', 'web'],  '结构层'),
-    ('search-车辆(web)',    'search',    ['车辆', '--platform', 'web'],  '结构层'),
-    ('search-报销(app)',    'search',    ['报销', '--platform', 'app'],  '结构层'),
-    ('api-asset',           'api',       ['asset'],                      '结构层'),
-    ('context_pack-车辆',   'context',   ['车辆', '--platform', 'web'],  '①③+设计'),
-    ('impact-/asset',       'impact',    ['/asset'],                     '图谱层'),
-    ('feature-资产管理',    'feature',   ['资产管理'],                    '图谱层'),
-    ('semantic-报销',       'semantic',  ['报销'],                       '向量层'),  # 26s 慢王
-]
-
-
-def _run_kg(args, use_daemon=True, timeout=120):
-    """跑一次 kg.py 子命令, 返回 (耗时秒, 返回码)。
-
-    use_daemon=True  : 走默认 (kg.py 内部会优先 daemon)
-    use_daemon=False : 加 --no-daemon 强制冷路径
-    """
-    cmd = [sys.executable, KG_PY] + args
-    if not use_daemon:
-        cmd.append('--no-daemon')
-    env = dict(os.environ)
-    env['PYTHONIOENCODING'] = 'utf-8'
-    t0 = time.time()
-    try:
-        # stdout 重定向到 DEVNULL, 只测耗时, 不看内容
-        r = subprocess.run(cmd, stdout=subprocess.DEVNULL,
-                           stderr=subprocess.DEVNULL, cwd=REPO_ROOT,
-                           env=env, timeout=timeout)
-        return time.time() - t0, r.returncode
-    except subprocess.TimeoutExpired:
-        return float(timeout), -1
-
-
-def _median(samples):
-    """取中位数 (抗抖动)。"""
-    s = sorted(samples)
-    n = len(s)
-    return s[n // 2] if n % 2 else (s[n // 2 - 1] + s[n // 2]) / 2.0
-
-
-def bench_case(name, cmd, args, cold=True, daemon=False, repeats=3):
-    """跑单个用例, 返回 (中位数耗时, 状态)。
-
-    cold=True  : 测冷启动 (--no-daemon)
-    daemon=True: 测 daemon 热路径 (不加 --no-daemon, 但需 daemon 在线)
-    """
-    if cold and daemon:
-        raise ValueError('cold 和 daemon 互斥')
-    # 重量级命令 (semantic 冷启动 ~27s) 只跑 1 次, 避免基准脚本本身过慢
-    if cmd == 'semantic' and cold:
-        repeats = 1
-    use_daemon = daemon
-    samples = []
-    status = 'ok'
-    for _ in range(repeats):
-        elapsed, rc = _run_kg([cmd] + args, use_daemon=use_daemon)
-        samples.append(elapsed)
-        if rc != 0:
-            status = 'rc=%d' % rc
-    return _median(samples), status
-
-
-def daemon_online():
-    """探测 daemon 是否在线 (通过 kg.py status, 1s 超时)。"""
-    try:
-        from kgd import kgd_client
-        return kgd_client.ping(timeout=1.0)
-    except Exception:
-        return False
-
-
-def fmt_speedup(cold_s, hot_s):
-    """格式化加速比。"""
-    if hot_s <= 0.001:
-        return '-'
-    return '%.0fx' % (cold_s / hot_s)
-
-
-def main():
-    args = sys.argv[1:]
-    quick = '--quick' in args
-    want_daemon = '--with-daemon' in args
-
-    print('=' * 72)
-    print('知识图谱性能基准  (repo: %s)' % os.path.basename(REPO_ROOT))
-    print('=' * 72)
-
-    if quick:
-        print('[quick 模式] 跳过 semantic (向量层 26s), 只测轻量路径\n')
-        cases = [c for c in CASES if c[1] != 'semantic']
-    else:
-        cases = CASES
-
-    cold_results = []  # [(name, secs, status, layer)]
-    hot_results = {}   # name -> (secs, status)
-
-    # ── 1. 冷启动基线 (真实用户体验: 每次起一个进程) ──
-    print('[1/2] 冷启动基线 (--no-daemon, 模拟现状) ...')
-    for name, cmd, cargs, layer in cases:
-        secs, status = bench_case(name, cmd, cargs, cold=True)
-        cold_results.append((name, secs, status, layer))
-        marker = '  ' if status == 'ok' else '! '
-        print('  %s%-22s %6.2fs  [%s] %s' % (marker, name, secs, layer, status))
-    print()
-
-    # ── 2. daemon 热路径 (常驻加速层) ──
-    if want_daemon:
-        online = daemon_online()
-        if not online:
-            print('[2/2] daemon 未在线 — 跳过热路径测试。')
-            print('      (先启动: python .qoder/scripts/domain/kg/server/kgd.py start)')
-        else:
-            print('[2/2] daemon 在线, 测热路径 ...')
-            for name, cmd, cargs, layer in cases:
-                secs, status = bench_case(name, cmd, cargs, cold=False, daemon=True)
-                hot_results[name] = (secs, status)
-                marker = '  ' if status == 'ok' else '! '
-                print('  %s%-22s %6.2fs  [%s] %s' % (marker, name, secs, layer, status))
-        print()
-
-    # ── 汇总对比表 ──
-    print('-' * 72)
-    print('%-22s %10s %10s %10s' % ('用例', '冷启动', 'daemon', '加速'))
-    print('%-22s %10s %10s %10s' % ('─' * 18, '─' * 8, '─' * 8, '─' * 6))
-    for name, cold_s, status, layer in cold_results:
-        hot_s = hot_results.get(name, (None, None))[0]
-        hot_str = '%.2fs' % hot_s if hot_s else '-'
-        speed = fmt_speedup(cold_s, hot_s) if hot_s else '-'
-        print('%-22s %8.2fs %10s %10s' % (name, cold_s, hot_str, speed))
-    print('-' * 72)
-
-    # ── 诊断结论 ──
-    print('\n诊断:')
-    semantic_s = next((s for n, s, _, _ in cold_results if 'semantic' in n), None)
-    if semantic_s and semantic_s > 10:
-        print('  🔴 semantic %.1fs — 模型冷加载占 99%%, 是头号慢源' % semantic_s)
-        print('     解法: kgd.py start 常驻模型 → <0.5s')
-    elif semantic_s:
-        print('  🟢 semantic %.1fs — 在可接受范围' % semantic_s)
-
-    total_cold = sum(s for _, s, _, _ in cold_results)
-    print('  冷启动累积: %.1fs (一次 PRD 流程的隐性等待)' % total_cold)
-    if hot_results:
-        total_hot = sum(hot_results[n][0] for n in hot_results)
-        print('  daemon 累积: %.1fs  → 整体提速 %.0fx' %
-              (total_hot, total_cold / max(total_hot, 0.01)))
-
-    return 0
-
-
-if __name__ == '__main__':
-    sys.exit(main())

package/templates/qoder/scripts/domain/kg/sync_repowiki.py

@@ -1,109 +0,0 @@
-#!/usr/bin/env python
-"""同步 Qoder Repo Wiki → 平台 PG wiki 表。
-
-Qoder 自动为代码仓库生成 Repo Wiki（750+篇业务文档），存在：
-  data/code/{repo}/.qoder/repowiki/knowledge/zh/**/*.md
-
-本脚本读这些 md → UPSERT 到 PG wiki 表（repo + keyword + title + description）。
-这样知识层的 wiki 搜索(graphrag_ask/rag_search)能命中 Qoder 自动生成的高质量文档。
-
-用法：
-    python sync_repowiki.py                          # 同步全部仓库
-    python sync_repowiki.py --repo fywl-ics          # 只同步指定仓库
-    python sync_repowiki.py --dry-run                # 只统计不写
-"""
-import os
-import sys
-import glob
-
-_THIS_DIR = os.path.dirname(os.path.abspath(__file__))
-_up1 = os.path.dirname(_THIS_DIR)
-_up2 = os.path.dirname(_up1)
-SCRIPTS_DIR = os.path.dirname(_up2)
-REPO_ROOT = os.path.dirname(SCRIPTS_DIR)
-CODE_ROOT = os.path.join(REPO_ROOT, "data", "code")
-
-PG = dict(host="127.0.0.1", port=5432, user="wlinkj", password="changeme", dbname="wlinkj")
-
-
-def scan_repowiki(repo):
-    """扫描某仓库的 Repo Wiki，返回 [{path, title, content, dir_path}]。"""
-    wiki_base = os.path.join(CODE_ROOT, repo, ".qoder", "repowiki")
-    if not os.path.isdir(wiki_base):
-        return []
-    results = []
-    for md_path in glob.glob(os.path.join(wiki_base, "**", "*.md"), recursive=True):
-        try:
-            with open(md_path, encoding="utf-8") as f:
-                content = f.read()
-            # 标题：md 文件名或第一行 #
-            title = os.path.splitext(os.path.basename(md_path))[0]
-            for line in content.split("\n")[:5]:
-                if line.strip().startswith("#"):
-                    title = line.strip().lstrip("#").strip()
-                    break
-            # keyword：从目录路径提取业务模块名
-            rel = os.path.relpath(md_path, wiki_base)
-            parts = rel.replace("\\", "/").split("/")
-            keyword = parts[-2] if len(parts) >= 2 else title
-            results.append({
-                "path": md_path,
-                "rel_path": rel,
-                "title": title,
-                "keyword": keyword,
-                "content": content[:2000],  # 取前2000字
-            })
-        except Exception:
-            continue
-    return results
-
-
-def sync_to_pg(wiki_items, repo):
-    """UPSERT 到 PG wiki 表。"""
-    import psycopg2
-    from psycopg2.extras import execute_values
-
-    conn = psycopg2.connect(**PG)
-    conn.autocommit = True
-    cur = conn.cursor()
-
-    # ★ 不删旧数据（原 wiki 表有业务文档），只删 repowiki 来源的记录
-    # 用 md_path 前缀 'repowiki:' 标识（避免路径分隔符差异）
-    cur.execute("DELETE FROM wiki WHERE project = %s AND md_path LIKE 'repowiki:%%'", (repo,))
-
-    rows = [(w["keyword"], repo, w["title"], "repowiki:" + w["rel_path"], w["content"][:500])
-            for w in wiki_items]
-    if rows:
-        execute_values(
-            cur,
-            "INSERT INTO wiki(keyword, project, title, md_path, description) VALUES %s",
-            rows,
-        )
-
-    print(f"[{repo}] 同步 {len(rows)} 篇 Wiki 到 PG")
-    conn.close()
-
-
-def main():
-    import argparse
-    parser = argparse.ArgumentParser(description="同步 Qoder Repo Wiki → PG")
-    parser.add_argument("--repo", help="指定仓库名")
-    parser.add_argument("--dry-run", action="store_true", help="只统计不写")
-    args = parser.parse_args()
-
-    repos = [args.repo] if args.repo else ["fywl-ui", "fywl-ics", "Carmg-H5"]
-    total = 0
-    for repo in repos:
-        items = scan_repowiki(repo)
-        print(f"  {repo}: 扫到 {len(items)} 篇 Repo Wiki")
-        if items:
-            for it in items[:3]:
-                print(f"    [{it['keyword']}] {it['title']}")
-            if not args.dry_run:
-                sync_to_pg(items, repo)
-            total += len(items)
-    print(f"\n总计: {total} 篇 Wiki{'（dry-run 未写入）' if args.dry_run else ' 已同步到 PG'}")
-
-
-if __name__ == "__main__":
-    main()

package/templates/qoder/scripts/engine/poller.py

@@ -1,219 +0,0 @@
-"""引擎轮询器：后台轮询平台 pending 触发 → 认领 → 执行 → 回流 → 回填结果。
-
-这是"平台→引擎→平台"真闭环的引擎侧执行器：
-1. 轮询 GET /trigger/pending（带项目令牌）
-2. 认领 POST /trigger/{tid}/claim（原子锁）
-3. 执行：根据 command 调 MCP 取知识 + 生成产出（简化版：rag_search + 模板拼接）
-4. 回流：create_prd/submit_return
-5. 回填：PATCH /trigger/{tid}（mcp_tools_called/knowledge_used）
-
-用法：
-  python poller.py --config ../mcp_config.json --interval 10
-
-注：完整版需要接 LLM（qwen-plus）生成 PRD/原型。当前是简化版（rag_search + 模板），
-验证闭环链路。接 LLM 后把 _execute 里的模板拼接换成 cap.mcp.call("ask_corpus",...) 生成。
-"""
-import json
-import time
-import urllib.request
-import urllib.error
-import argparse
-import os
-import sys
-from pathlib import Path
-
-
-def _load_config(config_path: str) -> dict:
-    with open(config_path, encoding="utf-8") as f:
-        return json.load(f)
-
-
-def _get_token(cfg: dict) -> str:
-    for srv in (cfg.get("mcpServers") or {}).values():
-        return srv.get("token", "")
-    return ""
-
-
-def _get_pid(cfg: dict) -> str:
-    for srv in (cfg.get("mcpServers") or {}).values():
-        env = srv.get("env") or {}
-        return env.get("WLKJ_PROJECT_ID", "")
-    return ""
-
-
-def _get_base(cfg: dict) -> str:
-    ep = cfg.get("return_endpoint") or {}
-    url = ep.get("url", "")
-    # 从 return_endpoint.url 提取 base（/api/projects 前面那段）
-    if "/api/" in url:
-        return url.split("/api/")[0]
-    for srv in (cfg.get("mcpServers") or {}).values():
-        u = srv.get("url", "")
-        if "/mcp" in u:
-            return u.split("/mcp")[0]
-    return os.environ.get("WLKJ_BASE_URL", "http://10.89.7.120")
-
-
-def _api(base, method, path, token, body=None):
-    url = base + path
-    data = json.dumps(body).encode() if body else None
-    req = urllib.request.Request(url, data=data, method=method)
-    req.add_header("Content-Type", "application/json")
-    if token:
-        req.add_header("X-Engine-Token", token)
-    try:
-        with urllib.request.urlopen(req, timeout=30) as resp:
-            return resp.status, json.loads(resp.read().decode())
-    except urllib.error.HTTPError as e:
-        return e.code, json.loads(e.read().decode() or "{}")
-    except Exception as e:
-        return 0, {"error": str(e)}
-
-
-def _mcp_call(base, token, tool, args):
-    """通过 MCP JSON-RPC 调工具。"""
-    body = {"jsonrpc": "2.0", "id": 1, "method": "tools/call",
-            "params": {"name": tool, "arguments": args}}
-    data = json.dumps(body).encode()
-    req = urllib.request.Request(base + "/mcp", data=data, method="POST")
-    req.add_header("Content-Type", "application/json")
-    req.add_header("X-MCP-Token", token)
-    try:
-        with urllib.request.urlopen(req, timeout=60) as resp:
-            r = json.loads(resp.read().decode())
-            text = r.get("result", {}).get("content", [{}])[0].get("text", "")
-            return json.loads(text) if text else {}
-    except Exception as e:
-        return {"error": str(e)}
-
-
-def _execute(base, token, pid, command, args):
-    """执行触发的工作流（简化版：rag_search 取知识 + 模板拼 PRD + learn 写回）。
-    完整版应接 LLM（ask_corpus）生成自然语言 PRD。"""
-    query = (args or {}).get("query", "")
-    tools_called = []
-    knowledge_used = []
-
-    # 1) rag_search 取知识
-    if query:
-        r = _mcp_call(base, token, "rag_search", {"query": query, "top_k": 8})
-        tools_called.append("rag_search")
-        knowledge_used = [it.get("entity_id", "") for it in r.get("items", [])[:5]]
-        knowledge_text = "\n".join(
-            "- %s (%s)" % (it.get("text", "")[:60], it.get("entity_id", "")[:30])
-            for it in r.get("items", [])[:8]
-        )
-        # 1b) get_learnings 查之前学到的（反哺）
-        lr = _mcp_call(base, token, "get_learnings", {"project_id": pid, "limit": 5})
-        tools_called.append("get_learnings")
-        learnings_text = "\n".join(
-            "- [%s] %s" % (l.get("category",""), (l.get("pattern","")[:60]))
-            for l in (lr.get("items") or [])[:5]
-        ) or "(暂无学习记录)"
-    else:
-        knowledge_text = "(无关键词)"
-        learnings_text = ""
-
-    # 2) 根据 command 生成产出
-    if "prd" in command.lower():
-        prd_md = f"# {query} PRD（引擎自动生成）\n\n## 概述\n基于知识层自动生成的「{query}」需求文档。\n\n## 相关知识\n{knowledge_text}\n\n## 历史学习\n{learnings_text}\n\n## 功能\n（根据上述知识补充）"
-        # 回流
-        r = _mcp_call(base, token, "create_prd", {
-            "project_id": pid, "title": f"{query}PRD(引擎触发)", "content_md": prd_md, "status": "planning"
-        })
-        tools_called.append("create_prd")
-        # 学习写回：把这次的关键认知沉淀
-        _mcp_call(base, token, "learn", {"project_id": pid, "category": "rule",
-            "pattern": f"{query}: PRD已生成，涉及知识{len(knowledge_used)}条", "source": "wlkj-poller"})
-        tools_called.append("learn")
-        output = f"生成PRD: {query}PRD(引擎触发) + 学习沉淀"
-    elif "design" in command.lower():
-        html = f"<html><body><h1>{query}</h1><p>引擎自动生成原型</p></body></html>"
-        r = _mcp_call(base, token, "create_prototype", {
-            "project_id": pid, "feature": f"{query}(引擎触发)", "platform": "web", "html": html
-        })
-        tools_called.append("create_prototype")
-        output = f"生成原型: {query}(引擎触发)"
-    else:
-        # learn 写回
-        _mcp_call(base, token, "learn", {
-            "project_id": pid, "category": "rule", "pattern": f"{query}相关规则(引擎触发)",
-            "source": "wlkj-poller"
-        })
-        tools_called.append("learn")
-        output = f"执行命令: {command}"
-
-    return {"output": output, "tools": tools_called, "knowledge": knowledge_used}
-
-
-def poll_once(cfg):
-    """轮询一次：取 pending → 认领 → 执行 → 回填。"""
-    token = _get_token(cfg)
-    pid = _get_pid(cfg)
-    base = _get_base(cfg)
-    if not token or not pid:
-        print("[poller] 配置缺 token/project_id，跳过")
-        return
-
-    # 1) 查 pending
-    _, pending = _api(base, "GET", f"/api/projects/{pid}/trigger/pending", token)
-    items = pending.get("pending", [])
-    if not items:
-        return  # 无待执行
-
-    for item in items[:1]:  # 一次只处理 1 条
-        tid = item.get("triggerId")
-        cmd = item.get("command", "")
-        args = item.get("args", {})
-        print(f"[poller] 认领: {tid} {cmd} {args}")
-
-        # 2) claim
-        code, resp = _api(base, "POST", f"/api/projects/{pid}/trigger/workflow/{tid}/claim",
-                          token, {"engine_id": "poller-001"})
-        if code != 200:
-            print(f"[poller] 认领失败({code}): {resp}")
-            continue
-
-        # 3) 执行
-        t0 = time.time()
-        try:
-            result = _execute(base, token, pid, cmd, args)
-            status = "success"
-        except Exception as e:
-            result = {"output": str(e), "tools": [], "knowledge": []}
-            status = "failed"
-
-        # 4) patch 回填
-        _api(base, "PATCH", f"/api/projects/{pid}/trigger/workflow/{tid}", token, {
-            "status": status,
-            "output_summary": result["output"],
-            "knowledge_used": result["knowledge"],
-            "mcp_tools_called": result["tools"],
-            "duration_sec": int(time.time() - t0),
-        })
-        print(f"[poller] 完成: {status} → {result['output']} (tools={result['tools']})")
-
-
-def main():
-    parser = argparse.ArgumentParser(description="wlkj 引擎轮询器")
-    parser.add_argument("--config", default=str(Path(__file__).parent.parent.parent / "mcp_config.json"))
-    parser.add_argument("--interval", type=int, default=10, help="轮询间隔(秒)")
-    parser.add_argument("--once", action="store_true", help="只跑一次")
-    args = parser.parse_args()
-
-    cfg = _load_config(args.config)
-    print(f"[poller] 启动: project={_get_pid(cfg)} interval={args.interval}s")
-    print(f"[poller] 按 Ctrl+C 停止")
-
-    while True:
-        try:
-            poll_once(cfg)
-        except Exception as e:
-            print(f"[poller] 异常: {e}")
-        if args.once:
-            break
-        time.sleep(args.interval)
-
-
-if __name__ == "__main__":
-    main()