sophhub 0.1.0

package/skills/builtin/sophnet-customer-management/src/customer_mgmt_core/models.py

@@ -0,0 +1,84 @@
+from __future__ import annotations
+
+from dataclasses import asdict, dataclass, field
+from typing import Any
+
+
+BUILTIN_CUSTOMER_FIELDS = {
+    "name",
+    "primary_phone",
+    "birthday",
+    "tags",
+    "notes",
+}
+
+
+@dataclass(slots=True)
+class FieldDefinition:
+    field_key: str
+    label: str
+    value_type: str = "string"
+    entity_type: str = "customer"
+    is_required: bool = False
+    source: str = "user_confirmed"
+    status: str = "active"
+    aliases: list[str] = field(default_factory=list)
+
+    def to_dict(self) -> dict[str, Any]:
+        return asdict(self)
+
+
+@dataclass(slots=True)
+class CustomerPayload:
+    name: str
+    primary_phone: str | None = None
+    birthday: str | None = None
+    tags: list[str] = field(default_factory=list)
+    notes: str | None = None
+    dynamic_fields: dict[str, Any] = field(default_factory=dict)
+
+    def to_dict(self) -> dict[str, Any]:
+        return asdict(self)
+
+
+@dataclass(slots=True)
+class BusinessRecordPayload:
+    customer_id: str
+    record_type: str
+    status: str | None = None
+    record_date: str | None = None
+    amount: str | None = None
+    title: str | None = None
+    raw_payload: dict[str, Any] = field(default_factory=dict)
+
+    def to_dict(self) -> dict[str, Any]:
+        return asdict(self)
+
+
+@dataclass(slots=True)
+class ReminderPlan:
+    customer_id: str
+    customer_name: str
+    reminder_type: str
+    title: str
+    trigger_at: str | None
+    cron_expr: str
+    message: str
+    recurring: bool = False
+
+    def to_dict(self) -> dict[str, Any]:
+        return asdict(self)
+
+
+@dataclass(slots=True)
+class ImportPreview:
+    mode: str
+    source_file: str
+    customer_count: int
+    record_count: int
+    new_field_count: int
+    warnings: list[str] = field(default_factory=list)
+    preview_rows: list[dict[str, Any]] = field(default_factory=list)
+
+    def to_dict(self) -> dict[str, Any]:
+        return asdict(self)

package/skills/builtin/sophnet-customer-management/src/customer_mgmt_core/normalizer.py

@@ -0,0 +1,144 @@
+from __future__ import annotations
+
+import hashlib
+import json
+import re
+from datetime import date, datetime
+from typing import Any
+
+
+NULL_MARKERS = {"", "nan", "none", "null", "nat", "未填写", "暂无", "-"}
+
+
+def clean_text(value: Any) -> str:
+    if value is None:
+        return ""
+    text = str(value).strip()
+    text = text.replace("\u3000", " ")
+    text = re.sub(r"\s+", " ", text)
+    return text
+
+
+def is_blank(value: Any) -> bool:
+    return clean_text(value).lower() in NULL_MARKERS
+
+
+def normalize_optional_text(value: Any) -> str | None:
+    text = clean_text(value)
+    if text.lower() in NULL_MARKERS:
+        return None
+    return text
+
+
+def normalize_phone(value: Any) -> str | None:
+    text = clean_text(value)
+    if not text:
+        return None
+    digits = re.sub(r"\D+", "", text)
+    if len(digits) >= 11:
+        return digits[-11:]
+    if len(digits) >= 7:
+        return digits
+    return None
+
+
+def normalize_date(value: Any) -> str | None:
+    text = clean_text(value)
+    if not text or text.lower() in NULL_MARKERS:
+        return None
+    text = text.replace("年", ".").replace("月", ".").replace("日", "")
+    text = text.replace("/", ".").replace("-", ".")
+    text = re.sub(r"\.+", ".", text).strip(".")
+    candidates = [
+        "%Y.%m.%d",
+        "%Y.%m",
+        "%m.%d",
+    ]
+    for fmt in candidates:
+        try:
+            parsed = datetime.strptime(text, fmt)
+            year = parsed.year
+            if fmt == "%m.%d":
+                year = date.today().year
+            month = parsed.month
+            day = parsed.day if "%d" in fmt else 1
+            return date(year, month, day).isoformat()
+        except ValueError:
+            continue
+    if re.fullmatch(r"\d{4}\.\d{1,2}\.\d{1,2}", text):
+        parts = [int(item) for item in text.split(".")]
+        return date(parts[0], parts[1], parts[2]).isoformat()
+    return None
+
+
+def normalize_tags(value: Any) -> list[str]:
+    if isinstance(value, (list, tuple, set)):
+        return [clean_text(item) for item in value if clean_text(item)]
+    text = clean_text(value)
+    if not text:
+        return []
+    parts = re.split(r"[,，、/\s]+", text)
+    return [item for item in (part.strip() for part in parts) if item]
+
+
+def normalize_money(value: Any) -> str | None:
+    text = clean_text(value)
+    if not text or text.lower() in NULL_MARKERS:
+        return None
+    return text
+
+
+def normalize_value_for_type(value: Any, value_type: str) -> str | None:
+    if value_type == "date":
+        return normalize_date(value)
+    if value_type == "phone":
+        return normalize_phone(value)
+    if value_type == "tags":
+        tags = normalize_tags(value)
+        return json.dumps(tags, ensure_ascii=False)
+    if value_type == "money":
+        return normalize_money(value)
+    return normalize_optional_text(value)
+
+
+def guess_value_type(label: str, values: list[Any]) -> str:
+    joined_label = clean_text(label).lower()
+    if any(keyword in joined_label for keyword in ["微信", "wechat", "wx"]):
+        return "string"
+    if any(keyword in joined_label for keyword in ["电话", "手机", "手机号", "mobile", "phone"]):
+        return "phone"
+    if any(keyword in joined_label for keyword in ["生日", "日期", "时间", "生效", "到期", "续费", "回访", "预约"]):
+        return "date"
+    if any(keyword in joined_label for keyword in ["金额", "保费", "保额", "消费", "价格", "佣金"]):
+        return "money"
+
+    non_blank = [clean_text(value) for value in values if not is_blank(value)]
+    if not non_blank:
+        return "string"
+
+    date_hits = sum(1 for value in non_blank if normalize_date(value))
+    if date_hits == len(non_blank):
+        return "date"
+
+    phone_hits = sum(1 for value in non_blank if normalize_phone(value))
+    if phone_hits == len(non_blank):
+        return "phone"
+
+    numeric_hits = sum(1 for value in non_blank if re.fullmatch(r"[\d.]+", value))
+    if numeric_hits == len(non_blank):
+        return "number"
+
+    return "string"
+
+
+def stable_field_key(label: str) -> str:
+    text = clean_text(label).lower()
+    ascii_text = re.sub(r"[^a-z0-9]+", "_", text).strip("_")
+    if ascii_text:
+        return ascii_text[:48]
+    digest = hashlib.sha1(clean_text(label).encode("utf-8")).hexdigest()[:12]
+    return f"fld_{digest}"
+
+
+def dumps_json(data: Any) -> str:
+    return json.dumps(data, ensure_ascii=False, sort_keys=True)

package/skills/builtin/sophnet-customer-management/src/customer_mgmt_core/parser.py

@@ -0,0 +1,241 @@
+from __future__ import annotations
+
+import csv
+import re
+from pathlib import Path
+from typing import Any
+
+import openpyxl
+import xlrd
+
+from .normalizer import clean_text, is_blank
+from .schema import resolve_grouped_record_field
+
+
+def parse_file(file_path: str | Path) -> dict[str, Any]:
+    path = Path(file_path)
+    suffix = path.suffix.lower()
+    if suffix in {".csv"}:
+        tables = [_grid_to_table(_read_csv_grid(path), title=path.stem)]
+    elif suffix in {".xlsx"}:
+        tables = _read_xlsx_tables(path)
+    elif suffix in {".xls"}:
+        tables = _read_xls_tables(path)
+    elif suffix in {".md", ".markdown", ".txt"}:
+        tables = _read_markdown_tables(path)
+    else:
+        raise ValueError(f"暂不支持的文件类型: {suffix}")
+
+    filtered_tables = [table for table in tables if table and table["rows"]]
+    return {
+        "source_file": str(path),
+        "format": suffix.lstrip("."),
+        "tables": filtered_tables,
+    }
+
+
+def _read_csv_grid(path: Path) -> list[list[str]]:
+    with path.open("r", encoding="utf-8-sig", newline="") as file:
+        return [[clean_text(cell) for cell in row] for row in csv.reader(file)]
+
+
+def _read_xlsx_tables(path: Path) -> list[dict[str, Any]]:
+    workbook = openpyxl.load_workbook(path, data_only=True)
+    tables: list[dict[str, Any]] = []
+    for sheet in workbook.worksheets:
+        grid = [
+            [sheet.cell(row_idx, col_idx).value for col_idx in range(1, sheet.max_column + 1)]
+            for row_idx in range(1, sheet.max_row + 1)
+        ]
+        for merged in sheet.merged_cells.ranges:
+            value = grid[merged.min_row - 1][merged.min_col - 1]
+            for row_idx in range(merged.min_row - 1, merged.max_row):
+                for col_idx in range(merged.min_col - 1, merged.max_col):
+                    grid[row_idx][col_idx] = value
+        grid = [[clean_text(cell) for cell in row] for row in grid]
+        table = _grid_to_table(grid, title=sheet.title)
+        if table:
+            tables.append(table)
+    return tables
+
+
+def _read_xls_tables(path: Path) -> list[dict[str, Any]]:
+    workbook = xlrd.open_workbook(path, formatting_info=True)
+    tables: list[dict[str, Any]] = []
+    for index in range(workbook.nsheets):
+        sheet = workbook.sheet_by_index(index)
+        grid = [
+            [sheet.cell_value(row_idx, col_idx) for col_idx in range(sheet.ncols)]
+            for row_idx in range(sheet.nrows)
+        ]
+        for row_lo, row_hi, col_lo, col_hi in sheet.merged_cells:
+            value = grid[row_lo][col_lo]
+            for row_idx in range(row_lo, row_hi):
+                for col_idx in range(col_lo, col_hi):
+                    grid[row_idx][col_idx] = value
+        grid = [[clean_text(cell) for cell in row] for row in grid]
+        table = _grid_to_table(grid, title=sheet.name)
+        if table:
+            tables.append(table)
+    return tables
+
+
+def _read_markdown_tables(path: Path) -> list[dict[str, Any]]:
+    lines = path.read_text(encoding="utf-8").splitlines()
+    blocks: list[list[list[str]]] = []
+    current: list[list[str]] = []
+
+    def flush_current() -> None:
+        nonlocal current
+        if current:
+            blocks.append(current)
+            current = []
+
+    for line in lines:
+        stripped = line.strip()
+        if not stripped.startswith("|"):
+            flush_current()
+            continue
+        cells = [clean_text(cell) for cell in stripped.strip("|").split("|")]
+        if all(re.fullmatch(r"[-:\s]+", cell or "-") for cell in cells):
+            continue
+        current.append(cells)
+    flush_current()
+    tables = []
+    for index, block in enumerate(blocks):
+        table = _grid_to_table(block, title=f"table_{index + 1}")
+        if table:
+            tables.append(table)
+    return tables
+
+
+def _grid_to_table(grid: list[list[str]], title: str) -> dict[str, Any] | None:
+    rows = [_trim_row(row) for row in grid if any(not is_blank(cell) for cell in row)]
+    if not rows:
+        return None
+
+    title_row = None
+    if _looks_like_title_row(rows[0]):
+        title_row = rows.pop(0)
+    if not rows:
+        return None
+
+    header_start = 0
+    headers = rows[0]
+    data_start = 1
+    if _has_second_header_row(rows):
+        headers = _combine_headers(rows[0], rows[1])
+        data_start = 2
+    headers = _dedupe_headers(headers)
+    if not any(headers):
+        return None
+
+    mode = "grouped_records" if _looks_like_grouped_record_headers(headers) else "generic"
+    parsed_rows = _rows_to_dicts(rows[data_start:], headers, forward_fill=(mode == "grouped_records"))
+    return {
+        "title": clean_text(title_row[0]) if title_row else title,
+        "headers": headers,
+        "rows": parsed_rows,
+        "mode": mode,
+    }
+
+
+def _trim_row(row: list[str]) -> list[str]:
+    cleaned = [clean_text(cell) for cell in row]
+    while cleaned and is_blank(cleaned[-1]):
+        cleaned.pop()
+    return cleaned
+
+
+def _looks_like_title_row(row: list[str]) -> bool:
+    first = clean_text(row[0]) if row else ""
+    if "客户档案" in first:
+        return True
+    unnamed_count = sum(1 for cell in row if "unnamed" in clean_text(cell).lower())
+    return unnamed_count >= max(2, len(row) // 3)
+
+
+def _has_second_header_row(rows: list[list[str]]) -> bool:
+    if len(rows) < 2:
+        return False
+    second_row = rows[1]
+    markers = {"姓名", "性别", "生日"}
+    return sum(1 for cell in second_row if clean_text(cell) in markers) >= 2
+
+
+def _combine_headers(main_headers: list[str], sub_headers: list[str]) -> list[str]:
+    result: list[str] = []
+    current_group = ""
+    for index, main in enumerate(main_headers):
+        sub = sub_headers[index] if index < len(sub_headers) else ""
+        main_text = clean_text(main)
+        sub_text = clean_text(sub)
+        if not is_blank(main_text):
+            current_group = main_text
+        elif current_group and sub_text:
+            main_text = current_group
+        if is_blank(main_text):
+            result.append(sub_text)
+            continue
+        if is_blank(sub_text):
+            result.append(main_text)
+            continue
+        if sub_text == main_text:
+            result.append(main_text)
+            continue
+        result.append(f"{main_text}_{sub_text}")
+    return result
+
+
+def _dedupe_headers(headers: list[str]) -> list[str]:
+    seen: dict[str, int] = {}
+    result: list[str] = []
+    for index, header in enumerate(headers):
+        text = clean_text(header)
+        if not text or text.lower().startswith("unnamed"):
+            text = f"column_{index + 1}"
+        count = seen.get(text, 0)
+        seen[text] = count + 1
+        result.append(text if count == 0 else f"{text}_{count + 1}")
+    return result
+
+
+def _looks_like_grouped_record_headers(headers: list[str]) -> bool:
+    grouped_hits = 0
+    normalized_hits = 0
+    for header in headers:
+        if "_" in header:
+            prefix, suffix = header.split("_", 1)
+            if prefix and suffix in {"姓名", "性别", "生日", "出生日期", "手机", "手机号", "电话", "联系电话"}:
+                grouped_hits += 1
+        if resolve_grouped_record_field(header):
+            normalized_hits += 1
+    return grouped_hits >= 2 or normalized_hits >= 3
+
+
+def _rows_to_dicts(rows: list[list[str]], headers: list[str], *, forward_fill: bool) -> list[dict[str, str]]:
+    output: list[dict[str, str]] = []
+    previous_values = {header: "" for header in headers}
+    for raw_row in rows:
+        if not raw_row:
+            continue
+        row: dict[str, str] = {}
+        for index, header in enumerate(headers):
+            value = clean_text(raw_row[index]) if index < len(raw_row) else ""
+            if forward_fill and is_blank(value):
+                value = previous_values.get(header, "")
+            row[header] = value
+            if not is_blank(value):
+                previous_values[header] = value
+        if _is_meaningful_row(row):
+            output.append(row)
+    return output
+
+
+def _is_meaningful_row(row: dict[str, str]) -> bool:
+    non_blank_values = [value for value in row.values() if not is_blank(value)]
+    if not non_blank_values:
+        return False
+    if len(non_blank_values) == 1 and non_blank_values[0].isdigit():
+        return False
+    return True

package/skills/builtin/sophnet-customer-management/src/customer_mgmt_core/query.py

@@ -0,0 +1,109 @@
+from __future__ import annotations
+
+from datetime import date, timedelta
+from typing import Any
+
+from .normalizer import clean_text, normalize_date, normalize_phone
+
+
+def match_filters(customer: dict[str, Any], query: dict[str, Any]) -> bool:
+    customer_id = clean_text(query.get("customer_id"))
+    if customer_id and customer_id != clean_text(customer.get("customer_id")):
+        return False
+
+    name = clean_text(query.get("name"))
+    if name and name not in clean_text(customer.get("name")):
+        return False
+
+    phone = normalize_phone(query.get("primary_phone") or query.get("phone"))
+    if phone:
+        customer_phone = normalize_phone(customer.get("primary_phone"))
+        if not customer_phone or phone not in customer_phone:
+            return False
+
+    birthday_month = query.get("birthday_month")
+    if birthday_month:
+        birthday = normalize_date(customer.get("birthday"))
+        if not birthday or int(birthday.split("-")[1]) != int(birthday_month):
+            return False
+
+    tags = query.get("tags") or []
+    if query.get("tag"):
+        tags = [query["tag"], *tags]
+    if tags:
+        customer_tags = set(customer.get("tags", []))
+        if not set(tags).issubset(customer_tags):
+            return False
+
+    dynamic_filters = query.get("dynamic_filters") or []
+    field_map = customer.get("dynamic_field_map", {})
+    for item in dynamic_filters:
+        field_key = item.get("field_key") or item.get("field")
+        if not field_key:
+            return False
+        data = field_map.get(field_key)
+        if not data:
+            data = next(
+                (
+                    candidate
+                    for candidate in field_map.values()
+                    if clean_text(candidate.get("label")) == clean_text(field_key)
+                ),
+                None,
+            )
+        if not data:
+            return False
+        op = item.get("op", "contains")
+        expected = clean_text(item.get("value"))
+        actual = clean_text(data.get("displayValue") or data.get("value"))
+        if op == "eq" and actual != expected:
+            return False
+        if op == "contains" and expected not in actual:
+            return False
+    return True
+
+
+def sort_customers(customers: list[dict[str, Any]]) -> list[dict[str, Any]]:
+    return sorted(
+        customers,
+        key=lambda item: (
+            item.get("birthday") or "9999-12-31",
+            item.get("name") or "",
+        ),
+    )
+
+
+def select_due_fields(customer: dict[str, Any]) -> list[dict[str, Any]]:
+    results = []
+    for field_key, value in customer.get("dynamic_field_map", {}).items():
+        label = clean_text(value.get("label", ""))
+        normalized = normalize_date(value.get("value"))
+        if not normalized:
+            continue
+        if any(keyword in label for keyword in ["到期", "续费", "回访", "预约"]):
+            results.append(
+                {
+                    "field_key": field_key,
+                    "label": label,
+                    "date": normalized,
+                    "display_value": value.get("displayValue") or value.get("value"),
+                }
+            )
+    return results
+
+
+def query_due_within_days(customers: list[dict[str, Any]], days: int) -> list[dict[str, Any]]:
+    today = date.today()
+    end_date = today + timedelta(days=days)
+    matched: list[dict[str, Any]] = []
+    for customer in customers:
+        due_fields = []
+        for item in select_due_fields(customer):
+            due_date = date.fromisoformat(item["date"])
+            if today <= due_date <= end_date:
+                due_fields.append(item)
+        if due_fields:
+            cloned = dict(customer)
+            cloned["due_fields"] = due_fields
+            matched.append(cloned)
+    return matched

package/skills/builtin/sophnet-customer-management/src/customer_mgmt_core/reminder.py

@@ -0,0 +1,121 @@
+from __future__ import annotations
+
+import subprocess
+from dataclasses import asdict
+from datetime import date, datetime, timedelta
+from typing import Any
+
+from .models import ReminderPlan
+from .query import select_due_fields
+
+
+def build_birthday_plans(customers: list[dict[str, Any]]) -> list[ReminderPlan]:
+    plans: list[ReminderPlan] = []
+    for customer in customers:
+        birthday = customer.get("birthday")
+        if not birthday:
+            continue
+        try:
+            month = int(birthday.split("-")[1])
+            day = int(birthday.split("-")[2])
+        except (IndexError, ValueError):
+            continue
+        cron_expr = f"0 9 {day} {month} *"
+        plans.append(
+            ReminderPlan(
+                customer_id=customer["customer_id"],
+                customer_name=customer["name"],
+                reminder_type="birthday",
+                title=f"{customer['name']} 生日提醒",
+                trigger_at=None,
+                cron_expr=cron_expr,
+                message=f"🎂 客户 {customer['name']} 今天生日，记得送上祝福或做一次回访。",
+                recurring=True,
+            )
+        )
+    return plans
+
+
+def build_due_plans(customers: list[dict[str, Any]], *, days: tuple[int, ...] = (30, 7, 1)) -> list[ReminderPlan]:
+    today = date.today()
+    plans: list[ReminderPlan] = []
+    for customer in customers:
+        for item in select_due_fields(customer):
+            due_date = date.fromisoformat(item["date"])
+            for before_days in days:
+                trigger_date = due_date - timedelta(days=before_days)
+                if trigger_date < today:
+                    continue
+                cron_expr = f"0 9 {trigger_date.day} {trigger_date.month} *"
+                plans.append(
+                    ReminderPlan(
+                        customer_id=customer["customer_id"],
+                        customer_name=customer["name"],
+                        reminder_type="due_date",
+                        title=f"{customer['name']} {item['label']}提醒",
+                        trigger_at=trigger_date.isoformat(),
+                        cron_expr=cron_expr,
+                        message=(
+                            f"⏰ 客户 {customer['name']} 的「{item['label']}」将在 {before_days} 天后到来，"
+                            f"当前记录日期为 {item['display_value']}。"
+                        ),
+                        recurring=False,
+                    )
+                )
+    return plans
+
+
+def build_follow_up_plan(customer: dict[str, Any], follow_up_date: str) -> ReminderPlan:
+    due_date = date.fromisoformat(follow_up_date)
+    cron_expr = f"0 9 {due_date.day} {due_date.month} *"
+    return ReminderPlan(
+        customer_id=customer["customer_id"],
+        customer_name=customer["name"],
+        reminder_type="follow_up",
+        title=f"{customer['name']} 跟进提醒",
+        trigger_at=follow_up_date,
+        cron_expr=cron_expr,
+        message=f"📞 记得跟进客户 {customer['name']}。",
+        recurring=False,
+    )
+
+
+def schedule_plans(plans: list[ReminderPlan], *, tz: str = "Asia/Shanghai") -> list[dict[str, Any]]:
+    results = []
+    for plan in plans:
+        task_name = _build_task_name(plan)
+        command = [
+            "openclaw",
+            "cron",
+            "add",
+            "--name",
+            task_name,
+            "--cron",
+            plan.cron_expr,
+            "--tz",
+            tz,
+            "--session",
+            "main",
+            "--system-event",
+            plan.message,
+        ]
+        if not plan.recurring:
+            command.append("--delete-after-run")
+
+        process = subprocess.run(command, capture_output=True, text=True)
+        results.append(
+            {
+                **asdict(plan),
+                "task_name": task_name,
+                "scheduled": process.returncode == 0,
+                "stdout": process.stdout.strip(),
+                "stderr": process.stderr.strip(),
+            }
+        )
+    return results
+
+
+def _build_task_name(plan: ReminderPlan) -> str:
+    timestamp = plan.trigger_at or datetime.now().date().isoformat()
+    safe_name = "".join(char if char.isalnum() else "_" for char in plan.customer_name)[:24]
+    return f"customer-{plan.reminder_type}-{timestamp}-{safe_name}"