@se-studio/site-check 1.3.1 → 1.4.0

package/dist/cms-seo/seo-audit.js

@@ -1,926 +0,0 @@
-import { mkdir, writeFile } from 'node:fs/promises';
-import path from 'node:path';
-const LOCALE = 'en-US';
-function field(entry, key) {
-    return entry.fields?.[key]?.[LOCALE];
-}
-/** Human-readable template identifier — Headwater uses cmsLabel; legacy entries may use slug or name. */
-function templateLabel(template) {
-    return (field(template, 'cmsLabel') ??
-        field(template, 'slug') ??
-        field(template, 'name') ??
-        template.sys.id);
-}
-function isGeneralPageTemplate(template) {
-    return /general/i.test(templateLabel(template));
-}
-function isArticlePageTemplate(template) {
-    return /(publication|news article) template/i.test(templateLabel(template));
-}
-function entryStatus(entry) {
-    return entry.sys.publishedAt ? 'published' : 'draft';
-}
-function escapeCsv(value) {
-    if (/[",\n]/.test(value))
-        return `"${value.replace(/"/g, '""')}"`;
-    return value;
-}
-function trimDescription(text, max = 160) {
-    const cleaned = text.replace(/\s+/g, ' ').trim();
-    if (cleaned.length <= max)
-        return cleaned;
-    const cut = cleaned.slice(0, max - 1);
-    const lastSpace = cut.lastIndexOf(' ');
-    return `${(lastSpace > 120 ? cut.slice(0, lastSpace) : cut).trim()}…`;
-}
-async function fetchEntriesByType(client, contentType) {
-    const items = [];
-    let skip = 0;
-    while (true) {
-        const page = await client.entry.getMany({
-            query: { content_type: contentType, limit: 100, skip },
-        });
-        items.push(...page.items);
-        skip += 100;
-        if (skip >= page.total)
-            break;
-    }
-    return items;
-}
-function sameIdSet(a, b) {
-    if (a.length !== b.length)
-        return false;
-    const left = [...a].sort();
-    const right = [...b].sort();
-    return left.every((id, index) => id === right[index]);
-}
-function linkIds(entry, fieldName) {
-    const value = field(entry, fieldName);
-    if (!value)
-        return [];
-    if (Array.isArray(value)) {
-        return value
-            .map((item) => {
-            if (item && typeof item === 'object' && 'sys' in item) {
-                const sys = item.sys;
-                return sys?.id ?? '';
-            }
-            return '';
-        })
-            .filter(Boolean);
-    }
-    if (typeof value === 'object' && value !== null && 'sys' in value) {
-        const id = value.sys?.id;
-        return id ? [id] : [];
-    }
-    return [];
-}
-function buildTagMaps(tags, tagTypes) {
-    const tagTypeById = new Map();
-    for (const tt of tagTypes)
-        tagTypeById.set(tt.sys.id, tt);
-    const tagById = new Map();
-    for (const tag of tags)
-        tagById.set(tag.sys.id, tag);
-    return { tagById, tagTypeById };
-}
-function primaryTagSlug(article, tagById, tagTypeById, articleTypeById) {
-    const tagIds = linkIds(article, 'tags');
-    const tags = tagIds.map((id) => tagById.get(id)).filter(Boolean);
-    const atId = field(article, 'articleType')?.sys.id;
-    const atSlug = atId ? (field(articleTypeById.get(atId), 'slug') ?? '') : '';
-    let preferredTagType;
-    if (atSlug.includes('resources/news'))
-        preferredTagType = 'asset-type';
-    else if (atSlug.includes('resources/publications'))
-        preferredTagType = 'presentation-type';
-    if (preferredTagType) {
-        for (const tag of tags) {
-            const ttId = field(tag, 'tagType')?.sys.id;
-            const tt = ttId ? tagTypeById.get(ttId) : undefined;
-            if (tt && field(tt, 'slug') === preferredTagType) {
-                const slug = field(tag, 'slug');
-                if (slug)
-                    return slug;
-            }
-        }
-    }
-    return 'other';
-}
-function articleUrl(config, articleTypeSlug, articleSlug, primaryTag) {
-    const base = `${config.articlesBase}/resources/${articleTypeSlug.split('/').pop() ?? articleTypeSlug}`;
-    if (config.enablePrimaryTagPartOfSlug) {
-        return `${base}/${primaryTag}/${articleSlug}/`;
-    }
-    return `${base}/${articleSlug}/`;
-}
-function pageUrl(slug) {
-    if (slug === 'index')
-        return '/';
-    return `/${slug}/`;
-}
-function schemaLinkSummary(entry, schemaById) {
-    const ids = [...linkIds(entry, 'structuredData'), ...linkIds(entry, 'indexPageStructuredData')];
-    if (ids.length === 0)
-        return '';
-    return ids
-        .map((id) => {
-        const schema = schemaById.get(id);
-        const label = schema ? (field(schema, 'cmsLabel') ?? id) : id;
-        return `${label} (${id})`;
-    })
-        .join('; ');
-}
-function recommendArticleDescription(_config, title, articleTypeSlug, current) {
-    if (current.trim().length >= 120 && current.trim().length <= 160)
-        return current.trim();
-    const isPublication = articleTypeSlug.includes('publications');
-    const prefix = isPublication
-        ? 'Explore this publication on real-world evidence'
-        : 'Read the latest news on regulatory-grade real-world evidence';
-    const base = `${prefix}: ${title}.`;
-    return trimDescription(base);
-}
-function classifyRowSchema(contentType, slug, url, _config, articleTypeSlug) {
-    if (contentType === 'tagType') {
-        return {
-            types: 'N/A',
-            action: 'none',
-            notes: 'Taxonomy only — no public URL or CMS SEO fields',
-        };
-    }
-    if (url.includes('/resources/') && url.split('/').filter(Boolean).length === 3) {
-        return {
-            types: 'CollectionPage',
-            action: 'link template',
-            notes: 'Combo URL — description auto-generated at runtime; link CollectionPage schema via tag or shared template',
-        };
-    }
-    if (contentType === 'template') {
-        return {
-            types: 'Organization; WebSite',
-            action: 'link',
-            notes: 'Template-level Organization + WebSite (SearchAction deferred until search index populated on Headwater)',
-        };
-    }
-    if (contentType === 'page') {
-        if (slug === 'about' || slug === 'about-us') {
-            return {
-                types: 'AboutPage',
-                action: 'link',
-                notes: 'Entry or shared AboutPage schema; inherits Organization/WebSite from template',
-            };
-        }
-        if (slug === 'contact' || slug === 'contact-us') {
-            return { types: 'ContactPage', action: 'link', notes: 'Entry-level ContactPage schema' };
-        }
-        if (slug === 'index' || slug === 'home') {
-            return {
-                types: 'WebPage',
-                action: 'link',
-                notes: 'Homepage WebPage + template Organization/WebSite',
-            };
-        }
-        if (slug.includes('privacy') || slug.includes('cookie')) {
-            return { types: 'WebPage', action: 'keep', notes: 'Legal page — minimal rich schema' };
-        }
-        return {
-            types: 'WebPage',
-            action: 'link',
-            notes: 'Shared WebPage Mustache template (page.title, page.description, breadcrumbs)',
-        };
-    }
-    if (contentType === 'articleType') {
-        return {
-            types: 'CollectionPage',
-            action: 'link',
-            notes: 'indexPageStructuredData — CollectionPage for resource hub',
-        };
-    }
-    if (contentType === 'customType') {
-        return {
-            types: 'CollectionPage',
-            action: 'link',
-            notes: 'indexPageStructuredData on customType (people/categories index)',
-        };
-    }
-    if (contentType === 'tag') {
-        return {
-            types: 'CollectionPage',
-            action: 'link',
-            notes: 'tag.structuredData — CollectionPage for category hub',
-        };
-    }
-    if (contentType === 'article') {
-        if (articleTypeSlug?.includes('publications')) {
-            return {
-                types: 'ScholarlyArticle',
-                action: 'link via articleType',
-                notes: 'Prefer articleType.structuredData template; entry override only if unique',
-            };
-        }
-        return {
-            types: 'BlogPosting',
-            action: 'link via articleType',
-            notes: 'articleType.structuredData BlogPosting template with article.* Mustache vars',
-        };
-    }
-    if (contentType === 'person') {
-        return {
-            types: 'ProfilePage; Person',
-            action: 'link',
-            notes: 'person.structuredData — ProfilePage + nested Person',
-        };
-    }
-    return { types: 'WebPage', action: 'keep', notes: '' };
-}
-export async function runSeoAudit(client, config, options) {
-    const [pages, articles, articleTypes, tags, tagTypes, customTypes, people, schemas, templates] = await Promise.all([
-        fetchEntriesByType(client, 'page'),
-        fetchEntriesByType(client, 'article'),
-        fetchEntriesByType(client, 'articleType'),
-        fetchEntriesByType(client, 'tag'),
-        fetchEntriesByType(client, 'tagType'),
-        fetchEntriesByType(client, 'customType'),
-        fetchEntriesByType(client, 'person'),
-        fetchEntriesByType(client, 'schema'),
-        fetchEntriesByType(client, 'template'),
-    ]);
-    const schemaById = new Map(schemas.map((s) => [s.sys.id, s]));
-    const articleTypeById = new Map(articleTypes.map((at) => [at.sys.id, at]));
-    const { tagById, tagTypeById } = buildTagMaps(tags, tagTypes);
-    const rows = [];
-    const usedDescriptions = new Set();
-    function pushRow(partial) {
-        const recommended = partial.recommendedDescription.trim();
-        const flags = partial.flags ? partial.flags.split('; ').filter(Boolean) : [];
-        if (recommended && usedDescriptions.has(recommended.toLowerCase()))
-            flags.push('duplicate recommended description');
-        if (recommended)
-            usedDescriptions.add(recommended.toLowerCase());
-        if (partial.chars > 0 && (partial.chars < 120 || partial.chars > 160))
-            flags.push('char count outside 120–160');
-        if (partial.flags.includes('auto-generated'))
-            partial.reviewStatus = partial.reviewStatus ?? 'Skip';
-        else if (flags.some((f) => f.includes('TBC')))
-            partial.reviewStatus = partial.reviewStatus ?? 'Revise';
-        else
-            partial.reviewStatus = partial.reviewStatus ?? 'Approved';
-        rows.push({
-            ...partial,
-            flags: flags.join('; '),
-            reviewStatus: partial.reviewStatus ?? 'Approved',
-            applied: partial.applied ?? '',
-        });
-    }
-    // Pages
-    for (const page of pages) {
-        const slug = field(page, 'slug') ?? page.sys.id;
-        const url = pageUrl(slug);
-        const current = field(page, 'description') ?? '';
-        const recommended = config.pageDescriptions[slug] ??
-            (current.trim() ? trimDescription(current) : trimDescription(config.siteDescription));
-        const schema = classifyRowSchema('page', slug, url, config);
-        pushRow({
-            url,
-            contentType: 'page',
-            slug,
-            entryId: page.sys.id,
-            status: entryStatus(page),
-            currentDescription: current,
-            chars: current.length,
-            recommendedDescription: recommended,
-            targetKeyword: config.pageKeywords[slug] ?? slug.replace(/-/g, ' '),
-            currentSchemaLinks: schemaLinkSummary(page, schemaById),
-            recommendedSchemaTypes: schema.types,
-            schemaAction: schema.action,
-            schemaTemplateNotes: schema.notes,
-            flags: slug === 'index' && url === '/' ? 'root URL alias' : '',
-            applied: '',
-        });
-    }
-    // Article types
-    for (const at of articleTypes) {
-        const slug = field(at, 'slug') ?? at.sys.id;
-        const segment = slug.split('/').pop() ?? slug;
-        const url = `/resources/${segment}/`;
-        const current = field(at, 'indexPageDescription') ?? '';
-        const recommended = config.indexDescriptions[slug] ??
-            (current.trim() ||
-                trimDescription(`Browse ${config.siteName} ${segment.replace(/-/g, ' ')} — regulatory-grade real-world evidence and insights.`));
-        const schema = classifyRowSchema('articleType', slug, url, config);
-        pushRow({
-            url,
-            contentType: 'articleType',
-            slug,
-            entryId: at.sys.id,
-            status: entryStatus(at),
-            currentDescription: current,
-            chars: current.length,
-            recommendedDescription: recommended,
-            targetKeyword: config.indexKeywords[slug] ?? segment,
-            currentSchemaLinks: schemaLinkSummary(at, schemaById),
-            recommendedSchemaTypes: schema.types,
-            schemaAction: schema.action,
-            schemaTemplateNotes: schema.notes,
-            flags: '',
-            applied: '',
-        });
-    }
-    // Custom types
-    for (const ct of customTypes) {
-        const slug = field(ct, 'slug') ?? ct.sys.id;
-        const url = `/${slug}/`;
-        const current = field(ct, 'indexPageDescription') ?? '';
-        const recommended = config.indexDescriptions[slug] ??
-            (current.trim() ||
-                trimDescription(`Explore ${slug.replace(/-/g, ' ')} at ${config.siteName}.`));
-        const schema = classifyRowSchema('customType', slug, url, config);
-        pushRow({
-            url,
-            contentType: 'customType',
-            slug,
-            entryId: ct.sys.id,
-            status: entryStatus(ct),
-            currentDescription: current,
-            chars: current.length,
-            recommendedDescription: recommended,
-            targetKeyword: config.indexKeywords[slug] ?? slug,
-            currentSchemaLinks: schemaLinkSummary(ct, schemaById),
-            recommendedSchemaTypes: schema.types,
-            schemaAction: schema.action,
-            schemaTemplateNotes: schema.notes,
-            flags: '',
-            applied: '',
-        });
-    }
-    // Tags + combo URLs
-    for (const tag of tags) {
-        const slug = field(tag, 'slug') ?? tag.sys.id;
-        const url = `${config.tagsBase}/${slug}/`;
-        const current = field(tag, 'description') ?? '';
-        const recommended = current.trim() ||
-            trimDescription(`Resources and insights tagged ${slug.replace(/-/g, ' ')} from ${config.siteName}.`);
-        const schema = classifyRowSchema('tag', slug, url, config);
-        pushRow({
-            url,
-            contentType: 'tag',
-            slug,
-            entryId: tag.sys.id,
-            status: entryStatus(tag),
-            currentDescription: current,
-            chars: current.length,
-            recommendedDescription: recommended,
-            targetKeyword: slug.replace(/-/g, ' '),
-            currentSchemaLinks: schemaLinkSummary(tag, schemaById),
-            recommendedSchemaTypes: schema.types,
-            schemaAction: schema.action,
-            schemaTemplateNotes: schema.notes,
-            flags: '',
-            applied: '',
-        });
-        for (const at of articleTypes) {
-            const atSlug = field(at, 'slug') ?? '';
-            const segment = atSlug.split('/').pop() ?? atSlug;
-            const comboUrl = `/resources/${segment}/${slug}/`;
-            const autoDesc = `Browse the latest ${segment.replace(/-/g, ' ')} resources related to ${slug.replace(/-/g, ' ')}.`;
-            const comboSchema = classifyRowSchema('tag', slug, comboUrl, config);
-            pushRow({
-                url: comboUrl,
-                contentType: 'articleType+tag',
-                slug: `${atSlug}+${slug}`,
-                entryId: `${at.sys.id}+${tag.sys.id}`,
-                status: entryStatus(tag),
-                currentDescription: autoDesc,
-                chars: autoDesc.length,
-                recommendedDescription: autoDesc,
-                targetKeyword: `${segment} ${slug}`,
-                currentSchemaLinks: schemaLinkSummary(tag, schemaById),
-                recommendedSchemaTypes: comboSchema.types,
-                schemaAction: 'document only',
-                schemaTemplateNotes: comboSchema.notes,
-                flags: 'auto-generated description — not CMS-editable',
-                reviewStatus: 'Skip',
-                applied: '',
-            });
-        }
-    }
-    // tagType taxonomy
-    for (const tt of tagTypes) {
-        const slug = field(tt, 'slug') ?? tt.sys.id;
-        const schema = classifyRowSchema('tagType', slug, '', config);
-        pushRow({
-            url: 'N/A',
-            contentType: 'tagType',
-            slug,
-            entryId: tt.sys.id,
-            status: entryStatus(tt),
-            currentDescription: '',
-            chars: 0,
-            recommendedDescription: '',
-            targetKeyword: '',
-            currentSchemaLinks: '',
-            recommendedSchemaTypes: schema.types,
-            schemaAction: schema.action,
-            schemaTemplateNotes: schema.notes,
-            flags: 'taxonomy only',
-            reviewStatus: 'Skip',
-            applied: '',
-        });
-    }
-    // People
-    for (const person of people) {
-        const slug = field(person, 'slug') ?? person.sys.id;
-        const url = `${config.peopleBase}/${slug}/`;
-        const name = field(person, 'name') ?? slug;
-        const jobTitle = field(person, 'jobTitle') ?? '';
-        const current = field(person, 'description') ?? '';
-        const recommended = current.trim() ||
-            trimDescription(jobTitle
-                ? `${name}, ${jobTitle} at ${config.orgName}. Learn about their work in real-world evidence.`
-                : `${name} at ${config.orgName}. Learn about their role and expertise.`);
-        const schema = classifyRowSchema('person', slug, url, config);
-        pushRow({
-            url,
-            contentType: 'person',
-            slug,
-            entryId: person.sys.id,
-            status: entryStatus(person),
-            currentDescription: current,
-            chars: current.length,
-            recommendedDescription: recommended,
-            targetKeyword: name,
-            currentSchemaLinks: schemaLinkSummary(person, schemaById),
-            recommendedSchemaTypes: schema.types,
-            schemaAction: schema.action,
-            schemaTemplateNotes: schema.notes,
-            flags: '',
-            applied: '',
-        });
-    }
-    // Articles (optionally sample)
-    const articlesByType = new Map();
-    for (const article of articles) {
-        const atId = field(article, 'articleType')?.sys.id;
-        const atSlug = atId
-            ? (field(articleTypeById.get(atId), 'slug') ?? 'unknown')
-            : 'unknown';
-        if (!articlesByType.has(atSlug))
-            articlesByType.set(atSlug, []);
-        articlesByType.get(atSlug).push(article);
-    }
-    for (const [atSlug, typeArticles] of articlesByType) {
-        const sorted = [...typeArticles].sort((a, b) => {
-            const da = field(a, 'date') ?? '';
-            const db = field(b, 'date') ?? '';
-            return db.localeCompare(da);
-        });
-        const selected = options.sampleArticlesOnly ? sorted.slice(0, 5) : sorted;
-        for (const article of selected) {
-            const slug = field(article, 'slug') ?? article.sys.id;
-            const title = field(article, 'title') ?? slug;
-            const primaryTag = primaryTagSlug(article, tagById, tagTypeById, articleTypeById);
-            const url = articleUrl(config, atSlug, slug, primaryTag);
-            const current = field(article, 'description') ?? '';
-            const recommended = recommendArticleDescription(config, title, atSlug, current);
-            const schema = classifyRowSchema('article', slug, url, config, atSlug);
-            pushRow({
-                url,
-                contentType: 'article',
-                slug,
-                entryId: article.sys.id,
-                status: entryStatus(article),
-                currentDescription: current,
-                chars: current.length,
-                recommendedDescription: recommended,
-                targetKeyword: title.slice(0, 40),
-                currentSchemaLinks: schemaLinkSummary(article, schemaById),
-                recommendedSchemaTypes: schema.types,
-                schemaAction: schema.action,
-                schemaTemplateNotes: schema.notes,
-                flags: options.sampleArticlesOnly ? 'sample row' : '',
-                applied: '',
-            });
-        }
-    }
-    // Templates (sitewide schema)
-    for (const template of templates) {
-        const slug = templateLabel(template);
-        const generalTemplate = isGeneralPageTemplate(template);
-        const articleTemplate = isArticlePageTemplate(template);
-        const linkOrgWebsite = generalTemplate || articleTemplate;
-        pushRow({
-            url: 'sitewide',
-            contentType: 'template',
-            slug,
-            entryId: template.sys.id,
-            status: entryStatus(template),
-            currentDescription: '',
-            chars: 0,
-            recommendedDescription: '',
-            targetKeyword: '',
-            currentSchemaLinks: schemaLinkSummary(template, schemaById),
-            recommendedSchemaTypes: linkOrgWebsite ? 'Organization; WebSite' : '',
-            schemaAction: linkOrgWebsite ? 'link Organization + WebSite schema entries' : 'skip',
-            schemaTemplateNotes: generalTemplate
-                ? 'General template structuredData — shared across pages using this template'
-                : articleTemplate
-                    ? 'Article template structuredData — Organization/WebSite plus articleType article schema'
-                    : 'Other templates — no sitewide schema',
-            flags: linkOrgWebsite ? '' : 'non-sitewide template',
-            reviewStatus: linkOrgWebsite ? 'Approved' : 'Skip',
-            applied: '',
-        });
-    }
-    const csvHeader = [
-        'URL',
-        'Content type',
-        'Slug',
-        'Entry ID',
-        'Status',
-        'Current description',
-        'Chars',
-        'Recommended description',
-        'Target keyword',
-        'Current schema links',
-        'Recommended schema type(s)',
-        'Schema action',
-        'Schema template notes',
-        'Flags',
-        'Review status',
-        'Applied?',
-    ];
-    const csvLines = [
-        csvHeader.join(','),
-        ...rows.map((r) => [
-            r.url,
-            r.contentType,
-            r.slug,
-            r.entryId,
-            r.status,
-            r.currentDescription,
-            String(r.chars),
-            r.recommendedDescription,
-            r.targetKeyword,
-            r.currentSchemaLinks,
-            r.recommendedSchemaTypes,
-            r.schemaAction,
-            r.schemaTemplateNotes,
-            r.flags,
-            r.reviewStatus,
-            r.applied,
-        ]
-            .map(escapeCsv)
-            .join(',')),
-    ];
-    await mkdir(path.dirname(config.outputCsvPath), { recursive: true });
-    await writeFile(config.outputCsvPath, `${csvLines.join('\n')}\n`, 'utf8');
-    if (options.apply) {
-        await applySeoAudit(client, config, rows, {
-            schemas,
-            templates,
-            articleTypes,
-            schemaById,
-        });
-    }
-    return { rows, csvPath: config.outputCsvPath };
-}
-function findSchemaIdByLabel(schemaById, cmsLabel) {
-    for (const [id, entry] of schemaById) {
-        if (field(entry, 'cmsLabel') === cmsLabel)
-            return id;
-    }
-    return undefined;
-}
-async function ensureSchemaEntry(client, existingId, cmsLabel, markup, schemaById) {
-    const resolvedId = existingId ?? findSchemaIdByLabel(schemaById, cmsLabel);
-    if (resolvedId && schemaById.has(resolvedId)) {
-        const existing = schemaById.get(resolvedId);
-        if (field(existing, 'markup') !== markup) {
-            const updated = await client.entry.update({ entryId: resolvedId }, {
-                sys: { version: existing.sys.version },
-                fields: {
-                    ...existing.fields,
-                    markup: { [LOCALE]: markup },
-                },
-            });
-            schemaById.set(resolvedId, updated);
-        }
-        return resolvedId;
-    }
-    const created = await client.entry.create({ contentTypeId: 'schema' }, { fields: { cmsLabel: { [LOCALE]: cmsLabel }, markup: { [LOCALE]: markup } } });
-    schemaById.set(created.sys.id, created);
-    return created.sys.id;
-}
-function organizationMarkup(config) {
-    const sameAs = config.linkedInUrl
-        ? `,\n      "sameAs": [\n        "${config.linkedInUrl}"\n      ]`
-        : '';
-    return `{
-  "@context": "https://schema.org",
-  "@graph": [
-    {
-      "@type": ["Organization", "MedicalOrganization"],
-      "@id": "{{{baseUrl}}}/#organization",
-      "name": "${config.orgName}",
-      "url": "{{{baseUrl}}}",
-      "description": "${config.siteDescription.replace(/"/g, '\\"')}"${sameAs}
-    }
-  ]
-}`;
-}
-function websiteMarkup(config, includeSearch) {
-    const searchBlock = includeSearch
-        ? `,
-      "potentialAction": {
-        "@type": "SearchAction",
-        "target": {
-          "@type": "EntryPoint",
-          "urlTemplate": "{{{baseUrl}}}/search?q={search_term_string}"
-        },
-        "query-input": "required name=search_term_string"
-      }`
-        : '';
-    return `{
-  "@context": "https://schema.org",
-  "@graph": [
-    {
-      "@type": "WebSite",
-      "@id": "{{{baseUrl}}}/#website",
-      "url": "{{{baseUrl}}}",
-      "name": "${config.orgName}",
-      "description": "${config.siteDescription.replace(/"/g, '\\"')}",
-      "publisher": {
-        "@id": "{{{baseUrl}}}/#organization"
-      }${searchBlock}
-    }
-  ]
-}`;
-}
-function webPageMarkup(pageType = 'WebPage') {
-    return `{
-  "@context": "https://schema.org",
-  "@graph": [
-    {
-      "@type": "${pageType}",
-      "@id": "{{{currentUrl}}}",
-      "url": "{{{currentUrl}}}",
-      "name": "{{page.title}}",
-      "description": "{{page.description}}",
-      "image": "{{{page.imageUrl}}}",
-      "publisher": {
-        "@id": "{{{baseUrl}}}/#organization"
-      },
-      "isPartOf": {
-        "@id": "{{{baseUrl}}}/#website"
-      }
-    }
-  ]
-}`;
-}
-function collectionPageMarkup() {
-    return `{
-  "@context": "https://schema.org",
-  "@graph": [
-    {
-      "@type": "CollectionPage",
-      "@id": "{{{currentUrl}}}",
-      "url": "{{{currentUrl}}}",
-      "name": "{{page.title}}",
-      "description": "{{page.description}}",
-      "publisher": {
-        "@id": "{{{baseUrl}}}/#organization"
-      },
-      "isPartOf": {
-        "@id": "{{{baseUrl}}}/#website"
-      }
-    }
-  ]
-}`;
-}
-function blogPostingMarkup(config) {
-    return `{
-  "@context": "https://schema.org",
-  "@graph": [
-    {
-      "@type": "BlogPosting",
-      "@id": "{{{currentUrl}}}",
-      "url": "{{{currentUrl}}}",
-      "headline": "{{article.title}}",
-      "description": "{{article.description}}",
-      "datePublished": "{{article.date}}",
-      "image": "{{{article.imageUrl}}}",
-      "author": {
-        "@type": "Organization",
-        "name": "${config.orgName}"
-      },
-      "publisher": {
-        "@id": "{{{baseUrl}}}/#organization"
-      },
-      "isPartOf": {
-        "@id": "{{{baseUrl}}}/#website"
-      }
-    }
-  ]
-}`;
-}
-function scholarlyArticleMarkup(config) {
-    return `{
-  "@context": "https://schema.org",
-  "@graph": [
-    {
-      "@type": "ScholarlyArticle",
-      "@id": "{{{currentUrl}}}",
-      "url": "{{{currentUrl}}}",
-      "headline": "{{article.title}}",
-      "description": "{{article.description}}",
-      "datePublished": "{{article.date}}",
-      "image": "{{{article.imageUrl}}}",
-      "author": {
-        "@type": "Organization",
-        "name": "${config.orgName}"
-      },
-      "publisher": {
-        "@id": "{{{baseUrl}}}/#organization"
-      },
-      "isPartOf": {
-        "@id": "{{{baseUrl}}}/#website"
-      }
-    }
-  ]
-}`;
-}
-export function profilePageMarkup(config) {
-    return `{
-  "@context": "https://schema.org",
-  "@graph": [
-    {
-      "@type": "ProfilePage",
-      "@id": "{{{currentUrl}}}",
-      "url": "{{{currentUrl}}}",
-      "name": "{{person.name}}",
-      "description": "{{page.description}}",
-      "mainEntity": {
-        "@type": "Person",
-        "@id": "{{{currentUrl}}}#person",
-        "name": "{{person.name}}",
-        "jobTitle": "{{person.jobTitle}}",
-        "image": "{{{person.imageUrl}}}",
-        "worksFor": {
-          "@id": "{{{baseUrl}}}/#organization"
-        }
-      },
-      "publisher": {
-        "@id": "{{{baseUrl}}}/#organization"
-      },
-      "isPartOf": {
-        "@id": "{{{baseUrl}}}/#website"
-      }
-    }
-  ]
-}`;
-}
-async function updateEntryField(client, entryId, fields) {
-    const entry = await client.entry.get({ entryId });
-    const merged = { ...entry.fields };
-    for (const [key, value] of Object.entries(fields)) {
-        merged[key] = { [LOCALE]: value };
-    }
-    await client.entry.update({ entryId }, { ...entry, fields: merged });
-}
-async function linkSchemaArray(client, entryId, fieldName, schemaIds) {
-    const entry = await client.entry.get({ entryId });
-    const links = schemaIds.map((id) => ({
-        sys: { type: 'Link', linkType: 'Entry', id },
-    }));
-    const merged = {
-        ...entry.fields,
-        [fieldName]: { [LOCALE]: links },
-    };
-    await client.entry.update({ entryId }, { ...entry, fields: merged });
-}
-async function applySeoAudit(client, config, rows, ctx) {
-    const includeSearch = config.enableSearchAction ?? false;
-    const orgId = await ensureSchemaEntry(client, config.schemaIds?.organization, `${config.orgName} — Organization`, organizationMarkup(config), ctx.schemaById);
-    const websiteId = await ensureSchemaEntry(client, config.schemaIds?.website, `${config.orgName} — WebSite`, websiteMarkup(config, includeSearch), ctx.schemaById);
-    if (config.schemaIds?.website && includeSearch && ctx.schemaById.has(config.schemaIds.website)) {
-        const entry = await client.entry.get({ entryId: config.schemaIds.website });
-        const merged = {
-            ...entry.fields,
-            markup: { [LOCALE]: websiteMarkup(config, true) },
-        };
-        await client.entry.update({ entryId: config.schemaIds.website }, { ...entry, fields: merged });
-    }
-    const webPageId = await ensureSchemaEntry(client, config.schemaIds?.webPage, `${config.orgName} — WebPage`, webPageMarkup('WebPage'), ctx.schemaById);
-    const collectionId = await ensureSchemaEntry(client, config.schemaIds?.collectionPage, `${config.orgName} — CollectionPage`, collectionPageMarkup(), ctx.schemaById);
-    const blogId = await ensureSchemaEntry(client, config.schemaIds?.blogPosting, `${config.orgName} — BlogPosting`, blogPostingMarkup(config), ctx.schemaById);
-    const scholarlyId = await ensureSchemaEntry(client, config.schemaIds?.scholarlyArticle, `${config.orgName} — ScholarlyArticle`, scholarlyArticleMarkup(config), ctx.schemaById);
-    const profilePageId = await ensureSchemaEntry(client, config.schemaIds?.profilePage, `${config.orgName} — ProfilePage (Person)`, profilePageMarkup(config), ctx.schemaById);
-    // Template-level Organization + WebSite (general pages + article templates)
-    for (const template of ctx.templates) {
-        if (!isGeneralPageTemplate(template) && !isArticlePageTemplate(template))
-            continue;
-        await linkSchemaArray(client, template.sys.id, 'structuredData', [orgId, websiteId]);
-    }
-    // Article type schema templates
-    for (const at of ctx.articleTypes) {
-        const slug = field(at, 'slug') ?? '';
-        const ids = slug.includes('publications')
-            ? [collectionId, scholarlyId]
-            : [collectionId, blogId];
-        await linkSchemaArray(client, at.sys.id, 'indexPageStructuredData', [collectionId]);
-        await linkSchemaArray(client, at.sys.id, 'structuredData', [ids[1]]);
-    }
-    for (const row of rows) {
-        if (row.reviewStatus !== 'Approved')
-            continue;
-        if (row.flags.includes('auto-generated') || row.flags.includes('taxonomy only'))
-            continue;
-        if (!row.recommendedDescription || row.recommendedDescription === row.currentDescription) {
-            // still may need schema links
-        }
-        try {
-            if (row.contentType === 'page' &&
-                row.recommendedDescription &&
-                row.recommendedDescription !== row.currentDescription) {
-                await updateEntryField(client, row.entryId, { description: row.recommendedDescription });
-                row.applied = 'description';
-            }
-            else if (row.contentType === 'articleType' || row.contentType === 'customType') {
-                if (row.recommendedDescription && row.recommendedDescription !== row.currentDescription) {
-                    await updateEntryField(client, row.entryId, {
-                        indexPageDescription: row.recommendedDescription,
-                    });
-                    row.applied = 'indexPageDescription';
-                }
-            }
-            else if (row.contentType === 'tag' &&
-                row.recommendedDescription &&
-                row.recommendedDescription !== row.currentDescription) {
-                await updateEntryField(client, row.entryId, { description: row.recommendedDescription });
-                row.applied = 'description';
-            }
-            else if (row.contentType === 'person' &&
-                row.recommendedDescription &&
-                row.recommendedDescription !== row.currentDescription) {
-                await updateEntryField(client, row.entryId, { description: row.recommendedDescription });
-                row.applied = 'description';
-            }
-            else if (row.contentType === 'article' &&
-                row.recommendedDescription &&
-                row.recommendedDescription !== row.currentDescription) {
-                await updateEntryField(client, row.entryId, { description: row.recommendedDescription });
-                row.applied = 'description';
-            }
-            if (row.contentType === 'page') {
-                const entry = (await client.entry.get({ entryId: row.entryId }));
-                const existing = linkIds(entry, 'structuredData');
-                const canonical = [webPageId, websiteId];
-                if (!sameIdSet(existing, canonical)) {
-                    await linkSchemaArray(client, row.entryId, 'structuredData', canonical);
-                    row.applied = row.applied ? `${row.applied}; schema` : 'schema';
-                }
-            }
-            if (row.contentType === 'tag') {
-                const entry = (await client.entry.get({ entryId: row.entryId }));
-                const existing = linkIds(entry, 'structuredData');
-                const canonical = [collectionId];
-                if (!sameIdSet(existing, canonical)) {
-                    await linkSchemaArray(client, row.entryId, 'structuredData', canonical);
-                    row.applied = row.applied ? `${row.applied}; schema` : 'schema';
-                }
-            }
-            if (row.contentType === 'customType') {
-                const entry = (await client.entry.get({ entryId: row.entryId }));
-                const existing = linkIds(entry, 'indexPageStructuredData');
-                const canonical = [collectionId];
-                if (!sameIdSet(existing, canonical)) {
-                    await linkSchemaArray(client, row.entryId, 'indexPageStructuredData', canonical);
-                    row.applied = row.applied ? `${row.applied}; schema` : 'schema';
-                }
-            }
-            if (row.contentType === 'person') {
-                const entry = (await client.entry.get({ entryId: row.entryId }));
-                const existing = linkIds(entry, 'structuredData');
-                const canonical = [profilePageId];
-                if (!sameIdSet(existing, canonical)) {
-                    await linkSchemaArray(client, row.entryId, 'structuredData', canonical);
-                    row.applied = row.applied ? `${row.applied}; schema` : 'schema';
-                }
-            }
-        }
-        catch (error) {
-            row.applied = `error: ${error instanceof Error ? error.message : String(error)}`;
-        }
-    }
-}
-export function parseSeoAuditArgv(argv) {
-    const featuredImagesOnly = argv.includes('--featured-images-only');
-    return {
-        apply: argv.includes('--apply'),
-        sampleArticlesOnly: argv.includes('--sample-articles'),
-        featuredImages: featuredImagesOnly || argv.includes('--featured-images'),
-        featuredImagesOnly,
-    };
-}
-//# sourceMappingURL=seo-audit.js.map