nexo-brain 0.1.0

package/src/tools_credentials.py

@@ -0,0 +1,64 @@
+"""Credentials CRUD tools: get, create, update, delete, list."""
+
+from db import create_credential, update_credential, delete_credential, get_credential, list_credentials
+
+
+def handle_credential_get(service: str, key: str = '') -> str:
+    """Retrieve credential(s) including their values. Use for reading secrets."""
+    results = get_credential(service, key if key else None)
+    if not results:
+        target = f"{service}/{key}" if key else service
+        return f"ERROR: No se encontraron credenciales para '{target}'."
+    lines = []
+    for r in results:
+        lines.append(f"CREDENCIAL {r['service']}/{r['key']}:")
+        lines.append(f"  Valor: {r['value']}")
+        notes = r.get("notes") or ""
+        lines.append(f"  Notas: {notes if notes else '—'}")
+    return "\n".join(lines)
+
+
+def handle_credential_create(service: str, key: str, value: str, notes: str = '') -> str:
+    """Create a new credential entry."""
+    result = create_credential(service, key, value, notes)
+    if "error" in result:
+        return f"ERROR: {result['error']}"
+    return f"Credencial {service}/{key} creada."
+
+
+def handle_credential_update(service: str, key: str, value: str = '', notes: str = '') -> str:
+    """Update the value and/or notes of an existing credential."""
+    result = update_credential(
+        service,
+        key,
+        value if value else None,
+        notes if notes else None,
+    )
+    if "error" in result:
+        return f"ERROR: {result['error']}"
+    return f"Credencial {service}/{key} actualizada."
+
+
+def handle_credential_delete(service: str, key: str = '') -> str:
+    """Delete a credential or all credentials for a service."""
+    deleted = delete_credential(service, key if key else None)
+    if not deleted:
+        target = f"{service}/{key}" if key else service
+        return f"ERROR: No se encontraron credenciales para '{target}'."
+    if key:
+        return f"Credencial {service}/{key} eliminada."
+    return f"Todas las credenciales de {service} eliminadas."
+
+
+def handle_credential_list(service: str = '') -> str:
+    """List credential service/key names and notes — values are never shown."""
+    results = list_credentials(service if service else None)
+    label = service if service else "TODAS"
+    if not results:
+        return f"CREDENCIALES {label.upper()}: Sin entradas."
+    lines = [f"CREDENCIALES {label.upper()} ({len(results)}):"]
+    for r in results:
+        notes = r.get("notes") or ""
+        suffix = f" — {notes}" if notes else ""
+        lines.append(f"  {r['service']}/{r['key']}{suffix}")
+    return "\n".join(lines)

package/src/tools_learnings.py

@@ -0,0 +1,180 @@
+"""Learnings CRUD tools: add, search, update, delete, list."""
+
+from db import (create_learning, update_learning, delete_learning, search_learnings,
+                list_learnings, find_similar_learnings, get_db, now_epoch)
+
+VALID_CATEGORIES = {
+    "nexo-ops", "infrastructure", "security", "brain-engine",
+    "api", "database", "frontend", "backend", "devops", "general"
+}
+
+
+def handle_learning_add(category: str, title: str, content: str, reasoning: str = '',
+                        prevention: str = '', applies_to: str = '', review_days: int = 30) -> str:
+    """Add a new learning entry to the specified category.
+
+    Args:
+        category: One of the valid categories
+        title: Short title for the learning
+        content: Full description of what was learned
+        reasoning: WHY this matters — what led to discovering this, what was the context
+        prevention: Concrete rule/check that prevents repeating this mistake
+        applies_to: Files, systems, or areas this learning applies to
+        review_days: Days until this learning should be reviewed again
+    """
+    if category not in VALID_CATEGORIES:
+        valid = ", ".join(sorted(VALID_CATEGORIES))
+        return f"ERROR: Category '{category}' invalid. Valid: {valid}"
+    result = create_learning(
+        category, title, content, reasoning=reasoning
+    )
+    if "error" in result:
+        return f"ERROR: {result['error']}"
+    if prevention or applies_to or review_days > 0:
+        conn = get_db()
+        conn.execute(
+            "UPDATE learnings SET prevention = ?, applies_to = ?, status = COALESCE(status, 'active'), "
+            "review_due_at = ?, updated_at = ? WHERE id = ?",
+            (prevention, applies_to, now_epoch() + (max(1, int(review_days)) * 86400), now_epoch(), result["id"])
+        )
+        conn.commit()
+        result = conn.execute("SELECT * FROM learnings WHERE id = ?", (result["id"],)).fetchone()
+        result = dict(result)
+
+    # Cognitive ingest — embed learning for semantic search
+    new_id = result["id"]
+    try:
+        import cognitive
+        cognitive.ingest(f"{title}: {content}", "learning", f"L{new_id}", title, category)
+    except Exception:
+        pass
+
+    # Similarity check — detect repeated errors
+    matches = find_similar_learnings(new_id, title, content, category)
+    repetition_msg = ""
+    if matches:
+        conn = get_db()
+        for original_id, similarity in matches:
+            conn.execute(
+                "INSERT INTO error_repetitions (new_learning_id, original_learning_id, similarity, area) VALUES (?,?,?,?)",
+                (new_id, original_id, similarity, category)
+            )
+        conn.commit()
+        repetition_msg = f"\n⚠️ REPETITION WARNING: Similar to {len(matches)} existing learning(s): " + \
+            ", ".join(f"#{m[0]} ({m[1]:.0%})" for m in matches[:3])
+
+    meta = []
+    if prevention:
+        meta.append("with prevention")
+    if applies_to:
+        meta.append(f"applies_to={applies_to}")
+    meta_str = f" ({', '.join(meta)})" if meta else ""
+    return f"Learning #{result['id']} added in {category}: {title}{meta_str}{repetition_msg}"
+
+
+def handle_learning_search(query: str, category: str = '') -> str:
+    """Search learnings by query string, optionally filtered by category."""
+    results = search_learnings(query, category if category else None)
+    if not results:
+        return f"No results for '{query}'."
+    lines = [f"RESULTS ({len(results)}):"]
+    for r in results:
+        snippet = r["content"][:100] + "..." if len(r["content"]) > 100 else r["content"]
+        status = r.get("status", "active")
+        review_due = r.get("review_due_at")
+        review_note = f" | review_due={review_due:.0f}" if isinstance(review_due, (int, float)) and review_due else ""
+        lines.append(f"  #{r['id']} [{r['category']}] [{status}] {r['title']}{review_note}")
+        lines.append(f"    {snippet}")
+        if r.get("prevention"):
+            lines.append(f"    Prevention: {r['prevention'][:100]}")
+
+    # Passive rehearsal — strengthen matching cognitive memories
+    try:
+        import cognitive
+        for r in results[:5]:
+            cognitive.rehearse_by_content(f"{r.get('title', '')} {r.get('content', '')[:200]}")
+    except Exception:
+        pass
+
+    return "\n".join(lines)
+
+
+def handle_learning_update(id: int, title: str = '', content: str = '', category: str = '',
+                           reasoning: str = '', prevention: str = '', applies_to: str = '',
+                           status: str = '', review_days: int = 0) -> str:
+    """Update an existing learning, including review metadata."""
+    kwargs = {}
+    if title:
+        kwargs["title"] = title
+    if content:
+        kwargs["content"] = content
+    if category:
+        if category not in VALID_CATEGORIES:
+            valid = ", ".join(sorted(VALID_CATEGORIES))
+            return f"ERROR: Category '{category}' invalid. Valid: {valid}"
+        kwargs["category"] = category
+    if reasoning:
+        kwargs["reasoning"] = reasoning
+    if prevention:
+        kwargs["prevention"] = prevention
+    if applies_to:
+        kwargs["applies_to"] = applies_to
+    if status:
+        kwargs["status"] = status
+    if review_days > 0:
+        kwargs["review_days"] = review_days
+    if not kwargs:
+        return "ERROR: Nothing to update. Provide new fields."
+    basic_kwargs = {k: v for k, v in kwargs.items() if k in {"title", "content", "category", "reasoning"}}
+    result = update_learning(id, **basic_kwargs)
+    if "error" in result:
+        return f"ERROR: {result['error']}"
+    extra_updates = {}
+    if prevention:
+        extra_updates["prevention"] = prevention
+    if applies_to:
+        extra_updates["applies_to"] = applies_to
+    if status:
+        extra_updates["status"] = status
+    if review_days > 0:
+        extra_updates["review_due_at"] = now_epoch() + (max(1, int(review_days)) * 86400)
+    if extra_updates:
+        extra_updates["updated_at"] = now_epoch()
+        set_clause = ", ".join(f"{k} = ?" for k in extra_updates)
+        values = list(extra_updates.values()) + [id]
+        conn = get_db()
+        conn.execute(f"UPDATE learnings SET {set_clause} WHERE id = ?", values)
+        conn.commit()
+    return f"Learning #{id} updated."
+
+
+def handle_learning_delete(id: int) -> str:
+    """Delete a learning entry by ID."""
+    deleted = delete_learning(id)
+    if not deleted:
+        return f"ERROR: Learning #{id} not found."
+    return f"Learning #{id} deleted."
+
+
+def handle_learning_list(category: str = '') -> str:
+    """List all learnings, grouped by category if no filter given."""
+    results = list_learnings(category if category else None)
+    if not results:
+        label = category if category else "ALL"
+        return f"LEARNINGS {label} (0): No entries."
+
+    if category:
+        label = category.upper()
+        lines = [f"LEARNINGS {label} ({len(results)}):"]
+        for r in results:
+            lines.append(f"  #{r['id']} [{r.get('status','active')}] {r['title']}")
+    else:
+        lines = [f"LEARNINGS ALL ({len(results)}):"]
+        current_cat = None
+        for r in results:
+            if r["category"] != current_cat:
+                current_cat = r["category"]
+                lines.append(f"\n  [{current_cat.upper()}]")
+            lines.append(f"    #{r['id']} [{r.get('status','active')}] {r['title']}")
+
+    return "\n".join(lines)

package/src/tools_menu.py

@@ -0,0 +1,208 @@
+"""Menu generator — NEXO operations center."""
+
+from datetime import datetime, timedelta
+import json
+import os
+import subprocess
+import sys
+from pathlib import Path
+from tools_sessions import handle_status
+from tools_reminders import handle_reminders
+from db import get_db
+
+NEXO_HOME = Path(os.environ.get("NEXO_HOME", str(Path.home() / ".nexo")))
+
+
+def _get_date_str() -> str:
+    """Get formatted current date and time."""
+    try:
+        result = subprocess.run(
+            ["date", "+%A %d %B %Y, %H:%M"],
+            capture_output=True, text=True,
+            env={"PATH": "/usr/bin:/bin"}
+        )
+        return result.stdout.strip()
+    except Exception:
+        return datetime.now().strftime("%Y-%m-%d %H:%M")
+
+
+MENU_ITEMS = [
+    ("Projects", [
+        ("1", "Project Status - Review active projects"),
+        ("2", "Infrastructure - Server health check"),
+    ]),
+    ("Advertising", [
+        ("3", "Google Ads - Manage campaigns"),
+        ("4", "Meta Ads - Manage Facebook/Instagram"),
+    ]),
+    ("Analytics & Monitoring", [
+        ("5", "Google Analytics - Review web analytics"),
+        ("6", "Email Review - Review inboxes"),
+    ]),
+    ("Maintenance", [
+        ("7", "Backup - Check backup status"),
+        ("8", "Memory Review - Review pending learnings/decisions"),
+    ]),
+]
+
+
+def _get_dashboard_alerts() -> list[dict]:
+    """Run proactive dashboard and return alerts."""
+    try:
+        script = NEXO_HOME / "scripts" / "nexo-proactive-dashboard.py"
+        if not script.exists():
+            return []
+        result = subprocess.run(
+            [sys.executable, str(script), "--json"],
+            capture_output=True, text=True, timeout=10
+        )
+        if result.stdout.strip():
+            return json.loads(result.stdout)
+    except Exception:
+        pass
+    return []
+
+
+def _get_memory_review_summary() -> dict:
+    """Return counts of due memory reviews."""
+    try:
+        conn = get_db()
+        now_epoch = datetime.now().timestamp()
+        now_iso = datetime.now().isoformat(timespec="seconds")
+        due_learnings = conn.execute(
+            "SELECT COUNT(*) FROM learnings WHERE review_due_at IS NOT NULL AND status != 'superseded' AND review_due_at <= ?",
+            (now_epoch,)
+        ).fetchone()[0]
+        due_decisions = conn.execute(
+            "SELECT COUNT(*) FROM decisions WHERE review_due_at IS NOT NULL AND status != 'reviewed' AND review_due_at <= ?",
+            (now_iso,)
+        ).fetchone()[0]
+        return {
+            "learnings": due_learnings,
+            "decisions": due_decisions,
+            "total": due_learnings + due_decisions,
+        }
+    except Exception:
+        return {"learnings": 0, "decisions": 0, "total": 0}
+
+
+def handle_menu() -> str:
+    """Generate the full operations menu with alerts."""
+    date_str = _get_date_str()
+    W = 56  # inner width
+
+    lines = []
+    lines.append("╔" + "═" * W + "╗")
+    lines.append("║" + "NEXO — OPERATIONS CENTER".center(W) + "║")
+    lines.append("║" + date_str.center(W) + "║")
+    lines.append("╠" + "═" * W + "╣")
+
+    # Proactive dashboard alerts
+    dashboard_alerts = _get_dashboard_alerts()
+    memory_reviews = _get_memory_review_summary()
+    due = handle_reminders("due")
+    has_alerts = dashboard_alerts or memory_reviews["total"] > 0 or (due and "Sin recordatorios" not in due)
+
+    if has_alerts:
+        lines.append("║" + "  PROACTIVE ALERTS".ljust(W) + "║")
+        lines.append("╠" + "═" * W + "╣")
+
+        if dashboard_alerts:
+            for alert in dashboard_alerts[:10]:
+                sev = alert.get("severity", "low")
+                icon = {"high": "!!!", "medium": " ! ", "low": " . "}.get(sev, " . ")
+                text = alert.get("title", "")[:W - 8]
+                lines.append("║" + f"  {icon} {text}".ljust(W) + "║")
+            if len(dashboard_alerts) > 10:
+                more = len(dashboard_alerts) - 10
+                lines.append("║" + f"  ... and {more} more alerts".ljust(W) + "║")
+
+        if memory_reviews["total"] > 0:
+            text = (
+                f"MEMORY: {memory_reviews['total']} reviews pending "
+                f"({memory_reviews['decisions']} decisions, {memory_reviews['learnings']} learnings)"
+            )[:W - 4]
+            lines.append("║" + f"  !  {text}".ljust(W) + "║")
+
+        if due and "Sin recordatorios" not in due:
+            for reminder_line in due.split("\n"):
+                if reminder_line.strip():
+                    truncated = reminder_line[:W - 2]
+                    lines.append("║" + f"  {truncated}".ljust(W) + "║")
+
+        lines.append("╠" + "═" * W + "╣")
+
+    # Menu categories
+    for category, items in MENU_ITEMS:
+        lines.append("║" + f"  {category.upper()}".ljust(W) + "║")
+        lines.append("║" + "─" * W + "║")
+        for num, desc in items:
+            entry = f"  {num:>3}. {desc}"
+            lines.append("║" + entry.ljust(W) + "║")
+        lines.append("╠" + "═" * W + "╣")
+
+    # Backlog: ideas, future projects, undated tasks
+    try:
+        conn = get_db()
+        cutoff = (datetime.now() + timedelta(days=7)).strftime("%Y-%m-%d")
+        no_date = conn.execute(
+            "SELECT id, description, category FROM reminders WHERE status LIKE 'PENDIENTE%' AND (date IS NULL OR date='') ORDER BY category, id"
+        ).fetchall()
+        future = conn.execute(
+            "SELECT id, description, date, category FROM reminders WHERE status LIKE 'PENDIENTE%' AND date > ? ORDER BY date",
+            (cutoff,)
+        ).fetchall()
+        nf_no_date = conn.execute(
+            "SELECT id, description FROM followups WHERE status NOT LIKE 'COMPLETADO%' AND (date IS NULL OR date='') ORDER BY id"
+        ).fetchall()
+
+        if no_date or future or nf_no_date:
+            lines.append("║" + "  BACKLOG / IDEAS / FUTURE".ljust(W) + "║")
+            lines.append("║" + "─" * W + "║")
+
+            if no_date:
+                by_cat = {}
+                for r in no_date:
+                    cat = (r["category"] or "general").capitalize()
+                    by_cat.setdefault(cat, []).append(r)
+                for cat, items in by_cat.items():
+                    lines.append("║" + f"  [{cat}]".ljust(W) + "║")
+                    for r in items:
+                        short = r["description"][:W - 10]
+                        lines.append("║" + f"    {r['id']}: {short}".ljust(W) + "║")
+
+            if future:
+                lines.append("║" + f"  [Scheduled]".ljust(W) + "║")
+                for r in future:
+                    short = r["description"][:W - 18]
+                    lines.append("║" + f"    {r['id']} ({r['date']}): {short}".ljust(W) + "║")
+
+            if nf_no_date:
+                lines.append("║" + f"  [Pending followups]".ljust(W) + "║")
+                for r in nf_no_date:
+                    short = r["description"][:W - 12]
+                    lines.append("║" + f"    {r['id']}: {short}".ljust(W) + "║")
+
+            lines.append("╠" + "═" * W + "╣")
+    except Exception as e:
+        lines.append("║" + f"  ! Backlog error: {e}".ljust(W) + "║")
+        lines.append("╠" + "═" * W + "╣")
+
+    # Active sessions
+    sessions = handle_status()
+    if "Sin sesiones" not in sessions:
+        lines.append("║" + "  ACTIVE SESSIONS".ljust(W) + "║")
+        lines.append("║" + "─" * W + "║")
+        for s_line in sessions.split("\n"):
+            if s_line.strip() and "SESIONES ACTIVAS" not in s_line:
+                truncated = s_line[:W - 2]
+                lines.append("║" + f"  {truncated}".ljust(W) + "║")
+        lines.append("╠" + "═" * W + "╣")
+
+    # Replace last ╠═╣ with bottom border
+    if lines[-1].startswith("╠"):
+        lines[-1] = "╚" + "═" * W + "╝"
+    else:
+        lines.append("╚" + "═" * W + "╝")
+
+    return "\n".join(lines)

package/src/tools_reminders.py

@@ -0,0 +1,80 @@
+"""Reminders and followups reader — reads from SQLite database."""
+
+from db import get_reminders, get_followups
+from datetime import date
+
+
+def _is_due(date_str: str) -> bool:
+    """Check if a date string is today or in the past."""
+    if not date_str:
+        return False
+    try:
+        d = date.fromisoformat(date_str.strip()[:10])
+        return d <= date.today()
+    except (ValueError, IndexError):
+        return False
+
+
+def handle_reminders(filter_type: str = "due") -> str:
+    """Read reminders and followups from SQLite, return relevant ones.
+
+    Args:
+        filter_type: 'due' (vencidos/hoy), 'all' (todos activos), 'followups' (solo followups)
+    """
+    parts = []
+
+    if filter_type in ("due", "all"):
+        r = _format_reminders(filter_type)
+        if r:
+            parts.append(r)
+
+    if filter_type in ("due", "all", "followups"):
+        f = _format_followups(filter_type)
+        if f:
+            parts.append(f)
+
+    result = "\n\n".join(parts)
+    return result if result else "Sin recordatorios pendientes."
+
+
+def _format_reminders(filter_type: str) -> str:
+    """Format reminders from database."""
+    rows = get_reminders(filter_type)
+    if not rows:
+        return ""
+
+    lines = ["RECORDATORIOS:"]
+    for r in rows:
+        rid = r.get("id", "?")
+        fecha = r.get("date") or ""
+        desc = r.get("description", "")
+        status = r.get("status", "")
+        desc = desc.replace("**", "")
+        due_marker = " [VENCIDO]" if _is_due(fecha) else ""
+        fecha_display = f"({fecha})" if fecha else "(—)"
+        lines.append(f"  {rid} {fecha_display}{due_marker} — {desc[:120]}")
+        if "RECURRENTE" in status.upper():
+            lines.append(f"    Estado: {status}")
+
+    return "\n".join(lines)
+
+
+def _format_followups(filter_type: str) -> str:
+    """Format followups from database."""
+    rows = get_followups(filter_type)
+    if not rows:
+        return ""
+
+    lines = ["FOLLOWUPS NEXO:"]
+    for r in rows:
+        nfid = r.get("id", "?")
+        fecha = r.get("date") or ""
+        desc = r.get("description", "")
+        desc = desc.replace("**", "")
+        due_marker = " [VENCIDO]" if _is_due(fecha) else ""
+        fecha_display = f"({fecha})" if fecha else "(—)"
+        rec = r.get("recurrence") or ""
+        rec_tag = f" [♻️ {rec}]" if rec else ""
+        lines.append(f"  {nfid} {fecha_display}{due_marker}{rec_tag} — {desc[:120]}")
+
+    return "\n".join(lines)