@akredit/acik-mcp 0.1.0 → 0.4.0

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

@@ -0,0 +1,319 @@
+// 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 benzerlik denetiminden geçmezse sonuç "doğrulanamadı"dır; istem o
+// eserin asla önerilmemesini söyler.
+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;
+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ı. */
+export function baslikEslesir(sorgu, bulunan) {
+    const a = sadele(sorgu);
+    const b = new Set(sadele(bulunan));
+    if (!a.length || !b.size)
+        return false;
+    const ortak = a.filter((x) => b.has(x)).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 geçiyor mu. */
+export function yazarEslesir(sorgu, yazarlar) {
+    const soyad = sorgu.includes(",") ? (sorgu.split(",")[0] ?? "") : (sorgu.trim().split(/\s+/u).at(-1) ?? "");
+    const s = sadele(soyad).join(" ");
+    if (!s)
+        return false;
+    return yazarlar.some((y) => sadele(y).join(" ").includes(s));
+}
+// ---------------------------------------------------------------- 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");
+    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 y.text();
+    if (metin.length > EN_BUYUK_YANIT)
+        return null;
+    try {
+        return JSON.parse(metin);
+    }
+    catch {
+        return null;
+    }
+}
+// ---------------------------------------------------------------- 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 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) => {
+    const g = { ...k, kurumYazar: false };
+    const { kunye, eksikler } = kunyeBicimle(g);
+    return {
+        durum: "dogrulandi",
+        kunye,
+        eksikler,
+        baglanti,
+        katalog,
+        baslik: k.baslik,
+        yazarlar: k.yazarlar,
+        ...(k.yil !== undefined ? { yil: k.yil } : {}),
+    };
+};
+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 tur = e.type === "journal-article" ? "makale" : e.type === "book-chapter" ? "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");
+}
+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";
+async function doiIle(f, doi) {
+    const y = CrossrefTek.safeParse(await getir(f, new URL(`${CROSSREF}/${encodeURIComponent(doi)}`)));
+    const k = y.success ? crossrefKunye(y.data.message) : null;
+    return k ?? { durum: "dogrulanamadi", neden: "Bu DOI Crossref kataloğunda bulunamadı." };
+}
+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) : { durum: "dogrulanamadi", neden: "Bu ISBN Open Library ve Google Books'ta bulunamadı." };
+}
+async function baslikIle(f, baslik, yazar) {
+    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));
+    const c = gy.success
+        ? gy.data.items?.find((x) => baslikEslesir(baslik, x.volumeInfo.title) && yazarEslesir(yazar, x.volumeInfo.authors ?? []))
+        : undefined;
+    if (c)
+        return googleKunye(c);
+    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 && baslikEslesir(baslik, k.baslik) && yazarEslesir(yazar, k.yazarlar))
+                return k;
+        }
+    return {
+        durum: "dogrulanamadi",
+        neden: "Bu başlık ve yazarla eşleşen eser Google Books ve Crossref kataloglarında bulunamadı.",
+    };
+}
+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(),
+})
+    .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) {
+    if (k.doi) {
+        const d = doiTemizle(k.doi);
+        if (!d)
+            return { durum: "dogrulanamadi", neden: "DOI biçimi geçersiz (10.xxxx/... olmalı)." };
+        return doiIle(f, d);
+    }
+    if (k.isbn) {
+        const i = isbnTemizle(k.isbn);
+        if (!i)
+            return { durum: "dogrulanamadi", neden: "ISBN geçersiz (denetim basamağı tutmuyor)." };
+        return isbnIle(f, i);
+    }
+    return baslikIle(f, k.baslik ?? "", k.yazar ?? "");
+}
+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çık kataloglarda (Crossref, Open Library, Google Books) arar. Bulursa katalogdaki bilgiden künye ve açılabilir bağlantı döndürür; bulamazsa 'doğrulanamadı' der. Önerilecek her kaynak önce bu araçtan geçer.",
+    sonrakiAdim: "Yalnız durumu 'dogrulandi' olan kaynakları hocaya künyesi ve bağlantısıyla numaralı seçenek olarak gösterin. 'dogrulanamadi' olan kaynağı asla önermeyin, künyesini yazmayın; yerine başka bir aday arayıp yeniden doğrulayı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(10),
+    }),
+    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 dogrulanan = liste.filter((s) => s.durum === "dogrulandi").length;
+        return {
+            sonuc: {
+                kaynaklar: liste,
+                dogrulanan,
+                dogrulanamayan: liste.length - dogrulanan,
+                kural: "Doğrulanamayan kaynak önerilmez. Künye katalog bilgisinden kurulur; katalogda olmayan alan [EKSİK] kalır.",
+            },
+            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 {};

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

@@ -0,0 +1,155 @@
+// Kaynak künyesi biçimlendirme: APA 7'ye benzer, Türkçe kısaltmalı, deterministik. Yalnız verilen bilgiyi dizer;
+// eksik bilgi tahmin edilmez, künyede [EKSİK: ...] olarak görünür. Yazar adları yayımlanmış künyedir; bu araçta
+// kişi adı deseni aranmaz (künye kuralı), e-posta ve telefon yine reddedilir.
+import { z } from "zod";
+import { arac, KOD_KAYNAGI } from "./temel.js";
+const Kaynak = z.object({
+    tur: z.enum(["kitap", "makale", "kitap_bolumu", "web", "tez"]).default("kitap"),
+    yazarlar: z
+        .array(z.string().trim().min(2).max(120))
+        .max(25)
+        .default([])
+        .describe("'Soyad, Ad' ya da 'Ad Soyad'; kurum adı da olabilir"),
+    kurumYazar: z.boolean().default(false).describe("Yazar bir kurumsa (ör. Kurgu Bakanlığı) true"),
+    yil: z.union([z.number().int().min(1400).max(2100), z.string().trim().max(20)]).optional(),
+    baslik: z.string().trim().min(2).max(400),
+    baski: z.number().int().min(2).max(50).optional(),
+    yayinevi: z.string().trim().max(200).optional(),
+    dergi: z.string().trim().max(200).optional(),
+    cilt: z.string().trim().max(20).optional(),
+    sayi: z.string().trim().max(20).optional(),
+    sayfalar: z.string().trim().max(30).optional().describe("ör. '12-30'"),
+    editorler: z.array(z.string().trim().min(2).max(120)).max(10).optional(),
+    kitapBasligi: z.string().trim().max(400).optional(),
+    kurum: z.string().trim().max(200).optional().describe("Tezde üniversite"),
+    tezTuru: z.enum(["yuksek_lisans", "doktora"]).optional(),
+    site: z.string().trim().max(200).optional(),
+    doi: z.string().trim().max(200).optional(),
+    url: z.string().trim().max(500).optional(),
+});
+const bas = (s) => {
+    const h = [...s.trim()][0] ?? "";
+    return h ? `${h.toLocaleUpperCase("tr")}.` : "";
+};
+/** "Soyad, Ad İkinci" ya da "Ad İkinci Soyad" → "Soyad, A. İ." */
+export function yazarBicimle(ad, kurum = false) {
+    const a = ad.trim().replace(/\s+/gu, " ");
+    if (kurum)
+        return a;
+    if (a.includes(",")) {
+        const [soyad, ...ilk] = a.split(",");
+        const adlar = ilk
+            .join(" ")
+            .trim()
+            .split(/[\s-]+/u)
+            .filter(Boolean);
+        return [soyad?.trim(), adlar.map(bas).join(" ")].filter(Boolean).join(", ");
+    }
+    const p = a.split(" ");
+    if (p.length === 1)
+        return a;
+    const soyad = p.at(-1) ?? "";
+    return `${soyad}, ${p.slice(0, -1).map(bas).join(" ")}`;
+}
+/** APA 7: 1 yazar "A"; 2 yazar "A, & B"; 3-20 yazar virgülle, sonuncudan önce "&"; 21+ ilk 19, "...", son. */
+export function yazarListesi(yazarlar, kurum = false) {
+    const b = yazarlar.map((y) => yazarBicimle(y, kurum));
+    if (b.length === 0)
+        return "";
+    if (b.length === 1)
+        return b[0] ?? "";
+    if (b.length <= 20)
+        return `${b.slice(0, -1).join(", ")}, & ${b.at(-1)}`;
+    return `${b.slice(0, 19).join(", ")}, ... ${b.at(-1)}`;
+}
+const nokta = (s) => (/[.?!]$/u.test(s) ? s : `${s}.`);
+const doiBagi = (d) => (/^https?:\/\//u.test(d) ? d : `https://doi.org/${d.replace(/^doi:\s*/iu, "")}`);
+const editorKisa = (e) => {
+    const b = yazarBicimle(e);
+    const [soyad, bas] = b.split(", ");
+    return bas ? `${bas} ${soyad}` : b;
+};
+/** Tek künye. Eksik zorunlu bilgi [EKSİK: ...] olarak yazılır ve ayrıca listelenir. */
+export function kunyeBicimle(k) {
+    const eksikler = [];
+    const eksik = (ad) => {
+        eksikler.push(ad);
+        return `[EKSİK: ${ad}]`;
+    };
+    const yazar = k.yazarlar.length ? yazarListesi(k.yazarlar, k.kurumYazar) : eksik("yazar");
+    const yil = k.yil === undefined || k.yil === "" ? "t.y." : String(k.yil);
+    if (yil === "t.y.")
+        eksikler.push("yıl (t.y. yazıldı)");
+    const parcalar = [`${nokta(yazar)} (${yil}).`];
+    const baski = k.baski ? ` (${k.baski}. bs.)` : "";
+    switch (k.tur) {
+        case "kitap":
+            parcalar.push(nokta(`${k.baslik}${baski}`), nokta(k.yayinevi || eksik("yayınevi")));
+            break;
+        case "makale": {
+            parcalar.push(nokta(k.baslik));
+            const dergi = k.dergi || eksik("dergi adı");
+            const cilt = k.cilt ? `, ${k.cilt}${k.sayi ? `(${k.sayi})` : ""}` : "";
+            const sayfa = k.sayfalar ? `, ${k.sayfalar}` : "";
+            parcalar.push(nokta(`${dergi}${cilt}${sayfa}`));
+            if (!k.cilt)
+                eksikler.push("cilt");
+            if (!k.sayfalar)
+                eksikler.push("sayfalar");
+            break;
+        }
+        case "kitap_bolumu": {
+            parcalar.push(nokta(k.baslik));
+            const ed = k.editorler?.length
+                ? `${k.editorler.map(editorKisa).join(", ")} (${k.editorler.length > 1 ? "Ed'ler" : "Ed."}), `
+                : "";
+            const kitap = k.kitapBasligi || eksik("kitap adı");
+            const ss = k.sayfalar ? ` (ss. ${k.sayfalar})` : "";
+            parcalar.push(nokta(`İçinde ${ed}${kitap}${baski}${ss}`), nokta(k.yayinevi || eksik("yayınevi")));
+            break;
+        }
+        case "tez": {
+            const tur = k.tezTuru === "doktora"
+                ? "Doktora tezi"
+                : k.tezTuru === "yuksek_lisans"
+                    ? "Yüksek lisans tezi"
+                    : eksik("tez türü");
+            parcalar.push(`${k.baslik} [${tur}, ${k.kurum || eksik("üniversite")}].`);
+            break;
+        }
+        case "web":
+            parcalar.push(nokta(k.baslik));
+            if (k.site)
+                parcalar.push(nokta(k.site));
+            if (!k.url)
+                parcalar.push(eksik("adres"));
+            break;
+    }
+    if (k.doi)
+        parcalar.push(doiBagi(k.doi));
+    else if (k.url)
+        parcalar.push(k.url);
+    return { kunye: parcalar.join(" ").replace(/\s+/gu, " ").trim(), eksikler };
+}
+export const kaynakBicimleAraci = arac({
+    ad: "kaynak_bicimle",
+    baslik: "Kaynak künyesi biçimle",
+    aciklama: "Hocanın verdiği kitap, makale, kitap bölümü, tez ya da web kaynağını APA 7'ye benzer Türkçe künyeye çevirir. Yalnız verilen bilgiyi dizer; eksik bilgi [EKSİK] olarak görünür, uydurulmaz.",
+    sonrakiAdim: "Künyeleri hocaya gösterin. Eserin varlığını kaynak_dogrula ile doğrulayın; doğrulanamayanı yazmayın. EKSİK bilgiyi tahmin etmeyin. Sonra künyeleri kaynaklar alanına koyun.",
+    kunyeAlanlari: ["kaynaklar"],
+    girdi: z.object({
+        kaynaklar: z.array(Kaynak).min(1).max(30),
+    }),
+    calistir: ({ kaynaklar }) => {
+        const sonuclar = kaynaklar.map((k, i) => ({ no: i + 1, ...kunyeBicimle(k) }));
+        return {
+            sonuc: {
+                kunyeler: sonuclar,
+                tamamlanan: sonuclar.filter((s) => !s.eksikler.length).length,
+                not: "Biçim APA 7'ye benzer bir Akredit biçimidir; kurumunuzun yazım kılavuzu farklıysa o önceliklidir. Eser bilgisinin doğruluğunu hoca denetler.",
+                uydurmaYok: "Bu araç yalnız verilen bilgiyi biçimlendirir. Asistan, kaynak_dogrula ile doğrulanmamış bir eseri önermez.",
+            },
+            kaynak: [KOD_KAYNAGI("apps/acik-mcp/src/kaynak.ts", "Akredit künye biçimleyici")],
+        };
+    },
+});

package/dist/apps/acik-mcp/src/kisisel-veri.d.ts

@@ -1,3 +1,15 @@
-/** Girdide kişisel veri olabilecek türlerin adları (değerler değil). Boşsa temiz. */
-export declare function kisiselVeriTurleri(girdi: unknown): string[];
+/**
+ * Girdide kişisel veri olabilecek türlerin adları (değerler değil). Boşsa temiz.
+ * `kunyeAnahtarlari`: altındaki metinler künye kuralıyla (yazar adı serbest) değerlendirilen alan adları.
+ */
+export type KisiselVeriKapsami = "yok" | "ogrenci" | "tam";
+export declare function kisiselVeriTurleri(girdi: unknown, kunyeAnahtarlari?: readonly string[], kapsam?: KisiselVeriKapsami): string[];
 export declare function kisiselVeriIletisi(turler: readonly string[]): string;
+/** Girdide giriş bilgisi var mı? Yalnız evet ya da hayır döner, değer döndürmez. */
+export declare function girisBilgisiVar(girdi: unknown): boolean;
+/** Yapıştırılan sayfadan oturum kimliklerini, parola kutularını ve çerez satırlarını bellekte atar. */
+export declare function girisBilgisiAyikla(metin: string): {
+    metin: string;
+    atildi: boolean;
+};
+export declare const GIRIS_BILGISI_ILETISI = "G\u00F6nderdi\u011Finiz veride parola, do\u011Frulama kodu ya da oturum \u00E7erezi olabilecek bir ifade var. Bu bilgiler yapay zek\u00E2ya ve Akredit'e hi\u00E7 verilmez; yaln\u0131z OBS'nin kendi giri\u015F ekran\u0131na siz yazars\u0131n\u0131z. O k\u0131sm\u0131 silip yeniden g\u00F6nderin. Parolan\u0131z\u0131 bir sohbete yazd\u0131ysan\u0131z OBS'de de\u011Fi\u015Ftirmeniz iyi olur.";

package/dist/apps/acik-mcp/src/kisisel-veri.js

@@ -1,7 +1,18 @@
-// Gelen veride kişisel veri denetimi. Açık sunucu kişisel veri işlemez (CLAUDE.md ilke 7): desen görülürse
-// istek reddedilir, kullanıcıdan maskeleyip yeniden göndermesi istenir. Bulunan değer hiçbir yere yazılmaz,
-// yalnız türü söylenir. Desenler @akredit/yz KVKK maskeleyicisinden gelir (TCKN, telefon, e-posta, IBAN,
-// öğrenci numarası, unvanlı ya da yaygın adla başlayan kişi adı, adres, imza).
+// Gelen veride kişisel veri ve giriş bilgisi denetimi. Bulunan değer hiçbir yere yazılmaz, yalnız türü söylenir.
+// Desenler @akredit/yz KVKK maskeleyicisinden gelir.
+//
+// Kapsam (İP-49): hocanın kendi sayfasında yayımlanmış görev bilgisi (Dersi Verenler, Koordinatör, iletişim)
+// kişisel veri sayılıp atılmaz; olduğu gibi okunur ve korunur. Araçlar kapsamı kendisi seçer:
+// - "yok": yalnız giriş bilgisi denetlenir (Bologna araçları).
+// - "ogrenci" (varsayılan): öğrenci ve kimlik verisi (T.C. kimlik no, öğrenci numarası, IBAN) reddedilir.
+// - "tam": bütün desenler (not tablosu ve ÇK/PÇ: öğrenci adı ve numarası takma adla gelmelidir).
+//
+// Künye kuralı: kaynakçadaki yazar adları yayımlanmış künyedir, kişisel veri sayılmaz. Bu yüzden künye alanlarında
+// (araç bunları adıyla bildirir) kişi adı deseni aranmaz; e-posta, telefon, kimlik numarası gibi öbür desenler
+// yine aranır.
+//
+// Giriş bilgisi (ilke 8): parola, doğrulama kodu ve oturum çerezi sunucuya hiç girmez. Böyle bir desen görülürse
+// çağrı reddedilir; değer yanıtta tekrarlanmaz.
 import { maskele } from "../../../packages/yz/src/index.js";
 const TUR_ADI = {
     KİŞİ: "kişi adı",
@@ -13,28 +24,65 @@ const TUR_ADI = {
     ADRES: "adres",
     İMZA: "imza",
 };
-/** Bir girdideki bütün metinleri (anahtarlar dahil) gezer. */
-function metinler(deger, cikti = []) {
+/** Bir girdideki bütün metinleri (anahtarlar dahil) gezer; künye alanlarındaki metinleri ayrı toplar. */
+function metinler(deger, kunyeAnahtarlari, cikti = { genel: [], kunye: [] }, kunyede = false) {
     if (typeof deger === "string")
-        cikti.push(deger);
+        (kunyede ? cikti.kunye : cikti.genel).push(deger);
     else if (Array.isArray(deger))
         for (const x of deger)
-            metinler(x, cikti);
+            metinler(x, kunyeAnahtarlari, cikti, kunyede);
     else if (deger !== null && typeof deger === "object")
         for (const [k, v] of Object.entries(deger)) {
-            cikti.push(k);
-            metinler(v, cikti);
+            cikti.genel.push(k);
+            metinler(v, kunyeAnahtarlari, cikti, kunyede || kunyeAnahtarlari.has(k));
         }
     return cikti;
 }
-/** Girdide kişisel veri olabilecek türlerin adları (değerler değil). Boşsa temiz. */
-export function kisiselVeriTurleri(girdi) {
+/** "ogrenci" kapsamında aranan türler; öbürleri (ad, e-posta, telefon, adres, imza) kapalıdır. */
+const OGRENCI_TURLERI = ["TCKN", "ÖĞRENCİ-NO", "IBAN"];
+const TUM_TURLER = Object.keys(TUR_ADI);
+export function kisiselVeriTurleri(girdi, kunyeAnahtarlari = [], kapsam = "tam") {
+    if (kapsam === "yok")
+        return [];
+    const kapali = kapsam === "ogrenci" ? TUM_TURLER.filter((t) => !OGRENCI_TURLERI.includes(t)) : [];
     const turler = new Set();
-    for (const m of metinler(girdi))
-        for (const e of maskele(m).eslemeler)
+    const m = metinler(girdi, new Set(kunyeAnahtarlari));
+    for (const x of m.genel)
+        for (const e of maskele(x, { kapali }).eslemeler)
+            turler.add(e.tur);
+    for (const x of m.kunye)
+        for (const e of maskele(x, { kapali: [...new Set([...kapali, "KİŞİ"])] }).eslemeler)
             turler.add(e.tur);
     return [...turler].map((t) => TUR_ADI[t]);
 }
 export function kisiselVeriIletisi(turler) {
-    return `Gönderdiğiniz veride kişisel veri olabilecek ifadeler var (${turler.join(", ")}). Bu sunucu kişisel veri işlemez. Adları, numaraları ve iletişim bilgilerini maskeleyip (ör. "Öğrenci 1", "[KİŞİ-1]") yeniden gönderin.`;
+    return `Gönderdiğiniz veride kişisel veri olabilecek ifadeler var (${turler.join(", ")}). Öğrenci ve kimlik bilgileri bu araca takma adla gelmelidir. Bu kısımları takma adla (ör. "o1", "Öğrenci 1") değiştirip yeniden gönderin.`;
+}
+const OTURUM_KIMLIGI = /\b(jsessionid|phpsessid|asp\.net_sessionid|aspsessionid\w*|sessionid|connect\.sid|laravel_session|\.aspxauth)\s*=\s*[\w%.-]{6,}/iu;
+/** Giriş bilgisi desenleri: etiketli parola ya da doğrulama kodu, çerez başlığı, oturum kimliği, erişim belirteci. */
+const GIRIS_DESENLERI = [
+    /(^|[^\p{L}])(parola|şifre|sifre|password|passwd|pwd)\s*[:=]\s*\S+/iu,
+    /(doğrulama kodu|dogrulama kodu|onay kodu|tek kullanımlık kod|sms kodu|verification code|otp|2fa kodu)\s*[:=]?\s*\d{4,8}(?!\d)/iu,
+    /\b(set-cookie|cookie)\s*:\s*\S+=/iu,
+    OTURUM_KIMLIGI,
+    /\bBearer\s+[\w.~+/-]{16,}=*/u,
+];
+/** Girdide giriş bilgisi var mı? Yalnız evet ya da hayır döner, değer döndürmez. */
+export function girisBilgisiVar(girdi) {
+    const m = metinler(girdi, new Set());
+    return [...m.genel, ...m.kunye].some((x) => GIRIS_DESENLERI.some((d) => d.test(x)));
+}
+/** Yapıştırılan sayfadan oturum kimliklerini, parola kutularını ve çerez satırlarını bellekte atar. */
+export function girisBilgisiAyikla(metin) {
+    let atildi = false;
+    const at = () => {
+        atildi = true;
+        return "";
+    };
+    const yeni = metin
+        .replace(new RegExp(OTURUM_KIMLIGI.source, "giu"), at)
+        .replace(/<input\b[^>]*type\s*=\s*["']?password[^>]*>/giu, at)
+        .replace(/\b(set-cookie|cookie)\s*:[^\n]*/giu, at);
+    return { metin: yeni, atildi };
 }
+export const GIRIS_BILGISI_ILETISI = "Gönderdiğiniz veride parola, doğrulama kodu ya da oturum çerezi olabilecek bir ifade var. Bu bilgiler yapay zekâya ve Akredit'e hiç verilmez; yalnız OBS'nin kendi giriş ekranına siz yazarsınız. O kısmı silip yeniden gönderin. Parolanızı bir sohbete yazdıysanız OBS'de değiştirmeniz iyi olur.";