@cemalidev/trate 1.4.1

package/dist/index.js

@@ -0,0 +1,1587 @@
+#!/usr/bin/env node
+
+// src/index.ts
+import { program } from "commander";
+
+// src/config/config.ts
+import Conf from "conf";
+
+// src/i18n/tr.ts
+var tr = {
+  app: {
+    name: "trate",
+    tagline: "Terminal d\xF6viz kuru takip\xE7isi"
+  },
+  error: {
+    noConnection: "\u0130nternet ba\u011Flant\u0131n\u0131z\u0131 kontrol ediniz",
+    notFound: "bulunamad\u0131",
+    invalidCurrency: "Ge\xE7ersiz para birimi",
+    goldPricesUnavailable: "Alt\u0131n fiyatlar\u0131 \u015Fu anda mevcut de\u011Fil",
+    goldPricesLoadFailed: "Alt\u0131n fiyatlar\u0131 y\xFCklenemedi",
+    sameCurrency: "Ayn\u0131 para birimi d\xF6n\xFC\u015F\xFCm\xFC",
+    rateNotFound: "kuru bulunamad\u0131"
+  },
+  success: {
+    added: "Eklendi",
+    removed: "\xC7\u0131kar\u0131ld\u0131",
+    cacheCleared: "Cache temizlendi",
+    settingsReset: "Ayarlar s\u0131f\u0131rland\u0131",
+    baseCurrencySet: "Base para birimi"
+  },
+  ui: {
+    base: "Base",
+    rate: "Kur",
+    date: "Tarih",
+    type: "Tip",
+    symbol: "Sembol",
+    price: "Fiyat",
+    info: "Info",
+    tip: "\u0130pucu",
+    noConversionNeeded: "(d\xF6n\xFC\u015F\xFCme gerek yok)",
+    loading: "loading..."
+  },
+  commands: {
+    setBase: "set-base",
+    list: "list",
+    favs: "favs",
+    add: "add",
+    remove: "remove",
+    help: "help",
+    refresh: "refresh",
+    reset: "reset",
+    moon: "moon",
+    setLang: "set-lang"
+  },
+  dashboard: {
+    title: "Favoriler Panosu",
+    favorites: "Favoriler",
+    usage: "H\u0131zl\u0131 kur i\xE7in",
+    usageAdd: "Favori eklemek i\xE7in",
+    type: {
+      fiat: "FIAT",
+      crypto: "KR\u0130PTO",
+      metal: "METAL",
+      gold: "ALTIN"
+    }
+  },
+  help: {
+    usage: "Kullan\u0131m",
+    examples: "\xD6rnekler",
+    crypto: "Kripto",
+    metals: "Metaller",
+    jewelry: "Kuyumculuk",
+    config: "Ayarlar",
+    alias: "\xD6zel K\u0131sayollar",
+    aliasCreate: "K\u0131sayol olu\u015Ftur",
+    aliasView: "K\u0131sayollar\u0131 g\xF6r"
+  },
+  moon: {
+    toTheMoon: "Ay'a!",
+    goingToMoon: "AY'A G\u0130D\u0130YORUZ!",
+    tip: "G\xFCncel fiyatlar\u0131 g\xF6rmek i\xE7in"
+  },
+  display: {
+    goldOunce: "Alt\u0131n Ons",
+    goldKg: "Gram Alt\u0131n",
+    silverKg: "G\xFCm\xFC\u015F Kg",
+    silverOunce: "G\xFCm\xFC\u015F Ons",
+    quarterGold: "\xC7eyrek Alt\u0131n",
+    halfGold: "Yar\u0131m Alt\u0131n",
+    fullGold: "Tam Alt\u0131n",
+    ataGold: "Ata Alt\u0131n",
+    gremseGold: "Gremse Alt\u0131n"
+  },
+  cli: {
+    specifyCurrency: "Bir para birimi belirtin",
+    usage: "Kullan\u0131m",
+    invalidCommand: "Ge\xE7ersiz komut"
+  }
+};
+
+// src/i18n/en.ts
+var en = {
+  app: {
+    name: "trate",
+    tagline: "Terminal exchange rate tracker"
+  },
+  error: {
+    noConnection: "Check your internet connection",
+    notFound: "not found",
+    invalidCurrency: "Invalid currency",
+    goldPricesUnavailable: "Gold prices are currently unavailable",
+    goldPricesLoadFailed: "Failed to load gold prices",
+    sameCurrency: "Same currency conversion",
+    rateNotFound: "rate not found"
+  },
+  success: {
+    added: "Added",
+    removed: "Removed",
+    cacheCleared: "Cache cleared",
+    settingsReset: "Settings reset",
+    baseCurrencySet: "Base currency"
+  },
+  ui: {
+    base: "Base",
+    rate: "Rate",
+    date: "Date",
+    type: "Type",
+    symbol: "Symbol",
+    price: "Price",
+    info: "Info",
+    tip: "Tip",
+    noConversionNeeded: "(no conversion needed)",
+    loading: "loading..."
+  },
+  commands: {
+    setBase: "set-base",
+    list: "list",
+    favs: "favs",
+    add: "add",
+    remove: "remove",
+    help: "help",
+    refresh: "refresh",
+    reset: "reset",
+    moon: "moon",
+    setLang: "set-lang",
+    alias: "alias",
+    aliasAdd: "alias add",
+    aliasRemove: "alias remove",
+    aliasList: "alias list"
+  },
+  dashboard: {
+    title: "Favorites Dashboard",
+    favorites: "Favorites",
+    usage: "Use for quick rate",
+    usageAdd: "Use to add favorites",
+    type: {
+      fiat: "FIAT",
+      crypto: "CRYPTO",
+      metal: "METAL",
+      gold: "GOLD"
+    }
+  },
+  help: {
+    usage: "Usage",
+    examples: "Examples",
+    crypto: "Crypto",
+    metals: "Metals",
+    jewelry: "Jewelry",
+    config: "Config",
+    alias: "Custom Aliases",
+    aliasCreate: "Create shortcut",
+    aliasView: "View aliases"
+  },
+  moon: {
+    toTheMoon: "To The Moon!",
+    goingToMoon: "WE ARE GOING TO THE MOON!",
+    tip: "Use for current prices"
+  },
+  display: {
+    goldOunce: "Gold Ounce",
+    goldKg: "Gram Gold",
+    silverKg: "Silver Kg",
+    silverOunce: "Silver Ounce",
+    quarterGold: "Quarter Gold",
+    halfGold: "Half Gold",
+    fullGold: "Full Gold",
+    ataGold: "Ata Gold",
+    gremseGold: "Gremse Gold"
+  },
+  cli: {
+    specifyCurrency: "Specify a currency",
+    usage: "Usage",
+    invalidCommand: "Invalid command"
+  }
+};
+
+// src/i18n/de.ts
+var de = {
+  app: {
+    name: "trate",
+    tagline: "Terminal-W\xE4hrungsrechner"
+  },
+  error: {
+    noConnection: "\xDCberpr\xFCfen Sie Ihre Internetverbindung",
+    notFound: "nicht gefunden",
+    invalidCurrency: "Ung\xFCltige W\xE4hrung",
+    goldPricesUnavailable: "Goldpreise sind derzeit nicht verf\xFCgbar",
+    goldPricesLoadFailed: "Goldpreise konnten nicht geladen werden",
+    sameCurrency: "Gleiche W\xE4hrungsumrechnung",
+    rateNotFound: "Kurs nicht gefunden"
+  },
+  success: {
+    added: "Hinzugef\xFCgt",
+    removed: "Entfernt",
+    cacheCleared: "Cache geleert",
+    settingsReset: "Einstellungen zur\xFCckgesetzt",
+    baseCurrencySet: "Basisw\xE4hrung"
+  },
+  ui: {
+    base: "Basis",
+    rate: "Kurs",
+    date: "Datum",
+    type: "Typ",
+    symbol: "Symbol",
+    price: "Preis",
+    info: "Info",
+    tip: "Tipp",
+    noConversionNeeded: "(keine Konvertierung n\xF6tig)",
+    loading: "lade..."
+  },
+  commands: {
+    setBase: "set-base",
+    list: "list",
+    favs: "favs",
+    add: "add",
+    remove: "remove",
+    help: "help",
+    refresh: "refresh",
+    reset: "reset",
+    moon: "moon",
+    setLang: "set-lang"
+  },
+  dashboard: {
+    title: "Favoriten-Dashboard",
+    favorites: "Favoriten",
+    usage: "F\xFCr Schnellkurs verwenden",
+    usageAdd: "Zum Hinzuf\xFCgen von Favoriten",
+    type: {
+      fiat: "FIAT",
+      crypto: "Krypto",
+      metal: "METALL",
+      gold: "GOLD"
+    }
+  },
+  help: {
+    usage: "Verwendung",
+    examples: "Beispiele",
+    crypto: "Krypto",
+    metals: "Metalle",
+    jewelry: "Schmuck",
+    config: "Konfiguration",
+    alias: "Benutzerdefinierte Aliase",
+    aliasCreate: "Shortcut erstellen",
+    aliasView: "Aliase anzeigen"
+  },
+  moon: {
+    toTheMoon: "Zum Mond!",
+    goingToMoon: "WIR FLIEGEN ZUM MOND!",
+    tip: "F\xFCr aktuelle Preise verwenden"
+  },
+  display: {
+    goldOunce: "Gold Unze",
+    goldKg: "Gramm Gold",
+    silverKg: "Silber Kg",
+    silverOunce: "Silber Unze",
+    quarterGold: "Viertel Gold",
+    halfGold: "Halbes Gold",
+    fullGold: "Volles Gold",
+    ataGold: "Ata Gold",
+    gremseGold: "Gremse Gold"
+  },
+  cli: {
+    specifyCurrency: "Geben Sie eine W\xE4hrung an",
+    usage: "Verwendung",
+    invalidCommand: "Ung\xFCltiger Befehl"
+  }
+};
+
+// src/i18n/fr.ts
+var fr = {
+  app: {
+    name: "trate",
+    tagline: "Suivi des taux de change pour terminal"
+  },
+  error: {
+    noConnection: "V\xE9rifiez votre connexion internet",
+    notFound: "non trouv\xE9",
+    invalidCurrency: "Devise invalide",
+    goldPricesUnavailable: "Les prix de l'or ne sont actuellement pas disponibles",
+    goldPricesLoadFailed: "\xC9chec du chargement des prix de l'or",
+    sameCurrency: "Conversion de m\xEAme devise",
+    rateNotFound: "taux non trouv\xE9"
+  },
+  success: {
+    added: "Ajout\xE9",
+    removed: "Supprim\xE9",
+    cacheCleared: "Cache vid\xE9",
+    settingsReset: "Param\xE8tres r\xE9initialis\xE9s",
+    baseCurrencySet: "Devise de base"
+  },
+  ui: {
+    base: "Base",
+    rate: "Taux",
+    date: "Date",
+    type: "Type",
+    symbol: "Symbole",
+    price: "Prix",
+    info: "Info",
+    tip: "Astuce",
+    noConversionNeeded: "(pas de conversion n\xE9cessaire)",
+    loading: "chargement..."
+  },
+  commands: {
+    setBase: "set-base",
+    list: "list",
+    favs: "favs",
+    add: "add",
+    remove: "remove",
+    help: "help",
+    refresh: "refresh",
+    reset: "reset",
+    moon: "moon",
+    setLang: "set-lang"
+  },
+  dashboard: {
+    title: "Tableau de bord des favoris",
+    favorites: "Favoris",
+    usage: "Utiliser pour le taux rapide",
+    usageAdd: "Utiliser pour ajouter des favoris",
+    type: {
+      fiat: "FIAT",
+      crypto: "CRYPTO",
+      metal: "M\xC9TAUX",
+      gold: "OR"
+    }
+  },
+  help: {
+    usage: "Utilisation",
+    examples: "Exemples",
+    crypto: "Crypto",
+    metals: "M\xE9taux",
+    jewelry: "Bijouterie",
+    config: "Configuration",
+    alias: "Alias Personnalis\xE9s",
+    aliasCreate: "Cr\xE9er raccourci",
+    aliasView: "Voir alias"
+  },
+  moon: {
+    toTheMoon: "Vers la Lune!",
+    goingToMoon: "NOUS ALLONS VERS LA LUNE!",
+    tip: "Utiliser pour les prix actuels"
+  },
+  display: {
+    goldOunce: "Once d'or",
+    goldKg: "Or Gramme",
+    silverKg: "Argent Kg",
+    silverOunce: "Once d'argent",
+    quarterGold: "Quart d'or",
+    halfGold: "Demi-or",
+    fullGold: "Or entier",
+    ataGold: "Or Ata",
+    gremseGold: "Or Gremse"
+  },
+  cli: {
+    specifyCurrency: "Sp\xE9cifiez une devise",
+    usage: "Utilisation",
+    invalidCommand: "Commande invalide"
+  }
+};
+
+// src/i18n/es.ts
+var es = {
+  app: {
+    name: "trate",
+    tagline: "Rastreador de tipos de cambio para terminal"
+  },
+  error: {
+    noConnection: "Verifica tu conexi\xF3n a internet",
+    notFound: "no encontrado",
+    invalidCurrency: "Moneda inv\xE1lida",
+    goldPricesUnavailable: "Los precios del oro no est\xE1n disponibles actualmente",
+    goldPricesLoadFailed: "Error al cargar los precios del oro",
+    sameCurrency: "Conversi\xF3n de la misma moneda",
+    rateNotFound: "tipo de cambio no encontrado"
+  },
+  success: {
+    added: "A\xF1adido",
+    removed: "Eliminado",
+    cacheCleared: "Cach\xE9 limpiado",
+    settingsReset: "Configuraci\xF3n reiniciada",
+    baseCurrencySet: "Moneda base"
+  },
+  ui: {
+    base: "Base",
+    rate: "Tipo",
+    date: "Fecha",
+    type: "Tipo",
+    symbol: "S\xEDmbolo",
+    price: "Precio",
+    info: "Info",
+    tip: "Consejo",
+    noConversionNeeded: "(sin conversi\xF3n necesaria)",
+    loading: "cargando..."
+  },
+  commands: {
+    setBase: "set-base",
+    list: "list",
+    favs: "favs",
+    add: "add",
+    remove: "remove",
+    help: "help",
+    refresh: "refresh",
+    reset: "reset",
+    moon: "moon",
+    setLang: "set-lang"
+  },
+  dashboard: {
+    title: "Panel de favoritos",
+    favorites: "Favoritos",
+    usage: "Usar para tipo r\xE1pido",
+    usageAdd: "Usar para a\xF1adir favoritos",
+    type: {
+      fiat: "FIAT",
+      crypto: "CRIPTO",
+      metal: "METALES",
+      gold: "ORO"
+    }
+  },
+  help: {
+    usage: "Uso",
+    examples: "Ejemplos",
+    crypto: "Cripto",
+    metals: "Metales",
+    jewelry: "Joyer\xEDa",
+    config: "Config",
+    alias: "Alias Personalizados",
+    aliasCreate: "Crear atajo",
+    aliasView: "Ver aliases"
+  },
+  moon: {
+    toTheMoon: "\xA1A la Luna!",
+    goingToMoon: "\xA1VAMOS A LA LUNA!",
+    tip: "Usar para precios actuales"
+  },
+  display: {
+    goldOunce: "Onza de oro",
+    goldKg: "Oro Gramo",
+    silverKg: "Plata Kg",
+    silverOunce: "Onza de plata",
+    quarterGold: "Cuarto de oro",
+    halfGold: "Medio oro",
+    fullGold: "Oro entero",
+    ataGold: "Oro Ata",
+    gremseGold: "Oro Gremse"
+  },
+  cli: {
+    specifyCurrency: "Especifica una moneda",
+    usage: "Uso",
+    invalidCommand: "Comando inv\xE1lido"
+  }
+};
+
+// src/i18n/index.ts
+var translations = {
+  tr,
+  en,
+  de,
+  fr,
+  es
+};
+var supportedLocales = ["tr", "en", "de", "fr", "es"];
+function getSystemLocale() {
+  const systemLocale = Intl.DateTimeFormat().resolvedOptions().locale;
+  const languageCode = systemLocale.split("-")[0].toLowerCase();
+  if (supportedLocales.includes(languageCode)) {
+    return languageCode;
+  }
+  return "en";
+}
+var currentLocale = null;
+function getLocale() {
+  if (currentLocale) {
+    return currentLocale;
+  }
+  return getSystemLocale();
+}
+function setLocale(locale) {
+  if (!supportedLocales.includes(locale)) {
+    throw new Error(`Unsupported locale: ${locale}. Supported: ${supportedLocales.join(", ")}`);
+  }
+  currentLocale = locale;
+}
+function getSupportedLocales() {
+  return [...supportedLocales];
+}
+function getLocaleDisplayName(locale) {
+  const displayNames = {
+    tr: "T\xFCrk\xE7e",
+    en: "English",
+    de: "Deutsch",
+    fr: "Fran\xE7ais",
+    es: "Espa\xF1ol"
+  };
+  return displayNames[locale];
+}
+function getNestedValue(obj, path) {
+  const keys = path.split(".");
+  let value = obj;
+  for (const key of keys) {
+    if (value && typeof value === "object" && key in value) {
+      value = value[key];
+    } else {
+      return path;
+    }
+  }
+  return typeof value === "string" ? value : path;
+}
+function t(key) {
+  const locale = getLocale();
+  const translation = translations[locale];
+  const value = getNestedValue(translation, key);
+  if (value === key && locale !== "en") {
+    return getNestedValue(translations.en, key);
+  }
+  return value;
+}
+
+// src/config/config.ts
+var schema = {
+  baseCurrency: {
+    type: "string",
+    default: "TRY",
+    description: "Base currency for exchange rates"
+  },
+  favorites: {
+    type: "array",
+    default: ["USD", "EUR", "GBP", "JPY"],
+    description: "Favorite currency pairs"
+  },
+  locale: {
+    type: "string",
+    default: getSystemLocale(),
+    description: "Language preference (tr, en, de, fr, es)"
+  },
+  aliases: {
+    type: "object",
+    default: {},
+    description: "Custom currency aliases"
+  }
+};
+var ConfigService = class {
+  store;
+  constructor() {
+    this.store = new Conf({
+      projectName: "trate",
+      schema
+    });
+  }
+  get baseCurrency() {
+    return this.store.get("baseCurrency");
+  }
+  set baseCurrency(value) {
+    this.store.set("baseCurrency", value.toUpperCase());
+  }
+  get favorites() {
+    return this.store.get("favorites");
+  }
+  set favorites(value) {
+    this.store.set(
+      "favorites",
+      value.map((v) => v.toUpperCase())
+    );
+  }
+  get locale() {
+    const stored = this.store.get("locale");
+    return stored || getSystemLocale();
+  }
+  set locale(value) {
+    this.store.set("locale", value);
+  }
+  get clientId() {
+    const stored = this.store.get("clientId");
+    if (!stored) {
+      const newId = crypto.randomUUID();
+      this.store.set("clientId", newId);
+      return newId;
+    }
+    return stored;
+  }
+  get aliases() {
+    return this.store.get("aliases") || {};
+  }
+  set aliases(value) {
+    const normalized = {};
+    for (const [key, val] of Object.entries(value)) {
+      normalized[key.toLowerCase()] = val.toUpperCase();
+    }
+    this.store.set("aliases", normalized);
+  }
+  addAlias(alias, currency) {
+    const current = this.aliases;
+    current[alias.toLowerCase()] = currency.toUpperCase();
+    this.aliases = current;
+  }
+  removeAlias(alias) {
+    const current = this.aliases;
+    if (current[alias.toLowerCase()]) {
+      delete current[alias.toLowerCase()];
+      this.aliases = current;
+      return true;
+    }
+    return false;
+  }
+  addFavorite(currency) {
+    const current = this.favorites;
+    if (!current.includes(currency.toUpperCase())) {
+      this.favorites = [...current, currency.toUpperCase()];
+    }
+  }
+  removeFavorite(currency) {
+    this.favorites = this.favorites.filter((f) => f !== currency.toUpperCase());
+  }
+  getAll() {
+    return {
+      baseCurrency: this.baseCurrency,
+      favorites: this.favorites,
+      locale: this.locale,
+      clientId: this.clientId,
+      aliases: this.aliases
+    };
+  }
+  reset() {
+    this.store.clear();
+  }
+};
+var configService = new ConfigService();
+
+// src/convert.ts
+import fetch from "node-fetch";
+
+// src/utils/logger.ts
+var LOG_LEVEL_NAMES = {
+  [0 /* DEBUG */]: "DEBUG",
+  [1 /* INFO */]: "INFO",
+  [2 /* WARN */]: "WARN",
+  [3 /* ERROR */]: "ERROR"
+};
+var currentLogLevel = 1 /* INFO */;
+var isDebugMode = false;
+function setLogLevel(level) {
+  currentLogLevel = level;
+}
+function setDebugMode(enabled) {
+  isDebugMode = enabled;
+  if (enabled && currentLogLevel > 0 /* DEBUG */) {
+    currentLogLevel = 0 /* DEBUG */;
+  }
+}
+function isDebugEnabled() {
+  return isDebugMode;
+}
+function shouldLog(level) {
+  return level >= currentLogLevel;
+}
+function formatMessage(level, message, meta) {
+  const timestamp = (/* @__PURE__ */ new Date()).toISOString();
+  const levelName = LOG_LEVEL_NAMES[level];
+  const metaStr = meta ? ` ${JSON.stringify(meta)}` : "";
+  return `[${timestamp}] [${levelName}] ${message}${metaStr}`;
+}
+function debug(message, meta) {
+  if (shouldLog(0 /* DEBUG */)) {
+    console.debug(formatMessage(0 /* DEBUG */, message, meta));
+  }
+}
+function info(message, meta) {
+  if (shouldLog(1 /* INFO */)) {
+    console.info(formatMessage(1 /* INFO */, message, meta));
+  }
+}
+function warn(message, meta) {
+  if (shouldLog(2 /* WARN */)) {
+    console.warn(formatMessage(2 /* WARN */, message, meta));
+  }
+}
+function error(message, error2, meta) {
+  if (shouldLog(3 /* ERROR */)) {
+    const errorMeta = error2 instanceof Error ? { ...meta, errorName: error2.name, errorMessage: error2.message } : { ...meta, error: error2 };
+    console.error(formatMessage(3 /* ERROR */, message, errorMeta));
+  }
+}
+var logger = {
+  debug,
+  info,
+  warn,
+  error,
+  setLogLevel,
+  setDebugMode,
+  isDebugEnabled
+};
+
+// src/convert.ts
+var TRATE_API = "https://trate-api.cemali.dev/v1";
+var cache = /* @__PURE__ */ new Map();
+var CACHE_TTL = 5 * 60 * 1e3;
+var rateLimitMap = /* @__PURE__ */ new Map();
+var RATE_LIMIT_WINDOW = 60 * 1e3;
+var RATE_LIMIT_MAX = 30;
+function checkRateLimit(endpoint) {
+  const now = Date.now();
+  const entry = rateLimitMap.get(endpoint);
+  if (!entry || now > entry.resetTime) {
+    rateLimitMap.set(endpoint, { count: 1, resetTime: now + RATE_LIMIT_WINDOW });
+    return true;
+  }
+  if (entry.count >= RATE_LIMIT_MAX) {
+    logger.warn(`Rate limit exceeded for ${endpoint}`, { resetIn: entry.resetTime - now });
+    return false;
+  }
+  entry.count++;
+  return true;
+}
+var cacheApi = {
+  clear: () => cache.clear()
+};
+var CRYPTO_SYMBOLS = [
+  "BTC",
+  "ETH",
+  "SOL",
+  "BNB",
+  "XRP",
+  "ADA",
+  "DOGE",
+  "DOT",
+  "AVAX",
+  "MATIC",
+  "LINK",
+  "UNI",
+  "LTC",
+  "ATOM"
+];
+var METAL_SYMBOLS = ["ONS", "GUMUS_OZ", "GRAM_ALTIN"];
+var JEWELRY_SYMBOLS = ["CEYREK_ALTIN", "YARIM_ALTIN", "TAM_ALTIN", "ATA_ALTIN"];
+var SUPPORTED_FIAT = [
+  "EUR",
+  "USD",
+  "GBP",
+  "JPY",
+  "CHF",
+  "CAD",
+  "AUD",
+  "NZD",
+  "CNY",
+  "HKD",
+  "SGD",
+  "INR",
+  "RUB",
+  "TRY",
+  "BRL",
+  "ZAR",
+  "MXN"
+];
+var JEWELRY_API_MAP = {
+  CEYREK_ALTIN: "ceyrek_altin",
+  YARIM_ALTIN: "yarim_altin",
+  TAM_ALTIN: "tam_altin",
+  ATA_ALTIN: "ata_altin"
+};
+var METAL_API_MAP = {
+  ONS: "ons_altin",
+  GUMUS_OZ: "gumus_ons",
+  GRAM_ALTIN: "gram_altin"
+};
+function isCrypto(symbol) {
+  return CRYPTO_SYMBOLS.includes(symbol.toUpperCase());
+}
+function isMetal(symbol) {
+  return METAL_SYMBOLS.includes(symbol.toUpperCase());
+}
+function isJewelry(symbol) {
+  return JEWELRY_SYMBOLS.includes(symbol.toUpperCase());
+}
+function isFiat(symbol) {
+  return SUPPORTED_FIAT.includes(symbol.toUpperCase());
+}
+function getCached(key) {
+  const cached = cache.get(key);
+  if (cached && Date.now() - cached.timestamp < CACHE_TTL) {
+    return cached.data;
+  }
+  return null;
+}
+function setCache(key, data, base) {
+  cache.set(key, { data, timestamp: Date.now(), base });
+}
+async function fetchWithTimeout(url, timeout = 8e3) {
+  const controller = new AbortController();
+  const timeoutId = setTimeout(() => controller.abort(), timeout);
+  try {
+    const response = await fetch(url, {
+      signal: controller.signal,
+      headers: {
+        "X-Client-ID": configService.clientId,
+        "User-Agent": "trate-cli/1.0.0"
+      }
+    });
+    clearTimeout(timeoutId);
+    return response;
+  } catch (error2) {
+    clearTimeout(timeoutId);
+    throw error2;
+  }
+}
+async function fetchFiatRates() {
+  const cacheKey = "fiat-rates";
+  const cached = getCached(cacheKey);
+  if (cached) return cached;
+  if (!checkRateLimit("fiat")) {
+    throw new Error(t("error.noConnection"));
+  }
+  try {
+    const response = await fetchWithTimeout(`${TRATE_API}/latest`);
+    if (!response.ok) throw new Error();
+    const data = await response.json();
+    if (!data.rates || Object.keys(data.rates).length === 0) throw new Error("Empty rates");
+    setCache(cacheKey, data.rates, "USD");
+    return data.rates;
+  } catch {
+    throw new Error(t("error.noConnection"));
+  }
+}
+function getFiatRateBase() {
+  const cached = cache.get("fiat-rates");
+  return cached?.base;
+}
+async function fetchCryptoRates() {
+  const cacheKey = "crypto-rates";
+  const cached = getCached(cacheKey);
+  if (cached) return cached;
+  if (!checkRateLimit("crypto")) {
+    throw new Error(t("error.noConnection"));
+  }
+  try {
+    const response = await fetchWithTimeout(`${TRATE_API}/crypto`);
+    if (!response.ok) throw new Error();
+    const data = await response.json();
+    setCache(cacheKey, data.prices);
+    return data.prices;
+  } catch {
+    throw new Error(t("error.noConnection"));
+  }
+}
+async function fetchMetalsPrices() {
+  const cacheKey = "metals-prices";
+  const cached = getCached(cacheKey);
+  if (cached) return cached;
+  if (!checkRateLimit("metals")) {
+    throw new Error(t("error.noConnection"));
+  }
+  try {
+    const response = await fetchWithTimeout(`${TRATE_API}/metals`);
+    if (!response.ok) throw new Error();
+    const data = await response.json();
+    if (!data.prices || Object.keys(data.prices).length === 0) {
+      throw new Error(t("error.goldPricesUnavailable"));
+    }
+    setCache(cacheKey, data.prices);
+    return data.prices;
+  } catch (error2) {
+    if (error2 instanceof Error && error2.message.includes(t("error.goldPricesUnavailable").replace("\u015F", "s").replace("\u0131", "i"))) {
+      throw error2;
+    }
+    throw new Error(t("error.goldPricesLoadFailed"), { cause: error2 });
+  }
+}
+async function convert(amount, from, to) {
+  try {
+    from = from.toUpperCase();
+    to = to.toUpperCase();
+    if (from === to) {
+      return {
+        success: true,
+        result: amount,
+        rate: 1,
+        base: from,
+        date: (/* @__PURE__ */ new Date()).toISOString().split("T")[0]
+      };
+    }
+    const fromIsCrypto = isCrypto(from);
+    const toIsCrypto = isCrypto(to);
+    const fromIsMetal = isMetal(from);
+    const toIsMetal = isMetal(to);
+    const fromIsJewelry = isJewelry(from);
+    const toIsJewelry = isJewelry(to);
+    const fromIsFiat = isFiat(from);
+    const toIsFiat = isFiat(to);
+    let result;
+    let rate;
+    if (fromIsJewelry && toIsJewelry) {
+      const metalsPrices = await fetchMetalsPrices();
+      const fromApiKey = JEWELRY_API_MAP[from];
+      const toApiKey = JEWELRY_API_MAP[to];
+      const fromPriceTRY = metalsPrices[fromApiKey].satis;
+      const toPriceTRY = metalsPrices[toApiKey].satis;
+      rate = fromPriceTRY / toPriceTRY;
+      result = amount * rate;
+    } else if (fromIsJewelry && toIsFiat) {
+      const metalsPrices = await fetchMetalsPrices();
+      const fiatRates = await fetchFiatRates();
+      const fromApiKey = JEWELRY_API_MAP[from];
+      const jewelryPriceTRY = metalsPrices[fromApiKey].satis;
+      const jewelryPriceUSD = jewelryPriceTRY / fiatRates["TRY"];
+      if (to === "USD") {
+        rate = jewelryPriceUSD;
+      } else {
+        const targetToUSD = fiatRates[to];
+        if (!targetToUSD) {
+          return { success: false, error: `${to} ${t("error.rateNotFound")}` };
+        }
+        rate = jewelryPriceUSD * targetToUSD;
+      }
+      result = amount * rate;
+    } else if (fromIsFiat && toIsJewelry) {
+      const metalsPrices = await fetchMetalsPrices();
+      const fiatRates = await fetchFiatRates();
+      const toApiKey = JEWELRY_API_MAP[to];
+      const jewelryPriceTRY = metalsPrices[toApiKey].satis;
+      const jewelryPriceUSD = jewelryPriceTRY / fiatRates["TRY"];
+      if (from === "USD") {
+        rate = 1 / jewelryPriceUSD;
+      } else {
+        const fiatToUSD = fiatRates[from];
+        if (!fiatToUSD) {
+          return { success: false, error: `${from} ${t("error.rateNotFound")}` };
+        }
+        rate = fiatToUSD / jewelryPriceUSD;
+      }
+      result = amount * rate;
+    } else if (fromIsJewelry && toIsCrypto) {
+      const metalsPrices = await fetchMetalsPrices();
+      const fiatRates = await fetchFiatRates();
+      const cryptoRates = await fetchCryptoRates();
+      const fromApiKey = JEWELRY_API_MAP[from];
+      const jewelryPriceTRY = metalsPrices[fromApiKey].satis;
+      const cryptoPriceUSD = cryptoRates[to];
+      const usdToTry = fiatRates["TRY"];
+      const jewelryPriceUSD = jewelryPriceTRY / usdToTry;
+      rate = jewelryPriceUSD / cryptoPriceUSD;
+      result = amount * rate;
+    } else if (fromIsCrypto && toIsJewelry) {
+      const metalsPrices = await fetchMetalsPrices();
+      const fiatRates = await fetchFiatRates();
+      const cryptoRates = await fetchCryptoRates();
+      const toApiKey = JEWELRY_API_MAP[to];
+      const jewelryPriceTRY = metalsPrices[toApiKey].satis;
+      const cryptoPriceUSD = cryptoRates[from];
+      const usdToTry = fiatRates["TRY"];
+      const cryptoInTRY = cryptoPriceUSD * usdToTry;
+      rate = cryptoInTRY / jewelryPriceTRY;
+      result = amount * rate;
+    } else if (fromIsMetal && toIsFiat) {
+      const metalsPrices = await fetchMetalsPrices();
+      const fiatRates = await fetchFiatRates();
+      const apiKey = METAL_API_MAP[from];
+      let metalPriceTRY;
+      if (from === "ONS") {
+        metalPriceTRY = metalsPrices[apiKey].satis;
+      } else if (from === "ALTIN_KG") {
+        metalPriceTRY = metalsPrices[apiKey].satis * 10.33;
+      } else {
+        metalPriceTRY = metalsPrices[apiKey].satis;
+      }
+      const metalPriceUSD = metalPriceTRY / fiatRates["TRY"];
+      if (to === "USD") {
+        rate = metalPriceUSD;
+      } else {
+        const targetToUSD = fiatRates[to];
+        if (!targetToUSD) {
+          return { success: false, error: `${to} ${t("error.rateNotFound")}` };
+        }
+        rate = metalPriceUSD * targetToUSD;
+      }
+      result = amount * rate;
+    } else if (fromIsFiat && toIsMetal) {
+      const metalsPrices = await fetchMetalsPrices();
+      const fiatRates = await fetchFiatRates();
+      const apiKey = METAL_API_MAP[to];
+      let metalPriceTRY;
+      if (to === "ONS") {
+        metalPriceTRY = metalsPrices[apiKey].satis;
+      } else if (to === "ALTIN_KG") {
+        metalPriceTRY = metalsPrices[apiKey].satis * 10.33;
+      } else {
+        metalPriceTRY = metalsPrices[apiKey].satis;
+      }
+      const metalPriceUSD = metalPriceTRY / fiatRates["TRY"];
+      if (from === "USD") {
+        rate = 1 / metalPriceUSD;
+      } else {
+        const fiatToUSD = fiatRates[from];
+        if (!fiatToUSD) {
+          return { success: false, error: `${from} ${t("error.rateNotFound")}` };
+        }
+        rate = fiatToUSD / metalPriceUSD;
+      }
+      result = amount * rate;
+    } else if (fromIsMetal && toIsCrypto) {
+      const metalsPrices = await fetchMetalsPrices();
+      const fiatRates = await fetchFiatRates();
+      const cryptoRates = await fetchCryptoRates();
+      const apiKey = METAL_API_MAP[from];
+      let metalPriceTRY;
+      if (from === "ONS") {
+        metalPriceTRY = metalsPrices[apiKey].satis;
+      } else if (from === "ALTIN_KG") {
+        metalPriceTRY = metalsPrices[apiKey].satis * 10.33;
+      } else {
+        metalPriceTRY = metalsPrices[apiKey].satis;
+      }
+      const metalPriceUSD = metalPriceTRY / fiatRates["TRY"];
+      const cryptoPriceUSD = cryptoRates[to];
+      rate = metalPriceUSD / cryptoPriceUSD;
+      result = amount * rate;
+    } else if (fromIsCrypto && toIsMetal) {
+      const metalsPrices = await fetchMetalsPrices();
+      const fiatRates = await fetchFiatRates();
+      const cryptoRates = await fetchCryptoRates();
+      const apiKey = METAL_API_MAP[to];
+      let metalPriceTRY;
+      if (to === "ONS") {
+        metalPriceTRY = metalsPrices[apiKey].satis;
+      } else if (to === "ALTIN_KG") {
+        metalPriceTRY = metalsPrices[apiKey].satis * 10.33;
+      } else {
+        metalPriceTRY = metalsPrices[apiKey].satis;
+      }
+      const cryptoPriceUSD = cryptoRates[from];
+      const cryptoInTRY = cryptoPriceUSD * fiatRates["TRY"];
+      rate = cryptoInTRY / metalPriceTRY;
+      result = amount * rate;
+    } else if (fromIsCrypto && toIsCrypto) {
+      const cryptoRates = await fetchCryptoRates();
+      const fromPrice = cryptoRates[from];
+      const toPrice = cryptoRates[to];
+      if (!fromPrice || !toPrice) {
+        return { success: false, error: `${!fromPrice ? from : to} ${t("error.notFound")}` };
+      }
+      rate = fromPrice / toPrice;
+      result = amount * rate;
+    } else if (fromIsCrypto && toIsFiat) {
+      const cryptoRates = await fetchCryptoRates();
+      const fiatRates = await fetchFiatRates();
+      const cryptoPriceUSD = cryptoRates[from];
+      if (!cryptoPriceUSD) {
+        return { success: false, error: `${from} ${t("error.notFound")}` };
+      }
+      if (to === "USD") {
+        rate = cryptoPriceUSD;
+      } else {
+        const targetToUSD = fiatRates[to];
+        if (!targetToUSD) {
+          return { success: false, error: `${to} ${t("error.rateNotFound")}` };
+        }
+        rate = cryptoPriceUSD * targetToUSD;
+      }
+      result = amount * rate;
+    } else if (fromIsFiat && toIsCrypto) {
+      const cryptoRates = await fetchCryptoRates();
+      const fiatRates = await fetchFiatRates();
+      const cryptoPriceUSD = cryptoRates[to];
+      if (!cryptoPriceUSD) {
+        return { success: false, error: `${to} ${t("error.notFound")}` };
+      }
+      if (from === "USD") {
+        rate = 1 / cryptoPriceUSD;
+      } else {
+        const fiatToUSD = fiatRates[from];
+        if (!fiatToUSD) {
+          return { success: false, error: `${from} ${t("error.rateNotFound")}` };
+        }
+        rate = fiatToUSD / cryptoPriceUSD;
+      }
+      result = amount * rate;
+    } else {
+      const fiatRates = await fetchFiatRates();
+      const rateBase = getFiatRateBase();
+      const fromRate = fiatRates[from];
+      const toRate = fiatRates[to];
+      if (!fromRate) {
+        return { success: false, error: `${from} ${t("error.rateNotFound")}` };
+      }
+      if (!toRate) {
+        return { success: false, error: `${to} ${t("error.rateNotFound")}` };
+      }
+      if (rateBase === "USD") {
+        rate = toRate / fromRate;
+      } else {
+        rate = fromRate / toRate;
+      }
+      result = amount * rate;
+    }
+    return {
+      success: true,
+      result: result < 0.01 ? parseFloat(result.toFixed(8)) : Math.round(result * 100) / 100,
+      rate: result < 0.01 ? parseFloat(rate.toPrecision(6)) : Math.round(rate * 1e6) / 1e6,
+      base: configService.baseCurrency,
+      date: (/* @__PURE__ */ new Date()).toISOString().split("T")[0]
+    };
+  } catch (error2) {
+    return {
+      success: false,
+      error: error2 instanceof Error ? error2.message : t("error.noConnection")
+    };
+  }
+}
+function getFiatList() {
+  return SUPPORTED_FIAT;
+}
+function getCryptoList() {
+  return CRYPTO_SYMBOLS;
+}
+function getMetalList() {
+  return METAL_SYMBOLS;
+}
+function getJewelryList() {
+  return JEWELRY_SYMBOLS;
+}
+function getDisplayName(symbol) {
+  const displayNames = {
+    ONS: t("display.goldOunce"),
+    GUMUS_OZ: t("display.silverOunce"),
+    GRAM_ALTIN: t("display.goldKg"),
+    CEYREK_ALTIN: t("display.quarterGold"),
+    YARIM_ALTIN: t("display.halfGold"),
+    TAM_ALTIN: t("display.fullGold"),
+    ATA_ALTIN: t("display.ataGold")
+  };
+  return displayNames[symbol.toUpperCase()] || symbol;
+}
+
+// src/ui.ts
+var COLORS = {
+  reset: "\x1B[0m",
+  bold: "\x1B[1m",
+  dim: "\x1B[2m",
+  cyan: "\x1B[36m",
+  green: "\x1B[32m",
+  yellow: "\x1B[33m",
+  red: "\x1B[31m",
+  magenta: "\x1B[35m"
+};
+var colors = {
+  bold: (text) => `${COLORS.bold}${text}${COLORS.reset}`,
+  dim: (text) => `${COLORS.dim}${text}${COLORS.reset}`,
+  cyan: (text) => `${COLORS.cyan}${text}${COLORS.reset}`,
+  green: (text) => `${COLORS.green}${text}${COLORS.reset}`,
+  yellow: (text) => `${COLORS.yellow}${text}${COLORS.reset}`,
+  red: (text) => `${COLORS.red}${text}${COLORS.reset}`,
+  magenta: (text) => `${COLORS.magenta}${text}${COLORS.reset}`
+};
+function divider(width = 55) {
+  return colors.dim("\u2500".repeat(width));
+}
+
+// src/logo.ts
+import figlet from "figlet";
+var cachedLogo = null;
+function getLogo() {
+  if (cachedLogo) return cachedLogo;
+  const dollarSign = figlet.textSync("$", {
+    font: "Slant",
+    horizontalLayout: "default",
+    verticalLayout: "default"
+  });
+  const trateText = figlet.textSync("trate", {
+    font: "Slant",
+    horizontalLayout: "default",
+    verticalLayout: "default"
+  });
+  const white = "\x1B[38;5;15m";
+  const reset = "\x1B[0m";
+  const dollarLines = dollarSign.split("\n");
+  const trateLines = trateText.split("\n");
+  const combined = dollarLines.map((line, i) => {
+    const trateLine = trateLines[i] || "";
+    return `${white}${line}${reset} ${white}${trateLine}${reset}`;
+  });
+  cachedLogo = combined.join("\n");
+  return cachedLogo;
+}
+
+// src/dashboard.ts
+async function displayFavoritesDashboard() {
+  const config = configService.getAll();
+  const favorites = config.favorites;
+  const base = config.baseCurrency;
+  const lines = [];
+  lines.push(`
+  ${colors.bold(t("dashboard.title"))}    ${t("ui.base")}: ${colors.cyan(base)}`);
+  lines.push(colors.dim("  " + "\u2500".repeat(70)));
+  const header = `  ${colors.bold(t("ui.symbol"))}     ${colors.bold(t("ui.price"))}              ${colors.bold(t("ui.type"))}`;
+  lines.push(header);
+  lines.push(colors.dim("  " + "\u2500".repeat(70)));
+  const promises = favorites.map(async (symbol) => {
+    const isCryptoSymbol = isCrypto(symbol);
+    const isMetalSymbol = isMetal(symbol);
+    const isJewelrySymbol = isJewelry(symbol);
+    const rate = await convert(1, symbol, base);
+    if (rate.success) {
+      const displaySymbol = isMetalSymbol || isJewelrySymbol ? getDisplayName(symbol) : symbol;
+      const resultStr = rate.result < 0.01 ? rate.result.toPrecision(6) : rate.result.toLocaleString();
+      let typeLabel = t("dashboard.type.fiat");
+      let symbolColor = colors.cyan(symbol);
+      if (isCryptoSymbol) {
+        typeLabel = t("dashboard.type.crypto");
+        symbolColor = colors.yellow(symbol);
+      } else if (isMetalSymbol) {
+        typeLabel = t("dashboard.type.metal");
+        symbolColor = colors.magenta(symbol);
+      } else if (isJewelrySymbol) {
+        typeLabel = t("dashboard.type.gold");
+        symbolColor = colors.magenta(symbol + " \u{1F3C6}");
+      }
+      return {
+        symbol: displaySymbol,
+        type: typeLabel,
+        symbolColor,
+        price: resultStr,
+        rate: `1 ${symbol}`
+      };
+    }
+    return null;
+  });
+  const results = await Promise.all(promises);
+  for (const result of results) {
+    if (result) {
+      lines.push(
+        `  ${result.symbolColor.padEnd(14)} ${result.rate.padEnd(8)} ${base.padEnd(12)} ${colors.dim(result.type)}`
+      );
+    }
+  }
+  lines.push(colors.dim("  " + "\u2500".repeat(70)));
+  lines.push(
+    `  ${colors.dim(t("ui.tip") + ":")} Use ${colors.cyan("trate <symbol>")} ${t("dashboard.usage").toLowerCase()}`
+  );
+  lines.push(
+    `  ${colors.dim(t("ui.tip") + ":")} Use ${colors.cyan("trate add <currency>")} ${t("dashboard.usageAdd").toLowerCase()}`
+  );
+  return lines.join("\n");
+}
+
+// src/index.ts
+var STATUS_WIDTH = 55;
+var getSupportedCurrencies = () => {
+  const fiat = getFiatList().join(", ");
+  const crypto2 = getCryptoList().join(", ");
+  const metals = getMetalList().join(", ");
+  return { fiat, crypto: crypto2, metals };
+};
+var helpText = async () => {
+  const config = configService.getAll();
+  const { crypto: crypto2, metals } = getSupportedCurrencies();
+  let statusLine = `${colors.yellow(t("ui.base") + ":")} ${colors.cyan(config.baseCurrency)}`;
+  try {
+    const usdResult = await convert(1, "USD", config.baseCurrency);
+    if (usdResult.success) {
+      statusLine += ` | 1 USD = ${colors.green(usdResult.result.toFixed(2))} ${config.baseCurrency}`;
+    }
+  } catch {
+    statusLine += ` | ${colors.dim(t("ui.loading"))}`;
+  }
+  return `
+${getLogo()}
+
+${colors.dim(t("app.tagline"))}
+
+${colors.bold(t("help.usage") + ":")}
+  ${colors.cyan("trate <amount> <from> <to>")}    ${t("help.examples")} (${colors.dim("trate 100 usd try")})
+  ${colors.cyan("trate <currency>")}              ${t("dashboard.usage")} (${colors.dim("trate btc")})
+
+${colors.bold(t("help.examples") + ":")}
+  ${colors.dim("$")} ${colors.yellow("trate 100 usd")}       100 USD \u2192 ${config.baseCurrency}
+  ${colors.dim("$")} ${colors.yellow("trate btc")}           BTC \u2192 ${config.baseCurrency}
+  ${colors.dim("$")} ${colors.yellow("trate ceyrek_altin")}  \xC7eyrek Alt\u0131n \u2192 ${config.baseCurrency}
+
+${colors.bold(t("help.crypto") + ":")} ${colors.dim(crypto2)}
+
+${colors.bold(t("help.metals") + ":")} ${colors.yellow(metals)}
+
+${colors.bold(t("help.jewelry") + ":")}
+  ${colors.yellow("ceyrek_altin")} ${colors.yellow("yarim_altin")} ${colors.yellow("tam_altin")} ${colors.yellow("ata_altin")}
+
+${colors.bold(t("help.config") + ":")}
+  ${colors.yellow("set-base")} | ${colors.yellow("list")} | ${colors.yellow("add")} | ${colors.yellow("remove")} | ${colors.yellow("set-lang")} | ${colors.yellow("alias")} | ${colors.yellow("help")}
+
+${colors.bold(t("help.alias") + ":")}
+  ${colors.dim("$")} ${colors.cyan("trate alias add ceyrek CEYREK_ALTIN")}  ${t("help.aliasCreate")}
+  ${colors.dim("$")} ${colors.cyan("trate alias list")}                    ${t("help.aliasView")}
+
+${divider(STATUS_WIDTH)}
+${statusLine}
+`;
+};
+var startScreen = () => {
+  const config = configService.getAll();
+  return `
+${getLogo()}
+
+${colors.dim(t("app.tagline"))}
+
+${colors.dim("$")} ${colors.cyan("trate 100 usd")}         100 USD \u2192 ${config.baseCurrency}
+${colors.dim("$")} ${colors.cyan("trate btc")}            BTC \u2192 ${config.baseCurrency}
+${colors.dim("$")} ${colors.cyan("trate ceyrek_altin")}   \xC7eyrek Alt\u0131n
+${colors.dim("$")} ${colors.cyan("trate list")}           ${t("dashboard.favorites")}
+${colors.dim("$")} ${colors.cyan("trate alias list")}     View aliases
+${colors.dim("$")} ${colors.cyan("trate help")}           ${t("commands.help")}
+`;
+};
+var validateCurrency = (symbol) => {
+  const fiatList = getFiatList().map((s) => s.toUpperCase());
+  const cryptoList = getCryptoList().map((s) => s.toUpperCase());
+  const metalList = getMetalList().map((s) => s.toUpperCase());
+  const jewelryList = getJewelryList().map((s) => s.toUpperCase());
+  const upperSymbol = symbol.toUpperCase();
+  const lowerSymbol = symbol.toLowerCase();
+  const aliases = configService.aliases;
+  return fiatList.includes(upperSymbol) || cryptoList.includes(upperSymbol) || metalList.includes(upperSymbol) || jewelryList.includes(upperSymbol) || lowerSymbol in aliases || Object.values(aliases).includes(upperSymbol);
+};
+var resolveAlias = (symbol) => {
+  const aliases = configService.aliases;
+  const lowerSymbol = symbol.toLowerCase();
+  return aliases[lowerSymbol] || symbol.toUpperCase();
+};
+var convertCommand = async (args) => {
+  const config = configService.getAll();
+  let amount = 1;
+  let from = "";
+  let to = config.baseCurrency;
+  if (args.length === 1) {
+    from = resolveAlias(args[0]);
+    to = config.baseCurrency;
+    amount = 1;
+  } else if (args.length === 2) {
+    const first = args[0];
+    const second = args[1];
+    if (!isNaN(parseFloat(first))) {
+      amount = parseFloat(first);
+      from = resolveAlias(second);
+      to = config.baseCurrency;
+    } else {
+      from = resolveAlias(first);
+      to = resolveAlias(second);
+    }
+  } else if (args.length >= 3) {
+    amount = parseFloat(args[0]);
+    from = resolveAlias(args[1]);
+    to = resolveAlias(args[2]);
+  }
+  if (from === to) {
+    console.log(`
+  ${colors.dim(t("ui.info") + ":")} ${t("error.sameCurrency")}`);
+    console.log(`  ${amount} ${from} = ${amount} ${to} ${colors.dim(t("ui.noConversionNeeded"))}`);
+    return;
+  }
+  const result = await convert(amount, from, to);
+  if (result.success) {
+    const displayFrom = isMetal(from) || isJewelry(from) ? getDisplayName(from) : from;
+    const displayTo = isMetal(to) || isJewelry(to) ? getDisplayName(to) : to;
+    const resultStr = result.result < 0.01 ? result.result.toPrecision(6) : result.result.toLocaleString();
+    console.log(
+      `
+  ${colors.bold(amount.toLocaleString())} ${displayFrom} = ${colors.green(resultStr)} ${displayTo}`
+    );
+    console.log(
+      `  ${colors.dim(t("ui.rate") + ":")} 1 ${from} = ${result.rate < 1e-4 ? result.rate.toPrecision(6) : result.rate.toFixed(6)} ${to}`
+    );
+    console.log(
+      `  ${colors.dim(t("ui.base") + ":")} ${result.base} | ${colors.dim(t("ui.date") + ":")} ${result.date}`
+    );
+  } else {
+    console.log(`
+  ${colors.red("Error:")} ${result.error}`);
+  }
+};
+var listCommand = async () => {
+  console.log(await displayFavoritesDashboard());
+};
+var moonCommand = async () => {
+  console.log(`
+  ${colors.bold(t("moon.toTheMoon"))}
+`);
+  console.log(`  ${colors.yellow("\u{1F680}")} ${colors.bold(t("moon.goingToMoon"))}`);
+  console.log(
+    `  ${colors.dim(t("moon.tip"))} ${colors.cyan("trate <crypto>")} ${colors.dim(t("ui.type") + ":")}`
+  );
+  console.log("");
+};
+function initLocale() {
+  const configLocale = configService.locale;
+  if (configLocale) {
+    setLocale(configLocale);
+  }
+}
+initLocale();
+program.name("trate").description(t("app.tagline")).version("1.0.0");
+program.argument("[args...]", "Arguments for conversion or command").action(async (args) => {
+  if (!args || args.length === 0) {
+    console.log(startScreen());
+    return;
+  }
+  const cmd = args[0].toLowerCase();
+  if (cmd === "set-base") {
+    const newBase = args[1]?.toUpperCase();
+    if (!newBase) {
+      console.log(`  ${colors.red("Error:")} ${t("cli.specifyCurrency")}`);
+      console.log(`  ${colors.dim(t("cli.usage") + ":")} trate set-base <currency>`);
+      return;
+    }
+    if (!validateCurrency(newBase)) {
+      console.log(`  ${colors.red("Error:")} ${t("error.invalidCurrency")}: ${newBase}`);
+      console.log(`  ${colors.dim(t("help.crypto") + ":")} ${getFiatList().join(", ")}`);
+      return;
+    }
+    configService.baseCurrency = newBase;
+    console.log(`  ${colors.green("\u2713")} ${t("success.baseCurrencySet")}: ${newBase}`);
+    return;
+  }
+  if (cmd === "set-lang") {
+    const newLocale = args[1]?.toLowerCase();
+    if (!newLocale) {
+      console.log(`  ${colors.red("Error:")} ${t("cli.specifyCurrency")}`);
+      console.log(`  ${colors.dim(t("cli.usage") + ":")} trate set-lang <locale>`);
+      console.log(
+        `  ${colors.dim("Available:")} ${getSupportedLocales().map((l) => colors.cyan(l)).join(", ")}`
+      );
+      return;
+    }
+    if (!getSupportedLocales().includes(newLocale)) {
+      console.log(`  ${colors.red("Error:")} ${t("error.invalidCurrency")}: ${newLocale}`);
+      console.log(
+        `  ${colors.dim("Available:")} ${getSupportedLocales().map((l) => `${colors.cyan(l)} (${getLocaleDisplayName(l)})`).join(", ")}`
+      );
+      return;
+    }
+    configService.locale = newLocale;
+    setLocale(newLocale);
+    console.log(`  ${colors.green("\u2713")} Language set to: ${getLocaleDisplayName(newLocale)}`);
+    return;
+  }
+  if (cmd === "add") {
+    const cur = args[1]?.toUpperCase();
+    if (!cur) {
+      console.log(`  ${colors.red("Error:")} ${t("cli.specifyCurrency")}`);
+      console.log(`  ${colors.dim(t("cli.usage") + ":")} trate add <currency>`);
+      return;
+    }
+    if (!validateCurrency(cur)) {
+      console.log(`  ${colors.red("Error:")} ${t("error.invalidCurrency")}: ${cur}`);
+      return;
+    }
+    configService.addFavorite(cur);
+    console.log(`  ${colors.green("\u2713")} ${t("success.added")}: ${cur}`);
+    return;
+  }
+  if (cmd === "remove") {
+    const cur = args[1]?.toUpperCase();
+    if (!cur) {
+      console.log(`  ${colors.red("Error:")} ${t("cli.specifyCurrency")}`);
+      console.log(`  ${colors.dim(t("cli.usage") + ":")} trate remove <currency>`);
+      return;
+    }
+    configService.removeFavorite(cur);
+    console.log(`  ${colors.green("\u2713")} ${t("success.removed")}: ${cur}`);
+    return;
+  }
+  if (cmd === "list" || cmd === "favs") {
+    await listCommand();
+    return;
+  }
+  if (cmd === "moon") {
+    await moonCommand();
+    return;
+  }
+  if (cmd === "refresh") {
+    cacheApi.clear();
+    console.log(`  ${colors.green("\u2713")} ${t("success.cacheCleared")}`);
+    return;
+  }
+  if (cmd === "reset") {
+    configService.reset();
+    console.log(`  ${colors.green("\u2713")} ${t("success.settingsReset")}`);
+    return;
+  }
+  if (cmd === "help") {
+    console.log(await helpText());
+    return;
+  }
+  if (cmd === "alias") {
+    const subCmd = args[1]?.toLowerCase();
+    const alias = args[2]?.toLowerCase();
+    const currency = args[3]?.toUpperCase();
+    if (subCmd === "list") {
+      const aliases = configService.aliases;
+      const entries = Object.entries(aliases);
+      if (entries.length === 0) {
+        console.log(`
+  ${colors.dim("No aliases defined")}`);
+      } else {
+        console.log(`
+  ${colors.bold("Aliases:")}`);
+        for (const [key, val] of entries) {
+          console.log(`  ${colors.yellow(key)} \u2192 ${colors.cyan(val)}`);
+        }
+      }
+      return;
+    }
+    if (subCmd === "add") {
+      if (!alias || !currency) {
+        console.log(`  ${colors.red("Error:")} Specify alias and currency`);
+        console.log(
+          `  ${colors.dim("Usage:")} ${colors.cyan("trate alias add <alias> <currency>")}`
+        );
+        console.log(
+          `  ${colors.dim("Example:")} ${colors.cyan("trate alias add ceyrek CEYREK_ALTIN")}`
+        );
+        return;
+      }
+      const resolvedCurrency = resolveAlias(currency);
+      if (!validateCurrency(resolvedCurrency)) {
+        console.log(`  ${colors.red("Error:")} Invalid currency: ${resolvedCurrency}`);
+        return;
+      }
+      configService.addAlias(alias, resolvedCurrency);
+      console.log(
+        `  ${colors.green("\u2713")} Alias added: ${colors.yellow(alias)} \u2192 ${colors.cyan(resolvedCurrency)}`
+      );
+      return;
+    }
+    if (subCmd === "remove") {
+      if (!alias) {
+        console.log(`  ${colors.red("Error:")} Specify alias to remove`);
+        console.log(`  ${colors.dim("Usage:")} ${colors.cyan("trate alias remove <alias>")}`);
+        return;
+      }
+      const removed = configService.removeAlias(alias);
+      if (removed) {
+        console.log(`  ${colors.green("\u2713")} Alias removed: ${colors.yellow(alias)}`);
+      } else {
+        console.log(`  ${colors.red("Error:")} Alias not found: ${colors.yellow(alias)}`);
+      }
+      return;
+    }
+    console.log(`  ${colors.bold("Alias Commands:")}`);
+    console.log(`  ${colors.cyan("trate alias list")}          ${colors.dim("List all aliases")}`);
+    console.log(
+      `  ${colors.cyan("trate alias add <alias> <currency>")}  ${colors.dim("Add alias")}`
+    );
+    console.log(
+      `  ${colors.cyan("trate alias remove <alias>")}         ${colors.dim("Remove alias")}`
+    );
+    return;
+  }
+  if (validateCurrency(cmd)) {
+    await convertCommand(args);
+  } else {
+    await convertCommand(args.slice(1));
+  }
+});
+program.parse();
+process.on("SIGINT", () => {
+  logger.debug("Received SIGINT, shutting down gracefully");
+  process.exit(0);
+});
+process.on("SIGTERM", () => {
+  logger.debug("Received SIGTERM, shutting down gracefully");
+  process.exit(0);
+});