sergio/takana

1#!/bin/sh
2# import-batch.sh <pkg...>   |   import-batch.sh -f <listfile>   — Etapa G: importa una TANDA a
3# escala aplicando la ESCALERA DE FALLBACK (memoria etapa-g): por cada paquete intenta primero nix
4# (Rust/Go/CLI moderno, ~100% en musl) y, si el import falla (src no-clasificable, eval error), cae
5# a Alpine (que TRAE los parches de musl) probando `main` y luego `community`. Escribe la receta a
6# OUTDIR/<pkg>.toml y, al final, MIDE EL YIELD POR TIER (nix / alpine / fallaron) — el dato real que
7# decide dónde está la fricción al escalar, sin especular.
8#
9# Es sólo el IMPORT (barato). El trabajo real es construir: encadená con
10#   scripts/pin-recipes.sh "$OUTDIR"/*.toml     (Fase 2: tag→SHA en lote)
11#   scripts/build-repo.sh                       (Etapa F: pack --build + repo firmado)
12#
13# Ej:  scripts/import-batch.sh ripgrep fd bat hyperfine
14#      scripts/import-batch.sh -f tandas/cli-rust.txt
15#      OUTDIR=recipes/incoming scripts/import-batch.sh sd dust
16# Env: OUTDIR (default recipes), PREFER (nix|alpine; default nix — alpine antepone Alpine para tandas
17#      C, que necesitan sus parches musl), NIX_STORE (p.ej. $HOME/.nixstore si /nix/store no es
18#      escribible), ALPINE_BRANCH (default master), HAMMER (cmd del cli).  Un nombre puede mapear
19#      nix→alpine distintos con `nixattr=alpinepkg` (p.ej. `the_silver_searcher=the-silver-searcher`).
20set -eu
21
22here=$(dirname "$0")
23OUTDIR="${OUTDIR:-recipes}"
24export OUTDIR  # alpine-import.sh baja sus .patch acá
25
26# Resolver la lista de paquetes: -f <fichero> (una entrada por línea, '#' comenta) o argumentos.
27if [ "${1:-}" = "-f" ]; then
28  [ -n "${2:-}" ] || { echo "uso: import-batch.sh -f <listfile>" >&2; exit 1; }
29  pkgs=$(sed -e 's/#.*//' -e '/^[[:space:]]*$/d' "$2")
30else
31  [ "$#" -gt 0 ] || { echo "uso: import-batch.sh <pkg...> | -f <listfile>" >&2; exit 1; }
32  pkgs=$(printf '%s\n' "$@")
33fi
34
35# Orden de fuentes: PREFER=nix (default, tier-1 Rust/Go) o PREFER=alpine (tier-2 C, trae parches musl).
36case "${PREFER:-nix}" in
37  alpine) TIERS="alpine-main alpine-community nix" ;;
38  nix|*)  TIERS="nix alpine-main alpine-community" ;;
39esac
40
41mkdir -p "$OUTDIR"
42nix_n=0; alpine_n=0; failed=""; got=""
43
44# IFS=newline para tolerar una entrada por línea; restaurar después no hace falta (sub-shell del for).
45OLDIFS=$IFS; IFS='
46'
47for entry in $pkgs; do
48  IFS=$OLDIFS
49  # Mapeo opcional nixattr=alpinepkg; si no hay '=', el mismo nombre sirve para ambas fuentes.
50  case $entry in
51    *=*) nixattr=${entry%%=*}; alpinepkg=${entry#*=} ;;
52    *)   nixattr=$entry; alpinepkg=$entry ;;
53  esac
54  out="$OUTDIR/${nixattr}.toml"
55
56  printf '%-24s ' "$nixattr" >&2
57  done_pkg=""
58  # Orden de fuentes según PREFER (default nix, ~100% Rust/Go). PREFER=alpine antepone Alpine para
59  # tandas C: el import de nix de un C tiene éxito (tarball) pero SIN los parches musl ⇒ rompería al
60  # construir; Alpine los TRAE. Cada "tier" es una etiqueta y el comando que produce la receta.
61  for tier in $TIERS; do
62    case $tier in
63      nix)            src="nix";             cmd_out=$("$here/nix-import.sh" "$nixattr" 2>/dev/null) || cmd_out="" ;;
64      alpine-main)    src="alpine/main";      cmd_out=$("$here/alpine-import.sh" "$alpinepkg" main 2>/dev/null) || cmd_out="" ;;
65      alpine-comm*)   src="alpine/community"; cmd_out=$("$here/alpine-import.sh" "$alpinepkg" community 2>/dev/null) || cmd_out="" ;;
66    esac
67    if [ -n "$cmd_out" ]; then
68      printf '%s\n' "$cmd_out" > "$out"
69      case $tier in nix) nix_n=$((nix_n + 1)) ;; *) alpine_n=$((alpine_n + 1)) ;; esac
70      got="$got $nixattr"; done_pkg=1
71      echo "✓ $src" >&2
72      break
73    fi
74  done
75  if [ -z "$done_pkg" ]; then
76    failed="$failed $nixattr"
77    echo "✗ ninguna fuente" >&2
78  fi
79done
80
81total=$((nix_n + alpine_n))
82echo >&2
83echo "yield import: $total/$((total + $(printf '%s' "$failed" | wc -w))) — nix=$nix_n, alpine=$alpine_n.${failed:+ FALLARON:$failed}" >&2
84echo "recetas en $OUTDIR/.${got:+ Siguiente: pin + build —} ${got:+scripts/pin-recipes.sh}${got:+ $OUTDIR/*.toml}" >&2
85# Salida limpia en stdout: los nombres importados (para encadenar con xargs si se quiere).
86printf '%s\n' $got