sophhub 0.4.21 → 0.4.22

package/skills/insurance-schedule-renewal/src/src/insurance_schedule_cli/orchestrator.py

@@ -0,0 +1,94 @@
+"""Shared-db read helpers for insurance-schedule-renewal."""
+from __future__ import annotations
+
+from insurance_schedule_cli import db
+
+
+def policy_query(expire_before: str | None = None,
+                 next_pay_before: str | None = None,
+                 customer_id: str | None = None) -> dict:
+    conn = db.connect()
+    try:
+        sql = "SELECT * FROM policies WHERE status='active'"
+        vals: list[str] = []
+        if customer_id:
+            sql += " AND customer_id=?"
+            vals.append(customer_id)
+        if expire_before:
+            sql += " AND expire_date<>'' AND expire_date IS NOT NULL AND expire_date<=?"
+            vals.append(expire_before)
+        if next_pay_before:
+            sql += " AND next_pay_date<>'' AND next_pay_date IS NOT NULL AND next_pay_date<=?"
+            vals.append(next_pay_before)
+        sql += " ORDER BY effective_date DESC"
+        rows = list(conn.execute(sql, tuple(vals)))
+        return {"ok": True, "policies": [dict(r) for r in rows], "count": len(rows)}
+    finally:
+        conn.close()
+
+
+def customer_query(customer_id: str | None = None) -> dict:
+    conn = db.connect()
+    try:
+        if customer_id:
+            rows = list(
+                conn.execute("SELECT * FROM customers WHERE id=? AND status='active'", (customer_id,))
+            )
+        else:
+            rows = list(conn.execute("SELECT * FROM customers WHERE status='active' ORDER BY created_at DESC"))
+        return {"ok": True, "customers": [dict(r) for r in rows], "count": len(rows)}
+    finally:
+        conn.close()
+
+
+def followup_query(customer_id: str | None = None, days: int | None = None) -> dict:
+    conn = db.connect()
+    try:
+        if customer_id:
+            rows = list(
+                conn.execute(
+                    "SELECT * FROM followups WHERE customer_id=? ORDER BY created_at DESC",
+                    (customer_id,),
+                )
+            )
+        elif days is not None:
+            rows = list(
+                conn.execute(
+                    "SELECT * FROM followups WHERE created_at >= datetime('now', ?) ORDER BY created_at DESC",
+                    (f"-{int(days)} days",),
+                )
+            )
+        else:
+            rows = list(conn.execute("SELECT * FROM followups ORDER BY created_at DESC"))
+        return {"ok": True, "followups": [dict(r) for r in rows], "count": len(rows)}
+    finally:
+        conn.close()
+
+
+def gap_analysis(customer_id: str) -> dict:
+    conn = db.connect()
+    try:
+        row = conn.execute(
+            "SELECT id, name FROM customers WHERE id=? AND status='active'",
+            (customer_id,),
+        ).fetchone()
+        if not row:
+            return {"ok": False, "error": "customer_not_found"}
+        need_types = ["重疾险", "医疗险", "意外险", "寿险", "养老险", "教育金"]
+        owned = {
+            r["product_type"]
+            for r in conn.execute(
+                "SELECT DISTINCT product_type FROM policies WHERE customer_id=? AND status='active'",
+                (customer_id,),
+            )
+            if r["product_type"]
+        }
+        result = {
+            "customer_id": row["id"],
+            "name": row["name"],
+            "owned_types": sorted(owned),
+            "gaps": [t for t in need_types if t not in owned],
+        }
+        return {"ok": True, "result": result}
+    finally:
+        conn.close()

package/skills/insurance-shared-data/skill.json

@@ -0,0 +1,20 @@
+{
+  "name": "insurance-shared-data",
+  "version": "1.0.0",
+  "types": [
+    "store"
+  ],
+  "displayName": "保险统一数据底座",
+  "description": "保险系列套件入口：内置共享单库 insurance.sqlite3 的首次自动初始化，insurance-customer-policy / insurance-product-analysis / insurance-sales-pipeline / insurance-schedule-renewal 共用一套数据库。",
+  "changelog": [
+    {
+      "version": "1.0.0",
+      "date": "2026-05-12",
+      "changes": [
+        "初次提交：保险系列统一数据底座入口 skill（共享库自动初始化与路径约定说明）"
+      ]
+    }
+  ],
+  "createdAt": "2026-05-12",
+  "updatedAt": "2026-05-12"
+}

package/skills/insurance-shared-data/src/SKILL.md

@@ -0,0 +1,33 @@
+---
+name: insurance-shared-data
+description: "保险套件入口：内置共享单库 insurance.sqlite3 的首次自动初始化。"
+---
+
+# 保险统一数据底座入口
+
+安装本 skill 后，`insurance-*` 系列会在首次运行时自动初始化共享单库 `insurance.sqlite3`（自动建库建表），用户无需手动配置环境变量，也不需要手动建表。
+
+## 共享数据库位置
+
+- Windows：`%USERPROFILE%\.config\insurance\insurance.sqlite3`
+- Linux/macOS：`$HOME/.config/insurance/insurance.sqlite3`
+
+## 共享范围
+
+以下保险 skill 共用同一个数据库：
+
+- `insurance-customer-policy`
+- `insurance-product-analysis`
+- `insurance-sales-pipeline`
+- `insurance-schedule-renewal`
+
+## 可选环境变量（一般无需配置）
+
+- `INSURANCE_DB_PATH`：统一覆盖共享数据库文件路径。
+
+兼容历史变量（已有旧部署时仍可生效）：
+
+- `INSURANCE_CUSTOMER_DB_PATH`
+- `INSURANCE_PRODUCT_DB_PATH`
+- `INSURANCE_PIPELINE_DB_PATH`
+- `INSURANCE_SCHEDULE_DB_PATH`

package/skills/insurance-shared-data/src/scripts/cloud_insurance_super_test.py

@@ -0,0 +1,246 @@
+#!/usr/bin/env python3
+# -*- coding: utf-8 -*-
+"""保险系列云端超级回归测试（失败不中断版）。
+
+目标：
+1) 尽可能覆盖所有保险 skill 功能；
+2) 任一子测试失败不会阻塞后续测试；
+3) 最终输出统一汇总报告与日志目录，方便一次定位多处问题。
+
+推荐在云端执行：
+    python3 /app/skills/insurance-shared-data/src/scripts/cloud_insurance_super_test.py
+或（扁平安装）：
+    python3 /app/skills/insurance-shared-data/scripts/cloud_insurance_super_test.py
+
+可选参数：
+    --skills-root /app/skills
+    --artifacts-dir /tmp/insurance-super-test
+    --skip-full
+    --always-zero
+"""
+from __future__ import annotations
+
+import argparse
+import json
+import os
+import subprocess
+import sys
+import time
+from dataclasses import dataclass
+from pathlib import Path
+from typing import Any
+
+
+@dataclass
+class StepResult:
+    name: str
+    ok: bool
+    returncode: int
+    seconds: float
+    stdout_file: str
+    stderr_file: str
+    error: str = ""
+
+
+def _discover_skills_root(explicit: str | None) -> Path:
+    if explicit:
+        p = Path(explicit).expanduser().resolve()
+        if p.is_dir():
+            return p
+        raise SystemExit(f"[FAIL] --skills-root 不存在: {p}")
+
+    env = os.environ.get("INSURANCE_SKILLS_ROOT") or os.environ.get("SKILLS_ROOT")
+    if env:
+        p = Path(env).expanduser().resolve()
+        if p.is_dir():
+            return p
+        raise SystemExit(f"[FAIL] INSURANCE_SKILLS_ROOT/SKILLS_ROOT 不存在: {p}")
+
+    here = Path(__file__).resolve()
+    for c in [here.parents[3], Path("/app/skills"), Path.cwd() / "skills", Path.cwd()]:
+        try:
+            if (c / "insurance-customer-policy").is_dir():
+                return c.resolve()
+        except OSError:
+            continue
+    raise SystemExit("[FAIL] 无法定位 skills 根目录，请显式传入 --skills-root 或设置 INSURANCE_SKILLS_ROOT")
+
+
+def _must_file(p: Path) -> None:
+    if not p.is_file():
+        raise SystemExit(f"[FAIL] 文件不存在: {p}")
+
+
+def _resolve_script(skills_root: Path, skill: str, script_name: str) -> Path:
+    """Resolve script path in both source and flattened layouts."""
+    candidates = [
+        skills_root / skill / "src" / "scripts" / script_name,
+        skills_root / skill / "scripts" / script_name,
+        Path("/app/skills") / skill / "src" / "scripts" / script_name,
+        Path("/app/skills") / skill / "scripts" / script_name,
+    ]
+    for p in candidates:
+        try:
+            if p.is_file():
+                return p
+        except OSError:
+            continue
+    tried = "\n  - ".join(str(x) for x in candidates)
+    raise SystemExit(f"[FAIL] 找不到脚本 {skill}/{script_name}，已尝试:\n  - {tried}")
+
+
+def _write_text(path: Path, txt: str) -> None:
+    path.parent.mkdir(parents=True, exist_ok=True)
+    path.write_text(txt, encoding="utf-8")
+
+
+def _run_step(
+    name: str,
+    cmd: list[str],
+    *,
+    env: dict[str, str],
+    cwd: Path,
+    logs_dir: Path,
+    timeout: int = 1800,
+) -> StepResult:
+    safe = "".join(ch if ch.isalnum() or ch in ("-", "_") else "_" for ch in name).strip("_")
+    out_file = logs_dir / f"{safe}.stdout.log"
+    err_file = logs_dir / f"{safe}.stderr.log"
+    t0 = time.time()
+    try:
+        r = subprocess.run(
+            cmd,
+            env=env,
+            cwd=str(cwd),
+            capture_output=True,
+            text=True,
+            encoding="utf-8",
+            timeout=timeout,
+        )
+        _write_text(out_file, r.stdout or "")
+        _write_text(err_file, r.stderr or "")
+        return StepResult(
+            name=name,
+            ok=(r.returncode == 0),
+            returncode=r.returncode,
+            seconds=round(time.time() - t0, 2),
+            stdout_file=str(out_file),
+            stderr_file=str(err_file),
+        )
+    except Exception as e:  # noqa: BLE001
+        _write_text(out_file, "")
+        _write_text(err_file, str(e))
+        return StepResult(
+            name=name,
+            ok=False,
+            returncode=999,
+            seconds=round(time.time() - t0, 2),
+            stdout_file=str(out_file),
+            stderr_file=str(err_file),
+            error=str(e),
+        )
+
+
+def main() -> int:
+    parser = argparse.ArgumentParser(description="保险 skill 云端超级回归（失败不中断）")
+    parser.add_argument("--skills-root", help="skills 目录路径（包含 insurance-* 子目录）")
+    parser.add_argument("--artifacts-dir", help="日志与报告输出目录")
+    parser.add_argument("--skip-full", action="store_true", help="跳过 cloud_insurance_full_test.py 全量集成阶段")
+    parser.add_argument("--always-zero", action="store_true", help="即使失败也返回 0（适合人工巡检场景）")
+    args = parser.parse_args()
+
+    try:
+        sys.stdout.reconfigure(encoding="utf-8")
+        sys.stderr.reconfigure(encoding="utf-8")
+    except (AttributeError, OSError):
+        pass
+
+    skills_root = _discover_skills_root(args.skills_root)
+    scripts = {
+        "customer_smoke": _resolve_script(skills_root, "insurance-customer-policy", "run_e2e_smoke.py"),
+        "product_smoke": _resolve_script(skills_root, "insurance-product-analysis", "run_e2e_smoke.py"),
+        "pipeline_smoke": _resolve_script(skills_root, "insurance-sales-pipeline", "run_e2e_smoke.py"),
+        "schedule_smoke": _resolve_script(skills_root, "insurance-schedule-renewal", "run_e2e_smoke.py"),
+        "full": _resolve_script(skills_root, "insurance-customer-policy", "cloud_insurance_full_test.py"),
+        "dashboard_all": _resolve_script(skills_root, "insurance-customer-policy", "dashboard_all.py"),
+        "super_self": _resolve_script(skills_root, "insurance-shared-data", "cloud_insurance_super_test.py"),
+    }
+
+    ts = time.strftime("%Y%m%d-%H%M%S", time.localtime())
+    artifacts = Path(args.artifacts_dir).expanduser().resolve() if args.artifacts_dir else Path(f"/tmp/insurance-super-test-{ts}")
+    logs_dir = artifacts / "logs"
+    artifacts.mkdir(parents=True, exist_ok=True)
+    logs_dir.mkdir(parents=True, exist_ok=True)
+
+    # 每个子脚本自己会再创建隔离数据库，统一给定父目录便于回溯。
+    env = dict(os.environ)
+    env["INSURANCE_SKILLS_ROOT"] = str(skills_root)
+    env["INSURANCE_CLOUD_TEST_DIR"] = str(artifacts / "db")
+    env["PYTHONIOENCODING"] = "utf-8"
+
+    steps: list[tuple[str, list[str], int]] = [
+        ("customer_smoke", [sys.executable, str(scripts["customer_smoke"])], 1200),
+        ("product_smoke", [sys.executable, str(scripts["product_smoke"])], 1200),
+        ("pipeline_smoke", [sys.executable, str(scripts["pipeline_smoke"])], 1200),
+        ("schedule_smoke", [sys.executable, str(scripts["schedule_smoke"])], 1200),
+        ("dashboard_all_json", [sys.executable, str(scripts["dashboard_all"]), "--json"], 300),
+        ("dashboard_all_md", [sys.executable, str(scripts["dashboard_all"]), "--md"], 300),
+    ]
+    if not args.skip_full:
+        steps.extend(
+            [
+                ("cloud_full_smoke", [sys.executable, str(scripts["full"]), "--smoke"], 1800),
+                ("cloud_full_all", [sys.executable, str(scripts["full"]), "-v"], 3600),
+            ]
+        )
+
+    print("====== 保险技能超级回归（失败不中断）======")
+    print(f"skills_root   : {skills_root}")
+    print(f"artifacts_dir : {artifacts}")
+    print(f"steps         : {len(steps)}")
+    print("------------------------------------------")
+
+    results: list[StepResult] = []
+    for idx, (name, cmd, timeout) in enumerate(steps, start=1):
+        print(f"[{idx}/{len(steps)}] RUN {name}")
+        r = _run_step(name, cmd, env=env, cwd=skills_root, logs_dir=logs_dir, timeout=timeout)
+        results.append(r)
+        if r.ok:
+            print(f"  -> PASS ({r.seconds}s)")
+        else:
+            print(f"  -> FAIL rc={r.returncode} ({r.seconds}s)")
+
+    passed = sum(1 for r in results if r.ok)
+    failed = len(results) - passed
+    summary: dict[str, Any] = {
+        "ok": failed == 0,
+        "skills_root": str(skills_root),
+        "artifacts_dir": str(artifacts),
+        "stats": {"total": len(results), "passed": passed, "failed": failed},
+        "results": [r.__dict__ for r in results],
+    }
+    summary_file = artifacts / "summary.json"
+    _write_text(summary_file, json.dumps(summary, ensure_ascii=False, indent=2))
+
+    print("\n============== 汇总 ==============")
+    print(f"PASS: {passed}")
+    print(f"FAIL: {failed}")
+    print(f"SUMMARY: {summary_file}")
+    print(f"LOG DIR: {logs_dir}")
+
+    if failed > 0:
+        print("\n失败项：")
+        for r in results:
+            if not r.ok:
+                print(f"- {r.name}: rc={r.returncode}")
+                print(f"  stderr: {r.stderr_file}")
+                print(f"  stdout: {r.stdout_file}")
+
+    if failed > 0 and not args.always_zero:
+        return 1
+    return 0
+
+
+if __name__ == "__main__":
+    raise SystemExit(main())
+