#!/usr/bin/env bash
# rtk-hook-version: 3-wizz3
# RTK Claude Code hook — rewrites commands to use rtk for token savings.
# Requires: rtk >= 0.23.0, jq
#
# Fonte de verdade: tools/hooks/rtk-rewrite.sh neste repo. Instalado em
# ~/.claude/hooks/ via `npm run sync:global` (nunca editar a cópia global
# direto: ela é substituída no próximo sync). Isto é um FORK local do hook
# gerado pelo instalador upstream do rtk (que documenta "single source of
# truth = src/discover/registry.rs, não edite este arquivo"): mantemos a
# delegação da lógica de rewrite pro binário `rtk rewrite`, mas aplicamos 3
# patches locais que o upstream não tem (auditoria 2026-07-07, C4/RT1; e
# auditoria 2026-09-11, RT-H3):
#
#   1. Bug de comando multi-linha: `rtk rewrite` (confirmado ainda presente
#      no binário 0.43.0, reportado
#      upstream) só reescreve a 1ª linha de um comando multi-linha; as
#      demais passam cruas, sem aviso, gerando saída mista. Correção: este
#      hook detecta comando multi-linha e chama `rtk rewrite` LINHA A LINHA,
#      preservando a reescrita completa em vez de só a primeira linha.
#   2. Timeout interno por linha (RTK_HOOK_TIMEOUT, default 3s): evita que
#      uma chamada travada a `rtk rewrite` prenda o prompt inteiro. Não
#      depende do `timeout`/`gtimeout` do GNU coreutils (ausente por padrão
#      no macOS) — usa um watcher em background portátil (bash puro).
#      Isso é além do timeout de 5s já configurado no bloco PreToolUse do
#      settings.json (defesa em profundidade, não substituição).
#   3. Cache do version-guard (RTK_CACHE_TTL_SECONDS, default 1h): sem isso
#      o guard rodava `rtk --version` + parsing a CADA Bash tool call da
#      sessão (5 spawns/chamada). Ver comentário em `rtk_version_ok` abaixo
#      para o formato do cache e o motivo do diretório escolhido.
#
# Version guard (floor de compatibilidade do subcomando `rewrite`, 0.23.0):
# é diferente do pin de supply chain do registry (`cli_utility.rtk`, hoje
# v0.43.0) — aquele controla o que o installer OFERECE instalar; este
# controla o que ESTE hook aceita rodar sem quebrar.

RTK_HOOK_TIMEOUT="${RTK_HOOK_TIMEOUT:-3}"

# Cache do version-guard (RT-H3, auditoria 2026-09-11): sem cache, o guard
# de versão rodava `rtk --version` + `grep` + `head` + 2x `cut` (5 spawns)
# a CADA Bash tool call da sessão inteira, só pra confirmar um dado que não
# muda no meio da sessão. Agora fica em cache com TTL de 1h, invalidado
# também se o binário `rtk` do PATH mudar de lugar (upgrade/reinstall no
# meio da sessão).
#
# Local do cache: ${XDG_CACHE_HOME:-$HOME/.cache}/wizz/rtk-version.
# XDG_CACHE_HOME é o padrão em Linux e cada vez mais respeitado em macOS
# também (Homebrew, uv, Docker Desktop já escrevem em ~/.cache); cai pra
# $HOME/.cache quando ausente, que existe nas duas plataformas — mais
# portátil que hardcodar um dos dois. Preferido a ${TMPDIR:-/tmp}: TMPDIR
# é o certo pra artefato descartável de UM processo, mas o objetivo aqui é
# sobreviver a Bash calls dentro da mesma sessão (e entre sessões, já que a
# versão instalada muda raramente) — cache "de configuração", não "de
# processo". Conteúdo não é sensível (só path do binário, status ok/old e
# timestamp), então não precisa do isolamento por-UID que TMPDIR daria.
RTK_CACHE_TTL_SECONDS="${RTK_CACHE_TTL_SECONDS:-3600}"
RTK_CACHE_DIR="${XDG_CACHE_HOME:-$HOME/.cache}/wizz"
RTK_CACHE_FILE="$RTK_CACHE_DIR/rtk-version"

if ! command -v jq &>/dev/null; then
  echo "[rtk] WARNING: jq is not installed. Hook cannot rewrite commands. Install jq: https://jqlang.github.io/jq/download/" >&2
  exit 0
fi

if ! command -v rtk &>/dev/null; then
  echo "[rtk] WARNING: rtk is not installed or not in PATH. Hook cannot rewrite commands. Install: https://github.com/rtk-ai/rtk#installation" >&2
  exit 0
fi

# rtk_version_ok — true (exit 0) quando o `rtk` do PATH é >= 0.23.0 (piso de
# compatibilidade do subcomando `rewrite`). Resultado cacheado em
# $RTK_CACHE_FILE por $RTK_CACHE_TTL_SECONDS; cache ilegível, corrompido,
# expirado, ou com path de binário diferente do atual é ignorado em
# silêncio e recomputado — fail-open, mesma filosofia do resto do hook: um
# cache ruim nunca deve travar o rewrite, só custar 1 recomputo.
#
# Caminho quente (cache válido): zero spawns — `command -v` é builtin do
# bash, `read` lê o arquivo sem subshell, e `$EPOCHSECONDS` (bash >= 5,
# padrão no macOS/Linux modernos) evita o spawn de `date`; em bash < 5 cai
# pra `date +%s` (1 spawn). Caminho frio (cache ausente/expirado, ~1x/h):
# `rtk --version` + `mktemp` + `mv` (3 spawns, contra 5 de antes, e só uma
# vez por hora em vez de a cada comando).
rtk_version_ok() {
  local rtk_path cached_path cached_status cached_ts now elapsed
  rtk_path=$(command -v rtk)
  now="${EPOCHSECONDS:-$(date +%s)}"

  if [ -r "$RTK_CACHE_FILE" ]; then
    IFS=$'\t' read -r cached_path cached_status cached_ts _ <"$RTK_CACHE_FILE" 2>/dev/null
    case "$cached_ts" in
      '' | *[!0-9]*) cached_ts="" ;;
    esac
    if [ -n "$cached_ts" ] && [ "$cached_path" = "$rtk_path" ] &&
      { [ "$cached_status" = "ok" ] || [ "$cached_status" = "old" ]; }; then
      elapsed=$((now - cached_ts))
      if [ "$elapsed" -ge 0 ] && [ "$elapsed" -lt "$RTK_CACHE_TTL_SECONDS" ]; then
        [ "$cached_status" = "ok" ]
        return $?
      fi
    fi
  fi

  # Cache ausente/corrompido/expirado/binário mudou: recomputa (1 spawn:
  # `rtk --version`). Extração de X.Y.Z via builtins (case + parameter
  # expansion), sem grep/cut, equivalente ao antigo
  # `grep -oE '[0-9]+\.[0-9]+\.[0-9]+' | head -1` + `cut -d. -f1/f2`.
  local version_line word vnum major minor status
  version_line=$(rtk --version 2>/dev/null)
  status="ok"
  vnum=""
  for word in $version_line; do
    case "$word" in
      v[0-9]*.[0-9]*.[0-9]*) word="${word#v}" ;;
    esac
    case "$word" in
      [0-9]*.[0-9]*.[0-9]*)
        vnum="$word"
        break
        ;;
    esac
  done
  if [ -n "$vnum" ]; then
    major="${vnum%%.*}"
    minor="${vnum#*.}"
    minor="${minor%%.*}"
    case "$major" in '' | *[!0-9]*) major=0 ;; esac
    case "$minor" in '' | *[!0-9]*) minor=0 ;; esac
    # Require >= 0.23.0
    if [ "$major" -eq 0 ] && [ "$minor" -lt 23 ]; then
      status="old"
      echo "[rtk] WARNING: rtk $vnum is too old (need >= 0.23.0). Upgrade: cargo install rtk" >&2
    fi
  fi

  # Escrita atômica (tmp + mv no mesmo dir): qualquer falha (dir não
  # gravável, disco cheio, /tmp somente-leitura) é ignorada — o cache é só
  # uma otimização, nunca uma dependência.
  if mkdir -p "$RTK_CACHE_DIR" 2>/dev/null; then
    local tmp
    tmp=$(mktemp "$RTK_CACHE_DIR/.rtk-version.XXXXXX" 2>/dev/null) && {
      printf '%s\t%s\t%s\n' "$rtk_path" "$status" "$now" >"$tmp" 2>/dev/null &&
        mv -f "$tmp" "$RTK_CACHE_FILE" 2>/dev/null
      rm -f "$tmp" 2>/dev/null
    }
  fi

  [ "$status" = "ok" ]
}

if ! rtk_version_ok; then
  exit 0
fi

# multiline_unsafe <cmd> — retorna 0 (unsafe) quando reescrever linha a
# linha pode corromper o comando: heredoc (linhas de corpo que parecem
# comando seriam reescritas, ex. `git status` dentro de `cat <<EOF`),
# continuação com `\` no fim da linha (a linha seguinte é argumento, não
# comando) ou aspas desbalanceadas numa linha (string atravessa a quebra).
# Nesses casos o comando passa INTACTO (fail-open), sem reescrita parcial.
multiline_unsafe() {
  local cmd="$1"
  case "$cmd" in
    *"<<"*) return 0 ;;
  esac
  local line dq sq
  while IFS= read -r line || [ -n "$line" ]; do
    case "$line" in
      *\\) return 0 ;;
    esac
    dq=$(printf '%s' "$line" | tr -cd '"' | wc -c)
    sq=$(printf '%s' "$line" | tr -cd "'" | wc -c)
    if [ $((dq % 2)) -ne 0 ] || [ $((sq % 2)) -ne 0 ]; then
      return 0
    fi
  done <<RTK_HOOK_GUARD_EOF
$cmd
RTK_HOOK_GUARD_EOF
  return 1
}

# rewrite_one <line> — imprime a linha reescrita, limitada por
# RTK_HOOK_TIMEOUT segundos. Em timeout ou qualquer falha do rtk, imprime a
# linha original sem alteração (fail-open, mesma filosofia do resto do hook).
rewrite_one() {
  local line="$1"
  if [ -z "$line" ]; then
    printf '%s' ''
    return 0
  fi
  local tmp
  tmp=$(mktemp 2>/dev/null) || {
    printf '%s' "$line"
    return 0
  }
  ( rtk rewrite "$line" >"$tmp" 2>/dev/null ) &
  local pid=$!
  # O watcher roda com stdout/stderr em /dev/null: esta função é chamada
  # dentro de $(...), e um filho que herdasse o pipe da substituição de
  # comando seguraria o chamador até o `sleep` terminar (3 s por chamada,
  # mesmo com o rtk respondendo em ms). O trap mata o `sleep` quando o
  # watcher recebe TERM, para não sobrar um kill tardio num pid reciclado.
  (
    trap 'kill "$sleeper" 2>/dev/null; exit 0' TERM
    sleep "$RTK_HOOK_TIMEOUT" &
    sleeper=$!
    wait "$sleeper"
    kill -TERM "$pid" 2>/dev/null
  ) >/dev/null 2>&1 &
  local watcher=$!
  wait "$pid" 2>/dev/null
  local status=$?
  kill -TERM "$watcher" 2>/dev/null
  wait "$watcher" 2>/dev/null

  # Exit codes do `rtk rewrite`: 0 = reescrito (≤0.30.x), 3 = reescrito
  # (0.43.0+, apesar do --help ainda dizer 0), 1 = sem equivalente (sem
  # output). Qualquer outro status (timeout/SIGTERM=143, erro) = fail-open.
  if { [ "$status" -eq 0 ] || [ "$status" -eq 3 ]; } && [ -s "$tmp" ]; then
    cat "$tmp"
  else
    printf '%s' "$line"
  fi
  rm -f "$tmp" 2>/dev/null
}

INPUT=$(cat)
CMD=$(echo "$INPUT" | jq -r '.tool_input.command // empty')

if [ -z "$CMD" ]; then
  exit 0
fi

case "$CMD" in
  *$'\n'*)
    # Comando multi-linha: reescreve linha a linha (bug RT1/C4), exceto
    # quando o guard detecta risco de corrupção (heredoc, continuação,
    # string multi-linha) — aí passa intacto. O heredoc do loop (não um
    # pipe) garante que ele roda no shell atual, não numa subshell, para
    # REWRITTEN sobreviver ao loop.
    if multiline_unsafe "$CMD"; then
      exit 0
    fi
    REWRITTEN=""
    first=1
    while IFS= read -r line || [ -n "$line" ]; do
      rewritten_line=$(rewrite_one "$line")
      if [ "$first" -eq 1 ]; then
        REWRITTEN="$rewritten_line"
        first=0
      else
        REWRITTEN="$REWRITTEN
$rewritten_line"
      fi
    done <<RTK_HOOK_EOF
$CMD
RTK_HOOK_EOF
    ;;
  *)
    REWRITTEN=$(rewrite_one "$CMD")
    ;;
esac

# No change — nothing to do.
if [ "$CMD" = "$REWRITTEN" ]; then
  exit 0
fi

ORIGINAL_INPUT=$(echo "$INPUT" | jq -c '.tool_input')
UPDATED_INPUT=$(echo "$ORIGINAL_INPUT" | jq --arg cmd "$REWRITTEN" '.command = $cmd')

jq -n \
  --argjson updated "$UPDATED_INPUT" \
  '{
    "hookSpecificOutput": {
      "hookEventName": "PreToolUse",
      "permissionDecision": "allow",
      "permissionDecisionReason": "RTK auto-rewrite",
      "updatedInput": $updated
    }
  }'
