@kaiord/cli 0.1.1 → 2.0.1

package/dist/bin/kaiord.js

@@ -1,55 +1,442 @@
 #!/usr/bin/env node
-import {
-  isTTY
-} from "../chunk-TI3WVGXE.js";
+var __defProp = Object.defineProperty;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __esm = (fn, res) => function __init() {
+  return fn && (res = (0, fn[__getOwnPropNames(fn)[0]])(fn = 0)), res;
+};
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+
+// ../../node_modules/.pnpm/tsup@8.5.1_jiti@2.6.1_postcss@8.5.6_tsx@4.20.6_typescript@5.9.3/node_modules/tsup/assets/esm_shims.js
+import path from "path";
+import { fileURLToPath } from "url";
+var init_esm_shims = __esm({
+  "../../node_modules/.pnpm/tsup@8.5.1_jiti@2.6.1_postcss@8.5.6_tsx@4.20.6_typescript@5.9.3/node_modules/tsup/assets/esm_shims.js"() {
+    "use strict";
+  }
+});
+
+// src/utils/is-tty.ts
+var isTTY;
+var init_is_tty = __esm({
+  "src/utils/is-tty.ts"() {
+    "use strict";
+    init_esm_shims();
+    isTTY = () => {
+      return process.stdout.isTTY === true;
+    };
+  }
+});
+
+// src/adapters/logger/structured-logger.ts
+var structured_logger_exports = {};
+__export(structured_logger_exports, {
+  createStructuredLogger: () => createStructuredLogger
+});
+import winston from "winston";
+var createStructuredLogger;
+var init_structured_logger = __esm({
+  "src/adapters/logger/structured-logger.ts"() {
+    "use strict";
+    init_esm_shims();
+    createStructuredLogger = (options = {}) => {
+      const level = options.level || "info";
+      const quiet = options.quiet || false;
+      const winstonLogger = winston.createLogger({
+        level: quiet ? "error" : level,
+        format: winston.format.combine(
+          winston.format.timestamp(),
+          winston.format.json()
+        ),
+        transports: [
+          new winston.transports.Console({
+            stderrLevels: ["error", "warn", "info", "debug"]
+          })
+        ]
+      });
+      return {
+        debug: (message, context) => {
+          winstonLogger.debug(message, context);
+        },
+        info: (message, context) => {
+          winstonLogger.info(message, context);
+        },
+        warn: (message, context) => {
+          winstonLogger.warn(message, context);
+        },
+        error: (message, context) => {
+          winstonLogger.error(message, context);
+        }
+      };
+    };
+  }
+});
+
+// src/adapters/logger/pretty-logger.ts
+var pretty_logger_exports = {};
+__export(pretty_logger_exports, {
+  createPrettyLogger: () => createPrettyLogger
+});
+import chalk6 from "chalk";
+var createPrettyLogger;
+var init_pretty_logger = __esm({
+  "src/adapters/logger/pretty-logger.ts"() {
+    "use strict";
+    init_esm_shims();
+    init_is_tty();
+    createPrettyLogger = (options = {}) => {
+      const level = options.level || "info";
+      const quiet = options.quiet || false;
+      const forceColor = process.env.FORCE_COLOR === "1";
+      const useColors = isTTY() || forceColor;
+      const levels = ["debug", "info", "warn", "error"];
+      const minLevelIndex = levels.indexOf(level);
+      const shouldLog = (messageLevel) => {
+        if (quiet && messageLevel !== "error") {
+          return false;
+        }
+        const messageLevelIndex = levels.indexOf(messageLevel);
+        return messageLevelIndex >= minLevelIndex;
+      };
+      const formatContext = (context) => {
+        if (!context || Object.keys(context).length === 0) {
+          return "";
+        }
+        const contextStr = JSON.stringify(context);
+        return " " + (useColors ? chalk6.gray(contextStr) : contextStr);
+      };
+      return {
+        debug: (message, context) => {
+          if (shouldLog("debug")) {
+            const formatted = `\u{1F41B} ${message}${formatContext(context)}`;
+            console.log(useColors ? chalk6.gray(formatted) : formatted);
+          }
+        },
+        info: (message, context) => {
+          if (shouldLog("info")) {
+            const formatted = `\u2139 ${message}${formatContext(context)}`;
+            console.log(useColors ? chalk6.blue(formatted) : formatted);
+          }
+        },
+        warn: (message, context) => {
+          if (shouldLog("warn")) {
+            const formatted = `\u26A0 ${message}${formatContext(context)}`;
+            console.warn(useColors ? chalk6.yellow(formatted) : formatted);
+          }
+        },
+        error: (message, context) => {
+          if (shouldLog("error")) {
+            const formatted = `\u2716 ${message}${formatContext(context)}`;
+            console.error(useColors ? chalk6.red(formatted) : formatted);
+          }
+        }
+      };
+    };
+  }
+});
 
 // src/bin/kaiord.ts
-import chalk3 from "chalk";
+init_esm_shims();
 import { readFileSync } from "fs";
-import { dirname as dirname2, join as join2 } from "path";
-import { fileURLToPath } from "url";
+import { dirname as dirname2, join as join3 } from "path";
+import { fileURLToPath as fileURLToPath2 } from "url";
 import yargs from "yargs";
 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 chalk2 from "chalk";
-import ora from "ora";
-import { basename, join } from "path";
+import { createAllProviders } from "@kaiord/all";
+
+// src/utils/config-loader.ts
+init_esm_shims();
+import { readFile } from "fs/promises";
+import { homedir } from "os";
+import { join } from "path";
 import { z as z2 } from "zod";
 
+// src/utils/format-detector.ts
+init_esm_shims();
+import { extname } from "path";
+import { z } from "zod";
+var fileFormatSchema = z.enum(["fit", "krd", "tcx", "zwo"]);
+var EXTENSION_TO_FORMAT = {
+  ".fit": "fit",
+  ".krd": "krd",
+  ".tcx": "tcx",
+  ".zwo": "zwo"
+};
+var detectFormat = (filePath) => {
+  const ext = extname(filePath).toLowerCase();
+  return EXTENSION_TO_FORMAT[ext] || null;
+};
+
+// src/utils/config-loader.ts
+var configSchema = z2.object({
+  // Default formats
+  defaultInputFormat: fileFormatSchema.optional(),
+  defaultOutputFormat: fileFormatSchema.optional(),
+  // Default directories
+  defaultOutputDir: z2.string().optional(),
+  // Default tolerance config path
+  defaultToleranceConfig: z2.string().optional(),
+  // Default logging options
+  verbose: z2.boolean().optional(),
+  quiet: z2.boolean().optional(),
+  json: z2.boolean().optional(),
+  logFormat: z2.enum(["pretty", "structured"]).optional()
+});
+var loadConfigWithMetadata = async () => {
+  const configPaths = [
+    join(process.cwd(), ".kaiordrc.json"),
+    join(homedir(), ".kaiordrc.json")
+  ];
+  for (const configPath of configPaths) {
+    try {
+      const configContent = await readFile(configPath, "utf-8");
+      const configJson = JSON.parse(configContent);
+      const config = configSchema.parse(configJson);
+      return { config, loadedFrom: configPath, searchedPaths: configPaths };
+    } catch {
+      continue;
+    }
+  }
+  return { config: {}, loadedFrom: null, searchedPaths: configPaths };
+};
+var mergeWithConfig = (cliOptions, config) => {
+  const merged = { ...config };
+  for (const key in cliOptions) {
+    if (cliOptions[key] !== void 0) {
+      merged[key] = cliOptions[key];
+    }
+  }
+  return merged;
+};
+
 // src/utils/error-formatter.ts
+init_esm_shims();
+
+// 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");
@@ -60,506 +447,848 @@ 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)}`);
-    }
+
+// 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:",
-      "  Verify the file is a valid FIT workout file.",
-      "  Try opening it in Garmin Connect to confirm."
+      useColors ? chalk5.cyan("Suggestion:") : "Suggestion:",
+      ...suggestion.map((s) => `  ${s}`)
     );
-    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");
+};
+var formatUnknownError2 = (error, useColors) => {
+  return [
+    useColors ? chalk5.red("\u2716 Error: An unexpected error occurred") : "\u2716 Error: An unexpected error occurred",
+    "",
+    useColors ? chalk5.gray("Details:") : "Details:",
+    `  ${String(error)}`
+  ].join("\n");
+};
+
+// 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 KrdValidationError2) {
+    return formatKrdValidationError(error, useColors);
+  }
+  if (error instanceof ToleranceExceededError2) {
+    return formatToleranceError2(error, useColors);
+  }
+  if (error instanceof Error) {
+    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);
+  }
+};
+
+// 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 } 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}`
     );
-    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)
-    ];
-    lines.push(
-      "",
-      useColors ? chalk.cyan("Suggestion:") : "Suggestion:",
-      "  The conversion may have lost precision.",
-      "  Consider adjusting tolerance values if the deviations are acceptable."
+};
+
+// src/utils/file-handler.ts
+var readFile2 = async (path2, format) => {
+  validatePathSecurity(path2);
+  try {
+    if (format === "fit") {
+      const buffer = await fsReadFile(path2);
+      return new Uint8Array(buffer);
+    } else {
+      return await fsReadFile(path2, "utf-8");
+    }
+  } catch (error) {
+    if (isNodeSystemError(error)) {
+      if (error.code === "ENOENT") {
+        throw new Error(`File not found: ${path2}`);
+      }
+      if (error.code === "EACCES") {
+        throw new Error(`Permission denied: ${path2}`);
+      }
+    }
+    throw new Error(`Failed to read file: ${path2}`);
+  }
+};
+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 {
+    if (format === "fit") {
+      await fsWriteFile(path2, data);
+    } else {
+      await fsWriteFile(path2, data, "utf-8");
+    }
+  } catch (error) {
+    if (isNodeSystemError(error)) {
+      if (error.code === "EACCES") {
+        throw new Error(`Permission denied writing file: ${path2}`);
+      }
+      if (error.code === "EISDIR") {
+        throw new Error(`Cannot write file (path is a directory): ${path2}`);
+      }
+    }
+    throw new Error(`Failed to write file: ${path2}`);
+  }
+};
+var findFiles = async (pattern) => {
+  const files = await glob(pattern, {
+    nodir: true,
+    absolute: false
+  });
+  return files.sort();
+};
+
+// src/commands/convert/single-file.ts
+init_esm_shims();
+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`
     );
-    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");
+  const fileData = await readFile2(filePath, detectedFormat);
+  return convertToKrd(fileData, detectedFormat, providers);
+};
+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 });
   }
-  return [
-    useColors ? chalk.red("\u2716 Error: An unexpected error occurred") : "\u2716 Error: An unexpected error occurred",
-    "",
-    useColors ? chalk.gray("Details:") : "Details:",
-    `  ${String(error)}`
-  ].join("\n");
+  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 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
+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;
   }
-  if (error instanceof KrdValidationError) {
-    return JSON.stringify(
-      {
+  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,
-        error: {
-          type: "KrdValidationError",
-          message: error.message,
-          errors: error.errors,
-          suggestion: "Check the KRD file against the schema."
-        }
-      },
-      null,
-      2
+        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 {
+    console.log(
+      JSON.stringify(
+        {
+          success: failed.length === 0,
+          total: files.length,
+          successful: successful.length,
+          failed: failed.length,
+          totalTime,
+          results
+        },
+        null,
+        2
+      )
     );
   }
-  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 (failed.length === 0) {
+    return ExitCode.SUCCESS;
   }
-  if (error instanceof Error) {
-    return JSON.stringify(
-      {
-        success: false,
-        error: {
-          type: error.name || "Error",
-          message: error.message,
-          stack: error.stack
-        }
-      },
-      null,
-      2
-    );
+  if (successful.length === 0) {
+    return ExitCode.INVALID_ARGUMENT;
   }
-  return JSON.stringify(
-    {
-      success: false,
-      error: {
-        type: "UnknownError",
-        message: String(error)
-      }
-    },
-    null,
-    2
-  );
+  return ExitCode.PARTIAL_SUCCESS;
 };
 
-// src/utils/file-handler.ts
-import {
-  readFile as fsReadFile,
-  writeFile as fsWriteFile,
-  mkdir
-} from "fs/promises";
-import { glob } from "glob";
-import { dirname } from "path";
-var readFile = async (path, format) => {
+// 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(),
+  outputDir: z3.string().optional(),
+  inputFormat: fileFormatSchema.optional(),
+  outputFormat: fileFormatSchema.optional(),
+  verbose: z3.boolean().optional(),
+  quiet: z3.boolean().optional(),
+  json: z3.boolean().optional(),
+  logFormat: z3.enum(["pretty", "structured"]).optional()
+});
+
+// src/commands/convert/index.ts
+var isBatchMode = (input) => {
+  return input.includes("*") || input.includes("?");
+};
+var convertCommand = async (options) => {
+  const configResult = await loadConfigWithMetadata();
+  const { config } = configResult;
+  const mergedOptions = mergeWithConfig(options, config);
+  const optionsWithDefaults = {
+    ...mergedOptions,
+    inputFormat: mergedOptions.inputFormat || config.defaultInputFormat,
+    outputFormat: mergedOptions.outputFormat || config.defaultOutputFormat,
+    outputDir: mergedOptions.outputDir || config.defaultOutputDir,
+    verbose: mergedOptions.verbose ?? config.verbose,
+    quiet: mergedOptions.quiet ?? config.quiet,
+    json: mergedOptions.json ?? config.json,
+    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 {
-    if (format === "fit") {
-      const buffer = await fsReadFile(path);
-      return new Uint8Array(buffer);
+    const providers = createAllProviders(logger);
+    if (isBatchMode(validatedOptions.input)) {
+      return await executeBatchConversion(validatedOptions, providers, logger);
     } else {
-      return await fsReadFile(path, "utf-8");
+      await executeSingleFileConversion(validatedOptions, providers, logger);
+      return ExitCode.SUCCESS;
     }
   } catch (error) {
-    if (error instanceof Error && "code" in error) {
-      if (error.code === "ENOENT") {
-        throw new Error(`File not found: ${path}`);
-      }
-      if (error.code === "EACCES") {
-        throw new Error(`Permission denied: ${path}`);
+    logger.error("Conversion failed", { error });
+    const formattedError = formatError(error, {
+      json: validatedOptions.json
+    });
+    if (validatedOptions.json) {
+      console.log(formattedError);
+    } else {
+      console.error(formattedError);
+    }
+    let exitCode = ExitCode.UNKNOWN_ERROR;
+    if (error instanceof Error) {
+      if (error.message.includes("File not found")) {
+        exitCode = ExitCode.FILE_NOT_FOUND;
+      } else if (error.message.includes("Permission denied")) {
+        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 = ExitCode.INVALID_ARGUMENT;
       }
     }
-    throw new Error(`Failed to read file: ${path}`);
+    return exitCode;
   }
 };
-var writeFile = async (path, data, format) => {
-  try {
-    const dir = dirname(path);
-    await mkdir(dir, { recursive: true });
-    if (format === "fit") {
-      if (!(data instanceof Uint8Array)) {
-        throw new Error("FIT files require Uint8Array data");
-      }
-      await fsWriteFile(path, data);
-    } else {
-      if (typeof data !== "string") {
-        throw new Error("Text files require string data");
-      }
-      await fsWriteFile(path, data, "utf-8");
-    }
-  } catch (error) {
-    if (error instanceof Error && "code" in error) {
-      if (error.code === "EACCES") {
-        throw new Error(`Permission denied: ${path}`);
-      }
+
+// src/commands/diff.ts
+init_esm_shims();
+
+// 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;
+  const steps1 = workout1?.steps || [];
+  const steps2 = workout2?.steps || [];
+  const differences = [];
+  const maxSteps = Math.max(steps1.length, steps2.length);
+  for (let i = 0; i < maxSteps; i++) {
+    const step1 = steps1[i];
+    const step2 = steps2[i];
+    if (!step1 && step2) {
+      differences.push({
+        stepIndex: i,
+        field: "step",
+        file1Value: void 0,
+        file2Value: step2
+      });
+      continue;
     }
-    if (error instanceof Error && error.message.includes("require")) {
-      throw error;
+    if (step1 && !step2) {
+      differences.push({
+        stepIndex: i,
+        field: "step",
+        file1Value: step1,
+        file2Value: void 0
+      });
+      continue;
     }
-    throw new Error(`Failed to write file: ${path}`);
+    if (!step1 || !step2) continue;
+    compareStepFields(i, step1, step2, differences);
   }
+  return { file1Count: steps1.length, file2Count: steps2.length, differences };
 };
-var findFiles = async (pattern) => {
-  const files = await glob(pattern, {
-    nodir: true,
-    absolute: false
-  });
-  return files.sort();
-};
+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]
+      });
+    }
+  }
+}
 
-// src/utils/format-detector.ts
-import { extname } from "path";
-import { z } from "zod";
-var fileFormatSchema = z.enum(["fit", "krd", "tcx", "zwo"]);
-var EXTENSION_TO_FORMAT = {
-  ".fit": "fit",
-  ".krd": "krd",
-  ".tcx": "tcx",
-  ".zwo": "zwo"
-};
-var detectFormat = (filePath) => {
-  const ext = extname(filePath).toLowerCase();
-  return EXTENSION_TO_FORMAT[ext] || null;
+// 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;
 };
-
-// src/utils/logger-factory.ts
-var isCI = () => {
-  return process.env.CI === "true" || process.env.NODE_ENV === "production" || !process.stdout.isTTY;
+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 createLogger = async (options = {}) => {
-  const loggerType = options.type || (isCI() ? "structured" : "pretty");
-  if (loggerType === "structured") {
-    const { createStructuredLogger } = await import("../structured-logger-HMEQGEES.js");
-    return createStructuredLogger(options);
-  } else {
-    const { createPrettyLogger } = await import("../pretty-logger-P2OWMOGW.js");
-    return createPrettyLogger(options);
+var compareExtensions = (krd1, krd2) => {
+  const ext1 = krd1.extensions || {};
+  const ext2 = krd2.extensions || {};
+  const keys1 = Object.keys(ext1);
+  const keys2 = Object.keys(ext2);
+  const allKeys = /* @__PURE__ */ new Set([...keys1, ...keys2]);
+  const differences = [];
+  for (const key of allKeys) {
+    if (isDifferent(ext1[key], ext2[key])) {
+      differences.push({ key, file1Value: ext1[key], file2Value: ext2[key] });
+    }
   }
+  return { file1Keys: keys1, file2Keys: keys2, differences };
 };
 
-// src/commands/convert.ts
-var convertOptionsSchema = z2.object({
-  input: z2.string(),
-  output: z2.string().optional(),
-  outputDir: z2.string().optional(),
-  inputFormat: fileFormatSchema.optional(),
-  outputFormat: fileFormatSchema.optional(),
-  verbose: z2.boolean().optional(),
-  quiet: z2.boolean().optional(),
-  json: z2.boolean().optional(),
-  logFormat: z2.enum(["pretty", "structured"]).optional()
-});
-var isBatchMode = (input) => {
-  return input.includes("*") || input.includes("?");
-};
-var convertSingleFile = async (inputFile, outputFile, inputFormat, outputFormat, providers) => {
-  const inputData = await readFile(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");
+// src/commands/diff/formatter.ts
+init_esm_shims();
+import chalk8 from "chalk";
+var formatDiffPretty = (result, file1, file2) => {
+  if (result.identical) {
+    return chalk8.green("Files are identical");
+  }
+  const lines = [];
+  lines.push(chalk8.yellow(`
+Comparing: ${file1} vs ${file2}
+`));
+  if (result.metadataDiff && result.metadataDiff.length > 0) {
+    lines.push(chalk8.bold("Metadata Differences:"));
+    for (const diff of result.metadataDiff) {
+      lines.push(
+        `  ${chalk8.cyan(diff.field)}:`,
+        `    ${chalk8.red("-")} ${JSON.stringify(diff.file1Value)}`,
+        `    ${chalk8.green("+")} ${JSON.stringify(diff.file2Value)}`
+      );
     }
-    krd = await providers.convertTcxToKrd({ tcxString: inputData });
-  } else if (inputFormat === "zwo") {
-    if (typeof inputData !== "string") {
-      throw new Error("ZWO input must be string");
+    lines.push("");
+  }
+  if (result.stepsDiff && result.stepsDiff.differences.length > 0) {
+    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} - ${chalk8.cyan(diff.field)}:`,
+        `    ${chalk8.red("-")} ${JSON.stringify(diff.file1Value)}`,
+        `    ${chalk8.green("+")} ${JSON.stringify(diff.file2Value)}`
+      );
     }
-    krd = await providers.convertZwiftToKrd({ zwiftString: inputData });
-  } else if (inputFormat === "krd") {
-    if (typeof inputData !== "string") {
-      throw new Error("KRD input must be string");
+    lines.push("");
+  }
+  if (result.extensionsDiff && result.extensionsDiff.differences.length > 0) {
+    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(
+        `  ${chalk8.cyan(diff.key)}:`,
+        `    ${chalk8.red("-")} ${JSON.stringify(diff.file1Value)}`,
+        `    ${chalk8.green("+")} ${JSON.stringify(diff.file2Value)}`
+      );
     }
-    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}`);
+    lines.push("");
   }
-  await writeFile(outputFile, outputData, outputFormat);
+  return lines.join("\n");
 };
-var convertCommand = async (options) => {
-  const validatedOptions = convertOptionsSchema.parse(options);
+
+// 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({
     type: validatedOptions.logFormat,
     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 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 = join(validatedOptions.outputDir, outputFileName);
-          await convertSingleFile(
-            file,
-            outputFile,
-            inputFormat,
-            outputFormat,
-            providers
-          );
-          results.push({
+    const providers = createAllProviders2(logger);
+    logger.debug("Loading files for comparison", {
+      file1: validatedOptions.file1,
+      file2: validatedOptions.file2
+    });
+    const krd1 = await loadFileAsKrd(
+      validatedOptions.file1,
+      validatedOptions.format1,
+      providers
+    );
+    const krd2 = await loadFileAsKrd(
+      validatedOptions.file2,
+      validatedOptions.format2,
+      providers
+    );
+    logger.debug("Files loaded successfully");
+    const metadataDiff = compareMetadata(krd1, krd2);
+    const stepsDiff = compareSteps(krd1, krd2);
+    const extensionsDiff = compareExtensions(krd1, krd2);
+    const identical = metadataDiff.length === 0 && stepsDiff.differences.length === 0 && extensionsDiff.differences.length === 0;
+    const result = {
+      identical,
+      metadataDiff: metadataDiff.length > 0 ? metadataDiff : void 0,
+      stepsDiff: stepsDiff.differences.length > 0 ? stepsDiff : void 0,
+      extensionsDiff: extensionsDiff.differences.length > 0 ? extensionsDiff : void 0
+    };
+    if (validatedOptions.json) {
+      console.log(
+        JSON.stringify(
+          {
             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(
-          chalk2.green(`  \u2713 Successful: ${successful.length}/${files.length}`)
-        );
-        if (failed.length > 0) {
-          console.log(
-            chalk2.red(`  \u2717 Failed: ${failed.length}/${files.length}`)
-          );
-        }
-        console.log(`  Total time: ${(totalTime / 1e3).toFixed(2)}s`);
-        if (failed.length > 0) {
-          console.log(chalk2.red("\nFailed conversions:"));
-          for (const result of failed) {
-            console.log(chalk2.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);
-      }
+            file1: validatedOptions.file1,
+            file2: validatedOptions.file2,
+            ...result
+          },
+          null,
+          2
+        )
+      );
     } 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;
-      }
+      console.log(
+        formatDiffPretty(result, validatedOptions.file1, validatedOptions.file2)
+      );
     }
+    return identical ? ExitCode.SUCCESS : ExitCode.DIFFERENCES_FOUND;
   } catch (error) {
-    logger.error("Conversion failed", { error });
+    logger.error("Diff command failed", { error });
     const formattedError = formatError(error, {
       json: validatedOptions.json
     });
@@ -568,53 +1297,61 @@ var convertCommand = async (options) => {
     } else {
       console.error(formattedError);
     }
-    let exitCode = 1;
-    if (error instanceof Error) {
-      if (error.message.includes("File not found")) {
-        exitCode = 1;
-      } else if (error.message.includes("Permission denied")) {
-        exitCode = 1;
-      } else if (error instanceof FitParsingError2) {
-        exitCode = 1;
-      } else if (error instanceof KrdValidationError2) {
-        exitCode = 1;
-      } else if (error instanceof ToleranceExceededError2) {
-        exitCode = 1;
-      } else if (error.name === "InvalidArgumentError") {
-        exitCode = 1;
-      }
-    }
-    process.exit(exitCode);
+    return ExitCode.UNKNOWN_ERROR;
   }
 };
 
 // src/commands/validate.ts
+init_esm_shims();
 import {
-  createDefaultProviders as createDefaultProviders2,
   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 { z as z3 } from "zod";
-var validateOptionsSchema = z3.object({
-  input: z3.string(),
-  toleranceConfig: z3.string().optional(),
-  verbose: z3.boolean().optional(),
-  quiet: z3.boolean().optional(),
-  json: z3.boolean().optional(),
-  logFormat: z3.enum(["pretty", "json"]).optional()
+import ora3 from "ora";
+import { z as z5 } from "zod";
+var validateOptionsSchema = z5.object({
+  input: z5.string(),
+  toleranceConfig: z5.string().optional(),
+  verbose: z5.boolean().optional(),
+  quiet: z5.boolean().optional(),
+  json: z5.boolean().optional(),
+  logFormat: z5.enum(["pretty", "json"]).optional()
 });
 var validateCommand = async (options) => {
-  const opts = validateOptionsSchema.parse(options);
-  const loggerType = opts.logFormat === "json" ? "structured" : opts.logFormat;
-  const logger = await createLogger({
-    type: loggerType,
-    level: opts.verbose ? "debug" : opts.quiet ? "error" : "info",
-    quiet: opts.quiet
-  });
+  let logger;
+  let spinner = null;
   try {
+    const configResult = await loadConfigWithMetadata();
+    const { config } = configResult;
+    const mergedOptions = mergeWithConfig(
+      options,
+      config
+    );
+    const optionsWithDefaults = {
+      ...mergedOptions,
+      toleranceConfig: mergedOptions.toleranceConfig || config.defaultToleranceConfig,
+      verbose: mergedOptions.verbose ?? config.verbose,
+      quiet: mergedOptions.quiet ?? config.quiet,
+      json: mergedOptions.json ?? config.json,
+      logFormat: mergedOptions.logFormat || config.logFormat
+    };
+    const opts = validateOptionsSchema.parse(optionsWithDefaults);
+    const loggerType = opts.logFormat === "json" ? "structured" : opts.logFormat;
+    logger = await createLogger({
+      type: loggerType,
+      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}`);
@@ -624,24 +1361,24 @@ var validateCommand = async (options) => {
         `Validation currently only supports FIT files. Got: ${format}`
       );
     }
-    logger.debug("Reading input file", { path: opts.input, format });
-    const inputData = await readFile(opts.input, format);
+    logger?.debug("Reading input file", { path: opts.input, format });
+    const inputData = await readFile2(opts.input, format);
     if (typeof inputData === "string") {
       throw new Error("Expected binary data for FIT file");
     }
     let toleranceConfig;
     if (opts.toleranceConfig) {
-      logger.debug("Loading custom tolerance config", {
+      logger?.debug("Loading custom tolerance config", {
         path: opts.toleranceConfig
       });
       const configContent = await fsReadFile2(opts.toleranceConfig, "utf-8");
       const configJson = JSON.parse(configContent);
       toleranceConfig = toleranceConfigSchema.parse(configJson);
-      logger.debug("Custom tolerance config loaded", {
+      logger?.debug("Custom tolerance config loaded", {
         config: toleranceConfig
       });
     }
-    const providers = createDefaultProviders2(logger);
+    const providers = createAllProviders3(logger);
     const toleranceChecker = toleranceConfig ? createToleranceChecker(toleranceConfig) : providers.toleranceChecker;
     const roundTripValidator = validateRoundTrip(
       providers.fitReader,
@@ -649,8 +1386,8 @@ var validateCommand = async (options) => {
       toleranceChecker,
       logger
     );
-    const spinner = opts.quiet || opts.json ? null : ora2("Validating round-trip conversion...").start();
-    logger.info("Starting round-trip validation", { file: opts.input });
+    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
     });
@@ -664,7 +1401,7 @@ var validateCommand = async (options) => {
       }
     }
     if (violations.length === 0) {
-      logger.info("Round-trip validation passed");
+      logger?.info("Round-trip validation passed");
       if (opts.json) {
         console.log(
           JSON.stringify(
@@ -679,11 +1416,11 @@ 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", {
+      logger?.warn("Round-trip validation failed", {
         violationCount: violations.length
       });
       if (opts.json) {
@@ -700,19 +1437,27 @@ 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 });
-    if (opts.json) {
+    logger?.error("Validation failed", { error });
+    let jsonOutput = false;
+    try {
+      const opts = validateOptionsSchema.parse(options);
+      jsonOutput = opts.json || false;
+    } catch {
+    }
+    if (jsonOutput) {
+      const errorObj = formatError(error, { json: true });
+      const errorData = typeof errorObj === "string" ? JSON.parse(errorObj) : errorObj;
       console.log(
         JSON.stringify(
           {
             success: false,
-            error: formatError(error, { json: true })
+            error: errorData
           },
           null,
           2
@@ -721,43 +1466,28 @@ 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();
   }
 };
 
 // src/bin/kaiord.ts
-var __filename2 = fileURLToPath(import.meta.url);
+var __filename2 = fileURLToPath2(import.meta.url);
 var __dirname2 = dirname2(__filename2);
-var packageJsonPath = __dirname2.includes("/dist") ? join2(__dirname2, "../../package.json") : join2(__dirname2, "../../package.json");
+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(
-    chalk3.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",
@@ -794,7 +1524,7 @@ var main = async () => {
         );
       },
       async (argv) => {
-        await convertCommand({
+        const exitCode = await convertCommand({
           input: argv.input,
           output: argv.output,
           outputDir: argv.outputDir,
@@ -805,10 +1535,13 @@ var main = async () => {
           json: argv.json,
           logFormat: argv.logFormat
         });
+        if (exitCode !== 0) {
+          process.exit(exitCode);
+        }
       }
     ).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",
@@ -827,7 +1560,7 @@ var main = async () => {
         );
       },
       async (argv) => {
-        await validateCommand({
+        const exitCode = await validateCommand({
           input: argv.input,
           toleranceConfig: argv.toleranceConfig,
           verbose: argv.verbose,
@@ -835,6 +1568,60 @@ 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
+        }).option("format1", {
+          type: "string",
+          choices: ["fit", "krd", "tcx", "zwo"],
+          description: "Override format detection for first file"
+        }).option("format2", {
+          type: "string",
+          choices: ["fit", "krd", "tcx", "zwo"],
+          description: "Override format detection for second file"
+        }).example(
+          "$0 diff --file1 workout1.fit --file2 workout2.fit",
+          "Compare two FIT files"
+        ).example(
+          "$0 diff --file1 workout.fit --file2 workout.krd",
+          "Compare FIT and KRD files"
+        ).example(
+          "$0 diff --file1 workout1.krd --file2 workout2.krd --json",
+          "Compare with JSON output"
+        );
+      },
+      async (argv) => {
+        const exitCode = await diffCommand({
+          file1: argv.file1,
+          file2: argv.file2,
+          format1: argv.format1,
+          format2: argv.format2,
+          verbose: argv.verbose,
+          quiet: argv.quiet,
+          json: argv.json,
+          logFormat: argv.logFormat
+        });
+        if (exitCode !== ExitCode.SUCCESS && exitCode !== ExitCode.DIFFERENCES_FOUND) {
+          process.exit(exitCode);
+        }
+        if (exitCode === ExitCode.DIFFERENCES_FOUND) {
+          process.exit(exitCode);
+        }
       }
     ).option("verbose", {
       type: "boolean",
@@ -860,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);
 });