nexo-brain 5.3.19 → 5.3.21

package/src/db/_sessions 2.py

@@ -0,0 +1,330 @@
+from __future__ import annotations
+"""NEXO DB — Sessions module."""
+import time, secrets, string, sqlite3
+from datetime import datetime
+from db._core import get_db, _gen_id, now_epoch, local_time_str, SESSION_STALE_SECONDS, MESSAGE_TTL_SECONDS, QUESTION_TTL_SECONDS
+
+# ── Session operations ──────────────────────────────────────────────
+
+def now_epoch() -> float:
+    return time.time()
+
+
+def local_time_str() -> str:
+    from datetime import datetime
+    return datetime.now().strftime("%H:%M")
+
+
+import re
+_SID_EXACT = re.compile(r'^nexo-\d+-\d+$')
+_SID_SEARCH = re.compile(r'nexo-\d+-\d+')
+
+def _validate_sid(sid: str) -> str:
+    """Validate and sanitize SID. Extracts clean SID if embedded in text."""
+    if not sid:
+        raise ValueError("SID cannot be empty")
+    sid = sid.strip()
+    # Clean SID — most common case
+    if _SID_EXACT.match(sid):
+        return sid
+    # Extract SID from text like "SID: nexo-1234-5678\nOther stuff..."
+    match = _SID_SEARCH.search(sid)
+    if match:
+        return match.group(0)
+    raise ValueError(f"Invalid SID format: {sid[:80]}")
+
+
+def register_session(
+    sid: str,
+    task: str,
+    claude_session_id: str = "",
+    *,
+    external_session_id: str = "",
+    session_client: str = "",
+) -> dict:
+    """Register or re-register a session."""
+    sid = _validate_sid(sid)
+    conn = get_db()
+    now = now_epoch()
+    linked_session_id = (external_session_id or claude_session_id or "").strip()
+    conn.execute(
+        "INSERT OR REPLACE INTO sessions (sid, task, started_epoch, last_update_epoch, local_time, claude_session_id, external_session_id, session_client) "
+        "VALUES (?, ?, ?, ?, ?, ?, ?, ?)",
+        (sid, task, now, now, local_time_str(), linked_session_id, linked_session_id, (session_client or "").strip())
+    )
+    conn.commit()
+    return {"sid": sid, "task": task, "external_session_id": linked_session_id, "session_client": (session_client or "").strip()}
+
+
+def update_session(sid: str, task: str | None) -> dict:
+    """Update session timestamp (and task if provided). Preserves started_epoch.
+
+    Args:
+        sid: Session ID.
+        task: New task description, or None to keep current task (keepalive touch).
+    """
+    sid = _validate_sid(sid)
+    conn = get_db()
+    now = now_epoch()
+    row = conn.execute("SELECT started_epoch, task FROM sessions WHERE sid = ?", (sid,)).fetchone()
+    if row:
+        effective_task = task if task is not None else row["task"]
+        conn.execute(
+            "UPDATE sessions SET task = ?, last_update_epoch = ?, local_time = ? WHERE sid = ?",
+            (effective_task, now, local_time_str(), sid)
+        )
+    else:
+        effective_task = task or "Unknown"
+        conn.execute(
+            "INSERT INTO sessions (sid, task, started_epoch, last_update_epoch, local_time) "
+            "VALUES (?, ?, ?, ?, ?)",
+            (sid, effective_task, now, now, local_time_str())
+        )
+    conn.commit()
+    return {"sid": sid, "task": effective_task}
+
+
+def complete_session(sid: str):
+    """Remove session and its tracked files."""
+    sid = _validate_sid(sid)
+    conn = get_db()
+    conn.execute("PRAGMA foreign_keys=ON")
+    conn.execute("DELETE FROM tracked_files WHERE sid = ?", (sid,))
+    conn.execute("DELETE FROM sessions WHERE sid = ?", (sid,))
+    conn.commit()
+
+
+def get_active_sessions() -> list[dict]:
+    """Get all sessions updated within STALE threshold."""
+    conn = get_db()
+    cutoff = now_epoch() - SESSION_STALE_SECONDS
+    rows = conn.execute(
+        "SELECT sid, task, started_epoch, last_update_epoch, local_time "
+        "FROM sessions WHERE last_update_epoch > ?",
+        (cutoff,)
+    ).fetchall()
+    return [dict(r) for r in rows]
+
+
+def clean_stale_sessions() -> int:
+    """Remove stale sessions. Returns count removed."""
+    conn = get_db()
+    cutoff = now_epoch() - SESSION_STALE_SECONDS
+    stale = conn.execute(
+        "SELECT sid FROM sessions WHERE last_update_epoch <= ?", (cutoff,)
+    ).fetchall()
+    for row in stale:
+        conn.execute("DELETE FROM tracked_files WHERE sid = ?", (row["sid"],))
+    result = conn.execute(
+        "DELETE FROM sessions WHERE last_update_epoch <= ?", (cutoff,)
+    )
+    count = result.rowcount
+    conn.commit()
+    return count
+
+
+def search_sessions(keyword: str) -> list[dict]:
+    """Find sessions whose task contains keyword (case-insensitive)."""
+    conn = get_db()
+    cutoff = now_epoch() - SESSION_STALE_SECONDS
+    rows = conn.execute(
+        "SELECT sid, task, last_update_epoch, local_time FROM sessions "
+        "WHERE last_update_epoch > ? AND LOWER(task) LIKE ?",
+        (cutoff, f"%{keyword.lower()}%")
+    ).fetchall()
+    return [dict(r) for r in rows]
+
+
+# ── File tracking ───────────────────────────────────────────────────
+
+def track_files(sid: str, paths: list[str]) -> dict:
+    """Track files for a session. Returns conflicts if any."""
+    conn = get_db()
+    now = now_epoch()
+    session = conn.execute("SELECT sid FROM sessions WHERE sid = ?", (sid,)).fetchone()
+    if not session:
+            return {"error": f"Session {sid} not found. Register first."}
+
+    for path in paths:
+        conn.execute(
+            "INSERT OR IGNORE INTO tracked_files (sid, path, tracked_at) VALUES (?, ?, ?)",
+            (sid, path, now)
+        )
+    conn.commit()
+    conflicts = _check_conflicts(conn, sid)
+    return {"tracked": paths, "conflicts": conflicts}
+
+
+def untrack_files(sid: str, paths: list[str] | None = None):
+    """Untrack files. If paths is None, untrack all."""
+    conn = get_db()
+    if paths:
+        for path in paths:
+            conn.execute(
+                "DELETE FROM tracked_files WHERE sid = ? AND path = ?",
+                (sid, path)
+            )
+    else:
+        conn.execute("DELETE FROM tracked_files WHERE sid = ?", (sid,))
+    conn.commit()
+
+
+def get_all_tracked_files() -> dict:
+    """Get all tracked files grouped by session."""
+    conn = get_db()
+    cutoff = now_epoch() - SESSION_STALE_SECONDS
+    rows = conn.execute(
+        "SELECT tf.sid, tf.path, s.task FROM tracked_files tf "
+        "JOIN sessions s ON tf.sid = s.sid "
+        "WHERE s.last_update_epoch > ?",
+        (cutoff,)
+    ).fetchall()
+    result = {}
+    for r in rows:
+        sid = r["sid"]
+        if sid not in result:
+            result[sid] = {"task": r["task"], "files": []}
+        result[sid]["files"].append(r["path"])
+    return result
+
+
+def _check_conflicts(conn: sqlite3.Connection, sid: str) -> list[dict]:
+    """Check if any of sid's files are tracked by other active sessions."""
+    cutoff = now_epoch() - SESSION_STALE_SECONDS
+    my_files = conn.execute(
+        "SELECT path FROM tracked_files WHERE sid = ?", (sid,)
+    ).fetchall()
+    my_paths = {r["path"] for r in my_files}
+    if not my_paths:
+        return []
+
+    conflicts = []
+    others = conn.execute(
+        "SELECT tf.sid, tf.path, s.task FROM tracked_files tf "
+        "JOIN sessions s ON tf.sid = s.sid "
+        "WHERE tf.sid != ? AND s.last_update_epoch > ?",
+        (sid, cutoff)
+    ).fetchall()
+    by_sid = {}
+    for r in others:
+        if r["path"] in my_paths:
+            osid = r["sid"]
+            if osid not in by_sid:
+                by_sid[osid] = {"sid": osid, "task": r["task"], "files": []}
+            by_sid[osid]["files"].append(r["path"])
+    return list(by_sid.values())
+
+
+# ── Messages ────────────────────────────────────────────────────────
+
+def send_message(from_sid: str, to_sid: str, text: str) -> str:
+    """Send a message. to_sid can be 'all' for broadcast."""
+    conn = get_db()
+    _clean_old_messages(conn)
+    msg_id = _gen_id("msg", 6)
+    conn.execute(
+        "INSERT INTO messages (id, from_sid, to_sid, text, created_epoch) "
+        "VALUES (?, ?, ?, ?, ?)",
+        (msg_id, from_sid, to_sid, text, now_epoch())
+    )
+    conn.commit()
+    return msg_id
+
+
+def get_inbox(sid: str) -> list[dict]:
+    """Get unread messages for a session."""
+    conn = get_db()
+    _clean_old_messages(conn)
+    rows = conn.execute(
+        "SELECT m.id, m.from_sid, m.to_sid, m.text, m.created_epoch "
+        "FROM messages m "
+        "WHERE (m.to_sid = 'all' OR m.to_sid = ?) "
+        "AND m.from_sid != ? "
+        "AND m.id NOT IN (SELECT message_id FROM message_reads WHERE sid = ?)",
+        (sid, sid, sid)
+    ).fetchall()
+    for r in rows:
+        conn.execute(
+            "INSERT OR IGNORE INTO message_reads (message_id, sid) VALUES (?, ?)",
+            (r["id"], sid)
+        )
+    conn.commit()
+    result = [dict(r) for r in rows]
+    return result
+
+
+def _clean_old_messages(conn: sqlite3.Connection):
+    """Remove expired messages and commit immediately."""
+    cutoff = now_epoch() - MESSAGE_TTL_SECONDS
+    conn.execute("DELETE FROM messages WHERE created_epoch < ?", (cutoff,))
+    conn.commit()
+
+
+# ── Questions ───────────────────────────────────────────────────────
+
+def ask_question(from_sid: str, to_sid: str, question: str) -> str:
+    """Create a pending question. Returns qid."""
+    conn = get_db()
+    _expire_old_questions(conn)
+    qid = _gen_id("q", 8)
+    conn.execute(
+        "INSERT INTO questions (qid, from_sid, to_sid, question, status, created_epoch) "
+        "VALUES (?, ?, ?, ?, 'pending', ?)",
+        (qid, from_sid, to_sid, question, now_epoch())
+    )
+    conn.commit()
+    return qid
+
+
+def answer_question(qid: str, answer: str) -> dict:
+    """Answer a pending question."""
+    conn = get_db()
+    row = conn.execute(
+        "SELECT * FROM questions WHERE qid = ?", (qid,)
+    ).fetchone()
+    if not row:
+            return {"error": f"Question {qid} not found"}
+    if row["status"] != "pending":
+            return {"error": f"Question {qid} is {row['status']}, not pending"}
+    conn.execute(
+        "UPDATE questions SET answer = ?, status = 'answered', answered_epoch = ? "
+        "WHERE qid = ?",
+        (answer, now_epoch(), qid)
+    )
+    conn.commit()
+    return {"qid": qid, "status": "answered"}
+
+
+def get_pending_questions(sid: str) -> list[dict]:
+    """Get pending questions addressed to this session."""
+    conn = get_db()
+    _expire_old_questions(conn)
+    rows = conn.execute(
+        "SELECT qid, from_sid, question, created_epoch FROM questions "
+        "WHERE to_sid = ? AND status = 'pending'",
+        (sid,)
+    ).fetchall()
+    conn.commit()
+    return [dict(r) for r in rows]
+
+
+def check_answer(qid: str) -> dict | None:
+    """Check if a question has been answered. Returns answer or None."""
+    conn = get_db()
+    row = conn.execute(
+        "SELECT qid, answer, status FROM questions WHERE qid = ?", (qid,)
+    ).fetchone()
+    if not row:
+        return None
+    return dict(row)
+
+
+def _expire_old_questions(conn: sqlite3.Connection):
+    """Mark old pending questions as expired."""
+    cutoff = now_epoch() - QUESTION_TTL_SECONDS
+    conn.execute(
+        "UPDATE questions SET status = 'expired' "
+        "WHERE status = 'pending' AND created_epoch < ?",
+        (cutoff,)
+    )
+

package/src/db/_tasks 2.py

@@ -0,0 +1,91 @@
+"""NEXO DB — Tasks module."""
+from db._core import get_db, now_epoch
+
+# ── Task History & Frequencies ─────────────────────────────────────
+
+def log_task(task_num: str, task_name: str, notes: str = '', reasoning: str = '') -> dict:
+    """Log a task execution with optional reasoning."""
+    conn = get_db()
+    now = now_epoch()
+    cursor = conn.execute(
+        "INSERT INTO task_history (task_num, task_name, executed_at, notes, reasoning) "
+        "VALUES (?, ?, ?, ?, ?)",
+        (task_num, task_name, now, notes, reasoning)
+    )
+    conn.commit()
+    row = conn.execute(
+        "SELECT * FROM task_history WHERE id = ?", (cursor.lastrowid,)
+    ).fetchone()
+    return dict(row)
+
+
+def list_task_history(task_num: str = None, days: int = 30) -> list[dict]:
+    """List task execution history, optionally filtered by task_num."""
+    conn = get_db()
+    cutoff = now_epoch() - (days * 86400)
+    if task_num:
+        rows = conn.execute(
+            "SELECT * FROM task_history WHERE task_num = ? AND executed_at >= ? "
+            "ORDER BY executed_at DESC",
+            (task_num, cutoff)
+        ).fetchall()
+    else:
+        rows = conn.execute(
+            "SELECT * FROM task_history WHERE executed_at >= ? "
+            "ORDER BY executed_at DESC",
+            (cutoff,)
+        ).fetchall()
+    return [dict(r) for r in rows]
+
+
+def set_task_frequency(task_num: str, task_name: str,
+                       frequency_days: int, description: str = '') -> dict:
+    """Set or update the expected frequency for a task."""
+    conn = get_db()
+    conn.execute(
+        "INSERT OR REPLACE INTO task_frequencies (task_num, task_name, frequency_days, description) "
+        "VALUES (?, ?, ?, ?)",
+        (task_num, task_name, frequency_days, description)
+    )
+    conn.commit()
+    row = conn.execute(
+        "SELECT * FROM task_frequencies WHERE task_num = ?", (task_num,)
+    ).fetchone()
+    return dict(row)
+
+
+def get_overdue_tasks() -> list[dict]:
+    """Get tasks where last execution exceeds the configured frequency."""
+    conn = get_db()
+    freqs = conn.execute("SELECT * FROM task_frequencies").fetchall()
+    now = now_epoch()
+    overdue = []
+    for f in freqs:
+        last = conn.execute(
+            "SELECT MAX(executed_at) as last_exec FROM task_history WHERE task_num = ?",
+            (f["task_num"],)
+        ).fetchone()
+        last_exec = last["last_exec"] if last and last["last_exec"] else None
+        threshold = f["frequency_days"] * 86400
+        if last_exec is None or (now - last_exec) > threshold:
+            days_ago = round((now - last_exec) / 86400, 1) if last_exec else None
+            overdue.append({
+                "task_num": f["task_num"],
+                "task_name": f["task_name"],
+                "frequency_days": f["frequency_days"],
+                "last_executed": last_exec,
+                "days_since_last": days_ago,
+                "description": f["description"]
+            })
+    return overdue
+
+
+def get_task_frequencies() -> list[dict]:
+    """Get all configured task frequencies."""
+    conn = get_db()
+    rows = conn.execute(
+        "SELECT * FROM task_frequencies ORDER BY task_num ASC"
+    ).fetchall()
+    return [dict(r) for r in rows]
+
+

package/src/db/_watchers 2.py

@@ -0,0 +1,173 @@
+from __future__ import annotations
+"""NEXO DB — state watchers registry."""
+
+import json
+import secrets
+import time
+
+from db._core import get_db
+
+WATCHER_TYPES = {"repo_drift", "cron_drift", "api_health", "environment_drift", "expiry"}
+WATCHER_STATUSES = {"active", "paused", "archived"}
+WATCHER_HEALTH = {"unknown", "healthy", "degraded", "critical"}
+
+
+def _watcher_id() -> str:
+    return f"SW-{int(time.time())}-{secrets.randbelow(100000)}"
+
+
+def _as_json(value, default):
+    if value is None:
+        value = default
+    if isinstance(value, str):
+        return value
+    return json.dumps(value, ensure_ascii=False)
+
+
+def _parse_json(value, default):
+    if value in (None, ""):
+        return default
+    if isinstance(value, (dict, list)):
+        return value
+    try:
+        return json.loads(value)
+    except Exception:
+        return default
+
+
+def _row_to_watcher(row) -> dict:
+    watcher = dict(row)
+    watcher["config"] = _parse_json(watcher.get("config"), {})
+    watcher["last_result"] = _parse_json(watcher.get("last_result"), {})
+    return watcher
+
+
+def create_state_watcher(
+    watcher_type: str,
+    title: str,
+    *,
+    target: str = "",
+    severity: str = "warn",
+    status: str = "active",
+    config=None,
+) -> dict:
+    clean_type = str(watcher_type or "").strip().lower()
+    if clean_type not in WATCHER_TYPES:
+        raise ValueError(f"Unsupported watcher_type: {watcher_type}")
+    clean_status = str(status or "active").strip().lower()
+    if clean_status not in WATCHER_STATUSES:
+        clean_status = "active"
+    watcher_id = _watcher_id()
+    conn = get_db()
+    conn.execute(
+        """INSERT INTO state_watchers (
+               watcher_id, watcher_type, title, target, severity, status, config,
+               last_health, last_result, last_checked_at
+           ) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?)""",
+        (
+            watcher_id,
+            clean_type,
+            str(title or "").strip(),
+            str(target or "").strip(),
+            str(severity or "warn").strip().lower() or "warn",
+            clean_status,
+            _as_json(config, {}),
+            "unknown",
+            "{}",
+            "",
+        ),
+    )
+    conn.commit()
+    return get_state_watcher(watcher_id) or {"watcher_id": watcher_id}
+
+
+def get_state_watcher(watcher_id: str) -> dict | None:
+    conn = get_db()
+    row = conn.execute(
+        "SELECT * FROM state_watchers WHERE watcher_id = ?",
+        (str(watcher_id or "").strip(),),
+    ).fetchone()
+    return _row_to_watcher(row) if row else None
+
+
+def list_state_watchers(*, status: str = "", watcher_type: str = "", limit: int = 100) -> list[dict]:
+    clauses: list[str] = []
+    params: list[object] = []
+    if status:
+        clauses.append("status = ?")
+        params.append(str(status).strip().lower())
+    if watcher_type:
+        clauses.append("watcher_type = ?")
+        params.append(str(watcher_type).strip().lower())
+    where = f"WHERE {' AND '.join(clauses)}" if clauses else ""
+    params.append(max(1, int(limit or 100)))
+    conn = get_db()
+    rows = conn.execute(
+        f"""SELECT *
+            FROM state_watchers
+            {where}
+            ORDER BY updated_at DESC, watcher_id DESC
+            LIMIT ?""",
+        tuple(params),
+    ).fetchall()
+    return [_row_to_watcher(row) for row in rows]
+
+
+def update_state_watcher(
+    watcher_id: str,
+    *,
+    title: str | None = None,
+    target: str | None = None,
+    severity: str | None = None,
+    status: str | None = None,
+    config=None,
+) -> dict | None:
+    current = get_state_watcher(watcher_id)
+    if not current:
+        return None
+    updates = {
+        "title": current["title"] if title is None else str(title).strip(),
+        "target": current["target"] if target is None else str(target).strip(),
+        "severity": current["severity"] if severity is None else str(severity).strip().lower(),
+        "status": current["status"] if status is None else str(status).strip().lower(),
+        "config": _as_json(current["config"] if config is None else config, {}),
+    }
+    if updates["status"] not in WATCHER_STATUSES:
+        updates["status"] = current["status"]
+    conn = get_db()
+    conn.execute(
+        """UPDATE state_watchers
+           SET title = ?, target = ?, severity = ?, status = ?, config = ?,
+               updated_at = datetime('now')
+           WHERE watcher_id = ?""",
+        (
+            updates["title"],
+            updates["target"],
+            updates["severity"],
+            updates["status"],
+            updates["config"],
+            str(watcher_id).strip(),
+        ),
+    )
+    conn.commit()
+    return get_state_watcher(watcher_id)
+
+
+def update_state_watcher_result(watcher_id: str, *, health: str, result=None, checked_at: str = "") -> dict | None:
+    clean_health = str(health or "unknown").strip().lower()
+    if clean_health not in WATCHER_HEALTH:
+        clean_health = "unknown"
+    conn = get_db()
+    conn.execute(
+        """UPDATE state_watchers
+           SET last_health = ?, last_result = ?, last_checked_at = ?, updated_at = datetime('now')
+           WHERE watcher_id = ?""",
+        (
+            clean_health,
+            _as_json(result, {}),
+            checked_at.strip(),
+            str(watcher_id or "").strip(),
+        ),
+    )
+    conn.commit()
+    return get_state_watcher(watcher_id)

package/src/doctor/formatters 2.py

@@ -0,0 +1,52 @@
+"""Doctor output formatters — text and JSON."""
+from __future__ import annotations
+
+import json
+from dataclasses import asdict
+
+from doctor.models import DoctorReport
+
+
+def format_report(report: DoctorReport, fmt: str = "text") -> str:
+    """Format a DoctorReport as text or JSON."""
+    if fmt == "json":
+        return json.dumps(asdict(report), indent=2, ensure_ascii=False)
+    return _format_text(report)
+
+
+def _format_text(report: DoctorReport) -> str:
+    """Human-friendly text output."""
+    lines = []
+
+    # Header
+    icon = {"healthy": "✓", "degraded": "⚠", "critical": "✗"}.get(report.overall_status, "?")
+    lines.append(f"NEXO Doctor — {icon} {report.overall_status.upper()}")
+    lines.append(f"  {report.counts.get('healthy', 0)} healthy, "
+                 f"{report.counts.get('degraded', 0)} degraded, "
+                 f"{report.counts.get('critical', 0)} critical "
+                 f"({report.duration_ms}ms)")
+    lines.append("")
+
+    # Group by tier
+    current_tier = None
+    for check in report.checks:
+        if check.tier != current_tier:
+            current_tier = check.tier
+            lines.append(f"── {current_tier.upper()} ──")
+
+        icon = {"healthy": "✓", "degraded": "⚠", "critical": "✗"}.get(check.status, "?")
+        fixed = " [FIXED]" if check.fixed else ""
+        lines.append(f"  {icon} {check.summary}{fixed}")
+
+        if check.status != "healthy":
+            for ev in check.evidence:
+                lines.append(f"    → {ev}")
+            if check.repair_plan:
+                lines.append("    Fix:")
+                for step in check.repair_plan:
+                    lines.append(f"      • {step}")
+            if check.escalation_prompt:
+                lines.append(f"    Escalation: {check.escalation_prompt}")
+
+    lines.append("")
+    return "\n".join(lines)