nexo-brain 2.0.0 → 2.2.0

package/scripts/migrate-v1.7-to-v1.8 2.py

@@ -0,0 +1,214 @@
+#!/usr/bin/env python3
+"""
+NEXO Migration Script: v1.7.x -> v1.8.0 (Hybrid Architecture)
+
+Migrates CLAUDE.md to the new hybrid architecture where:
+- CLAUDE.md = bootstrap (identity, profile, format, autonomy, project atlas)
+- MCP instructions field = tool-coupled behavioral rules
+- nexo_context_packet = on-demand area-specific context
+
+The MCP server now carries all tool-coupled rules in its `instructions` field,
+so CLAUDE.md no longer needs to duplicate them. This reduces CLAUDE.md from
+~130 lines to ~50 lines, saving ~3K context tokens per session.
+
+Safe to run multiple times (idempotent). Creates a backup before modifying.
+
+Usage:
+    python3 migrate-v1.7-to-v1.8.py [--dry-run] [--nexo-home /path/to/nexo]
+"""
+
+import argparse
+import os
+import re
+import shutil
+import sys
+from datetime import datetime
+
+
+# Sections that are now in the MCP instructions field and should be REMOVED from CLAUDE.md
+MCP_OWNED_SECTIONS = [
+    "Heartbeat",
+    "Guard",
+    "Delegation",
+    "Reminders & Followups",
+    "Reminders y Followups",
+    "Memory",
+    "Memoria",
+    "Trust Score",
+    "Adaptive Mode",
+    "Dissonance",
+    "Disonancia",
+    "Observe the User",
+    "Observar a Francisco",  # legacy personal CLAUDE.md files
+    "Observar al Usuario",
+    "Change Log",
+    "Session Diary",
+    "Cortex",
+    "Operational Codex",
+]
+
+# Sections that STAY in CLAUDE.md (bootstrap layer)
+BOOTSTRAP_SECTIONS = [
+    "Startup",
+    "User Profile",
+    "Francisco",  # legacy personal CLAUDE.md files
+    "Formato",
+    "Format",
+    "Autonomy",
+    "Autonomía",
+    "Project Atlas",
+    "Atlas de Proyectos",
+    "Hooks",
+    "Menu",
+    "Platforms",
+    "Plataformas",
+    "Repo",
+]
+
+
+def find_nexo_home(override=None):
+    if override:
+        return override
+    candidates = [
+        os.path.expanduser("~/nexo"),
+        os.path.expanduser("~/.nexo"),
+        os.path.expanduser("~/claude/nexo-mcp"),
+    ]
+    for c in candidates:
+        if os.path.isdir(c):
+            return c
+    return None
+
+
+def find_claude_md():
+    """Find the CLAUDE.md file that contains NEXO instructions."""
+    candidates = [
+        os.path.expanduser("~/.claude/CLAUDE.md"),
+        os.path.expanduser("~/CLAUDE.md"),
+    ]
+    for c in candidates:
+        if os.path.isfile(c):
+            return c
+    return None
+
+
+def parse_sections(content):
+    """Parse markdown into sections by ## headers."""
+    sections = []
+    current_header = None
+    current_lines = []
+
+    for line in content.split("\n"):
+        if line.startswith("## "):
+            if current_header is not None:
+                sections.append((current_header, "\n".join(current_lines)))
+            current_header = line[3:].strip()
+            current_lines = [line]
+        else:
+            current_lines.append(line)
+
+    if current_header is not None:
+        sections.append((current_header, "\n".join(current_lines)))
+    elif current_lines:
+        sections.append(("_preamble", "\n".join(current_lines)))
+
+    return sections
+
+
+def is_mcp_owned(header):
+    """Check if a section header matches an MCP-owned section."""
+    header_lower = header.lower()
+    for section in MCP_OWNED_SECTIONS:
+        if section.lower() in header_lower:
+            return True
+    return False
+
+
+def migrate_claude_md(path, dry_run=False):
+    """Slim down CLAUDE.md by removing MCP-owned sections."""
+    with open(path, "r") as f:
+        content = f.read()
+
+    original_lines = len(content.strip().split("\n"))
+    sections = parse_sections(content)
+
+    # Separate preamble, bootstrap, and MCP-owned sections
+    preamble = ""
+    kept = []
+    removed = []
+
+    for header, body in sections:
+        if header == "_preamble":
+            preamble = body
+        elif is_mcp_owned(header):
+            removed.append(header)
+        else:
+            kept.append((header, body))
+
+    if not removed:
+        print("  CLAUDE.md already migrated (no MCP-owned sections found).")
+        return False
+
+    # Add hybrid architecture note to preamble
+    if "MCP instructions" not in preamble and "instructions" not in preamble:
+        preamble = preamble.rstrip() + (
+            "\nTool-coupled behavioral rules (heartbeat, guard, trust, memory, diary) "
+            "now live in the MCP server instructions field and are injected automatically.\n"
+        )
+
+    # Reconstruct
+    new_content = preamble + "\n"
+    for header, body in kept:
+        new_content += "\n" + body + "\n"
+
+    new_lines = len(new_content.strip().split("\n"))
+
+    print(f"  Sections removed (now in MCP): {', '.join(removed)}")
+    print(f"  Lines: {original_lines} → {new_lines} (saved {original_lines - new_lines})")
+
+    if dry_run:
+        print("  [DRY RUN] No changes written.")
+        return True
+
+    # Backup
+    backup = path + f".backup-{datetime.now().strftime(\"%Y%m%d-%H%M%S\")}"
+    shutil.copy2(path, backup)
+    print(f"  Backup: {backup}")
+
+    with open(path, "w") as f:
+        f.write(new_content)
+    print("  CLAUDE.md updated.")
+    return True
+
+
+def main():
+    parser = argparse.ArgumentParser(description="Migrate NEXO to v1.8 hybrid architecture")
+    parser.add_argument("--dry-run", action="store_true", help="Show what would change without modifying files")
+    parser.add_argument("--nexo-home", help="Override NEXO home directory")
+    args = parser.parse_args()
+
+    print("NEXO v1.7 → v1.8 Migration (Hybrid Architecture)")
+    print("=" * 50)
+    print()
+
+    # Step 1: Find and migrate CLAUDE.md
+    claude_md = find_claude_md()
+    if claude_md:
+        print(f"Found CLAUDE.md: {claude_md}")
+        migrate_claude_md(claude_md, dry_run=args.dry_run)
+    else:
+        print("No CLAUDE.md found (skipping).")
+
+    print()
+    print("Migration complete.")
+    print()
+    print("What changed:")
+    print("  - CLAUDE.md now contains only bootstrap (identity, format, autonomy)")
+    print("  - Tool-coupled rules are in the MCP server instructions field")
+    print("  - Context-specific rules load on-demand via nexo_context_packet")
+    print()
+    print("The MCP server must be restarted for instructions to take effect.")
+
+
+if __name__ == "__main__":
+    main()

package/scripts/pre-commit-check 2.sh

@@ -0,0 +1,55 @@
+#!/bin/bash
+# Pre-commit hook: prevent private data from being committed to the public repo.
+# Installed by nexo-brain or manually: cp scripts/pre-commit-check.sh .git/hooks/pre-commit
+
+RED='\033[0;31m'
+NC='\033[0m'
+
+# Add patterns specific to your private data here.
+# These are checked against staged files to prevent accidental leaks.
+# The pre-commit-check.sh script itself is excluded from scanning.
+BLOCKED_PATTERNS=(
+    # Add your own patterns below, e.g.:
+    # "my-private-api-key"
+    # "my-private-domain.com"
+    # "my-server-ip"
+)
+
+STAGED_FILES=$(git diff --cached --name-only --diff-filter=ACMR)
+
+if [ -z "$STAGED_FILES" ]; then
+    exit 0
+fi
+
+FOUND=0
+for pattern in "${BLOCKED_PATTERNS[@]}"; do
+    MATCHES=$(echo "$STAGED_FILES" | xargs grep -l "$pattern" 2>/dev/null)
+    if [ -n "$MATCHES" ]; then
+        echo -e "${RED}BLOCKED: Found private data pattern '$pattern' in:${NC}"
+        echo "$MATCHES" | sed 's/^/  /'
+        FOUND=1
+    fi
+done
+
+# Also check for .db files, tokens, credentials
+DB_FILES=$(echo "$STAGED_FILES" | grep -E '\.(db|db-wal|db-shm|key|pem)$')
+if [ -n "$DB_FILES" ]; then
+    echo -e "${RED}BLOCKED: Database/key files staged:${NC}"
+    echo "$DB_FILES" | sed 's/^/  /'
+    FOUND=1
+fi
+
+TOKEN_FILES=$(echo "$STAGED_FILES" | grep -E '_token\.|credentials|\.env$')
+if [ -n "$TOKEN_FILES" ]; then
+    echo -e "${RED}BLOCKED: Token/credential files staged:${NC}"
+    echo "$TOKEN_FILES" | sed 's/^/  /'
+    FOUND=1
+fi
+
+if [ $FOUND -eq 1 ]; then
+    echo ""
+    echo -e "${RED}Commit blocked. Remove private data before pushing to public repo.${NC}"
+    exit 1
+fi
+
+exit 0

package/src/auto_close_sessions 2.py

@@ -0,0 +1,159 @@
+#!/usr/bin/env python3
+"""Auto-close orphan sessions and promote diary drafts.
+
+Runs every 5 minutes via LaunchAgent (com.nexo.auto-close-sessions).
+Finds sessions that exceeded TTL without a diary and promotes their
+draft to a real diary entry marked as source=auto-close.
+"""
+
+import json
+import os
+import sys
+import datetime
+
+# Ensure we can import from the source directory
+sys.path.insert(0, os.path.dirname(os.path.abspath(__file__)))
+os.environ["NEXO_SKIP_FS_INDEX"] = "1"  # Skip FTS rebuild on import
+
+from db import (
+    init_db, get_db, get_diary_draft, delete_diary_draft,
+    get_orphan_sessions, write_session_diary, now_epoch,
+    SESSION_STALE_SECONDS,
+)
+
+NEXO_HOME = os.environ.get("NEXO_HOME", os.path.expanduser("~/.nexo"))
+LOG_DIR = os.path.join(NEXO_HOME, "operations", "tool-logs")
+AUTO_CLOSE_LOG = os.path.join(NEXO_HOME, "coordination", "auto-close.log")
+
+
+def get_tool_log_summary(sid: str) -> str:
+    """Extract tool names from today's tool log for this session."""
+    today = datetime.date.today().isoformat()
+    log_path = os.path.join(LOG_DIR, f"{today}.jsonl")
+    if not os.path.exists(log_path):
+        return ""
+
+    tools = []
+    try:
+        with open(log_path) as f:
+            for line in f:
+                try:
+                    entry = json.loads(line)
+                    if entry.get("session_id") == sid:
+                        tool = entry.get("tool_name", "")
+                        if tool and tool not in ("Read", "Grep", "Glob"):
+                            tools.append(tool)
+                except json.JSONDecodeError:
+                    continue
+    except Exception:
+        pass
+
+    if tools:
+        seen = set()
+        unique = []
+        for t in tools:
+            if t not in seen:
+                seen.add(t)
+                unique.append(t)
+        return f"Tools used: {', '.join(unique[-15:])}"
+    return ""
+
+
+def promote_draft_to_diary(sid: str, draft: dict, task: str = ""):
+    """Promote a diary draft to a real session diary entry."""
+    tasks = json.loads(draft.get("tasks_seen", "[]"))
+    change_ids = json.loads(draft.get("change_ids", "[]"))
+    decision_ids = json.loads(draft.get("decision_ids", "[]"))
+    context_hint = draft.get("last_context_hint", "")
+    hb_count = draft.get("heartbeat_count", 0)
+
+    summary_parts = []
+    if draft.get("summary_draft"):
+        summary_parts.append(draft["summary_draft"])
+
+    tool_summary = get_tool_log_summary(sid)
+    if tool_summary:
+        summary_parts.append(tool_summary)
+
+    summary = " | ".join(summary_parts) if summary_parts else f"Auto-closed session ({hb_count} heartbeats)"
+
+    # Build decisions from actual decision records
+    decisions_text = ""
+    if decision_ids:
+        conn = get_db()
+        placeholders = ",".join("?" * len(decision_ids))
+        rows = conn.execute(
+            f"SELECT id, decision, domain FROM decisions WHERE id IN ({placeholders})",
+            decision_ids
+        ).fetchall()
+        if rows:
+            decisions_text = json.dumps([
+                {"id": r["id"], "decision": r["decision"][:100], "domain": r["domain"]}
+                for r in rows
+            ])
+
+    # Build context_next
+    context_next = ""
+    if context_hint:
+        context_next = f"Last topic: {context_hint}"
+    if tasks:
+        context_next += f" | Tasks: {', '.join(tasks[-5:])}"
+
+    write_session_diary(
+        session_id=sid,
+        decisions=decisions_text or "No decisions logged",
+        summary=summary,
+        discarded="",
+        pending=f"Changes: {change_ids}" if change_ids else "",
+        context_next=context_next,
+        mental_state=f"[auto-close] Session ended without explicit diary. Draft promoted. {hb_count} heartbeats recorded.",
+        domain="",
+        user_signals="",
+        self_critique="[auto-close] No self-critique available — session terminated without cleanup.",
+        source="auto-close",
+    )
+    delete_diary_draft(sid)
+
+
+def main():
+    init_db()
+    conn = get_db()
+
+    orphans = get_orphan_sessions(SESSION_STALE_SECONDS)
+    if not orphans:
+        print(f"[{datetime.datetime.now().isoformat(timespec='seconds')}] No stale sessions")
+        return
+
+    for session in orphans:
+        sid = session["sid"]
+        draft = get_diary_draft(sid)
+
+        if draft:
+            promote_draft_to_diary(sid, draft, task=session.get("task", ""))
+        else:
+            write_session_diary(
+                session_id=sid,
+                decisions="No decisions logged",
+                summary=f"Auto-closed session. Task: {session.get('task', 'unknown')}",
+                context_next="",
+                mental_state="[auto-close] No draft available. Minimal diary.",
+                self_critique="[auto-close] Session terminated without diary or draft.",
+                source="auto-close",
+            )
+
+        # Clean up the session
+        conn.execute("DELETE FROM tracked_files WHERE sid = ?", (sid,))
+        conn.execute("DELETE FROM sessions WHERE sid = ?", (sid,))
+        conn.execute("DELETE FROM session_diary_draft WHERE sid = ?", (sid,))
+
+    conn.commit()
+
+    # Log what we did
+    os.makedirs(os.path.dirname(AUTO_CLOSE_LOG), exist_ok=True)
+    with open(AUTO_CLOSE_LOG, "a") as f:
+        ts = datetime.datetime.now().isoformat(timespec="seconds")
+        f.write(f"{ts} — auto-closed {len(orphans)} session(s): {[s['sid'] for s in orphans]}\n")
+
+
+if __name__ == "__main__":
+    main()