blume 1.7.3 → 2.0.1

package/src/upgrade/upgrade.ts

@@ -0,0 +1,499 @@
+import { existsSync } from "node:fs";
+import { readFile, writeFile } from "node:fs/promises";
+
+import { join, relative, resolve } from "pathe";
+import { glob } from "tinyglobby";
+import { z } from "zod";
+
+import {
+  analyzeComponentOverrides,
+  ComponentOverridesError,
+} from "../core/component-overrides.ts";
+import { ConfigValidationError, loadConfig } from "../core/config.ts";
+import { BlumeError, locateFrontmatterKey } from "../core/diagnostics.ts";
+import matter from "../core/frontmatter.ts";
+import { createModuleLoader } from "../core/load-module.ts";
+import { findComponentsFile, findConfigFile } from "../core/project.ts";
+import { pageMetaSchema } from "../core/schema.ts";
+import { baselineScanIgnore } from "../core/sources/watch.ts";
+import type { Diagnostic } from "../core/types.ts";
+import {
+  DEFAULT_CONTENT_EXCLUDE,
+  DEFAULT_CONTENT_INCLUDE,
+} from "../sources/filesystem.ts";
+
+/**
+ * `blume upgrade`'s logic, kept out of the command module so it runs (and is
+ * covered) in-process: bump the `blume` dependency to the running CLI's major,
+ * then check the project against it — the config through the same loader
+ * every command uses, which names each removed or renamed field and its
+ * replacement, `components.ts` through the same static planner the build
+ * runs, and each page's front matter for fields the schema removed. The
+ * command prints the findings or hands them to a coding agent.
+ */
+
+/** The upgrade guide's route on the Blume docs site. */
+export const UPGRADE_GUIDE_URL = "https://useblume.dev/docs/upgrading";
+
+/** The upgrade guide's file inside the published package's bundled docs. */
+export const UPGRADE_GUIDE_FILE = join("docs", "03-upgrading.mdx");
+
+/** What `bumpBlumeDependency` did to `package.json`. */
+export type DependencyBump =
+  | {
+      field: DependencyField;
+      from: string;
+      status: "bumped";
+      to: string;
+    }
+  | { range: string; status: "current" }
+  | { status: "missing" };
+
+type DependencyField = "dependencies" | "devDependencies";
+
+const DEPENDENCY_FIELDS: DependencyField[] = [
+  "dependencies",
+  "devDependencies",
+];
+
+/** The slice of `package.json` the bump reads and rewrites. */
+interface PackageJson {
+  dependencies?: Record<string, string>;
+  devDependencies?: Record<string, string>;
+}
+
+// Leading comparators and a `v` may precede the major (`^1.7.3`, `>=1 <2`,
+// `v1`); a protocol (`workspace:`, `file:`, `npm:`) or a tag (`latest`) names
+// no major at all, and those ranges are left to the user.
+const RANGE_MAJOR = /^[\s<=>^~v]*(?<major>\d+)/u;
+
+/** The major version a dependency range pins, or null when it names none. */
+export const rangeMajor = (range: string): number | null => {
+  const major = RANGE_MAJOR.exec(range)?.groups?.major;
+  return major === undefined ? null : Number(major);
+};
+
+// The file's own indentation (two spaces, four, or a tab), so a fallback
+// rewrite doesn't reformat a package.json the user keeps differently.
+const INDENT = /^(?<indent>[ \t]+)"/mu;
+
+const REGEXP_SPECIAL = /[$()*+.?[\\\]^{|}]/gu;
+const escapeRegExp = (value: string): string =>
+  value.replaceAll(REGEXP_SPECIAL, String.raw`\$&`);
+
+/**
+ * `text` with the `blume` range under `field` replaced in place, so the file
+ * keeps its own formatting, key order, and inline objects; null when the entry
+ * isn't written the plain way (an escaped key or value).
+ */
+const replaceRange = (
+  text: string,
+  field: DependencyField,
+  from: string,
+  to: string
+): string | null => {
+  const value = JSON.stringify(from);
+  const entry = new RegExp(`"blume"\\s*:\\s*${escapeRegExp(value)}`, "gu");
+  entry.lastIndex = Math.max(text.indexOf(JSON.stringify(field)), 0);
+  const match = entry.exec(text);
+  if (!match) {
+    return null;
+  }
+  const end = match.index + match[0].length;
+  return `${text.slice(0, end - value.length)}${JSON.stringify(to)}${text.slice(end)}`;
+};
+
+/**
+ * Point `package.json`'s `blume` dependency at `^version` when it pins an
+ * older major. A range already on this major, or one that names no version
+ * (`workspace:*`, `latest`), is reported as current and left alone; a
+ * project with no `package.json`, or none that lists `blume`, is `missing`.
+ * Only the range changes: the rest of the file is kept byte for byte.
+ */
+export const bumpBlumeDependency = async (
+  root: string,
+  version: string
+): Promise<DependencyBump> => {
+  const path = join(root, "package.json");
+  if (!existsSync(path)) {
+    return { status: "missing" };
+  }
+  const text = await readFile(path, "utf-8");
+  // SAFETY: package.json is a JSON object; only its dependency maps, which
+  // map package names to range strings, are read.
+  const pkg = JSON.parse(text) as PackageJson;
+  const field = DEPENDENCY_FIELDS.find(
+    (name) => pkg[name]?.blume !== undefined
+  );
+  const from = field ? pkg[field]?.blume : undefined;
+  if (!(field && from)) {
+    return { status: "missing" };
+  }
+  const current = rangeMajor(from);
+  const target = rangeMajor(version);
+  if (current === null || target === null || current >= target) {
+    return { range: from, status: "current" };
+  }
+  const to = `^${version}`;
+  const indent = INDENT.exec(text)?.groups?.indent ?? "  ";
+  const updated = { ...pkg, [field]: { ...pkg[field], blume: to } };
+  await writeFile(
+    path,
+    replaceRange(text, field, from, to) ??
+      `${JSON.stringify(updated, null, indent)}\n`
+  );
+  return { field, from, status: "bumped", to };
+};
+
+/**
+ * Whether `root` is no Blume project at all: no config file and no `blume`
+ * dependency, so the upgrade would only check the defaults and report the
+ * folder ready. A zero-config project still lists `blume`.
+ */
+export const isOutsideBlumeProject = (
+  root: string,
+  bump: DependencyBump
+): boolean => bump.status === "missing" && findConfigFile(root) === null;
+
+// ---------------------------------------------------------------------------
+// Removed `blume build` flags
+// ---------------------------------------------------------------------------
+
+/** A `blume build` flag Blume 2 removed, bare or with an `=value`. */
+const REMOVED_BUILD_FLAG = /^--(?<flag>adapter|base|output)(?:=|$)/u;
+
+/** The removed `blume build` flags among `args`, in order, each once. */
+export const removedBuildFlags = (args: readonly string[]): string[] => [
+  ...new Set(
+    args.flatMap((arg) => {
+      const flag = REMOVED_BUILD_FLAG.exec(arg)?.groups?.flag;
+      return flag ? [flag] : [];
+    })
+  ),
+];
+
+/** The flags as the reader typed them: `--adapter, --output`. */
+export const flagList = (flags: string[]): string =>
+  flags.map((flag) => `--${flag}`).join(", ");
+
+/** What replaces each removed flag: the `deployment` config. */
+export const removedBuildFlagsAdvice = (flags: string[]): string => {
+  const advice: string[] = [];
+  if (flags.includes("adapter") || flags.includes("output")) {
+    advice.push(
+      'name the host in blume.config.ts with `deployment: vercel()` (or `netlify()`, `cloudflare()`, `node()`) from "blume/deploy" — a host adapter builds for the server, and `output: "static"` keeps it static'
+    );
+  }
+  if (flags.includes("base")) {
+    advice.push(
+      'set the subpath with `deployment: { base: "/docs" }`, or the host adapter\'s `base` option'
+    );
+  }
+  return `Drop ${flagList(flags)} and ${advice.join("; ")}.`;
+};
+
+// A command that runs the Blume CLI: the bare bin, a versioned package
+// (`blume@2`), or a path to it (`./node_modules/.bin/blume`).
+const BLUME_BIN = /(?:^|[/\\])blume(?:@\S+)?$/u;
+const COMMAND_SEPARATOR = /&&|\|\||[;|]/u;
+const WHITESPACE = /\s+/u;
+
+/** The arguments each `blume build` in a script passes, flattened. */
+const buildArgs = (script: string): string[] =>
+  script.split(COMMAND_SEPARATOR).flatMap((command) => {
+    const words = command.trim().split(WHITESPACE);
+    const at = words.findIndex(
+      (word, index) => BLUME_BIN.test(word) && words[index + 1] === "build"
+    );
+    return at === -1 ? [] : words.slice(at + 2);
+  });
+
+/** The slice of package.json the script check reads. */
+const scriptsSchema = z.looseObject({
+  scripts: z.record(z.string(), z.string()).default({}),
+});
+
+const lineOf = (text: string, index: number): number =>
+  text.slice(0, index).split("\n").length;
+
+/**
+ * A finding for each package.json script that still passes a removed flag to
+ * `blume build` — it would otherwise build a static site without a word.
+ */
+const scriptFindings = async (root: string): Promise<Diagnostic[]> => {
+  const path = join(root, "package.json");
+  if (!existsSync(path)) {
+    return [];
+  }
+  const text = await readFile(path, "utf-8");
+  const pkg = scriptsSchema.safeParse(JSON.parse(text));
+  const scripts = pkg.success ? pkg.data.scripts : {};
+  const scriptsAt = text.indexOf('"scripts"');
+  return Object.entries(scripts).flatMap(([name, script]) => {
+    const flags = removedBuildFlags(buildArgs(script));
+    if (flags.length === 0) {
+      return [];
+    }
+    const at = text.indexOf(JSON.stringify(name), scriptsAt);
+    return [
+      {
+        code: "BLUME_BUILD_FLAG_REMOVED",
+        file: path,
+        line: at === -1 ? undefined : lineOf(text, at),
+        message: `The "${name}" script passes ${flagList(flags)} to \`blume build\`, which Blume 2 removed.`,
+        severity: "error",
+        suggestion: removedBuildFlagsAdvice(flags),
+      } satisfies Diagnostic,
+    ];
+  });
+};
+
+// ---------------------------------------------------------------------------
+// Removed front matter fields
+// ---------------------------------------------------------------------------
+
+/** Where a project's local content lives, as its config names it. */
+interface ContentGlobs {
+  exclude: string[];
+  include: string[];
+  root: string;
+}
+
+const globFields = {
+  exclude: z.array(z.string()).optional(),
+  include: z.array(z.string()).optional(),
+  root: z.string().optional(),
+};
+
+/**
+ * A filesystem source in either form a config being upgraded may hold: the
+ * `filesystem()` descriptor, or Blume 1's `{ type: "filesystem" }` object.
+ */
+const rawFilesystemSourceSchema = z.union([
+  z
+    .looseObject({
+      kind: z.literal("filesystem"),
+      options: z.looseObject(globFields).default({}),
+    })
+    .transform((source) => source.options),
+  z.looseObject({ type: z.literal("filesystem"), ...globFields }),
+]);
+
+/** The `content` slice of a config as written, before validation. */
+const rawContentSchema = z.looseObject({
+  content: z
+    .looseObject({ ...globFields, sources: z.array(z.unknown()).optional() })
+    .optional(),
+});
+
+/**
+ * The content roots to scan, read from the config as written rather than the
+ * validated config: the upgrade runs on configs that don't validate yet. Its
+ * filesystem sources when it lists any, else the `content.root` shorthand,
+ * else the zero-config `docs` folder.
+ */
+export const contentGlobs = ({
+  content,
+}: z.infer<typeof rawContentSchema>): ContentGlobs[] => {
+  const sources = (content?.sources ?? []).flatMap((source) => {
+    const filesystem = rawFilesystemSourceSchema.safeParse(source);
+    return filesystem.success ? [filesystem.data] : [];
+  });
+  return (sources.length > 0 ? sources : [content ?? {}]).map((globs) => ({
+    exclude: globs.exclude ?? DEFAULT_CONTENT_EXCLUDE,
+    include: globs.include ?? DEFAULT_CONTENT_INCLUDE,
+    root: globs.root ?? "docs",
+  }));
+};
+
+/** The content roots the project's config names, loaded as written. */
+const configContentGlobs = async (root: string): Promise<ContentGlobs[]> => {
+  const file = findConfigFile(root);
+  let raw: z.infer<typeof rawContentSchema> = {};
+  if (file) {
+    try {
+      const parsed = rawContentSchema.safeParse(
+        await createModuleLoader()(file)
+      );
+      raw = parsed.success ? parsed.data : {};
+    } catch {
+      // A config that won't load is already reported by the config check;
+      // its content still gets the zero-config scan.
+    }
+  }
+  return contentGlobs(raw);
+};
+
+const isPathKey = (segment: PropertyKey): segment is number | string =>
+  typeof segment !== "symbol";
+
+// Zod's own wording for an unknown key; a removed field's hint replaces it.
+const PLAIN_UNKNOWN_KEY = "Unrecognized key";
+
+/**
+ * The removed fields among one page's front matter issues, each at its own
+ * line. Only issues the page schema words as a removed-field hint count: a
+ * key a project declares through `frontmatter.extend` is unknown to the bare
+ * schema, and any other invalid value was already an error on Blume 1.
+ */
+const removedFieldFindings = (
+  file: string,
+  text: string,
+  issues: readonly z.core.$ZodIssue[]
+): Diagnostic[] =>
+  issues.flatMap((issue) => {
+    if (
+      issue.code !== "unrecognized_keys" ||
+      issue.message.startsWith(PLAIN_UNKNOWN_KEY)
+    ) {
+      return [];
+    }
+    const path = issue.path.filter(isPathKey);
+    const position =
+      locateFrontmatterKey(text, [...path, ...issue.keys.slice(0, 1)]) ??
+      locateFrontmatterKey(text, path);
+    return [
+      {
+        code: "BLUME_FRONTMATTER_INVALID",
+        column: position?.column,
+        file,
+        line: position?.line,
+        message: issue.message,
+        severity: "error",
+      } satisfies Diagnostic,
+    ];
+  });
+
+/** The removed front matter fields in one page, or none it can't parse. */
+const pageFindings = async (file: string): Promise<Diagnostic[]> => {
+  const text = await readFile(file, "utf-8");
+  let parsed: ReturnType<typeof pageMetaSchema.safeParse>;
+  try {
+    parsed = pageMetaSchema.safeParse(matter(text).data);
+  } catch {
+    // Unparseable front matter fails the build with its own diagnostic.
+    return [];
+  }
+  return parsed.success
+    ? []
+    : removedFieldFindings(file, text, parsed.error.issues);
+};
+
+/**
+ * A finding for each front matter field Blume 2 removed, across the project's
+ * local content. A page with one fails validation and drops out of the build,
+ * which the config and components checks alone would report as ready.
+ */
+const frontmatterFindings = async (root: string): Promise<Diagnostic[]> => {
+  const roots = await configContentGlobs(root);
+  const matches = await Promise.all(
+    roots.map((globs) => {
+      const cwd = resolve(root, globs.root);
+      return existsSync(cwd)
+        ? glob(globs.include, {
+            absolute: true,
+            cwd,
+            ignore: [...globs.exclude, ...baselineScanIgnore()],
+            onlyFiles: true,
+          })
+        : [];
+    })
+  );
+  // Two sources can share a folder; each page is checked once.
+  const files = [...new Set(matches.flat())].toSorted();
+  const findings = await Promise.all(files.map(pageFindings));
+  return findings.flat();
+};
+
+/**
+ * Run one check, turning the {@link BlumeError} it throws into its findings:
+ * each config issue or `components.ts` entry on its own, or the one diagnostic
+ * any other check has.
+ */
+const findingsOf = async (
+  check: () => Promise<void>
+): Promise<Diagnostic[]> => {
+  try {
+    await check();
+    return [];
+  } catch (error) {
+    if (
+      error instanceof ConfigValidationError ||
+      error instanceof ComponentOverridesError
+    ) {
+      return error.issues;
+    }
+    if (error instanceof BlumeError) {
+      return [error.diagnostic];
+    }
+    throw error;
+  }
+};
+
+/**
+ * Check a project against this version of Blume: its config through the
+ * loader (every invalid field, each with its line and replacement), its
+ * `components.ts` through the static override planner (each entry at its
+ * line), its pages' front matter for removed fields, and its package.json
+ * scripts for `blume build` flags that no longer exist. Returns the failures;
+ * an empty list means the project is ready.
+ */
+export const collectUpgradeFindings = async (
+  root: string
+): Promise<Diagnostic[]> => {
+  const componentsFile = findComponentsFile(root);
+  return [
+    ...(await findingsOf(async () => {
+      await loadConfig(root);
+    })),
+    ...(componentsFile
+      ? await findingsOf(async () => {
+          analyzeComponentOverrides(
+            await readFile(componentsFile, "utf-8"),
+            componentsFile
+          );
+        })
+      : []),
+    ...(await frontmatterFindings(root)),
+    ...(await scriptFindings(root)),
+  ];
+};
+
+/** A finding as plain text for the agent: where, what, and the fix. */
+const plainFinding = (finding: Diagnostic, root: string): string => {
+  const where = finding.file
+    ? `${relative(root, finding.file)}${finding.line === undefined ? "" : `:${finding.line}`}`
+    : "blume.config.ts";
+  const fix = finding.suggestion ? `\n  Fix: ${finding.suggestion}` : "";
+  return `- ${where} (${finding.code})\n  ${finding.message.replaceAll("\n", "\n  ")}${fix}`;
+};
+
+/**
+ * The handoff prompt: the findings inline (they're few, and each already
+ * names its replacement), where the guide is, and the ground rules — change
+ * the config's shape, never the site's behavior, and verify with the site's
+ * own checks, run through the project's package runner (`npx`, `pnpm exec`),
+ * since a local install puts no `blume` on PATH.
+ */
+export const upgradePrompt = (options: {
+  findings: Diagnostic[];
+  guidePath: string;
+  root: string;
+  runner: string;
+  version: string;
+}): string =>
+  `Upgrade this Blume project to Blume ${options.version}. \`blume upgrade\` has bumped the \`blume\` dependency in package.json where it could; what's left is the config.
+
+The upgrade guide is at ${options.guidePath} (online at ${UPGRADE_GUIDE_URL}). It covers every change between Blume 1 and 2 with before-and-after examples: search, deployment, content sources, API references, analytics, and the assistant's model provider become adapters imported from \`blume/*\` subpaths; the machine-readable settings move from \`ai\` to \`agents\`; Ask AI is renamed the assistant, so \`ai.ask\` becomes \`ai.assistant\`; and \`components.ts\` entries must be one of the static forms.
+
+\`blume upgrade\` found:
+
+${options.findings.map((finding) => plainFinding(finding, options.root)).join("\n\n")}
+
+Work through every finding:
+1. Read the guide section for each change before editing.
+2. Rewrite the config to the Blume 2 form, adding the adapter imports it needs. Keep the site's behavior the same: the same content, routes, search backend, deployment target, analytics, and credentials (keep reading secrets from the same environment variables).
+3. The config loader reports every invalid field at once, but some changes only surface once earlier ones are fixed, so rerun \`${options.runner} blume doctor\` after each round of edits.
+4. Never delete content, or remove a setting only to silence an error; if something needs a human decision, leave it and say so in your summary.
+
+When \`${options.runner} blume doctor\` reports no errors, run \`${options.runner} blume build\` and fix anything it reports until it succeeds.`;

package/dist/cli/chunk-0qymqwzz.js

@@ -1,164 +0,0 @@
-#!/usr/bin/env node
-import {
-  siteRoot,
-  absoluteUrl,
-  MCP_TOOLS
-} from "./chunk-ct47dqpx.js";
-import {
-  resolveReferences
-} from "./chunk-7s8hm3b6.js";
-import {
-  trimChar,
-  normalizeBasePath,
-  withBasePath
-} from "./chunk-2mzebbbz.js";
-
-// src/ai/api/paths.ts
-var OPENAPI_PATH = "/openapi.json";
-var API_BASE = "/api/docs";
-var API_PAGES_PATH = `${API_BASE}/pages.json`;
-var API_PAGE_PATH = `${API_BASE}/pages/{route}.json`;
-var API_NAVIGATION_PATH = `${API_BASE}/navigation.json`;
-var API_SEARCH_PATH = `${API_BASE}/search`;
-var pageParam = (route) => route === "/" ? "index" : route.slice(1);
-var pageJsonPath = (route) => `${API_BASE}/pages/${pageParam(route)}.json`;
-
-// src/ai/api-catalog.ts
-var API_CATALOG_PATH = "/.well-known/api-catalog";
-var API_CATALOG_TYPE = "application/linkset+json";
-var HTTP_URL = /^https?:\/\//u;
-var linksetEntries = (config) => {
-  const site = config.deployment.site ?? null;
-  const deployBase = normalizeBasePath(config.deployment.base);
-  const abs = (path) => {
-    const based = withBasePath(deployBase, path);
-    return site ? absoluteUrl(site, based) : based;
-  };
-  const entries = [];
-  for (const reference of resolveReferences(config)) {
-    const docRoute = reference.renderer === "blume" ? withBasePath(reference.basePath, reference.route) : reference.route;
-    const entry = {
-      anchor: abs(docRoute),
-      "service-doc": [{ href: abs(docRoute), type: "text/html" }]
-    };
-    if (HTTP_URL.test(reference.spec)) {
-      entry["service-desc"] = [{ href: reference.spec }];
-    }
-    entries.push(entry);
-  }
-  if (config.ai.api) {
-    entries.push({
-      anchor: abs(API_BASE),
-      "service-desc": [{ href: abs(OPENAPI_PATH), type: "application/json" }],
-      "service-doc": [{ href: abs("/"), type: "text/html" }]
-    });
-  }
-  if (config.ai.mcp.enabled) {
-    entries.push({
-      anchor: abs(config.ai.mcp.route),
-      "service-desc": [
-        { href: abs("/.well-known/mcp.json"), type: "application/json" }
-      ],
-      "service-doc": [{ href: abs("/"), type: "text/html" }]
-    });
-  }
-  return entries;
-};
-var hasApiCatalog = (config) => linksetEntries(config).length > 0;
-
-// src/ai/mcp/discovery.ts
-var serverUrl = (input) => {
-  const path = withBasePath(input.base, input.route);
-  return input.site ? absoluteUrl(input.site, path) : path;
-};
-var buildMcpDiscovery = (input) => ({
-  servers: [
-    {
-      name: input.name,
-      transport: "streamable-http",
-      url: serverUrl(input)
-    }
-  ]
-});
-var SERVER_CARD_SCHEMA = "https://static.modelcontextprotocol.io/schemas/v1/server-card.schema.json";
-var CARD_TEXT_MAX = 100;
-var truncate = (text) => text.length > CARD_TEXT_MAX ? `${text.slice(0, CARD_TEXT_MAX - 1)}…` : text;
-var NON_ASCII_SLUG = /[^a-z0-9]+/gu;
-var COMBINING_MARKS = /\p{M}+/gu;
-var asciiSlugify = (text) => trimChar(text.normalize("NFKD").replace(COMBINING_MARKS, "").toLowerCase().replace(NON_ASCII_SLUG, "-"), "-");
-var reverseDnsName = (input) => {
-  let namespace = "localhost";
-  if (input.site) {
-    try {
-      namespace = new URL(input.site).hostname.split(".").toReversed().join(".");
-    } catch {}
-  }
-  return `${namespace}/${asciiSlugify(input.name) || "docs"}`;
-};
-var HTTP_URL2 = /^https?:\/\//u;
-var buildMcpServerCard = (input) => {
-  const url = serverUrl(input);
-  const card = {
-    $schema: SERVER_CARD_SCHEMA,
-    capabilities: {
-      resources: { listChanged: false, subscribe: false },
-      tools: { listChanged: false }
-    },
-    description: truncate(`Model Context Protocol server for the ${input.name} documentation.`),
-    name: reverseDnsName(input),
-    serverInfo: { name: input.name, version: input.version },
-    title: truncate(input.name),
-    tools: MCP_TOOLS.map((tool) => ({
-      annotations: tool.annotations,
-      description: tool.description,
-      name: tool.name,
-      title: tool.title
-    })),
-    transport: "streamable-http",
-    transports: [{ endpoint: url, type: "streamable-http" }],
-    url,
-    version: input.version
-  };
-  if (HTTP_URL2.test(url)) {
-    card.remotes = [{ type: "streamable-http", url }];
-  }
-  if (input.site) {
-    card.websiteUrl = siteRoot(input.site);
-  }
-  return card;
-};
-
-// src/ai/skills.ts
-import { join } from "pathe";
-
-// src/ai/tar.ts
-import { createTar } from "nanotar";
-var encoder = new TextEncoder;
-
-// src/ai/skills.ts
-var AGENT_SKILLS_DIR = "/.well-known/agent-skills";
-var AGENT_SKILLS_INDEX_PATH = "/.well-known/agent-skills/index.json";
-
-// src/ai/ai-catalog.ts
-var AI_CATALOG_PATH = "/.well-known/ai-catalog.json";
-var ARD_MANIFEST_PATH = "/.well-known/ard.json";
-var AI_CATALOG_TYPE = "application/ai-catalog+json";
-var hasAiCatalog = (config) => config.ai.catalog.enabled && Boolean(config.deployment.site) && (config.ai.mcp.enabled || config.ai.api || config.ai.llmsTxt.enabled || Boolean(config.ai.skills) || resolveReferences(config).length > 0);
-var crossOriginDiscoveryPaths = (config) => {
-  const paths = [];
-  if (hasAiCatalog(config)) {
-    paths.push(AI_CATALOG_PATH, ARD_MANIFEST_PATH);
-  }
-  if (hasApiCatalog(config)) {
-    paths.push(API_CATALOG_PATH);
-  }
-  if (config.ai.mcp.enabled) {
-    paths.push("/.well-known/mcp.json", "/.well-known/mcp/server-card.json");
-  }
-  return paths;
-};
-
-export { OPENAPI_PATH, API_PAGES_PATH, API_PAGE_PATH, API_NAVIGATION_PATH, API_SEARCH_PATH, pageJsonPath, API_CATALOG_PATH, API_CATALOG_TYPE, hasApiCatalog, buildMcpDiscovery, buildMcpServerCard, AGENT_SKILLS_DIR, AGENT_SKILLS_INDEX_PATH, AI_CATALOG_PATH, AI_CATALOG_TYPE, hasAiCatalog, crossOriginDiscoveryPaths };
-
-//# debugId=26AE621DEDAFCC8A64756E2164756E21
-//# sourceMappingURL=chunk-0qymqwzz.js.map