svedocs-cli 0.1.0-beta.1

package/dist/chunk-QD6TB2KV.js

@@ -0,0 +1,751 @@
+// src/index.ts
+import { mkdir as mkdir3, writeFile as writeFile3 } from "fs/promises";
+import path6 from "path";
+import { loadSvedocsConfig } from "svedocs/config";
+import { checkPackagePublication } from "svedocs/core";
+import { createOgImage, createOgImageInput } from "svedocs/og";
+import { syncCloudflareAiSearchIndex } from "svedocs/search";
+
+// src/commands/create.ts
+import { access, cp, mkdir, readFile as readFile3, readdir, writeFile } from "fs/promises";
+import path3 from "path";
+import { fileURLToPath } from "url";
+import { Command } from "commander";
+
+// src/package-manager.ts
+import { spawn } from "child_process";
+import { readFile } from "fs/promises";
+import path from "path";
+var packageManagers = ["pnpm", "npm", "yarn", "bun"];
+var fallbackOrder = ["pnpm", "npm", "yarn", "bun"];
+async function resolvePackageManager(options = {}) {
+  const requested = normalizePackageManagerName(options.requested);
+  if (options.requested && !requested && options.requested !== "auto") {
+    throw new Error(`Invalid package manager "${options.requested}". Use auto, pnpm, npm, yarn, or bun.`);
+  }
+  const readVersion = options.readVersion ?? readPackageManagerVersion;
+  if (requested) {
+    const version = await readVersion(requested);
+    if (!version) throw new Error(`${requested} was requested but was not found on this machine.`);
+    return { name: requested, version, source: "explicit" };
+  }
+  const env = options.env ?? process.env;
+  const envManager = detectPackageManagerFromEnv(env);
+  const projectManager = await detectPackageManagerFromProject(options.cwd ?? process.cwd());
+  for (const candidate of [
+    envManager ? { name: envManager, source: "environment" } : void 0,
+    projectManager ? { name: projectManager, source: "project" } : void 0
+  ]) {
+    if (!candidate) continue;
+    const version = await readVersion(candidate.name);
+    if (version) return { ...candidate, version, detected: candidate.name };
+  }
+  for (const [index, name] of fallbackOrder.entries()) {
+    const version = await readVersion(name);
+    if (version) {
+      const detected = envManager ?? projectManager;
+      return {
+        name,
+        version,
+        source: index === 0 ? "default" : "fallback",
+        ...detected ? { detected } : {}
+      };
+    }
+  }
+  throw new Error("No supported package manager was found. Install pnpm, npm, yarn, or bun and try again.");
+}
+function detectPackageManagerFromEnv(env = process.env) {
+  const userAgent = env.npm_config_user_agent;
+  const userAgentManager = userAgent ? normalizePackageManagerName(userAgent.split(/[ /]/)[0]) : void 0;
+  if (userAgentManager) return userAgentManager;
+  const execPath = `${env.npm_execpath ?? ""} ${env.npm_node_execpath ?? ""}`.toLowerCase();
+  if (execPath.includes("pnpm")) return "pnpm";
+  if (execPath.includes("yarn")) return "yarn";
+  if (execPath.includes("bun")) return "bun";
+  if (execPath.includes("npm")) return "npm";
+  return void 0;
+}
+async function detectPackageManagerFromProject(cwd) {
+  for (const directory of ancestors(cwd)) {
+    const packageJsonManager = await readPackageManagerField(path.join(directory, "package.json"));
+    if (packageJsonManager) return packageJsonManager;
+    if (await fileExists(path.join(directory, "pnpm-lock.yaml"))) return "pnpm";
+    if (await fileExists(path.join(directory, "package-lock.json")) || await fileExists(path.join(directory, "npm-shrinkwrap.json"))) return "npm";
+    if (await fileExists(path.join(directory, "yarn.lock"))) return "yarn";
+    if (await fileExists(path.join(directory, "bun.lock")) || await fileExists(path.join(directory, "bun.lockb"))) return "bun";
+  }
+  return void 0;
+}
+function createPackageManagerField(choice) {
+  return choice.version ? `${choice.name}@${choice.version}` : void 0;
+}
+function createInstallCommand(name) {
+  return name === "yarn" ? ["yarn", "install"] : [name, "install"];
+}
+function createRunCommand(name, script) {
+  if (name === "npm") return ["npm", "run", script];
+  if (name === "bun") return ["bun", "run", script];
+  return [name, script];
+}
+function formatCommand(parts) {
+  return parts.map(shellQuote).join(" ");
+}
+function describePackageManagerSource(choice) {
+  const version = choice.version ? ` ${choice.version}` : "";
+  if (choice.source === "explicit") return `${choice.name}${version} selected by --package-manager`;
+  if (choice.source === "environment") return `${choice.name}${version} detected from the invoking package manager`;
+  if (choice.source === "project") return `${choice.name}${version} detected from the current project`;
+  if (choice.source === "fallback") {
+    const detected = choice.detected ? ` after ${choice.detected} was unavailable` : "";
+    return `${choice.name}${version} selected as fallback${detected}`;
+  }
+  return `${choice.name}${version} selected as the default package manager`;
+}
+function normalizePackageManagerName(value) {
+  if (!value || value === "auto") return void 0;
+  const normalized = value.toLowerCase();
+  return packageManagers.includes(normalized) ? normalized : void 0;
+}
+async function readPackageManagerVersion(name) {
+  return new Promise((resolve) => {
+    const child = spawn(name, ["--version"], {
+      stdio: ["ignore", "pipe", "pipe"],
+      shell: process.platform === "win32"
+    });
+    let output = "";
+    child.stdout.on("data", (chunk) => {
+      output += String(chunk);
+    });
+    child.stderr.on("data", (chunk) => {
+      output += String(chunk);
+    });
+    child.on("close", (code) => {
+      resolve(code === 0 ? output.trim().split(/\s+/)[0] : void 0);
+    });
+    child.on("error", () => {
+      resolve(void 0);
+    });
+  });
+}
+async function readPackageManagerField(packageJsonPath) {
+  try {
+    const packageJson = JSON.parse(await readFile(packageJsonPath, "utf8"));
+    return normalizePackageManagerName(packageJson.packageManager?.split("@")[0]);
+  } catch {
+    return void 0;
+  }
+}
+async function fileExists(file) {
+  try {
+    await readFile(file);
+    return true;
+  } catch {
+    return false;
+  }
+}
+function ancestors(cwd) {
+  const directories = [];
+  let current = path.resolve(cwd);
+  while (true) {
+    directories.push(current);
+    const parent = path.dirname(current);
+    if (parent === current) return directories;
+    current = parent;
+  }
+}
+function shellQuote(value) {
+  return /^[a-zA-Z0-9_./:@-]+$/.test(value) ? value : `'${value.replace(/'/g, "'\\''")}'`;
+}
+
+// src/result.ts
+function ok(command, args, message) {
+  return { command, args, ok: true, message };
+}
+function fail(command, args, message) {
+  return { command, args, ok: false, message };
+}
+
+// src/utils.ts
+import { spawn as spawn2 } from "child_process";
+import { readFile as readFile2 } from "fs/promises";
+import path2 from "path";
+async function spawnCommand(command, args, env = {}, options = {}) {
+  return new Promise((resolve) => {
+    const child = spawn2(command, args, {
+      stdio: "inherit",
+      shell: process.platform === "win32",
+      cwd: options.cwd,
+      env: { ...process.env, ...env }
+    });
+    child.on("close", (code) => {
+      resolve({
+        ok: code === 0,
+        message: `${command} ${args.join(" ")} exited with code ${code ?? 0}.`
+      });
+    });
+    child.on("error", (error) => {
+      resolve({ ok: false, message: error.message });
+    });
+  });
+}
+function readOption(args, name) {
+  const inline = args.find((arg) => arg.startsWith(`${name}=`));
+  if (inline) return inline.slice(name.length + 1);
+  const index = args.indexOf(name);
+  return index >= 0 ? args[index + 1] : void 0;
+}
+function readOptions(args, name) {
+  const values = [];
+  for (let index = 0; index < args.length; index += 1) {
+    const arg = args[index];
+    if (arg?.startsWith(`${name}=`)) {
+      values.push(arg.slice(name.length + 1));
+      continue;
+    }
+    const next = args[index + 1];
+    if (arg === name && next) {
+      values.push(next);
+      index += 1;
+    }
+  }
+  return values;
+}
+function readCsvOptions(args, name) {
+  return readOptions(args, name).flatMap((value) => value.split(",").map((item) => item.trim()).filter(Boolean));
+}
+function readPositiveIntegerOption(args, name) {
+  const value = Number(readOption(args, name));
+  return Number.isInteger(value) && value > 0 ? value : void 0;
+}
+function readNonNegativeIntegerOption(args, name) {
+  const value = Number(readOption(args, name));
+  return Number.isInteger(value) && value >= 0 ? value : void 0;
+}
+async function readOgFonts(args) {
+  const fontPaths = readOptions(args, "--font");
+  return Promise.all(
+    fontPaths.map(async (fontPath, index) => ({
+      name: index === 0 ? "Inter" : `SvedocsFont${index + 1}`,
+      data: await readFile2(path2.resolve(process.cwd(), fontPath)),
+      weight: 400,
+      style: "normal"
+    }))
+  );
+}
+
+// src/commands/create.ts
+function renderCreateSvedocsHelp() {
+  return [
+    "create-svedocs",
+    "",
+    "Usage:",
+    "  create-svedocs [dir]",
+    "",
+    "Options:",
+    "  --template <name>     minimal, docs, or cloudflare",
+    "  --package-manager <name>",
+    "                       auto, pnpm, npm, yarn, or bun",
+    "  --pm <name>           Alias for --package-manager",
+    "  --install             Install dependencies after creating the project",
+    "  --force               Allow writing into an existing directory"
+  ].join("\n");
+}
+async function runCreateSvedocsCli(args, runtime = {}) {
+  if (args.includes("--help") || args.includes("-h")) return ok("help", args, renderCreateSvedocsHelp());
+  const program = new Command("create-svedocs").argument("[dir]", "target directory", "svedocs-app").option("--template <name>", "template name", "docs").option("--package-manager <name>", "package manager to use: auto, pnpm, npm, yarn, or bun", "auto").option("--pm <name>", "alias for --package-manager").option("--install", "install dependencies after creating the project", false).option("--force", "allow writing into an existing directory").exitOverride();
+  try {
+    program.parse(args, { from: "user" });
+  } catch (error) {
+    return fail("create", args, error instanceof Error ? error.message : String(error));
+  }
+  const target = program.args[0] ?? "svedocs-app";
+  const options = program.opts();
+  const template = options.template;
+  if (!["minimal", "docs", "cloudflare"].includes(template)) {
+    return fail("create", args, `Unknown template "${template}". Use minimal, docs, or cloudflare.`);
+  }
+  const source = await resolveTemplateSource(template);
+  const destination = path3.resolve(process.cwd(), target);
+  let packageManager;
+  try {
+    packageManager = await resolvePackageManager({
+      requested: options.pm ?? options.packageManager,
+      cwd: process.cwd(),
+      ...runtime.env ? { env: runtime.env } : {},
+      ...runtime.readPackageManagerVersion ? { readVersion: runtime.readPackageManagerVersion } : {}
+    });
+  } catch (error) {
+    return fail("create", args, error instanceof Error ? error.message : String(error));
+  }
+  if (!options.force && !await isEmptyOrMissingDirectory(destination)) {
+    return fail("create", args, `${destination} already exists and is not empty. Re-run with --force to merge template files.`);
+  }
+  await mkdir(destination, { recursive: true });
+  await cp(source, destination, { recursive: true, force: Boolean(options.force), errorOnExist: false });
+  await rewriteTemplatePackageJson(destination, target, packageManager);
+  let installMessage;
+  if (options.install) {
+    const installCommand = createInstallCommand(packageManager.name);
+    const result = await spawnCommand(installCommand[0], installCommand.slice(1), {}, { cwd: destination });
+    if (!result.ok) return fail("create", args, result.message);
+    installMessage = `Installed dependencies with ${packageManager.name}.`;
+  }
+  return ok("create", args, renderCreateSuccess({
+    destination,
+    packageManager,
+    template,
+    installed: Boolean(options.install),
+    ...installMessage ? { installMessage } : {}
+  }));
+}
+async function isEmptyOrMissingDirectory(directory) {
+  try {
+    return (await readdir(directory)).length === 0;
+  } catch {
+    return true;
+  }
+}
+async function rewriteTemplatePackageJson(directory, target, packageManager) {
+  const packageJsonPath = path3.join(directory, "package.json");
+  const pkg = JSON.parse(await readFile3(packageJsonPath, "utf8"));
+  pkg.name = createPackageName(target);
+  const packageManagerField = createPackageManagerField(packageManager);
+  if (packageManagerField) pkg.packageManager = packageManagerField;
+  await writeFile(packageJsonPath, `${JSON.stringify(pkg, null, 2)}
+`, "utf8");
+}
+function createPackageName(target) {
+  const name = path3.basename(target).toLowerCase().replace(/[^a-z0-9._-]+/g, "-").replace(/^-+|-+$/g, "");
+  return name || "svedocs-app";
+}
+async function resolveTemplateSource(template) {
+  const candidates = [
+    new URL(`../../templates/${template}`, import.meta.url),
+    new URL(`../templates/${template}`, import.meta.url)
+  ].map((url) => fileURLToPath(url));
+  for (const candidate of candidates) {
+    try {
+      await access(candidate);
+      return candidate;
+    } catch {
+    }
+  }
+  throw new Error(`Template "${template}" was not found. Checked: ${candidates.join(", ")}`);
+}
+function renderCreateSuccess(input) {
+  const relativeDestination = path3.relative(process.cwd(), input.destination) || ".";
+  const cdCommand = ["cd", relativeDestination.startsWith("..") ? input.destination : relativeDestination];
+  const installCommand = createInstallCommand(input.packageManager.name);
+  const devCommand = createRunCommand(input.packageManager.name, "dev");
+  const buildCommand = createRunCommand(input.packageManager.name, "build");
+  const ssgCommand = createRunCommand(input.packageManager.name, "build:ssg");
+  return [
+    `Created ${input.template} svedocs project at ${input.destination}`,
+    `Package manager: ${describePackageManagerSource(input.packageManager)}.`,
+    ...input.installMessage ? [input.installMessage] : [],
+    "",
+    "Next steps:",
+    `  ${formatCommand(cdCommand)}`,
+    ...input.installed ? [] : [`  ${formatCommand(installCommand)}`],
+    `  ${formatCommand(devCommand)}`,
+    "",
+    "Build commands:",
+    `  ${formatCommand(buildCommand)}`,
+    `  ${formatCommand(ssgCommand)}`
+  ].join("\n");
+}
+
+// src/commands/deploy.ts
+import { mkdir as mkdir2, writeFile as writeFile2 } from "fs/promises";
+import path5 from "path";
+import { createCloudflareEnvDts, createWranglerJsonc, createWranglerToml } from "svedocs/cloudflare";
+
+// src/project.ts
+import { access as access2 } from "fs/promises";
+import { createRequire } from "module";
+import path4 from "path";
+import { pathToFileURL } from "url";
+import { loadSvedocsContent } from "svedocs/core";
+var defaultConfigFiles = [
+  "svedocs.config.ts",
+  "svedocs.config.mts",
+  "svedocs.config.js",
+  "svedocs.config.mjs"
+];
+async function loadProjectManifest(options = {}) {
+  const projectRoot = options.projectRoot ?? process.cwd();
+  const config = await loadProjectConfig(projectRoot, options.configFile);
+  const merged = mergeSvedocsConfig(config, options.configOverrides);
+  return loadSvedocsContent(merged ? { projectRoot, config: merged } : { projectRoot });
+}
+async function loadProjectConfig(projectRoot = process.cwd(), configFile) {
+  const resolvedConfigFile = configFile ? path4.resolve(projectRoot, configFile) : await findConfigFile(projectRoot);
+  if (!resolvedConfigFile) return void 0;
+  try {
+    return await loadConfigWithVite(projectRoot, resolvedConfigFile);
+  } catch (error) {
+    if (!/\.[cm]?js$/.test(resolvedConfigFile)) {
+      const message = error instanceof Error ? error.message : String(error);
+      throw new Error(`Failed to load ${path4.relative(projectRoot, resolvedConfigFile)}. Install project dependencies first so Vite can load TypeScript config files. ${message}`);
+    }
+    const module = await import(pathToFileURL(resolvedConfigFile).href);
+    return module.default ?? module.config;
+  }
+}
+async function findConfigFile(projectRoot) {
+  for (const file of defaultConfigFiles) {
+    const candidate = path4.join(projectRoot, file);
+    if (await fileExists2(candidate)) return candidate;
+  }
+  return void 0;
+}
+async function loadConfigWithVite(projectRoot, configFile) {
+  const require2 = createRequire(path4.join(projectRoot, "package.json"));
+  const vitePath = require2.resolve("vite");
+  const vite = await import(pathToFileURL(vitePath).href);
+  const loaded = await vite.loadConfigFromFile(
+    {
+      command: "serve",
+      mode: process.env.NODE_ENV ?? "production"
+    },
+    configFile,
+    projectRoot,
+    "silent"
+  );
+  const config = loaded?.config;
+  if (!config || typeof config !== "object") {
+    throw new Error(`No config object was exported from ${configFile}.`);
+  }
+  return config;
+}
+function mergeSvedocsConfig(base, overrides) {
+  if (!base) return overrides;
+  if (!overrides) return base;
+  const site = mergeObject(base.site, overrides.site);
+  const content = mergeObject(base.content, overrides.content);
+  const build = mergeObject(base.build, overrides.build);
+  const theme = mergeObject(base.theme, overrides.theme);
+  const palette = mergeObject(base.theme?.palette, overrides.theme?.palette);
+  const fonts = mergeObject(base.theme?.fonts, overrides.theme?.fonts);
+  const codeTheme = mergeObject(
+    typeof base.theme?.codeTheme === "object" ? base.theme.codeTheme : void 0,
+    typeof overrides.theme?.codeTheme === "object" ? overrides.theme.codeTheme : void 0
+  );
+  const markdown = mergeObject(base.markdown, overrides.markdown);
+  const seo = mergeObject(base.seo, overrides.seo);
+  const source = mergeObject(base.source, overrides.source);
+  const checks = mergeObject(base.checks, overrides.checks);
+  const cloudflare = mergeObject(base.cloudflare, overrides.cloudflare);
+  const aiSearch = mergeObject(base.cloudflare?.aiSearch, overrides.cloudflare?.aiSearch);
+  const search = overrides.search ?? base.search;
+  const ai = overrides.ai ?? base.ai;
+  const i18n = overrides.i18n ?? base.i18n;
+  return {
+    ...base,
+    ...overrides,
+    ...site ? { site } : {},
+    ...content ? { content } : {},
+    ...build ? { build } : {},
+    ...theme ? {
+      theme: {
+        ...theme,
+        ...palette ? { palette } : {},
+        ...fonts ? { fonts } : {},
+        ...codeTheme ? { codeTheme } : {}
+      }
+    } : {},
+    ...markdown ? { markdown } : {},
+    ...seo ? { seo } : {},
+    ...source ? { source } : {},
+    ...checks ? { checks } : {},
+    ...cloudflare ? { cloudflare: { ...cloudflare, ...aiSearch ? { aiSearch } : {} } } : {},
+    ...search !== void 0 ? { search } : {},
+    ...ai !== void 0 ? { ai } : {},
+    ...i18n !== void 0 ? { i18n } : {}
+  };
+}
+function mergeObject(base, overrides) {
+  if (!base && !overrides) return void 0;
+  return {
+    ...base ?? {},
+    ...overrides ?? {}
+  };
+}
+async function fileExists2(filePath) {
+  try {
+    await access2(filePath);
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+// src/commands/deploy.ts
+async function runDeployCommand(args) {
+  const target = args[0] ?? "cloudflare";
+  if (target !== "cloudflare") {
+    return fail("deploy", args, `Unknown deploy target "${target}". Use cloudflare.`);
+  }
+  const write = args.includes("--write");
+  const format = readOption(args, "--format") ?? "toml";
+  if (!["toml", "jsonc"].includes(format)) {
+    return fail("deploy", args, "Invalid Cloudflare config format. Use toml or jsonc.");
+  }
+  const manifest = await loadProjectManifest({ configFile: readOption(args, "--config") });
+  const wrangler = format === "jsonc" ? createWranglerJsonc(manifest.config) : createWranglerToml(manifest.config);
+  const wranglerFile = format === "jsonc" ? "wrangler.jsonc" : "wrangler.toml";
+  const envDts = createCloudflareEnvDts(manifest.config);
+  if (write) {
+    await mkdir2(path5.resolve(process.cwd(), "src"), { recursive: true });
+    await writeFile2(path5.resolve(process.cwd(), wranglerFile), wrangler, "utf8");
+    await writeFile2(path5.resolve(process.cwd(), "src/app.cloudflare.d.ts"), envDts, "utf8");
+    return ok("deploy", args, `Wrote ${wranglerFile} and src/app.cloudflare.d.ts for Cloudflare Pages.`);
+  }
+  return ok("deploy", args, [
+    "Cloudflare deploy dry-run passed.",
+    "",
+    `${wranglerFile}:`,
+    wrangler.trim(),
+    "",
+    `Run with --write to create ${wranglerFile} and Cloudflare platform types.`
+  ].join("\n"));
+}
+
+// src/index.ts
+function renderSvedocsHelp() {
+  return [
+    "svedocs",
+    "",
+    "Commands:",
+    "  create              Create a new svedocs project",
+    "  dev                 Start the development server",
+    "  build               Build the documentation site",
+    "  ssg                 Build a static SSG site",
+    "  preview             Preview the built site",
+    "  check               Check project configuration and content",
+    "  index               Print or write search index records",
+    "  og                  Generate Open Graph assets",
+    "  deploy              Deploy helpers and provider checks",
+    "",
+    "Global options:",
+    "  --config <path>      Use a specific svedocs config file",
+    "",
+    "Build options:",
+    "  --mode <mode>        Build mode: edge, static, or spa",
+    "  --no-og              Skip automatic static OG asset generation",
+    "",
+    "Check options:",
+    "  --strict             Treat warnings as failures",
+    "  --external-links     Verify http(s) links with HEAD requests",
+    "  --no-assets          Skip local asset existence checks",
+    "  --translations       Warn when configured locales are missing doc pages",
+    "  --package            Validate package files and exports",
+    "",
+    "Use --help on a command for more details."
+  ].join("\n");
+}
+async function runSvedocsCli(args) {
+  const command = args[0] ?? "help";
+  if (command === "help" || command === "--help" || command === "-h") return ok("help", args, renderSvedocsHelp());
+  if (command === "create") return runCreateSvedocsCli(args.slice(1));
+  if (command === "dev") return runViteCommand("dev", args.slice(1));
+  if (command === "preview") return runViteCommand("preview", args.slice(1));
+  if (command === "build") return runBuildCommand(args.slice(1));
+  if (command === "ssg") return runBuildCommand(["--mode", "static", ...args.slice(1)]);
+  if (command === "check") return runCheckCommand(args.slice(1));
+  if (command === "index") return runIndexCommand(args.slice(1));
+  if (command === "og") return runOgCommand(args.slice(1));
+  if (command === "deploy") return runDeployCommand(args.slice(1));
+  return fail(command, args, `Unknown command "${command}".
+
+${renderSvedocsHelp()}`);
+}
+async function runBuildCommand(args) {
+  const configFile = readOption(args, "--config");
+  const config = loadSvedocsConfig(await loadProjectConfig(process.cwd(), configFile) ?? {});
+  const mode = readOption(args, "--mode") ?? process.env.SVEDOCS_BUILD_MODE ?? config.build.mode;
+  if (!mode || !["edge", "static", "spa"].includes(mode)) {
+    return fail("build", args, "Invalid build mode. Use edge, static, or spa.");
+  }
+  const warning = mode === "spa" ? "SPA mode prerenders known docs pages and writes a static fallback; hosted Search, Ask AI, and other server-only features need an edge runtime.\n" : "";
+  const result = await spawnCommand("vite", ["build", ...createViteArgs(args)], {
+    SVEDOCS_BUILD_MODE: mode,
+    ...createConfigEnv(configFile)
+  });
+  if (!result.ok) return fail("build", args, `${warning}${result.message}`);
+  const ogResult = await runConfiguredOgGeneration(configFile, args, config.seo.ogImage);
+  const message = ogResult ? `${result.message}
+${ogResult.message}` : result.message;
+  return ok("build", args, `${warning}${message}`);
+}
+async function runViteCommand(command, args) {
+  const configFile = readOption(args, "--config");
+  const result = await spawnCommand("vite", [command, ...createViteArgs(args)], createConfigEnv(configFile));
+  return result.ok ? ok(command, args, result.message) : fail(command, args, result.message);
+}
+async function runCheckCommand(args) {
+  const manifest = await loadProjectManifest({
+    configFile: readOption(args, "--config"),
+    configOverrides: createCheckConfigOverrides(args)
+  });
+  const strict = args.includes("--strict");
+  const packageIssues = args.includes("--package") ? await checkPackagePublication(process.cwd()) : [];
+  const allIssues = [...manifest.issues, ...packageIssues];
+  const allErrors = allIssues.filter((issue) => issue.severity === "error");
+  const allWarnings = allIssues.filter((issue) => issue.severity === "warning");
+  const summary = `svedocs check: ${manifest.pages.length} pages, ${manifest.search.length} search records, ${allErrors.length} errors, ${allWarnings.length} warnings.`;
+  const details = allIssues.map((issue) => `${issue.severity.toUpperCase()} ${issue.code}: ${issue.message}`);
+  const message = [summary, ...details].join("\n");
+  if (allErrors.length > 0 || strict && allWarnings.length > 0) {
+    return fail("check", args, message);
+  }
+  return ok("check", args, message);
+}
+function createCheckConfigOverrides(args) {
+  const checks = {};
+  if (args.includes("--external-links")) checks.externalLinks = true;
+  if (args.includes("--no-assets")) checks.assets = false;
+  if (args.includes("--translations")) checks.translations = true;
+  return Object.keys(checks).length ? { checks } : void 0;
+}
+function createViteArgs(args) {
+  const output = [];
+  for (let index = 0; index < args.length; index += 1) {
+    const arg = args[index];
+    if (!arg) continue;
+    if (arg === "--") {
+      output.push(...args.slice(index + 1));
+      break;
+    }
+    if (arg === "--no-og") continue;
+    if (arg === "--mode" || arg === "--config") {
+      index += 1;
+      continue;
+    }
+    if (arg.startsWith("--mode=") || arg.startsWith("--config=")) continue;
+    output.push(arg);
+  }
+  return output;
+}
+function createConfigEnv(configFile) {
+  return configFile ? { SVEDOCS_CONFIG_FILE: configFile } : {};
+}
+async function runIndexCommand(args) {
+  const manifest = await loadProjectManifest({ configFile: readOption(args, "--config") });
+  const out = readOption(args, "--out");
+  const format = readOption(args, "--format") ?? "json";
+  const provider = readOption(args, "--provider") ?? manifest.config.search.provider;
+  if (!["json", "jsonl"].includes(format)) {
+    return fail("index", args, "Invalid index format. Use json or jsonl.");
+  }
+  const payload = format === "jsonl" ? manifest.search.map((record) => JSON.stringify(record)).join("\n") : JSON.stringify(manifest.search, null, 2);
+  if (provider === "cloudflare-ai-search" && !out) {
+    const accountId = process.env.CLOUDFLARE_ACCOUNT_ID;
+    const apiToken = process.env.CLOUDFLARE_API_TOKEN;
+    const namespace = readOption(args, "--namespace");
+    const strategy = readOption(args, "--strategy") ?? "append";
+    if (!["append", "replace"].includes(strategy)) {
+      return fail("index", args, "Invalid Cloudflare AI Search strategy. Use append or replace.");
+    }
+    const existingIds = readCsvOptions(args, "--existing");
+    const deleteIds = readOptions(args, "--delete");
+    const result = await syncCloudflareAiSearchIndex({
+      records: manifest.search,
+      instanceName: readOption(args, "--instance") ?? manifest.config.cloudflare.aiSearch.instanceName,
+      ...accountId ? { accountId } : {},
+      ...apiToken ? { apiToken } : {},
+      ...namespace ? { namespace } : {},
+      ...args.includes("--dry-run") ? { dryRun: true } : {},
+      ...args.includes("--wait") ? { waitForCompletion: true } : {},
+      strategy,
+      batchSize: readPositiveIntegerOption(args, "--batch-size") ?? 10,
+      maxRetries: readNonNegativeIntegerOption(args, "--retries") ?? 2,
+      ...existingIds.length ? { existingIds } : {},
+      ...deleteIds.length ? { deleteIds } : {}
+    });
+    const details = result.errors.map((error) => `ERROR ${error.id}: ${error.message}`);
+    const message = [
+      result.dryRun ? `Cloudflare AI Search dry-run: ${result.indexed} uploads and ${result.deleted} deletes planned for ${result.instanceName}.` : `Cloudflare AI Search indexed ${result.indexed} records and deleted ${result.deleted} items for ${result.instanceName}; ${result.failed} failed.`,
+      `Strategy: ${strategy}`,
+      `Endpoint: ${result.endpoint}`,
+      ...result.dryRun ? ["Set CLOUDFLARE_ACCOUNT_ID and CLOUDFLARE_API_TOKEN to upload records."] : [],
+      ...details
+    ].join("\n");
+    return result.failed > 0 ? fail("index", args, message) : ok("index", args, message);
+  }
+  if (out) {
+    const destination = path6.resolve(process.cwd(), out);
+    await mkdir3(path6.dirname(destination), { recursive: true });
+    await writeFile3(destination, `${payload}
+`, "utf8");
+    return ok("index", args, `Indexed ${manifest.search.length} records for ${provider} at ${destination}`);
+  }
+  return ok("index", args, payload);
+}
+async function runOgCommand(args) {
+  const manifest = await loadProjectManifest({ configFile: readOption(args, "--config") });
+  const out = path6.resolve(process.cwd(), readOption(args, "--out") ?? (manifest.config.seo.ogImage === false ? "static/og" : manifest.config.seo.ogImage.outDir));
+  const format = readOption(args, "--format") ?? (manifest.config.seo.ogImage === false ? "svg" : manifest.config.seo.ogImage.format);
+  const renderer = readOption(args, "--renderer") ?? (manifest.config.seo.ogImage === false ? "svg" : manifest.config.seo.ogImage.renderer);
+  if (!["svg", "png"].includes(format)) {
+    return fail("og", args, "Invalid OG format. Use svg or png.");
+  }
+  if (!["svg", "satori"].includes(renderer)) {
+    return fail("og", args, "Invalid OG renderer. Use svg or satori.");
+  }
+  const fonts = await readOgFonts(args);
+  if (renderer === "satori" && fonts.length === 0) {
+    return fail("og", args, "Satori OG rendering requires at least one --font path.");
+  }
+  const configFile = readOption(args, "--config");
+  return generateOgAssets({
+    args,
+    out,
+    format,
+    renderer,
+    fonts,
+    ...configFile ? { configFile } : {}
+  });
+}
+async function runConfiguredOgGeneration(configFile, buildArgs, ogConfig) {
+  if (buildArgs.includes("--no-og")) return void 0;
+  if (ogConfig === false) return void 0;
+  if (ogConfig.renderer === "satori") return void 0;
+  const manifest = await loadProjectManifest({ configFile });
+  return generateOgAssets({
+    args: ["og", "--auto"],
+    out: path6.resolve(process.cwd(), ogConfig.outDir),
+    format: ogConfig.format,
+    renderer: ogConfig.renderer,
+    fonts: [],
+    ...configFile ? { configFile } : {},
+    manifest
+  });
+}
+async function generateOgAssets(input) {
+  const manifest = input.manifest ?? await loadProjectManifest({ configFile: input.configFile });
+  const { out, format, renderer, fonts, args } = input;
+  await mkdir3(out, { recursive: true });
+  const written = [];
+  for (const page of manifest.pages) {
+    if (page.hidden) continue;
+    const fileName = `${page.routePath === "/" ? "index" : page.routePath.replace(/^\/+/, "").replace(/[^a-zA-Z0-9]+/g, "-")}.${format}`;
+    const destination = path6.join(out, fileName);
+    const asset = await createOgImage(createOgImageInput(manifest.config, page), {
+      format,
+      renderer,
+      ...manifest.config.seo.ogImage !== false && typeof manifest.config.seo.ogImage.template === "function" ? { template: manifest.config.seo.ogImage.template } : {},
+      ...fonts.length ? { fonts } : {}
+    });
+    await writeFile3(destination, asset);
+    written.push(destination);
+  }
+  return ok("og", args, `Generated ${written.length} OG ${format.toUpperCase()} files with ${renderer} renderer in ${out}`);
+}
+
+export {
+  renderCreateSvedocsHelp,
+  runCreateSvedocsCli,
+  renderSvedocsHelp,
+  runSvedocsCli
+};