nexo-brain 2.3.0 → 2.3.2

package/src/plugins/core_rules 2.py

@@ -1,252 +0,0 @@
-"""Core Rules plugin — query and manage versioned behavioral rules."""
-
-import json
-import os
-
-
-def _get_db():
-    from db import get_db
-    return get_db()
-
-
-def _seed_if_empty():
-    """Seed rules from JSON if table is empty (first run after migration)."""
-    import sys
-    conn = _get_db()
-    try:
-        count = conn.execute("SELECT COUNT(*) FROM core_rules WHERE is_active = 1").fetchone()[0]
-    except Exception:
-        # Table doesn't exist yet — create it
-        conn.execute("""CREATE TABLE IF NOT EXISTS core_rules (
-            id TEXT PRIMARY KEY, category TEXT NOT NULL, rule TEXT NOT NULL,
-            why TEXT NOT NULL, importance INTEGER NOT NULL DEFAULT 3,
-            type TEXT NOT NULL DEFAULT 'advisory', added_in TEXT DEFAULT '',
-            removed_in TEXT DEFAULT NULL, is_active INTEGER NOT NULL DEFAULT 1)""")
-        conn.execute("""CREATE TABLE IF NOT EXISTS core_rules_version (
-            id INTEGER PRIMARY KEY, version TEXT NOT NULL, updated_at TEXT NOT NULL)""")
-        conn.execute("INSERT OR IGNORE INTO core_rules_version (id, version, updated_at) VALUES (1, '0.0.0', datetime('now'))")
-        conn.commit()
-        count = 0
-    if count > 0:
-        return
-
-    rules_file = os.path.join(os.path.dirname(os.path.dirname(os.path.abspath(__file__))),
-                              "rules", "core-rules.json")
-    if not os.path.exists(rules_file):
-        print(f"[core_rules] WARNING: {rules_file} not found, skipping seed", file=sys.stderr)
-        return
-
-    try:
-        with open(rules_file) as f:
-            data = json.load(f)
-
-        version = data["_meta"]["version"]
-        loaded = 0
-        for cat_key, cat in data["categories"].items():
-            for rule in cat["rules"]:
-                conn.execute(
-                    """INSERT OR REPLACE INTO core_rules (id, category, rule, why, importance, type, added_in)
-                       VALUES (?, ?, ?, ?, ?, ?, ?)""",
-                    (rule["id"], cat_key, rule["rule"], rule["why"],
-                     rule["importance"], rule["type"], rule.get("added_in", version))
-                )
-                loaded += 1
-
-        conn.execute("UPDATE core_rules_version SET version = ?, updated_at = datetime('now') WHERE id = 1", (version,))
-        conn.commit()
-        print(f"[core_rules] Seeded {loaded} rules (v{version})", file=sys.stderr)
-    except Exception as e:
-        print(f"[core_rules] ERROR seeding rules: {e}", file=sys.stderr)
-
-
-def handle_rules_check(area: str = "", importance_min: int = 0) -> str:
-    """Get applicable core rules for a given area or action.
-
-    Returns BLOCKING rules that must be followed and ADVISORY rules as guidance.
-    Call this before taking any significant action.
-
-    Args:
-        area: Area of work — 'code', 'delegation', 'communication', 'memory', or empty for all.
-              Maps to categories: code→execution+integrity, delegation→delegation, etc.
-        importance_min: Minimum importance level (1-5, default 0 = all rules)
-    """
-    _seed_if_empty()
-    conn = _get_db()
-
-    area_to_categories = {
-        "code": ("integrity", "execution"),
-        "edit": ("integrity", "execution"),
-        "delegation": ("delegation",),
-        "delegate": ("delegation",),
-        "subagent": ("delegation",),
-        "communication": ("communication",),
-        "respond": ("communication",),
-        "memory": ("memory",),
-        "learn": ("memory",),
-        "proactivity": ("proactivity",),
-        "protect": ("proactivity",),
-    }
-
-    where = "WHERE is_active = 1"
-    params = []
-
-    if area and area.lower() in area_to_categories:
-        cats = area_to_categories[area.lower()]
-        placeholders = ",".join("?" * len(cats))
-        where += f" AND category IN ({placeholders})"
-        params.extend(cats)
-
-    if importance_min > 0:
-        where += " AND importance >= ?"
-        params.append(importance_min)
-
-    rows = conn.execute(
-        f"SELECT id, category, rule, why, importance, type FROM core_rules {where} ORDER BY importance DESC, category, id",
-        params
-    ).fetchall()
-
-    if not rows:
-        return "No rules found for this area."
-
-    # Get version
-    ver = conn.execute("SELECT version FROM core_rules_version WHERE id = 1").fetchone()
-    version = ver[0] if ver else "unknown"
-
-    blocking = [r for r in rows if r["type"] == "blocking"]
-    advisory = [r for r in rows if r["type"] == "advisory"]
-
-    lines = [f"CORE RULES (v{version}) — {len(blocking)} BLOCKING, {len(advisory)} ADVISORY"]
-    if area:
-        lines[0] += f" [area: {area}]"
-    lines.append("")
-
-    if blocking:
-        lines.append("## BLOCKING (must follow)")
-        for r in blocking:
-            lines.append(f"  {r['id']}. {r['rule']}")
-            lines.append(f"     Why: {r['why']}")
-        lines.append("")
-
-    if advisory:
-        lines.append("## ADVISORY (recommended)")
-        for r in advisory:
-            lines.append(f"  {r['id']}. {r['rule']}")
-            lines.append(f"     Why: {r['why']}")
-
-    return "\n".join(lines)
-
-
-def handle_rules_list() -> str:
-    """List all core rules with their status, grouped by category."""
-    _seed_if_empty()
-    conn = _get_db()
-
-    ver = conn.execute("SELECT version FROM core_rules_version WHERE id = 1").fetchone()
-    version = ver[0] if ver else "unknown"
-
-    rows = conn.execute(
-        "SELECT id, category, rule, importance, type, is_active, added_in, removed_in FROM core_rules ORDER BY category, id"
-    ).fetchall()
-
-    lines = [f"CORE RULES v{version} — {len([r for r in rows if r['is_active']])} active, {len([r for r in rows if not r['is_active']])} removed", ""]
-
-    current_cat = None
-    for r in rows:
-        if r["category"] != current_cat:
-            current_cat = r["category"]
-            lines.append(f"### {current_cat.upper()}")
-
-        status = "✓" if r["is_active"] else "✗"
-        tag = "BLOCK" if r["type"] == "blocking" else "ADVSR"
-        lines.append(f"  [{status}] {r['id']} [{tag}] imp={r['importance']} — {r['rule']}")
-        if r["removed_in"]:
-            lines.append(f"       Removed in v{r['removed_in']}")
-
-    return "\n".join(lines)
-
-
-def handle_rules_migrate(dry_run: bool = False) -> str:
-    """Sync core rules from the JSON definition file to the database.
-
-    Adds new rules, marks removed ones as inactive. Safe to run multiple times.
-
-    Args:
-        dry_run: If True, show what would change without applying
-    """
-    conn = _get_db()
-    rules_file = os.path.join(os.path.dirname(os.path.dirname(os.path.abspath(__file__))),
-                              "rules", "core-rules.json")
-    if not os.path.exists(rules_file):
-        return "ERROR: core-rules.json not found"
-
-    with open(rules_file) as f:
-        data = json.load(f)
-
-    new_version = data["_meta"]["version"]
-    ver = conn.execute("SELECT version FROM core_rules_version WHERE id = 1").fetchone()
-    current_version = ver[0] if ver else "0.0.0"
-
-    # Collect all rule IDs from JSON
-    json_ids = set()
-    json_rules = {}
-    for cat_key, cat in data["categories"].items():
-        for rule in cat["rules"]:
-            json_ids.add(rule["id"])
-            json_rules[rule["id"]] = {**rule, "category": cat_key}
-
-    # Collect active IDs from DB
-    db_ids = set()
-    for r in conn.execute("SELECT id FROM core_rules WHERE is_active = 1").fetchall():
-        db_ids.add(r[0])
-
-    added = json_ids - db_ids
-    removed = db_ids - json_ids
-    unchanged = json_ids & db_ids
-
-    lines = [
-        f"RULES MIGRATION: v{current_version} → v{new_version}",
-        f"  Added: {len(added)} — {', '.join(sorted(added)) if added else 'none'}",
-        f"  Removed: {len(removed)} — {', '.join(sorted(removed)) if removed else 'none'}",
-        f"  Unchanged: {len(unchanged)}",
-    ]
-
-    if dry_run:
-        lines.append("  Mode: DRY RUN (no changes applied)")
-        return "\n".join(lines)
-
-    # Apply additions
-    for rid in added:
-        r = json_rules[rid]
-        conn.execute(
-            """INSERT OR REPLACE INTO core_rules (id, category, rule, why, importance, type, added_in, is_active)
-               VALUES (?, ?, ?, ?, ?, ?, ?, 1)""",
-            (r["id"], r["category"], r["rule"], r["why"], r["importance"], r["type"], r.get("added_in", new_version))
-        )
-
-    # Apply removals (soft delete)
-    for rid in removed:
-        conn.execute(
-            "UPDATE core_rules SET is_active = 0, removed_in = ? WHERE id = ?",
-            (new_version, rid)
-        )
-
-    # Update existing rules (content might have changed)
-    for rid in unchanged:
-        r = json_rules[rid]
-        conn.execute(
-            "UPDATE core_rules SET rule = ?, why = ?, importance = ?, type = ?, category = ? WHERE id = ?",
-            (r["rule"], r["why"], r["importance"], r["type"], r["category"], rid)
-        )
-
-    conn.execute("UPDATE core_rules_version SET version = ?, updated_at = datetime('now') WHERE id = 1", (new_version,))
-    conn.commit()
-
-    lines.append("  Status: APPLIED")
-    return "\n".join(lines)
-
-
-TOOLS = [
-    (handle_rules_check, "nexo_rules_check", "Get applicable core rules for an area before acting. Returns BLOCKING and ADVISORY rules."),
-    (handle_rules_list, "nexo_rules_list", "List all core rules with status, grouped by category."),
-    (handle_rules_migrate, "nexo_rules_migrate", "Sync rules from JSON definition to database. Adds new, soft-deletes removed."),
-]

package/src/plugins/cortex 2.py

@@ -1,299 +0,0 @@
-"""Cognitive Cortex plugin — middleware cognitive layer for NEXO Brain.
-
-Provides structured pre-action reasoning with architectural inhibitory control.
-The Cortex does NOT generate answers — it gates, plans, and validates actions.
-
-Activation: event-driven, not on every turn. Only on:
-- Tool intent (edit, execute, delegate)
-- Ambiguity in user request
-- Destructive actions
-- Multi-step tasks
-- Retry after failure
-- Contradictions with known facts
-
-v0.1: Single MCP tool + middleware validation.
-"""
-
-import json
-import time
-
-
-def _get_db():
-    from db import get_db
-    return get_db()
-
-
-def _get_core_rules_for_task(task_type: str) -> list[str]:
-    """Get relevant Core Rules for the given task type."""
-    conn = _get_db()
-    try:
-        # Map task type to rule categories
-        category_map = {
-            "edit": ["integrity", "execution"],
-            "execute": ["integrity", "execution", "delegation"],
-            "delegate": ["delegation"],
-            "analyze": ["execution", "memory"],
-            "answer": ["communication"],
-        }
-        categories = category_map.get(task_type, ["integrity", "execution"])
-        placeholders = ",".join("?" * len(categories))
-
-        rows = conn.execute(
-            f"SELECT id, rule FROM core_rules WHERE category IN ({placeholders}) AND is_active = 1 AND type = 'blocking' ORDER BY importance DESC LIMIT 5",
-            categories
-        ).fetchall()
-        return [f"{r['id']}: {r['rule']}" for r in rows]
-    except Exception:
-        return []
-
-
-def _get_trust_score() -> float:
-    """Get current trust score from cognitive.db."""
-    try:
-        import cognitive
-        return cognitive.get_trust_score()
-    except Exception:
-        return 50.0
-
-
-def _validate_state(state: dict) -> dict:
-    """Validate cognitive state and determine action mode.
-
-    Returns dict with: mode, warnings, injected_rules, blocked_reason
-    """
-    warnings = []
-    mode = "act"  # default: allow action
-    blocked_reason = None
-
-    task_type = state.get("task_type", "answer")
-    plan = state.get("plan", [])
-    unknowns = state.get("unknowns", [])
-    evidence = state.get("evidence_refs", [])
-    verification = state.get("verification_step", "")
-    constraints = state.get("constraints", [])
-    goal = state.get("goal", "")
-
-    # === INHIBITION RULES (architectural, not advisory) ===
-
-    # Rule 1: unknowns exist → force ASK mode
-    if unknowns:
-        mode = "ask"
-        blocked_reason = f"Cannot act with {len(unknowns)} unknown(s). Resolve first."
-        warnings.append(f"UNKNOWNS: {', '.join(unknowns[:3])}")
-
-    # Rule 2: edit/execute without plan → force PROPOSE
-    if task_type in ("edit", "execute", "delegate") and not plan and mode == "act":
-        mode = "propose"
-        blocked_reason = "No plan defined for action task. Propose plan first."
-        warnings.append("MISSING PLAN: define steps before executing")
-
-    # Rule 3: edit/execute without verification → force PROPOSE
-    if task_type in ("edit", "execute") and not verification and mode == "act":
-        mode = "propose"
-        blocked_reason = "No verification step. How will you confirm it worked?"
-        warnings.append("MISSING VERIFICATION: define how to verify")
-
-    # Rule 4: execute without evidence → force PROPOSE
-    if task_type == "execute" and not evidence and mode == "act":
-        mode = "propose"
-        blocked_reason = "No evidence supporting this action."
-        warnings.append("MISSING EVIDENCE: what supports this action?")
-
-    # Rule 5: no goal → force ASK
-    if not goal:
-        mode = "ask"
-        blocked_reason = "No goal defined."
-        warnings.append("NO GOAL: what are you trying to achieve?")
-
-    # === TRUST-BASED ADJUSTMENTS ===
-    trust = _get_trust_score()
-    if trust < 30 and mode == "act" and task_type in ("edit", "execute"):
-        mode = "propose"
-        blocked_reason = f"Trust score {trust:.0f}/100 — propose before acting."
-        warnings.append(f"LOW TRUST ({trust:.0f}): extra verification required")
-
-    # === INJECT RELEVANT RULES ===
-    rules = _get_core_rules_for_task(task_type)
-
-    return {
-        "mode": mode,
-        "tools_available": _tools_for_mode(mode),
-        "warnings": warnings,
-        "blocked_reason": blocked_reason,
-        "injected_rules": rules,
-        "trust_score": round(trust),
-    }
-
-
-def _tools_for_mode(mode: str) -> list[str]:
-    """Define which tool categories are available per mode."""
-    if mode == "ask":
-        return ["read", "search", "ask_user"]
-    elif mode == "propose":
-        return ["read", "search", "analyze", "propose_plan"]
-    else:  # act
-        return ["all"]
-
-
-def handle_cortex_check(
-    goal: str,
-    task_type: str = "answer",
-    plan: str = "[]",
-    known_facts: str = "[]",
-    unknowns: str = "[]",
-    constraints: str = "[]",
-    evidence_refs: str = "[]",
-    verification_step: str = "",
-) -> str:
-    """Cognitive Cortex pre-action check. Call BEFORE significant actions.
-
-    Validates your reasoning state and determines if you can act, should propose,
-    or need to ask for clarification first. Implements architectural inhibitory control.
-
-    WHEN TO CALL:
-    - Before editing files or running commands
-    - Before delegating to subagents
-    - When the task has multiple possible approaches
-    - After a failed attempt (before retrying)
-    - When user instruction seems to conflict with known facts
-
-    DO NOT CALL for simple chat responses, greetings, or explanations.
-
-    Args:
-        goal: What you are trying to achieve (required)
-        task_type: One of: answer, analyze, edit, execute, delegate
-        plan: JSON array of planned steps (e.g. '["read file", "edit function", "test"]')
-        known_facts: JSON array of facts you have (from user, memory, files)
-        unknowns: JSON array of things you don't know yet but need
-        constraints: JSON array of rules or limitations that apply
-        evidence_refs: JSON array of evidence supporting your plan (learnings, user statements, file contents)
-        verification_step: How you will verify the action worked
-
-    Returns:
-        Mode (ask/propose/act), available tools, warnings, and relevant Core Rules
-    """
-    # Parse JSON arrays safely
-    def _parse(s):
-        try:
-            v = json.loads(s) if isinstance(s, str) else s
-            return v if isinstance(v, list) else []
-        except (json.JSONDecodeError, TypeError):
-            return []
-
-    state = {
-        "goal": goal.strip() if goal else "",
-        "task_type": task_type if task_type in ("answer", "analyze", "edit", "execute", "delegate") else "answer",
-        "plan": _parse(plan),
-        "known_facts": _parse(known_facts),
-        "unknowns": _parse(unknowns),
-        "constraints": _parse(constraints),
-        "evidence_refs": _parse(evidence_refs),
-        "verification_step": verification_step.strip() if verification_step else "",
-    }
-
-    result = _validate_state(state)
-
-    # Format response
-    lines = [
-        f"CORTEX CHECK — mode: {result['mode'].upper()}",
-        f"Trust: {result['trust_score']}/100",
-    ]
-
-    if result["mode"] == "act":
-        lines.append("CLEARED: You may proceed with the action.")
-    elif result["mode"] == "propose":
-        lines.append(f"PROPOSE ONLY: {result['blocked_reason']}")
-        lines.append("Show the user your plan and get approval before executing.")
-    elif result["mode"] == "ask":
-        lines.append(f"ASK FIRST: {result['blocked_reason']}")
-        lines.append("Gather the missing information before proceeding.")
-
-    if result["warnings"]:
-        lines.append("")
-        lines.append("Warnings:")
-        for w in result["warnings"]:
-            lines.append(f"  - {w}")
-
-    if result["injected_rules"]:
-        lines.append("")
-        lines.append("Applicable Core Rules:")
-        for r in result["injected_rules"]:
-            lines.append(f"  - {r}")
-
-    lines.append("")
-    lines.append(f"Tools available: {', '.join(result['tools_available'])}")
-
-    # Log cortex activation for metrics
-    try:
-        conn = _get_db()
-        conn.execute(
-            """CREATE TABLE IF NOT EXISTS cortex_log (
-                id INTEGER PRIMARY KEY AUTOINCREMENT,
-                goal TEXT,
-                task_type TEXT,
-                mode TEXT,
-                warnings TEXT,
-                trust_score INTEGER,
-                created_at TEXT DEFAULT (datetime('now'))
-            )"""
-        )
-        conn.execute(
-            "INSERT INTO cortex_log (goal, task_type, mode, warnings, trust_score) VALUES (?, ?, ?, ?, ?)",
-            (goal[:200], task_type, result["mode"], json.dumps(result["warnings"]), result["trust_score"])
-        )
-        conn.commit()
-    except Exception:
-        pass
-
-    return "\n".join(lines)
-
-
-def handle_cortex_stats(days: int = 7) -> str:
-    """View Cortex activation statistics — how often it activates, modes, warnings.
-
-    Args:
-        days: Period to analyze (default 7)
-    """
-    conn = _get_db()
-    try:
-        conn.execute("SELECT 1 FROM cortex_log LIMIT 1")
-    except Exception:
-        return "No Cortex data yet. The Cortex activates on significant actions."
-
-    cutoff = f"datetime('now', '-{days} days')"
-
-    total = conn.execute(f"SELECT COUNT(*) FROM cortex_log WHERE created_at >= {cutoff}").fetchone()[0]
-    by_mode = conn.execute(
-        f"SELECT mode, COUNT(*) as c FROM cortex_log WHERE created_at >= {cutoff} GROUP BY mode ORDER BY c DESC"
-    ).fetchall()
-    by_type = conn.execute(
-        f"SELECT task_type, COUNT(*) as c FROM cortex_log WHERE created_at >= {cutoff} GROUP BY task_type ORDER BY c DESC"
-    ).fetchall()
-
-    lines = [
-        f"CORTEX STATS — last {days} days",
-        f"Total activations: {total}",
-        "",
-        "By mode:",
-    ]
-    for r in by_mode:
-        pct = (r["c"] / total * 100) if total > 0 else 0
-        lines.append(f"  {r['mode']}: {r['c']} ({pct:.0f}%)")
-
-    lines.append("")
-    lines.append("By task type:")
-    for r in by_type:
-        lines.append(f"  {r['task_type']}: {r['c']}")
-
-    # Inhibition rate = % of activations that resulted in ask or propose (not act)
-    inhibited = sum(r["c"] for r in by_mode if r["mode"] != "act")
-    inhibition_rate = (inhibited / total * 100) if total > 0 else 0
-    lines.append(f"\nInhibition rate: {inhibition_rate:.0f}% (target: 30-60%)")
-
-    return "\n".join(lines)
-
-
-TOOLS = [
-    (handle_cortex_check, "nexo_cortex_check", "Cognitive pre-action check. Validates reasoning and determines if you can act, should propose, or need to ask first. Call before significant actions."),
-    (handle_cortex_stats, "nexo_cortex_stats", "View Cortex activation statistics — modes, task types, inhibition rate."),
-]

package/src/plugins/entities 2.py

@@ -1,67 +0,0 @@
-"""Entities plugin — people, services, URLs, recurring contacts."""
-from db import create_entity, search_entities, list_entities, update_entity, delete_entity
-
-def handle_entity_search(query: str, type: str = "") -> str:
-    """Search entities by name or value. Optional type filter."""
-    results = search_entities(query, type)
-    if not results:
-        return "No results."
-    lines = []
-    for e in results:
-        notes = f" — {e['notes']}" if e.get("notes") else ""
-        lines.append(f"  [{e['id']}] ({e['type']}) {e['name']}: {e['value']}{notes}")
-    return f"ENTIDADES ({len(results)}):\n" + "\n".join(lines)
-
-def handle_entity_create(name: str, type: str, value: str, notes: str = "") -> str:
-    """Create a new entity."""
-    eid = create_entity(name, type, value, notes)
-    # KG hook
-    try:
-        from kg_populate import on_entity_create
-        on_entity_create(eid, name, type)
-    except Exception:
-        pass
-    return f"Entity created: [{eid}] {name} ({type})"
-
-def handle_entity_update(id: int, name: str = "", type: str = "", value: str = "", notes: str = "") -> str:
-    """Update an entity. Only non-empty fields are changed."""
-    kwargs = {}
-    if name: kwargs["name"] = name
-    if type: kwargs["type"] = type
-    if value: kwargs["value"] = value
-    if notes: kwargs["notes"] = notes
-    if not kwargs: return "Nothing to update."
-    update_entity(id, **kwargs)
-    return f"Entity [{id}] updated."
-
-def handle_entity_delete(id: int) -> str:
-    """Delete an entity."""
-    if not delete_entity(id):
-        return f"ERROR: Entity [{id}] not found."
-    return f"Entity [{id}] deleted."
-
-def handle_entity_list(type: str = "") -> str:
-    """List all entities, optionally filtered by type."""
-    results = list_entities(type)
-    if not results:
-        return "No entities."
-    grouped = {}
-    for e in results:
-        t = e["type"]
-        if t not in grouped: grouped[t] = []
-        grouped[t].append(e)
-    lines = []
-    for t, entities in grouped.items():
-        lines.append(f"\n  [{t.upper()}]")
-        for e in entities:
-            notes = f" — {e['notes']}" if e.get("notes") else ""
-            lines.append(f"    [{e['id']}] {e['name']}: {e['value']}{notes}")
-    return f"ENTIDADES ({len(results)}):" + "\n".join(lines)
-
-TOOLS = [
-    (handle_entity_search, "nexo_entity_search", "Search entities by name, value, or type"),
-    (handle_entity_create, "nexo_entity_create", "Create a new entity (person, service, URL)"),
-    (handle_entity_update, "nexo_entity_update", "Update an entity's fields"),
-    (handle_entity_delete, "nexo_entity_delete", "Delete an entity"),
-    (handle_entity_list, "nexo_entity_list", "List all entities grouped by type"),
-]