napcat-cli 2.0.0__py3-none-any.whl

napcat_cli/lib/events_sqlite.py

@@ -0,0 +1,242 @@
+"""SQLite event store for NapCat CLI.
+
+Replaces the filesystem JSON approach with a SQLite database for:
+- Faster querying (time-based filters, type filters)
+- No file naming conflicts
+- Atomic writes
+- Proper indexing for time-based lookups
+
+The database is stored at DATA_DIR/napcat_events.db.
+"""
+from __future__ import annotations
+
+import json
+import sqlite3
+import time
+from pathlib import Path
+from typing import Any
+
+
+def get_db_path(data_dir: Path | None = None) -> Path:
+    """Get the path to the events database."""
+    if data_dir is None:
+        from .config import DATA_DIR
+        data_dir = DATA_DIR
+    return data_dir / "napcat_events.db"
+
+
+def get_connection(data_dir: Path | None = None) -> sqlite3.Connection:
+    """Get a connection to the events database, creating it if needed."""
+    db_path = get_db_path(data_dir)
+    conn = sqlite3.connect(str(db_path), check_same_thread=False)
+    conn.row_factory = sqlite3.Row
+    conn.execute("PRAGMA journal_mode=WAL")
+    conn.execute("PRAGMA synchronous=NORMAL")
+    init_db(conn)
+    return conn
+
+
+def init_db(conn: sqlite3.Connection) -> None:
+    """Initialize the database schema if tables don't exist."""
+    conn.executescript(
+        "CREATE TABLE IF NOT EXISTS events ("
+        "id INTEGER PRIMARY KEY AUTOINCREMENT, "
+        "timestamp INTEGER NOT NULL, "
+        "post_type TEXT NOT NULL, "
+        "event_type TEXT NOT NULL, "
+        "raw_json TEXT NOT NULL, "
+        "self_id INTEGER, "
+        "group_id INTEGER, "
+        "user_id INTEGER, "
+        "message_id INTEGER, "
+        "message_type TEXT, "
+        "sender_id INTEGER, "
+        "created_at INTEGER NOT NULL"
+        "); "
+
+        "CREATE INDEX IF NOT EXISTS idx_events_timestamp ON events(timestamp DESC); "
+        "CREATE INDEX IF NOT EXISTS idx_events_post_type ON events(post_type); "
+        "CREATE INDEX IF NOT EXISTS idx_events_event_type ON events(event_type); "
+        "CREATE INDEX IF NOT EXISTS idx_events_group_id ON events(group_id); "
+        "CREATE INDEX IF NOT EXISTS idx_events_user_id ON events(user_id); "
+        "CREATE INDEX IF NOT EXISTS idx_events_sender_id ON events(sender_id); "
+
+        "CREATE TABLE IF NOT EXISTS alerts ("
+        "id INTEGER PRIMARY KEY AUTOINCREMENT, "
+        "name TEXT NOT NULL, "
+        "timestamp INTEGER NOT NULL, "
+        "raw_json TEXT NOT NULL, "
+        "created_at INTEGER NOT NULL"
+        "); "
+
+        "CREATE INDEX IF NOT EXISTS idx_alerts_name ON alerts(name); "
+        "CREATE INDEX IF NOT EXISTS idx_alerts_timestamp ON alerts(timestamp DESC);"
+    )
+    conn.commit()
+
+    # Schema migration: add columns missing from older databases
+    for col, ctype in (("message_id", "INTEGER DEFAULT NULL"),):
+        try:
+            conn.execute(f"ALTER TABLE events ADD COLUMN {col} {ctype}")
+        except sqlite3.OperationalError:
+            pass
+    conn.commit()
+
+    # Ensure index exists (may fail if table was old but column was added manually)
+    try:
+        conn.execute(
+            "CREATE INDEX IF NOT EXISTS idx_events_message_id ON events(message_id)"
+        )
+        conn.commit()
+    except sqlite3.OperationalError:
+        pass
+
+
+# ---------------------------------------------------------------------------
+# Writer operations
+# ---------------------------------------------------------------------------
+
+def write_event(conn: sqlite3.Connection, event: dict[str, Any]) -> int:
+    """Write an event to the database. Returns the new event ID."""
+    now = int(time.time())
+    ts = event.get("time", now)
+    post_type = event.get("post_type", "unknown")
+    event_type = event.get("notice_type", event.get("request_type", event.get("meta_event_type", post_type)))
+    raw_json = json.dumps(event, ensure_ascii=False)
+
+    self_id = event.get("self_id")
+    group_id = event.get("group_id")
+    user_id = event.get("user_id")
+    message_id = event.get("message_id")
+    message_type = event.get("message_type")
+    sender_id = event.get("sender", {}).get("user_id") if "sender" in event else None
+
+    cursor = conn.execute(
+        "INSERT INTO events "
+        "(timestamp, post_type, event_type, raw_json, self_id, group_id, user_id, "
+        "message_id, message_type, sender_id, created_at) "
+        "VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)",
+        (ts, post_type, event_type, raw_json, self_id, group_id, user_id,
+         message_id, message_type, sender_id, now),
+    )
+    conn.commit()
+    return cursor.lastrowid
+
+
+def write_alert(conn: sqlite3.Connection, name: str, data: dict[str, Any]) -> int:
+    """Write an alert to the database. Returns the new alert ID."""
+    now = int(time.time())
+    raw_json = json.dumps(data, ensure_ascii=False)
+    alert_ts = data.get("timestamp", now)
+
+    cursor = conn.execute(
+        "INSERT INTO alerts (name, timestamp, raw_json, created_at) VALUES (?, ?, ?, ?)",
+        (name, alert_ts, raw_json, now),
+    )
+    conn.commit()
+    return cursor.lastrowid
+
+
+# ---------------------------------------------------------------------------
+# Reader operations
+# ---------------------------------------------------------------------------
+
+def read_events(
+    conn: sqlite3.Connection,
+    limit: int = 50,
+    event_type: str | None = None,
+    since: int | None = None,
+    post_type: str | None = None,
+    group_id: int | None = None,
+    user_id: int | None = None,
+    keyword: str | None = None,
+) -> list[dict[str, Any]]:
+    """Read events from the database, newest first."""
+    query = "SELECT raw_json FROM events WHERE 1=1"
+    params: list[Any] = []
+
+    if event_type:
+        query += " AND event_type = ?"
+        params.append(event_type)
+    if since:
+        query += " AND timestamp >= ?"
+        params.append(since)
+    if post_type:
+        query += " AND post_type = ?"
+        params.append(post_type)
+    if group_id:
+        query += " AND group_id = ?"
+        params.append(group_id)
+    if user_id:
+        query += " AND (user_id = ? OR sender_id = ?)"
+        params.append(user_id)
+        params.append(user_id)
+    if keyword:
+        query += " AND raw_json LIKE ?"
+        params.append(f"%{keyword}%")
+
+    query += " ORDER BY timestamp DESC LIMIT ?"
+    params.append(limit)
+
+    rows = conn.execute(query, params).fetchall()
+    events = []
+    for row in rows:
+        try:
+            events.append(json.loads(row["raw_json"]))
+        except json.JSONDecodeError:
+            continue
+    return events
+
+
+def read_alerts(
+    conn: sqlite3.Connection,
+    name: str | None = None,
+    limit: int = 50,
+) -> list[dict[str, Any]]:
+    """Read alerts from the database."""
+    query = "SELECT name, raw_json FROM alerts WHERE 1=1"
+    params: list[Any] = []
+
+    if name:
+        query += " AND name = ?"
+        params.append(name)
+
+    query += " ORDER BY timestamp DESC LIMIT ?"
+    params.append(limit)
+
+    rows = conn.execute(query, params).fetchall()
+    return [{"name": r["name"], **json.loads(r["raw_json"])} for r in rows]
+
+
+def clear_alerts(conn: sqlite3.Connection, name: str | None = None) -> int:
+    """Clear alerts. If name is given, clear only that alert type.
+    Returns count of deleted rows."""
+    cur = conn
+    if name:
+        cur = conn.execute("DELETE FROM alerts WHERE name = ?", (name,))
+    else:
+        cur = conn.execute("DELETE FROM alerts")
+    deleted = cur.rowcount
+    conn.commit()
+    return deleted
+
+
+def get_event_count(conn: sqlite3.Connection) -> int:
+    """Get total event count."""
+    return conn.execute("SELECT COUNT(*) FROM events").fetchone()[0]
+
+
+def get_alert_count(conn: sqlite3.Connection, name: str | None = None) -> int:
+    """Get alert count, optionally filtered by name."""
+    if name:
+        return conn.execute("SELECT COUNT(*) FROM alerts WHERE name = ?", (name,)).fetchone()[0]
+    return conn.execute("SELECT COUNT(*) FROM alerts").fetchone()[0]
+
+
+def prune_events(conn: sqlite3.Connection, older_than_days: int = 7) -> int:
+    """Remove events older than specified days."""
+    cutoff = int(time.time()) - (older_than_days * 86400)
+    cur = conn.execute("DELETE FROM events WHERE timestamp < ?", (cutoff,))
+    deleted = cur.rowcount
+    conn.commit()
+    return deleted

napcat_cli/lib/message.py

@@ -0,0 +1,156 @@
+"""NapCat/OneBot 11 message segment parsing and formatting.
+
+Converts between NapCat segment format (array of {type, data}) and display format.
+Extracts file paths from image/video/record segments for agent to read.
+"""
+
+from __future__ import annotations
+
+import json
+from pathlib import Path
+from typing import Any
+
+
+def format_message(msg: list[dict[str, Any]]) -> str:
+    """Convert NapCat message segments to display string.
+
+    Handles all segment types: text, at, image, record (voice), reply, video, face.
+
+    Args:
+        msg: List of segment dicts like [{"type": "text", "data": {"text": "hi"}}]
+
+    Returns:
+        Formatted message string with inline indicators (e.g., [media], @user)
+    """
+    if not isinstance(msg, list):
+        return str(msg)
+
+    parts = []
+    for seg in msg:
+        seg_type = seg.get("type", "")
+        data = seg.get("data", {})
+
+        if seg_type == "text":
+            parts.append(data.get("text", ""))
+        elif seg_type == "at":
+            # @mention: qq is QQ number as string
+            qq = data.get("qq", "")
+            if qq:
+                parts.append(f"@{qq}")
+        elif seg_type == "image":
+            # Image: file path, summary, url
+            summary = data.get("summary", "").strip()
+            if summary:
+                parts.append(f"[图片: {summary}]")
+            else:
+                parts.append("[图片]")
+        elif seg_type == "record":
+            # Voice/audio: file, path, url
+            parts.append("[语音]")
+        elif seg_type == "video":
+            # Video: file, url
+            parts.append("[视频]")
+        elif seg_type == "reply":
+            # Reply reference
+            reply_id = data.get("id", "")
+            if reply_id:
+                parts.append(f"[回复: {reply_id}]")
+        elif seg_type == "face":
+            # QQ face emoji
+            face_id = data.get("id", "")
+            parts.append(f"[表情: {face_id}]")
+        else:
+            # Unknown segment type
+            parts.append(f"[{seg_type}]")
+
+    return "".join(parts)
+
+
+def extract_files(msg: list[dict[str, Any]], base_dir: str | None = None) -> list[Path]:
+    """Extract file paths from image/video/record segments for agent reading.
+
+    Args:
+        msg: NapCat message segments
+        base_dir: Optional base directory for relative paths
+
+    Returns:
+        List of Path objects pointing to files referenced in the message.
+    """
+    if not isinstance(msg, list):
+        return []
+
+    files = []
+    for seg in msg:
+        seg_type = seg.get("type", "")
+        data = seg.get("data", {})
+
+        # Look for file, path, or url fields
+        for key in ("file", "path"):
+            path_str = data.get(key, "")
+            if path_str:
+                p = Path(path_str)
+                if base_dir:
+                    p = Path(base_dir) / p
+                if p.exists():
+                    files.append(p)
+                    break  # Prefer file over path
+
+    return files
+
+
+def segments_from_raw(raw_message: str, msg: list[dict[str, Any]]) -> list[dict[str, Any]]:
+    """Parse message from raw_message string (legacy fallback).
+
+    NapCat provides both raw_message (plain string) and message (segments).
+    If raw_message differs from segments, this attempts to convert.
+
+    Args:
+        raw_message: Plain text message
+        msg: Parsed message segments
+
+    Returns:
+        Normalized segment list
+    """
+    if not msg or raw_message != format_message(msg):
+        # raw_message has different content, treat as plain text
+        return [{"type": "text", "data": {"text": raw_message}}]
+
+    return msg
+
+
+def extract_file_paths(msg: list[dict[str, Any]]) -> list[str]:
+    """Extract file path strings from image/video/record segments.
+
+    Returns all file paths referenced in the message, regardless of whether
+    the files exist. Useful for establishing message→file mapping.
+
+    Args:
+        msg: NapCat message segments
+
+    Returns:
+        List of file path strings
+    """
+    if not isinstance(msg, list):
+        return []
+
+    files = []
+    for seg in msg:
+        seg_type = seg.get("type", "")
+        data = seg.get("data", {})
+
+        if seg_type in ("image", "record", "video"):
+            for key in ("file", "path"):
+                path_str = data.get(key, "")
+                if path_str:
+                    files.append(path_str)
+                    break  # Prefer file over path
+
+    return files
+
+
+__all__ = [
+    "format_message",
+    "extract_files",
+    "extract_file_paths",
+    "segments_from_raw",
+]