mega-brain-ai 1.1.0

package/.claude/hooks/auto_formatter.py

@@ -0,0 +1,158 @@
+#!/usr/bin/env python3
+"""
+AUTO FORMATTER HOOK
+===================
+Formata código automaticamente após Write/Edit.
+
+Baseado em Boris Cherny: "bun run format || true"
+
+Formatters suportados:
+- Python: black, autopep8
+- JavaScript/TypeScript: prettier
+- JSON: jq
+- YAML: yamlfmt
+- Markdown: prettier
+
+Usage (via hook):
+    python3 auto_formatter.py "$TOOL_INPUT"
+"""
+
+import sys
+import os
+import subprocess
+import json
+import re
+from pathlib import Path
+
+PROJECT_ROOT = Path(os.environ.get('CLAUDE_PROJECT_DIR', '.'))
+
+# File extensions and their formatters
+FORMATTERS = {
+    '.py': ['black', '--quiet', '--line-length', '100'],
+    '.js': ['prettier', '--write'],
+    '.ts': ['prettier', '--write'],
+    '.jsx': ['prettier', '--write'],
+    '.tsx': ['prettier', '--write'],
+    '.json': ['prettier', '--write'],
+    '.md': ['prettier', '--write', '--prose-wrap', 'always'],
+    '.yaml': ['prettier', '--write'],
+    '.yml': ['prettier', '--write'],
+}
+
+# Alternative formatters if primary not available
+FALLBACK_FORMATTERS = {
+    '.py': ['autopep8', '--in-place', '--aggressive'],
+}
+
+
+def extract_file_path(tool_input: str) -> str:
+    """Extract file path from tool input"""
+    # Try to parse as JSON first
+    try:
+        data = json.loads(tool_input)
+        return data.get('file_path', '')
+    except:
+        pass
+
+    # Try regex for file_path
+    match = re.search(r'"file_path"\s*:\s*"([^"]+)"', tool_input)
+    if match:
+        return match.group(1)
+
+    # Try to find any path-like string
+    match = re.search(r'(/[^\s"]+\.\w+)', tool_input)
+    if match:
+        return match.group(1)
+
+    return ''
+
+
+def check_formatter_available(formatter: list) -> bool:
+    """Check if formatter is installed"""
+    try:
+        subprocess.run(
+            [formatter[0], '--version'],
+            capture_output=True,
+            timeout=5
+        )
+        return True
+    except:
+        return False
+
+
+def format_file(filepath: str) -> tuple[bool, str]:
+    """Format a file using appropriate formatter"""
+    if not os.path.exists(filepath):
+        return False, f"File not found: {filepath}"
+
+    ext = Path(filepath).suffix.lower()
+
+    if ext not in FORMATTERS:
+        return True, f"No formatter for {ext}"
+
+    formatter = FORMATTERS[ext]
+
+    # Check if formatter is available
+    if not check_formatter_available(formatter):
+        # Try fallback
+        if ext in FALLBACK_FORMATTERS:
+            formatter = FALLBACK_FORMATTERS[ext]
+            if not check_formatter_available(formatter):
+                return True, f"No formatter available for {ext}"
+        else:
+            return True, f"Formatter {formatter[0]} not installed"
+
+    # Run formatter
+    try:
+        cmd = formatter + [filepath]
+        result = subprocess.run(
+            cmd,
+            capture_output=True,
+            text=True,
+            timeout=30
+        )
+
+        if result.returncode == 0:
+            return True, f"Formatted with {formatter[0]}"
+        else:
+            # Don't fail on formatter errors - just report
+            return True, f"Formatter warning: {result.stderr[:100]}"
+
+    except subprocess.TimeoutExpired:
+        return True, "Formatter timeout"
+    except Exception as e:
+        return True, f"Formatter error: {str(e)[:100]}"
+
+
+def main():
+    if len(sys.argv) < 2:
+        sys.exit(0)
+
+    tool_input = sys.argv[1]
+    filepath = extract_file_path(tool_input)
+
+    if not filepath:
+        sys.exit(0)
+
+    # Skip non-code files
+    ext = Path(filepath).suffix.lower()
+    if ext not in FORMATTERS:
+        sys.exit(0)
+
+    # Skip files outside project
+    if str(PROJECT_ROOT) not in filepath:
+        sys.exit(0)
+
+    # Format
+    success, message = format_file(filepath)
+
+    if success:
+        print(f"✨ {message}: {Path(filepath).name}")
+    else:
+        print(f"⚠️ {message}")
+
+    sys.exit(0)
+
+
+if __name__ == '__main__':
+    main()

package/.claude/hooks/checkpoint_writer.py

@@ -0,0 +1,244 @@
+#!/usr/bin/env python3
+"""
+JARVIS Checkpoint Writer v1.0
+Salva estado completo antes de compactação de contexto.
+
+Arquivos gerados:
+- CURRENT-TASK.md (tarefa atual destacada)
+- CONTEXT-SNAPSHOT.md (resumo do contexto atual)
+- INSIGHTS-SESSION.md (insights da sessão)
+"""
+
+import json
+import sys
+import os
+from datetime import datetime
+from pathlib import Path
+
+def get_project_dir():
+    """Obtém o diretório do projeto."""
+    return os.environ.get('CLAUDE_PROJECT_DIR', os.getcwd())
+
+def load_checkpoint_trigger():
+    """Carrega dados do trigger de checkpoint."""
+    project_dir = get_project_dir()
+    trigger_path = Path(project_dir) / '.claude' / 'mission-control' / 'CHECKPOINT-TRIGGER.json'
+
+    if trigger_path.exists():
+        with open(trigger_path, 'r', encoding='utf-8') as f:
+            return json.load(f)
+    return None
+
+def load_jarvis_state():
+    """Carrega estado do JARVIS."""
+    project_dir = get_project_dir()
+
+    # Tentar .claude/jarvis/ primeiro
+    state_path = Path(project_dir) / '.claude' / 'jarvis' / 'STATE.json'
+    if state_path.exists():
+        with open(state_path, 'r', encoding='utf-8') as f:
+            return json.load(f)
+
+    # Fallback
+    state_path = Path(project_dir) / 'system' / 'JARVIS-STATE.json'
+    if state_path.exists():
+        with open(state_path, 'r', encoding='utf-8') as f:
+            return json.load(f)
+
+    return None
+
+def load_pending():
+    """Carrega pendências atuais."""
+    project_dir = get_project_dir()
+    pending_path = Path(project_dir) / '.claude' / 'jarvis' / 'PENDING.md'
+
+    if pending_path.exists():
+        with open(pending_path, 'r', encoding='utf-8') as f:
+            return f.read()
+    return None
+
+def update_current_task(trigger_data, state):
+    """Atualiza CURRENT-TASK.md com estado atual."""
+    project_dir = get_project_dir()
+    task_path = Path(project_dir) / '.claude' / 'jarvis' / 'CURRENT-TASK.md'
+
+    # Construir conteúdo
+    objective = "Continuar tarefa da sessão anterior"
+    context = "Checkpoint automático disparado por uso de contexto."
+
+    if state:
+        if 'next_action' in state:
+            objective = state['next_action'].get('description', objective)
+        if 'mission' in state:
+            mission = state['mission']
+            context = f"Missão: Fase {mission.get('phase', '?')} | Batch {mission.get('batch', '?')}"
+
+    content = f"""# CURRENT-TASK.md
+
+> Tarefa atual em andamento. Atualizado automaticamente via checkpoint.
+> Lido no início de cada sessão para continuidade.
+
+---
+
+## Objetivo
+
+{objective}
+
+## Contexto
+
+{context}
+
+## Checkpoint Info
+
+- Razão: {trigger_data.get('reason', 'MANUAL')}
+- Tokens estimados: {trigger_data.get('tokens_estimated', 'N/A')}
+- Uso de contexto: {trigger_data.get('usage_percent', 'N/A')}%
+- Mensagens na sessão: {trigger_data.get('messages_count', 'N/A')}
+
+## Próximos Passos
+
+1. Verificar PENDING.md para tarefas pendentes
+2. Consultar JARVIS-MEMORY.md para contexto relacional
+3. Retomar de onde parou
+
+## Insights da Sessão
+
+*Adicione insights importantes aqui durante a sessão*
+
+---
+
+*Atualizado: {datetime.now().strftime('%Y-%m-%d %H:%M:%S')}*
+*Checkpoint automático JARVIS Memory System v2.0*
+"""
+
+    with open(task_path, 'w', encoding='utf-8') as f:
+        f.write(content)
+
+    return task_path
+
+def create_context_snapshot(trigger_data, state):
+    """Cria snapshot do contexto atual."""
+    project_dir = get_project_dir()
+    timestamp = datetime.now().strftime('%Y%m%d-%H%M%S')
+    snapshot_path = Path(project_dir) / '.claude' / 'jarvis' / 'snapshots' / f'CONTEXT-{timestamp}.md'
+    snapshot_path.parent.mkdir(parents=True, exist_ok=True)
+
+    # Estado da missão
+    mission_info = "Não disponível"
+    if state and 'mission' in state:
+        m = state['mission']
+        mission_info = f"Fase {m.get('phase', '?')} | Batch {m.get('batch', '?')}/{m.get('total_batches', '?')} | {m.get('status', 'UNKNOWN')}"
+
+    # Progresso acumulado
+    progress_info = "Não disponível"
+    if state and 'accumulated' in state:
+        a = state['accumulated']
+        progress_info = f"{a.get('progress_percent', 0)}% | {a.get('files', 0)} arquivos | {a.get('insights', 0)} insights"
+
+    content = f"""# CONTEXT SNAPSHOT
+
+> Snapshot automático do contexto da sessão.
+> Gerado em: {datetime.now().strftime('%Y-%m-%d %H:%M:%S')}
+
+---
+
+## Trigger
+
+| Campo | Valor |
+|-------|-------|
+| Razão | {trigger_data.get('reason', 'N/A')} |
+| Tokens | {trigger_data.get('tokens_estimated', 'N/A')} |
+| Uso % | {trigger_data.get('usage_percent', 'N/A')}% |
+| Mensagens | {trigger_data.get('messages_count', 'N/A')} |
+
+## Estado da Missão
+
+{mission_info}
+
+## Progresso Acumulado
+
+{progress_info}
+
+## Arquivos de Memória
+
+| Arquivo | Status |
+|---------|--------|
+| JARVIS-MEMORY.md | Verificar |
+| PENDING.md | Verificar |
+| STATE.json | {'Carregado' if state else 'Não encontrado'} |
+
+---
+
+*Snapshot JARVIS Memory System v2.0*
+"""
+
+    with open(snapshot_path, 'w', encoding='utf-8') as f:
+        f.write(content)
+
+    # Também manter um LATEST
+    latest_path = Path(project_dir) / '.claude' / 'jarvis' / 'CONTEXT-SNAPSHOT-LATEST.md'
+    with open(latest_path, 'w', encoding='utf-8') as f:
+        f.write(content)
+
+    return snapshot_path
+
+def log_checkpoint(trigger_data, files_created):
+    """Loga o checkpoint executado."""
+    project_dir = get_project_dir()
+    log_path = Path(project_dir) / 'logs' / 'checkpoints.jsonl'
+
+    log_entry = {
+        'timestamp': datetime.now().isoformat(),
+        'trigger': trigger_data,
+        'files_created': [str(f) for f in files_created]
+    }
+
+    log_path.parent.mkdir(parents=True, exist_ok=True)
+    with open(log_path, 'a', encoding='utf-8') as f:
+        f.write(json.dumps(log_entry, ensure_ascii=False) + '\n')
+
+def main():
+    """Função principal do checkpoint writer."""
+    try:
+        # Carregar trigger data
+        trigger_data = load_checkpoint_trigger()
+        if not trigger_data:
+            trigger_data = {
+                'reason': 'MANUAL',
+                'timestamp': datetime.now().isoformat()
+            }
+
+        # Carregar estado
+        state = load_jarvis_state()
+
+        # Criar arquivos de checkpoint
+        files_created = []
+
+        # 1. Atualizar CURRENT-TASK.md
+        task_file = update_current_task(trigger_data, state)
+        files_created.append(task_file)
+
+        # 2. Criar snapshot de contexto
+        snapshot_file = create_context_snapshot(trigger_data, state)
+        files_created.append(snapshot_file)
+
+        # 3. Logar checkpoint
+        log_checkpoint(trigger_data, files_created)
+
+        # Output
+        output = {
+            'success': True,
+            'files_created': [str(f) for f in files_created],
+            'message': f"Checkpoint salvo com sucesso. {len(files_created)} arquivos criados."
+        }
+
+        print(json.dumps(output))
+
+    except Exception as e:
+        print(json.dumps({
+            'success': False,
+            'error': str(e)
+        }))
+
+if __name__ == '__main__':
+    main()

package/.claude/hooks/claude_md_guard.py

@@ -0,0 +1,146 @@
+#!/usr/bin/env python3
+"""
+CLAUDE.md Guard Hook - VETO: Blocks CLAUDE.md creation outside sanctioned locations.
+
+Hook Type: PreToolUse (Write|Edit)
+Adapted from: aios-core/.claude/hooks/claude_md_guard.py
+Date: 2026-02-18
+
+Architecture Rule Enforced:
+  CLAUDE.md files are ONLY allowed in these locations:
+  - .claude/CLAUDE.md (project instructions)
+  - CLAUDE.md (repo root)
+
+  Agent memory MUST use .claude/agent-memory/{slug}/MEMORY.md
+  NEVER create CLAUDE.md in code directories, data dirs, or subfolders.
+
+VETO CONDITIONS:
+  - Any Write/Edit targeting a CLAUDE.md outside sanctioned paths -> BLOCK
+  - Any content containing <claude-mem-context> outside .claude/ -> BLOCK
+"""
+
+import json
+import sys
+import os
+from pathlib import Path
+
+# Sanctioned CLAUDE.md locations (relative to project root)
+SANCTIONED_CLAUDE_MD = {
+    "CLAUDE.md",                    # Repo root
+    ".claude/CLAUDE.md",            # Project instructions
+}
+
+# Patterns that indicate auto-generated memory spam
+SPAM_INDICATORS = [
+    "<claude-mem-context>",
+    "<!-- This section is auto-generated by claude-mem",
+    "# Recent Activity",
+]
+
+
+def normalize_path(file_path: str) -> str:
+    """Normalize path to relative, forward-slash format."""
+    project_dir = os.environ.get('CLAUDE_PROJECT_DIR', '.')
+
+    fp = Path(file_path).resolve()
+    pd = Path(project_dir).resolve()
+
+    try:
+        rel = fp.relative_to(pd)
+        return str(rel).replace("\\", "/")
+    except ValueError:
+        return file_path.replace("\\", "/")
+
+
+def is_claude_md(file_path: str) -> bool:
+    """Check if the file is a CLAUDE.md file."""
+    normalized = file_path.replace("\\", "/")
+    return normalized.endswith("/CLAUDE.md") or normalized == "CLAUDE.md"
+
+
+def is_sanctioned(relative_path: str) -> bool:
+    """Check if the CLAUDE.md path is in a sanctioned location."""
+    return relative_path in SANCTIONED_CLAUDE_MD
+
+
+def content_is_spam(content: str) -> bool:
+    """Check if content contains auto-generated memory spam markers."""
+    if not content:
+        return False
+    for indicator in SPAM_INDICATORS:
+        if indicator in content:
+            return True
+    return False
+
+
+def main():
+    try:
+        input_data = sys.stdin.read()
+        if not input_data:
+            print(json.dumps({"decision": "allow"}))
+            return
+
+        hook_input = json.loads(input_data)
+        tool_name = hook_input.get("tool_name", "")
+        tool_input = hook_input.get("tool_input", {})
+
+        # Only check Write and Edit tools
+        if tool_name not in ("Write", "Edit", "write", "edit"):
+            print(json.dumps({"decision": "allow"}))
+            return
+
+        file_path = tool_input.get("file_path", "")
+        if not file_path:
+            print(json.dumps({"decision": "allow"}))
+            return
+
+        relative_path = normalize_path(file_path)
+
+        # Check if targeting a CLAUDE.md file
+        if not is_claude_md(relative_path):
+            print(json.dumps({"decision": "allow"}))
+            return
+
+        # Check if it's a sanctioned location
+        if is_sanctioned(relative_path):
+            content = tool_input.get("content", "")
+            if not content:
+                content = tool_input.get("new_string", "")
+
+            if content_is_spam(content):
+                print(json.dumps({
+                    "decision": "allow",
+                    "message": (
+                        "Warning: CLAUDE.md Guard: Detected claude-mem-context in sanctioned file. "
+                        "Agent memory should use .claude/agent-memory/{slug}/MEMORY.md instead."
+                    )
+                }))
+                return
+
+            print(json.dumps({"decision": "allow"}))
+            return
+
+        # UNSANCTIONED CLAUDE.md -> BLOCK
+        print(json.dumps({
+            "decision": "block",
+            "reason": (
+                f"VETO: CLAUDE.md Guard\n"
+                f"   Path: {relative_path}\n"
+                f"   Rule: CLAUDE.md files are NOT allowed outside sanctioned locations.\n"
+                f"   Sanctioned: {', '.join(sorted(SANCTIONED_CLAUDE_MD))}\n"
+                f"   Agent memory -> .claude/agent-memory/{{slug}}/MEMORY.md"
+            )
+        }))
+
+    except json.JSONDecodeError:
+        print(json.dumps({"decision": "allow"}))
+    except Exception as e:
+        # Fail-open: don't block on errors
+        print(json.dumps({
+            "decision": "allow",
+            "message": f"CLAUDE.md Guard error (fail-open): {str(e)}"
+        }))
+
+
+if __name__ == "__main__":
+    main()