sophhub 0.4.21 → 0.4.23

package/skills/insurance-schedule-renewal/src/scripts/insurance_schedule_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_SCHEDULE_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-schedule-renewal/src/scripts/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-schedule-renewal/src/scripts/run_e2e_smoke.py

@@ -0,0 +1,218 @@
+#!/usr/bin/env python3
+"""E2E smoke for insurance-schedule-renewal on shared insurance DB."""
+from __future__ import annotations
+
+import json
+import os
+import sqlite3
+import subprocess
+import sys
+import tempfile
+from datetime import datetime, timedelta
+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}")
+
+
+SCHEDULE_CLI = _resolve_cli("insurance-schedule-renewal")
+CUSTOMER_CLI = _resolve_cli("insurance-customer-policy")
+
+
+def _run_json(cmd: list[str], env: dict[str, str], label: str, timeout: int = 120) -> dict:
+    r = subprocess.run(cmd, env=env, capture_output=True, text=True, encoding="utf-8", timeout=timeout)
+    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_schedule(*args: str) -> dict:
+    cmd = [sys.executable, str(SCHEDULE_CLI), *args]
+    env = {**os.environ, "PYTHONIOENCODING": "utf-8"}
+    return _run_json(cmd, env, "schedule", timeout=120)
+
+
+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", timeout=60)
+
+
+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 main() -> int:
+    tmp = tempfile.mkdtemp(prefix="ins_sched_smoke_")
+    shared = str(Path(tmp) / "insurance.sqlite3")
+    os.environ["INSURANCE_DB_PATH"] = shared
+    os.environ["INSURANCE_SCHEDULE_DB_PATH"] = shared
+    os.environ["INSURANCE_CUSTOMER_DB_PATH"] = shared
+
+    today = datetime.now()
+    in_15 = (today + timedelta(days=15)).strftime("%Y-%m-%d")
+    in_45 = (today + timedelta(days=45)).strftime("%Y-%m-%d")
+    long_ago = (today - timedelta(days=400)).strftime("%Y-%m-%d")
+
+    print("[setup] customers")
+    assert_ok(run_customer("customer-add", "--name", "张先生", "--phone", "13800138000",
+                           "--age", "35", "--income", "300000",
+                           "--household", '{"spouse":true,"children":2}',
+                           "--birthday", f"1989-{today.month:02d}-09"))
+    assert_ok(run_customer("customer-add", "--name", "李女士", "--phone", "13900139000",
+                           "--age", "40", "--birthday",
+                           f"1985-{(today.month % 12) + 1:02d}-15"))
+    assert_ok(run_customer("customer-add", "--name", "王先生", "--phone", "13700137000", "--age", "50"))
+
+    print("[setup] policies")
+    p1 = assert_ok(run_customer("policy-add", "--customer-id", "C001",
+                                "--company", "A保险", "--product", "重疾险XX",
+                                "--type", "重疾险", "--coverage", "500000", "--premium", "8000",
+                                "--effective-date", long_ago,
+                                "--expire-date", in_15,
+                                "--next-pay-date", in_15))
+    assert p1["id"] == "P001"
+    eff_recent = (today - timedelta(days=20)).strftime("%Y-%m-%d")  # 周年月份
+    eff_recent = f"{today.year - 2}-{today.month:02d}-15"
+    assert_ok(run_customer("policy-add", "--customer-id", "C002",
+                           "--company", "B保险", "--product", "百万医疗",
+                           "--type", "医疗险", "--coverage", "1000000", "--premium", "500",
+                           "--effective-date", eff_recent,
+                           "--expire-date", in_45))
+    assert_ok(run_customer("policy-add", "--customer-id", "C003",
+                           "--company", "C保险", "--product", "意外险",
+                           "--type", "意外险", "--coverage", "500000", "--premium", "300",
+                           "--effective-date", "2020-01-01"))
+
+    print("[setup] followups (C001 has recent, C002/C003 backdated to >30d/>60d)")
+    assert_ok(run_customer("followup-add", "--customer-id", "C001", "--content", "刚刚跟进过"))
+    # Backdate customer created_at so 'lapsed' logic kicks in.
+    conn = sqlite3.connect(os.environ["INSURANCE_DB_PATH"])
+    backdated_30 = (today - timedelta(days=45)).strftime("%Y-%m-%d %H:%M:%S")
+    backdated_60 = (today - timedelta(days=80)).strftime("%Y-%m-%d %H:%M:%S")
+    conn.execute("UPDATE customers SET created_at=? WHERE id='C002'", (backdated_30,))
+    conn.execute("UPDATE customers SET created_at=? WHERE id='C003'", (backdated_60,))
+    conn.commit()
+    conn.close()
+
+    print("[1] renewal-query days=30 (P001 expire in 15d)")
+    d = assert_ok(run_schedule("renewal-query", "--days", "30"))
+    assert any(it["policy_id"] == "P001" for it in d["items"]), d
+    assert d["items"][0]["customer_name"] == "张先生", d
+    assert d["count"] >= 1
+
+    print("[2] renewal-query days=60 (catches P002 too)")
+    d = assert_ok(run_schedule("renewal-query", "--days", "60"))
+    assert any(it["policy_id"] == "P002" for it in d["items"]), d
+
+    print("[3] renewal-remind --mark-sent (first run -> new)")
+    d = assert_ok(run_schedule("renewal-remind", "--days", "30", "--mark-sent"))
+    assert d["new_count"] >= 1
+    assert d["skipped_count"] == 0
+
+    print("[4] renewal-remind same bucket (second run -> already_sent)")
+    d = assert_ok(run_schedule("renewal-remind", "--days", "30", "--mark-sent"))
+    assert d["new_count"] == 0
+    assert d["skipped_count"] >= 1
+
+    print("[5] followup-check days=30 (C002, C003 lapsed; C001 recent)")
+    d = assert_ok(run_schedule("followup-check", "--days", "30"))
+    cids = [c["customer_id"] for c in d["items"]]
+    assert "C001" not in cids
+    assert "C002" in cids and "C003" in cids
+
+    print("[6] followup-remind dedup")
+    a = assert_ok(run_schedule("followup-remind", "--days", "30", "--mark-sent"))
+    assert a["new_count"] >= 2 and a["skipped_count"] == 0
+    b = assert_ok(run_schedule("followup-remind", "--days", "30", "--mark-sent"))
+    assert b["new_count"] == 0 and b["skipped_count"] >= 2
+
+    print("[7] dormant-query days=60 (only C003 lapsed >60d)")
+    d = assert_ok(run_schedule("dormant-query", "--days", "60"))
+    cids = [c["customer_id"] for c in d["items"]]
+    assert "C003" in cids and "C001" not in cids, d
+
+    print("[8] dormant-wake (script generated)")
+    d = assert_ok(run_schedule("dormant-wake", "--days", "60"))
+    angles = {it["angle"] for it in d["items"]}
+    assert angles, d
+    assert all(it["script"] for it in d["items"]), d
+
+    print("[9] special-date-query birthday (current month)")
+    d = assert_ok(run_schedule("special-date-query", "--type", "birthday",
+                               "--month", str(today.month)))
+    assert any(it["customer_id"] == "C001" for it in d["items"]), d
+
+    print("[10] special-date-query anniversary (current month)")
+    d = assert_ok(run_schedule("special-date-query", "--type", "anniversary",
+                               "--month", str(today.month)))
+    assert any(it["policy_id"] == "P002" for it in d["items"]), d
+
+    print("[11] daily-summary")
+    d = assert_ok(run_schedule("daily-summary"))
+    assert d["summary"]["renewal_30d"] >= 1
+    assert "续保提醒" in d["markdown"]
+
+    print("[12] dashboard")
+    d = assert_ok(run_schedule("dashboard", "--json"))
+    assert d["skill"] == "insurance-schedule-renewal"
+
+    print("ALL OK")
+    return 0
+
+
+if __name__ == "__main__":
+    raise SystemExit(main())

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

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