weflow-cli 1.14.1 → 1.15.1

package/scripts/promises.py

@@ -0,0 +1,185 @@
+"""欠账清单：我说过要给谁做什么，后来做了没有。
+
+这是微信永远回答不了的问题 —— 它知道"我明天发你"，但不知道"兑现"是什么。
+
+**默认不调模型**：先用规则把候选捞出来（我发的 + 承诺句式），再在同一个会话之后的对话里
+找"完成信号 / 对方催问 / 对方确认"三类证据。规则会误报，所以每条都带着原话和后续，
+让读者自己判 —— 而不是给一个"AI 认为你欠了 7 件事"的黑箱。
+
+用法：
+    python scripts/promises.py --days 60
+    python scripts/promises.py --days 90 --json
+    python scripts/promises.py --days 60 --talker 老表
+"""
+from __future__ import annotations
+
+import argparse
+import json
+import pathlib
+import re
+import sys
+from collections import defaultdict
+from datetime import datetime, timezone, timedelta
+
+SCRIPT_DIR = pathlib.Path(__file__).resolve().parent
+sys.path.insert(0, str(SCRIPT_DIR))
+
+from _utils import load_config, decrypt_lock  # noqa: E402
+import nt_decrypt as nd  # noqa: E402
+
+TZ = timezone(timedelta(hours=8))
+
+# 承诺句式：我 + 将来/稍后 + 一个交付动作。宁可多收，后面还有证据过滤。
+PROMISE_RE = re.compile(
+    r'(我|这边)[^。！？\n]{0,12}'
+    r'(明天|后天|下周|下周一|晚点|稍后|回头|等会|等会儿|下午|晚上|今天之内|这周)[^。！？\n]{0,12}'
+    r'(发|给|寄|做|弄|整理|传|送|安排|联系|确认|回复|处理)')
+DELIVER_RE = re.compile(r'(发了|发你了|发您了|已发|寄了|弄好了|做好了|整理好了|搞定了|已上传|传了|安排了|回复了|处理好了)')
+CHASE_RE = re.compile(r'(发了吗|寄了吗|好了吗|弄好了吗|什么时候|还没|催一下|怎么还没|在吗.{0,6}(发|给))')
+ACK_RE = re.compile(r'^(收到|好的|好滴|谢谢|多谢|ok|OK|嗯嗯|好嘞)')
+_NOT_PROMISE = re.compile(r'(我明天要|我下周要|我想|我觉得|我昨天|我上次|我已经)')
+
+
+def _clean(text):
+    text = ' '.join(str(text or '').split())
+    return re.sub(r'^[A-Za-z0-9_\-]+@?(chatroom|openim)?\s*:\s*', '', text)
+
+
+def same_account(name, wxid):
+    """配置里的 wxid 与 `Name2Id` 里的账号名**可能是同一个人的两种写法**。
+
+    实测本机：配置是 `wxid_账号A_后缀`，而 `Name2Id` 里只有 `wxid_账号A`（没有后缀）——
+    精确比较一个都匹配不上，于是"我发的消息"一条也捞不到（第一版就是这么得到 0 条承诺的）。
+    """
+    n, w = (name or '').strip(), (wxid or '').strip()
+    if not n or not w:
+        return False
+    return n == w or n.startswith(w + '_') or w.startswith(n + '_')
+
+
+def load_messages(conns, days, my_wxid):
+    """{talker: [ (ts, is_me, sender, text) ]}，按时间升序。"""
+    since = int((datetime.now(TZ) - timedelta(days=days)).timestamp())
+    out = defaultdict(list)
+    for conn in conns:
+        c = conn.cursor()
+        try:
+            c.execute('SELECT rowid, user_name FROM Name2Id')
+            id2name = {r[0]: r[1] for r in c.fetchall()}
+        except Exception:
+            continue
+        try:
+            c.execute('SELECT user_name FROM Name2Id WHERE is_session = 1')
+            sessions = [r[0] for r in c.fetchall() if r[0]]
+        except Exception:
+            sessions = []
+        for talker in sessions:
+            tbl = 'Msg_%s' % __import__('hashlib').md5(talker.encode()).hexdigest()
+            try:
+                c.execute('SELECT COUNT(*) FROM sqlite_master WHERE name=?', (tbl,))
+                if c.fetchone()[0] == 0:
+                    continue
+                c.execute('SELECT create_time, real_sender_id, local_type, message_content FROM "%s" '
+                          'WHERE create_time >= ? ORDER BY create_time' % tbl, (since,))
+                for ts, sender, ltype, content in c.fetchall():
+                    if (int(ltype or 0) & 0xFFFFFFFF) != 1:
+                        continue
+                    text = _clean(nd._decode_content(content))
+                    if not text:
+                        continue
+                    who = id2name.get(sender, '')
+                    out[talker].append((int(ts), same_account(who, my_wxid), who, text))
+            except Exception:
+                continue
+    return out
+
+
+def classify(follow):
+    """看承诺之后发生了什么：兑现 / 被催 / 只有确认 / 无后续。"""
+    if any(f[1] and DELIVER_RE.search(f[3]) for f in follow):
+        return 'delivered', '我后来提到"已发/已弄好"'
+    chases = [f for f in follow if not f[1] and CHASE_RE.search(f[3])]
+    if chases:
+        return 'chased', '对方后来催过：' + chases[0][3][:40]
+    if any(not f[1] and ACK_RE.search(f[3]) for f in follow):
+        return 'acked', '对方回复了确认'
+    return 'unknown', '没有后续证据'
+
+
+def main():
+    ap = argparse.ArgumentParser(description='我说过要给谁做什么，后来做了没有')
+    ap.add_argument('--days', type=int, default=60)
+    ap.add_argument('--talker', default='', help='只看某个会话（wxid 或昵称子串）')
+    ap.add_argument('--limit', type=int, default=30, help='最多列几条（默认 30）')
+    ap.add_argument('--json', action='store_true')
+    args = ap.parse_args()
+
+    cfg = load_config()
+    db = cfg.get('ntDbPath') or ''
+    my_wxid = cfg.get('wxid') or ''
+    if not db:
+        raise SystemExit('配置里没有 ntDbPath')
+    key = decrypt_lock(cfg.get('ntKey', '') or '')
+    salt = decrypt_lock(cfg.get('ntSalt', '') or '')
+    pw = decrypt_lock(cfg.get('favPassphrase', '') or cfg.get('decryptKey', '') or '')
+    conns = nd.connect_message_shards(db, key, salt, pw)
+    if not conns:
+        raise SystemExit('打不开消息分片')
+
+    try:
+        by_talker = load_messages(conns, args.days, my_wxid)
+        # 昵称在 **contact.db**，消息库里没有 `contact` 表 —— 从消息库找一定落空，
+        # 输出里就只剩 wxid（和 on_this_day.py 同一个坑）。
+        name_map = {}
+        try:
+            from network import load_graph
+            people, _rooms, _members = load_graph(cfg)
+            name_map = {p['username']: (p['remark'] or p['nick'] or p['username'])
+                        for p in people.values()}
+        except Exception as exc:
+            print(f'[WARN] 读联系人失败（{type(exc).__name__}: {exc}），下面显示 id',
+                  file=sys.stderr)
+    finally:
+        for conn in conns:
+            try:
+                conn.close()
+            except Exception:
+                pass
+
+    items = []
+    for talker, msgs in by_talker.items():
+        shown = name_map.get(talker, talker)
+        if args.talker and args.talker not in (talker, shown):
+            continue
+        for i, (ts, is_me, who, text) in enumerate(msgs):
+            if not is_me or not PROMISE_RE.search(text) or _NOT_PROMISE.search(text):
+                continue
+            follow = msgs[i + 1:i + 20]
+            state, why = classify(follow)
+            items.append({
+                'time': datetime.fromtimestamp(ts, tz=TZ).strftime('%Y-%m-%d %H:%M'),
+                'talker': shown,
+                'said': text[:100],
+                'state': state,
+                'evidence': why,
+            })
+    items.sort(key=lambda x: x['time'], reverse=True)
+    items = items[:args.limit]
+
+    if args.json:
+        print(json.dumps({'success': True, 'days': args.days, 'items': items}, ensure_ascii=False, indent=2))
+        return
+
+    label = {'delivered': '已兑现', 'chased': '可能欠着', 'acked': '已确认', 'unknown': '看不清'}
+    order = {'chased': 0, 'unknown': 1, 'delivered': 2, 'acked': 3}
+    items.sort(key=lambda x: (order[x['state']], x['time']))
+    print(f'最近 {args.days} 天里，"我"承诺过 {len(items)} 件事：\n')
+    for it in items:
+        print(f"[{label[it['state']]}] {it['time']}  {it['talker']}")
+        print(f"    我说：{it['said']}")
+        print(f"    后续：{it['evidence']}")
+        print()
+
+
+if __name__ == '__main__':
+    main()

package/scripts/semantic_search.py

@@ -1166,6 +1166,11 @@ PHRASE_DB = PHRASE_INDEX_DIR / 'phrase.sqlite'
 PHRASE_MIN_CHARS = 3
 PHRASE_TEXT_LIMIT = FULL_TEXT_LIMIT
 
+# 语音转写清单（`voice_transcribe.py` 产出）。它不是语义索引的一部分——语音走的是另一个
+# 引擎、也不该为它再花一次 embedding 钱——但它同样是"原话"，所以并进**短语索引**：
+# `search --phrase` 于是能搜到语音说过什么，而语音是微信自己搜不到的东西。
+VOICE_JSONL = INDEX_DIR.parent / '.voice_index' / 'voices.jsonl'
+
 
 def escape_phrase(query):
     """把整串当**字面量**（而不是 FTS 语法）：外层加引号，内部 `"` 翻倍。"""
@@ -1224,6 +1229,33 @@ def build_phrase_index(line: str = 'all', db_path=None, meta_path=None):
         rows.append((text, str(item.get('id') or ''), key, _phrase_label(item),
                      str(item.get('date') or item.get('time') or ''),
                      str(item.get('title') or '')))
+
+    # 语音转写并进同一条短语线（`type='voice'`）。`--line chat|wiki` 时**不**带它——
+    # 那两条线是用户明确限定的范围，语音属于第三类证据。
+    #
+    # 路径**在这里现算**（挂在 `OUTPUT_ROOT` 下），不写成模块级常量：常量在 import 时就固定，
+    # 测试把 `OUTPUT_ROOT` 指到临时目录后仍会读到真实 `output/` 里的语音，于是
+    # "3 条记录"变成 8 条（2026-10-22 就是这么红的）。
+    if types is None:
+        voice_file = Path(OUTPUT_ROOT) / '.voice_index' / 'voices.jsonl'
+        voice_rows = 0
+        if voice_file.exists():
+            try:
+                for line_text in voice_file.read_text(encoding='utf-8').splitlines():
+                    if not line_text.strip():
+                        continue
+                    rec = json.loads(line_text)
+                    body = str(rec.get('text') or '').strip()
+                    if len(body) < PHRASE_MIN_CHARS:
+                        continue
+                    rows.append((body, str(rec.get('id') or ''), 'voice',
+                                 str(rec.get('talker') or ''), str(rec.get('time') or ''), ''))
+                    voice_rows += 1
+            except Exception as exc:
+                print(f'[WARN] 读语音转写失败（{type(exc).__name__}: {exc}），这次不并入',
+                      file=sys.stderr)
+        if voice_rows:
+            by_line['voice'] = by_line.get('voice', 0) + voice_rows
     path = Path(db_path or PHRASE_DB)
     path.parent.mkdir(parents=True, exist_ok=True)
     conn = sqlite3.connect(str(path))

package/scripts/voice_transcribe.py

@@ -0,0 +1,139 @@
+"""批量转写语音消息，产出一份可检索的清单（`output/.voice_index/voices.jsonl`）。
+
+为什么要有它：`wechat_voice.py` 只能一条会话一条会话地转，转完就躺在一个按**内容哈希**
+命名的缓存里——**知道"这段音频说了什么"，但不知道"是哪条消息、谁在什么时候发的"**。
+而检索需要的正是后者。
+
+所以这里做三件事：
+  1. 从 `media_*.db` 的 `VoiceInfo` 按时间取语音（带上会话、发送者、时间）；
+  2. 调 `wechat_voice.ensure_transcripts` 填空缺（断点续传：已转过的按内容命中缓存）；
+  3. 把 `(消息, 时间, 会话, 文本)` 落成 JSONL，供 `phrase-build` 并进 FTS。
+
+用法：
+    python scripts/voice_transcribe.py --days 30
+    python scripts/voice_transcribe.py --days 7 --limit 5      # 先试几条
+    python scripts/voice_transcribe.py --days 30 --model tiny  # 更快、更糙
+"""
+from __future__ import annotations
+
+import argparse
+import json
+import pathlib
+import sys
+import time
+from datetime import datetime, timezone, timedelta
+
+SCRIPT_DIR = pathlib.Path(__file__).resolve().parent
+sys.path.insert(0, str(SCRIPT_DIR))
+
+from _utils import load_config, decrypt_lock  # noqa: E402
+import wechat_voice as wv  # noqa: E402
+
+ROOT = SCRIPT_DIR.parent
+OUT_DIR = ROOT / 'output' / '.voice_index'
+CACHE_DIR = ROOT / 'output' / '.voice_cache'
+TZ = timezone(timedelta(hours=8))
+
+
+def _keys(cfg):
+    """配置里的密钥是 `lock:` 密文，必须先解密 —— 直接拿密文去派生只会得到"不是数据库"。"""
+    key = decrypt_lock(cfg.get('ntKey', '') or '')
+    salt = decrypt_lock(cfg.get('ntSalt', '') or '')
+    pw = decrypt_lock(cfg.get('favPassphrase', '') or cfg.get('decryptKey', '') or '')
+    return key, salt, pw
+
+
+def collect(cfg, days, limit=0):
+    """[(shard, chat_name_id, local_id, create_time, blob, name)]，按时间倒序。"""
+    key, salt, pw = _keys(cfg)
+    db = cfg.get('ntDbPath') or ''
+    if not db:
+        raise SystemExit('配置里没有 ntDbPath')
+    since = int(time.time()) - days * 86400
+    rows = []
+    for shard in wv.voice_shards(db):
+        conn = None
+        try:
+            conn, cur = wv._open(shard, key, salt, pw)
+            cur.execute('SELECT rowid, user_name FROM Name2Id')
+            names = {r[0]: r[1] for r in cur.fetchall()}
+            cur.execute(
+                'SELECT chat_name_id, local_id, create_time, voice_data FROM VoiceInfo '
+                'WHERE voice_data IS NOT NULL AND create_time >= ? '
+                'ORDER BY create_time DESC', (since,))
+            for cid, lid, ts, blob in cur.fetchall():
+                rows.append((str(shard), cid, lid, int(ts or 0), blob,
+                         names.get(cid, str(cid))))
+        except Exception as exc:
+            print(f'[WARN] {pathlib.Path(shard).name} 读不了（{type(exc).__name__}: {exc}）',
+                  file=sys.stderr)
+        finally:
+            if conn:
+                conn.close()
+    rows.sort(key=lambda r: r[3], reverse=True)
+    if limit and limit > 0:
+        rows = rows[:limit]
+
+    # 会话名从 **contact.db** 补一层：消息库的 `Name2Id` 只有 id，语音清单里
+    # 只写 id 的话，搜索结果显示成 `wxid_xxx`（2026-10-22 第一版就是这样）。
+    try:
+        from network import load_graph
+        people, _rooms, _members = load_graph(cfg)
+        by_username = {p['username']: (p['remark'] or p['nick'] or p['username'])
+                       for p in people.values()}
+        rows = [(s, c, l, t, b, by_username.get(name, name)) for s, c, l, t, b, name in rows]
+    except Exception as exc:
+        print(f'[WARN] 读联系人失败（{type(exc).__name__}: {exc}），语音清单里显示 id',
+              file=sys.stderr)
+    return rows
+
+
+def main():
+    ap = argparse.ArgumentParser(description='批量转写微信语音，产出可检索清单')
+    ap.add_argument('--days', type=int, default=30, help='只转最近 N 天（默认 30）')
+    ap.add_argument('--limit', type=int, default=0, help='最多转写几条（0 = 不限）')
+    ap.add_argument('--model', default='small', help='faster-whisper 模型名或本地目录')
+    ap.add_argument('--language', default='zh', help='语言提示')
+    ap.add_argument('--cache-dir', default='', help='转写缓存目录（换模型时换一个，否则会命中旧模型的结果）')
+    args = ap.parse_args()
+
+    cfg = load_config()
+    rows = collect(cfg, args.days, args.limit)
+    print(f'最近 {args.days} 天语音: {len(rows)} 条')
+    if not rows:
+        return 0
+    cache_dir = args.cache_dir or str(CACHE_DIR)
+    pathlib.Path(cache_dir).mkdir(parents=True, exist_ok=True)
+
+    voices = {(r[5], r[2]): r[4] for r in rows}
+    started = time.time()
+    processed, cached, failed = wv.ensure_transcripts(
+        voices, cache_dir, model_name=args.model, language=args.language)
+    elapsed = time.time() - started
+    print(f'转写完成: 新增 {processed}，缓存命中 {cached}，失败 {failed}，耗时 {elapsed/60:.1f} 分钟')
+
+    cache = wv.TranscriptCache(cache_dir)
+    OUT_DIR.mkdir(parents=True, exist_ok=True)
+    out = OUT_DIR / 'voices.jsonl'
+    written = empty = 0
+    with out.open('w', encoding='utf-8') as fh:
+        for shard, cid, lid, ts, blob, name in rows:
+            text = (cache.get(wv.voice_key(blob)) or '').strip()
+            if not text:
+                empty += 1
+                continue
+            dt = datetime.fromtimestamp(ts, tz=TZ)
+            fh.write(json.dumps({
+                'id': f'voice:{name}:{lid}',
+                'talker': name,
+                'time': dt.strftime('%Y-%m-%d %H:%M'),
+                'ts': ts,
+                'text': text[:500],
+            }, ensure_ascii=False) + '\n')
+            written += 1
+    print(f'写入 {out}：{written} 条有文字（空转写/解码失败 {empty} 条）')
+    return 0
+
+
+if __name__ == '__main__':
+    sys.exit(main())

package/scripts/wechat_emoticon.py

@@ -56,7 +56,7 @@ def derive_key(seed, wxid):
 
 
 def account_wxid(account_dir_name):
-    """`wxid_mgnjdl8034eh22_4c8e` -> `wxid_mgnjdl8034eh22`."""
+    """`wxid_账号A_后缀` -> `wxid_账号A`."""
     parts = account_dir_name.rsplit('_', 1)
     return parts[0] if len(parts) == 2 and len(parts[1]) == 4 else account_dir_name
 

package/scripts/wechat_voice.py

@@ -234,10 +234,35 @@ class TranscriptCache:
 
 
 def transcribe_wav(wav_path, model, beam_size=1, language=DEFAULT_LANGUAGE):
-    """Transcript for a WAV file, or '' when nothing was recognised."""
+    """Transcript for a WAV file, or '' when nothing was recognised.
+
+    `condition_on_previous_text=False` 是**针对复读**的：Whisper 会把已生成的文本当作
+    后续解码的上文条件，在听不清的时候这个条件会把同一句反复"确认"下去（实测同一段
+    方言语音稳定输出「我做的事情都没有做过」三遍）。关掉它以后每段独立解码，复读的
+    自我强化链就断了。`vad_filter` 再切掉静音——短语音里静音占比高时最容易触发幻觉。
+    """
     try:
-        segments, _ = model.transcribe(wav_path, language=language, beam_size=beam_size)
+        segments, _ = model.transcribe(
+            wav_path, language=language, beam_size=beam_size,
+            condition_on_previous_text=False,
+            vad_filter=True,
+            vad_parameters={'min_silence_duration_ms': 300},
+            no_speech_threshold=0.6,
+            # 复读的第二道闸：`compression_ratio_threshold` 判"这段输出是不是在重复自己"，
+            # 超了就提高温度重解（默认 2.4，实测偏松）；`temperature` 给一条回退阶梯，
+            # 让它在重复时真的敢走下一步而不是原地复读。
+            compression_ratio_threshold=2.0,
+            temperature=[0.0, 0.2, 0.4, 0.6, 0.8, 1.0],
+            repetition_penalty=1.15,
+        )
         return ''.join(segment.text for segment in segments).strip()
+    except TypeError:
+        # 老版本 faster-whisper 不认这些关键字：退回最朴素的调用，别因为参数报错丢掉转写。
+        try:
+            segments, _ = model.transcribe(wav_path, language=language, beam_size=beam_size)
+            return ''.join(segment.text for segment in segments).strip()
+        except Exception:
+            return ''
     except Exception:
         return ''