argo-search 2.9.7 → 2.9.8

package/sub-skills/local-seek/tests/test_content_rank.py

@@ -1,222 +0,0 @@
-#!/usr/bin/env python3
-"""tests/test_content_rank.py — 内容 BM25F 重排 + fzf V2 评分契约（2026-10-07 方案甲）。
-
-守四类不变式：
-  A. 重排闸门：逃生门/正则查询/count/context 一律保持 (路径,行号) 原序
-  B. 重排质量：文件名命中 > 纯行命中；多词全覆盖 > 单词擦边；噪声档
-     分层在重排后依然成立（真源在前）
-  C. 确定性：打分只依赖内容，发射序打乱输出逐位一致（2026-10-06 契约延续）
-  D. fzf V2：边界/驼峰/连续/gap 惩罚的相对次序与 fzf 口径一致，全等最优
-
-打桩纪律：unittest.mock.patch.object（自动恢复）——直接给 s.run 赋值且
-不恢复会把同进程后续测试的真实 rg 顶掉（2026-10-06 实锤教训，见
-test_determinism_20261006.py 模块头）。
-"""
-
-from __future__ import annotations
-
-import subprocess
-import sys
-import unittest
-from pathlib import Path
-from unittest.mock import patch
-
-ROOT = Path(__file__).resolve().parent.parent
-sys.path.insert(0, str(ROOT / "scripts"))
-
-import seek as s  # noqa: E402
-import seek_rank as r  # noqa: E402
-
-
-def _proc(stdout: str, rc: int = 0) -> subprocess.CompletedProcess:
-    return subprocess.CompletedProcess(args=[], returncode=rc,
-                                       stdout=stdout, stderr="")
-
-
-class TestRerankGate(unittest.TestCase):
-    """A. 闸门：不该重排的场景必须保持 (路径,行号) 原序。"""
-
-    ROWS = [
-        ("b/beta.py", 5, "alpha"),
-        ("a/alpha.py", 9, "alpha"),
-        ("c/gamma.md", 1, "alpha"),
-    ]
-
-    def _search(self, raw_query, fixed=True, ctx=0, count=False):
-        with patch.object(s, "run", return_value=_proc("a/x.py:1:hit\n")):
-            # 直接对池行调用重排闸门（不走 rg，隔离网络与文件系统）
-            return s._rerank_content(list(self.ROWS), raw_query, ctx, count, fixed)
-
-    def test_escape_hatch_restores_order(self):
-        import os
-        old = os.environ.pop("ARGO_SEEK_CONTENT_RERANK", None)
-        os.environ["ARGO_SEEK_CONTENT_RERANK"] = "0"
-        try:
-            self.assertEqual(self._search("alpha"), self.ROWS)
-        finally:
-            os.environ.pop("ARGO_SEEK_CONTENT_RERANK", None)
-            if old is not None:
-                os.environ["ARGO_SEEK_CONTENT_RERANK"] = old
-
-    def test_regex_query_not_reranked(self):
-        # fixed=False（正则/PCRE2）：词元切分只会产生碎片，闸门必须放行原序
-        self.assertEqual(self._search(r"\d{4}", fixed=False), self.ROWS)
-
-    def test_count_and_context_not_reranked(self):
-        self.assertEqual(self._search("alpha", count=True), self.ROWS)
-        self.assertEqual(self._search("alpha", ctx=3), self.ROWS)
-
-    def test_no_token_query_not_reranked(self):
-        self.assertEqual(self._search("!!!"), self.ROWS)
-
-
-class TestRerankQuality(unittest.TestCase):
-    """B. 重排质量：相关度次序的三条核心判据。"""
-
-    def test_filename_match_beats_content_only(self):
-        rows = [
-            ("docs/notes.md", 12, "支持噪声档降权的说明文字。"),
-            ("src/noise_tier.py", 3, "placeholder"),
-            ("src/other.py", 8, "噪声相关但文件无关。"),
-        ]
-        out = r.rank_rows(rows, "noise_tier")
-        self.assertEqual(out[0][0], "src/noise_tier.py")
-
-    def test_multi_token_coverage_beats_partial(self):
-        rows = [
-            ("a/one.md", 1, "只提到缓存一个词。"),
-            ("b/both.md", 2, "语义缓存与 minhash 软命中都在这行。"),
-        ]
-        out = r.rank_rows(rows, "语义缓存 minhash")
-        self.assertEqual(out[0][0], "b/both.md")
-
-    def test_verbatim_phrase_beats_bigram_scatter(self):
-        # 二元组分不清「噪声档的实现行」与「只有噪声二字的无关行」：
-        # 逐字短语加成必须把前者顶上去
-        rows = [
-            ("a/x.md", 1, "设备噪声很大。"),
-            ("b/y.py", 2, "噪声档的阈值定义在此。"),
-        ]
-        out = r.rank_rows(rows, "噪声档")
-        self.assertEqual(out[0][0], "b/y.py")
-
-    def test_ties_break_by_path_line(self):
-        rows = [("b.py", 2, "same"), ("a.py", 9, "same"), ("a.py", 1, "same")]
-        out = r.rank_rows(rows, "same")
-        self.assertEqual([(p, l) for p, l, _ in out],
-                         [("a.py", 1), ("a.py", 9), ("b.py", 2)])
-
-    def test_noise_floor_after_rerank(self):
-        # 重排改变池内次序后，噪声档分层（真源在前）必须依然成立——
-        # 分层发生在 rg_search 的 _apply_noise_floor（重排之后），走全链路验证
-        rows = [
-            "tmp/x.py:1:noise tier keyword",
-            "src/y.py:2:noise tier keyword here",
-        ]
-        with patch.object(s, "run", return_value=_proc("\n".join(rows) + "\n")):
-            out, err = s.rg_search(["noise"], ".", [], [], 0, False, 5,
-                                   fixed=True, raw_query="noise tier keyword")
-        self.assertIsNone(err)
-        self.assertTrue(out, "真源行不应消失")
-        self.assertTrue(out[0][0].startswith("src/"),
-                        f"真源应排最前，实际: {out[0][0]}")
-
-
-class TestRerankDeterminism(unittest.TestCase):
-    """C. 确定性：打平发射序（2026-10-06 契约在重排开启下延续）。"""
-
-    def test_output_independent_of_emission_order(self):
-        rows = [f"src/f{i:03d}.py:{j + 1}:alpha beta hit {i}-{j}"
-                for i in range(40) for j in range(1)]
-        with patch.object(s, "run", return_value=_proc("\n".join(rows) + "\n")):
-            a, err = s.rg_search(["alpha"], ".", [], [], 0, False, 5,
-                                 fixed=True, raw_query="alpha beta")
-            import random
-            shuffled = rows[:]
-            random.Random(7).shuffle(shuffled)
-            with patch.object(s, "run", return_value=_proc("\n".join(shuffled) + "\n")):
-                b, err2 = s.rg_search(["alpha"], ".", [], [], 0, False, 5,
-                                      fixed=True, raw_query="alpha beta")
-        self.assertIsNone(err)
-        self.assertIsNone(err2)
-        self.assertEqual(a, b)
-
-
-class TestFzfV2(unittest.TestCase):
-    """D. fzf FuzzyMatchV2 口径。"""
-
-    def test_no_match_is_zero(self):
-        self.assertEqual(s._fzf_score("zzz.txt", "rep"), 0)
-
-    def test_smart_case(self):
-        self.assertGreater(s._fzf_score("Report_v2.md", "report"), 0)
-        # 模式带大写 → 区分大小写：R 匹配、r 不配
-        self.assertEqual(s._fzf_score("report.md", "R"), 0)
-
-    def test_boundary_beats_midword(self):
-        # bar 在 foo_bar（词边界）> xbarx（词中）
-        self.assertGreater(s._fzf_score("foo_bar.py", "bar"),
-                           s._fzf_score("xbarx.py", "bar"))
-
-    def test_consecutive_beats_gappy(self):
-        self.assertGreater(s._fzf_score("xabc.md", "abc"),
-                           s._fzf_score("axbxc.md", "abc"))
-
-    def test_camel_bonus(self):
-        self.assertGreater(s._fzf_score("parseHTTPResponse.py", "hr"), 0)
-
-    def test_dp_optimal_alignment(self):
-        # xaabc 搜 ab：DP 应发现「跳过词首 a、取边界 b」的对齐优于顺位连打
-        # （顺位贪心：a@1 + b@4 有 gap；最优：a@1 + b@4 不如 a@3?——此处锚定
-        # 已知反超事实：xaabc 的分必须高于等长无边界对照 axbxc 的同模式分）
-        self.assertGreater(s._fzf_score("xaabc", "ab"),
-                           s._fzf_score("axbxc", "ab"))
-
-    def test_exact_beats_partial(self):
-        self.assertGreater(s._fzf_score("seek.py", "seek.py"),
-                           s._fzf_score("seek_helper.py", "seek.py"))
-
-    def test_exact_case_beats_icase(self):
-        self.assertGreaterEqual(s._fzf_score("Seek.py", "seek.py"),
-                                s._fzf_score("seek.py", "seek.py")
-                                )  # 全等大写版含 case bonus，不小于纯 icase
-
-
-class TestFrecencyWiring(unittest.TestCase):
-    """frecency 默认关闭：不启用时不产生任何行为差异。"""
-
-    def test_disabled_by_default(self):
-        import os
-        old = os.environ.pop("ARGO_SEEK_FRECENCY", None)
-        try:
-            import seek_frecency
-            self.assertFalse(seek_frecency.enabled())
-            self.assertEqual(seek_frecency.boost("/any/path"), 0.0)
-        finally:
-            if old is not None:
-                os.environ["ARGO_SEEK_FRECENCY"] = old
-
-    def test_boost_and_record_roundtrip(self):
-        import os
-        import tempfile
-        old_flag = os.environ.pop("ARGO_SEEK_FRECENCY", None)
-        old_db = os.environ.pop("ARGO_SEEK_FRECENCY_DB", None)
-        with tempfile.TemporaryDirectory() as td:
-            os.environ["ARGO_SEEK_FRECENCY"] = "1"
-            os.environ["ARGO_SEEK_FRECENCY_DB"] = str(Path(td) / "f.json")
-            try:
-                import seek_frecency
-                seek_frecency.record(["/a/b.py", "/c/d.py"])
-                self.assertGreater(seek_frecency.boost("/a/b.py"), 0.0)
-                self.assertEqual(seek_frecency.boost("/z/missing.py"), 0.0)
-            finally:
-                os.environ.pop("ARGO_SEEK_FRECENCY", None)
-                os.environ.pop("ARGO_SEEK_FRECENCY_DB", None)
-                if old_flag is not None:
-                    os.environ["ARGO_SEEK_FRECENCY"] = old_flag
-                if old_db is not None:
-                    os.environ["ARGO_SEEK_FRECENCY_DB"] = old_db
-
-
-if __name__ == "__main__":
-    unittest.main()

package/sub-skills/local-seek/tests/test_determinism_20261006.py

@@ -1,145 +0,0 @@
-#!/usr/bin/env python3
-"""tests/test_determinism_20261006.py — 宽查询输出确定性回归（方案一，2026-10-06）。
-
-守 v1.4.1 审计遗留的定性修复：
-  1. rg 并行遍历发射序不定 →「先到先得」截断拿到任意的 cap 条，同查询
-     两次跑结果集与排序都不同。修复后有界堆按 (路径,行号,内容) 选池，
-     **同一命中集无论以什么顺序发射，输出逐条一致**。
-  2. count 模式并列计数按路径升序决出稳定次序。
-  3. grep 兜底路径同款语义。
-  4. 锁定 ja/ko 2-gram 既有行为（CJK_RE 覆盖假名/谚文——2026-10-06 实测
-     已支持，修正审计记忆里「无分词只能整词匹配」的过时记录）。
-
-打桩纪律：一律 unittest.mock.patch.object（自动恢复）。首版直接给
-s.run 赋值且不恢复，把同进程后续测试的真实 rg 全部替换成假输出——
-套件 9 红的根因（2026-10-06 实锤，教训记录在此防再犯）。
-"""
-
-from __future__ import annotations
-
-import subprocess
-import sys
-import unittest
-from pathlib import Path
-from unittest.mock import patch
-
-ROOT = Path(__file__).resolve().parent.parent
-sys.path.insert(0, str(ROOT / "scripts"))
-
-import seek as s  # noqa: E402
-
-
-def _proc(stdout: str, rc: int = 0) -> subprocess.CompletedProcess:
-    return subprocess.CompletedProcess(args=[], returncode=rc,
-                                       stdout=stdout, stderr="")
-
-
-def _matches(n_files: int, lines_per: int = 1) -> list[str]:
-    """n_files 个文件的 rg 命中行（路径 f{i:03d}.py 保证字典序可控）。"""
-    out = []
-    for i in range(n_files):
-        for j in range(lines_per):
-            out.append(f"src/f{i:03d}.py:{j + 1}:hit {i}-{j}")
-    return out
-
-
-class RgBodyDeterminism(unittest.TestCase):
-    """rg 主体路径：池子选择与发射序无关。"""
-
-    def test_output_independent_of_emission_order(self):
-        rows = _matches(40)
-        # max_results=5 → cap = max(5, min(20, 400)) = 20：命中 40 > cap，
-        # 池子选择真正发生截断
-        for drop_noise in (True, False):
-            with self.subTest(drop_noise=drop_noise):
-                with patch.object(s, "run",
-                                  return_value=_proc("\n".join(rows) + "\n")):
-                    a, err = s.rg_search(["q"], ".", [], [], 0, False, 5,
-                                         fixed=True, drop_noise=drop_noise)
-                with patch.object(s, "run",
-                                  return_value=_proc(
-                                      "\n".join(reversed(rows)) + "\n")):
-                    b, err2 = s.rg_search(["q"], ".", [], [], 0, False, 5,
-                                          fixed=True, drop_noise=drop_noise)
-                self.assertIsNone(err)
-                self.assertIsNone(err2)
-                self.assertEqual(a, b, "同一命中集、不同发射序 → 输出必须一致")
-
-    def test_pool_is_path_smallest_and_sorted(self):
-        rows = _matches(40)
-        with patch.object(s, "run",
-                          return_value=_proc("\n".join(rows) + "\n")):
-            out, err = s.rg_search(["q"], ".", [], [], 0, False, 5,
-                                   fixed=True, drop_noise=False)
-        self.assertIsNone(err)
-        self.assertEqual([r[0] for r in out],
-                         [f"src/f{i:03d}.py" for i in range(5)])
-        self.assertEqual(len(out), 5)
-
-    def test_noise_floor_layering_deterministic(self):
-        """clean 在前 noisy 在后的分层语义在确定池子上仍然成立。"""
-        rows = (["src/clean_{:03d}.py:1:hit".format(i) for i in range(30)]
-                + ["src/repos/lib_{:03d}.py:1:hit".format(i) for i in range(30)])
-        outs = []
-        for order in (rows, list(reversed(rows))):
-            with patch.object(s, "run",
-                              return_value=_proc("\n".join(order) + "\n")):
-                out, err = s.rg_search(["q"], ".", [], [], 0, False, 5,
-                                       fixed=True, drop_noise=True)
-            self.assertIsNone(err)
-            outs.append(out)
-        self.assertEqual(outs[0], outs[1])
-        self.assertTrue(all("/repos/" not in r[0] for r in outs[0]),
-                        "clean 够数时噪声档不得混入")
-
-
-class CountTieDeterminism(unittest.TestCase):
-    def test_equal_counts_sorted_by_path(self):
-        rows = ["src/b.py:5", "src/a.py:5", "src/c.py:2"]
-        with patch.object(s, "run",
-                          return_value=_proc("\n".join(rows) + "\n")):
-            out, err = s.rg_search(["q"], ".", [], [], 0, True, 10,
-                                   fixed=True, drop_noise=False)
-        self.assertIsNone(err)
-        self.assertEqual([r[0] for r in out],
-                         ["src/a.py", "src/b.py", "src/c.py"])
-
-
-class GrepFallbackDeterminism(unittest.TestCase):
-    def test_body_and_count_deterministic(self):
-        rows = _matches(40)
-        for order in (rows, list(reversed(rows))):
-            with patch.object(s, "run",
-                              return_value=_proc("\n".join(order) + "\n")):
-                body, err = s.grep_search("grep", ["q"], ".", [], [], 0,
-                                          False, 5, fixed=True)
-            self.assertIsNone(err)
-            self.assertEqual([r[0] for r in body],
-                             [f"src/f{i:03d}.py" for i in range(5)])
-        cnt_rows = ["src/b.py:5", "src/a.py:5"]
-        with patch.object(s, "run",
-                          return_value=_proc("\n".join(cnt_rows) + "\n")):
-            cnt, err = s.grep_search("grep", ["q"], ".", [], [], 0,
-                                     True, 10, fixed=True)
-        self.assertIsNone(err)
-        self.assertEqual([r[0] for r in cnt], ["src/a.py", "src/b.py"])
-
-
-class JaKoBigramLocked(unittest.TestCase):
-    """锁定既有行为（实测于 2026-10-06）：CJK_RE 已覆盖假名/谚文。"""
-
-    def test_japanese_compound_gets_bigrams(self):
-        pats, literal = s.build_patterns("プロンプトエンジニアリング入門")
-        self.assertIn("プロンプトエンジニアリング入門", pats)  # 整词
-        self.assertIn("プロ", pats)                            # 首个 2-gram
-        self.assertTrue(literal)
-
-    def test_korean_spaced_words_and_compound(self):
-        pats, _ = s.build_patterns("프로프트 검색 설정")
-        self.assertIn("프로프트", pats)   # 复合词整词
-        self.assertIn("프로", pats)       # 复合词 2-gram
-        self.assertIn("검색", pats)       # 空格分隔词保持整词
-
-
-if __name__ == "__main__":
-    unittest.main()

package/sub-skills/local-seek/tests/test_noise_tier.py

@@ -1,101 +0,0 @@
-#!/usr/bin/env python3
-"""噪声档降权的回归测试（2026-09-27 新增，方案 C3）。
-
-实测背景（Documents/GPT 搜 "import"，rg 61899 处命中）：
-    vendor/生成物/归档  7% + 测试/fixture/benchmark  27% + tmp/  7% = 41%
-搜代码时，四成命中是「不想看到的东西」。原来的 DEFAULT_EXCLUDES 挡掉了
-node_modules/dist 之类，但漏了三类最大的：repos/（克隆仓）、tests|fixtures|
-benchmark、tmp/。
-
-**为什么是降权不是排除**：排除 = 这些内容永远搜不到。搜「某个克隆仓里怎么
-写的」「我的测试怎么写的」是真实且常见的用法，排除会让工具在这些查询上
-直接回答「未找到匹配」——那比返回噪声更糟。降权 + 无命中自动回落，两者兼得。
-
-本文件锁定的性质：
-  1. 默认搜不到噪声档内容（降权生效）；
-  2. 噪声档独有内容**仍可达**（回落生效，不制造「明明有却搜不到」）；
-  3. --include-noise 显式关闭降权；
-  4. 回落不影响正常命中（有真源时不去噪声档白跑一趟）。
-"""
-from __future__ import annotations
-
-import os
-import subprocess
-import sys
-from pathlib import Path
-
-SEEK = Path(__file__).resolve().parent.parent / "scripts" / "seek.py"
-
-
-def _have(*tools) -> bool:
-    import shutil
-    return all(shutil.which(t) for t in tools)
-
-
-def _run(args, cwd):
-    return subprocess.run([sys.executable, str(SEEK)] + args, cwd=cwd,
-                          capture_output=True, text=True, timeout=120)
-
-
-def _make_tree(root: Path):
-    """构造一棵含「真实源」与「噪声档」两类内容的最小目录树。
-
-    标记词刻意选 `zzmarker_*`：pytest 的 tmp_path 目录名会带测试函数名
-    （如 `test_noise_tier_is_deprioritiz0`），若标记词是 `pytest` 之类，
-    路径本身就会命中，测试变成在验证「路径里有这个词」而非「噪声档降权」。
-    这是第一版用例写错的地方。
-    """
-    (root / "src").mkdir(parents=True)
-    (root / "src" / "app.py").write_text("import os\nimport sys\n", encoding="utf-8")
-    (root / "repos" / "thirdparty").mkdir(parents=True)
-    (root / "repos" / "thirdparty" / "lib.py").write_text(
-        "import zzzarker_clonelib\n", encoding="utf-8")
-    (root / "tests").mkdir()
-    (root / "tests" / "test_x.py").write_text(
-        "import zzzarker_fixture\n", encoding="utf-8")
-
-
-def test_noise_tier_is_deprioritized_and_reachable(tmp_path):
-    if not _have("rg"):
-        import pytest
-        pytest.skip("rg 未安装")
-    _make_tree(tmp_path)
-    proj = str(tmp_path)
-
-    # 噪声档独有内容：搜得到（相对根判定，本例的 tests/ 在根之下），
-    # 且**不触发**回落重搜——它本来就没被排除，只是被排到真源之后。
-    r = _run(["zzzarker_fixture", "--path", proj], tmp_path)
-    assert "test_x.py" in r.stdout, r.stdout
-    assert "噪声档" not in r.stdout, "没被排除就不该多跑一趟回落"
-
-    # 正常源：不受降权影响
-    r2 = _run(["import", "--path", proj], tmp_path)
-    assert "app.py" in r2.stdout, r2.stdout
-
-
-def test_deprioritized_means_source_wins(tmp_path):
-    """同一查询同时命中真源与噪声档时，真源必须排在前面。"""
-    if not _have("rg"):
-        import pytest
-        pytest.skip("rg 未安装")
-    (tmp_path / "src").mkdir()
-    (tmp_path / "src" / "real.py").write_text("import shared_token\n", encoding="utf-8")
-    (tmp_path / "repos").mkdir()
-    (tmp_path / "repos" / "copy.py").write_text("import shared_token\n", encoding="utf-8")
-    proj = str(tmp_path)
-
-    r = _run(["shared_token", "--path", proj, "--max", "1"], tmp_path)
-    assert "real.py" in r.stdout, r.stdout
-    assert "copy.py" not in r.stdout, r.stdout
-
-
-def test_include_noise_flag_is_explicit(tmp_path):
-    if not _have("rg"):
-        import pytest
-        pytest.skip("rg 未安装")
-    _make_tree(tmp_path)
-    proj = str(tmp_path)
-    r = _run(["zzzarker_fixture", "--path", proj, "--include-noise"], tmp_path)
-    assert "test_x.py" in r.stdout, r.stdout
-    # 显式开启时不应再回落（那会多跑一趟）
-    assert "噪声档" not in r.stdout, r.stdout

package/sub-skills/local-seek/tests/test_pcre2_probe.py

@@ -1,136 +0,0 @@
-#!/usr/bin/env python3
-"""pcre2 判据回归测试（2026-09-27）。
-
-守的缺陷：`pcre2_supported()` 曾用「跑一次匹配看返回码」判定 rg 是否支持 PCRE2：
-
-    proc = run(["rg", "--pcre2", "-e", "x", os.devnull])
-    _pcre2_ok = proc is not None and proc.returncode == 0
-
-`/dev/null` 永远没有匹配，rg 无匹配时返回 1，于是判据恒为 False——本机
-rg 明明带 +pcre2，却永远被判为「未编译 PCRE2」，所有 look-around /
-反向引用查询被拒绝（用户可见的报错：「请简化查询」）。
-
-根因是**判据的观察量与被判定的性质无关**：探测目标的匹配结果说明不了
-二进制是否带某个特性。修法改读 `rg --version` 的 features 行。
-
-这组测试把「返回码语义」钉死：只 mock run() 的返回值，覆盖
-  - features 行含 +pcre2 → True
-  - features 行是 -pcre2 → False
-  - rg 不存在（run 返回 None）→ False
-  - 只判 features 行，不被「匹配有无」影响（原缺陷的形态）
-
-运行：
-  cd ~/.agents/skills/argo
-  python3 -m pytest sub-skills/local-seek/tests/test_pcre2_probe.py -q
-"""
-
-from __future__ import annotations
-
-import subprocess
-import sys
-import unittest
-from pathlib import Path
-from unittest import mock
-
-SCRIPTS = Path(__file__).resolve().parent.parent / "scripts"
-sys.path.insert(0, str(SCRIPTS))
-
-import seek as s  # noqa: E402
-
-
-def _proc(stdout: str, returncode: int = 0):
-    p = mock.Mock()
-    p.stdout = stdout
-    p.returncode = returncode
-    return p
-
-
-class TestPcre2Probe(unittest.TestCase):
-    def setUp(self):
-        # 模块级缓存必须在每个用例前清掉，否则第一个用例的结果会被后续复用
-        self._saved = s._pcre2_ok
-        s._pcre2_ok = None
-        self.addCleanup(lambda: setattr(s, "_pcre2_ok", self._saved))
-
-    def test_features_line_with_pcre2_is_true(self):
-        """正面：features:+pcre2 → 支持（本机 rg 15.0.0 的真实形态）。"""
-        out = "ripgrep 15.0.0 (rev 3a612f88b8)\n\nfeatures:+pcre2\nsimd(compile):+NEON\n"
-        with mock.patch.object(s, "run", return_value=_proc(out)):
-            self.assertTrue(s.pcre2_supported())
-
-    def test_features_line_without_pcre2_is_false(self):
-        """反面：features 行明确是 -pcre2 → 不支持，走 grep 回退。"""
-        out = "ripgrep 13.0.0\n\nfeatures:-pcre2\n"
-        with mock.patch.object(s, "run", return_value=_proc(out)):
-            self.assertFalse(s.pcre2_supported())
-
-    def test_missing_rg_is_false(self):
-        """rg 不存在时 run() 返回 None → False（不得抛异常）。"""
-        with mock.patch.object(s, "run", return_value=None):
-            self.assertFalse(s.pcre2_supported())
-
-    def test_does_not_depend_on_match_result(self):
-        """核心回归：判据不得再依赖「有没有匹配」。
-
-        原缺陷的形态是 `returncode == 0`——把「无匹配(1)」误读成「不支持」。
-        这里给一个**无匹配语义**的返回码 1 但 features 行含 +pcre2，
-        新判据必须仍判 True。若有人把它改回看返回码，本用例会红。
-        """
-        out = "ripgrep 15.0.0\n\nfeatures:+pcre2\n"
-        with mock.patch.object(s, "run", return_value=_proc(out, returncode=1)):
-            self.assertTrue(s.pcre2_supported(),
-                            "判据又依赖返回码了：无匹配(rc=1)被误读成不支持 PCRE2")
-
-    def test_probe_targets_version_not_a_match_run(self):
-        """确认探测命令本身是 --version，而不是「跑一次匹配」。"""
-        captured = {}
-
-        def _fake(cmd, **kwargs):
-            captured["cmd"] = cmd
-            return _proc("ripgrep 15.0.0\nfeatures:+pcre2\n")
-
-        with mock.patch.object(s, "run", side_effect=_fake):
-            s.pcre2_supported()
-        self.assertIn("--version", captured["cmd"],
-                      "探测命令必须是 rg --version（读特性声明），不是匹配探测")
-
-    def test_module_cache_avoids_repeated_probe(self):
-        """缓存语义：只探一次，第二次不再调 run()。"""
-        calls = []
-
-        def _fake(cmd, **kwargs):
-            calls.append(cmd)
-            return _proc("ripgrep 15.0.0\nfeatures:+pcre2\n")
-
-        with mock.patch.object(s, "run", side_effect=_fake):
-            s.pcre2_supported()
-            s.pcre2_supported()
-            s.pcre2_supported()
-        self.assertEqual(len(calls), 1, "模块级缓存失效，重复探测")
-
-
-class TestPcre2EndToEnd(unittest.TestCase):
-    """真机对照：本机 rg 带 +pcre2 时，look-around 查询真的能出结果。
-
-    不断言「一定支持」（别的机器可能没有），而是断言**判据与真机能力一致**：
-    先读 rg --version 拿真值，再要求 pcre2_supported() 与之一致。
-    """
-
-    def test_agrees_with_real_rg(self):
-        try:
-            real = subprocess.run(["rg", "--version"], capture_output=True,
-                                  text=True, timeout=10)
-        except (FileNotFoundError, subprocess.TimeoutExpired):
-            self.skipTest("本机无 rg，跳过真机对照")
-        truth = "+pcre2" in (real.stdout or "")
-        saved = s._pcre2_ok
-        s._pcre2_ok = None
-        try:
-            self.assertEqual(s.pcre2_supported(), truth,
-                             "判据与 rg 自报的特性不一致")
-        finally:
-            s._pcre2_ok = saved
-
-
-if __name__ == "__main__":
-    unittest.main()

package/sub-skills/local-seek/tests/test_rank_pinyin.py

@@ -1,77 +0,0 @@
-#!/usr/bin/env python3
-"""local-seek 文件名相关性排序 + 拼音首字母单测（离线）
-
-覆盖：
-  1. pinyin_initials：中文→拼音首字母（pypinyin 优先 / GB2312 保底）
-  2. _fzf_score：fzf 式文件名评分（smart case / 连续 / 边界 / 全等）
-  3. _file_pinyin_bonus：正向（中文→缩写）与反向（缩写→中文文件名）加分
-  4. _rank_path_results：按相关性 + mtime 排序
-  5. _looks_like_pinyin_abbrev：拼音缩写判定
-
-运行：
-  cd ~/.agents/skills/argo
-  python3.14 -m pytest sub-skills/local-seek/tests/test_rank_pinyin.py -q
-"""
-
-from __future__ import annotations
-
-import sys
-import unittest
-from pathlib import Path
-
-SCRIPTS = Path(__file__).resolve().parent.parent / "scripts"
-sys.path.insert(0, str(SCRIPTS))
-
-import seek as s  # noqa: E402
-
-
-class TestPinyin(unittest.TestCase):
-    def test_zh_initials(self):
-        self.assertEqual(s.pinyin_initials("新建夹"), "xjj")
-
-    def test_non_cjk_kept(self):
-        self.assertIn("report", s.pinyin_initials("report_v2.md"))
-
-    def test_empty(self):
-        self.assertEqual(s.pinyin_initials(""), "")
-
-
-class TestFzfScore(unittest.TestCase):
-    def test_match_boundary(self):
-        self.assertGreater(s._fzf_score("新建夹.pdf", "新"), 0)
-
-    def test_continuous(self):
-        self.assertGreater(s._fzf_score("report_v2.md", "rep"), 0)
-
-    def test_no_match(self):
-        self.assertEqual(s._fzf_score("zzz.txt", "rep"), 0)
-
-    def test_case_insensitive(self):
-        self.assertGreater(s._fzf_score("Report_v2.md", "report"), 0)
-
-
-class TestPinyinBonus(unittest.TestCase):
-    def test_forward(self):
-        self.assertEqual(s._file_pinyin_bonus("新建夹.pdf", "新建夹"), 50)
-
-    def test_reverse(self):
-        self.assertEqual(s._file_pinyin_bonus("新建夹.pdf", "xjj"), 8)
-
-    def test_none(self):
-        self.assertEqual(s._file_pinyin_bonus("other.txt", "xjj"), 0)
-
-
-class TestRank(unittest.TestCase):
-    def test_rank_top_by_relevance(self):
-        r = [("a/zzz.txt", 0, ""), ("b/新建夹.pdf", 0, ""), ("c/report_v2.md", 0, "")]  # noqa: E741
-        ranked = s._rank_path_results(r, "新")
-        self.assertEqual(ranked[0][0], "b/新建夹.pdf")
-
-    def test_abbrev_look(self):
-        self.assertTrue(s._looks_like_pinyin_abbrev("xjj"))
-        self.assertFalse(s._looks_like_pinyin_abbrev("新"))
-        self.assertFalse(s._looks_like_pinyin_abbrev("report"))
-
-
-if __name__ == "__main__":
-    unittest.main()