@arcadialdev/arcality 4.1.0 → 4.1.1

package/scripts/edit-config.mjs

@@ -0,0 +1,843 @@
+#!/usr/bin/env node
+
+import 'dotenv/config';
+import fs from 'node:fs';
+import path from 'node:path';
+import { createRequire } from 'node:module';
+import { fileURLToPath } from 'node:url';
+import {
+    intro,
+    outro,
+    text,
+    password as passwordPrompt,
+    select,
+    note,
+    isCancel,
+    cancel,
+    confirm
+} from '@clack/prompts';
+import chalk from 'chalk';
+import {
+    configExists,
+    loadProjectConfig,
+    saveProjectConfig
+} from '../src/configManager.mjs';
+import {
+    loadDatabaseMcpConfig,
+    resolveDatabaseConnectionEnv,
+    resolveDatabaseProvider
+} from '../src/services/databaseValidationService.mjs';
+import { callMcpToolWithConfig, extractRowsFromMcpToolResult } from '../src/services/mcpStdioClient.mjs';
+
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = path.dirname(__filename);
+const PACKAGE_ROOT = process.env.ARCALITY_ROOT || path.resolve(__dirname, '..');
+const DEFAULT_DB_CATALOG_PATH = '.arcality/db-validations.yaml';
+const DEFAULT_MCP_CONFIG_PATH = '.arcality/mcp.postgres.json';
+const DEFAULT_MCP_TEMPLATE_PATH = path.join(PACKAGE_ROOT, '.arcality', 'mcp.postgres.example.json');
+
+function deepClone(value) {
+    return JSON.parse(JSON.stringify(value));
+}
+
+function isValidUrl(url) {
+    try {
+        const parsed = new URL(url);
+        return parsed.protocol === 'http:' || parsed.protocol === 'https:';
+    } catch {
+        return false;
+    }
+}
+
+function detectFramework(projectRoot) {
+    try {
+        const pkgPath = path.join(projectRoot, 'package.json');
+        if (!fs.existsSync(pkgPath)) return null;
+        const pkg = JSON.parse(fs.readFileSync(pkgPath, 'utf8'));
+        const deps = { ...pkg.dependencies, ...pkg.devDependencies };
+        if (deps.next) return 'Next.js';
+        if (deps.nuxt || deps.nuxt3) return 'Nuxt';
+        if (deps.vite) return 'Vite';
+        if (deps['react-scripts']) return 'Create React App';
+        if (deps['@angular/core']) return 'Angular';
+        if (deps.vue) return 'Vue.js';
+        if (deps.svelte || deps['@sveltejs/kit']) return 'Svelte';
+        return null;
+    } catch {
+        return null;
+    }
+}
+
+function ensureArcalityDir(projectRoot) {
+    const dir = path.join(projectRoot, '.arcality');
+    if (!fs.existsSync(dir)) {
+        fs.mkdirSync(dir, { recursive: true });
+    }
+    return dir;
+}
+
+function toEnvKey(value) {
+    return String(value || '')
+        .trim()
+        .toUpperCase()
+        .replace(/[^A-Z0-9]+/g, '_')
+        .replace(/^_+|_+$/g, '');
+}
+
+function parseEnvFile(content) {
+    const entries = new Map();
+    const lines = content.split(/\r?\n/);
+
+    for (const line of lines) {
+        const trimmed = line.trim();
+        if (!trimmed || trimmed.startsWith('#')) continue;
+        const eqIndex = line.indexOf('=');
+        if (eqIndex === -1) continue;
+        const key = line.slice(0, eqIndex).trim();
+        let value = line.slice(eqIndex + 1).trim();
+        if (
+            (value.startsWith('"') && value.endsWith('"')) ||
+            (value.startsWith("'") && value.endsWith("'"))
+        ) {
+            value = value.slice(1, -1);
+        }
+        entries.set(key, value);
+    }
+
+    return { entries, lines };
+}
+
+function escapeEnvValue(value) {
+    const stringValue = String(value ?? '');
+    const needsQuotes = /[\s"'`\\]/.test(stringValue);
+    const escaped = stringValue.replace(/"/g, '\\"');
+    return needsQuotes ? `"${escaped}"` : escaped;
+}
+
+function readEnvMap(projectRoot) {
+    const envPath = path.join(projectRoot, '.env');
+    if (!fs.existsSync(envPath)) {
+        return { path: envPath, entries: new Map(), rawLines: [] };
+    }
+
+    const raw = fs.readFileSync(envPath, 'utf8');
+    const parsed = parseEnvFile(raw);
+    return { path: envPath, entries: parsed.entries, rawLines: parsed.lines };
+}
+
+function syncEnvFromLocalFile(projectRoot) {
+    const envState = readEnvMap(projectRoot);
+    for (const [key, value] of envState.entries.entries()) {
+        process.env[key] = value;
+    }
+}
+
+function writeEnvUpdates(projectRoot, updates) {
+    const envState = readEnvMap(projectRoot);
+    const lineIndexByKey = new Map();
+
+    envState.rawLines.forEach((line, index) => {
+        const eqIndex = line.indexOf('=');
+        if (eqIndex === -1) return;
+        const key = line.slice(0, eqIndex).trim();
+        if (key && !key.startsWith('#')) {
+            lineIndexByKey.set(key, index);
+        }
+    });
+
+    const lines = envState.rawLines.length > 0 ? [...envState.rawLines] : ['# Variables locales de Arcality', ''];
+
+    for (const [key, rawValue] of Object.entries(updates)) {
+        if (rawValue === undefined) continue;
+        const rendered = `${key}=${escapeEnvValue(rawValue)}`;
+        if (lineIndexByKey.has(key)) {
+            lines[lineIndexByKey.get(key)] = rendered;
+        } else {
+            if (lines.length > 0 && lines[lines.length - 1] !== '') {
+                lines.push('');
+            }
+            lines.push(rendered);
+            lineIndexByKey.set(key, lines.length - 1);
+        }
+    }
+
+    if (lines[lines.length - 1] !== '') {
+        lines.push('');
+    }
+
+    fs.writeFileSync(envState.path, lines.join('\n'), 'utf8');
+    for (const [key, rawValue] of Object.entries(updates)) {
+        if (rawValue !== undefined) process.env[key] = String(rawValue);
+    }
+}
+
+
+function getDbState(projectRoot) {
+    const envState = readEnvMap(projectRoot);
+    const provider = String(envState.entries.get('ARCALITY_DB_PROVIDER') || process.env.ARCALITY_DB_PROVIDER || '').trim().toLowerCase();
+    const profile = String(envState.entries.get('ARCALITY_DB_PROFILE') || process.env.ARCALITY_DB_PROFILE || 'qa_local').trim();
+    const profileKey = toEnvKey(profile);
+    const connectionKey = profileKey ? `ARCALITY_DB_${profileKey}_URL` : 'ARCALITY_DB_CONNECTION';
+    const connectionValue = envState.entries.get(connectionKey) || process.env[connectionKey] || '';
+    const mcpConfigPath = envState.entries.get('ARCALITY_DB_MCP_CONFIG') || process.env.ARCALITY_DB_MCP_CONFIG || DEFAULT_MCP_CONFIG_PATH;
+    const catalogPath = envState.entries.get('ARCALITY_DB_CATALOG') || process.env.ARCALITY_DB_CATALOG || DEFAULT_DB_CATALOG_PATH;
+    const enabledValue = String(envState.entries.get('ARCALITY_DB_ENABLED') || process.env.ARCALITY_DB_ENABLED || '').trim().toLowerCase();
+    const enabled = ['1', 'true', 'yes', 'on'].includes(enabledValue);
+
+    return {
+        provider: provider || 'postgres',
+        profile,
+        connectionKey,
+        hasConnectionString: !!connectionValue,
+        mcpConfigPath,
+        catalogPath,
+        enabled
+    };
+}
+
+function ensureDbCatalogTemplate(projectRoot) {
+    const targetPath = path.join(projectRoot, DEFAULT_DB_CATALOG_PATH);
+    if (fs.existsSync(targetPath)) return false;
+
+    ensureArcalityDir(projectRoot);
+    const template = `# Arcality local database validation catalog.
+# Keep this file free of secrets. Connection strings belong in .env.
+
+queries:
+  example_record_by_name:
+    description: Replace this query with a real QA or Staging lookup.
+    sql: >
+      select id, name, status, created_at
+      from example_table
+      where name = $1
+      order by created_at desc
+      limit 1
+    params:
+      - name
+    redact:
+      - id
+`;
+    fs.writeFileSync(targetPath, template, 'utf8');
+    return true;
+}
+
+function ensureMcpConfigTemplate(projectRoot) {
+    const targetPath = path.join(projectRoot, DEFAULT_MCP_CONFIG_PATH);
+    if (fs.existsSync(targetPath)) return false;
+
+    ensureArcalityDir(projectRoot);
+    if (fs.existsSync(DEFAULT_MCP_TEMPLATE_PATH)) {
+        fs.copyFileSync(DEFAULT_MCP_TEMPLATE_PATH, targetPath);
+        return true;
+    }
+
+    const fallback = {
+        command: 'npx',
+        args: ['-y', '@modelcontextprotocol/server-postgres', '${ARCALITY_DB_QA_LOCAL_URL}'],
+        toolName: 'query',
+        toolArguments: {
+            sql: '{{sql}}',
+            params: '{{params}}'
+        },
+        resultRowsPath: 'rows',
+        timeoutMs: 15000
+    };
+    fs.writeFileSync(targetPath, `${JSON.stringify(fallback, null, 2)}\n`, 'utf8');
+    return true;
+}
+
+function ensureQaContextFiles(projectRoot, username) {
+    const dir = ensureArcalityDir(projectRoot);
+    const contextPath = path.join(dir, 'qa-context.md');
+    const metaPath = path.join(dir, 'qa-context.meta.json');
+    let createdContext = false;
+    let createdMeta = false;
+
+    if (!fs.existsSync(contextPath)) {
+        const qaTemplate = `# Arcality QA Context
+<!--
+Este archivo se inyecta antes de cada mision.
+Escribe reglas cortas, especificas y accionables.
+Usa un bullet por regla real.
+-->
+
+## Reglas del Dominio
+- Ejemplo: Un usuario no puede registrar mas de 24 horas en un mismo dia.
+
+## Navegacion y UI Especial
+- Ejemplo: Espera a que la tabla principal termine de cargar antes de interactuar.
+
+## Casos Prohibidos y Anti-patrones
+- Ejemplo: No cierres modales con Escape si existe un boton Cancelar.
+
+## Datos y Credenciales de Prueba
+- Ejemplo: Usa el usuario QA_PORTAL_01 para pruebas de alta.
+
+## Resultado Esperado y Validaciones Clave
+- Ejemplo: El registro debe aparecer en la tabla principal con estado ACTIVE.
+`;
+        fs.writeFileSync(contextPath, qaTemplate, 'utf8');
+        createdContext = true;
+    }
+
+    if (!fs.existsSync(metaPath)) {
+        const metaTemplate = {
+            version: '1.0.0',
+            updated_by: username || 'qa.owner@empresa.com',
+            approved_by: '',
+            owner_team: 'QA',
+            effective_from: new Date().toISOString().slice(0, 10),
+            change_summary: 'Creacion inicial del QA Context para este proyecto.',
+            tags: ['business-rules', 'ui-navigation']
+        };
+        fs.writeFileSync(metaPath, `${JSON.stringify(metaTemplate, null, 2)}\n`, 'utf8');
+        createdMeta = true;
+    }
+
+    return { createdContext, createdMeta, contextPath, metaPath };
+}
+
+async function runDatabaseHealthCheck(projectRoot) {
+    syncEnvFromLocalFile(projectRoot);
+    const provider = resolveDatabaseProvider();
+
+    if (provider === 'mcp') {
+        const { configPath, config } = loadDatabaseMcpConfig({ projectRoot });
+        const result = await callMcpToolWithConfig(config, {
+            sql: 'select 1 as ok',
+            params: [],
+            paramsNamed: {},
+            paramsJson: '[]',
+            queryId: 'health_check',
+            validationName: 'db_health_check',
+            timeoutMs: 5000
+        });
+        const rows = extractRowsFromMcpToolResult(result, String(config.resultRowsPath || '').trim());
+        return {
+            provider: 'mcp',
+            detail: configPath,
+            rowCount: Array.isArray(rows) ? rows.length : 0
+        };
+    }
+
+    const connection = resolveDatabaseConnectionEnv();
+    if (!connection.hasConnectionString) {
+        throw new Error(`Missing PostgreSQL connection string in ${connection.connectionEnvName}.`);
+    }
+
+    const roots = [process.env.ARCALITY_ROOT, process.cwd()].filter(Boolean);
+    let Pool = null;
+    for (const root of roots) {
+        try {
+            const requireFromRoot = createRequire(path.join(root, 'package.json'));
+            Pool = requireFromRoot('pg').Pool;
+            break;
+        } catch {}
+    }
+
+    if (!Pool) {
+        throw new Error('PostgreSQL driver "pg" is not installed.');
+    }
+
+    const pool = new Pool({
+        connectionString: connection.connectionString,
+        max: 1,
+        idleTimeoutMillis: 1000,
+        connectionTimeoutMillis: 5000,
+        statement_timeout: 5000
+    });
+
+    try {
+        const result = await pool.query('select 1 as ok');
+        return {
+            provider: 'postgres',
+            detail: connection.connectionEnvName,
+            rowCount: Array.isArray(result.rows) ? result.rows.length : 0
+        };
+    } finally {
+        await pool.end().catch(() => {});
+    }
+}
+
+async function promptDatabaseHealthCheck(projectRoot, session) {
+    const wantsCheck = await confirm({
+        message: 'Deseas probar la conexion BD ahora?'
+    });
+    if (isCancel(wantsCheck) || !wantsCheck) return;
+
+    try {
+        const result = await runDatabaseHealthCheck(projectRoot);
+        pushSessionChange(session, `Health check BD exitoso via ${result.provider} (${result.detail}).`);
+        note(
+            chalk.green('Conexion BD verificada correctamente.') + '\n' +
+            chalk.white(`Proveedor: ${result.provider}`) + '\n' +
+            chalk.white(`Referencia: ${result.detail}`) + '\n' +
+            chalk.white(`Filas devueltas por health check: ${result.rowCount}`),
+            'Health Check BD'
+        );
+    } catch (error) {
+        pushSessionChange(session, `Health check BD fallido: ${error.message}`);
+        note(chalk.red(`No se pudo validar la conexion BD: ${error.message}`), 'Health Check BD');
+    }
+}
+
+function getQaContextState(projectRoot) {
+    const envState = readEnvMap(projectRoot);
+    const governance = String(
+        envState.entries.get('ARCALITY_QA_CONTEXT_GOVERNANCE') ||
+        process.env.ARCALITY_QA_CONTEXT_GOVERNANCE ||
+        'warn'
+    ).trim().toLowerCase();
+
+    return {
+        contextExists: fs.existsSync(path.join(projectRoot, '.arcality', 'qa-context.md')),
+        metaExists: fs.existsSync(path.join(projectRoot, '.arcality', 'qa-context.meta.json')),
+        governance: governance || 'warn'
+    };
+}
+
+function formatSummary(config, projectRoot) {
+    const dbState = getDbState(projectRoot);
+    const qaState = getQaContextState(projectRoot);
+    const authConfigured = config.auth?.username && config.auth?.password ? 'si' : 'no';
+    const dbMode = dbState.enabled ? `${dbState.provider} (${dbState.profile})` : 'deshabilitada (opt-in)';
+
+    return [
+        `${chalk.bold('Proyecto:')} ${chalk.cyan(config.project?.name || 'Sin nombre')}`,
+        `${chalk.bold('Base URL:')} ${chalk.cyan(config.project?.baseUrl || 'No definida')}`,
+        `${chalk.bold('Autenticacion:')} ${chalk.white(authConfigured)}`,
+        `${chalk.bold('Framework:')} ${chalk.magenta(config.project?.frameworkDetected || 'N/A')}`,
+        `${chalk.bold('Misiones YAML:')} ${chalk.yellow(config.runtime?.yamlOutputDir || './.arcality')}`,
+        `${chalk.bold('Validacion BD:')} ${chalk.white(dbMode)}`,
+        `${chalk.bold('QA Context:')} ${chalk.white(`contexto=${qaState.contextExists ? 'si' : 'no'}, metadata=${qaState.metaExists ? 'si' : 'no'}, governance=${qaState.governance}`)}`
+    ].join('\n');
+}
+
+function getConfigDiffLines(originalConfig, draftConfig) {
+    const lines = [];
+
+    if ((originalConfig.project?.name || '') !== (draftConfig.project?.name || '')) {
+        lines.push(`Proyecto.nombre: ${originalConfig.project?.name || 'N/A'} -> ${draftConfig.project?.name || 'N/A'}`);
+    }
+    if ((originalConfig.project?.baseUrl || '') !== (draftConfig.project?.baseUrl || '')) {
+        lines.push(`Proyecto.baseUrl: ${originalConfig.project?.baseUrl || 'N/A'} -> ${draftConfig.project?.baseUrl || 'N/A'}`);
+    }
+    if ((originalConfig.project?.frameworkDetected || '') !== (draftConfig.project?.frameworkDetected || '')) {
+        lines.push(`Proyecto.frameworkDetected: ${originalConfig.project?.frameworkDetected || 'N/A'} -> ${draftConfig.project?.frameworkDetected || 'N/A'}`);
+    }
+    if ((originalConfig.auth?.username || '') !== (draftConfig.auth?.username || '')) {
+        lines.push(`Auth.username: ${originalConfig.auth?.username || 'N/A'} -> ${draftConfig.auth?.username || 'N/A'}`);
+    }
+    if ((originalConfig.auth?.password || '') !== (draftConfig.auth?.password || '')) {
+        lines.push('Auth.password: actualizada');
+    }
+    if ((originalConfig.runtime?.yamlOutputDir || './.arcality') !== (draftConfig.runtime?.yamlOutputDir || './.arcality')) {
+        lines.push(`Runtime.yamlOutputDir: ${originalConfig.runtime?.yamlOutputDir || './.arcality'} -> ${draftConfig.runtime?.yamlOutputDir || './.arcality'}`);
+    }
+
+    return lines;
+}
+
+function createSessionState() {
+    return {
+        changes: []
+    };
+}
+
+function pushSessionChange(session, change) {
+    if (!change) return;
+    session.changes.push(change);
+}
+
+function buildPendingChanges(session, originalConfig, draftConfig) {
+    const lines = [];
+    const configDiffLines = getConfigDiffLines(originalConfig, draftConfig);
+
+    if (configDiffLines.length > 0) {
+        lines.push('Cambios pendientes en arcality.config:');
+        for (const line of configDiffLines) {
+            lines.push(`- ${line}`);
+        }
+    }
+
+    if (session.changes.length > 0) {
+        lines.push(configDiffLines.length > 0 ? '' : 'Cambios aplicados en esta sesion:');
+        if (configDiffLines.length > 0) {
+            lines.push('');
+            lines.push('Cambios auxiliares (.env y archivos locales):');
+        }
+        for (const change of session.changes) {
+            lines.push(`- ${change}`);
+        }
+    }
+
+    return lines.filter((line, index, arr) => !(line === '' && arr[index - 1] === '')).join('\n').trim();
+}
+
+async function editProjectSection(config, projectRoot, session) {
+    const projectName = await text({
+        message: 'Nombre del proyecto:',
+        initialValue: config.project?.name || '',
+        validate: value => value && value.trim().length >= 2 ? undefined : 'Ingresa al menos 2 caracteres.'
+    });
+    if (isCancel(projectName)) return;
+
+    const baseUrl = await text({
+        message: 'Base URL de la aplicacion:',
+        initialValue: config.project?.baseUrl || '',
+        validate: value => isValidUrl(value) ? undefined : 'Usa una URL valida con http:// o https://'
+    });
+    if (isCancel(baseUrl)) return;
+
+    const redetect = await confirm({
+        message: 'Deseas redetectar el framework local?'
+    });
+    if (isCancel(redetect)) return;
+
+    config.project = config.project || {};
+    config.project.name = projectName.trim();
+    config.project.baseUrl = baseUrl.trim();
+    if (redetect) {
+        config.project.frameworkDetected = detectFramework(projectRoot);
+    }
+
+    pushSessionChange(session, 'Se recalibro la seccion Proyecto.');
+    note(chalk.green('Proyecto actualizado en borrador.'), 'Resumen');
+}
+
+async function editAuthSection(config, session) {
+    const needsLogin = await confirm({
+        message: 'La aplicacion requiere autenticacion?'
+    });
+    if (isCancel(needsLogin)) return;
+
+    config.auth = config.auth || {};
+
+    if (!needsLogin) {
+        config.auth.username = '';
+        config.auth.password = '';
+        pushSessionChange(session, 'Se deshabilito la autenticacion en arcality.config.');
+        note(chalk.green('Autenticacion limpiada en borrador.'), 'Resumen');
+        return;
+    }
+
+    const username = await text({
+        message: 'Usuario o correo de acceso:',
+        initialValue: config.auth.username || '',
+        validate: value => value && value.trim() ? undefined : 'El usuario es obligatorio.'
+    });
+    if (isCancel(username)) return;
+
+    const password = await passwordPrompt({
+        message: config.auth.password
+            ? 'Nueva contrasena (deja vacio para conservar la actual):'
+            : 'Contrasena de acceso:',
+        validate: value => {
+            if (config.auth.password && !value) return undefined;
+            return value && value.length ? undefined : 'La contrasena es obligatoria.';
+        }
+    });
+    if (isCancel(password)) return;
+
+    config.auth.username = username.trim();
+    if (password) {
+        config.auth.password = password;
+    }
+
+    pushSessionChange(session, 'Se recalibro la seccion Autenticacion.');
+    note(chalk.green('Autenticacion actualizada en borrador.'), 'Resumen');
+}
+
+async function editRuntimeSection(config, session) {
+    const yamlOutputDir = await text({
+        message: 'Carpeta base para YAML, reportes y contexto:',
+        initialValue: config.runtime?.yamlOutputDir || './.arcality',
+        validate: value => value && value.trim() ? undefined : 'La carpeta no puede quedar vacia.'
+    });
+    if (isCancel(yamlOutputDir)) return;
+
+    config.runtime = config.runtime || {};
+    config.runtime.yamlOutputDir = yamlOutputDir.trim();
+    config.runtime.reuseSuccessfulYamls = true;
+    config.runtime.singleConfigurationMode = true;
+
+    pushSessionChange(session, 'Se actualizo el runtime y la carpeta base de misiones.');
+    note(chalk.green('Runtime actualizado en borrador.'), 'Resumen');
+}
+
+async function editDatabaseSection(projectRoot, session) {
+    const current = getDbState(projectRoot);
+    const wantsDatabaseValidation = await confirm({
+        message: current.enabled
+            ? 'Deseas mantener habilitada la validacion BD para este proyecto?'
+            : 'Este proyecto requiere validacion BD local?'
+    });
+    if (isCancel(wantsDatabaseValidation)) return;
+
+    if (!wantsDatabaseValidation) {
+        writeEnvUpdates(projectRoot, {
+            ARCALITY_DB_ENABLED: 'false'
+        });
+        pushSessionChange(session, 'Se deshabilito la validacion BD en .env.');
+        note(
+            chalk.green('Validacion BD deshabilitada para este proyecto.') + '\n' +
+            chalk.white('No se pedira connection string ni configuracion MCP mientras siga apagada.'),
+            'Base de datos'
+        );
+        return;
+    }
+
+    const mode = await select({
+        message: 'Como deseas conectar la corroboracion BD?',
+        options: [
+            { label: 'PostgreSQL directo (.env)', value: 'postgres' },
+            { label: 'MCP PostgreSQL (.env + mcp.postgres.json)', value: 'mcp' }
+        ],
+        initialValue: current.enabled ? current.provider : 'postgres'
+    });
+    if (isCancel(mode)) return;
+
+    const profile = await text({
+        message: 'Perfil logico de BD:',
+        initialValue: current.profile || 'qa_local',
+        validate: value => value && value.trim() ? undefined : 'El perfil es obligatorio.'
+    });
+    if (isCancel(profile)) return;
+
+    const profileKey = toEnvKey(profile);
+    const connectionKey = profileKey ? `ARCALITY_DB_${profileKey}_URL` : current.connectionKey;
+    const connectionString = await passwordPrompt({
+        message: current.hasConnectionString
+            ? `Connection string para ${connectionKey} (deja vacio para conservar la actual):`
+            : `Connection string para ${connectionKey}:`,
+        validate: value => {
+            if (current.hasConnectionString && !value) return undefined;
+            return value && value.trim() ? undefined : 'La connection string es obligatoria.';
+        }
+    });
+    if (isCancel(connectionString)) return;
+
+    const catalogCreated = ensureDbCatalogTemplate(projectRoot);
+
+    const updates = {
+        ARCALITY_DB_ENABLED: 'true',
+        ARCALITY_DB_PROVIDER: mode,
+        ARCALITY_DB_PROFILE: profile.trim(),
+        ARCALITY_DB_CATALOG: DEFAULT_DB_CATALOG_PATH
+    };
+
+    if (connectionString && connectionString.trim()) {
+        updates[connectionKey] = connectionString.trim();
+    }
+
+    let mcpCreated = false;
+    if (mode === 'mcp') {
+        mcpCreated = ensureMcpConfigTemplate(projectRoot);
+        updates.ARCALITY_DB_MCP_CONFIG = DEFAULT_MCP_CONFIG_PATH;
+    }
+
+    writeEnvUpdates(projectRoot, updates);
+
+    pushSessionChange(session, `Se habilito validacion BD en modo ${mode} con perfil ${profile.trim()}.`);
+    pushSessionChange(session, `Se actualizo la variable ${connectionKey} en .env${connectionString ? '' : ' (se conservo el valor actual)'}.`);
+    if (catalogCreated) {
+        pushSessionChange(session, `Se creo ${DEFAULT_DB_CATALOG_PATH}.`);
+    }
+    if (mcpCreated) {
+        pushSessionChange(session, `Se creo ${DEFAULT_MCP_CONFIG_PATH}.`);
+    }
+
+    note(
+        chalk.green(`Validacion BD configurada en modo ${mode}.`) + '\n' +
+        chalk.white(`Archivo de catalogo: ${DEFAULT_DB_CATALOG_PATH}`) + '\n' +
+        (mode === 'mcp' ? chalk.white(`Archivo MCP: ${DEFAULT_MCP_CONFIG_PATH}`) : chalk.white(`Variable de conexion: ${connectionKey}`)),
+        'Base de datos'
+    );
+
+    await promptDatabaseHealthCheck(projectRoot, session);
+}
+async function editQaContextSection(projectRoot, username, session) {
+    const action = await select({
+        message: 'QA Context y gobernanza:',
+        options: [
+            { label: 'Crear archivos base si faltan', value: 'bootstrap' },
+            { label: 'Cambiar modo de gobernanza', value: 'governance' }
+        ]
+    });
+    if (isCancel(action)) return;
+
+    if (action === 'bootstrap') {
+        const result = ensureQaContextFiles(projectRoot, username);
+        if (result.createdContext) {
+            pushSessionChange(session, `Se creo ${path.relative(projectRoot, result.contextPath)}.`);
+        }
+        if (result.createdMeta) {
+            pushSessionChange(session, `Se creo ${path.relative(projectRoot, result.metaPath)}.`);
+        }
+        note(
+            [
+                result.createdContext ? `Se creo ${path.relative(projectRoot, result.contextPath)}` : `Ya existe ${path.relative(projectRoot, result.contextPath)}`,
+                result.createdMeta ? `Se creo ${path.relative(projectRoot, result.metaPath)}` : `Ya existe ${path.relative(projectRoot, result.metaPath)}`
+            ].join('\n'),
+            'QA Context'
+        );
+        return;
+    }
+
+    const governance = await select({
+        message: 'Modo de gobernanza:',
+        options: [
+            { label: 'warn', value: 'warn' },
+            { label: 'strict', value: 'strict' },
+            { label: 'off', value: 'off' }
+        ],
+        initialValue: getQaContextState(projectRoot).governance
+    });
+    if (isCancel(governance)) return;
+
+    writeEnvUpdates(projectRoot, {
+        ARCALITY_QA_CONTEXT_GOVERNANCE: governance
+    });
+    pushSessionChange(session, `Se actualizo ARCALITY_QA_CONTEXT_GOVERNANCE=${governance} en .env.`);
+    note(chalk.green(`Gobernanza actualizada a ${governance} en .env.`), 'QA Context');
+}
+
+async function reviewAndConfirmSave(session, originalConfig, draftConfig) {
+    const summary = buildPendingChanges(session, originalConfig, draftConfig);
+
+    if (!summary) {
+        note(chalk.yellow('No hay cambios pendientes por guardar.'), 'Revision');
+        return false;
+    }
+
+    note(summary, 'Revision de cambios');
+
+    const shouldSave = await confirm({
+        message: 'Deseas guardar estos cambios?'
+    });
+    if (isCancel(shouldSave) || !shouldSave) {
+        note(chalk.cyan('Se conservaron los cambios en borrador, pero no se guardaron todavia.'), 'Revision');
+        return false;
+    }
+
+    return true;
+}
+
+async function main() {
+    const projectRoot = process.cwd();
+
+    if (!configExists(projectRoot)) {
+        note(
+            chalk.yellow('No existe arcality.config en este proyecto.') + '\n' +
+            chalk.white('Primero ejecuta la configuracion inicial completa con ') + chalk.cyan('npx arcality init'),
+            'Configuracion faltante'
+        );
+        process.exit(1);
+    }
+
+    const originalConfig = loadProjectConfig(projectRoot);
+    if (!originalConfig) {
+        note(chalk.red('No se pudo leer arcality.config.'), 'Error');
+        process.exit(1);
+    }
+
+    const draftConfig = deepClone(originalConfig);
+    const session = createSessionState();
+
+    console.clear();
+    intro(chalk.cyan('Arcality Config Editor'));
+
+    let shouldSave = false;
+
+    while (true) {
+        const pendingChanges = buildPendingChanges(session, originalConfig, draftConfig);
+        note(
+            formatSummary(draftConfig, projectRoot) +
+            (pendingChanges ? `\n\n${chalk.bold('Cambios pendientes:')} ${chalk.yellow(String(session.changes.length + getConfigDiffLines(originalConfig, draftConfig).length))}` : ''),
+            'Estado actual'
+        );
+
+        const action = await select({
+            message: 'Que deseas recalibrar?',
+            options: [
+                { label: 'Proyecto (nombre, URL, framework)', value: 'project' },
+                { label: 'Autenticacion', value: 'auth' },
+                { label: 'Runtime y carpeta de misiones', value: 'runtime' },
+                { label: 'Validacion BD', value: 'db' },
+                { label: 'Probar conexion BD actual', value: 'db_check' },
+                { label: 'QA Context y gobernanza', value: 'qa' },
+                { label: 'Revisar cambios pendientes', value: 'review' },
+                { label: 'Guardar cambios y salir', value: 'save' },
+                { label: 'Salir sin guardar', value: 'exit' }
+            ]
+        });
+
+        if (isCancel(action) || action === 'exit') {
+            break;
+        }
+
+        if (action === 'project') {
+            await editProjectSection(draftConfig, projectRoot, session);
+            continue;
+        }
+
+        if (action === 'auth') {
+            await editAuthSection(draftConfig, session);
+            continue;
+        }
+
+        if (action === 'runtime') {
+            await editRuntimeSection(draftConfig, session);
+            continue;
+        }
+
+        if (action === 'db') {
+            await editDatabaseSection(projectRoot, session);
+            continue;
+        }
+
+        if (action === 'db_check') {
+            await promptDatabaseHealthCheck(projectRoot, session);
+            continue;
+        }
+
+        if (action === 'qa') {
+            await editQaContextSection(projectRoot, draftConfig.auth?.username || '', session);
+            continue;
+        }
+
+        if (action === 'review') {
+            const summary = buildPendingChanges(session, originalConfig, draftConfig);
+            note(summary || chalk.cyan('Aun no hay cambios pendientes en esta sesion.'), 'Revision de cambios');
+            continue;
+        }
+
+        if (action === 'save') {
+            shouldSave = await reviewAndConfirmSave(session, originalConfig, draftConfig);
+            if (shouldSave) break;
+            continue;
+        }
+    }
+
+    if (!shouldSave) {
+        cancel('No se guardaron cambios en arcality.config.');
+        process.exit(0);
+    }
+
+    saveProjectConfig(draftConfig, projectRoot);
+
+    note(
+        chalk.green('Configuracion actualizada correctamente.') + '\n' +
+        chalk.white(`Proyecto: ${draftConfig.project?.name || 'N/A'}`) + '\n' +
+        chalk.white(`Base URL: ${draftConfig.project?.baseUrl || 'N/A'}`) + '\n' +
+        chalk.white(`YAML base: ${draftConfig.runtime?.yamlOutputDir || './.arcality'}`),
+        'Cambios guardados'
+    );
+
+    outro(chalk.cyan('Listo. Ya puedes seguir usando Arcality con la configuracion recalibrada.'));
+}
+
+main().catch(error => {
+    console.error(chalk.red('Error al editar la configuracion:'), error.message);
+    process.exit(1);
+});