argo-search 1.0.1 → 2.9.8

package/sub-skills/local-search/engine_registry.py

@@ -1,5 +1,5 @@
 #!/usr/bin/env python3
-"""engine_registry.py — local-search 引擎注册中心（唯一真源）
+"""engine_registry.py — local-search 引擎注册中心（唯一来源）
 
 读取 sub-skills/local-search/config.yaml 与 parse_maps.yaml，维护 24+ 本地引擎的
 元数据、分类与可用状态。新增引擎只需改 YAML，无需改代码。
@@ -11,6 +11,7 @@ import functools
 import json
 import logging
 import os
+import sys
 import time
 from pathlib import Path
 from typing import Any
@@ -29,6 +30,11 @@ SKILL_DIR = Path(__file__).resolve().parent
 CONFIG_PATH = SKILL_DIR / "config.yaml"
 PARSE_MAPS_PATH = SKILL_DIR / "parse_maps.yaml"
 
+# 健康条目陈旧线（与 _load_health/_save_health 共用）：30 天未探针的记录对路由
+# 已无参考价值，读入与写回两侧都要过滤——长驻进程的内存快照是全量写回的，
+# 只在读取侧过滤，两天后一次保存就会把 31 天的陈旧条目复活。
+_HEALTH_STALE_S = 30 * 86400
+
 # 领域分类（与 config.yaml 中 engines[*].category 对应）
 DEFAULT_CATEGORIES = [
     "web_general",
@@ -40,30 +46,40 @@ DEFAULT_CATEGORIES = [
     "vertical",
 ]
 
-# 反爬/拦截标记（用于 health_check 快速判定）
-ANTI_BOT_MARKERS = [
-    "captcha", "recaptcha", "robot", "robots", "cloudflare", "challenge",
-    "blocked", "verification", "please verify", "access denied",
-    "too many requests", "rate limit",
-]
+def _ensure_root_scripts() -> None:
+    _root_scripts = SKILL_DIR.parents[1] / "scripts"
+    if _root_scripts.exists() and str(_root_scripts) not in sys.path:
+        sys.path.append(str(_root_scripts))
 
 
 def _load_yaml(path: Path) -> dict[str, Any]:
-    if yaml is None:
-        raise ImportError("缺少 PyYAML，请安装：pip install pyyaml")
     try:
+        _ensure_root_scripts()
+        from yaml_load import load as _yaml_load
         with path.open("r", encoding="utf-8") as f:
-            data = yaml.safe_load(f)
+            data = _yaml_load(f)
         return data if isinstance(data, dict) else {}
-    except Exception as e:
-        logger.warning(f"加载 YAML 失败 {path}: {e}")
-        return {}
+    except Exception:
+        if yaml is None:
+            raise ImportError("缺少 PyYAML，请安装：pip install pyyaml")
+        try:
+            with path.open("r", encoding="utf-8") as f:
+                data = yaml.safe_load(f)
+            return data if isinstance(data, dict) else {}
+        except Exception as e:
+            logger.warning(f"加载 YAML 失败 {path}: {e}")
+            return {}
 
 
 def _default_health_state_path() -> Path:
-    base = Path(os.path.expanduser("~/.cache/unified-search"))
-    base.mkdir(parents=True, exist_ok=True)
-    return base / "local_search_health.json"
+    try:
+        _ensure_root_scripts()
+        from argo_paths import state_path
+        return state_path("local_search_health.json")
+    except Exception:
+        base = Path(os.path.expanduser("~/.cache/unified-search"))
+        base.mkdir(parents=True, exist_ok=True)
+        return base / "local_search_health.json"
 
 
 class EngineRegistry:
@@ -77,7 +93,8 @@ class EngineRegistry:
     ):
         self.config_path = Path(config_path) if config_path else CONFIG_PATH
         self.parse_maps_path = Path(parse_maps_path) if parse_maps_path else PARSE_MAPS_PATH
-        self.health_state_path = Path(health_state_path) if health_state_path else _default_health_state_path()
+        self._explicit_health_path = Path(health_state_path) if health_state_path else None
+        self._loaded_health_path: Path | None = None
         self._config_mtime: float = 0.0
         self._parse_mtime: float = 0.0
         self._config: dict[str, Any] = {}
@@ -85,6 +102,19 @@ class EngineRegistry:
         self._health: dict[str, Any] = {}
         self._load()
 
+    @property
+    def health_state_path(self) -> Path:
+        return self._explicit_health_path or _default_health_state_path()
+
+    @health_state_path.setter
+    def health_state_path(self, val: Path | str | None) -> None:
+        self._explicit_health_path = Path(val) if val else None
+
+    def _sync_health_path(self) -> None:
+        cur = self.health_state_path
+        if self._loaded_health_path != cur:
+            self._health = self._load_health()
+
     def _load(self) -> None:
         """加载配置、解析映射和健康状态缓存。"""
         cfg = _load_yaml(self.config_path)
@@ -99,22 +129,44 @@ class EngineRegistry:
         self._health = self._load_health()
 
     def _load_health(self) -> dict[str, Any]:
-        if not self.health_state_path.exists():
+        hp = self.health_state_path
+        self._loaded_health_path = hp
+        if not hp.exists():
             return {}
         try:
-            with self.health_state_path.open("r", encoding="utf-8") as f:
+            with hp.open("r", encoding="utf-8") as f:
                 data = json.load(f)
             if isinstance(data, dict):
-                return data
+                # 陈旧条目清理（2026-09-29）：健康文件此前只增不减——实测
+                # 有条目 49 天未刷新、还有测试引擎名残留。30 天未探针的记录
+                # 对路由已无参考价值（引擎配置都可能换过），读入时丢弃。
+                cutoff = time.time() - _HEALTH_STALE_S
+                return {k: v for k, v in data.items()
+                        if isinstance(v, dict) and v.get("last_checked", 0) >= cutoff}
         except Exception as e:
             logger.warning(f"加载健康状态失败: {e}")
         return {}
 
     def _save_health(self) -> None:
         try:
-            self.health_state_path.parent.mkdir(parents=True, exist_ok=True)
-            with self.health_state_path.open("w", encoding="utf-8") as f:
-                json.dump(self._health, f, ensure_ascii=False, indent=2)
+            hp = self.health_state_path
+            self._loaded_health_path = hp
+            # 写回前套用与 _load_health 相同的陈旧过滤：内存快照是全量写回的，
+            # 不过滤会让 30 天未刷新的条目复活并覆盖他进程新写的条目。
+            cutoff = time.time() - _HEALTH_STALE_S
+            payload = {k: v for k, v in self._health.items()
+                       if isinstance(v, dict) and v.get("last_checked", 0) >= cutoff}
+            hp.parent.mkdir(parents=True, exist_ok=True)
+            try:
+                _ensure_root_scripts()
+                from argo_paths import atomic_write_json, file_lock
+                with file_lock(hp):
+                    atomic_write_json(hp, payload)
+            except ImportError:
+                tmp = hp.with_name(hp.name + f".{os.getpid()}.tmp")
+                with tmp.open("w", encoding="utf-8") as f:
+                    json.dump(payload, f, ensure_ascii=False, indent=2)
+                os.replace(tmp, hp)
         except Exception as e:
             logger.warning(f"保存健康状态失败: {e}")
 
@@ -150,6 +202,7 @@ class EngineRegistry:
 
     def get_engine(self, name: str) -> dict[str, Any] | None:
         """获取指定引擎的完整配置（含运行时可用状态）。"""
+        self._sync_health_path()
         spec = self.engines.get(name)
         if spec is None:
             return None
@@ -211,26 +264,37 @@ class EngineRegistry:
     # ── 可用性管理 ───────────────────────────────────────────────────────────────
 
     def get_health(self, name: str) -> dict[str, Any]:
+        self._sync_health_path()
         return dict(self._health.get(name, {}))
 
-    def update_availability(self, name: str, available: bool, **extra: Any) -> None:
-        """更新单个引擎的可用状态，并持久化。"""
+    def update_availability(self, name: str, available: bool,
+                            persist: bool = True, **extra: Any) -> None:
+        """更新单个引擎的可用状态。
+
+        persist=False 时只改内存、不落盘——批量更新方（run_health_check 一轮
+        N 个引擎）用它把 N 次全文件重写收成 1 次，由调用方最后统一 _save_health。
+        """
+        self._sync_health_path()
         now = time.time()
         record = self._health.setdefault(name, {})
         record["last_checked"] = now
         record["available"] = available
         if available:
             record["consecutive_failures"] = 0
+            # 连续成功计数：健康门自适应 TTL 的依据（稳定引擎拉长探针间隔）
+            record["consecutive_ok"] = record.get("consecutive_ok", 0) + 1
             record["last_ok"] = now
             record["fail_reason"] = None
         else:
             record["consecutive_failures"] = record.get("consecutive_failures", 0) + 1
+            record["consecutive_ok"] = 0
             if extra.get("fail_reason"):
                 record["fail_reason"] = extra["fail_reason"]
         for k, v in extra.items():
             if k not in ("last_checked", "available", "consecutive_failures"):
                 record[k] = v
-        self._save_health()
+        if persist:
+            self._save_health()
 
     def bulk_update_availability(self, updates: dict[str, dict[str, Any]]) -> None:
         """批量更新可用状态。"""
@@ -238,6 +302,7 @@ class EngineRegistry:
             self.update_availability(name, data.get("available", False), **data)
 
     def is_available(self, name: str) -> bool:
+        self._sync_health_path()
         eng = self.get_engine(name)
         if eng is not None:
             return bool(eng.get("available", True))

package/sub-skills/local-search/{health_check.py → local_health_check.py}

@@ -17,6 +17,8 @@ import json
 import logging
 import os
 import re
+import shutil
+import sys
 import time
 import urllib.error
 import urllib.parse
@@ -26,6 +28,11 @@ from typing import Any
 
 from engine_registry import EngineRegistry, get_registry, update_availability
 
+# scripts/ 入路径（net_proxy 出口需要；append 不抢占子技能同名模块的优先级）
+_ROOT_SCRIPTS = Path(__file__).resolve().parents[2] / "scripts"
+if _ROOT_SCRIPTS.exists() and str(_ROOT_SCRIPTS) not in sys.path:
+    sys.path.append(str(_ROOT_SCRIPTS))
+
 logger = logging.getLogger("local_search.health_check")
 if not logger.handlers:
     logger.setLevel(logging.WARNING)
@@ -41,6 +48,21 @@ ANTI_BOT_MARKERS = [
 # HTTP 状态码分组
 RETRYABLE_STATUS = {429, 503, 502, 504}
 
+# 自适应 TTL 上限（秒）
+_MAX_HEALTH_TTL_S = 3600.0
+
+
+def _effective_ttl(rec: dict[str, Any], base_ttl_s: float) -> float:
+    """连续成功 → 探测间隔指数放宽（×2^min(streak,3)，硬上限 60min）。
+
+    探针不是免费的：HTTP canary 是直连上游的真实请求（最坏 8s 墙钟，且
+    每 5min 对 baidu/sogou/360 这类激进反爬源发一次固定「test」查询，纯增
+    封号风险）。稳定可用的引擎不需要高频确认；任何一次失败 consecutive_ok
+    归零，立即回到基准 TTL。
+    """
+    streak = int(rec.get("consecutive_ok", 0) or 0)
+    return min(base_ttl_s * (2 ** min(max(streak, 0), 3)), _MAX_HEALTH_TTL_S)
+
 
 def _now() -> float:
     return time.time()
@@ -96,9 +118,19 @@ def _fetch_probe(
     req_headers.setdefault("Accept-Language", "zh-CN,zh;q=0.9,en;q=0.8")
 
     req = urllib.request.Request(url, headers=req_headers, method=method)
+    # 出口统一走 net_proxy.open_url（与 search_v3._fetch 同语义）：裸 urlopen
+    # 不认 argo 在 config.yaml network.proxy 里配置的 url/rules——「必须经代理
+    # 才能出网」的环境里探针全部连不上，所有 HTTP 引擎被判 unavailable，
+    # fast/budget 路由随后被静默清空，症状与「源挂了」完全一样（主仓
+    # issue #13 同形态，13 个模块已修，这里是漏网的一个）。scripts/ 不在
+    # 路径（独立打包形态）时回退裸 urlopen，行为与改动前一致。
+    try:
+        from net_proxy import open_url
+    except ImportError:
+        open_url = urllib.request.urlopen  # type: ignore[assignment]
     t0 = time.time()
     try:
-        with urllib.request.urlopen(req, timeout=timeout) as resp:
+        with open_url(req, timeout=timeout) as resp:
             raw = resp.read()
             try:
                 text = raw.decode("utf-8", errors="replace")
@@ -149,6 +181,73 @@ def _parse_success(engine_name: str, text: str, fmt: str, registry: EngineRegist
     return len(text) > 200
 
 
+def _check_cli_engine(engine_name: str, spec: dict[str, Any],
+                      timeout: float = 8,
+                      canary_query: str = "test", n: int = 1) -> dict[str, Any]:
+    """CLI 引擎健康探针：跑一次真实 canary 查询，校验「能出结果」。
+
+    2026-10-06 修复假阳性：此前只跑 `ddgs --help`——二进制存在即判
+    available。ddgs 9.14.4 移除 bing text 后端、brave/yahoo 对真实查询
+    稳定 0 结果后，`--help` 全绿而搜索全灭，死引擎反复混入组合（本地
+    兜底链 4.5-8.3s 的结构性成因之一）。探针与搜索同路径（复用
+    search_v3._run_cli_engine），canary 拿不到 ≥1 条结果即失败。
+    代价：一次真实查询的墙钟（仅健康记录过期时发生，TTL 5min 起）。
+    search_v3 不可导入时退化为 --help 探测（fail-open，不崩探针链）。
+    """
+    cli_cmd = spec.get("cli_command", "")
+    if not cli_cmd:
+        return {"name": engine_name, "url": "", "status": None,
+                "latency_ms": 0, "parse_ok": False, "text_sample": "",
+                "fail_reason": "missing_cli_command", "available": False}
+    # which 短路：二进制不在 PATH 上时不再白付一次 --help 子进程 spawn
+    # （ddgs 冷启实测 0.35s）。与 search_v3._check_cli_available 同判据；
+    # shim 损坏（能 which 到但跑不动）仍由下方真实调用暴露。
+    if shutil.which(cli_cmd) is None:
+        return {"name": engine_name, "url": "", "status": None,
+                "latency_ms": 0, "parse_ok": False, "text_sample": "",
+                "fail_reason": "cli_not_found", "available": False}
+    import subprocess
+    t0 = time.time()
+    fail_reason = None
+    ok = False
+    text_sample = ""
+    try:
+        try:
+            from search_v3 import _run_cli_engine  # 同目录，探针与搜索同路径
+        except ImportError:
+            _run_cli_engine = None  # type: ignore[assignment]
+        if _run_cli_engine is not None:
+            results, err = _run_cli_engine(spec, canary_query, n,
+                                           min(timeout, 8))
+            ok = bool(results)
+            if not ok:
+                fail_reason = (err or "no_results")[:120]
+                text_sample = (err or "")[:300]
+        else:
+            # 退化路径：search_v3 不可用，只验证可执行（fail-open）。
+            # 真正的搜索失败由执行层熔断器记录。
+            result = subprocess.run(
+                [cli_cmd, "--help"],
+                capture_output=True, text=True, timeout=min(timeout, 5),
+                encoding="utf-8", errors="replace",  # Windows GBK locale 下 UTF-8 输出会解码崩
+            )
+            ok = result.returncode == 0
+            if not ok:
+                fail_reason = f"cli_exit_{result.returncode}"
+    except subprocess.TimeoutExpired:
+        ok, fail_reason = False, "cli_timeout"
+    except FileNotFoundError:
+        ok, fail_reason = False, "cli_not_found"
+    except Exception as e:  # 探针自身失败不判引擎死（fail-open）：记为软失败
+        ok, fail_reason = False, f"probe_error:{e}"[:120]
+    return {
+        "name": engine_name, "url": "", "status": 200 if ok else None,
+        "latency_ms": round((time.time() - t0) * 1000, 2),
+        "parse_ok": ok, "text_sample": text_sample,
+        "fail_reason": fail_reason, "available": ok,
+    }
+
+
 def check_engine(
     engine_name: str,
     registry: EngineRegistry | None = None,
@@ -164,6 +263,11 @@ def check_engine(
     if not spec.get("enabled", True):
         return {"name": engine_name, "available": False, "fail_reason": "disabled"}
 
+    # cli 引擎无 HTTP 端点，走 CLI 探针而非 URL 探针
+    if spec.get("type") == "cli":
+        return _check_cli_engine(engine_name, spec, timeout=timeout,
+                                 canary_query=canary_query, n=n)
+
     url, headers = _build_canary_url(spec, canary_query, n)
     method = spec.get("method", "GET")
     status, latency_ms, text, fail_reason = _fetch_probe(url, headers, method=method, timeout=timeout)
@@ -254,13 +358,18 @@ def run_health_check(
     enabled = engine_names if engine_names is not None else reg.list_engines(enabled_only=True)
 
     now = _now()
-    # TTL 检查：在有效期内直接复用缓存
+    # TTL 检查：在有效期内直接复用缓存。
+    # 按引擎名逐一比对（此前 cached.values() 里的 dict 与 enabled 的 str 比较
+    # 恒 False → all(空) 恒 True → 健康状态永不刷新），任一引擎记录缺失或
+    # 过期即重新探针。TTL 按连续成功自适应放宽（_effective_ttl）。
     cached = reg._health
-    all_recent = all(
-        (now - h.get("last_checked", 0)) < ttl_minutes * 60
-        for h in cached.values() if engine_names is None or h in enabled
-    )
-    if cached and all_recent:
+
+    def _recent(name: str) -> bool:
+        rec = cached.get(name)
+        return bool(rec) and (now - rec.get("last_checked", 0)) < _effective_ttl(rec, ttl_minutes * 60)
+
+    all_recent = bool(enabled) and all(_recent(n) for n in enabled)
+    if all_recent:
         return {name: dict(h) for name, h in cached.items() if name in enabled}
 
     reports: dict[str, dict[str, Any]] = {}
@@ -278,8 +387,9 @@ def run_health_check(
     for name, report in reports.items():
         previous = reg.get_health(name)
         final_available = apply_threshold(report, previous)
+        # available 以位置参数传入，勿再放进 kwargs（此前重复键触发
+        # TypeError，被 #⑨ 缓存恒命中掩盖，健康检查从未真正执行）
         update_data = {
-            "available": final_available,
             "latency_ms": report.get("latency_ms"),
             "status": report.get("status"),
             "parse_ok": report.get("parse_ok"),
@@ -289,7 +399,11 @@ def run_health_check(
             update_data["success_rate"] = 1.0
         else:
             update_data["success_rate"] = 0.0
-        reg.update_availability(name, final_available, **update_data)
+        # persist=False：一轮 N 个引擎收成 1 次落盘（此前每引擎全文件重写一次）
+        reg.update_availability(name, final_available, persist=False, **update_data)
+
+    if reports:
+        reg._save_health()
 
     return reports
 
@@ -310,8 +424,24 @@ def get_available_engines(
         now = _now()
         ttl = reg.settings.get("health_check", {}).get("ttl_minutes", 5) * 60
         cached = reg._health
-        if cached and all((now - h.get("last_checked", 0)) < ttl for h in cached.values() if h in engine_names):
+
+        def _recent(name: str) -> bool:
+            rec = cached.get(name)
+            # TTL 按连续成功自适应放宽：稳定引擎最多放宽到 60min，
+            # 探针墙钟与对反爬源的 canary 流量随之下降一个量级。
+            return bool(rec) and (now - rec.get("last_checked", 0)) < _effective_ttl(rec, ttl)
+
+        # 逐引擎名比对新鲜度（此前 dict in list[str] 恒 False → 恒命中，
+        # 健康状态永不刷新）。
+        # 2026-10-06：只探**过期**的引擎——此前 all() 判全新鲜，任一过期即
+        # 全量重探，稳定引擎（TTL 放宽到 60min）被反复拖进探针浪；探针浪
+        # 实测 ~2-4.5s（yahoo 慢空），全量重探把它加到每次调用路径上。
+        # 注意 engine_names 在上方已保证非空（None → 全量启用列表）。
+        stale = [n for n in engine_names if not _recent(n)]
+        if not stale:
             return [n for n in engine_names if reg.is_available(n)]
+        run_health_check(registry=reg, engine_names=stale)
+        return [n for n in engine_names if reg.is_available(n)]
     run_health_check(registry=reg, engine_names=engine_names)
     return [n for n in engine_names if reg.is_available(n)]
 

package/sub-skills/local-search/local_search_adapter.py

@@ -2,7 +2,7 @@
 """local_search_adapter.py — local-search 兼容入口
 
 保留原 adapter 接口，内部委托 search_v3.search_engines 执行。
-unified-search 可通过 --sub-skill local-search 或 --local-first 调用本入口。
+unified-search 可通过 --local-first 调用本入口。
 """
 
 from __future__ import annotations
@@ -29,10 +29,18 @@ def main():
     parser.add_argument("--engine", "-e", default="", help="引擎名，多个用逗号分隔")
     parser.add_argument("--n", type=int, default=5, help="每引擎结果数")
     parser.add_argument("--timeout", "-t", type=float, default=None, help="超时秒数")
-    parser.add_argument("--max-parallel", type=int, default=5)
+    # None = 以 config 的 max_parallel_engines 为真源（与主链进程内路径同口径）
+    parser.add_argument("--max-parallel", type=int, default=None)
     parser.add_argument("--no-cache", action="store_true", help="跳过缓存")
     parser.add_argument("--mode", default="fast", choices=["fast", "auto", "deep", "budget"],
                         help="unified-search 模式透传")
+    parser.add_argument("--since", default=None,
+                        help="发布时间下限（7d / 2026-08-01），下推到支持时间参数的引擎")
+    parser.add_argument("--until", default=None,
+                        help="发布时间上限（7d / 2026-08-01），下推到支持时间参数的引擎")
+    parser.add_argument("--sort", default="relevance",
+                        choices=["relevance", "oldest", "newest"],
+                        help="时间排序：relevance=相关度（默认）, oldest=最早在前（溯源）, newest=最新在前")
     parser.add_argument("--json", action="store_true", help="输出 JSON")
     args = parser.parse_args()
 
@@ -48,6 +56,9 @@ def main():
         max_parallel=args.max_parallel,
         skip_cache=args.no_cache,
         mode=args.mode,
+        since=args.since,
+        until=args.until,
+        sort=args.sort,
     )
     print(json.dumps(result, ensure_ascii=False, indent=2))
 

package/sub-skills/local-search/parse_maps.yaml

@@ -15,51 +15,11 @@ html:
     url_attr: href
     score: 0.75
 
-  local_google:
-    container: "div.g"
-    title: "h3"
-    url: "a"
-    snippet: "div.VwiC3b, div.s, span.aCOpRe"
-    url_attr: href
-    score: 0.75
-
-  local_mojeek:
-    container: "li.results-standard-list"
-    title: "a.ob"
-    url: "a.ob"
-    snippet: "p.s"
-    url_attr: href
-    score: 0.7
-
-  local_yandex:
-    container: "li.serp-item"
-    title: "a.Link"
-    url: "a.Link"
-    snippet: "div.TextContainer"
-    url_attr: href
-    score: 0.65
-
-  local_startpage:
-    container: "div.result"
-    title: "a.result-title"
-    url: "a.result-title"
-    snippet: "p.result-snippet"
-    url_attr: href
-    score: 0.7
-
-  local_duckduckgo:
-    container: ".result"
-    title: "a.result__a"
-    url: "a.result__a"
-    snippet: "a.result__snippet"
-    url_attr: href
-    score: 0.7
-
   local_baidu:
-    container: ".result, .c-container"
+    container: ".result, .c-container, .cosc-card-content-border"
     title: "h3"
     url: "a"
-    snippet: ".content-right_8Zs40, .c-abstract, .content-left_3d_H4"
+    snippet: ".c-abstract, .cosc-card-content-border, .cosc-card-content, .summary-text_15QGa, .text_2NOr6, .main-info_4Q_kj, .bk_polysemy_1Ef6j"
     url_attr: href
     score: 0.7
 
@@ -71,6 +31,22 @@ html:
     url_attr: href
     score: 0.65
 
+  local_360:
+    container: "li.res-list"
+    title: "h3.res-title a"
+    url: "h3.res-title a"
+    snippet: "p.res-desc"
+    url_attr: data-mdurl
+    score: 0.7
+
+  local_jisilu:
+    container: ".aw-question-list .aw-item"
+    title: "h4 a"
+    url: "h4 a"
+    snippet: ".aw-text-color-999"
+    url_attr: href
+    score: 0.6
+
   local_stackoverflow:
     container: ".question-summary"
     title: "a.question-hyperlink"
@@ -95,12 +71,28 @@ html:
     url_attr: href
     score: 0.7
 
+  know_your_meme:
+    container: "a.item"
+    title: "h3"
+    url: "a"
+    url_attr: href
+    score: 0.7
+
+  moegirl:
+    container: "li.mw-search-result"
+    title: "div.mw-search-result-heading a"
+    url: "div.mw-search-result-heading a"
+    snippet: "div.searchresult"
+    url_attr: href
+    score: 0.7
+
 xml:
   local_arxiv:
     entry_path: ".//{http://www.w3.org/2005/Atom}entry"
     title: "atom:title"
     url: "atom:id"
     snippet: "atom:summary"
+    published_at: "atom:published"
     namespaces:
       atom: "http://www.w3.org/2005/Atom"
 
@@ -138,36 +130,42 @@ json:
     title: "full_name"
     url: "html_url"
     snippet: "description"
+    published_at: "created_at"
 
   local_npm:
     items: "objects"
     title: "package.name"
     url: "package.links.npm"
     snippet: "package.description"
+    published_at: "package.date"
 
   local_gitlab:
     items: "."
     title: "name_with_namespace"
     url: "web_url"
     snippet: "description"
+    published_at: "created_at"
 
   local_stackoverflow:
     items: "items"
     title: "title"
     url: "link"
     snippet: null
+    published_at: "creation_date"
 
   local_crossref:
     items: "message.items"
     title: "title"
     url: "URL"
     snippet: "abstract"
+    published_at: "message.published-print.date-parts.0"
 
   local_semantic_scholar:
     items: "data"
     title: "title"
     url: "url"
     snippet: "abstract"
+    published_at: "publicationDate"
 
   local_pubmed:
     items: "esearchresult.idlist"