Add precision formatting to converters and compare CLI command

playground/bin/cli.js

@@ -1,12 +1,51 @@
 #!/usr/bin/env node
-import { convert } from "../src/convert.js";
+import { convert, compare } from "../src/convert.js";
 
-const [,, type, value, from, to] = process.argv;
+const [,, command, ...args] = process.argv;
 
-if (!type || !value) {
+if (!command) {
   console.error("Usage: convert <type> <value> [from] [to]");
+  console.error("   or: convert compare <value1> <unit1> <value2> <unit2>");
   process.exit(1);
 }
 
-const result = convert(type, Number(value), from, to);
-console.log(result);
+if (command === "compare") {
+  if (args.length < 4) {
+    console.error("Usage: convert compare <value1> <unit1> <value2> <unit2>");
+    console.error("Example: convert compare 5 km 3 mi");
+    process.exit(1);
+  }
+
+  const [value1, unit1, value2, unit2] = args;
+  try {
+    const result = compare(Number(value1), unit1, Number(value2), unit2);
+
+    console.log(`Comparison (${result.type}):`);
+    console.log(`  ${result.value1.value} ${result.value1.unit} = ${result.value1.converted} ${result.commonUnit}`);
+    console.log(`  ${result.value2.value} ${result.value2.unit} = ${result.value2.converted} ${result.commonUnit}`);
+    console.log(`  Difference: ${result.difference} ${result.commonUnit}`);
+    if (result.isEqual) {
+      console.log(`  Values are equal`);
+    } else {
+      console.log(`  ${result.larger.value} ${result.larger.unit} is larger`);
+    }
+  } catch (error) {
+    console.error(`Error: ${error.message}`);
+    process.exit(1);
+  }
+} else {
+  const [value, from, to] = args;
+
+  if (!value) {
+    console.error("Usage: convert <type> <value> [from] [to]");
+    process.exit(1);
+  }
+
+  try {
+    const result = convert(command, Number(value), from, to);
+    console.log(result);
+  } catch (error) {
+    console.error(`Error: ${error.message}`);
+    process.exit(1);
+  }
+}

playground/src/convert.js

@@ -11,19 +11,98 @@ const defaults = JSON.parse(
   readFileSync(join(__dirname, "../config/defaults.json"), "utf-8")
 );
 
+function roundToPrecision(value, precision) {
+  return Math.round(value * Math.pow(10, precision)) / Math.pow(10, precision);
+}
+
+function detectTypeFromUnit(unit) {
+  const distanceUnits = ["km", "mi"];
+  const weightUnits = ["g", "oz"];
+  const temperatureUnits = ["C", "F"];
+
+  if (distanceUnits.includes(unit)) return "distance";
+  if (weightUnits.includes(unit)) return "weight";
+  if (temperatureUnits.includes(unit)) return "temperature";
+  throw new Error(`Unknown unit: ${unit}`);
+}
+
+function getCommonUnit(type) {
+  switch (type) {
+    case "distance":
+      return "km";
+    case "weight":
+      return "g";
+    case "temperature":
+      return "C";
+    default:
+      throw new Error(`Unknown type: ${type}`);
+  }
+}
+
+export function compare(value1, unit1, value2, unit2) {
+  const type1 = detectTypeFromUnit(unit1);
+  const type2 = detectTypeFromUnit(unit2);
+
+  if (type1 !== type2) {
+    throw new Error(`Cannot compare ${unit1} (${type1}) with ${unit2} (${type2})`);
+  }
+
+  const type = type1;
+  const commonUnit = getCommonUnit(type);
+
+  // Convert both values to common unit
+  let converted1 = value1;
+  let converted2 = value2;
+
+  if (unit1 !== commonUnit) {
+    converted1 = convert(type, value1, unit1, commonUnit);
+  }
+  if (unit2 !== commonUnit) {
+    converted2 = convert(type, value2, unit2, commonUnit);
+  }
+
+  const rounded1 = roundToPrecision(converted1, defaults.precision);
+  const rounded2 = roundToPrecision(converted2, defaults.precision);
+  const difference = Math.abs(rounded1 - rounded2);
+  const isEqual = difference === 0;
+
+  const larger = rounded1 > rounded2 ? { value: value1, unit: unit1, converted: rounded1 } 
+                                      : rounded2 > rounded1 ? { value: value2, unit: unit2, converted: rounded2 }
+                                      : null;
+  const smaller = rounded1 < rounded2 ? { value: value1, unit: unit1, converted: rounded1 }
+                                      : rounded2 < rounded1 ? { value: value2, unit: unit2, converted: rounded2 }
+                                      : null;
+
+  return {
+    type,
+    value1: { value: value1, unit: unit1, converted: rounded1 },
+    value2: { value: value2, unit: unit2, converted: rounded2 },
+    commonUnit,
+    difference: roundToPrecision(difference, defaults.precision),
+    isEqual,
+    larger,
+    smaller
+  };
+}
+
 export function convert(type, value, from, to) {
+  let result;
   switch (type) {
     case "temperature":
-      return temperature.convertTemperature(
+      result = temperature.convertTemperature(
         value,
         from || defaults.temperature.defaultFrom,
         to || defaults.temperature.defaultTo
       );
+      break;
     case "distance":
-      return distance.convertDistance(value, from, to);
+      result = distance.convertDistance(value, from, to);
+      break;
     case "weight":
-      return weight.convertWeight(value, from, to);
+      result = weight.convertWeight(value, from, to);
+      break;
     default:
       throw new Error("Unknown type " + type);
   }
+  return roundToPrecision(result, defaults.precision);
 }