nexo-brain 5.3.26 → 5.3.28

package/src/db/_sessions 2.py

@@ -1,330 +0,0 @@
-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

@@ -1,91 +0,0 @@
-"""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

@@ -1,173 +0,0 @@
-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

@@ -1,52 +0,0 @@
-"""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)