@kaiord/cli 0.1.1

package/README.md

@@ -0,0 +1,227 @@
+# @kaiord/cli
+
+Command-line interface for Kaiord workout file conversion. Convert workout files between FIT, KRD, TCX, and ZWO formats with ease.
+
+## Installation
+
+Install globally using npm or pnpm:
+
+```bash
+npm install -g @kaiord/cli
+```
+
+or
+
+```bash
+pnpm add -g @kaiord/cli
+```
+
+After installation, the `kaiord` command will be available globally.
+
+## Usage
+
+### Convert Command
+
+Convert workout files between different formats.
+
+#### Basic Usage
+
+```bash
+kaiord convert --input workout.fit --output workout.krd
+```
+
+#### FIT to KRD
+
+```bash
+kaiord convert --input workout.fit --output workout.krd
+```
+
+#### KRD to FIT
+
+```bash
+kaiord convert --input workout.krd --output workout.fit
+```
+
+#### Batch Conversion
+
+Convert multiple files using glob patterns:
+
+```bash
+kaiord convert --input "workouts/*.fit" --output-dir converted/
+```
+
+#### Format Override
+
+Override automatic format detection:
+
+```bash
+kaiord convert --input data.bin --input-format fit --output workout.krd
+```
+
+### Validate Command
+
+Perform round-trip validation to verify data integrity.
+
+#### Basic Validation
+
+```bash
+kaiord validate --input workout.fit
+```
+
+#### Custom Tolerances
+
+Use a custom tolerance configuration file:
+
+```bash
+kaiord validate --input workout.fit --tolerance-config tolerance.json
+```
+
+Example `tolerance.json`:
+
+```json
+{
+  "time": { "absolute": 1, "unit": "seconds" },
+  "power": { "absolute": 1, "percentage": 1, "unit": "watts" },
+  "heartRate": { "absolute": 1, "unit": "bpm" },
+  "cadence": { "absolute": 1, "unit": "rpm" }
+}
+```
+
+## Global Options
+
+### Verbosity Control
+
+```bash
+# Verbose output (detailed logging)
+kaiord convert --input workout.fit --output workout.krd --verbose
+
+# Quiet mode (errors only)
+kaiord convert --input workout.fit --output workout.krd --quiet
+```
+
+### Output Format
+
+```bash
+# JSON output (machine-readable)
+kaiord convert --input workout.fit --output workout.krd --json
+
+# Force pretty terminal output
+kaiord convert --input workout.fit --output workout.krd --log-format pretty
+
+# Force structured JSON logs
+kaiord convert --input workout.fit --output workout.krd --log-format json
+```
+
+## Environment Variables
+
+The CLI automatically detects the environment and adjusts its behavior:
+
+- **CI=true**: Enables structured JSON logging
+- **NODE_ENV=production**: Enables structured JSON logging
+- **TTY detection**: Automatically disables colors and spinners in non-interactive environments
+
+## Supported Formats
+
+- **FIT** (.fit) - Garmin's binary workout file format
+- **KRD** (.krd) - Kaiord's canonical JSON format
+- **TCX** (.tcx) - Training Center XML format
+- **ZWO** (.zwo) - Zwift workout XML format
+
+## Exit Codes
+
+- **0**: Success
+- **1**: Error (invalid arguments, file not found, parsing error, validation error)
+
+## Troubleshooting
+
+### File Not Found
+
+Ensure the input file path is correct and the file exists:
+
+```bash
+ls -la workout.fit
+kaiord convert --input workout.fit --output workout.krd
+```
+
+### Permission Errors
+
+Check file permissions:
+
+```bash
+chmod 644 workout.fit
+kaiord convert --input workout.fit --output workout.krd
+```
+
+### Format Detection Issues
+
+If automatic format detection fails, use explicit format flags:
+
+```bash
+kaiord convert --input data.bin --input-format fit --output workout.krd --output-format krd
+```
+
+### Corrupted Files
+
+If a file is corrupted, the CLI will display a descriptive error message:
+
+```bash
+kaiord convert --input corrupted.fit --output workout.krd
+# Error: Failed to parse FIT file
+# Details: Corrupted file header
+```
+
+## Testing
+
+Run the test suites:
+
+```bash
+# Run all tests
+pnpm test
+
+# Run unit tests only
+pnpm test:unit
+
+# Run integration tests
+pnpm test:integration
+
+# Run smoke tests
+pnpm test:smoke
+
+# Run tests in watch mode
+pnpm test:watch
+```
+
+## Development
+
+```bash
+# Install dependencies
+pnpm install
+
+# Build the CLI
+pnpm build
+
+# Run in development mode
+pnpm dev -- convert --input workout.fit --output workout.krd
+
+# Link for local testing
+npm link
+kaiord --version
+npm unlink -g
+```
+
+## Documentation
+
+For more information about the Kaiord project and the KRD format, see:
+
+- [Kaiord Core Library](https://github.com/your-org/kaiord/tree/main/packages/core)
+- [KRD Format Specification](https://github.com/your-org/kaiord/blob/main/docs/KRD_FORMAT.md)
+- [Contributing Guide](https://github.com/your-org/kaiord/blob/main/CONTRIBUTING.md)
+
+## License
+
+MIT - See [LICENSE](../../LICENSE) file for details.
+
+## Support
+
+- Report issues: [GitHub Issues](https://github.com/your-org/kaiord/issues)
+- Ask questions: [GitHub Discussions](https://github.com/your-org/kaiord/discussions)

package/dist/bin/kaiord.js

@@ -0,0 +1,884 @@
+#!/usr/bin/env node
+import {
+  isTTY
+} from "../chunk-TI3WVGXE.js";
+
+// src/bin/kaiord.ts
+import chalk3 from "chalk";
+import { readFileSync } from "fs";
+import { dirname as dirname2, join as join2 } from "path";
+import { fileURLToPath } from "url";
+import yargs from "yargs";
+import { hideBin } from "yargs/helpers";
+
+// src/commands/convert.ts
+import {
+  createDefaultProviders,
+  FitParsingError as FitParsingError2,
+  KrdValidationError as KrdValidationError2,
+  ToleranceExceededError as ToleranceExceededError2
+} from "@kaiord/core";
+import chalk2 from "chalk";
+import ora from "ora";
+import { basename, join } from "path";
+import { z as z2 } from "zod";
+
+// src/utils/error-formatter.ts
+import {
+  FitParsingError,
+  KrdValidationError,
+  ToleranceExceededError
+} from "@kaiord/core";
+import chalk 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:"
+  ];
+  for (const error of errors) {
+    const fieldPath = useColors ? chalk.yellow(error.field) : error.field;
+    const bullet = useColors ? chalk.red("\u2022") : "\u2022";
+    lines.push(`  ${bullet} ${fieldPath}: ${error.message}`);
+  }
+  return lines.join("\n");
+};
+var formatToleranceViolations = (violations) => {
+  if (violations.length === 0) {
+    return "";
+  }
+  const useColors = shouldUseColors();
+  const lines = [
+    useColors ? chalk.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 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)
+    ];
+    lines.push(
+      "",
+      useColors ? chalk.cyan("Suggestion:") : "Suggestion:",
+      "  The conversion may have lost precision.",
+      "  Consider adjusting tolerance values if the deviations are acceptable."
+    );
+    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 [
+    useColors ? chalk.red("\u2716 Error: An unexpected error occurred") : "\u2716 Error: An unexpected error occurred",
+    "",
+    useColors ? chalk.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
+    );
+  }
+  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 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 Error) {
+    return JSON.stringify(
+      {
+        success: false,
+        error: {
+          type: error.name || "Error",
+          message: error.message,
+          stack: error.stack
+        }
+      },
+      null,
+      2
+    );
+  }
+  return JSON.stringify(
+    {
+      success: false,
+      error: {
+        type: "UnknownError",
+        message: String(error)
+      }
+    },
+    null,
+    2
+  );
+};
+
+// 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) => {
+  try {
+    if (format === "fit") {
+      const buffer = await fsReadFile(path);
+      return new Uint8Array(buffer);
+    } else {
+      return await fsReadFile(path, "utf-8");
+    }
+  } 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}`);
+      }
+    }
+    throw new Error(`Failed to read file: ${path}`);
+  }
+};
+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}`);
+      }
+    }
+    if (error instanceof Error && error.message.includes("require")) {
+      throw error;
+    }
+    throw new Error(`Failed to write file: ${path}`);
+  }
+};
+var findFiles = async (pattern) => {
+  const files = await glob(pattern, {
+    nodir: true,
+    absolute: false
+  });
+  return files.sort();
+};
+
+// 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/utils/logger-factory.ts
+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 } = await import("../structured-logger-HMEQGEES.js");
+    return createStructuredLogger(options);
+  } else {
+    const { createPrettyLogger } = await import("../pretty-logger-P2OWMOGW.js");
+    return createPrettyLogger(options);
+  }
+};
+
+// 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");
+    }
+    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 validatedOptions = convertOptionsSchema.parse(options);
+  const logger = await createLogger({
+    type: validatedOptions.logFormat,
+    level: validatedOptions.verbose ? "debug" : validatedOptions.quiet ? "error" : "info",
+    quiet: validatedOptions.quiet
+  });
+  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({
+            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);
+      }
+    } 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;
+      }
+    }
+  } catch (error) {
+    logger.error("Conversion failed", { error });
+    const formattedError = formatError(error, {
+      json: validatedOptions.json
+    });
+    if (validatedOptions.json) {
+      console.log(formattedError);
+    } 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);
+  }
+};
+
+// src/commands/validate.ts
+import {
+  createDefaultProviders as createDefaultProviders2,
+  createToleranceChecker,
+  toleranceConfigSchema,
+  validateRoundTrip
+} from "@kaiord/core";
+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()
+});
+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
+  });
+  try {
+    const format = detectFormat(opts.input);
+    if (!format) {
+      throw new Error(`Unable to detect format from file: ${opts.input}`);
+    }
+    if (format !== "fit") {
+      throw new Error(
+        `Validation currently only supports FIT files. Got: ${format}`
+      );
+    }
+    logger.debug("Reading input file", { path: opts.input, format });
+    const inputData = await readFile(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", {
+        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", {
+        config: toleranceConfig
+      });
+    }
+    const providers = createDefaultProviders2(logger);
+    const toleranceChecker = toleranceConfig ? createToleranceChecker(toleranceConfig) : providers.toleranceChecker;
+    const roundTripValidator = validateRoundTrip(
+      providers.fitReader,
+      providers.fitWriter,
+      toleranceChecker,
+      logger
+    );
+    const spinner = opts.quiet || opts.json ? null : ora2("Validating round-trip conversion...").start();
+    logger.info("Starting round-trip validation", { file: opts.input });
+    const violations = await roundTripValidator.validateFitToKrdToFit({
+      originalFit: inputData
+    });
+    if (spinner) {
+      if (violations.length === 0) {
+        spinner.succeed("Validation complete - no tolerance violations");
+      } else {
+        spinner.fail(
+          `Validation failed - ${violations.length} tolerance violation(s)`
+        );
+      }
+    }
+    if (violations.length === 0) {
+      logger.info("Round-trip validation passed");
+      if (opts.json) {
+        console.log(
+          JSON.stringify(
+            {
+              success: true,
+              file: opts.input,
+              format,
+              violations: []
+            },
+            null,
+            2
+          )
+        );
+      } else if (!opts.quiet) {
+        console.log("\u2713 Round-trip validation passed");
+      }
+      process.exit(0);
+    } else {
+      logger.warn("Round-trip validation failed", {
+        violationCount: violations.length
+      });
+      if (opts.json) {
+        console.log(
+          JSON.stringify(
+            {
+              success: false,
+              file: opts.input,
+              format,
+              violations
+            },
+            null,
+            2
+          )
+        );
+      } else {
+        console.error("\u2716 Round-trip validation failed\n");
+        console.error(formatToleranceViolations(violations));
+      }
+      process.exit(1);
+    }
+  } catch (error) {
+    logger.error("Validation failed", { error });
+    if (opts.json) {
+      console.log(
+        JSON.stringify(
+          {
+            success: false,
+            error: formatError(error, { json: true })
+          },
+          null,
+          2
+        )
+      );
+    } else {
+      console.error(formatError(error, { json: false }));
+    }
+    process.exit(1);
+  }
+};
+
+// src/bin/kaiord.ts
+var __filename2 = fileURLToPath(import.meta.url);
+var __dirname2 = dirname2(__filename2);
+var packageJsonPath = __dirname2.includes("/dist") ? join2(__dirname2, "../../package.json") : join2(__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",
+      (yargs2) => {
+        return yargs2.option("input", {
+          alias: "i",
+          type: "string",
+          description: "Input file path or glob pattern",
+          demandOption: true
+        }).option("output", {
+          alias: "o",
+          type: "string",
+          description: "Output file path"
+        }).option("output-dir", {
+          type: "string",
+          description: "Output directory for batch conversion"
+        }).option("input-format", {
+          type: "string",
+          choices: ["fit", "krd", "tcx", "zwo"],
+          description: "Override input format detection"
+        }).option("output-format", {
+          type: "string",
+          choices: ["fit", "krd", "tcx", "zwo"],
+          description: "Override output format detection"
+        }).example(
+          "$0 convert -i workout.fit -o workout.krd",
+          "Convert FIT to KRD"
+        ).example(
+          "$0 convert -i workout.krd -o workout.fit",
+          "Convert KRD to FIT"
+        ).example(
+          '$0 convert -i "workouts/*.fit" --output-dir converted/',
+          "Batch convert all FIT files"
+        );
+      },
+      async (argv) => {
+        await convertCommand({
+          input: argv.input,
+          output: argv.output,
+          outputDir: argv.outputDir,
+          inputFormat: argv.inputFormat,
+          outputFormat: argv.outputFormat,
+          verbose: argv.verbose,
+          quiet: argv.quiet,
+          json: argv.json,
+          logFormat: argv.logFormat
+        });
+      }
+    ).command(
+      "validate",
+      "Validate round-trip conversion of workout files",
+      (yargs2) => {
+        return yargs2.option("input", {
+          alias: "i",
+          type: "string",
+          description: "Input file path",
+          demandOption: true
+        }).option("tolerance-config", {
+          type: "string",
+          description: "Path to custom tolerance configuration JSON"
+        }).example(
+          "$0 validate -i workout.fit",
+          "Validate round-trip conversion"
+        ).example(
+          "$0 validate -i workout.fit --tolerance-config custom.json",
+          "Validate with custom tolerances"
+        );
+      },
+      async (argv) => {
+        await validateCommand({
+          input: argv.input,
+          toleranceConfig: argv.toleranceConfig,
+          verbose: argv.verbose,
+          quiet: argv.quiet,
+          json: argv.json,
+          logFormat: argv.logFormat
+        });
+      }
+    ).option("verbose", {
+      type: "boolean",
+      description: "Enable verbose logging",
+      global: true
+    }).option("quiet", {
+      type: "boolean",
+      description: "Suppress all output except errors",
+      global: true
+    }).option("json", {
+      type: "boolean",
+      description: "Output results in JSON format",
+      global: true
+    }).option("log-format", {
+      type: "string",
+      choices: ["pretty", "structured"],
+      description: "Force specific log format",
+      global: true
+    }).version(version).alias("version", "v").help().alias("help", "h").demandCommand(1, "You must specify a command").strict().parse();
+  } catch (error) {
+    const formattedError = formatError(error, { json: false });
+    console.error(formattedError);
+    if (error && typeof error === "object" && "name" in error) {
+      const errorName = error.name;
+      if (errorName === "FitParsingError") {
+        process.exit(4);
+      } else if (errorName === "KrdValidationError") {
+        process.exit(5);
+      } else if (errorName === "ToleranceExceededError") {
+        process.exit(6);
+      }
+    }
+    process.exit(99);
+  }
+};
+process.on("unhandledRejection", (reason) => {
+  console.error("Unhandled rejection:", reason);
+  process.exit(99);
+});
+process.on("uncaughtException", (error) => {
+  console.error("Uncaught exception:", error);
+  process.exit(99);
+});
+main().catch((error) => {
+  console.error("Fatal error:", error);
+  process.exit(99);
+});

package/dist/chunk-TI3WVGXE.js

@@ -0,0 +1,10 @@
+#!/usr/bin/env node
+
+// src/utils/is-tty.ts
+var isTTY = () => {
+  return process.stdout.isTTY === true;
+};
+
+export {
+  isTTY
+};

package/dist/pretty-logger-P2OWMOGW.js

@@ -0,0 +1,58 @@
+#!/usr/bin/env node
+import {
+  isTTY
+} from "./chunk-TI3WVGXE.js";
+
+// src/adapters/logger/pretty-logger.ts
+import chalk from "chalk";
+var 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 ? chalk.gray(contextStr) : contextStr);
+  };
+  return {
+    debug: (message, context) => {
+      if (shouldLog("debug")) {
+        const formatted = `\u{1F41B} ${message}${formatContext(context)}`;
+        console.log(useColors ? chalk.gray(formatted) : formatted);
+      }
+    },
+    info: (message, context) => {
+      if (shouldLog("info")) {
+        const formatted = `\u2139 ${message}${formatContext(context)}`;
+        console.log(useColors ? chalk.blue(formatted) : formatted);
+      }
+    },
+    warn: (message, context) => {
+      if (shouldLog("warn")) {
+        const formatted = `\u26A0 ${message}${formatContext(context)}`;
+        console.warn(useColors ? chalk.yellow(formatted) : formatted);
+      }
+    },
+    error: (message, context) => {
+      if (shouldLog("error")) {
+        const formatted = `\u2716 ${message}${formatContext(context)}`;
+        console.error(useColors ? chalk.red(formatted) : formatted);
+      }
+    }
+  };
+};
+export {
+  createPrettyLogger
+};

package/dist/structured-logger-HMEQGEES.js

@@ -0,0 +1,37 @@
+#!/usr/bin/env node
+
+// src/adapters/logger/structured-logger.ts
+import winston from "winston";
+var 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);
+    }
+  };
+};
+export {
+  createStructuredLogger
+};

package/package.json

@@ -0,0 +1,70 @@
+{
+  "name": "@kaiord/cli",
+  "version": "0.1.1",
+  "description": "Command-line interface for Kaiord workout file conversion",
+  "type": "module",
+  "bin": {
+    "kaiord": "./dist/bin/kaiord.js"
+  },
+  "files": [
+    "dist",
+    "README.md",
+    "LICENSE"
+  ],
+  "scripts": {
+    "build": "tsup",
+    "test": "vitest run",
+    "test:unit": "vitest run --exclude '**/*-{integration,smoke,snapshot}.test.ts'",
+    "test:integration": "vitest run src/commands/convert-integration.test.ts src/commands/validate-integration.test.ts",
+    "test:smoke": "vitest run src/tests/cli-smoke.test.ts",
+    "test:watch": "vitest",
+    "dev": "tsx src/bin/kaiord.ts",
+    "prepublishOnly": "pnpm build && pnpm test",
+    "check-licenses": "license-checker --onlyAllow 'MIT;Apache-2.0;BSD;BSD-2-Clause;BSD-3-Clause;ISC' --production"
+  },
+  "keywords": [
+    "kaiord",
+    "fit",
+    "tcx",
+    "zwo",
+    "workout",
+    "garmin",
+    "zwift",
+    "cli",
+    "converter"
+  ],
+  "author": "Kaiord Contributors",
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/your-org/kaiord.git",
+    "directory": "packages/cli"
+  },
+  "homepage": "https://www.npmjs.com/package/@kaiord/cli",
+  "bugs": {
+    "url": "https://github.com/your-org/kaiord/issues"
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "dependencies": {
+    "@kaiord/core": "workspace:*",
+    "chalk": "^5.3.0",
+    "glob": "^10.3.10",
+    "ora": "^8.0.1",
+    "winston": "^3.11.0",
+    "yargs": "^17.7.2",
+    "zod": "^3.22.4"
+  },
+  "devDependencies": {
+    "@types/yargs": "^17.0.32",
+    "execa": "^8.0.1",
+    "license-checker": "^25.0.1",
+    "strip-ansi": "^7.1.0",
+    "tmp-promise": "^3.0.3",
+    "tsup": "^8.0.1",
+    "tsx": "^4.7.0",
+    "typescript": "^5.3.3",
+    "vitest": "^1.2.0"
+  }
+}