sophhub 0.4.21 → 0.4.23

package/skills/insurance-product-analysis/src/scripts/insurance_product_cli/db.py

@@ -0,0 +1,180 @@
+"""Shared SQLite schema for insurance skills."""
+from __future__ import annotations
+
+import os
+import sqlite3
+from pathlib import Path
+
+
+def default_db_path() -> Path:
+    base = Path.home() / ".config" / "insurance"
+    base.mkdir(parents=True, exist_ok=True)
+    return base / "insurance.sqlite3"
+
+
+def get_db_path() -> Path:
+    for key in ("INSURANCE_DB_PATH", "INSURANCE_PRODUCT_DB_PATH"):
+        p = os.environ.get(key)
+        if p:
+            path = Path(p)
+            path.parent.mkdir(parents=True, exist_ok=True)
+            return path
+    return default_db_path()
+
+
+def connect() -> sqlite3.Connection:
+    conn = sqlite3.connect(str(get_db_path()))
+    conn.row_factory = sqlite3.Row
+    conn.execute("PRAGMA foreign_keys=ON")
+    init_schema(conn)
+    return conn
+
+
+def init_schema(conn: sqlite3.Connection) -> None:
+    conn.executescript(
+        """
+        CREATE TABLE IF NOT EXISTS customers (
+            id TEXT PRIMARY KEY,
+            name TEXT NOT NULL,
+            phone TEXT,
+            age INTEGER,
+            gender TEXT,
+            income REAL,
+            household_json TEXT NOT NULL DEFAULT '{}',
+            occupation TEXT,
+            birthday TEXT,
+            tags_json TEXT NOT NULL DEFAULT '[]',
+            fields_json TEXT NOT NULL DEFAULT '{}',
+            status TEXT NOT NULL DEFAULT 'active',
+            created_at TEXT NOT NULL DEFAULT (datetime('now','localtime')),
+            updated_at TEXT NOT NULL DEFAULT (datetime('now','localtime'))
+        );
+        CREATE INDEX IF NOT EXISTS idx_customers_phone ON customers(phone);
+        CREATE INDEX IF NOT EXISTS idx_customers_birthday ON customers(birthday);
+
+        CREATE TABLE IF NOT EXISTS policies (
+            id TEXT PRIMARY KEY,
+            customer_id TEXT NOT NULL REFERENCES customers(id) ON DELETE RESTRICT,
+            company TEXT NOT NULL,
+            product_name TEXT NOT NULL,
+            product_type TEXT NOT NULL,
+            coverage REAL NOT NULL DEFAULT 0,
+            premium REAL NOT NULL DEFAULT 0,
+            pay_period TEXT,
+            effective_date TEXT NOT NULL,
+            expire_date TEXT,
+            next_pay_date TEXT,
+            insured_name TEXT,
+            beneficiary TEXT,
+            notes TEXT,
+            status TEXT NOT NULL DEFAULT 'active',
+            created_at TEXT NOT NULL DEFAULT (datetime('now','localtime')),
+            updated_at TEXT NOT NULL DEFAULT (datetime('now','localtime'))
+        );
+        CREATE INDEX IF NOT EXISTS idx_policies_customer ON policies(customer_id, status);
+        CREATE INDEX IF NOT EXISTS idx_policies_expire ON policies(expire_date, status);
+        CREATE INDEX IF NOT EXISTS idx_policies_next_pay ON policies(next_pay_date, status);
+        CREATE INDEX IF NOT EXISTS idx_policies_type ON policies(product_type, status);
+
+        CREATE TABLE IF NOT EXISTS followups (
+            id INTEGER PRIMARY KEY AUTOINCREMENT,
+            customer_id TEXT NOT NULL REFERENCES customers(id) ON DELETE CASCADE,
+            content TEXT NOT NULL,
+            next_step TEXT,
+            next_date TEXT,
+            channel TEXT,
+            created_at TEXT NOT NULL DEFAULT (datetime('now','localtime'))
+        );
+        CREATE INDEX IF NOT EXISTS idx_followups_customer ON followups(customer_id, created_at DESC);
+
+        CREATE TABLE IF NOT EXISTS customer_fields (
+            name TEXT PRIMARY KEY,
+            type TEXT NOT NULL DEFAULT 'text'
+        );
+
+        CREATE TABLE IF NOT EXISTS products (
+            id INTEGER PRIMARY KEY AUTOINCREMENT,
+            name TEXT NOT NULL UNIQUE,
+            company TEXT NOT NULL,
+            product_type TEXT NOT NULL,
+            coverage_min REAL,
+            coverage_max REAL,
+            premium_min REAL,
+            premium_max REAL,
+            age_min INTEGER,
+            age_max INTEGER,
+            waiting_period TEXT,
+            deductible TEXT,
+            renewal_terms TEXT,
+            highlights_json TEXT NOT NULL DEFAULT '[]',
+            target_audience TEXT,
+            file_path TEXT,
+            raw_text TEXT,
+            status TEXT NOT NULL DEFAULT 'active',
+            created_at TEXT NOT NULL DEFAULT (datetime('now','localtime')),
+            updated_at TEXT NOT NULL DEFAULT (datetime('now','localtime'))
+        );
+        CREATE INDEX IF NOT EXISTS idx_products_type ON products(product_type, status);
+        CREATE INDEX IF NOT EXISTS idx_products_company ON products(company, status);
+
+        CREATE TABLE IF NOT EXISTS product_analysis_cache (
+            product_id INTEGER PRIMARY KEY REFERENCES products(id) ON DELETE CASCADE,
+            key_terms_json TEXT,
+            selling_points_json TEXT,
+            fit_audience_json TEXT,
+            pitch_script TEXT,
+            analyzed_at TEXT NOT NULL DEFAULT (datetime('now','localtime'))
+        );
+
+        CREATE TABLE IF NOT EXISTS deals (
+            id TEXT PRIMARY KEY,
+            customer_id TEXT NOT NULL,
+            customer_name TEXT,
+            product_name TEXT,
+            product_type TEXT,
+            stage TEXT NOT NULL,
+            estimated_premium REAL NOT NULL DEFAULT 0,
+            actual_premium REAL,
+            expected_close_date TEXT,
+            closed_at TEXT,
+            lost_reason TEXT,
+            lost_note TEXT,
+            note TEXT,
+            created_at TEXT NOT NULL DEFAULT (datetime('now','localtime')),
+            updated_at TEXT NOT NULL DEFAULT (datetime('now','localtime'))
+        );
+        CREATE INDEX IF NOT EXISTS idx_deals_stage ON deals(stage, expected_close_date);
+        CREATE INDEX IF NOT EXISTS idx_deals_customer ON deals(customer_id);
+
+        CREATE TABLE IF NOT EXISTS deal_stage_log (
+            id INTEGER PRIMARY KEY AUTOINCREMENT,
+            deal_id TEXT NOT NULL REFERENCES deals(id) ON DELETE CASCADE,
+            from_stage TEXT,
+            to_stage TEXT NOT NULL,
+            note TEXT,
+            created_at TEXT NOT NULL DEFAULT (datetime('now','localtime'))
+        );
+        CREATE INDEX IF NOT EXISTS idx_stage_log_deal ON deal_stage_log(deal_id, created_at);
+
+        CREATE TABLE IF NOT EXISTS monthly_targets (
+            month TEXT PRIMARY KEY,
+            target_premium REAL NOT NULL,
+            note TEXT,
+            created_at TEXT NOT NULL DEFAULT (datetime('now','localtime')),
+            updated_at TEXT NOT NULL DEFAULT (datetime('now','localtime'))
+        );
+
+        CREATE TABLE IF NOT EXISTS sent_reminders (
+            id INTEGER PRIMARY KEY AUTOINCREMENT,
+            reminder_type TEXT NOT NULL,
+            target_id TEXT NOT NULL,
+            bucket TEXT NOT NULL,
+            sent_at TEXT NOT NULL DEFAULT (datetime('now','localtime')),
+            status TEXT NOT NULL DEFAULT 'sent',
+            note TEXT,
+            UNIQUE (reminder_type, target_id, bucket)
+        );
+        CREATE INDEX IF NOT EXISTS idx_sent_target ON sent_reminders(target_id, reminder_type);
+        """
+    )
+    conn.commit()

package/skills/insurance-product-analysis/src/scripts/insurance_product_cli/orchestrator.py

@@ -0,0 +1,163 @@
+"""Shared-db read helpers for insurance-product-analysis."""
+from __future__ import annotations
+
+import json
+import sqlite3
+from datetime import datetime, timedelta
+
+from insurance_product_cli import db
+
+
+def gap_analysis(customer_id: str | None = None, gap_type: str | None = None,
+                 all_customers: bool = False) -> dict:
+    conn = db.connect()
+    try:
+        need_types = ["重疾险", "医疗险", "意外险", "寿险", "养老险", "教育金"]
+        if customer_id:
+            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"}
+            results = [row]
+        elif all_customers or gap_type:
+            results = list(
+                conn.execute("SELECT id, name FROM customers WHERE status='active' ORDER BY id")
+            )
+        else:
+            return {"ok": False, "error": "need_customer_id_or_all"}
+
+        payload = []
+        for r in results:
+            owned = {
+                row["product_type"]
+                for row in conn.execute(
+                    "SELECT DISTINCT product_type FROM policies WHERE customer_id=? AND status='active'",
+                    (r["id"],),
+                )
+                if row["product_type"]
+            }
+            gaps = [t for t in need_types if t not in owned]
+            item = {"customer_id": r["id"], "name": r["name"], "owned_types": sorted(owned), "gaps": gaps}
+            if customer_id:
+                return {"ok": True, "result": item}
+            payload.append(item)
+        if gap_type:
+            payload = [x for x in payload if gap_type in x.get("gaps", [])]
+        return {"ok": True, "results": payload, "count": len(payload)}
+    finally:
+        conn.close()
+
+
+def customer_query(customer_id: str | None = None, keyword: str | None = None) -> dict:
+    conn = db.connect()
+    try:
+        cur = conn.cursor()
+        if customer_id:
+            rows = list(cur.execute("SELECT * FROM customers WHERE id=? AND status='active'", (customer_id,)))
+        elif keyword:
+            kw = f"%{keyword}%"
+            rows = list(
+                cur.execute(
+                    "SELECT * FROM customers WHERE status='active' AND (id LIKE ? OR name LIKE ? OR phone LIKE ?) "
+                    "ORDER BY created_at DESC",
+                    (kw, kw, kw),
+                )
+            )
+        else:
+            rows = list(cur.execute("SELECT * FROM customers WHERE status='active' ORDER BY created_at DESC"))
+        customers: list[dict] = []
+        for row in rows:
+            d = dict(row)
+            d["policies_count"] = int(
+                conn.execute(
+                    "SELECT COUNT(*) AS n FROM policies WHERE customer_id=? AND status='active'",
+                    (row["id"],),
+                ).fetchone()["n"]
+            )
+            last_fu = conn.execute(
+                "SELECT MAX(created_at) AS ts FROM followups WHERE customer_id=?",
+                (row["id"],),
+            ).fetchone()["ts"]
+            d["last_followup_at"] = last_fu
+            for k in ("household_json", "tags_json", "fields_json"):
+                try:
+                    d[k[:-5]] = json.loads(d.get(k) or "{}")
+                except json.JSONDecodeError:
+                    d[k[:-5]] = {}
+            customers.append(d)
+        return {"ok": True, "customers": customers, "count": len(customers)}
+    finally:
+        conn.close()
+
+
+def policy_query(customer_id: str | None = None, product_type: str | None = None) -> dict:
+    conn = db.connect()
+    try:
+        cur = conn.cursor()
+        if customer_id:
+            rows = list(
+                cur.execute(
+                    "SELECT * FROM policies WHERE customer_id=? AND status='active' ORDER BY effective_date DESC",
+                    (customer_id,),
+                )
+            )
+        elif product_type:
+            rows = list(
+                cur.execute(
+                    "SELECT * FROM policies WHERE product_type=? AND status='active' ORDER BY effective_date DESC",
+                    (product_type,),
+                )
+            )
+        else:
+            rows = list(cur.execute("SELECT * FROM policies WHERE status='active' ORDER BY effective_date DESC"))
+        return {"ok": True, "policies": [dict(r) for r in rows], "count": len(rows)}
+    finally:
+        conn.close()
+
+
+def customer_segment() -> dict:
+    conn = db.connect()
+    try:
+        now = datetime.now()
+        d30 = (now - timedelta(days=30)).strftime("%Y-%m-%d %H:%M:%S")
+        d60 = (now - timedelta(days=60)).strftime("%Y-%m-%d %H:%M:%S")
+        rows = list(conn.execute("SELECT * FROM customers WHERE status='active' ORDER BY created_at DESC"))
+        hi_value: list[dict] = []
+        active: list[dict] = []
+        new: list[dict] = []
+        dormant: list[dict] = []
+        for r in rows:
+            cid = r["id"]
+            premium = float(
+                conn.execute(
+                    "SELECT COALESCE(SUM(premium),0) AS s FROM policies WHERE customer_id=? AND status='active'",
+                    (cid,),
+                ).fetchone()["s"]
+            )
+            last_followup = conn.execute(
+                "SELECT MAX(created_at) AS ts FROM followups WHERE customer_id=?",
+                (cid,),
+            ).fetchone()["ts"]
+            slot = {"customer_id": cid, "name": r["name"]}
+            if premium > 50000:
+                hi_value.append(slot)
+            if r["created_at"] and str(r["created_at"]) >= d30:
+                new.append(slot)
+            if last_followup:
+                if str(last_followup) >= d30:
+                    active.append(slot)
+                elif str(last_followup) < d60:
+                    dormant.append(slot)
+            elif r["created_at"] and str(r["created_at"]) < d60:
+                dormant.append(slot)
+        return {
+            "ok": True,
+            "hi_value": hi_value,
+            "active": active,
+            "new": new,
+            "dormant": dormant,
+        }
+    finally:
+        conn.close()

package/skills/insurance-product-analysis/src/scripts/run_e2e_smoke.py

@@ -0,0 +1,202 @@
+#!/usr/bin/env python3
+"""E2E smoke for insurance-product-analysis over shared insurance DB."""
+from __future__ import annotations
+
+import json
+import os
+import subprocess
+import sys
+import tempfile
+from pathlib import Path
+
+HERE = Path(__file__).resolve().parent
+
+
+def _discover_skills_root() -> Path:
+    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
+    candidates = [HERE.parents[2], HERE.parents[1], Path("/app/skills"), Path.cwd() / "skills"]
+    for c in candidates:
+        try:
+            if (c / "insurance-customer-policy").is_dir():
+                return c.resolve()
+        except OSError:
+            continue
+    raise SystemExit("[FAIL] cannot discover skills root for smoke test")
+
+
+def _resolve_customer_pkg(skills_root: Path) -> Path:
+    candidates = [
+        skills_root / "insurance-customer-policy" / "scripts",
+        skills_root / "insurance-customer-policy" / "src" / "scripts",
+        skills_root / "insurance-customer-policy" / "src" / "src",
+    ]
+    for p in candidates:
+        try:
+            if (p / "insurance_customer_cli" / "__init__.py").is_file():
+                return p
+        except OSError:
+            continue
+    raise SystemExit("[FAIL] cannot locate insurance_customer_cli package for smoke test")
+
+
+SKILLS_ROOT = _discover_skills_root()
+CUSTOMER_PKG = _resolve_customer_pkg(SKILLS_ROOT)
+
+
+def _resolve_cli(skill_folder: str) -> Path:
+    candidates = [
+        SKILLS_ROOT / skill_folder / "scripts" / "cli.py",
+        SKILLS_ROOT / skill_folder / "src" / "scripts" / "cli.py",
+    ]
+    for p in candidates:
+        if p.is_file():
+            return p
+    raise SystemExit(f"[FAIL] cannot locate cli.py for {skill_folder}")
+
+
+PRODUCT_CLI = _resolve_cli("insurance-product-analysis")
+CUSTOMER_CLI = _resolve_cli("insurance-customer-policy")
+
+
+def _run_json(cmd: list[str], env: dict[str, str], label: str) -> dict:
+    r = subprocess.run(cmd, env=env, capture_output=True, text=True, encoding="utf-8", timeout=120)
+    if r.returncode not in (0, 1):
+        raise SystemExit(f"{label} rc={r.returncode}\nCMD: {' '.join(cmd)}\nSTDOUT:\n{r.stdout}\nSTDERR:\n{r.stderr}")
+    out = (r.stdout or "").strip()
+    if not out:
+        raise SystemExit(f"{label} empty stdout\nCMD: {' '.join(cmd)}\nrc={r.returncode}\nSTDERR:\n{r.stderr}")
+    try:
+        return json.loads(out)
+    except json.JSONDecodeError as e:
+        raise SystemExit(f"{label} bad json: {e}\nCMD: {' '.join(cmd)}\nSTDOUT:\n{out}\nSTDERR:\n{r.stderr}")
+
+
+def run_product(*args: str) -> dict:
+    cmd = [sys.executable, str(PRODUCT_CLI), *args]
+    env = {**os.environ, "PYTHONIOENCODING": "utf-8"}
+    return _run_json(cmd, env, "product")
+
+
+def run_customer(*args: str) -> dict:
+    cmd = [sys.executable, str(CUSTOMER_CLI), *args]
+    env = {**os.environ, "PYTHONIOENCODING": "utf-8"}
+    return _run_json(cmd, env, "customer")
+
+
+def assert_ok(d: dict, *args: str) -> dict:
+    if not d.get("ok"):
+        raise SystemExit(f"expected ok=True got {d} args={args}")
+    return d
+
+
+def assert_err(d: dict, code: str, *args: str) -> None:
+    if d.get("ok") or d.get("error") != code:
+        raise SystemExit(f"expected error={code} got {d} args={args}")
+
+
+def main() -> int:
+    tmp = tempfile.mkdtemp(prefix="ins_prod_smoke_")
+    shared = str(Path(tmp) / "insurance.sqlite3")
+    os.environ["INSURANCE_DB_PATH"] = shared
+    os.environ["INSURANCE_PRODUCT_DB_PATH"] = shared
+    os.environ["INSURANCE_CUSTOMER_DB_PATH"] = shared
+
+    print("[setup] seed customer-policy data")
+    assert_ok(run_customer("customer-add", "--name", "张先生", "--phone", "13800138000",
+                           "--age", "35", "--income", "300000",
+                           "--household", '{"spouse":true,"children":2}'))
+    assert_ok(run_customer("customer-add", "--name", "李女士", "--phone", "13900139000",
+                           "--age", "28", "--income", "150000"))
+    assert_ok(run_customer("policy-add", "--customer-id", "C001",
+                           "--company", "A保险", "--product", "百万医疗",
+                           "--type", "医疗险", "--coverage", "1000000", "--premium", "500",
+                           "--effective-date", "2024-01-01", "--pay-period", "1年"))
+    assert_ok(run_customer("followup-add", "--customer-id", "C001", "--content", "刚刚跟进"))
+
+    print("[1] product-add")
+    p1 = assert_ok(run_product("product-add", "--name", "XX重疾险2024",
+                               "--company", "A保险公司", "--type", "重疾险",
+                               "--coverage-range", "10万-100万",
+                               "--premium-range", "3000-15000",
+                               "--age-range", "0-55岁",
+                               "--highlights", "覆盖120种重疾|轻症豁免|保额递增",
+                               "--raw-text", "保120种重疾，等待期90天..."))
+    assert p1["id"]
+    assert_ok(run_product("product-add", "--name", "YY重疾险2024",
+                          "--company", "B保险公司", "--type", "重疾险",
+                          "--coverage-range", "30万-200万",
+                          "--premium-range", "5000-20000",
+                          "--age-range", "0-55岁",
+                          "--highlights", "保额翻倍|覆盖180种重疾"))
+
+    print("[2] product-add: duplicate")
+    assert_err(run_product("product-add", "--name", "XX重疾险2024",
+                           "--company", "A", "--type", "重疾险"), "duplicate_product")
+
+    print("[3] product-query")
+    d = assert_ok(run_product("product-query", "--type", "重疾险"))
+    assert d["count"] == 2
+
+    print("[4] product-update + cache invalidation")
+    assert_ok(run_product("product-update", "--name", "XX重疾险2024",
+                          "--set", '{"highlights":["新亮点A","新亮点B"]}'))
+    d = assert_ok(run_product("product-query", "--name", "XX重疾险2024"))
+    assert "新亮点A" in d["products"][0]["highlights"]
+
+    print("[5] product-analyze (no cache → needs_llm)")
+    d = run_product("product-analyze", "--product", "XX重疾险2024")
+    assert d.get("error") == "needs_llm", d
+    assert "prompt_template" in d
+
+    print("[6] analysis-write + product-analyze (cache hit)")
+    assert_ok(run_product("analysis-write", "--product", "XX重疾险2024",
+                          "--result", json.dumps({
+                              "key_terms": ["保120种重疾", "等待期90天"],
+                              "selling_points": ["保额递增", "轻症豁免", "费率低"],
+                              "fit_audience": ["25-45岁", "年收入20w+"],
+                              "pitch_script": "您已有医疗险..."
+                          }, ensure_ascii=False)))
+    d = assert_ok(run_product("product-analyze", "--product", "XX重疾险2024"))
+    assert d["result"]["from_cache"] is True
+    assert "保额递增" in d["result"]["selling_points"]
+
+    print("[7] gap-analysis (forwarded)")
+    d = assert_ok(run_product("gap-analysis", "--customer-id", "C001"))
+    assert "重疾险" in d["result"]["gaps"]
+    d = assert_ok(run_product("gap-analysis", "--all", "--gap-type", "重疾险"))
+    assert d["count"] >= 1
+
+    print("[8] customer-match (product → customers)")
+    d = assert_ok(run_product("customer-match", "--product", "XX重疾险2024"))
+    assert any(m["matches_gap"] for m in d["matches"])
+    top = d["matches"][0]
+    assert top["score"] >= 100, top
+
+    print("[9] customer-match (customer → products)")
+    d = assert_ok(run_product("customer-match", "--customer-id", "C001"))
+    assert d["matches"], d
+    assert d["matches"][0]["matches_gap"] is True
+
+    print("[10] product-compare")
+    d = assert_ok(run_product("product-compare", "--product-a", "XX重疾险2024",
+                              "--product-b", "YY重疾险2024"))
+    assert any(r["field"] == "公司" for r in d["compare"])
+
+    print("[11] dashboard")
+    d = assert_ok(run_product("dashboard", "--json"))
+    assert d["products_total"] == 2
+
+    print("[12] product-delete")
+    assert_err(run_product("product-delete", "--name", "YY重疾险2024"), "need_confirm")
+    assert_ok(run_product("product-delete", "--name", "YY重疾险2024", "--yes"))
+
+    print("ALL OK")
+    return 0
+
+
+if __name__ == "__main__":
+    raise SystemExit(main())

package/skills/insurance-product-analysis/src/src/insurance_product_cli/__main__.py

@@ -0,0 +1,4 @@
+from insurance_product_cli.cli import main
+
+if __name__ == "__main__":
+    raise SystemExit(main())