lingo.dev 0.111.4 → 0.111.6

package/build/cli.mjs

@@ -216,6 +216,7 @@ var docLinks = {
 };
 var CLIError = class extends Error {
   docUrl;
+  errorType = "cli_error";
   constructor({ message, docUrl }) {
     super(message);
     this.docUrl = docLinks[docUrl];
@@ -223,6 +224,137 @@ var CLIError = class extends Error {
  visit: ${this.docUrl}`;
   }
 };
+var ConfigError = class extends CLIError {
+  errorType = "config_error";
+  constructor({ message, docUrl }) {
+    super({ message, docUrl });
+    this.name = "ConfigError";
+  }
+};
+var AuthenticationError = class extends CLIError {
+  errorType = "auth_error";
+  constructor({ message, docUrl }) {
+    super({ message, docUrl });
+    this.name = "AuthenticationError";
+  }
+};
+var ValidationError = class extends CLIError {
+  errorType = "validation_error";
+  constructor({ message, docUrl }) {
+    super({ message, docUrl });
+    this.name = "ValidationError";
+  }
+};
+var LocalizationError = class extends Error {
+  errorType = "locale_error";
+  bucket;
+  sourceLocale;
+  targetLocale;
+  pathPattern;
+  constructor(message, context) {
+    super(message);
+    this.name = "LocalizationError";
+    this.bucket = context?.bucket;
+    this.sourceLocale = context?.sourceLocale;
+    this.targetLocale = context?.targetLocale;
+    this.pathPattern = context?.pathPattern;
+  }
+};
+var BucketProcessingError = class extends Error {
+  errorType = "bucket_error";
+  bucket;
+  constructor(message, bucket) {
+    super(message);
+    this.name = "BucketProcessingError";
+    this.bucket = bucket;
+  }
+};
+function isConfigError(error) {
+  return error instanceof ConfigError || error.errorType === "config_error";
+}
+function isAuthenticationError(error) {
+  return error instanceof AuthenticationError || error.errorType === "auth_error";
+}
+function isValidationError(error) {
+  return error instanceof ValidationError || error.errorType === "validation_error";
+}
+function isLocalizationError(error) {
+  return error instanceof LocalizationError || error.errorType === "locale_error";
+}
+function isBucketProcessingError(error) {
+  return error instanceof BucketProcessingError || error.errorType === "bucket_error";
+}
+function getCLIErrorType(error) {
+  if (isConfigError(error)) return "config_error";
+  if (isAuthenticationError(error)) return "auth_error";
+  if (isValidationError(error)) return "validation_error";
+  if (isLocalizationError(error)) return "locale_error";
+  if (isBucketProcessingError(error)) return "bucket_error";
+  if (error instanceof CLIError) return "cli_error";
+  return "unknown_error";
+}
+function createPreviousErrorContext(errorDetails) {
+  if (errorDetails.length === 0) return void 0;
+  return {
+    count: errorDetails.length,
+    types: [...new Set(errorDetails.map((e) => e.type))],
+    buckets: [...new Set(errorDetails.map((e) => e.bucket).filter(Boolean))]
+  };
+}
+function aggregateErrorAnalytics(errorDetails, buckets, targetLocales, i18nConfig) {
+  if (errorDetails.length === 0) {
+    return {
+      errorCount: 0,
+      errorTypes: [],
+      errorsByBucket: {},
+      errorsByType: {},
+      firstError: void 0,
+      bucketCount: buckets.length,
+      localeCount: targetLocales.length,
+      i18nConfig: {
+        sourceLocale: i18nConfig.locale.source,
+        targetLocales: i18nConfig.locale.targets,
+        bucketTypes: Object.keys(i18nConfig.buckets)
+      }
+    };
+  }
+  const errorsByBucket = errorDetails.reduce(
+    (acc, error) => {
+      if (error.bucket) {
+        acc[error.bucket] = (acc[error.bucket] || 0) + 1;
+      }
+      return acc;
+    },
+    {}
+  );
+  const errorsByType = errorDetails.reduce(
+    (acc, error) => {
+      acc[error.type] = (acc[error.type] || 0) + 1;
+      return acc;
+    },
+    {}
+  );
+  return {
+    errorCount: errorDetails.length,
+    errorTypes: [...new Set(errorDetails.map((e) => e.type))],
+    errorsByBucket,
+    errorsByType,
+    firstError: {
+      type: errorDetails[0].type,
+      bucket: errorDetails[0].bucket,
+      locale: errorDetails[0].locale,
+      pathPattern: errorDetails[0].pathPattern,
+      message: errorDetails[0].message
+    },
+    bucketCount: buckets.length,
+    localeCount: targetLocales.length,
+    i18nConfig: {
+      sourceLocale: i18nConfig.locale.source,
+      targetLocales: i18nConfig.locale.targets,
+      bucketTypes: Object.keys(i18nConfig.buckets)
+    }
+  };
+}
 
 // src/cli/utils/cloudflare-status.ts
 async function checkCloudflareStatus() {
@@ -7483,7 +7615,11 @@ function trackEvent(distinctId, event, properties) {
         properties: {
           ...properties,
           $lib: "lingo.dev-cli",
-          $lib_version: process.env.npm_package_version || "unknown"
+          $lib_version: process.env.npm_package_version || "unknown",
+          // Essential debugging context only
+          node_version: process.version,
+          is_ci: !!process.env.CI,
+          debug_enabled: process.env.DEBUG === "true"
         },
         timestamp: (/* @__PURE__ */ new Date()).toISOString()
       };
@@ -7683,7 +7819,21 @@ var i18n_default = new Command12().command("i18n").description("Run Localization
 ).action(async function(options) {
   updateGitignore();
   const ora = Ora7();
-  const flags = parseFlags(options);
+  let flags;
+  try {
+    flags = parseFlags(options);
+  } catch (parseError) {
+    await trackEvent("unknown", "cmd.i18n.error", {
+      errorType: "validation_error",
+      errorName: parseError.name || "ValidationError",
+      errorMessage: parseError.message || "Invalid command line options",
+      errorStack: parseError.stack,
+      fatal: true,
+      errorCount: 1,
+      stage: "flag_validation"
+    });
+    throw parseError;
+  }
   if (flags.debug) {
     const { debug } = await inquirer2.prompt([
       {
@@ -7695,6 +7845,7 @@ var i18n_default = new Command12().command("i18n").description("Run Localization
   }
   let hasErrors = false;
   let authId = null;
+  const errorDetails = [];
   try {
     ora.start("Loading configuration...");
     const i18nConfig = getConfig();
@@ -7996,9 +8147,23 @@ var i18n_default = new Command12().command("i18n").description("Run Localization
                 );
               }
             } catch (_error) {
-              const error = new Error(
-                `[${sourceLocale} -> ${targetLocale}] Localization failed: ${_error.message}`
+              const error = new LocalizationError(
+                `[${sourceLocale} -> ${targetLocale}] Localization failed: ${_error.message}`,
+                {
+                  bucket: bucket.type,
+                  sourceLocale,
+                  targetLocale,
+                  pathPattern: bucketPath.pathPattern
+                }
               );
+              errorDetails.push({
+                type: "locale_error",
+                bucket: bucket.type,
+                locale: `${sourceLocale} -> ${targetLocale}`,
+                pathPattern: bucketPath.pathPattern,
+                message: _error.message,
+                stack: _error.stack
+              });
               if (flags.strict) {
                 throw error;
               } else {
@@ -8014,9 +8179,16 @@ var i18n_default = new Command12().command("i18n").description("Run Localization
           }
         }
       } catch (_error) {
-        const error = new Error(
-          `Failed to process bucket ${bucket.type}: ${_error.message}`
+        const error = new BucketProcessingError(
+          `Failed to process bucket ${bucket.type}: ${_error.message}`,
+          bucket.type
         );
+        errorDetails.push({
+          type: "bucket_error",
+          bucket: bucket.type,
+          message: _error.message,
+          stack: _error.stack
+        });
         if (flags.strict) {
           throw error;
         } else {
@@ -8029,20 +8201,54 @@ var i18n_default = new Command12().command("i18n").description("Run Localization
     if (!hasErrors) {
       ora.succeed("Localization completed.");
       await trackEvent(authId, "cmd.i18n.success", {
-        i18nConfig,
-        flags
+        i18nConfig: {
+          sourceLocale: i18nConfig.locale.source,
+          targetLocales: i18nConfig.locale.targets,
+          bucketTypes: Object.keys(i18nConfig.buckets)
+        },
+        flags,
+        bucketCount: buckets.length,
+        localeCount: targetLocales.length,
+        processedSuccessfully: true
       });
     } else {
       ora.warn("Localization completed with errors.");
       await trackEvent(authId || "unknown", "cmd.i18n.error", {
-        flags
+        flags,
+        ...aggregateErrorAnalytics(
+          errorDetails,
+          buckets,
+          targetLocales,
+          i18nConfig
+        )
       });
     }
   } catch (error) {
     ora.fail(error.message);
+    const errorType = getCLIErrorType(error);
+    let errorContext = {};
+    if (isLocalizationError(error)) {
+      errorContext = {
+        bucket: error.bucket,
+        sourceLocale: error.sourceLocale,
+        targetLocale: error.targetLocale,
+        pathPattern: error.pathPattern
+      };
+    } else if (isBucketProcessingError(error)) {
+      errorContext = {
+        bucket: error.bucket
+      };
+    }
     await trackEvent(authId || "unknown", "cmd.i18n.error", {
       flags,
-      error
+      errorType,
+      errorName: error.name || "Error",
+      errorMessage: error.message,
+      errorStack: error.stack,
+      errorContext,
+      fatal: true,
+      errorCount: errorDetails.length + 1,
+      previousErrors: createPreviousErrorContext(errorDetails)
     });
   }
 });
@@ -8063,7 +8269,7 @@ function parseFlags(options) {
 }
 async function validateAuth(settings) {
   if (!settings.auth.apiKey) {
-    throw new CLIError({
+    throw new AuthenticationError({
       message: "Not authenticated. Please run `lingo.dev login` to authenticate.",
       docUrl: "authError"
     });
@@ -8074,7 +8280,7 @@ async function validateAuth(settings) {
   });
   const user = await authenticator.whoami();
   if (!user) {
-    throw new CLIError({
+    throw new AuthenticationError({
       message: "Invalid API key. Please run `lingo.dev login` to authenticate.",
       docUrl: "authError"
     });
@@ -8083,24 +8289,24 @@ async function validateAuth(settings) {
 }
 function validateParams(i18nConfig, flags) {
   if (!i18nConfig) {
-    throw new CLIError({
+    throw new ConfigError({
       message: "i18n.json not found. Please run `lingo.dev init` to initialize the project.",
       docUrl: "i18nNotFound"
     });
   } else if (!i18nConfig.buckets || !Object.keys(i18nConfig.buckets).length) {
-    throw new CLIError({
+    throw new ConfigError({
       message: "No buckets found in i18n.json. Please add at least one bucket containing i18n content.",
       docUrl: "bucketNotFound"
     });
   } else if (flags.locale?.some((locale) => !i18nConfig.locale.targets.includes(locale))) {
-    throw new CLIError({
+    throw new ValidationError({
       message: `One or more specified locales do not exist in i18n.json locale.targets. Please add them to the list and try again.`,
       docUrl: "localeTargetNotFound"
     });
   } else if (flags.bucket?.some(
     (bucket) => !i18nConfig.buckets[bucket]
   )) {
-    throw new CLIError({
+    throw new ValidationError({
       message: `One or more specified buckets do not exist in i18n.json. Please add them to the list and try again.`,
       docUrl: "bucketNotFound"
     });
@@ -10903,7 +11109,7 @@ async function renderHero2() {
 // package.json
 var package_default = {
   name: "lingo.dev",
-  version: "0.111.4",
+  version: "0.111.6",
   description: "Lingo.dev CLI",
   private: false,
   publishConfig: {