nexo-brain 2.2.0 → 2.3.1

package/src/plugins/agents 2.py

@@ -1,52 +0,0 @@
-"""Agents plugin — registry of known agent types with their configs."""
-from db import create_agent, get_agent, list_agents, update_agent, delete_agent
-
-def handle_agent_get(id: str) -> str:
-    """Get an agent's full profile by ID."""
-    a = get_agent(id)
-    if not a: return f"Agent '{id}' not found."
-    lines = [f"AGENT: {a['name']} ({a['id']})", f"  Specialization: {a['specialization']}", f"  Model: {a['model']}"]
-    if a["tools"]: lines.append(f"  Tools: {a['tools']}")
-    if a["context_files"]: lines.append(f"  Contexto: {a['context_files']}")
-    if a["rules"]: lines.append(f"  Reglas: {a['rules']}")
-    return "\n".join(lines)
-
-def handle_agent_create(id: str, name: str, specialization: str, model: str = "sonnet",
-                        tools: str = "", context_files: str = "", rules: str = "") -> str:
-    """Register a new agent in the registry."""
-    create_agent(id, name, specialization, model, tools, context_files, rules)
-    return f"Agent '{id}' ({name}) registered. Model: {model}"
-
-def handle_agent_update(id: str, name: str = "", specialization: str = "", model: str = "",
-                        tools: str = "", context_files: str = "", rules: str = "") -> str:
-    """Update agent fields. Only non-empty fields are changed."""
-    kwargs = {}
-    for k, v in [("name", name), ("specialization", specialization), ("model", model),
-                  ("tools", tools), ("context_files", context_files), ("rules", rules)]:
-        if v: kwargs[k] = v
-    if not kwargs: return "Nothing to update."
-    update_agent(id, **kwargs)
-    return f"Agent '{id}' updated."
-
-def handle_agent_list() -> str:
-    """List all registered agents."""
-    agents = list_agents()
-    if not agents: return "No agents registered."
-    lines = ["REGISTERED AGENTS:"]
-    for a in agents:
-        lines.append(f"  {a['id']} — {a['name']} ({a['model']}) — {a['specialization'][:60]}")
-    return "\n".join(lines)
-
-def handle_agent_delete(id: str) -> str:
-    """Remove an agent from the registry."""
-    if not delete_agent(id):
-        return f"ERROR: Agent '{id}' not found."
-    return f"Agent '{id}' deleted."
-
-TOOLS = [
-    (handle_agent_get, "nexo_agent_get", "Get an agent's full profile"),
-    (handle_agent_create, "nexo_agent_create", "Register a new agent"),
-    (handle_agent_update, "nexo_agent_update", "Update agent fields"),
-    (handle_agent_list, "nexo_agent_list", "List all registered agents"),
-    (handle_agent_delete, "nexo_agent_delete", "Remove an agent from registry"),
-]

package/src/plugins/artifact_registry 2.py

@@ -1,450 +0,0 @@
-"""Artifact Registry plugin — structured index of things NEXO creates/deploys.
-
-Solves 'recent work amnesia': NEXO builds services, dashboards, scripts, APIs
-but can't find them hours later because semantic search ('backend') doesn't
-match operational terms ('FastAPI localhost:6174').
-
-Architecture (from 3-way AI debate — GPT-5.4 + Gemini 3.1 Pro + Claude Opus 4.6):
-1. Structured SQLite table with aliases, ports, paths, run commands
-2. Retrieval ladder: exact alias → port/path match → fuzzy token → semantic fallback
-3. User-language alias learning: when the user says 'backend' and it resolves
-   to dashboard:6174, store that mapping for O(1) next time
-4. Temporal filtering: 'last night' → hard SQL constraint before any search
-"""
-
-import json
-import datetime
-from db import get_db
-
-
-# Valid artifact kinds
-VALID_KINDS = {
-    'service', 'dashboard', 'script', 'api', 'cron', 'website',
-    'database', 'repo', 'config', 'tool', 'plugin', 'other',
-}
-
-VALID_STATES = {'active', 'inactive', 'broken', 'archived'}
-
-
-def _cognitive_ingest_safe(content, source_type, source_id="", source_title="", domain=""):
-    """Ingest to cognitive STM. Silently fails if cognitive engine unavailable."""
-    try:
-        import cognitive
-        cognitive.ingest(content, source_type, source_id, source_title, domain)
-    except Exception:
-        pass
-
-
-def handle_artifact_create(
-    kind: str,
-    canonical_name: str,
-    aliases: str = '[]',
-    description: str = '',
-    uri: str = '',
-    ports: str = '[]',
-    paths: str = '[]',
-    run_cmd: str = '',
-    repo: str = '',
-    domain: str = '',
-    session_id: str = '',
-    metadata: str = '{}',
-) -> str:
-    """Register a new artifact (service, dashboard, script, API, etc.).
-
-    Call this whenever NEXO creates, deploys, or discovers a runnable/accessible artifact.
-
-    Args:
-        kind: Type — service, dashboard, script, api, cron, website, database, repo, config, tool, plugin, other
-        canonical_name: Primary name (e.g., 'NEXO Brain Dashboard')
-        aliases: JSON array of alternative names users might use (e.g., '["backend", "dashboard", "nexo web"]')
-        description: What it does (1-2 sentences)
-        uri: Access URL or address (e.g., 'localhost:6174', 'nexo-brain.com')
-        ports: JSON array of ports (e.g., '[6174]')
-        paths: JSON array of file paths (e.g., '["/Users/x/nexo/src/dashboard/app.py"]')
-        run_cmd: Command to start/open it (e.g., 'python3 -m dashboard.app --port 6174')
-        repo: Repository path or URL
-        domain: Project domain (nexo, my-project, project-a, project-b, etc.)
-        session_id: Current session ID
-        metadata: JSON object with extra key-value pairs
-    """
-    if kind not in VALID_KINDS:
-        return f"ERROR: kind must be one of: {', '.join(sorted(VALID_KINDS))}"
-
-    # Parse aliases
-    try:
-        alias_list = json.loads(aliases) if aliases and aliases != '[]' else []
-    except (json.JSONDecodeError, TypeError):
-        alias_list = [a.strip() for a in aliases.split(',') if a.strip()]
-
-    conn = get_db()
-    cur = conn.execute(
-        """INSERT INTO artifact_registry
-           (kind, canonical_name, aliases, description, uri, ports, paths,
-            run_cmd, repo, domain, state, session_id, metadata)
-           VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, 'active', ?, ?)""",
-        (kind, canonical_name, json.dumps(alias_list), description, uri, ports,
-         paths, run_cmd, repo, domain, session_id, metadata),
-    )
-    artifact_id = cur.lastrowid
-    conn.commit()
-
-    # Insert aliases into lookup table
-    for alias in alias_list + [canonical_name.lower()]:
-        alias_clean = alias.strip().lower()
-        if alias_clean:
-            try:
-                conn.execute(
-                    "INSERT OR IGNORE INTO artifact_aliases (artifact_id, phrase, source) VALUES (?, ?, 'create')",
-                    (artifact_id, alias_clean),
-                )
-            except Exception:
-                pass
-    conn.commit()
-
-    # Ingest to cognitive memory
-    content = f"Artifact: {canonical_name} ({kind}). {description}. URI: {uri}. Aliases: {', '.join(alias_list)}"
-    _cognitive_ingest_safe(content, "artifact", f"A{artifact_id}", canonical_name[:80], domain)
-
-    return f"Artifact #{artifact_id} created: {canonical_name} ({kind}) — {uri or 'no URI'}"
-
-
-def handle_artifact_find(query: str, kind: str = '', state: str = 'active') -> str:
-    """Find artifacts using the retrieval ladder: exact alias → port/path → fuzzy token → all recent.
-
-    This is the PRIMARY retrieval tool. Use it when the user references something
-    they or NEXO built/deployed/created. Designed for natural language like
-    'the backend', 'that script from yesterday', 'localhost something'.
-
-    Args:
-        query: What to search for — name, alias, port, path, or description fragment
-        kind: Filter by kind (optional)
-        state: Filter by state — default 'active'. Use 'all' for everything.
-    """
-    conn = get_db()
-    results = []
-    query_lower = query.strip().lower()
-
-    state_filter = "AND state = ?" if state != 'all' else ""
-    state_params = (state,) if state != 'all' else ()
-
-    kind_filter = "AND kind = ?" if kind else ""
-    kind_params = (kind,) if kind else ()
-
-    extra_filters = state_filter + " " + kind_filter
-    extra_params = state_params + kind_params
-
-    # --- STAGE 1: Exact alias match (fastest, O(1)) ---
-    rows = conn.execute(
-        f"""SELECT DISTINCT r.* FROM artifact_registry r
-            JOIN artifact_aliases a ON a.artifact_id = r.id
-            WHERE a.phrase = ? {extra_filters}
-            ORDER BY r.last_touched_at DESC LIMIT 5""",
-        (query_lower,) + extra_params,
-    ).fetchall()
-    if rows:
-        results = [dict(r) for r in rows]
-        return _format_results(results, "alias match", query)
-
-    # --- STAGE 2: Port or URI match ---
-    rows = conn.execute(
-        f"""SELECT * FROM artifact_registry
-            WHERE (uri LIKE ? OR ports LIKE ?) {extra_filters}
-            ORDER BY last_touched_at DESC LIMIT 5""",
-        (f"%{query_lower}%", f"%{query_lower}%") + extra_params,
-    ).fetchall()
-    if rows:
-        results = [dict(r) for r in rows]
-        return _format_results(results, "URI/port match", query)
-
-    # --- STAGE 3: Path match ---
-    rows = conn.execute(
-        f"""SELECT * FROM artifact_registry
-            WHERE paths LIKE ? {extra_filters}
-            ORDER BY last_touched_at DESC LIMIT 5""",
-        (f"%{query_lower}%",) + extra_params,
-    ).fetchall()
-    if rows:
-        results = [dict(r) for r in rows]
-        return _format_results(results, "path match", query)
-
-    # --- STAGE 4: Fuzzy token match on name, description, aliases ---
-    tokens = query_lower.split()
-    if tokens:
-        conditions = " AND ".join(
-            "(LOWER(canonical_name) LIKE ? OR LOWER(description) LIKE ? OR LOWER(aliases) LIKE ?)"
-            for _ in tokens
-        )
-        params = []
-        for t in tokens:
-            p = f"%{t}%"
-            params.extend([p, p, p])
-        rows = conn.execute(
-            f"""SELECT * FROM artifact_registry
-                WHERE {conditions} {extra_filters}
-                ORDER BY last_touched_at DESC LIMIT 10""",
-            tuple(params) + extra_params,
-        ).fetchall()
-        if rows:
-            results = [dict(r) for r in rows]
-            return _format_results(results, "token match", query)
-
-    # --- STAGE 5: Recent artifacts (last 72h) as fallback ---
-    cutoff = (datetime.datetime.now() - datetime.timedelta(hours=72)).isoformat()
-    rows = conn.execute(
-        f"""SELECT * FROM artifact_registry
-            WHERE last_touched_at >= ? {extra_filters}
-            ORDER BY last_touched_at DESC LIMIT 10""",
-        (cutoff,) + extra_params,
-    ).fetchall()
-    if rows:
-        results = [dict(r) for r in rows]
-        return _format_results(results, "recent (72h)", query)
-
-    return f"No artifacts found for '{query}'. Use artifact_list to see all registered artifacts."
-
-
-def handle_artifact_update(
-    id: int,
-    canonical_name: str = '',
-    aliases: str = '',
-    description: str = '',
-    uri: str = '',
-    ports: str = '',
-    paths: str = '',
-    run_cmd: str = '',
-    state: str = '',
-    domain: str = '',
-    metadata: str = '',
-) -> str:
-    """Update an artifact. Only non-empty fields are changed.
-
-    Args:
-        id: Artifact ID to update
-        canonical_name: New primary name
-        aliases: New JSON array of aliases (replaces existing)
-        description: New description
-        uri: New URI
-        ports: New ports JSON array
-        paths: New paths JSON array
-        run_cmd: New run command
-        state: New state (active, inactive, broken, archived)
-        domain: New domain
-        metadata: New metadata JSON (merged with existing)
-    """
-    conn = get_db()
-    row = conn.execute("SELECT * FROM artifact_registry WHERE id = ?", (id,)).fetchone()
-    if not row:
-        return f"ERROR: Artifact #{id} not found."
-
-    updates = []
-    params = []
-
-    if canonical_name:
-        updates.append("canonical_name = ?"); params.append(canonical_name)
-    if description:
-        updates.append("description = ?"); params.append(description)
-    if uri:
-        updates.append("uri = ?"); params.append(uri)
-    if ports:
-        updates.append("ports = ?"); params.append(ports)
-    if paths:
-        updates.append("paths = ?"); params.append(paths)
-    if run_cmd:
-        updates.append("run_cmd = ?"); params.append(run_cmd)
-    if domain:
-        updates.append("domain = ?"); params.append(domain)
-    if state:
-        if state not in VALID_STATES:
-            return f"ERROR: state must be one of: {', '.join(sorted(VALID_STATES))}"
-        updates.append("state = ?"); params.append(state)
-    if metadata:
-        try:
-            existing = json.loads(row["metadata"] or '{}')
-            new = json.loads(metadata)
-            existing.update(new)
-            updates.append("metadata = ?"); params.append(json.dumps(existing))
-        except (json.JSONDecodeError, TypeError):
-            pass
-
-    if aliases:
-        try:
-            alias_list = json.loads(aliases) if aliases.startswith('[') else [a.strip() for a in aliases.split(',')]
-        except (json.JSONDecodeError, TypeError):
-            alias_list = [a.strip() for a in aliases.split(',')]
-        updates.append("aliases = ?"); params.append(json.dumps(alias_list))
-        # Rebuild alias lookup table
-        conn.execute("DELETE FROM artifact_aliases WHERE artifact_id = ?", (id,))
-        for alias in alias_list:
-            alias_clean = alias.strip().lower()
-            if alias_clean:
-                conn.execute(
-                    "INSERT OR IGNORE INTO artifact_aliases (artifact_id, phrase, source) VALUES (?, ?, 'update')",
-                    (id, alias_clean),
-                )
-
-    if not updates:
-        return "Nothing to update."
-
-    updates.append("last_touched_at = datetime('now')")
-    params.append(id)
-    conn.execute(f"UPDATE artifact_registry SET {', '.join(updates)} WHERE id = ?", tuple(params))
-    conn.commit()
-    return f"Artifact #{id} updated."
-
-
-def handle_artifact_learn_alias(id: int, phrase: str) -> str:
-    """Learn a new alias from user language. Call this when the user refers to an
-    artifact with a term not yet registered (e.g., the user says 'backend' for dashboard:6174).
-
-    Args:
-        id: Artifact ID
-        phrase: The user's term (e.g., 'backend', 'that api thing')
-    """
-    conn = get_db()
-    row = conn.execute("SELECT * FROM artifact_registry WHERE id = ?", (id,)).fetchone()
-    if not row:
-        return f"ERROR: Artifact #{id} not found."
-
-    phrase_clean = phrase.strip().lower()
-    if not phrase_clean:
-        return "ERROR: Empty phrase."
-
-    # Add to alias lookup table
-    conn.execute(
-        "INSERT OR IGNORE INTO artifact_aliases (artifact_id, phrase, source) VALUES (?, ?, 'user_language')",
-        (id, phrase_clean),
-    )
-
-    # Also add to the artifact's aliases JSON array
-    try:
-        existing = json.loads(row["aliases"] or '[]')
-    except (json.JSONDecodeError, TypeError):
-        existing = []
-    if phrase_clean not in [a.lower() for a in existing]:
-        existing.append(phrase_clean)
-        conn.execute(
-            "UPDATE artifact_registry SET aliases = ?, last_touched_at = datetime('now') WHERE id = ?",
-            (json.dumps(existing), id),
-        )
-
-    conn.commit()
-    return f"Alias '{phrase_clean}' learned for artifact #{id} ({row['canonical_name']})."
-
-
-def handle_artifact_list(kind: str = '', state: str = 'active', recent_hours: int = 0) -> str:
-    """List all artifacts, optionally filtered.
-
-    Args:
-        kind: Filter by kind (service, dashboard, script, etc.)
-        state: Filter by state — 'active' (default), 'all', 'inactive', 'broken', 'archived'
-        recent_hours: If >0, only show artifacts touched in the last N hours
-    """
-    conn = get_db()
-    conditions = []
-    params = []
-
-    if state != 'all':
-        conditions.append("state = ?"); params.append(state)
-    if kind:
-        conditions.append("kind = ?"); params.append(kind)
-    if recent_hours > 0:
-        cutoff = (datetime.datetime.now() - datetime.timedelta(hours=recent_hours)).isoformat()
-        conditions.append("last_touched_at >= ?"); params.append(cutoff)
-
-    where = "WHERE " + " AND ".join(conditions) if conditions else ""
-    rows = conn.execute(
-        f"SELECT * FROM artifact_registry {where} ORDER BY last_touched_at DESC",
-        tuple(params),
-    ).fetchall()
-
-    if not rows:
-        filters = []
-        if kind: filters.append(f"kind={kind}")
-        if state != 'all': filters.append(f"state={state}")
-        if recent_hours: filters.append(f"last {recent_hours}h")
-        return f"No artifacts found{' (' + ', '.join(filters) + ')' if filters else ''}."
-
-    lines = [f"ARTIFACT REGISTRY ({len(rows)}):"]
-    for r in rows:
-        r = dict(r)
-        aliases_str = ""
-        try:
-            aliases = json.loads(r.get("aliases", "[]"))
-            if aliases:
-                aliases_str = f" aka [{', '.join(aliases[:3])}]"
-        except (json.JSONDecodeError, TypeError):
-            pass
-        uri_str = f" → {r['uri']}" if r.get("uri") else ""
-        cmd_str = f" | cmd: {r['run_cmd'][:60]}" if r.get("run_cmd") else ""
-        touched = r.get("last_touched_at", "")[:16]
-        lines.append(
-            f"  #{r['id']} [{r['kind']}] {r['canonical_name']}{aliases_str}{uri_str}{cmd_str} "
-            f"({r['state']}, {touched})"
-        )
-    return "\n".join(lines)
-
-
-def handle_artifact_delete(id: int) -> str:
-    """Delete an artifact from the registry.
-
-    Args:
-        id: Artifact ID to delete
-    """
-    conn = get_db()
-    row = conn.execute("SELECT canonical_name FROM artifact_registry WHERE id = ?", (id,)).fetchone()
-    if not row:
-        return f"ERROR: Artifact #{id} not found."
-    name = row["canonical_name"]
-    conn.execute("DELETE FROM artifact_aliases WHERE artifact_id = ?", (id,))
-    conn.execute("DELETE FROM artifact_registry WHERE id = ?", (id,))
-    conn.commit()
-    return f"Artifact #{id} ({name}) deleted."
-
-
-def _format_results(results, method, query):
-    """Format search results for display."""
-    lines = [f"ARTIFACTS FOUND ({len(results)}, via {method} for '{query}'):"]
-    for r in results:
-        aliases_str = ""
-        try:
-            aliases = json.loads(r.get("aliases", "[]"))
-            if aliases:
-                aliases_str = f" aka [{', '.join(aliases[:4])}]"
-        except (json.JSONDecodeError, TypeError):
-            pass
-        uri_str = f" → {r['uri']}" if r.get("uri") else ""
-        cmd_str = f"\n    Run: {r['run_cmd']}" if r.get("run_cmd") else ""
-        paths_str = ""
-        try:
-            paths = json.loads(r.get("paths", "[]"))
-            if paths:
-                paths_str = f"\n    Paths: {', '.join(paths[:3])}"
-        except (json.JSONDecodeError, TypeError):
-            pass
-        touched = r.get("last_touched_at", "")[:16]
-        lines.append(
-            f"  #{r['id']} [{r['kind']}] {r['canonical_name']}{aliases_str}{uri_str} "
-            f"({r['state']}, {touched}){cmd_str}{paths_str}"
-        )
-    return "\n".join(lines)
-
-
-# Plugin registration — TOOLS array consumed by plugin_loader.py
-TOOLS = [
-    (handle_artifact_create, "nexo_artifact_create",
-     "Register a new artifact (service, dashboard, script, API, etc.) in the Artifact Registry. "
-     "Call this whenever NEXO creates, deploys, or discovers a runnable/accessible artifact."),
-    (handle_artifact_find, "nexo_artifact_find",
-     "Find artifacts using the retrieval ladder: exact alias → port/path → fuzzy token → recent. "
-     "PRIMARY retrieval tool for when users reference something built/deployed. Handles natural "
-     "language like 'the backend', 'that script', 'localhost something'."),
-    (handle_artifact_update, "nexo_artifact_update",
-     "Update an existing artifact. Only non-empty fields are changed."),
-    (handle_artifact_learn_alias, "nexo_artifact_learn_alias",
-     "Learn a new alias from user language. Call when the user refers to an artifact with "
-     "an unregistered term (e.g., 'backend' for the NEXO Brain Dashboard)."),
-    (handle_artifact_list, "nexo_artifact_list",
-     "List all registered artifacts, optionally filtered by kind, state, or recency."),
-    (handle_artifact_delete, "nexo_artifact_delete",
-     "Delete an artifact from the registry."),
-]

package/src/plugins/backup 2.py

@@ -1,104 +0,0 @@
-"""Backup plugin — hourly SQLite backups with 7-day retention."""
-import os
-import shutil
-import time
-import glob
-from db import get_db
-
-NEXO_HOME = os.environ.get("NEXO_HOME", os.path.expanduser("~/.nexo"))
-DB_PATH = os.path.join(NEXO_HOME, "data", "nexo.db")
-BACKUP_DIR = os.path.join(NEXO_HOME, "backups")
-
-RETENTION_DAYS = 7
-
-
-def handle_backup_now() -> str:
-    """Create an immediate backup of the NEXO database."""
-    os.makedirs(BACKUP_DIR, exist_ok=True)
-    timestamp = time.strftime("%Y-%m-%d-%H%M")
-    dest = os.path.join(BACKUP_DIR, f"nexo-{timestamp}.db")
-
-    # Use SQLite backup API for consistency
-    import sqlite3
-    src_conn = sqlite3.connect(DB_PATH)
-    dst_conn = sqlite3.connect(dest)
-    src_conn.backup(dst_conn)
-    dst_conn.close()
-    src_conn.close()
-
-    size_kb = os.path.getsize(dest) / 1024
-    _cleanup_old()
-    return f"Backup created: {os.path.basename(dest)} ({size_kb:.0f} KB)"
-
-
-def handle_backup_list() -> str:
-    """List available backups with dates and sizes."""
-    if not os.path.isdir(BACKUP_DIR):
-        return "No backups."
-    files = sorted(glob.glob(os.path.join(BACKUP_DIR, "nexo-*.db")), reverse=True)
-    if not files:
-        return "No backups."
-    lines = [f"BACKUPS ({len(files)}):"]
-    total_size = 0
-    for f in files:
-        size = os.path.getsize(f) / 1024
-        total_size += size
-        name = os.path.basename(f)
-        lines.append(f"  {name} ({size:.0f} KB)")
-    lines.append(f"\n  Total: {total_size/1024:.1f} MB")
-    return "\n".join(lines)
-
-
-def handle_backup_restore(filename: str) -> str:
-    """Restore database from a backup file. DESTRUCTIVE — replaces current DB.
-
-    Args:
-        filename: Backup filename (e.g., 'nexo-2026-03-11-1200.db')
-    """
-    src = os.path.join(BACKUP_DIR, filename)
-    if not os.path.isfile(src):
-        return f"Backup not found: {filename}"
-
-    # Create safety backup first
-    safety = os.path.join(BACKUP_DIR, f"nexo-pre-restore-{time.strftime('%Y%m%d%H%M%S')}.db")
-    import sqlite3
-    src_conn = sqlite3.connect(DB_PATH)
-    dst_conn = sqlite3.connect(safety)
-    src_conn.backup(dst_conn)
-    dst_conn.close()
-    src_conn.close()
-
-    # Restore
-    restore_conn = sqlite3.connect(src)
-    target_conn = sqlite3.connect(DB_PATH)
-    restore_conn.backup(target_conn)
-    target_conn.close()
-    restore_conn.close()
-
-    # Invalidate shared connection so db.py reconnects to restored data
-    import db
-    if db._shared_conn is not None:
-        try:
-            db._shared_conn.close()
-        except Exception:
-            pass
-        db._shared_conn = None
-
-    return f"DB restaurada desde {filename}. Safety backup: {os.path.basename(safety)}"
-
-
-def _cleanup_old():
-    """Remove backups older than RETENTION_DAYS."""
-    if not os.path.isdir(BACKUP_DIR):
-        return
-    cutoff = time.time() - (RETENTION_DAYS * 86400)
-    for f in glob.glob(os.path.join(BACKUP_DIR, "nexo-*.db")):
-        if os.path.getmtime(f) < cutoff:
-            os.remove(f)
-
-
-TOOLS = [
-    (handle_backup_now, "nexo_backup_now", "Create an immediate backup of the NEXO database"),
-    (handle_backup_list, "nexo_backup_list", "List available backups with dates and sizes"),
-    (handle_backup_restore, "nexo_backup_restore", "Restore database from a backup (DESTRUCTIVE)"),
-]