@akredit/acik-mcp 0.1.0 → 0.5.0

package/dist/apps/acik-mcp/src/kaynak-dogrula.js

@@ -0,0 +1,460 @@
+// Kaynak doğrulama: DOI, ISBN ya da başlık+yazar ile eserin gerçekten var olduğunu açık kataloglardan denetler.
+// Yalnız sabit, izinli hostlara sorar (api.crossref.org, openlibrary.org, www.googleapis.com/books). Ağ adresi
+// kullanıcıdan alınmaz; kullanıcı girdisi yalnız doğrulanmış DOI, ISBN ya da sorgu parametresi olarak, kodlanarak
+// adrese girer (SSRF yok). Her istekte zaman aşımı ve yanıt boyutu sınırı vardır, yanıt zod ile doğrulanır.
+//
+// Uydurma yok: künye yalnız katalog yanıtındaki alanlardan kurulur ve kaynak_bicimle biçimiyle yazılır. Başlık
+// ve yazarla aramada eşleşme deterministik bir denetimden (başlık sözcükleri, tam soyad belirteci, kayıt türü,
+// verilmişse yıl) geçmezse sonuç "bulunamadi"dır.
+//
+// Ayrım (dış inceleme 2026-11-05): "katalogda bulundu" yalnız eserin katalogda var olduğunu söyler; "ders kaynağı
+// olarak uygun" kararı hocanındır. Türkçe kitapların çoğu bu kataloglarda yoktur: bulunamayan eser uydurma sayılmaz
+// ama doğrulanmış da sayılmaz; yalnız hocanın verdiği bilgiyle "hoca_beyani" etiketiyle yazılabilir.
+//
+// Kötüye kullanım sınırı: çağrı başına en çok 5 kaynak, süreç genelinde en çok 4 eşzamanlı dış istek, yanıt akışla
+// okunur ve sınırda kesilir. Adres başına ayrı kota HTTP katmanındadır (http.ts).
+//
+// İmza: bulunan her kayıt, sürecin gizli anahtarıyla künye+bağlantı üzerinden imzalanır. Bologna araçları kaynağı
+// "doğrulanmış" saymak için bu imzayı arar; asistan imzayı kendisi üretemez.
+import { createHmac, randomBytes, timingSafeEqual } from "node:crypto";
+import { z } from "zod";
+import { kunyeBicimle } from "./kaynak.js";
+import { AracHatasi, arac, KOD_KAYNAGI } from "./temel.js";
+export const IZINLI_HOSTLAR = ["api.crossref.org", "openlibrary.org", "www.googleapis.com"];
+export const ZAMAN_ASIMI_MS = 8000;
+export const EN_BUYUK_YANIT = 1_000_000;
+/** Çağrı başına en çok kaynak. */
+export const EN_COK_KAYNAK = 5;
+/** Süreç genelinde aynı anda en çok dış istek. */
+export const ESZAMANLI_DIS_ISTEK = 4;
+// ---------------------------------------------------------------- Eşzamanlılık sınırı (semafor)
+let aktifIstek = 0;
+const bekleyenler = [];
+/** Süreç genelindeki dış istek semaforu. Sınır doluysa sıra bekler. */
+export async function sinirli(is) {
+    if (aktifIstek >= ESZAMANLI_DIS_ISTEK)
+        await new Promise((coz) => bekleyenler.push(coz));
+    aktifIstek += 1;
+    try {
+        return await is();
+    }
+    finally {
+        aktifIstek -= 1;
+        bekleyenler.shift()?.();
+    }
+}
+// ---------------------------------------------------------------- İmza
+// Anahtar ilk kullanımda üretilir: modül tarayıcı araçlarına da (/deneyin) girer ve orada imza hiç kullanılmaz.
+let imzaAnahtari;
+function anahtar() {
+    if (!imzaAnahtari) {
+        const ortam = typeof process !== "undefined" ? process.env.AKREDIT_MCP_IMZA_ANAHTARI : undefined;
+        imzaAnahtari = ortam && ortam.length >= 16 ? Buffer.from(ortam) : randomBytes(32);
+    }
+    return imzaAnahtari;
+}
+/** Katalog kaydının imzası: künye ve bağlantı üzerinden HMAC-SHA256 (ilk 32 onaltılık hane). */
+export function kaynakImzasi(kunye, baglanti) {
+    return createHmac("sha256", anahtar()).update(`${kunye}\n${baglanti}`).digest("hex").slice(0, 32);
+}
+/** İmza bu sürecin kaynak_dogrula çıktısına mı ait? */
+export function kaynakImzasiDogru(kunye, baglanti, imza) {
+    const beklenen = Buffer.from(kaynakImzasi(kunye, baglanti));
+    const verilen = Buffer.from(String(imza));
+    return beklenen.length === verilen.length && timingSafeEqual(beklenen, verilen);
+}
+const DOI_DESENI = /^10\.\d{4,9}\/[^\s]{1,200}$/u;
+/** "https://doi.org/10.x/y", "doi:10.x/y" ya da "10.x/y" → "10.x/y". Geçersizse null. */
+export function doiTemizle(d) {
+    const t = d
+        .trim()
+        .replace(/^https?:\/\/(dx\.)?doi\.org\//iu, "")
+        .replace(/^doi:\s*/iu, "");
+    return DOI_DESENI.test(t) ? t : null;
+}
+/** ISBN-10 ya da ISBN-13; tire ve boşluk atılır, denetim basamağı sınanır. Geçersizse null. */
+export function isbnTemizle(i) {
+    const t = i.replace(/[\s-]/gu, "").toUpperCase();
+    if (/^\d{13}$/u.test(t)) {
+        // ISBN-13: basamaklar sırayla 1 ve 3 ile çarpılır, toplam 10'un katı olmalı.
+        const top = [...t].reduce((s, c, k) => s + Number(c) * (k % 2 ? 3 : 1), 0);
+        return top % 10 === 0 ? t : null;
+    }
+    if (/^\d{9}[\dX]$/u.test(t)) {
+        // ISBN-10: basamaklar 10'dan 1'e ağırlıkla çarpılır (X = 10), toplam 11'in katı olmalı.
+        const top = [...t].reduce((s, c, k) => s + (c === "X" ? 10 : Number(c)) * (10 - k), 0);
+        return top % 11 === 0 ? t : null;
+    }
+    return null;
+}
+/** Karşılaştırma için sadeleştirme: küçük harf, Türkçe harfler düz, noktalama yok. */
+export function sadele(s) {
+    return s
+        .toLocaleLowerCase("tr")
+        .normalize("NFD")
+        .replace(/\p{M}/gu, "")
+        .replace(/ı/gu, "i")
+        .replace(/[^\p{L}\p{N}\s]/gu, " ")
+        .split(/\s+/u)
+        .filter((x) => x.length > 1);
+}
+/**
+ * Sorgu başlığının sözcüklerinin en az %80'i bulunan başlıkta var mı, ve bulunanın en az %60'ı sorguda var mı.
+ * Kısa (en çok iki sözcüklü) başlıklarda ("Veri Yapıları", "Genel Kimya") sözcük kümeleri birebir aynı olmalı.
+ */
+export function baslikEslesir(sorgu, bulunan) {
+    const a = [...new Set(sadele(sorgu))];
+    const b = new Set(sadele(bulunan));
+    if (!a.length || !b.size)
+        return false;
+    const ortak = a.filter((x) => b.has(x)).length;
+    if (a.length <= 2)
+        return ortak === a.length && b.size === a.length;
+    return ortak / a.length >= 0.8 && ortak / b.size >= 0.6;
+}
+/**
+ * Sorgudaki yazar soyadı (son sözcük ya da virgülden önceki kısım) bulunan yazarlardan birinde TAM belirteç olarak
+ * geçiyor mu. Alt dize yetmez: "Yılmaz" sorgusu "Yılmazer" ile eşleşmez.
+ */
+export function yazarEslesir(sorgu, yazarlar) {
+    const soyad = sorgu.includes(",") ? (sorgu.split(",")[0] ?? "") : (sorgu.trim().split(/\s+/u).at(-1) ?? "");
+    const s = sadele(soyad);
+    if (!s.length)
+        return false;
+    return yazarlar.some((y) => {
+        const b = new Set(sadele(y));
+        return s.every((x) => b.has(x));
+    });
+}
+// ---------------------------------------------------------------- Güvenli istek
+async function getir(f, adres) {
+    if (adres.protocol !== "https:" || !IZINLI_HOSTLAR.includes(adres.hostname))
+        throw new Error("İzinsiz host");
+    if (adres.hostname === "www.googleapis.com" && !adres.pathname.startsWith("/books/"))
+        throw new Error("İzinsiz yol");
+    return sinirli(async () => {
+        let y;
+        try {
+            y = await f(adres.toString(), {
+                signal: AbortSignal.timeout(ZAMAN_ASIMI_MS),
+                redirect: "error",
+                headers: { accept: "application/json", "user-agent": "akredit-acik-mcp (https://akredit.org)" },
+            });
+        }
+        catch {
+            return null;
+        }
+        if (!y.ok)
+            return null;
+        const uzunluk = Number(y.headers.get("content-length") ?? "0");
+        if (uzunluk > EN_BUYUK_YANIT)
+            return null;
+        const metin = await sinirliMetin(y, EN_BUYUK_YANIT);
+        if (metin === null)
+            return null;
+        try {
+            return JSON.parse(metin);
+        }
+        catch {
+            return null;
+        }
+    });
+}
+/** Yanıt gövdesini bayt sayarak okur; sınır aşılırsa akışı iptal edip null döner. */
+export async function sinirliMetin(y, enBuyuk) {
+    if (!y.body)
+        return "";
+    const okuyucu = y.body.getReader();
+    const parcalar = [];
+    let toplam = 0;
+    try {
+        for (;;) {
+            const { done, value } = await okuyucu.read();
+            if (done)
+                break;
+            toplam += value.byteLength;
+            if (toplam > enBuyuk) {
+                await okuyucu.cancel().catch(() => { });
+                return null;
+            }
+            parcalar.push(value);
+        }
+    }
+    catch {
+        return null;
+    }
+    return Buffer.concat(parcalar).toString("utf8");
+}
+// ---------------------------------------------------------------- Katalog yanıtları (zod)
+const CrossrefEser = z.object({
+    DOI: z.string(),
+    type: z.string().optional(),
+    title: z.array(z.string()).optional(),
+    author: z
+        .array(z.object({ given: z.string().optional(), family: z.string().optional(), name: z.string().optional() }))
+        .optional(),
+    editor: z.array(z.object({ given: z.string().optional(), family: z.string().optional() })).optional(),
+    "container-title": z.array(z.string()).optional(),
+    publisher: z.string().optional(),
+    volume: z.string().optional(),
+    issue: z.string().optional(),
+    page: z.string().optional(),
+    issued: z.object({ "date-parts": z.array(z.array(z.number().nullable())).optional() }).optional(),
+});
+const CrossrefTek = z.object({ message: CrossrefEser });
+const CrossrefListe = z.object({ message: z.object({ items: z.array(CrossrefEser) }) });
+const OpenLibraryKitap = z.object({
+    title: z.string(),
+    url: z.string().optional(),
+    authors: z.array(z.object({ name: z.string() })).optional(),
+    publishers: z.array(z.object({ name: z.string() })).optional(),
+    publish_date: z.string().optional(),
+});
+const OpenLibraryYanit = z.record(z.string(), OpenLibraryKitap);
+const GoogleCilt = z.object({
+    id: z.string(),
+    volumeInfo: z.object({
+        title: z.string(),
+        subtitle: z.string().optional(),
+        authors: z.array(z.string()).optional(),
+        publisher: z.string().optional(),
+        publishedDate: z.string().optional(),
+        industryIdentifiers: z.array(z.object({ type: z.string(), identifier: z.string() })).optional(),
+    }),
+});
+const GoogleYanit = z.object({ totalItems: z.number().optional(), items: z.array(GoogleCilt).optional() });
+const HOCA_BEYANI = "Katalogda bulunamadı. Hoca bu eseri kendisi kullanıyorsa künyesini hocanın verdiği bilgiyle 'hoca_beyani' etiketiyle yazın; asistan künye alanı uydurmaz.";
+const bulunamadi = (neden) => ({ durum: "bulunamadi", neden, hocaBeyani: HOCA_BEYANI });
+const yilAl = (s) => {
+    const m = s?.match(/\b(1[4-9]\d{2}|20\d{2}|2100)\b/u);
+    return m ? Number(m[1]) : undefined;
+};
+const kur = (k, baglanti, katalog, kayitTuru = k.tur === "makale" ? "makale" : k.tur === "kitap_bolumu" ? "kitap_bolumu" : "kitap") => {
+    const g = { ...k, kurumYazar: false };
+    const { kunye, eksikler } = kunyeBicimle(g);
+    return {
+        durum: "katalogda_bulundu",
+        kunye,
+        eksikler,
+        baglanti,
+        katalog,
+        kayitTuru,
+        baslik: k.baslik,
+        yazarlar: k.yazarlar,
+        ...(k.yil !== undefined ? { yil: k.yil } : {}),
+        kimlik_eslesmesi: { yontem: "baslik_yazar", denetlenen: [] },
+        bibliyografik_tamlik: eksikler.length ? "eksik" : "tam",
+        ders_kaynagi_uygunlugu: "hoca karar verir",
+        imza: kaynakImzasi(kunye, baglanti),
+    };
+};
+const CROSSREF_KITAP = new Set(["book", "monograph", "edited-book", "reference-book", "book-set", "book-series"]);
+const crossrefTuru = (t) => t === "journal-article"
+    ? "makale"
+    : t === "book-chapter" || t === "book-section" || t === "book-part"
+        ? "kitap_bolumu"
+        : t && CROSSREF_KITAP.has(t)
+            ? "kitap"
+            : "diger";
+function crossrefKunye(e) {
+    const baslik = e.title?.[0]?.trim();
+    if (!baslik)
+        return null;
+    const yazarlar = (e.author ?? [])
+        .map((a) => (a.family ? [a.family, a.given].filter(Boolean).join(", ") : (a.name ?? "")))
+        .filter(Boolean);
+    const yil = e.issued?.["date-parts"]?.[0]?.[0] ?? undefined;
+    const kap = e["container-title"]?.[0];
+    const kayit = crossrefTuru(e.type);
+    const tur = kayit === "makale" ? "makale" : kayit === "kitap_bolumu" ? "kitap_bolumu" : "kitap";
+    const doi = e.DOI;
+    return kur({
+        tur,
+        yazarlar,
+        baslik,
+        ...(yil ? { yil } : {}),
+        ...(tur === "makale" && kap ? { dergi: kap } : {}),
+        ...(tur === "kitap_bolumu" && kap ? { kitapBasligi: kap } : {}),
+        ...(tur !== "makale" && e.publisher ? { yayinevi: e.publisher } : {}),
+        ...(tur === "kitap_bolumu" && e.editor?.length
+            ? {
+                editorler: e.editor.map((x) => [x.family, x.given].filter(Boolean).join(", ")).filter((x) => x.length >= 2),
+            }
+            : {}),
+        ...(e.volume ? { cilt: e.volume } : {}),
+        ...(e.issue ? { sayi: e.issue } : {}),
+        ...(e.page ? { sayfalar: e.page } : {}),
+        doi,
+    }, `https://doi.org/${doi}`, "Crossref", kayit);
+}
+function googleKunye(c) {
+    const v = c.volumeInfo;
+    const yil = yilAl(v.publishedDate);
+    return kur({
+        tur: "kitap",
+        yazarlar: v.authors ?? [],
+        baslik: v.subtitle ? `${v.title}: ${v.subtitle}` : v.title,
+        ...(yil ? { yil } : {}),
+        ...(v.publisher ? { yayinevi: v.publisher } : {}),
+    }, `https://books.google.com/books?id=${encodeURIComponent(c.id)}`, "Google Books");
+}
+// ---------------------------------------------------------------- Sorgular
+const CROSSREF = "https://api.crossref.org/works";
+const OPENLIBRARY = "https://openlibrary.org/api/books";
+const GOOGLE = "https://www.googleapis.com/books/v1/volumes";
+const KAYIT_ADI = {
+    kitap: "kitap",
+    makale: "dergi makalesi",
+    kitap_bolumu: "kitap bölümü",
+    diger: "başka türde bir kayıt (bildiri, rapor...)",
+};
+/** Aranan tür ve yıl verildiyse kayıtla uyuşuyor mu; uyuşmuyorsa nedeni. */
+function ekDenetim(k, s) {
+    if (s.tur && s.tur !== "herhangi" && k.kayitTuru !== s.tur)
+        return `Katalogdaki kayıt ${KAYIT_ADI[k.kayitTuru]}; aranan ${KAYIT_ADI[s.tur]}. Aynı eser sayılmadı.`;
+    if (s.yil !== undefined) {
+        const y = typeof k.yil === "number" ? k.yil : yilAl(String(k.yil ?? ""));
+        if (y === undefined)
+            return "Katalog kaydında yıl yok; verilen yılla karşılaştırılamadı.";
+        if (y !== s.yil)
+            return `Katalogdaki yıl ${y}, verilen yıl ${s.yil}. Aynı baskı sayılmadı.`;
+    }
+    return null;
+}
+function sonla(k, yontem, s, bulunamadiNedeni) {
+    if (!k)
+        return bulunamadi(bulunamadiNedeni);
+    const sorun = ekDenetim(k, s);
+    if (sorun)
+        return bulunamadi(sorun);
+    const denetlenen = [
+        yontem === "doi" ? "DOI" : yontem === "isbn" ? "ISBN (sağlama basamağı geçerli)" : "başlık sözcükleri, tam soyad",
+        ...(s.tur && s.tur !== "herhangi" ? ["kayıt türü"] : []),
+        ...(s.yil !== undefined ? ["yıl"] : []),
+    ];
+    return { ...k, kimlik_eslesmesi: { yontem, denetlenen } };
+}
+async function doiIle(f, doi) {
+    const y = CrossrefTek.safeParse(await getir(f, new URL(`${CROSSREF}/${encodeURIComponent(doi)}`)));
+    return y.success ? crossrefKunye(y.data.message) : null;
+}
+async function isbnIle(f, isbn) {
+    const ol = new URL(OPENLIBRARY);
+    ol.searchParams.set("bibkeys", `ISBN:${isbn}`);
+    ol.searchParams.set("format", "json");
+    ol.searchParams.set("jscmd", "data");
+    const o = OpenLibraryYanit.safeParse(await getir(f, ol));
+    const kitap = o.success ? o.data[`ISBN:${isbn}`] : undefined;
+    if (kitap) {
+        const yil = yilAl(kitap.publish_date);
+        const baglanti = kitap.url && /^https:\/\/openlibrary\.org\//u.test(kitap.url)
+            ? kitap.url
+            : `https://openlibrary.org/isbn/${isbn}`;
+        return kur({
+            tur: "kitap",
+            yazarlar: (kitap.authors ?? []).map((a) => a.name),
+            baslik: kitap.title,
+            ...(yil ? { yil } : {}),
+            ...(kitap.publishers?.[0] ? { yayinevi: kitap.publishers[0].name } : {}),
+        }, baglanti, "Open Library");
+    }
+    const g = new URL(GOOGLE);
+    g.searchParams.set("q", `isbn:${isbn}`);
+    const gy = GoogleYanit.safeParse(await getir(f, g));
+    const c = gy.success
+        ? gy.data.items?.find((x) => (x.volumeInfo.industryIdentifiers ?? []).some((i) => i.identifier.replace(/-/gu, "") === isbn))
+        : undefined;
+    return c ? googleKunye(c) : null;
+}
+async function baslikIle(f, baslik, yazar, s) {
+    const uygun = (k) => baslikEslesir(baslik, k.baslik) && yazarEslesir(yazar, k.yazarlar) && ekDenetim(k, s) === null;
+    const g = new URL(GOOGLE);
+    g.searchParams.set("q", `intitle:${baslik} inauthor:${yazar}`);
+    g.searchParams.set("maxResults", "5");
+    const gy = GoogleYanit.safeParse(await getir(f, g));
+    if (gy.success)
+        for (const x of gy.data.items ?? []) {
+            const k = googleKunye(x);
+            if (baslikEslesir(baslik, x.volumeInfo.title) && uygun(k))
+                return k;
+        }
+    const cr = new URL(CROSSREF);
+    cr.searchParams.set("query.bibliographic", baslik);
+    cr.searchParams.set("query.author", yazar);
+    cr.searchParams.set("rows", "5");
+    const cy = CrossrefListe.safeParse(await getir(f, cr));
+    if (cy.success)
+        for (const e of cy.data.message.items) {
+            const k = crossrefKunye(e);
+            if (k && uygun(k))
+                return k;
+        }
+    return null;
+}
+const KaynakSorgusu = z
+    .object({
+    doi: z.string().trim().max(250).optional(),
+    isbn: z.string().trim().max(30).optional(),
+    baslik: z.string().trim().min(2).max(300).optional(),
+    yazar: z.string().trim().min(2).max(120).optional(),
+    tur: z
+        .enum(["kitap", "makale", "kitap_bolumu", "herhangi"])
+        .optional()
+        .describe("Aranan kayıt türü. Kitap aranıyorsa dergi makalesi kabul edilmez. ISBN verilirse varsayılan kitap."),
+    yil: z.number().int().min(1400).max(2100).optional().describe("Biliniyorsa yayın yılı; kayıtla birebir uymalı"),
+})
+    .refine((k) => k.doi || k.isbn || (k.baslik && k.yazar), {
+    message: "DOI, ISBN ya da başlık ile yazar verin.",
+});
+/** Tek kaynağı doğrular. DOI önce, sonra ISBN, sonra başlık+yazar. */
+export async function kaynakDogrula(f, k) {
+    const ek = { tur: k.tur, yil: k.yil };
+    if (k.doi) {
+        const d = doiTemizle(k.doi);
+        if (!d)
+            return bulunamadi("DOI biçimi geçersiz (10.xxxx/... olmalı).");
+        return sonla(await doiIle(f, d), "doi", ek, "Bu DOI Crossref kataloğunda bulunamadı.");
+    }
+    if (k.isbn) {
+        const i = isbnTemizle(k.isbn);
+        if (!i)
+            return bulunamadi("ISBN geçersiz (sağlama basamağı tutmuyor).");
+        return sonla(await isbnIle(f, i), "isbn", { ...ek, tur: k.tur ?? "kitap" }, "Bu ISBN Open Library ve Google Books'ta bulunamadı.");
+    }
+    return sonla(await baslikIle(f, k.baslik ?? "", k.yazar ?? "", ek), "baslik_yazar", ek, "Bu başlık ve yazarla (tam soyad, verildiyse tür ve yıl) eşleşen eser Google Books ve Crossref kataloglarında bulunamadı. Türkçe kitapların çoğu bu kataloglarda yoktur.");
+}
+const KATALOG_KAYNAKLARI = [
+    { ad: "Crossref REST API", adres: "https://api.crossref.org" },
+    { ad: "Open Library Books API", adres: "https://openlibrary.org/developers/api" },
+    { ad: "Google Books API", adres: "https://developers.google.com/books" },
+];
+export const kaynakDogrulaAraci = arac({
+    ad: "kaynak_dogrula",
+    baslik: "Kaynağın gerçekten var olduğunu doğrula",
+    aciklama: "DOI, ISBN ya da başlık ile yazar verilen eserleri (çağrı başına en çok 5) açık kataloglarda (Crossref, Open Library, Google Books) arar. Eşleşme için tam soyad, başlık sözcükleri, verildiyse kayıt türü ve yıl denetlenir. Bulursa katalogdaki bilgiden künye, bağlantı ve imza döndürür ('katalogda_bulundu'); bulamazsa 'bulunamadi' der. Katalogda bulunmak ders kaynağı olarak uygunluk demek değildir; ona hoca karar verir.",
+    sonrakiAdim: "Yalnız 'katalogda_bulundu' olan kaynakları hocaya künyesi ve bağlantısıyla gösterin; uygunluğuna hoca karar verir. Bologna araçlarına kaynağı { kunye, dogrulama: { durum, baglanti, imza } } olarak aynen verin. 'bulunamadi' olan kaynağı asla kendiniz önermeyin; hoca o eseri kullandığını söylerse yalnız hocanın verdiği bilgiyle dogrulama: 'hoca_beyani' olarak yazın.",
+    kunyeAlanlari: ["kaynaklar"],
+    disAg: true,
+    // Künye ve katalog numaraları kişisel veri değildir; ISBN gibi uzun sayılar numara deseniyle karışmasın.
+    kisiselVeriKapsami: "yok",
+    girdi: z.object({
+        kaynaklar: z.array(KaynakSorgusu).min(1).max(EN_COK_KAYNAK),
+    }),
+    calistir: async ({ kaynaklar }, b) => {
+        const f = b.fetch ?? globalThis.fetch;
+        if (!f)
+            throw new AracHatasi("Bu ortamda dış katalog sorgusu yapılamıyor. Kaynakları şimdilik önermeyin.");
+        const sonuclar = await Promise.all(kaynaklar.map((k) => kaynakDogrula(f, k)));
+        const liste = sonuclar.map((s, i) => ({ no: i + 1, ...s }));
+        const bulunan = liste.filter((s) => s.durum === "katalogda_bulundu").length;
+        return {
+            sonuc: {
+                kaynaklar: liste,
+                katalogdaBulunan: bulunan,
+                bulunamayan: liste.length - bulunan,
+                kural: "Katalogda bulunmayan kaynak asistanca önerilmez; hoca kullandığını söylerse 'hoca_beyani' etiketiyle yazılır. Künye katalog bilgisinden kurulur; katalogda olmayan alan [EKSİK] kalır. Ders kaynağı olarak uygunluğa hoca karar verir.",
+            },
+            kaynak: [KOD_KAYNAGI("apps/acik-mcp/src/kaynak-dogrula.ts", "Akredit kaynak doğrulayıcı"), ...KATALOG_KAYNAKLARI],
+        };
+    },
+});

package/dist/apps/acik-mcp/src/kaynak.d.ts

@@ -0,0 +1,72 @@
+import { z } from "zod";
+declare const Kaynak: z.ZodObject<{
+    tur: z.ZodDefault<z.ZodEnum<{
+        web: "web";
+        kitap: "kitap";
+        makale: "makale";
+        kitap_bolumu: "kitap_bolumu";
+        tez: "tez";
+    }>>;
+    yazarlar: z.ZodDefault<z.ZodArray<z.ZodString>>;
+    kurumYazar: z.ZodDefault<z.ZodBoolean>;
+    yil: z.ZodOptional<z.ZodUnion<readonly [z.ZodNumber, z.ZodString]>>;
+    baslik: z.ZodString;
+    baski: z.ZodOptional<z.ZodNumber>;
+    yayinevi: z.ZodOptional<z.ZodString>;
+    dergi: z.ZodOptional<z.ZodString>;
+    cilt: z.ZodOptional<z.ZodString>;
+    sayi: z.ZodOptional<z.ZodString>;
+    sayfalar: z.ZodOptional<z.ZodString>;
+    editorler: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    kitapBasligi: z.ZodOptional<z.ZodString>;
+    kurum: z.ZodOptional<z.ZodString>;
+    tezTuru: z.ZodOptional<z.ZodEnum<{
+        yuksek_lisans: "yuksek_lisans";
+        doktora: "doktora";
+    }>>;
+    site: z.ZodOptional<z.ZodString>;
+    doi: z.ZodOptional<z.ZodString>;
+    url: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
+type KaynakT = z.infer<typeof Kaynak>;
+/** "Soyad, Ad İkinci" ya da "Ad İkinci Soyad" → "Soyad, A. İ." */
+export declare function yazarBicimle(ad: string, kurum?: boolean): string;
+/** APA 7: 1 yazar "A"; 2 yazar "A, & B"; 3-20 yazar virgülle, sonuncudan önce "&"; 21+ ilk 19, "...", son. */
+export declare function yazarListesi(yazarlar: string[], kurum?: boolean): string;
+/** Tek künye. Eksik zorunlu bilgi [EKSİK: ...] olarak yazılır ve ayrıca listelenir. */
+export declare function kunyeBicimle(k: KaynakT): {
+    kunye: string;
+    eksikler: string[];
+};
+export declare const kaynakBicimleAraci: import("./temel.ts").AcikArac<z.ZodObject<{
+    kaynaklar: z.ZodArray<z.ZodObject<{
+        tur: z.ZodDefault<z.ZodEnum<{
+            web: "web";
+            kitap: "kitap";
+            makale: "makale";
+            kitap_bolumu: "kitap_bolumu";
+            tez: "tez";
+        }>>;
+        yazarlar: z.ZodDefault<z.ZodArray<z.ZodString>>;
+        kurumYazar: z.ZodDefault<z.ZodBoolean>;
+        yil: z.ZodOptional<z.ZodUnion<readonly [z.ZodNumber, z.ZodString]>>;
+        baslik: z.ZodString;
+        baski: z.ZodOptional<z.ZodNumber>;
+        yayinevi: z.ZodOptional<z.ZodString>;
+        dergi: z.ZodOptional<z.ZodString>;
+        cilt: z.ZodOptional<z.ZodString>;
+        sayi: z.ZodOptional<z.ZodString>;
+        sayfalar: z.ZodOptional<z.ZodString>;
+        editorler: z.ZodOptional<z.ZodArray<z.ZodString>>;
+        kitapBasligi: z.ZodOptional<z.ZodString>;
+        kurum: z.ZodOptional<z.ZodString>;
+        tezTuru: z.ZodOptional<z.ZodEnum<{
+            yuksek_lisans: "yuksek_lisans";
+            doktora: "doktora";
+        }>>;
+        site: z.ZodOptional<z.ZodString>;
+        doi: z.ZodOptional<z.ZodString>;
+        url: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>>;
+}, z.core.$strip>>;
+export {};