tdk-api-wrapper 1.4.0 → 1.5.1

package/dist/index.mjs

@@ -1,5 +1,6 @@
 import {
   TDK,
+  TDKClient,
   TDKError,
   TDKNetworkError,
   TDKValidationError,
@@ -8,11 +9,14 @@ import {
   getStemCandidates,
   isVowel,
   restoreConsonantSoftening,
+  restoreGemination,
   restoreInfinitive,
-  restoreVowelDrop
-} from "./chunk-5TYJDVHK.mjs";
+  restoreVowelDrop,
+  restoreVowelNarrowing
+} from "./chunk-NEC5MIQM.mjs";
 export {
   TDK,
+  TDKClient,
   TDKError,
   TDKNetworkError,
   TDKValidationError,
@@ -21,6 +25,8 @@ export {
   getStemCandidates,
   isVowel,
   restoreConsonantSoftening,
+  restoreGemination,
   restoreInfinitive,
-  restoreVowelDrop
+  restoreVowelDrop,
+  restoreVowelNarrowing
 };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "tdk-api-wrapper",
-  "version": "1.4.0",
+  "version": "1.5.1",
   "description": "TDK (Türk Dil Kurumu) unofficial live data API wrapper for Node.js",
   "main": "dist/index.js",
   "module": "dist/index.mjs",
@@ -17,7 +17,7 @@
   },
   "scripts": {
     "build": "tsup src/index.ts src/cli.ts --format cjs,esm --dts --clean --shims",
-    "test": "node test/morphology.test.js"
+    "test": "node test/morphology.test.js && node test/grammar.test.js && node test/proofread.test.js && node test/tools.test.js"
   },
   "keywords": [
     "tdk",

package/src/cli.ts

@@ -4,6 +4,17 @@ import { TDK } from "./tdk";
 const rawArgs = process.argv.slice(2);
 const jsonMode = rawArgs.includes("--json");
 const args = rawArgs.filter((a) => a !== "--json");
+
+const isColor = !jsonMode && Boolean(process.stdout.isTTY);
+const c = {
+  bold: (s: string) => (isColor ? `\x1b[1m${s}\x1b[0m` : s),
+  dim: (s: string) => (isColor ? `\x1b[2m${s}\x1b[0m` : s),
+  green: (s: string) => (isColor ? `\x1b[32m${s}\x1b[0m` : s),
+  yellow: (s: string) => (isColor ? `\x1b[33m${s}\x1b[0m` : s),
+  cyan: (s: string) => (isColor ? `\x1b[36m${s}\x1b[0m` : s),
+  red: (s: string) => (isColor ? `\x1b[31m${s}\x1b[0m` : s),
+};
+
 const KNOWN_COMMANDS = new Set([
   "ara",
   "anlam",
@@ -11,6 +22,7 @@ const KNOWN_COMMANDS = new Set([
   "ornek",
   "hece",
   "uyum",
+  "kucukuyum",
   "yazim",
   "kok",
   "stem",
@@ -25,6 +37,14 @@ const KNOWN_COMMANDS = new Set([
   "karsilastir",
   "analiz",
   "oneri",
+  "bulmaca",
+  "pattern",
+  "anagram",
+  "kafiye",
+  "rhyme",
+  "denetle",
+  "proofread",
+  "repl",
   "kubbealti",
   "nisanyan",
   "viki",
@@ -33,7 +53,7 @@ const KNOWN_COMMANDS = new Set([
 let command = args[0];
 let word = args.slice(1).join(" ");
 
-if (command && !KNOWN_COMMANDS.has(command) && command !== "--help" && command !== "-h") {
+if (command && !KNOWN_COMMANDS.has(command) && command !== "--help" && command !== "-h" && command !== "--version" && command !== "-v") {
   word = args.join(" ");
   command = "anlam";
 }
@@ -50,18 +70,101 @@ function printError(message: string) {
   if (jsonMode) {
     console.log(JSON.stringify({ error: message }));
   } else {
-    console.log(`Hata: ${message}`);
+    console.log(c.red(`Hata: ${message}`));
   }
 }
 
+async function startRepl() {
+  const readline = await import("node:readline");
+  const rl = readline.createInterface({
+    input: process.stdin,
+    output: process.stdout,
+    prompt: c.cyan("tdk> "),
+  });
+
+  console.log(c.bold("TDK İnteraktif Sözlük Kabuğu (Çıkmak için 'exit' veya Ctrl+C)"));
+  console.log(c.dim("Komutlar: ara <kelime>, hece <kelime>, bulmaca <desen>, denetle <metin> veya doğrudan kelime"));
+  rl.prompt();
+
+  rl.on("line", async (line) => {
+    const trimmed = line.trim();
+    if (!trimmed) {
+      rl.prompt();
+      return;
+    }
+    if (trimmed === "exit" || trimmed === "quit" || trimmed === ".exit") {
+      rl.close();
+      return;
+    }
+
+    const parts = trimmed.split(/\s+/);
+    let subCmd = parts[0].toLowerCase();
+    let subArg = parts.slice(1).join(" ");
+    if (!KNOWN_COMMANDS.has(subCmd)) {
+      subArg = trimmed;
+      subCmd = "anlam";
+    }
+
+    try {
+      if (subCmd === "ara" || subCmd === "anlam") {
+        const meanings = await TDK.getMeanings(subArg);
+        if (meanings.length === 0) console.log(c.dim("Sonuç bulunamadı."));
+        else meanings.forEach((m, i) => console.log(`${i + 1}. ${c.green(m)}`));
+      } else if (subCmd === "koken") {
+        const origin = await TDK.getOrigin(subArg);
+        console.log(`Köken: ${c.cyan(origin || "Bilinmiyor")}`);
+      } else if (subCmd === "hece") {
+        const s = TDK.syllabicate(subArg);
+        console.log(`Heceler: ${c.yellow(s.join("-"))}`);
+      } else if (subCmd === "uyum") {
+        const h = TDK.checkVowelHarmony(subArg);
+        console.log(`Büyük Ünlü Uyumu: ${h ? c.green("Uyar") : c.red("Uymaz")}`);
+      } else if (subCmd === "kucukuyum") {
+        const h = TDK.checkLabialHarmony(subArg);
+        console.log(`Küçük Ünlü Uyumu: ${h ? c.green("Uyar") : c.red("Uymaz")}`);
+      } else if (subCmd === "bulmaca" || subCmd === "pattern") {
+        const matches = await TDK.patternSearch(subArg);
+        console.log(matches.slice(0, 15).join(", "));
+      } else if (subCmd === "denetle" || subCmd === "proofread") {
+        const res = await TDK.proofread(subArg);
+        if (res.isCorrect) console.log(c.green("✓ Sorun bulunamadı."));
+        else res.issues.forEach((iss) => console.log(`- ${c.yellow(iss.word)}: ${iss.message}${iss.suggestion ? " -> " + c.green(iss.suggestion) : ""}`));
+      } else {
+        console.log(c.dim("Örnek komutlar: 'ara kalem', 'hece elektrik', 'bulmaca k_l_m', 'denetle Bugün evdeyim'"));
+      }
+    } catch (e: any) {
+      console.log(c.red(`Hata: ${e?.message || e}`));
+    }
+    rl.prompt();
+  });
+}
+
 async function run() {
-  if (!command || command === "--help" || command === "-h") {
+  if (!command) {
+    if (process.stdin.isTTY) {
+      await startRepl();
+      return;
+    }
     console.log("Kullanım: tdk [komut] <kelime> [--json]");
     console.log(
-      "Komutlar: ara, anlam, koken, ornek, hece, uyum, yazim, kok, deyim, gunun, rastgele, esanlam, karsit, yabanci, kurallar, kural, karsilastir, analiz, oneri, kubbealti, nisanyan, viki"
+      "Komutlar: ara, anlam, koken, ornek, hece, uyum, kucukuyum, yazim, kok, deyim, gunun, rastgele, esanlam, karsit, yabanci, kurallar, kural, karsilastir, analiz, oneri, bulmaca, anagram, kafiye, denetle, repl, kubbealti, nisanyan, viki"
     );
     console.log("Not: Komut belirtilmezse doğrudan kelime anlamı aranır (örn: tdk selam)");
-    process.exit(command ? 0 : 1);
+    process.exit(1);
+  }
+
+  if (command === "--version" || command === "-v") {
+    console.log("tdk-api-wrapper v1.5.1");
+    process.exit(0);
+  }
+
+  if (command === "--help" || command === "-h") {
+    console.log("Kullanım: tdk [komut] <kelime> [--json]");
+    console.log(
+      "Komutlar: ara, anlam, koken, ornek, hece, uyum, kucukuyum, yazim, kok, deyim, gunun, rastgele, esanlam, karsit, yabanci, kurallar, kural, karsilastir, analiz, oneri, bulmaca, anagram, kafiye, denetle, repl, kubbealti, nisanyan, viki"
+    );
+    console.log("Not: Komut belirtilmezse doğrudan kelime anlamı aranır (örn: tdk selam)");
+    process.exit(0);
   }
 
   TDK.enableCache(false);
@@ -121,6 +224,16 @@ async function run() {
         break;
       }
 
+      case "kucukuyum":
+      case "labial": {
+        if (!word) throw new Error("Kelime belirtmelisiniz.");
+        const isHarmony = TDK.checkLabialHarmony(word);
+        printResult({ word, labialHarmony: isHarmony }, () =>
+          console.log(`Küçük Ünlü Uyumu: ${isHarmony ? "Uyar" : "Uymaz"}`)
+        );
+        break;
+      }
+
       case "yazim": {
         if (!word) throw new Error("Kelime belirtmelisiniz.");
         const spellResult = await TDK.checkSpelling(word);
@@ -299,6 +412,79 @@ async function run() {
         break;
       }
 
+      case "bulmaca":
+      case "pattern": {
+        if (!word) throw new Error("Desen belirtmelisiniz (örn: k_l_m).");
+        const matches = await TDK.patternSearch(word);
+        printResult(matches, () => {
+          if (matches.length === 0) {
+            console.log("Eşleşen kelime bulunamadı.");
+          } else {
+            console.log(c.bold(`Bulunan Kelimeler (${matches.length}):`));
+            matches.forEach((m, i) => console.log(`${i + 1}. ${c.cyan(m)}`));
+          }
+        });
+        break;
+      }
+
+      case "anagram": {
+        if (!word) throw new Error("Harfler belirtmelisiniz.");
+        const anagrams = await TDK.findAnagrams(word);
+        printResult(anagrams, () => {
+          if (anagrams.length === 0) {
+            console.log("Anagram veya bu harflerle türetilebilecek kelime bulunamadı.");
+          } else {
+            const clean = word.trim().toLocaleLowerCase("tr-TR").replace(/[^a-zçğıöşüâîû]/gi, "");
+            const hasExact = anagrams.some((a) => a.length === clean.length);
+            const title = hasExact
+              ? `Anagramlar (${anagrams.length}):`
+              : `Birebir anagram bulunamadı. Bu harflerle türetilen kelimeler (${anagrams.length}):`;
+            console.log(c.bold(title));
+            anagrams.forEach((a, i) => console.log(`${i + 1}. ${c.green(a)} ${c.dim(`(${a.length} harf)`)}`));
+          }
+        });
+        break;
+      }
+
+      case "kafiye":
+      case "rhyme": {
+        if (!word) throw new Error("Kelime belirtmelisiniz.");
+        const rhymes = await TDK.findRhymes(word);
+        printResult(rhymes, () => {
+          if (rhymes.length === 0) {
+            console.log("Kafiye bulunamadı.");
+          } else {
+            console.log(c.bold(`Kafiyeli Kelimeler (${rhymes.length}):`));
+            rhymes.forEach((r, i) => console.log(`${i + 1}. ${c.yellow(r)}`));
+          }
+        });
+        break;
+      }
+
+      case "denetle":
+      case "proofread": {
+        if (!word) throw new Error("Metin belirtmelisiniz.");
+        const result = await TDK.proofread(word);
+        printResult(result, () => {
+          if (result.isCorrect) {
+            console.log(c.green("✓ Metinde imla veya bağlaç hatası tespit edilmedi."));
+          } else {
+            console.log(c.bold(c.red(`Metinde ${result.issues.length} olası sorun tespit edildi:`)));
+            result.issues.forEach((issue, i) => {
+              const label = c.yellow(`[${issue.type}]`);
+              const sug = issue.suggestion ? c.green(` -> Öneri: ${issue.suggestion}`) : "";
+              console.log(`${i + 1}. ${label} "${c.bold(issue.word)}": ${issue.message}${sug}`);
+            });
+          }
+        });
+        break;
+      }
+
+      case "repl": {
+        await startRepl();
+        break;
+      }
+
       case "kubbealti": {
         if (!word) throw new Error("Kelime belirtmelisiniz.");
         const meanings = await TDK.getKubbealtiMeanings(word);

package/src/index.ts

@@ -1,4 +1,4 @@
-export { TDK } from "./tdk";
+export { TDK, TDKClient } from "./tdk";
 export * from "./types";
 export * from "./errors";
 export * from "./morphology";

package/src/morphology.ts

@@ -67,7 +67,8 @@ export const TURKISH_SUFFIXES: readonly string[] = [
   "miş", "mış", "muş", "müş", "dim", "dım", "dum", "düm", "tim", "tım", "tum", "tüm",
   "din", "dın", "dun", "dün", "tin", "tın", "tun", "tün", "dik", "dık", "duk", "dük",
   "tik", "tık", "tuk", "tük", "ydi", "ydı", "ydu", "ydü", "yim", "yım", "yum", "yüm",
-  "sin", "sın", "sun", "sün", "siz", "sız", "suz", "süz", "lik", "lık", "luk", "lük",
+  "sin", "sın", "sun", "sün", "sen", "san", "sem", "sam", "sek", "sak",
+  "siz", "sız", "suz", "süz", "lik", "lık", "luk", "lük",
   "ici", "ıcı", "ucu", "ücü", "gen", "gan", "ken", "kan",
   "len", "lan", "leş", "laş", "mek", "mak", "yor",
   // 2-letter suffixes
@@ -126,6 +127,61 @@ export function restoreVowelDrop(stem: string): string[] {
   return [];
 }
 
+/**
+ * Reverses Turkish consonant gemination (ünsüz türemesi / ikizleşmesi):
+ * In words of Arabic/foreign origin, when receiving a vowel-initial suffix, the final consonant doubles:
+ * e.g. hak->hakkı, his->hissi, sır->sırrı, af->affı, ret->reddi, tıp->tıbbı, zam->zammı, hat->hattı.
+ * Restores the single consonant form and checks consonant softening on the result (e.g. redd -> red -> ret).
+ */
+export function restoreGemination(stem: string): string[] {
+  if (stem.length < 3) return [];
+  const c1 = stem[stem.length - 2];
+  const c2 = stem[stem.length - 1];
+  if (c1 === c2 && !isVowel(c1)) {
+    const single = stem.slice(0, -1);
+    const hardened = restoreConsonantSoftening(single);
+    return [single, ...hardened];
+  }
+  return [];
+}
+
+/**
+ * Reverses Turkish vowel narrowing (ünlü daralması):
+ * Verbs ending in wide vowels 'a' or 'e' narrow to 'ı', 'i', 'u', 'ü' before the continuous tense suffix -yor:
+ * e.g. başla-yor -> başlıyor, bekle-yor -> bekliyor, özle-yor -> özlüyor, anla-yor -> anlıyor.
+ * Also handles irregular monosyllabic verbs: de-yor -> diyor, ye-yor -> yiyor.
+ */
+export function restoreVowelNarrowing(stem: string): string[] {
+  if (stem.length < 2) return [];
+
+  // Irregular monosyllabic verbs
+  if (stem === "di") return ["de"];
+  if (stem === "yi") return ["ye"];
+
+  const lastChar = stem[stem.length - 1];
+  const isLastNarrow = "ıiuü".includes(lastChar);
+
+  // Case 1: stem ends with narrow vowel (e.g. başlı, bekli, özlü, kutlu)
+  if (isLastNarrow) {
+    const vowelsInBase = stem.slice(0, -1).split("").filter(isVowel);
+    const lastVowel = vowelsInBase.length > 0 ? vowelsInBase[vowelsInBase.length - 1] : lastChar;
+    const widened = "aıou".includes(lastVowel) ? "a" : "e";
+    return [stem.slice(0, -1) + widened];
+  }
+
+  // Case 2: stem ends with consonant (e.g. başlıyor stripped by -ıyor -> stem: başl)
+  if (!isVowel(lastChar)) {
+    const vowelsInBase = stem.split("").filter(isVowel);
+    if (vowelsInBase.length > 0) {
+      const lastVowel = vowelsInBase[vowelsInBase.length - 1];
+      const widened = "aıou".includes(lastVowel) ? "a" : "e";
+      return [stem + widened];
+    }
+  }
+
+  return [];
+}
+
 /**
  * Restores verb infinitive headword form (-mek / -mak):
  * Since TDK registers verbs in their infinitive form (e.g. okumak, gelmek, yazmak),
@@ -174,6 +230,15 @@ export function getStemCandidates(
     }
   }
 
+  // Bare verb imperative candidates (e.g. "söyle" -> "söylemek", "oku" -> "okumak")
+  const bareInfinitives = restoreInfinitive(normalized);
+  for (const inf of bareInfinitives) {
+    if (!seen.has(inf) && inf !== normalized) {
+      seen.add(inf);
+      candidatesWithWeight.push({ candidate: inf, baseLength: normalized.length });
+    }
+  }
+
   let frontier = [normalized];
 
   for (let depth = 0; depth < maxDepth; depth++) {
@@ -186,11 +251,55 @@ export function getStemCandidates(
 
           const hardened = restoreConsonantSoftening(stem);
           const vowelDropped = restoreVowelDrop(stem);
-          // Infinitives only apply to direct stems or consonant-hardened stems (e.g. gid -> git -> gitmek),
-          // NOT to vowel-dropped nouns (nouns like akıl/omuz/şehir don't take infinitive -mek/-mak).
-          const verbalBases = [stem, ...hardened];
+          const geminated = restoreGemination(stem);
+
+          // Vowel narrowing (ünlü daralması) in Turkish strictly occurs with continuous tense (-yor)
+          // or with the monosyllabic verbs de-/ye- before buffer 'y' (diye, yiyen).
+          // Restricting narrowing to these suffixes prevents false-positive stems on other suffixes.
+          const isNarrowingSuffix =
+            suffix.startsWith("yor") ||
+            suffix.includes("iyor") ||
+            suffix.includes("ıyor") ||
+            suffix.includes("uyor") ||
+            suffix.includes("üyor");
+
+          const isDeYeBuffer = (stem === "di" || stem === "yi") && suffix.startsWith("y");
+          const narrowed = isNarrowingSuffix || isDeYeBuffer ? restoreVowelNarrowing(stem) : [];
+
+          // Suffix indicator for verbs: -yor, -ecek, -miş, -di, etc.
+          const isVerbSuffix =
+            isNarrowingSuffix ||
+            suffix.includes("ecek") ||
+            suffix.includes("acak") ||
+            suffix.includes("miş") ||
+            suffix.includes("mış") ||
+            suffix.includes("müş") ||
+            suffix.includes("muş") ||
+            suffix.includes("mek") ||
+            suffix.includes("mak") ||
+            suffix.includes("erek") ||
+            suffix.includes("arak") ||
+            suffix.includes("dik") ||
+            suffix.includes("dık") ||
+            suffix.includes("duk") ||
+            suffix.includes("dük") ||
+            suffix.includes("tik") ||
+            suffix.includes("tık") ||
+            suffix.includes("tuk") ||
+            suffix.includes("tük") ||
+            suffix.includes("sen") ||
+            suffix.includes("san") ||
+            suffix.includes("sem") ||
+            suffix.includes("sam") ||
+            suffix.includes("sek") ||
+            suffix.includes("sak");
+
+          // Infinitives apply to direct stems, hardened stems, and widened stems (e.g. başlı -> başla -> başlamak)
+          const verbalBases = [stem, ...hardened, ...narrowed];
           const infinitives = verbalBases.flatMap((v) => restoreInfinitive(v));
-          const variants = [stem, ...hardened, ...vowelDropped, ...infinitives];
+
+          // Base candidates
+          const variants = [stem, ...hardened, ...vowelDropped, ...geminated, ...narrowed];
 
           for (const variant of variants) {
             if (!seen.has(variant) && variant !== normalized) {
@@ -199,6 +308,16 @@ export function getStemCandidates(
               candidatesWithWeight.push({ candidate: variant, baseLength: stem.length });
             }
           }
+
+          // Push infinitives with high priority if a verbal suffix matched, preventing noun false-positives
+          for (const inf of infinitives) {
+            if (!seen.has(inf) && inf !== normalized) {
+              seen.add(inf);
+              nextFrontier.push(inf);
+              const weight = isVerbSuffix ? stem.length + 5 : stem.length;
+              candidatesWithWeight.push({ candidate: inf, baseLength: weight });
+            }
+          }
         }
       }
     }