weflow-cli 1.7.0 → 1.8.1

package/scripts/semantic_search.py

@@ -6,6 +6,9 @@
   # 构建索引（首次或增量）
   python scripts/semantic_search.py build
 
+  # 窗口可调（默认聊天 90 天 / 日报 30 天；要"整段历史"就给大值）
+  python scripts/semantic_search.py build --days 3650 --article-days 365
+
   # 搜索（有索引用向量，否则关键词 fallback）
   python scripts/semantic_search.py search "有人推荐过遥感的工具吗" --top-k 10
 
@@ -15,21 +18,39 @@
 输出: JSON 格式
 """
 
-import sys, os, json, hashlib, argparse
+import sys, os, json, hashlib, re, argparse
 from datetime import datetime, timezone, timedelta
 from pathlib import Path
 
-try:
-    import numpy as np
-except ImportError:
-    print(json.dumps({"error": "请安装: pip install numpy"}))
-    sys.exit(1)
+# 重依赖一律懒加载（照 nt_decrypt.require_sqlcipher 的做法）：
+# 关键词检索与重排不需要它们，缺了也不该让整份模块 import 就 sys.exit——
+# 那样连不碰向量库的代码路径都用不了，CI 里也没法测任何东西。
+np = None
+sqlcipher = None
 
-try:
-    from sqlcipher3 import dbapi2 as sqlcipher
-except ImportError:
-    print(json.dumps({"error": "请安装: pip install sqlcipher3"}))
-    sys.exit(1)
+
+def require_numpy():
+    global np
+    if np is not None:
+        return np
+    try:
+        import numpy as _np
+    except ImportError:
+        raise RuntimeError('需要 numpy: pip install numpy')
+    np = _np
+    return np
+
+
+def require_sqlcipher():
+    global sqlcipher
+    if sqlcipher is not None:
+        return sqlcipher
+    try:
+        from sqlcipher3 import dbapi2 as _sqlcipher
+    except ImportError:
+        raise RuntimeError('需要 sqlcipher3: pip install sqlcipher3')
+    sqlcipher = _sqlcipher
+    return sqlcipher
 
 try:
     import urllib.request
@@ -38,7 +59,8 @@ except:
     pass
 
 sys.path.insert(0, os.path.dirname(os.path.abspath(__file__)))
-from _utils import load_config, decrypt_lock
+from _utils import load_config, decrypt_lock, get_dashscope_key
+from jev_client import create_client
 
 OUTPUT_ROOT = 'output'
 INDEX_DIR = Path(OUTPUT_ROOT) / '.semantic_index'
@@ -99,6 +121,7 @@ def get_embeddings(texts: list[str], api_key: str) -> list[list[float]]:
 # ====== Data Collection ======
 
 def open_db(db_path, key_hex, salt_hex):
+    sqlcipher = require_sqlcipher()
     raw_key = f"x'{key_hex}{salt_hex}'"
     conn = sqlcipher.connect(db_path)
     c = conn.cursor()
@@ -171,20 +194,27 @@ def collect_chat_messages(conn, name_map, days=90):
     return items
 
 
-def collect_articles():
-    """Collect articles from biz-daily."""
+def collect_articles(article_days=30):
+    """Collect articles from biz-daily.
+
+    `article_days` = 取最近多少个**日期目录**（原来写死 30）。可调是必要的：
+    这个窗口决定了"知识库里有多少文章"，而它原先只写在常量里，用户看不到也改不了。
+    """
     items = []
     daily_dir = Path(OUTPUT_ROOT) / 'biz-daily'
     if not daily_dir.exists():
         return items
 
-    for date_dir in sorted(daily_dir.iterdir(), reverse=True)[:30]:  # Last 30 days
+    for date_dir in sorted(daily_dir.iterdir(), reverse=True)[:article_days]:
         if not date_dir.is_dir():
             continue
         for topic_dir in date_dir.iterdir():
             if not topic_dir.is_dir():
                 continue
-            for f in topic_dir.glob(' marriage*.md'):
+            # 这里原先是 topic_dir.glob(' marriage*.md')——前导空格加 marriage 前缀，
+            # 在真实的「公众号-标题.md」命名下一个都匹配不到。后果是 collect_articles()
+            # 永远返回空表，**语义索引里从来没有任何文章**，只有聊天记录，而且不报错。
+            for f in topic_dir.glob('*.md'):
                 if f.name == 'README.md':
                     continue
                 try:
@@ -217,9 +247,17 @@ def collect_articles():
 
 # ====== Index Operations ======
 
-def build_index(api_key: str, full: bool = False):
-    """Build or update the semantic index."""
+def build_index(api_key: str, full: bool = False, days: int = 90, article_days: int = 30):
+    """Build or update the semantic index.
+
+    `days` / `article_days` 决定这个索引**记多久**：它们原先写死在两处调用里
+    （聊天 90 天、日报 30 天），用户既看不见也改不了——而"个人知识库只有三个月记忆"
+    正是那个写死的数字造成的。现在由 CLI 显式传进来（见 `search-index --days / --article-days`），
+    默认值保持不变，**不悄悄改变代价**。
+    """
+    np = require_numpy()
     INDEX_DIR.mkdir(parents=True, exist_ok=True)
+    print(f"窗口: 聊天最近 {days} 天 / 日报最近 {article_days} 天", file=sys.stderr)
 
     # Load existing index
     existing_ids = set()
@@ -253,13 +291,13 @@ def build_index(api_key: str, full: bool = False):
     items = []
     try:
         conn = open_db(nt_db, nt_key, nt_salt)
-        chat_items = collect_chat_messages(conn, name_map, days=90)
+        chat_items = collect_chat_messages(conn, name_map, days=days)
         items.extend(chat_items)
         conn.close()
     except Exception as e:
         print(f"[WARN] 聊天消息收集失败: {e}", file=sys.stderr)
 
-    article_items = collect_articles()
+    article_items = collect_articles(article_days=article_days)
     items.extend(article_items)
 
     # Filter new items
@@ -267,7 +305,8 @@ def build_index(api_key: str, full: bool = False):
     print(f"总数据: {len(items)} 条, 新数据: {len(new_items)} 条", file=sys.stderr)
 
     if not new_items:
-        return {"status": "up_to_date", "total": len(items)}
+        return {"status": "up_to_date", "total": len(items),
+                "chatDays": days, "articleDays": article_days}
 
     # Generate embeddings
     print("生成 embeddings...", file=sys.stderr)
@@ -275,7 +314,8 @@ def build_index(api_key: str, full: bool = False):
     embeddings = get_embeddings(texts, api_key)
 
     if not embeddings or all(e == [0.0] * EMBEDDING_DIM for e in embeddings):
-        return {"error": "Embedding 生成失败，请检查 API key"}
+        return {"error": "Embedding 生成失败，请检查 API key",
+                "chatDays": days, "articleDays": article_days}
 
     # Load existing vectors
     if VECTORS_FILE.exists() and not full:
@@ -303,23 +343,38 @@ def build_index(api_key: str, full: bool = False):
         "status": "success",
         "total": len(meta),
         "new": len(new_items),
+        "chatDays": days,
+        "articleDays": article_days,
     }
 
 
-def keyword_search(query: str, top_k: int = 10):
-    """Simple keyword fallback: scan articles + messages for keyword matches."""
+def keyword_search(query: str, top_k: int = 10, root=None):
+    """Simple keyword fallback: scan articles + messages for keyword matches.
+
+    `root` 只为可测而参数化（默认就是日报目录）。它原先硬编码成相对路径，
+    于是这条路径只能靠 chdir 才能测，也就一直没被测过——而它正是检索不可用时
+    真正跑着的那条（本机索引从未构建过）。
+    """
     results = []
     keywords = query.lower().split()
 
     # Scan biz-daily articles
-    biz_dir = Path('output/biz-daily')
+    biz_dir = Path(root or 'output/biz-daily')
     if biz_dir.exists():
         for md_file in sorted(biz_dir.rglob('*.md'), reverse=True):
-            if md_file.name == 'README.md' or md_file.name.startswith('.'):
-                continue
+            # **只收真文章。** 日报目录里还躺着 <天>/README.md、<天>/行动建议.md
+            # 这类**生成产物**，它们会被当成检索结果返回（实测搜到过
+            # 「行动建议 — 2026-08-30」）。而它们**两种深度都有**：既在日期目录下、
+            # 也在主题目录下（实测各 4 个），所以按路径判断是不够的——我第一版就是这么
+            # 写的，然后拿一个"看不见产物"的 top_k 去验证，误以为修好了。
+            #
+            # 判据用内容：真文章的 frontmatter 里一定有 url。
+            # `quality_eval.read_article` 用的是同一条。
             try:
                 content = md_file.read_text(encoding='utf-8')[:5000]
-            except:
+            except OSError:
+                continue
+            if not re.search(r'^url:\s*\S', content[:800], re.M):
                 continue
             score = sum(content.lower().count(kw) for kw in keywords)
             if score > 0:
@@ -350,11 +405,99 @@ def keyword_search(query: str, top_k: int = 10):
     return results[:top_k]
 
 
-def search(query: str, api_key: str, top_k: int = 10):
+# 送进重排的候选数。检索是粗筛（"语义相近"），重排是细判（"真的回答了问题吗"），
+# 所以池子要比 top_k 大，才有可换的空间。
+RERANK_CANDIDATES = 20
+RERANK_EXCERPT_CHARS = 300
+
+
+def build_rerank_questions(count):
+    """**一次请求问 N 个候选**——这是 Jev 最适合"重排"的地方。
+
+    实测 2 个问题 0.84s、12 个问题 0.91s（`state` 才是开销大头），所以给 20 条候选
+    各问一个是 0.9 秒量级，不是 20 次往返。问题编号与候选编号必须严格对应：
+    错位了不会报错，只会把最相关的排到最后——所以每条候选在 state 里都带【候选k】标签。
+    """
+    return {
+        'c%d' % i: {'type': 'noul',
+                    'instructions': '【候选%d】是否直接回答了上面的问题，'
+                                    '或含有回答它所需的关键信息？仅话题相近不算。' % i}
+        for i in range(count)
+    }
+
+
+def rerank(query, results, client=None, pool_size=RERANK_CANDIDATES):
+    """用**一次**决策请求给检索结果重排。
+
+    没有客户端、候选太少、或调用失败 → 原样返回（也就是这个函数还不存在时的行为）。
+    这是刻意的：重排是加分项，不该让检索本身失败。
+
+    `score` 保持原义（余弦相似度或关键词命中数），新的分数放在 `rerankScore` 里，
+    与 `relevanceScore`/`includeScore` 同一套只增字段的做法——下游可能在展示 score。
+    """
+    if client is None or len(results) < 2:
+        return results
+
+    pool = results[:pool_size]
+    lines = []
+    for i, item in enumerate(pool):
+        excerpt = (item.get('text') or '').strip().replace(chr(10), ' ')
+        lines.append('【候选%d】%s｜%s' % (i, item.get('title') or item.get('source') or '',
+                                          excerpt[:RERANK_EXCERPT_CHARS]))
+    state = '问题：%s\n\n候选：\n%s' % (query, chr(10).join(lines))
+    questions = build_rerank_questions(len(pool))
+    # 同问两次的一致性检查：哪一条最直接地回答了问题。逐条打分与这个单选对不上，
+    # 通常意味着编号被模型搞混了——那正是重排最危险、也最不容易察觉的失效方式。
+    questions['best'] = {
+        'type': 'choice',
+        'instructions': '哪一条候选最直接地回答了上面的问题？',
+        'criteria': {'候选%d' % i: (item.get('title') or None)
+                     for i, item in enumerate(pool)},
+    }
+
+    try:
+        answers, _usage = client.decide(state, questions)
+    except Exception as error:
+        print('  [WARN] 重排失败（%s），保持原检索顺序：%s' % (type(error).__name__, error))
+        return results
+
+    scored = []
+    for i, item in enumerate(pool):
+        value = (answers.get('c%d' % i) or {}).get('noul')
+        try:
+            value = float(value)
+        except (TypeError, ValueError):
+            value = None
+        scored.append((value, i, item))
+
+    if all(value is None for value, _i, _item in scored):
+        print('  [WARN] 重排没有返回任何可用分数，保持原检索顺序')
+        return results
+
+    # 没拿到分数的按原序垫在最后，而不是当成 0 分——"未知"和"不相关"不是一回事。
+    scored.sort(key=lambda triple: (triple[0] is None, -(triple[0] or 0.0), triple[1]))
+    best = (answers.get('best') or {}).get('choice')
+    top = scored[0]
+    if best is not None and best != '候选%d' % top[1]:
+        print('  [WARN] 重排自检不一致：逐条打分最高的是候选%d，单选却答 %s'
+              % (top[1], best))
+
+    ordered = []
+    for value, i, item in scored:
+        entry = dict(item)
+        if value is not None:
+            entry['rerankScore'] = round(value, 3)
+        ordered.append(entry)
+    ordered.extend(results[pool_size:])
+    return ordered
+
+
+def search(query: str, api_key: str, top_k: int = 10, rerank_results: bool = True):
     """Semantic search with keyword fallback."""
     # Try embedding-based search first
     if VECTORS_FILE.exists() and META_FILE.exists():
         try:
+            np = require_numpy()
             vectors = np.load(VECTORS_FILE)
             meta = json.loads(META_FILE.read_text(encoding='utf-8'))
             query_embeddings = get_embeddings([query], api_key)
@@ -362,34 +505,40 @@ def search(query: str, api_key: str, top_k: int = 10):
                 query_vec = np.array(query_embeddings[0], dtype=np.float32)
                 query_vec = query_vec / np.linalg.norm(query_vec)
                 similarities = np.dot(vectors, query_vec)
-                top_indices = np.argsort(similarities)[::-1][:top_k]
+                # 先取一个比重排池更大的候选集，重排才有可以换的空间。
+                pool_size = max(top_k, RERANK_CANDIDATES) if rerank_results else top_k
+                top_indices = np.argsort(similarities)[::-1][:pool_size]
                 results = []
                 for idx in top_indices:
                     item = meta[idx]
                     results.append({**item, 'score': float(similarities[idx])})
-                return results
+                if rerank_results:
+                    results = rerank(query, results, create_client())
+                return results[:top_k]
         except:
             pass
 
     # Fallback: keyword search
-    return keyword_search(query, top_k)
+    results = keyword_search(query, max(top_k, RERANK_CANDIDATES) if rerank_results else top_k)
+    if rerank_results:
+        # 关键词打分比余弦更粗，重排在这里的收益反而更大。
+        results = rerank(query, results, create_client())
+    return results[:top_k]
 
-    results = []
-    for idx in top_indices:
-        item = meta[idx]
-        results.append({
-            **item,
-            "score": float(similarities[idx]),
-        })
 
-    return {
-        "query": query,
-        "total": len(meta),
-        "results": results,
-    }
+# ====== Main ======
 
+def add_window_args(parser):
+    """索引窗口（两个子命令共用）。
+
+    默认值与原先把死的数字**完全一致**（聊天 90 / 日报 30）——加参数不是改代价，
+    只是把原来改不了的数字变成改得了的。要建"整段历史"的知识库就显式给一个大值。
+    """
+    parser.add_argument('--days', type=int, default=90,
+                        help='聊天记录收最近多少天（默认 90）')
+    parser.add_argument('--article-days', type=int, default=30,
+                        help='日报文章收最近多少个日期目录（默认 30）')
 
-# ====== Main ======
 
 def main():
     sys.stdout.reconfigure(encoding='utf-8', errors='replace')
@@ -400,31 +549,41 @@ def main():
     p = subparsers.add_parser('build')
     p.add_argument('--api-key', help='DeepSeek API key（优先从 config 读取）')
     p.add_argument('--full', action='store_true', help='全量重建')
+    add_window_args(p)
 
     # update
     p = subparsers.add_parser('update')
     p.add_argument('--api-key', help='DeepSeek API key（优先从 config 读取）')
+    add_window_args(p)
 
     # search
     p = subparsers.add_parser('search')
     p.add_argument('query', nargs='?')
     p.add_argument('--api-key', help='DeepSeek API key（向量搜索时需要，关键词 fallback 不需要）')
     p.add_argument('--top-k', type=int, default=10)
+    p.add_argument('--no-rerank', action='store_true',
+                   help='不调用决策模型重排，只按向量/关键词相似度返回（回退到引入重排之前）')
 
     args = parser.parse_args()
+    # 手动跑时的第二道闸门（CLI 那条路已经按 1-36500 校验过）：0 天等于建一个空库，
+    # 那结果看起来"建好了"，实际什么都没有——这种"看起来成功"的失败要挡住
+    if getattr(args, 'days', 90) < 1 or getattr(args, 'article_days', 30) < 1:
+        json_output({'error': '--days 与 --article-days 都要 ≥ 1（0 天等于索引一个空库）'})
+        return
     config = load_config()
-    api_key = args.api_key or os.environ.get('DASHSCOPE_API_KEY', '') or config.get('dashscopeApiKey', '')
+    api_key = args.api_key or os.environ.get('DASHSCOPE_API_KEY', '') or get_dashscope_key(config)
 
     if args.command == 'build':
-        result = build_index(api_key, full=args.full)
+        result = build_index(api_key, full=args.full, days=args.days, article_days=args.article_days)
     elif args.command == 'update':
-        result = build_index(api_key, full=False)
+        result = build_index(api_key, full=False, days=args.days, article_days=args.article_days)
     elif args.command == 'search':
         query = args.query or os.environ.get('WEFLOW_SEARCH_QUERY', '')
         if not query:
             result = {"error": "missing search query"}
         else:
-            result = search(query, api_key, top_k=args.top_k)
+            result = search(query, api_key, top_k=args.top_k,
+                            rerank_results=not args.no_rerank)
     else:
         result = {"error": f"未知命令: {args.command}"}