@open-mova/cli 0.1.20 → 0.1.22

package/dist/application/native-capabilities.js

@@ -0,0 +1,143 @@
+import { spawnSync } from 'node:child_process';
+import { existsSync, readFileSync, writeFileSync } from 'node:fs';
+import { join } from 'node:path';
+import { npmCommand, useCommandShell } from '../utils/platform.js';
+import { readApplicationConfiguration, writeApplicationConfiguration } from './configuration.js';
+import { readNativeCapabilityCatalog, synchronizeShellConfiguration, } from './shell-configuration.js';
+export function listNativeCapabilities(applicationRoot) {
+    const configuration = readApplicationConfiguration(applicationRoot);
+    const enabled = new Set(configuration.native?.capabilities ?? []);
+    return readNativeCapabilityCatalog(applicationRoot).capabilities.map((definition) => ({
+        definition,
+        enabled: enabled.has(definition.name),
+    }));
+}
+export function enableNativeCapabilities(applicationRoot, requestedNames) {
+    const configuration = readApplicationConfiguration(applicationRoot);
+    const definitions = resolveDefinitions(applicationRoot, requestedNames);
+    const enabled = new Set(configuration.native?.capabilities ?? []);
+    const newDefinitions = definitions.filter((definition) => !enabled.has(definition.name));
+    for (const definition of definitions)
+        enabled.add(definition.name);
+    installPackages(applicationRoot, newDefinitions);
+    return persistCapabilities(applicationRoot, configuration, [...enabled]);
+}
+export function disableNativeCapabilities(applicationRoot, requestedNames) {
+    const configuration = readApplicationConfiguration(applicationRoot);
+    const definitions = resolveDefinitions(applicationRoot, requestedNames);
+    const currentlyEnabled = new Set(configuration.native?.capabilities ?? []);
+    const activeDefinitions = definitions.filter((definition) => currentlyEnabled.has(definition.name));
+    const disabled = new Set(definitions.map((definition) => definition.name));
+    const remainingNames = (configuration.native?.capabilities ?? []).filter((name) => !disabled.has(name));
+    const remainingDefinitions = remainingNames.length > 0 ? resolveDefinitions(applicationRoot, remainingNames) : [];
+    const retainedPackages = new Set(remainingDefinitions.map((definition) => definition.package));
+    const packagesToRemove = [
+        ...new Set(activeDefinitions
+            .map((definition) => definition.package)
+            .filter((packageName) => packageName !== '@capacitor/core')),
+    ].filter((packageName) => !retainedPackages.has(packageName));
+    uninstallPackages(applicationRoot, packagesToRemove);
+    return persistCapabilities(applicationRoot, configuration, remainingNames);
+}
+export function diagnoseNativeCapabilities(applicationRoot, platform) {
+    const statuses = listNativeCapabilities(applicationRoot).filter((status) => status.enabled);
+    const messages = [];
+    if (statuses.length === 0) {
+        return ['No hay capacidades nativas habilitadas.'];
+    }
+    for (const { definition } of statuses) {
+        if (platform && !definition.platforms.includes(platform)) {
+            messages.push(`⚠ ${definition.name}: no es compatible con ${platform}.`);
+            continue;
+        }
+        const requirements = [];
+        if (platform === 'android' && definition.minimumAndroidSdk) {
+            requirements.push(`Android SDK mínimo ${definition.minimumAndroidSdk}`);
+        }
+        if (platform && definition.permissions?.[platform]?.length) {
+            requirements.push(`permisos: ${definition.permissions[platform]?.join(', ')}`);
+        }
+        if (definition.notes?.length)
+            requirements.push(...definition.notes);
+        messages.push(requirements.length > 0
+            ? `• ${definition.name}: ${requirements.join('; ')}`
+            : `✓ ${definition.name}: sin configuración adicional declarada${platform ? ` para ${platform}` : ''}.`);
+    }
+    return messages;
+}
+/**
+ * Recompone las dependencias seleccionables después de actualizar la shell.
+ * No instala paquetes: el flujo de update regenera después el lockfile.
+ */
+export function synchronizeNativeCapabilityDependencies(applicationRoot, configuration) {
+    const packagePath = join(applicationRoot, 'package.json');
+    const packageConfiguration = JSON.parse(readFileSync(packagePath, 'utf8'));
+    const dependencies = { ...(packageConfiguration.dependencies ?? {}) };
+    const catalog = readNativeCapabilityCatalog(applicationRoot);
+    const enabled = new Set(configuration.native?.capabilities ?? []);
+    const selectablePackages = new Set(catalog.capabilities
+        .map((definition) => definition.package)
+        .filter((packageName) => packageName !== '@capacitor/core'));
+    for (const packageName of selectablePackages)
+        delete dependencies[packageName];
+    for (const definition of catalog.capabilities) {
+        if (enabled.has(definition.name) &&
+            definition.package !== '@capacitor/core' &&
+            definition.version) {
+            dependencies[definition.package] = definition.version;
+        }
+    }
+    packageConfiguration.dependencies = Object.fromEntries(Object.entries(dependencies).sort(([first], [second]) => first.localeCompare(second)));
+    writeFileSync(packagePath, `${JSON.stringify(packageConfiguration, null, 2)}\n`, 'utf8');
+}
+function persistCapabilities(applicationRoot, configuration, capabilities) {
+    const updated = {
+        ...configuration,
+        native: {
+            ...configuration.native,
+            capabilities: [...new Set(capabilities)].sort(),
+        },
+    };
+    writeApplicationConfiguration(applicationRoot, updated);
+    synchronizeShellConfiguration(applicationRoot, updated);
+    return updated;
+}
+function resolveDefinitions(applicationRoot, names) {
+    if (names.length === 0)
+        throw new Error('Indica al menos una capacidad nativa.');
+    const catalog = readNativeCapabilityCatalog(applicationRoot);
+    const definitionsByName = new Map(catalog.capabilities.map((definition) => [definition.name, definition]));
+    const unknown = names.filter((name) => !definitionsByName.has(name));
+    if (unknown.length > 0) {
+        throw new Error(`Capacidades desconocidas: ${unknown.join(', ')}. Usa "mova cap list" para consultar el catálogo.`);
+    }
+    return names.map((name) => definitionsByName.get(name));
+}
+function installPackages(applicationRoot, definitions) {
+    const packages = [
+        ...new Set(definitions
+            .filter((definition) => definition.package !== '@capacitor/core')
+            .map((definition) => `${definition.package}@${definition.version ?? 'latest'}`)),
+    ];
+    if (packages.length > 0)
+        runNpm(applicationRoot, ['install', '--save', ...packages]);
+}
+function uninstallPackages(applicationRoot, packages) {
+    if (packages.length > 0)
+        runNpm(applicationRoot, ['uninstall', '--save', ...packages]);
+}
+function runNpm(applicationRoot, arguments_) {
+    if (!existsSync(join(applicationRoot, 'package.json'))) {
+        throw new Error(`No se encuentra package.json en ${applicationRoot}.`);
+    }
+    const result = spawnSync(npmCommand(), arguments_, {
+        cwd: applicationRoot,
+        stdio: 'inherit',
+        shell: useCommandShell(),
+    });
+    if (result.error)
+        throw result.error;
+    if (result.status !== 0) {
+        throw new Error(`${npmCommand()} ${arguments_.join(' ')} terminó con error.`);
+    }
+}

package/dist/application/project-update.d.ts

@@ -0,0 +1,8 @@
+export interface FileChange {
+    readonly path: string;
+    readonly content?: Buffer;
+}
+export declare function compareManagedFiles(projectRoot: string, currentDirectory: string, targetDirectory: string, conflicts: string[], ignoredPaths: ReadonlySet<string>): FileChange[];
+export declare function comparePackageConfiguration(projectRoot: string, currentDirectory: string, targetDirectory: string, conflicts: string[]): string | undefined;
+export declare function applyFileChanges(projectRoot: string, changes: readonly FileChange[]): void;
+export declare function requireCleanGitRepository(projectRoot: string): void;

package/dist/application/project-update.js

@@ -0,0 +1,106 @@
+import { spawnSync } from 'node:child_process';
+import { existsSync, mkdirSync, readFileSync, readdirSync, rmSync, writeFileSync } from 'node:fs';
+import { dirname, join, relative } from 'node:path';
+export function compareManagedFiles(projectRoot, currentDirectory, targetDirectory, conflicts, ignoredPaths) {
+    const paths = new Set([...listFiles(currentDirectory), ...listFiles(targetDirectory)]);
+    const changes = [];
+    for (const path of [...paths].sort()) {
+        if (ignoredPaths.has(path))
+            continue;
+        const currentContent = readOptionalFile(join(currentDirectory, path));
+        const targetContent = readOptionalFile(join(targetDirectory, path));
+        const projectContent = readOptionalFile(join(projectRoot, path));
+        if (buffersEqual(currentContent, targetContent))
+            continue;
+        if (buffersEqual(projectContent, currentContent)) {
+            changes.push({ path, ...(targetContent ? { content: targetContent } : {}) });
+            continue;
+        }
+        if (buffersEqual(projectContent, targetContent))
+            continue;
+        conflicts.push(path);
+    }
+    return changes;
+}
+export function comparePackageConfiguration(projectRoot, currentDirectory, targetDirectory, conflicts) {
+    const project = readJson(join(projectRoot, 'package.json'));
+    const current = readJson(join(currentDirectory, 'package.json'));
+    const target = readJson(join(targetDirectory, 'package.json'));
+    let changed = false;
+    for (const section of ['scripts', 'dependencies', 'devDependencies']) {
+        const projectSection = readStringMap(project[section]);
+        const currentSection = readStringMap(current[section]);
+        const targetSection = readStringMap(target[section]);
+        const keys = new Set([...Object.keys(currentSection), ...Object.keys(targetSection)]);
+        for (const key of keys) {
+            if (currentSection[key] === targetSection[key])
+                continue;
+            if (projectSection[key] === currentSection[key]) {
+                if (targetSection[key] === undefined) {
+                    delete projectSection[key];
+                }
+                else {
+                    projectSection[key] = targetSection[key];
+                }
+                changed = true;
+            }
+            else if (projectSection[key] !== targetSection[key]) {
+                conflicts.push(`package.json#${section}.${key}`);
+            }
+        }
+        project[section] = projectSection;
+    }
+    return changed ? `${JSON.stringify(project, null, 2)}\n` : undefined;
+}
+export function applyFileChanges(projectRoot, changes) {
+    for (const change of changes) {
+        const destination = join(projectRoot, change.path);
+        if (change.content) {
+            mkdirSync(dirname(destination), { recursive: true });
+            writeFileSync(destination, change.content);
+        }
+        else {
+            rmSync(destination, { force: true });
+        }
+    }
+}
+export function requireCleanGitRepository(projectRoot) {
+    const repository = spawnSync('git', ['-C', projectRoot, 'rev-parse', '--is-inside-work-tree'], {
+        encoding: 'utf8',
+    });
+    if (repository.status !== 0) {
+        throw new Error('Inicializa Git y crea un commit antes de actualizar.');
+    }
+    const status = spawnSync('git', ['-C', projectRoot, 'status', '--porcelain', '--untracked-files=all'], { encoding: 'utf8' });
+    if (status.status !== 0 || status.stdout.trim() !== '') {
+        throw new Error('El repositorio debe estar limpio antes de actualizar.');
+    }
+}
+function listFiles(directory) {
+    const files = [];
+    const visit = (currentDirectory) => {
+        for (const entry of readdirSync(currentDirectory, { withFileTypes: true })) {
+            const absolutePath = join(currentDirectory, entry.name);
+            if (entry.isDirectory())
+                visit(absolutePath);
+            else if (entry.isFile())
+                files.push(relative(directory, absolutePath));
+        }
+    };
+    visit(directory);
+    return files;
+}
+function readOptionalFile(path) {
+    return existsSync(path) ? readFileSync(path) : undefined;
+}
+function buffersEqual(first, second) {
+    return first === undefined ? second === undefined : second !== undefined && first.equals(second);
+}
+function readJson(path) {
+    return JSON.parse(readFileSync(path, 'utf8'));
+}
+function readStringMap(value) {
+    if (!value || typeof value !== 'object' || Array.isArray(value))
+        return {};
+    return { ...value };
+}

package/dist/application/shell-configuration.d.ts

@@ -1,2 +1,22 @@
 import type { OpenMovaApplicationConfiguration } from '../types.js';
+export interface NativeCapabilityDefinition {
+    readonly name: string;
+    readonly implementation: string;
+    readonly exportName: string;
+    readonly package: string;
+    readonly version?: string;
+    readonly platforms: readonly ('android' | 'ios' | 'web')[];
+    readonly minimumAndroidSdk?: number;
+    readonly permissions?: {
+        readonly android?: readonly string[];
+        readonly ios?: readonly string[];
+    };
+    readonly notes?: readonly string[];
+}
+interface NativeCapabilityCatalog {
+    readonly schemaVersion: 1;
+    readonly capabilities: readonly NativeCapabilityDefinition[];
+}
 export declare function synchronizeShellConfiguration(applicationRoot: string, configuration: OpenMovaApplicationConfiguration): void;
+export declare function readNativeCapabilityCatalog(applicationRoot: string): NativeCapabilityCatalog;
+export {};

package/dist/application/shell-configuration.js

@@ -1,4 +1,4 @@
-import { writeFileSync } from 'node:fs';
+import { readFileSync, writeFileSync } from 'node:fs';
 import { join } from 'node:path';
 export function synchronizeShellConfiguration(applicationRoot, configuration) {
     const manifest = Object.fromEntries(configuration.microfrontends.map((microfrontend) => [
@@ -7,6 +7,55 @@ export function synchronizeShellConfiguration(applicationRoot, configuration) {
     ]));
     writeFileSync(join(applicationRoot, 'src', 'assets', 'federation.manifest.json'), `${JSON.stringify(manifest, null, 2)}\n`, 'utf8');
     writeFileSync(join(applicationRoot, 'src', 'app', 'application.config.ts'), renderApplicationConfiguration(configuration), 'utf8');
+    synchronizeNativeCapabilities(applicationRoot, configuration);
+}
+export function readNativeCapabilityCatalog(applicationRoot) {
+    const catalogPath = join(applicationRoot, 'native-capabilities.catalog.json');
+    const catalog = JSON.parse(readFileSync(catalogPath, 'utf8'));
+    if (catalog.schemaVersion !== 1 || !Array.isArray(catalog.capabilities)) {
+        throw new Error(`${catalogPath} no contiene un catálogo de capacidades válido.`);
+    }
+    return catalog;
+}
+function synchronizeNativeCapabilities(applicationRoot, configuration) {
+    const catalog = readNativeCapabilityCatalog(applicationRoot);
+    const enabledNames = new Set(configuration.native?.capabilities ?? []);
+    const knownNames = new Set(catalog.capabilities.map((capability) => capability.name));
+    const unknownNames = [...enabledNames].filter((name) => !knownNames.has(name));
+    if (unknownNames.length > 0) {
+        throw new Error(`Capacidades nativas desconocidas: ${unknownNames.join(', ')}.`);
+    }
+    const enabled = catalog.capabilities.filter((capability) => enabledNames.has(capability.name));
+    const imports = enabled
+        .map((capability) => `import { ${capability.exportName} } from './${capability.implementation}';`)
+        .join('\n');
+    const entries = catalog.capabilities
+        .map((capability) => {
+        const value = enabledNames.has(capability.name)
+            ? capability.exportName
+            : `createUnavailableNativeCapability<NativeCapabilities[${JSON.stringify(capability.name)}]>(${JSON.stringify(capability.name)})`;
+        return `  ${capability.name}: ${value},`;
+    })
+        .join('\n');
+    const source = `import type { Provider } from '@angular/core';
+import { NATIVE_CAPABILITIES, type NativeCapabilities } from '@open-mova/core';
+import { createUnavailableNativeCapability } from './unavailable-native-capability';
+${imports ? `\n${imports}` : ''}
+
+// Generado por el CLI desde mova.config.json. No editar manualmente.
+const nativeCapabilities = {
+  version: 1,
+${entries}
+} satisfies NativeCapabilities;
+
+export function provideNativeCapabilities(): Provider {
+  return {
+    provide: NATIVE_CAPABILITIES,
+    useValue: nativeCapabilities,
+  };
+}
+`;
+    writeFileSync(join(applicationRoot, 'src', 'native-capabilities', 'native-capabilities.provider.ts'), source, 'utf8');
 }
 function renderApplicationConfiguration(configuration) {
     const entries = configuration.microfrontends
@@ -14,12 +63,14 @@ function renderApplicationConfiguration(configuration) {
     path: ${JSON.stringify(microfrontend.route)},
     remote: ${JSON.stringify(microfrontend.remoteName)},
     exposedModule: './Routes',
+    requiredCoreVersion: ${JSON.stringify(microfrontend.compatibility.requiredCoreVersion)},
   },`)
         .join('\n');
     return `export interface MicrofrontendDefinition {
   readonly path: string;
   readonly remote: string;
   readonly exposedModule: './Routes';
+  readonly requiredCoreVersion: string;
 }
 
 // Este fichero lo mantiene el CLI a partir de mova.config.json.

package/dist/application/shell-repository.d.ts

@@ -1,4 +1,4 @@
-export declare const SHELL_REPOSITORY = "https://github.com/rgarciadelongoria/open-mova.git";
+export declare const SHELL_REPOSITORY: string;
 export declare const DEMO_MICROFRONTEND_REMOTE_ENTRY = "https://rgarciadelongoria.github.io/open-mova/remoteEntry.json";
 export interface ShellVersion {
     readonly repository: string;

package/dist/application/shell-repository.js

@@ -1,8 +1,8 @@
 import { spawnSync } from 'node:child_process';
-import { cpSync, existsSync, mkdtempSync, readFileSync, rmSync, writeFileSync, } from 'node:fs';
+import { cpSync, existsSync, mkdtempSync, readFileSync, rmSync, writeFileSync } from 'node:fs';
 import { basename, join } from 'node:path';
 import { tmpdir } from 'node:os';
-export const SHELL_REPOSITORY = 'https://github.com/rgarciadelongoria/open-mova.git';
+export const SHELL_REPOSITORY = process.env['OPEN_MOVA_SHELL_REPOSITORY'] ?? 'https://github.com/rgarciadelongoria/open-mova.git';
 // El demo publicado permite probar una aplicación recién creada sin desplegar un MF propio.
 export const DEMO_MICROFRONTEND_REMOTE_ENTRY = 'https://rgarciadelongoria.github.io/open-mova/remoteEntry.json';
 const VERSION_PATTERN = /^v(\d+)\.(\d+)\.(\d+)$/;
@@ -41,9 +41,17 @@ export function downloadTaggedProject(project, destination, requestedVersion) {
     try {
         const checkout = join(temporaryDirectory, 'repository');
         runGit([
-            '-c', 'advice.detachedHead=false',
-            'clone', '--quiet', '--depth', '1', '--single-branch',
-            '--branch', version, SHELL_REPOSITORY, checkout,
+            '-c',
+            'advice.detachedHead=false',
+            'clone',
+            '--quiet',
+            '--depth',
+            '1',
+            '--single-branch',
+            '--branch',
+            version,
+            SHELL_REPOSITORY,
+            checkout,
         ]);
         const source = join(checkout, project);
         const requiredFiles = ['package.json', 'angular.json', 'src/main.ts'];
@@ -92,8 +100,7 @@ export function configureDownloadedShell(destination, applicationName, includesS
         writeFileSync(capacitorPath, customizedConfig);
     }
     writeFileSync(join(destination, '.nvmrc'), '22\n');
-    const installSteps = 'npm install\n' +
-        (includesStarterMicrofrontend ? 'npm --prefix mfs/home install\n' : '');
+    const installSteps = 'npm install\n' + (includesStarterMicrofrontend ? 'npm --prefix mfs/home install\n' : '');
     const runSteps = includesStarterMicrofrontend
         ? 'Inicia `npm --prefix mfs/home start` y `npm start` en dos terminales. Abre `http://localhost:4200/home/inicio`.\n'
         : 'Registra primero un MF con `mova mf create nombre` y después ejecuta `mova start`.\n';

package/dist/application/shell-update.d.ts

@@ -1,9 +1,6 @@
 import type { OpenMovaApplicationConfiguration } from '../types.js';
 import { type ShellVersion } from './shell-repository.js';
-interface FileChange {
-    readonly path: string;
-    readonly content?: Buffer;
-}
+import { type FileChange } from './project-update.js';
 export interface ShellUpdatePlan {
     readonly currentVersion: string;
     readonly target: ShellVersion;
@@ -16,4 +13,3 @@ export interface ShellUpdatePlan {
 }
 export declare function createShellUpdatePlan(applicationRoot: string, configuration: OpenMovaApplicationConfiguration, requestedVersion?: string): ShellUpdatePlan;
 export declare function applyShellUpdate(applicationRoot: string, configuration: OpenMovaApplicationConfiguration, plan: ShellUpdatePlan): void;
-export {};

package/dist/application/shell-update.js

@@ -1,10 +1,13 @@
-import { spawnSync } from 'node:child_process';
-import { existsSync, mkdirSync, mkdtempSync, readFileSync, readdirSync, rmSync, writeFileSync, } from 'node:fs';
-import { dirname, join, relative } from 'node:path';
+import { existsSync, mkdtempSync, readFileSync, rmSync, writeFileSync } from 'node:fs';
+import { join } from 'node:path';
 import { tmpdir } from 'node:os';
 import { synchronizeShellConfiguration } from './shell-configuration.js';
 import { downloadShell, listShellVersions } from './shell-repository.js';
 import { writeApplicationConfiguration } from './configuration.js';
+import { applyFileChanges, compareManagedFiles, comparePackageConfiguration, requireCleanGitRepository, } from './project-update.js';
+import { findIncompatibleMicrofrontends } from './core-compatibility.js';
+import { readRequiredCoreVersion } from './microfrontend-manifest.js';
+import { synchronizeNativeCapabilityDependencies } from './native-capabilities.js';
 const GENERATED_PATHS = new Set([
     'package.json',
     'package-lock.json',
@@ -34,8 +37,10 @@ export function createShellUpdatePlan(applicationRoot, configuration, requestedV
             throw new Error(`El commit registrado para ${configuration.shell.version} no coincide con el tag remoto.`);
         }
         const conflicts = [];
-        const fileChanges = compareManagedFiles(applicationRoot, currentDirectory, targetDirectory, conflicts);
+        const fileChanges = compareManagedFiles(applicationRoot, currentDirectory, targetDirectory, conflicts, GENERATED_PATHS);
         const packageUpdate = comparePackageConfiguration(applicationRoot, currentDirectory, targetDirectory, conflicts);
+        const targetCoreVersion = readRequiredCoreVersion(targetDirectory);
+        conflicts.push(...findIncompatibleMicrofrontends(configuration, targetCoreVersion));
         const capacitorUpdate = compareCapacitorConfiguration(applicationRoot, currentDirectory, targetDirectory, conflicts);
         const changes = [
             ...fileChanges.map((change) => `${change.content ? 'Actualizar' : 'Eliminar'} ${change.path}`),
@@ -65,16 +70,7 @@ export function applyShellUpdate(applicationRoot, configuration, plan) {
         throw new Error('No se puede actualizar mientras existan conflictos.');
     }
     requireCleanGitRepository(applicationRoot);
-    for (const change of plan.fileChanges) {
-        const destination = join(applicationRoot, change.path);
-        if (change.content) {
-            mkdirSync(dirname(destination), { recursive: true });
-            writeFileSync(destination, change.content);
-        }
-        else {
-            rmSync(destination, { force: true });
-        }
-    }
+    applyFileChanges(applicationRoot, plan.fileChanges);
     if (plan.packageContent) {
         writeFileSync(join(applicationRoot, 'package.json'), plan.packageContent, 'utf8');
     }
@@ -88,63 +84,10 @@ export function applyShellUpdate(applicationRoot, configuration, plan) {
         ...configuration,
         shell: plan.target,
     };
+    synchronizeNativeCapabilityDependencies(applicationRoot, updatedConfiguration);
     writeApplicationConfiguration(applicationRoot, updatedConfiguration);
     synchronizeShellConfiguration(applicationRoot, updatedConfiguration);
 }
-function compareManagedFiles(applicationRoot, currentDirectory, targetDirectory, conflicts) {
-    const paths = new Set([
-        ...listFiles(currentDirectory),
-        ...listFiles(targetDirectory),
-    ]);
-    const changes = [];
-    for (const path of [...paths].sort()) {
-        if (GENERATED_PATHS.has(path))
-            continue;
-        const currentContent = readOptionalFile(join(currentDirectory, path));
-        const targetContent = readOptionalFile(join(targetDirectory, path));
-        const applicationContent = readOptionalFile(join(applicationRoot, path));
-        if (buffersEqual(currentContent, targetContent))
-            continue;
-        if (buffersEqual(applicationContent, currentContent)) {
-            changes.push({ path, ...(targetContent ? { content: targetContent } : {}) });
-            continue;
-        }
-        if (buffersEqual(applicationContent, targetContent))
-            continue;
-        conflicts.push(path);
-    }
-    return changes;
-}
-function comparePackageConfiguration(applicationRoot, currentDirectory, targetDirectory, conflicts) {
-    const application = readJson(join(applicationRoot, 'package.json'));
-    const current = readJson(join(currentDirectory, 'package.json'));
-    const target = readJson(join(targetDirectory, 'package.json'));
-    let changed = false;
-    for (const section of ['scripts', 'dependencies', 'devDependencies']) {
-        const applicationSection = readStringMap(application[section]);
-        const currentSection = readStringMap(current[section]);
-        const targetSection = readStringMap(target[section]);
-        const keys = new Set([...Object.keys(currentSection), ...Object.keys(targetSection)]);
-        for (const key of keys) {
-            if (currentSection[key] === targetSection[key])
-                continue;
-            if (applicationSection[key] === currentSection[key]) {
-                if (targetSection[key] === undefined) {
-                    delete applicationSection[key];
-                }
-                else {
-                    applicationSection[key] = targetSection[key];
-                }
-                changed = true;
-            }
-            else if (applicationSection[key] !== targetSection[key]) {
-                conflicts.push(`package.json#${section}.${key}`);
-            }
-        }
-        application[section] = applicationSection;
-    }
-    return changed ? `${JSON.stringify(application, null, 2)}\n` : undefined;
-}
 function compareCapacitorConfiguration(applicationRoot, currentDirectory, targetDirectory, conflicts) {
     const applicationPath = join(applicationRoot, 'capacitor.config.ts');
     const currentPath = join(currentDirectory, 'capacitor.config.ts');
@@ -163,46 +106,6 @@ function compareCapacitorConfiguration(applicationRoot, currentDirectory, target
     conflicts.push('capacitor.config.ts');
     return undefined;
 }
-function requireCleanGitRepository(applicationRoot) {
-    const repository = spawnSync('git', ['-C', applicationRoot, 'rev-parse', '--is-inside-work-tree'], { encoding: 'utf8' });
-    if (repository.status !== 0) {
-        throw new Error('Inicializa Git y crea un commit antes de ejecutar mova update.');
-    }
-    const status = spawnSync('git', ['-C', applicationRoot, 'status', '--porcelain', '--untracked-files=all'], { encoding: 'utf8' });
-    if (status.status !== 0 || status.stdout.trim() !== '') {
-        throw new Error('El repositorio debe estar limpio antes de ejecutar mova update.');
-    }
-}
-function listFiles(directory) {
-    const files = [];
-    const visit = (currentDirectory) => {
-        for (const entry of readdirSync(currentDirectory, { withFileTypes: true })) {
-            const absolutePath = join(currentDirectory, entry.name);
-            if (entry.isDirectory()) {
-                visit(absolutePath);
-            }
-            else if (entry.isFile()) {
-                files.push(relative(directory, absolutePath));
-            }
-        }
-    };
-    visit(directory);
-    return files;
-}
-function readOptionalFile(path) {
-    return existsSync(path) ? readFileSync(path) : undefined;
-}
-function buffersEqual(first, second) {
-    return first === undefined ? second === undefined : second !== undefined && first.equals(second);
-}
-function readJson(path) {
-    return JSON.parse(readFileSync(path, 'utf8'));
-}
-function readStringMap(value) {
-    if (!value || typeof value !== 'object' || Array.isArray(value))
-        return {};
-    return { ...value };
-}
 function readCapacitorIdentity(content) {
     const appId = content.match(/\bappId:\s*['"]([^'"]+)['"]/)?.[1];
     const appName = content.match(/\bappName:\s*['"]([^'"]+)['"]/)?.[1];

package/dist/cli.js

@@ -4,6 +4,7 @@ import { Command } from 'commander';
 import { registerBuildCommand } from './commands/build.js';
 import { registerCapacitorCommands } from './commands/capacitor.js';
 import { registerCreateCommand } from './commands/create.js';
+import { registerDoctorCommand } from './commands/doctor.js';
 import { registerInfoCommand } from './commands/info.js';
 import { registerMicrofrontendCommands } from './commands/microfrontend.js';
 import { registerStartCommand } from './commands/start.js';
@@ -16,6 +17,7 @@ program
     .description('Herramientas de desarrollo para aplicaciones Open Mova')
     .version(packageVersion.version);
 registerCreateCommand(program);
+registerDoctorCommand(program);
 registerMicrofrontendCommands(program);
 registerStartCommand(program);
 registerShellCommands(program);