@sonordev/site-kit 6.5.0 → 7.0.1

package/dist/chunk-SSUQKA7L.js

@@ -0,0 +1,746 @@
+import { getLLMsData, getOptimizedLLMsTxt } from './chunk-GLHQ3LRO.js';
+import { linkClassificationHost } from './chunk-L5UOHS6E.js';
+import { resolveArticleUrl } from './chunk-WMVK77ND.js';
+import { freshFetch } from './chunk-VX5CMNMM.js';
+import { LLM_GEO_CONTRACT_VERSION, sanitizePrimaryLanguageTag, sanitizeLlmsDisclaimerLine, sanitizeLlmsPublicSummary } from './chunk-4Y5FWDPM.js';
+import { resolveTrailingSlash, applyTrailingSlash } from './chunk-YVKRYQRG.js';
+import { resolveSiteHost } from './chunk-FESKKJAS.js';
+import { readFileSync, existsSync, mkdirSync, writeFileSync, renameSync, unlinkSync, readdirSync } from 'fs';
+import { join } from 'path';
+
+var AGENT_ACCESS_HEADING = "## Agent access";
+var DEFAULT_MCP_ENDPOINT = "/api/mcp";
+var DEFAULT_MCP_SERVER_CARD = "/.well-known/mcp-server-card";
+var absolute = (baseUrl, path) => `${baseUrl.replace(/\/+$/, "")}${path.startsWith("/") ? path : `/${path}`}`;
+function formatAgentAccessSection(baseUrl, options = {}) {
+  const endpoint = absolute(baseUrl, options.endpoint ?? DEFAULT_MCP_ENDPOINT);
+  const card = absolute(baseUrl, options.card ?? DEFAULT_MCP_SERVER_CARD);
+  const tools = (options.tools ?? []).filter(Boolean);
+  return [
+    AGENT_ACCESS_HEADING,
+    "",
+    "This site answers AI assistants directly through the Model Context Protocol, so an assistant can look things up (and, where offered, send an inquiry for someone) instead of reading pages.",
+    "",
+    `- [MCP endpoint](${endpoint}): Streamable HTTP. Call tools/list for the current tools.`,
+    `- [Server card](${card}): what the server is and how to connect.`,
+    ...tools.length ? ["", `Tools include ${tools.map((t) => `\`${t}\``).join(", ")}.`] : []
+  ].join("\n");
+}
+function appendAgentAccessSection(markdown, baseUrl, options = {}) {
+  if (!baseUrl || describesMcp(markdown)) return markdown;
+  return `${markdown.trimEnd()}
+
+---
+
+${formatAgentAccessSection(baseUrl, options)}
+`;
+}
+function describesMcp(markdown) {
+  return markdown.includes(AGENT_ACCESS_HEADING) || markdown.includes("/.well-known/mcp-server-card") || markdown.includes("/.well-known/mcp.json");
+}
+var MCP_ROUTE_FILES = ["route.ts", "route.tsx", "route.js", "route.jsx", "route.mjs"];
+var SERVER_CARD_DIRS = ["mcp-server-card", "mcp.json"];
+var BUILT_IN = /\bsonorMcp(Server|Tools)\s*\(/;
+function firstExisting(paths) {
+  return paths.find((p) => existsSync(p)) ?? null;
+}
+function mcpSourceFiles(cwd) {
+  const files = [];
+  for (const app of ["app", join("src", "app")]) {
+    for (const f of MCP_ROUTE_FILES) files.push(join(cwd, app, "api", "mcp", f));
+  }
+  for (const lib of ["lib", join("src", "lib")]) {
+    for (const ext of ["ts", "tsx", "js", "mjs"]) files.push(join(cwd, lib, `mcp.${ext}`));
+    const dir = join(cwd, lib, "mcp");
+    try {
+      for (const f of readdirSync(dir)) if (/\.(tsx?|m?js)$/.test(f) && !/\.test\./.test(f)) files.push(join(dir, f));
+    } catch {
+    }
+  }
+  return files.filter((f) => existsSync(f));
+}
+function detectMcpServer(cwd) {
+  const route = firstExisting(
+    ["app", join("src", "app")].flatMap((app) => MCP_ROUTE_FILES.map((f) => join(cwd, app, "api", "mcp", f)))
+  );
+  const card = firstExisting(
+    ["app", join("src", "app")].flatMap(
+      (app) => SERVER_CARD_DIRS.flatMap((dir) => MCP_ROUTE_FILES.map((f) => join(cwd, app, ".well-known", dir, f)))
+    )
+  );
+  if (!route && !card) return null;
+  const builtIn = mcpSourceFiles(cwd).some((f) => {
+    try {
+      return BUILT_IN.test(readFileSync(f, "utf8"));
+    } catch {
+      return false;
+    }
+  });
+  return builtIn ? "built-in" : "custom";
+}
+
+// src/llms/humanize-industry.ts
+function humanizeIndustry(industry) {
+  const spaced = industry.replace(/[_-]+/g, " ").trim();
+  if (!spaced) return industry;
+  return spaced.charAt(0).toUpperCase() + spaced.slice(1);
+}
+
+// src/llms/links.ts
+var ABSOLUTE_URL = /https?:\/\/[^\s<>()[\]"'`]+/g;
+var RELATIVE_LINK_TARGET = /\]\((\/(?!\/)[^)\s]*)/g;
+var TRAILING_PUNCTUATION = /[.,;:!?]+$/;
+function applyTrailingSlashToSiteLinks(markdown, site, trailingSlash) {
+  if (!trailingSlash || !markdown) return markdown;
+  const siteHost = site ? linkClassificationHost(site) : "";
+  let out = markdown.replace(RELATIVE_LINK_TARGET, (_match, path) => `](${applyTrailingSlash(path, true)}`);
+  if (!siteHost) return out;
+  out = out.replace(ABSOLUTE_URL, (raw) => {
+    const punctuation = raw.match(TRAILING_PUNCTUATION)?.[0] ?? "";
+    const url = punctuation ? raw.slice(0, -punctuation.length) : raw;
+    const match = /^(https?:\/\/[^/?#]+)(.*)$/.exec(url);
+    if (!match || linkClassificationHost(match[1]) !== siteHost) return raw;
+    const [, origin, rest] = match;
+    if (!rest.startsWith("/")) return raw;
+    return `${origin}${applyTrailingSlash(rest, true)}${punctuation}`;
+  });
+  return out;
+}
+
+// src/llms/generateLLMsTxt.ts
+function mergeLlmsMeta(fallback, primary) {
+  if (!primary && !fallback) return void 0;
+  if (!primary) return fallback ?? void 0;
+  if (!fallback) return primary;
+  return {
+    contract_version: primary.contract_version ?? fallback.contract_version,
+    last_updated: primary.last_updated ?? fallback.last_updated ?? null,
+    primary_language: primary.primary_language ?? fallback.primary_language ?? null,
+    llms_disclaimer: primary.llms_disclaimer ?? fallback.llms_disclaimer ?? null
+  };
+}
+function resolveBaseUrl(optionBaseUrl, businessWebsite) {
+  const candidate = optionBaseUrl || businessWebsite || process.env.NEXT_PUBLIC_SITE_URL || process.env.SITE_URL || "";
+  return candidate.trim().replace(/\/+$/, "");
+}
+function mergeLLMsData(portal, local) {
+  if (!local) return portal;
+  if (!portal) return local;
+  return {
+    meta: mergeLlmsMeta(local.meta, portal.meta),
+    business: portal.business ?? local.business,
+    contact: portal.contact ?? local.contact,
+    services: (portal.services?.length ? portal.services : local.services) ?? [],
+    faq: (portal.faq?.length ? portal.faq : local.faq) ?? [],
+    pages: (portal.pages?.length ? portal.pages : local.pages) ?? [],
+    portfolio: (portal.portfolio?.length ? portal.portfolio : local.portfolio) ?? []
+  };
+}
+async function generateLLMsTxt(options) {
+  const {
+    projectId,
+    baseUrl: baseUrlOption,
+    site,
+    trailingSlash: trailingSlashOption,
+    getLocalData,
+    includeBusinessInfo = true,
+    includeServices = true,
+    includeFAQ = true,
+    includePages = true,
+    includeContact = true,
+    includePortfolio = true,
+    includeEntities = true,
+    maxFAQItems = 20,
+    maxPages = 50,
+    maxPortfolioItems = 20,
+    maxEntities = 50,
+    maxArticlesPerCluster = 5,
+    publication = {},
+    customSections = [],
+    optionalPagePaths = [],
+    linkToFullLlms = false,
+    fullLlmsTxtPath = "/llms-full.txt",
+    pageListNotesFromPublicSummaryOnly = false,
+    headerPrimaryLanguage,
+    headerDisclaimer,
+    fresh = false
+  } = options;
+  const readFetch = fresh ? freshFetch : fetch;
+  let data = await getLLMsData(projectId, site, fresh);
+  const useLocal = getLocalData && (!data || !data.services?.length);
+  if (useLocal && getLocalData) {
+    try {
+      const local = await getLocalData();
+      data = mergeLLMsData(data ?? null, local);
+    } catch (err) {
+      console.warn("[site-kit] getLocalData failed:", err);
+    }
+  }
+  if (!data) {
+    return {
+      markdown: "# Website\n\n> Information not available.",
+      metadata: {
+        generated_at: (/* @__PURE__ */ new Date()).toISOString(),
+        project_id: projectId || "",
+        sections: []
+      }
+    };
+  }
+  const headerMeta = buildHeaderMeta(
+    data.meta,
+    headerPrimaryLanguage,
+    headerDisclaimer
+  );
+  const baseUrl = resolveBaseUrl(baseUrlOption, data.business?.website);
+  const trailingSlash = resolveTrailingSlash(trailingSlashOption);
+  const sections = [];
+  const sectionNames = [];
+  const attemptedSections = [];
+  const failedSections = [];
+  if (includeBusinessInfo && data.business) {
+    const header = generateHeaderSection(data.business, headerMeta, baseUrl);
+    sections.push(header);
+    sectionNames.push("header");
+  }
+  if (includeBusinessInfo && data.business?.description) {
+    const about = generateAboutSection(data.business);
+    sections.push(about);
+    sectionNames.push("about");
+  }
+  if (includeServices && data.services?.length > 0) {
+    const services = generateServicesSection(data.services);
+    sections.push(services);
+    sectionNames.push("services");
+  }
+  if (includePortfolio) {
+    let portfolioItems = data.portfolio || [];
+    if (portfolioItems.length === 0) {
+      attemptedSections.push("portfolio");
+      try {
+        const apiUrl = process.env.SONOR_API_URL || "https://api.sonor.io";
+        const apiKey = process.env.SONOR_API_KEY || "";
+        if (apiKey) {
+          const response = await readFetch(`${apiUrl}/api/public/portfolio/items`, {
+            method: "GET",
+            headers: {
+              "Content-Type": "application/json",
+              "x-api-key": apiKey
+            }
+          });
+          if (response.ok) {
+            const result = await response.json();
+            const items = result?.portfolioItems || result?.items || result || [];
+            portfolioItems = items.filter((item) => item.status === "published");
+          }
+        }
+      } catch (err) {
+        console.warn("[site-kit/llms] Portfolio section failed:", err);
+        failedSections.push("portfolio");
+      }
+    }
+    if (portfolioItems.length > 0) {
+      const portfolio = generatePortfolioSection(
+        portfolioItems.slice(0, maxPortfolioItems),
+        baseUrl
+      );
+      sections.push(portfolio);
+      sectionNames.push("portfolio");
+    }
+  }
+  if (includeContact && data.contact) {
+    const contact = generateContactSection(data.contact);
+    sections.push(contact);
+    sectionNames.push("contact");
+  }
+  if (includeFAQ && data.faq?.length > 0) {
+    const faq = generateFAQSection(data.faq.slice(0, maxFAQItems));
+    sections.push(faq);
+    sectionNames.push("faq");
+  }
+  const renderOptional = optionalPagePaths.length > 0 && Boolean(baseUrl);
+  const optionalKeys = renderOptional ? new Set(optionalPagePaths.map(normalizeLlmsPagePath)) : null;
+  const indexPages = optionalKeys ? (data.pages ?? []).filter((p) => !optionalKeys.has(normalizeLlmsPagePath(p.path))) : data.pages ?? [];
+  if (includePages && indexPages.length > 0) {
+    const pages = generatePagesSection(
+      indexPages.slice(0, maxPages),
+      baseUrl,
+      pageListNotesFromPublicSummaryOnly
+    );
+    sections.push(pages);
+    sectionNames.push("pages");
+  }
+  if (renderOptional) {
+    const opt = generateOptionalPagesSection(
+      optionalPagePaths,
+      data.pages || [],
+      baseUrl,
+      pageListNotesFromPublicSummaryOnly,
+      trailingSlash
+    );
+    if (opt) {
+      sections.push(opt);
+      sectionNames.push("optional");
+    }
+  }
+  if (linkToFullLlms && baseUrl) {
+    const fullPath = fullLlmsTxtPath.startsWith("/") ? fullLlmsTxtPath : `/${fullLlmsTxtPath}`;
+    const fullUrl = fullPath.startsWith("http") ? fullPath : `${baseUrl}${fullPath}`;
+    sections.push(
+      `## Full context
+
+- [llms-full.txt](${fullUrl}): Expanded page index and FAQ for large-context systems.`
+    );
+    sectionNames.push("full-context");
+  }
+  {
+    const optionalFetches = [];
+    if (includeEntities) {
+      attemptedSections.push("knowledge-graph");
+      optionalFetches.push(
+        import('./server-api-GJJQZVG7.js').then(async ({ getEntities, getPrimaryEntity }) => {
+          const [entities, primaryEntity] = await Promise.all([
+            getEntities().then((e) => e.slice(0, maxEntities)),
+            getPrimaryEntity()
+          ]);
+          return { kind: "entities", entities, primaryEntity };
+        }).catch((err) => {
+          console.warn("[site-kit/llms] Knowledge graph section failed:", err);
+          failedSections.push("knowledge-graph");
+          return null;
+        })
+      );
+    }
+    attemptedSections.push("topic-clusters");
+    optionalFetches.push(
+      import('./articles/server.js').then(async ({ getTopicClusters }) => {
+        const clusters = await getTopicClusters({ site });
+        return { kind: "clusters", clusters };
+      }).catch((err) => {
+        console.warn("[site-kit/llms] Topic clusters section failed:", err);
+        failedSections.push("topic-clusters");
+        return null;
+      })
+    );
+    const settled = await Promise.all(optionalFetches);
+    for (const result of settled) {
+      if (!result) continue;
+      if (result.kind === "entities") {
+        if (result.entities.length > 0 || result.primaryEntity) {
+          const entitySection = generateEntitySection(result.entities, result.primaryEntity);
+          sections.push(entitySection);
+          sectionNames.push("knowledge-graph");
+        }
+      }
+      if (result.kind === "clusters" && result.clusters.length > 0) {
+        const clusterLines = ["## Topic Clusters", ""];
+        clusterLines.push("Organized content collections providing comprehensive coverage of key topics.", "");
+        for (const cluster of result.clusters) {
+          clusterLines.push(`### ${cluster.cluster_name}`);
+          clusterLines.push(`Topic: ${cluster.core_topic}`);
+          if (cluster.geo_target) clusterLines.push(`Area: ${cluster.geo_target}`);
+          clusterLines.push(`Articles: ${cluster.article_count}`);
+          if (cluster.target_service_page) {
+            clusterLines.push(`Service page: ${baseUrl}${cluster.target_service_page}`);
+          }
+          if (cluster.pillar) {
+            const pillarUrl = cluster.pillar.slug ? resolveArticleUrl(cluster.pillar, { ...publication, siteUrl: baseUrl }) : "";
+            clusterLines.push(`Pillar: [${cluster.pillar.title || cluster.cluster_name}](${pillarUrl})`);
+          }
+          const supports = cluster.supports || [];
+          if (supports.length > 0) {
+            const sorted = [...supports].sort((a, b) => (b.published_at || "").localeCompare(a.published_at || "")).slice(0, maxArticlesPerCluster);
+            for (const article of sorted) {
+              const articleUrl = article.slug ? resolveArticleUrl(article, { ...publication, siteUrl: baseUrl }) : "";
+              const dateStr = article.published_at ? ` (${new Date(article.published_at).toLocaleDateString("en-US", { month: "short", day: "numeric", year: "numeric" })})` : "";
+              clusterLines.push(`- [${article.title}](${articleUrl})${dateStr}`);
+            }
+          }
+          clusterLines.push("");
+        }
+        sections.push(clusterLines.join("\n"));
+        sectionNames.push("topic-clusters");
+      }
+    }
+  }
+  if (options.mcp && baseUrl) {
+    sections.push(formatAgentAccessSection(baseUrl, options.mcp === true ? {} : options.mcp));
+    sectionNames.push("agent-access");
+  }
+  for (const custom of customSections) {
+    sections.push(`## ${custom.title}
+
+${custom.content}`);
+    sectionNames.push(custom.title.toLowerCase().replace(/\s+/g, "-"));
+  }
+  return {
+    // Every own-site link (pages, clusters, portfolio, custom sections) takes
+    // the site's trailing-slash shape in one pass.
+    markdown: applyTrailingSlashToSiteLinks(sections.join("\n\n---\n\n"), baseUrl, trailingSlash),
+    metadata: {
+      generated_at: (/* @__PURE__ */ new Date()).toISOString(),
+      project_id: projectId || "",
+      sections: sectionNames,
+      attempted_sections: attemptedSections.length ? attemptedSections : void 0,
+      failed_sections: failedSections.length ? failedSections : void 0
+    }
+  };
+}
+async function generateLLMsFullTxt(options) {
+  return generateLLMsTxt({
+    ...options,
+    includeBusinessInfo: true,
+    includeServices: true,
+    includeFAQ: true,
+    includePages: true,
+    includeContact: true,
+    includePortfolio: true,
+    includeEntities: true,
+    maxFAQItems: 100,
+    maxPages: 200,
+    maxPortfolioItems: 50,
+    maxEntities: 200
+  });
+}
+function buildHeaderMeta(base, primaryLanguageOverride, disclaimerOverride) {
+  if (primaryLanguageOverride === void 0 && disclaimerOverride === void 0) {
+    return base ?? void 0;
+  }
+  const merged = {
+    contract_version: base?.contract_version ?? LLM_GEO_CONTRACT_VERSION,
+    last_updated: base?.last_updated ?? null,
+    primary_language: base?.primary_language ?? null,
+    llms_disclaimer: base?.llms_disclaimer ?? null
+  };
+  if (primaryLanguageOverride !== void 0) {
+    const pl = sanitizePrimaryLanguageTag(primaryLanguageOverride);
+    merged.primary_language = pl ?? merged.primary_language;
+  }
+  if (disclaimerOverride !== void 0) {
+    const d = sanitizeLlmsDisclaimerLine(disclaimerOverride);
+    merged.llms_disclaimer = d ?? merged.llms_disclaimer;
+  }
+  return merged;
+}
+function generateHeaderSection(business, meta, resolvedBaseUrl) {
+  const lines = [];
+  lines.push(`# ${business.name}`);
+  lines.push("");
+  const summary = business.tagline || business.description?.split(".")[0] || business.name;
+  lines.push(`> ${summary}`);
+  if (meta?.last_updated) {
+    lines.push(`> Content index last updated: ${meta.last_updated}`);
+  }
+  if (meta?.primary_language) {
+    lines.push(`> Primary language: ${meta.primary_language}`);
+  }
+  if (meta?.llms_disclaimer) {
+    lines.push(`> ${meta.llms_disclaimer}`);
+  }
+  if (business.industry) {
+    lines.push("");
+    lines.push(`**Industry:** ${humanizeIndustry(business.industry)}`);
+  }
+  if (business.service_area) {
+    lines.push(`**Service Area:** ${business.service_area}`);
+  }
+  const website = business.website || resolvedBaseUrl;
+  if (website) {
+    lines.push(`**Website:** ${website}`);
+  }
+  return lines.join("\n");
+}
+function generateAboutSection(business) {
+  const lines = [];
+  lines.push("## About");
+  lines.push("");
+  lines.push(business.description);
+  if (business.founded) {
+    lines.push("");
+    lines.push(`Established: ${business.founded}`);
+  }
+  return lines.join("\n");
+}
+function generateServicesSection(services) {
+  const lines = [];
+  lines.push("## Services");
+  lines.push("");
+  for (const service of services) {
+    if (service.url) {
+      lines.push(`- **[${service.name}](${service.url})**: ${service.description}`);
+    } else {
+      lines.push(`- **${service.name}**: ${service.description}`);
+    }
+  }
+  return lines.join("\n");
+}
+function generatePortfolioSection(items, baseUrl) {
+  const lines = [];
+  lines.push("## Portfolio & Case Studies");
+  lines.push("");
+  for (const item of items) {
+    const url = item.live_url || (item.slug ? `${baseUrl}/portfolio/${item.slug}` : "");
+    if (url) {
+      lines.push(`### [${item.title}](${url})`);
+    } else {
+      lines.push(`### ${item.title}`);
+    }
+    lines.push("");
+    if (item.description) {
+      lines.push(item.description);
+      lines.push("");
+    }
+    const meta = [];
+    if (item.category) {
+      meta.push(`**Category:** ${item.category}`);
+    }
+    if (item.services?.length) {
+      meta.push(`**Services:** ${item.services.join(", ")}`);
+    }
+    if (item.live_url) {
+      meta.push(`**Live Site:** ${item.live_url}`);
+    }
+    if (meta.length > 0) {
+      lines.push(meta.join(" | "));
+      lines.push("");
+    }
+  }
+  return lines.join("\n").trim();
+}
+function generateContactSection(contact) {
+  const lines = [];
+  lines.push("## Contact Information");
+  lines.push("");
+  if (contact.phone) {
+    lines.push(`- **Phone:** ${contact.phone}`);
+  }
+  if (contact.email) {
+    lines.push(`- **Email:** ${contact.email}`);
+  }
+  if (contact.address || contact.city) {
+    const addressParts = [
+      contact.address,
+      contact.city,
+      contact.state,
+      contact.postal_code,
+      contact.country
+    ].filter(Boolean);
+    lines.push(`- **Address:** ${addressParts.join(", ")}`);
+  }
+  if (contact.hours) {
+    lines.push(`- **Hours:** ${contact.hours}`);
+  }
+  return lines.join("\n");
+}
+function generateFAQSection(faq) {
+  const lines = [];
+  lines.push("## Frequently Asked Questions");
+  lines.push("");
+  for (const item of faq) {
+    lines.push(`### ${item.question}`);
+    lines.push("");
+    lines.push(item.answer);
+    lines.push("");
+  }
+  return lines.join("\n").trim();
+}
+function pageListNote(page, publicSummaryOnly) {
+  const pub = sanitizeLlmsPublicSummary(page.llms_public_summary);
+  if (pub) return pub;
+  if (publicSummaryOnly) return void 0;
+  if (page.description) return page.description.replace(/[\[\]\r\n]/g, " ").trim();
+  return void 0;
+}
+function normalizeLlmsPagePath(path) {
+  const withLeading = path.startsWith("/") ? path : `/${path}`;
+  return withLeading.replace(/\/$/, "") || "/";
+}
+function formatPageLine(page, baseUrl, publicSummaryOnly) {
+  const url = page.path.startsWith("http") ? page.path : `${baseUrl}${page.path}`;
+  const note = pageListNote(page, publicSummaryOnly);
+  return note ? `- [${page.title}](${url}): ${note}` : `- [${page.title}](${url})`;
+}
+function generatePagesSection(pages, baseUrl, publicSummaryOnly) {
+  const lines = [];
+  lines.push("## Site Pages");
+  lines.push("");
+  for (const page of pages) {
+    lines.push(formatPageLine(page, baseUrl, publicSummaryOnly));
+  }
+  return lines.join("\n");
+}
+function generateOptionalPagesSection(paths, pages, baseUrl, publicSummaryOnly, trailingSlash) {
+  const byPath = /* @__PURE__ */ new Map();
+  for (const page of pages) {
+    const key = normalizeLlmsPagePath(page.path);
+    if (!byPath.has(key)) byPath.set(key, page);
+  }
+  const lines = ["## Optional", ""];
+  const seen = /* @__PURE__ */ new Set();
+  for (const raw of paths) {
+    const key = normalizeLlmsPagePath(raw);
+    if (seen.has(key)) continue;
+    seen.add(key);
+    const match = byPath.get(key);
+    if (match) {
+      lines.push(formatPageLine(match, baseUrl, publicSummaryOnly));
+      continue;
+    }
+    const title = key.split("/").filter(Boolean).pop() || key;
+    lines.push(`- [${title}](${baseUrl}${applyTrailingSlash(key, trailingSlash)})`);
+  }
+  return seen.size > 0 ? lines.join("\n") : null;
+}
+function generateEntitySection(entities, primaryEntity, detailed) {
+  const lines = [];
+  lines.push("## Knowledge Graph");
+  lines.push("");
+  if (primaryEntity) {
+    lines.push(`### ${primaryEntity.name} (Primary)`);
+    lines.push("");
+    lines.push(`- **Type:** ${primaryEntity.entity_type}`);
+    if (primaryEntity.schema_type) {
+      lines.push(`- **Schema:** ${primaryEntity.schema_type}`);
+    }
+    lines.push("");
+  }
+  const grouped = /* @__PURE__ */ new Map();
+  for (const entity of entities) {
+    if (primaryEntity && entity.id === primaryEntity.id) continue;
+    const type = entity.entity_type;
+    if (!grouped.has(type)) grouped.set(type, []);
+    grouped.get(type).push(entity);
+  }
+  for (const [type, group] of grouped) {
+    const label = type.charAt(0).toUpperCase() + type.slice(1) + "s";
+    lines.push(`### ${label}`);
+    lines.push("");
+    for (const entity of group) {
+      {
+        lines.push(`- ${entity.name}`);
+      }
+    }
+    lines.push("");
+  }
+  return lines.join("\n").trim();
+}
+
+// src/llms/writeLLMsTxt.ts
+async function writeLLMsTxtToPublic(options = {}) {
+  const {
+    outputDir = "public",
+    full = false,
+    apiUrl,
+    apiKey,
+    fallbackToLocal = true,
+    site,
+    publication,
+    trailingSlash: trailingSlashOption,
+    getLocalData,
+    publicSummaryOnly,
+    customSections,
+    mcp: mcpOption
+  } = options;
+  const trailingSlash = resolveTrailingSlash(trailingSlashOption);
+  const linkHost = resolveSiteHost(site);
+  const cwd = typeof process !== "undefined" ? process.cwd() : ".";
+  const mcp = mcpOption ?? detectMcpServer(cwd) === "built-in";
+  const siteOrigin = process.env.NEXT_PUBLIC_SITE_URL || (linkHost ? `https://${linkHost}` : "");
+  const withAgentAccess = (md) => mcp ? appendAgentAccessSection(md, siteOrigin, mcp === true ? {} : mcp) : md;
+  const shapeLinks = (md) => applyTrailingSlashToSiteLinks(withAgentAccess(md), linkHost, trailingSlash);
+  const outPath = join(cwd, outputDir);
+  const llmsPath = join(outPath, "llms.txt");
+  const llmsFullPath = join(outPath, "llms-full.txt");
+  if (!existsSync(outPath)) {
+    mkdirSync(outPath, { recursive: true });
+  }
+  const apiOptions = { apiUrl, apiKey, publicSummaryOnly, site };
+  const genOpts = {
+    site,
+    publication,
+    trailingSlash,
+    getLocalData,
+    pageListNotesFromPublicSummaryOnly: !!publicSummaryOnly,
+    // This writes a file that outlives the build, so every Sonor read behind
+    // it bypasses Next's Data Cache (getOptimizedLLMsTxt always does).
+    fresh: true
+  };
+  let markdown = toWritableMarkdown(await getOptimizedLLMsTxt({ ...apiOptions, full: false }));
+  let optimized = !!markdown;
+  if (!markdown && fallbackToLocal) {
+    console.warn("[site-kit] Optimized llms.txt unavailable, using local generation");
+    const result = await generateLLMsTxt(genOpts);
+    markdown = toWritableMarkdown(result.markdown, result.metadata);
+  }
+  if (!markdown) {
+    console.warn(
+      `[site-kit] llms.txt unavailable (Portal fetch failed, no local data) \u2014 skipped write, keeping any existing file at ${llmsPath}`
+    );
+    return { success: false, path: llmsPath, optimized: false };
+  }
+  atomicWriteSync(llmsPath, shapeLinks(markdown));
+  console.log(`[site-kit] Wrote llms.txt to ${llmsPath}`);
+  if (full) {
+    const sections = await resolveCustomSections(customSections);
+    let fullMarkdown = toWritableMarkdown(await getOptimizedLLMsTxt({ ...apiOptions, full: true }));
+    if (fullMarkdown && sections.length > 0) {
+      fullMarkdown = appendCustomSections(fullMarkdown, sections);
+    }
+    if (!fullMarkdown && fallbackToLocal) {
+      const result = await generateLLMsFullTxt({ ...genOpts, customSections: sections });
+      fullMarkdown = toWritableMarkdown(result.markdown, result.metadata);
+    }
+    if (fullMarkdown) {
+      atomicWriteSync(llmsFullPath, shapeLinks(fullMarkdown));
+      console.log(`[site-kit] Wrote llms-full.txt to ${llmsFullPath}`);
+    } else {
+      console.warn(
+        `[site-kit] llms-full.txt unavailable \u2014 skipped write, keeping any existing file at ${llmsFullPath}`
+      );
+    }
+  }
+  return { success: true, path: llmsPath, optimized };
+}
+function toWritableMarkdown(markdown, metadata) {
+  if (!markdown || !markdown.trim()) return null;
+  if (metadata && metadata.sections.length === 0) return null;
+  return markdown;
+}
+async function resolveCustomSections(input) {
+  if (!input) return [];
+  try {
+    const raw = typeof input === "function" ? await input() : input;
+    if (!Array.isArray(raw)) return [];
+    return raw.filter(
+      (s) => !!s && typeof s.title === "string" && !!s.title.trim() && typeof s.content === "string" && !!s.content.trim()
+    );
+  } catch (err) {
+    console.warn("[site-kit] llms customSections factory failed \u2014 sections skipped:", err);
+    return [];
+  }
+}
+function appendCustomSections(markdown, sections) {
+  const blocks = sections.map((s) => `## ${s.title}
+
+${s.content}`);
+  return `${markdown.replace(/\s+$/, "")}
+
+---
+
+${blocks.join("\n\n---\n\n")}
+`;
+}
+function atomicWriteSync(filePath, content) {
+  const tmp = `${filePath}.tmp`;
+  try {
+    writeFileSync(tmp, content, "utf-8");
+    renameSync(tmp, filePath);
+  } catch (err) {
+    try {
+      unlinkSync(tmp);
+    } catch {
+    }
+    throw err;
+  }
+}
+
+export { AGENT_ACCESS_HEADING, appendAgentAccessSection, describesMcp, detectMcpServer, formatAgentAccessSection, generateLLMsFullTxt, generateLLMsTxt, writeLLMsTxtToPublic };