sophhub 0.2.2 → 0.2.4

package/skills/sophnet-schedule/src/services/local_event_store.py

@@ -0,0 +1,266 @@
+"""
+本地事件存储。
+
+使用 JSON 文件作为单用户场景下的轻量事件仓储：
+- 事件持久化
+- 原子写入
+- 简单文件锁
+- 查询 / 删除 / 同步状态更新
+"""
+
+from __future__ import annotations
+
+import json
+import os
+import uuid
+from contextlib import contextmanager
+from datetime import datetime
+from pathlib import Path
+from tempfile import NamedTemporaryFile
+from typing import Iterator
+
+try:
+    import fcntl
+except ImportError:  # pragma: no cover - Windows fallback
+    fcntl = None
+
+from config.settings import LOCAL_EVENTS_FILE
+from gcal.models import CalendarEvent
+
+
+def _default_store() -> dict:
+    return {"version": 1, "events": []}
+
+
+def resolve_store_path(path: str | Path | None = None) -> Path:
+    return Path(path) if path is not None else LOCAL_EVENTS_FILE
+
+
+def _atomic_write_json(path: Path, data: dict) -> None:
+    path.parent.mkdir(parents=True, exist_ok=True)
+    tmp_name = None
+    try:
+        with NamedTemporaryFile(
+            "w",
+            dir=path.parent,
+            delete=False,
+            encoding="utf-8",
+        ) as tmp:
+            json.dump(data, tmp, indent=2, ensure_ascii=False)
+            tmp.flush()
+            os.fsync(tmp.fileno())
+            tmp_name = tmp.name
+        os.replace(tmp_name, path)
+    finally:
+        if tmp_name and os.path.exists(tmp_name):
+            os.unlink(tmp_name)
+
+
+def _normalize_record(raw: dict) -> dict:
+    record = dict(raw)
+    record.setdefault("id", f"local_{uuid.uuid4().hex[:12]}")
+    record.setdefault("summary", "无标题")
+    record.setdefault("status", "confirmed")
+    record.setdefault("is_all_day", False)
+    record.setdefault("location", "")
+    record.setdefault("description", "")
+    record.setdefault("remind_minutes", 0)
+    record.setdefault("google_event_id", "")
+    record.setdefault("sync_state", "local_only")
+    record.setdefault("last_sync_error", "")
+    record.setdefault("created_at", record.get("start", ""))
+    record.setdefault("updated_at", record.get("created_at", ""))
+    return record
+
+
+def _read_store(path: Path) -> dict:
+    try:
+        with open(path, encoding="utf-8") as f:
+            data = json.load(f)
+    except FileNotFoundError:
+        return _default_store()
+    if not isinstance(data, dict):
+        raise ValueError("local_events.json 格式错误：根节点必须是对象")
+    data.setdefault("version", 1)
+    events = data.setdefault("events", [])
+    if not isinstance(events, list):
+        raise ValueError("local_events.json 格式错误：events 必须是数组")
+    data["events"] = [_normalize_record(item) for item in events if isinstance(item, dict)]
+    return data
+
+
+@contextmanager
+def _locked_store(path: str | Path | None = None) -> Iterator[tuple[Path, dict]]:
+    store_path = resolve_store_path(path)
+    store_path.parent.mkdir(parents=True, exist_ok=True)
+    lock_path = store_path.with_suffix(store_path.suffix + ".lock")
+    with open(lock_path, "a+", encoding="utf-8") as lock_file:
+        if fcntl is not None:
+            fcntl.flock(lock_file.fileno(), fcntl.LOCK_EX)
+        yield store_path, _read_store(store_path)
+
+
+def _ensure_aware(dt: datetime) -> datetime:
+    if dt.tzinfo is None:
+        raise ValueError("datetime 必须携带时区信息")
+    return dt
+
+
+def record_to_event(record: dict) -> CalendarEvent:
+    return CalendarEvent(
+        id=record["id"],
+        summary=record.get("summary", "无标题"),
+        start=datetime.fromisoformat(record["start"]),
+        end=datetime.fromisoformat(record["end"]),
+        status=record.get("status", "confirmed"),
+        is_all_day=bool(record.get("is_all_day", False)),
+        location=record.get("location", ""),
+        description=record.get("description", ""),
+    )
+
+
+def load_store(path: str | Path | None = None) -> dict:
+    with _locked_store(path) as (_, data):
+        return data
+
+
+def list_records(
+    time_min: datetime | None = None,
+    time_max: datetime | None = None,
+    include_cancelled: bool = False,
+    path: str | Path | None = None,
+) -> list[dict]:
+    with _locked_store(path) as (_, data):
+        records = []
+        for raw in data.get("events", []):
+            record = _normalize_record(raw)
+            if not include_cancelled and record.get("status") == "cancelled":
+                continue
+            event = record_to_event(record)
+            if time_min is not None and _ensure_aware(event.end) <= _ensure_aware(time_min):
+                continue
+            if time_max is not None and _ensure_aware(event.start) >= _ensure_aware(time_max):
+                continue
+            records.append(record)
+        records.sort(key=lambda item: item.get("start", ""))
+        return records
+
+
+def list_events(
+    time_min: datetime | None = None,
+    time_max: datetime | None = None,
+    include_cancelled: bool = False,
+    path: str | Path | None = None,
+) -> list[CalendarEvent]:
+    return [
+        record_to_event(record)
+        for record in list_records(
+            time_min=time_min,
+            time_max=time_max,
+            include_cancelled=include_cancelled,
+            path=path,
+        )
+    ]
+
+
+def get_record(event_id: str, path: str | Path | None = None) -> dict | None:
+    with _locked_store(path) as (_, data):
+        for raw in data.get("events", []):
+            record = _normalize_record(raw)
+            if record["id"] == event_id:
+                return record
+    return None
+
+
+def get_event_status(event_id: str, path: str | Path | None = None) -> str | None:
+    record = get_record(event_id, path=path)
+    return record.get("status") if record else None
+
+
+def create_event(
+    summary: str,
+    start: datetime,
+    end: datetime,
+    location: str = "",
+    description: str = "",
+    remind_minutes: int = 0,
+    path: str | Path | None = None,
+) -> dict:
+    start = _ensure_aware(start)
+    end = _ensure_aware(end)
+    now = datetime.now(start.tzinfo)
+    record = _normalize_record({
+        "id": f"local_{uuid.uuid4().hex[:12]}",
+        "summary": summary,
+        "start": start.isoformat(),
+        "end": end.isoformat(),
+        "status": "confirmed",
+        "is_all_day": False,
+        "location": location,
+        "description": description,
+        "remind_minutes": int(remind_minutes),
+        "google_event_id": "",
+        "sync_state": "local_only",
+        "last_sync_error": "",
+        "created_at": now.isoformat(),
+        "updated_at": now.isoformat(),
+    })
+    with _locked_store(path) as (store_path, data):
+        events = data.setdefault("events", [])
+        events.append(record)
+        _atomic_write_json(store_path, data)
+    return record
+
+
+def delete_event(event_id: str, path: str | Path | None = None) -> bool:
+    with _locked_store(path) as (store_path, data):
+        changed = False
+        for record in data.get("events", []):
+            normalized = _normalize_record(record)
+            if normalized["id"] != event_id:
+                continue
+            record["status"] = "cancelled"
+            record["updated_at"] = datetime.now().isoformat()
+            if not record.get("sync_state"):
+                record["sync_state"] = "local_only"
+            changed = True
+            break
+        if changed:
+            _atomic_write_json(store_path, data)
+        return changed
+
+
+def update_sync_status(
+    event_id: str,
+    sync_state: str,
+    google_event_id: str = "",
+    last_sync_error: str = "",
+    path: str | Path | None = None,
+) -> bool:
+    with _locked_store(path) as (store_path, data):
+        changed = False
+        for record in data.get("events", []):
+            normalized = _normalize_record(record)
+            if normalized["id"] != event_id:
+                continue
+            record["sync_state"] = sync_state
+            record["google_event_id"] = google_event_id
+            record["last_sync_error"] = last_sync_error
+            record["updated_at"] = datetime.now().isoformat()
+            changed = True
+            break
+        if changed:
+            _atomic_write_json(store_path, data)
+        return changed
+
+
+def list_syncable_records(path: str | Path | None = None) -> list[dict]:
+    records = list_records(include_cancelled=False, path=path)
+    result = []
+    for record in records:
+        if record.get("status") != "confirmed":
+            continue
+        if record.get("sync_state") == "synced" and record.get("google_event_id"):
+            continue
+        result.append(record)
+    return result

package/skills/sophnet-schedule/src/services/reminder_planner.py

@@ -0,0 +1,116 @@
+"""
+提醒计划生成器。
+
+从事件列表生成提醒计划，处理全天事件、已过期提醒等边界情况。
+"""
+
+from __future__ import annotations
+
+import logging
+import sys
+from dataclasses import dataclass
+from datetime import datetime, timedelta, timezone
+from pathlib import Path
+
+sys.path.insert(0, str(Path(__file__).parent.parent))
+
+import yaml
+
+from compat import ZoneInfo, make_aware
+from gcal.models import CalendarEvent
+from .event_classifier import EventClassifier
+
+logger = logging.getLogger(__name__)
+
+_DEFAULT_RULES_PATH = Path(__file__).parent.parent / "config" / "reminder_rules.yaml"
+_DEFAULT_TZ = "Asia/Shanghai"
+
+_BUILTIN_LEAD = {"sport": 15, "meal": 15, "family": 15, "medical": 30, "appointment": 10}
+_BUILTIN_DEFAULT_LEAD = 10
+
+
+def _load_lead_minutes(path: Path) -> tuple[dict[str, int], int]:
+    try:
+        with open(path, encoding="utf-8") as f:
+            data = yaml.safe_load(f) or {}
+        lead    = {k: int(v) for k, v in data.get("lead_minutes", {}).items()}
+        default = int(data.get("default_lead_minutes", _BUILTIN_DEFAULT_LEAD))
+        return lead or _BUILTIN_LEAD, default
+    except Exception as e:
+        logger.warning(f"加载提醒规则失败，使用内置: {e}")
+        return _BUILTIN_LEAD, _BUILTIN_DEFAULT_LEAD
+
+
+@dataclass
+class ReminderPlan:
+    event:           CalendarEvent
+    event_type:      str       # sport / meal / family / medical / appointment
+    lead_minutes:    int       # 提前多少分钟
+    remind_at:       datetime  # 北京时间（aware）
+    remind_at_utc:   datetime  # UTC（aware）
+    should_schedule: bool      # False = 提醒时间已过，跳过创建
+
+    def reminder_message(self) -> str:
+        t_start   = self.event.start.strftime("%H:%M")
+        t_end     = self.event.end.strftime("%H:%M") if self.event.end else ""
+        time_range = f"{t_start}–{t_end}" if t_end and t_end != t_start else t_start
+
+        lines = [f"⏰ **{self.event.summary}** 将在 {self.lead_minutes} 分钟后开始"]
+        lines.append(f"🕐 {time_range}（共 {self.event.duration_minutes()} 分钟）")
+        if self.event.location:
+            lines.append(f"📍 {self.event.location}")
+        if self.event.description:
+            first_line = self.event.description.split("\n")[0].strip()
+            if first_line and len(first_line) <= 60:
+                lines.append(f"📝 {first_line}")
+        return "\n".join(lines)
+
+
+def plan_reminders(
+    events: list[CalendarEvent],
+    now: datetime | None = None,
+    rules_path: Path | None = None,
+    classifier: EventClassifier | None = None,
+    tz: str = _DEFAULT_TZ,
+) -> list[ReminderPlan]:
+    """
+    从事件列表生成提醒计划列表。
+
+    跳过：
+      - 全天事件（is_all_day=True）
+      - start 为空的事件
+    标记 should_schedule=False（不跳过，但不创建 cron 任务）：
+      - 提醒时间早于 now
+    """
+    zone = ZoneInfo(tz)
+    if now is None:
+        now = datetime.now(zone)
+    if now.tzinfo is None:
+        now = now.replace(tzinfo=zone)
+
+    lead_map, default_lead = _load_lead_minutes(rules_path or _DEFAULT_RULES_PATH)
+    clf = classifier or EventClassifier(rules_path)
+
+    plans: list[ReminderPlan] = []
+    for event in events:
+        if event.is_all_day:
+            logger.debug(f"跳过全天事件: {event.summary}")
+            continue
+        if event.start is None:
+            logger.debug(f"跳过无开始时间事件: {event.summary}")
+            continue
+
+        event_type = clf.classify(event.summary, event.description)
+        lead       = lead_map.get(event_type, default_lead)
+        remind_at  = event.start - timedelta(minutes=lead)
+
+        plans.append(ReminderPlan(
+            event           = event,
+            event_type      = event_type,
+            lead_minutes    = lead,
+            remind_at       = remind_at,
+            remind_at_utc   = remind_at.astimezone(timezone.utc),
+            should_schedule = remind_at >= now,
+        ))
+
+    return plans

package/skills/sophnet-schedule/src/services/runtime_utils.py

@@ -0,0 +1,31 @@
+"""
+运行时工具。
+
+统一处理：
+- Python 解释器选择
+- task_registry 占位符替换
+"""
+
+from __future__ import annotations
+
+from pathlib import Path
+
+from config.settings import OPENCLAW_BASE, PYTHON_BIN, SKILL_BASE
+
+
+def expand_command_vars(text: str) -> str:
+    expanded = (
+        text
+        .replace("{OPENCLAW_BASE}", str(OPENCLAW_BASE))
+        .replace("{SKILL_BASE}", str(SKILL_BASE))
+        .replace("{PYTHON_BIN}", PYTHON_BIN)
+    )
+    if expanded.startswith("python3 "):
+        return expanded.replace("python3 ", f"{PYTHON_BIN} ", 1)
+    if expanded.startswith("python "):
+        return expanded.replace("python ", f"{PYTHON_BIN} ", 1)
+    return expanded
+
+
+def build_python_command(script: str | Path, *args: str) -> list[str]:
+    return [PYTHON_BIN, str(script), *[str(arg) for arg in args]]

package/skills/sophnet-schedule/src/services/table_parser.py

@@ -0,0 +1,286 @@
+"""
+Markdown 表格解析器。
+
+从 markitdown 或 OCR 输出的 Markdown 内容中提取结构化日程事件。
+移植自 skills/schedule-reminder/scripts/parse_schedule.py 的列名识别逻辑，
+输出格式与 add_event.py / import_events.py 兼容。
+
+用法：
+    from services.table_parser import parse_events_from_markdown
+    events = parse_events_from_markdown(md_content)
+    # events: [{"summary": "...", "date": "YYYY-MM-DD", "start": "HH:MM", ...}, ...]
+"""
+
+from __future__ import annotations
+
+import re
+import sys
+from datetime import date, datetime
+from pathlib import Path
+from typing import Optional
+
+sys.path.insert(0, str(Path(__file__).parent.parent))
+
+from services.datetime_utils import current_year
+
+# ─────────────────────────── 列名别名表 ──────────────────────────
+# 各字段的候选列名（中英文、简写、Excel 常见变体）
+
+COLUMN_ALIASES: dict[str, set[str]] = {
+    "date": {
+        "日期", "date", "Date", "DATE", "日", "活动日期", "会议日期",
+        "事件日期", "日程日期", "计划日期", "时间",
+    },
+    "start": {
+        "开始时间", "开始", "start", "Start", "START", "开始时刻",
+        "起始时间", "from", "From", "时间开始", "起始", "开始时间段",
+    },
+    "end": {
+        "结束时间", "结束", "end", "End", "END", "结束时刻",
+        "to", "To", "时间结束", "终止",
+    },
+    "title": {
+        "事项", "标题", "title", "Title", "TITLE", "内容", "会议", "活动",
+        "事件", "subject", "Subject", "name", "Name", "任务", "描述",
+        "会议名称", "活动名称", "事项名称", "议题", "主题", "项目",
+        "meeting", "Meeting", "event", "Event", "topic", "Topic",
+    },
+    "location": {
+        "地点", "location", "Location", "LOCATION", "地址", "会议室",
+        "venue", "Venue", "place", "Place", "room", "Room", "场所", "场地",
+    },
+    "participants": {
+        "参与者", "人员", "participants", "Participants", "与会者", "成员",
+        "attendees", "Attendees", "负责人", "参会人", "参会人员",
+    },
+    "advance": {
+        "提前(分钟)", "提前提醒", "提前", "advance", "Advance",
+        "reminder", "Reminder", "提前时间", "提醒时间", "提前分钟",
+    },
+    "note": {
+        "备注", "note", "Note", "NOTE", "notes", "Notes",
+        "说明", "remark", "Remark", "comments", "附注", "补充",
+    },
+}
+
+_DEFAULT_DURATION_MINUTES = 60
+_DEFAULT_ADVANCE_MINUTES  = 15
+
+
+# ─────────────────────────── 列名检测 ────────────────────────────
+
+def detect_column_mapping(
+    header_cells: list[str],
+    user_map: dict[str, str] | None = None,
+) -> dict[str, int]:
+    """
+    根据表头行自动推断字段→列索引映射。
+
+    优先级：用户自定义 > 精确别名匹配 > 子串匹配。
+
+    Args:
+        header_cells: Markdown 表头各列文字列表
+        user_map:     自定义映射 {"自定义列名": "字段名", ...}
+
+    Returns:
+        {"title": 0, "date": 1, "start": 2, ...}
+    """
+    mapping: dict[str, int] = {}
+    used_indices: set[int]  = set()
+
+    # 用户自定义（最高优先级）
+    if user_map:
+        for i, cell in enumerate(header_cells):
+            cell_clean = cell.strip()
+            if cell_clean in user_map:
+                field = user_map[cell_clean]
+                if field not in mapping:
+                    mapping[field] = i
+                    used_indices.add(i)
+
+    # 精确匹配
+    for field, aliases in COLUMN_ALIASES.items():
+        if field in mapping:
+            continue
+        for i, cell in enumerate(header_cells):
+            if i in used_indices:
+                continue
+            if cell.strip() in aliases:
+                mapping[field] = i
+                used_indices.add(i)
+                break
+
+    # 子串匹配（兜底）
+    for field, aliases in COLUMN_ALIASES.items():
+        if field in mapping:
+            continue
+        for i, cell in enumerate(header_cells):
+            if i in used_indices:
+                continue
+            cell_lower = cell.strip().lower()
+            if any(a.lower() in cell_lower or cell_lower in a.lower()
+                   for a in aliases):
+                mapping[field] = i
+                used_indices.add(i)
+                break
+
+    return mapping
+
+
+# ─────────────────────────── 时间规范化 ──────────────────────────
+
+def normalize_date(raw: str) -> Optional[str]:
+    """
+    将各种日期格式规范化为 YYYY-MM-DD，失败返回 None。
+    支持：2026-04-01 / 2026/04/01 / 04-01 / 4/1（补全年份）
+    """
+    raw = raw.strip()
+    for fmt in ("%Y-%m-%d", "%Y/%m/%d"):
+        try:
+            return datetime.strptime(raw, fmt).strftime("%Y-%m-%d")
+        except ValueError:
+            pass
+    for fmt in ("%m-%d", "%m/%d"):
+        try:
+            d = datetime.strptime(raw, fmt)
+            return d.replace(year=current_year()).strftime("%Y-%m-%d")
+        except ValueError:
+            pass
+    return None
+
+
+def normalize_time(raw: str) -> Optional[str]:
+    """
+    将时间字符串规范化为 HH:MM，失败返回 None。
+    支持：14:30 / 14:30:00 / 9:05
+    """
+    raw = raw.strip().replace("：", ":")
+    m = re.match(r"(\d{1,2}):(\d{2})", raw)
+    if m:
+        return f"{int(m.group(1)):02d}:{int(m.group(2)):02d}"
+    return None
+
+
+def add_minutes_to_time(time_str: str, minutes: int) -> str:
+    """HH:MM 加 N 分钟，返回 HH:MM（不跨日边界处理）。"""
+    h, m = map(int, time_str.split(":"))
+    total = h * 60 + m + minutes
+    return f"{(total // 60) % 24:02d}:{total % 60:02d}"
+
+
+# ─────────────────────────── 表格解析 ────────────────────────────
+
+def _split_md_row(line: str) -> list[str]:
+    """将 Markdown 表格行拆分为单元格列表（去掉首尾 |）。"""
+    cells = line.strip().strip("|").split("|")
+    return [c.strip() for c in cells]
+
+
+def _is_separator_row(line: str) -> bool:
+    """判断是否为 Markdown 表格分隔行（如 |---|---|）。"""
+    stripped = line.strip()
+    # 去掉首尾 | 后，只含 -、:、|、空格
+    inner = stripped.strip("|")
+    return bool(inner) and bool(re.match(r"^[\s\-:|]+$", inner))
+
+
+def parse_events_from_markdown(
+    content: str,
+    user_map: dict[str, str] | None = None,
+    default_advance: int = _DEFAULT_ADVANCE_MINUTES,
+    default_duration: int = _DEFAULT_DURATION_MINUTES,
+) -> list[dict]:
+    """
+    从 Markdown 内容中提取所有日程事件。
+
+    每个事件输出结构：
+        {
+            "summary":  str,           # 必填
+            "date":     "YYYY-MM-DD",  # 必填
+            "start":    "HH:MM",       # 必填
+            "end":      "HH:MM",       # 可选
+            "location": str,           # 可选
+            "description": str,        # 备注
+            "remind":   int,           # 提醒分钟数（默认 15）
+        }
+
+    跳过：title/date/start 任一缺失或解析失败的行。
+    """
+    events: list[dict] = []
+    lines   = content.splitlines()
+    i       = 0
+
+    while i < len(lines):
+        line = lines[i]
+
+        # 找到一个表格的表头行
+        if not line.strip().startswith("|"):
+            i += 1
+            continue
+
+        header_cells = _split_md_row(line)
+
+        # 下一行应为分隔行
+        if i + 1 >= len(lines) or not _is_separator_row(lines[i + 1]):
+            i += 1
+            continue
+
+        col_map = detect_column_mapping(header_cells, user_map)
+
+        # title / date / start 是必需字段，至少要有 title
+        if "title" not in col_map:
+            i += 2
+            continue
+
+        # 读数据行
+        i += 2
+        while i < len(lines) and lines[i].strip().startswith("|"):
+            cells = _split_md_row(lines[i])
+            i += 1
+
+            def _cell(field: str) -> str:
+                idx = col_map.get(field)
+                if idx is None or idx >= len(cells):
+                    return ""
+                return cells[idx].strip()
+
+            title    = _cell("title")
+            date_raw = _cell("date")
+            start_raw= _cell("start")
+
+            if not title or title in ("-", ""):
+                continue
+
+            date_str  = normalize_date(date_raw)  if date_raw  else None
+            start_str = normalize_time(start_raw) if start_raw else None
+
+            if not date_str or not start_str:
+                continue
+
+            end_raw = _cell("end")
+            end_str = normalize_time(end_raw) if end_raw else None
+            if not end_str:
+                end_str = add_minutes_to_time(start_str, default_duration)
+
+            advance_raw = _cell("advance")
+            try:
+                remind = int(advance_raw) if advance_raw else default_advance
+            except ValueError:
+                remind = default_advance
+
+            note     = _cell("note")
+            location = _cell("location")
+            parts_raw = _cell("participants")
+            description = " | ".join(filter(None, [note, parts_raw]))
+
+            events.append({
+                "summary":     title,
+                "date":        date_str,
+                "start":       start_str,
+                "end":         end_str,
+                "location":    location,
+                "description": description,
+                "remind":      remind,
+            })
+
+    return events