turkiyem 1.0.0

package/README.md

@@ -0,0 +1,129 @@
+# turkiyem
+
+Turkiye Toplu Tasima ve Deprem CLI araci.
+
+AFAD deprem verileri, EGO (Ankara) otobus saatleri ve IETT (Istanbul) GTFS hat bilgilerini terminalden sorgulayabilirsiniz.
+
+## Kurulum
+
+```bash
+npm install -g turkiyem
+```
+
+Veya yerel olarak:
+
+```bash
+git clone <repo-url>
+cd turkiyemCLI
+npm install
+npm link
+```
+
+## Gereksinimler
+
+- Node.js 20+
+
+## Kullanim
+
+### Banner ve Yardim
+
+```bash
+turkiyem
+turkiyem help
+```
+
+### Sehir Secimi
+
+Hat sorgulama icin once sehir secmelisiniz:
+
+```bash
+turkiyem sehir ankara
+turkiyem sehir istanbul
+```
+
+### Hat Sorgulama
+
+Secili sehre gore hat bilgilerini sorgular:
+
+```bash
+# Ankara (EGO)
+turkiyem sehir ankara
+turkiyem hat 340
+
+# Istanbul (IETT)
+turkiyem sehir istanbul
+turkiyem hat 34AS
+```
+
+Ankara icin EGO web sitesinden sefer saatleri cekilir.
+Istanbul icin IETT GTFS verilerinden hat bilgileri (durak sayisi, ilk/son durak) gosterilir.
+
+### Deprem Sorgulama
+
+AFAD API uzerinden gercek zamanli deprem verileri:
+
+```bash
+# Son 24 saat
+turkiyem deprem son24
+
+# Son 7 gun
+turkiyem deprem 7gun
+
+# Buyukluge gore filtrele (ornegin >= 4.0)
+turkiyem deprem buyukluk 4.0
+```
+
+Buyuklugu 4.0 ve ustu olan depremler kirmizi ile vurgulanir.
+
+### Temizleme
+
+Cache ve yapilandirmayi sifirlar:
+
+```bash
+turkiyem temizle
+```
+
+### Versiyon
+
+```bash
+turkiyem --version
+```
+
+## Yapilandirma
+
+Secili sehir `~/.turkiyem/config.json` dosyasinda saklanir. Bu dosya otomatik olusturulur.
+
+## Veri Kaynaklari
+
+| Kaynak | Aciklama |
+|--------|----------|
+| AFAD | Deprem verileri (deprem.afad.gov.tr) |
+| EGO | Ankara otobus sefer saatleri (ego.gov.tr) |
+| IETT | Istanbul GTFS hat verileri (data.ibb.gov.tr) |
+
+## npm Publish
+
+1. npm hesabiniza giris yapin:
+
+```bash
+npm login
+```
+
+2. package.json icindeki `name`, `version`, `author` alanlarini duzenleyin.
+
+3. Yayinlayin:
+
+```bash
+npm publish
+```
+
+4. Guncelleme icin versiyonu artirin:
+
+```bash
+npm version patch
+npm publish
+```
+
+## Lisans
+
+MIT

package/package.json

@@ -0,0 +1,45 @@
+{
+  "name": "turkiyem",
+  "version": "1.0.0",
+  "description": "Türkiye Toplu Taşıma ve Deprem CLI aracı - AFAD deprem verileri, EGO/IETT hat bilgileri",
+  "type": "module",
+  "main": "./src/index.js",
+  "bin": {
+    "turkiyem": "./src/index.js"
+  },
+  "scripts": {
+    "start": "node src/index.js",
+    "test": "echo \"No tests yet\""
+  },
+  "keywords": [
+    "turkiye",
+    "deprem",
+    "afad",
+    "iett",
+    "ego",
+    "toplu-tasima",
+    "cli",
+    "earthquake",
+    "transit"
+  ],
+  "author": "",
+  "license": "MIT",
+  "engines": {
+    "node": ">=20.0.0"
+  },
+  "dependencies": {
+    "axios": "^1.7.9",
+    "chalk": "^5.4.1",
+    "cheerio": "^1.0.0",
+    "cli-table3": "^0.6.5",
+    "commander": "^13.1.0",
+    "csv-parse": "^5.6.0",
+    "dotenv": "^16.4.7",
+    "node-cache": "^5.1.2",
+    "ora": "^8.2.0"
+  },
+  "files": [
+    "src/**/*",
+    "README.md"
+  ]
+}

package/src/commands/deprem.js

@@ -0,0 +1,67 @@
+import chalk from 'chalk';
+import ora from 'ora';
+import { fetchEarthquakes, fetchByMagnitude } from '../services/afadService.js';
+import { createEarthquakeTable } from '../utils/display.js';
+
+export async function depremSon24() {
+  const spinner = ora('AFAD verileri alınıyor (son 24 saat)...').start();
+
+  try {
+    const earthquakes = await fetchEarthquakes('son24');
+
+    if (!earthquakes || earthquakes.length === 0) {
+      spinner.info('Son 24 saatte kayıtlı deprem bulunamadı.');
+      return;
+    }
+
+    spinner.succeed(`${earthquakes.length} deprem bulundu (son 24 saat)`);
+    console.log('');
+    console.log(createEarthquakeTable(earthquakes));
+  } catch (err) {
+    spinner.fail(chalk.red(err.message));
+  }
+}
+
+export async function deprem7Gun() {
+  const spinner = ora('AFAD verileri alınıyor (son 7 gün)...').start();
+
+  try {
+    const earthquakes = await fetchEarthquakes('7gun');
+
+    if (!earthquakes || earthquakes.length === 0) {
+      spinner.info('Son 7 günde kayıtlı deprem bulunamadı.');
+      return;
+    }
+
+    spinner.succeed(`${earthquakes.length} deprem bulundu (son 7 gün)`);
+    console.log('');
+    console.log(createEarthquakeTable(earthquakes));
+  } catch (err) {
+    spinner.fail(chalk.red(err.message));
+  }
+}
+
+export async function depremBuyukluk(value) {
+  const min = parseFloat(value);
+  if (isNaN(min)) {
+    console.log(chalk.red('Geçerli bir büyüklük değeri girin. Örnek: turkiyem deprem buyukluk 4.0'));
+    return;
+  }
+
+  const spinner = ora(`Büyüklüğü >= ${min} olan depremler aranıyor...`).start();
+
+  try {
+    const earthquakes = await fetchByMagnitude(min);
+
+    if (!earthquakes || earthquakes.length === 0) {
+      spinner.info(`Büyüklüğü >= ${min} olan deprem bulunamadı (son 7 gün).`);
+      return;
+    }
+
+    spinner.succeed(`${earthquakes.length} deprem bulundu (büyüklük >= ${min})`);
+    console.log('');
+    console.log(createEarthquakeTable(earthquakes));
+  } catch (err) {
+    spinner.fail(chalk.red(err.message));
+  }
+}

package/src/commands/hat.js

@@ -0,0 +1,70 @@
+import chalk from 'chalk';
+import ora from 'ora';
+import { getCity } from '../utils/config.js';
+import { fetchEgoSchedule } from '../services/egoService.js';
+import { fetchIettRoute } from '../services/iettService.js';
+import { createEgoInfoTable, createEgoScheduleTable, createRouteTable } from '../utils/display.js';
+
+export async function hatSorgula(hatNo) {
+  if (!hatNo) {
+    console.log(chalk.red('Hat numarası belirtmelisiniz. Örnek: turkiyem hat 340'));
+    return;
+  }
+
+  const city = getCity();
+
+  if (!city) {
+    console.log(chalk.yellow('Henüz şehir seçmediniz. Önce şehir seçin:'));
+    console.log(chalk.cyan('  turkiyem sehir ankara'));
+    console.log(chalk.cyan('  turkiyem sehir istanbul'));
+    return;
+  }
+
+  if (city === 'ankara') {
+    await queryEgo(hatNo);
+  } else if (city === 'istanbul') {
+    await queryIett(hatNo);
+  } else {
+    console.log(chalk.red(`Desteklenmeyen şehir: ${city}. ankara veya istanbul seçin.`));
+  }
+}
+
+async function queryEgo(hatNo) {
+  const spinner = ora(`EGO hat ${hatNo} bilgileri alınıyor...`).start();
+
+  try {
+    const result = await fetchEgoSchedule(hatNo);
+
+    spinner.succeed(`Hat ${hatNo} bilgileri alındı`);
+    console.log('');
+
+    console.log(chalk.white.bold('  Hat Bilgileri'));
+    console.log(createEgoInfoTable(result.info));
+    console.log('');
+
+    if (result.schedule && result.schedule.length > 0) {
+      console.log(chalk.white.bold('  Sefer Saatleri'));
+      console.log(createEgoScheduleTable(result.schedule));
+    } else {
+      console.log(chalk.yellow('  Sefer saati bilgisi bulunamadı.'));
+    }
+  } catch (err) {
+    spinner.fail(chalk.red(err.message));
+  }
+}
+
+async function queryIett(hatNo) {
+  const spinner = ora(`IETT hat ${hatNo} bilgileri alınıyor (GTFS verileri indiriliyor)...`).start();
+
+  try {
+    const route = await fetchIettRoute(hatNo);
+
+    spinner.succeed(`Hat ${hatNo} bilgileri alındı`);
+    console.log('');
+
+    console.log(chalk.white.bold('  Hat Bilgileri (IETT)'));
+    console.log(createRouteTable(route));
+  } catch (err) {
+    spinner.fail(chalk.red(err.message));
+  }
+}

package/src/commands/sehir.js

@@ -0,0 +1,34 @@
+import chalk from 'chalk';
+import { setCity, getCity } from '../utils/config.js';
+
+const SUPPORTED_CITIES = ['ankara', 'istanbul'];
+
+export function sehirSec(city) {
+  if (!city) {
+    const current = getCity();
+    if (current) {
+      console.log(chalk.green(`Şu an seçili şehir: ${chalk.bold(current)}`));
+    } else {
+      console.log(chalk.yellow('Henüz şehir seçilmemiş.'));
+    }
+    console.log('');
+    console.log(chalk.white('Kullanım:'));
+    console.log(chalk.cyan('  turkiyem sehir ankara'));
+    console.log(chalk.cyan('  turkiyem sehir istanbul'));
+    return;
+  }
+
+  const normalized = city.toLowerCase().trim();
+
+  if (!SUPPORTED_CITIES.includes(normalized)) {
+    console.log(chalk.red(`"${city}" desteklenmiyor.`));
+    console.log(chalk.white('Desteklenen şehirler:'));
+    SUPPORTED_CITIES.forEach((c) => {
+      console.log(chalk.cyan(`  - ${c}`));
+    });
+    return;
+  }
+
+  setCity(normalized);
+  console.log(chalk.green(`Şehir "${chalk.bold(normalized)}" olarak ayarlandı.`));
+}

package/src/commands/temizle.js

@@ -0,0 +1,13 @@
+import chalk from 'chalk';
+import { flushCache } from '../utils/cache.js';
+import { resetConfig } from '../utils/config.js';
+
+export function temizle() {
+  try {
+    flushCache();
+    resetConfig();
+    console.log(chalk.green('Cache ve yapılandırma başarıyla temizlendi.'));
+  } catch (err) {
+    console.log(chalk.red(`Temizleme sırasında hata oluştu: ${err.message}`));
+  }
+}

package/src/index.js

@@ -0,0 +1,91 @@
+#!/usr/bin/env node
+
+import 'dotenv/config';
+import { Command } from 'commander';
+import { createRequire } from 'node:module';
+import { printBanner, printHelp } from './utils/banner.js';
+import { sehirSec } from './commands/sehir.js';
+import { hatSorgula } from './commands/hat.js';
+import { depremSon24, deprem7Gun, depremBuyukluk } from './commands/deprem.js';
+import { temizle } from './commands/temizle.js';
+
+const require = createRequire(import.meta.url);
+const pkg = require('../package.json');
+
+process.on('unhandledRejection', (err) => {
+  console.error('Beklenmeyen hata:', err?.message || err);
+  process.exit(1);
+});
+
+process.on('uncaughtException', (err) => {
+  console.error('Kritik hata:', err?.message || err);
+  process.exit(1);
+});
+
+const program = new Command();
+
+program
+  .name('turkiyem')
+  .description('Türkiye Toplu Taşıma ve Deprem CLI')
+  .version(pkg.version, '-v, --version', 'Versiyon göster')
+  .helpOption('-h, --help', 'Yardım göster')
+  .addHelpCommand(false);
+
+program
+  .command('sehir [sehir]')
+  .description('Şehir seç (ankara veya istanbul)')
+  .action((sehir) => {
+    sehirSec(sehir);
+  });
+
+program
+  .command('hat <numara>')
+  .description('Hat bilgilerini sorgula')
+  .action(async (numara) => {
+    await hatSorgula(numara);
+  });
+
+const depremCmd = program
+  .command('deprem')
+  .description('Deprem verileri sorgula');
+
+depremCmd
+  .command('son24')
+  .description('Son 24 saat depremler')
+  .action(async () => {
+    await depremSon24();
+  });
+
+depremCmd
+  .command('7gun')
+  .description('Son 7 gün depremler')
+  .action(async () => {
+    await deprem7Gun();
+  });
+
+depremCmd
+  .command('buyukluk <deger>')
+  .description('Büyüklüğe göre filtrele (ör: 4.0)')
+  .action(async (deger) => {
+    await depremBuyukluk(deger);
+  });
+
+program
+  .command('temizle')
+  .description('Cache ve yapılandırmayı temizle')
+  .action(() => {
+    temizle();
+  });
+
+program
+  .command('help')
+  .description('Yardım göster')
+  .action(() => {
+    printHelp();
+  });
+
+if (process.argv.length <= 2) {
+  printHelp();
+} else {
+  program.parse(process.argv);
+}

package/src/services/afadService.js

@@ -0,0 +1,110 @@
+import axios from 'axios';
+import { getCached, setCached } from '../utils/cache.js';
+
+const AFAD_URL = 'https://deprem.afad.gov.tr/apiv2/event/filter';
+
+function formatISODate(date) {
+  return date.toISOString().replace(/\.\d{3}Z$/, '');
+}
+
+function computeTimeRange(period) {
+  const end = new Date();
+  const start = new Date();
+
+  if (period === 'son24') {
+    start.setHours(start.getHours() - 24);
+  } else if (period === '7gun') {
+    start.setDate(start.getDate() - 7);
+  } else {
+    start.setDate(start.getDate() - 1);
+  }
+
+  return { start: formatISODate(start), end: formatISODate(end) };
+}
+
+function normalizeQuake(raw) {
+  return {
+    magnitude: raw.magnitude ?? raw.mag ?? raw.Magnitude ?? '-',
+    depth: raw.depth ?? raw.Depth ?? raw.derinlik ?? '-',
+    location: raw.location ?? raw.Location ?? raw.title ?? raw.yer ?? '-',
+    date: raw.date ?? raw.Date ?? raw.eventDate ?? '-',
+    latitude: raw.latitude ?? raw.Latitude ?? '-',
+    longitude: raw.longitude ?? raw.Longitude ?? '-',
+    type: raw.type ?? raw.Type ?? '-',
+  };
+}
+
+export async function fetchEarthquakes(period, limit = 20) {
+  const cacheKey = `afad_${period}_${limit}`;
+  const cached = getCached(cacheKey);
+  if (cached) return cached;
+
+  const { start, end } = computeTimeRange(period);
+
+  const params = {
+    start,
+    end,
+    format: 'json',
+    limit,
+    orderby: 'timedesc',
+  };
+
+  try {
+    const response = await axios.get(AFAD_URL, {
+      params,
+      timeout: 15000,
+      maxRedirects: 5,
+      headers: {
+        'User-Agent': 'turkiyem-cli/1.0',
+        'Accept': 'application/json',
+      },
+      validateStatus(status) {
+        return status >= 200 && status < 600;
+      },
+    });
+
+    if (response.status === 500) {
+      const body = response.data;
+      if (body && body.status === 400) {
+        throw new Error(`AFAD API hata döndürdü: ${body.message || 'Geçersiz istek parametreleri'}`);
+      }
+      throw new Error(`AFAD API sunucu hatası (HTTP 500)`);
+    }
+
+    if (response.status < 200 || response.status >= 300) {
+      throw new Error(`AFAD API HTTP ${response.status} hatası döndürdü`);
+    }
+
+    const data = response.data;
+
+    if (!Array.isArray(data)) {
+      throw new Error('AFAD API beklenmeyen yanıt formatı döndürdü');
+    }
+
+    const earthquakes = data.map(normalizeQuake);
+    setCached(cacheKey, earthquakes);
+    return earthquakes;
+  } catch (err) {
+    if (err.code === 'ECONNABORTED') {
+      throw new Error('AFAD API isteği zaman aşımına uğradı. Lütfen tekrar deneyin.');
+    }
+    if (err.code === 'ENOTFOUND' || err.code === 'ECONNREFUSED') {
+      throw new Error('AFAD API sunucusuna bağlanılamıyor. İnternet bağlantınızı kontrol edin.');
+    }
+    throw err;
+  }
+}
+
+export async function fetchByMagnitude(minMagnitude) {
+  const cacheKey = `afad_mag_${minMagnitude}`;
+  const cached = getCached(cacheKey);
+  if (cached) return cached;
+
+  const earthquakes = await fetchEarthquakes('7gun', 100);
+  const filtered = earthquakes.filter(
+    (eq) => parseFloat(eq.magnitude) >= parseFloat(minMagnitude)
+  );
+
+  setCached(cacheKey, filtered);
+  return filtered;
+}

package/src/services/egoService.js

@@ -0,0 +1,124 @@
+import axios from 'axios';
+import * as cheerio from 'cheerio';
+import { getCached, setCached } from '../utils/cache.js';
+
+const EGO_URL = 'https://www.ego.gov.tr/hareketsaatleri';
+
+function parseInfoTable($) {
+  const info = {
+    hatNo: '',
+    hatAdi: '',
+    kalkis: '',
+    varis: '',
+    mesafe: '',
+    sure: '',
+  };
+
+  const infoTable = $('.hatbilgileri table');
+  if (!infoTable.length) return info;
+
+  infoTable.find('tr').each((_, row) => {
+    const cells = $(row).find('td');
+    if (cells.length >= 3) {
+      const label = $(cells[0]).text().trim().toLowerCase();
+      const value = $(cells[2]).text().trim();
+
+      if (label.includes('hat no')) info.hatNo = value;
+      else if (label.includes('hat adı') || label.includes('hat ismi')) info.hatAdi = value;
+      else if (label.includes('kalkış')) info.kalkis = value;
+      else if (label.includes('varış')) info.varis = value;
+      else if (label.includes('mesafe')) info.mesafe = value;
+      else if (label.includes('süre')) info.sure = value;
+    }
+  });
+
+  return info;
+}
+
+function parseScheduleTable($, hatNo) {
+  const schedule = [];
+  const scheduleTable = $('.hareket-saatleri table');
+  if (!scheduleTable.length) return schedule;
+
+  const headers = [];
+  scheduleTable.find('th').each((_, th) => {
+    headers.push($(th).text().trim());
+  });
+
+  const dataRow = scheduleTable.find('tr').last();
+  const cells = dataRow.find('td');
+
+  cells.each((i, cell) => {
+    const raw = $(cell).html() || '';
+    const times = raw
+      .split(/<br\s*\/?>/i)
+      .map((t) => t.replace(/<[^>]*>/g, '').trim())
+      .filter((t) => t.length > 0)
+      .map((t) => t.replace(/\s*-\s*$/, '').trim())
+      .filter((t) => t.length > 0);
+
+    if (times.length > 0) {
+      const gunTipi = headers[i] || ['Hafta içi', 'Cumartesi', 'Pazar'][i] || `Sütun ${i + 1}`;
+      schedule.push({
+        hat: String(hatNo),
+        gunTipi,
+        saatler: times.join(', '),
+      });
+    }
+  });
+
+  return schedule;
+}
+
+export async function fetchEgoSchedule(hatNo) {
+  const cacheKey = `ego_${hatNo}`;
+  const cached = getCached(cacheKey);
+  if (cached) return cached;
+
+  try {
+    const response = await axios.get(EGO_URL, {
+      params: { hat_no: hatNo },
+      timeout: 15000,
+      maxRedirects: 5,
+      headers: {
+        'User-Agent': 'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/120.0.0.0 Safari/537.36',
+        'Accept': 'text/html,application/xhtml+xml,application/xml;q=0.9,*/*;q=0.8',
+        'Accept-Language': 'tr-TR,tr;q=0.9,en-US;q=0.8,en;q=0.7',
+      },
+      responseType: 'text',
+    });
+
+    if (response.status !== 200) {
+      throw new Error(`EGO sunucusu HTTP ${response.status} döndürdü`);
+    }
+
+    const html = response.data;
+    if (!html || html.length < 100) {
+      throw new Error('EGO sunucusundan geçerli yanıt alınamadı');
+    }
+
+    const $ = cheerio.load(html);
+    const info = parseInfoTable($);
+
+    if (!info.hatNo) {
+      info.hatNo = String(hatNo);
+    }
+
+    const schedule = parseScheduleTable($, hatNo);
+
+    const result = { info, schedule };
+    setCached(cacheKey, result);
+    return result;
+  } catch (err) {
+    if (err.code === 'ECONNABORTED') {
+      throw new Error('EGO sunucusu isteği zaman aşımına uğradı. Lütfen tekrar deneyin.');
+    }
+    if (err.code === 'ENOTFOUND' || err.code === 'ECONNREFUSED') {
+      throw new Error('EGO sunucusuna bağlanılamıyor. İnternet bağlantınızı kontrol edin.');
+    }
+    if (err.response && err.response.status === 404) {
+      throw new Error(`Hat numarası "${hatNo}" bulunamadı.`);
+    }
+    throw err;
+  }
+}

package/src/services/iettService.js

@@ -0,0 +1,153 @@
+import axios from 'axios';
+import { getCached, setCached } from '../utils/cache.js';
+
+const DATASTORE_SQL_URL = 'https://data.ibb.gov.tr/api/3/action/datastore_search_sql';
+const DATASTORE_SEARCH_URL = 'https://data.ibb.gov.tr/api/3/action/datastore_search';
+
+const RESOURCE_IDS = {
+  routes: '46dbe388-c8c2-45c4-ac72-c06953de56a2',
+  trips: '7ff49bdd-b0d2-4a6e-9392-b598f77f5070',
+  stopTimes: '23778613-16fe-4d30-b8b8-8ca934ed2978',
+  stops: '2299bc82-983b-4bdf-8520-5cef8c555e29',
+};
+
+const API_TIMEOUT = 30000;
+const API_HEADERS = { 'User-Agent': 'turkiyem-cli/1.0' };
+
+function escapeSQL(str) {
+  return str.replace(/'/g, "''");
+}
+
+async function datastoreSQL(sql) {
+  try {
+    const response = await axios.get(DATASTORE_SQL_URL, {
+      params: { sql },
+      timeout: API_TIMEOUT,
+      headers: API_HEADERS,
+    });
+
+    if (!response.data?.success) {
+      throw new Error('IETT SQL sorgusu başarısız');
+    }
+
+    return response.data.result.records;
+  } catch (err) {
+    if (err.response?.status === 403) {
+      throw new Error('IETT veri kaynağı erişim engeli (403 Forbidden). Lütfen daha sonra tekrar deneyin.');
+    }
+    if (err.code === 'ECONNABORTED') {
+      throw new Error('IETT veri kaynağı zaman aşımına uğradı. Lütfen tekrar deneyin.');
+    }
+    throw err;
+  }
+}
+
+async function datastoreSearch(resourceId, options = {}) {
+  const params = {
+    resource_id: resourceId,
+    limit: options.limit || 100,
+  };
+
+  if (options.filters) params.filters = JSON.stringify(options.filters);
+  if (options.sort) params.sort = options.sort;
+
+  try {
+    const response = await axios.get(DATASTORE_SEARCH_URL, {
+      params,
+      timeout: API_TIMEOUT,
+      headers: API_HEADERS,
+    });
+
+    if (!response.data?.success) {
+      throw new Error('IETT veri kaynağı başarısız yanıt döndürdü');
+    }
+
+    return response.data.result;
+  } catch (err) {
+    if (err.response?.status === 403) {
+      throw new Error('IETT veri kaynağı erişim engeli (403 Forbidden). Lütfen daha sonra tekrar deneyin.');
+    }
+    if (err.code === 'ECONNABORTED') {
+      throw new Error('IETT veri kaynağı zaman aşımına uğradı. Lütfen tekrar deneyin.');
+    }
+    throw err;
+  }
+}
+
+function extractStopsFromName(longName) {
+  if (!longName || longName === '-') return { first: '-', last: '-' };
+
+  const separators = [' - ', ' – ', '-'];
+  for (const sep of separators) {
+    const parts = longName.split(sep).map((p) => p.trim()).filter(Boolean);
+    if (parts.length >= 2) {
+      return { first: parts[0], last: parts[parts.length - 1] };
+    }
+  }
+
+  return { first: longName, last: '-' };
+}
+
+async function tryGetStopCount(routeId) {
+  try {
+    const tripsResult = await datastoreSearch(RESOURCE_IDS.trips, {
+      filters: { route_id: routeId },
+      limit: 10,
+    });
+
+    const trips = tripsResult.records;
+    if (trips.length === 0) return 0;
+
+    for (const trip of trips) {
+      const stResult = await datastoreSearch(RESOURCE_IDS.stopTimes, {
+        filters: { trip_id: trip.trip_id },
+        limit: 1,
+      });
+
+      if (stResult.total > 0) {
+        return stResult.total;
+      }
+    }
+
+    return 0;
+  } catch {
+    return 0;
+  }
+}
+
+export async function fetchIettRoute(routeCode) {
+  const cacheKey = `iett_route_${routeCode.toUpperCase()}`;
+  const cached = getCached(cacheKey);
+  if (cached) return cached;
+
+  const code = routeCode.toUpperCase();
+  const sql = `SELECT * FROM "${RESOURCE_IDS.routes}" WHERE UPPER(route_short_name)='${escapeSQL(code)}' LIMIT 20`;
+  const routes = await datastoreSQL(sql);
+
+  if (!routes || routes.length === 0) {
+    throw new Error(`"${routeCode}" hat numarası IETT verilerinde bulunamadı.`);
+  }
+
+  const route = routes[0];
+  const { first, last } = extractStopsFromName(route.route_long_name);
+
+  const routeCount = routes.length;
+  const directions = routes
+    .map((r) => r.route_long_name)
+    .filter((v, i, a) => a.indexOf(v) === i);
+
+  const stopCount = await tryGetStopCount(route.route_id);
+
+  const result = {
+    routeShortName: route.route_short_name || code,
+    routeLongName: route.route_long_name || '-',
+    stopCount,
+    firstStop: first,
+    lastStop: last,
+    routeVariants: routeCount,
+    directions,
+  };
+
+  setCached(cacheKey, result);
+  return result;
+}

package/src/utils/banner.js

@@ -0,0 +1,31 @@
+import chalk from 'chalk';
+
+const BANNER = `
+${chalk.red.bold('  ████████╗██╗   ██╗██████╗ ██╗  ██╗██╗██╗   ██╗███████╗███╗   ███╗')}
+${chalk.red.bold('  ╚══██╔══╝██║   ██║██╔══██╗██║ ██╔╝██║╚██╗ ██╔╝██╔════╝████╗ ████║')}
+${chalk.red.bold('     ██║   ██║   ██║██████╔╝█████╔╝ ██║ ╚████╔╝ █████╗  ██╔████╔██║')}
+${chalk.red.bold('     ██║   ██║   ██║██╔══██╗██╔═██╗ ██║  ╚██╔╝  ██╔══╝  ██║╚██╔╝██║')}
+${chalk.red.bold('     ██║   ╚██████╔╝██║  ██║██║  ██╗██║   ██║   ███████╗██║ ╚═╝ ██║')}
+${chalk.red.bold('     ╚═╝    ╚═════╝ ╚═╝  ╚═╝╚═╝  ╚═╝╚═╝   ╚═╝   ╚══════╝╚═╝     ╚═╝')}
+
+                          ${chalk.white.bold('☾ ★')}
+
+       ${chalk.gray('Türkiye Toplu Taşıma ve Deprem CLI')}
+`;
+
+export function printBanner() {
+  console.log(BANNER);
+}
+
+export function printHelp() {
+  printBanner();
+  console.log(chalk.white.bold('  Komutlar:\n'));
+  console.log(chalk.cyan('    turkiyem sehir <ankara|istanbul>') + chalk.gray('  Şehir seç'));
+  console.log(chalk.cyan('    turkiyem hat <numara>') + chalk.gray('             Hat sorgula'));
+  console.log(chalk.cyan('    turkiyem deprem son24') + chalk.gray('             Son 24 saat depremler'));
+  console.log(chalk.cyan('    turkiyem deprem 7gun') + chalk.gray('              Son 7 gün depremler'));
+  console.log(chalk.cyan('    turkiyem deprem buyukluk <deger>') + chalk.gray('  Büyüklüğe göre filtrele'));
+  console.log(chalk.cyan('    turkiyem temizle') + chalk.gray('                  Cache ve config temizle'));
+  console.log(chalk.cyan('    turkiyem --version') + chalk.gray('                Versiyon göster'));
+  console.log('');
+}

package/src/utils/cache.js

@@ -0,0 +1,21 @@
+import NodeCache from 'node-cache';
+
+const cache = new NodeCache({ stdTTL: 300, checkperiod: 60 });
+
+export function getCached(key) {
+  return cache.get(key) || null;
+}
+
+export function setCached(key, value, ttl) {
+  if (ttl !== undefined) {
+    cache.set(key, value, ttl);
+  } else {
+    cache.set(key, value);
+  }
+}
+
+export function flushCache() {
+  cache.flushAll();
+}
+
+export default cache;

package/src/utils/config.js

@@ -0,0 +1,54 @@
+import fs from 'node:fs';
+import path from 'node:path';
+import os from 'node:os';
+
+const CONFIG_DIR = path.join(os.homedir(), '.turkiyem');
+const CONFIG_FILE = path.join(CONFIG_DIR, 'config.json');
+
+const DEFAULT_CONFIG = { city: null };
+
+function ensureDir() {
+  fs.mkdirSync(CONFIG_DIR, { recursive: true });
+}
+
+export function readConfig() {
+  try {
+    ensureDir();
+    if (!fs.existsSync(CONFIG_FILE)) {
+      writeConfig(DEFAULT_CONFIG);
+      return { ...DEFAULT_CONFIG };
+    }
+    const raw = fs.readFileSync(CONFIG_FILE, 'utf-8');
+    const parsed = JSON.parse(raw);
+    if (typeof parsed !== 'object' || parsed === null) {
+      writeConfig(DEFAULT_CONFIG);
+      return { ...DEFAULT_CONFIG };
+    }
+    return parsed;
+  } catch {
+    writeConfig(DEFAULT_CONFIG);
+    return { ...DEFAULT_CONFIG };
+  }
+}
+
+export function writeConfig(config) {
+  ensureDir();
+  fs.writeFileSync(CONFIG_FILE, JSON.stringify(config, null, 2), 'utf-8');
+}
+
+export function getCity() {
+  const config = readConfig();
+  return config.city || null;
+}
+
+export function setCity(city) {
+  const config = readConfig();
+  config.city = city;
+  writeConfig(config);
+}
+
+export function resetConfig() {
+  writeConfig({ ...DEFAULT_CONFIG });
+}
+
+export { CONFIG_DIR, CONFIG_FILE };

package/src/utils/display.js

@@ -0,0 +1,103 @@
+import Table from 'cli-table3';
+import chalk from 'chalk';
+
+export function createEarthquakeTable(earthquakes) {
+  const table = new Table({
+    head: [
+      chalk.white.bold('Tarih'),
+      chalk.white.bold('Büyüklük'),
+      chalk.white.bold('Derinlik (km)'),
+      chalk.white.bold('Konum'),
+    ],
+    colWidths: [22, 12, 15, 45],
+    style: { head: [], border: ['gray'] },
+  });
+
+  for (const eq of earthquakes) {
+    const mag = parseFloat(eq.magnitude);
+    const magStr = mag >= 4.0
+      ? chalk.red.bold(mag.toFixed(1))
+      : chalk.yellow(mag.toFixed(1));
+
+    const row = [
+      eq.date,
+      magStr,
+      eq.depth,
+      eq.location,
+    ];
+
+    table.push(row);
+  }
+
+  return table.toString();
+}
+
+export function createEgoScheduleTable(schedule) {
+  const table = new Table({
+    head: [
+      chalk.white.bold('Hat'),
+      chalk.white.bold('Gün Tipi'),
+      chalk.white.bold('Kalkış Saatleri'),
+    ],
+    colWidths: [10, 14, 70],
+    style: { head: [], border: ['gray'] },
+    wordWrap: true,
+  });
+
+  for (const row of schedule) {
+    table.push([row.hat, row.gunTipi, row.saatler]);
+  }
+
+  return table.toString();
+}
+
+export function createEgoInfoTable(info) {
+  const table = new Table({
+    style: { head: [], border: ['gray'] },
+  });
+
+  table.push(
+    { [chalk.cyan('Hat No')]: info.hatNo || '-' },
+    { [chalk.cyan('Hat Adı')]: info.hatAdi || '-' },
+    { [chalk.cyan('Kalkış')]: info.kalkis || '-' },
+    { [chalk.cyan('Varış')]: info.varis || '-' },
+    { [chalk.cyan('Mesafe')]: info.mesafe || '-' },
+    { [chalk.cyan('Süre')]: info.sure || '-' },
+  );
+
+  return table.toString();
+}
+
+export function createRouteTable(route) {
+  const table = new Table({
+    style: { head: [], border: ['gray'] },
+  });
+
+  table.push(
+    { [chalk.cyan('Hat Kısa Adı')]: route.routeShortName || '-' },
+    { [chalk.cyan('Hat Uzun Adı')]: route.routeLongName || '-' },
+  );
+
+  if (route.stopCount > 0) {
+    table.push({ [chalk.cyan('Durak Sayısı')]: String(route.stopCount) });
+  }
+
+  table.push(
+    { [chalk.cyan('İlk Durak')]: route.firstStop || '-' },
+    { [chalk.cyan('Son Durak')]: route.lastStop || '-' },
+  );
+
+  if (route.directions && route.directions.length > 1) {
+    table.push({
+      [chalk.cyan('Güzergahlar')]: route.directions.join('\n'),
+    });
+  }
+
+  if (route.routeVariants && route.routeVariants > 1) {
+    table.push({
+      [chalk.cyan('Varyant Sayısı')]: String(route.routeVariants),
+    });
+  }
+
+  return table.toString();
+}