tdk-api-wrapper 1.0.1 → 1.1.0

package/dist/cli.js

@@ -23,12 +23,41 @@ var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__ge
   mod
 ));
 
+// src/errors.ts
+var TDKError = class extends Error {
+  constructor(message) {
+    super(message);
+    this.name = "TDKError";
+    Object.setPrototypeOf(this, new.target.prototype);
+  }
+};
+var TDKValidationError = class extends TDKError {
+  constructor(message) {
+    super(message);
+    this.name = "TDKValidationError";
+    Object.setPrototypeOf(this, new.target.prototype);
+  }
+};
+var TDKNetworkError = class extends TDKError {
+  status;
+  cause;
+  constructor(message, options) {
+    super(message);
+    this.name = "TDKNetworkError";
+    this.status = options?.status;
+    this.cause = options?.cause;
+    Object.setPrototypeOf(this, new.target.prototype);
+  }
+};
+
 // src/tdk.ts
 var fs = __toESM(require("fs"));
 var path = __toESM(require("path"));
 var os = __toESM(require("os"));
+var https = __toESM(require("https"));
 var TDK = class {
   static BASE_URL = "https://sozluk.gov.tr";
+  static AUDIO_API_HOST = "api.sozluk.gov.tr";
   // Cache Mechanism
   static isCacheEnabled = false;
   static wordCache = /* @__PURE__ */ new Map();
@@ -59,35 +88,42 @@ var TDK = class {
    */
   static async getWord(word2) {
     if (!word2 || word2.trim() === "") {
-      throw new Error("Word parameter cannot be empty.");
+      throw new TDKValidationError("Word parameter cannot be empty.");
     }
-    const cleanWord = word2.trim().toLowerCase();
+    const cleanWord = word2.trim().toLocaleLowerCase("tr-TR");
     if (this.isCacheEnabled && this.wordCache.has(cleanWord)) {
       return this.wordCache.get(cleanWord);
     }
     const url = `${this.BASE_URL}/gts?ara=${encodeURIComponent(cleanWord)}`;
+    let response;
     try {
-      const response = await fetch(url, {
+      response = await fetch(url, {
         headers: { "User-Agent": "TDK-API-Nodejs-Wrapper/1.0" }
       });
-      if (!response.ok)
-        throw new Error(`HTTP error! status: ${response.status}`);
-      const data = await response.json();
-      if (!Array.isArray(data) && data && "error" in data) {
-        if (this.isCacheEnabled)
-          this.wordCache.set(cleanWord, []);
-        return [];
-      }
-      const results = data;
-      if (this.isCacheEnabled) {
-        this.wordCache.set(cleanWord, results);
-      }
-      return results;
     } catch (error) {
-      if (error instanceof Error)
-        throw new Error(`Failed to fetch word from TDK: ${error.message}`);
-      throw new Error("Failed to fetch word from TDK: Unknown error");
+      throw new TDKNetworkError("Failed to fetch word from TDK: request failed.", { cause: error });
     }
+    if (!response.ok) {
+      throw new TDKNetworkError(`Failed to fetch word from TDK: HTTP ${response.status}.`, {
+        status: response.status
+      });
+    }
+    let data;
+    try {
+      data = await response.json();
+    } catch (error) {
+      throw new TDKNetworkError("Failed to fetch word from TDK: invalid JSON response.", { cause: error });
+    }
+    if (!Array.isArray(data) && data && "error" in data) {
+      if (this.isCacheEnabled)
+        this.wordCache.set(cleanWord, []);
+      return [];
+    }
+    const results = data;
+    if (this.isCacheEnabled) {
+      this.wordCache.set(cleanWord, results);
+    }
+    return results;
   }
   /**
    * Helper method to get only the meanings (definitions) of a word as a string array.
@@ -124,8 +160,8 @@ var TDK = class {
         return [];
       }
     }
-    const cleanPrefix = prefix.toLowerCase();
-    return this.autocompleteCache.filter((w) => w.toLowerCase().startsWith(cleanPrefix)).slice(0, 10);
+    const cleanPrefix = prefix.toLocaleLowerCase("tr-TR");
+    return this.autocompleteCache.filter((w) => w.toLocaleLowerCase("tr-TR").startsWith(cleanPrefix)).slice(0, 10);
   }
   /**
    * Returns a list of proverbs and idioms containing the word.
@@ -146,14 +182,40 @@ var TDK = class {
     return proverbs;
   }
   /**
-   * Returns the etymological origin of the word if it's a foreign word.
+   * Returns the etymological origin of the word, or "Türkçe" if TDK doesn't
+   * record a foreign origin for it. Returns `null` only when the word itself
+   * isn't found in the dictionary at all.
    */
   static async getOrigin(word2) {
     const results = await this.getWord(word2);
-    if (results.length > 0 && results[0].lisan) {
-      return results[0].lisan;
+    if (results.length === 0)
+      return null;
+    return results[0].lisan || "T\xFCrk\xE7e";
+  }
+  /**
+   * Returns whether the word has a recorded foreign etymological origin.
+   * Returns `null` (instead of a boolean) when the word isn't found at all.
+   */
+  static async isForeignWord(word2) {
+    const origin = await this.getOrigin(word2);
+    if (origin === null)
+      return null;
+    return origin !== "T\xFCrk\xE7e";
+  }
+  /**
+   * Groups a list of words by their etymological origin. Words not found in
+   * the dictionary are grouped under "Bilinmiyor". Throttled like getWordsBatch.
+   */
+  static async groupByOrigin(words) {
+    const groups = {};
+    for (const word2 of words) {
+      const origin = await this.getOrigin(word2) ?? "Bilinmiyor";
+      if (!groups[origin])
+        groups[origin] = [];
+      groups[origin].push(word2);
+      await this.delay(200);
     }
-    return "T\xFCrk\xE7e";
+    return groups;
   }
   /**
    * Returns literature examples containing the word.
@@ -176,15 +238,108 @@ var TDK = class {
     return examples;
   }
   /**
-   * Returns the direct URL of the audio pronunciation if available.
-   * Note: TDK audio URL usually uses the exact audio id. Sometimes it requires MD5, but we provide a common pattern.
+   * Calls the `api.sozluk.gov.tr/gts-yeni` endpoint the official web UI uses
+   * internally (richer than the public `/gts`: includes `seskod`,
+   * `anlamEsAnlam`/`anlamKarsitAnlam`, etc). That endpoint 403s unless the
+   * request looks like it came from a browser tab on sozluk.gov.tr: it needs
+   * an `Origin`/`Referer` pair matching that site AND a browser-like
+   * `User-Agent` (our usual `TDK-API-Nodejs-Wrapper/…` UA gets rejected).
+   * `fetch` (undici) also strips a manually-set `Origin` header as a
+   * forbidden header name, so this uses `node:https` directly instead.
+   * This is inherently fragile scraping of an undocumented endpoint — if
+   * TDK tightens this check further, this should fail closed to `null`
+   * rather than throw.
+   */
+  static fetchGtsYeni(word2) {
+    return new Promise((resolve) => {
+      const req = https.request(
+        {
+          hostname: this.AUDIO_API_HOST,
+          path: `/gts-yeni?ara=${encodeURIComponent(word2)}`,
+          method: "GET",
+          headers: {
+            "User-Agent": "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/128.0.0.0 Safari/537.36",
+            Origin: this.BASE_URL,
+            Referer: `${this.BASE_URL}/`
+          }
+        },
+        (res) => {
+          let body = "";
+          res.on("data", (chunk) => body += chunk);
+          res.on("end", () => {
+            try {
+              const data = JSON.parse(body);
+              resolve(Array.isArray(data) ? data : null);
+            } catch {
+              resolve(null);
+            }
+          });
+        }
+      );
+      req.on("error", () => resolve(null));
+      req.end();
+    });
+  }
+  static async fetchSeskod(word2) {
+    const data = await this.fetchGtsYeni(word2);
+    const seskod = data?.[0]?.seskod;
+    return seskod ? String(seskod) : null;
+  }
+  /**
+   * Returns synonyms ("eş anlamlı kelimeler") recorded for the word, pooled
+   * across all of its meanings. Uses the same undocumented `gts-yeni`
+   * endpoint as `getAudioUrl` — returns `[]` if the lookup fails.
+   */
+  static async getSynonyms(word2) {
+    if (!word2 || word2.trim() === "")
+      return [];
+    const data = await this.fetchGtsYeni(word2.trim().toLocaleLowerCase("tr-TR"));
+    if (!data)
+      return [];
+    const synonyms = [];
+    for (const entry of data) {
+      for (const anlam of entry.anlamlarListe ?? []) {
+        for (const es of anlam.anlamEsAnlam ?? []) {
+          if (es.deger)
+            synonyms.push(es.deger);
+        }
+      }
+    }
+    return [...new Set(synonyms)];
+  }
+  /**
+   * Returns antonyms ("zıt anlamlı kelimeler") recorded for the word, pooled
+   * across all of its meanings. Uses the same undocumented `gts-yeni`
+   * endpoint as `getAudioUrl` — returns `[]` if the lookup fails.
+   */
+  static async getAntonyms(word2) {
+    if (!word2 || word2.trim() === "")
+      return [];
+    const data = await this.fetchGtsYeni(word2.trim().toLocaleLowerCase("tr-TR"));
+    if (!data)
+      return [];
+    const antonyms = [];
+    for (const entry of data) {
+      for (const anlam of entry.anlamlarListe ?? []) {
+        for (const ka of anlam.anlamKarsitAnlam ?? []) {
+          if (ka.deger)
+            antonyms.push(ka.deger);
+        }
+      }
+    }
+    return [...new Set(antonyms)];
+  }
+  /**
+   * Returns the direct URL of the audio pronunciation, if TDK has one recorded for this word.
    */
   static async getAudioUrl(word2) {
-    const results = await this.getWord(word2);
-    if (results.length > 0) {
-      return `https://sozluk.gov.tr/ses/${encodeURIComponent(word2)}.wav`;
+    if (!word2 || word2.trim() === "") {
+      throw new TDKValidationError("Word parameter cannot be empty.");
     }
-    return null;
+    const seskod = await this.fetchSeskod(word2.trim().toLocaleLowerCase("tr-TR"));
+    if (!seskod)
+      return null;
+    return `https://${this.AUDIO_API_HOST}/ses/${encodeURIComponent(seskod)}.wav`;
   }
   /**
    * Downloads the audio pronunciation to the specified path.
@@ -215,14 +370,29 @@ var TDK = class {
     }
     const daily = await this.getDailyContent();
     if (daily) {
-      const syydMatch = daily.syyd.find((s) => s.yanliskelime.toLowerCase() === word2.toLowerCase());
+      const syydMatch = daily.syyd.find((s) => s.yanliskelime.toLocaleLowerCase("tr-TR") === word2.toLocaleLowerCase("tr-TR"));
       if (syydMatch) {
         return { isCorrect: false, word: word2, suggestion: syydMatch.dogrukelime };
       }
-      const mixMatch = daily.karistirma.find((s) => s.yanlis.toLowerCase() === word2.toLowerCase());
+      const mixMatch = daily.karistirma.find((s) => s.yanlis.toLocaleLowerCase("tr-TR") === word2.toLocaleLowerCase("tr-TR"));
       if (mixMatch) {
         return { isCorrect: false, word: word2, suggestion: mixMatch.dogru };
       }
+      const candidates = [
+        ...daily.syyd.map((s) => s.dogrukelime),
+        ...daily.karistirma.flatMap((s) => [s.yanlis, s.dogru]),
+        ...daily.kelime.map((k) => k.madde)
+      ];
+      let best = null;
+      for (const candidate of candidates) {
+        const distance = this.levenshtein(word2.toLocaleLowerCase("tr-TR"), candidate.toLocaleLowerCase("tr-TR"));
+        if (distance > 0 && (!best || distance < best.distance)) {
+          best = { candidate, distance };
+        }
+      }
+      if (best && best.distance <= 2) {
+        return { isCorrect: false, word: word2, suggestion: best.candidate };
+      }
     }
     return { isCorrect: false, word: word2 };
   }
@@ -247,6 +417,94 @@ var TDK = class {
     }
     return null;
   }
+  /**
+   * Returns today's word of the day along with all of its listed meanings.
+   */
+  static async getWordOfTheDay() {
+    const daily = await this.getDailyContent();
+    if (!daily || daily.kelime.length === 0)
+      return null;
+    const word2 = daily.kelime[0].madde;
+    const meanings = daily.kelime.filter((k) => k.madde === word2).map((k) => k.anlam);
+    return { word: word2, meanings };
+  }
+  /**
+   * Picks a random entry (word or proverb) from today's daily content.
+   * Note: this samples from today's `getDailyContent()` picks, not the full dictionary.
+   */
+  static async getRandomWord() {
+    const daily = await this.getDailyContent();
+    if (!daily)
+      return null;
+    const pool = [
+      ...daily.kelime.map((k) => ({ type: "kelime", madde: k.madde, anlam: k.anlam })),
+      ...daily.atasoz.map((a) => ({ type: "atasoz", madde: a.madde, anlam: a.anlam }))
+    ];
+    if (pool.length === 0)
+      return null;
+    return pool[Math.floor(Math.random() * pool.length)];
+  }
+  /**
+   * Returns the spelling-rule page(s) ("yazım kuralları") linked from TDK's
+   * `/icerik` daily-content feed, e.g. `{ adi: "Kısaltmalar", url: "https://..." }`.
+   * Note: like `getRandomWord()`, this is NOT a fixed catalog — `/icerik`
+   * appears to hand back a single randomly-rotated rule per request, so two
+   * calls a second apart can return entirely different rules.
+   */
+  static async getKurallar() {
+    const daily = await this.getDailyContent();
+    return daily?.kural ?? [];
+  }
+  /**
+   * Fetches the full plain-text content of a named spelling rule (matched
+   * case-insensitively, substring match) from `tdk.gov.tr`. Since `/icerik`
+   * hands back a single randomly-rotated rule per request (out of a pool of
+   * roughly twenty) rather than a fixed catalog, a single `getKurallar()`
+   * draw would rarely match a given name — this re-draws (bounded, with a
+   * short delay) until it finds a match or gives up. Returns `null` if no
+   * match turns up within the attempt budget or the matched page can't be
+   * parsed.
+   */
+  static async getRule(name) {
+    if (!name || name.trim() === "")
+      return null;
+    const target = name.trim().toLocaleLowerCase("tr-TR");
+    for (let attempt = 0; attempt < 25; attempt++) {
+      const rules = await this.getKurallar();
+      const match = rules.find((r) => r.adi.toLocaleLowerCase("tr-TR").includes(target));
+      if (match)
+        return this.fetchRuleText(match.url);
+      await this.delay(100);
+    }
+    return null;
+  }
+  /**
+   * `tdk.gov.tr` rule pages are WordPress/Avada-themed. The actual article
+   * text lives in `<div ... itemprop="text">...</div>` right before a
+   * `<footer class="entry...">` (share buttons, author box, structured-data
+   * spans) — cutting there avoids that trailing cruft.
+   */
+  static async fetchRuleText(url) {
+    try {
+      const response = await fetch(url, { headers: { "User-Agent": "TDK-API-Nodejs-Wrapper/1.0" } });
+      if (!response.ok)
+        return null;
+      const html = await response.text();
+      const marker = html.indexOf('itemprop="text"');
+      if (marker === -1)
+        return null;
+      const contentStart = html.indexOf(">", marker) + 1;
+      const contentEnd = html.indexOf("<footer", contentStart);
+      if (contentEnd === -1)
+        return null;
+      return this.htmlToPlainText(html.slice(contentStart, contentEnd));
+    } catch {
+      return null;
+    }
+  }
+  static htmlToPlainText(html) {
+    return html.replace(/<br\s*\/?>/gi, "\n").replace(/<\/(p|div)>/gi, "\n\n").replace(/<[^>]+>/g, "").replace(/&nbsp;/gi, " ").replace(/&amp;/gi, "&").replace(/&quot;/gi, '"').replace(/&#39;|&rsquo;/gi, "'").replace(/[ \t]+/g, " ").replace(/[ \t]*\n[ \t]*/g, "\n").replace(/\n{3,}/g, "\n\n").trim();
+  }
   /**
    * Returns compound words that contain this word.
    */
@@ -265,6 +523,9 @@ var TDK = class {
   }
   /**
    * Returns the part of speech (isim, sıfat, zarf vb.).
+   * TDK's `ozelliklerListe` mixes grammatical categories (`tur: "3"`, e.g.
+   * sıfat/zarf/isim) with usage-register tags (`tur: "4"`, e.g. mecaz/argo)
+   * in the same list — only `tur === "3"` entries are actual parts of speech.
    */
   static async getPartOfSpeech(word2) {
     const results = await this.getWord(word2);
@@ -274,7 +535,8 @@ var TDK = class {
         for (const anlam of result.anlamlarListe) {
           if (anlam.ozelliklerListe) {
             for (const ozellik of anlam.ozelliklerListe) {
-              pos.add(ozellik.tam_adi);
+              if (ozellik.tur === "3")
+                pos.add(ozellik.tam_adi);
             }
           }
         }
@@ -285,6 +547,116 @@ var TDK = class {
     }
     return Array.from(pos);
   }
+  /**
+   * Compares two words side by side: meaning count, etymological origin,
+   * syllables and vowel-harmony compliance.
+   */
+  static async compareWords(a, b) {
+    const [meaningsA, meaningsB, originA, originB] = await Promise.all([
+      this.getMeanings(a),
+      this.getMeanings(b),
+      this.getOrigin(a),
+      this.getOrigin(b)
+    ]);
+    return {
+      a: {
+        word: a,
+        meaningCount: meaningsA.length,
+        origin: originA,
+        syllables: this.syllabicate(a),
+        harmony: this.checkVowelHarmony(a)
+      },
+      b: {
+        word: b,
+        meaningCount: meaningsB.length,
+        origin: originB,
+        syllables: this.syllabicate(b),
+        harmony: this.checkVowelHarmony(b)
+      }
+    };
+  }
+  static STOPWORDS = /* @__PURE__ */ new Set([
+    "ve",
+    "veya",
+    "ile",
+    "ama",
+    "fakat",
+    "ancak",
+    "de",
+    "da",
+    "ki",
+    "bu",
+    "\u015Fu",
+    "o",
+    "bir",
+    "\xE7ok",
+    "az",
+    "gibi",
+    "i\xE7in",
+    "mi",
+    "m\u0131",
+    "mu",
+    "m\xFC",
+    "ne",
+    "her",
+    "hi\xE7",
+    "ben",
+    "sen",
+    "biz",
+    "siz",
+    "onlar",
+    "de\u011Fil",
+    "bile",
+    "diye"
+  ]);
+  static firstMeaning(results) {
+    for (const result of results) {
+      for (const anlam of result.anlamlarListe ?? []) {
+        if (anlam.anlam)
+          return anlam.anlam;
+      }
+    }
+    return null;
+  }
+  /**
+   * Analyzes every distinct word in a text (Turkish stopwords filtered out),
+   * returning each word's first meaning and etymological origin if found.
+   * Looks each word up individually (throttled), so scales with text length.
+   */
+  static async analyzeText(text) {
+    const words = text.toLocaleLowerCase("tr-TR").replace(/[^\p{L}\s]/gu, " ").split(/\s+/).filter((w) => w.length > 1 && !this.STOPWORDS.has(w));
+    const unique = [...new Set(words)];
+    const analyses = [];
+    for (const word2 of unique) {
+      const results = await this.getWord(word2);
+      const found = results.length > 0;
+      analyses.push({
+        word: word2,
+        found,
+        meaning: found ? this.firstMeaning(results) : null,
+        origin: found ? results[0].lisan || "T\xFCrk\xE7e" : null
+      });
+      await this.delay(200);
+    }
+    return analyses;
+  }
+  /**
+   * Classic edit-distance between two strings.
+   */
+  static levenshtein(a, b) {
+    const dp = Array.from({ length: a.length + 1 }, () => new Array(b.length + 1).fill(0));
+    for (let i = 0; i <= a.length; i++)
+      dp[i][0] = i;
+    for (let j = 0; j <= b.length; j++)
+      dp[0][j] = j;
+    for (let i = 1; i <= a.length; i++) {
+      for (let j = 1; j <= b.length; j++) {
+        const cost = a[i - 1] === b[j - 1] ? 0 : 1;
+        dp[i][j] = Math.min(dp[i - 1][j] + 1, dp[i][j - 1] + 1, dp[i - 1][j - 1] + cost);
+      }
+    }
+    return dp[a.length][b.length];
+  }
   /**
    * Fetches multiple words concurrently with a small delay to avoid rate limiting.
    */
@@ -335,87 +707,262 @@ var TDK = class {
   }
   /**
    * Checks if a word follows Turkish Major Vowel Harmony (Büyük Ünlü Uyumu).
+   * Normalizes case via the Turkish locale first: a plain case-insensitive
+   * regex would fold ASCII "I" to "i", misreading the back vowel "I"
+   * (dotless) as the front vowel "i" (dotted).
    */
   static checkVowelHarmony(word2) {
-    const backVowels = /[aıou]/i;
-    const frontVowels = /[eiöü]/i;
-    const hasBack = backVowels.test(word2);
-    const hasFront = frontVowels.test(word2);
+    const lower = word2.toLocaleLowerCase("tr-TR");
+    const backVowels = /[aıou]/;
+    const frontVowels = /[eiöü]/;
+    const hasBack = backVowels.test(lower);
+    const hasFront = frontVowels.test(lower);
     return !(hasBack && hasFront);
   }
 };
 
 // src/cli.ts
-var args = process.argv.slice(2);
+var rawArgs = process.argv.slice(2);
+var jsonMode = rawArgs.includes("--json");
+var args = rawArgs.filter((a) => a !== "--json");
+var KNOWN_COMMANDS = /* @__PURE__ */ new Set([
+  "ara",
+  "anlam",
+  "koken",
+  "ornek",
+  "hece",
+  "uyum",
+  "yazim",
+  "gunun",
+  "rastgele",
+  "esanlam",
+  "karsit",
+  "yabanci",
+  "kurallar",
+  "kural",
+  "karsilastir",
+  "analiz"
+]);
 var command = args[0];
-var word = args[1];
+var word = args.slice(1).join(" ");
+if (command && !KNOWN_COMMANDS.has(command) && command !== "--help" && command !== "-h") {
+  word = args.join(" ");
+  command = "anlam";
+}
+function printResult(data, formatted) {
+  if (jsonMode) {
+    console.log(JSON.stringify(data));
+  } else {
+    formatted();
+  }
+}
+function printError(message) {
+  if (jsonMode) {
+    console.log(JSON.stringify({ error: message }));
+  } else {
+    console.log(`Hata: ${message}`);
+  }
+}
 async function run() {
-  if (!command) {
-    console.log("Kullan\u0131m: tdk <komut> <kelime>");
-    console.log("Komutlar: ara, anlam, koken, ornek, hece, uyum, yazim");
-    process.exit(1);
+  if (!command || command === "--help" || command === "-h") {
+    console.log("Kullan\u0131m: tdk [komut] <kelime> [--json]");
+    console.log(
+      "Komutlar: ara, anlam, koken, ornek, hece, uyum, yazim, gunun, rastgele, esanlam, karsit, yabanci, kurallar, kural, karsilastir, analiz"
+    );
+    console.log("Not: Komut belirtilmezse do\u011Frudan kelime anlam\u0131 aran\u0131r (\xF6rn: tdk selam)");
+    process.exit(command ? 0 : 1);
   }
   TDK.enableCache(false);
   try {
     switch (command) {
       case "ara":
-      case "anlam":
+      case "anlam": {
         if (!word)
           throw new Error("Kelime belirtmelisiniz.");
         const meanings = await TDK.getMeanings(word);
-        if (meanings.length === 0) {
-          console.log("Sonu\xE7 bulunamad\u0131.");
-        } else {
-          meanings.forEach((m, i) => console.log(`${i + 1}. ${m}`));
-        }
+        printResult(meanings, () => {
+          if (meanings.length === 0) {
+            console.log("Sonu\xE7 bulunamad\u0131.");
+          } else {
+            meanings.forEach((m, i) => console.log(`${i + 1}. ${m}`));
+          }
+        });
         break;
-      case "koken":
+      }
+      case "koken": {
         if (!word)
           throw new Error("Kelime belirtmelisiniz.");
         const origin = await TDK.getOrigin(word);
-        console.log(`K\xF6ken: ${origin}`);
+        printResult({ word, origin }, () => console.log(`K\xF6ken: ${origin}`));
         break;
-      case "ornek":
+      }
+      case "ornek": {
         if (!word)
           throw new Error("Kelime belirtmelisiniz.");
         const examples = await TDK.getExamples(word);
-        if (examples.length === 0) {
-          console.log("\xD6rnek bulunamad\u0131.");
-        } else {
-          examples.forEach((ex, i) => {
-            const yazar = ex.author ? ` (${ex.author})` : "";
-            console.log(`${i + 1}. ${ex.sentence}${yazar}`);
-          });
-        }
+        printResult(examples, () => {
+          if (examples.length === 0) {
+            console.log("\xD6rnek bulunamad\u0131.");
+          } else {
+            examples.forEach((ex, i) => {
+              const yazar = ex.author ? ` (${ex.author})` : "";
+              console.log(`${i + 1}. ${ex.sentence}${yazar}`);
+            });
+          }
+        });
         break;
-      case "hece":
+      }
+      case "hece": {
         if (!word)
           throw new Error("Kelime belirtmelisiniz.");
         const syllables = TDK.syllabicate(word);
-        console.log(`Heceler: ${syllables.join("-")}`);
+        printResult(syllables, () => console.log(`Heceler: ${syllables.join("-")}`));
         break;
-      case "uyum":
+      }
+      case "uyum": {
         if (!word)
           throw new Error("Kelime belirtmelisiniz.");
         const isHarmony = TDK.checkVowelHarmony(word);
-        console.log(`B\xFCy\xFCk \xDCnl\xFC Uyumu: ${isHarmony ? "Uyar" : "Uymaz"}`);
+        printResult(
+          { word, harmony: isHarmony },
+          () => console.log(`B\xFCy\xFCk \xDCnl\xFC Uyumu: ${isHarmony ? "Uyar" : "Uymaz"}`)
+        );
         break;
-      case "yazim":
+      }
+      case "yazim": {
         if (!word)
           throw new Error("Kelime belirtmelisiniz.");
         const spellResult = await TDK.checkSpelling(word);
-        if (spellResult.isCorrect) {
-          console.log("Do\u011Fru yaz\u0131m.");
-        } else {
-          console.log(`Yanl\u0131\u015F yaz\u0131m.${spellResult.suggestion ? " Do\u011Frusu: " + spellResult.suggestion : ""}`);
-        }
+        printResult(spellResult, () => {
+          if (spellResult.isCorrect) {
+            console.log("Do\u011Fru yaz\u0131m.");
+          } else {
+            console.log(`Yanl\u0131\u015F yaz\u0131m.${spellResult.suggestion ? " Do\u011Frusu: " + spellResult.suggestion : ""}`);
+          }
+        });
+        break;
+      }
+      case "gunun": {
+        const wotd = await TDK.getWordOfTheDay();
+        printResult(wotd, () => {
+          if (!wotd) {
+            console.log("G\xFCn\xFCn kelimesi al\u0131namad\u0131.");
+          } else {
+            console.log(`G\xFCn\xFCn kelimesi: ${wotd.word}`);
+            wotd.meanings.forEach((m, i) => console.log(`${i + 1}. ${m}`));
+          }
+        });
+        break;
+      }
+      case "rastgele": {
+        const pick = await TDK.getRandomWord();
+        printResult(pick, () => {
+          if (!pick) {
+            console.log("Rastgele i\xE7erik al\u0131namad\u0131.");
+          } else {
+            const label = pick.type === "kelime" ? "Kelime" : "Atas\xF6z\xFC";
+            console.log(`${label}: ${pick.madde}`);
+            console.log(pick.anlam);
+          }
+        });
         break;
+      }
+      case "esanlam": {
+        if (!word)
+          throw new Error("Kelime belirtmelisiniz.");
+        const synonyms = await TDK.getSynonyms(word);
+        printResult(synonyms, () => {
+          if (synonyms.length === 0) {
+            console.log("E\u015F anlaml\u0131 kelime bulunamad\u0131.");
+          } else {
+            synonyms.forEach((s, i) => console.log(`${i + 1}. ${s}`));
+          }
+        });
+        break;
+      }
+      case "karsit": {
+        if (!word)
+          throw new Error("Kelime belirtmelisiniz.");
+        const antonyms = await TDK.getAntonyms(word);
+        printResult(antonyms, () => {
+          if (antonyms.length === 0) {
+            console.log("Z\u0131t anlaml\u0131 kelime bulunamad\u0131.");
+          } else {
+            antonyms.forEach((s, i) => console.log(`${i + 1}. ${s}`));
+          }
+        });
+        break;
+      }
+      case "yabanci": {
+        if (!word)
+          throw new Error("Kelime belirtmelisiniz.");
+        const foreign = await TDK.isForeignWord(word);
+        printResult({ word, foreign }, () => {
+          if (foreign === null) {
+            console.log("Kelime bulunamad\u0131.");
+          } else {
+            console.log(foreign ? "Yabanc\u0131 k\xF6kenli." : "T\xFCrk\xE7e k\xF6kenli.");
+          }
+        });
+        break;
+      }
+      case "kurallar": {
+        const rules = await TDK.getKurallar();
+        printResult(rules, () => {
+          if (rules.length === 0) {
+            console.log("Kural listesi al\u0131namad\u0131.");
+          } else {
+            rules.forEach((r, i) => console.log(`${i + 1}. ${r.adi}`));
+          }
+        });
+        break;
+      }
+      case "kural": {
+        if (!word)
+          throw new Error("Kural ad\u0131 belirtmelisiniz.");
+        const rule = await TDK.getRule(word);
+        printResult(rule, () => {
+          console.log(rule ?? "Kural bulunamad\u0131.");
+        });
+        break;
+      }
+      case "karsilastir": {
+        const [wordA, wordB] = args.slice(1);
+        if (!wordA || !wordB)
+          throw new Error("\u0130ki kelime belirtmelisiniz.");
+        const comparison = await TDK.compareWords(wordA, wordB);
+        printResult(comparison, () => {
+          for (const side of [comparison.a, comparison.b]) {
+            console.log(`${side.word}: ${side.meaningCount} anlam, k\xF6ken: ${side.origin ?? "bulunamad\u0131"}, hece: ${side.syllables.join("-")}, b\xFCy\xFCk \xFCnl\xFC uyumu: ${side.harmony ? "uyar" : "uymaz"}`);
+          }
+        });
+        break;
+      }
+      case "analiz": {
+        if (!word)
+          throw new Error("Metin belirtmelisiniz.");
+        const analysis = await TDK.analyzeText(word);
+        printResult(analysis, () => {
+          if (analysis.length === 0) {
+            console.log("Analiz edilecek kelime bulunamad\u0131.");
+          } else {
+            analysis.forEach((a) => {
+              if (a.found) {
+                console.log(`${a.word}: ${a.meaning ?? "-"} (${a.origin})`);
+              } else {
+                console.log(`${a.word}: bulunamad\u0131`);
+              }
+            });
+          }
+        });
+        break;
+      }
       default:
-        console.log("Bilinmeyen komut.");
+        printError("Bilinmeyen komut.");
     }
   } catch (error) {
     if (error instanceof Error) {
-      console.log(`Hata: ${error.message}`);
+      printError(error.message);
     }
   }
 }