turkiyem 1.2.0 → 1.4.0

package/README.md

@@ -3,6 +3,7 @@
 Turkiye Toplu Tasima ve Deprem CLI araci.
 
 AFAD deprem verileri, EGO (Ankara) otobus saatleri ve IETT (Istanbul) hat/saat bilgilerini terminalden sorgulayabilirsiniz.
+Open-Meteo ile API key gerektirmeden guncel hava, saatlik tahmin ve hava kalitesi sorgulayabilirsiniz.
 
 ## Kurulum
 
@@ -81,6 +82,30 @@ turkiyem deprem buyukluk 4.0
 
 Buyuklugu 4.0 ve ustu olan depremler kirmizi ile vurgulanir.
 
+### Hava Durumu ve Hava Kalitesi
+
+Open-Meteo uzerinden API key gerektirmeden sorgu yapar:
+
+```bash
+# Secili sehir icin guncel hava
+turkiyem hava guncel
+
+# Sehir bazli guncel hava
+turkiyem hava guncel istanbul
+
+# Koordinat bazli guncel hava
+turkiyem hava guncel 41.0082,28.9784
+
+# Saatlik tahmin (varsayilan 2 gun)
+turkiyem hava saatlik istanbul
+
+# Saatlik tahmin gun sayisi (1-7)
+turkiyem hava saatlik istanbul --gun 3
+
+# Hava kalitesi
+turkiyem hava kalite ankara
+```
+
 ### Temizleme
 
 Cache ve yapilandirmayi sifirlar:
@@ -107,6 +132,8 @@ Secili sehir `~/.turkiyem/config.json` dosyasinda saklanir. Bu dosya otomatik ol
 | EGO | Ankara otobus sefer saatleri (ego.gov.tr) |
 | IETT | Istanbul GTFS hat verileri (data.ibb.gov.tr) |
 | IETT SOAP | Planlanan sefer saatleri (api.ibb.gov.tr) |
+| Open-Meteo | Guncel hava ve saatlik tahmin (api.open-meteo.com) |
+| Open-Meteo AQ | Hava kalitesi (air-quality-api.open-meteo.com) |
 
 ## npm Publish
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "turkiyem",
-  "version": "1.2.0",
+  "version": "1.4.0",
   "description": "Türkiye Toplu Taşıma ve Deprem CLI aracı - AFAD deprem verileri, EGO hat saatleri ve IETT SOAP/GTFS bilgileri",
   "type": "module",
   "main": "./src/index.js",
@@ -21,7 +21,10 @@
     "cli",
     "earthquake",
     "transit",
-    "soap"
+    "soap",
+    "weather",
+    "open-meteo",
+    "air-quality"
   ],
   "author": "",
   "license": "MIT",

package/src/commands/hava.js

@@ -0,0 +1,58 @@
+import chalk from 'chalk';
+import ora from 'ora';
+import { fetchAirQuality, fetchCurrentWeather, fetchHourlyForecast } from '../services/weatherService.js';
+import {
+  createAirQualityTable,
+  createCurrentWeatherTable,
+  createHourlyWeatherTable,
+} from '../utils/display.js';
+
+function formatLocationHint(city) {
+  if (city) return city;
+  return 'seçili şehir';
+}
+
+export async function havaGuncel(city) {
+  const spinner = ora(`Güncel hava verisi alınıyor (${formatLocationHint(city)})...`).start();
+
+  try {
+    const result = await fetchCurrentWeather(city);
+    spinner.succeed('Güncel hava verisi alındı');
+    console.log('');
+    console.log(createCurrentWeatherTable(result));
+  } catch (err) {
+    spinner.fail(chalk.red(err.message));
+  }
+}
+
+export async function havaSaatlik(city, days) {
+  const parsedDays = Number.parseInt(days, 10);
+  if (!Number.isNaN(parsedDays) && (parsedDays < 1 || parsedDays > 7)) {
+    console.log(chalk.red('Gün sayısı 1 ile 7 arasında olmalıdır.'));
+    return;
+  }
+
+  const spinner = ora(`Saatlik tahmin verisi alınıyor (${formatLocationHint(city)})...`).start();
+
+  try {
+    const result = await fetchHourlyForecast(city, parsedDays || 2);
+    spinner.succeed(`Saatlik tahmin verisi alındı (${result.forecastDays} gün)`);
+    console.log('');
+    console.log(createHourlyWeatherTable(result));
+  } catch (err) {
+    spinner.fail(chalk.red(err.message));
+  }
+}
+
+export async function havaKalitesi(city) {
+  const spinner = ora(`Hava kalitesi verisi alınıyor (${formatLocationHint(city)})...`).start();
+
+  try {
+    const result = await fetchAirQuality(city);
+    spinner.succeed('Hava kalitesi verisi alındı');
+    console.log('');
+    console.log(createAirQualityTable(result));
+  } catch (err) {
+    spinner.fail(chalk.red(err.message));
+  }
+}

package/src/index.js

@@ -7,6 +7,7 @@ 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 { havaGuncel, havaKalitesi, havaSaatlik } from './commands/hava.js';
 import { temizle } from './commands/temizle.js';
 
 const require = createRequire(import.meta.url);
@@ -70,6 +71,32 @@ depremCmd
     await depremBuyukluk(deger);
   });
 
+const havaCmd = program
+  .command('hava')
+  .description('Hava durumu ve hava kalitesi sorgula');
+
+havaCmd
+  .command('guncel [sehirVeyaKoordinat]')
+  .description('Güncel sıcaklık, rüzgar ve nem bilgisi')
+  .action(async (sehirVeyaKoordinat) => {
+    await havaGuncel(sehirVeyaKoordinat);
+  });
+
+havaCmd
+  .command('saatlik [sehirVeyaKoordinat]')
+  .description('Saatlik hava tahmini (varsayılan 2 gün)')
+  .option('-g, --gun <gun>', 'Tahmin gün sayısı (1-7)', '2')
+  .action(async (sehirVeyaKoordinat, options) => {
+    await havaSaatlik(sehirVeyaKoordinat, options.gun);
+  });
+
+havaCmd
+  .command('kalite [sehirVeyaKoordinat]')
+  .description('Güncel hava kalitesi (PM10, PM2.5, CO, NO2)')
+  .action(async (sehirVeyaKoordinat) => {
+    await havaKalitesi(sehirVeyaKoordinat);
+  });
+
 program
   .command('temizle')
   .description('Cache ve yapılandırmayı temizle')

package/src/services/weatherService.js

@@ -0,0 +1,274 @@
+import axios from 'axios';
+import { CACHE_TTL, getCached, setCached } from '../utils/cache.js';
+import { getCity } from '../utils/config.js';
+
+const FORECAST_URL = 'https://api.open-meteo.com/v1/forecast';
+const AIR_QUALITY_URL = 'https://air-quality-api.open-meteo.com/v1/air-quality';
+const GEOCODING_URL = 'https://geocoding-api.open-meteo.com/v1/search';
+
+const REQUEST_TIMEOUT = 15000;
+
+function isCoordinateInput(value) {
+  return /^-?\d+(\.\d+)?,\s*-?\d+(\.\d+)?$/.test(value);
+}
+
+function parseCoordinates(value) {
+  const [latRaw, lonRaw] = value.split(',');
+  const latitude = Number.parseFloat(latRaw.trim());
+  const longitude = Number.parseFloat(lonRaw.trim());
+
+  if (
+    Number.isNaN(latitude)
+    || Number.isNaN(longitude)
+    || latitude < -90
+    || latitude > 90
+    || longitude < -180
+    || longitude > 180
+  ) {
+    throw new Error('Koordinatlar geçersiz. Örnek: 41.0082,28.9784');
+  }
+
+  return { latitude, longitude };
+}
+
+async function fetchGeocodeByName(cityName) {
+  const cacheKey = `geo_${cityName.toLowerCase()}`;
+  const cached = getCached(cacheKey);
+  if (cached) return cached;
+
+  const response = await axios.get(GEOCODING_URL, {
+    params: {
+      name: cityName,
+      count: 1,
+      language: 'tr',
+      format: 'json',
+    },
+    timeout: REQUEST_TIMEOUT,
+  });
+
+  if (response.status !== 200 || !response.data) {
+    throw new Error('Open-Meteo geocoding yanıtı alınamadı.');
+  }
+
+  const first = response.data.results?.[0];
+  if (!first) {
+    throw new Error(`"${cityName}" için konum bulunamadı.`);
+  }
+
+  const normalized = {
+    name: [first.name, first.admin1, first.country].filter(Boolean).join(', '),
+    latitude: first.latitude,
+    longitude: first.longitude,
+    timezone: first.timezone || 'auto',
+  };
+
+  setCached(cacheKey, normalized, CACHE_TTL.DEFAULT);
+  return normalized;
+}
+
+export async function resolveLocation(inputCity) {
+  const raw = (inputCity || getCity() || '').trim();
+  if (!raw) {
+    throw new Error('Şehir belirtilmedi. Örnek: turkiyem hava guncel istanbul');
+  }
+
+  if (isCoordinateInput(raw)) {
+    const coords = parseCoordinates(raw);
+    return {
+      name: `${coords.latitude},${coords.longitude}`,
+      latitude: coords.latitude,
+      longitude: coords.longitude,
+      timezone: 'auto',
+    };
+  }
+
+  return fetchGeocodeByName(raw);
+}
+
+function buildHourlyRows(hourly, limitCount) {
+  const times = hourly.time || [];
+  const temperatures = hourly.temperature_2m || [];
+  const apparent = hourly.apparent_temperature || [];
+  const precipitation = hourly.precipitation_probability || [];
+
+  const size = Math.min(times.length, temperatures.length, apparent.length, precipitation.length, limitCount);
+  const rows = [];
+
+  for (let i = 0; i < size; i += 1) {
+    rows.push({
+      time: times[i],
+      temperature: temperatures[i],
+      apparentTemperature: apparent[i],
+      precipitationProbability: precipitation[i],
+    });
+  }
+
+  return rows;
+}
+
+function findClosestIndex(timeValues) {
+  if (!Array.isArray(timeValues) || timeValues.length === 0) return -1;
+
+  const nowTs = Date.now();
+  let bestIndex = 0;
+  let bestDelta = Number.POSITIVE_INFINITY;
+
+  for (let i = 0; i < timeValues.length; i += 1) {
+    const ts = new Date(timeValues[i]).getTime();
+    if (Number.isNaN(ts)) continue;
+    const delta = Math.abs(nowTs - ts);
+    if (delta < bestDelta) {
+      bestDelta = delta;
+      bestIndex = i;
+    }
+  }
+
+  return bestIndex;
+}
+
+function normalizeAxiosError(err, sourceName) {
+  if (err?.code === 'ECONNABORTED') {
+    throw new Error(`${sourceName} isteği zaman aşımına uğradı.`);
+  }
+  if (err?.code === 'ENOTFOUND' || err?.code === 'ECONNREFUSED') {
+    throw new Error(`${sourceName} sunucusuna bağlanılamadı.`);
+  }
+  if (err?.response?.status) {
+    throw new Error(`${sourceName} HTTP ${err.response.status} hatası döndürdü.`);
+  }
+  throw err;
+}
+
+export async function fetchCurrentWeather(inputCity) {
+  const location = await resolveLocation(inputCity);
+  const cacheKey = `weather_current_${location.latitude}_${location.longitude}`;
+  const cached = getCached(cacheKey);
+  if (cached) return cached;
+
+  try {
+    const response = await axios.get(FORECAST_URL, {
+      params: {
+        latitude: location.latitude,
+        longitude: location.longitude,
+        current: 'temperature_2m,wind_speed_10m,relative_humidity_2m',
+        timezone: location.timezone || 'auto',
+      },
+      timeout: REQUEST_TIMEOUT,
+    });
+
+    if (response.status !== 200 || !response.data?.current) {
+      throw new Error('Güncel hava verisi alınamadı.');
+    }
+
+    const result = {
+      locationName: location.name,
+      latitude: location.latitude,
+      longitude: location.longitude,
+      timezone: response.data.timezone || location.timezone || 'auto',
+      current: {
+        time: response.data.current.time,
+        temperature: response.data.current.temperature_2m,
+        windSpeed: response.data.current.wind_speed_10m,
+        humidity: response.data.current.relative_humidity_2m,
+      },
+    };
+
+    setCached(cacheKey, result, CACHE_TTL.WEATHER_CURRENT);
+    return result;
+  } catch (err) {
+    normalizeAxiosError(err, 'Open-Meteo');
+  }
+}
+
+export async function fetchHourlyForecast(inputCity, forecastDays = 2) {
+  const location = await resolveLocation(inputCity);
+  const safeDays = Number.isFinite(forecastDays)
+    ? Math.min(Math.max(Number.parseInt(forecastDays, 10), 1), 7)
+    : 2;
+
+  const cacheKey = `weather_hourly_${location.latitude}_${location.longitude}_${safeDays}`;
+  const cached = getCached(cacheKey);
+  if (cached) return cached;
+
+  try {
+    const response = await axios.get(FORECAST_URL, {
+      params: {
+        latitude: location.latitude,
+        longitude: location.longitude,
+        hourly: 'temperature_2m,apparent_temperature,precipitation_probability',
+        forecast_days: safeDays,
+        timezone: location.timezone || 'auto',
+      },
+      timeout: REQUEST_TIMEOUT,
+    });
+
+    if (response.status !== 200 || !response.data?.hourly) {
+      throw new Error('Saatlik tahmin verisi alınamadı.');
+    }
+
+    const limitCount = Math.min(safeDays * 24, 48);
+    const rows = buildHourlyRows(response.data.hourly, limitCount);
+
+    const result = {
+      locationName: location.name,
+      latitude: location.latitude,
+      longitude: location.longitude,
+      timezone: response.data.timezone || location.timezone || 'auto',
+      rows,
+      forecastDays: safeDays,
+    };
+
+    setCached(cacheKey, result, CACHE_TTL.WEATHER_HOURLY);
+    return result;
+  } catch (err) {
+    normalizeAxiosError(err, 'Open-Meteo');
+  }
+}
+
+export async function fetchAirQuality(inputCity) {
+  const location = await resolveLocation(inputCity);
+  const cacheKey = `weather_air_${location.latitude}_${location.longitude}`;
+  const cached = getCached(cacheKey);
+  if (cached) return cached;
+
+  try {
+    const response = await axios.get(AIR_QUALITY_URL, {
+      params: {
+        latitude: location.latitude,
+        longitude: location.longitude,
+        hourly: 'pm10,pm2_5,carbon_monoxide,nitrogen_dioxide',
+        timezone: 'auto',
+      },
+      timeout: REQUEST_TIMEOUT,
+    });
+
+    const hourly = response.data?.hourly;
+    if (response.status !== 200 || !hourly) {
+      throw new Error('Hava kalitesi verisi alınamadı.');
+    }
+
+    const idx = findClosestIndex(hourly.time);
+    if (idx < 0) {
+      throw new Error('Hava kalitesi saat verisi çözümlenemedi.');
+    }
+
+    const result = {
+      locationName: location.name,
+      latitude: location.latitude,
+      longitude: location.longitude,
+      timezone: response.data.timezone || 'auto',
+      current: {
+        time: hourly.time?.[idx] ?? '-',
+        pm10: hourly.pm10?.[idx] ?? null,
+        pm25: hourly.pm2_5?.[idx] ?? null,
+        carbonMonoxide: hourly.carbon_monoxide?.[idx] ?? null,
+        nitrogenDioxide: hourly.nitrogen_dioxide?.[idx] ?? null,
+      },
+    };
+
+    setCached(cacheKey, result, CACHE_TTL.WEATHER_AIR);
+    return result;
+  } catch (err) {
+    normalizeAxiosError(err, 'Open-Meteo Air Quality');
+  }
+}

package/src/utils/banner.js

@@ -22,6 +22,9 @@ export function printHelp() {
   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 hava guncel [sehir|lat,lon]') + chalk.gray('  Güncel hava'));
+  console.log(chalk.cyan('    turkiyem hava saatlik [sehir|lat,lon] -g 2') + chalk.gray('  Saatlik tahmin'));
+  console.log(chalk.cyan('    turkiyem hava kalite [sehir|lat,lon]') + chalk.gray('  Hava kalitesi'));
   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'));

package/src/utils/cache.js

@@ -3,6 +3,9 @@ import NodeCache from 'node-cache';
 export const CACHE_TTL = Object.freeze({
   DEFAULT: 300,
   IETT_SOAP: 90,
+  WEATHER_CURRENT: 300,
+  WEATHER_HOURLY: 600,
+  WEATHER_AIR: 600,
 });
 
 const cache = new NodeCache({ stdTTL: CACHE_TTL.DEFAULT, checkperiod: 60 });

package/src/utils/display.js

@@ -135,3 +135,66 @@ export function createIettPlannedTimesTable(plannedTimes) {
 
   return table.toString();
 }
+
+export function createCurrentWeatherTable(result) {
+  const table = new Table({
+    style: { head: [], border: ['gray'] },
+    wordWrap: true,
+  });
+
+  table.push(
+    { [chalk.cyan('Konum')]: result.locationName || '-' },
+    { [chalk.cyan('Koordinat')]: `${result.latitude}, ${result.longitude}` },
+    { [chalk.cyan('Zaman Dilimi')]: result.timezone || '-' },
+    { [chalk.cyan('Ölçüm Zamanı')]: result.current?.time || '-' },
+    { [chalk.cyan('Sıcaklık (°C)')]: String(result.current?.temperature ?? '-') },
+    { [chalk.cyan('Rüzgar (km/s)')]: String(result.current?.windSpeed ?? '-') },
+    { [chalk.cyan('Nem (%)')]: String(result.current?.humidity ?? '-') },
+  );
+
+  return table.toString();
+}
+
+export function createHourlyWeatherTable(result) {
+  const table = new Table({
+    head: [
+      chalk.white.bold('Saat'),
+      chalk.white.bold('Sıcaklık (°C)'),
+      chalk.white.bold('Hissedilen (°C)'),
+      chalk.white.bold('Yağış Olasılığı (%)'),
+    ],
+    colWidths: [22, 15, 18, 22],
+    style: { head: [], border: ['gray'] },
+  });
+
+  for (const row of result.rows || []) {
+    table.push([
+      row.time || '-',
+      String(row.temperature ?? '-'),
+      String(row.apparentTemperature ?? '-'),
+      String(row.precipitationProbability ?? '-'),
+    ]);
+  }
+
+  return table.toString();
+}
+
+export function createAirQualityTable(result) {
+  const table = new Table({
+    style: { head: [], border: ['gray'] },
+    wordWrap: true,
+  });
+
+  table.push(
+    { [chalk.cyan('Konum')]: result.locationName || '-' },
+    { [chalk.cyan('Koordinat')]: `${result.latitude}, ${result.longitude}` },
+    { [chalk.cyan('Zaman Dilimi')]: result.timezone || '-' },
+    { [chalk.cyan('Ölçüm Zamanı')]: result.current?.time || '-' },
+    { [chalk.cyan('PM10 (µg/m3)')]: String(result.current?.pm10 ?? '-') },
+    { [chalk.cyan('PM2.5 (µg/m3)')]: String(result.current?.pm25 ?? '-') },
+    { [chalk.cyan('CO (µg/m3)')]: String(result.current?.carbonMonoxide ?? '-') },
+    { [chalk.cyan('NO2 (µg/m3)')]: String(result.current?.nitrogenDioxide ?? '-') },
+  );
+
+  return table.toString();
+}