J'ai construit un système de garde-fous pour empêcher Claude Code de me mentir

mkdir -p ~/.claude/brake

cat > ~/.claude/brake/gate-parse.py << 'PYEOF'
#!/usr/bin/env python3
"""Parse l'input du hook PreToolCall, met à jour session-state, retourne les infos."""
import json
import os
import sys
from datetime import datetime

SESSION_FILE = os.path.expanduser("~/.claude/brake/session-state.json")

# Lire stdin
try:
    inp = sys.stdin.read()
except Exception:
    inp = ""

# Parser l'input JSON
tool_name = "unknown"
file_path = ""
command = ""

try:
    d = json.loads(inp)
    tool_name = d.get("tool_name", "unknown")
    ti = d.get("tool_input", {})
    if isinstance(ti, dict):
        file_path = ti.get("file_path", ti.get("path", ""))
        command = ti.get("command", "")
except Exception:
    pass

# Charger session-state
try:
    with open(SESSION_FILE) as f:
        state = json.load(f)
except Exception:
    state = {
        "db_queried": False,
        "roko_invoked": False,
        "tests_run": False,
        "context_mode": "dev",
        "files_read": 0,
        "files_edited": 0,
        "deploy_attempted": False,
        "tools": [],
    }

# Tracker l'outil
state["tools"].append({"tool": tool_name, "time": datetime.now().isoformat()[:19]})

# Détecter requête DB
cmd_lower = command.lower()
if tool_name == "Bash" and any(
    k in cmd_lower
    for k in ["supabase", "pipeline_jobs", "from('", 'from("', ".select(", "psql"]
):
    state["db_queried"] = True

# Détecter invocation agent contradicteur
if tool_name == "Bash" and "roko" in cmd_lower:
    state["roko_invoked"] = True
if tool_name == "Skill" and "roko" in inp.lower():
    state["roko_invoked"] = True

# Détecter tests
if tool_name == "Bash" and any(
    k in command for k in ["npm test", "npm run test", "jest", "vitest", "mocha", "pytest"]
):
    state["tests_run"] = True

# Tracker lectures et editions
if tool_name in ("Read", "Grep"):
    state["files_read"] = state.get("files_read", 0) + 1
if tool_name in ("Edit", "Write"):
    state["files_edited"] = state.get("files_edited", 0) + 1

# Détecter deploy
if tool_name == "Bash" and any(
    k in command
    for k in ["rsync", "pm2 restart", "pm2 reload", "docker push", "npm run deploy"]
):
    state["deploy_attempted"] = True

# Sauvegarder
with open(SESSION_FILE, "w") as f:
    json.dump(state, f)

# Output pour gate.sh
print(
    f"{tool_name}|||{file_path}|||{command}|||"
    f"{state['db_queried']}|||{state['roko_invoked']}|||{state['tests_run']}|||"
    f"{state['files_read']}|||{state['files_edited']}|||{state.get('context_mode', 'dev')}"
)
PYEOF

cat > ~/.claude/brake/gate.sh << 'GATEOF'
#!/usr/bin/env bash
# gate.sh — PreToolCall hook : BLOQUE les actions non conformes (exit 2)
# Exit 0 = autorise | Exit 2 = BLOQUE (message stderr affiche à l'IA)

# Degradation gracieuse : si ce script plante, on autorise l'outil
trap 'exit 0' ERR

BRAKE_DIR="$HOME/.claude/brake"

# Lire stdin
INPUT=""
if [[ ! -t 0 ]]; then
    INPUT=$(cat 2>/dev/null || true)
fi

# Parser via Python
PARSED=$(echo "$INPUT" | python3 "$BRAKE_DIR/gate-parse.py" 2>/dev/null || echo "unknown||||||False|||False|||False|||0|||0|||dev")

# Extraire les valeurs (separateur |||)
TOOL_NAME=$(echo "$PARSED" | cut -d'|' -f1)
FILE_PATH=$(echo "$PARSED" | cut -d'|' -f4)
COMMAND=$(echo "$PARSED" | cut -d'|' -f7)
DB_QUERIED=$(echo "$PARSED" | cut -d'|' -f10)
ROKO_INVOKED=$(echo "$PARSED" | cut -d'|' -f13)
TESTS_RUN=$(echo "$PARSED" | cut -d'|' -f16)
FILES_READ=$(echo "$PARSED" | cut -d'|' -f19)
FILES_EDITED=$(echo "$PARSED" | cut -d'|' -f22)

# Parsing échoué = laisser passer
if [[ "$TOOL_NAME" == "unknown" || -z "$TOOL_NAME" ]]; then
    exit 0
fi

# ============================================================
# REGLES DE BLOCAGE — Adapter selon vos besoins
# ============================================================

# REGLE 1 : Pas de lecture de code serveur sans requête DB (après 2 lectures)
if [[ "$TOOL_NAME" == "Read" || "$TOOL_NAME" == "Grep" ]]; then
    if echo "$FILE_PATH" | grep -qE '(server/|worker|pipeline|api/)' 2>/dev/null; then
        if [[ "$DB_QUERIED" == "False" && "${FILES_READ:-0}" -gt 2 ]]; then
            echo "BRAKE BLOQUE : Lecture code serveur sans requête base (${FILES_READ} lectures)." >&2
            echo "ACTION : Requeter la base d'abord. Diagnostic AVANT code." >&2
            exit 2
        fi
    fi
fi

# REGLE 2 : Pas d'edition de code sans diagnostic base
if [[ "$TOOL_NAME" == "Edit" || "$TOOL_NAME" == "Write" ]]; then
    if echo "$FILE_PATH" | grep -qE '\.(js|ts|jsx|tsx|py)$' 2>/dev/null; then
        if [[ "$DB_QUERIED" == "False" && "${FILES_READ:-0}" -gt 3 ]]; then
            echo "BRAKE BLOQUE : Edition après $FILES_READ lectures sans requête base." >&2
            echo "Pattern : lecture code -> faux diagnostic -> faux fix. STOP." >&2
            exit 2
        fi
    fi
fi

# REGLE 3 : Pas de deploy sans audit contradicteur
if [[ "$TOOL_NAME" == "Bash" ]]; then
    if echo "$COMMAND" | grep -qE '(rsync|pm2 restart|pm2 reload|docker push|npm run deploy)' 2>/dev/null; then
        if [[ "$ROKO_INVOKED" == "False" ]]; then
            echo "BRAKE BLOQUE : Deploy sans audit contradicteur." >&2
            echo "Checklist : tests, backup, env vars, commit propre, rollback." >&2
            exit 2
        fi
    fi
fi

# REGLE 4 : Pas de push sans tests
if [[ "$TOOL_NAME" == "Bash" ]]; then
    if echo "$COMMAND" | grep -qE 'git push.*(main|develop|origin)' 2>/dev/null; then
        if [[ "$TESTS_RUN" == "False" ]]; then
            echo "BRAKE BLOQUE : Push sans tests. Lance les tests d'abord." >&2
            exit 2
        fi
    fi
fi

# REGLE 5 : Pas de HTML/CSS pour les visuels (utiliser l'outil prescrit)
if [[ "$TOOL_NAME" == "Write" ]]; then
    if echo "$FILE_PATH" | grep -qE '\.(html|svg)$' 2>/dev/null; then
        if echo "$FILE_PATH" | grep -qiE '(slide|carousel|carrousel|presentation|poster|visual|banner|infograph)' 2>/dev/null; then
            echo "BRAKE BLOQUE : Visuel en HTML. Utiliser l'outil prescrit." >&2
            exit 2
        fi
    fi
fi

# WARNINGS (ne bloquent pas)
if [[ "$TOOL_NAME" == "Read" || "$TOOL_NAME" == "Grep" ]]; then
    if echo "$FILE_PATH" | grep -qE '(server/|worker|pipeline|api/)' 2>/dev/null; then
        if [[ "$DB_QUERIED" == "False" && "${FILES_READ:-0}" -gt 0 && "${FILES_READ:-0}" -le 2 ]]; then
            echo "BRAKE WARNING : Lecture code serveur sans requête base (${FILES_READ}/2 avant blocage)." >&2
        fi
    fi
fi

exit 0
GATEOF

chmod +x ~/.claude/brake/gate.sh

cat > ~/.claude/brake/session-reset.sh << 'EOF'
#!/usr/bin/env bash
cat > ~/.claude/brake/session-state.json << 'JSON'
{"db_queried":false,"roko_invoked":false,"tests_run":false,"context_mode":"dev","files_read":0,"files_edited":0,"deploy_attempted":false,"tools":[]}
JSON
EOF

chmod +x ~/.claude/brake/session-reset.sh
bash ~/.claude/brake/session-reset.sh

{
  "hooks": {
    "PreToolCall": [
      {
        "matcher": "Read|Grep|Edit|Write|Bash",
        "hooks": [
          {
            "type": "command",
            "command": "bash $HOME/.claude/brake/gate.sh",
            "timeout": 5
          }
        ]
      }
    ]
  }
}

# Syntaxe OK ?
bash -n ~/.claude/brake/gate.sh && echo "OK"
python3 -m py_compile ~/.claude/brake/gate-parse.py && echo "OK"

# Test blocage DB_FIRST (simuler 3 lectures sans DB query)
cat > ~/.claude/brake/session-state.json << 'JSON'
{"db_queried":false,"roko_invoked":false,"tests_run":false,"context_mode":"dev","files_read":3,"files_edited":0,"deploy_attempted":false,"tools":[]}
JSON

echo '{"tool_name":"Read","tool_input":{"file_path":"server/worker.js"}}' | bash ~/.claude/brake/gate.sh 2>&1
echo "Exit code: $?"
# Attendu : message BRAKE BLOQUE + exit code 2

# Test deploy sans audit
bash ~/.claude/brake/session-reset.sh
echo '{"tool_name":"Bash","tool_input":{"command":"rsync -avz ./dist/ user@server:/app/"}}' | bash ~/.claude/brake/gate.sh 2>&1
echo "Exit code: $?"
# Attendu : BRAKE BLOQUE + exit code 2

# Test push sans tests
echo '{"tool_name":"Bash","tool_input":{"command":"git push origin main"}}' | bash ~/.claude/brake/gate.sh 2>&1
echo "Exit code: $?"
# Attendu : BRAKE BLOQUE + exit code 2

# Test Write HTML visuel
echo '{"tool_name":"Write","tool_input":{"file_path":"/tmp/carrousel-linkedin.html"}}' | bash ~/.claude/brake/gate.sh 2>&1
echo "Exit code: $?"
# Attendu : BRAKE BLOQUE + exit code 2

# Test Write HTML normal (code applicatif) — doit passer
echo '{"tool_name":"Write","tool_input":{"file_path":"/app/client/index.html"}}' | bash ~/.claude/brake/gate.sh 2>&1
echo "Exit code: $?"
# Attendu : exit code 0

# Reset pour usage normal
bash ~/.claude/brake/session-reset.sh

# docker-compose.yml
cat > ~/hindsight-docker/docker-compose.yml << 'DCEOF'
version: '3.8'
services:
  hindsight-db:
    image: pgvector/pgvector:pg18
    container_name: hindsight-db
    environment:
      POSTGRES_USER: hindsight
      POSTGRES_PASSWORD: hindsight
      POSTGRES_DB: hindsight
    volumes:
      - hindsight-pgdata:/var/lib/postgresql/data
    healthcheck:
      test: ["CMD-SHELL", "pg_isready -U hindsight"]
      interval: 5s
      timeout: 5s
      retries: 5

  hindsight-app:
    image: ghcr.io/vectorize-io/hindsight:latest
    container_name: hindsight-app
    ports:
      - "8888:8888"
      - "9999:9999"
    environment:
      HINDSIGHT_API_DATABASE_URL: "postgresql://hindsight:hindsight@hindsight-db:5432/hindsight"
      HINDSIGHT_API_LLM_PROVIDER: "openai"
      HINDSIGHT_API_LLM_API_KEY: "${OPENAI_API_KEY}"
      HINDSIGHT_API_LLM_MODEL: "gpt-4o-mini"
    depends_on:
      hindsight-db:
        condition: service_healthy

volumes:
  hindsight-pgdata:
DCEOF

cd ~/hindsight-docker
docker compose up -d

curl -s http://localhost:8888/health
# {"status": "healthy", "database": "connected"}

curl -s -X PUT http://localhost:8888/v1/default/banks/david-global \
  -H "Content-Type: application/json" \
  -d '{
    "description": "Regles globales, feedbacks, protocoles pour toutes les sessions"
  }'

# Exemple : ingérer un feedback
curl -s -X POST http://localhost:8888/v1/default/banks/david-global/memories \
  -H "Content-Type: application/json" \
  -d '{
    "items": [{
      "content": "Regle : toujours requêter la base de données AVANT de lire le code source pour diagnostiquer un bug. Ne jamais proposer un fix sans avoir vu la donnée réelle.",
      "context": "feedback-rule",
      "tags": ["feedback", "global-rules"]
    }],
    "async": false
  }'

# Ingerer tous vos fichiers de feedback en batch
for f in ~/.claude/projects/*/memory/feedback-*.md; do
  python3 -c "
import json, urllib.request, os
content = open('$f').read()
payload = json.dumps({
    'items': [{'content': content, 'context': 'feedback-rule', 'tags': ['feedback', 'global-rules']}],
    'async': False
})
req = urllib.request.Request(
    'http://localhost:8888/v1/default/banks/david-global/memories',
    data=payload.encode(),
    headers={'Content-Type': 'application/json'},
    method='POST'
)
resp = urllib.request.urlopen(req, timeout=60)
result = json.loads(resp.read())
print(f'OK: {os.path.basename(\"$f\")} — {result.get(\"usage\",{}).get(\"total_tokens\",0)} tokens')
"
done

curl -s -X POST http://localhost:8888/v1/default/banks/david-global/memories/recall \
  -H "Content-Type: application/json" \
  -d '{"query": "comment debugger un job bloque dans le pipeline"}' | python3 -c "
import json, sys
d = json.load(sys.stdin)
for m in d.get('results', [])[:3]:
    print(f'  {m[\"text\"][:150]}')
    print()
"

# Ajouter le marketplace Hindsight
claude plugin marketplace add vectorize-io/hindsight

# Installer le plugin mémoire
claude plugin install hindsight-memory

mkdir -p ~/.hindsight

cat > ~/.hindsight/claude-code.json << 'EOF'
{
  "hindsightApiUrl": "http://localhost:8888",
  "bankId": "david-global",
  "bankMission": "Mémoire globale. Regles de travail, feedbacks critiques, protocoles obligatoires, corrections comportementales.",
  "retainMission": "Extraire : corrections sur le comportement (complaisance, raccourcis, mensonges), decisions techniques, règles de process, préférénces de travail. Ignorer les salutations.",
  "autoRecall": true,
  "autoRetain": true,
  "recallBudget": "mid",
  "recallMaxTokens": 2048,
  "recallTypes": ["world", "experience", "observation"],
  "recallContextTurns": 2,
  "retainEveryNTurns": 5,
  "retainOverlapTurns": 2,
  "debug": false
}
EOF

# docker-compose-langfuse.yml
cat > ~/langfuse-docker/docker-compose.yml << 'DCEOF'
version: '3.8'
services:
  langfuse-server:
    image: langfuse/langfuse:2
    ports:
      - "3001:3000"
    environment:
      DATABASE_URL: "postgresql://langfuse:langfuse@langfuse-db:5432/langfuse"
      NEXTAUTH_SECRET: "votre-secret-aleatoire-ici"
      NEXTAUTH_URL: "http://localhost:3001"
      SALT: "votre-salt-aleatoire-ici"
    depends_on:
      langfuse-db:
        condition: service_healthy

  langfuse-db:
    image: postgres:16
    environment:
      POSTGRES_USER: langfuse
      POSTGRES_PASSWORD: langfuse
      POSTGRES_DB: langfuse
    volumes:
      - langfuse-data:/var/lib/postgresql/data
    healthcheck:
      test: ["CMD-SHELL", "pg_isready -U langfuse"]
      interval: 5s
      timeout: 5s
      retries: 5

volumes:
  langfuse-data:
DCEOF

cd ~/langfuse-docker
docker compose up -d

# Dashboard accessible sur http://localhost:3001