svedocs-cli 0.1.0-beta.1 → 0.1.0-beta.2

package/dist/{chunk-QD6TB2KV.js → chunk-VMZTD7VT.js}

@@ -1,161 +1,125 @@
-// src/index.ts
-import { mkdir as mkdir3, writeFile as writeFile3 } from "fs/promises";
-import path6 from "path";
+// src/commands/build.ts
 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";
+// src/project.ts
+import { access } from "fs/promises";
+import { createRequire } from "module";
 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 } : {}
-      };
+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 ? path.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 ${path.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;
   }
-  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";
+async function findConfigFile(projectRoot) {
+  for (const file of defaultConfigFiles) {
+    const candidate = path.join(projectRoot, file);
+    if (await fileExists(candidate)) return candidate;
   }
   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}`;
+async function loadConfigWithVite(projectRoot, configFile) {
+  const require2 = createRequire(path.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 `${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;
+  return config;
 }
-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);
-    });
-  });
+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 } : {}
+  };
 }
-async function readPackageManagerField(packageJsonPath) {
-  try {
-    const packageJson = JSON.parse(await readFile(packageJsonPath, "utf8"));
-    return normalizePackageManagerName(packageJson.packageManager?.split("@")[0]);
-  } catch {
-    return void 0;
-  }
+function mergeObject(base, overrides) {
+  if (!base && !overrides) return void 0;
+  return {
+    ...base ?? {},
+    ...overrides ?? {}
+  };
 }
-async function fileExists(file) {
+async function fileExists(filePath) {
   try {
-    await readFile(file);
+    await access(filePath);
     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) {
@@ -166,12 +130,12 @@ function fail(command, args, message) {
 }
 
 // src/utils.ts
-import { spawn as spawn2 } from "child_process";
-import { readFile as readFile2 } from "fs/promises";
+import { spawn } from "child_process";
+import { readFile } from "fs/promises";
 import path2 from "path";
 async function spawnCommand(command, args, env = {}, options = {}) {
   return new Promise((resolve) => {
-    const child = spawn2(command, args, {
+    const child = spawn(command, args, {
       stdio: "inherit",
       shell: process.platform === "win32",
       cwd: options.cwd,
@@ -226,47 +190,347 @@ async function readOgFonts(args) {
   return Promise.all(
     fontPaths.map(async (fontPath, index) => ({
       name: index === 0 ? "Inter" : `SvedocsFont${index + 1}`,
-      data: await readFile2(path2.resolve(process.cwd(), fontPath)),
+      data: await readFile(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;
+// src/commands/og.ts
+import { mkdir, writeFile } from "fs/promises";
+import path3 from "path";
+import { createOgImage, createOgImageInput } from "svedocs/og";
+async function runOgCommand(args) {
+  const manifest = await loadProjectManifest({ configFile: readOption(args, "--config") });
+  const out = path3.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: path3.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 mkdir(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 = path3.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 writeFile(destination, asset);
+    written.push(destination);
+  }
+  return ok("og", args, `Generated ${written.length} OG ${format.toUpperCase()} files with ${renderer} renderer in ${out}`);
+}
+
+// src/commands/build.ts
+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);
+}
+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 } : {};
+}
+
+// src/commands/check.ts
+import { checkPackagePublication } from "svedocs/core";
+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;
+}
+
+// src/commands/create.ts
+import { access as access2, cp, mkdir as mkdir2, mkdtemp, readFile as readFile3, readdir, rm, writeFile as writeFile2 } from "fs/promises";
+import { tmpdir } from "os";
+import path5 from "path";
+import { fileURLToPath } from "url";
+import { Command } from "commander";
+
+// src/package-manager.ts
+import { spawn as spawn2 } from "child_process";
+import { readFile as readFile2 } from "fs/promises";
+import path4 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(path4.join(directory, "package.json"));
+    if (packageJsonManager) return packageJsonManager;
+    if (await fileExists2(path4.join(directory, "pnpm-lock.yaml"))) return "pnpm";
+    if (await fileExists2(path4.join(directory, "package-lock.json")) || await fileExists2(path4.join(directory, "npm-shrinkwrap.json"))) return "npm";
+    if (await fileExists2(path4.join(directory, "yarn.lock"))) return "yarn";
+    if (await fileExists2(path4.join(directory, "bun.lock")) || await fileExists2(path4.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 = spawn2(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 readFile2(packageJsonPath, "utf8"));
+    return normalizePackageManagerName(packageJson.packageManager?.split("@")[0]);
+  } catch {
+    return void 0;
+  }
+}
+async function fileExists2(file) {
+  try {
+    await readFile2(file);
+    return true;
+  } catch {
+    return false;
+  }
+}
+function ancestors(cwd) {
+  const directories = [];
+  let current = path4.resolve(cwd);
+  while (true) {
+    directories.push(current);
+    const parent = path4.dirname(current);
+    if (parent === current) return directories;
+    current = parent;
+  }
+}
+function shellQuote(value) {
+  return /^[a-zA-Z0-9_./:@-]+$/.test(value) ? value : `'${value.replace(/'/g, "'\\''")}'`;
+}
+
+// src/commands/create.ts
+var templateNames = ["minimal", "docs", "cloudflare"];
+var defaultTemplateRepository = "backrunner/svedocs";
+var defaultTemplateRef = "main";
+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 (!templateNames.includes(template)) {
+    return fail("create", args, `Unknown template "${template}". Use minimal, docs, or cloudflare.`);
+  }
+  let source;
+  try {
+    source = await resolveTemplateSource(template, runtime);
+  } catch (error) {
+    return fail("create", args, error instanceof Error ? error.message : String(error));
+  }
+  const destination = path5.resolve(process.cwd(), target);
+  let packageManager;
   try {
     packageManager = await resolvePackageManager({
       requested: options.pm ?? options.packageManager,
@@ -280,23 +544,28 @@ async function runCreateSvedocsCli(args, runtime = {}) {
   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 } : {}
-  }));
+  try {
+    await mkdir2(destination, { recursive: true });
+    await cp(source.directory, 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,
+      templateSource: source.description,
+      installed: Boolean(options.install),
+      ...installMessage ? { installMessage } : {}
+    }));
+  } finally {
+    await source.cleanup?.();
+  }
 }
 async function isEmptyOrMissingDirectory(directory) {
   try {
@@ -306,34 +575,116 @@ async function isEmptyOrMissingDirectory(directory) {
   }
 }
 async function rewriteTemplatePackageJson(directory, target, packageManager) {
-  const packageJsonPath = path3.join(directory, "package.json");
+  const packageJsonPath = path5.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)}
+  await writeFile2(packageJsonPath, `${JSON.stringify(pkg, null, 2)}
 `, "utf8");
 }
 function createPackageName(target) {
-  const name = path3.basename(target).toLowerCase().replace(/[^a-z0-9._-]+/g, "-").replace(/^-+|-+$/g, "");
+  const name = path5.basename(target).toLowerCase().replace(/[^a-z0-9._-]+/g, "-").replace(/^-+|-+$/g, "");
   return name || "svedocs-app";
 }
-async function resolveTemplateSource(template) {
+async function resolveTemplateSource(template, runtime) {
+  const env = { ...process.env, ...runtime.env };
+  const mode = readTemplateSourceMode(env);
+  if (mode !== "bundled") {
+    try {
+      return await downloadGitHubTemplate(template, env, runtime.fetch ?? fetch);
+    } catch (error) {
+      if (mode === "github") throw error;
+      const bundled = await resolveBundledTemplateSource(template);
+      return {
+        ...bundled,
+        description: `${bundled.description} fallback (${formatErrorMessage(error)})`
+      };
+    }
+  }
+  return resolveBundledTemplateSource(template);
+}
+async function resolveBundledTemplateSource(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;
+      await access2(candidate);
+      return { directory: candidate, description: "bundled" };
     } catch {
     }
   }
   throw new Error(`Template "${template}" was not found. Checked: ${candidates.join(", ")}`);
 }
+function readTemplateSourceMode(env) {
+  const value = env.SVEDOCS_TEMPLATE_SOURCE ?? "auto";
+  if (value === "auto" || value === "github" || value === "bundled") return value;
+  throw new Error("Invalid SVEDOCS_TEMPLATE_SOURCE. Use auto, github, or bundled.");
+}
+async function downloadGitHubTemplate(template, env, fetchTemplate) {
+  const repository = env.SVEDOCS_TEMPLATE_REPOSITORY ?? defaultTemplateRepository;
+  const ref = env.SVEDOCS_TEMPLATE_REF ?? defaultTemplateRef;
+  const prefix = `packages/cli/templates/${template}/`;
+  const treeUrl = `https://api.github.com/repos/${repository}/git/trees/${encodeURIComponent(ref)}?recursive=1`;
+  const tree = await fetchJson(fetchTemplate, treeUrl);
+  if (tree.truncated) throw new Error(`GitHub template tree for ${repository}@${ref} is truncated.`);
+  const files = (tree.tree ?? []).filter((entry) => entry.type === "blob" && typeof entry.path === "string").filter((entry) => entry.path.startsWith(prefix));
+  if (files.length === 0) throw new Error(`GitHub template "${template}" was not found in ${repository}@${ref}.`);
+  const tempRoot = await mkdtemp(path5.join(tmpdir(), "svedocs-template-"));
+  const cleanup = async () => {
+    await rm(tempRoot, { recursive: true, force: true });
+  };
+  try {
+    for (const file of files) {
+      const relativePath = file.path.slice(prefix.length);
+      const outputPath = resolveInside(tempRoot, relativePath);
+      await mkdir2(path5.dirname(outputPath), { recursive: true });
+      const response = await fetchTemplate(createRawGitHubUrl(repository, ref, file.path), {
+        headers: { "User-Agent": "create-svedocs" }
+      });
+      if (!response.ok) {
+        throw new Error(`GitHub raw request failed for ${file.path}: ${response.status} ${response.statusText}`);
+      }
+      await writeFile2(outputPath, Buffer.from(await response.arrayBuffer()));
+    }
+    return {
+      directory: tempRoot,
+      description: `GitHub ${repository}@${ref}`,
+      cleanup
+    };
+  } catch (error) {
+    await cleanup();
+    throw error;
+  }
+}
+async function fetchJson(fetchTemplate, url) {
+  const response = await fetchTemplate(url, {
+    headers: {
+      Accept: "application/vnd.github+json",
+      "User-Agent": "create-svedocs"
+    }
+  });
+  if (!response.ok) throw new Error(`GitHub request failed: ${response.status} ${response.statusText}`);
+  return await response.json();
+}
+function createRawGitHubUrl(repository, ref, filePath) {
+  const pathSegments = filePath.split("/").map(encodeURIComponent).join("/");
+  return `https://raw.githubusercontent.com/${repository}/${encodeURIComponent(ref)}/${pathSegments}`;
+}
+function resolveInside(root, relativePath) {
+  const resolved = path5.resolve(root, relativePath);
+  if (resolved !== root && !resolved.startsWith(`${root}${path5.sep}`)) {
+    throw new Error(`Template path escapes destination: ${relativePath}`);
+  }
+  return resolved;
+}
+function formatErrorMessage(error) {
+  return error instanceof Error ? error.message : String(error);
+}
 function renderCreateSuccess(input) {
-  const relativeDestination = path3.relative(process.cwd(), input.destination) || ".";
+  const relativeDestination = path5.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");
@@ -341,6 +692,7 @@ function renderCreateSuccess(input) {
   const ssgCommand = createRunCommand(input.packageManager.name, "build:ssg");
   return [
     `Created ${input.template} svedocs project at ${input.destination}`,
+    `Template source: ${input.templateSource}.`,
     `Package manager: ${describePackageManagerSource(input.packageManager)}.`,
     ...input.installMessage ? [input.installMessage] : [],
     "",
@@ -356,159 +708,469 @@ function renderCreateSuccess(input) {
 }
 
 // src/commands/deploy.ts
-import { mkdir as mkdir2, writeFile as writeFile2 } from "fs/promises";
-import path5 from "path";
+import { mkdir as mkdir3, writeFile as writeFile3 } from "fs/promises";
+import path6 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 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 mkdir3(path6.resolve(process.cwd(), "src"), { recursive: true });
+    await writeFile3(path6.resolve(process.cwd(), wranglerFile), wrangler, "utf8");
+    await writeFile3(path6.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"));
 }
-async function findConfigFile(projectRoot) {
-  for (const file of defaultConfigFiles) {
-    const candidate = path4.join(projectRoot, file);
-    if (await fileExists2(candidate)) return candidate;
+
+// src/commands/search-index.ts
+import { mkdir as mkdir4, writeFile as writeFile4 } from "fs/promises";
+import path7 from "path";
+import { syncCloudflareAiSearchIndex } from "svedocs/search";
+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.");
   }
-  return void 0;
+  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) {
+    return runCloudflareAiSearchIndex(args, manifest);
+  }
+  if (out) {
+    const destination = path7.resolve(process.cwd(), out);
+    await mkdir4(path7.dirname(destination), { recursive: true });
+    await writeFile4(destination, `${payload}
+`, "utf8");
+    return ok("index", args, `Indexed ${manifest.search.length} records for ${provider} at ${destination}`);
+  }
+  return ok("index", args, payload);
 }
-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}.`);
+async function runCloudflareAiSearchIndex(args, manifest) {
+  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.");
   }
-  return config;
+  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);
 }
-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 } : {}
+
+// src/commands/upgrade.ts
+import { readFile as readFile5, writeFile as writeFile5 } from "fs/promises";
+import path9 from "path";
+import { Command as Command2 } from "commander";
+
+// src/commands/upgrade-compatibility.ts
+var upgradeCompatibilityRules = [];
+function checkUpgradeCompatibility(input) {
+  const currentVersion = input.currentSpec ? parseVersionSpec(input.currentSpec) : void 0;
+  const targetVersion = parseVersionSpec(input.targetSpec);
+  const notices = [];
+  const notes = [];
+  for (const rule of upgradeCompatibilityRules) {
+    const introducedIn = parseVersionSpec(rule.introducedIn);
+    if (!introducedIn) continue;
+    if (!currentVersion || !targetVersion) {
+      notices.push({
+        code: "upgrade-span-unknown",
+        severity: "warning",
+        message: `Cannot fully evaluate ${rule.code} because the current or target version is not concrete.`
+      });
+      continue;
+    }
+    if (compareVersions(currentVersion, introducedIn) < 0 && compareVersions(targetVersion, introducedIn) >= 0) {
+      notices.push({
+        code: rule.code,
+        severity: rule.severity,
+        message: rule.message
+      });
+    }
+  }
+  if (!input.currentSpec) {
+    notes.push("No existing svedocs dependency was found; this is treated as a fresh install.");
+  } else if (!currentVersion) {
+    notes.push(`Current svedocs spec "${input.currentSpec}" from ${input.currentSpecSource} is not a concrete version, so version-span checks are limited.`);
+  } else {
+    notes.push(`Current svedocs version: ${formatVersion(currentVersion)} from ${input.currentSpecSource}.`);
+  }
+  if (!targetVersion) {
+    notes.push(`Target "${input.targetSpec}" is not a concrete version before installation, so version-span checks are limited.`);
+  } else {
+    notes.push(`Target svedocs version: ${formatVersion(targetVersion)}.`);
+  }
+  if (upgradeCompatibilityRules.length === 0) {
+    notes.push("No breaking upgrade rules are registered yet.");
+  }
+  return {
+    ...currentVersion ? { currentVersion } : {},
+    ...targetVersion ? { targetVersion } : {},
+    notes,
+    notices
   };
 }
-function mergeObject(base, overrides) {
-  if (!base && !overrides) return void 0;
+function parseVersionSpec(spec) {
+  const match = spec.match(/(?:^|[^0-9])v?(\d+)\.(\d+)\.(\d+)(?:-([0-9A-Za-z.-]+))?/);
+  if (!match) return void 0;
+  const major = Number(match[1]);
+  const minor = Number(match[2]);
+  const patch = Number(match[3]);
+  if (!Number.isInteger(major) || !Number.isInteger(minor) || !Number.isInteger(patch)) return void 0;
   return {
-    ...base ?? {},
-    ...overrides ?? {}
+    major,
+    minor,
+    patch,
+    ...match[4] ? { prerelease: match[4] } : {}
   };
 }
-async function fileExists2(filePath) {
-  try {
-    await access2(filePath);
-    return true;
-  } catch {
-    return false;
+function compareVersions(left, right) {
+  for (const key of ["major", "minor", "patch"]) {
+    if (left[key] > right[key]) return 1;
+    if (left[key] < right[key]) return -1;
   }
+  return 0;
+}
+function formatVersion(version) {
+  const core = `${version.major}.${version.minor}.${version.patch}`;
+  return version.prerelease ? `${core}-${version.prerelease}` : core;
 }
 
-// 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.`);
+// src/commands/upgrade-dependencies.ts
+import { readFile as readFile4 } from "fs/promises";
+import path8 from "path";
+var dependencySections = [
+  "dependencies",
+  "devDependencies",
+  "optionalDependencies",
+  "peerDependencies"
+];
+function createDependencyChanges(pkg, target) {
+  return [
+    createDependencyChange(pkg, "svedocs", target, "dependencies"),
+    createDependencyChange(pkg, "svedocs-cli", target, "devDependencies")
+  ];
+}
+function applyDependencyChanges(pkg, changes) {
+  let changed = false;
+  for (const change of changes) {
+    if (change.action === "keep") continue;
+    const dependencies = ensureDependencySection(pkg, change.section);
+    dependencies[change.name] = change.to;
+    changed = true;
   }
-  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.");
+  return changed;
+}
+function findDependency(pkg, name) {
+  for (const section of dependencySections) {
+    const dependencies = readDependencySection(pkg, section);
+    const spec = dependencies?.[name];
+    if (typeof spec === "string") return { section, spec };
   }
-  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 void 0;
+}
+function createPackageManagerUpgradeCommands(packageManager, target) {
+  const framework = createPackageSpec("svedocs", target);
+  const cli = createPackageSpec("svedocs-cli", target);
+  if (packageManager === "npm") {
+    return [
+      ["npm", "install", "--save", framework],
+      ["npm", "install", "--save-dev", cli]
+    ];
   }
-  return ok("deploy", args, [
-    "Cloudflare deploy dry-run passed.",
+  if (packageManager === "yarn") {
+    return [
+      ["yarn", "add", framework],
+      ["yarn", "add", "-D", cli]
+    ];
+  }
+  if (packageManager === "bun") {
+    return [
+      ["bun", "add", framework],
+      ["bun", "add", "--dev", cli]
+    ];
+  }
+  return [
+    ["pnpm", "add", framework],
+    ["pnpm", "add", "-D", cli]
+  ];
+}
+async function readInstalledDependencyVersion(projectRoot, name) {
+  try {
+    const packageJson = JSON.parse(await readFile4(path8.join(projectRoot, "node_modules", name, "package.json"), "utf8"));
+    return typeof packageJson.version === "string" ? packageJson.version : void 0;
+  } catch {
+    return void 0;
+  }
+}
+function createDependencyChange(pkg, name, target, fallbackSection) {
+  const existing = findDependency(pkg, name);
+  const to = createPackageJsonTargetSpec(existing?.spec, target);
+  if (!existing) return { action: "add", name, section: fallbackSection, to };
+  if (existing.spec === to) {
+    return { action: "keep", name, section: existing.section, from: existing.spec, to };
+  }
+  return { action: "update", name, section: existing.section, from: existing.spec, to };
+}
+function readDependencySection(pkg, section) {
+  const value = pkg[section];
+  if (!isStringRecord(value)) return void 0;
+  return value;
+}
+function ensureDependencySection(pkg, section) {
+  const existing = readDependencySection(pkg, section);
+  if (existing) return existing;
+  const next = {};
+  pkg[section] = next;
+  return next;
+}
+function createPackageJsonTargetSpec(currentSpec, target) {
+  if (!isPlainSemver(target)) return target;
+  const rangePrefix = currentSpec?.match(/^[~^]/)?.[0];
+  return rangePrefix ? `${rangePrefix}${target}` : target;
+}
+function createPackageSpec(name, target) {
+  return `${name}@${target}`;
+}
+function isPlainSemver(target) {
+  return /^\d+\.\d+\.\d+(?:-[0-9A-Za-z.-]+)?(?:\+[0-9A-Za-z.-]+)?$/.test(target);
+}
+function isStringRecord(value) {
+  if (!value || typeof value !== "object" || Array.isArray(value)) return false;
+  return Object.values(value).every((item) => typeof item === "string");
+}
+
+// src/commands/upgrade.ts
+function renderUpgradeHelp() {
+  return [
+    "svedocs upgrade",
     "",
-    `${wranglerFile}:`,
-    wrangler.trim(),
+    "Usage:",
+    "  svedocs upgrade [target]",
     "",
-    `Run with --write to create ${wranglerFile} and Cloudflare platform types.`
-  ].join("\n"));
+    "Arguments:",
+    "  target                Version, range, or dist-tag to install. Defaults to latest.",
+    "",
+    "Options:",
+    "  --package-manager <name>",
+    "                       auto, pnpm, npm, yarn, or bun",
+    "  --pm <name>           Alias for --package-manager",
+    "  --no-install          Rewrite package.json without running the package manager",
+    "  --dry-run             Print planned changes without writing files or installing",
+    "  --check-only          Run compatibility checks without changing dependencies",
+    "  --force               Continue through compatibility blockers"
+  ].join("\n");
+}
+async function runUpgradeCommand(args) {
+  if (args.includes("--help") || args.includes("-h")) return ok("help", args, renderUpgradeHelp());
+  const program = new Command2("svedocs upgrade").argument("[target]", "target svedocs version, range, or dist-tag", "latest").option("--package-manager <name>", "package manager to use: auto, pnpm, npm, yarn, or bun", "auto").option("--pm <name>", "alias for --package-manager").option("--no-install", "rewrite package.json without running the package manager").option("--dry-run", "print planned changes without writing files or installing", false).option("--check-only", "run compatibility checks without changing dependencies", false).option("--force", "continue through compatibility blockers", false).exitOverride();
+  try {
+    program.parse(args, { from: "user" });
+  } catch (error) {
+    return fail("upgrade", args, formatErrorMessage2(error));
+  }
+  const options = program.opts();
+  const target = program.args[0] ?? "latest";
+  const requestedPackageManager = options.pm ?? options.packageManager;
+  if (!isValidTargetSpec(target)) {
+    return fail("upgrade", args, "Invalid target. Use a version, dist-tag, or package spec without whitespace.");
+  }
+  if (requestedPackageManager !== "auto" && !normalizePackageManagerName(requestedPackageManager)) {
+    return fail("upgrade", args, `Invalid package manager "${requestedPackageManager}". Use auto, pnpm, npm, yarn, or bun.`);
+  }
+  const project = await readUpgradeProject(process.cwd());
+  if (!project.ok) return fail("upgrade", args, project.message);
+  const currentDependency = findDependency(project.pkg, "svedocs");
+  const installedVersion = await readInstalledDependencyVersion(project.root, "svedocs");
+  const currentSpec = installedVersion ?? currentDependency?.spec;
+  const compatibility = checkUpgradeCompatibility({
+    currentSpecSource: installedVersion ? "installed package" : currentDependency ? "package.json" : "missing dependency",
+    targetSpec: target,
+    ...currentSpec ? { currentSpec } : {}
+  });
+  const changes = createDependencyChanges(project.pkg, target);
+  if (compatibility.notices.some((notice) => notice.severity === "error") && !options.force) {
+    return fail("upgrade", args, renderUpgradeReport({
+      heading: `svedocs upgrade blocked for ${project.packageJsonPath}.`,
+      target,
+      changes,
+      compatibility,
+      footer: "Re-run with --force after reviewing the compatibility notes."
+    }));
+  }
+  if (options.checkOnly) {
+    return ok("upgrade", args, renderUpgradeReport({
+      heading: `svedocs upgrade check for ${project.packageJsonPath}.`,
+      target,
+      changes,
+      compatibility,
+      footer: "No dependency changes were written."
+    }));
+  }
+  if (options.dryRun) {
+    return ok("upgrade", args, renderUpgradeReport({
+      heading: `svedocs upgrade dry-run for ${project.packageJsonPath}.`,
+      target,
+      changes,
+      compatibility,
+      footer: "No files were changed."
+    }));
+  }
+  if (!options.install) {
+    const changed = applyDependencyChanges(project.pkg, changes);
+    if (changed) await writeFile5(project.packageJsonPath, `${JSON.stringify(project.pkg, null, 2)}
+`, "utf8");
+    const installHint = await renderInstallHint(project.root);
+    return ok("upgrade", args, renderUpgradeReport({
+      heading: changed ? `Updated ${project.packageJsonPath}.` : `${project.packageJsonPath} already targets ${target}.`,
+      target,
+      changes,
+      compatibility,
+      footer: `Install skipped. ${installHint}`
+    }));
+  }
+  return runPackageManagerUpgrade({
+    args,
+    changes,
+    compatibility,
+    project,
+    requestedPackageManager,
+    target
+  });
+}
+async function runPackageManagerUpgrade(input) {
+  let packageManager;
+  try {
+    packageManager = await resolvePackageManager({
+      requested: input.requestedPackageManager,
+      cwd: input.project.root
+    });
+  } catch (error) {
+    return fail("upgrade", input.args, formatErrorMessage2(error));
+  }
+  const commands = createPackageManagerUpgradeCommands(packageManager.name, input.target);
+  for (const command of commands) {
+    const [bin, ...commandArgs] = command;
+    const result = await spawnCommand(bin, commandArgs, {}, { cwd: input.project.root });
+    if (!result.ok) {
+      return fail("upgrade", input.args, renderUpgradeReport({
+        heading: `svedocs upgrade failed while running ${formatCommand(command)}.`,
+        target: input.target,
+        changes: input.changes,
+        compatibility: input.compatibility,
+        footer: result.message
+      }));
+    }
+  }
+  return ok("upgrade", input.args, renderUpgradeReport({
+    heading: `Updated svedocs dependencies with ${describePackageManagerSource(packageManager)}.`,
+    target: input.target,
+    changes: input.changes,
+    compatibility: input.compatibility,
+    footer: [
+      "Ran:",
+      ...commands.map((command) => `  ${formatCommand(command)}`)
+    ].join("\n")
+  }));
+}
+async function readUpgradeProject(cwd) {
+  const packageJsonPath = await findProjectPackageJson(cwd);
+  if (!packageJsonPath) return { ok: false, message: "No package.json was found in this directory or its parents." };
+  try {
+    const pkg = JSON.parse(await readFile5(packageJsonPath, "utf8"));
+    return { ok: true, packageJsonPath, pkg, root: path9.dirname(packageJsonPath) };
+  } catch (error) {
+    return { ok: false, message: `Could not read ${packageJsonPath}: ${formatErrorMessage2(error)}` };
+  }
+}
+function renderUpgradeReport(input) {
+  const notices = input.compatibility.notices.map((notice) => {
+    return `${notice.severity.toUpperCase()} ${notice.code}: ${notice.message}`;
+  });
+  return [
+    input.heading,
+    `Target: ${input.target}`,
+    "Dependency plan:",
+    ...input.changes.map(formatDependencyChange),
+    "Compatibility:",
+    ...input.compatibility.notes.map((note) => `  ${note}`),
+    ...notices.map((notice) => `  ${notice}`),
+    ...input.footer ? [input.footer] : []
+  ].join("\n");
+}
+function formatDependencyChange(change) {
+  const from = change.from ?? "(missing)";
+  if (change.action === "keep") return `  ${change.section}.${change.name}: ${change.to} (already set)`;
+  return `  ${change.section}.${change.name}: ${from} -> ${change.to}`;
+}
+async function renderInstallHint(projectRoot) {
+  const packageManager = await detectPackageManagerFromProject(projectRoot);
+  if (!packageManager) return "Run your package manager install command to refresh the lockfile.";
+  return `Run ${formatCommand(createInstallCommand(packageManager))} to refresh the lockfile.`;
+}
+async function findProjectPackageJson(cwd) {
+  let current = path9.resolve(cwd);
+  while (true) {
+    const packageJsonPath = path9.join(current, "package.json");
+    try {
+      await readFile5(packageJsonPath);
+      return packageJsonPath;
+    } catch {
+      const parent = path9.dirname(current);
+      if (parent === current) return void 0;
+      current = parent;
+    }
+  }
+}
+function isValidTargetSpec(target) {
+  return target.trim().length > 0 && !/\s/.test(target);
+}
+function formatErrorMessage2(error) {
+  return error instanceof Error ? error.message : String(error);
 }
 
 // src/index.ts
@@ -518,6 +1180,7 @@ function renderSvedocsHelp() {
     "",
     "Commands:",
     "  create              Create a new svedocs project",
+    "  upgrade             Upgrade svedocs dependencies",
     "  dev                 Start the development server",
     "  build               Build the documentation site",
     "  ssg                 Build a static SSG site",
@@ -548,6 +1211,7 @@ 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 === "upgrade") return runUpgradeCommand(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));
@@ -560,192 +1224,11 @@ async function runSvedocsCli(args) {
 
 ${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,
+  renderUpgradeHelp,
   renderSvedocsHelp,
   runSvedocsCli
 };