🎯 08_14 - Asset Selection System

Sistema completo de selección, configuración y empaquetado de assets para plugins AudioLab.

📦 Módulos

08_14_00 - Packaging Configuration

Sistema de configuración de empaquetado con soporte multi-plataforma.

Componentes: - AssetInclusionRules: Reglas glob con wildcards (**/*.wav, presets/**/*.json) - PlatformSpecificAssets: Assets específicos por Windows/macOS/Linux - InstallerConfiguration: Config de instaladores (NSIS/PKG/DEB) - JSON Schema: packaging_config.json validado

08_14_01 - Selection Criteria

Criterios de selección de assets: quality tiers, requisitos, licencias, inventario.

Componentes: - QualityTierSelector: Draft/Pro/Ultra tiers con límites de tamaño - PlatformRequirements: Validación de requisitos del sistema - LicenseChecker: Compliance de licencias (MIT/GPL/Apache/etc) - AssetInventory: Inventario completo con hashes y metadata - VersionTracking: Versionado semántico y changelog

🚀 Quick Start

Ejemplo Completo

#include "AssetInclusionRules.hpp"
#include "PlatformSpecificAssets.hpp"
#include "InstallerConfiguration.hpp"
#include "QualityTierSelector.hpp"
#include "LicenseChecker.hpp"
#include "AssetInventory.hpp"

using namespace audiolab::plugins::packaging;

int main() {
    // 1. Configurar reglas de inclusión
    AssetInclusionRules rules;
    rules.addRule({"**/*.dll", true, Platform::Windows});
    rules.addRule({"**/*.vst3", true, Platform::All});
    rules.addRule({"samples/**/*.wav", true, Platform::All, QualityTier::Ultra});
    rules.addRule({"temp/**", false, Platform::All, QualityTier::All, 100});

    // 2. Seleccionar tier de calidad
    QualityTierSelector tierSelector;
    auto tier = tierSelector.selectTierBySize("TS_Compressor", 20 * 1024 * 1024);
    // Result: QualityTier::Pro (fits in 20MB)

    // 3. Seleccionar assets según reglas y tier
    auto selectedAssets = rules.selectAssets(
        "/build/output",
        Platform::Windows,
        tier
    );

    std::cout << "Selected " << selectedAssets.size() << " assets\n";

    // 4. Verificar licencias
    LicenseChecker licenseChecker;
    LicenseChecker::ProjectLicense projectLicense;
    projectLicense.type = LicenseType::Proprietary;
    projectLicense.commercialUse = true;
    licenseChecker.setProjectLicense(projectLicense);

    auto validation = licenseChecker.validateAllAssets();
    if (!validation.allCompliant) {
        std::cerr << validation.generateReport();
        return 1;
    }

    // 5. Crear inventario
    AssetInventory inventory;
    AssetInventory::ScanOptions scanOptions;
    scanOptions.computeHashes = true;
    scanOptions.excludePatterns = {".git", "temp"};

    inventory.scanDirectory("/build/output", scanOptions);

    auto stats = inventory.getStatistics();
    std::cout << "Total size: " << (stats.totalSize / 1024 / 1024) << " MB\n";

    // 6. Configurar instalador
    InstallerConfiguration installer;
    InstallerConfiguration::Configuration winConfig;
    winConfig.type = InstallerType::NSIS;
    winConfig.metadata.productName = "TS_Compressor";
    winConfig.metadata.version = "1.0.0";
    winConfig.paths = InstallPaths::getDefaultPaths(Platform::Windows);

    installer.setConfiguration(Platform::Windows, winConfig);

    // 7. Generar script de instalador
    auto script = installer.generateInstallerScript(Platform::Windows);
    std::ofstream(script.filename) << script.content;

    std::cout << "Package ready for deployment!\n";
    return 0;
}

Configuración JSON

Archivo product_packaging.json:

{
  "product": "TS_Compressor",
  "version": "1.0.0",
  "publisher": "AudioLab",
  "platforms": {
    "windows": {
      "installer": "NSIS",
      "assets": [
        {"pattern": "bin/**/*.dll", "tier": "all"},
        {"pattern": "*.vst3", "tier": "all"},
        {"pattern": "presets/**/*.json", "tier": "all"},
        {"pattern": "samples/**/*.wav", "tier": "ultra"}
      ],
      "installPaths": {
        "vst3": "%PROGRAMFILES%\\Common Files\\VST3",
        "presets": "%APPDATA%\\AudioLab\\Presets"
      },
      "metadata": {
        "productName": "TS Compressor",
        "description": "Professional dynamics processor",
        "publisher": "AudioLab",
        "guid": "{12345678-1234-1234-1234-123456789012}"
      }
    },
    "macos": {
      "installer": "PKG",
      "assets": [
        {"pattern": "*.vst3", "tier": "all"},
        {"pattern": "*.component", "tier": "all"}
      ],
      "installPaths": {
        "vst3": "/Library/Audio/Plug-Ins/VST3",
        "au": "/Library/Audio/Plug-Ins/Components"
      }
    }
  },
  "tiers": {
    "draft": {
      "include": ["bin/**", "presets/factory/*.json"],
      "exclude": ["docs/**", "samples/**"],
      "maxSize": 10485760
    },
    "pro": {
      "include": ["**"],
      "exclude": ["samples/ultra/**"],
      "maxSize": 52428800
    },
    "ultra": {
      "include": ["**"],
      "additionalAssets": ["samples/high_quality/**"]
    }
  },
  "globalExclusions": [
    "**/.git/**",
    "**/.DS_Store",
    "**/Thumbs.db",
    "**/*.pdb"
  ]
}

📊 Quality Tiers

Tier	Size Limit	Use Case	Assets
Draft	<10MB	Development, fast iteration	Minimal: binaries + factory presets
Pro	10-50MB	Standard release	Full plugin + docs + presets
Ultra	>50MB	Premium release	Everything + samples + extras

🔧 Workflow Típico

1. Development (Draft Tier)

# Seleccionar tier Draft para desarrollo rápido
./package.sh --tier draft --platform windows
# Output: TS_Compressor_Draft_Win.zip (8MB)

2. Testing (Pro Tier)

# Tier Pro para QA
./package.sh --tier pro --platform all
# Output: TS_Compressor_Pro_Win.exe (28MB)
#         TS_Compressor_Pro_Mac.pkg (25MB)

3. Release (Ultra Tier)

# Tier Ultra para release final
./package.sh --tier ultra --platform all --verify-licenses
# Output: TS_Compressor_Ultra_Win.exe (68MB)
#         Includes all samples and documentation

📋 Checklist de Deployment

Pre-packaging

• Compilar todos los targets (Release)
• Ejecutar tests unitarios
• Verificar versiones semánticas
• Actualizar changelog

Asset Selection

• Escanear directorio de build
• Aplicar reglas de inclusión/exclusión
• Seleccionar quality tier apropiado
• Validar tamaños estimados

License Compliance

• Verificar licencias de dependencias
• Generar texto de atribución
• Incluir THIRD_PARTY_LICENSES.txt
• Validar compatibilidad comercial

Platform-Specific

• Configurar paths de instalación
• Validar requisitos del sistema
• Generar scripts de instalador
• Firmar binarios (Windows/macOS)

Verification

• Verificar hashes de assets
• Validar inventario completo
• Test de instalación en VM limpia
• Verificar desinstalación

🛠️ Build System Integration

CMake

# En tu CMakeLists.txt principal
add_subdirectory(08_14_asset_selection/08_14_00_packaging_config)
add_subdirectory(08_14_asset_selection/08_14_01_selection_criteria)

target_link_libraries(your_packaging_tool
    PRIVATE
        packaging_config
        selection_criteria
)

Custom Packaging Tool

// packaging_tool.cpp
#include "AssetInclusionRules.hpp"
#include "QualityTierSelector.hpp"
#include "InstallerConfiguration.hpp"

int main(int argc, char* argv[]) {
    // Parse args: --tier, --platform, --product
    auto tier = parseArg("--tier");  // draft/pro/ultra
    auto platform = parseArg("--platform");
    auto productId = parseArg("--product");

    // Load configuration
    auto config = loadFromJSON("packaging_config.json");

    // Select and package
    packageProduct(productId, platform, tier);

    return 0;
}

📚 Documentación Detallada

• Packaging Configuration README
• Selection Criteria README
• JSON Schema

🎓 Ejemplos Avanzados

Multi-tier Deployment

// Deploy all tiers simultaneously
for (auto tier : {QualityTier::Draft, QualityTier::Pro, QualityTier::Ultra}) {
    for (auto platform : {Platform::Windows, Platform::MacOS, Platform::Linux}) {
        packageProduct("TS_Compressor", platform, tier);
    }
}

Conditional Asset Selection

AssetInclusionRules rules;

// Base assets (all tiers, all platforms)
rules.addRule({"bin/**/*.dll", true, Platform::Windows, QualityTier::All, 0});
rules.addRule({"*.vst3", true, Platform::All, QualityTier::All, 0});

// Platform-specific
rules.addRule({"*.component", true, Platform::MacOS, QualityTier::All, 0});

// Tier-specific
rules.addRule({"docs/**", true, Platform::All, QualityTier::Pro, 0});
rules.addRule({"samples/**", true, Platform::All, QualityTier::Ultra, 0});

// Exclusions (high priority)
rules.addRule({"**/*.pdb", false, Platform::All, QualityTier::All, 100});
rules.addRule({"temp/**", false, Platform::All, QualityTier::All, 100});

✅ Testing

# Test packaging config
cd 08_14_00_packaging_config/tests/build
./test_packaging_config.exe

# Test selection criteria
cd 08_14_01_selection_criteria/tests/build
./test_selection_criteria.exe

📊 Dependencies

08_14 Depende de:

• ✅ 08_12 (Product Catalog) - Product metadata
• ✅ 08_13 (Products) - Actual products to package

08_14 es Bloqueante para:

• Deployment/Release pipelines
• Distribution packages
• App Store submissions

🎯 Status

✅ FASE 1 COMPLETA - Packaging Configuration ✅ FASE 2 COMPLETA - Selection Criteria ✅ Listo para deployment

---

Total Time: 6-10 horas Lines of Code: ~3500 Test Coverage: Completa