kcreate-scaffolding-gcp-script 0.0.0-stage → 0.2.0

package/skill/scripts/20_validate_file_parity.sh

@@ -0,0 +1,107 @@
+#!/usr/bin/env bash
+# Etapa: Validación — script 1.
+# Compara, por cantidad Y por estructura, los archivos que realmente
+# pertenecen al proyecto (los que git comitearía — ni temporales ni cache)
+# entre live/<SOURCE_ENV>/ y live/<NEW_ENV>/.
+#
+# Uso: 20_validate_file_parity.sh <SOURCE_ENV> <NEW_ENV>
+#
+# Termina con exactamente uno de estos mensajes:
+#   "FILE_PARITY_OK: <n> archivos en ambos lados"              (exit 0)
+#   "FILE_PARITY_MISMATCH: faltan <n>, sobran <m> (ver detalle arriba)"  (exit 1)
+
+set -uo pipefail
+
+SCRIPT_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
+# shellcheck source=lib/common.sh
+source "$SCRIPT_DIR/lib/common.sh"
+
+SOURCE_ENV="${1:-}"
+NEW_ENV="${2:-}"
+[[ -n "$SOURCE_ENV" && -n "$NEW_ENV" ]] || ksc_die "uso: 20_validate_file_parity.sh <SOURCE_ENV> <NEW_ENV>"
+
+REPO_ROOT="$(ksc_repo_root)"
+[[ -d "$REPO_ROOT/live/$SOURCE_ENV" ]] || ksc_die "no existe live/$SOURCE_ENV"
+[[ -d "$REPO_ROOT/live/$NEW_ENV" ]]    || ksc_die "no existe live/$NEW_ENV"
+
+# "Archivos que pertenecen al proyecto" = los que `git add -A` incluiría:
+# ya trackeados (--cached) + nuevos no ignorados (--others --exclude-standard).
+# Así se excluyen automáticamente .terraform/, *.tfstate, plan.binary/.txt,
+# y cualquier otro patrón cubierto por .gitignore — sin mantener una lista
+# de extensiones a mano.
+list_project_files() {
+  local env="$1"
+  (cd "$REPO_ROOT" && git ls-files --cached --others --exclude-standard -- "live/$env/") \
+    | sed "s|^live/$env/||" | sort
+}
+
+# El build (10_build_components.sh) excluye por defecto los componentes
+# opcionales de SOURCE_ENV que no sean "base" (intersección real de
+# live/), salvo que EXTRA_COMPONENTS del config los pida. Comparar contra
+# TODOS los archivos de SOURCE_ENV sin esa misma restricción marcaría como
+# "falta" algo que nunca se intentó copiar a propósito — no es un defecto
+# de construcción. Se restringe la lista de SOURCE_ENV a los mismos
+# componentes que el build intentó, usando el config de NEW_ENV si existe.
+ALLOWED_TOPLEVEL=()
+CONFIG_FILE="$(ksc_config_path "$REPO_ROOT" "$NEW_ENV")"
+if [[ -f "$CONFIG_FILE" ]]; then
+  EXTRA_COMPONENTS="$(ksc_hcl_get "$CONFIG_FILE" EXTRA_COMPONENTS 2>/dev/null || true)"
+else
+  EXTRA_COMPONENTS=""
+  ksc_info "no existe $CONFIG_FILE — se compara contra TODOS los componentes de $SOURCE_ENV, sin filtrar por EXTRA_COMPONENTS."
+fi
+mapfile -t BASE_COMPONENTS < <(ksc_base_components "$REPO_ROOT" "$NEW_ENV")
+ALLOWED_TOPLEVEL=("${BASE_COMPONENTS[@]}" "project.hcl" "Makefile" "README.md" ".gitignore")
+IFS=';' read -ra _extra <<<"$EXTRA_COMPONENTS"
+for x in "${_extra[@]}"; do [[ -n "$x" ]] && ALLOWED_TOPLEVEL+=("$x"); done
+
+filter_allowed() {
+  local line top
+  while IFS= read -r line; do
+    top="${line%%/*}"
+    for a in "${ALLOWED_TOPLEVEL[@]}"; do
+      [[ "$top" == "$a" ]] && { printf '%s\n' "$line"; break; }
+    done
+  done
+}
+
+SRC_LIST="/tmp/ksc_parity_src.$$"
+NEW_LIST="/tmp/ksc_parity_new.$$"
+list_project_files "$SOURCE_ENV" | filter_allowed > "$SRC_LIST"
+list_project_files "$NEW_ENV" > "$NEW_LIST"
+
+MISSING="/tmp/ksc_parity_missing.$$"
+EXTRA="/tmp/ksc_parity_extra.$$"
+comm -23 "$SRC_LIST" "$NEW_LIST" > "$MISSING"   # en SOURCE pero no en NEW
+comm -13 "$SRC_LIST" "$NEW_LIST" > "$EXTRA"     # en NEW pero no en SOURCE
+
+SRC_COUNT=$(wc -l < "$SRC_LIST")
+NEW_COUNT=$(wc -l < "$NEW_LIST")
+MISSING_COUNT=$(wc -l < "$MISSING")
+EXTRA_COUNT=$(wc -l < "$EXTRA")
+
+echo "live/$SOURCE_ENV/: $SRC_COUNT archivos de proyecto"
+echo "live/$NEW_ENV/:    $NEW_COUNT archivos de proyecto"
+
+STATUS=0
+if [[ "$MISSING_COUNT" -gt 0 ]]; then
+  echo
+  echo "Archivos de $SOURCE_ENV que NO existen (con ruta equivalente) en $NEW_ENV:"
+  sed 's/^/  - /' "$MISSING"
+  STATUS=1
+fi
+if [[ "$EXTRA_COUNT" -gt 0 ]]; then
+  echo
+  echo "Archivos en $NEW_ENV que no tienen equivalente en $SOURCE_ENV:"
+  sed 's/^/  + /' "$EXTRA"
+  STATUS=1
+fi
+
+rm -f "$SRC_LIST" "$NEW_LIST" "$MISSING" "$EXTRA"
+
+if [[ "$STATUS" -eq 0 ]]; then
+  echo "FILE_PARITY_OK: $SRC_COUNT archivos en ambos lados"
+else
+  echo "FILE_PARITY_MISMATCH: faltan $MISSING_COUNT, sobran $EXTRA_COUNT (ver detalle arriba)"
+fi
+exit "$STATUS"

package/skill/scripts/21_validate_project_pinning.sh

@@ -0,0 +1,105 @@
+#!/usr/bin/env bash
+# Etapa: Validación — script 2.
+# Confirma que, sin importar qué proyecto tenga `gcloud` como default en el
+# momento de ejecutar `terragrunt`, cada componente de live/<NEW_ENV>/
+# resuelve siempre al proyecto correcto. Dos cosas se verifican:
+#
+#   1. live/<NEW_ENV>/project.hcl fija project_id = "<NEW_ENV>" como literal
+#      (la raíz de la cadena de la que todos los componentes heredan).
+#   2. Cada componente que declara `project_id` en sus `inputs` lo hace vía
+#      `local.project_id` (que viene de ese project.hcl por
+#      find_in_parent_folders) — nunca un literal distinto, nunca vacío.
+#   3. Ningún archivo de live/<NEW_ENV>/ contiene todavía el nombre del
+#      entorno fuente (sustitución incompleta real, no solo teórica).
+#
+# Uso: 21_validate_project_pinning.sh <NEW_ENV>
+#
+# Termina con exactamente uno de estos mensajes:
+#   "PROJECT_PINNING_OK: <n> componentes verificados"      (exit 0)
+#   "PROJECT_PINNING_FAILED: <detalle arriba>"              (exit 1)
+
+set -uo pipefail
+
+SCRIPT_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
+# shellcheck source=lib/common.sh
+source "$SCRIPT_DIR/lib/common.sh"
+
+NEW_ENV="${1:-}"
+[[ -n "$NEW_ENV" ]] || ksc_die "uso: 21_validate_project_pinning.sh <NEW_ENV>"
+
+REPO_ROOT="$(ksc_repo_root)"
+NEW_DIR="$REPO_ROOT/live/$NEW_ENV"
+[[ -d "$NEW_DIR" ]] || ksc_die "no existe $NEW_DIR"
+
+CONFIG_FILE="$(ksc_config_path "$REPO_ROOT" "$NEW_ENV")"
+SOURCE_ENV=""
+[[ -f "$CONFIG_FILE" ]] && SOURCE_ENV="$(ksc_hcl_get "$CONFIG_FILE" SOURCE_ENV 2>/dev/null || true)"
+[[ -n "$SOURCE_ENV" ]] || SOURCE_ENV="$(grep -m1 '^SOURCE_ENV=' "$CONFIG_FILE" 2>/dev/null | sed -E 's/^SOURCE_ENV="(.*)"$/\1/')"
+
+FAILURES=()
+
+# --- 1. project.hcl fija el project_id como literal ------------------------
+PROJECT_HCL="$NEW_DIR/project.hcl"
+if [[ ! -f "$PROJECT_HCL" ]]; then
+  FAILURES+=("falta $PROJECT_HCL")
+else
+  pid="$(ksc_hcl_get "$PROJECT_HCL" project_id)"
+  if [[ "$pid" != "$NEW_ENV" ]]; then
+    FAILURES+=("$PROJECT_HCL: project_id = \"$pid\" (debería ser literal \"$NEW_ENV\")")
+  fi
+fi
+
+# --- 2. cada componente resuelve project_id vía local.project_id -----------
+CHECKED=0
+for tg in "$NEW_DIR"/*/terragrunt.hcl; do
+  [[ -f "$tg" ]] || continue
+  comp="$(basename "$(dirname "$tg")")"
+  CHECKED=$((CHECKED + 1))
+
+  if ! grep -q 'find_in_parent_folders("project.hcl")' "$tg"; then
+    FAILURES+=("$comp: no encontré find_in_parent_folders(\"project.hcl\") — no hereda project_id de la raíz")
+    continue
+  fi
+
+  # No todos los componentes usan una clave llamada exactamente
+  # "project_id" en inputs (org_policies usa `parent = "projects/${local.
+  # project_id}"`, storage_assets/storage_docs usan `project =
+  # local.project_id`). Lo que de verdad importa es que, en algún lado del
+  # archivo, se USE la referencia corta `local.project_id` — la línea que
+  # la DEFINE ("local.project_vars.locals.project_id") no cuenta como uso,
+  # porque ese substring exacto no aparece ahí (locals. != local.).
+  refs="$(grep -c 'local\.project_id' "$tg" || true)"
+  if [[ "$refs" -eq 0 ]]; then
+    FAILURES+=("$comp: nunca referencia local.project_id en el archivo — revisar cómo usa el project id")
+  fi
+done
+
+# --- 3. nada de live/<NEW_ENV>/ menciona ya al entorno fuente --------------
+if [[ -n "$SOURCE_ENV" ]]; then
+  # Se ignoran líneas de comentario (# ...): este skill deja a propósito
+  # una nota en project_iam mencionando a SOURCE_ENV por nombre (guía
+  # §3.12) — eso no es una sustitución incompleta, es documentación. Un
+  # leftover real siempre está en una línea de código (un valor, un
+  # nombre), nunca solo en un comentario.
+  #
+  # Se revisa CADA archivo de texto bajo live/<NEW_ENV>/ (no solo
+  # terragrunt.hcl/project.hcl/README.md) — Review V2 (N-3) encontró que
+  # una lista fija de nombres de archivo deja fuera Makefile/.gitignore
+  # de cada componente, y cualquier archivo nuevo que un componente
+  # agregue en el futuro, sin que nadie lo note.
+  while IFS= read -r -d '' tg_file; do
+    if grep -v '^[[:space:]]*#' "$tg_file" 2>/dev/null | grep -q "$SOURCE_ENV"; then
+      FAILURES+=("$tg_file: todavía contiene \"$SOURCE_ENV\" fuera de un comentario (sustitución incompleta)")
+    fi
+  done < <(find "$NEW_DIR" -maxdepth 2 -type f -print0)
+fi
+
+if [[ "${#FAILURES[@]}" -eq 0 ]]; then
+  echo "PROJECT_PINNING_OK: $CHECKED componentes verificados"
+  exit 0
+fi
+
+echo "Problemas encontrados:"
+printf '  - %s\n' "${FAILURES[@]}"
+echo "PROJECT_PINNING_FAILED: ${#FAILURES[@]} problema(s) (ver detalle arriba)"
+exit 1