fn_registry/.claude/commands/compile.md

/compile — Compila la app actual y la copia al escritorio de Windows

Compila una app del registry para los targets que soporte (Windows via MinGW, Android via Gradle/NDK si esta configurado) y deja el resultado en /mnt/c/Users/lucas/Desktop/apps/<app>/, listo para usar desde Windows.

Pensado para apps C++ del workspace cpp/ (donde ya hay toolchain mingw-w64.cmake y build dir cpp/build/windows/). Si en el futuro hay apps Android (Gradle wrapper o NDK), tambien las detecta.

Argumento

$ARGUMENTS — opcional. Nombre de la app a compilar (ej: chart_demo, registry_dashboard).

• Sin argumento: detectar la app desde pwd (si estas dentro de cpp/apps/<X>/ o projects/*/apps/<X>/).
• Si no hay app deducible y no se pasa argumento → listar apps disponibles y pedir nombre.
• Si se pasa argumento, usarlo directamente.

Pasos

1. Resolver la app y su directorio fuente

ROOT=/home/lucas/fn_registry
APP_ARG="$ARGUMENTS"

# Detectar desde CWD si no hay argumento
if [ -z "$APP_ARG" ]; then
  CWD="$(pwd)"
  case "$CWD" in
    "$ROOT"/cpp/apps/*|"$ROOT"/projects/*/apps/*)
      APP_ARG="$(basename "$CWD")" ;;
  esac
fi

# Si sigue vacio, listar apps y abortar
if [ -z "$APP_ARG" ]; then
  echo "Apps disponibles:"
  ls "$ROOT"/cpp/apps/ 2>/dev/null
  ls "$ROOT"/projects/*/apps/ 2>/dev/null
  echo "Uso: /compile <app_name>"
  exit 1
fi

# Buscar el directorio real
APP_DIR=""
for cand in "$ROOT/cpp/apps/$APP_ARG" "$ROOT"/projects/*/apps/"$APP_ARG"; do
  [ -d "$cand" ] && APP_DIR="$cand" && break
done

if [ -z "$APP_DIR" ]; then
  echo "No encuentro app '$APP_ARG' en cpp/apps/ ni projects/*/apps/"
  exit 1
fi
echo "App: $APP_ARG"
echo "Dir: $APP_DIR"

2. Detectar targets soportados

Examinar el app.md y los archivos del directorio para decidir que se puede compilar:

• Windows (MinGW): si la app tiene CMakeLists.txt y se registra en cpp/CMakeLists.txt (es decir, aparece como subdirectorio en cpp/build/windows/apps/<APP>/). Default para apps C++.
• Android: si existe AndroidManifest.xml, build.gradle, build.gradle.kts o carpeta android/ dentro de $APP_DIR. (Hoy no hay ninguna; saltar silenciosamente.)
• Linux (opcional, no por defecto): el build dir cpp/build/ ya genera el binario para Linux. Solo se hace si el usuario lo pide explicitamente.

TARGETS=()
[ -f "$APP_DIR/CMakeLists.txt" ] && TARGETS+=("windows")

if [ -f "$APP_DIR/AndroidManifest.xml" ] || \
   [ -f "$APP_DIR/build.gradle" ] || \
   [ -f "$APP_DIR/build.gradle.kts" ] || \
   [ -d "$APP_DIR/android" ]; then
  TARGETS+=("android")
fi

if [ ${#TARGETS[@]} -eq 0 ]; then
  echo "No se detecta ningun target compilable en $APP_DIR"
  exit 1
fi
echo "Targets: ${TARGETS[*]}"

3. Compilar Windows (cross-compile MinGW)

Solo si windows esta en TARGETS.

BUILD_WIN="$ROOT/cpp/build/windows"

# Configurar build dir si no existe
if [ ! -f "$BUILD_WIN/CMakeCache.txt" ]; then
  mkdir -p "$BUILD_WIN"
  cmake -S "$ROOT/cpp" -B "$BUILD_WIN" \
    -DCMAKE_TOOLCHAIN_FILE="$ROOT/cpp/toolchains/mingw-w64.cmake" \
    -DCMAKE_BUILD_TYPE=Release
fi

# Compilar SOLO el target de la app (no todo el arbol)
cmake --build "$BUILD_WIN" --target "$APP_ARG" -j"$(nproc)"

Si el target no existe en CMake (porque la app no esta registrada en cpp/CMakeLists.txt), reportar y proponer registrarla siguiendo cpp_apps.md §5. NO autoregistrarla sin confirmacion del usuario.

4. Copiar a /mnt/c/Users/lucas/Desktop/apps/<APP>/

Replica el flujo documentado en memoria (feedback_no_adminlocal.md): el .exe + las TTFs de fuentes que el shell ImGui necesita. NO usar AdminLocal.

DEST="/mnt/c/Users/lucas/Desktop/apps/$APP_ARG"
mkdir -p "$DEST"

EXE_SRC="$BUILD_WIN/apps/$APP_ARG/$APP_ARG.exe"
if [ ! -f "$EXE_SRC" ]; then
  echo "ERROR: no se ha generado $EXE_SRC"
  exit 1
fi

cp -v "$EXE_SRC" "$DEST/"

# TTFs (estan junto al exe tras el build, copiados por add_imgui_app)
for ttf in "$BUILD_WIN/apps/$APP_ARG"/*.ttf; do
  [ -f "$ttf" ] && cp -v "$ttf" "$DEST/"
done

# Assets opcionales (carpeta assets/ junto al exe del build)
if [ -d "$BUILD_WIN/apps/$APP_ARG/assets" ]; then
  rsync -a --delete "$BUILD_WIN/apps/$APP_ARG/assets/" "$DEST/assets/"
fi

echo "OK: $APP_ARG -> $DEST"

5. Compilar Android (solo si TARGETS contiene android)

Hoy no hay apps Android en el registry, asi que esta rama no se ejecuta. Cuando se anada la primera, este es el patron previsto:

if [[ " ${TARGETS[*]} " == *" android "* ]]; then
  ANDROID_DIR="$APP_DIR"
  [ -d "$APP_DIR/android" ] && ANDROID_DIR="$APP_DIR/android"

  cd "$ANDROID_DIR"
  if [ -x "./gradlew" ]; then
    ./gradlew assembleRelease
    APK="$(find "$ANDROID_DIR/app/build/outputs/apk/release" -name '*.apk' | head -n1)"
    [ -n "$APK" ] && cp -v "$APK" "/mnt/c/Users/lucas/Desktop/apps/$APP_ARG/"
  else
    echo "android: no hay ./gradlew en $ANDROID_DIR — saltando."
  fi
fi

Cuando llegue la primera app Android, este bloque puede ampliarse (firma, ABI splits, etc.).

6. Resumen

Imprime al final una linea por target con:

• Tamano del binario (ls -lh)
• Path final en /mnt/c/Users/lucas/Desktop/apps/<APP>/
• Nombre del exe/apk

Notas

• El build de Windows usa cpp/build/windows/ (no cpp/build/). El de Linux es cpp/build/. Coexisten sin conflicto.
• El toolchain mingw-w64.cmake ya configura linkado estatico (-static-libgcc -static-libstdc++ -lwinpthread) — el .exe resultante es self-contained y no necesita DLLs en el escritorio.
• Si se pasa una app que vive en projects/<proj>/apps/<APP>/, el target CMake sigue siendo <APP> (registrado en cpp/CMakeLists.txt con add_subdirectory(${PROJ_DIR}/apps/<APP> ${CMAKE_BINARY_DIR}/apps/<APP>)).
• NO tocar AdminLocal ni instalar nada en Program Files — solo el escritorio del usuario.