@opendocsdev/cli 0.2.0

package/dist/bin/opendocs.js

@@ -0,0 +1,712 @@
+#!/usr/bin/env node
+
+// bin/opendocs.ts
+import { Command } from "commander";
+
+// src/commands/init.ts
+import fs from "fs-extra";
+import path from "path";
+import chalk2 from "chalk";
+import ora from "ora";
+import { fileURLToPath } from "url";
+
+// src/utils/logger.ts
+import chalk from "chalk";
+var LOG_LEVEL_ORDER = {
+  debug: 0,
+  info: 1,
+  warn: 2,
+  error: 3
+};
+var currentLevel = "info";
+function shouldLog(level) {
+  return LOG_LEVEL_ORDER[level] >= LOG_LEVEL_ORDER[currentLevel];
+}
+var logger = {
+  debug(message, ...args) {
+    if (shouldLog("debug")) {
+      console.log(chalk.gray(`[debug] ${message}`), ...args);
+    }
+  },
+  info(message, ...args) {
+    if (shouldLog("info")) {
+      console.log(message, ...args);
+    }
+  },
+  warn(message, ...args) {
+    if (shouldLog("warn")) {
+      console.warn(chalk.yellow(message), ...args);
+    }
+  },
+  error(message, ...args) {
+    if (shouldLog("error")) {
+      console.error(chalk.red(message), ...args);
+    }
+  },
+  success(message, ...args) {
+    if (shouldLog("info")) {
+      console.log(chalk.green(message), ...args);
+    }
+  },
+  plain(message, ...args) {
+    if (shouldLog("info")) {
+      console.log(message, ...args);
+    }
+  }
+};
+
+// src/utils/errors.ts
+function getErrorMessage(error) {
+  if (error instanceof Error) {
+    return error.message;
+  }
+  return String(error);
+}
+
+// src/constants.ts
+var CLI_NAME = "opendocs";
+var CLI_VERSION = "0.1.0";
+var DOCS_CONFIG_FILE = "docs.json";
+var DEFAULT_SNIPPETS = ["snippets"];
+var ENGINE_RELATIVE_PATH = "../../src/engine";
+var DEFAULT_API_URL = "https://app.opendocs.dev";
+var DIST_DIR = "dist";
+
+// src/commands/init.ts
+var __dirname2 = path.dirname(fileURLToPath(import.meta.url));
+function getTemplatesDir() {
+  const devPath = path.join(__dirname2, "..", "templates");
+  const prodPath = path.join(__dirname2, "..", "..", "templates");
+  if (fs.existsSync(devPath)) {
+    return devPath;
+  }
+  return prodPath;
+}
+async function readTemplate(filename, replacements) {
+  const templatesDir = getTemplatesDir();
+  const filePath = path.join(templatesDir, filename);
+  let content = await fs.readFile(filePath, "utf-8");
+  if (replacements) {
+    for (const [key, value] of Object.entries(replacements)) {
+      content = content.replace(new RegExp(`\\{\\{${key}\\}\\}`, "g"), value);
+    }
+  }
+  return content;
+}
+var TEMPLATE_FILES = [
+  { template: "introduction.mdx", output: "introduction.mdx" },
+  { template: "quickstart.mdx", output: "quickstart.mdx" },
+  { template: "components.mdx", output: "components.mdx" },
+  { template: "configuration.mdx", output: "configuration.mdx" },
+  { template: "writing-content.mdx", output: "writing-content.mdx" },
+  { template: "api-reference.mdx", output: "api-reference.mdx" },
+  { template: "logo.svg", output: "public/logo.svg" }
+];
+async function init(name = "my-docs") {
+  const projectDir = path.resolve(process.cwd(), name);
+  if (await fs.pathExists(projectDir)) {
+    logger.error(`Error: Directory "${name}" already exists.`);
+    logger.info(chalk2.gray("Please choose a different name or remove the existing directory."));
+    process.exit(1);
+  }
+  const spinner = ora(`Creating new opendocs project: ${name}`).start();
+  try {
+    await fs.mkdir(projectDir, { recursive: true });
+    spinner.text = `Creating ${DOCS_CONFIG_FILE} configuration...`;
+    const docsConfig = await readTemplate(DOCS_CONFIG_FILE, { PROJECT_NAME: name });
+    await fs.writeFile(path.join(projectDir, DOCS_CONFIG_FILE), docsConfig);
+    for (const { template, output } of TEMPLATE_FILES) {
+      spinner.text = `Creating ${output}...`;
+      const content = await readTemplate(template);
+      const outputPath = path.join(projectDir, output);
+      await fs.mkdir(path.dirname(outputPath), { recursive: true });
+      await fs.writeFile(outputPath, content);
+    }
+    spinner.succeed(chalk2.green(`Successfully created "${name}"!`));
+    logger.plain("");
+    logger.info(chalk2.bold("Next steps:"));
+    logger.plain("");
+    logger.info(chalk2.gray("  1.") + ` cd ${name}`);
+    logger.info(chalk2.gray("  2.") + " opendocs dev");
+    logger.plain("");
+    logger.info(chalk2.gray("Then open") + " " + chalk2.cyan("http://localhost:4321") + " " + chalk2.gray("in your browser."));
+    logger.plain("");
+    logger.info(chalk2.gray("Edit") + " " + chalk2.cyan(DOCS_CONFIG_FILE) + " " + chalk2.gray("to customize your documentation."));
+  } catch (error) {
+    spinner.fail(chalk2.red("Failed to create project"));
+    logger.error(getErrorMessage(error));
+    process.exit(1);
+  }
+}
+
+// src/commands/dev.ts
+import { spawn } from "child_process";
+import path3 from "path";
+import { fileURLToPath as fileURLToPath2 } from "url";
+import chalk4 from "chalk";
+
+// src/utils/docs-config.ts
+import path2 from "path";
+import fs2 from "fs-extra";
+import chalk3 from "chalk";
+
+// src/config/schema.ts
+import { z } from "zod";
+var logoSchema = z.union([
+  z.string(),
+  z.object({
+    light: z.string(),
+    dark: z.string()
+  })
+]);
+var pageItemSchema = z.lazy(
+  () => z.union([
+    z.string(),
+    z.object({
+      page: z.string(),
+      children: z.array(z.string())
+    }),
+    z.object({
+      group: z.string(),
+      pages: z.array(pageItemSchema)
+    })
+  ])
+);
+var navigationItemSchema = z.object({
+  group: z.string(),
+  pages: z.array(pageItemSchema)
+});
+var socialLinksSchema = z.object({
+  github: z.string().url().optional(),
+  twitter: z.string().url().optional(),
+  discord: z.string().url().optional()
+}).optional();
+var themeSchema = z.object({
+  primaryColor: z.string().optional(),
+  accentColor: z.string().optional(),
+  darkMode: z.boolean().optional()
+}).optional();
+var featuresSchema = z.object({
+  search: z.boolean().optional(),
+  feedback: z.boolean().optional(),
+  analytics: z.boolean().optional()
+}).optional();
+var footerSchema = z.object({
+  copyright: z.string().optional(),
+  links: z.array(
+    z.object({
+      title: z.string(),
+      url: z.string()
+    })
+  ).optional()
+}).optional();
+var metadataSchema = z.object({
+  url: z.string().url().optional(),
+  ogImage: z.string().optional()
+}).optional();
+var docsConfigSchema = z.object({
+  // Required fields
+  name: z.string(),
+  // Optional content fields
+  logo: logoSchema.optional(),
+  favicon: z.string().optional(),
+  // Navigation structure
+  navigation: z.array(navigationItemSchema),
+  // Styling
+  theme: themeSchema,
+  // Backend integration (optional - for analytics/feedback/deploy)
+  backend: z.object({
+    siteId: z.string(),
+    apiUrl: z.string().url().optional()
+  }).optional(),
+  // Feature flags
+  features: featuresSchema,
+  // Footer content
+  footer: footerSchema,
+  // Social links (GitHub, Twitter, etc.)
+  socialLinks: socialLinksSchema,
+  // SEO metadata
+  metadata: metadataSchema,
+  // Snippet folders configuration
+  snippets: z.array(z.string()).optional().default(["snippets"])
+});
+
+// src/utils/docs-config.ts
+async function requireDocsJson(cwd) {
+  const docsJsonPath = path2.join(cwd, DOCS_CONFIG_FILE);
+  if (!await fs2.pathExists(docsJsonPath)) {
+    logger.error(`Error: ${DOCS_CONFIG_FILE} not found in current directory.`);
+    logger.info(chalk3.gray("Make sure you're in an opendocs project directory or run:"));
+    logger.info(chalk3.cyan("  opendocs init my-docs"));
+    process.exit(1);
+  }
+  return docsJsonPath;
+}
+async function loadDocsConfig(docsJsonPath) {
+  const raw = await fs2.readJson(docsJsonPath);
+  const result = docsConfigSchema.safeParse(raw);
+  if (!result.success) {
+    logger.warn(
+      "docs.json has validation issues: " + result.error.issues.map((i) => i.message).join(", ")
+    );
+    return raw;
+  }
+  return result.data;
+}
+function getSnippetsDirs(config) {
+  return Array.isArray(config.snippets) ? config.snippets : DEFAULT_SNIPPETS;
+}
+function buildEngineEnv(cwd, snippets) {
+  return {
+    ...process.env,
+    OPENDOCS_PROJECT_DIR: cwd,
+    OPENDOCS_SNIPPETS: JSON.stringify(snippets)
+  };
+}
+function resolveEngineDir(dirname) {
+  return path2.resolve(dirname, ENGINE_RELATIVE_PATH);
+}
+
+// src/utils/process.ts
+function attachProcessHandlers(child, label) {
+  child.on("error", (error) => {
+    logger.error(`Failed to start ${label}: ${error.message}`);
+    process.exit(1);
+  });
+  child.on("close", (code) => {
+    if (code !== 0 && code !== null) {
+      process.exit(code);
+    }
+  });
+  const cleanup = () => {
+    child.kill("SIGTERM");
+  };
+  process.on("SIGINT", cleanup);
+  process.on("SIGTERM", cleanup);
+}
+
+// src/commands/dev.ts
+var __filename2 = fileURLToPath2(import.meta.url);
+var __dirname3 = path3.dirname(__filename2);
+async function dev(options) {
+  const cwd = process.cwd();
+  const docsJsonPath = await requireDocsJson(cwd);
+  const docsConfig = await loadDocsConfig(docsJsonPath);
+  const snippets = getSnippetsDirs(docsConfig);
+  const engineDir = resolveEngineDir(__dirname3);
+  const env = buildEngineEnv(cwd, snippets);
+  logger.info(chalk4.cyan("Starting development server..."));
+  logger.info(chalk4.gray(`Project directory: ${cwd}`));
+  logger.info(chalk4.gray(`Port: ${options.port}`));
+  logger.plain("");
+  const child = spawn(
+    "npx",
+    ["astro", "dev", "--port", options.port, "--root", engineDir],
+    {
+      cwd: engineDir,
+      env,
+      stdio: "inherit",
+      shell: true
+    }
+  );
+  attachProcessHandlers(child, "development server");
+}
+
+// src/commands/build.ts
+import { spawn as spawn2 } from "child_process";
+import path5 from "path";
+import { fileURLToPath as fileURLToPath3 } from "url";
+import fs4 from "fs-extra";
+import chalk5 from "chalk";
+import ora2 from "ora";
+
+// src/utils/sitemap.ts
+import fs3 from "fs-extra";
+import path4 from "path";
+import fg from "fast-glob";
+async function generateSitemap(distDir, baseUrl = "") {
+  const htmlFiles = await fg("**/*.html", {
+    cwd: distDir,
+    absolute: true
+  });
+  const entries = await Promise.all(
+    htmlFiles.map(async (filePath) => {
+      const relativePath = path4.relative(distDir, filePath);
+      let urlPath = "/" + relativePath.replace(/\\/g, "/");
+      if (urlPath.endsWith("/index.html")) {
+        urlPath = urlPath.slice(0, -"index.html".length);
+      } else if (urlPath.endsWith(".html")) {
+        urlPath = urlPath.slice(0, -".html".length);
+      }
+      if (!urlPath.endsWith("/") && !urlPath.includes(".")) {
+        urlPath = urlPath + "/";
+      }
+      const stats = await fs3.stat(filePath);
+      const lastmod = stats.mtime.toISOString().split("T")[0];
+      return {
+        loc: `${baseUrl}${urlPath}`,
+        lastmod
+      };
+    })
+  );
+  entries.sort((a, b) => a.loc.localeCompare(b.loc));
+  const xml = `<?xml version="1.0" encoding="UTF-8"?>
+<urlset xmlns="http://www.sitemaps.org/schemas/sitemap/0.9">
+${entries.map((entry) => `  <url>
+    <loc>${escapeXml(entry.loc)}</loc>
+    <lastmod>${entry.lastmod}</lastmod>
+  </url>`).join("\n")}
+</urlset>
+`;
+  return xml;
+}
+function escapeXml(str) {
+  return str.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;").replace(/"/g, "&quot;").replace(/'/g, "&apos;");
+}
+async function writeSitemap(distDir, baseUrl = "") {
+  const sitemapContent = await generateSitemap(distDir, baseUrl);
+  const sitemapPath = path4.join(distDir, "sitemap.xml");
+  await fs3.writeFile(sitemapPath, sitemapContent, "utf-8");
+}
+
+// src/commands/build.ts
+var __filename3 = fileURLToPath3(import.meta.url);
+var __dirname4 = path5.dirname(__filename3);
+function runCommand(command, args, options) {
+  return new Promise((resolve, reject) => {
+    const child = spawn2(command, args, {
+      cwd: options.cwd,
+      env: options.env || process.env,
+      stdio: "inherit",
+      shell: true
+    });
+    child.on("error", (error) => {
+      reject(error);
+    });
+    child.on("close", (code) => {
+      if (code === 0) {
+        resolve();
+      } else {
+        reject(new Error(`Command exited with code ${code}`));
+      }
+    });
+  });
+}
+async function build() {
+  const cwd = process.cwd();
+  const docsJsonPath = await requireDocsJson(cwd);
+  const docsConfig = await loadDocsConfig(docsJsonPath);
+  const snippets = getSnippetsDirs(docsConfig);
+  const engineDir = resolveEngineDir(__dirname4);
+  const projectDistDir = path5.join(cwd, DIST_DIR);
+  const env = buildEngineEnv(cwd, snippets);
+  logger.info(chalk5.cyan("\n\u{1F4E6} Building documentation site...\n"));
+  const cleanSpinner = ora2("Cleaning existing dist folder...").start();
+  try {
+    if (await fs4.pathExists(projectDistDir)) {
+      await fs4.remove(projectDistDir);
+    }
+    cleanSpinner.succeed("Cleaned dist folder");
+  } catch (error) {
+    cleanSpinner.fail("Failed to clean dist folder");
+    logger.error(getErrorMessage(error));
+    process.exit(1);
+  }
+  const buildSpinner = ora2("Running Astro build...").start();
+  try {
+    buildSpinner.text = "Running Astro build (this may take a moment)...";
+    await runCommand("npx", ["astro", "build", "--root", engineDir], {
+      cwd: engineDir,
+      env
+    });
+    buildSpinner.succeed("Astro build completed");
+  } catch (error) {
+    buildSpinner.fail("Astro build failed");
+    logger.error(getErrorMessage(error));
+    process.exit(1);
+  }
+  if (!await fs4.pathExists(projectDistDir)) {
+    logger.error("Build output not found at: " + projectDistDir);
+    process.exit(1);
+  }
+  const pagefindSpinner = ora2("Generating search index with Pagefind...").start();
+  try {
+    await runCommand("npx", ["pagefind", "--site", projectDistDir], {
+      cwd
+    });
+    pagefindSpinner.succeed("Search index generated");
+  } catch (error) {
+    pagefindSpinner.fail("Pagefind indexing failed");
+    logger.error(getErrorMessage(error));
+    process.exit(1);
+  }
+  const sitemapSpinner = ora2("Generating sitemap.xml...").start();
+  try {
+    const baseUrl = docsConfig.metadata?.url || docsConfig.baseUrl || "";
+    await writeSitemap(projectDistDir, baseUrl);
+    sitemapSpinner.succeed("Sitemap generated");
+  } catch (error) {
+    sitemapSpinner.fail("Sitemap generation failed");
+    logger.error(getErrorMessage(error));
+    process.exit(1);
+  }
+  const robotsSpinner = ora2("Generating robots.txt...").start();
+  try {
+    const siteUrl = docsConfig.metadata?.url || "";
+    const sitemapLine = siteUrl ? `
+Sitemap: ${siteUrl}/sitemap.xml` : "";
+    const robotsTxt = `User-agent: *
+Allow: /${sitemapLine}
+`;
+    await fs4.writeFile(path5.join(projectDistDir, "robots.txt"), robotsTxt, "utf-8");
+    robotsSpinner.succeed("robots.txt generated");
+  } catch (error) {
+    robotsSpinner.fail("robots.txt generation failed");
+    logger.error(getErrorMessage(error));
+    process.exit(1);
+  }
+  logger.plain("");
+  logger.success("\u2713 Build completed successfully!");
+  logger.plain("");
+  logger.info(chalk5.gray("Output directory:") + " " + chalk5.cyan(projectDistDir));
+  logger.plain("");
+  logger.info(chalk5.gray("To preview the build locally, run:"));
+  logger.info(chalk5.cyan("  opendocs preview"));
+  logger.plain("");
+}
+
+// src/commands/preview.ts
+import { spawn as spawn3 } from "child_process";
+import path6 from "path";
+import fs5 from "fs-extra";
+import chalk6 from "chalk";
+async function preview(options) {
+  const cwd = process.cwd();
+  const distDir = path6.join(cwd, DIST_DIR);
+  if (!await fs5.pathExists(distDir)) {
+    logger.error("Error: dist folder not found.");
+    logger.info(chalk6.gray("The production build has not been created yet."));
+    logger.info(chalk6.gray("Run the build command first:"));
+    logger.info(chalk6.cyan("  opendocs build"));
+    process.exit(1);
+  }
+  logger.info(chalk6.cyan("Starting preview server..."));
+  logger.info(chalk6.gray(`Serving: ${distDir}`));
+  logger.info(chalk6.gray(`Port: ${options.port}`));
+  logger.plain("");
+  logger.success(`  Local: http://localhost:${options.port}`);
+  logger.plain("");
+  const child = spawn3(
+    "npx",
+    ["serve", distDir, "-l", options.port],
+    {
+      cwd,
+      stdio: "inherit",
+      shell: true
+    }
+  );
+  attachProcessHandlers(child, "preview server");
+}
+
+// src/commands/deploy.ts
+import path7 from "path";
+import fs6 from "fs-extra";
+import chalk7 from "chalk";
+import ora3 from "ora";
+import * as tar from "tar-stream";
+import { createGzip } from "zlib";
+import { password } from "@inquirer/prompts";
+
+// src/utils/format.ts
+function formatBytes(bytes) {
+  if (bytes === 0) return "0 B";
+  const k = 1024;
+  const sizes = ["B", "KB", "MB", "GB"];
+  const i = Math.floor(Math.log(bytes) / Math.log(k));
+  return `${parseFloat((bytes / Math.pow(k, i)).toFixed(2))} ${sizes[i]}`;
+}
+
+// src/commands/deploy.ts
+async function deploy(options = {}) {
+  const cwd = process.cwd();
+  const distDir = path7.join(cwd, DIST_DIR);
+  const docsJsonPath = await requireDocsJson(cwd);
+  const docsConfig = await loadDocsConfig(docsJsonPath);
+  const siteId = docsConfig.backend?.siteId;
+  if (!siteId) {
+    logger.error("Error: No siteId configured in docs.json");
+    logger.info(chalk7.gray("Add the following to your docs.json:"));
+    logger.info(
+      chalk7.cyan(`  "backend": {
+    "siteId": "your-site-id"
+  }`)
+    );
+    process.exit(1);
+  }
+  logger.info(chalk7.cyan("\u{1F511} Authentication required\n"));
+  let apiKey;
+  try {
+    apiKey = await password({
+      message: "Deploy key:",
+      mask: "*"
+    });
+  } catch (err) {
+    logger.error("\nPrompt error: " + getErrorMessage(err));
+    logger.info(chalk7.yellow("Deployment cancelled."));
+    process.exit(0);
+  }
+  if (!apiKey || !apiKey.trim()) {
+    logger.error("\nError: Deploy key is required.");
+    process.exit(1);
+  }
+  logger.plain("");
+  if (!options.skipBuild) {
+    await build();
+    logger.plain("");
+  }
+  if (!await fs6.pathExists(distDir)) {
+    logger.error("Error: dist folder not found.");
+    logger.info(
+      chalk7.gray("Run 'opendocs build' first or remove --skip-build.")
+    );
+    process.exit(1);
+  }
+  logger.info(chalk7.cyan("\u{1F680} Deploying documentation...\n"));
+  const tarballSpinner = ora3("Creating deployment package...").start();
+  let tarballBuffer;
+  try {
+    tarballBuffer = await createTarball(distDir);
+    tarballSpinner.succeed(
+      `Created deployment package (${formatBytes(tarballBuffer.length)})`
+    );
+  } catch (error) {
+    tarballSpinner.fail("Failed to create deployment package");
+    logger.error(getErrorMessage(error));
+    process.exit(1);
+  }
+  const uploadSpinner = ora3("Uploading to server...").start();
+  try {
+    const apiUrl = docsConfig.backend?.apiUrl || DEFAULT_API_URL;
+    const deployUrl = `${apiUrl}/api/sites/${siteId}/deploy`;
+    const response = await fetch(deployUrl, {
+      method: "POST",
+      headers: {
+        Authorization: `Bearer ${apiKey}`,
+        "Content-Type": "application/gzip"
+      },
+      body: new Uint8Array(tarballBuffer)
+    });
+    if (!response.ok) {
+      const errorBody = await response.text();
+      let errorMessage = `Upload failed with status ${response.status}`;
+      try {
+        const errorJson = JSON.parse(errorBody);
+        if (errorJson.error) {
+          errorMessage = errorJson.error;
+        }
+      } catch {
+        logger.error("Error: " + errorBody);
+      }
+      throw new Error(errorMessage);
+    }
+    const result = await response.json();
+    uploadSpinner.succeed("Upload complete");
+    logger.plain("");
+    logger.success("\u2713 Deployment successful!");
+    logger.plain("");
+    logger.info(
+      chalk7.gray("Version:") + " " + chalk7.cyan(`v${result.version}`)
+    );
+    logger.info(
+      chalk7.gray("Files:") + " " + chalk7.cyan(result.fileCount.toString())
+    );
+    logger.info(
+      chalk7.gray("Size:") + " " + chalk7.cyan(formatBytes(result.sizeBytes))
+    );
+    if (result.url) {
+      logger.plain("");
+      logger.info(chalk7.gray("Your docs are live at:"));
+      logger.info(chalk7.cyan.bold(`  ${result.url}`));
+    } else {
+      logger.plain("");
+      logger.info(
+        chalk7.yellow(
+          "Note: Configure a subdomain to access your docs publicly."
+        )
+      );
+    }
+    logger.plain("");
+  } catch (error) {
+    uploadSpinner.fail("Deployment failed");
+    logger.error(getErrorMessage(error));
+    process.exit(1);
+  }
+}
+async function createTarball(distDir) {
+  const pack2 = tar.pack();
+  const gzip = createGzip();
+  const chunks = [];
+  const bufferPromise = new Promise((resolve, reject) => {
+    gzip.on("data", (chunk) => {
+      chunks.push(chunk);
+    });
+    gzip.on("end", () => {
+      resolve(Buffer.concat(chunks));
+    });
+    gzip.on("error", reject);
+    pack2.on("error", reject);
+  });
+  pack2.pipe(gzip);
+  await addFilesToPack(pack2, distDir, "");
+  pack2.finalize();
+  return bufferPromise;
+}
+async function addFilesToPack(pack2, baseDir, relativePath) {
+  const fullPath = path7.join(baseDir, relativePath);
+  const entries = await fs6.readdir(fullPath, { withFileTypes: true });
+  for (const entry of entries) {
+    const entryRelativePath = path7.join(relativePath, entry.name);
+    if (entry.isDirectory()) {
+      await addFilesToPack(pack2, baseDir, entryRelativePath);
+    } else if (entry.isFile()) {
+      const filePath = path7.join(baseDir, entryRelativePath);
+      const content = await fs6.readFile(filePath);
+      const stats = await fs6.stat(filePath);
+      await new Promise((resolve, reject) => {
+        const entry2 = pack2.entry(
+          {
+            name: entryRelativePath,
+            size: content.length,
+            mtime: stats.mtime
+          },
+          (err) => {
+            if (err) reject(err);
+            else resolve();
+          }
+        );
+        entry2.end(content);
+      });
+    }
+  }
+}
+
+// bin/opendocs.ts
+var program = new Command();
+program.name(CLI_NAME).description("Beautiful docs with zero config. One codebase, deploy anywhere.").version(CLI_VERSION);
+program.command("init [name]").description("Initialize a new opendocs project").action(async (name) => {
+  await init(name);
+});
+program.command("dev").description("Start the development server with hot reload").option("-p, --port <port>", "Port to run the dev server on", "4321").action(async (options) => {
+  await dev(options);
+});
+program.command("build").description("Build the documentation site for production").action(async () => {
+  await build();
+});
+program.command("preview").description("Preview the production build locally").option("-p, --port <port>", "Port to run the preview server on", "4321").action(async (options) => {
+  await preview(options);
+});
+program.command("deploy").description("Deploy documentation to the hosted platform").option("--skip-build", "Skip the build step (use existing dist folder)").action(async (options) => {
+  await deploy(options);
+});
+program.parse(process.argv);
+//# sourceMappingURL=opendocs.js.map