ThomasMoreAI/legal-skills-open / br/data-protection/skills/lgpd-enterprise-auditor-brunolagoa
lgpd-enterprise-auditor-brunolagoa
FlaggedAuditoria de conformidade LGPD (Lei nº 13.709/2018) orientada a evidências, com ECA Digital e plataformas digitais — checklist em 17 domínios, severidade, score 0–100 e relatório com plano de adequação. Use quando o usuário pedir auditoria, diagnóstico ou adequação à LGPD/ANPD de um sistema, SaaS, site, app mobile, pipeline DevSecOps ou sistema de IA/LLM.
scripts/install.sh
View on GitHub#!/usr/bin/env bash
# LGPD Enterprise Auditor — instalador local, por projeto (macOS, Linux, Git Bash/WSL).
# Compatível com bash 3.2 (padrão do macOS): sem arrays associativos, sem mapfile.
set -euo pipefail
REPO_DEFAULT="BrunoLagoa/lgpd-enterprise-auditor"
SCHEMA_VERSION="1"
FRAMEWORK_REL=".agents/lgpd-enterprise-auditor"
STATE_REL="${FRAMEWORK_REL}/.install"
SKILL_NAME="lgpd-enterprise-auditor"
EXIT_NOT_FOUND=2
SUPPORTED_TARGETS="claude cursor vscode opencode agents"
ACTION="install"
NON_INTERACTIVE=0
TARGET=""
WITH_SKILL=""
VERSION=""
PROJECT_DIR=""
REPO="$REPO_DEFAULT"
SOURCE_ROOT=""
SOURCE_REF=""
SOURCE_VERSION=""
TMP_ROOT=""
SCRIPT_FILE="${BASH_SOURCE[0]:-}"
SCRIPT_DIR=""
if [[ -n "$SCRIPT_FILE" && -f "$SCRIPT_FILE" ]]; then
SCRIPT_DIR="$(cd "$(dirname "$SCRIPT_FILE")" && pwd -P)"
fi
# ---------------------------------------------------------------------------
# Saída e interação
# ---------------------------------------------------------------------------
color() {
if [[ -t 1 ]]; then printf "\033[%sm" "$1"; fi
}
color_reset() {
if [[ -t 1 ]]; then printf "\033[0m"; fi
}
log_info() { printf "%s[INFO]%s %s\n" "$(color 36)" "$(color_reset)" "$*"; }
log_ok() { printf "%s[OK]%s %s\n" "$(color 32)" "$(color_reset)" "$*"; }
log_warn() { printf "%s[WARN]%s %s\n" "$(color 33)" "$(color_reset)" "$*" >&2; }
log_error() { printf "%s[ERROR]%s %s\n" "$(color 31)" "$(color_reset)" "$*" >&2; }
die() {
log_error "$*"
exit 1
}
die_with_code() {
local code="$1"
shift
log_error "$*"
exit "$code"
}
# LGPD_AUDITOR_NO_TTY=1 força a leitura pelo stdin (usado nos testes).
tty_available() {
[[ "${LGPD_AUDITOR_NO_TTY:-0}" != "1" ]] && { : < /dev/tty; } 2>/dev/null
}
# Perguntas vão para o terminal (ou stderr) para não poluir capturas $(...).
prompt_out() {
if tty_available; then
printf "%s" "$*" > /dev/tty
else
printf "%s" "$*" >&2
fi
}
read_answer() {
local __var="$1"
local __reply=""
if tty_available; then
IFS= read -r __reply < /dev/tty || die "Entrada interativa indisponível. Use --non-interactive."
else
IFS= read -r __reply || die "Entrada interativa indisponível. Use --non-interactive."
fi
printf -v "$__var" "%s" "$__reply"
}
confirm() {
local question="$1"
local default_choice="${2:-y}"
local suffix="[y/N]"
local answer=""
if [[ "$default_choice" == "y" ]]; then suffix="[Y/n]"; fi
prompt_out "${question} ${suffix}: "
read_answer answer
answer="$(printf "%s" "${answer:-$default_choice}" | tr '[:upper:]' '[:lower:]')"
[[ "$answer" == "y" || "$answer" == "yes" || "$answer" == "s" || "$answer" == "sim" ]]
}
# Imprime as opções e devolve (stdout) o número escolhido.
choose_index() {
local question="$1"
shift
local idx=1
local answer=""
local option
prompt_out "${question}"$'\n'
for option in "$@"; do
prompt_out " ${idx}) ${option}"$'\n'
idx=$((idx + 1))
done
while true; do
prompt_out "Selecione uma opção [1-$#]: "
read_answer answer
if [[ "$answer" =~ ^[0-9]+$ ]] && (( answer >= 1 && answer <= $# )); then
printf "%s" "$answer"
return 0
fi
log_warn "Opção inválida. Tente novamente."
done
}
print_banner() {
cat <<'EOF'
_ ____ ____ ____
| | / ___| _ \| _ \
| | | | _| |_) | | | |
| |__| |_| | __/| |_| |
|_____\____|_| |____/
EOF
printf "\nLGPD Enterprise Auditor %s\n\n" "$1"
printf "Framework de auditoria de conformidade LGPD orientado a evidências, para usar com o seu\n"
printf "assistente de IA (Claude Code, Cursor, VS Code + Copilot, OpenCode, Codex, Gemini CLI).\n"
printf "A instalação é local: tudo fica dentro do projeto auditado.\n\n"
}
usage() {
cat <<'EOF'
LGPD Enterprise Auditor — instalador
Uso:
install.sh [install|update|uninstall|check] [opções]
Ações:
install Instala o framework e os comandos da ferramenta escolhida (padrão)
update Reinstala as ferramentas já instaladas na versão escolhida
uninstall Remove a instalação de uma ferramenta (ou de todas)
check Verifica a instalação do projeto
Opções:
--target <claude|cursor|vscode|opencode|agents> Ferramenta (obrigatória com --non-interactive no install)
--with-skill Instala também a skill
--no-skill Não instala a skill (padrão)
--project-dir <dir> Projeto de destino (padrão: raiz git do diretório atual)
--version <ref|local> Tag, branch ou "local" (padrão: última tag publicada)
--repo <owner/repo> Repositório GitHub (padrão: BrunoLagoa/lgpd-enterprise-auditor)
--non-interactive Executa sem perguntas
-h, --help Exibe esta ajuda
Exemplos:
curl -fsSL https://github.com/BrunoLagoa/lgpd-enterprise-auditor/releases/latest/download/install.sh | bash -s -- install
./scripts/install.sh install --target cursor --with-skill --project-dir ../meu-app
./scripts/install.sh update --non-interactive
./scripts/install.sh uninstall --target claude --non-interactive
EOF
}
# ---------------------------------------------------------------------------
# Argumentos e ambiente
# ---------------------------------------------------------------------------
require_value() {
[[ $# -ge 2 && -n "$2" && "${2#--}" == "$2" ]] || die "A opção $1 exige um valor."
}
parse_args() {
if [[ $# -gt 0 && "${1#-}" == "$1" ]]; then
ACTION="$1"
shift
fi
while [[ $# -gt 0 ]]; do
case "$1" in
--target) require_value "$@"; TARGET="$2"; shift 2 ;;
--with-skill) WITH_SKILL=1; shift ;;
--no-skill) WITH_SKILL=0; shift ;;
--project-dir) require_value "$@"; PROJECT_DIR="$2"; shift 2 ;;
--version) require_value "$@"; VERSION="$2"; shift 2 ;;
--repo) require_value "$@"; REPO="$2"; shift 2 ;;
--non-interactive) NON_INTERACTIVE=1; shift ;;
-h|--help) usage; exit 0 ;;
*) die "Argumento desconhecido: $1 (use --help)" ;;
esac
done
case "$ACTION" in
install|update|uninstall|check) ;;
*) die "Ação inválida: $ACTION (use install, update, uninstall ou check)" ;;
esac
if [[ -n "$TARGET" ]] && ! is_supported_target "$TARGET"; then
die "Ferramenta não suportada: $TARGET (use: ${SUPPORTED_TARGETS// /, })"
fi
[[ "$REPO" =~ ^[A-Za-z0-9._-]+/[A-Za-z0-9._-]+$ ]] || die "Repositório inválido: $REPO (use owner/repo)"
}
is_supported_target() {
case "$1" in
claude|cursor|vscode|opencode|agents) return 0 ;;
*) return 1 ;;
esac
}
detect_os() {
case "$(uname -s | tr '[:upper:]' '[:lower:]')" in
darwin*) printf "macos" ;;
msys*|mingw*|cygwin*) printf "windows" ;;
*) printf "linux" ;;
esac
}
iso_timestamp() {
date -u +"%Y-%m-%dT%H:%M:%SZ"
}
ensure_command() {
command -v "$1" >/dev/null 2>&1 || die "Pré-requisito ausente: $1"
}
resolve_project_dir() {
if [[ -n "$PROJECT_DIR" ]]; then
[[ -d "$PROJECT_DIR" ]] || die "Diretório do projeto não encontrado: $PROJECT_DIR"
PROJECT_DIR="$(cd "$PROJECT_DIR" && pwd -P)"
else
local current
current="$(pwd -P)"
PROJECT_DIR="$current"
while [[ "$current" != "/" ]]; do
if [[ -e "${current}/.git" ]]; then
PROJECT_DIR="$current"
break
fi
current="$(dirname "$current")"
done
fi
if [[ "$PROJECT_DIR" == "/" || "$PROJECT_DIR" == "$(cd "$HOME" && pwd -P)" ]]; then
die "Recusado instalar em ${PROJECT_DIR}. Rode na raiz do projeto ou use --project-dir."
fi
}
# ---------------------------------------------------------------------------
# Ferramentas (targets)
# ---------------------------------------------------------------------------
target_label() {
case "$1" in
claude) printf "claude (Claude Code)" ;;
cursor) printf "cursor (Cursor)" ;;
vscode) printf "vscode (VS Code + GitHub Copilot)" ;;
opencode) printf "opencode (OpenCode)" ;;
agents) printf "agents (outra ferramenta: Codex, Gemini CLI e similares)" ;;
esac
}
target_commands_dir() {
case "$1" in
claude) printf ".claude/commands" ;;
cursor) printf ".cursor/commands" ;;
vscode) printf ".github/prompts" ;;
opencode) printf ".opencode/commands" ;;
agents) printf "" ;;
esac
}
target_command_file() {
local target="$1"
local stem="$2"
if [[ "$target" == "vscode" ]]; then
printf "%s.prompt.md" "$stem"
else
printf "%s.md" "$stem"
fi
}
target_skill_dir() {
if [[ "$1" == "claude" ]]; then
printf ".claude/skills/%s" "$SKILL_NAME"
else
printf ".agents/skills/%s" "$SKILL_NAME"
fi
}
print_next_steps() {
local target="$1"
local skill="$2"
printf "\nPróximos passos\n"
case "$target" in
claude) printf " Abra o Claude Code na raiz do projeto (claude) e rode /lgpd-saas, /lgpd-full-audit etc.\n" ;;
cursor) printf " No chat do Cursor, digite /lgpd-saas, /lgpd-full-audit etc.\n" ;;
vscode) printf " No Copilot Chat do VS Code, digite /lgpd-saas, /lgpd-full-audit etc.\n" ;;
opencode) printf " Rode opencode na raiz do projeto e use /lgpd-saas, /lgpd-full-audit etc.\n" ;;
agents) printf " Peça ao seu agente: \"faça uma auditoria LGPD deste projeto\" — ele carrega a skill %s.\n" "$SKILL_NAME" ;;
esac
if [[ "$skill" == "1" && "$target" != "agents" ]]; then
printf " Com a skill instalada, você também pode pedir a auditoria em linguagem natural.\n"
fi
printf " Coloque política de privacidade, RIPD, contratos (DPA) e nomeação do DPO dentro do projeto\n"
printf " (ex.: docs/lgpd/) para que contem como evidência documental.\n"
}
# Claude e OpenCode leem o frontmatter como está.
# Cursor: remove o frontmatter e promove a description para a primeira linha.
# VS Code: mantém só os campos aceitos em .prompt.md (name, description) e roda em modo agent.
render_command() {
local target="$1"
local src="$2"
local dest="$3"
case "$target" in
cursor)
awk '
NR == 1 && $0 == "---" { in_fm = 1; next }
in_fm && $0 == "---" { in_fm = 0; if (desc != "") { print "> " desc; print "" }; skip_blank = 1; next }
in_fm { if ($0 ~ /^description:/) { desc = $0; sub(/^description:[[:space:]]*/, "", desc); gsub(/^["\047]|["\047]$/, "", desc) }; next }
skip_blank && $0 ~ /^[[:space:]]*$/ { next }
{ skip_blank = 0; print }
' "$src" > "$dest"
;;
vscode)
awk '
NR == 1 && $0 == "---" { in_fm = 1; next }
in_fm && $0 == "---" { in_fm = 0; print "---"; if (name != "") print name; if (desc != "") print desc; print "agent: agent"; print "---"; next }
in_fm { if ($0 ~ /^name:/) name = $0; if ($0 ~ /^description:/) desc = $0; next }
{ print }
' "$src" > "$dest"
;;
*)
cp "$src" "$dest"
;;
esac
}
# ---------------------------------------------------------------------------
# Origem dos arquivos (local ou GitHub)
# ---------------------------------------------------------------------------
cleanup() {
if [[ -n "$TMP_ROOT" && -d "$TMP_ROOT" ]]; then
rm -rf "$TMP_ROOT"
fi
}
local_source_root() {
if [[ -z "$SCRIPT_DIR" ]]; then
return 1
fi
local root
root="$(cd "$SCRIPT_DIR/.." && pwd -P)"
if [[ -d "${root}/${FRAMEWORK_REL}" && -f "${root}/SKILL.md" && -d "${root}/commands" ]]; then
printf "%s" "$root"
return 0
fi
return 1
}
skill_version() {
sed -n 's/^[[:space:]]*version:[[:space:]]*"\{0,1\}\([^"]*\)"\{0,1\}[[:space:]]*$/\1/p' "$1" | head -n 1
}
# Imprime a última tag publicada. Retorno: 0 com a tag; 1 se o repositório não tem tag v*;
# 2 se a consulta falhou (sem rede, limite da API do GitHub ou modo offline).
fetch_latest_tag() {
local response
[[ "${LGPD_AUDITOR_OFFLINE:-0}" != "1" ]] || return 2
command -v curl >/dev/null 2>&1 || return 2
response="$(curl -fsSL --max-time 10 "https://api.github.com/repos/${REPO}/tags?per_page=100" 2>/dev/null)" || return 2
printf "%s" "$response" \
| grep -o '"name": *"v[0-9][^"]*"' \
| sed 's/.*"\(v[^"]*\)"/\1/' \
| sort -V \
| tail -n 1
}
# Define SOURCE_REF antes de baixar (para exibir no banner e no resumo).
resolve_ref() {
if [[ -z "$VERSION" ]]; then
if local_source_root >/dev/null; then
VERSION="local"
else
local tag_status=0
VERSION="$(fetch_latest_tag)" || tag_status=$?
if [[ -z "$VERSION" ]]; then
if [[ "$tag_status" -eq 2 ]]; then
# Falha de consulta não é "sem versão publicada": a branch main pode ter mudanças não lançadas.
log_warn "Não foi possível consultar a última versão publicada (sem rede ou limite da API do GitHub)."
if [[ "$NON_INTERACTIVE" -eq 1 ]]; then
die "Informe a versão com --version (ex.: --version vX.Y.Z) ou tente de novo mais tarde."
fi
confirm "Instalar a partir da branch main, que pode conter mudanças ainda não publicadas?" "n" \
|| die "Instalação cancelada. Informe a versão com --version (ex.: --version vX.Y.Z)."
else
log_warn "Nenhuma tag publicada encontrada; usando a branch main."
fi
VERSION="main"
fi
fi
fi
SOURCE_REF="$VERSION"
if [[ "$SOURCE_REF" == "local" ]]; then
SOURCE_ROOT="$(local_source_root)" || die "--version local exige rodar o script a partir de um clone do repositório."
SOURCE_VERSION="$(skill_version "${SOURCE_ROOT}/SKILL.md")"
fi
}
ref_label() {
if [[ "$SOURCE_REF" == "local" ]]; then
printf "v%s (cópia local em %s)" "$SOURCE_VERSION" "$SOURCE_ROOT"
else
printf "%s" "$SOURCE_REF"
fi
}
fetch_source() {
if [[ -n "$SOURCE_ROOT" ]]; then
return 0
fi
ensure_command curl
ensure_command tar
local archive="${TMP_ROOT}/source.tar.gz"
local url="https://codeload.github.com/${REPO}/tar.gz/${SOURCE_REF}"
log_info "Baixando ${REPO}@${SOURCE_REF}..."
curl -fsSL "$url" -o "$archive" || die "Falha ao baixar ${url}. Verifique a versão (--version) e a conexão."
mkdir -p "${TMP_ROOT}/source"
tar -xzf "$archive" -C "${TMP_ROOT}/source"
local extracted
extracted="$(find "${TMP_ROOT}/source" -mindepth 1 -maxdepth 1 -type d | head -n 1)"
[[ -n "$extracted" && -d "${extracted}/${FRAMEWORK_REL}" && -f "${extracted}/SKILL.md" && -d "${extracted}/commands" ]] \
|| die "Conteúdo baixado inválido para ${SOURCE_REF}."
SOURCE_ROOT="$extracted"
SOURCE_VERSION="$(skill_version "${SOURCE_ROOT}/SKILL.md")"
}
guard_not_source_repo() {
if [[ -n "$SOURCE_ROOT" && "$SOURCE_ROOT" == "$PROJECT_DIR" ]]; then
die "O destino é o próprio repositório do framework. Use --project-dir para apontar o projeto a ser auditado."
fi
}
# ---------------------------------------------------------------------------
# Manifestos (um por ferramenta, em .agents/lgpd-enterprise-auditor/.install/)
# ---------------------------------------------------------------------------
manifest_path() {
printf "%s/%s/%s.json" "$PROJECT_DIR" "$STATE_REL" "$1"
}
json_value() {
sed -n "s/^[[:space:]]*\"$2\":[[:space:]]*\"\{0,1\}\([^\",]*\)\"\{0,1\},\{0,1\}[[:space:]]*$/\1/p" "$1" | head -n 1
}
manifest_files() {
awk '
/"files":[[:space:]]*\[/ { if ($0 !~ /\]/) in_files = 1; next }
in_files && /\]/ { in_files = 0; next }
in_files { gsub(/^[[:space:]]*"|",?[[:space:]]*$/, ""); if ($0 != "") print }
' "$1"
}
installed_targets() {
local target
for target in $SUPPORTED_TARGETS; do
if [[ -f "$(manifest_path "$target")" ]]; then
printf "%s\n" "$target"
fi
done
}
write_manifest() {
local target="$1"
local skill="$2"
local files="$3"
local skill_dir="$4"
local manifest
manifest="$(manifest_path "$target")"
mkdir -p "$(dirname "$manifest")"
local skill_json="false"
if [[ "$skill" == "1" ]]; then skill_json="true"; fi
{
printf "{\n"
printf " \"schemaVersion\": \"%s\",\n" "$SCHEMA_VERSION"
printf " \"project\": \"lgpd-enterprise-auditor\",\n"
printf " \"version\": \"%s\",\n" "$SOURCE_VERSION"
printf " \"ref\": \"%s\",\n" "$SOURCE_REF"
printf " \"repo\": \"%s\",\n" "$REPO"
printf " \"target\": \"%s\",\n" "$target"
printf " \"withSkill\": %s,\n" "$skill_json"
printf " \"os\": \"%s\",\n" "$(detect_os)"
printf " \"frameworkDir\": \"%s\",\n" "$FRAMEWORK_REL"
printf " \"commandsDir\": \"%s\",\n" "$(target_commands_dir "$target")"
printf " \"skillDir\": \"%s\",\n" "$skill_dir"
printf " \"installedAt\": \"%s\",\n" "$(iso_timestamp)"
printf " \"files\": ["
local first=1
local file
while IFS= read -r file; do
[[ -n "$file" ]] || continue
if [[ "$first" -eq 1 ]]; then printf "\n"; first=0; else printf ",\n"; fi
printf " \"%s\"" "$file"
done <<< "$files"
if [[ "$first" -eq 0 ]]; then printf "\n "; fi
printf "]\n"
printf "}\n"
} > "$manifest"
}
# ---------------------------------------------------------------------------
# Instalação e remoção
# ---------------------------------------------------------------------------
safe_rel_path() {
[[ -n "$1" && "${1:0:1}" != "/" && "$1" != *".."* ]]
}
# Outra ferramenta (diferente de $1) usa a mesma pasta de skill?
skill_dir_shared() {
local target="$1"
local skill_dir="$2"
local other manifest
for other in $(installed_targets); do
[[ "$other" != "$target" ]] || continue
manifest="$(manifest_path "$other")"
if [[ "$(json_value "$manifest" withSkill)" == "true" && "$(json_value "$manifest" skillDir)" == "$skill_dir" ]]; then
return 0
fi
done
return 1
}
prune_empty_dirs() {
local dir
for dir in .claude/commands .claude/skills .claude .cursor/commands .cursor .github/prompts .github \
.opencode/commands .opencode .agents/skills .agents; do
rmdir "${PROJECT_DIR}/${dir}" 2>/dev/null || true
done
}
remove_target_files() {
local target="$1"
local manifest
manifest="$(manifest_path "$target")"
[[ -f "$manifest" ]] || return 0
local file
while IFS= read -r file; do
safe_rel_path "$file" || continue
rm -f "${PROJECT_DIR}/${file}"
done < <(manifest_files "$manifest")
local skill_dir
skill_dir="$(json_value "$manifest" skillDir)"
if [[ "$(json_value "$manifest" withSkill)" == "true" ]] && safe_rel_path "$skill_dir" \
&& [[ "$skill_dir" == *"/${SKILL_NAME}" ]] && ! skill_dir_shared "$target" "$skill_dir"; then
rm -rf "${PROJECT_DIR:?}/${skill_dir}"
fi
}
backup_existing() {
local target="$1"
local backup_dir
backup_dir="${PROJECT_DIR}/.lgpd-auditor-backup/$(date +%Y%m%d%H%M%S)"
mkdir -p "$backup_dir"
if [[ -d "${PROJECT_DIR}/${FRAMEWORK_REL}" ]]; then
mkdir -p "${backup_dir}/$(dirname "$FRAMEWORK_REL")"
cp -R "${PROJECT_DIR}/${FRAMEWORK_REL}" "${backup_dir}/${FRAMEWORK_REL}"
fi
local manifest file skill_dir
manifest="$(manifest_path "$target")"
if [[ -f "$manifest" ]]; then
while IFS= read -r file; do
safe_rel_path "$file" || continue
if [[ -f "${PROJECT_DIR}/${file}" ]]; then
mkdir -p "${backup_dir}/$(dirname "$file")"
cp "${PROJECT_DIR}/${file}" "${backup_dir}/${file}"
fi
done < <(manifest_files "$manifest")
skill_dir="$(json_value "$manifest" skillDir)"
if safe_rel_path "$skill_dir" && [[ -d "${PROJECT_DIR}/${skill_dir}" ]]; then
mkdir -p "${backup_dir}/$(dirname "$skill_dir")"
cp -R "${PROJECT_DIR}/${skill_dir}" "${backup_dir}/${skill_dir}"
fi
fi
log_info "Backup criado em ${backup_dir}"
log_info "Dica: adicione .lgpd-auditor-backup/ ao .gitignore do projeto."
}
install_framework() {
local framework_dir="${PROJECT_DIR}/${FRAMEWORK_REL}"
local saved_state="${TMP_ROOT}/install-state"
if [[ -d "${framework_dir}/.install" ]]; then
rm -rf "$saved_state"
mv "${framework_dir}/.install" "$saved_state"
fi
rm -rf "$framework_dir"
mkdir -p "$(dirname "$framework_dir")"
cp -R "${SOURCE_ROOT}/${FRAMEWORK_REL}" "$framework_dir"
rm -rf "${framework_dir}/.install"
find "$framework_dir" -name .DS_Store -type f -delete 2>/dev/null || true
if [[ -d "$saved_state" ]]; then
mv "$saved_state" "${framework_dir}/.install"
fi
}
install_target() {
local target="$1"
local skill="$2"
remove_target_files "$target"
install_framework
local files=""
local commands_dir
commands_dir="$(target_commands_dir "$target")"
if [[ -n "$commands_dir" ]]; then
mkdir -p "${PROJECT_DIR}/${commands_dir}"
local src stem rel
for src in "${SOURCE_ROOT}"/commands/*.md; do
[[ -f "$src" ]] || continue
stem="$(basename "$src" .md)"
rel="${commands_dir}/$(target_command_file "$target" "$stem")"
render_command "$target" "$src" "${PROJECT_DIR}/${rel}"
files="${files}${rel}"$'\n'
done
[[ -n "$files" ]] || die "Nenhum comando encontrado em ${SOURCE_ROOT}/commands."
fi
local skill_dir=""
if [[ "$skill" == "1" ]]; then
skill_dir="$(target_skill_dir "$target")"
mkdir -p "${PROJECT_DIR}/${skill_dir}"
cp "${SOURCE_ROOT}/SKILL.md" "${PROJECT_DIR}/${skill_dir}/SKILL.md"
fi
write_manifest "$target" "$skill" "$files" "$skill_dir"
prune_empty_dirs
log_ok "$(target_label "$target") instalado (v${SOURCE_VERSION})."
}
warn_version_drift() {
local target other installed_version
target="$1"
for other in $(installed_targets); do
[[ "$other" != "$target" ]] || continue
installed_version="$(json_value "$(manifest_path "$other")" version)"
if [[ "$installed_version" != "$SOURCE_VERSION" ]]; then
log_warn "Os comandos de ${other} estão na v${installed_version}, mas o framework agora está na v${SOURCE_VERSION}. Rode a ação update para alinhar."
fi
done
}
# ---------------------------------------------------------------------------
# Ações
# ---------------------------------------------------------------------------
run_install() {
resolve_ref
guard_not_source_repo
if [[ "$NON_INTERACTIVE" -eq 0 ]]; then
print_banner "$(ref_label)"
log_info "Sistema operacional: $(detect_os)"
log_info "Projeto: ${PROJECT_DIR}"
printf "\n"
fi
if [[ -z "$TARGET" ]]; then
[[ "$NON_INTERACTIVE" -eq 0 ]] || die "Informe --target no modo --non-interactive."
local choice
choice="$(choose_index "1 - Selecione a ferramenta" \
"$(target_label claude)" "$(target_label cursor)" "$(target_label vscode)" \
"$(target_label opencode)" "$(target_label agents)")"
TARGET="$(printf "%s" "$SUPPORTED_TARGETS" | cut -d' ' -f"$choice")"
else
[[ "$NON_INTERACTIVE" -eq 1 ]] || printf "1 - Ferramenta\n > %s\n" "$(target_label "$TARGET")"
fi
if [[ "$TARGET" == "agents" ]]; then
[[ "$WITH_SKILL" != "0" ]] || die "A opção agents não tem slash commands: a skill é obrigatória (remova --no-skill)."
WITH_SKILL=1
[[ "$NON_INTERACTIVE" -eq 1 ]] || printf "2 - Skill\n > sim (obrigatória para agents: é a forma de acionar a auditoria)\n"
elif [[ -z "$WITH_SKILL" ]]; then
WITH_SKILL=0
if [[ "$NON_INTERACTIVE" -eq 0 ]]; then
prompt_out "2 - Instalar também a skill?"$'\n'
prompt_out " Permite acionar a auditoria em linguagem natural, sem slash command."$'\n'
if confirm " Instalar a skill?" "n"; then WITH_SKILL=1; fi
fi
fi
local commands_dir skill_label
commands_dir="$(target_commands_dir "$TARGET")"
skill_label="não"
if [[ "$WITH_SKILL" == "1" ]]; then skill_label="sim → ${PROJECT_DIR}/$(target_skill_dir "$TARGET")"; fi
printf "\nResumo da instalação\n"
printf " Ferramenta: %s\n" "$(target_label "$TARGET")"
printf " Versão: %s\n" "$(ref_label)"
printf " Framework: %s/%s\n" "$PROJECT_DIR" "$FRAMEWORK_REL"
if [[ -n "$commands_dir" ]]; then
printf " Comandos: %s/%s\n" "$PROJECT_DIR" "$commands_dir"
fi
printf " Skill: %s\n" "$skill_label"
if [[ -f "$(manifest_path "$TARGET")" ]]; then
printf " Atenção: já existe uma instalação para %s (v%s); ela será substituída.\n" \
"$TARGET" "$(json_value "$(manifest_path "$TARGET")" version)"
fi
printf "\n"
if [[ "$NON_INTERACTIVE" -eq 0 ]]; then
confirm "Confirmar instalação?" "y" || { log_warn "Instalação cancelada."; exit 0; }
if [[ -d "${PROJECT_DIR}/${FRAMEWORK_REL}" ]] && confirm "Instalação existente detectada. Criar backup antes de substituir?" "y"; then
backup_existing "$TARGET"
fi
fi
fetch_source
guard_not_source_repo
install_target "$TARGET" "$WITH_SKILL"
warn_version_drift "$TARGET"
print_next_steps "$TARGET" "$WITH_SKILL"
}
run_update() {
local targets
if [[ -n "$TARGET" ]]; then
[[ -f "$(manifest_path "$TARGET")" ]] || die_with_code "$EXIT_NOT_FOUND" "Nenhuma instalação de ${TARGET} encontrada em ${PROJECT_DIR}."
targets="$TARGET"
else
targets="$(installed_targets)"
[[ -n "$targets" ]] || die_with_code "$EXIT_NOT_FOUND" "Nenhuma instalação encontrada em ${PROJECT_DIR}. Use a ação install."
fi
resolve_ref
guard_not_source_repo
printf "\nResumo da atualização\n"
printf " Projeto: %s\n" "$PROJECT_DIR"
printf " Versão: %s\n" "$(ref_label)"
local target
for target in $targets; do
printf " - %s (atual: v%s)\n" "$(target_label "$target")" "$(json_value "$(manifest_path "$target")" version)"
done
printf "\n"
if [[ "$NON_INTERACTIVE" -eq 0 ]]; then
confirm "Confirmar atualização?" "y" || { log_warn "Atualização cancelada."; exit 0; }
fi
fetch_source
guard_not_source_repo
local skill
for target in $targets; do
skill=0
if [[ "$(json_value "$(manifest_path "$target")" withSkill)" == "true" ]]; then skill=1; fi
if [[ -n "$WITH_SKILL" && -n "$TARGET" && "$target" != "agents" ]]; then skill="$WITH_SKILL"; fi
install_target "$target" "$skill"
done
}
run_uninstall() {
local installed
installed="$(installed_targets)"
[[ -n "$installed" ]] || die_with_code "$EXIT_NOT_FOUND" "Nenhuma instalação encontrada em ${PROJECT_DIR}."
local targets=""
if [[ -n "$TARGET" ]]; then
[[ -f "$(manifest_path "$TARGET")" ]] || die_with_code "$EXIT_NOT_FOUND" "Nenhuma instalação de ${TARGET} encontrada em ${PROJECT_DIR}."
targets="$TARGET"
elif [[ "$NON_INTERACTIVE" -eq 1 || "$(printf "%s\n" "$installed" | wc -l | tr -d ' ')" -eq 1 ]]; then
targets="$installed"
else
local options="" target choice count
for target in $installed; do options="${options}${target} "; done
# shellcheck disable=SC2086
choice="$(choose_index "Qual instalação remover?" $options "todas")"
count="$(printf "%s\n" "$installed" | wc -l | tr -d ' ')"
if [[ "$choice" -gt "$count" ]]; then
targets="$installed"
else
targets="$(printf "%s\n" "$installed" | sed -n "${choice}p")"
fi
fi
printf "\nResumo da remoção\n"
printf " Projeto: %s\n" "$PROJECT_DIR"
local target
for target in $targets; do
printf " - %s\n" "$(target_label "$target")"
done
printf "\n"
if [[ "$NON_INTERACTIVE" -eq 0 ]]; then
confirm "Confirmar remoção?" "n" || { log_warn "Remoção cancelada."; exit 0; }
fi
for target in $targets; do
remove_target_files "$target"
rm -f "$(manifest_path "$target")"
log_ok "$(target_label "$target") removido."
done
if [[ -z "$(installed_targets)" ]]; then
rm -rf "${PROJECT_DIR:?}/${FRAMEWORK_REL}"
log_ok "Framework removido de ${PROJECT_DIR}/${FRAMEWORK_REL}."
fi
prune_empty_dirs
}
run_check() {
local installed
installed="$(installed_targets)"
[[ -n "$installed" ]] || die_with_code "$EXIT_NOT_FOUND" "Nenhuma instalação encontrada em ${PROJECT_DIR}."
local broken=0
if [[ ! -f "${PROJECT_DIR}/${FRAMEWORK_REL}/core/auditor-core.md" ]]; then
log_error "Framework incompleto em ${PROJECT_DIR}/${FRAMEWORK_REL}."
broken=1
fi
local target manifest file missing skill_dir version newest=""
for target in $installed; do
manifest="$(manifest_path "$target")"
version="$(json_value "$manifest" version)"
missing=0
while IFS= read -r file; do
[[ -f "${PROJECT_DIR}/${file}" ]] || { log_error "${target}: arquivo ausente ${file}"; missing=1; }
done < <(manifest_files "$manifest")
skill_dir="$(json_value "$manifest" skillDir)"
if [[ "$(json_value "$manifest" withSkill)" == "true" && ! -f "${PROJECT_DIR}/${skill_dir}/SKILL.md" ]]; then
log_error "${target}: skill ausente em ${skill_dir}"
missing=1
fi
if [[ "$missing" -eq 0 ]]; then
log_ok "$(target_label "$target") — v${version}, skill: $(json_value "$manifest" withSkill), instalado em $(json_value "$manifest" installedAt)"
else
broken=1
fi
done
newest="$(fetch_latest_tag || true)"
if [[ -n "$newest" && "v${version}" != "$newest" ]]; then
log_info "Versão publicada mais recente: ${newest}. Rode a ação update para atualizar."
fi
if [[ "$broken" -eq 1 ]]; then
log_error "Instalação com problemas. Rode a ação install novamente para corrigir."
exit 1
fi
}
main() {
parse_args "$@"
resolve_project_dir
TMP_ROOT="$(mktemp -d)"
trap cleanup EXIT
case "$ACTION" in
install) run_install ;;
update) run_update ;;
uninstall) run_uninstall ;;
check) run_check ;;
esac
}
main "$@"
Related skills
| Skill | Stars | Updated | Works with | Status | Install |
|---|---|---|---|---|---|
| rea-analysis-optimizationmorluto/reaOptimize REA providers and shared analysis workflows for agent context, latency, CPU, and memory while preserving correctness and Evidence. Use for analysis bottlenecks and cache or query design; CI/test-suite optimization belongs to rea-ci-tests-audit. | Stars: 472k | Updated | Claude CodeCodex | Verified | Install |
| rea-ci-tests-auditmorluto/reaAudit REA CI and test suites for correctness, fixture drift, false passes, and measured performance; use for suite or workflow investigations and efficiency changes, rather than ordinary feature testing or a single test failure. | Stars: 472k | Updated | Claude CodeCodex | Verified | Install |
| rea-tool-designmorluto/reaAudit, investigate, design, or change REA investigation tools, CLI/MCP contracts, provider capabilities, and Evidence semantics. | Stars: 472k | Updated | Claude CodeCodex | Verified | Install |
| ponytail-auditDietrichGebert/ponytailQuality audit of the whole repo: bugs, security, real load, missing tests, speed, and what to delete. Most important first. | Stars: 196k | Updated | Claude CodeCodex | Verified | Install |