nexo-brain 5.3.19 → 5.3.21

package/src/scripts/nexo-watchdog-smoke 2.py

@@ -0,0 +1,119 @@
+#!/usr/bin/env python3
+"""
+NEXO Watchdog Smoke
+
+Runs the same health checks as the shell watchdog, but never restores files,
+restarts services, disables evolution or notifies the user.
+"""
+
+from __future__ import annotations
+
+import hashlib
+import json
+import os
+import sqlite3
+import subprocess
+from datetime import datetime
+from pathlib import Path
+
+HOME = Path.home()
+NEXO_HOME = Path(os.environ.get("NEXO_HOME", str(HOME / ".nexo")))
+NEXO_CODE = Path(os.environ.get("NEXO_CODE", str(NEXO_HOME)))
+BRAIN_DIR = NEXO_HOME / "brain"
+LOG_DIR = NEXO_HOME / "logs"
+SUMMARY_FILE = LOG_DIR / "watchdog-smoke-summary.json"
+HASH_REGISTRY = NEXO_HOME / "scripts" / ".watchdog-hashes"
+RESTORE_LOG = LOG_DIR / "snapshot-restores.log"
+
+
+def _read_restore_count_for_current_hour() -> int:
+    if not RESTORE_LOG.exists():
+        return 0
+    needle = datetime.now().strftime("%Y-%m-%d %H")
+    return sum(1 for line in RESTORE_LOG.read_text(errors="ignore").splitlines()
+               if needle in line and "/.codex/memories/nexo-" not in line)
+
+
+def _sha256(path: Path) -> str:
+    return hashlib.sha256(path.read_bytes()).hexdigest()
+
+
+def main() -> int:
+    LOG_DIR.mkdir(parents=True, exist_ok=True)
+    findings = []
+
+    db_path = NEXO_HOME / "data" / "nexo.db"
+    integrity = "missing"
+    if db_path.exists():
+        try:
+            conn = sqlite3.connect(str(db_path), timeout=10)
+            integrity = conn.execute("PRAGMA integrity_check").fetchone()[0]
+            conn.close()
+        except Exception as exc:
+            integrity = f"error:{exc}"
+    if integrity != "ok":
+        findings.append({"severity": "ERROR", "area": "sqlite", "msg": f"integrity={integrity}"})
+
+    # Check if the NEXO MCP server process is alive (replaces legacy cortex process check)
+    nexo_server_running = subprocess.run(
+        ["pgrep", "-f", "nexo-brain"],
+        capture_output=True,
+        text=True,
+    ).returncode == 0
+    if not nexo_server_running:
+        findings.append({"severity": "INFO", "area": "server", "msg": "nexo-brain not running (normal if no active session)"})
+
+    backups = sorted((NEXO_HOME / "backups").glob("nexo-*.db"), key=lambda p: p.stat().st_mtime, reverse=True)
+    if backups:
+        age_seconds = int(datetime.now().timestamp() - backups[0].stat().st_mtime)
+        if age_seconds > 7200:
+            findings.append({"severity": "WARN", "area": "backup", "msg": f"latest backup age={age_seconds}s"})
+    else:
+        findings.append({"severity": "WARN", "area": "backup", "msg": "no backups found"})
+
+    if HASH_REGISTRY.exists():
+        for line in HASH_REGISTRY.read_text().splitlines():
+            if not line.strip():
+                continue
+            filepath, expected_hash = line.split("|", 1)
+            path = Path(filepath)
+            if path.exists() and _sha256(path) != expected_hash:
+                findings.append({"severity": "ERROR", "area": "immutable", "msg": f"hash mismatch: {filepath}"})
+
+    restore_count = _read_restore_count_for_current_hour()
+    if restore_count > 2:
+        findings.append({"severity": "ERROR", "area": "restore_loop", "msg": f"{restore_count} restores this hour"})
+    elif restore_count > 0:
+        findings.append({"severity": "INFO", "area": "restore_activity", "msg": f"{restore_count} restores this hour"})
+
+    # Check brain/ (canonical) first, fall back to cortex/ (legacy)
+    objective = BRAIN_DIR / "evolution-objective.json"
+    if not objective.exists():
+        objective = NEXO_HOME / "cortex" / "evolution-objective.json"
+    evolution_enabled = None
+    if objective.exists():
+        obj = json.loads(objective.read_text())
+        evolution_enabled = obj.get("evolution_enabled", True)
+        if not evolution_enabled:
+            findings.append({
+                "severity": "WARN",
+                "area": "evolution",
+                "msg": f"disabled: {obj.get('disabled_reason', 'unknown')}",
+            })
+
+    summary = {
+        "timestamp": datetime.now().isoformat(),
+        "ok": not any(f["severity"] == "ERROR" for f in findings),
+        "integrity": integrity,
+        "server_running": nexo_server_running,
+        "evolution_enabled": evolution_enabled,
+        "restore_count_current_hour": restore_count,
+        "findings": findings,
+    }
+    SUMMARY_FILE.write_text(json.dumps(summary, indent=2, ensure_ascii=False))
+    print(json.dumps(summary, ensure_ascii=False))
+    return 1 if any(f["severity"] == "ERROR" for f in findings) else 0
+
+
+if __name__ == "__main__":
+    raise SystemExit(main())

package/src/scripts/rehydrate_learnings_from_archive 2.py

@@ -0,0 +1,245 @@
+#!/usr/bin/env python3
+from __future__ import annotations
+
+"""Rehydrate archived markdown learnings back into the NEXO learnings table.
+
+The original Evolution #5 incident found an empty learnings table while the
+historical archive still existed as markdown grouped by domain. This helper
+parses the archive format used in those files:
+
+- markdown tables with `Error | Solucion`
+- dated sections with bullet/numbered operational learnings
+
+Dry-run is the default. Pass `--apply` to insert missing learnings.
+"""
+
+import argparse
+import re
+import sys
+from dataclasses import dataclass
+from pathlib import Path
+
+REPO_SRC = Path(__file__).resolve().parents[1]
+if str(REPO_SRC) not in sys.path:
+    sys.path.insert(0, str(REPO_SRC))
+
+from db import create_learning, get_db, init_db  # noqa: E402
+from runtime_home import export_resolved_nexo_home  # noqa: E402
+
+NEXO_HOME = export_resolved_nexo_home()
+TABLE_HEADER_TITLES = {"error", "problema", "issue"}
+DEFAULT_ARCHIVE_DIRS = (
+    NEXO_HOME / "claude" / "operations" / "archive" / "learnings",
+    Path.home() / "claude" / "operations" / "archive" / "learnings",
+    Path.home() / ".claude" / "operations" / "archive" / "learnings",
+)
+
+
+@dataclass(frozen=True)
+class LearningCandidate:
+    category: str
+    title: str
+    content: str
+    reasoning: str
+    prevention: str
+    status: str = "active"
+
+
+def _strip_markdown(text: str) -> str:
+    text = text.replace("**", "").replace("__", "")
+    text = text.replace("~~", "")
+    text = re.sub(r"`([^`]*)`", r"\1", text)
+    text = re.sub(r"\[([^\]]+)\]\([^)]+\)", r"\1", text)
+    text = re.sub(r"\s+", " ", text).strip(" |")
+    return text.strip()
+
+
+def _derive_title(text: str) -> str:
+    first_sentence = re.split(r"(?<=[.!?])\s+", text, maxsplit=1)[0].strip()
+    if not first_sentence:
+        first_sentence = text.strip()
+    return first_sentence[:180].rstrip(" .")
+
+
+def _derive_prevention(text: str) -> str:
+    match = re.search(r"(Regla:\s*.*|SIEMPRE\s+.*|NUNCA\s+.*)", text, flags=re.IGNORECASE)
+    if match:
+        return match.group(1).strip()
+    return text[:500].strip()
+
+
+def _candidate_reasoning(path: Path, section: str) -> str:
+    section_note = f" [{section}]" if section and section != path.stem else ""
+    return f"Rehydrated from markdown archive {path.name}{section_note}"
+
+
+def _parse_table_row(path: Path, section: str, line: str) -> LearningCandidate | None:
+    parts = [_strip_markdown(cell) for cell in line.strip().strip("|").split("|")]
+    if len(parts) < 2:
+        return None
+    title, prevention = parts[0], parts[1]
+    if title.lower() in TABLE_HEADER_TITLES or set(title) <= {"-"}:
+        return None
+    if not title or not prevention:
+        return None
+    status = "superseded" if "obsoleto" in prevention.lower() or "obsoleto" in title.lower() else "active"
+    content = f"{title}. {prevention}"
+    return LearningCandidate(
+        category=path.stem,
+        title=title,
+        content=content,
+        reasoning=_candidate_reasoning(path, section),
+        prevention=prevention,
+        status=status,
+    )
+
+
+def _consume_bullet_block(lines: list[str], start: int) -> tuple[str, int]:
+    pieces = [re.sub(r"^([-*]|\d+\.)\s+", "", lines[start].strip())]
+    idx = start + 1
+    while idx < len(lines):
+        stripped = lines[idx].strip()
+        if not stripped:
+            break
+        if stripped.startswith("## ") or stripped.startswith("|"):
+            break
+        if re.match(r"^([-*]|\d+\.)\s+", stripped):
+            break
+        pieces.append(stripped)
+        idx += 1
+    return _strip_markdown(" ".join(pieces)), idx
+
+
+def _parse_bullet(path: Path, section: str, text: str) -> LearningCandidate | None:
+    if len(text) < 12:
+        return None
+    title = _derive_title(text)
+    prevention = _derive_prevention(text)
+    status = "superseded" if "obsoleto" in text.lower() else "active"
+    return LearningCandidate(
+        category=path.stem,
+        title=title,
+        content=text,
+        reasoning=_candidate_reasoning(path, section),
+        prevention=prevention,
+        status=status,
+    )
+
+
+def parse_archive_file(path: Path) -> list[LearningCandidate]:
+    lines = path.read_text(encoding="utf-8", errors="ignore").splitlines()
+    section = path.stem
+    results: list[LearningCandidate] = []
+    idx = 0
+    while idx < len(lines):
+        stripped = lines[idx].strip()
+        if stripped.startswith("## "):
+            section = _strip_markdown(stripped[3:])
+            idx += 1
+            continue
+        if stripped.startswith("|") and not re.match(r"^\|\s*-", stripped):
+            row = _parse_table_row(path, section, stripped)
+            if row is not None:
+                results.append(row)
+            idx += 1
+            continue
+        if re.match(r"^([-*]|\d+\.)\s+", stripped):
+            block, next_idx = _consume_bullet_block(lines, idx)
+            row = _parse_bullet(path, section, block)
+            if row is not None:
+                results.append(row)
+            idx = next_idx
+            continue
+        idx += 1
+    return results
+
+
+def parse_archive_dir(archive_dir: Path) -> list[LearningCandidate]:
+    candidates: list[LearningCandidate] = []
+    for path in sorted(archive_dir.glob("*.md")):
+        candidates.extend(parse_archive_file(path))
+
+    deduped: list[LearningCandidate] = []
+    seen: set[tuple[str, str]] = set()
+    for item in candidates:
+        key = (item.category.lower(), item.title.lower())
+        if key in seen:
+            continue
+        seen.add(key)
+        deduped.append(item)
+    return deduped
+
+
+def resolve_archive_dir(explicit: str = "") -> Path:
+    if explicit:
+        path = Path(explicit).expanduser()
+        if not path.is_dir():
+            raise FileNotFoundError(f"archive dir not found: {path}")
+        return path
+    for candidate in DEFAULT_ARCHIVE_DIRS:
+        if candidate.is_dir():
+            return candidate
+    raise FileNotFoundError(
+        "No learnings archive found. Tried: "
+        + ", ".join(str(path) for path in DEFAULT_ARCHIVE_DIRS)
+    )
+
+
+def apply_candidates(candidates: list[LearningCandidate], *, apply: bool) -> dict:
+    init_db()
+    conn = get_db()
+    existing = {
+        (row[0].lower(), row[1].lower())
+        for row in conn.execute("SELECT category, title FROM learnings").fetchall()
+    }
+    inserted = 0
+    skipped = 0
+    for item in candidates:
+        key = (item.category.lower(), item.title.lower())
+        if key in existing:
+            skipped += 1
+            continue
+        if apply:
+            create_learning(
+                item.category,
+                item.title,
+                item.content,
+                reasoning=item.reasoning,
+                prevention=item.prevention,
+                status=item.status,
+            )
+        existing.add(key)
+        inserted += 1
+    return {
+        "parsed": len(candidates),
+        "inserted": inserted,
+        "skipped_existing": skipped,
+        "mode": "apply" if apply else "dry-run",
+    }
+
+
+def build_arg_parser() -> argparse.ArgumentParser:
+    parser = argparse.ArgumentParser(description=__doc__)
+    parser.add_argument("--archive-dir", default="", help="Override archive directory")
+    parser.add_argument("--apply", action="store_true", help="Insert parsed learnings into the DB")
+    return parser
+
+
+def main(argv: list[str] | None = None) -> int:
+    args = build_arg_parser().parse_args(argv)
+    try:
+        archive_dir = resolve_archive_dir(args.archive_dir)
+    except FileNotFoundError as exc:
+        print(f"ERROR: {exc}", file=sys.stderr)
+        return 1
+    candidates = parse_archive_dir(archive_dir)
+    summary = apply_candidates(candidates, apply=args.apply)
+    print(
+        f"{summary['mode']}: archive={archive_dir} parsed={summary['parsed']} "
+        f"inserted={summary['inserted']} skipped_existing={summary['skipped_existing']}"
+    )
+    return 0
+
+
+if __name__ == "__main__":
+    raise SystemExit(main())