nexo-brain 2.2.0 → 2.3.1

package/src/scripts/nexo-inbox-hook 2.sh

@@ -1,74 +0,0 @@
-#!/bin/bash
-# nexo-inbox-hook.sh — PostToolUse: automatic inter-terminal inbox check (D+)
-#
-# Zero output when no messages = zero tokens consumed in Claude's context.
-# Reads SQLite directly (no MCP overhead). Write-only: INSERT OR IGNORE for mark-as-read.
-# Debounce: skips if last check was <2 seconds ago.
-
-INPUT=$(cat)
-
-# 1. Skip read-only tools (same logic as capture-tool-logs.sh)
-TOOL_NAME=$(echo "$INPUT" | python3 -c "import sys,json; print(json.load(sys.stdin).get('tool_name',''))" 2>/dev/null)
-case "$TOOL_NAME" in
-    Read|Grep|Glob|LS|Skill|ToolSearch|Agent) exit 0 ;;
-esac
-
-# 2. Extract Claude Code session_id
-CLAUDE_SID=$(echo "$INPUT" | python3 -c "import sys,json; print(json.load(sys.stdin).get('session_id',''))" 2>/dev/null)
-[ -z "$CLAUDE_SID" ] && exit 0
-
-# 3. Debounce: skip if last check <2s ago
-DEBOUNCE_FILE="/tmp/nexo-inbox-ts-${CLAUDE_SID}"
-NOW=$(date +%s)
-LAST=$(cat "$DEBOUNCE_FILE" 2>/dev/null || echo 0)
-DIFF=$((NOW - LAST))
-[ "$DIFF" -lt 2 ] && exit 0
-echo "$NOW" > "$DEBOUNCE_FILE"
-
-# 4. Find NEXO SID mapped to this Claude session_id
-NEXO_HOME="${NEXO_HOME:-$HOME/.nexo}"
-DB="$NEXO_HOME/data/nexo.db"
-[ -f "$DB" ] || exit 0
-
-NEXO_SID=$(sqlite3 "$DB" "SELECT sid FROM sessions WHERE claude_session_id = '${CLAUDE_SID}' AND last_update_epoch > (strftime('%s','now') - 900) ORDER BY last_update_epoch DESC LIMIT 1;" 2>/dev/null)
-[ -z "$NEXO_SID" ] && exit 0
-
-# 5. Check inbox — messages addressed to this session or broadcast
-MESSAGES=$(sqlite3 -separator '|' "$DB" "
-    SELECT m.id, m.from_sid, m.text FROM messages m
-    WHERE (m.to_sid = 'all' OR m.to_sid = '${NEXO_SID}')
-    AND m.from_sid != '${NEXO_SID}'
-    AND m.id NOT IN (SELECT message_id FROM message_reads WHERE sid = '${NEXO_SID}')
-    LIMIT 5;
-" 2>/dev/null)
-
-# 6. Check pending questions
-QUESTIONS=$(sqlite3 -separator '|' "$DB" "
-    SELECT qid, from_sid, question FROM questions
-    WHERE to_sid = '${NEXO_SID}' AND answer IS NULL
-    LIMIT 3;
-" 2>/dev/null)
-
-# 7. If empty → silent exit (0 tokens consumed)
-[ -z "$MESSAGES" ] && [ -z "$QUESTIONS" ] && exit 0
-
-# 8. Format and output (injected into Claude's context)
-echo ""
-echo "📨 INTER-TERMINAL MESSAGE (auto-detected):"
-
-if [ -n "$MESSAGES" ]; then
-    echo "$MESSAGES" | while IFS='|' read -r mid from text; do
-        echo "  [$from]: $text"
-        # Mark as read (lightweight INSERT, WAL mode, no lock contention)
-        sqlite3 "$DB" "INSERT OR IGNORE INTO message_reads (message_id, sid) VALUES ('${mid}', '${NEXO_SID}');" 2>/dev/null
-    done
-fi
-
-if [ -n "$QUESTIONS" ]; then
-    echo "  ⚠ PREGUNTAS de otra terminal — responder con nexo_answer:"
-    echo "$QUESTIONS" | while IFS='|' read -r qid from question; do
-        echo "  Q[$qid] de [$from]: $question"
-    done
-fi
-
-exit 0

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

@@ -1,6 +0,0 @@
-#!/usr/bin/env python3
-"""DEPRECATED: Use 'npx nexo-brain' instead. This installer is no longer maintained."""
-import sys
-print("This installer is deprecated. Please use: npx nexo-brain")
-print("See: https://github.com/wazionapps/nexo#installation")
-sys.exit(1)

package/src/scripts/nexo-learning-housekeep 2.py

@@ -1,245 +0,0 @@
-#!/usr/bin/env python3
-"""NEXO Learning Housekeeping — Nightly dedup, weight adjustment, and review.
-
-Runs daily. Adjusts learning weights based on usage (guard_hits),
-detects duplicates via semantic similarity, and archives stale learnings.
-"""
-
-import json
-import os
-import sqlite3
-import sys
-import time
-from datetime import datetime, timedelta
-from pathlib import Path
-
-NEXO_HOME = Path(os.environ.get("NEXO_HOME", str(Path.home() / ".nexo")))
-# Auto-detect: if running from repo (src/scripts/), use src/ as NEXO_CODE
-_script_dir = Path(__file__).resolve().parent
-_repo_src = _script_dir.parent  # src/scripts/ -> src/
-NEXO_CODE = Path(os.environ.get("NEXO_CODE", str(_repo_src) if (_repo_src / "server.py").exists() else str(NEXO_HOME)))
-
-sys.path.insert(0, str(NEXO_CODE))
-
-DB_PATH = NEXO_HOME / "data" / "nexo.db"
-STATE_FILE = NEXO_HOME / "operations" / ".catchup-state.json"
-
-# Weight adjustment rates
-GUARD_HIT_BOOST = 0.02       # per guard hit since last run
-DECAY_RATE = 0.005            # daily decay for unused learnings
-MIN_WEIGHT = 0.05
-MAX_WEIGHT = 1.0
-DEDUP_THRESHOLD = 0.85        # cosine similarity for duplicate detection
-ARCHIVE_AFTER_DAYS = 90       # archive if weight < 0.1 and no hits in this many days
-
-
-def get_db():
-    conn = sqlite3.connect(str(DB_PATH))
-    conn.row_factory = sqlite3.Row
-    return conn
-
-
-def update_catchup_state():
-    try:
-        state = json.loads(STATE_FILE.read_text()) if STATE_FILE.exists() else {}
-    except Exception:
-        state = {}
-    state["learning-housekeep"] = datetime.now().isoformat()
-    STATE_FILE.parent.mkdir(parents=True, exist_ok=True)
-    STATE_FILE.write_text(json.dumps(state, indent=2))
-
-
-def adjust_weights(conn):
-    """Boost weight for frequently-used learnings, decay unused ones."""
-    ts = datetime.now().strftime("%Y-%m-%d %H:%M:%S")
-    now = time.time()
-    one_day_ago = now - 86400
-
-    learnings = conn.execute(
-        "SELECT id, weight, guard_hits, last_guard_hit_at, priority, created_at "
-        "FROM learnings WHERE status = 'active'"
-    ).fetchall()
-
-    adjusted = 0
-    for l in learnings:
-        old_weight = l["weight"] or 0.5
-        hits = l["guard_hits"] or 0
-        last_hit = l["last_guard_hit_at"] or 0
-        priority = l["priority"] or "medium"
-
-        # Priority floor — critical learnings never drop below 0.5
-        priority_floor = {"critical": 0.5, "high": 0.3, "medium": 0.1, "low": 0.05}[priority]
-
-        new_weight = old_weight
-
-        if last_hit > one_day_ago:
-            # Recent guard hit — boost
-            recent_hits = 1  # Simplified: at least 1 hit today
-            new_weight = min(MAX_WEIGHT, old_weight + (GUARD_HIT_BOOST * recent_hits))
-        else:
-            # No recent hits — decay
-            new_weight = max(priority_floor, old_weight - DECAY_RATE)
-
-        new_weight = max(MIN_WEIGHT, min(MAX_WEIGHT, new_weight))
-
-        if abs(new_weight - old_weight) > 0.001:
-            conn.execute("UPDATE learnings SET weight = ? WHERE id = ?", (round(new_weight, 4), l["id"]))
-            adjusted += 1
-
-    conn.commit()
-    print(f"[{ts}] Weight adjustment: {adjusted}/{len(learnings)} learnings adjusted")
-    return adjusted
-
-
-def auto_prioritize(conn):
-    """Auto-upgrade priority based on guard hits and repetitions."""
-    ts = datetime.now().strftime("%Y-%m-%d %H:%M:%S")
-
-    # Learnings with 10+ guard hits that are still medium → upgrade to high
-    upgraded = conn.execute(
-        "UPDATE learnings SET priority = 'high', weight = MAX(weight, 0.7) "
-        "WHERE status = 'active' AND priority = 'medium' AND guard_hits >= 10"
-    ).rowcount
-
-    # Learnings with repetitions (same error happened again) → upgrade to high
-    repeated = conn.execute(
-        """UPDATE learnings SET priority = 'high', weight = MAX(weight, 0.7)
-           WHERE status = 'active' AND priority IN ('medium', 'low')
-           AND id IN (SELECT original_learning_id FROM error_repetitions)"""
-    ).rowcount
-
-    conn.commit()
-    total = upgraded + repeated
-    if total > 0:
-        print(f"[{ts}] Auto-prioritize: {upgraded} by guard_hits, {repeated} by repetitions")
-    return total
-
-
-def detect_duplicates(conn):
-    """Find semantically similar learnings using fastembed."""
-    ts = datetime.now().strftime("%Y-%m-%d %H:%M:%S")
-    try:
-        from fastembed import TextEmbedding
-        import numpy as np
-    except ImportError:
-        print(f"[{ts}] Dedup skipped: fastembed not available")
-        return []
-
-    learnings = conn.execute(
-        "SELECT id, title, content, weight, guard_hits FROM learnings WHERE status = 'active'"
-    ).fetchall()
-
-    if len(learnings) < 2:
-        return []
-
-    model = TextEmbedding("BAAI/bge-base-en-v1.5")
-    texts = [f"{l['title']}: {l['content'][:300]}" for l in learnings]
-    embeddings = list(model.embed(texts))
-    embeddings = np.array(embeddings)
-
-    # Normalize
-    norms = np.linalg.norm(embeddings, axis=1, keepdims=True)
-    norms[norms == 0] = 1
-    embeddings = embeddings / norms
-
-    duplicates = []
-    for i in range(len(learnings)):
-        for j in range(i + 1, len(learnings)):
-            sim = float(np.dot(embeddings[i], embeddings[j]))
-            if sim >= DEDUP_THRESHOLD:
-                # Keep the one with higher weight/hits
-                a, b = learnings[i], learnings[j]
-                score_a = (a["weight"] or 0.5) + (a["guard_hits"] or 0) * 0.01
-                score_b = (b["weight"] or 0.5) + (b["guard_hits"] or 0) * 0.01
-                keep, drop = (a, b) if score_a >= score_b else (b, a)
-                duplicates.append({
-                    "keep_id": keep["id"], "keep_title": keep["title"],
-                    "drop_id": drop["id"], "drop_title": drop["title"],
-                    "similarity": round(sim, 3)
-                })
-
-    if duplicates:
-        print(f"[{ts}] Duplicates found: {len(duplicates)} pairs (>= {DEDUP_THRESHOLD})")
-        for d in duplicates[:10]:
-            print(f"[{ts}]   [{d['similarity']}] keep #{d['keep_id']} '{d['keep_title'][:40]}', archive #{d['drop_id']} '{d['drop_title'][:40]}'")
-            # Archive the duplicate (don't delete — just mark inactive)
-            conn.execute("UPDATE learnings SET status = 'archived' WHERE id = ?", (d["drop_id"],))
-        conn.commit()
-    else:
-        print(f"[{ts}] No duplicates found ({len(learnings)} learnings scanned)")
-
-    return duplicates
-
-
-def archive_stale(conn):
-    """Archive learnings with very low weight and no recent guard hits."""
-    ts = datetime.now().strftime("%Y-%m-%d %H:%M:%S")
-    cutoff = time.time() - (ARCHIVE_AFTER_DAYS * 86400)
-
-    stale = conn.execute(
-        "SELECT id, title, weight, last_guard_hit_at FROM learnings "
-        "WHERE status = 'active' AND weight < 0.1 AND priority NOT IN ('critical', 'high') "
-        "AND (last_guard_hit_at IS NULL OR last_guard_hit_at < ?)",
-        (cutoff,)
-    ).fetchall()
-
-    if stale:
-        for s in stale:
-            conn.execute("UPDATE learnings SET status = 'archived' WHERE id = ?", (s["id"],))
-            print(f"[{ts}]   Archived #{s['id']} '{s['title'][:50]}' (weight={s['weight']:.2f})")
-        conn.commit()
-        print(f"[{ts}] Archived {len(stale)} stale learnings")
-    else:
-        print(f"[{ts}] No stale learnings to archive")
-
-    return len(stale)
-
-
-def print_summary(conn):
-    """Print summary stats."""
-    ts = datetime.now().strftime("%Y-%m-%d %H:%M:%S")
-    stats = conn.execute(
-        """SELECT
-            COUNT(*) as total,
-            SUM(CASE WHEN status = 'active' THEN 1 ELSE 0 END) as active,
-            SUM(CASE WHEN status = 'archived' THEN 1 ELSE 0 END) as archived,
-            SUM(CASE WHEN priority = 'critical' THEN 1 ELSE 0 END) as critical,
-            SUM(CASE WHEN priority = 'high' THEN 1 ELSE 0 END) as high,
-            SUM(CASE WHEN priority = 'medium' THEN 1 ELSE 0 END) as medium,
-            SUM(CASE WHEN priority = 'low' THEN 1 ELSE 0 END) as low,
-            printf('%.2f', AVG(CASE WHEN status = 'active' THEN weight END)) as avg_weight
-        FROM learnings"""
-    ).fetchone()
-    print(f"[{ts}] Summary: {stats['active']} active, {stats['archived']} archived | "
-          f"Priority: {stats['critical']}C {stats['high']}H {stats['medium']}M {stats['low']}L | "
-          f"Avg weight: {stats['avg_weight']}")
-
-
-def main():
-    ts = datetime.now().strftime("%Y-%m-%d %H:%M:%S")
-    print(f"[{ts}] Learning housekeeping starting...")
-
-    conn = get_db()
-
-    # 1. Adjust weights based on usage
-    adjust_weights(conn)
-
-    # 2. Auto-prioritize based on guard hits and repetitions
-    auto_prioritize(conn)
-
-    # 3. Detect and archive duplicates
-    detect_duplicates(conn)
-
-    # 4. Archive stale learnings
-    archive_stale(conn)
-
-    # 5. Summary
-    print_summary(conn)
-
-    conn.close()
-    update_catchup_state()
-    print(f"[{datetime.now().strftime('%Y-%m-%d %H:%M:%S')}] Done.")
-
-
-if __name__ == "__main__":
-    main()

package/src/scripts/nexo-learning-validator 2.py

@@ -1,207 +0,0 @@
-#!/usr/bin/env python3
-"""
-NEXO Learning Validator — Cross-checks findings against existing learnings.
-
-Wrapper collects the finding + all learnings from SQLite, then passes
-to Claude CLI (opus) to make an intelligent determination of whether
-the finding is known, related, or genuinely new.
-
-Usage as CLI:
-    python3 nexo-learning-validator.py "finding text to validate"
-    python3 nexo-learning-validator.py --category project "finding text"
-
-Usage as library:
-    from nexo_learning_validator import validate_finding
-    result = validate_finding("CRITICAL: message_id column is NULL")
-    if result["known"]:
-        print(f"Already known: {result['matching_learnings']}")
-
-Exit codes:
-    0 = Finding is NEW (not known)
-    1 = Finding is KNOWN (matches existing learning)
-"""
-
-import json
-import os
-import sqlite3
-import subprocess
-import sys
-from pathlib import Path
-
-NEXO_HOME = Path(os.environ.get("NEXO_HOME", str(Path.home() / ".nexo")))
-
-NEXO_DB = NEXO_HOME / "data" / "nexo.db"
-CLAUDE_CLI = Path.home() / ".local" / "bin" / "claude"
-
-
-def get_all_learnings(category: str = None) -> list[dict]:
-    """Fetch all learnings from nexo.db."""
-    conn = sqlite3.connect(str(NEXO_DB), timeout=10)
-    conn.row_factory = sqlite3.Row
-    if category:
-        rows = conn.execute(
-            "SELECT id, category, title, content FROM learnings WHERE category = ?",
-            (category,)
-        ).fetchall()
-    else:
-        rows = conn.execute(
-            "SELECT id, category, title, content FROM learnings"
-        ).fetchall()
-    conn.close()
-    return [dict(r) for r in rows]
-
-
-def validate_finding(finding: str, category: str = None) -> dict:
-    """
-    Validate a finding against existing learnings using Claude CLI.
-
-    Returns:
-        {
-            "known": bool,
-            "confidence": float (0-1),
-            "matching_learnings": [{"id": int, "title": str, "similarity": float}],
-            "recommendation": str
-        }
-    """
-    learnings = get_all_learnings(category)
-
-    if not learnings:
-        return {
-            "known": False,
-            "confidence": 0,
-            "matching_learnings": [],
-            "recommendation": "No learnings in DB — finding is new by default"
-        }
-
-    # Build compact learnings reference for CLI
-    learnings_ref = []
-    for l in learnings:
-        learnings_ref.append({
-            "id": l["id"],
-            "cat": l["category"],
-            "title": l["title"],
-            "content": (l["content"] or "")[:300],
-        })
-
-    prompt = f"""You are a finding deduplication engine. Compare a new finding against existing learnings and determine if it's already known.
-
-NEW FINDING:
-{finding}
-
-EXISTING LEARNINGS ({len(learnings_ref)} total):
-{json.dumps(learnings_ref, indent=1)}
-
-Respond with ONLY valid JSON (no markdown, no code fences):
-{{
-  "known": true/false,
-  "confidence": 0.0-1.0,
-  "matching_learnings": [
-    {{"id": <learning_id>, "title": "<title>", "similarity": 0.0-1.0}}
-  ],
-  "recommendation": "<one line: KNOWN/LIKELY KNOWN/POSSIBLY RELATED/NEW>"
-}}
-
-Rules:
-- confidence >= 0.7 and same root cause = known: true
-- confidence 0.55-0.7 and related topic = known: true, say LIKELY KNOWN
-- confidence < 0.55 = known: false
-- Max 5 matching_learnings, sorted by similarity descending
-- If the finding describes the SAME bug/issue/pattern as a learning, it's known even if worded differently
-- Be strict: different symptoms of different bugs are NOT the same even if they mention the same file"""
-
-    # Try CLI first, fall back to mechanical similarity
-    if CLAUDE_CLI.exists():
-    # Fallback: mechanical SequenceMatcher (original logic)
-    return _mechanical_validate(finding, learnings)
-
-
-def _mechanical_validate(finding: str, learnings: list[dict]) -> dict:
-    """Fallback validation using SequenceMatcher when CLI is unavailable."""
-    from difflib import SequenceMatcher
-
-    threshold = 0.45
-    finding_kw = _extract_keywords(finding)
-    matches = []
-
-    for learning in learnings:
-        title_sim = SequenceMatcher(None, finding.lower(), learning["title"].lower()).ratio()
-        content_sim = SequenceMatcher(None, finding.lower(), (learning["content"] or "").lower()).ratio()
-
-        learning_text = f"{learning['title']} {learning['content'] or ''}"
-        learning_kw = _extract_keywords(learning_text)
-        kw_overlap = len(finding_kw & learning_kw) / len(finding_kw) if finding_kw and learning_kw else 0
-
-        combined = max(title_sim, content_sim) * 0.6 + kw_overlap * 0.4
-
-        if combined >= threshold:
-            matches.append({
-                "id": learning["id"],
-                "category": learning["category"],
-                "title": learning["title"],
-                "similarity": round(combined, 3),
-            })
-
-    matches.sort(key=lambda x: x["similarity"], reverse=True)
-    top = matches[:5]
-
-    if not top:
-        return {"known": False, "confidence": 0, "matching_learnings": [], "recommendation": "NEW finding"}
-
-    best = top[0]["similarity"]
-    if best >= 0.7:
-        return {"known": True, "confidence": best, "matching_learnings": top,
-                "recommendation": f"KNOWN issue (learning #{top[0]['id']})"}
-    elif best >= 0.55:
-        return {"known": True, "confidence": best, "matching_learnings": top,
-                "recommendation": f"LIKELY KNOWN (learning #{top[0]['id']})"}
-    else:
-        return {"known": False, "confidence": best, "matching_learnings": top,
-                "recommendation": "POSSIBLY RELATED but different enough to report"}
-
-
-def _extract_keywords(text: str) -> set:
-    """Extract meaningful keywords from text."""
-    stop_words = {
-        'the', 'a', 'an', 'is', 'are', 'was', 'were', 'be', 'been', 'being',
-        'have', 'has', 'had', 'do', 'does', 'did', 'will', 'would', 'could',
-        'should', 'may', 'might', 'must', 'shall', 'can', 'need', 'dare',
-        'to', 'of', 'in', 'for', 'on', 'with', 'at', 'by', 'from', 'as',
-        'and', 'but', 'or', 'nor', 'not', 'so', 'yet', 'both', 'either',
-        'error', 'critical', 'warning', 'bug', 'issue', 'problem', 'fix',
-        'el', 'la', 'los', 'las', 'un', 'una', 'de', 'en', 'que', 'por',
-    }
-    words = set()
-    for word in text.lower().split():
-        clean = ''.join(c for c in word if c.isalnum() or c == '_')
-        if clean and len(clean) > 2 and clean not in stop_words:
-            words.add(clean)
-    return words
-
-
-def main():
-    import argparse
-    parser = argparse.ArgumentParser(description="Validate findings against existing NEXO learnings")
-    parser.add_argument("finding", help="The finding text to validate")
-    parser.add_argument("--category", "-c", help="Filter learnings by category")
-    parser.add_argument("--json", "-j", action="store_true", help="Output as JSON")
-    args = parser.parse_args()
-
-    result = validate_finding(args.finding, args.category)
-
-    if args.json:
-        print(json.dumps(result, indent=2))
-    else:
-        status = "KNOWN" if result["known"] else "NEW"
-        print(f"Status: {status} (confidence: {result['confidence']:.0%})")
-        print(f"Recommendation: {result['recommendation']}")
-        if result["matching_learnings"]:
-            print(f"Related learnings:")
-            for m in result["matching_learnings"]:
-                cat = m.get('category', '?')
-                print(f"  #{m['id']} [{cat}] {m['title']} ({m['similarity']:.0%})")
-
-    sys.exit(1 if result["known"] else 0)
-
-
-if __name__ == "__main__":
-    main()