nexo-brain 2.2.0 → 2.3.1

package/src/plugins/knowledge_graph_tools 2.py

@@ -1,105 +0,0 @@
-"""Knowledge Graph MCP tools — query, path, neighbors, stats."""
-import os
-import sys
-
-sys.path.insert(0, os.path.join(os.path.dirname(os.path.abspath(__file__)), ".."))
-import knowledge_graph as kg
-
-
-def _find_node(node_type: str, node_ref: str):
-    """Find a node, trying both raw ref and type-prefixed ref (area:X, file:X)."""
-    node = kg.get_node(node_type, node_ref)
-    if not node:
-        node = kg.get_node(node_type, f"{node_type}:{node_ref}")
-    return node
-
-
-def handle_kg_query(node_type: str, node_ref: str, depth: int = 2, relation: str = "") -> str:
-    """Traverse the knowledge graph from a node up to `depth` hops."""
-    node = _find_node(node_type, node_ref)
-    if not node:
-        return f"Node not found: {node_type}/{node_ref}"
-    result = kg.traverse(node["id"], max_depth=depth, relation_filter=relation or None)
-    nodes = result["nodes"][:30]
-    edges = result["edges"][:30]
-    lines = [f"KG TRAVERSE — {node['label']} ({node_type}/{node_ref}) depth={depth}"]
-    lines.append(f"Nodes: {len(result['nodes'])}  Edges: {len(result['edges'])}")
-    lines.append("")
-    lines.append("NODES:")
-    for n in nodes:
-        indent = "  " * n.get("depth", 0)
-        lines.append(f"  {indent}[{n['id']}] ({n['node_type']}) {n['label']} — {n['node_ref']}")
-    lines.append("")
-    lines.append("EDGES:")
-    for e in edges[:20]:
-        lines.append(f"  [{e['source_id']}] --{e['relation']}--> [{e['target_id']}]  w={e['weight']}")
-    return "\n".join(lines)
-
-
-def handle_kg_path(from_type: str, from_ref: str, to_type: str, to_ref: str) -> str:
-    """Find the shortest path between two nodes in the knowledge graph."""
-    from_node = _find_node(from_type, from_ref)
-    if not from_node:
-        return f"Source node not found: {from_type}/{from_ref}"
-    to_node = _find_node(to_type, to_ref)
-    if not to_node:
-        return f"Target node not found: {to_type}/{to_ref}"
-    path_ids = kg.shortest_path(from_node["id"], to_node["id"])
-    if not path_ids:
-        return f"No path found between {from_ref} and {to_ref}"
-    lines = [f"PATH ({len(path_ids) - 1} hops): {from_ref} → {to_ref}"]
-    for i, nid in enumerate(path_ids):
-        node = kg.get_node_by_id(nid)
-        label = node["label"] if node else f"[{nid}]"
-        ntype = node["node_type"] if node else "?"
-        lines.append(f"  {i}. [{nid}] ({ntype}) {label}")
-    return "\n".join(lines)
-
-
-def handle_kg_neighbors(node_type: str, node_ref: str, relation: str = "") -> str:
-    """Get direct neighbors of a node, optionally filtered by relation type."""
-    node = _find_node(node_type, node_ref)
-    if not node:
-        return f"Node not found: {node_type}/{node_ref}"
-    neighbors = kg.get_neighbors(node["id"], relation=relation or None)
-    if not neighbors:
-        rel_info = f" (relation={relation})" if relation else ""
-        return f"No neighbors found for {node['label']}{rel_info}"
-    lines = [f"NEIGHBORS of [{node['id']}] {node['label']} ({len(neighbors)} total):"]
-    for n in neighbors[:30]:
-        direction = n.get("direction", "?")
-        arrow = "-->" if direction == "outgoing" else "<--"
-        lines.append(f"  {arrow} [{n['id']}] {n['label']} ({n['node_type']})  rel={n['relation']}  w={n['weight']}")
-    if len(neighbors) > 30:
-        lines.append(f"  ... +{len(neighbors) - 30} more")
-    return "\n".join(lines)
-
-
-def handle_kg_stats() -> str:
-    """Return knowledge graph statistics: node counts, edge counts, top connected nodes."""
-    s = kg.stats()
-    lines = ["KNOWLEDGE GRAPH STATS"]
-    lines.append(f"  Nodes: {s['nodes']}")
-    lines.append(f"  Edges (active): {s['edges_active']}")
-    lines.append(f"  Edges (historical): {s['edges_historical']}")
-    if s["node_types"]:
-        lines.append("\nNODE TYPES:")
-        for t, cnt in sorted(s["node_types"].items(), key=lambda x: -x[1]):
-            lines.append(f"  {t}: {cnt}")
-    if s["relation_types"]:
-        lines.append("\nRELATION TYPES:")
-        for r, cnt in sorted(s["relation_types"].items(), key=lambda x: -x[1])[:20]:
-            lines.append(f"  {r}: {cnt}")
-    if s["most_connected"]:
-        lines.append("\nMOST CONNECTED:")
-        for n in s["most_connected"][:10]:
-            lines.append(f"  [{n['id']}] {n['label']} ({n['node_type']}) — {n['connections']} connections")
-    return "\n".join(lines)
-
-
-TOOLS = [
-    (handle_kg_query, "nexo_kg_query", "Query knowledge graph — traverse from a node"),
-    (handle_kg_path, "nexo_kg_path", "Find shortest path between two nodes"),
-    (handle_kg_neighbors, "nexo_kg_neighbors", "Get direct neighbors of a node"),
-    (handle_kg_stats, "nexo_kg_stats", "Knowledge graph statistics"),
-]

package/src/plugins/preferences 2.py

@@ -1,47 +0,0 @@
-"""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"Preference '{key}' not found."
-    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"Preference '{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 "No preferences."
-    grouped = {}
-    for p in prefs:
-        c = p["category"]
-        if c not in grouped: grouped[c] = []
-        grouped[c].append(p)
-    lines = ["PREFERENCES:"]
-    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: Preference '{key}' not found."
-    return f"Preference '{key}' deleted."
-
-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/plugins/update 2.py

@@ -1,256 +0,0 @@
-"""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")
-
-        # Step 7: Sync crons with manifest
-        cron_sync_result = ""
-        try:
-            cron_sync_path = NEXO_CODE / "crons" / "sync.py"
-            if cron_sync_path.exists():
-                import subprocess as _sp
-                r = _sp.run(
-                    [sys.executable, str(cron_sync_path)],
-                    capture_output=True, text=True, timeout=30,
-                    env={**os.environ, "NEXO_HOME": str(NEXO_HOME), "NEXO_CODE": str(NEXO_CODE)},
-                )
-                cron_sync_result = r.stdout.strip()
-                steps_done.append("cron-sync")
-        except Exception as e:
-            cron_sync_result = f"Cron sync warning: {e}"
-
-        # 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")
-        if "cron-sync" in steps_done:
-            lines.append("  Crons: synced with manifest")
-        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 2.txt

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