@arcadialdev/arcality 3.0.3 → 4.0.0

package/src/services/generatedMissionStore.mjs

@@ -0,0 +1,117 @@
+import fs from 'node:fs';
+import path from 'node:path';
+import { dump, load as loadYaml } from 'js-yaml';
+import { buildMissionIdentity } from './missionGenerator.mjs';
+import { assertGeneratedMissionSchema } from './generatedMissionSchema.mjs';
+
+const YAML_RE = /\.(yaml|yml)$/i;
+
+function toPosix(value) {
+    return String(value || '').split(path.sep).join('/');
+}
+
+function walk(dir, out = []) {
+    if (!fs.existsSync(dir)) return out;
+    const entries = fs.readdirSync(dir, { withFileTypes: true });
+    for (const entry of entries) {
+        const full = path.join(dir, entry.name);
+        if (entry.isDirectory()) {
+            if (entry.name === '_templates') continue;
+            walk(full, out);
+        } else {
+            out.push(full);
+        }
+    }
+    return out;
+}
+
+function sanitizeName(value) {
+    return String(value || 'generated_mission')
+        .trim()
+        .replace(/[^\w.-]+/g, '_')
+        .replace(/_+/g, '_')
+        .replace(/^_+|_+$/g, '') || 'generated_mission';
+}
+
+function ensureDir(dir) {
+    if (!fs.existsSync(dir)) fs.mkdirSync(dir, { recursive: true });
+}
+
+function loadExistingMissionIdentities(targetDir) {
+    const identities = new Set();
+    if (!fs.existsSync(targetDir)) return identities;
+
+    const files = walk(targetDir).filter(file => YAML_RE.test(file)).filter(file => !/[\\/]_collection\.(yaml|yml)$/i.test(file));
+    for (const file of files) {
+        try {
+            const parsed = loadYaml(fs.readFileSync(file, 'utf8'));
+            if (!parsed || typeof parsed !== 'object') continue;
+            const identity = buildMissionIdentity(parsed);
+            if (identity) identities.add(identity);
+        } catch {
+            // Silencioso: si un YAML existente no se puede leer, no bloqueamos la generación.
+        }
+    }
+
+    return identities;
+}
+
+function writeCache(projectRoot, payload) {
+    const cacheDir = path.join(projectRoot, '.arcality', 'cache');
+    ensureDir(cacheDir);
+    fs.writeFileSync(path.join(cacheDir, 'generate-state.json'), JSON.stringify(payload, null, 2), 'utf8');
+}
+
+export function saveGeneratedMissions({ projectRoot, targetDir, missions, dryRun = false }) {
+    const existingIdentities = loadExistingMissionIdentities(targetDir);
+    const created = [];
+    const skipped = [];
+
+    if (!dryRun) ensureDir(targetDir);
+
+    for (const mission of missions) {
+        assertGeneratedMissionSchema(mission);
+        const identity = buildMissionIdentity(mission);
+        if (!identity || existingIdentities.has(identity)) {
+            skipped.push({
+                name: mission.name,
+                page_path: mission.page_path,
+                reason: 'duplicate'
+            });
+            continue;
+        }
+
+        const collectionRel = String(mission.collection || 'generated/general').replace(/^\/+/, '');
+        const targetCollectionDir = path.join(targetDir, collectionRel);
+        const fileName = `${sanitizeName(mission.name)}.yaml`;
+        const filePath = path.join(targetCollectionDir, fileName);
+
+        if (!dryRun) {
+            ensureDir(targetCollectionDir);
+            fs.writeFileSync(filePath, dump(mission, { lineWidth: 120, noRefs: true }), 'utf8');
+        }
+
+        existingIdentities.add(identity);
+        created.push({
+            name: mission.name,
+            page_path: mission.page_path,
+            filePath: toPosix(path.relative(projectRoot, filePath))
+        });
+    }
+
+    const summary = {
+        generated_at: new Date().toISOString(),
+        target_dir: toPosix(path.relative(projectRoot, targetDir) || '.'),
+        total_requested: missions.length,
+        created_count: created.length,
+        skipped_count: skipped.length,
+        created,
+        skipped
+    };
+
+    if (!dryRun) {
+        writeCache(projectRoot, summary);
+    }
+
+    return summary;
+}

package/src/services/generationContext.mjs

@@ -0,0 +1,242 @@
+import fs from 'node:fs';
+import path from 'node:path';
+
+function asTrimmedString(value) {
+    if (typeof value !== 'string') return null;
+    const trimmed = value.trim();
+    return trimmed || null;
+}
+
+function asStringList(value) {
+    if (!Array.isArray(value)) return [];
+    return value.map(asTrimmedString).filter(Boolean);
+}
+
+function normalizeRuleText(value) {
+    return String(value || '')
+        .replace(/^[-*+]\s+/, '')
+        .replace(/^\d+\.\s+/, '')
+        .trim();
+}
+
+function tokenize(value) {
+    return String(value || '')
+        .toLowerCase()
+        .split(/[^a-z0-9áéíóúñ]+/i)
+        .map(token => token.trim())
+        .filter(token => token.length >= 3);
+}
+
+function stripComments(content) {
+    return String(content || '').replace(/<!--[\s\S]*?-->/g, '');
+}
+
+function parseQaContext(projectRoot) {
+    const filePath = path.join(projectRoot, '.arcality', 'qa-context.md');
+    const metaPath = path.join(projectRoot, '.arcality', 'qa-context.meta.json');
+    const result = {
+        exists: false,
+        filePath,
+        status: 'missing',
+        warnings: [],
+        rules: [],
+        tags: [],
+        governance: {
+            exists: false,
+            version: null,
+            updatedBy: null,
+            ownerTeam: null,
+            changeSummary: null
+        }
+    };
+
+    if (fs.existsSync(metaPath)) {
+        try {
+            const parsed = JSON.parse(fs.readFileSync(metaPath, 'utf8'));
+            result.governance = {
+                exists: true,
+                version: asTrimmedString(parsed?.version),
+                updatedBy: asTrimmedString(parsed?.updated_by ?? parsed?.updatedBy),
+                ownerTeam: asTrimmedString(parsed?.owner_team ?? parsed?.ownerTeam),
+                changeSummary: asTrimmedString(parsed?.change_summary ?? parsed?.changeSummary)
+            };
+            result.tags = asStringList(parsed?.tags);
+        } catch {
+            result.warnings.push('qa-context.meta.json no se pudo parsear para generation guidance.');
+        }
+    }
+
+    if (!fs.existsSync(filePath)) {
+        return result;
+    }
+
+    result.exists = true;
+    const raw = stripComments(fs.readFileSync(filePath, 'utf8'));
+    const lines = raw.split(/\r?\n/);
+    let currentSection = 'General';
+    const seen = new Set();
+
+    for (const rawLine of lines) {
+        const line = rawLine.trim();
+        if (!line) continue;
+        if (/^##\s+/.test(line)) {
+            currentSection = line.replace(/^##\s+/, '').trim() || 'General';
+            continue;
+        }
+        if (!/^[-*+]\s+/.test(line) && !/^\d+\.\s+/.test(line)) continue;
+        const rule = normalizeRuleText(line);
+        if (!rule) continue;
+        const dedupeKey = rule.toLowerCase();
+        if (seen.has(dedupeKey)) continue;
+        seen.add(dedupeKey);
+        result.rules.push({
+            section: currentSection,
+            text: rule,
+            tokens: tokenize(rule)
+        });
+    }
+
+    result.status = result.rules.length > 0 ? 'ready' : 'empty';
+    if (result.exists && !result.governance.exists) {
+        result.warnings.push('QA context existe pero no tiene metadata de gobernanza.');
+    }
+    if (result.exists && result.rules.length === 0) {
+        result.warnings.push('QA context sin reglas accionables.');
+    }
+
+    return result;
+}
+
+function parseFeasibilityDoc(projectRoot) {
+    const filePath = path.join(projectRoot, 'BUGSTER_FEATURE_FEASIBILITY.md');
+    const result = {
+        exists: false,
+        filePath,
+        warnings: [],
+        globalHints: [],
+        routeHints: {
+            dynamic: [],
+            checkout: [],
+            form: [],
+            auth: [],
+            list: []
+        }
+    };
+
+    if (!fs.existsSync(filePath)) {
+        return result;
+    }
+
+    result.exists = true;
+    const raw = fs.readFileSync(filePath, 'utf8');
+    const lower = raw.toLowerCase();
+
+    if (lower.includes('pocos escenarios observables y accionables')) {
+        result.globalHints.push('Prioriza escenarios observables y accionables sobre cobertura generica.');
+    }
+    if (lower.includes('rutas dinamicas necesitan ejemplos de parametros')) {
+        result.routeHints.dynamic.push('Si la ruta es dinamica, valida contexto del registro y considera necesidad de parametros de ejemplo.');
+    }
+    if (lower.includes('focus on validation and payment edge cases') || lower.includes('payment edge cases')) {
+        result.routeHints.checkout.push('Enfatiza validaciones y edge cases de pago sin ejecutar cobros reales.');
+    }
+    if (lower.includes('validaciones visibles') || lower.includes('formularios')) {
+        result.routeHints.form.push('Prioriza validaciones visibles, mensajes de error y reglas de captura observables.');
+    }
+    if (lower.includes('autenticacion') || lower.includes('auth')) {
+        result.routeHints.auth.push('Valida autenticacion con feedback observable y estados de acceso consistentes.');
+    }
+    if (lower.includes('filtros') || lower.includes('busqueda') || lower.includes('listado')) {
+        result.routeHints.list.push('Valida exploracion de datos mediante listados, filtros y busqueda cuando aplique.');
+    }
+
+    if (result.globalHints.length === 0) {
+        result.globalHints.push('Prioriza escenarios observables y accionables sobre cobertura generica.');
+    }
+
+    return result;
+}
+
+function buildRouteKeywords(routeEntry) {
+    return Array.from(new Set([
+        ...tokenize(routeEntry.route),
+        ...tokenize(routeEntry.pagePath),
+        ...(routeEntry.tags || []).flatMap(tokenize),
+        ...((routeEntry.signals?.keywords) || []).flatMap(tokenize)
+    ]));
+}
+
+function collectThemeKeywords(routeEntry) {
+    const signals = routeEntry.signals || {};
+    const routeKeywords = buildRouteKeywords(routeEntry);
+    const themes = new Set(routeKeywords);
+
+    if (signals.hasAuth) ['login', 'auth', 'password', 'session', 'acceso'].forEach(value => themes.add(value));
+    if (signals.hasCheckout) ['checkout', 'payment', 'billing', 'pago', 'card'].forEach(value => themes.add(value));
+    if (signals.hasForm || signals.isCrudLike) ['form', 'formulario', 'validacion', 'guardar', 'campo'].forEach(value => themes.add(value));
+    if (signals.isListLike) ['list', 'listado', 'tabla', 'busqueda', 'filtro'].forEach(value => themes.add(value));
+    if (signals.hasSettings) ['settings', 'configuracion', 'preferencias'].forEach(value => themes.add(value));
+    if (signals.hasUpload) ['upload', 'archivo', 'imagen'].forEach(value => themes.add(value));
+    if (signals.isDynamicRoute) ['detalle', 'detail', 'registro', 'contexto'].forEach(value => themes.add(value));
+
+    return Array.from(themes);
+}
+
+function scoreRule(rule, routeKeywords) {
+    const tokens = rule.tokens || [];
+    let score = 0;
+    for (const token of tokens) {
+        if (routeKeywords.includes(token)) score += 2;
+    }
+
+    const lower = rule.text.toLowerCase();
+    if (/(nunca|siempre|obligatorio|critic|must|required|bloque)/i.test(lower)) score += 1;
+    return score;
+}
+
+function inferContextPriority(matchedRules = []) {
+    for (const rule of matchedRules) {
+        if (/(critic|obligatorio|nunca|must|required|seguridad|pago|payment|auth)/i.test(rule.text)) {
+            return 'high';
+        }
+    }
+    return null;
+}
+
+export function loadGenerationContext(projectRoot = process.cwd()) {
+    return {
+        qaContext: parseQaContext(projectRoot),
+        feasibility: parseFeasibilityDoc(projectRoot)
+    };
+}
+
+export function resolveRouteGuidance(routeEntry, generationContext = {}) {
+    const qaContext = generationContext.qaContext || { exists: false, rules: [], tags: [], warnings: [] };
+    const feasibility = generationContext.feasibility || { exists: false, globalHints: [], routeHints: {} };
+    const routeKeywords = collectThemeKeywords(routeEntry);
+
+    const matchedRules = (qaContext.rules || [])
+        .map(rule => ({ ...rule, score: scoreRule(rule, routeKeywords) }))
+        .filter(rule => rule.score > 0)
+        .sort((a, b) => b.score - a.score)
+        .slice(0, 3);
+
+    const feasibilityHints = [...(feasibility.globalHints || [])];
+    const signals = routeEntry.signals || {};
+    if (signals.isDynamicRoute) feasibilityHints.push(...(feasibility.routeHints?.dynamic || []));
+    if (signals.hasCheckout) feasibilityHints.push(...(feasibility.routeHints?.checkout || []));
+    if (signals.hasForm || signals.isCrudLike) feasibilityHints.push(...(feasibility.routeHints?.form || []));
+    if (signals.hasAuth) feasibilityHints.push(...(feasibility.routeHints?.auth || []));
+    if (signals.isListLike) feasibilityHints.push(...(feasibility.routeHints?.list || []));
+
+    return {
+        matchedRules,
+        feasibilityHints: Array.from(new Set(feasibilityHints)).slice(0, 3),
+        priorityOverride: inferContextPriority(matchedRules),
+        extraTags: Array.from(new Set(qaContext.tags || [])).slice(0, 4),
+        contextStatus: {
+            qaContext: qaContext.exists ? qaContext.status : 'missing',
+            feasibility: feasibility.exists ? 'loaded' : 'missing'
+        }
+    };
+}

package/src/services/missionGenerator.mjs

@@ -0,0 +1,328 @@
+function simpleHash(value) {
+    let hash = 0;
+    const text = String(value || '');
+    for (let i = 0; i < text.length; i++) {
+        hash = ((hash << 5) - hash) + text.charCodeAt(i);
+        hash |= 0;
+    }
+    return `h_${Math.abs(hash).toString(36)}`;
+}
+
+function toSentenceCase(value) {
+    const text = String(value || '').trim();
+    if (!text) return text;
+    return text.charAt(0).toUpperCase() + text.slice(1);
+}
+
+function inferCollection(route) {
+    if (route === '/') return 'generated/root';
+    const first = route.replace(/^\/+/, '').split('/')[0] || 'general';
+    return `generated/${first}`;
+}
+
+function normalizeTags(tags = [], promptFocus = '') {
+    const result = new Set(tags.filter(Boolean));
+    if (promptFocus) {
+        const focusTokens = String(promptFocus)
+            .toLowerCase()
+            .split(/[^a-z0-9]+/i)
+            .filter(token => token.length >= 4)
+            .slice(0, 3);
+        for (const token of focusTokens) result.add(token);
+    }
+    return Array.from(result);
+}
+
+function buildPromptFocusSuffix(promptFocus) {
+    if (!promptFocus) return '';
+    return ` Enfoca especialmente la mision en: ${promptFocus}.`;
+}
+
+function buildExpectedFocusSuffix(promptFocus) {
+    if (!promptFocus) return '';
+    return ` Ademas, valida observaciones relacionadas con: ${toSentenceCase(promptFocus)}.`;
+}
+
+function buildMissionVariant(routeEntry, variant, options = {}) {
+    const promptFocus = String(options.prompt || '').trim();
+    const route = routeEntry.route || '/';
+    const baseName = routeEntry.name || 'GEN_route';
+    const variantCode = variant.code ? `_${variant.code}` : '';
+    const guidance = options.routeGuidance || {};
+    const guidanceLines = [];
+
+    if ((guidance.matchedRules || []).length > 0) {
+        guidanceLines.push(
+            'Aplica estas reglas del contexto del cliente durante la validacion: ' +
+            guidance.matchedRules.map(rule => rule.text).join(' | ')
+        );
+    }
+
+    if ((guidance.feasibilityHints || []).length > 0) {
+        guidanceLines.push(
+            'Considera estas prioridades de generacion: ' +
+            guidance.feasibilityHints.join(' | ')
+        );
+    }
+
+    const prompt = [
+        variant.prompt || routeEntry.prompt,
+        guidanceLines.join(' '),
+        buildPromptFocusSuffix(promptFocus).trim()
+    ].filter(Boolean).join(' ').trim();
+
+    const expectedResult = [
+        variant.expectedResult || routeEntry.expectedResult,
+        (guidance.matchedRules || []).length > 0 ? 'Ademas, respeta las reglas de negocio configuradas para esta pantalla.' : '',
+        buildExpectedFocusSuffix(promptFocus).trim()
+    ].filter(Boolean).join(' ').trim();
+
+    return {
+        name: `${baseName}${variantCode}`,
+        prompt,
+        page: route,
+        page_path: routeEntry.pagePath,
+        expected_result: expectedResult,
+        tags: normalizeTags([...(routeEntry.tags || []), ...(variant.tags || []), ...((guidance.extraTags) || [])], promptFocus),
+        priority: guidance.priorityOverride || variant.priority || routeEntry.priority || 'normal',
+        collection: inferCollection(route),
+        created_at: new Date().toISOString(),
+        generation: {
+            source: 'arcality generate',
+            framework: routeEntry.framework || 'unknown',
+            router_kind: routeEntry.routerKind || 'unknown',
+            variant: variant.code || 'core',
+            context_status: guidance.contextStatus || { qaContext: 'missing', feasibility: 'missing' },
+            route_example_path: routeEntry.routeExamplePath || route,
+            route_params: routeEntry.routeParams || [],
+            route_hash: simpleHash(`${route}|${routeEntry.pagePath}`),
+            prompt_hash: simpleHash(prompt)
+        }
+    };
+}
+
+function scoreVariant(routeEntry, variant) {
+    const signals = routeEntry.signals || {};
+    let score = 0;
+
+    switch (variant.code) {
+    case 'checkout':
+        score += 120;
+        break;
+    case 'auth':
+        score += 110;
+        break;
+    case 'form':
+        score += 95;
+        break;
+    case 'detail':
+        score += 90;
+        break;
+    case 'upload':
+        score += 85;
+        break;
+    case 'settings':
+        score += 80;
+        break;
+    case 'list':
+        score += 75;
+        break;
+    case 'core':
+        score += 40;
+        break;
+    default:
+        score += 20;
+    }
+
+    score += variant.priority === 'high' ? 10 : 0;
+    score += routeEntry.route === '/' ? 6 : 0;
+    score += (routeEntry.routeParams || []).length * 4;
+    score += signals.hasSearch || signals.hasFilter || signals.hasTable ? 4 : 0;
+    score += signals.hasForm ? 4 : 0;
+    score += signals.hasUpload ? 4 : 0;
+    return score;
+}
+
+function shouldKeepVariant(routeEntry, variant, allVariants) {
+    const signals = routeEntry.signals || {};
+    const hasSpecialized = allVariants.some(item => item.code !== 'core');
+    const isRootLike = routeEntry.route === '/' || signals.isDashboardLike;
+
+    if (variant.code === 'core') {
+        if (!hasSpecialized) return true;
+        return isRootLike;
+    }
+
+    if (variant.code === 'list') {
+        return Boolean(signals.hasTable || signals.hasSearch || signals.hasFilter || routeEntry.route.includes('list'));
+    }
+
+    if (variant.code === 'form') {
+        return Boolean(signals.hasForm || signals.hasCreateAction || signals.hasEditAction || signals.isCrudLike);
+    }
+
+    if (variant.code === 'settings') {
+        return Boolean(signals.hasSettings);
+    }
+
+    if (variant.code === 'upload') {
+        return Boolean(signals.hasUpload);
+    }
+
+    if (variant.code === 'detail') {
+        return Boolean(signals.isDynamicRoute || (routeEntry.routeParams || []).length > 0);
+    }
+
+    if (variant.code === 'auth') {
+        return Boolean(signals.hasAuth);
+    }
+
+    if (variant.code === 'checkout') {
+        return Boolean(signals.hasCheckout);
+    }
+
+    return true;
+}
+
+function selectUsefulVariants(routeEntry, variants) {
+    const filtered = variants.filter(variant => shouldKeepVariant(routeEntry, variant, variants));
+    const sorted = filtered.sort((a, b) => scoreVariant(routeEntry, b) - scoreVariant(routeEntry, a));
+    const maxVariants = routeEntry.route === '/' ? 5 : 4;
+
+    const selected = [];
+    const seenCodes = new Set();
+    for (const variant of sorted) {
+        if (seenCodes.has(variant.code)) continue;
+        seenCodes.add(variant.code);
+        selected.push(variant);
+        if (selected.length >= maxVariants) break;
+    }
+
+    const hasCore = selected.some(variant => variant.code === 'core');
+    if (selected.length === 0) {
+        const fallback = variants.find(variant => variant.code === 'core') || variants[0];
+        return fallback ? [fallback] : [];
+    }
+
+    if (!hasCore && (routeEntry.route === '/' || filtered.length === 1)) {
+        const core = variants.find(variant => variant.code === 'core');
+        if (core && selected.length < maxVariants) selected.push(core);
+    }
+
+    return selected.sort((a, b) => scoreVariant(routeEntry, b) - scoreVariant(routeEntry, a));
+}
+
+function buildMissionVariants(routeEntry) {
+    const signals = routeEntry.signals || {};
+    const route = routeEntry.route || '/';
+    const routeLabel = route === '/' ? 'la pagina principal' : `la pagina ${route}`;
+    const exampleRoute = routeEntry.routeExamplePath && routeEntry.routeExamplePath !== route ? routeEntry.routeExamplePath : null;
+    const variants = [{
+        code: 'core',
+        prompt: routeEntry.prompt,
+        expectedResult: routeEntry.expectedResult,
+        tags: ['core-flow'],
+        priority: routeEntry.priority || 'normal'
+    }];
+
+    if (signals.hasAuth) {
+        variants.push({
+            code: 'auth',
+            prompt: `Navega a ${route} y valida el flujo de autenticacion visible, incluyendo campos obligatorios, mensajes de error y acceso correcto cuando existan credenciales validas de prueba.`,
+            expectedResult: `${routeLabel} permite validar autenticacion y feedback de errores sin fallas visibles.`,
+            tags: ['auth', 'login', 'validation'],
+            priority: 'high'
+        });
+    }
+
+    if (signals.hasCheckout) {
+        variants.push({
+            code: 'checkout',
+            prompt: `Navega a ${route} y valida el flujo de checkout o pago visible, verificando resumen, captura de datos sensibles, validaciones y confirmacion clara del resultado sin ejecutar cobros reales.`,
+            expectedResult: `${routeLabel} permite revisar el flujo de pago con validaciones y estados consistentes sin errores visibles.`,
+            tags: ['checkout', 'payment', 'transaction'],
+            priority: 'high'
+        });
+    }
+
+    if (signals.hasForm || signals.isCrudLike) {
+        variants.push({
+            code: 'form',
+            prompt: `Navega a ${route} y valida el formulario o flujo CRUD principal, cubriendo captura, validaciones, guardado y mensajes de confirmacion o error.`,
+            expectedResult: `${routeLabel} permite capturar o editar informacion con validaciones claras y resultado consistente.`,
+            tags: ['form', 'crud', 'save'],
+            priority: signals.hasCreateAction || signals.hasEditAction ? 'high' : 'normal'
+        });
+    }
+
+    if (signals.isListLike) {
+        variants.push({
+            code: 'list',
+            prompt: `Navega a ${route} y valida el listado principal, incluyendo carga de registros, filtros, busqueda, orden o paginacion segun aplique.`,
+            expectedResult: `${routeLabel} muestra datos consultables y permite usar herramientas de exploracion sin errores visibles.`,
+            tags: ['list', 'search', 'filter'],
+            priority: 'normal'
+        });
+    }
+
+    if (signals.isDynamicRoute) {
+        variants.push({
+            code: 'detail',
+            prompt: `Navega a ${route}${exampleRoute ? ` usando una ruta ejemplo como ${exampleRoute}` : ''} y valida la vista de detalle, comprobando que la informacion contextual cargue correctamente y que la accion principal asociada al registro sea usable.`,
+            expectedResult: `${routeLabel} carga informacion contextual correcta del registro y permite validar al menos una accion clave.`,
+            tags: ['detail', 'contextual-data', ...(exampleRoute ? ['example-route'] : [])],
+            priority: 'normal'
+        });
+    }
+
+    if (signals.hasSettings) {
+        variants.push({
+            code: 'settings',
+            prompt: `Navega a ${route} y valida el flujo de configuracion o preferencias, verificando persistencia visual, cambios editables y mensajes claros de guardado.`,
+            expectedResult: `${routeLabel} permite ajustar configuraciones con persistencia y feedback confiable.`,
+            tags: ['settings', 'preferences', 'persistence'],
+            priority: 'normal'
+        });
+    }
+
+    if (signals.hasUpload) {
+        variants.push({
+            code: 'upload',
+            prompt: `Navega a ${route} y valida la carga de archivos disponible, comprobando restricciones, mensajes de estado y resultado visible despues del upload.`,
+            expectedResult: `${routeLabel} permite cargar archivos con validaciones y confirmacion observable del resultado.`,
+            tags: ['upload', 'file'],
+            priority: 'normal'
+        });
+    }
+
+    const uniqueVariants = [];
+    const seen = new Set();
+    for (const variant of variants) {
+        const key = `${variant.code}|${variant.prompt}|${variant.expectedResult}`;
+        if (seen.has(key)) continue;
+        seen.add(key);
+        uniqueVariants.push(variant);
+    }
+    return selectUsefulVariants(routeEntry, uniqueVariants);
+}
+
+export function generateMissionsForRoute(routeEntry, options = {}) {
+    return buildMissionVariants(routeEntry).map(variant => buildMissionVariant(routeEntry, {
+        ...variant
+    }, {
+        ...options,
+        routeGuidance: options.routeGuidance || {}
+    }));
+}
+
+export function generateMissionYamlData(routeEntry, options = {}) {
+    return generateMissionsForRoute(routeEntry, options)[0];
+}
+
+export function buildMissionIdentity(missionData) {
+    return [
+        missionData.page_path || '',
+        missionData.prompt || '',
+        missionData.expected_result || ''
+    ].join('||').toLowerCase();
+}