@kaiord/cli 0.1.1 → 1.0.0

package/README.md

@@ -87,6 +87,62 @@ Example `tolerance.json`:
 }
 ```
 
+## Configuration File
+
+You can create a `.kaiordrc.json` file to set default options. The CLI will search for this file in:
+
+1. Current working directory
+2. User home directory (`~/.kaiordrc.json`)
+
+CLI options always take precedence over config file defaults.
+
+### Example Configuration
+
+Create `.kaiordrc.json` in your project or home directory:
+
+```json
+{
+  "defaultInputFormat": "fit",
+  "defaultOutputFormat": "krd",
+  "defaultOutputDir": "./converted",
+  "defaultToleranceConfig": "./tolerance.json",
+  "verbose": false,
+  "quiet": false,
+  "json": false,
+  "logFormat": "pretty"
+}
+```
+
+### Configuration Options
+
+- **defaultInputFormat**: Default input format (`fit`, `krd`, `tcx`, `zwo`)
+- **defaultOutputFormat**: Default output format (`fit`, `krd`, `tcx`, `zwo`)
+- **defaultOutputDir**: Default output directory for batch conversions
+- **defaultToleranceConfig**: Path to default tolerance configuration file
+- **verbose**: Enable verbose logging by default
+- **quiet**: Enable quiet mode by default
+- **json**: Enable JSON output by default
+- **logFormat**: Default log format (`pretty` or `structured`)
+
+### Usage with Config File
+
+With a config file, you can simplify your commands:
+
+```bash
+# Without config file
+kaiord convert --input workout.fit --output workout.krd --output-format krd
+
+# With config file (defaultOutputFormat: "krd")
+kaiord convert --input workout.fit --output workout.krd
+```
+
+CLI options override config defaults:
+
+```bash
+# Config has verbose: true, but --quiet overrides it
+kaiord convert --input workout.fit --output workout.krd --quiet
+```
+
 ## Global Options
 
 ### Verbosity Control
@@ -112,14 +168,6 @@ kaiord convert --input workout.fit --output workout.krd --log-format pretty
 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
@@ -127,47 +175,63 @@ The CLI automatically detects the environment and adjusts its behavior:
 - **TCX** (.tcx) - Training Center XML format
 - **ZWO** (.zwo) - Zwift workout XML format
 
-## Exit Codes
+### Plugin System (Future Enhancement)
 
-- **0**: Success
-- **1**: Error (invalid arguments, file not found, parsing error, validation error)
+The CLI is designed with a plugin architecture that will allow third-party developers to add support for custom workout file formats without modifying the core library. See [Plugin Architecture Documentation](./docs/plugin-architecture.md) for details on the design.
 
-## Troubleshooting
+**Planned Features:**
 
-### File Not Found
+- Dynamic plugin discovery and loading
+- Type-safe plugin interface
+- Automatic format detection for plugin formats
+- Plugin configuration via `.kaiordrc.json`
+- Plugin management commands (`kaiord plugins list`, `install`, etc.)
 
-Ensure the input file path is correct and the file exists:
+**Example Plugin Usage (Future):**
 
 ```bash
-ls -la workout.fit
-kaiord convert --input workout.fit --output workout.krd
+# Install a plugin
+npm install -g @kaiord/plugin-gpx
+
+# Use plugin format
+kaiord convert --input workout.gpx --output workout.krd
 ```
 
-### Permission Errors
+See [Example GPX Plugin](./docs/example-plugin-gpx.md) for a complete plugin implementation example.
 
-Check file permissions:
+## Exit Codes
 
-```bash
-chmod 644 workout.fit
-kaiord convert --input workout.fit --output workout.krd
-```
+- **0**: Success
+- **1**: Error (invalid arguments, file not found, parsing error, validation error)
 
-### Format Detection Issues
+## Documentation
 
-If automatic format detection fails, use explicit format flags:
+### Main Documentation
 
-```bash
-kaiord convert --input data.bin --input-format fit --output workout.krd --output-format krd
-```
+- **[Getting Started](../../docs/getting-started.md)** - Installation and basic usage
+- **[KRD Format Specification](../../docs/krd-format.md)** - Complete format documentation
+- **[Deployment Guide](../../docs/deployment.md)** - CI/CD and npm publishing
+
+### Package-Specific Documentation
 
-### Corrupted Files
+- **[npm Publish Verification](./docs/npm-publish-verification.md)** - Publishing checklist and verification
 
-If a file is corrupted, the CLI will display a descriptive error message:
+## Development
 
 ```bash
-kaiord convert --input corrupted.fit --output workout.krd
-# Error: Failed to parse FIT file
-# Details: Corrupted file header
+# 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
 ```
 
 ## Testing
@@ -191,37 +255,6 @@ pnpm test:smoke
 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

@@ -1,29 +1,232 @@
 #!/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 chalk2 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 ? chalk2.gray(contextStr) : contextStr);
+      };
+      return {
+        debug: (message, context) => {
+          if (shouldLog("debug")) {
+            const formatted = `\u{1F41B} ${message}${formatContext(context)}`;
+            console.log(useColors ? chalk2.gray(formatted) : formatted);
+          }
+        },
+        info: (message, context) => {
+          if (shouldLog("info")) {
+            const formatted = `\u2139 ${message}${formatContext(context)}`;
+            console.log(useColors ? chalk2.blue(formatted) : formatted);
+          }
+        },
+        warn: (message, context) => {
+          if (shouldLog("warn")) {
+            const formatted = `\u26A0 ${message}${formatContext(context)}`;
+            console.warn(useColors ? chalk2.yellow(formatted) : formatted);
+          }
+        },
+        error: (message, context) => {
+          if (shouldLog("error")) {
+            const formatted = `\u2716 ${message}${formatContext(context)}`;
+            console.error(useColors ? chalk2.red(formatted) : formatted);
+          }
+        }
+      };
+    };
+  }
+});
 
 // src/bin/kaiord.ts
-import chalk3 from "chalk";
+init_esm_shims();
+import chalk5 from "chalk";
 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();
 import {
   createDefaultProviders,
   FitParsingError as FitParsingError2,
   KrdValidationError as KrdValidationError2,
   ToleranceExceededError as ToleranceExceededError2
 } from "@kaiord/core";
-import chalk2 from "chalk";
+import chalk3 from "chalk";
 import ora from "ora";
-import { basename, join } from "path";
+import { basename, join as join2 } from "path";
+import { z as z3 } from "zod";
+
+// 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 loadConfig = 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;
+    } catch (error) {
+      continue;
+    }
+  }
+  return {};
+};
+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();
+init_is_tty();
 import {
   FitParsingError,
   KrdValidationError,
@@ -218,6 +421,7 @@ var formatErrorAsJson = (error) => {
 };
 
 // src/utils/file-handler.ts
+init_esm_shims();
 import {
   readFile as fsReadFile,
   writeFile as fsWriteFile,
@@ -225,51 +429,51 @@ import {
 } from "fs/promises";
 import { glob } from "glob";
 import { dirname } from "path";
-var readFile = async (path, format) => {
+var readFile2 = async (path2, format) => {
   try {
     if (format === "fit") {
-      const buffer = await fsReadFile(path);
+      const buffer = await fsReadFile(path2);
       return new Uint8Array(buffer);
     } else {
-      return await fsReadFile(path, "utf-8");
+      return await fsReadFile(path2, "utf-8");
     }
   } catch (error) {
     if (error instanceof Error && "code" in error) {
       if (error.code === "ENOENT") {
-        throw new Error(`File not found: ${path}`);
+        throw new Error(`File not found: ${path2}`);
       }
       if (error.code === "EACCES") {
-        throw new Error(`Permission denied: ${path}`);
+        throw new Error(`Permission denied: ${path2}`);
       }
     }
-    throw new Error(`Failed to read file: ${path}`);
+    throw new Error(`Failed to read file: ${path2}`);
   }
 };
-var writeFile = async (path, data, format) => {
+var writeFile = async (path2, data, format) => {
   try {
-    const dir = dirname(path);
+    const dir = dirname(path2);
     await mkdir(dir, { recursive: true });
     if (format === "fit") {
       if (!(data instanceof Uint8Array)) {
         throw new Error("FIT files require Uint8Array data");
       }
-      await fsWriteFile(path, data);
+      await fsWriteFile(path2, data);
     } else {
       if (typeof data !== "string") {
         throw new Error("Text files require string data");
       }
-      await fsWriteFile(path, data, "utf-8");
+      await fsWriteFile(path2, data, "utf-8");
     }
   } catch (error) {
     if (error instanceof Error && "code" in error) {
       if (error.code === "EACCES") {
-        throw new Error(`Permission denied: ${path}`);
+        throw new Error(`Permission denied: ${path2}`);
       }
     }
     if (error instanceof Error && error.message.includes("require")) {
       throw error;
     }
-    throw new Error(`Failed to write file: ${path}`);
+    throw new Error(`Failed to write file: ${path2}`);
   }
 };
 var findFiles = async (pattern) => {
@@ -280,53 +484,39 @@ var findFiles = async (pattern) => {
   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
+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 } = await import("../structured-logger-HMEQGEES.js");
-    return createStructuredLogger(options);
+    const { createStructuredLogger: createStructuredLogger2 } = await Promise.resolve().then(() => (init_structured_logger(), structured_logger_exports));
+    return createStructuredLogger2(options);
   } else {
-    const { createPrettyLogger } = await import("../pretty-logger-P2OWMOGW.js");
-    return createPrettyLogger(options);
+    const { createPrettyLogger: createPrettyLogger2 } = await Promise.resolve().then(() => (init_pretty_logger(), pretty_logger_exports));
+    return createPrettyLogger2(options);
   }
 };
 
 // src/commands/convert.ts
-var convertOptionsSchema = z2.object({
-  input: z2.string(),
-  output: z2.string().optional(),
-  outputDir: z2.string().optional(),
+var convertOptionsSchema = z3.object({
+  input: z3.string(),
+  output: z3.string().optional(),
+  outputDir: z3.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()
+  verbose: z3.boolean().optional(),
+  quiet: z3.boolean().optional(),
+  json: z3.boolean().optional(),
+  logFormat: z3.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);
+  const inputData = await readFile2(inputFile, inputFormat);
   let krd;
   if (inputFormat === "fit") {
     if (!(inputData instanceof Uint8Array)) {
@@ -366,7 +556,19 @@ var convertSingleFile = async (inputFile, outputFile, inputFormat, outputFormat,
   await writeFile(outputFile, outputData, outputFormat);
 };
 var convertCommand = async (options) => {
-  const validatedOptions = convertOptionsSchema.parse(options);
+  const config = await loadConfig();
+  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);
   const logger = await createLogger({
     type: validatedOptions.logFormat,
     level: validatedOptions.verbose ? "debug" : validatedOptions.quiet ? "error" : "info",
@@ -424,7 +626,7 @@ var convertCommand = async (options) => {
             /\.(fit|krd|tcx|zwo)$/i,
             `.${outputFormat}`
           );
-          const outputFile = join(validatedOptions.outputDir, outputFileName);
+          const outputFile = join2(validatedOptions.outputDir, outputFileName);
           await convertSingleFile(
             file,
             outputFile,
@@ -455,18 +657,18 @@ var convertCommand = async (options) => {
       if (!validatedOptions.json) {
         console.log("\nBatch conversion complete:");
         console.log(
-          chalk2.green(`  \u2713 Successful: ${successful.length}/${files.length}`)
+          chalk3.green(`  \u2713 Successful: ${successful.length}/${files.length}`)
         );
         if (failed.length > 0) {
           console.log(
-            chalk2.red(`  \u2717 Failed: ${failed.length}/${files.length}`)
+            chalk3.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:"));
+          console.log(chalk3.red("\nFailed conversions:"));
           for (const result of failed) {
-            console.log(chalk2.red(`  ${result.inputFile}: ${result.error}`));
+            console.log(chalk3.red(`  ${result.inputFile}: ${result.error}`));
           }
         }
       } else {
@@ -568,53 +770,354 @@ var convertCommand = async (options) => {
     } else {
       console.error(formattedError);
     }
-    let exitCode = 1;
+    let exitCode = 99;
     if (error instanceof Error) {
       if (error.message.includes("File not found")) {
-        exitCode = 1;
+        exitCode = 2;
       } else if (error.message.includes("Permission denied")) {
-        exitCode = 1;
+        exitCode = 3;
       } else if (error instanceof FitParsingError2) {
-        exitCode = 1;
+        exitCode = 4;
       } else if (error instanceof KrdValidationError2) {
-        exitCode = 1;
+        exitCode = 5;
       } else if (error instanceof ToleranceExceededError2) {
-        exitCode = 1;
+        exitCode = 6;
       } else if (error.name === "InvalidArgumentError") {
         exitCode = 1;
       }
     }
-    process.exit(exitCode);
+    return exitCode;
+  }
+  return 0;
+};
+
+// src/commands/diff.ts
+init_esm_shims();
+import { createDefaultProviders as createDefaultProviders2 } from "@kaiord/core";
+import chalk4 from "chalk";
+import { z as z4 } from "zod";
+var diffOptionsSchema = z4.object({
+  file1: z4.string(),
+  file2: z4.string(),
+  format1: fileFormatSchema.optional(),
+  format2: fileFormatSchema.optional(),
+  verbose: z4.boolean().optional(),
+  quiet: z4.boolean().optional(),
+  json: z4.boolean().optional(),
+  logFormat: z4.enum(["pretty", "structured"]).optional()
+});
+var loadFileAsKrd = async (filePath, format, providers) => {
+  const detectedFormat = format || detectFormat(filePath);
+  if (!detectedFormat) {
+    throw new Error(
+      `Unable to detect format for file: ${filePath}. Supported formats: .fit, .krd, .tcx, .zwo`
+    );
+  }
+  const fileData = await readFile2(filePath, detectedFormat);
+  let krd;
+  if (detectedFormat === "fit") {
+    if (!(fileData instanceof Uint8Array)) {
+      throw new Error("FIT input must be Uint8Array");
+    }
+    krd = await providers.convertFitToKrd({ fitBuffer: fileData });
+  } else if (detectedFormat === "tcx") {
+    if (typeof fileData !== "string") {
+      throw new Error("TCX input must be string");
+    }
+    krd = await providers.convertTcxToKrd({ tcxString: fileData });
+  } else if (detectedFormat === "zwo") {
+    if (typeof fileData !== "string") {
+      throw new Error("ZWO input must be string");
+    }
+    krd = await providers.convertZwiftToKrd({ zwiftString: fileData });
+  } else if (detectedFormat === "krd") {
+    if (typeof fileData !== "string") {
+      throw new Error("KRD input must be string");
+    }
+    krd = JSON.parse(fileData);
+  } else {
+    throw new Error(`Unsupported format: ${detectedFormat}`);
+  }
+  return krd;
+};
+var isDifferent = (value1, value2) => {
+  if (value1 === value2) return false;
+  if (value1 === null || value1 === void 0) return true;
+  if (value2 === null || value2 === void 0) return true;
+  if (typeof value1 === "object" && typeof value2 === "object") {
+    return JSON.stringify(value1) !== JSON.stringify(value2);
+  }
+  return value1 !== value2;
+};
+var compareMetadata = (krd1, krd2) => {
+  const differences = [];
+  const metadataFields = [
+    "created",
+    "manufacturer",
+    "product",
+    "serialNumber",
+    "sport",
+    "subSport"
+  ];
+  for (const field of metadataFields) {
+    const value1 = krd1.metadata[field];
+    const value2 = krd2.metadata[field];
+    if (isDifferent(value1, value2)) {
+      differences.push({
+        field,
+        file1Value: value1,
+        file2Value: value2
+      });
+    }
+  }
+  return differences;
+};
+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 (step1 && !step2) {
+      differences.push({
+        stepIndex: i,
+        field: "step",
+        file1Value: step1,
+        file2Value: void 0
+      });
+      continue;
+    }
+    if (!step1 || !step2) continue;
+    const stepFields = [
+      "stepIndex",
+      "name",
+      "durationType",
+      "duration",
+      "targetType",
+      "target",
+      "intensity",
+      "notes",
+      "equipment"
+    ];
+    for (const field of stepFields) {
+      const value1 = step1[field];
+      const value2 = step2[field];
+      if (isDifferent(value1, value2)) {
+        differences.push({
+          stepIndex: i,
+          field,
+          file1Value: value1,
+          file2Value: value2
+        });
+      }
+    }
+  }
+  return {
+    file1Count: steps1.length,
+    file2Count: steps2.length,
+    differences
+  };
+};
+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) {
+    const value1 = ext1[key];
+    const value2 = ext2[key];
+    if (isDifferent(value1, value2)) {
+      differences.push({
+        key,
+        file1Value: value1,
+        file2Value: value2
+      });
+    }
+  }
+  return {
+    file1Keys: keys1,
+    file2Keys: keys2,
+    differences
+  };
+};
+var formatDiffPretty = (result, file1, file2) => {
+  if (result.identical) {
+    return chalk4.green("\u2713 Files are identical");
+  }
+  const lines = [];
+  lines.push(chalk4.yellow(`
+Comparing: ${file1} vs ${file2}
+`));
+  if (result.metadataDiff && result.metadataDiff.length > 0) {
+    lines.push(chalk4.bold("Metadata Differences:"));
+    for (const diff of result.metadataDiff) {
+      lines.push(
+        `  ${chalk4.cyan(diff.field)}:`,
+        `    ${chalk4.red("-")} ${JSON.stringify(diff.file1Value)}`,
+        `    ${chalk4.green("+")} ${JSON.stringify(diff.file2Value)}`
+      );
+    }
+    lines.push("");
+  }
+  if (result.stepsDiff && result.stepsDiff.differences.length > 0) {
+    lines.push(chalk4.bold("Workout Steps Differences:"));
+    lines.push(
+      `  Step count: ${result.stepsDiff.file1Count} vs ${result.stepsDiff.file2Count}`
+    );
+    for (const diff of result.stepsDiff.differences) {
+      lines.push(
+        `  Step ${diff.stepIndex} - ${chalk4.cyan(diff.field)}:`,
+        `    ${chalk4.red("-")} ${JSON.stringify(diff.file1Value)}`,
+        `    ${chalk4.green("+")} ${JSON.stringify(diff.file2Value)}`
+      );
+    }
+    lines.push("");
+  }
+  if (result.extensionsDiff && result.extensionsDiff.differences.length > 0) {
+    lines.push(chalk4.bold("Extensions Differences:"));
+    lines.push(
+      `  Keys in file1: ${result.extensionsDiff.file1Keys.join(", ")}`,
+      `  Keys in file2: ${result.extensionsDiff.file2Keys.join(", ")}`
+    );
+    for (const diff of result.extensionsDiff.differences) {
+      lines.push(
+        `  ${chalk4.cyan(diff.key)}:`,
+        `    ${chalk4.red("-")} ${JSON.stringify(diff.file1Value)}`,
+        `    ${chalk4.green("+")} ${JSON.stringify(diff.file2Value)}`
+      );
+    }
+    lines.push("");
+  }
+  return lines.join("\n");
+};
+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
+  });
+  try {
+    const providers = createDefaultProviders2(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,
+            file1: validatedOptions.file1,
+            file2: validatedOptions.file2,
+            ...result
+          },
+          null,
+          2
+        )
+      );
+    } else {
+      const output = formatDiffPretty(
+        result,
+        validatedOptions.file1,
+        validatedOptions.file2
+      );
+      console.log(output);
+    }
+    return identical ? 0 : 1;
+  } catch (error) {
+    logger.error("Diff command failed", { error });
+    const formattedError = formatError(error, {
+      json: validatedOptions.json
+    });
+    if (validatedOptions.json) {
+      console.log(formattedError);
+    } else {
+      console.error(formattedError);
+    }
+    return 99;
   }
 };
 
 // src/commands/validate.ts
+init_esm_shims();
 import {
-  createDefaultProviders as createDefaultProviders2,
+  createDefaultProviders as createDefaultProviders3,
   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()
+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 config = await loadConfig();
+    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
+    });
     const format = detectFormat(opts.input);
     if (!format) {
       throw new Error(`Unable to detect format from file: ${opts.input}`);
@@ -624,24 +1127,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 = createDefaultProviders3(logger);
     const toleranceChecker = toleranceConfig ? createToleranceChecker(toleranceConfig) : providers.toleranceChecker;
     const roundTripValidator = validateRoundTrip(
       providers.fitReader,
@@ -649,8 +1152,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 : ora2("Validating round-trip conversion...").start();
+    logger?.info("Starting round-trip validation", { file: opts.input });
     const violations = await roundTripValidator.validateFitToKrdToFit({
       originalFit: inputData
     });
@@ -664,7 +1167,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(
@@ -683,7 +1186,7 @@ var validateCommand = async (options) => {
       }
       process.exit(0);
     } else {
-      logger.warn("Round-trip validation failed", {
+      logger?.warn("Round-trip validation failed", {
         violationCount: violations.length
       });
       if (opts.json) {
@@ -706,13 +1209,21 @@ var validateCommand = async (options) => {
       process.exit(1);
     }
   } 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
@@ -722,29 +1233,31 @@ var validateCommand = async (options) => {
       console.error(formatError(error, { json: false }));
     }
     process.exit(1);
+  } 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(`
+    chalk5.cyan(`
 \u2554\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2557
 \u2551                                                           \u2551
-\u2551   \u{1F47B} Built with Kiro AI during Kiroween Hackathon \u{1F47B}    \u2551
+\u2551   \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   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   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   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
@@ -794,7 +1307,7 @@ var main = async () => {
         );
       },
       async (argv) => {
-        await convertCommand({
+        const exitCode = await convertCommand({
           input: argv.input,
           output: argv.output,
           outputDir: argv.outputDir,
@@ -805,6 +1318,9 @@ var main = async () => {
           json: argv.json,
           logFormat: argv.logFormat
         });
+        if (exitCode !== 0) {
+          process.exit(exitCode);
+        }
       }
     ).command(
       "validate",
@@ -836,6 +1352,52 @@ var main = async () => {
           logFormat: argv.logFormat
         });
       }
+    ).command(
+      "diff",
+      "Compare two workout files and show differences",
+      (yargs2) => {
+        return yargs2.option("file1", {
+          type: "string",
+          description: "First file to compare",
+          demandOption: true
+        }).option("file2", {
+          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 !== 0 && exitCode !== 1) {
+          process.exit(exitCode);
+        }
+      }
     ).option("verbose", {
       type: "boolean",
       description: "Enable verbose logging",

package/dist/package.json

@@ -0,0 +1,3 @@
+{
+  "type": "module"
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@kaiord/cli",
-  "version": "0.1.1",
+  "version": "1.0.0",
   "description": "Command-line interface for Kaiord workout file conversion",
   "type": "module",
   "bin": {
@@ -13,12 +13,13 @@
   ],
   "scripts": {
     "build": "tsup",
-    "test": "vitest run",
+    "test": "pnpm build && 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:integration": "pnpm build && vitest run src/commands/convert-integration.test.ts src/commands/validate-integration.test.ts",
+    "test:smoke": "pnpm build && vitest run src/tests/cli-smoke.test.ts",
     "test:watch": "vitest",
     "dev": "tsx src/bin/kaiord.ts",
+    "prebuild": "echo 'Building CLI...'",
     "prepublishOnly": "pnpm build && pnpm test",
     "check-licenses": "license-checker --onlyAllow 'MIT;Apache-2.0;BSD;BSD-2-Clause;BSD-3-Clause;ISC' --production"
   },
@@ -37,18 +38,18 @@
   "license": "MIT",
   "repository": {
     "type": "git",
-    "url": "https://github.com/your-org/kaiord.git",
+    "url": "https://github.com/pablo-albaladejo/kaiord.git",
     "directory": "packages/cli"
   },
   "homepage": "https://www.npmjs.com/package/@kaiord/cli",
   "bugs": {
-    "url": "https://github.com/your-org/kaiord/issues"
+    "url": "https://github.com/pablo-albaladejo/kaiord/issues"
   },
   "publishConfig": {
     "access": "public"
   },
   "dependencies": {
-    "@kaiord/core": "workspace:*",
+    "@kaiord/core": "^1.0.0",
     "chalk": "^5.3.0",
     "glob": "^10.3.10",
     "ora": "^8.0.1",
@@ -62,7 +63,7 @@
     "license-checker": "^25.0.1",
     "strip-ansi": "^7.1.0",
     "tmp-promise": "^3.0.3",
-    "tsup": "^8.0.1",
+    "tsup": "^8.5.1",
     "tsx": "^4.7.0",
     "typescript": "^5.3.3",
     "vitest": "^1.2.0"

package/dist/chunk-TI3WVGXE.js

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

package/dist/pretty-logger-P2OWMOGW.js

@@ -1,58 +0,0 @@
-#!/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

@@ -1,37 +0,0 @@
-#!/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
-};