nexo-brain 1.7.0 → 2.0.0

package/src/plugins/update.py

@@ -0,0 +1,238 @@
+"""Update plugin — pull latest code, backup DBs, run migrations, verify."""
+import json
+import os
+import shutil
+import sqlite3
+import subprocess
+import sys
+import time
+from pathlib import Path
+
+# Repo root: go up from src/plugins/ -> src/ -> repo/
+_THIS_DIR = Path(__file__).resolve().parent
+REPO_DIR = _THIS_DIR.parent.parent
+PACKAGE_JSON = REPO_DIR / "package.json"
+SRC_DIR = REPO_DIR / "src"
+
+NEXO_HOME = Path(os.environ.get("NEXO_HOME", str(Path.home() / ".nexo")))
+DATA_DIR = NEXO_HOME / "data"
+BACKUP_BASE = NEXO_HOME / "backups"
+
+
+def _read_version() -> str:
+    """Read version from package.json."""
+    try:
+        return json.loads(PACKAGE_JSON.read_text()).get("version", "unknown")
+    except Exception:
+        return "unknown"
+
+
+def _git(*args, cwd=None) -> tuple[int, str, str]:
+    """Run a git command and return (returncode, stdout, stderr)."""
+    result = subprocess.run(
+        ["git"] + list(args),
+        cwd=cwd or str(REPO_DIR),
+        capture_output=True,
+        text=True,
+        timeout=60,
+    )
+    return result.returncode, result.stdout.strip(), result.stderr.strip()
+
+
+def _check_dirty() -> str | None:
+    """Return error message if src/ has uncommitted changes, else None."""
+    rc, out, _ = _git("status", "--porcelain", "--", "src/")
+    if rc != 0:
+        return "Failed to check git status."
+    if out:
+        return f"Uncommitted changes in src/:\n{out}\nCommit or stash before updating."
+    return None
+
+
+def _backup_databases() -> tuple[str, str | None]:
+    """Backup all .db files from NEXO_HOME/data/. Returns (backup_dir, error)."""
+    timestamp = time.strftime("%Y-%m-%d-%H%M")
+    backup_dir = BACKUP_BASE / f"pre-update-{timestamp}"
+
+    db_files = list(DATA_DIR.glob("*.db")) if DATA_DIR.is_dir() else []
+    # Also check NEXO_HOME root for legacy db location
+    db_files += [f for f in NEXO_HOME.glob("*.db") if f.is_file()]
+    # And check src/ dir for nexo.db (dev mode)
+    src_db = SRC_DIR / "nexo.db"
+    if src_db.is_file() and src_db not in db_files:
+        db_files.append(src_db)
+
+    if not db_files:
+        return str(backup_dir), None  # No DBs to backup, not an error
+
+    backup_dir.mkdir(parents=True, exist_ok=True)
+
+    for db_file in db_files:
+        dest = backup_dir / db_file.name
+        try:
+            src_conn = sqlite3.connect(str(db_file))
+            dst_conn = sqlite3.connect(str(dest))
+            src_conn.backup(dst_conn)
+            dst_conn.close()
+            src_conn.close()
+        except Exception as e:
+            return str(backup_dir), f"Failed to backup {db_file.name}: {e}"
+
+    return str(backup_dir), None
+
+
+def _restore_databases(backup_dir: str):
+    """Restore .db files from a backup directory."""
+    bdir = Path(backup_dir)
+    if not bdir.is_dir():
+        return
+    for db_backup in bdir.glob("*.db"):
+        # Try to find original location
+        for candidate in [DATA_DIR / db_backup.name, NEXO_HOME / db_backup.name, SRC_DIR / db_backup.name]:
+            if candidate.is_file():
+                try:
+                    src_conn = sqlite3.connect(str(db_backup))
+                    dst_conn = sqlite3.connect(str(candidate))
+                    src_conn.backup(dst_conn)
+                    dst_conn.close()
+                    src_conn.close()
+                except Exception:
+                    pass
+                break
+
+
+def _run_migrations() -> str | None:
+    """Run init_db() to apply pending migrations. Returns error or None."""
+    try:
+        result = subprocess.run(
+            [sys.executable, "-c", "import db; db.init_db()"],
+            cwd=str(SRC_DIR),
+            capture_output=True,
+            text=True,
+            timeout=30,
+        )
+        if result.returncode != 0:
+            return f"Migration failed: {result.stderr or result.stdout}"
+    except Exception as e:
+        return f"Migration error: {e}"
+    return None
+
+
+def _verify_import() -> str | None:
+    """Verify server.py can be imported successfully."""
+    try:
+        result = subprocess.run(
+            [sys.executable, "-c", "import server"],
+            cwd=str(SRC_DIR),
+            capture_output=True,
+            text=True,
+            timeout=15,
+        )
+        if result.returncode != 0:
+            return f"Import verification failed: {result.stderr or result.stdout}"
+    except Exception as e:
+        return f"Import verification error: {e}"
+    return None
+
+
+def handle_update(remote: str = "origin", branch: str = "main") -> str:
+    """Pull latest NEXO code, backup databases, run migrations, and verify.
+
+    Full update flow:
+    1. Check for uncommitted changes in src/
+    2. Backup all .db files
+    3. git pull
+    4. Run migrations if version changed
+    5. Verify server.py imports
+    6. Rollback on failure
+
+    Args:
+        remote: Git remote name (default: origin)
+        branch: Git branch to pull (default: main)
+    """
+    steps_done = []
+    old_commit = None
+    backup_dir = None
+
+    try:
+        # Step 1: Check dirty
+        dirty_err = _check_dirty()
+        if dirty_err:
+            return f"ABORTED: {dirty_err}"
+        steps_done.append("clean-check")
+
+        # Record current state
+        old_version = _read_version()
+        rc, old_commit, _ = _git("rev-parse", "HEAD")
+        if rc != 0:
+            return "ABORTED: Not a git repository or git not available."
+
+        # Step 2: Backup databases
+        backup_dir, backup_err = _backup_databases()
+        if backup_err:
+            return f"ABORTED at backup: {backup_err}"
+        steps_done.append("backup")
+
+        # Step 3: git pull
+        rc, pull_out, pull_err = _git("pull", remote, branch)
+        if rc != 0:
+            return f"ABORTED at git pull: {pull_err or pull_out}"
+        steps_done.append("git-pull")
+
+        # Step 4: Check version change
+        new_version = _read_version()
+        version_changed = old_version != new_version
+
+        # Step 5: Run migrations if version changed
+        if version_changed:
+            mig_err = _run_migrations()
+            if mig_err:
+                raise RuntimeError(f"Migration failed: {mig_err}")
+            steps_done.append("migrations")
+
+        # Step 6: Verify import
+        verify_err = _verify_import()
+        if verify_err:
+            raise RuntimeError(f"Verification failed: {verify_err}")
+        steps_done.append("verify")
+
+        # Build result
+        if pull_out == "Already up to date.":
+            return f"Already up to date (v{old_version}). No changes pulled."
+
+        lines = ["UPDATE SUCCESSFUL"]
+        if version_changed:
+            lines.append(f"  Version: {old_version} -> {new_version}")
+        else:
+            lines.append(f"  Version: {old_version} (unchanged)")
+        lines.append(f"  Branch: {remote}/{branch}")
+        lines.append(f"  Backup: {backup_dir}")
+        if version_changed:
+            lines.append("  Migrations: applied")
+        lines.append("")
+        lines.append("MCP server restart needed to load new code.")
+        return "\n".join(lines)
+
+    except Exception as e:
+        # Rollback
+        rollback_lines = [f"UPDATE FAILED: {e}", "", "Rolling back..."]
+
+        if old_commit and "git-pull" in steps_done:
+            rc, _, err = _git("reset", "--hard", old_commit)
+            if rc == 0:
+                rollback_lines.append(f"  Git: reset to {old_commit[:8]}")
+            else:
+                rollback_lines.append(f"  Git rollback FAILED: {err}")
+
+        if backup_dir and "backup" in steps_done:
+            _restore_databases(backup_dir)
+            rollback_lines.append(f"  DBs: restored from {backup_dir}")
+
+        rollback_lines.append("")
+        rollback_lines.append("System restored to previous state.")
+        return "\n".join(rollback_lines)
+
+
+TOOLS = [
+    (handle_update, "nexo_update", "Pull latest NEXO code, backup DBs, run migrations, verify. Rolls back on failure."),
+]

package/src/requirements.txt

@@ -0,0 +1,12 @@
+# NEXO Brain — runtime dependencies
+# Core (required)
+fastmcp>=2.9.0
+numpy
+
+# Embedding model (optional but recommended for cognitive features)
+fastembed
+
+# Dashboard (optional, only needed for `python -m dashboard.app`)
+fastapi
+uvicorn
+pydantic

package/src/scripts/check-context.py

@@ -175,13 +175,21 @@ Rules:
 - Similar but different scope (e.g., different recipients) = NOT redundant
 - When in doubt, say not redundant (false negatives are cheaper than false positives)"""
 
+    auth_check = subprocess.run(
+        [str(CLAUDE_CLI), "-p", "Reply with exactly: ok", "--bare", "--output-format", "text", "--model", "haiku"],
+        capture_output=True, text=True, timeout=15
+    )
+    if auth_check.returncode != 0:
+        # CLI not authenticated, skip gracefully
+        return {"redundant": False, "reason": "CLI not authenticated — skipped analysis", "suggestion": "N/A"}
+
     env = os.environ.copy()
     env.pop("CLAUDECODE", None)
     env.pop("CLAUDE_CODE", None)
 
     try:
         result = subprocess.run(
-            [str(CLAUDE_CLI), "-p", prompt, "--model", "opus",
+            [str(CLAUDE_CLI), "-p", prompt, "--model", "opus", "--output-format", "text", "--bare",
              "--allowedTools", "Read,Write,Edit,Glob,Grep"],
             capture_output=True, text=True, timeout=60, env=env
         )

package/src/scripts/deep-sleep/apply_findings.py

@@ -1,10 +1,10 @@
-import os
 #!/usr/bin/env python3
 """
 Deep Sleep — Step 3: Apply findings.
 Takes the analysis output and writes feedback memories + trust adjustments.
 """
 import json
+import os
 import sqlite3
 import sys
 from datetime import datetime
@@ -13,7 +13,7 @@ from pathlib import Path
 NEXO_HOME = Path(os.environ.get("NEXO_HOME", str(Path.home() / ".nexo")))
 
 DEEP_SLEEP_DIR = NEXO_HOME / "operations" / "deep-sleep"
-NEXO_DB = NEXO_HOME / "nexo-mcp" / "db" / "nexo.db"
+NEXO_DB = NEXO_HOME / "data" / "nexo.db"
 
 
 def find_memory_dir() -> Path:
@@ -67,7 +67,7 @@ def update_memory_index(memory_dir: Path, new_entries: list[dict]):
 
 def adjust_trust(points: int, context: str):
     """Record trust adjustment in cognitive.db if available."""
-    cog_db = NEXO_HOME / "nexo-mcp" / "cognitive.db"
+    cog_db = NEXO_HOME / "data" / "cognitive.db"
     if not cog_db.exists():
         return
     try:

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

@@ -1,213 +1,6 @@
 #!/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
+"""DEPRECATED: Updates are handled automatically by NEXO on startup."""
 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()
+print("This script is deprecated. NEXO auto-updates on startup.")
+print("To update manually, use the nexo_update MCP tool.")
+sys.exit(0)

package/src/scripts/nexo-backup.sh

@@ -1,20 +1,12 @@
 #!/bin/bash
-# NEXO DB hourly backup
-# Install: crontab -e → 0 * * * * /path/to/nexo-backup.sh
-#
-# Keeps hourly backups for 48h and weekly backups for 90 days.
-
-NEXO_DIR="${NEXO_DIR:-$(dirname "$(dirname "$(realpath "$0")")")}"
-BACKUP_DIR="$NEXO_DIR/backups"
+# NEXO DB hourly backup — crontab: 0 * * * * $NEXO_HOME/scripts/nexo-backup.sh
+NEXO_HOME="${NEXO_HOME:-$HOME/.nexo}"
+NEXO_DIR="$NEXO_HOME"
+BACKUP_DIR="$NEXO_HOME/backups"
 WEEKLY_DIR="$BACKUP_DIR/weekly"
-DB="$NEXO_DIR/db/nexo.db"
+DB="$NEXO_HOME/data/nexo.db"
 RETENTION_HOURS=48
 
-if [ ! -f "$DB" ]; then
-    echo "ERROR: nexo.db not found at $DB" >&2
-    exit 1
-fi
-
 mkdir -p "$BACKUP_DIR" "$WEEKLY_DIR"
 
 # Hourly backup