nexo-brain 2.3.0 → 2.3.2

package/src/scripts/nexo-synthesis 2.py

@@ -1,253 +0,0 @@
-#!/usr/bin/env python3
-"""
-NEXO Synthesis Engine v2 — Daily intelligence brief.
-
-Before: ~400 lines of Python concatenating SQL results into markdown sections.
-Now: Collects raw data, passes to Claude CLI (sonnet) which synthesizes
-with real understanding of what matters for tomorrow.
-
-Runs every 2 hours via LaunchAgent. Executes ONCE per day (internal gate).
-"""
-
-import fcntl
-import json
-import os
-import sqlite3
-import subprocess
-import sys
-from datetime import datetime, date, timedelta
-from pathlib import Path
-
-HOME = Path.home()
-NEXO_HOME = Path(os.environ.get("NEXO_HOME", str(Path.home() / ".nexo")))
-CLAUDE_DIR = NEXO_HOME
-COORD_DIR = CLAUDE_DIR / "coordination"
-NEXO_DB = NEXO_HOME / "data" / "nexo.db"
-OUTPUT_FILE = COORD_DIR / "daily-synthesis.md"
-LAST_RUN_FILE = COORD_DIR / "synthesis-last-run"
-LOCK_FILE = COORD_DIR / "synthesis.lock"
-CLAUDE_CLI = HOME / ".local" / "bin" / "claude"
-
-TODAY = date.today()
-TODAY_STR = TODAY.isoformat()
-
-
-def log(msg: str):
-    ts = datetime.now().strftime("%H:%M:%S")
-    print(f"[{ts}] {msg}", flush=True)
-
-
-def should_run() -> bool:
-    if LAST_RUN_FILE.exists():
-        return LAST_RUN_FILE.read_text().strip() != TODAY_STR
-    return True
-
-
-def mark_done():
-    LAST_RUN_FILE.write_text(TODAY_STR)
-
-
-def acquire_lock():
-    lock_fd = open(LOCK_FILE, "w")
-    try:
-        fcntl.flock(lock_fd, fcntl.LOCK_EX | fcntl.LOCK_NB)
-        return lock_fd
-    except BlockingIOError:
-        log("Another instance running. Exiting.")
-        sys.exit(0)
-
-
-def release_lock(lock_fd):
-    fcntl.flock(lock_fd, fcntl.LOCK_UN)
-    lock_fd.close()
-    LOCK_FILE.unlink(missing_ok=True)
-
-
-def safe_query(sql: str, params=()) -> list:
-    if not NEXO_DB.exists():
-        return []
-    try:
-        conn = sqlite3.connect(str(NEXO_DB))
-        conn.row_factory = sqlite3.Row
-        rows = [dict(r) for r in conn.execute(sql, params).fetchall()]
-        conn.close()
-        return rows
-    except Exception as e:
-        log(f"Query error: {e}")
-        return []
-
-
-def collect_data() -> dict:
-    """Collect all raw data for synthesis."""
-    data = {"date": TODAY_STR}
-
-    # Today's learnings
-    data["learnings"] = safe_query(
-        "SELECT category, title, content, reasoning FROM learnings "
-        "WHERE date(created_at, 'unixepoch') = ? ORDER BY created_at DESC",
-        (TODAY_STR,)
-    )
-
-    # Today's decisions
-    data["decisions"] = safe_query(
-        "SELECT domain, decision, alternatives, based_on, outcome FROM decisions "
-        "WHERE date(created_at) = ? ORDER BY created_at DESC",
-        (TODAY_STR,)
-    )
-
-    # Today's changes
-    data["changes"] = safe_query(
-        "SELECT files, what_changed, why, affects, risks FROM change_log "
-        "WHERE date(created_at) = ? ORDER BY created_at DESC",
-        (TODAY_STR,)
-    )
-
-    # Session diaries (summaries + mental_state)
-    data["diaries"] = safe_query(
-        "SELECT summary, self_critique, mental_state, user_signals FROM session_diary "
-        "WHERE date(created_at) = ? ORDER BY created_at DESC",
-        (TODAY_STR,)
-    )
-
-    # Overdue reminders
-    data["overdue_reminders"] = safe_query(
-        "SELECT id, title, due_date FROM reminders "
-        "WHERE status='PENDING' AND due_date <= ? ORDER BY due_date",
-        (TODAY_STR,)
-    )
-
-    # Pending followups
-    data["pending_followups"] = safe_query(
-        "SELECT id, title, description, due_date FROM followups "
-        "WHERE status='pending' ORDER BY due_date"
-    )
-
-    # Guard stats
-    data["guard_stats"] = safe_query(
-        "SELECT category, COUNT(*) as cnt FROM learnings WHERE status='active' "
-        "GROUP BY category ORDER BY cnt DESC LIMIT 10"
-    )
-
-    # Postmortem daily (if exists)
-    pm_file = COORD_DIR / "postmortem-daily.md"
-    if pm_file.exists():
-        data["postmortem_summary"] = pm_file.read_text()[:2000]
-
-    return data
-
-
-def synthesize(data: dict) -> bool:
-    """CLI synthesizes the daily brief."""
-
-    data_json = json.dumps(data, ensure_ascii=False, indent=1)
-    if len(data_json) > 15000:
-        data_json = data_json[:15000] + "\n... (truncated)"
-
-    prompt = f"""FIRST: Call nexo_startup(task='daily synthesis') to register this session.
-
-You are NEXO's synthesis engine. Write the daily intelligence brief for tomorrow's
-startup. This file is read by NEXO at the beginning of each session to understand
-what happened today and what to focus on tomorrow. Use nexo_learning_add and nexo_followup_create if you discover actionable items.
-
-TODAY'S RAW DATA:
-{data_json}
-
-Write the synthesis to {OUTPUT_FILE} with this structure:
-
-# NEXO Daily Synthesis — {TODAY_STR}
-
-## Errors & Learnings
-[New learnings from today — what went wrong, what was learned]
-
-## Decisions Made
-[Key decisions and their reasoning]
-
-## Changes Deployed
-[What was changed in production today]
-
-## the user — Observations
-[Patterns in the user's behavior: frustrations, pending decisions, ideas without
-deadlines, topics he started but didn't close. This is NEXO's peripheral vision.]
-
-## Weak Points (self-assessment)
-[Where NEXO failed or could have done better today — from session diaries]
-
-## Tomorrow's Context
-[What the next session needs to know: pending followups, overdue reminders,
-in-progress tasks, things to verify]
-
-## Guard Status
-[Areas with most learnings — where errors concentrate]
-
-Be concise. Each section 3-8 bullet points max. Focus on what CHANGES BEHAVIOR,
-not what merely happened. If a section has nothing, write "Nothing notable."
-
-Execute without asking."""
-
-    log("Invoking Claude CLI (opus) for synthesis...")
-    env = os.environ.copy()
-    env["NEXO_HEADLESS"] = "1"  # Skip stop hook post-mortem
-    env.pop("CLAUDECODE", None)
-    env.pop("CLAUDE_CODE", None)
-
-    try:
-        result = subprocess.run(
-            [str(CLAUDE_CLI), "-p", prompt, "--model", "opus",
-             "--output-format", "text",
-             "--allowedTools", "Read,Write,Edit,Glob,Grep,Bash,mcp__nexo__*"],
-            capture_output=True, text=True, timeout=21600, env=env
-        )
-
-        if result.returncode != 0:
-            log(f"CLI error ({result.returncode}): {(result.stderr or '')[:300]}")
-            return False
-
-        log(f"Synthesis complete. Output: {len(result.stdout or '')} chars")
-        return True
-
-    except subprocess.TimeoutExpired:
-        log("CLI timed out (180s)")
-        return False
-    except Exception as e:
-        log(f"Exception: {e}")
-        return False
-
-
-def main():
-    if not should_run():
-        log(f"Already ran today ({TODAY_STR}). Skipping.")
-        return
-
-    lock_fd = acquire_lock()
-    try:
-        log(f"=== NEXO Synthesis v2 — {TODAY_STR} ===")
-
-        data = collect_data()
-        log(f"Collected: {len(data.get('learnings', []))} learnings, "
-            f"{len(data.get('decisions', []))} decisions, "
-            f"{len(data.get('changes', []))} changes, "
-            f"{len(data.get('diaries', []))} diaries")
-
-        success = synthesize(data)
-
-        if success:
-            mark_done()
-            log("Synthesis v2 complete.")
-        else:
-            log("Synthesis failed — will retry next trigger.")
-
-        # Register for catch-up
-        try:
-            state_file = NEXO_HOME / "operations" / ".catchup-state.json"
-            st = json.loads(state_file.read_text()) if state_file.exists() else {}
-            st["synthesis"] = datetime.now().isoformat()
-            state_file.write_text(json.dumps(st, indent=2))
-        except Exception:
-            pass
-
-    finally:
-        release_lock(lock_fd)
-
-
-if __name__ == "__main__":
-    main()

package/src/scripts/nexo-tcc-approve 2.sh

@@ -1,79 +0,0 @@
-#!/bin/bash
-# NEXO TCC Auto-Approve — grants macOS permissions to new Claude Code versions.
-#
-# macOS only. On Linux this is a no-op (Linux doesn't have TCC).
-# Runs at load to approve any new Claude versions that appeared.
-#
-# What it does:
-#   1. Scans ~/.local/share/claude/versions/ for Claude binaries
-#   2. For each new version, grants TCC access to Documents, Desktop, Downloads, etc.
-#   3. Also approves the Python binary used by NEXO's venv
-#   4. Tracks which versions have been approved to avoid re-processing
-#
-# Why: Claude Code updates frequently. Each new binary needs macOS permission
-# grants or the user gets popup dialogs interrupting their work.
-
-set -euo pipefail
-
-# Linux: nothing to do
-if [ "$(uname -s)" != "Darwin" ]; then
-    exit 0
-fi
-
-NEXO_HOME="${NEXO_HOME:-$HOME/.nexo}"
-TCC_DB="$HOME/Library/Application Support/com.apple.TCC/TCC.db"
-VERSIONS_DIR="$HOME/.local/share/claude/versions"
-MARKER_DIR="$NEXO_HOME/data/.tcc-approved"
-LOG="$NEXO_HOME/logs/tcc-auto-approve.log"
-
-mkdir -p "$MARKER_DIR" "$(dirname "$LOG")"
-
-# TCC services Claude Code needs
-SERVICES=(
-    kTCCServiceSystemPolicyDocumentsFolder
-    kTCCServiceSystemPolicyDesktopFolder
-    kTCCServiceSystemPolicyDownloadsFolder
-    kTCCServiceMediaLibrary
-    kTCCServiceSystemPolicyNetworkVolumes
-    kTCCServiceSystemPolicyAppData
-    kTCCServiceFileProviderDomain
-)
-
-# Approve Claude versions
-if [ -d "$VERSIONS_DIR" ]; then
-    for bin_path in "$VERSIONS_DIR"/*; do
-        [ ! -e "$bin_path" ] && continue
-        version=$(basename "$bin_path")
-        marker="$MARKER_DIR/$version"
-
-        # Skip if already approved
-        [ -f "$marker" ] && continue
-
-        echo "$(date '+%Y-%m-%d %H:%M:%S') Approving Claude $version" >> "$LOG"
-
-        for svc in "${SERVICES[@]}"; do
-            sqlite3 "$TCC_DB" "
-            INSERT OR REPLACE INTO access (service, client, client_type, auth_value, auth_reason, auth_version)
-            VALUES ('$svc', '$bin_path', 1, 2, 4, 1);
-            " 2>/dev/null
-        done
-
-        touch "$marker"
-        echo "$(date '+%Y-%m-%d %H:%M:%S') Done: Claude $version — ${#SERVICES[@]} services approved" >> "$LOG"
-    done
-fi
-
-# Also approve Python from NEXO's venv (if it exists)
-NEXO_CODE="${NEXO_CODE:-}"
-if [ -n "$NEXO_CODE" ]; then
-    PYTHON_BIN="$(dirname "$NEXO_CODE")/.venv/bin/python"
-    if [ -e "$PYTHON_BIN" ]; then
-        PYTHON_REAL=$(readlink -f "$PYTHON_BIN" 2>/dev/null || echo "$PYTHON_BIN")
-        for svc in "${SERVICES[@]}"; do
-            sqlite3 "$TCC_DB" "
-            INSERT OR REPLACE INTO access (service, client, client_type, auth_value, auth_reason, auth_version)
-            VALUES ('$svc', '$PYTHON_REAL', 1, 2, 4, 1);
-            " 2>/dev/null
-        done
-    fi
-fi

package/src/scripts/nexo-update 2.sh

@@ -1,161 +0,0 @@
-#!/usr/bin/env bash
-# nexo-update.sh — Standalone NEXO update script
-# Same logic as the MCP tool but usable when the server itself needs updating.
-#
-# Usage:
-#   nexo-update.sh                    # pull from origin main
-#   nexo-update.sh origin beta        # pull from origin beta
-#   NEXO_HOME=/path nexo-update.sh    # custom NEXO_HOME
-
-set -euo pipefail
-
-# --- Configuration ---
-REMOTE="${1:-origin}"
-BRANCH="${2:-main}"
-NEXO_HOME="${NEXO_HOME:-$HOME/.nexo}"
-
-# Determine repo directory: script is at src/scripts/, repo root is ../../
-SCRIPT_DIR="$(cd "$(dirname "$0")" && pwd)"
-REPO_DIR="$(cd "$SCRIPT_DIR/../.." && pwd)"
-SRC_DIR="$REPO_DIR/src"
-PACKAGE_JSON="$REPO_DIR/package.json"
-
-# --- Helpers ---
-RED='\033[0;31m'
-GREEN='\033[0;32m'
-YELLOW='\033[1;33m'
-NC='\033[0m'
-
-log()  { echo -e "${GREEN}[nexo-update]${NC} $*"; }
-warn() { echo -e "${YELLOW}[nexo-update]${NC} $*"; }
-err()  { echo -e "${RED}[nexo-update]${NC} $*" >&2; }
-
-read_version() {
-    python3 -c "import json; print(json.load(open('$PACKAGE_JSON')).get('version','unknown'))" 2>/dev/null || echo "unknown"
-}
-
-# --- Step 1: Check for uncommitted changes in src/ ---
-log "Checking for uncommitted changes in src/..."
-cd "$REPO_DIR"
-
-if [ -n "$(git status --porcelain -- src/ 2>/dev/null)" ]; then
-    err "ABORTED: Uncommitted changes in src/"
-    git status --short -- src/
-    exit 1
-fi
-log "Working tree clean."
-
-# Record current state
-OLD_VERSION="$(read_version)"
-OLD_COMMIT="$(git rev-parse HEAD)"
-log "Current: v${OLD_VERSION} (${OLD_COMMIT:0:8})"
-
-# --- Step 2: Backup databases ---
-TIMESTAMP="$(date +%Y-%m-%d-%H%M)"
-BACKUP_DIR="$NEXO_HOME/backups/pre-update-$TIMESTAMP"
-
-backup_dbs() {
-    local found=0
-    # Check data/, NEXO_HOME root, and src/ for .db files
-    for dir in "$NEXO_HOME/data" "$NEXO_HOME" "$SRC_DIR"; do
-        if [ -d "$dir" ]; then
-            for db in "$dir"/*.db; do
-                [ -f "$db" ] || continue
-                found=1
-                mkdir -p "$BACKUP_DIR"
-                cp "$db" "$BACKUP_DIR/$(basename "$db")"
-                log "  Backed up: $(basename "$db")"
-            done
-        fi
-    done
-    if [ "$found" -eq 0 ]; then
-        log "  No databases found to backup."
-    fi
-}
-
-log "Backing up databases..."
-backup_dbs
-
-# --- Step 3: git pull ---
-log "Pulling from ${REMOTE}/${BRANCH}..."
-PULL_OUTPUT="$(git pull "$REMOTE" "$BRANCH" 2>&1)" || {
-    err "git pull failed:"
-    err "$PULL_OUTPUT"
-    exit 1
-}
-log "$PULL_OUTPUT"
-
-if echo "$PULL_OUTPUT" | grep -q "Already up to date"; then
-    log "Already up to date (v${OLD_VERSION}). Done."
-    exit 0
-fi
-
-# --- Step 4: Check version ---
-NEW_VERSION="$(read_version)"
-log "New version: v${NEW_VERSION}"
-
-# --- Step 5: Run migrations if version changed ---
-if [ "$OLD_VERSION" != "$NEW_VERSION" ]; then
-    log "Version changed: ${OLD_VERSION} -> ${NEW_VERSION}"
-    log "Running migrations..."
-    if ! (cd "$SRC_DIR" && python3 -c "import db; db.init_db()" 2>&1); then
-        err "Migration failed! Rolling back..."
-        git reset --hard "$OLD_COMMIT"
-        # Restore DB backups
-        if [ -d "$BACKUP_DIR" ]; then
-            for db in "$BACKUP_DIR"/*.db; do
-                [ -f "$db" ] || continue
-                BASENAME="$(basename "$db")"
-                for candidate in "$NEXO_HOME/data/$BASENAME" "$NEXO_HOME/$BASENAME" "$SRC_DIR/$BASENAME"; do
-                    if [ -f "$candidate" ]; then
-                        cp "$db" "$candidate"
-                        warn "  Restored: $BASENAME"
-                        break
-                    fi
-                done
-            done
-        fi
-        err "Rolled back to ${OLD_COMMIT:0:8}. Databases restored."
-        exit 1
-    fi
-    log "Migrations applied."
-else
-    log "Version unchanged (${OLD_VERSION}), skipping migrations."
-fi
-
-# --- Step 6: Verify import ---
-log "Verifying server.py import..."
-if ! (cd "$SRC_DIR" && python3 -c "import server" 2>&1); then
-    err "Import verification failed! Rolling back..."
-    git reset --hard "$OLD_COMMIT"
-    if [ -d "$BACKUP_DIR" ]; then
-        for db in "$BACKUP_DIR"/*.db; do
-            [ -f "$db" ] || continue
-            BASENAME="$(basename "$db")"
-            for candidate in "$NEXO_HOME/data/$BASENAME" "$NEXO_HOME/$BASENAME" "$SRC_DIR/$BASENAME"; do
-                if [ -f "$candidate" ]; then
-                    cp "$db" "$candidate"
-                    warn "  Restored: $BASENAME"
-                    break
-                fi
-            done
-        done
-    fi
-    err "Rolled back to ${OLD_COMMIT:0:8}. Databases restored."
-    exit 1
-fi
-
-# --- Done ---
-echo ""
-log "========================================="
-log " UPDATE SUCCESSFUL"
-if [ "$OLD_VERSION" != "$NEW_VERSION" ]; then
-    log " Version: ${OLD_VERSION} -> ${NEW_VERSION}"
-else
-    log " Version: ${OLD_VERSION} (unchanged)"
-fi
-log " Branch: ${REMOTE}/${BRANCH}"
-log " Backup: ${BACKUP_DIR}"
-log "========================================="
-echo ""
-warn "MCP server restart needed to load new code."