mega-brain-ai 1.3.0

package/.claude/hooks/enforce_plan_mode.py

@@ -0,0 +1,220 @@
+#!/usr/bin/env python3
+"""
+ENFORCE PLAN MODE HOOK v1.0.0
+=============================
+
+Hook: UserPromptSubmit
+Propósito: Detecta quando o usuário solicita modificação de arquivos e
+           avisa se Plan Mode não foi ativado.
+
+REGRA #13: PLAN MODE OBRIGATÓRIO PARA MODIFICAÇÃO DE ARQUIVOS
+REGRA #29: WARN, NOT BLOCK (avisa, não bloqueia)
+
+Criado: 2026-01-14
+Autor: JARVIS
+"""
+
+import json
+import sys
+import re
+from datetime import datetime
+from pathlib import Path
+
+# Keywords que indicam intenção de modificar arquivos
+MODIFYING_KEYWORDS = [
+    # Português
+    "criar", "crie", "criando", "criação",
+    "atualizar", "atualize", "atualizando", "atualização",
+    "modificar", "modifique", "modificando", "modificação",
+    "implementar", "implemente", "implementando", "implementação",
+    "adicionar", "adicione", "adicionando", "adição",
+    "remover", "remova", "removendo", "remoção",
+    "deletar", "delete", "deletando",
+    "refatorar", "refatore", "refatorando", "refatoração",
+    "corrigir", "corrija", "corrigindo", "correção",
+    "fix", "fixing", "fixed",
+    "editar", "edite", "editando", "edição",
+    "escrever", "escreva", "escrevendo",
+    "gerar", "gere", "gerando", "geração",
+    "mudar", "mude", "mudando", "mudança",
+
+    # Inglês
+    "create", "creating", "creation",
+    "update", "updating",
+    "modify", "modifying", "modification",
+    "implement", "implementing", "implementation",
+    "add", "adding",
+    "remove", "removing", "removal",
+    "delete", "deleting", "deletion",
+    "refactor", "refactoring",
+    "edit", "editing",
+    "write", "writing",
+    "generate", "generating",
+    "change", "changing",
+
+    # Comandos específicos
+    "novo arquivo", "new file",
+    "nova feature", "new feature",
+    "novo hook", "new hook",
+    "nova skill", "new skill",
+    "novo agente", "new agent",
+    "bug fix", "bugfix",
+]
+
+# Keywords que indicam exceções (não precisa Plan Mode)
+EXCEPTION_KEYWORDS = [
+    # Leitura/consulta
+    "mostrar", "show", "exibir", "display",
+    "ler", "read", "leia",
+    "buscar", "search", "find", "procurar",
+    "verificar", "check", "verify",
+    "status", "estado",
+    "listar", "list",
+    "onde estamos", "where are we",
+    "o que é", "what is",
+    "como funciona", "how does",
+    "explique", "explain",
+    "descreva", "describe",
+
+    # Comandos slash (já são skills)
+    "/jarvis", "/status", "/save", "/resume",
+    "/conclave", "/verify", "/config",
+]
+
+# Log file
+LOG_FILE = Path(__file__).parent.parent / "mission-control" / "plan_mode_warnings.jsonl"
+
+
+def check_plan_mode_required(prompt: str) -> dict:
+    """
+    Analisa o prompt para determinar se Plan Mode é necessário.
+
+    Returns:
+        dict com:
+        - required: bool (se Plan Mode é necessário)
+        - keywords_found: list (keywords de modificação encontradas)
+        - exception_found: str|None (exceção que foi encontrada)
+        - confidence: str (HIGH, MEDIUM, LOW)
+    """
+    prompt_lower = prompt.lower()
+
+    # Verificar exceções primeiro
+    for exc in EXCEPTION_KEYWORDS:
+        if exc in prompt_lower:
+            return {
+                "required": False,
+                "keywords_found": [],
+                "exception_found": exc,
+                "confidence": "HIGH"
+            }
+
+    # Verificar keywords de modificação
+    found_keywords = []
+    for kw in MODIFYING_KEYWORDS:
+        # Usar word boundary para evitar falsos positivos
+        pattern = r'\b' + re.escape(kw) + r'\b'
+        if re.search(pattern, prompt_lower):
+            found_keywords.append(kw)
+
+    if not found_keywords:
+        return {
+            "required": False,
+            "keywords_found": [],
+            "exception_found": None,
+            "confidence": "HIGH"
+        }
+
+    # Determinar confiança baseado em quantidade de keywords
+    if len(found_keywords) >= 3:
+        confidence = "HIGH"
+    elif len(found_keywords) >= 2:
+        confidence = "MEDIUM"
+    else:
+        confidence = "LOW"
+
+    return {
+        "required": True,
+        "keywords_found": found_keywords,
+        "exception_found": None,
+        "confidence": confidence
+    }
+
+
+def log_warning(prompt: str, analysis: dict):
+    """Loga warning para auditoria."""
+    try:
+        LOG_FILE.parent.mkdir(parents=True, exist_ok=True)
+
+        entry = {
+            "timestamp": datetime.now().isoformat(),
+            "hook": "enforce_plan_mode",
+            "prompt_preview": prompt[:200] + "..." if len(prompt) > 200 else prompt,
+            "keywords_found": analysis["keywords_found"],
+            "confidence": analysis["confidence"],
+            "action": "WARNING_ISSUED"
+        }
+
+        with open(LOG_FILE, "a", encoding="utf-8") as f:
+            f.write(json.dumps(entry, ensure_ascii=False) + "\n")
+    except Exception:
+        # Não falhar por erro de log
+        pass
+
+
+def main():
+    try:
+        # Ler input do hook
+        input_data = json.loads(sys.stdin.read())
+
+        # Extrair prompt do usuário
+        prompt = input_data.get("prompt", "")
+
+        if not prompt:
+            # Sem prompt, não há o que analisar
+            print(json.dumps({"continue": True}))
+            sys.exit(0)
+
+        # Analisar se Plan Mode é necessário
+        analysis = check_plan_mode_required(prompt)
+
+        if not analysis["required"]:
+            # Não precisa de Plan Mode
+            print(json.dumps({"continue": True}))
+            sys.exit(0)
+
+        # Plan Mode é necessário - emitir WARNING (não bloquear)
+        # REGRA #29: WARN, NOT BLOCK
+
+        log_warning(prompt, analysis)
+
+        # Construir mensagem de aviso
+        warning_msg = (
+            f"[PLAN MODE WARNING] Detectada intenção de modificação de arquivos. "
+            f"Keywords: {', '.join(analysis['keywords_found'][:5])}. "
+            f"Confiança: {analysis['confidence']}. "
+            f"REGRA #13 recomenda Plan Mode para modificações. "
+            f"Use Shift+Tab 2x para ativar ou digite 'plan mode'."
+        )
+
+        # Retornar com aviso (não bloqueia - exit 0)
+        print(json.dumps({
+            "continue": True,
+            "feedback": warning_msg
+        }))
+        sys.exit(0)
+
+    except json.JSONDecodeError:
+        # Input inválido - continuar silenciosamente
+        print(json.dumps({"continue": True}))
+        sys.exit(0)
+    except Exception as e:
+        # Erro inesperado - logar e continuar (não bloquear)
+        print(json.dumps({
+            "continue": True,
+            "warning": f"enforce_plan_mode hook error: {str(e)}"
+        }))
+        sys.exit(0)  # Don't block on internal errors
+
+
+if __name__ == "__main__":
+    main()

package/.claude/hooks/gsd-check-update.js

@@ -0,0 +1,62 @@
+#!/usr/bin/env node
+// Check for GSD updates in background, write result to cache
+// Called by SessionStart hook - runs once per session
+
+const fs = require('fs');
+const path = require('path');
+const os = require('os');
+const { spawn } = require('child_process');
+
+const homeDir = os.homedir();
+const cwd = process.cwd();
+const cacheDir = path.join(homeDir, '.claude', 'cache');
+const cacheFile = path.join(cacheDir, 'gsd-update-check.json');
+
+// VERSION file locations (check project first, then global)
+const projectVersionFile = path.join(cwd, '.claude', 'get-shit-done', 'VERSION');
+const globalVersionFile = path.join(homeDir, '.claude', 'get-shit-done', 'VERSION');
+
+// Ensure cache directory exists
+if (!fs.existsSync(cacheDir)) {
+  fs.mkdirSync(cacheDir, { recursive: true });
+}
+
+// Run check in background (spawn background process, windowsHide prevents console flash)
+const child = spawn(process.execPath, ['-e', `
+  const fs = require('fs');
+  const { execSync } = require('child_process');
+
+  const cacheFile = ${JSON.stringify(cacheFile)};
+  const projectVersionFile = ${JSON.stringify(projectVersionFile)};
+  const globalVersionFile = ${JSON.stringify(globalVersionFile)};
+
+  // Check project directory first (local install), then global
+  let installed = '0.0.0';
+  try {
+    if (fs.existsSync(projectVersionFile)) {
+      installed = fs.readFileSync(projectVersionFile, 'utf8').trim();
+    } else if (fs.existsSync(globalVersionFile)) {
+      installed = fs.readFileSync(globalVersionFile, 'utf8').trim();
+    }
+  } catch (e) {}
+
+  let latest = null;
+  try {
+    latest = execSync('npm view get-shit-done-cc version', { encoding: 'utf8', timeout: 10000, windowsHide: true }).trim();
+  } catch (e) {}
+
+  const result = {
+    update_available: latest && installed !== latest,
+    installed,
+    latest: latest || 'unknown',
+    checked: Math.floor(Date.now() / 1000)
+  };
+
+  fs.writeFileSync(cacheFile, JSON.stringify(result));
+`], {
+  stdio: 'ignore',
+  windowsHide: true,
+  detached: true  // Required on Windows for proper process detachment
+});
+
+child.unref();

package/.claude/hooks/gsd-context-monitor.js

@@ -0,0 +1,122 @@
+#!/usr/bin/env node
+// Context Monitor - PostToolUse hook
+// Reads context metrics from the statusline bridge file and injects
+// warnings when context usage is high. This makes the AGENT aware of
+// context limits (the statusline only shows the user).
+//
+// How it works:
+// 1. The statusline hook writes metrics to /tmp/claude-ctx-{session_id}.json
+// 2. This hook reads those metrics after each tool use
+// 3. When remaining context drops below thresholds, it injects a warning
+//    as additionalContext, which the agent sees in its conversation
+//
+// Thresholds:
+//   WARNING  (remaining <= 35%): Agent should wrap up current task
+//   CRITICAL (remaining <= 25%): Agent should stop immediately and save state
+//
+// Debounce: 5 tool uses between warnings to avoid spam
+// Severity escalation bypasses debounce (WARNING -> CRITICAL fires immediately)
+
+const fs = require('fs');
+const os = require('os');
+const path = require('path');
+
+const WARNING_THRESHOLD = 35;  // remaining_percentage <= 35%
+const CRITICAL_THRESHOLD = 25; // remaining_percentage <= 25%
+const STALE_SECONDS = 60;      // ignore metrics older than 60s
+const DEBOUNCE_CALLS = 5;      // min tool uses between warnings
+
+let input = '';
+process.stdin.setEncoding('utf8');
+process.stdin.on('data', chunk => input += chunk);
+process.stdin.on('end', () => {
+  try {
+    const data = JSON.parse(input);
+    const sessionId = data.session_id;
+
+    if (!sessionId) {
+      process.exit(0);
+    }
+
+    const tmpDir = os.tmpdir();
+    const metricsPath = path.join(tmpDir, `claude-ctx-${sessionId}.json`);
+
+    // If no metrics file, this is a subagent or fresh session -- exit silently
+    if (!fs.existsSync(metricsPath)) {
+      process.exit(0);
+    }
+
+    const metrics = JSON.parse(fs.readFileSync(metricsPath, 'utf8'));
+    const now = Math.floor(Date.now() / 1000);
+
+    // Ignore stale metrics
+    if (metrics.timestamp && (now - metrics.timestamp) > STALE_SECONDS) {
+      process.exit(0);
+    }
+
+    const remaining = metrics.remaining_percentage;
+    const usedPct = metrics.used_pct;
+
+    // No warning needed
+    if (remaining > WARNING_THRESHOLD) {
+      process.exit(0);
+    }
+
+    // Debounce: check if we warned recently
+    const warnPath = path.join(tmpDir, `claude-ctx-${sessionId}-warned.json`);
+    let warnData = { callsSinceWarn: 0, lastLevel: null };
+    let firstWarn = true;
+
+    if (fs.existsSync(warnPath)) {
+      try {
+        warnData = JSON.parse(fs.readFileSync(warnPath, 'utf8'));
+        firstWarn = false;
+      } catch (e) {
+        // Corrupted file, reset
+      }
+    }
+
+    warnData.callsSinceWarn = (warnData.callsSinceWarn || 0) + 1;
+
+    const isCritical = remaining <= CRITICAL_THRESHOLD;
+    const currentLevel = isCritical ? 'critical' : 'warning';
+
+    // Emit immediately on first warning, then debounce subsequent ones
+    // Severity escalation (WARNING -> CRITICAL) bypasses debounce
+    const severityEscalated = currentLevel === 'critical' && warnData.lastLevel === 'warning';
+    if (!firstWarn && warnData.callsSinceWarn < DEBOUNCE_CALLS && !severityEscalated) {
+      // Update counter and exit without warning
+      fs.writeFileSync(warnPath, JSON.stringify(warnData));
+      process.exit(0);
+    }
+
+    // Reset debounce counter
+    warnData.callsSinceWarn = 0;
+    warnData.lastLevel = currentLevel;
+    fs.writeFileSync(warnPath, JSON.stringify(warnData));
+
+    // Build warning message
+    let message;
+    if (isCritical) {
+      message = `CONTEXT MONITOR CRITICAL: Usage at ${usedPct}%. Remaining: ${remaining}%. ` +
+        'STOP new work immediately. Save state NOW and inform the user that context is nearly exhausted. ' +
+        'If using GSD, run /gsd:pause-work to save execution state.';
+    } else {
+      message = `CONTEXT MONITOR WARNING: Usage at ${usedPct}%. Remaining: ${remaining}%. ` +
+        'Begin wrapping up current task. Do not start new complex work. ' +
+        'If using GSD, consider /gsd:pause-work to save state.';
+    }
+
+    const output = {
+      hookSpecificOutput: {
+        hookEventName: "PostToolUse",
+        additionalContext: message
+      }
+    };
+
+    process.stdout.write(JSON.stringify(output));
+  } catch (e) {
+    // Silent fail -- never block tool execution
+    process.exit(0);
+  }
+});

package/.claude/hooks/gsd-statusline.js

@@ -0,0 +1,108 @@
+#!/usr/bin/env node
+// Claude Code Statusline - GSD Edition
+// Shows: model | current task | directory | context usage
+
+const fs = require('fs');
+const path = require('path');
+const os = require('os');
+
+// Read JSON from stdin
+let input = '';
+process.stdin.setEncoding('utf8');
+process.stdin.on('data', chunk => input += chunk);
+process.stdin.on('end', () => {
+  try {
+    const data = JSON.parse(input);
+    const model = data.model?.display_name || 'Claude';
+    const dir = data.workspace?.current_dir || process.cwd();
+    const session = data.session_id || '';
+    const remaining = data.context_window?.remaining_percentage;
+
+    // Context window display (shows USED percentage scaled to 80% limit)
+    // Claude Code enforces an 80% context limit, so we scale to show 100% at that point
+    let ctx = '';
+    if (remaining != null) {
+      const rem = Math.round(remaining);
+      const rawUsed = Math.max(0, Math.min(100, 100 - rem));
+      // Scale: 80% real usage = 100% displayed
+      const used = Math.min(100, Math.round((rawUsed / 80) * 100));
+
+      // Write context metrics to bridge file for the context-monitor PostToolUse hook.
+      // The monitor reads this file to inject agent-facing warnings when context is low.
+      if (session) {
+        try {
+          const bridgePath = path.join(os.tmpdir(), `claude-ctx-${session}.json`);
+          const bridgeData = JSON.stringify({
+            session_id: session,
+            remaining_percentage: remaining,
+            used_pct: used,
+            timestamp: Math.floor(Date.now() / 1000)
+          });
+          fs.writeFileSync(bridgePath, bridgeData);
+        } catch (e) {
+          // Silent fail -- bridge is best-effort, don't break statusline
+        }
+      }
+
+      // Build progress bar (10 segments)
+      const filled = Math.floor(used / 10);
+      const bar = '█'.repeat(filled) + '░'.repeat(10 - filled);
+
+      // Color based on scaled usage (thresholds adjusted for new scale)
+      if (used < 63) {        // ~50% real
+        ctx = ` \x1b[32m${bar} ${used}%\x1b[0m`;
+      } else if (used < 81) { // ~65% real
+        ctx = ` \x1b[33m${bar} ${used}%\x1b[0m`;
+      } else if (used < 95) { // ~76% real
+        ctx = ` \x1b[38;5;208m${bar} ${used}%\x1b[0m`;
+      } else {
+        ctx = ` \x1b[5;31m💀 ${bar} ${used}%\x1b[0m`;
+      }
+    }
+
+    // Current task from todos
+    let task = '';
+    const homeDir = os.homedir();
+    const todosDir = path.join(homeDir, '.claude', 'todos');
+    if (session && fs.existsSync(todosDir)) {
+      try {
+        const files = fs.readdirSync(todosDir)
+          .filter(f => f.startsWith(session) && f.includes('-agent-') && f.endsWith('.json'))
+          .map(f => ({ name: f, mtime: fs.statSync(path.join(todosDir, f)).mtime }))
+          .sort((a, b) => b.mtime - a.mtime);
+
+        if (files.length > 0) {
+          try {
+            const todos = JSON.parse(fs.readFileSync(path.join(todosDir, files[0].name), 'utf8'));
+            const inProgress = todos.find(t => t.status === 'in_progress');
+            if (inProgress) task = inProgress.activeForm || '';
+          } catch (e) {}
+        }
+      } catch (e) {
+        // Silently fail on file system errors - don't break statusline
+      }
+    }
+
+    // GSD update available?
+    let gsdUpdate = '';
+    const cacheFile = path.join(homeDir, '.claude', 'cache', 'gsd-update-check.json');
+    if (fs.existsSync(cacheFile)) {
+      try {
+        const cache = JSON.parse(fs.readFileSync(cacheFile, 'utf8'));
+        if (cache.update_available) {
+          gsdUpdate = '\x1b[33m⬆ /gsd:update\x1b[0m │ ';
+        }
+      } catch (e) {}
+    }
+
+    // Output
+    const dirname = path.basename(dir);
+    if (task) {
+      process.stdout.write(`${gsdUpdate}\x1b[2m${model}\x1b[0m │ \x1b[1m${task}\x1b[0m │ \x1b[2m${dirname}\x1b[0m${ctx}`);
+    } else {
+      process.stdout.write(`${gsdUpdate}\x1b[2m${model}\x1b[0m │ \x1b[2m${dirname}\x1b[0m${ctx}`);
+    }
+  } catch (e) {
+    // Silent fail - don't break statusline on parse errors
+  }
+});