@shipi18n/cli 1.1.5 → 2.3.0

package/src/commands/translate.js

@@ -1,331 +1,88 @@
-import { readFileSync, writeFileSync, mkdirSync, existsSync, createWriteStream } from 'fs';
-import { join, parse, dirname } from 'path';
-import chalk from 'chalk';
-import archiver from 'archiver';
-import { Shipi18nAPI } from '../lib/api.js';
-import { getConfig } from '../lib/config.js';
-import { logger, formatError } from '../utils/logger.js';
-import { flattenObject, unflattenObject, deepMerge, findMissingKeys } from '../utils/incremental.js';
+import { readFileSync, writeFileSync, mkdirSync, existsSync } from 'node:fs'
+import { join } from 'node:path'
+import chalk from 'chalk'
+import ora from 'ora'
+import { translateJSON } from '@shipi18n/core'
+
+const PROVIDER_ENV = { anthropic: 'ANTHROPIC_API_KEY', openai: 'OPENAI_API_KEY' }
 
 export function translateCommand(program) {
   program
     .command('translate <input>')
-    .description('Translate a JSON locale file to multiple languages')
+    .description('Translate a JSON locale file to other languages using your own LLM')
     .option('-t, --target <languages>', 'Target languages (comma-separated)', 'es,fr')
     .option('-s, --source <language>', 'Source language', 'en')
     .option('-o, --output <dir>', 'Output directory', './locales')
-    .option('--api-key <key>', 'API key (overrides config)')
-    .option('--preserve-placeholders', 'Preserve placeholders like {name}, {{value}}, etc.', true)
-    .option('--html-handling <mode>', 'How to handle HTML in source text: none, strip, decode, preserve', 'none')
-    .option('--no-fallback', 'Disable fallback to source language for missing translations')
-    .option('--no-regional-fallback', 'Disable regional fallback (e.g., pt-BR -> pt)')
-    .option('-i, --incremental', 'Only translate new/missing keys (skip existing translations)')
-    .option('--skip-keys <keys>', 'Keys to skip from translation (comma-separated exact paths)')
-    .option('--skip-paths <patterns>', 'Paths to skip using wildcards (comma-separated, e.g., "states.*,config.*.secret")')
-    .option('--context-file <path>', 'JSON file with context annotations for disambiguation (e.g., {"close": "button - dismiss"})')
-    .option('--zip [filename]', 'Output translations as ZIP file (default: translations.zip)')
+    .option('-p, --provider <name>', 'LLM provider: anthropic | openai', 'anthropic')
+    .option('--api-key <key>', 'LLM API key (else read from provider env var)')
+    .option('--model <model>', 'Override the provider default model')
+    .option('-i, --incremental', 'Only translate new/missing keys (reuse existing output files)')
     .action(async (input, options) => {
-      const spinner = logger.spinner('Translating...');
-
+      const provider = options.provider
+      if (!PROVIDER_ENV[provider]) {
+        console.error(chalk.red(`Unknown provider '${provider}'. Use 'anthropic' or 'openai'.`))
+        process.exit(1)
+      }
+      const apiKey = options.apiKey || process.env[PROVIDER_ENV[provider]]
+      if (!apiKey) {
+        console.error(chalk.red(`No API key. Set ${chalk.yellow(PROVIDER_ENV[provider])} or pass --api-key.`))
+        console.error(chalk.gray(`This tool uses YOUR own ${provider} key — no account or Shipi18n key needed.`))
+        process.exit(1)
+      }
+      if (!existsSync(input)) {
+        console.error(chalk.red(`Input file not found: ${input}`))
+        process.exit(1)
+      }
+      let content
       try {
-        // Get config
-        const config = getConfig();
-        const apiKey = options.apiKey || config.apiKey;
-
-        if (!apiKey) {
-          spinner.fail();
-          logger.error('API key not found');
-          logger.info('Set your API key:');
-          logger.log(`  ${chalk.yellow('shipi18n config set apiKey YOUR_KEY')}`);
-          logger.log(`  ${chalk.gray('Get your free key at https://shipi18n.com')}`);
-          process.exit(1);
-        }
-
-        // Read input file
-        if (!existsSync(input)) {
-          spinner.fail();
-          logger.error(`Input file not found: ${input}`);
-          process.exit(1);
-        }
+        content = JSON.parse(readFileSync(input, 'utf8'))
+      } catch (e) {
+        console.error(chalk.red(`Invalid JSON in ${input}: ${e.message}`))
+        process.exit(1)
+      }
 
-        const fileContent = readFileSync(input, 'utf8');
-        let json;
+      const targets = options.target.split(',').map((s) => s.trim()).filter(Boolean)
+      mkdirSync(options.output, { recursive: true })
+      console.log(chalk.cyan(`\n🌍 Translating ${input} (${options.source} → ${targets.join(', ')}) via ${provider}\n`))
+
+      let hadWarnings = false
+      for (const to of targets) {
+        const spinner = ora(`Translating to ${to}...`).start()
+        const outPath = join(options.output, `${to}.json`)
+        const existing =
+          options.incremental && existsSync(outPath)
+            ? JSON.parse(readFileSync(outPath, 'utf8'))
+            : undefined
         try {
-          json = JSON.parse(fileContent);
-        } catch (error) {
-          spinner.fail();
-          logger.error(`Invalid JSON in ${input}: ${error.message}`);
-          process.exit(1);
-        }
-
-        // Parse target languages
-        const targetLanguages = options.target.split(',').map(lang => lang.trim());
-        const sourceLanguage = options.source;
-        const outputDir = options.output;
-        const inputFileName = parse(input).name;
-
-        // Parse skip options
-        const skipKeys = options.skipKeys
-          ? options.skipKeys.split(',').map(k => k.trim())
-          : [];
-        const skipPaths = options.skipPaths
-          ? options.skipPaths.split(',').map(p => p.trim())
-          : [];
-
-        if (skipKeys.length > 0 || skipPaths.length > 0) {
-          logger.info(`Skipping ${skipKeys.length + skipPaths.length} key/pattern(s) from translation`);
-        }
-
-        // Parse context annotations file
-        let contextAnnotations = {};
-        if (options.contextFile) {
-          if (!existsSync(options.contextFile)) {
-            spinner.fail();
-            logger.error(`Context file not found: ${options.contextFile}`);
-            process.exit(1);
-          }
-          try {
-            const contextContent = readFileSync(options.contextFile, 'utf8');
-            contextAnnotations = JSON.parse(contextContent);
-            const contextCount = Object.keys(contextAnnotations).length;
-            logger.info(`Loaded ${contextCount} context annotation(s) from ${options.contextFile}`);
-          } catch (error) {
-            spinner.fail();
-            logger.error(`Invalid JSON in context file: ${error.message}`);
-            process.exit(1);
-          }
-        }
-
-        // Incremental mode: load existing translations and find missing keys
-        let jsonToTranslate = json;
-        const existingTranslations = {};
-        let incrementalStats = { total: 0, existing: 0, toTranslate: 0 };
-
-        if (options.incremental) {
-          spinner.text = 'Checking existing translations...';
-
-          const sourceKeyCount = Object.keys(flattenObject(json)).length;
-          incrementalStats.total = sourceKeyCount;
-
-          // Load existing translations for each target language
-          for (const lang of targetLanguages) {
-            const targetFile = join(outputDir, lang, `${inputFileName}.json`);
-            const altTargetFile = join(outputDir, `${lang}.json`);
-
-            let existingFile = null;
-            if (existsSync(targetFile)) {
-              existingFile = targetFile;
-            } else if (existsSync(altTargetFile)) {
-              existingFile = altTargetFile;
-            }
-
-            if (existingFile) {
-              try {
-                const existingContent = readFileSync(existingFile, 'utf8');
-                existingTranslations[lang] = JSON.parse(existingContent);
-              } catch (e) {
-                logger.warn(`Could not parse ${existingFile}, will re-translate`);
-              }
-            }
-          }
-
-          // Find keys that need translation (missing from ANY target language)
-          const allMissingKeys = {};
-          for (const lang of targetLanguages) {
-            const existing = existingTranslations[lang] || {};
-            const missing = findMissingKeys(json, existing);
-            const missingFlat = flattenObject(missing);
-
-            for (const [key, value] of Object.entries(missingFlat)) {
-              if (!(key in allMissingKeys)) {
-                allMissingKeys[key] = value;
-              }
-            }
+          const { result, stats } = await translateJSON({
+            content,
+            from: options.source,
+            to,
+            provider,
+            apiKey,
+            model: options.model,
+            existing,
+          })
+          writeFileSync(outPath, JSON.stringify(result, null, 2) + '\n', 'utf8')
+          const warn = stats.placeholderWarnings.length
+          if (warn) hadWarnings = true
+          spinner.succeed(
+            `${to} → ${chalk.green(outPath)} ` +
+              chalk.gray(`(${stats.translated} translated, ${stats.reused} reused` +
+                (warn ? chalk.yellow(`, ${warn} placeholder warnings`) : '') + ')')
+          )
+          for (const w of stats.placeholderWarnings) {
+            console.log(chalk.yellow(`   ⚠ ${w.path}: placeholder drift — missing ${JSON.stringify(w.missing)}`))
           }
-
-          const missingKeyCount = Object.keys(allMissingKeys).length;
-          incrementalStats.existing = sourceKeyCount - missingKeyCount;
-          incrementalStats.toTranslate = missingKeyCount;
-
-          if (missingKeyCount === 0) {
-            spinner.succeed(chalk.green('All translations up to date!'));
-            logger.log('');
-            logger.log(chalk.gray(`   ${sourceKeyCount} key${sourceKeyCount !== 1 ? 's' : ''} already translated`));
-            return;
-          }
-
-          jsonToTranslate = unflattenObject(allMissingKeys);
-          spinner.text = `Translating ${missingKeyCount} new key${missingKeyCount !== 1 ? 's' : ''} to ${targetLanguages.length} language${targetLanguages.length > 1 ? 's' : ''}...`;
-          logger.log('');
-          logger.info(`Incremental mode: ${chalk.cyan(missingKeyCount)} new key${missingKeyCount !== 1 ? 's' : ''} to translate (${incrementalStats.existing} already exist)`);
-        } else {
-          spinner.text = `Translating to ${targetLanguages.length} language${targetLanguages.length > 1 ? 's' : ''}...`;
-        }
-
-        // Translate with fallback support
-        const api = new Shipi18nAPI(apiKey);
-        const translations = await api.translateJSON({
-          json: jsonToTranslate,
-          sourceLanguage,
-          targetLanguages,
-          preservePlaceholders: options.preservePlaceholders,
-          htmlHandling: options.htmlHandling,
-          fallback: {
-            fallbackToSource: options.fallback !== false,
-            regionalFallback: options.regionalFallback !== false,
-          },
-          skipKeys,
-          skipPaths,
-          contextAnnotations,
-        });
-
-        const keyCount = Object.keys(flattenObject(jsonToTranslate)).length;
-        spinner.succeed(chalk.green(`Translated ${keyCount} key${keyCount !== 1 ? 's' : ''} to ${targetLanguages.length} language${targetLanguages.length > 1 ? 's' : ''}!`));
-
-        // Save translated files
-        if (!existsSync(outputDir)) {
-          mkdirSync(outputDir, { recursive: true });
+        } catch (e) {
+          spinner.fail(`${to}: ${e.message}`)
+          process.exitCode = 1
         }
-
-        let savedCount = 0;
-
-        // Prepare translations for output (filter metadata, apply merging)
-        const outputTranslations = {};
-        for (const [langCode, content] of Object.entries(translations)) {
-          if (langCode === 'warnings' || langCode === 'fallbackInfo' || langCode === 'namespaceInfo' || langCode === 'skipped' || langCode === 'contextEnhanced') continue;
-
-          let finalContent = content;
-          if (options.incremental && existingTranslations[langCode]) {
-            finalContent = deepMerge(existingTranslations[langCode], content);
-          }
-          outputTranslations[langCode] = finalContent;
-        }
-
-        if (options.zip) {
-          // ZIP output mode
-          const zipFileName = typeof options.zip === 'string' ? options.zip : 'translations.zip';
-          const zipPath = join(outputDir, zipFileName);
-
-          await new Promise((resolve, reject) => {
-            const output = createWriteStream(zipPath);
-            const archive = archiver('zip', { zlib: { level: 9 } });
-
-            output.on('close', resolve);
-            archive.on('error', reject);
-
-            archive.pipe(output);
-
-            for (const [langCode, content] of Object.entries(outputTranslations)) {
-              archive.append(JSON.stringify(content, null, 2), { name: `${langCode}.json` });
-              savedCount++;
-            }
-
-            archive.finalize();
-          });
-
-          logger.success(`Saved: ${chalk.cyan(zipPath)} (${savedCount} file${savedCount !== 1 ? 's' : ''})`);
-        } else {
-          // Individual files mode
-          for (const [langCode, content] of Object.entries(outputTranslations)) {
-            const outputFile = join(outputDir, `${langCode}.json`);
-            writeFileSync(outputFile, JSON.stringify(content, null, 2), 'utf8');
-            logger.success(`Saved: ${chalk.cyan(outputFile)}${options.incremental ? chalk.gray(' (merged)') : ''}`);
-            savedCount++;
-          }
-        }
-
-        // Show fallback info if any fallbacks were used
-        if (translations.fallbackInfo && translations.fallbackInfo.used) {
-          const fallbackInfo = translations.fallbackInfo;
-          logger.log('');
-          logger.info('Fallback information:');
-
-          // Regional fallbacks
-          if (Object.keys(fallbackInfo.regionalFallbacks).length > 0) {
-            for (const [lang, baseLang] of Object.entries(fallbackInfo.regionalFallbacks)) {
-              logger.log(`  ${chalk.blue('•')} ${lang} → ${baseLang} ${chalk.gray('(regional fallback)')}`);
-            }
-          }
-
-          // Languages that fell back to source
-          if (fallbackInfo.languagesFallbackToSource.length > 0) {
-            for (const lang of fallbackInfo.languagesFallbackToSource) {
-              logger.log(`  ${chalk.yellow('•')} ${lang} → ${sourceLanguage} ${chalk.gray('(source fallback)')}`);
-            }
-          }
-
-          // Keys that used fallback
-          if (Object.keys(fallbackInfo.keysFallback).length > 0) {
-            for (const [lang, keys] of Object.entries(fallbackInfo.keysFallback)) {
-              logger.log(`  ${chalk.yellow('•')} ${lang}: ${keys.length} key${keys.length > 1 ? 's' : ''} used fallback`);
-              if (keys.length <= 5) {
-                keys.forEach(key => {
-                  logger.log(`    ${chalk.gray('- ' + key)}`);
-                });
-              }
-            }
-          }
-        }
-
-        // Show skipped keys info if any
-        if (translations.skipped && translations.skipped.count > 0) {
-          logger.log('');
-          logger.info(`Skipped ${translations.skipped.count} key${translations.skipped.count > 1 ? 's' : ''} from translation:`);
-          const keysToShow = translations.skipped.keys.slice(0, 10);
-          keysToShow.forEach(key => {
-            logger.log(`  ${chalk.gray('•')} ${key}`);
-          });
-          if (translations.skipped.keys.length > 10) {
-            logger.log(`  ${chalk.gray(`... and ${translations.skipped.keys.length - 10} more`)}`);
-          }
-        }
-
-        // Show context-enhanced keys info if any
-        if (translations.contextEnhanced && translations.contextEnhanced.count > 0) {
-          logger.log('');
-          logger.info(`${chalk.cyan('🎯')} ${translations.contextEnhanced.count} key${translations.contextEnhanced.count > 1 ? 's' : ''} translated with context annotations:`);
-          const keysToShow = translations.contextEnhanced.keys.slice(0, 10);
-          keysToShow.forEach(key => {
-            logger.log(`  ${chalk.cyan('•')} ${key}`);
-          });
-          if (translations.contextEnhanced.keys.length > 10) {
-            logger.log(`  ${chalk.gray(`... and ${translations.contextEnhanced.keys.length - 10} more`)}`);
-          }
-        }
-
-        // Show legal content warning with key details
-        const legalWarning = translations.warnings?.find(w => w.type === 'legal_content');
-        if (legalWarning?.details?.keys?.length > 0) {
-          logger.log('');
-          logger.warn(`${chalk.yellow('⚠️')}  Legal content detected - review these keys:`);
-          legalWarning.details.keys.forEach(key => {
-            logger.log(`  ${chalk.yellow('•')} ${key}`);
-          });
-          if (legalWarning.details.count > 10) {
-            logger.log(`  ${chalk.gray(`... and ${legalWarning.details.count - 10} more`)}`);
-          }
-          logger.log(`  ${chalk.gray('Machine-translated legal text may not be legally binding.')}`);
-        }
-
-        // Show other warnings if any (exclude legal_content since we showed it above)
-        const otherWarnings = translations.warnings?.filter(w => w.type !== 'legal_content') || [];
-        if (otherWarnings.length > 0) {
-          logger.log('');
-          logger.warn('Warnings:');
-          otherWarnings.forEach(warning => {
-            logger.log(`  ${chalk.yellow('•')} ${warning.message}`);
-          });
-        }
-
-        logger.log('');
-        logger.log(chalk.green(`✨ Successfully translated ${savedCount} file${savedCount > 1 ? 's' : ''}!`));
-        logger.log(chalk.gray(`   Output: ${outputDir}`));
-
-      } catch (error) {
-        spinner.fail();
-        logger.log('');
-        logger.log(formatError(error));
-        process.exit(1);
       }
-    });
+      console.log(
+        hadWarnings
+          ? chalk.yellow('\nDone, with placeholder warnings — review the flagged keys.')
+          : chalk.green('\n✓ Done.')
+      )
+    })
 }

package/src/reporters.js

@@ -0,0 +1,189 @@
+/**
+ * Output formats for `shipi18n check`.
+ *
+ * Reporters SERIALIZE a result; they never decide it. Exit codes come from
+ * `verdict()` alone, so switching reporter can never change whether CI fails.
+ */
+import chalk from 'chalk'
+
+/* ------------------------------------------------------------------ human */
+
+export function humanReport(result, verdictResult) {
+  const lines = []
+  lines.push('')
+  lines.push(
+    `🔎 shipi18n check — ${result.layout} layout, source '${result.source}', ${result.languages.length} target language(s)`
+  )
+  lines.push('')
+  for (const l of result.languages) {
+    const all = l.namespaces.flatMap((n) => n.findings.map((f) => ({ ...f, ns: n.ns })))
+    const mark = l.stats.errors ? chalk.red('✗') : all.length ? chalk.yellow('⚠') : chalk.green('✓')
+    lines.push(
+      `${mark} ${chalk.bold(l.lang)}  coverage ${(l.stats.coverage * 100).toFixed(1)}%  ${l.stats.errors} error(s), ${l.stats.warnings} warning(s)`
+    )
+    for (const f of all.slice(0, 50)) {
+      const color = f.severity === 'error' ? chalk.red : chalk.yellow
+      const where = result.layout === 'flat' ? f.path : `${f.ns}:${f.path}`
+      lines.push(`    ${color(f.severity)}  ${chalk.cyan(where)}  ${f.type} — ${f.message}`)
+    }
+    if (all.length > 50) lines.push(chalk.gray(`    … and ${all.length - 50} more`))
+  }
+  lines.push('')
+  lines.push(
+    verdictResult.ok
+      ? chalk.green('✓ check passed')
+      : chalk.red(`✗ check failed: ${verdictResult.failures.join('; ')}`)
+  )
+  return lines.join('\n')
+}
+
+/* ------------------------------------------------------------------- json */
+
+export function jsonReport(result, verdictResult) {
+  return JSON.stringify({ ...result, ok: verdictResult.ok, failures: verdictResult.failures }, null, 2)
+}
+
+/* ------------------------------------------------------------------ sarif */
+
+const RULE_META = {
+  'missing-key': 'A key present in the source language is missing from a translation.',
+  'orphan-key': 'A key present in a translation does not exist in the source language.',
+  'placeholder-missing': 'A placeholder from the source string was dropped in the translation.',
+  'placeholder-added': 'The translation contains a placeholder the source does not have.',
+  'plural-forms': 'A pipe-separated plural lost one or more of its forms in translation.',
+  'empty-value': 'The translation of a non-empty source string is empty.',
+  'untranslated': 'The translation is identical to a multi-word source string.',
+  'type-mismatch': 'Source and translation values have different JSON types.',
+  'invalid-json': 'A locale file could not be parsed as JSON.',
+  'missing-file': 'An expected locale file does not exist.',
+  'stale-translation': 'The catalog marks this translation as needing review.',
+  'glossary-violation': 'A do-not-translate or locked glossary term was not respected.',
+  'manual-translation-clobbered': 'A translation locked as hand-edited has been overwritten.',
+  'manual-translation-stale': 'The source changed after this translation was locked by hand.',
+  'semantic-mistranslation': 'LLM judge (majority vote): the translation states something different from the source.',
+  'semantic-omission': 'LLM judge (majority vote): meaningful source content is missing from the translation.',
+  'semantic-addition': 'LLM judge (majority vote): the translation contains claims the source does not make.',
+}
+
+/** SARIF 2.1.0 — one run, one rule per finding type, one result per finding. */
+export function sarifReport(result, _verdictResult, { toolVersion = '0.0.0' } = {}) {
+  const findings = []
+  for (const l of result.languages) {
+    for (const n of l.namespaces) {
+      for (const f of n.findings) findings.push({ lang: l.lang, ns: n.ns, file: n.file, ...f })
+    }
+  }
+  // Deterministic output: stable ordering makes committed SARIF diffable.
+  findings.sort((a, b) =>
+    `${a.file}|${a.path}|${a.type}`.localeCompare(`${b.file}|${b.path}|${b.type}`)
+  )
+
+  const usedTypes = [...new Set(findings.map((f) => f.type))].sort()
+  const ruleIndex = Object.fromEntries(usedTypes.map((t, i) => [t, i]))
+
+  const sarif = {
+    $schema: 'https://raw.githubusercontent.com/oasis-tcs/sarif-spec/master/Schemata/sarif-schema-2.1.0.json',
+    version: '2.1.0',
+    runs: [
+      {
+        tool: {
+          driver: {
+            name: 'shipi18n-check',
+            informationUri: 'https://github.com/Shipi18n/shipi18n',
+            version: toolVersion,
+            rules: usedTypes.map((t) => ({
+              id: t,
+              shortDescription: { text: RULE_META[t] || t },
+              helpUri: 'https://shipi18n.com/docs/cli/commands',
+            })),
+          },
+        },
+        results: findings.map((f) => ({
+          ruleId: f.type,
+          ruleIndex: ruleIndex[f.type],
+          level: f.severity === 'error' ? 'error' : 'warning',
+          message: { text: `[${f.lang}] ${f.path}: ${f.message}` },
+          locations: [
+            {
+              physicalLocation: {
+                artifactLocation: { uri: (f.file || '').split('\\').join('/') },
+              },
+            },
+          ],
+        })),
+      },
+    ],
+  }
+  return JSON.stringify(sarif, null, 2)
+}
+
+/* ------------------------------------------------------------------ junit */
+
+const xmlEscape = (s) =>
+  String(s)
+    .replace(/&/g, '&')
+    .replace(/</g, '&lt;')
+    .replace(/>/g, '&gt;')
+    .replace(/"/g, '&quot;')
+    .replace(/'/g, '&apos;')
+
+/**
+ * One <testsuite> per language, one <testcase> per namespace.
+ * Errors become <failure>; warnings go to <system-out> — a warning that fails
+ * CI gets the tool uninstalled.
+ */
+export function junitReport(result) {
+  const suites = []
+  let totalTests = 0
+  let totalFailures = 0
+
+  for (const l of result.languages) {
+    const cases = []
+    let failures = 0
+    for (const n of l.namespaces) {
+      totalTests++
+      const errors = n.findings.filter((f) => f.severity === 'error')
+      const warnings = n.findings.filter((f) => f.severity === 'warning')
+      const body = []
+      if (errors.length) {
+        failures++
+        totalFailures++
+        // Include the offending strings: "dropped {{name}}" is not actionable
+        // without seeing WHICH string dropped it.
+        const detail = errors
+          .map((f) => {
+            const lines = [`${f.path}: ${f.type} — ${f.message}`]
+            if (f.source != null) lines.push(`  source:      ${f.source}`)
+            if (f.translation != null) lines.push(`  translation: ${f.translation}`)
+            return lines.join('\n')
+          })
+          .join('\n')
+        body.push(
+          `      <failure message="${xmlEscape(`${errors.length} error(s) in ${l.lang}/${n.ns}`)}">${xmlEscape(detail)}</failure>`
+        )
+      }
+      if (warnings.length) {
+        const detail = warnings.map((f) => `${f.path}: ${f.type} — ${f.message}`).join('\n')
+        body.push(`      <system-out>${xmlEscape(detail)}</system-out>`)
+      }
+      cases.push(
+        body.length
+          ? `    <testcase classname="${xmlEscape(l.lang)}" name="${xmlEscape(n.ns)}">\n${body.join('\n')}\n    </testcase>`
+          : `    <testcase classname="${xmlEscape(l.lang)}" name="${xmlEscape(n.ns)}"/>`
+      )
+    }
+    suites.push(
+      `  <testsuite name="${xmlEscape(l.lang)}" tests="${l.namespaces.length}" failures="${failures}">\n${cases.join('\n')}\n  </testsuite>`
+    )
+  }
+
+  return [
+    '<?xml version="1.0" encoding="UTF-8"?>',
+    `<testsuites name="shipi18n-check" tests="${totalTests}" failures="${totalFailures}">`,
+    ...suites,
+    '</testsuites>',
+    '',
+  ].join('\n')
+}
+
+export const REPORTERS = { human: humanReport, json: jsonReport, sarif: sarifReport, junit: junitReport }