@arcadialdev/arcality 3.0.4 → 4.0.1

package/scripts/rebrand-report.mjs

@@ -1,4 +1,5 @@
 import fs from 'fs';
+import os from 'os';
 import path from 'path';
 import { fileURLToPath } from 'url';
 
@@ -9,11 +10,11 @@ const ARCALITY_ROOT = process.env.ARCALITY_ROOT || path.resolve(__dirname, '..')
 
 async function rebrandReport() {
     // Definir directorios objetivo: El reporte personalizado, el nativo anidado y el reporte interno
-    const reportDir = process.env.REPORTS_DIR || 'tests-report';
+    const reportDir = process.env.REPORTS_DIR || path.join(os.tmpdir(), 'arcality', 'reports');
     const targetDirs = [
         reportDir,
         path.join(reportDir, 'native'),
-        'playwright-internal-report'
+        path.join(os.tmpdir(), 'arcality', 'playwright-internal-report')
     ];
 
     const logoPngPath = path.join(ARCALITY_ROOT, 'public', 'logo.png');
@@ -52,22 +53,22 @@ function processDirectory(reportDir, logoBase64) {
             html = html.replace(/at\s+.*?node_modules.*?(\n|\r)/g, '');
             html = html.replace(/at\s+.*?agentic-runner\.spec\.ts:\d+/g, '');
 
-            // 3. Preserve custom Arcality reports before native Playwright styling.
-            // The custom Arcality report owns its visual system. Keep the
-            // aggressive Playwright rebrand injection for native reports only.
-            const isArcalityMissionConsole = html.includes('class="mission-brief"') || html.includes('Arcality QA Engine');
-            if (isArcalityMissionConsole) {
-                if (logoBase64) {
-                    html = html.replace(/rel="shortcut icon" href=".*?"/g, `rel="shortcut icon" href="${logoBase64}"`);
-                    html = html.replace(/rel="icon" href=".*?"/g, `rel="icon" href="${logoBase64}"`);
-                }
-                fs.writeFileSync(indexPath, html, 'utf8');
-                processTraceViewer(reportDir, logoBase64);
-                return;
-            }
-
-            // 4. Inyección de Estilos y Scripts (MODO AGRESIVO)
-            const customStyles = `
+            // 3. Preserve custom Arcality reports before native Playwright styling.
+            // The custom Arcality report owns its visual system. Keep the
+            // aggressive Playwright rebrand injection for native reports only.
+            const isArcalityMissionConsole = html.includes('class="mission-brief"') || html.includes('Arcality QA Engine');
+            if (isArcalityMissionConsole) {
+                if (logoBase64) {
+                    html = html.replace(/rel="shortcut icon" href=".*?"/g, `rel="shortcut icon" href="${logoBase64}"`);
+                    html = html.replace(/rel="icon" href=".*?"/g, `rel="icon" href="${logoBase64}"`);
+                }
+                fs.writeFileSync(indexPath, html, 'utf8');
+                processTraceViewer(reportDir, logoBase64);
+                return;
+            }
+
+            // 4. Inyección de Estilos y Scripts (MODO AGRESIVO)
+            const customStyles = `
                 <script id="arcality-branding-script">
                     /* ARCALITY_BRANDING_SCRIPT */
                     // 1. Limpieza de Caché y Service Worker

package/src/configManager.mjs

@@ -6,15 +6,17 @@ import fs from 'node:fs';
 import path from 'node:path';
 
 const CONFIG_FILENAME = 'arcality.config';
-
-export function isRealProjectId(projectId) {
-    const id = String(projectId || '').trim();
-    if (!id) return false;
-    if (id === 'undefined' || id === 'null') return false;
-    if (/^(local|mock)_/i.test(id)) return false;
-    if (/^0{8}-0{4}-0{4}-0{4}-0{12}$/i.test(id)) return false;
-    return true;
-}
+const LEGACY_OUTPUT_DIRS = new Set(['arcality', './arcality', '.\\arcality']);
+const DEFAULT_YAML_OUTPUT_DIR = './.arcality';
+
+export function isRealProjectId(projectId) {
+    const id = String(projectId || '').trim();
+    if (!id) return false;
+    if (id === 'undefined' || id === 'null') return false;
+    if (/^(local|mock)_/i.test(id)) return false;
+    if (/^0{8}-0{4}-0{4}-0{4}-0{12}$/i.test(id)) return false;
+    return true;
+}
 
 /**
  * Resolves the path to arcality.config in the project root.
@@ -68,55 +70,55 @@ export function saveProjectConfig(config, projectRoot) {
  * @param {ArcalityConfig} config
  * @returns {{ valid: boolean, missing: string[] }}
  */
-export function validateConfig(config) {
-    const missing = [];
+export function validateConfig(config) {
+    const missing = [];
 
     if (!config) {
         return { valid: false, missing: ['arcality.config file'] };
     }
 
-    if (!config.apiKey) missing.push('apiKey');
-    if (!isRealProjectId(config.projectId)) missing.push('projectId');
-    if (!config.project?.baseUrl) missing.push('project.baseUrl');
-    if (!config.auth?.username) missing.push('auth.username');
-    if (!config.auth?.password) missing.push('auth.password');
-
-    return { valid: missing.length === 0, missing };
-}
+    if (!config.apiKey) missing.push('apiKey');
+    if (!isRealProjectId(config.projectId)) missing.push('projectId');
+    if (!config.project?.baseUrl) missing.push('project.baseUrl');
+    if (!config.auth?.username) missing.push('auth.username');
+    if (!config.auth?.password) missing.push('auth.password');
+
+    return { valid: missing.length === 0, missing };
+}
 
 /**
  * Creates a fresh arcality.config structure.
  * @param {object} params
  * @returns {ArcalityConfig}
  */
-export function createConfig({
+export function createConfig({
     apiKey,
     organizationId,
     projectId,
-    projectName,
-    baseUrl,
-    frameworkDetected,
-    username,
-    password,
-    arcalityVersion,
-    yamlOutputDir = './arcality',
+    projectName,
+    baseUrl,
+    frameworkDetected,
+    username,
+    password,
+    arcalityVersion,
+    yamlOutputDir = DEFAULT_YAML_OUTPUT_DIR,
 }) {
-    return {
+    return {
         version: '1',
         apiKey,
         organizationId: organizationId || null,
         projectId,
         project: {
             name: projectName,
-            baseUrl,
-            frameworkDetected: frameworkDetected || null,
-        },
-        auth: {
-            username,
-            password,
-        },
-        runtime: {
-            yamlOutputDir,
+            baseUrl,
+            frameworkDetected: frameworkDetected || null,
+        },
+        auth: {
+            username,
+            password,
+        },
+        runtime: {
+            yamlOutputDir,
             reuseSuccessfulYamls: true,
             singleConfigurationMode: true,
         },
@@ -131,17 +133,18 @@ export function createConfig({
  * with existing modules that read from process.env.
  * @param {ArcalityConfig} config
  */
-export function injectConfigToEnv(config) {
-    if (!config) return;
+export function injectConfigToEnv(config) {
+    if (!config) return;
 
     if (config.apiKey) process.env.ARCALITY_API_KEY = config.apiKey;
-    if (isRealProjectId(config.projectId)) process.env.ARCALITY_PROJECT_ID = config.projectId;
-    if (config.project?.baseUrl && !process.env.BASE_URL) {
-        process.env.BASE_URL = config.project.baseUrl;
-    }
-    if (config.auth?.username) process.env.LOGIN_USER = config.auth.username;
-    if (config.auth?.password) process.env.LOGIN_PASSWORD = config.auth.password;
-}
+    if (config.organizationId) process.env.ARCALITY_ORG_ID = config.organizationId;
+    if (isRealProjectId(config.projectId)) process.env.ARCALITY_PROJECT_ID = config.projectId;
+    if (config.project?.baseUrl && !process.env.BASE_URL) {
+        process.env.BASE_URL = config.project.baseUrl;
+    }
+    if (config.auth?.username) process.env.LOGIN_USER = config.auth.username;
+    if (config.auth?.password) process.env.LOGIN_PASSWORD = config.auth.password;
+}
 
 /**
  * Gets the YAML output directory from config, falling back to default.
@@ -149,10 +152,13 @@ export function injectConfigToEnv(config) {
  * @param {string} [projectRoot]
  * @returns {string} absolute path
  */
-export function getYamlOutputDir(config, projectRoot) {
-    const dir = config?.runtime?.yamlOutputDir || './arcality';
-    return path.resolve(projectRoot || process.cwd(), dir);
-}
+export function getYamlOutputDir(config, projectRoot) {
+    const configuredDir = String(config?.runtime?.yamlOutputDir || '').trim();
+    const dir = LEGACY_OUTPUT_DIRS.has(configuredDir) || !configuredDir
+        ? DEFAULT_YAML_OUTPUT_DIR
+        : configuredDir;
+    return path.resolve(projectRoot || process.cwd(), dir);
+}
 
 /**
  * Ensures the YAML output directory exists.
@@ -175,7 +181,7 @@ export function ensureYamlOutputDir(config, projectRoot) {
  * @property {string|null} organizationId
  * @property {string} projectId
  * @property {{ name: string, baseUrl: string, frameworkDetected: string|null }} project
- * @property {{ username: string, password: string }} auth
+ * @property {{ username: string, password: string }} auth
  * @property {{ yamlOutputDir: string, reuseSuccessfulYamls: boolean, singleConfigurationMode: boolean }} runtime
  * @property {{ arcalityVersion: string }} meta
  */

package/src/services/codebaseAnalyzer.mjs

@@ -0,0 +1,59 @@
+import fs from 'node:fs';
+import path from 'node:path';
+import { discoverProjectRoutes } from './routeDiscovery.mjs';
+
+function readJson(filePath) {
+    const raw = fs.readFileSync(filePath, 'utf8');
+    return JSON.parse(raw);
+}
+
+function detectFramework(pkg) {
+    const deps = { ...(pkg.dependencies || {}), ...(pkg.devDependencies || {}) };
+    if (deps.next) return 'next';
+    if (deps.vite) return 'vite';
+    if (deps['react-scripts']) return 'cra';
+    return 'unknown';
+}
+
+export function analyzeCodebase(projectRoot = process.cwd(), options = {}) {
+    const pkgPath = path.join(projectRoot, 'package.json');
+    const result = {
+        projectRoot,
+        packageJsonPath: pkgPath,
+        projectName: path.basename(projectRoot),
+        framework: 'unknown',
+        scripts: [],
+        dependencies: [],
+        routeCount: 0,
+        routes: [],
+        warnings: []
+    };
+
+    if (!fs.existsSync(pkgPath)) {
+        result.warnings.push('No se encontro package.json en el proyecto destino.');
+        return result;
+    }
+
+    try {
+        const pkg = readJson(pkgPath);
+        result.projectName = pkg.name || result.projectName;
+        result.framework = detectFramework(pkg);
+        result.scripts = Object.keys(pkg.scripts || {});
+        result.dependencies = Object.keys({ ...(pkg.dependencies || {}), ...(pkg.devDependencies || {}) });
+        result.routes = discoverProjectRoutes(projectRoot, result.framework, {
+            baseUrl: options.baseUrl || ''
+        });
+        result.routeCount = result.routes.length;
+
+        if (result.routeCount === 0) {
+            result.warnings.push(`No se detectaron rutas automaticamente para el framework "${result.framework}".`);
+        }
+        if (result.framework === 'unknown') {
+            result.warnings.push('Framework no reconocido automaticamente. Se usaron heuristicas de fallback.');
+        }
+    } catch (error) {
+        result.warnings.push(`No se pudo analizar el proyecto: ${error.message}`);
+    }
+
+    return result;
+}

package/src/services/generatedMissionSchema.mjs

@@ -0,0 +1,76 @@
+function isNonEmptyString(value) {
+    return typeof value === 'string' && value.trim().length > 0;
+}
+
+function isPriority(value) {
+    return value === 'high' || value === 'normal' || value === 'low';
+}
+
+export function validateGeneratedMissionSchema(mission) {
+    const issues = [];
+
+    if (!mission || typeof mission !== 'object' || Array.isArray(mission)) {
+        return {
+            valid: false,
+            issues: ['Mission must be a plain object.']
+        };
+    }
+
+    if (!isNonEmptyString(mission.name)) issues.push('name is required.');
+    if (!isNonEmptyString(mission.prompt)) issues.push('prompt is required.');
+    if (!isNonEmptyString(mission.page)) issues.push('page is required.');
+    if (!isNonEmptyString(mission.page_path)) issues.push('page_path is required.');
+    if (!isNonEmptyString(mission.expected_result)) issues.push('expected_result is required.');
+    if (!Array.isArray(mission.tags) || mission.tags.length === 0) issues.push('tags must be a non-empty array.');
+    if (!isPriority(mission.priority)) issues.push('priority must be one of: high, normal, low.');
+    if (!isNonEmptyString(mission.collection)) issues.push('collection is required.');
+    if (!isNonEmptyString(mission.created_at) || Number.isNaN(Date.parse(mission.created_at))) {
+        issues.push('created_at must be a valid ISO date string.');
+    }
+
+    if (!mission.generation || typeof mission.generation !== 'object' || Array.isArray(mission.generation)) {
+        issues.push('generation metadata is required.');
+    } else {
+        if (!isNonEmptyString(mission.generation.source)) issues.push('generation.source is required.');
+        if (!isNonEmptyString(mission.generation.framework)) issues.push('generation.framework is required.');
+        if (!isNonEmptyString(mission.generation.router_kind)) issues.push('generation.router_kind is required.');
+        if (!isNonEmptyString(mission.generation.variant)) issues.push('generation.variant is required.');
+        if (!isNonEmptyString(mission.generation.route_hash)) issues.push('generation.route_hash is required.');
+        if (!isNonEmptyString(mission.generation.prompt_hash)) issues.push('generation.prompt_hash is required.');
+        if (!isNonEmptyString(mission.generation.route_example_path)) {
+            issues.push('generation.route_example_path is required.');
+        }
+        if (!Array.isArray(mission.generation.route_params)) {
+            issues.push('generation.route_params must be an array.');
+        }
+
+        const status = mission.generation.context_status;
+        if (!status || typeof status !== 'object' || Array.isArray(status)) {
+            issues.push('generation.context_status is required.');
+        } else {
+            if (!isNonEmptyString(status.qaContext)) issues.push('generation.context_status.qaContext is required.');
+            if (!isNonEmptyString(status.feasibility)) issues.push('generation.context_status.feasibility is required.');
+        }
+    }
+
+    if (Array.isArray(mission.tags)) {
+        for (const tag of mission.tags) {
+            if (!isNonEmptyString(tag)) {
+                issues.push('tags must contain only non-empty strings.');
+                break;
+            }
+        }
+    }
+
+    return {
+        valid: issues.length === 0,
+        issues
+    };
+}
+
+export function assertGeneratedMissionSchema(mission) {
+    const result = validateGeneratedMissionSchema(mission);
+    if (!result.valid) {
+        throw new Error(`Generated mission schema validation failed: ${result.issues.join(' ')}`);
+    }
+}

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;
+}