@kaiord/cli 1.0.0 → 3.0.0

package/dist/bin/kaiord.js

@@ -79,7 +79,7 @@ var pretty_logger_exports = {};
 __export(pretty_logger_exports, {
   createPrettyLogger: () => createPrettyLogger
 });
-import chalk2 from "chalk";
+import chalk6 from "chalk";
 var createPrettyLogger;
 var init_pretty_logger = __esm({
   "src/adapters/logger/pretty-logger.ts"() {
@@ -105,31 +105,31 @@ var init_pretty_logger = __esm({
           return "";
         }
         const contextStr = JSON.stringify(context);
-        return " " + (useColors ? chalk2.gray(contextStr) : contextStr);
+        return " " + (useColors ? chalk6.gray(contextStr) : contextStr);
       };
       return {
         debug: (message, context) => {
           if (shouldLog("debug")) {
             const formatted = `\u{1F41B} ${message}${formatContext(context)}`;
-            console.log(useColors ? chalk2.gray(formatted) : formatted);
+            console.log(useColors ? chalk6.gray(formatted) : formatted);
           }
         },
         info: (message, context) => {
           if (shouldLog("info")) {
             const formatted = `\u2139 ${message}${formatContext(context)}`;
-            console.log(useColors ? chalk2.blue(formatted) : formatted);
+            console.log(useColors ? chalk6.blue(formatted) : formatted);
           }
         },
         warn: (message, context) => {
           if (shouldLog("warn")) {
             const formatted = `\u26A0 ${message}${formatContext(context)}`;
-            console.warn(useColors ? chalk2.yellow(formatted) : formatted);
+            console.warn(useColors ? chalk6.yellow(formatted) : formatted);
           }
         },
         error: (message, context) => {
           if (shouldLog("error")) {
             const formatted = `\u2716 ${message}${formatContext(context)}`;
-            console.error(useColors ? chalk2.red(formatted) : formatted);
+            console.error(useColors ? chalk6.red(formatted) : formatted);
           }
         }
       };
@@ -139,7 +139,6 @@ var init_pretty_logger = __esm({
 
 // src/bin/kaiord.ts
 init_esm_shims();
-import chalk5 from "chalk";
 import { readFileSync } from "fs";
 import { dirname as dirname2, join as join3 } from "path";
 import { fileURLToPath as fileURLToPath2 } from "url";
@@ -148,16 +147,15 @@ import { hideBin } from "yargs/helpers";
 
 // src/commands/convert.ts
 init_esm_shims();
+
+// src/commands/convert/index.ts
+init_esm_shims();
 import {
-  createDefaultProviders,
-  FitParsingError as FitParsingError2,
-  KrdValidationError as KrdValidationError2,
-  ToleranceExceededError as ToleranceExceededError2
+  FitParsingError as FitParsingError3,
+  KrdValidationError as KrdValidationError3,
+  ToleranceExceededError as ToleranceExceededError3
 } from "@kaiord/core";
-import chalk3 from "chalk";
-import ora from "ora";
-import { basename, join as join2 } from "path";
-import { z as z3 } from "zod";
+import { createAllProviders } from "@kaiord/all";
 
 // src/utils/config-loader.ts
 init_esm_shims();
@@ -197,7 +195,7 @@ var configSchema = z2.object({
   json: z2.boolean().optional(),
   logFormat: z2.enum(["pretty", "structured"]).optional()
 });
-var loadConfig = async () => {
+var loadConfigWithMetadata = async () => {
   const configPaths = [
     join(process.cwd(), ".kaiordrc.json"),
     join(homedir(), ".kaiordrc.json")
@@ -207,12 +205,12 @@ var loadConfig = async () => {
       const configContent = await readFile(configPath, "utf-8");
       const configJson = JSON.parse(configContent);
       const config = configSchema.parse(configJson);
-      return config;
-    } catch (error) {
+      return { config, loadedFrom: configPath, searchedPaths: configPaths };
+    } catch {
       continue;
     }
   }
-  return {};
+  return { config: {}, loadedFrom: null, searchedPaths: configPaths };
 };
 var mergeWithConfig = (cliOptions, config) => {
   const merged = { ...config };
@@ -226,33 +224,219 @@ var mergeWithConfig = (cliOptions, config) => {
 
 // src/utils/error-formatter.ts
 init_esm_shims();
-init_is_tty();
+
+// src/utils/error-formatter-json.ts
+init_esm_shims();
 import {
   FitParsingError,
   KrdValidationError,
   ToleranceExceededError
 } from "@kaiord/core";
+
+// src/utils/error-suggestions.ts
+init_esm_shims();
+var ERROR_PATTERNS = [
+  {
+    pattern: "file not found",
+    title: "File not found",
+    suggestions: [
+      "Check that the file path is correct.",
+      "Use 'ls' or 'dir' to verify the file exists.",
+      "Ensure the path is relative to current directory or absolute."
+    ]
+  },
+  {
+    pattern: "permission denied",
+    title: "Permission denied",
+    suggestions: [
+      "Check file/directory permissions with 'ls -la'.",
+      "Ensure you have read/write access to the path.",
+      "Try running with appropriate permissions."
+    ]
+  },
+  {
+    pattern: "failed to create directory",
+    title: "Directory creation failed",
+    suggestions: [
+      "Check that the parent directory exists.",
+      "Verify you have write permissions to the parent directory.",
+      "Ensure the path does not conflict with an existing file."
+    ]
+  },
+  {
+    pattern: "cannot create directory",
+    title: "Directory creation failed",
+    suggestions: [
+      "Check that the parent directory exists.",
+      "Verify you have write permissions to the parent directory.",
+      "Ensure the path does not conflict with an existing file."
+    ]
+  },
+  {
+    pattern: "cannot use both",
+    title: "Invalid argument combination",
+    suggestions: [
+      "Use --output (-o) for single file conversion.",
+      "Use --output-dir for batch conversion with glob patterns."
+    ]
+  },
+  {
+    pattern: "no files found matching",
+    title: "No files matched",
+    suggestions: [
+      "Verify the glob pattern matches your files.",
+      'Use quotes around patterns with wildcards: "*.fit"',
+      "Check that files exist in the specified directory."
+    ]
+  },
+  {
+    pattern: "batch mode requires",
+    title: "Invalid argument",
+    suggestions: [
+      "Add --output-dir to specify where converted files should go.",
+      "Add --output-format to specify the target format."
+    ]
+  },
+  {
+    pattern: "unable to detect format",
+    title: "Invalid argument",
+    suggestions: [
+      "Use --input-format to explicitly specify the format.",
+      "Supported formats: fit, krd, tcx, zwo"
+    ]
+  }
+];
+var findMatchingPattern = (msg) => {
+  return ERROR_PATTERNS.find((p) => msg.includes(p.pattern));
+};
+var getErrorTitle = (error) => {
+  const msg = error.message.toLowerCase();
+  const match = findMatchingPattern(msg);
+  if (match) return match.title;
+  if (error.name === "InvalidArgumentError") return "Invalid argument";
+  return "An unexpected error occurred";
+};
+var getSuggestionForError = (error) => {
+  const msg = error.message.toLowerCase();
+  const match = findMatchingPattern(msg);
+  return match?.suggestions ?? null;
+};
+
+// src/utils/error-formatter-json.ts
+var toJson = (result) => {
+  return JSON.stringify(result, null, 2);
+};
+var formatFitError = (error) => toJson({
+  success: false,
+  error: {
+    type: "FitParsingError",
+    message: error.message,
+    cause: error.cause ? String(error.cause) : void 0,
+    suggestion: "Verify the file is a valid FIT workout file."
+  }
+});
+var formatKrdError = (error) => toJson({
+  success: false,
+  error: {
+    type: "KrdValidationError",
+    message: error.message,
+    errors: error.errors,
+    suggestion: "Check the KRD file against the schema."
+  }
+});
+var formatToleranceError = (error) => toJson({
+  success: false,
+  error: {
+    type: "ToleranceExceededError",
+    message: error.message,
+    violations: error.violations,
+    suggestion: "Consider adjusting tolerance values if acceptable."
+  }
+});
+var formatGenericError = (error) => {
+  const suggestion = getSuggestionForError(error);
+  return toJson({
+    success: false,
+    error: {
+      type: error.name || "Error",
+      message: error.message,
+      suggestion: suggestion ? suggestion.join(" ") : void 0
+    }
+  });
+};
+var formatUnknownError = (error) => toJson({
+  success: false,
+  error: {
+    type: "UnknownError",
+    message: String(error)
+  }
+});
+var formatErrorAsJson = (error) => {
+  if (error instanceof FitParsingError) return formatFitError(error);
+  if (error instanceof KrdValidationError) return formatKrdError(error);
+  if (error instanceof ToleranceExceededError)
+    return formatToleranceError(error);
+  if (error instanceof Error) return formatGenericError(error);
+  return formatUnknownError(error);
+};
+
+// src/utils/error-formatter-pretty.ts
+init_esm_shims();
+init_is_tty();
+import {
+  FitParsingError as FitParsingError2,
+  KrdValidationError as KrdValidationError2,
+  ToleranceExceededError as ToleranceExceededError2
+} from "@kaiord/core";
+
+// src/utils/pretty-formatters/index.ts
+init_esm_shims();
+
+// src/utils/pretty-formatters/fit-error.ts
+init_esm_shims();
 import chalk from "chalk";
+var formatFitParsingError = (error, useColors) => {
+  const lines = [
+    useColors ? chalk.red("\u2716 Error: Failed to parse FIT file") : "\u2716 Error: Failed to parse FIT file",
+    "",
+    useColors ? chalk.gray("Details:") : "Details:",
+    `  ${error.message}`
+  ];
+  if (error.cause) {
+    lines.push("", useColors ? chalk.gray("Cause:") : "Cause:");
+    lines.push(`  ${String(error.cause)}`);
+  }
+  lines.push(
+    "",
+    useColors ? chalk.cyan("Suggestion:") : "Suggestion:",
+    "  Verify the file is a valid FIT workout file.",
+    "  Try opening it in Garmin Connect to confirm."
+  );
+  return lines.join("\n");
+};
+
+// src/utils/pretty-formatters/krd-error.ts
+init_esm_shims();
+import chalk3 from "chalk";
+
+// src/utils/format-violations.ts
+init_esm_shims();
+init_is_tty();
+import chalk2 from "chalk";
 var shouldUseColors = () => {
   return isTTY() || process.env.FORCE_COLOR === "1";
 };
-var formatError = (error, options = {}) => {
-  if (options.json) {
-    return formatErrorAsJson(error);
-  }
-  return formatErrorAsPretty(error);
-};
 var formatValidationErrors = (errors) => {
   if (errors.length === 0) {
     return "";
   }
   const useColors = shouldUseColors();
   const lines = [
-    useColors ? chalk.red("Validation errors:") : "Validation errors:"
+    useColors ? chalk2.red("Validation errors:") : "Validation errors:"
   ];
   for (const error of errors) {
-    const fieldPath = useColors ? chalk.yellow(error.field) : error.field;
-    const bullet = useColors ? chalk.red("\u2022") : "\u2022";
+    const fieldPath = useColors ? chalk2.yellow(error.field) : error.field;
+    const bullet = useColors ? chalk2.red("\u2022") : "\u2022";
     lines.push(`  ${bullet} ${fieldPath}: ${error.message}`);
   }
   return lines.join("\n");
@@ -263,173 +447,209 @@ var formatToleranceViolations = (violations) => {
   }
   const useColors = shouldUseColors();
   const lines = [
-    useColors ? chalk.red("Tolerance violations:") : "Tolerance violations:"
+    useColors ? chalk2.red("Tolerance violations:") : "Tolerance violations:"
   ];
   for (const violation of violations) {
-    const fieldPath = useColors ? chalk.yellow(violation.field) : violation.field;
-    const bullet = useColors ? chalk.red("\u2022") : "\u2022";
-    const expected = violation.expected;
-    const actual = violation.actual;
+    const fieldPath = useColors ? chalk2.yellow(violation.field) : violation.field;
+    const bullet = useColors ? chalk2.red("\u2022") : "\u2022";
+    const { expected, actual, tolerance } = violation;
     const deviation = Math.abs(violation.deviation);
-    const tolerance = violation.tolerance;
     lines.push(
       `  ${bullet} ${fieldPath}: expected ${expected}, got ${actual} (deviation: ${deviation}, tolerance: \xB1${tolerance})`
     );
   }
   return lines.join("\n");
 };
-var formatErrorAsPretty = (error) => {
-  const useColors = shouldUseColors();
-  if (error instanceof FitParsingError) {
-    const lines = [
-      useColors ? chalk.red("\u2716 Error: Failed to parse FIT file") : "\u2716 Error: Failed to parse FIT file",
-      "",
-      useColors ? chalk.gray("Details:") : "Details:",
-      `  ${error.message}`
-    ];
-    if (error.cause) {
-      lines.push("", useColors ? chalk.gray("Cause:") : "Cause:");
-      lines.push(`  ${String(error.cause)}`);
-    }
-    lines.push(
-      "",
-      useColors ? chalk.cyan("Suggestion:") : "Suggestion:",
-      "  Verify the file is a valid FIT workout file.",
-      "  Try opening it in Garmin Connect to confirm."
-    );
-    return lines.join("\n");
-  }
-  if (error instanceof KrdValidationError) {
-    const lines = [
-      useColors ? chalk.red("\u2716 Error: Invalid KRD format") : "\u2716 Error: Invalid KRD format",
-      "",
-      formatValidationErrors(error.errors)
-    ];
-    lines.push(
-      "",
-      useColors ? chalk.cyan("Suggestion:") : "Suggestion:",
-      "  Check the KRD file against the schema.",
-      "  Ensure all required fields are present and have valid values."
-    );
-    return lines.join("\n");
-  }
-  if (error instanceof ToleranceExceededError) {
-    const lines = [
-      useColors ? chalk.red("\u2716 Error: Round-trip conversion failed") : "\u2716 Error: Round-trip conversion failed",
-      "",
-      formatToleranceViolations(error.violations)
-    ];
+
+// src/utils/pretty-formatters/krd-error.ts
+var formatKrdValidationError = (error, useColors) => {
+  const lines = [
+    useColors ? chalk3.red("\u2716 Error: Invalid KRD format") : "\u2716 Error: Invalid KRD format",
+    "",
+    formatValidationErrors(error.errors),
+    "",
+    useColors ? chalk3.cyan("Suggestion:") : "Suggestion:",
+    "  Check the KRD file against the schema.",
+    "  Ensure all required fields are present and have valid values."
+  ];
+  return lines.join("\n");
+};
+
+// src/utils/pretty-formatters/tolerance-error.ts
+init_esm_shims();
+import chalk4 from "chalk";
+var formatToleranceError2 = (error, useColors) => {
+  const lines = [
+    useColors ? chalk4.red("\u2716 Error: Round-trip conversion failed") : "\u2716 Error: Round-trip conversion failed",
+    "",
+    formatToleranceViolations(error.violations),
+    "",
+    useColors ? chalk4.cyan("Suggestion:") : "Suggestion:",
+    "  The conversion may have lost precision.",
+    "  Consider adjusting tolerance values if the deviations are acceptable."
+  ];
+  return lines.join("\n");
+};
+
+// src/utils/pretty-formatters/generic-error.ts
+init_esm_shims();
+import chalk5 from "chalk";
+var formatGenericError2 = (error, useColors) => {
+  const suggestion = getSuggestionForError(error);
+  const lines = [
+    useColors ? chalk5.red(`\u2716 Error: ${getErrorTitle(error)}`) : `\u2716 Error: ${getErrorTitle(error)}`,
+    "",
+    useColors ? chalk5.gray("Details:") : "Details:",
+    `  ${error.message}`
+  ];
+  if (suggestion) {
     lines.push(
       "",
-      useColors ? chalk.cyan("Suggestion:") : "Suggestion:",
-      "  The conversion may have lost precision.",
-      "  Consider adjusting tolerance values if the deviations are acceptable."
+      useColors ? chalk5.cyan("Suggestion:") : "Suggestion:",
+      ...suggestion.map((s) => `  ${s}`)
     );
-    return lines.join("\n");
-  }
-  if (error instanceof Error) {
-    return [
-      useColors ? chalk.red("\u2716 Error: An unexpected error occurred") : "\u2716 Error: An unexpected error occurred",
-      "",
-      useColors ? chalk.gray("Details:") : "Details:",
-      `  ${error.message}`,
-      "",
-      ...error.stack ? [
-        useColors ? chalk.gray("Stack trace:") : "Stack trace:",
-        `  ${error.stack}`
-      ] : []
-    ].join("\n");
   }
+  return lines.join("\n");
+};
+var formatUnknownError2 = (error, useColors) => {
   return [
-    useColors ? chalk.red("\u2716 Error: An unexpected error occurred") : "\u2716 Error: An unexpected error occurred",
+    useColors ? chalk5.red("\u2716 Error: An unexpected error occurred") : "\u2716 Error: An unexpected error occurred",
     "",
-    useColors ? chalk.gray("Details:") : "Details:",
+    useColors ? chalk5.gray("Details:") : "Details:",
     `  ${String(error)}`
   ].join("\n");
 };
-var formatErrorAsJson = (error) => {
-  if (error instanceof FitParsingError) {
-    return JSON.stringify(
-      {
-        success: false,
-        error: {
-          type: "FitParsingError",
-          message: error.message,
-          cause: error.cause ? String(error.cause) : void 0,
-          suggestion: "Verify the file is a valid FIT workout file."
-        }
-      },
-      null,
-      2
-    );
+
+// src/utils/error-formatter-pretty.ts
+var shouldUseColors2 = () => {
+  return isTTY() || process.env.FORCE_COLOR === "1";
+};
+var formatErrorAsPretty = (error) => {
+  const useColors = shouldUseColors2();
+  if (error instanceof FitParsingError2) {
+    return formatFitParsingError(error, useColors);
   }
-  if (error instanceof KrdValidationError) {
-    return JSON.stringify(
-      {
-        success: false,
-        error: {
-          type: "KrdValidationError",
-          message: error.message,
-          errors: error.errors,
-          suggestion: "Check the KRD file against the schema."
-        }
-      },
-      null,
-      2
-    );
+  if (error instanceof KrdValidationError2) {
+    return formatKrdValidationError(error, useColors);
   }
-  if (error instanceof ToleranceExceededError) {
-    return JSON.stringify(
-      {
-        success: false,
-        error: {
-          type: "ToleranceExceededError",
-          message: error.message,
-          violations: error.violations,
-          suggestion: "Consider adjusting tolerance values if acceptable."
-        }
-      },
-      null,
-      2
-    );
+  if (error instanceof ToleranceExceededError2) {
+    return formatToleranceError2(error, useColors);
   }
   if (error instanceof Error) {
-    return JSON.stringify(
-      {
-        success: false,
-        error: {
-          type: error.name || "Error",
-          message: error.message,
-          stack: error.stack
-        }
-      },
-      null,
-      2
-    );
+    return formatGenericError2(error, useColors);
+  }
+  return formatUnknownError2(error, useColors);
+};
+
+// src/utils/error-formatter.ts
+var formatError = (error, options = {}) => {
+  if (options.json) {
+    return formatErrorAsJson(error);
+  }
+  return formatErrorAsPretty(error);
+};
+
+// src/utils/exit-codes.ts
+init_esm_shims();
+var ExitCode = {
+  /** Successful execution */
+  SUCCESS: 0,
+  /** Invalid arguments or usage error */
+  INVALID_ARGUMENT: 1,
+  /** File not found */
+  FILE_NOT_FOUND: 2,
+  /** Permission denied */
+  PERMISSION_DENIED: 3,
+  /** Parsing error (corrupted or invalid file format) */
+  PARSING_ERROR: 4,
+  /** Validation error (schema validation failed) */
+  VALIDATION_ERROR: 5,
+  /** Tolerance exceeded (round-trip validation failed) */
+  TOLERANCE_EXCEEDED: 6,
+  /** Differences found (diff command - files are different, not an error) */
+  DIFFERENCES_FOUND: 10,
+  /** Partial success (batch operations with some failures) */
+  PARTIAL_SUCCESS: 11,
+  /** Directory creation failed */
+  DIRECTORY_CREATE_ERROR: 12,
+  /** Unknown or unhandled error */
+  UNKNOWN_ERROR: 99
+};
+
+// src/utils/logger-factory.ts
+init_esm_shims();
+var isCI = () => {
+  return process.env.CI === "true" || process.env.NODE_ENV === "production" || !process.stdout.isTTY;
+};
+var createLogger = async (options = {}) => {
+  const loggerType = options.type || (isCI() ? "structured" : "pretty");
+  if (loggerType === "structured") {
+    const { createStructuredLogger: createStructuredLogger2 } = await Promise.resolve().then(() => (init_structured_logger(), structured_logger_exports));
+    return createStructuredLogger2(options);
+  } else {
+    const { createPrettyLogger: createPrettyLogger2 } = await Promise.resolve().then(() => (init_pretty_logger(), pretty_logger_exports));
+    return createPrettyLogger2(options);
   }
-  return JSON.stringify(
-    {
-      success: false,
-      error: {
-        type: "UnknownError",
-        message: String(error)
-      }
-    },
-    null,
-    2
-  );
 };
 
+// src/commands/convert/batch.ts
+init_esm_shims();
+import chalk7 from "chalk";
+import ora2 from "ora";
+import { basename, join as join2 } from "path";
+
 // src/utils/file-handler.ts
 init_esm_shims();
-import {
-  readFile as fsReadFile,
-  writeFile as fsWriteFile,
-  mkdir
-} from "fs/promises";
+import { readFile as fsReadFile, writeFile as fsWriteFile } from "fs/promises";
 import { glob } from "glob";
+
+// src/utils/directory-handler.ts
+init_esm_shims();
+import { mkdir } from "fs/promises";
 import { dirname } from "path";
+
+// src/utils/fs-errors.ts
+init_esm_shims();
+var isNodeSystemError = (error) => {
+  return error instanceof Error && "code" in error;
+};
+
+// src/utils/directory-handler.ts
+var createOutputDirectory = async (path2) => {
+  const dir = dirname(path2);
+  try {
+    await mkdir(dir, { recursive: true });
+  } catch (error) {
+    if (isNodeSystemError(error)) {
+      if (error.code === "EACCES") {
+        throw new Error(`Permission denied creating directory: ${dir}`);
+      }
+      if (error.code === "ENOTDIR" || error.code === "EEXIST") {
+        throw new Error(
+          `Cannot create directory (path exists as file): ${dir}`
+        );
+      }
+    }
+    throw new Error(`Failed to create directory: ${dir}`);
+  }
+};
+
+// src/utils/path-security.ts
+init_esm_shims();
+var validatePathSecurity = (inputPath) => {
+  if (inputPath.includes("\0")) {
+    throw new Error(`Invalid path: null byte detected in ${inputPath}`);
+  }
+  if (inputPath.includes("|") || inputPath.includes(";")) {
+    throw new Error(
+      `Invalid path: shell metacharacters detected in ${inputPath}`
+    );
+  }
+};
+
+// src/utils/file-handler.ts
 var readFile2 = async (path2, format) => {
+  validatePathSecurity(path2);
   try {
     if (format === "fit") {
       const buffer = await fsReadFile(path2);
@@ -438,7 +658,7 @@ var readFile2 = async (path2, format) => {
       return await fsReadFile(path2, "utf-8");
     }
   } catch (error) {
-    if (error instanceof Error && "code" in error) {
+    if (isNodeSystemError(error)) {
       if (error.code === "ENOENT") {
         throw new Error(`File not found: ${path2}`);
       }
@@ -450,28 +670,28 @@ var readFile2 = async (path2, format) => {
   }
 };
 var writeFile = async (path2, data, format) => {
+  validatePathSecurity(path2);
+  if (format === "fit" && !(data instanceof Uint8Array)) {
+    throw new Error("FIT files require Uint8Array data");
+  }
+  if (format !== "fit" && typeof data !== "string") {
+    throw new Error("Text files require string data");
+  }
+  await createOutputDirectory(path2);
   try {
-    const dir = dirname(path2);
-    await mkdir(dir, { recursive: true });
     if (format === "fit") {
-      if (!(data instanceof Uint8Array)) {
-        throw new Error("FIT files require Uint8Array data");
-      }
       await fsWriteFile(path2, data);
     } else {
-      if (typeof data !== "string") {
-        throw new Error("Text files require string data");
-      }
       await fsWriteFile(path2, data, "utf-8");
     }
   } catch (error) {
-    if (error instanceof Error && "code" in error) {
+    if (isNodeSystemError(error)) {
       if (error.code === "EACCES") {
-        throw new Error(`Permission denied: ${path2}`);
+        throw new Error(`Permission denied writing file: ${path2}`);
+      }
+      if (error.code === "EISDIR") {
+        throw new Error(`Cannot write file (path is a directory): ${path2}`);
       }
-    }
-    if (error instanceof Error && error.message.includes("require")) {
-      throw error;
     }
     throw new Error(`Failed to write file: ${path2}`);
   }
@@ -484,23 +704,258 @@ var findFiles = async (pattern) => {
   return files.sort();
 };
 
-// src/utils/logger-factory.ts
+// src/commands/convert/single-file.ts
 init_esm_shims();
-var isCI = () => {
-  return process.env.CI === "true" || process.env.NODE_ENV === "production" || !process.stdout.isTTY;
+import ora from "ora";
+
+// src/utils/krd-file-loader.ts
+init_esm_shims();
+var loadFileAsKrd = async (filePath, format, providers) => {
+  const detectedFormat = format || detectFormat(filePath);
+  if (!detectedFormat) {
+    throw new Error(
+      `Unable to detect format for file: ${filePath}. Supported formats: .fit, .krd, .tcx, .zwo`
+    );
+  }
+  const fileData = await readFile2(filePath, detectedFormat);
+  return convertToKrd(fileData, detectedFormat, providers);
 };
-var createLogger = async (options = {}) => {
-  const loggerType = options.type || (isCI() ? "structured" : "pretty");
-  if (loggerType === "structured") {
-    const { createStructuredLogger: createStructuredLogger2 } = await Promise.resolve().then(() => (init_structured_logger(), structured_logger_exports));
-    return createStructuredLogger2(options);
+var convertToKrd = async (data, format, providers) => {
+  if (format === "fit") {
+    if (!(data instanceof Uint8Array)) {
+      throw new Error("FIT input must be Uint8Array");
+    }
+    return providers.convertFitToKrd({ fitBuffer: data });
+  }
+  if (format === "tcx") {
+    if (typeof data !== "string") {
+      throw new Error("TCX input must be string");
+    }
+    return providers.convertTcxToKrd({ tcxString: data });
+  }
+  if (format === "zwo") {
+    if (typeof data !== "string") {
+      throw new Error("ZWO input must be string");
+    }
+    return providers.convertZwiftToKrd({ zwiftString: data });
+  }
+  if (format === "krd") {
+    if (typeof data !== "string") {
+      throw new Error("KRD input must be string");
+    }
+    return JSON.parse(data);
+  }
+  throw new Error(`Unsupported format: ${format}`);
+};
+var convertFromKrd = async (krd, format, providers) => {
+  if (format === "fit") {
+    return providers.convertKrdToFit({ krd });
+  }
+  if (format === "tcx") {
+    return providers.convertKrdToTcx({ krd });
+  }
+  if (format === "zwo") {
+    return providers.convertKrdToZwift({ krd });
+  }
+  if (format === "krd") {
+    return JSON.stringify(krd, null, 2);
+  }
+  throw new Error(`Unsupported output format: ${format}`);
+};
+
+// src/commands/convert/single-file.ts
+var convertSingleFile = async (inputFile, outputFile, inputFormat, outputFormat, providers) => {
+  const krd = await loadFileAsKrd(inputFile, inputFormat, providers);
+  const outputData = await convertFromKrd(krd, outputFormat, providers);
+  await writeFile(outputFile, outputData, outputFormat);
+};
+var executeSingleFileConversion = async (options, providers, logger) => {
+  const inputFormat = options.inputFormat || detectFormat(options.input);
+  if (!inputFormat) {
+    const error = new Error(
+      `Unable to detect input format from file: ${options.input}. Supported formats: .fit, .krd, .tcx, .zwo`
+    );
+    error.name = "InvalidArgumentError";
+    throw error;
+  }
+  if (!options.output) {
+    const error = new Error("Output file is required");
+    error.name = "InvalidArgumentError";
+    throw error;
+  }
+  const outputFormat = options.outputFormat || detectFormat(options.output);
+  if (!outputFormat) {
+    const error = new Error(
+      `Unable to detect output format from file: ${options.output}. Supported formats: .fit, .krd, .tcx, .zwo`
+    );
+    error.name = "InvalidArgumentError";
+    throw error;
+  }
+  logger.debug("Convert command initialized", {
+    input: options.input,
+    output: options.output,
+    inputFormat,
+    outputFormat
+  });
+  const isTTY2 = process.stdout.isTTY && !options.quiet && !options.json;
+  const spinner = isTTY2 ? ora("Converting...").start() : null;
+  try {
+    await convertSingleFile(
+      options.input,
+      options.output,
+      inputFormat,
+      outputFormat,
+      providers
+    );
+    if (options.json) {
+      console.log(
+        JSON.stringify(
+          {
+            success: true,
+            inputFile: options.input,
+            outputFile: options.output,
+            inputFormat,
+            outputFormat
+          },
+          null,
+          2
+        )
+      );
+    } else if (spinner) {
+      spinner.succeed(
+        `Conversion complete: ${options.input} -> ${options.output}`
+      );
+    } else {
+      logger.info("Conversion complete", {
+        input: options.input,
+        output: options.output
+      });
+    }
+  } catch (error) {
+    if (spinner) {
+      spinner.fail("Conversion failed");
+    }
+    throw error;
+  }
+};
+
+// src/commands/convert/batch.ts
+var executeBatchConversion = async (options, providers, logger) => {
+  if (!options.outputDir) {
+    const error = new Error("Batch mode requires --output-dir flag");
+    error.name = "InvalidArgumentError";
+    throw error;
+  }
+  const outputFormat = options.outputFormat;
+  if (!outputFormat) {
+    const error = new Error(
+      "Batch mode requires --output-format flag to specify target format"
+    );
+    error.name = "InvalidArgumentError";
+    throw error;
+  }
+  const startTime = Date.now();
+  const files = await findFiles(options.input);
+  if (files.length === 0) {
+    const error = new Error(
+      `No files found matching pattern: ${options.input}`
+    );
+    error.name = "InvalidArgumentError";
+    throw error;
+  }
+  logger.debug("Batch conversion started", {
+    pattern: options.input,
+    fileCount: files.length,
+    outputDir: options.outputDir,
+    outputFormat
+  });
+  const isTTY2 = process.stdout.isTTY && !options.quiet && !options.json;
+  const spinner = isTTY2 ? ora2("Processing batch conversion...").start() : null;
+  const results = [];
+  for (const [index, file] of files.entries()) {
+    const fileNum = index + 1;
+    const fileName = basename(file);
+    if (spinner) {
+      spinner.text = `Converting ${fileNum}/${files.length}: ${fileName}`;
+    } else {
+      logger.info(`Converting ${fileNum}/${files.length}: ${fileName}`);
+    }
+    try {
+      const inputFormat = options.inputFormat || detectFormat(file);
+      if (!inputFormat) {
+        throw new Error(`Unable to detect format for file: ${file}`);
+      }
+      const outputFileName = fileName.replace(
+        /\.(fit|krd|tcx|zwo)$/i,
+        `.${outputFormat}`
+      );
+      const outputFile = join2(options.outputDir, outputFileName);
+      await convertSingleFile(
+        file,
+        outputFile,
+        inputFormat,
+        outputFormat,
+        providers
+      );
+      results.push({ success: true, inputFile: file, outputFile });
+    } catch (error) {
+      results.push({
+        success: false,
+        inputFile: file,
+        error: error instanceof Error ? error.message : String(error)
+      });
+      logger.error(`Failed to convert ${file}`, { error });
+    }
+  }
+  const totalTime = Date.now() - startTime;
+  const successful = results.filter((r) => r.success);
+  const failed = results.filter((r) => !r.success);
+  if (spinner) {
+    spinner.stop();
+  }
+  if (!options.json) {
+    console.log("\nBatch conversion complete:");
+    console.log(
+      chalk7.green(`  Successful: ${successful.length}/${files.length}`)
+    );
+    if (failed.length > 0) {
+      console.log(chalk7.red(`  Failed: ${failed.length}/${files.length}`));
+    }
+    console.log(`  Total time: ${(totalTime / 1e3).toFixed(2)}s`);
+    if (failed.length > 0) {
+      console.log(chalk7.red("\nFailed conversions:"));
+      for (const result of failed) {
+        console.log(chalk7.red(`  ${result.inputFile}: ${result.error}`));
+      }
+    }
   } else {
-    const { createPrettyLogger: createPrettyLogger2 } = await Promise.resolve().then(() => (init_pretty_logger(), pretty_logger_exports));
-    return createPrettyLogger2(options);
+    console.log(
+      JSON.stringify(
+        {
+          success: failed.length === 0,
+          total: files.length,
+          successful: successful.length,
+          failed: failed.length,
+          totalTime,
+          results
+        },
+        null,
+        2
+      )
+    );
+  }
+  if (failed.length === 0) {
+    return ExitCode.SUCCESS;
+  }
+  if (successful.length === 0) {
+    return ExitCode.INVALID_ARGUMENT;
   }
+  return ExitCode.PARTIAL_SUCCESS;
 };
 
-// src/commands/convert.ts
+// src/commands/convert/types.ts
+init_esm_shims();
+import { z as z3 } from "zod";
 var convertOptionsSchema = z3.object({
   input: z3.string(),
   output: z3.string().optional(),
@@ -512,51 +967,14 @@ var convertOptionsSchema = z3.object({
   json: z3.boolean().optional(),
   logFormat: z3.enum(["pretty", "structured"]).optional()
 });
+
+// src/commands/convert/index.ts
 var isBatchMode = (input) => {
   return input.includes("*") || input.includes("?");
 };
-var convertSingleFile = async (inputFile, outputFile, inputFormat, outputFormat, providers) => {
-  const inputData = await readFile2(inputFile, inputFormat);
-  let krd;
-  if (inputFormat === "fit") {
-    if (!(inputData instanceof Uint8Array)) {
-      throw new Error("FIT input must be Uint8Array");
-    }
-    krd = await providers.convertFitToKrd({ fitBuffer: inputData });
-  } else if (inputFormat === "tcx") {
-    if (typeof inputData !== "string") {
-      throw new Error("TCX input must be string");
-    }
-    krd = await providers.convertTcxToKrd({ tcxString: inputData });
-  } else if (inputFormat === "zwo") {
-    if (typeof inputData !== "string") {
-      throw new Error("ZWO input must be string");
-    }
-    krd = await providers.convertZwiftToKrd({ zwiftString: inputData });
-  } else if (inputFormat === "krd") {
-    if (typeof inputData !== "string") {
-      throw new Error("KRD input must be string");
-    }
-    krd = JSON.parse(inputData);
-  } else {
-    throw new Error(`Unsupported input format: ${inputFormat}`);
-  }
-  let outputData;
-  if (outputFormat === "fit") {
-    outputData = await providers.convertKrdToFit({ krd });
-  } else if (outputFormat === "tcx") {
-    outputData = await providers.convertKrdToTcx({ krd });
-  } else if (outputFormat === "zwo") {
-    outputData = await providers.convertKrdToZwift({ krd });
-  } else if (outputFormat === "krd") {
-    outputData = JSON.stringify(krd, null, 2);
-  } else {
-    throw new Error(`Unsupported output format: ${outputFormat}`);
-  }
-  await writeFile(outputFile, outputData, outputFormat);
-};
 var convertCommand = async (options) => {
-  const config = await loadConfig();
+  const configResult = await loadConfigWithMetadata();
+  const { config } = configResult;
   const mergedOptions = mergeWithConfig(options, config);
   const optionsWithDefaults = {
     ...mergedOptions,
@@ -569,196 +987,32 @@ var convertCommand = async (options) => {
     logFormat: mergedOptions.logFormat || config.logFormat
   };
   const validatedOptions = convertOptionsSchema.parse(optionsWithDefaults);
+  if (validatedOptions.output && validatedOptions.outputDir) {
+    const error = new Error(
+      "Cannot use both --output and --output-dir. Use --output for single file, --output-dir for batch conversion."
+    );
+    error.name = "InvalidArgumentError";
+    throw error;
+  }
   const logger = await createLogger({
     type: validatedOptions.logFormat,
     level: validatedOptions.verbose ? "debug" : validatedOptions.quiet ? "error" : "info",
     quiet: validatedOptions.quiet
   });
+  if (configResult.loadedFrom) {
+    logger.debug("Configuration loaded", { path: configResult.loadedFrom });
+  } else {
+    logger.debug("No configuration file found", {
+      searchedPaths: configResult.searchedPaths
+    });
+  }
   try {
-    const batchMode = isBatchMode(validatedOptions.input);
-    if (batchMode) {
-      if (!validatedOptions.outputDir) {
-        const error = new Error("Batch mode requires --output-dir flag");
-        error.name = "InvalidArgumentError";
-        throw error;
-      }
-      const outputFormat = validatedOptions.outputFormat;
-      if (!outputFormat) {
-        const error = new Error(
-          "Batch mode requires --output-format flag to specify target format"
-        );
-        error.name = "InvalidArgumentError";
-        throw error;
-      }
-      const providers = createDefaultProviders(logger);
-      const startTime = Date.now();
-      const files = await findFiles(validatedOptions.input);
-      if (files.length === 0) {
-        const error = new Error(
-          `No files found matching pattern: ${validatedOptions.input}`
-        );
-        error.name = "InvalidArgumentError";
-        throw error;
-      }
-      logger.debug("Batch conversion started", {
-        pattern: validatedOptions.input,
-        fileCount: files.length,
-        outputDir: validatedOptions.outputDir,
-        outputFormat
-      });
-      const isTTY2 = process.stdout.isTTY && !validatedOptions.quiet && !validatedOptions.json;
-      const spinner = isTTY2 ? ora("Processing batch conversion...").start() : null;
-      const results = [];
-      for (const [index, file] of files.entries()) {
-        const fileNum = index + 1;
-        const fileName = basename(file);
-        if (spinner) {
-          spinner.text = `Converting ${fileNum}/${files.length}: ${fileName}`;
-        } else {
-          logger.info(`Converting ${fileNum}/${files.length}: ${fileName}`);
-        }
-        try {
-          const inputFormat = validatedOptions.inputFormat || detectFormat(file);
-          if (!inputFormat) {
-            throw new Error(`Unable to detect format for file: ${file}`);
-          }
-          const outputFileName = fileName.replace(
-            /\.(fit|krd|tcx|zwo)$/i,
-            `.${outputFormat}`
-          );
-          const outputFile = join2(validatedOptions.outputDir, outputFileName);
-          await convertSingleFile(
-            file,
-            outputFile,
-            inputFormat,
-            outputFormat,
-            providers
-          );
-          results.push({
-            success: true,
-            inputFile: file,
-            outputFile
-          });
-        } catch (error) {
-          results.push({
-            success: false,
-            inputFile: file,
-            error: error instanceof Error ? error.message : String(error)
-          });
-          logger.error(`Failed to convert ${file}`, { error });
-        }
-      }
-      const totalTime = Date.now() - startTime;
-      const successful = results.filter((r) => r.success);
-      const failed = results.filter((r) => !r.success);
-      if (spinner) {
-        spinner.stop();
-      }
-      if (!validatedOptions.json) {
-        console.log("\nBatch conversion complete:");
-        console.log(
-          chalk3.green(`  \u2713 Successful: ${successful.length}/${files.length}`)
-        );
-        if (failed.length > 0) {
-          console.log(
-            chalk3.red(`  \u2717 Failed: ${failed.length}/${files.length}`)
-          );
-        }
-        console.log(`  Total time: ${(totalTime / 1e3).toFixed(2)}s`);
-        if (failed.length > 0) {
-          console.log(chalk3.red("\nFailed conversions:"));
-          for (const result of failed) {
-            console.log(chalk3.red(`  ${result.inputFile}: ${result.error}`));
-          }
-        }
-      } else {
-        console.log(
-          JSON.stringify(
-            {
-              success: failed.length === 0,
-              total: files.length,
-              successful: successful.length,
-              failed: failed.length,
-              totalTime,
-              results
-            },
-            null,
-            2
-          )
-        );
-      }
-      if (failed.length > 0) {
-        process.exit(1);
-      }
+    const providers = createAllProviders(logger);
+    if (isBatchMode(validatedOptions.input)) {
+      return await executeBatchConversion(validatedOptions, providers, logger);
     } else {
-      const inputFormat = validatedOptions.inputFormat || detectFormat(validatedOptions.input);
-      if (!inputFormat) {
-        const error = new Error(
-          `Unable to detect input format from file: ${validatedOptions.input}. Supported formats: .fit, .krd, .tcx, .zwo`
-        );
-        error.name = "InvalidArgumentError";
-        throw error;
-      }
-      if (!validatedOptions.output) {
-        const error = new Error("Output file is required");
-        error.name = "InvalidArgumentError";
-        throw error;
-      }
-      const outputFormat = validatedOptions.outputFormat || detectFormat(validatedOptions.output);
-      if (!outputFormat) {
-        const error = new Error(
-          `Unable to detect output format from file: ${validatedOptions.output}. Supported formats: .fit, .krd, .tcx, .zwo`
-        );
-        error.name = "InvalidArgumentError";
-        throw error;
-      }
-      const providers = createDefaultProviders(logger);
-      logger.debug("Convert command initialized", {
-        input: validatedOptions.input,
-        output: validatedOptions.output,
-        inputFormat,
-        outputFormat
-      });
-      const isTTY2 = process.stdout.isTTY && !validatedOptions.quiet && !validatedOptions.json;
-      const spinner = isTTY2 ? ora("Converting...").start() : null;
-      try {
-        await convertSingleFile(
-          validatedOptions.input,
-          validatedOptions.output,
-          inputFormat,
-          outputFormat,
-          providers
-        );
-        if (validatedOptions.json) {
-          console.log(
-            JSON.stringify(
-              {
-                success: true,
-                inputFile: validatedOptions.input,
-                outputFile: validatedOptions.output,
-                inputFormat,
-                outputFormat
-              },
-              null,
-              2
-            )
-          );
-        } else if (spinner) {
-          spinner.succeed(
-            `Conversion complete: ${validatedOptions.input} \u2192 ${validatedOptions.output}`
-          );
-        } else {
-          logger.info("Conversion complete", {
-            input: validatedOptions.input,
-            output: validatedOptions.output
-          });
-        }
-      } catch (error) {
-        if (spinner) {
-          spinner.fail("Conversion failed");
-        }
-        throw error;
-      }
+      await executeSingleFileConversion(validatedOptions, providers, logger);
+      return ExitCode.SUCCESS;
     }
   } catch (error) {
     logger.error("Conversion failed", { error });
@@ -770,108 +1024,38 @@ var convertCommand = async (options) => {
     } else {
       console.error(formattedError);
     }
-    let exitCode = 99;
+    let exitCode = ExitCode.UNKNOWN_ERROR;
     if (error instanceof Error) {
       if (error.message.includes("File not found")) {
-        exitCode = 2;
+        exitCode = ExitCode.FILE_NOT_FOUND;
       } else if (error.message.includes("Permission denied")) {
-        exitCode = 3;
-      } else if (error instanceof FitParsingError2) {
-        exitCode = 4;
-      } else if (error instanceof KrdValidationError2) {
-        exitCode = 5;
-      } else if (error instanceof ToleranceExceededError2) {
-        exitCode = 6;
+        exitCode = ExitCode.PERMISSION_DENIED;
+      } else if (error instanceof FitParsingError3) {
+        exitCode = ExitCode.PARSING_ERROR;
+      } else if (error instanceof KrdValidationError3) {
+        exitCode = ExitCode.VALIDATION_ERROR;
+      } else if (error instanceof ToleranceExceededError3) {
+        exitCode = ExitCode.TOLERANCE_EXCEEDED;
       } else if (error.name === "InvalidArgumentError") {
-        exitCode = 1;
+        exitCode = ExitCode.INVALID_ARGUMENT;
       }
     }
     return exitCode;
   }
-  return 0;
 };
 
 // src/commands/diff.ts
 init_esm_shims();
-import { createDefaultProviders as createDefaultProviders2 } from "@kaiord/core";
-import chalk4 from "chalk";
-import { z as z4 } from "zod";
-var diffOptionsSchema = z4.object({
-  file1: z4.string(),
-  file2: z4.string(),
-  format1: fileFormatSchema.optional(),
-  format2: fileFormatSchema.optional(),
-  verbose: z4.boolean().optional(),
-  quiet: z4.boolean().optional(),
-  json: z4.boolean().optional(),
-  logFormat: z4.enum(["pretty", "structured"]).optional()
-});
-var loadFileAsKrd = async (filePath, format, providers) => {
-  const detectedFormat = format || detectFormat(filePath);
-  if (!detectedFormat) {
-    throw new Error(
-      `Unable to detect format for file: ${filePath}. Supported formats: .fit, .krd, .tcx, .zwo`
-    );
-  }
-  const fileData = await readFile2(filePath, detectedFormat);
-  let krd;
-  if (detectedFormat === "fit") {
-    if (!(fileData instanceof Uint8Array)) {
-      throw new Error("FIT input must be Uint8Array");
-    }
-    krd = await providers.convertFitToKrd({ fitBuffer: fileData });
-  } else if (detectedFormat === "tcx") {
-    if (typeof fileData !== "string") {
-      throw new Error("TCX input must be string");
-    }
-    krd = await providers.convertTcxToKrd({ tcxString: fileData });
-  } else if (detectedFormat === "zwo") {
-    if (typeof fileData !== "string") {
-      throw new Error("ZWO input must be string");
-    }
-    krd = await providers.convertZwiftToKrd({ zwiftString: fileData });
-  } else if (detectedFormat === "krd") {
-    if (typeof fileData !== "string") {
-      throw new Error("KRD input must be string");
-    }
-    krd = JSON.parse(fileData);
-  } else {
-    throw new Error(`Unsupported format: ${detectedFormat}`);
-  }
-  return krd;
-};
-var isDifferent = (value1, value2) => {
-  if (value1 === value2) return false;
-  if (value1 === null || value1 === void 0) return true;
-  if (value2 === null || value2 === void 0) return true;
-  if (typeof value1 === "object" && typeof value2 === "object") {
-    return JSON.stringify(value1) !== JSON.stringify(value2);
-  }
-  return value1 !== value2;
-};
-var compareMetadata = (krd1, krd2) => {
-  const differences = [];
-  const metadataFields = [
-    "created",
-    "manufacturer",
-    "product",
-    "serialNumber",
-    "sport",
-    "subSport"
-  ];
-  for (const field of metadataFields) {
-    const value1 = krd1.metadata[field];
-    const value2 = krd2.metadata[field];
-    if (isDifferent(value1, value2)) {
-      differences.push({
-        field,
-        file1Value: value1,
-        file2Value: value2
-      });
-    }
-  }
-  return differences;
-};
+
+// src/commands/diff/index.ts
+init_esm_shims();
+import { createAllProviders as createAllProviders2 } from "@kaiord/all";
+
+// src/commands/diff/comparators.ts
+init_esm_shims();
+
+// src/commands/diff/compare-steps.ts
+init_esm_shims();
 var compareSteps = (krd1, krd2) => {
   const workout1 = krd1.extensions?.workout;
   const workout2 = krd2.extensions?.workout;
@@ -901,35 +1085,62 @@ var compareSteps = (krd1, krd2) => {
       continue;
     }
     if (!step1 || !step2) continue;
-    const stepFields = [
-      "stepIndex",
-      "name",
-      "durationType",
-      "duration",
-      "targetType",
-      "target",
-      "intensity",
-      "notes",
-      "equipment"
-    ];
-    for (const field of stepFields) {
-      const value1 = step1[field];
-      const value2 = step2[field];
-      if (isDifferent(value1, value2)) {
-        differences.push({
-          stepIndex: i,
-          field,
-          file1Value: value1,
-          file2Value: value2
-        });
-      }
+    compareStepFields(i, step1, step2, differences);
+  }
+  return { file1Count: steps1.length, file2Count: steps2.length, differences };
+};
+var STEP_FIELDS = [
+  "stepIndex",
+  "name",
+  "durationType",
+  "duration",
+  "targetType",
+  "target",
+  "intensity",
+  "notes",
+  "equipment"
+];
+function compareStepFields(stepIndex, step1, step2, differences) {
+  for (const field of STEP_FIELDS) {
+    if (isDifferent(step1[field], step2[field])) {
+      differences.push({
+        stepIndex,
+        field,
+        file1Value: step1[field],
+        file2Value: step2[field]
+      });
     }
   }
-  return {
-    file1Count: steps1.length,
-    file2Count: steps2.length,
-    differences
-  };
+}
+
+// src/commands/diff/comparators.ts
+var isDifferent = (value1, value2) => {
+  if (value1 === value2) return false;
+  if (value1 === null || value1 === void 0) return true;
+  if (value2 === null || value2 === void 0) return true;
+  if (typeof value1 === "object" && typeof value2 === "object") {
+    return JSON.stringify(value1) !== JSON.stringify(value2);
+  }
+  return value1 !== value2;
+};
+var compareMetadata = (krd1, krd2) => {
+  const differences = [];
+  const metadataFields = [
+    "created",
+    "manufacturer",
+    "product",
+    "serialNumber",
+    "sport",
+    "subSport"
+  ];
+  for (const field of metadataFields) {
+    const value1 = krd1.metadata[field];
+    const value2 = krd2.metadata[field];
+    if (isDifferent(value1, value2)) {
+      differences.push({ field, file1Value: value1, file2Value: value2 });
+    }
+  }
+  return differences;
 };
 var compareExtensions = (krd1, krd2) => {
   const ext1 = krd1.extensions || {};
@@ -939,72 +1150,82 @@ var compareExtensions = (krd1, krd2) => {
   const allKeys = /* @__PURE__ */ new Set([...keys1, ...keys2]);
   const differences = [];
   for (const key of allKeys) {
-    const value1 = ext1[key];
-    const value2 = ext2[key];
-    if (isDifferent(value1, value2)) {
-      differences.push({
-        key,
-        file1Value: value1,
-        file2Value: value2
-      });
+    if (isDifferent(ext1[key], ext2[key])) {
+      differences.push({ key, file1Value: ext1[key], file2Value: ext2[key] });
     }
   }
-  return {
-    file1Keys: keys1,
-    file2Keys: keys2,
-    differences
-  };
+  return { file1Keys: keys1, file2Keys: keys2, differences };
 };
+
+// src/commands/diff/formatter.ts
+init_esm_shims();
+import chalk8 from "chalk";
 var formatDiffPretty = (result, file1, file2) => {
   if (result.identical) {
-    return chalk4.green("\u2713 Files are identical");
+    return chalk8.green("Files are identical");
   }
   const lines = [];
-  lines.push(chalk4.yellow(`
+  lines.push(chalk8.yellow(`
 Comparing: ${file1} vs ${file2}
 `));
   if (result.metadataDiff && result.metadataDiff.length > 0) {
-    lines.push(chalk4.bold("Metadata Differences:"));
+    lines.push(chalk8.bold("Metadata Differences:"));
     for (const diff of result.metadataDiff) {
       lines.push(
-        `  ${chalk4.cyan(diff.field)}:`,
-        `    ${chalk4.red("-")} ${JSON.stringify(diff.file1Value)}`,
-        `    ${chalk4.green("+")} ${JSON.stringify(diff.file2Value)}`
+        `  ${chalk8.cyan(diff.field)}:`,
+        `    ${chalk8.red("-")} ${JSON.stringify(diff.file1Value)}`,
+        `    ${chalk8.green("+")} ${JSON.stringify(diff.file2Value)}`
       );
     }
     lines.push("");
   }
   if (result.stepsDiff && result.stepsDiff.differences.length > 0) {
-    lines.push(chalk4.bold("Workout Steps Differences:"));
+    lines.push(chalk8.bold("Workout Steps Differences:"));
     lines.push(
       `  Step count: ${result.stepsDiff.file1Count} vs ${result.stepsDiff.file2Count}`
     );
     for (const diff of result.stepsDiff.differences) {
       lines.push(
-        `  Step ${diff.stepIndex} - ${chalk4.cyan(diff.field)}:`,
-        `    ${chalk4.red("-")} ${JSON.stringify(diff.file1Value)}`,
-        `    ${chalk4.green("+")} ${JSON.stringify(diff.file2Value)}`
+        `  Step ${diff.stepIndex} - ${chalk8.cyan(diff.field)}:`,
+        `    ${chalk8.red("-")} ${JSON.stringify(diff.file1Value)}`,
+        `    ${chalk8.green("+")} ${JSON.stringify(diff.file2Value)}`
       );
     }
     lines.push("");
   }
   if (result.extensionsDiff && result.extensionsDiff.differences.length > 0) {
-    lines.push(chalk4.bold("Extensions Differences:"));
+    lines.push(chalk8.bold("Extensions Differences:"));
     lines.push(
       `  Keys in file1: ${result.extensionsDiff.file1Keys.join(", ")}`,
       `  Keys in file2: ${result.extensionsDiff.file2Keys.join(", ")}`
     );
     for (const diff of result.extensionsDiff.differences) {
       lines.push(
-        `  ${chalk4.cyan(diff.key)}:`,
-        `    ${chalk4.red("-")} ${JSON.stringify(diff.file1Value)}`,
-        `    ${chalk4.green("+")} ${JSON.stringify(diff.file2Value)}`
+        `  ${chalk8.cyan(diff.key)}:`,
+        `    ${chalk8.red("-")} ${JSON.stringify(diff.file1Value)}`,
+        `    ${chalk8.green("+")} ${JSON.stringify(diff.file2Value)}`
       );
     }
     lines.push("");
   }
   return lines.join("\n");
 };
+
+// src/commands/diff/types.ts
+init_esm_shims();
+import { z as z4 } from "zod";
+var diffOptionsSchema = z4.object({
+  file1: z4.string(),
+  file2: z4.string(),
+  format1: fileFormatSchema.optional(),
+  format2: fileFormatSchema.optional(),
+  verbose: z4.boolean().optional(),
+  quiet: z4.boolean().optional(),
+  json: z4.boolean().optional(),
+  logFormat: z4.enum(["pretty", "structured"]).optional()
+});
+
+// src/commands/diff/index.ts
 var diffCommand = async (options) => {
   const validatedOptions = diffOptionsSchema.parse(options);
   const logger = await createLogger({
@@ -1012,8 +1233,16 @@ var diffCommand = async (options) => {
     level: validatedOptions.verbose ? "debug" : validatedOptions.quiet ? "error" : "info",
     quiet: validatedOptions.quiet
   });
+  const configResult = await loadConfigWithMetadata();
+  if (configResult.loadedFrom) {
+    logger.debug("Configuration loaded", { path: configResult.loadedFrom });
+  } else {
+    logger.debug("No configuration file found", {
+      searchedPaths: configResult.searchedPaths
+    });
+  }
   try {
-    const providers = createDefaultProviders2(logger);
+    const providers = createAllProviders2(logger);
     logger.debug("Loading files for comparison", {
       file1: validatedOptions.file1,
       file2: validatedOptions.file2
@@ -1053,14 +1282,11 @@ var diffCommand = async (options) => {
         )
       );
     } else {
-      const output = formatDiffPretty(
-        result,
-        validatedOptions.file1,
-        validatedOptions.file2
+      console.log(
+        formatDiffPretty(result, validatedOptions.file1, validatedOptions.file2)
       );
-      console.log(output);
     }
-    return identical ? 0 : 1;
+    return identical ? ExitCode.SUCCESS : ExitCode.DIFFERENCES_FOUND;
   } catch (error) {
     logger.error("Diff command failed", { error });
     const formattedError = formatError(error, {
@@ -1071,20 +1297,20 @@ var diffCommand = async (options) => {
     } else {
       console.error(formattedError);
     }
-    return 99;
+    return ExitCode.UNKNOWN_ERROR;
   }
 };
 
 // src/commands/validate.ts
 init_esm_shims();
 import {
-  createDefaultProviders as createDefaultProviders3,
   createToleranceChecker,
   toleranceConfigSchema,
   validateRoundTrip
 } from "@kaiord/core";
+import { createAllProviders as createAllProviders3 } from "@kaiord/all";
 import { readFile as fsReadFile2 } from "fs/promises";
-import ora2 from "ora";
+import ora3 from "ora";
 import { z as z5 } from "zod";
 var validateOptionsSchema = z5.object({
   input: z5.string(),
@@ -1098,7 +1324,8 @@ var validateCommand = async (options) => {
   let logger;
   let spinner = null;
   try {
-    const config = await loadConfig();
+    const configResult = await loadConfigWithMetadata();
+    const { config } = configResult;
     const mergedOptions = mergeWithConfig(
       options,
       config
@@ -1118,6 +1345,13 @@ var validateCommand = async (options) => {
       level: opts.verbose ? "debug" : opts.quiet ? "error" : "info",
       quiet: opts.quiet
     });
+    if (configResult.loadedFrom) {
+      logger.debug("Configuration loaded", { path: configResult.loadedFrom });
+    } else {
+      logger.debug("No configuration file found", {
+        searchedPaths: configResult.searchedPaths
+      });
+    }
     const format = detectFormat(opts.input);
     if (!format) {
       throw new Error(`Unable to detect format from file: ${opts.input}`);
@@ -1144,7 +1378,7 @@ var validateCommand = async (options) => {
         config: toleranceConfig
       });
     }
-    const providers = createDefaultProviders3(logger);
+    const providers = createAllProviders3(logger);
     const toleranceChecker = toleranceConfig ? createToleranceChecker(toleranceConfig) : providers.toleranceChecker;
     const roundTripValidator = validateRoundTrip(
       providers.fitReader,
@@ -1152,7 +1386,7 @@ var validateCommand = async (options) => {
       toleranceChecker,
       logger
     );
-    spinner = opts.quiet || opts.json ? null : ora2("Validating round-trip conversion...").start();
+    spinner = opts.quiet || opts.json ? null : ora3("Validating round-trip conversion...").start();
     logger?.info("Starting round-trip validation", { file: opts.input });
     const violations = await roundTripValidator.validateFitToKrdToFit({
       originalFit: inputData
@@ -1182,9 +1416,9 @@ var validateCommand = async (options) => {
           )
         );
       } else if (!opts.quiet) {
-        console.log("\u2713 Round-trip validation passed");
+        console.log("Round-trip validation passed");
       }
-      process.exit(0);
+      return ExitCode.SUCCESS;
     } else {
       logger?.warn("Round-trip validation failed", {
         violationCount: violations.length
@@ -1203,10 +1437,10 @@ var validateCommand = async (options) => {
           )
         );
       } else {
-        console.error("\u2716 Round-trip validation failed\n");
+        console.error("Round-trip validation failed\n");
         console.error(formatToleranceViolations(violations));
       }
-      process.exit(1);
+      return ExitCode.TOLERANCE_EXCEEDED;
     }
   } catch (error) {
     logger?.error("Validation failed", { error });
@@ -1232,7 +1466,15 @@ var validateCommand = async (options) => {
     } else {
       console.error(formatError(error, { json: false }));
     }
-    process.exit(1);
+    if (error instanceof Error) {
+      if (error.message.includes("File not found")) {
+        return ExitCode.FILE_NOT_FOUND;
+      }
+      if (error.message.includes("only supports") || error.message.includes("Unable to detect")) {
+        return ExitCode.INVALID_ARGUMENT;
+      }
+    }
+    return ExitCode.UNKNOWN_ERROR;
   } finally {
     spinner?.stop();
   }
@@ -1244,33 +1486,8 @@ var __dirname2 = dirname2(__filename2);
 var packageJsonPath = __dirname2.includes("/dist") ? join3(__dirname2, "../../package.json") : join3(__dirname2, "../../package.json");
 var packageJson = JSON.parse(readFileSync(packageJsonPath, "utf-8"));
 var version = packageJson.version;
-var showKiroEasterEgg = () => {
-  console.log(
-    chalk5.cyan(`
-\u2554\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2557
-\u2551                                                           \u2551
-\u2551   \u{1F47B} Built with Kiro AI during Kiroween Hackathon \u{1F47B}      \u2551
-\u2551                                                           \u2551
-\u2551   Kiro helped design, architect, and implement this       \u2551
-\u2551   entire CLI tool through spec-driven development.        \u2551
-\u2551                                                           \u2551
-\u2551   Learn more about Kiroween:                              \u2551
-\u2551   \u{1F449} http://kiroween.devpost.com/                         \u2551
-\u2551                                                           \u2551
-\u2551   Kiro: Your AI pair programmer for building better       \u2551
-\u2551   software, faster. \u{1F680}                                    \u2551
-\u2551                                                           \u2551
-\u255A\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u255D
-  `)
-  );
-  process.exit(0);
-};
 var main = async () => {
   try {
-    const args = process.argv.slice(2);
-    if (args.includes("--kiro") || args.includes("--kiroween")) {
-      showKiroEasterEgg();
-    }
     await yargs(hideBin(process.argv)).scriptName("kaiord").usage("$0 <command> [options]").command(
       "convert",
       "Convert workout files between formats",
@@ -1324,7 +1541,7 @@ var main = async () => {
       }
     ).command(
       "validate",
-      "Validate round-trip conversion of workout files",
+      "Validate round-trip conversion of FIT files (FIT only)",
       (yargs2) => {
         return yargs2.option("input", {
           alias: "i",
@@ -1343,7 +1560,7 @@ var main = async () => {
         );
       },
       async (argv) => {
-        await validateCommand({
+        const exitCode = await validateCommand({
           input: argv.input,
           toleranceConfig: argv.toleranceConfig,
           verbose: argv.verbose,
@@ -1351,16 +1568,21 @@ var main = async () => {
           json: argv.json,
           logFormat: argv.logFormat
         });
+        if (exitCode !== ExitCode.SUCCESS) {
+          process.exit(exitCode);
+        }
       }
     ).command(
       "diff",
       "Compare two workout files and show differences",
       (yargs2) => {
         return yargs2.option("file1", {
+          alias: "1",
           type: "string",
           description: "First file to compare",
           demandOption: true
         }).option("file2", {
+          alias: "2",
           type: "string",
           description: "Second file to compare",
           demandOption: true
@@ -1394,7 +1616,10 @@ var main = async () => {
           json: argv.json,
           logFormat: argv.logFormat
         });
-        if (exitCode !== 0 && exitCode !== 1) {
+        if (exitCode !== ExitCode.SUCCESS && exitCode !== ExitCode.DIFFERENCES_FOUND) {
+          process.exit(exitCode);
+        }
+        if (exitCode === ExitCode.DIFFERENCES_FOUND) {
           process.exit(exitCode);
         }
       }
@@ -1422,25 +1647,27 @@ var main = async () => {
     if (error && typeof error === "object" && "name" in error) {
       const errorName = error.name;
       if (errorName === "FitParsingError") {
-        process.exit(4);
+        process.exit(ExitCode.PARSING_ERROR);
       } else if (errorName === "KrdValidationError") {
-        process.exit(5);
+        process.exit(ExitCode.VALIDATION_ERROR);
       } else if (errorName === "ToleranceExceededError") {
-        process.exit(6);
+        process.exit(ExitCode.TOLERANCE_EXCEEDED);
+      } else if (errorName === "InvalidArgumentError") {
+        process.exit(ExitCode.INVALID_ARGUMENT);
       }
     }
-    process.exit(99);
+    process.exit(ExitCode.UNKNOWN_ERROR);
   }
 };
 process.on("unhandledRejection", (reason) => {
   console.error("Unhandled rejection:", reason);
-  process.exit(99);
+  process.exit(ExitCode.UNKNOWN_ERROR);
 });
 process.on("uncaughtException", (error) => {
   console.error("Uncaught exception:", error);
-  process.exit(99);
+  process.exit(ExitCode.UNKNOWN_ERROR);
 });
 main().catch((error) => {
   console.error("Fatal error:", error);
-  process.exit(99);
+  process.exit(ExitCode.UNKNOWN_ERROR);
 });