mega-brain-ai 1.1.0

package/.claude/hooks/ledger_updater.py

@@ -0,0 +1,301 @@
+#!/usr/bin/env python3
+"""
+LEDGER UPDATER HOOK
+===================
+Atualiza o LEDGER.md automaticamente em pontos chave.
+
+Baseado no Continuous Claude: Context persistence via ledgers
+
+Triggers:
+- SessionEnd: Salva estado final
+- Após completar tarefa significativa
+- Antes de parar
+
+Usage:
+    python3 ledger_updater.py [action] [details]
+
+Actions:
+- complete_task: Marca tarefa como completada
+- add_blocker: Adiciona bloqueio
+- set_next_action: Define próxima ação
+- update_status: Atualiza status geral
+- session_end: Finaliza sessão
+"""
+
+import sys
+import os
+import json
+import re
+from pathlib import Path
+from datetime import datetime
+
+PROJECT_ROOT = Path(os.environ.get('CLAUDE_PROJECT_DIR', '.'))
+LEDGER_PATH = PROJECT_ROOT / ".claude" / "LEDGER.md"
+MISSION_STATE_PATH = (
+    PROJECT_ROOT / ".claude" / "mission-control" / "MISSION-STATE.json"
+)
+INBOX_PATH = PROJECT_ROOT / "inbox"
+
+
+def count_inbox_files() -> int:
+    """Count files in INBOX"""
+    if not INBOX_PATH.exists():
+        return 0
+
+    count = 0
+    exclude = ["_DUPLICATAS", "_BACKUP", ".DS_Store", "_INDEX"]
+
+    for item in INBOX_PATH.rglob("*"):
+        if item.is_file() and not any(e in str(item) for e in exclude):
+            if item.suffix.lower() in [".txt", ".md", ".docx", ".pdf"]:
+                count += 1
+    return count
+
+
+def get_mission_state() -> dict:
+    """Get current mission state"""
+    if not MISSION_STATE_PATH.exists():
+        return {}
+    try:
+        with open(MISSION_STATE_PATH, "r", encoding="utf-8") as f:
+            return json.load(f)
+    except:
+        return {}
+
+
+def read_ledger() -> str:
+    """Read current ledger content"""
+    if not LEDGER_PATH.exists():
+        return ""
+    return LEDGER_PATH.read_text(encoding="utf-8")
+
+
+def write_ledger(content: str):
+    """Write ledger content"""
+    LEDGER_PATH.write_text(content, encoding="utf-8")
+
+
+def update_timestamp(content: str) -> str:
+    """Update the timestamp in ledger"""
+    now = datetime.now().isoformat()
+
+    # Update timestamp line
+    pattern = r"\*\*Timestamp:\*\* .+"
+    replacement = f"**Timestamp:** {now}"
+    content = re.sub(pattern, replacement, content)
+
+    return content
+
+
+def update_inbox_status(content: str) -> str:
+    """Update INBOX status in ledger"""
+    inbox_count = count_inbox_files()
+    now = datetime.now().strftime("%Y-%m-%d %H:%M")
+
+    # Find and update INBOX table
+    # Pattern for "Arquivos pendentes" row
+    pattern = r"\| \*\*Arquivos pendentes\*\* \| .+ \|"
+    replacement = f"| **Arquivos pendentes** | {inbox_count} |"
+    content = re.sub(pattern, replacement, content)
+
+    # Update last scan
+    pattern = r"\| \*\*Última varredura\*\* \| .+ \|"
+    replacement = f"| **Última varredura** | {now} |"
+    content = re.sub(pattern, replacement, content)
+
+    return content
+
+
+def update_mission_status(content: str) -> str:
+    """Update mission status from MISSION-STATE.json"""
+    state = get_mission_state()
+
+    if not state:
+        return content
+
+    current = state.get("current_state", {})
+
+    # Update mission ID
+    mission_id = current.get("mission_id", state.get("mission_id", "-"))
+    pattern = r"\| \*\*ID\*\* \| .+ \|"
+    replacement = f"| **ID** | {mission_id} |"
+    content = re.sub(pattern, replacement, content)
+
+    # Update phase
+    phase = current.get("phase", "-")
+    phase_name = current.get("phase_name", "")
+    pattern = r"\| \*\*Fase\*\* \| .+ \|"
+    replacement = f"| **Fase** | {phase} ({phase_name}) |"
+    content = re.sub(pattern, replacement, content)
+
+    # Update status
+    status = current.get("status", "-")
+    pattern = r"\| \*\*Status\*\* \| .+ \|"
+    replacement = f"| **Status** | {status} |"
+    content = re.sub(pattern, replacement, content)
+
+    # Update batch info if available
+    batch_current = current.get("batch_current", "-")
+    batch_total = current.get("batch_total", "-")
+    percent = current.get("percent_complete", "-")
+
+    pattern = r"\| \*\*Batch atual\*\* \| .+ \|"
+    content = re.sub(pattern, f"| **Batch atual** | {batch_current} |", content)
+
+    pattern = r"\| \*\*Batch total\*\* \| .+ \|"
+    content = re.sub(pattern, f"| **Batch total** | {batch_total} |", content)
+
+    pattern = r"\| \*\*Progresso\*\* \| .+ \|"
+    content = re.sub(pattern, f"| **Progresso** | {percent}% |", content)
+
+    return content
+
+
+def add_completed_task(content: str, task: str) -> str:
+    """Add a completed task to the ledger"""
+    now = datetime.now().strftime("%H:%M")
+    task_line = f"- [x] [{now}] {task}"
+
+    # Find the completed tasks section and add
+    marker = "## ✅ Tarefas Completadas"
+    if marker in content:
+        # Find the next section
+        parts = content.split(marker)
+        if len(parts) >= 2:
+            # Find where to insert (after the header)
+            section = parts[1]
+            lines = section.split("\n")
+
+            # Find first empty checkbox or "Nenhuma tarefa"
+            insert_idx = None
+            for i, line in enumerate(lines):
+                if "(Nenhuma tarefa" in line:
+                    lines[i] = task_line
+                    insert_idx = -1  # Signal we replaced
+                    break
+                elif line.strip().startswith("- ["):
+                    insert_idx = i + 1
+
+            if insert_idx is None:
+                # Add after section header
+                for i, line in enumerate(lines):
+                    if line.strip() == "" and i > 0:
+                        lines.insert(i, task_line)
+                        break
+            elif insert_idx > 0:
+                lines.insert(insert_idx, task_line)
+
+            parts[1] = "\n".join(lines)
+            content = marker.join(parts)
+
+    return content
+
+
+def add_blocker(content: str, blocker: str) -> str:
+    """Add a blocker to the ledger"""
+    now = datetime.now().strftime("%H:%M")
+    blocker_line = f"- [{now}] {blocker}"
+
+    marker = "## ⚠️ Bloqueios Encontrados"
+    if marker in content:
+        # Remove "(Nenhum bloqueio registrado)" if present
+        content = content.replace("- (Nenhum bloqueio registrado)", blocker_line)
+
+    return content
+
+
+def set_next_action(content: str, action: str, priority: str = "Alta") -> str:
+    """Set the next action"""
+    pattern = r"AÇÃO: .+"
+    replacement = f"AÇÃO: {action}"
+    content = re.sub(pattern, replacement, content)
+
+    pattern = r"PRIORIDADE: .+"
+    replacement = f"PRIORIDADE: {priority}"
+    content = re.sub(pattern, replacement, content)
+
+    return content
+
+
+def add_iteration(content: str, duration: str, tasks: str, status: str) -> str:
+    """Add iteration to history"""
+    now = datetime.now().strftime("%Y-%m-%d")
+
+    # Find the history table
+    marker = "## 📊 Histórico de Iterações"
+    if marker in content:
+        parts = content.split(marker)
+        if len(parts) >= 2:
+            # Find last row number
+            matches = re.findall(r"\| (\d+) \|", parts[1])
+            last_num = int(matches[-1]) if matches else 0
+            new_num = last_num + 1
+
+            # Add new row before the closing
+            new_row = f"| {new_num} | {now} | {duration} | {tasks} | {status} |"
+
+            # Find where to insert
+            lines = parts[1].split("\n")
+            for i, line in enumerate(lines):
+                if line.strip().startswith("---") and i > 5:
+                    lines.insert(i, new_row)
+                    break
+
+            parts[1] = "\n".join(lines)
+            content = marker.join(parts)
+
+    return content
+
+
+def main():
+    try:
+        if len(sys.argv) < 2:
+            # Default: update all status
+            action = "update_status"
+        else:
+            action = sys.argv[1]
+
+        details = sys.argv[2] if len(sys.argv) > 2 else ""
+
+        # Read current ledger
+        content = read_ledger()
+
+        if not content:
+            print("Ledger not found - skipping update")
+            sys.exit(0)  # Não bloquear se ledger não existe
+
+        # Always update timestamp and status
+        content = update_timestamp(content)
+        content = update_inbox_status(content)
+        content = update_mission_status(content)
+
+        # Handle specific action
+        if action == "complete_task" and details:
+            content = add_completed_task(content, details)
+            print(f"✅ Task marked complete: {details}")
+
+        elif action == "add_blocker" and details:
+            content = add_blocker(content, details)
+            print(f"⚠️ Blocker added: {details}")
+
+        elif action == "set_next_action" and details:
+            content = set_next_action(content, details)
+            print(f"🎯 Next action set: {details}")
+
+        elif action == "session_end":
+            # Add iteration to history
+            content = add_iteration(content, "-", "Session ended", "✅")
+            print("📝 Session recorded in ledger")
+
+        # Write updated ledger
+        write_ledger(content)
+
+    except Exception as e:
+        # NUNCA bloquear operações do Claude Code por erro no ledger
+        sys.stderr.write(f"[LEDGER_UPDATER] Erro: {e}\n")
+
+    sys.exit(0)
+
+
+if __name__ == "__main__":
+    main()

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()