@cemalidev/trate 1.4.1

package/src/index.ts

@@ -0,0 +1,390 @@
+import { program } from 'commander';
+import { configService } from './config/config';
+import {
+  convert,
+  getFiatList,
+  getCryptoList,
+  getMetalList,
+  getJewelryList,
+  getDisplayName,
+  isMetal,
+  isJewelry,
+  cacheApi,
+} from './convert';
+import { colors, divider } from './ui';
+import { getLogo } from './logo';
+import { displayFavoritesDashboard } from './dashboard';
+import { t, setLocale, getSupportedLocales, getLocaleDisplayName, Locale } from './i18n';
+import { logger } from './utils/logger';
+
+const STATUS_WIDTH = 55;
+
+const getSupportedCurrencies = () => {
+  const fiat = getFiatList().join(', ');
+  const crypto = getCryptoList().join(', ');
+  const metals = getMetalList().join(', ');
+  return { fiat, crypto, metals };
+};
+
+const helpText = async () => {
+  const config = configService.getAll();
+  const { crypto, 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 → ${config.baseCurrency}
+  ${colors.dim('$')} ${colors.yellow('trate btc')}           BTC → ${config.baseCurrency}
+  ${colors.dim('$')} ${colors.yellow('trate ceyrek_altin')}  Çeyrek Altın → ${config.baseCurrency}
+
+${colors.bold(t('help.crypto') + ':')} ${colors.dim(crypto)}
+
+${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}
+`;
+};
+
+const startScreen = () => {
+  const config = configService.getAll();
+  return `
+${getLogo()}
+
+${colors.dim(t('app.tagline'))}
+
+${colors.dim('$')} ${colors.cyan('trate 100 usd')}         100 USD → ${config.baseCurrency}
+${colors.dim('$')} ${colors.cyan('trate btc')}            BTC → ${config.baseCurrency}
+${colors.dim('$')} ${colors.cyan('trate ceyrek_altin')}   Çeyrek Altın
+${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')}
+`;
+};
+
+const validateCurrency = (symbol: string): boolean => {
+  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)
+  );
+};
+
+const resolveAlias = (symbol: string): string => {
+  const aliases = configService.aliases;
+  const lowerSymbol = symbol.toLowerCase();
+  return aliases[lowerSymbol] || symbol.toUpperCase();
+};
+
+const convertCommand = async (args: string[]) => {
+  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(`\n  ${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(
+      `\n  ${colors.bold(amount.toLocaleString())} ${displayFrom} = ${colors.green(resultStr)} ${displayTo}`
+    );
+    console.log(
+      `  ${colors.dim(t('ui.rate') + ':')} 1 ${from} = ${result.rate! < 0.0001 ? 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(`\n  ${colors.red('Error:')} ${result.error}`);
+  }
+};
+
+const listCommand = async () => {
+  console.log(await displayFavoritesDashboard());
+};
+
+const moonCommand = async () => {
+  console.log(`\n  ${colors.bold(t('moon.toTheMoon'))}\n`);
+  console.log(`  ${colors.yellow('🚀')} ${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('✓')} ${t('success.baseCurrencySet')}: ${newBase}`);
+    return;
+  }
+
+  if (cmd === 'set-lang') {
+    const newLocale = args[1]?.toLowerCase() as Locale;
+    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('✓')} 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('✓')} ${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('✓')} ${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('✓')} ${t('success.cacheCleared')}`);
+    return;
+  }
+
+  if (cmd === 'reset') {
+    configService.reset();
+    console.log(`  ${colors.green('✓')} ${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(`\n  ${colors.dim('No aliases defined')}`);
+      } else {
+        console.log(`\n  ${colors.bold('Aliases:')}`);
+        for (const [key, val] of entries) {
+          console.log(`  ${colors.yellow(key)} → ${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('✓')} Alias added: ${colors.yellow(alias)} → ${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('✓')} 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);
+});

package/src/logo.ts

@@ -0,0 +1,33 @@
+import figlet from 'figlet';
+
+let cachedLogo: string | null = null;
+
+export function getLogo(): string {
+  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;
+}

package/src/types/errors.ts

@@ -0,0 +1,38 @@
+export enum ErrorCode {
+  NETWORK_ERROR = 'NETWORK_ERROR',
+  API_ERROR = 'API_ERROR',
+  INVALID_CURRENCY = 'INVALID_CURRENCY',
+  CURRENCY_NOT_FOUND = 'CURRENCY_NOT_FOUND',
+  RATE_NOT_FOUND = 'RATE_NOT_FOUND',
+  CONFIG_ERROR = 'CONFIG_ERROR',
+  UNKNOWN_ERROR = 'UNKNOWN_ERROR',
+}
+
+export class TrateError extends Error {
+  public readonly code: ErrorCode;
+  public readonly originalError?: Error;
+
+  constructor(code: ErrorCode, message: string, originalError?: Error) {
+    super(message);
+    this.name = 'TrateError';
+    this.code = code;
+    this.originalError = originalError;
+
+    if (Error.captureStackTrace) {
+      Error.captureStackTrace(this, TrateError);
+    }
+  }
+
+  toJSON() {
+    return {
+      name: this.name,
+      message: this.message,
+      code: this.code,
+      stack: this.stack,
+    };
+  }
+}
+
+export function isTrateError(error: unknown): error is TrateError {
+  return error instanceof TrateError;
+}

package/src/ui.ts

@@ -0,0 +1,40 @@
+const 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',
+};
+
+export const colors = {
+  bold: (text: string) => `${COLORS.bold}${text}${COLORS.reset}`,
+  dim: (text: string) => `${COLORS.dim}${text}${COLORS.reset}`,
+  cyan: (text: string) => `${COLORS.cyan}${text}${COLORS.reset}`,
+  green: (text: string) => `${COLORS.green}${text}${COLORS.reset}`,
+  yellow: (text: string) => `${COLORS.yellow}${text}${COLORS.reset}`,
+  red: (text: string) => `${COLORS.red}${text}${COLORS.reset}`,
+  magenta: (text: string) => `${COLORS.magenta}${text}${COLORS.reset}`,
+};
+
+export function gradient(text: string): string {
+  const gradientColors = [
+    '\x1b[38;5;39m', // Cyan
+    '\x1b[38;5;45m', // Light cyan
+    '\x1b[38;5;50m', // Light green
+    '\x1b[38;5;82m', // Green
+  ];
+
+  let result = '';
+  for (let i = 0; i < text.length; i++) {
+    const colorIndex = Math.floor((i / text.length) * gradientColors.length);
+    result += `${gradientColors[Math.min(colorIndex, gradientColors.length - 1)]}${text[i]}`;
+  }
+  return `${result}${COLORS.reset}`;
+}
+
+export function divider(width = 55): string {
+  return colors.dim('─'.repeat(width));
+}

package/src/utils/logger.ts

@@ -0,0 +1,84 @@
+export enum LogLevel {
+  DEBUG = 0,
+  INFO = 1,
+  WARN = 2,
+  ERROR = 3,
+}
+
+const LOG_LEVEL_NAMES: Record<LogLevel, string> = {
+  [LogLevel.DEBUG]: 'DEBUG',
+  [LogLevel.INFO]: 'INFO',
+  [LogLevel.WARN]: 'WARN',
+  [LogLevel.ERROR]: 'ERROR',
+};
+
+let currentLogLevel = LogLevel.INFO;
+let isDebugMode = false;
+
+export function setLogLevel(level: LogLevel): void {
+  currentLogLevel = level;
+}
+
+export function setDebugMode(enabled: boolean): void {
+  isDebugMode = enabled;
+  if (enabled && currentLogLevel > LogLevel.DEBUG) {
+    currentLogLevel = LogLevel.DEBUG;
+  }
+}
+
+export function isDebugEnabled(): boolean {
+  return isDebugMode;
+}
+
+function shouldLog(level: LogLevel): boolean {
+  return level >= currentLogLevel;
+}
+
+function formatMessage(level: LogLevel, message: string, meta?: Record<string, unknown>): string {
+  const timestamp = new Date().toISOString();
+  const levelName = LOG_LEVEL_NAMES[level];
+  const metaStr = meta ? ` ${JSON.stringify(meta)}` : '';
+  return `[${timestamp}] [${levelName}] ${message}${metaStr}`;
+}
+
+export function debug(message: string, meta?: Record<string, unknown>): void {
+  if (shouldLog(LogLevel.DEBUG)) {
+    console.debug(formatMessage(LogLevel.DEBUG, message, meta));
+  }
+}
+
+export function info(message: string, meta?: Record<string, unknown>): void {
+  if (shouldLog(LogLevel.INFO)) {
+    console.info(formatMessage(LogLevel.INFO, message, meta));
+  }
+}
+
+export function warn(message: string, meta?: Record<string, unknown>): void {
+  if (shouldLog(LogLevel.WARN)) {
+    console.warn(formatMessage(LogLevel.WARN, message, meta));
+  }
+}
+
+export function error(
+  message: string,
+  error?: Error | unknown,
+  meta?: Record<string, unknown>
+): void {
+  if (shouldLog(LogLevel.ERROR)) {
+    const errorMeta =
+      error instanceof Error
+        ? { ...meta, errorName: error.name, errorMessage: error.message }
+        : { ...meta, error };
+    console.error(formatMessage(LogLevel.ERROR, message, errorMeta));
+  }
+}
+
+export const logger = {
+  debug,
+  info,
+  warn,
+  error,
+  setLogLevel,
+  setDebugMode,
+  isDebugEnabled,
+};

package/tests/config.test.ts

@@ -0,0 +1,95 @@
+import { describe, it, expect, beforeEach } from 'vitest';
+import { ConfigService } from '../src/config/config';
+import { resetLocale } from '../src/i18n';
+
+describe('ConfigService', () => {
+  let configService: ConfigService;
+
+  beforeEach(() => {
+    configService = new ConfigService();
+    configService.reset();
+    resetLocale();
+  });
+
+  describe('baseCurrency', () => {
+    it('should have default base currency', () => {
+      expect(configService.baseCurrency).toBeDefined();
+      expect(typeof configService.baseCurrency).toBe('string');
+    });
+
+    it('should set base currency', () => {
+      configService.baseCurrency = 'USD';
+      expect(configService.baseCurrency).toBe('USD');
+    });
+
+    it('should uppercase the base currency', () => {
+      configService.baseCurrency = 'usd';
+      expect(configService.baseCurrency).toBe('USD');
+    });
+  });
+
+  describe('favorites', () => {
+    it('should have default favorites', () => {
+      const favorites = configService.favorites;
+      expect(Array.isArray(favorites)).toBe(true);
+      expect(favorites.length).toBeGreaterThan(0);
+    });
+
+    it('should add a favorite', () => {
+      configService.addFavorite('BTC');
+      expect(configService.favorites).toContain('BTC');
+    });
+
+    it('should not add duplicate favorites', () => {
+      configService.addFavorite('BTC');
+      configService.addFavorite('btc');
+      const count = configService.favorites.filter(f => f === 'BTC').length;
+      expect(count).toBe(1);
+    });
+
+    it('should remove a favorite', () => {
+      configService.addFavorite('BTC');
+      configService.removeFavorite('BTC');
+      expect(configService.favorites).not.toContain('BTC');
+    });
+
+    it('should handle case-insensitive operations', () => {
+      configService.addFavorite('btc');
+      configService.removeFavorite('BTC');
+      expect(configService.favorites).not.toContain('BTC');
+    });
+  });
+
+  describe('locale', () => {
+    it('should have a locale property', () => {
+      const locale = configService.locale;
+      expect(locale).toBeDefined();
+      expect(typeof locale).toBe('string');
+    });
+
+    it('should set locale', () => {
+      configService.locale = 'tr';
+      expect(configService.locale).toBe('tr');
+    });
+  });
+
+  describe('getAll', () => {
+    it('should return all config values', () => {
+      const config = configService.getAll();
+      expect(config).toHaveProperty('baseCurrency');
+      expect(config).toHaveProperty('favorites');
+      expect(config).toHaveProperty('locale');
+    });
+  });
+
+  describe('reset', () => {
+    it('should reset all settings', () => {
+      configService.baseCurrency = 'USD';
+      configService.addFavorite('BTC');
+      configService.reset();
+
+      expect(configService.baseCurrency).toBeDefined();
+      expect(configService.favorites).toBeDefined();
+    });
+  });
+});