nexo-brain 2.1.0 → 2.3.0

package/src/rules/migrate 2.py

@@ -0,0 +1,207 @@
+#!/usr/bin/env python3
+"""NEXO Brain Rules Migration System.
+
+Manages versioned core rules that ship with every installation.
+Handles adding new rules, removing deprecated ones, and updating
+the user's CLAUDE.md without touching their customizations.
+
+Usage:
+    from rules.migrate import migrate_rules
+    result = migrate_rules(nexo_home)  # Returns dict with changes applied
+"""
+
+import json
+import os
+import re
+from pathlib import Path
+from typing import Optional
+
+
+RULES_FILE = os.path.join(os.path.dirname(os.path.abspath(__file__)), "core-rules.json")
+VERSION_KEY = "rules_version"
+
+
+def load_core_rules() -> dict:
+    """Load the current core rules definition."""
+    with open(RULES_FILE, "r") as f:
+        return json.load(f)
+
+
+def get_installed_version(nexo_home: str) -> Optional[str]:
+    """Get the rules version currently installed in the user's NEXO home."""
+    version_file = os.path.join(nexo_home, "brain", "rules_version.json")
+    if not os.path.exists(version_file):
+        return None
+    try:
+        with open(version_file, "r") as f:
+            data = json.load(f)
+        return data.get("version")
+    except (json.JSONDecodeError, KeyError):
+        return None
+
+
+def save_installed_version(nexo_home: str, version: str, rule_ids: list[str]):
+    """Record which rules version and rule IDs are installed."""
+    version_file = os.path.join(nexo_home, "brain", "rules_version.json")
+    os.makedirs(os.path.dirname(version_file), exist_ok=True)
+    data = {
+        "version": version,
+        "installed_rule_ids": rule_ids,
+        "installed_at": _now_iso(),
+    }
+    with open(version_file, "w") as f:
+        json.dump(data, f, indent=2)
+
+
+def get_installed_rule_ids(nexo_home: str) -> list[str]:
+    """Get the list of rule IDs currently installed."""
+    version_file = os.path.join(nexo_home, "brain", "rules_version.json")
+    if not os.path.exists(version_file):
+        return []
+    try:
+        with open(version_file, "r") as f:
+            data = json.load(f)
+        return data.get("installed_rule_ids", [])
+    except (json.JSONDecodeError, KeyError):
+        return []
+
+
+def generate_rules_markdown(rules_data: dict) -> str:
+    """Generate the Operational Codex markdown from core-rules.json."""
+    lines = [
+        "## Operational Codex (NON-NEGOTIABLE)",
+        "",
+        "These rules are the behavioral foundation of every cognitive co-operator.",
+        "They are derived from real production failures and validated through multi-AI debate.",
+        f"Rules version: {rules_data['_meta']['version']}",
+        "",
+    ]
+
+    for cat_key, cat in rules_data["categories"].items():
+        lines.append(f"### {cat['label']}")
+        lines.append("")
+        for rule in cat["rules"]:
+            tag = "BLOCKING" if rule["type"] == "blocking" else "ADVISORY"
+            lines.append(f"**{rule['id']}. {rule['rule']}** [{tag}]")
+            lines.append(f"_{rule['why']}_")
+            lines.append("")
+
+    return "\n".join(lines)
+
+
+def find_codex_section(claude_md: str) -> tuple[int, int]:
+    """Find the start and end positions of the Operational Codex section in CLAUDE.md."""
+    # Look for the section header
+    start_pattern = r"## Operational Codex \(NON-NEGOTIABLE\)"
+    start_match = re.search(start_pattern, claude_md)
+    if not start_match:
+        return (-1, -1)
+
+    start = start_match.start()
+
+    # Find the next ## section header after the codex
+    rest = claude_md[start_match.end():]
+    next_section = re.search(r"\n## [A-Z]", rest)
+    if next_section:
+        end = start_match.end() + next_section.start()
+    else:
+        end = len(claude_md)
+
+    return (start, end)
+
+
+def migrate_rules(nexo_home: str, dry_run: bool = False) -> dict:
+    """Migrate rules to the latest version.
+
+    Compares installed rules version with current core-rules.json.
+    Adds new rules, removes deprecated ones, updates CLAUDE.md.
+
+    Args:
+        nexo_home: Path to NEXO home directory
+        dry_run: If True, show what would change without applying
+
+    Returns:
+        Dict with: version_from, version_to, added, removed, unchanged, dry_run
+    """
+    rules_data = load_core_rules()
+    current_version = rules_data["_meta"]["version"]
+    installed_version = get_installed_version(nexo_home)
+    installed_ids = set(get_installed_rule_ids(nexo_home))
+
+    # Collect all rule IDs from current version
+    current_ids = set()
+    for cat in rules_data["categories"].values():
+        for rule in cat["rules"]:
+            current_ids.add(rule["id"])
+
+    # Calculate diff
+    added = current_ids - installed_ids if installed_ids else current_ids
+    removed = installed_ids - current_ids if installed_ids else set()
+    unchanged = current_ids & installed_ids if installed_ids else set()
+
+    result = {
+        "version_from": installed_version or "none",
+        "version_to": current_version,
+        "added": sorted(added),
+        "removed": sorted(removed),
+        "unchanged": sorted(unchanged),
+        "total_rules": len(current_ids),
+        "dry_run": dry_run,
+    }
+
+    if installed_version == current_version and not added and not removed:
+        result["status"] = "up_to_date"
+        return result
+
+    if dry_run:
+        result["status"] = "changes_pending"
+        return result
+
+    # Apply: update the Operational Codex section in CLAUDE.md
+    claude_md_path = os.path.join(nexo_home, "CLAUDE.md")
+    if os.path.exists(claude_md_path):
+        with open(claude_md_path, "r") as f:
+            claude_md = f.read()
+
+        new_codex = generate_rules_markdown(rules_data)
+        start, end = find_codex_section(claude_md)
+
+        if start >= 0:
+            # Replace existing codex section
+            claude_md = claude_md[:start] + new_codex + "\n" + claude_md[end:]
+        else:
+            # Append codex after the first section
+            # Find the end of the first ## section
+            first_section_end = re.search(r"\n## ", claude_md[10:])
+            if first_section_end:
+                insert_pos = 10 + first_section_end.start()
+                claude_md = claude_md[:insert_pos] + "\n\n" + new_codex + "\n" + claude_md[insert_pos:]
+            else:
+                claude_md += "\n\n" + new_codex
+
+        with open(claude_md_path, "w") as f:
+            f.write(claude_md)
+
+    # Save version record
+    save_installed_version(nexo_home, current_version, sorted(current_ids))
+
+    result["status"] = "migrated"
+    return result
+
+
+def _now_iso() -> str:
+    from datetime import datetime
+    return datetime.utcnow().isoformat() + "Z"
+
+
+if __name__ == "__main__":
+    import sys
+    if len(sys.argv) < 2:
+        print("Usage: python migrate.py <nexo_home> [--dry-run]")
+        sys.exit(1)
+
+    home = sys.argv[1]
+    dry = "--dry-run" in sys.argv
+
+    result = migrate_rules(home, dry_run=dry)
+    print(json.dumps(result, indent=2))

package/src/scripts/check-context 2.py

@@ -0,0 +1,264 @@
+#!/usr/bin/env python3
+"""Context checker for NEXO operations - prevents duplicate actions.
+
+Mechanical checks (email sent, file exists, action done) run in Python.
+When the 'smart' command is used, passes context to Claude CLI for
+intelligent duplicate/conflict detection that goes beyond file checks.
+"""
+
+import os
+import sys
+import json
+import hashlib
+import subprocess
+from datetime import datetime
+from pathlib import Path
+
+NEXO_HOME = Path(os.environ.get("NEXO_HOME", str(Path.home() / ".nexo")))
+
+CLAUDE_CLI = Path.home() / ".local" / "bin" / "claude"
+
+class ContextChecker:
+    def __init__(self):
+        self.state_dir = NEXO_HOME / 'state'
+        self.state_dir.mkdir(exist_ok=True)
+        
+    def check_email_sent(self, to_addr, subject, since_hours=72):
+        """Check if email was already sent to address with subject."""
+        sent_path = Path.home() / 'mail' / '.nexo-sent' / '.Sent'  # Configure for your mail setup
+        if not sent_path.exists():
+            return False
+
+        subject_lower = subject.lower()
+        to_lower = to_addr.lower()
+        cutoff = datetime.now().timestamp() - (since_hours * 3600)
+        cur_dir = sent_path / 'cur'
+        if not cur_dir.exists():
+            return False
+
+        for msg_file in cur_dir.iterdir():
+            try:
+                if msg_file.stat().st_mtime < cutoff:
+                    continue
+                content = msg_file.read_text(errors='ignore')
+            except (OSError, UnicodeDecodeError):
+                continue
+
+            content_lower = content.lower()
+            if f"to:{to_lower}" in content_lower or f"to: {to_lower}" in content_lower:
+                if subject_lower in content_lower:
+                    return True
+        return False
+        
+    def check_file_exists(self, pattern, search_dirs=None):
+        """Check if file matching pattern exists in common locations."""
+        if search_dirs is None:
+            search_dirs = [
+                '/var/www/vhosts',
+                str(NEXO_HOME),
+                '/opt'
+            ]
+            
+        for base_dir in search_dirs:
+            if not os.path.exists(base_dir):
+                continue
+            matches = []
+            try:
+                for root, _, files in os.walk(base_dir):
+                    for filename in files:
+                        if pattern in filename:
+                            matches.append(str(Path(root) / filename))
+                            if len(matches) >= 5:
+                                return matches
+            except OSError:
+                continue
+        return []
+        
+    def check_action_done(self, action_type, identifier, ttl_days=7):
+        """Check if action was already performed recently."""
+        action_file = self.state_dir / 'actions.json'
+        
+        # Load existing actions
+        actions = {}
+        if action_file.exists():
+            with open(action_file) as f:
+                actions = json.load(f)
+                
+        # Create action key
+        key = hashlib.md5(f"{action_type}:{identifier}".encode()).hexdigest()
+        
+        # Check if exists and not expired
+        if key in actions:
+            action_time = datetime.fromisoformat(actions[key]['timestamp'])
+            age_days = (datetime.now() - action_time).days
+            if age_days < ttl_days:
+                return True, actions[key]
+                
+        return False, None
+        
+    def mark_action_done(self, action_type, identifier, metadata=None):
+        """Mark action as completed."""
+        action_file = self.state_dir / 'actions.json'
+        
+        # Load existing actions
+        actions = {}
+        if action_file.exists():
+            with open(action_file) as f:
+                actions = json.load(f)
+                
+        # Add new action
+        key = hashlib.md5(f"{action_type}:{identifier}".encode()).hexdigest()
+        actions[key] = {
+            'type': action_type,
+            'identifier': identifier,
+            'timestamp': datetime.now().isoformat(),
+            'metadata': metadata or {}
+        }
+        
+        # Save
+        with open(action_file, 'w') as f:
+            json.dump(actions, f, indent=2)
+            
+        return key
+
+def smart_check(action_description: str, context: str = "") -> dict:
+    """Use Claude CLI to intelligently check if an action would be redundant.
+
+    Goes beyond simple file/hash checks — understands intent and context
+    to detect semantic duplicates (e.g., "send welcome email" vs
+    "email onboarding message" to same person).
+    """
+    checker = ContextChecker()
+
+    # Gather mechanical context first
+    state_file = checker.state_dir / 'actions.json'
+    recent_actions = {}
+    if state_file.exists():
+        try:
+            all_actions = json.loads(state_file.read_text())
+            cutoff = datetime.now().timestamp() - (7 * 86400)
+            for k, v in all_actions.items():
+                try:
+                    ts = datetime.fromisoformat(v['timestamp']).timestamp()
+                    if ts > cutoff:
+                        recent_actions[k] = v
+                except (ValueError, KeyError):
+                    pass
+        except Exception:
+            pass
+
+    if not CLAUDE_CLI.exists():
+        return {"redundant": False, "reason": "CLI unavailable, cannot smart-check"}
+
+    prompt = f"""You are a context deduplication engine for NEXO operations.
+
+PROPOSED ACTION:
+{action_description}
+
+ADDITIONAL CONTEXT:
+{context or "None"}
+
+RECENT ACTIONS (last 7 days):
+{json.dumps(list(recent_actions.values()), indent=1, default=str)}
+
+Respond with ONLY valid JSON (no markdown):
+{{
+  "redundant": true/false,
+  "confidence": 0.0-1.0,
+  "reason": "<one line explanation>",
+  "matching_action": "<identifier of matching action if redundant, else null>"
+}}
+
+Rules:
+- Same recipient + same intent within 72h = redundant
+- Same file modification with same content = redundant
+- Similar but different scope (e.g., different recipients) = NOT redundant
+- When in doubt, say not redundant (false negatives are cheaper than false positives)"""
+    )
+    if auth_check.returncode != 0:
+        # CLI not authenticated, skip gracefully
+        return {"redundant": False, "reason": "CLI not authenticated — skipped analysis", "suggestion": "N/A"}
+
+    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:
+            text = result.stdout.strip()
+            if "```json" in text:
+                text = text.split("```json")[1].split("```")[0]
+            elif "```" in text:
+                text = text.split("```")[1].split("```")[0]
+            return json.loads(text.strip())
+    except Exception:
+        pass
+
+    return {"redundant": False, "reason": "CLI check failed, defaulting to not redundant"}
+
+
+def main():
+    """CLI interface for context checking."""
+    if len(sys.argv) < 3:
+        print("Usage: check-context.py <command> <args>")
+        print("Commands:")
+        print("  email <to> <subject>       - Check if email was sent")
+        print("  file <pattern>             - Check if file exists")
+        print("  action <type> <id>         - Check if action was done")
+        print("  smart <description> [ctx]  - Intelligent duplicate check via CLI")
+        sys.exit(1)
+
+    checker = ContextChecker()
+    command = sys.argv[1]
+
+    if command == 'email':
+        if len(sys.argv) < 4:
+            print("Usage: check-context.py email <to> <subject>")
+            sys.exit(1)
+        exists = checker.check_email_sent(sys.argv[2], sys.argv[3])
+        print("EXISTS" if exists else "NOT_FOUND")
+        sys.exit(0 if not exists else 1)
+
+    elif command == 'file':
+        files = checker.check_file_exists(sys.argv[2])
+        if files:
+            print("\n".join(files))
+            sys.exit(1)
+        else:
+            print("NOT_FOUND")
+            sys.exit(0)
+
+    elif command == 'action':
+        if len(sys.argv) < 4:
+            print("Usage: check-context.py action <type> <id>")
+            sys.exit(1)
+        done, data = checker.check_action_done(sys.argv[2], sys.argv[3])
+        if done:
+            print(f"DONE: {data}")
+            sys.exit(1)
+        else:
+            print("NOT_DONE")
+            sys.exit(0)
+
+    elif command == 'smart':
+        if len(sys.argv) < 3:
+            print("Usage: check-context.py smart <description> [context]")
+            sys.exit(1)
+        description = sys.argv[2]
+        context = sys.argv[3] if len(sys.argv) > 3 else ""
+        result = smart_check(description, context)
+        print(json.dumps(result, indent=2))
+        sys.exit(1 if result.get("redundant") else 0)
+
+    else:
+        print(f"Unknown command: {command}")
+        sys.exit(1)
+
+if __name__ == '__main__':
+    main()