nexo-brain 0.1.0

package/src/plugins/guard.py

@@ -0,0 +1,346 @@
+"""Guard plugin — Error prevention closed-loop system.
+
+Surfaces relevant learnings at the moment of action, tracks repetitions,
+and provides stats on error prevention effectiveness.
+"""
+import json
+import os
+from datetime import datetime, timedelta
+from pathlib import Path
+from db import get_db, find_similar_learnings, extract_keywords
+
+NEXO_HOME = Path(os.environ.get("NEXO_HOME", str(Path.home() / ".nexo")))
+SCHEMA_CACHE_PATH = str(NEXO_HOME / "schema_cache.json")
+
+
+def _load_schema_cache() -> dict:
+    """Load cached DB schemas from schema_cache.json."""
+    try:
+        if os.path.exists(SCHEMA_CACHE_PATH):
+            with open(SCHEMA_CACHE_PATH) as f:
+                return json.load(f)
+    except Exception:
+        pass
+    return {}
+
+
+def _get_nexo_table_schema(table_name: str) -> str:
+    """Get schema for a nexo.db table via PRAGMA."""
+    conn = get_db()
+    try:
+        rows = conn.execute(f"PRAGMA table_info({table_name})").fetchall()
+        if rows:
+            cols = [f"{r['name']}({r['type']})" for r in rows]
+            return ", ".join(cols)
+    except Exception:
+        pass
+    return ""
+
+
+def _extract_table_names(content: str) -> set:
+    """Extract SQL table names from source code."""
+    import re
+    tables = set()
+    patterns = [
+        r'(?:FROM|JOIN|INTO|UPDATE)\s+`?(\w+)`?',
+        r'CREATE\s+TABLE\s+(?:IF\s+NOT\s+EXISTS\s+)?`?(\w+)`?',
+        r'DESCRIBE\s+`?(\w+)`?',
+        r'table_info\([\'"]?(\w+)[\'"]?\)',
+    ]
+    for pat in patterns:
+        for m in re.finditer(pat, content, re.IGNORECASE):
+            tables.add(m.group(1))
+    sql_keywords = {'SELECT', 'WHERE', 'AND', 'OR', 'NOT', 'NULL', 'SET', 'VALUES', 'INTO', 'AS'}
+    return {t for t in tables if t.upper() not in sql_keywords}
+
+
+def handle_guard_check(files: str = "", area: str = "", include_schemas: str = "true") -> str:
+    """Check learnings relevant to files/area before editing. Call BEFORE any code change.
+
+    Args:
+        files: Comma-separated file paths about to be edited
+        area: System area (infrastructure, api, database, backend, etc.)
+        include_schemas: Include DB table schemas if files touch database code (true/false)
+    """
+    conn = get_db()
+    include_schemas_bool = include_schemas.lower() in ("true", "1", "yes")
+    file_list = [f.strip() for f in files.split(",") if f.strip()] if files else []
+
+    result = {
+        "learnings": [],
+        "universal_rules": [],
+        "schemas": {},
+        "area_repetition_rate": 0.0,
+        "blocking_rules": [],
+    }
+
+    seen_ids = set()
+
+    # 1. By file path — learnings mentioning the file name or parent directory
+    for filepath in file_list:
+        from pathlib import Path
+        p = Path(filepath)
+        filename = p.name
+        parent_dir = p.parent.name
+
+        rows = conn.execute(
+            "SELECT id, category, title, content FROM learnings WHERE INSTR(content, ?) > 0 OR INSTR(content, ?) > 0",
+            (filename, parent_dir)
+        ).fetchall()
+        for r in rows:
+            if r["id"] not in seen_ids:
+                seen_ids.add(r["id"])
+                result["learnings"].append({"id": r["id"], "category": r["category"], "rule": r["title"]})
+
+    # 2. By area/category
+    if area:
+        rows = conn.execute(
+            "SELECT id, category, title, content FROM learnings WHERE category = ?",
+            (area,)
+        ).fetchall()
+        for r in rows:
+            if r["id"] not in seen_ids:
+                seen_ids.add(r["id"])
+                result["learnings"].append({"id": r["id"], "category": r["category"], "rule": r["title"]})
+
+    # 3. Universal rules (SIEMPRE, NUNCA, ANTES, always, never)
+    rows = conn.execute(
+        "SELECT id, category, title, content FROM learnings WHERE "
+        "content LIKE '%SIEMPRE%' OR content LIKE '%NUNCA%' OR content LIKE '%ANTES%' "
+        "OR content LIKE '%always%' OR content LIKE '%never%'"
+    ).fetchall()
+    for r in rows:
+        if r["id"] not in seen_ids:
+            result["universal_rules"].append({"id": r["id"], "rule": r["title"]})
+
+    # 4. DB schemas if files contain SQL keywords
+    if include_schemas_bool and file_list:
+        all_tables = set()
+        for filepath in file_list:
+            try:
+                with open(filepath, 'r', errors='ignore') as f:
+                    content = f.read()
+                sql_keywords = ['SELECT', 'INSERT', 'UPDATE', 'DELETE', 'CREATE TABLE']
+                if any(kw in content.upper() for kw in sql_keywords):
+                    all_tables.update(_extract_table_names(content))
+            except (FileNotFoundError, PermissionError):
+                continue
+
+        cache = _load_schema_cache()
+        for table in all_tables:
+            schema = _get_nexo_table_schema(table)
+            if schema:
+                result["schemas"][table] = schema
+            elif "cloud_sql" in cache and table in cache["cloud_sql"]:
+                result["schemas"][table] = cache["cloud_sql"][table]
+
+    # 5. Check for blocking rules (5+ repetitions)
+    for learning in result["learnings"]:
+        lid = learning["id"]
+        rep_count = conn.execute(
+            "SELECT COUNT(*) as cnt FROM error_repetitions WHERE original_learning_id = ?",
+            (lid,)
+        ).fetchone()["cnt"]
+        if rep_count >= 5:
+            result["blocking_rules"].append(
+                {"id": lid, "rule": learning["rule"], "repetitions": rep_count}
+            )
+
+    # 6. Area repetition rate
+    if area:
+        total_area = conn.execute(
+            "SELECT COUNT(*) as cnt FROM learnings WHERE category = ?", (area,)
+        ).fetchone()["cnt"]
+        reps_area = conn.execute(
+            "SELECT COUNT(*) as cnt FROM error_repetitions WHERE area = ?", (area,)
+        ).fetchone()["cnt"]
+        if total_area > 0:
+            result["area_repetition_rate"] = round(reps_area / total_area, 2)
+
+    # 7. Cognitive metacognition — semantic search for related warnings
+    cognitive_warnings = []
+    trust_note = ""
+    try:
+        import cognitive
+        trust = cognitive.get_trust_score()
+
+        if trust < 40:
+            cog_top_k = 6
+            cog_min_score = 0.55
+            trust_note = f" [RIGOR: PARANOID — trust={trust:.0f}]"
+        elif trust > 80:
+            cog_top_k = 2
+            cog_min_score = 0.75
+            trust_note = f" [RIGOR: FLUENT — trust={trust:.0f}]"
+        else:
+            cog_top_k = 3
+            cog_min_score = 0.65
+
+        query_parts = []
+        if file_list:
+            query_parts.append(f"editing files: {', '.join(file_list[:5])}")
+        if area:
+            query_parts.append(f"area: {area}")
+        if query_parts:
+            query_text = ". ".join(query_parts)
+            cog_results = cognitive.search(
+                query_text, top_k=cog_top_k, min_score=cog_min_score,
+                stores="ltm", source_type_filter="learning", rehearse=False
+            )
+            for r in cog_results:
+                cognitive_warnings.append(
+                    f"[{r['score']:.2f}]: {r['source_title']} — {r['content'][:200]}"
+                )
+    except Exception:
+        pass  # Cognitive is optional
+
+    # Log the guard check
+    conn.execute(
+        "INSERT INTO guard_checks (session_id, files, area, learnings_returned, blocking_rules_returned) "
+        "VALUES (?, ?, ?, ?, ?)",
+        ("", files, area, len(result["learnings"]) + len(result["universal_rules"]),
+         len(result["blocking_rules"]))
+    )
+    conn.commit()
+
+    # Format output
+    lines = []
+    if result["blocking_rules"]:
+        lines.append("BLOCKING RULES (resolve BEFORE writing):")
+        for r in result["blocking_rules"]:
+            lines.append(f"  #{r['id']} ({r['repetitions']}x repeated): {r['rule']}")
+        lines.append("")
+
+    if result["learnings"]:
+        lines.append(f"RELEVANT LEARNINGS ({len(result['learnings'])}):")
+        for l in result["learnings"][:15]:
+            lines.append(f"  #{l['id']} [{l['category']}] {l['rule']}")
+        lines.append("")
+
+    if result["universal_rules"]:
+        lines.append(f"UNIVERSAL RULES ({len(result['universal_rules'])}):")
+        for r in result["universal_rules"][:10]:
+            lines.append(f"  #{r['id']} {r['rule']}")
+        lines.append("")
+
+    if result["schemas"]:
+        lines.append("DB SCHEMAS:")
+        for table, schema in result["schemas"].items():
+            lines.append(f"  {table}: {schema}")
+        lines.append("")
+
+    if result["area_repetition_rate"] > 0:
+        lines.append(f"Area repetition rate: {result['area_repetition_rate']:.0%}")
+
+    if cognitive_warnings:
+        lines.append(f"\nCOGNITIVE SEMANTIC MATCHES{trust_note}:")
+        for w in cognitive_warnings:
+            lines.append(f"  COGNITIVE MATCH {w}")
+
+    if not lines:
+        return "No relevant learnings found for these files/area."
+
+    return "\n".join(lines)
+
+
+def handle_guard_stats(period_days: int = 7) -> str:
+    """Get guard system statistics for the specified period.
+
+    Args:
+        period_days: Number of days to look back (default 7)
+    """
+    conn = get_db()
+    cutoff = (datetime.now() - timedelta(days=period_days)).strftime("%Y-%m-%d %H:%M:%S")
+
+    total_learnings = conn.execute("SELECT COUNT(*) as cnt FROM learnings").fetchone()["cnt"]
+
+    total_reps = conn.execute(
+        "SELECT COUNT(*) as cnt FROM error_repetitions WHERE created_at > ?", (cutoff,)
+    ).fetchone()["cnt"]
+
+    new_learnings_period = conn.execute(
+        "SELECT COUNT(*) as cnt FROM learnings WHERE created_at > ?",
+        ((datetime.now() - timedelta(days=period_days)).timestamp(),)
+    ).fetchone()["cnt"]
+    rep_rate = round(total_reps / new_learnings_period, 2) if new_learnings_period > 0 else 0.0
+
+    prev_cutoff = (datetime.now() - timedelta(days=period_days * 2)).strftime("%Y-%m-%d %H:%M:%S")
+    prev_reps = conn.execute(
+        "SELECT COUNT(*) as cnt FROM error_repetitions WHERE created_at > ? AND created_at <= ?",
+        (prev_cutoff, cutoff)
+    ).fetchone()["cnt"]
+    trend = "stable"
+    if total_reps < prev_reps:
+        trend = "improving"
+    elif total_reps > prev_reps:
+        trend = "worsening"
+
+    area_rows = conn.execute(
+        "SELECT area, COUNT(*) as cnt FROM error_repetitions WHERE created_at > ? GROUP BY area ORDER BY cnt DESC LIMIT 5",
+        (cutoff,)
+    ).fetchall()
+
+    ignored_rows = conn.execute(
+        "SELECT original_learning_id, COUNT(*) as cnt FROM error_repetitions "
+        "GROUP BY original_learning_id ORDER BY cnt DESC LIMIT 5"
+    ).fetchall()
+    most_ignored = []
+    for r in ignored_rows:
+        lr = conn.execute("SELECT title FROM learnings WHERE id = ?", (r["original_learning_id"],)).fetchone()
+        if lr:
+            most_ignored.append({"id": r["original_learning_id"], "title": lr["title"], "times_repeated": r["cnt"]})
+
+    checks_count = conn.execute(
+        "SELECT COUNT(*) as cnt FROM guard_checks WHERE created_at > ?", (cutoff,)
+    ).fetchone()["cnt"]
+
+    lines = [
+        f"GUARD STATS (last {period_days} days):",
+        f"  Repetition rate: {rep_rate:.0%} ({trend})",
+        f"  Total learnings: {total_learnings}",
+        f"  Repetitions in period: {total_reps}",
+        f"  Guard checks performed: {checks_count}",
+    ]
+
+    if area_rows:
+        lines.append("  Top areas:")
+        for r in area_rows:
+            lines.append(f"    {r['area']}: {r['cnt']} repetitions")
+
+    if most_ignored:
+        lines.append("  Most repeated learnings:")
+        for m in most_ignored:
+            lines.append(f"    #{m['id']} ({m['times_repeated']}x): {m['title'][:60]}")
+
+    return "\n".join(lines)
+
+
+def handle_guard_log_repetition(new_learning_id: int, original_learning_id: int, similarity: float = 0.75) -> str:
+    """Log that a new learning is similar to an existing one (repetition detected).
+
+    Args:
+        new_learning_id: ID of the new learning
+        original_learning_id: ID of the original learning it matches
+        similarity: Similarity score (0-1)
+    """
+    conn = get_db()
+
+    row = conn.execute("SELECT category FROM learnings WHERE id = ?", (new_learning_id,)).fetchone()
+    if not row:
+        return f"ERROR: Learning #{new_learning_id} not found."
+    area = row["category"]
+
+    conn.execute(
+        "INSERT INTO error_repetitions (new_learning_id, original_learning_id, similarity, area) VALUES (?,?,?,?)",
+        (new_learning_id, original_learning_id, similarity, area)
+    )
+    conn.commit()
+
+    return f"Repetition logged: #{new_learning_id} similar to #{original_learning_id} ({similarity:.0%})"
+
+
+TOOLS = [
+    (handle_guard_check, "nexo_guard_check", "Check learnings relevant to files/area BEFORE editing code. Call this before any code change."),
+    (handle_guard_stats, "nexo_guard_stats", "Get guard system statistics: repetition rate, trends, top problem areas"),
+    (handle_guard_log_repetition, "nexo_guard_log_repetition", "Log a learning repetition (new learning matches existing one)"),
+]

package/src/plugins/preferences.py

@@ -0,0 +1,47 @@
+"""Preferences plugin — learned behavior patterns and workflow rules."""
+from db import set_preference, get_preference, list_preferences, delete_preference
+
+def handle_preference_get(key: str) -> str:
+    """Get a specific preference by key."""
+    p = get_preference(key)
+    if not p: return f"Preferencia '{key}' no encontrada."
+    return f"{p['key']} = {p['value']} (cat: {p['category']})"
+
+def handle_preference_set(key: str, value: str, category: str = "general") -> str:
+    """Set a preference (creates or updates)."""
+    set_preference(key, value, category)
+    try:
+        import cognitive
+        cognitive.ingest_to_ltm(f"{key}: {value}", "preference", key, key, "")
+    except Exception:
+        pass
+    return f"Preferencia '{key}' = '{value}' ({category})"
+
+def handle_preference_list(category: str = "") -> str:
+    """List all preferences, optionally filtered by category."""
+    prefs = list_preferences(category)
+    if not prefs: return "Sin preferencias."
+    grouped = {}
+    for p in prefs:
+        c = p["category"]
+        if c not in grouped: grouped[c] = []
+        grouped[c].append(p)
+    lines = ["PREFERENCIAS:"]
+    for c, items in grouped.items():
+        lines.append(f"\n  [{c.upper()}]")
+        for p in items:
+            lines.append(f"    {p['key']} = {p['value']}")
+    return "\n".join(lines)
+
+def handle_preference_delete(key: str) -> str:
+    """Delete a preference."""
+    if not delete_preference(key):
+        return f"ERROR: Preferencia '{key}' no encontrada."
+    return f"Preferencia '{key}' eliminada."
+
+TOOLS = [
+    (handle_preference_get, "nexo_preference_get", "Get a specific preference value"),
+    (handle_preference_set, "nexo_preference_set", "Set a preference (creates or updates)"),
+    (handle_preference_list, "nexo_preference_list", "List all preferences grouped by category"),
+    (handle_preference_delete, "nexo_preference_delete", "Delete a preference"),
+]

package/src/scripts/nexo-auto-update.py

@@ -0,0 +1,213 @@
+#!/usr/bin/env python3
+"""
+NEXO Auto-Update — checks for new versions and applies updates.
+
+Runs at boot via the catch-up system or manually.
+Compares local version with the latest GitHub release.
+If a new version is available, downloads and applies the update.
+"""
+
+import json
+import os
+import shutil
+import subprocess
+import sys
+from datetime import datetime
+from pathlib import Path
+
+NEXO_HOME = Path(os.environ.get("NEXO_HOME", str(Path.home() / ".nexo")))
+VERSION_FILE = NEXO_HOME / "version.json"
+LOG_FILE = NEXO_HOME / "logs" / "auto-update.log"
+REPO = "wazionapps/nexo"
+
+
+def log(msg: str):
+    ts = datetime.now().strftime("%Y-%m-%d %H:%M:%S")
+    line = f"[{ts}] {msg}"
+    print(line, flush=True)
+    LOG_FILE.parent.mkdir(parents=True, exist_ok=True)
+    with open(LOG_FILE, "a") as f:
+        f.write(line + "\n")
+
+
+def get_local_version() -> str:
+    """Read locally installed version."""
+    if VERSION_FILE.exists():
+        try:
+            return json.loads(VERSION_FILE.read_text()).get("version", "0.0.0")
+        except Exception:
+            pass
+    return "0.0.0"
+
+
+def get_remote_version() -> dict | None:
+    """Check latest release on GitHub."""
+    try:
+        result = subprocess.run(
+            ["gh", "api", f"repos/{REPO}/releases/latest"],
+            capture_output=True, text=True, timeout=15
+        )
+        if result.returncode == 0:
+            data = json.loads(result.stdout)
+            return {
+                "version": data.get("tag_name", "").lstrip("v"),
+                "tarball_url": data.get("tarball_url", ""),
+                "published_at": data.get("published_at", ""),
+                "body": data.get("body", "")[:500],
+            }
+    except Exception:
+        pass
+    return None
+
+
+def version_compare(local: str, remote: str) -> int:
+    """Compare semver strings. Returns -1 (local older), 0 (same), 1 (local newer)."""
+    def parse(v):
+        parts = v.split(".")
+        return tuple(int(p) for p in parts if p.isdigit())
+
+    l, r = parse(local), parse(remote)
+    if l < r:
+        return -1
+    elif l > r:
+        return 1
+    return 0
+
+
+def apply_update(tarball_url: str, new_version: str) -> bool:
+    """Download and apply update from GitHub release tarball."""
+    import tempfile
+
+    log(f"Downloading update v{new_version}...")
+    tmp_dir = Path(tempfile.mkdtemp(prefix="nexo-update-"))
+
+    try:
+        # Download tarball
+        tarball = tmp_dir / "release.tar.gz"
+        result = subprocess.run(
+            ["curl", "-sL", "-o", str(tarball), tarball_url],
+            capture_output=True, timeout=60
+        )
+        if result.returncode != 0:
+            log(f"Download failed: {result.stderr}")
+            return False
+
+        # Extract
+        subprocess.run(
+            ["tar", "xzf", str(tarball), "-C", str(tmp_dir)],
+            capture_output=True, timeout=30
+        )
+
+        # Find extracted directory (GitHub tarballs have a top-level dir)
+        extracted = [d for d in tmp_dir.iterdir() if d.is_dir()]
+        if not extracted:
+            log("No directory found in tarball")
+            return False
+
+        src_dir = extracted[0] / "src"
+        if not src_dir.exists():
+            log("No src/ directory in release")
+            return False
+
+        # Backup current files
+        backup_dir = NEXO_HOME / "backups" / f"pre-update-{new_version}"
+        backup_dir.mkdir(parents=True, exist_ok=True)
+
+        files_updated = 0
+        # Update core Python files
+        for py_file in src_dir.glob("*.py"):
+            dest = NEXO_HOME / py_file.name
+            if dest.exists():
+                shutil.copy2(dest, backup_dir / py_file.name)
+            shutil.copy2(py_file, dest)
+            files_updated += 1
+
+        # Update plugins
+        plugins_src = src_dir / "plugins"
+        if plugins_src.exists():
+            plugins_dest = NEXO_HOME / "plugins"
+            plugins_dest.mkdir(exist_ok=True)
+            for py_file in plugins_src.glob("*.py"):
+                dest = plugins_dest / py_file.name
+                if dest.exists():
+                    shutil.copy2(dest, backup_dir / f"plugin_{py_file.name}")
+                shutil.copy2(py_file, dest)
+                files_updated += 1
+
+        # Update scripts
+        scripts_src = src_dir / "scripts"
+        if scripts_src.exists():
+            scripts_dest = NEXO_HOME / "scripts"
+            scripts_dest.mkdir(exist_ok=True)
+            for py_file in scripts_src.glob("*.py"):
+                dest = scripts_dest / py_file.name
+                if dest.exists():
+                    shutil.copy2(dest, backup_dir / f"script_{py_file.name}")
+                shutil.copy2(py_file, dest)
+                files_updated += 1
+
+        # Update hooks
+        hooks_src = src_dir / "hooks"
+        if hooks_src.exists():
+            hooks_dest = NEXO_HOME / "hooks"
+            hooks_dest.mkdir(exist_ok=True)
+            for sh_file in hooks_src.glob("*.sh"):
+                dest = hooks_dest / sh_file.name
+                shutil.copy2(sh_file, dest)
+                os.chmod(dest, 0o755)
+                files_updated += 1
+
+        # Save new version
+        VERSION_FILE.write_text(json.dumps({
+            "version": new_version,
+            "updated_at": datetime.now().isoformat(),
+            "files_updated": files_updated,
+            "backup": str(backup_dir),
+        }, indent=2))
+
+        log(f"Update applied: {files_updated} files updated. Backup at {backup_dir}")
+        return True
+
+    except Exception as e:
+        log(f"Update failed: {e}")
+        return False
+    finally:
+        shutil.rmtree(tmp_dir, ignore_errors=True)
+
+
+def main():
+    log("=== NEXO Auto-Update check ===")
+
+    local_ver = get_local_version()
+    log(f"Local version: {local_ver}")
+
+    remote = get_remote_version()
+    if not remote:
+        log("Could not check remote version (no network or no releases)")
+        return
+
+    remote_ver = remote["version"]
+    log(f"Remote version: {remote_ver}")
+
+    cmp = version_compare(local_ver, remote_ver)
+    if cmp >= 0:
+        log("Already up to date.")
+        return
+
+    log(f"Update available: {local_ver} → {remote_ver}")
+    log(f"Release notes: {remote['body'][:200]}")
+
+    if remote["tarball_url"]:
+        success = apply_update(remote["tarball_url"], remote_ver)
+        if success:
+            log(f"Successfully updated to v{remote_ver}")
+        else:
+            log("Update failed — will retry next boot")
+    else:
+        log("No tarball URL in release — manual update needed")
+
+    log("=== Done ===")
+
+
+if __name__ == "__main__":
+    main()