katman-mcp 0.1.0

package/dist/tools/method/core/plan.js

@@ -0,0 +1,405 @@
+import { logEvent, readText, writeJson, writeText, readJson } from "../../../state.js";
+import { mdTable } from "../../../util.js";
+import { calls } from "../lib/calls.js";
+import { fileHints, isCsr, pageLocation } from "../lib/framework.js";
+import { t } from "../lib/l10n.js";
+import { appPrefixes, findPage, knownPublicPaths, noindexRoutes, pathKnown } from "../lib/routes.js";
+import { loadConfigSafe, loadLatestAudit, loadResearchSafe, loadRuns, loadScan, runDate, staticDirFor } from "../lib/state.js";
+import { isFilled, isoDay, slugify } from "../lib/text.js";
+import { PAGE_TYPES } from "../data/pages.js";
+import { PROMPTS } from "../data/prompts.js";
+import { FIRST_30_DAYS } from "../data/roadmap.js";
+import { MEASURE_FREQUENCY, API_PROXY_NOTE } from "../data/measurement.js";
+import { researchCompleteness } from "./research.js";
+import { keySituationQuestionIds } from "./questions.js";
+import { siteUrlOf, situationUrl, verifyCalls } from "./prompt.js";
+const SEV_RANK = { critical: 0, high: 1, medium: 2, low: 3, info: 4 };
+/** `- [x] … <!-- id:P2 -->` → Map(P2 → true). */
+export function parsePlanChecks(md) {
+    const m = new Map();
+    if (!md)
+        return m;
+    for (const line of md.split(/\r?\n/)) {
+        const r = /^\s*[-*]\s+\[([ xX])\]\s.*<!--\s*id:([^\s>]+)\s*-->/.exec(line);
+        if (r)
+            m.set(r[2], r[1].toLowerCase() === "x");
+    }
+    return m;
+}
+/** Display a call without the machine-specific project_root. */
+export function fmtCallShort(c) {
+    const { project_root: _root, ...rest } = c.args;
+    void _root;
+    return `\`${c.tool}\`${Object.keys(rest).length ? ` \`${JSON.stringify(rest)}\`` : ""}`;
+}
+function weekOf(id) {
+    const p = PROMPTS.find((x) => x.id === id);
+    return (p?.week ?? 2);
+}
+export function buildPlanData(c) {
+    const lang = c.lang;
+    const L = (en, tr) => (lang === "tr" ? tr : en);
+    const r = c.research;
+    const scan = c.scan;
+    const audit = c.audit;
+    const sd = c.staticDir ?? "";
+    const siteUrl = siteUrlOf(r, c.config);
+    const now = c.now ?? new Date();
+    const primary = (r?.site.languages[0] ?? "en").toLowerCase().startsWith("tr") ? "tr" : "en";
+    const known = knownPublicPaths(scan, audit);
+    const langs = r?.site.languages ?? [];
+    const surl = (s) => situationUrl(s, langs);
+    const notes = [];
+    // ------------------------------------------------------------ page plan
+    const pages = [];
+    const noEvidence = !scan && !audit;
+    const statusOf = (src) => (src === "live" ? "live" : src === "scan" ? "in code" : noEvidence ? "unknown" : "missing");
+    const typeDef = (k) => PAGE_TYPES.find((p) => p.key === k);
+    const add = (key, matchKey, fallbackUrl, note) => {
+        const def = typeDef(key);
+        const found = matchKey ? findPage(known, matchKey) : undefined;
+        const url = found?.path ?? fallbackUrl;
+        const status = statusOf(found?.source);
+        pages.push({ key, name: t(def.name, lang), url, status, schema: def.schema, note, ...(status === "missing" && scan ? { file: pageLocation(scan, url, sd).files[0] } : {}) });
+    };
+    add("home", "home", "/", L("States who you are in one sentence (the category in the title); links to every important page.", "Kim olduğunuzu tek cümleyle söyler (title’da kategori); bütün önemli sayfalara link verir."));
+    for (const s of r?.situations ?? []) {
+        const url = surl(s);
+        const src = s.status === "live" ? "live" : pathKnown(known, url);
+        pages.push({
+            key: "situation",
+            name: t(typeDef("situation").name, lang),
+            url,
+            status: statusOf(src),
+            schema: typeDef("situation").schema,
+            note: `“${s.sentence}”`,
+            situationId: s.id,
+            ...(src || noEvidence ? {} : { file: pageLocation(scan, url, sd).files[0] }),
+        });
+    }
+    if (!r?.situations.length) {
+        pages.push({ key: "situation", name: t(typeDef("situation").name, lang), url: L("(one per situation)", "(her durum için bir tane)"), status: "unknown", schema: typeDef("situation").schema, note: L("Add 10–12 customer situations to research first.", "Önce araştırmaya 10–12 müşteri durumu ekleyin.") });
+    }
+    add("pricing", "pricing", primary === "tr" ? "/fiyatlandirma" : "/pricing", L("Prices in plain text; the same figures as llms.txt and schema.", "Fiyat düz metinde; llms.txt ve schema ile aynı rakam."));
+    const catSlug = isFilled(r?.brand.category) ? slugify(r.brand.category, 4) : "";
+    add("comparison", "comparison", catSlug ? (primary === "tr" ? `/rehber/${catSlug}-araclari` : `/guides/${catSlug}-tools`) : t(typeDef("comparison").url, lang), L("Neutral: competitors with source + date, us not first (P7).", "Tarafsız: rakipler kaynak + tarihle, biz ilk sırada değiliz (P7)."));
+    add("faq", "faq", primary === "tr" ? "/sss" : "/faq", L("Real customer questions; the first sentence of each answer is the answer.", "Müşterinin gerçek soruları; her cevabın ilk cümlesi cevaptır."));
+    add("about", "about", primary === "tr" ? "/hakkimizda" : "/about", L("Who builds it, the company, the not-X note, social accounts.", "Kim yapıyor, şirket, “X değildir” notu, sosyal hesaplar."));
+    add("guide", "guide", primary === "tr" ? "/rehber/..." : "/guides/...", L("Something others want to link to (backlinks come from here).", "Başkasının link vermek isteyeceği şey (backlink buradan gelir)."));
+    add("contact", "contact", primary === "tr" ? "/iletisim" : "/contact", L("E-mail as plain text; privacy and terms pages too.", "E-posta düz metin; gizlilik ve şartlar sayfaları da."));
+    const llmsExists = !!(scan?.files.llms.exists || audit?.site.llmsTxt.exists);
+    pages.push({ key: "llms", name: "llms.txt", url: "/llms.txt", status: audit?.site.llmsTxt.exists ? "live" : llmsExists ? "in code" : noEvidence ? "unknown" : "missing", schema: [], note: L("The one sentence, pricing, not-X, the important pages (P8).", "Tek cümle, fiyat, “X değildir”, önemli sayfalar (P8).") });
+    const scanSoft404 = !!scan && (/catch-all|fallback/i.test(scan.files.notFound.path ?? "") || scan.findings.some((f) => /soft-?404/i.test(f.id)));
+    const nfStatus = audit?.site.soft404 === true ? "soft 404" : audit?.site.soft404 === false ? "live" : scanSoft404 ? "soft 404" : scan?.files.notFound.exists ? "in code" : noEvidence ? "unknown" : "missing";
+    pages.push({ key: "notfound", name: t(typeDef("notfound").name, lang), url: t(typeDef("notfound").url, lang), status: nfStatus, schema: [], note: L("A real 404 status, with links to the important pages (P11).", "Gerçek 404 durum kodu, önemli sayfalara linkle (P11).") });
+    // ------------------------------------------------------------ keep out of the index
+    const ap = appPrefixes(scan);
+    const disallow = ap.prefixes.map((p) => `${p}/`);
+    const noindex = noindexRoutes(scan, ap.prefixes);
+    if (noEvidence)
+        notes.push(L("No scan or audit yet, so which pages exist is unknown: run katman_scan_code and katman_audit_site, then katman_plan again.", "Henüz tarama ya da denetim yok, hangi sayfaların var olduğu bilinmiyor: katman_scan_code ve katman_audit_site çalıştırıp katman_plan’ı yeniden çağırın."));
+    if (ap.defaulted)
+        notes.push(L("No scan yet: the Disallow list uses the book's defaults (/app/, /admin/, /api/, /dashboard/). Run katman_scan_code for the real app routes.", "Henüz tarama yok: Disallow listesi kitabın varsayılanlarını kullanıyor (/app/, /admin/, /api/, /dashboard/). Gerçek uygulama yolları için katman_scan_code çalıştırın."));
+    if (ap.conflicts.length)
+        notes.push(L(`App routes share a prefix with public pages under ${ap.conflicts.join(", ")}: Disallow the specific app paths by hand, never the whole prefix.`, `${ap.conflicts.join(", ")} altında uygulama yolları herkese açık sayfalarla aynı öneki paylaşıyor: tüm öneki değil, belirli uygulama yollarını elle kapatın.`));
+    // ------------------------------------------------------------ tasks
+    const tasks = [];
+    const shortVerify = (id, situation) => {
+        const vc = verifyCalls(id, c.root, siteUrl, situation, sd, langs).map(fmtCallShort);
+        if (vc.length)
+            return vc.join(" · ");
+        return PROMPTS.find((p) => p.id === id).verifiedBy.map((v) => (v.tool === "manual" ? t(v.check, lang) : v.tool)).join(" + ");
+    };
+    const promptTask = (id, extra = {}) => {
+        const def = PROMPTS.find((p) => p.id === id);
+        return {
+            id,
+            week: def.week,
+            prompt: id,
+            title: `${id} · ${t(def.title, lang)}`,
+            files: fileHints(id, scan, sd),
+            accept: t(def.accept, lang),
+            verifiedBy: id === "P14" ? `${shortVerify(id)} · ${L("release script / CI", "yayın betiği / CI")}: \`npx -y katman-mcp audit ${siteUrl ?? "<site URL>"} --strict\`` : shortVerify(id),
+            done: false,
+            source: "roadmap",
+            ...extra,
+        };
+    };
+    const toolTask = (id, week, tool, title, accept, verifiedBy, files = []) => ({
+        id, week, ...(tool ? { tool } : {}), title, files, accept, verifiedBy, done: false, source: "roadmap",
+    });
+    const completeness = researchCompleteness(r);
+    // Week 1
+    tasks.push(toolTask("research", 1, "katman_research", L("Fill research: one sentence, not-X, 10–12 situations, competitors, proof (ch. 7)", "Araştırmayı doldur: tek cümle, “X değildir”, 10–12 durum, rakipler, kanıt (07)"), L("katman_research shows 100%: name, category, the 4-part sentence, not-X, ≥10 unbranded situations, ≥3 competitors with url + date, the question set.", "katman_research %100 gösteriyor: ad, kategori, 4 parçalı cümle, “X değildir”, ≥10 markasız durum, url + tarihli ≥3 rakip, soru seti."), fmtCallShort(calls.researchShow(c.root))));
+    tasks.push(toolTask("measure-1", 1, "katman_visibility_run", L("First measurement with the question set (ch. 15)", "Soru setiyle ilk ölçüm (15)"), L("A run is saved in .katman/runs with today's date; from now on the 12 + 2 questions stay fixed.", "Bugünün tarihiyle .katman/runs’a bir ölçüm kaydedildi; bundan sonra 12 + 2 soru sabit."), `${fmtCallShort(calls.visibilityDryRun(c.root))} ${L("or", "ya da")} ${fmtCallShort(calls.manualCheck(c.root))}`));
+    tasks.push(toolTask("traps", 1, "katman_audit_site", L("Test the 6 traps (ch. 5): text in JavaScript, bots at the door, soft 404s, open preview copy, links that aren't links, missing from Bing/Brave", "6 tuzağı test et (05): JavaScript’te metin, kapıdaki botlar, sahte 404, açık önizleme kopyası, link olmayan linkler, Bing/Brave’de yokluk"), L("Text visible with JavaScript off; AI bots get 200; an unknown URL returns 404; the preview copy redirects or is noindex; menu links are <a href>; site: searches in Bing and Brave show pages.", "JavaScript kapalıyken metin görünüyor; yapay zekâ botları 200 alıyor; olmayan adres 404; önizleme kopyası yönleniyor ya da noindex; menü linkleri <a href>; Bing ve Brave’de site: aramasında sayfalar çıkıyor."), `${fmtCallShort(calls.scan(c.root))} · ${fmtCallShort(calls.audit(c.root, siteUrl ?? "[FILL: site URL]"))} · ${L("site: searches by hand", "site: aramaları elle")}`));
+    tasks.push(promptTask("P0"));
+    tasks.push(promptTask("P1"));
+    // Week 2
+    const p2Findings = [...(scan?.findings ?? []), ...(audit?.findings ?? [])].some((f) => f.prompt === "P2");
+    // lead-approved CSR thresholds: critical only on strong evidence (< 50 JS-off words); 50–99 is a thin page
+    const lowWords = (audit?.pages ?? []).filter((p) => p.status === 200 && p.wordsJsOff < 50).length;
+    const needP2 = !scan || isCsr(scan) || p2Findings || lowWords > 0;
+    if (needP2)
+        tasks.push(promptTask("P2", isCsr(scan) || lowWords > 0 ? { week: 1 } : {}));
+    else
+        notes.push(L(`P2 isn't needed: the scan says the public pages are rendered as ${scan.rendering.verdict} HTML. Re-check with the JS-off word count after big changes.`, `P2 gerekmiyor: taramaya göre herkese açık sayfalar ${scan.rendering.verdict} HTML olarak üretiliyor. Büyük değişikliklerden sonra JavaScript kapalı kelime sayısıyla tekrar kontrol edin.`));
+    for (const id of ["P3", "P4", "P5", "P9", "P10", "P11", "P12"])
+        tasks.push(promptTask(id));
+    tasks.push(toolTask("cdn", 2, undefined, L("CDN / firewall bot settings (ch. 6): legacy AI-bot block off, Search + Agent allowed, managed robots.txt / AI Labyrinth / Bot Fight Mode / e-mail obfuscation off", "CDN / güvenlik duvarı bot ayarları (06): eski AI bot engeli kapalı, Arama + Ajan izinli, yönetilen robots.txt / AI Labyrinth / Bot Fight Mode / e-posta gizleme kapalı"), L("Every AI bot gets 200 through the CDN (command 5); robots.txt and the CDN say the same thing.", "Her yapay zekâ botu CDN’den 200 alıyor (komut 5); robots.txt ile CDN aynı şeyi söylüyor."), fmtCallShort(calls.audit(c.root, siteUrl ?? "[FILL: site URL]"))));
+    tasks.push(toolTask("notify", 2, "katman_indexnow", L("Tell the search engines (ch. 13): Search Console (DNS), Bing Webmaster Tools, IndexNow key, Brave submit-url; open the Search Console Gen-AI and Bing AI Performance reports", "Arama motorlarına bildir (13): Search Console (DNS), Bing Webmaster Tools, IndexNow anahtarı, Brave submit-url; Search Console Gen-AI ve Bing AI Performance raporlarını aç"), L("Sitemap submitted to Google and Bing; the IndexNow key file is live; Brave submission done.", "Sitemap Google ve Bing’e gönderildi; IndexNow anahtar dosyası yayında; Brave gönderimi yapıldı."), `${fmtCallShort(calls.generate(c.root, "indexnow-key"))} · ${fmtCallShort(calls.indexnow(c.root))}`));
+    // Week 3
+    const sitsMissing = (r?.situations ?? []).filter((s) => s.status !== "live" && pathKnown(known, surl(s)) !== "live");
+    for (const s of sitsMissing.slice(0, 5)) {
+        const def = PROMPTS.find((p) => p.id === "P6");
+        tasks.push({
+            id: `P6-${s.id}`,
+            week: 3,
+            prompt: "P6",
+            title: `P6 · ${t(def.title, lang)}: “${s.sentence}” → ${surl(s)}`,
+            files: pageLocation(scan, surl(s), sd).files,
+            accept: t(def.accept, lang),
+            verifiedBy: shortVerify("P6", s),
+            done: false,
+            situationId: s.id,
+            source: "situation",
+        });
+    }
+    if (sitsMissing.length > 5)
+        notes.push(L(`${sitsMissing.length - 5} more situation page(s) after these 5: keep to 5–10 new pages a week.`, `Bu 5’ten sonra ${sitsMissing.length - 5} durum sayfası daha: haftada 5–10 yeni sayfayı geçmeyin.`));
+    if (!r?.situations.length)
+        tasks.push(promptTask("P6", { id: "P6", title: L("P6 · Write situation pages (add situations to research first)", "P6 · Durum sayfaları yaz (önce araştırmaya durum ekleyin)"), source: "situation" }));
+    tasks.push(promptTask("P7"));
+    tasks.push(promptTask("P8"));
+    tasks.push(toolTask("landing", 3, undefined, L("Welcome the visitor (ch. 10): on the pages assistants send people to, one immediate action usable within 60 s on a phone; don't re-ask what they told ChatGPT", "Ziyaretçiyi karşıla (10): asistanların insan gönderdiği sayfalarda telefonda 60 saniyede kullanılabilen tek bir eylem; ChatGPT’ye anlattığını tekrar sorma"), L("On a phone, without signing up, a visitor sees within 60 seconds that the product works for their situation.", "Telefonda, kayıt olmadan, ziyaretçi 60 saniye içinde ürünün kendi durumunda işe yaradığını görüyor."), L("by hand on a phone", "telefonda elle")));
+    tasks.push(toolTask("notify-new", 3, "katman_indexnow", L("Announce every new page (ch. 13): in the sitemap, ≥1 internal link, P14 passed; IndexNow for that URL only; Search Console request indexing; Bing URL Submission; Brave submit-url", "Her yeni sayfayı bildir (13): sitemap’te, ≥1 iç link, P14 geçti; IndexNow’a yalnızca o adres; Search Console dizine ekleme isteği; Bing URL Submission; Brave submit-url"), L("Every new page is in the sitemap, linked, verified and submitted once.", "Her yeni sayfa sitemap’te, linkli, doğrulanmış ve bir kez gönderilmiş."), fmtCallShort(calls.indexnow(c.root))));
+    // Week 4
+    tasks.push(promptTask("P13"));
+    tasks.push(toolTask("offsite", 4, "katman_report", L("Traces outside the site (ch. 14): one YouTube video for a top situation, directory texts (name, category, 60-char tagline, 250/600-char descriptions), an outreach list from the domains assistants cite", "Site dışı izler (14): önde gelen bir durum için bir YouTube videosu, dizin metinleri (ad, kategori, 60 karakterlik slogan, 250/600 karakterlik açıklamalar), asistanların alıntıladığı alan adlarından bir ulaşma listesi"), L("One video live and embedded on its page; directory text ready (the one sentence word for word); outreach list written down. No bought links, fake reviews or self-ranked lists.", "Bir video yayında ve sayfasına gömülü; dizin metni hazır (tek cümle aynen); ulaşma listesi yazılı. Satın alınmış link, sahte yorum ya da kendini birinci yazan liste yok."), `${fmtCallShort(calls.report(c.root))} (${L("top cited domains", "en çok alıntılanan alan adları")})`));
+    tasks.push(toolTask("remeasure", 4, "katman_visibility_run", L("Day 14: ask the question set again — same questions, models and temperature; 3 samples for the 3 most important situation questions; confirm them in the real apps", "14. gün: soru setini tekrar sor — aynı sorular, modeller ve sıcaklık; en önemli 3 durum sorusu için 3 örnek; gerçek uygulamalarda doğrula"), L("A second run is saved next to the first; you read frequency (how often named / recommended / cited), not rank.", "İkinci ölçüm birincinin yanında kayıtlı; sırayı değil sıklığı okuyorsunuz (ne sıklıkla anıldı / önerildi / kaynak gösterildi)."), `${fmtCallShort(calls.visibilityDryRun(c.root))} (${L("full set", "tüm set")}) · ${fmtCallShort(calls.visibilityDryRun(c.root, { question_ids: keySituationQuestionIds(r).length ? keySituationQuestionIds(r) : ["q1", "q2", "q3"], samples: 3 }))} · ${fmtCallShort(calls.manualCheck(c.root))}`));
+    tasks.push(toolTask("gsc", 4, undefined, L("Search Console: why aren't pages indexed? “Discovered – not indexed” → internal links; “Crawled – not indexed” → stop that template (30% rule)", "Search Console: sayfalar neden dizinde değil? “Keşfedildi, dizine eklenmedi” → iç link; “Tarandı, dizine eklenmedi” → o şablonu durdur (%30 kuralı)"), L("Every non-indexed page has a known reason and an action.", "Dizinde olmayan her sayfanın bilinen bir sebebi ve bir aksiyonu var."), L("Search Console → Pages, by hand", "Search Console → Sayfalar, elle")));
+    tasks.push(promptTask("P14"));
+    // ------------------------------------------------------------ findings
+    const findings = new Map();
+    for (const f of scan?.findings ?? [])
+        findings.set(f.id, { ...f, from: "scan" });
+    for (const f of audit?.findings ?? [])
+        findings.set(f.id, { ...f, from: "audit" });
+    const otherFindings = [];
+    const byPrompt = (p) => tasks.find((x) => x.prompt === p);
+    for (const f of [...findings.values()].sort((a, b) => SEV_RANK[a.severity] - SEV_RANK[b.severity])) {
+        const important = f.severity === "critical" || f.severity === "high";
+        let task = f.prompt ? byPrompt(f.prompt) : undefined;
+        if (!task && f.prompt === "P2" && important) {
+            task = promptTask("P2", { week: 1 });
+            tasks.push(task);
+        }
+        if (task) {
+            (task.findings ??= []).push({ id: f.id, title: f.title, severity: f.severity });
+            if (!task.severity || SEV_RANK[f.severity] < SEV_RANK[task.severity])
+                task.severity = f.severity;
+            if (f.severity === "critical")
+                task.week = 1;
+            for (const file of f.files ?? [])
+                if (!task.files.includes(file))
+                    task.files.push(file);
+            continue;
+        }
+        if (important) {
+            tasks.push({
+                id: `F-${f.id}`,
+                week: f.severity === "critical" ? 1 : f.prompt ? weekOf(f.prompt) : 2,
+                ...(f.prompt ? { prompt: f.prompt } : {}),
+                tool: f.from === "scan" ? "katman_scan_code" : "katman_audit_site",
+                title: `[${f.severity.toUpperCase()}] ${f.title}`,
+                files: f.files ?? [],
+                accept: f.accept ?? L("The finding no longer appears in the next scan/audit.", "Bulgu bir sonraki tarama/denetimde çıkmıyor."),
+                verifiedBy: f.from === "scan" ? fmtCallShort(calls.scan(c.root)) : fmtCallShort(calls.audit(c.root, siteUrl ?? "[FILL: site URL]")),
+                done: false,
+                severity: f.severity,
+                findings: [{ id: f.id, title: f.title, severity: f.severity }],
+                source: "finding",
+            });
+        }
+        else {
+            otherFindings.push({ id: f.id, title: f.title, severity: f.severity, gate: f.gate, ...(f.prompt ? { prompt: f.prompt } : {}) });
+        }
+    }
+    // ------------------------------------------------------------ done state
+    const prev = c.previousChecks ?? new Map();
+    const prevTasks = new Map((c.previousTasks ?? []).map((x) => [x.id, x]));
+    const runsSorted = [...c.runs];
+    const firstRun = runsSorted[0] ? runDate(runsSorted[0]) : undefined;
+    const lastRun = runsSorted.length ? runDate(runsSorted[runsSorted.length - 1]) : undefined;
+    const auto = {
+        research: completeness.percent >= 100 ? L("research is 100% complete", "araştırma %100 dolu") : undefined,
+        "measure-1": c.runs.length ? L(`${c.runs.length} run(s) recorded`, `${c.runs.length} ölçüm kaydedildi`) : undefined,
+        P1: scan && audit ? L("scan + audit exist", "tarama + denetim var") : undefined,
+        cdn: audit && audit.site.bots.length && !audit.site.bots.some((b) => b.blocked) ? L("every tested AI bot got 200", "test edilen her yapay zekâ botu 200 aldı") : undefined,
+        remeasure: firstRun && lastRun && c.runs.length >= 2 && lastRun.getTime() - firstRun.getTime() >= 13 * 86_400_000 ? L("a second run ≥13 days after the first", "ilkinden ≥13 gün sonra ikinci ölçüm") : undefined,
+    };
+    for (const task of tasks) {
+        const was = prev.has(task.id) ? prev.get(task.id) : prevTasks.get(task.id)?.done ?? false;
+        task.done = was;
+        const a = auto[task.id];
+        if (a) {
+            task.done = true;
+            task.auto = a;
+        }
+    }
+    // carry over tasks that were done before but are no longer generated (e.g. fixed findings)
+    for (const [id, old] of prevTasks) {
+        const done = prev.has(id) ? prev.get(id) : old.done;
+        if (done && !tasks.some((x) => x.id === id))
+            tasks.push({ ...old, done: true, source: "carried" });
+    }
+    // order: by week, then severity, then original order
+    const order = new Map(tasks.map((x, i) => [x, i]));
+    tasks.sort((a, b) => a.week - b.week || (SEV_RANK[a.severity ?? "info"] - SEV_RANK[b.severity ?? "info"]) || order.get(a) - order.get(b));
+    return {
+        version: 1,
+        generatedAt: now.toISOString(),
+        lang,
+        ...(siteUrl ? { siteUrl } : {}),
+        ...(isFilled(r?.brand.name) ? { brand: r.brand.name } : {}),
+        sources: { researchPct: completeness.percent, ...(scan?.ts ? { scanTs: scan.ts } : {}), ...(audit?.ts ? { auditTs: audit.ts } : {}), runs: c.runs.length },
+        pages,
+        noindex,
+        disallow,
+        conflicts: ap.conflicts,
+        notes,
+        tasks,
+        otherFindings,
+    };
+}
+export function renderPlanMd(plan) {
+    const lang = plan.lang;
+    const L = (en, tr) => (lang === "tr" ? tr : en);
+    const out = [];
+    out.push(`# ${L("Katman plan", "Katman planı")}${plan.brand ? ` — ${plan.brand}` : ""}`);
+    out.push(L(`Generated ${isoDay(plan.generatedAt)} from research (${plan.sources.researchPct}%), scan (${plan.sources.scanTs ? isoDay(plan.sources.scanTs) : "none"}), audit (${plan.sources.auditTs ? isoDay(plan.sources.auditTs) : "none"}) and ${plan.sources.runs} visibility run(s).\nTick a task (\`- [x]\`) only when its acceptance check passes. \`katman_plan\` keeps your ticks when it regenerates this file; tasks marked _auto_ were verified by Katman.`, `${isoDay(plan.generatedAt)} tarihinde araştırma (%${plan.sources.researchPct}), tarama (${plan.sources.scanTs ? isoDay(plan.sources.scanTs) : "yok"}), denetim (${plan.sources.auditTs ? isoDay(plan.sources.auditTs) : "yok"}) ve ${plan.sources.runs} görünürlük ölçümünden üretildi.\nBir görevi (\`- [x]\`) yalnızca kabul kontrolü geçince işaretleyin. \`katman_plan\` dosyayı yeniden üretirken işaretlerinizi korur; _auto_ işaretliler Katman tarafından doğrulandı.`));
+    out.push(`## ${L("Page plan", "Sayfa planı")}`);
+    out.push(mdTable([L("Page", "Sayfa"), "URL", L("Status", "Durum"), "Schema", L("Notes", "Notlar")], plan.pages.map((p) => [p.name, p.url, p.status, p.schema.join(", ") || "–", p.note + (p.file ? ` · ${L("file", "dosya")}: ${p.file}` : "")])));
+    out.push(`## ${L("Keep out of the index", "Dizine girmemesi gerekenler")}`);
+    out.push([
+        `- ${L("`noindex,follow` and not in the sitemap", "`noindex,follow` ve sitemap’te yok")}: ${plan.noindex.length ? plan.noindex.join(", ") : L("login, sign-up, password reset, checkout, thank-you and site-search pages (none found by the scan)", "giriş, kayıt, şifre sıfırlama, ödeme, teşekkür ve site içi arama sayfaları (tarama bulmadı)")}`,
+        `- ${L("`Disallow` in robots.txt (app paths, trailing slash)", "robots.txt’de `Disallow` (uygulama yolları, sonda /)")}: ${plan.disallow.length ? plan.disallow.join(", ") : L("none", "yok")}`,
+        `- ${L("Never Disallow a page that carries noindex: Google then can't see the noindex.", "noindex taşıyan bir sayfayı asla Disallow etmeyin: Google o zaman noindex’i göremez.")}`,
+    ].join("\n"));
+    if (plan.notes.length)
+        out.push(plan.notes.map((n) => `> ${n}`).join("\n"));
+    const done = plan.tasks.filter((x) => x.done).length;
+    out.push(`## ${L("Tasks — first 30 days", "Görevler — ilk 30 gün")} (${done}/${plan.tasks.length} ${L("done", "tamam")})`);
+    for (const w of [1, 2, 3, 4]) {
+        const wt = plan.tasks.filter((x) => x.week === w);
+        if (!wt.length)
+            continue;
+        const wp = FIRST_30_DAYS.find((x) => x.week === w);
+        out.push(`### ${L("Week", "Hafta")} ${w} — ${t(wp.title, lang)}`);
+        out.push(wt
+            .map((x) => {
+            const lines = [`- [${x.done ? "x" : " "}] **${x.title}**${x.severity && (x.severity === "critical" || x.severity === "high") ? ` · ${x.severity.toUpperCase()}` : ""}${x.auto ? ` _(auto: ${x.auto})_` : ""} <!-- id:${x.id} -->`];
+            lines.push(`  - ${L("Accept", "Kabul")}: ${x.accept}`);
+            lines.push(`  - ${L("Verify", "Doğrula")}: ${x.verifiedBy}`);
+            if (x.prompt)
+                lines.push(`  - ${L("Prompt", "Prompt")}: \`katman_prompt {"id":"${x.prompt}"${x.situationId ? `,"situation_id":"${x.situationId}"` : ""}}\``);
+            if (x.files.length)
+                lines.push(`  - ${L("Files", "Dosyalar")}: ${x.files.join(", ")}`);
+            for (const f of x.findings ?? [])
+                lines.push(`  - ${L("Finding", "Bulgu")} [${f.severity.toUpperCase()}]: ${f.title}`);
+            return lines.join("\n");
+        })
+            .join("\n"));
+    }
+    if (plan.otherFindings.length) {
+        out.push(`## ${L("Other findings (medium / low)", "Diğer bulgular (orta / düşük)")}`);
+        out.push(plan.otherFindings.map((f) => `- [${f.severity.toUpperCase()}] ${f.title} (${f.gate}${f.prompt ? `, ${f.prompt}` : ""})`).join("\n"));
+    }
+    out.push(`## ${L("Measuring", "Ölçüm")}\n- ${t(MEASURE_FREQUENCY, lang)}\n- ${t(API_PROXY_NOTE, lang)}`);
+    out.push(`---\nGenerated with Katman — katman.pro`);
+    return out.join("\n\n") + "\n";
+}
+export function openTasks(plan) {
+    return plan.tasks.filter((x) => !x.done);
+}
+/** Task → the tool call that starts it. */
+export function taskCall(root, task, siteUrl) {
+    if (task.prompt)
+        return calls.prompt(root, task.prompt, task.situationId);
+    switch (task.tool) {
+        case "katman_research": return calls.researchShow(root);
+        case "katman_visibility_run": return calls.visibilityDryRun(root);
+        case "katman_audit_site": return siteUrl ? calls.audit(root, siteUrl) : calls.scan(root);
+        case "katman_indexnow": return calls.indexnow(root);
+        case "katman_report": return calls.report(root);
+        case "katman_scan_code": return calls.scan(root);
+        default: return undefined;
+    }
+}
+export async function loadPlanState(root) {
+    const md = await readText(root, "plan.md");
+    const plan = await readJson(root, "plan.json");
+    const checks = parsePlanChecks(md);
+    if (plan && Array.isArray(plan.tasks)) {
+        for (const task of plan.tasks)
+            if (checks.has(task.id))
+                task.done = checks.get(task.id);
+        return { plan, checks, md };
+    }
+    return { checks, md };
+}
+export async function runPlan(root, args = {}) {
+    const [research, config, scan, loaded, runs, prevState] = await Promise.all([
+        loadResearchSafe(root), loadConfigSafe(root), loadScan(root), loadLatestAudit(root), loadRuns(root), loadPlanState(root),
+    ]);
+    const lang = args.lang ?? config.lang ?? "en";
+    const staticDir = staticDirFor(root, scan).dir;
+    const plan = buildPlanData({
+        root, lang, research, config, scan, audit: loaded?.audit, runs,
+        previousChecks: prevState.checks,
+        previousTasks: prevState.plan?.tasks,
+        staticDir,
+    });
+    await writeJson(root, "plan.json", plan);
+    await writeText(root, "plan.md", renderPlanMd(plan));
+    const open = openTasks(plan);
+    const done = plan.tasks.length - open.length;
+    await logEvent(root, `katman_plan: ${plan.tasks.length} tasks (${done} done), ${plan.pages.filter((p) => p.status === "missing").length} pages missing`);
+    const L = (en, tr) => (lang === "tr" ? tr : en);
+    const missingPages = plan.pages.filter((p) => p.status === "missing" || p.status === "soft 404");
+    const warn = [];
+    if (!research)
+        warn.push(L(`No research yet: the plan is generic. Start with ${fmtCallShort(calls.researchTemplate(root))}.`, `Henüz araştırma yok: plan genel. ${fmtCallShort(calls.researchTemplate(root))} ile başlayın.`));
+    if (!scan)
+        warn.push(L("No scan yet: file hints are generic (katman_scan_code).", "Henüz tarama yok: dosya ipuçları genel (katman_scan_code)."));
+    if (!loaded)
+        warn.push(L("No audit yet: live status of pages is unknown (katman_audit_site).", "Henüz denetim yok: sayfaların canlı durumu bilinmiyor (katman_audit_site)."));
+    const siteUrl = siteUrlOf(research, config);
+    const firstOpen = open.slice(0, 5).map((x, i) => {
+        const call = taskCall(root, x, siteUrl);
+        return `${i + 1}. **${x.title}** (${L("week", "hafta")} ${x.week}${x.severity ? `, ${x.severity}` : ""})\n   ${L("Accept", "Kabul")}: ${x.accept}\n   ${call ? `${L("Start", "Başla")}: ${fmtCallShort(call)}` : L("Manual task — tick it in plan.md when done.", "Elle yapılan görev — bitince plan.md’de işaretleyin.")}`;
+    });
+    const text = [
+        `${L("Wrote", "Yazıldı")} \`.katman/plan.md\` + \`.katman/plan.json\`: ${plan.tasks.length} ${L("tasks", "görev")} (${done} ${L("done", "tamam")}), ${plan.pages.length} ${L("pages in the page plan", "sayfa planında")} (${missingPages.length} ${L("missing", "eksik")}).`,
+        warn.join("\n"),
+        missingPages.length ? `**${L("Missing pages", "Eksik sayfalar")}:** ${missingPages.map((p) => `${p.name} ${p.url}`).join(" · ")}` : "",
+        `**${L("Keep out of the index", "Dizin dışı")}:** noindex → ${plan.noindex.join(", ") || L("(none found)", "(bulunamadı)")}; Disallow → ${plan.disallow.join(", ") || L("none", "yok")}`,
+        plan.notes.map((n) => `> ${n}`).join("\n"),
+        `**${L("First open tasks", "İlk açık görevler")}:**\n${firstOpen.join("\n") || L("All tasks are done: verify, notify and re-measure.", "Bütün görevler tamam: doğrula, bildir, yeniden ölç.")}`,
+        L("Show the plan to the user and get approval before changing code (P0).", "Kod değiştirmeden önce planı kullanıcıya gösterin ve onay alın (P0)."),
+    ]
+        .filter(Boolean)
+        .join("\n\n");
+    return {
+        text,
+        plan,
+        structured: {
+            tasks: plan.tasks.length,
+            done,
+            open: open.slice(0, 5).map((x) => ({ id: x.id, week: x.week, title: x.title, prompt: x.prompt, accept: x.accept })),
+            missingPages: missingPages.map((p) => ({ name: p.name, url: p.url })),
+            noindex: plan.noindex,
+            disallow: plan.disallow,
+        },
+    };
+}

package/dist/tools/method/core/prompt.js

@@ -0,0 +1,150 @@
+import { domainOf } from "../../../util.js";
+import { calls, fmtCall } from "../lib/calls.js";
+import { frameworkNotes, fwLabel } from "../lib/framework.js";
+import { t } from "../lib/l10n.js";
+import { appPathsText, knownPublicPaths, pathKnown } from "../lib/routes.js";
+import { loadConfigSafe, loadLatestAudit, loadResearchSafe, loadScan, staticDirFor } from "../lib/state.js";
+import { brandSentence, codeBlock, fillTemplate, hasNotX, isFilled, slugify } from "../lib/text.js";
+import { PLACEHOLDERS, PROMPTS, getPrompt, promptPlaceholders } from "../data/prompts.js";
+import { detectLang } from "./questions.js";
+export function siteUrlOf(r, cfg) {
+    if (r && isFilled(r.site.url) && /^https?:\/\//i.test(r.site.url))
+        return r.site.url.replace(/\/+$/, "");
+    if (cfg?.siteUrl)
+        return cfg.siteUrl.replace(/\/+$/, "");
+    return undefined;
+}
+/** Planned or live URL of a situation page; a sentence in a secondary site language gets its /<lang>/ prefix. */
+export function situationUrl(s, languages = []) {
+    if (s.url && s.url.startsWith("/"))
+        return s.url;
+    const slug = slugify(s.sentence);
+    if (languages.length > 1) {
+        const l = detectLang(s.sentence, languages);
+        if (l !== languages[0])
+            return `/${l.split("-")[0]}/${slug}`;
+    }
+    return `/${slug}`;
+}
+/** The situation to use: by id, else the first one without a live page, else the first one. */
+export function pickSituation(r, id, scan, audit) {
+    if (!r || !r.situations.length)
+        return undefined;
+    if (id)
+        return r.situations.find((s) => s.id === id || s.sentence.toLowerCase() === id.toLowerCase());
+    const known = knownPublicPaths(scan, audit);
+    return r.situations.find((s) => s.status !== "live" && pathKnown(known, situationUrl(s, r.site.languages)) !== "live") ?? r.situations[0];
+}
+export function fillValues(r, cfg, scan, situation) {
+    const siteUrl = siteUrlOf(r, cfg);
+    const langs = r?.site.languages.length ? r.site.languages : scan?.i18n.locales.length ? scan.i18n.locales : scan?.i18n.htmlLang ? [scan.i18n.htmlLang] : [];
+    const competitors = (r?.competitors ?? [])
+        .slice(0, 8)
+        .map((c) => {
+        const bits = [isFilled(c.url) ? c.url : "", isFilled(c.checkedAt) ? `checked ${c.checkedAt}` : ""].filter(Boolean);
+        return bits.length ? `${c.name} (${bits.join(", ")})` : c.name;
+    })
+        .join("; ");
+    return {
+        brand: r?.brand.name,
+        domain: r && isFilled(r.site.domain) ? r.site.domain : siteUrl ? domainOf(siteUrl) : undefined,
+        site_url: siteUrl,
+        category: r?.brand.category,
+        sentence: brandSentence(r),
+        not_x: hasNotX(r?.brand.notX) ? r.brand.notX : undefined,
+        situation: situation?.sentence,
+        situation_url: situation ? situationUrl(situation, r?.site.languages) : undefined,
+        competitors: competitors || undefined,
+        languages: langs.length ? langs.join(", ") : undefined,
+        app_paths: appPathsText(scan),
+    };
+}
+export function fillPrompt(def, values, lang) {
+    return fillTemplate(t(def.body, lang), values, PLACEHOLDERS);
+}
+/** The exact Katman call(s) that check the acceptance criterion. */
+export function verifyCalls(id, root, siteUrl, situation, staticDir = "", languages = []) {
+    const site = siteUrl ?? "[FILL: site URL]";
+    switch (id) {
+        case "P0": return [calls.researchShow(root)];
+        case "P1": return [calls.scan(root), calls.audit(root, site)];
+        case "P6": {
+            const url = situation ? situationUrl(situation, languages) : "/[FILL]";
+            return [
+                calls.lint(root, { file: "[FILL: the new page file]", page_type: "situation", ...(situation ? { situation_id: situation.id } : {}) }),
+                calls.auditUrls(root, [`${site}${url}`]),
+            ];
+        }
+        case "P7": return [calls.lint(root, { file: "[FILL: the guide page file]", page_type: "comparison" })];
+        case "P8": return [calls.generate(root, "llms.txt"), calls.lint(root, { file: `${staticDir ? staticDir + "/" : ""}llms.txt` })];
+        case "P12": return [];
+        case "P13": return [calls.scan(root)];
+        case "P14": return [calls.auditUrls(root, [`${site}/`])];
+        default: return [calls.audit(root, site)];
+    }
+}
+export function renderPrompt(def, o) {
+    const values = fillValues(o.research, o.config, o.scan, o.situation);
+    const filled = fillPrompt(def, values, o.lang);
+    const used = promptPlaceholders(def);
+    const missing = used.filter((p) => !isFilled(values[p]));
+    const L = (en, tr) => (o.lang === "tr" ? tr : en);
+    const parts = [];
+    parts.push(`# ${def.id} · ${t(def.title, o.lang)}${def.tag ? ` — ${t(def.tag, o.lang)}` : ""}`);
+    parts.push(`**${L("When", "Ne zaman")}:** ${t(def.when, o.lang)}${def.changesCode ? "" : L(" This prompt changes no code.", " Bu prompt hiçbir kodu değiştirmez.")}`);
+    if (def.id === "P6" && o.situation)
+        parts.push(`**${L("Situation", "Durum")}:** \`${o.situation.id}\` "${o.situation.sentence}"`);
+    parts.push(`## ${L("Prompt (do this now)", "Prompt (şimdi bunu yap)")}\n${codeBlock(filled)}`);
+    if (missing.length) {
+        parts.push(L(`**[FILL] left in the prompt:** ${missing.map((m) => `{${m}}`).join(", ")}. Fill them in research (katman_research mode "update") or ask the user — don't guess.`, `**Prompt’ta [FILL] kaldı:** ${missing.map((m) => `{${m}}`).join(", ")}. Araştırmada doldurun (katman_research mode "update") ya da kullanıcıya sorun — tahmin etmeyin.`));
+    }
+    parts.push(`**${L("Accept", "Kabul")}:** ${t(def.accept, o.lang)}`);
+    parts.push(`**${L("Why", "Neden")}:** ${t(def.why, o.lang)}`);
+    if (def.katmanNote)
+        parts.push(`**${L("Evidence note", "Kanıt notu")}:** ${t(def.katmanNote, o.lang)}`);
+    const verify = def.verifiedBy.map((v) => `- ${v.tool === "manual" ? L("by hand", "elle") : `\`${v.tool}\``}: ${t(v.check, o.lang)}`);
+    const vc = verifyCalls(def.id, o.root, siteUrlOf(o.research, o.config), o.situation, o.staticDir, o.research?.site.languages);
+    parts.push(`## ${L("How Katman verifies this", "Katman bunu nasıl doğrular")}\n${verify.join("\n")}${vc.length ? `\n\n${L("Run", "Çalıştır")}: ${vc.map(fmtCall).join(" · ")}` : ""}`);
+    const notes = frameworkNotes(def.id, o.scan, o.lang, o.staticDir ?? "");
+    if (notes.length)
+        parts.push(`## ${L("Notes for this codebase", "Bu kod tabanı için notlar")} (${fwLabel(o.scan)})\n${notes.map((n) => `- ${n.replace(/\n/g, "\n  ")}`).join("\n")}`);
+    else if (!o.scan && ["P2", "P3", "P4", "P6", "P11", "P13"].includes(def.id)) {
+        parts.push(L(`No scan yet: run ${fmtCall(calls.scan(o.root))} for framework-specific notes.`, `Henüz tarama yok: çatıya özel notlar için ${fmtCall(calls.scan(o.root))} çalıştırın.`));
+    }
+    parts.push(L(`**When you're done:** list the files you changed, run the check above, and tick this task in .katman/plan.md only when it passes.`, `**Bitirince:** değiştirdiğin dosyaları listele, yukarıdaki kontrolü çalıştır ve görevi .katman/plan.md’de yalnızca kontrol geçince işaretle.`));
+    return { markdown: parts.join("\n\n"), filled, missing };
+}
+export async function runPrompt(root, args) {
+    const def = getPrompt(args.id);
+    if (!def) {
+        return { text: `Unknown prompt "${args.id}". Valid ids: ${PROMPTS.map((p) => p.id).join(", ")}.`, isError: true };
+    }
+    const [research, config, scan, loaded] = await Promise.all([loadResearchSafe(root), loadConfigSafe(root), loadScan(root), loadLatestAudit(root)]);
+    const lang = args.lang ?? config.lang ?? "en";
+    let situation;
+    if (def.id === "P6") {
+        situation = pickSituation(research, args.situationId, scan, loaded?.audit);
+        if (args.situationId && !situation) {
+            const ids = (research?.situations ?? []).map((s) => `${s.id} ("${s.sentence}")`).join(", ");
+            return { text: `Situation "${args.situationId}" not found in research. Known situations: ${ids || "none — add them with katman_research mode \"update\""}.`, isError: true };
+        }
+    }
+    const staticDir = staticDirFor(root, scan).dir;
+    const out = renderPrompt(def, { root, lang, research, config, scan, audit: loaded?.audit, situation, staticDir });
+    const warn = [];
+    if (!research)
+        warn.push(`No research yet, so placeholders are [FILL]. Start with ${fmtCall(calls.researchTemplate(root))}.`);
+    return {
+        text: [warn.join("\n"), out.markdown].filter(Boolean).join("\n\n"),
+        structured: {
+            id: def.id,
+            lang,
+            prompt: out.filled,
+            accept: t(def.accept, lang),
+            why: t(def.why, lang),
+            verifiedBy: def.verifiedBy.map((v) => ({ tool: v.tool, check: t(v.check, lang) })),
+            missing: out.missing,
+            ...(situation ? { situation } : {}),
+        },
+    };
+}