arcli 2.1.0 → 2.2.0

package/dist/cli/commands/billing.command.shortcuts.js

@@ -14,7 +14,7 @@ export function resolveIvaShortcut(commandOptions) {
         commandOptions.irSnc ? 'sujeto-no-categorizado' : null,
     ].filter(Boolean);
     if (shortcuts.length > 1) {
-        throw new InputValidationError('Use solo un flag de IVA receptor entre las opciones --ir-*.');
+        throw new InputValidationError('Usá solo un flag de IVA receptor entre las opciones --ir-*.');
     }
     return shortcuts[0];
 }
@@ -34,7 +34,7 @@ export function resolveDocumentIdentity(commandOptions) {
             : null,
     ].filter(Boolean);
     if (candidates.length > 1) {
-        throw new InputValidationError('Use solo una identidad de receptor: --cuit, --cuil, --dni, --consumidor-final o --cfinal.');
+        throw new InputValidationError('Usá solo una identidad de receptor: --cuit, --cuil, --dni, --consumidor-final o --cfinal.');
     }
     return candidates[0] ?? {};
 }
@@ -45,8 +45,7 @@ export function resolveConceptShortcut(commandOptions) {
         commandOptions.csp ? 'productos-servicios' : null,
     ].filter(Boolean);
     if (shortcutConcepts.length > 1) {
-        throw new InputValidationError('Use solo un flag de concepto entre --cs, --cp o --csp.');
+        throw new InputValidationError('Usá solo un flag de concepto entre --cs, --cp o --csp.');
     }
     return shortcutConcepts[0];
 }
-//# sourceMappingURL=billing.command.shortcuts.js.map

package/dist/cli/commands/completion.command.js

@@ -0,0 +1,140 @@
+import { InputValidationError } from '../../lib/errors/app-error.js';
+import { billingIvaConditionSchema, IVA_RATE_ALIASES } from '../../modules/billing/billing.schemas.js';
+import { VOUCHER_LETTERS, VOUCHER_SHORTCUTS } from '../../modules/billing/voucher-kind-map.js';
+import { completeWords } from '../../modules/completion/completion.js';
+import { formatCompletionResultAsText, formatCompletionStateAsJson, formatCompletionStateAsText, } from '../../modules/completion/completion.presenter.js';
+import { currentCompletionEnvironment, detectShell, getCompletionState, installCompletion, uninstallCompletion, } from '../../modules/completion/installer.js';
+import { buildCompletionScript, COMPLETE_COMMAND, COMPLETION_SHELLS, } from '../../modules/completion/shell-scripts.js';
+import { configPublicKeySchema } from '../../modules/config/config.schemas.js';
+import { ConfigService } from '../../modules/config/config.service.js';
+import { EXPORT_VOUCHER_KIND } from '../../modules/export/export.types.js';
+import { CONFIG_FIELDS } from '../../modules/interactive/config-fields.js';
+import { PARAMETER_TABLE_NAMES } from '../../modules/parameters/parameters.js';
+import { writeTerminalJson, writeTerminalOutput } from '../../ui/index.js';
+import { registerJsonOption, resolveOutputJson } from '../global-options.js';
+import { configureSpanishHelp, createCompletionHelp } from '../help.js';
+/** No se ofrecen: herramientas internas. */
+const INTERNAL_COMMANDS = new Set([COMPLETE_COMMAND, 'storybook']);
+const IVA_RATES = [...new Set([...Object.values(IVA_RATE_ALIASES), '5', '2.5', ...Object.keys(IVA_RATE_ALIASES)])];
+/** Valores que aceptan las opciones, por flag largo. */
+const OPTION_VALUES = {
+    '--ac': VOUCHER_SHORTCUTS,
+    '--alicuota': IVA_RATES,
+    '--concepto': ['productos', 'servicios', 'productos-servicios'],
+    '--ir': billingIvaConditionSchema.options,
+    '--iva-receptor': billingIvaConditionSchema.options,
+    '--mda': ['ARS', 'USD'],
+    '--moneda': ['ARS', 'USD'],
+    '--transferencia': ['sca', 'adc'],
+};
+/** `config establecer <clave> <valor>`: el valor depende de la clave. */
+const configValues = ([key]) => CONFIG_FIELDS.find((field) => field.key === key)?.choices ?? [];
+/** Valores de los argumentos posicionales, por nombre del argumento. */
+const ARGUMENT_VALUES = {
+    clave: configPublicKeySchema.options,
+    letra: VOUCHER_LETTERS,
+    moneda: ['USD', 'DOL'],
+    shell: COMPLETION_SHELLS,
+    tabla: [...PARAMETER_TABLE_NAMES, 'cotizacion'],
+    tipo: VOUCHER_SHORTCUTS,
+    valor: configValues,
+};
+/** La familia `factura` tambien acepta la letra E (exportacion). */
+function argumentValues(command, name) {
+    return name === 'letra' && command.name() === EXPORT_VOUCHER_KIND.family
+        ? [...VOUCHER_LETTERS, EXPORT_VOUCHER_KIND.letter]
+        : ARGUMENT_VALUES[name];
+}
+/** El arbol de commander como lo necesita el autocompletado. */
+export function describeCompletionTree(command) {
+    return {
+        argumentValues: command.registeredArguments.map((argument) => argumentValues(command, argument.name())),
+        name: command.name(),
+        options: command.options.map((option) => ({
+            flags: [option.long, option.short].filter((flag) => Boolean(flag)),
+            hidden: option.hidden,
+            takesValue: option.required || option.optional,
+            values: option.long ? OPTION_VALUES[option.long] : undefined,
+        })),
+        subcommands: command.commands
+            .filter((subcommand) => !INTERNAL_COMMANDS.has(subcommand.name()))
+            .map(describeCompletionTree),
+    };
+}
+function parseShell(value) {
+    if (!COMPLETION_SHELLS.includes(value)) {
+        throw new InputValidationError(`El shell "${value}" no es válido. Usá ${COMPLETION_SHELLS.join(', ')}.`);
+    }
+    return value;
+}
+/** El shell pedido o, si no se paso, el de `$SHELL`. */
+export function resolveShell(value, environment) {
+    if (value) {
+        return parseShell(value);
+    }
+    const detected = detectShell(environment.shell);
+    if (!detected) {
+        throw new InputValidationError(`No se pudo saber qué shell usás${environment.shell ? ` (${environment.shell})` : ''}. Indicalo: bash, zsh o fish.`);
+    }
+    return detected;
+}
+function isJson(command) {
+    const service = new ConfigService();
+    try {
+        return resolveOutputJson(command, service.getConfig());
+    }
+    finally {
+        service.close();
+    }
+}
+export function registerCompletionCommands(program) {
+    const environment = currentCompletionEnvironment();
+    const command = registerJsonOption(program
+        .command('completado')
+        .description('autocompletado con Tab para bash, zsh o fish: instalarlo, desinstalarlo o ver el script')
+        .argument('[shell]', `${COMPLETION_SHELLS.join(', ')}: imprime el script; sin shell, muestra si está instalado`)).action((shell, _options, self) => {
+        if (shell) {
+            process.stdout.write(buildCompletionScript(parseShell(shell)));
+            return;
+        }
+        const state = getCompletionState(resolveShell(undefined, environment), environment);
+        if (isJson(self)) {
+            writeTerminalJson(formatCompletionStateAsJson(state));
+        }
+        else {
+            writeTerminalOutput(formatCompletionStateAsText(state, environment.home));
+        }
+    });
+    configureSpanishHelp(command);
+    command.addHelpText('after', createCompletionHelp());
+    // Pedir el comando ya es la confirmacion, como en `pdf instalar`: no se vuelve a preguntar.
+    for (const [name, description, run] of [
+        ['instalar', 'agregar el autocompletado al archivo de inicio del shell', installCompletion],
+        ['desinstalar', 'sacar el autocompletado que agrego arcli', uninstallCompletion],
+    ]) {
+        const subcommand = registerJsonOption(command
+            .command(name)
+            .description(description)
+            .argument('[shell]', `${COMPLETION_SHELLS.join(', ')}; por defecto el de $SHELL`)).action((shell, _options, self) => {
+            const result = run(resolveShell(shell, environment), environment);
+            if (isJson(self)) {
+                writeTerminalJson(formatCompletionStateAsJson(result));
+            }
+            else {
+                writeTerminalOutput(formatCompletionResultAsText(result, environment.home));
+            }
+        });
+        configureSpanishHelp(subcommand);
+    }
+    // Lo llama el script del shell en cada Tab: `arcli __completar -- <palabras escritas>`. Una por linea.
+    program
+        .command(COMPLETE_COMMAND, { hidden: true })
+        .argument('[palabras...]')
+        .allowUnknownOption()
+        .action((words = []) => {
+        const candidates = completeWords(describeCompletionTree(program), words);
+        if (candidates.length > 0) {
+            process.stdout.write(`${candidates.join('\n')}\n`);
+        }
+    });
+}

package/dist/cli/commands/config.command.js

@@ -28,7 +28,7 @@ export function buildRuntimeChecks(config) {
         catch (error) {
             return {
                 environment,
-                error: error instanceof Error ? error.message : 'No se pudo completar la validacion.',
+                error: error instanceof Error ? error.message : 'No se pudo completar la validación.',
             };
         }
     });
@@ -36,7 +36,7 @@ export function buildRuntimeChecks(config) {
 export function registerConfigCommand(program) {
     const configCommand = program
         .command('config')
-        .description('guardar defaults, credenciales y revisar si el CLI esta listo para emitir');
+        .description('guardar defaults, credenciales y revisar si el CLI está listo para emitir');
     configureSpanishHelp(configCommand);
     registerJsonOption(configCommand).action((_options, command) => {
         const service = createConfigService();
@@ -52,14 +52,14 @@ export function registerConfigCommand(program) {
     configCommand.addHelpText('after', createConfigHelp());
     const revisarCommand = configCommand
         .command('revisar')
-        .description('revisar configuracion, defaults, credenciales y validacion de cada entorno')
+        .description('revisar configuración, defaults, credenciales y validación de cada entorno')
         .action((_options, command) => {
         const service = createConfigService();
         let spinner = null;
         try {
             const config = service.getConfig();
             const useJson = resolveOutputJson(command, config);
-            spinner = useJson ? null : startSpinner('Generando revision...');
+            spinner = useJson ? null : startSpinner('Generando revisión...');
             const report = buildConfigDoctorReport(config, buildRuntimeChecks(config));
             spinner?.stop();
             printConfigResult(formatConfigDoctorAsText(report), formatConfigDoctor(report), useJson);
@@ -74,7 +74,7 @@ export function registerConfigCommand(program) {
     });
     registerJsonOption(revisarCommand);
     configureSpanishHelp(revisarCommand);
-    const rutaCommand = registerJsonOption(configCommand.command('ruta').description('mostrar la ruta del archivo de configuracion')).action((_options, command) => {
+    const rutaCommand = registerJsonOption(configCommand.command('ruta').description('mostrar la ruta del archivo de configuración')).action((_options, command) => {
         const service = createConfigService();
         try {
             const path = service.getPath();
@@ -87,8 +87,8 @@ export function registerConfigCommand(program) {
     configureSpanishHelp(rutaCommand);
     const establecerCommand = configCommand
         .command('establecer')
-        .description('guardar un valor de configuracion')
-        .argument('<clave>', 'clave publica de configuracion')
+        .description('guardar un valor de configuración')
+        .argument('<clave>', 'clave publica de configuración')
         .argument('<valor>', 'valor a guardar')
         .addHelpText('after', createConfigSetHelp())
         .action((key, value, _options, command) => {
@@ -107,8 +107,8 @@ export function registerConfigCommand(program) {
     configureSpanishHelp(establecerCommand);
     const eliminarCommand = configCommand
         .command('eliminar')
-        .description('eliminar un valor de configuracion')
-        .argument('<clave>', 'clave publica de configuracion')
+        .description('eliminar un valor de configuración')
+        .argument('<clave>', 'clave publica de configuración')
         .action((key, _options, command) => {
         // Sin ensureInitialized: si la config quedo invalida, establecer o eliminar la clave es la forma de arreglarla.
         const service = new ConfigService();
@@ -124,4 +124,3 @@ export function registerConfigCommand(program) {
     registerJsonOption(eliminarCommand);
     configureSpanishHelp(eliminarCommand);
 }
-//# sourceMappingURL=config.command.js.map

package/dist/cli/commands/cuit-argument.js

@@ -1,10 +1,10 @@
 import { InputValidationError } from '../../lib/errors/app-error.js';
-/** CUIT de un argumento posicional: 11 digitos, sin guiones. */
+import { parseCuit } from '../../lib/identity/cuit.js';
+/** CUIT de un argumento posicional, con o sin guiones. */
 export function parseCuitArgument(value) {
-    const normalizedValue = value.trim();
-    if (!/^\d{11}$/.test(normalizedValue)) {
-        throw new InputValidationError(`El CUIT "${value}" no es valido: debe tener 11 digitos.`);
+    const result = parseCuit(value);
+    if (!result.ok) {
+        throw new InputValidationError(`El CUIT "${value}" no es válido: ${result.reason}.`);
     }
-    return Number(normalizedValue);
+    return Number(result.value);
 }
-//# sourceMappingURL=cuit-argument.js.map

package/dist/cli/commands/examples.command.js

@@ -11,4 +11,3 @@ export function registerExamplesCommand(program) {
         .addHelpText('after', createExamplesHelp());
     configureSpanishHelp(command);
 }
-//# sourceMappingURL=examples.command.js.map

package/dist/cli/commands/export-shortcut.command.js

@@ -0,0 +1,19 @@
+import { EXPORT_VOUCHER_KIND } from '../../modules/export/export.types.js';
+import { registerGlobalOptions } from '../global-options.js';
+import { configureSpanishHelp, createExportShortcutHelp } from '../help.js';
+import { executeExportCommand } from './export.command.js';
+import { registerExportOptions } from './export.command.options.js';
+/** `arcli fe`: el atajo de la factura E, como `fa`, `fb` y `fc`. Es lo mismo que `arcli factura e`. */
+export function registerExportShortcutCommand(program) {
+    // Oculto en la lista de comandos: la ayuda principal lo muestra en la tabla de atajos.
+    const command = program
+        .command(EXPORT_VOUCHER_KIND.shortcut, { hidden: true })
+        .description(`${EXPORT_VOUCHER_KIND.displayName} por shortcut (WSFEX), con ayuda guiada para previsualizar o emitir`);
+    configureSpanishHelp(command);
+    registerGlobalOptions(command);
+    registerExportOptions(command);
+    command.action(async () => {
+        await executeExportCommand(command);
+    });
+    command.addHelpText('after', createExportShortcutHelp());
+}

package/dist/cli/commands/export.command.js

@@ -0,0 +1,106 @@
+import { ExportService } from '../../modules/export/export.service.js';
+import { EXPORT_VOUCHER_KIND } from '../../modules/export/export.types.js';
+import { ArcaClientFactory } from '../../services/arca/arca-client.factory.js';
+import { ArcaExportGateway } from '../../services/arca/arca-export.gateway.js';
+import { formatExportResultAsJson, formatExportResultAsText, formatPdfOutcomeAsText, writeTerminalJson, writeTerminalOutput, } from '../../ui/index.js';
+import { certificateWarnings, resolveArcaRuntime } from '../arca-runtime.js';
+import { getGlobalOptions } from '../global-options.js';
+import { chooseOne } from '../interactive/prompts.js';
+import { startSpinner } from '../spinner.js';
+import { REJECTED_EXIT_CODE } from './billing.command.shared.js';
+import { parseExportCommandPlan } from './export.command.parser.js';
+import { attachExportPdf } from './export.command.pdf.js';
+const ITEMS_DESCRIPTION_WARNING = '--descripcion se usa solo cuando no hay --item: el detalle del comprobante sale de los items.';
+function writeExportResult(result, options) {
+    if (options.outputJson) {
+        writeTerminalJson(formatExportResultAsJson(result, { raw: options.raw }));
+        return;
+    }
+    writeTerminalOutput(formatExportResultAsText(result, {
+        environment: options.environment,
+        previewShown: options.previewShown,
+        raw: options.raw,
+    }));
+}
+function resolveWarnings(certificateWarningsList, input) {
+    const ignored = input.items && input.items.length > 0 && input.description?.trim() ? [ITEMS_DESCRIPTION_WARNING] : [];
+    return [...certificateWarningsList, ...ignored];
+}
+/** Esc cuenta como no, igual que en A, B y C. */
+async function promptForEmission() {
+    return chooseOne(`¿Querés emitir ${EXPORT_VOUCHER_KIND.displayName} ahora?`, [
+        { name: 'Sí, emitir ahora', value: true },
+        { name: 'No, dejar sin emitir', value: false },
+    ], true, { escapeLabel: 'no emitir', escapeValue: false });
+}
+/**
+ * Un comprobante por ejecucion: resuelve el payload contra WSFEX, muestra la vista previa si corresponde,
+ * emite y, si hay CAE, genera el PDF.
+ */
+export async function executeExportCommand(command, options = {}) {
+    const globalOptions = getGlobalOptions(command);
+    let spinner = null;
+    try {
+        const runtime = resolveArcaRuntime(globalOptions);
+        const plan = parseExportCommandPlan(command, { defaultEmit: runtime.config.output.emitirPorDefecto });
+        const useRaw = typeof globalOptions.bruto === 'boolean' ? globalOptions.bruto : runtime.outputRaw;
+        const interactive = !runtime.outputJson && Boolean(process.stdin.isTTY && process.stdout.isTTY);
+        const service = new ExportService();
+        const gateway = new ArcaExportGateway(new ArcaClientFactory().createForExport(runtime));
+        spinner = runtime.outputJson ? null : startSpinner('Consultando WSFEX...');
+        const resolved = await service.resolve(plan.input, gateway, runtime);
+        // Los avisos de la resolucion (por ejemplo, la cotizacion de un dia anterior) van con los del certificado.
+        const warnings = [
+            ...resolveWarnings(certificateWarnings(runtime), plan.input),
+            ...(options.extraWarnings ?? []),
+            ...(resolved.warnings ?? []),
+        ];
+        spinner?.stop();
+        spinner = null;
+        let result = service.preview(resolved, runtime, warnings);
+        let previewShown = false;
+        if (!plan.input.emit) {
+            // Sin flags de emision y con terminal: se muestra la vista previa y se pregunta. Con --json o sin
+            // terminal nadie puede responder, asi que queda en vista previa.
+            if (plan.modeSource !== 'default' || !interactive) {
+                writeExportResult(result, {
+                    environment: runtime.environment,
+                    outputJson: runtime.outputJson,
+                    previewShown: false,
+                    raw: useRaw,
+                });
+                return;
+            }
+            writeTerminalOutput(formatExportResultAsText(result, { environment: runtime.environment, raw: useRaw }));
+            if (!(await promptForEmission())) {
+                return;
+            }
+            previewShown = true;
+        }
+        spinner = runtime.outputJson ? null : startSpinner('Emitiendo comprobante...');
+        result = await service.execute({ gateway, resolved, runtime, warnings });
+        spinner?.stop();
+        spinner = null;
+        result = await attachExportPdf(result, {
+            config: runtime.config,
+            input: plan.input,
+            interactive,
+        });
+        writeExportResult(result, {
+            environment: runtime.environment,
+            outputJson: runtime.outputJson,
+            previewShown,
+            raw: useRaw,
+        });
+        if (result.response.status === 'rechazado') {
+            process.exitCode = REJECTED_EXIT_CODE;
+        }
+        if (result.pdf && !runtime.outputJson) {
+            writeTerminalOutput(formatPdfOutcomeAsText(result.pdf));
+        }
+    }
+    catch (error) {
+        spinner?.stop();
+        throw error;
+    }
+}

package/dist/cli/commands/export.command.options.js

@@ -0,0 +1,140 @@
+import { Option } from 'commander';
+import { InputValidationError } from '../../lib/errors/app-error.js';
+import { EXCHANGE_RATE_DECIMALS } from '../../lib/numbers/argentine-amount.js';
+import { parseStrictInteger } from '../../lib/numbers/strict-integer.js';
+import { parseExportItemArgument } from '../../modules/export/export.items.js';
+import { amountOption, integerOption } from '../option-parsers.js';
+function exportTypeOption(value) {
+    const parsed = parseStrictInteger(value);
+    if (parsed !== 1 && parsed !== 2 && parsed !== 4) {
+        throw new InputValidationError(`--tipo-expo "${value}" no es válido: usá 1 (bienes), 2 (servicios) o 4 (otros).`);
+    }
+    return parsed;
+}
+function repeatable(parse) {
+    return (value, previous) => [...(Array.isArray(previous) ? previous : []), parse(value)];
+}
+const EXPORT_OPTIONS = [
+    {
+        description: 'importe total del comprobante, por ejemplo 15000 o 1.500,50',
+        flags: '-m, --monto <numero>',
+        parser: amountOption('--monto'),
+    },
+    { description: 'nombre o razón social del cliente del exterior', flags: '--cliente <texto>' },
+    { description: 'domicilio del cliente en el exterior', flags: '--domicilio-cliente <texto>' },
+    {
+        description: 'país de destino por código o nombre, por ejemplo 203 o Brasil',
+        flags: '--pais-destino <codigo|nombre>',
+    },
+    { description: 'ID impositivo del cliente en su país', flags: '--id-impositivo <texto>' },
+    {
+        description: 'CUIT del país del cliente; sin este flag se resuelve desde el país de destino',
+        flags: '--cuit-pais <numero>',
+        parser: integerOption('--cuit-pais'),
+    },
+    {
+        description: 'tipo de exportación: 1 bienes, 2 servicios (por defecto), 4 otros',
+        flags: '--tipo-expo <1|2|4>',
+        parser: exportTypeOption,
+    },
+    {
+        description: 'código de la tabla de actividades de WSFEX, por ejemplo 620100; sin flag, exportacion.actividad de la config',
+        flags: '--actividad <codigo>',
+        parser: integerOption('--actividad'),
+    },
+    { description: 'código de incoterm, por ejemplo FOB', flags: '--incoterm <codigo>' },
+    { description: 'descripción del incoterm; por defecto la de la tabla de ARCA', flags: '--incoterms-desc <texto>' },
+    {
+        description: 'código de idioma del comprobante: 1 español (por defecto), 2 inglés, 3 portugués',
+        flags: '--idioma <codigo>',
+        parser: integerOption('--idioma'),
+    },
+    { description: 'forma de pago; por defecto "Transferencia Internacional"', flags: '--forma-pago <texto>' },
+    {
+        description: 'permiso de embarque ya existente; repetible. Requiere --permiso-existente y --tipo-expo 1',
+        flags: '--permiso <id>',
+        parser: repeatable((value) => value),
+    },
+    {
+        description: 'el permiso de embarque informado ya existe en ARCA',
+        flags: '--permiso-existente',
+    },
+    {
+        description: 'item del comprobante: "codigo|descripcion|cantidad|precio|unidad". Repetible; la suma tiene que dar --monto',
+        flags: '--item <partes>',
+        parser: repeatable((value) => parseExportItemArgument(value)),
+    },
+    {
+        description: 'número del comprobante; por defecto el siguiente de ARCA',
+        flags: '--numero <numero>',
+        parser: integerOption('--numero'),
+    },
+    {
+        description: 'ID de la solicitud; por defecto el siguiente de ARCA',
+        flags: '--id-solicitud <numero>',
+        parser: integerOption('--id-solicitud'),
+    },
+    {
+        description: 'punto de venta (alias: --pv)',
+        flags: '--punto-venta <numero>',
+        parser: integerOption('--punto-venta'),
+    },
+    { description: 'alias de --punto-venta', flags: '--pv <numero>', hidden: true, parser: integerOption('--pv') },
+    { description: 'fecha del comprobante; acepta D, D/M, D/M/YY o D/M/YYYY con - o /', flags: '-f, --fecha <fecha>' },
+    { description: 'fecha de pago; por defecto la del comprobante', flags: '--fecha-pago <fecha>' },
+    { description: 'código de moneda: USD o DOL (por defecto), ARS o PES (alias: --mda)', flags: '--moneda <codigo>' },
+    { description: 'alias de --moneda', flags: '--mda <codigo>', hidden: true },
+    {
+        description: 'cotización de la moneda; sin este flag se usa la de aduana que publica ARCA (alias: --cm)',
+        flags: '--cotizacion-moneda <numero>',
+        parser: amountOption('--cotizacion-moneda', EXCHANGE_RATE_DECIMALS),
+    },
+    {
+        description: 'alias de --cotizacion-moneda',
+        flags: '--cm <numero>',
+        hidden: true,
+        parser: amountOption('--cm', EXCHANGE_RATE_DECIMALS),
+    },
+    { description: 'el pago se cancela en la misma moneda extranjera', flags: '--misma-moneda' },
+    { description: 'observaciones del comprobante', flags: '--observaciones <texto>' },
+    { description: 'observaciones comerciales del comprobante', flags: '--obs-comerciales <texto>' },
+    {
+        description: 'descripción del comprobante cuando no se informan items; también va al PDF',
+        flags: '--descripcion <texto>',
+    },
+    { description: 'cargar los datos desde un archivo JSON', flags: '--cargar <ruta>' },
+    {
+        description: 'generar el PDF del comprobante emitido, aunque la config diga otra cosa (alias: --pdf)',
+        flags: '--exportar-pdf',
+    },
+    { description: 'alias de --exportar-pdf', flags: '--pdf', hidden: true },
+    { description: 'no generar el PDF, aunque la config diga otra cosa', flags: '--sin-pdf' },
+    { description: 'mostrar el payload antes de emitir en ARCA', flags: '--previsualizar' },
+    { description: 'emitir realmente en ARCA', flags: '--emitir' },
+];
+/** Los flags largos que aplican a la factura E, incluidos los que comparte con A, B y C (`--monto`, `--fecha`...). */
+export const EXPORT_OPTION_FLAGS = new Set(EXPORT_OPTIONS.map((definition) => new Option(definition.flags).long).filter((flag) => Boolean(flag)));
+/**
+ * Registra las opciones de la factura E. `hidden` las registra sin mostrarlas: `arcli factura <letra>` las acepta
+ * para la letra E. Las que el comando ya tiene (`--monto`, `--fecha`...) se reusan. Devuelve las que agrego.
+ */
+export function registerExportOptions(command, options = {}) {
+    const existing = new Set(command.options.flatMap((option) => [option.short, option.long]).filter((flag) => Boolean(flag)));
+    const added = [];
+    for (const definition of EXPORT_OPTIONS) {
+        const option = new Option(definition.flags, definition.description);
+        const flags = [option.short, option.long].filter((flag) => Boolean(flag));
+        if (flags.some((flag) => existing.has(flag))) {
+            continue;
+        }
+        if (definition.parser) {
+            option.argParser(definition.parser);
+        }
+        if (options.hidden || definition.hidden) {
+            option.hideHelp();
+        }
+        command.addOption(option);
+        added.push(option);
+    }
+    return added;
+}

package/dist/cli/commands/export.command.parser.js

@@ -0,0 +1,84 @@
+import { InputValidationError } from '../../lib/errors/app-error.js';
+import { readJsonFile } from '../../lib/files/read-json-file.js';
+import { mapExportJsonItems, readExportJsonInput } from '../../modules/export/export.json-input.js';
+function pickString(...values) {
+    return values.find((value) => typeof value === 'string');
+}
+function pickNumber(...values) {
+    return values.find((value) => typeof value === 'number');
+}
+function pickBoolean(...values) {
+    return values.find((value) => typeof value === 'boolean');
+}
+function pickItems(flagsValue, fileItems) {
+    return Array.isArray(flagsValue) && flagsValue.length > 0 ? flagsValue : fileItems;
+}
+function pickList(flagsValue, fileValue) {
+    return Array.isArray(flagsValue) && flagsValue.length > 0 ? flagsValue : fileValue?.slice();
+}
+/** `--emitir` y `--previsualizar` deciden juntos, y el archivo de `--cargar` puede traer `emitir`. */
+function resolveEmitDecision(flags, file, defaults) {
+    if (flags.emitir && flags.previsualizar) {
+        throw new InputValidationError('Usá --emitir o --previsualizar, no los dos.');
+    }
+    if (flags.emitir !== undefined) {
+        return { emit: flags.emitir, modeSource: 'flags' };
+    }
+    if (flags.previsualizar !== undefined) {
+        return { emit: !flags.previsualizar, modeSource: 'flags' };
+    }
+    if (file?.emitir !== undefined) {
+        return { emit: file.emitir, modeSource: 'file' };
+    }
+    if (file?.previsualizar !== undefined) {
+        return { emit: !file.previsualizar, modeSource: 'file' };
+    }
+    return { emit: defaults.defaultEmit ?? false, modeSource: 'default' };
+}
+/** Los flags ganan sobre el JSON de `--cargar`, igual que en facturacion. */
+export function parseExportCommandPlan(command, defaults = {}) {
+    const options = command.optsWithGlobals();
+    const filePath = typeof options.cargar === 'string' ? options.cargar : undefined;
+    const file = filePath ? readExportJsonInput(readJsonFile(filePath)) : undefined;
+    const { emit, modeSource } = resolveEmitDecision({ emitir: pickBoolean(options.emitir), previsualizar: pickBoolean(options.previsualizar) }, file, defaults);
+    const destination = pickString(options.paisDestino, file?.paisDestino) ?? pickNumber(options.paisDestino, file?.paisDestino);
+    const currency = pickString(options.moneda, options.mda, file?.codigoMoneda);
+    const pdf = pickBoolean(options.exportarPdf, options.pdf) ?? (pickBoolean(options.sinPdf) === true ? false : undefined);
+    return {
+        input: {
+            activity: pickNumber(options.actividad, file?.actividad),
+            amount: pickNumber(options.monto, file?.monto),
+            clientAddress: pickString(options.domicilioCliente, file?.domicilioCliente),
+            clientCountryCuit: pickNumber(options.cuitPais, file?.cuitPais),
+            clientName: pickString(options.cliente, file?.cliente),
+            clientTaxId: pickString(options.idImpositivo, file?.idImpositivo),
+            commercialObservations: pickString(options.obsComerciales, file?.observacionesComerciales),
+            currencyCode: currency,
+            description: pickString(options.descripcion, file?.descripcion),
+            destinationCountry: destination === undefined ? undefined : String(destination),
+            emit,
+            exchangeRate: pickNumber(options.cotizacionMoneda, options.cm, file?.cotizacionMoneda),
+            exportType: pickNumber(options.tipoExpo, file?.tipoExpo),
+            incoterm: pickString(options.incoterm, file?.incoterm),
+            incotermDescription: pickString(options.incotermsDesc, file?.descripcionIncoterm),
+            items: pickItems(options.item, mapExportJsonItems(file?.items)),
+            language: pickNumber(options.idioma, file?.idioma),
+            modeSource,
+            observations: pickString(options.observaciones, file?.observaciones),
+            paymentDate: pickString(options.fechaPago, file?.fechaPago),
+            paymentTerms: pickString(options.formaPago, file?.formaPago),
+            pdf,
+            permits: pickList(options.permiso, file?.permisos),
+            permitsExisting: pickBoolean(options.permisoExistente, file?.permisoExistente),
+            pointOfSale: pickNumber(options.puntoVenta, options.pv, file?.puntoVenta),
+            requestId: pickNumber(options.idSolicitud, file?.idSolicitud),
+            sameCurrency: pickBoolean(options.mismaMoneda, file?.mismaMoneda),
+            voucherDate: pickString(options.fecha, file?.fechaComprobante),
+            voucherNumber: pickNumber(options.numero, file?.numero),
+        },
+        modeSource,
+    };
+}
+export function parseExportCommandInput(command, defaults = {}) {
+    return parseExportCommandPlan(command, defaults).input;
+}