mega-brain-ai 1.3.0

package/.claude/hooks/memory_hints_injector.py

@@ -0,0 +1,251 @@
+#!/usr/bin/env python3
+"""
+Memory Hints Injector v1.0 (Mega Brain) - Bracket-Aware Agent Memory Enhancement
+
+Implements MIS (Memory Integration System) for bracket-aware memory injection
+that adapts to context window usage.
+
+Adapted from: aios-core/.claude/hooks/memory_hints_injector.py
+
+BRACKETS:
+  FRESH    (60-100% context remaining) -> No extra memory needed
+  MODERATE (40-60%)  -> Brief memory reminder (~50 tokens)
+  DEPLETED (25-40%)  -> Extended memory reinforcement (~200 tokens)
+  CRITICAL (0-25%)   -> Full memory + handoff warning (~1000 tokens)
+
+INTEGRATION:
+  - Runs at UserPromptSubmit, AFTER skill_router.py
+  - Tracks prompt_count in STATE.json (mis.prompt_count)
+  - Reads from .claude/agent-memory/ (our existing data store)
+  - Returns feedback with memory hints when bracket warrants it
+
+FAIL-OPEN: Never blocks user input. Returns {"continue": true} on any error.
+
+Hook Type: UserPromptSubmit
+"""
+
+import json
+import sys
+import os
+import time
+from pathlib import Path
+
+PROJECT_ROOT = Path(os.environ.get('CLAUDE_PROJECT_DIR', '.'))
+STATE_DIR = PROJECT_ROOT / ".claude" / "jarvis"
+STATE_FILE = STATE_DIR / "STATE.json"
+AGENT_MEMORY_DIR = PROJECT_ROOT / ".claude" / "agent-memory"
+
+# Context Brackets
+BRACKET_LAYER_MAP = {
+    "FRESH":    {"layer": 0, "max_tokens": 0,    "max_lines": 0},
+    "MODERATE": {"layer": 1, "max_tokens": 50,   "max_lines": 5},
+    "DEPLETED": {"layer": 2, "max_tokens": 200,  "max_lines": 20},
+    "CRITICAL": {"layer": 3, "max_tokens": 1000, "max_lines": 50},
+}
+
+DEFAULTS = {
+    "avg_tokens_per_prompt": 1500,
+    "max_context": 200000,
+}
+
+INTERNAL_TIMEOUT_MS = 80
+
+
+def calculate_bracket(context_percent):
+    """Calculate context bracket from remaining context percentage."""
+    if not isinstance(context_percent, (int, float)):
+        return "CRITICAL"
+    if context_percent >= 60:
+        return "FRESH"
+    if context_percent >= 40:
+        return "MODERATE"
+    if context_percent >= 25:
+        return "DEPLETED"
+    return "CRITICAL"
+
+
+def estimate_context_percent(prompt_count, avg_tokens=None, max_context=None):
+    """Estimate percentage of context remaining based on prompt count."""
+    avg = avg_tokens or DEFAULTS["avg_tokens_per_prompt"]
+    mx = max_context or DEFAULTS["max_context"]
+
+    if not isinstance(prompt_count, (int, float)) or prompt_count < 0:
+        return 100
+    if mx <= 0:
+        return 0
+
+    used = prompt_count * avg
+    percent = 100 - (used / mx * 100)
+    return max(0.0, min(100.0, percent))
+
+
+def load_state():
+    """Load STATE.json safely."""
+    if not STATE_FILE.exists():
+        return {}
+    try:
+        with open(STATE_FILE, "r", encoding="utf-8") as f:
+            return json.load(f)
+    except (json.JSONDecodeError, IOError):
+        return {}
+
+
+def save_state(state):
+    """Save STATE.json safely."""
+    try:
+        STATE_DIR.mkdir(parents=True, exist_ok=True)
+        with open(STATE_FILE, "w", encoding="utf-8") as f:
+            json.dump(state, f, indent=2, ensure_ascii=False)
+    except Exception:
+        pass
+
+
+def get_active_agent(state):
+    """Get active agent slug from state."""
+    session = state.get("session", {})
+    agent = session.get("agent_active")
+    if agent and isinstance(agent, str) and agent.strip():
+        return agent.strip()
+    return None
+
+
+def estimate_tokens(text):
+    """Rough token estimation (~4 chars per token)."""
+    if not text:
+        return 0
+    return max(1, len(text) // 4)
+
+
+def read_agent_memory_hints(agent_slug, max_lines, max_tokens):
+    """
+    Read memory hints from agent's MEMORY.md, respecting token budget.
+    Reads from the END of the file (most recent entries) working backwards.
+    """
+    memory_path = AGENT_MEMORY_DIR / agent_slug / "MEMORY.md"
+    if not memory_path.exists():
+        return ""
+
+    try:
+        content = memory_path.read_text(encoding="utf-8")
+    except Exception:
+        return ""
+
+    lines = content.split("\n")
+    if len(lines) < 10:
+        return ""
+
+    useful_lines = []
+    tokens_used = 0
+
+    for line in reversed(lines):
+        stripped = line.strip()
+
+        if not stripped:
+            if useful_lines:
+                useful_lines.insert(0, "")
+            continue
+
+        if stripped.startswith("# ") and len(useful_lines) == 0:
+            continue
+        if stripped.startswith("> ") and len(useful_lines) == 0:
+            continue
+
+        line_tokens = estimate_tokens(stripped)
+
+        if tokens_used + line_tokens > max_tokens:
+            break
+        if len(useful_lines) >= max_lines:
+            break
+
+        useful_lines.insert(0, line)
+        tokens_used += line_tokens
+
+    result = "\n".join(useful_lines).strip()
+
+    while result.startswith("---"):
+        result = result[3:].strip()
+
+    return result
+
+
+def main():
+    """Main hook execution."""
+    start_time = time.time()
+
+    try:
+        input_data = sys.stdin.read()
+
+        state = load_state()
+        if not state:
+            print(json.dumps({"continue": True}))
+            return
+
+        # MIS Prompt Counter
+        session_id = state.get("session_id", "")
+        mis = state.setdefault("mis", {})
+
+        if mis.get("session_id") != session_id:
+            mis["session_id"] = session_id
+            mis["prompt_count"] = 0
+
+        prompt_count = mis.get("prompt_count", 0) + 1
+        mis["prompt_count"] = prompt_count
+
+        # Calculate Bracket
+        context_percent = estimate_context_percent(prompt_count)
+        bracket = calculate_bracket(context_percent)
+        mis["bracket"] = bracket
+        mis["context_percent"] = round(context_percent, 1)
+
+        save_state(state)
+
+        # Check if memory hints needed
+        layer_config = BRACKET_LAYER_MAP.get(bracket, BRACKET_LAYER_MAP["FRESH"])
+        max_tokens = layer_config["max_tokens"]
+        max_lines = layer_config["max_lines"]
+
+        if max_tokens <= 0:
+            print(json.dumps({"continue": True}))
+            return
+
+        # Timeout check
+        elapsed_ms = (time.time() - start_time) * 1000
+        if elapsed_ms > INTERNAL_TIMEOUT_MS * 0.5:
+            print(json.dumps({"continue": True}))
+            return
+
+        # Get active agent
+        raw_slug = get_active_agent(state)
+        if not raw_slug:
+            print(json.dumps({"continue": True}))
+            return
+
+        agent_slug = raw_slug
+
+        # Read memory hints
+        hints = read_agent_memory_hints(agent_slug, max_lines, max_tokens)
+
+        # Final timeout check
+        elapsed_ms = (time.time() - start_time) * 1000
+        if elapsed_ms > INTERNAL_TIMEOUT_MS:
+            print(json.dumps({"continue": True}))
+            return
+
+        # Return feedback
+        if hints:
+            if bracket == "CRITICAL":
+                prefix = f"[MIS:{bracket}] Context at {round(context_percent)}%. Memory reinforcement for @{agent_slug}:"
+            else:
+                prefix = f"[MIS:{bracket}] @{agent_slug} memory:"
+
+            feedback = f"{prefix}\n{hints}"
+            print(json.dumps({"continue": True, "feedback": feedback}))
+        else:
+            print(json.dumps({"continue": True}))
+
+    except Exception:
+        print(json.dumps({"continue": True}))
+
+
+if __name__ == "__main__":
+    main()

package/.claude/hooks/memory_updater.py

@@ -0,0 +1,202 @@
+#!/usr/bin/env python3
+"""
+JARVIS Memory Updater Hook
+Atualiza JARVIS-MEMORY.md automaticamente.
+
+Triggers:
+- Decisoes importantes detectadas
+- Preferencias demonstradas
+- Final de sessao
+- Padroes de comportamento observados
+"""
+
+import json
+import sys
+import os
+import re
+from datetime import datetime
+from pathlib import Path
+
+def get_project_dir():
+    """Obtem o diretorio do projeto."""
+    return os.environ.get('CLAUDE_PROJECT_DIR', os.getcwd())
+
+def load_memory():
+    """Carrega JARVIS-MEMORY.md atual."""
+    project_dir = get_project_dir()
+    memory_path = Path(project_dir) / '.claude' / 'jarvis' / 'JARVIS-MEMORY.md'
+
+    if memory_path.exists():
+        with open(memory_path, 'r', encoding='utf-8') as f:
+            return f.read()
+    return None
+
+def detect_decision(message):
+    """Detecta se a mensagem contem uma decisao importante."""
+    decision_patterns = [
+        r'decid[io]',
+        r'escolh[eo]',
+        r'prefer[eo]',
+        r'vamos (usar|fazer|implementar)',
+        r'aprovo',
+        r'confirmo',
+        r'sim,?\s*(pode|faz|continua)',
+        r'nao,?\s*(nao pode|nao faz)',
+    ]
+
+    message_lower = message.lower()
+    for pattern in decision_patterns:
+        if re.search(pattern, message_lower):
+            return True
+    return False
+
+def detect_preference(message):
+    """Detecta se a mensagem demonstra uma preferencia."""
+    preference_patterns = [
+        r'gosto (de|quando)',
+        r'prefiro',
+        r'sempre (quero|faz)',
+        r'nunca (quero|faz)',
+        r'melhor (assim|dessa forma)',
+        r'perfeito',
+    ]
+
+    message_lower = message.lower()
+    for pattern in preference_patterns:
+        if re.search(pattern, message_lower):
+            return True
+    return False
+
+def extract_decision_summary(message):
+    """Extrai um resumo da decisao."""
+    # Limitar a 100 caracteres
+    summary = message[:100]
+    if len(message) > 100:
+        summary += "..."
+    return summary
+
+def update_memory_file(section, content):
+    """Atualiza uma secao especifica do JARVIS-MEMORY.md."""
+    project_dir = get_project_dir()
+    memory_path = Path(project_dir) / '.claude' / 'jarvis' / 'JARVIS-MEMORY.md'
+
+    if not memory_path.exists():
+        return False
+
+    with open(memory_path, 'r', encoding='utf-8') as f:
+        memory = f.read()
+
+    # Encontrar secao de decisoes e adicionar
+    if section == 'decisions':
+        # Procurar por "### Decisoes Importantes"
+        if '### Decisoes Importantes' in memory:
+            # Adicionar nova decisao
+            date_str = datetime.now().strftime('%Y-%m-%d')
+            new_entry = f"\n{date_str}:\n├─ {content}\n"
+
+            # Inserir apos o header da secao
+            parts = memory.split('### Decisoes Importantes')
+            if len(parts) == 2:
+                # Encontrar o bloco de codigo
+                if '```' in parts[1]:
+                    code_start = parts[1].find('```')
+                    code_end = parts[1].find('```', code_start + 3)
+                    if code_end > code_start:
+                        # Inserir antes do fechamento do bloco
+                        before = parts[1][:code_end]
+                        after = parts[1][code_end:]
+                        parts[1] = before + new_entry + after
+                        memory = '### Decisoes Importantes'.join(parts)
+
+    # Atualizar timestamp
+    memory = re.sub(
+        r'\*Ultima atualizacao: \d{4}-\d{2}-\d{2}\*',
+        f'*Ultima atualizacao: {datetime.now().strftime("%Y-%m-%d")}*',
+        memory
+    )
+
+    # Incrementar contador de interacoes
+    match = re.search(r'\*Interacoes registradas: (\d+)\*', memory)
+    if match:
+        count = int(match.group(1)) + 1
+        memory = re.sub(
+            r'\*Interacoes registradas: \d+\*',
+            f'*Interacoes registradas: {count}*',
+            memory
+        )
+
+    with open(memory_path, 'w', encoding='utf-8') as f:
+        f.write(memory)
+
+    return True
+
+def log_update(update_type, content):
+    """Loga a atualizacao de memoria."""
+    project_dir = get_project_dir()
+    log_path = Path(project_dir) / 'logs' / 'memory_updates.jsonl'
+    log_path.parent.mkdir(parents=True, exist_ok=True)
+
+    log_entry = {
+        'timestamp': datetime.now().isoformat(),
+        'type': update_type,
+        'content': content[:200]
+    }
+
+    with open(log_path, 'a', encoding='utf-8') as f:
+        f.write(json.dumps(log_entry, ensure_ascii=False) + '\n')
+
+def main():
+    """Funcao principal do hook."""
+    try:
+        # Ler input do hook
+        input_data = sys.stdin.read()
+        if not input_data:
+            print(json.dumps({'continue': True}))
+            return
+
+        hook_input = json.loads(input_data)
+
+        # Extrair mensagem do usuario (se disponivel)
+        message = hook_input.get('message', '')
+        if not message:
+            # Tentar extrair de outros campos
+            message = hook_input.get('content', '')
+            if not message:
+                message = hook_input.get('text', '')
+
+        if not message:
+            print(json.dumps({'continue': True}))
+            return
+
+        updated = False
+
+        # Detectar decisoes
+        if detect_decision(message):
+            summary = extract_decision_summary(message)
+            if update_memory_file('decisions', summary):
+                log_update('decision', summary)
+                updated = True
+
+        # Detectar preferencias
+        if detect_preference(message):
+            summary = extract_decision_summary(message)
+            log_update('preference', summary)
+            updated = True
+
+        # Output
+        output = {
+            'continue': True,
+            'memory_updated': updated
+        }
+
+        print(json.dumps(output))
+
+    except Exception as e:
+        # Nao bloquear em caso de erro
+        print(json.dumps({
+            'continue': True,
+            'error': str(e)
+        }))
+
+if __name__ == '__main__':
+    main()

package/.claude/hooks/notification_system.py

@@ -0,0 +1,115 @@
+#!/usr/bin/env python3
+"""
+NOTIFICATION SYSTEM
+===================
+Envia notificações do sistema quando Claude precisa de input ou completa tarefas.
+
+Baseado no workflow Boris Cherny: "I use system notifications to know when a Claude needs input"
+
+Platforms:
+- macOS: osascript (native notifications)
+- Terminal: bell + print
+
+Usage:
+    python3 notification_system.py "Title" "Message" [type]
+
+Types:
+- info: Informational (default)
+- success: Task completed
+- warning: Needs attention
+- error: Something failed
+"""
+
+import sys
+import os
+import subprocess
+from datetime import datetime
+from pathlib import Path
+
+# Fix Windows cp1252 encoding — emojis crash without this
+if sys.platform == 'win32':
+    sys.stdout.reconfigure(encoding='utf-8', errors='replace')
+    sys.stderr.reconfigure(encoding='utf-8', errors='replace')
+
+PROJECT_ROOT = Path(os.environ.get('CLAUDE_PROJECT_DIR', '.'))
+LOGS_PATH = PROJECT_ROOT / 'logs' / 'notifications'
+LOGS_PATH.mkdir(parents=True, exist_ok=True)
+
+def send_macos_notification(title: str, message: str, sound: str = "default"):
+    """Send native macOS notification"""
+    script = f'''
+    display notification "{message}" with title "{title}" sound name "{sound}"
+    '''
+    try:
+        subprocess.run(['osascript', '-e', script], capture_output=True, timeout=5)
+        return True
+    except Exception:
+        return False
+
+def send_terminal_bell():
+    """Send terminal bell character"""
+    print('\a', end='', flush=True)
+
+def log_notification(title: str, message: str, notif_type: str):
+    """Log notification"""
+    log_file = LOGS_PATH / 'notifications.jsonl'
+    import json
+    entry = {
+        'timestamp': datetime.now().isoformat(),
+        'title': title,
+        'message': message,
+        'type': notif_type
+    }
+    with open(log_file, 'a') as f:
+        f.write(json.dumps(entry) + '\n')
+
+def get_sound_for_type(notif_type: str) -> str:
+    """Get appropriate sound for notification type"""
+    sounds = {
+        'info': 'Pop',
+        'success': 'Glass',
+        'warning': 'Basso',
+        'error': 'Sosumi'
+    }
+    return sounds.get(notif_type, 'default')
+
+def main():
+    import json as json_module
+
+    if len(sys.argv) < 3:
+        print(json_module.dumps({"continue": True, "feedback": "notification_system: missing args"}))
+        sys.exit(0)
+
+    title = sys.argv[1]
+    message = sys.argv[2]
+    notif_type = sys.argv[3] if len(sys.argv) > 3 else 'info'
+
+    log_notification(title, message, notif_type)
+
+    sound = get_sound_for_type(notif_type)
+    send_macos_notification(title, message, sound)
+    send_terminal_bell()
+
+    # Output valid JSON for Claude Code hooks
+    print(json_module.dumps({"continue": True, "feedback": f"[{title}] {message}"}))
+    sys.exit(0)
+
+# Convenience functions for direct import
+def notify_needs_input(context: str = ""):
+    """Notify that Claude needs user input"""
+    msg = f"Claude needs your input{': ' + context if context else ''}"
+    send_macos_notification("🤖 JARVIS", msg, "Basso")
+    send_terminal_bell()
+
+def notify_task_complete(task: str = ""):
+    """Notify that a task completed"""
+    msg = f"Task completed{': ' + task if task else ''}"
+    send_macos_notification("✅ JARVIS", msg, "Glass")
+
+def notify_error(error: str = ""):
+    """Notify about an error"""
+    msg = f"Error{': ' + error if error else ''}"
+    send_macos_notification("❌ JARVIS", msg, "Sosumi")
+
+if __name__ == '__main__':
+    main()