nexo-brain 5.3.26 → 5.3.27

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."),
-]