@raystack/chronicle 0.1.0-canary.a638730 → 0.1.0-canary.bd7f9af

package/dist/cli/index.js

@@ -16,55 +16,104 @@ var __export = (target, all) => {
 var __esm = (fn, res) => () => (fn && (res = fn(fn = 0)), res);
 var __require = /* @__PURE__ */ createRequire(import.meta.url);
 
+// src/lib/remark-unused-directives.ts
+import { visit } from "unist-util-visit";
+var remarkUnusedDirectives = () => {
+  return (tree) => {
+    visit(tree, ["textDirective"], (node) => {
+      const directive = node;
+      if (!directive.data) {
+        const hasAttributes = directive.attributes && Object.keys(directive.attributes).length > 0;
+        const hasChildren = directive.children && directive.children.length > 0;
+        if (!hasAttributes && !hasChildren) {
+          const name = directive.name;
+          if (!name)
+            return;
+          Object.keys(directive).forEach((key) => delete directive[key]);
+          directive.type = "text";
+          directive.value = `:${name}`;
+        }
+      }
+    });
+  };
+}, remark_unused_directives_default;
+var init_remark_unused_directives = __esm(() => {
+  remark_unused_directives_default = remarkUnusedDirectives;
+});
+
 // src/server/vite-config.ts
 var exports_vite_config = {};
 __export(exports_vite_config, {
   createViteConfig: () => createViteConfig
 });
-import path5 from "path";
 import react from "@vitejs/plugin-react";
-import mdx from "@mdx-js/rollup";
+import { remarkDirectiveAdmonition, remarkMdxMermaid } from "fumadocs-core/mdx-plugins";
+import { defineConfig as defineFumadocsConfig } from "fumadocs-mdx/config";
+import mdx from "fumadocs-mdx/vite";
+import { nitro } from "nitro/vite";
+import path4 from "node:path";
 import remarkDirective from "remark-directive";
-import remarkGfm from "remark-gfm";
-import remarkFrontmatter from "remark-frontmatter";
-import remarkMdxFrontmatter from "remark-mdx-frontmatter";
-import rehypeShiki from "@shikijs/rehype";
 async function createViteConfig(options) {
-  const { root, contentDir, isDev = false } = options;
+  const { packageRoot, projectRoot, contentDir, preset } = options;
   return {
-    root,
+    root: packageRoot,
     configFile: false,
+    plugins: [
+      nitro({
+        serverDir: path4.resolve(packageRoot, "src/server"),
+        ...preset && { preset }
+      }),
+      mdx({
+        default: defineFumadocsConfig({
+          mdxOptions: {
+            remarkPlugins: [
+              remarkDirective,
+              [remarkDirectiveAdmonition, {
+                tags: {
+                  CalloutContainer: "Callout",
+                  CalloutTitle: "CalloutTitle",
+                  CalloutDescription: "CalloutDescription"
+                },
+                types: {
+                  note: "accent",
+                  tip: "accent",
+                  info: "accent",
+                  warn: "attention",
+                  warning: "attention",
+                  danger: "alert",
+                  caution: "alert",
+                  success: "success"
+                }
+              }],
+              remark_unused_directives_default,
+              remarkMdxMermaid
+            ]
+          }
+        })
+      }, { index: false }),
+      react()
+    ],
     resolve: {
       alias: {
-        "@": path5.resolve(root, "src"),
-        "@content": contentDir
+        "@": path4.resolve(packageRoot, "src")
       },
-      dedupe: ["react", "react-dom", "react/jsx-runtime", "react/jsx-dev-runtime"]
+      conditions: ["module-sync", "import", "node"],
+      dedupe: [
+        "react",
+        "react-dom",
+        "react/jsx-runtime",
+        "react/jsx-dev-runtime",
+        "react-router"
+      ]
     },
     server: {
       fs: {
-        allow: [root, contentDir]
+        allow: [packageRoot, projectRoot, contentDir]
       }
     },
-    plugins: [
-      mdx({
-        remarkPlugins: [
-          remarkFrontmatter,
-          remarkMdxFrontmatter,
-          remarkGfm,
-          remarkDirective
-        ],
-        rehypePlugins: [
-          [rehypeShiki, { themes: { light: "github-light", dark: "github-dark" }, defaultColor: false }]
-        ],
-        mdExtensions: [".md"],
-        mdxExtensions: [".mdx"]
-      }),
-      react()
-    ],
     define: {
-      "process.env.CHRONICLE_CONTENT_DIR": JSON.stringify(contentDir),
-      "process.env.CHRONICLE_PROJECT_ROOT": JSON.stringify(root)
+      __CHRONICLE_CONTENT_DIR__: JSON.stringify(contentDir),
+      __CHRONICLE_PROJECT_ROOT__: JSON.stringify(projectRoot)
     },
     css: {
       modules: {
@@ -72,348 +121,109 @@ async function createViteConfig(options) {
       }
     },
     ssr: {
-      noExternal: ["@raystack/apsara"]
+      noExternal: ["@raystack/apsara", "dayjs", "fumadocs-core"]
     },
-    build: {
-      rolldownOptions: {
-        input: isDev ? undefined : {
-          client: path5.resolve(root, "src/server/index.html")
-        }
-      }
-    }
-  };
-}
-var init_vite_config = () => {};
-
-// src/server/dev.ts
-var exports_dev = {};
-__export(exports_dev, {
-  startDevServer: () => startDevServer
-});
-import { createServer as createViteServer } from "vite";
-import { createServer } from "http";
-import fsPromises from "fs/promises";
-import { createReadStream } from "fs";
-import path6 from "path";
-import chalk3 from "chalk";
-async function startDevServer(options) {
-  const { port, root, contentDir } = options;
-  const viteConfig = await createViteConfig({ root, contentDir, isDev: true });
-  const vite = await createViteServer({
-    ...viteConfig,
-    server: { middlewareMode: true },
-    appType: "custom"
-  });
-  const templatePath = path6.resolve(root, "src/server/index.html");
-  const server = createServer(async (req, res) => {
-    const url = req.url || "/";
-    try {
-      if (url.startsWith("/@") || url.startsWith("/__vite") || url.startsWith("/node_modules/")) {
-        vite.middlewares(req, res, () => {
-          res.statusCode = 404;
-          res.end();
-        });
-        return;
-      }
-      const contentFile = path6.join(contentDir, decodeURIComponent(url.split("?")[0]));
-      if (!url.endsWith(".md") && !url.endsWith(".mdx")) {
-        try {
-          const stat = await fsPromises.stat(contentFile);
-          if (stat.isFile()) {
-            const ext = path6.extname(contentFile).toLowerCase();
-            const mimeTypes = {
-              ".png": "image/png",
-              ".jpg": "image/jpeg",
-              ".jpeg": "image/jpeg",
-              ".gif": "image/gif",
-              ".svg": "image/svg+xml",
-              ".webp": "image/webp",
-              ".ico": "image/x-icon",
-              ".pdf": "application/pdf",
-              ".json": "application/json",
-              ".yaml": "text/yaml",
-              ".yml": "text/yaml",
-              ".txt": "text/plain"
-            };
-            res.setHeader("Content-Type", mimeTypes[ext] || "application/octet-stream");
-            createReadStream(contentFile).pipe(res);
-            return;
+    environments: {
+      client: {
+        build: {
+          rollupOptions: {
+            input: path4.resolve(packageRoot, "src/server/entry-client.tsx")
           }
-        } catch {}
-      }
-      if (/\.(js|ts|tsx|css|map)(\?|$)/.test(url)) {
-        vite.middlewares(req, res, () => {
-          res.statusCode = 404;
-          res.end();
-        });
-        return;
-      }
-      const { matchRoute } = await vite.ssrLoadModule(path6.resolve(root, "src/server/router.ts"));
-      const routeHandler = matchRoute(new URL(url, `http://localhost:${port}`).href);
-      if (routeHandler) {
-        const request = new Request(new URL(url, `http://localhost:${port}`));
-        const response = await routeHandler(request);
-        res.statusCode = response.status;
-        response.headers.forEach((value, key) => res.setHeader(key, value));
-        const body = await response.text();
-        res.end(body);
-        return;
-      }
-      const pathname = new URL(url, `http://localhost:${port}`).pathname;
-      const slug = pathname === "/" ? [] : pathname.slice(1).split("/").filter(Boolean);
-      const source = await vite.ssrLoadModule(path6.resolve(root, "src/lib/source.ts"));
-      const { mdxComponents } = await vite.ssrLoadModule(path6.resolve(root, "src/components/mdx/index.tsx"));
-      const { loadConfig } = await vite.ssrLoadModule(path6.resolve(root, "src/lib/config.ts"));
-      const config = loadConfig();
-      const { loadApiSpecs } = await vite.ssrLoadModule(path6.resolve(root, "src/lib/openapi.ts"));
-      const apiSpecs = config.api?.length ? loadApiSpecs(config.api) : [];
-      const [tree, sourcePage] = await Promise.all([
-        source.buildPageTree(),
-        source.getPage(slug)
-      ]);
-      let pageData = null;
-      let embeddedData = { config, tree, slug, frontmatter: null, filePath: null };
-      if (sourcePage) {
-        const component = await source.loadPageComponent(sourcePage);
-        const React = await import("react");
-        const MDXBody = component;
-        pageData = {
-          slug,
-          frontmatter: sourcePage.frontmatter,
-          content: MDXBody ? React.createElement(MDXBody, { components: mdxComponents }) : null
-        };
-        embeddedData.frontmatter = sourcePage.frontmatter;
-        embeddedData.filePath = sourcePage.filePath;
+        }
       }
-      let template = await fsPromises.readFile(templatePath, "utf-8");
-      template = await vite.transformIndexHtml(url, template);
-      const dataScript = `<script>window.__PAGE_DATA__ = ${JSON.stringify(embeddedData)}</script>`;
-      template = template.replace("<!--head-outlet-->", `<!--head-outlet-->${dataScript}`);
-      const { render } = await vite.ssrLoadModule(path6.resolve(root, "src/server/entry-server.tsx"));
-      const html = render(url, { config, tree, page: pageData, apiSpecs });
-      const finalHtml = template.replace("<!--ssr-outlet-->", html);
-      res.setHeader("Content-Type", "text/html");
-      res.statusCode = 200;
-      res.end(finalHtml);
-    } catch (e) {
-      vite.ssrFixStacktrace(e);
-      console.error(e);
-      res.statusCode = 500;
-      res.end(e.message);
     }
-  });
-  server.listen(port, () => {
-    console.log(chalk3.cyan(`
-  Chronicle dev server running at:`));
-    console.log(chalk3.green(`  http://localhost:${port}
-`));
-  });
-  const shutdown = () => {
-    vite.close();
-    server.close();
-    process.exit(0);
   };
-  process.on("SIGINT", shutdown);
-  process.on("SIGTERM", shutdown);
-  return { server, vite };
 }
-var init_dev = __esm(() => {
-  init_vite_config();
+var init_vite_config = __esm(() => {
+  init_remark_unused_directives();
 });
 
-// src/server/adapters/vercel.ts
-var exports_vercel = {};
-__export(exports_vercel, {
-  buildVercelOutput: () => buildVercelOutput
-});
-import path7 from "path";
-import fs3 from "fs/promises";
-import { existsSync } from "fs";
-import chalk5 from "chalk";
-async function buildVercelOutput(options) {
-  const { distDir, contentDir, projectRoot } = options;
-  const outputDir = path7.resolve(projectRoot, ".vercel/output");
-  console.log(chalk5.gray("Generating Vercel output..."));
-  await fs3.rm(outputDir, { recursive: true, force: true });
-  const staticDir = path7.resolve(outputDir, "static");
-  const funcDir = path7.resolve(outputDir, "functions/index.func");
-  await fs3.mkdir(staticDir, { recursive: true });
-  await fs3.mkdir(funcDir, { recursive: true });
-  const clientDir = path7.resolve(distDir, "client");
-  await copyDir(clientDir, staticDir);
-  console.log(chalk5.gray("  Copied client assets to static/"));
-  if (existsSync(contentDir)) {
-    await copyContentAssets(contentDir, staticDir);
-    console.log(chalk5.gray("  Copied content assets to static/"));
-  }
-  const serverDir = path7.resolve(distDir, "server");
-  await copyDir(serverDir, funcDir);
-  console.log(chalk5.gray("  Copied server bundle to functions/"));
-  const templateSrc = path7.resolve(clientDir, "src/server/index.html");
-  await fs3.copyFile(templateSrc, path7.resolve(funcDir, "index.html"));
-  await fs3.writeFile(path7.resolve(funcDir, "package.json"), JSON.stringify({ type: "module" }, null, 2));
-  await fs3.writeFile(path7.resolve(funcDir, ".vc-config.json"), JSON.stringify({
-    runtime: "nodejs22.x",
-    handler: "entry-vercel.js",
-    launcherType: "Nodejs"
-  }, null, 2));
-  await fs3.writeFile(path7.resolve(outputDir, "config.json"), JSON.stringify({
-    version: 3,
-    routes: [
-      { handle: "filesystem" },
-      { src: "/(.*)", dest: "/index" }
-    ]
-  }, null, 2));
-  console.log(chalk5.green("Vercel output generated →"), outputDir);
-}
-async function copyDir(src, dest) {
-  await fs3.mkdir(dest, { recursive: true });
-  const entries = await fs3.readdir(src, { withFileTypes: true });
-  for (const entry of entries) {
-    const srcPath = path7.join(src, entry.name);
-    const destPath = path7.join(dest, entry.name);
-    if (entry.isDirectory()) {
-      await copyDir(srcPath, destPath);
-    } else {
-      await fs3.copyFile(srcPath, destPath);
-    }
-  }
-}
-async function copyContentAssets(contentDir, staticDir) {
-  const entries = await fs3.readdir(contentDir, { withFileTypes: true });
-  for (const entry of entries) {
-    const srcPath = path7.join(contentDir, entry.name);
-    if (entry.isDirectory()) {
-      const destSubDir = path7.join(staticDir, entry.name);
-      await copyContentAssetsRecursive(srcPath, destSubDir);
-    } else {
-      const ext = path7.extname(entry.name).toLowerCase();
-      if (CONTENT_EXTENSIONS.has(ext)) {
-        await fs3.copyFile(srcPath, path7.join(staticDir, entry.name));
-      }
-    }
-  }
-}
-async function copyContentAssetsRecursive(srcDir, destDir) {
-  const entries = await fs3.readdir(srcDir, { withFileTypes: true });
-  for (const entry of entries) {
-    const srcPath = path7.join(srcDir, entry.name);
-    if (entry.isDirectory()) {
-      await copyContentAssetsRecursive(srcPath, path7.join(destDir, entry.name));
-    } else {
-      const ext = path7.extname(entry.name).toLowerCase();
-      if (CONTENT_EXTENSIONS.has(ext)) {
-        await fs3.mkdir(destDir, { recursive: true });
-        await fs3.copyFile(srcPath, path7.join(destDir, entry.name));
-      }
-    }
-  }
-}
-var CONTENT_EXTENSIONS;
-var init_vercel = __esm(() => {
-  CONTENT_EXTENSIONS = new Set([
-    ".png",
-    ".jpg",
-    ".jpeg",
-    ".gif",
-    ".svg",
-    ".webp",
-    ".ico",
-    ".pdf",
-    ".json",
-    ".yaml",
-    ".yml",
-    ".txt"
-  ]);
-});
-
-// src/server/prod.ts
-var exports_prod = {};
-__export(exports_prod, {
-  startProdServer: () => startProdServer
-});
-import path9 from "path";
-import chalk7 from "chalk";
-async function startProdServer(options) {
-  const { port, distDir } = options;
-  const serverEntry = path9.resolve(distDir, "server/entry-prod.js");
-  const { startServer } = await import(serverEntry);
-  console.log(chalk7.cyan("Starting production server..."));
-  return startServer({ port, distDir });
-}
-var init_prod = () => {};
-
 // src/cli/index.ts
 import { Command as Command6 } from "commander";
 
-// src/cli/commands/init.ts
+// src/cli/commands/build.ts
+import chalk2 from "chalk";
 import { Command } from "commander";
-import { execSync } from "child_process";
-import fs2 from "fs";
-import path3 from "path";
-import chalk from "chalk";
-import { stringify } from "yaml";
 
-// src/cli/utils/scaffold.ts
-import fs from "fs";
-import path2 from "path";
+// src/cli/utils/config.ts
+import path from "node:path";
+import chalk from "chalk";
+import { parse } from "yaml";
+function resolveContentDir(contentFlag) {
+  if (contentFlag)
+    return path.resolve(contentFlag);
+  return path.resolve("content");
+}
 
 // src/cli/utils/resolve.ts
-import path from "path";
+import path2 from "path";
 import { fileURLToPath } from "url";
-var PACKAGE_ROOT = path.resolve(path.dirname(fileURLToPath(import.meta.url)), "..", "..");
+var PACKAGE_ROOT = path2.resolve(path2.dirname(fileURLToPath(import.meta.url)), "..", "..");
 
 // src/cli/utils/scaffold.ts
-function detectPackageManager() {
-  if (process.env.npm_config_user_agent) {
-    return process.env.npm_config_user_agent.split("/")[0];
-  }
-  const cwd = process.cwd();
-  if (fs.existsSync(path2.join(cwd, "bun.lock")) || fs.existsSync(path2.join(cwd, "bun.lockb")))
-    return "bun";
-  if (fs.existsSync(path2.join(cwd, "pnpm-lock.yaml")))
-    return "pnpm";
-  if (fs.existsSync(path2.join(cwd, "yarn.lock")))
-    return "yarn";
-  return "npm";
-}
-function getChronicleVersion() {
-  const pkgPath = path2.join(PACKAGE_ROOT, "package.json");
-  const pkg = JSON.parse(fs.readFileSync(pkgPath, "utf-8"));
-  return pkg.version;
+import fs from "node:fs/promises";
+import path3 from "node:path";
+async function linkContent(contentDir) {
+  const linkPath = path3.join(PACKAGE_ROOT, ".content");
+  const target = path3.resolve(contentDir);
+  try {
+    const existing = await fs.readlink(linkPath);
+    if (existing === target)
+      return;
+    await fs.unlink(linkPath);
+  } catch {}
+  await fs.symlink(target, linkPath);
 }
 
+// src/cli/commands/build.ts
+var buildCommand = new Command("build").description("Build for production").option("-c, --content <path>", "Content directory").option("--preset <preset>", "Deploy preset (vercel, cloudflare, node-server)").action(async (options) => {
+  const contentDir = resolveContentDir(options.content);
+  await linkContent(contentDir);
+  console.log(chalk2.cyan("Building for production..."));
+  const { createBuilder } = await import("vite");
+  const { createViteConfig: createViteConfig2 } = await Promise.resolve().then(() => (init_vite_config(), exports_vite_config));
+  const config = await createViteConfig2({
+    packageRoot: PACKAGE_ROOT,
+    projectRoot: process.cwd(),
+    contentDir,
+    preset: options.preset
+  });
+  const builder = await createBuilder({ ...config, builder: {} });
+  await builder.buildApp();
+  console.log(chalk2.green("Build complete"));
+});
+
+// src/cli/commands/dev.ts
+import chalk3 from "chalk";
+import { Command as Command2 } from "commander";
+var devCommand = new Command2("dev").description("Start development server").option("-p, --port <port>", "Port number", "3000").option("-c, --content <path>", "Content directory").action(async (options) => {
+  const contentDir = resolveContentDir(options.content);
+  const port = parseInt(options.port, 10);
+  await linkContent(contentDir);
+  console.log(chalk3.cyan("Starting dev server..."));
+  const { createServer } = await import("vite");
+  const { createViteConfig: createViteConfig2 } = await Promise.resolve().then(() => (init_vite_config(), exports_vite_config));
+  const config = await createViteConfig2({ packageRoot: PACKAGE_ROOT, projectRoot: process.cwd(), contentDir });
+  const server = await createServer({
+    ...config,
+    server: { ...config.server, port }
+  });
+  await server.listen();
+  server.printUrls();
+});
+
 // src/cli/commands/init.ts
-function createConfig() {
-  return {
-    title: "My Documentation",
-    description: "Documentation powered by Chronicle",
-    theme: { name: "default" },
-    search: { enabled: true, placeholder: "Search documentation..." }
-  };
-}
-function createPackageJson(name) {
-  return {
-    name,
-    private: true,
-    type: "module",
-    scripts: {
-      dev: "chronicle dev",
-      build: "chronicle build",
-      start: "chronicle start"
-    },
-    dependencies: {
-      "@raystack/chronicle": `^${getChronicleVersion()}`
-    },
-    devDependencies: {
-      "@raystack/tools-config": "0.56.0",
-      "openapi-types": "^12.1.3",
-      typescript: "5.9.3",
-      "@types/react": "^19.2.10",
-      "@types/node": "^25.1.0"
-    }
-  };
-}
+import fs2 from "node:fs";
+import path5 from "node:path";
+import chalk4 from "chalk";
+import { Command as Command3 } from "commander";
+import { stringify } from "yaml";
+var defaultConfig = {
+  title: "My Documentation",
+  description: "Documentation powered by Chronicle",
+  theme: { name: "default" },
+  search: { enabled: true, placeholder: "Search documentation..." }
+};
 var sampleMdx = `---
 title: Welcome
 description: Getting started with your documentation
@@ -424,74 +234,28 @@ order: 1
 
 This is your documentation home page.
 `;
-var initCommand = new Command("init").description("Initialize a new Chronicle project").option("-c, --content <path>", "Content directory name", "content").action((options) => {
+var initCommand = new Command3("init").description("Initialize a new Chronicle project").option("-c, --content <path>", "Content directory name", "content").action((options) => {
   const projectDir = process.cwd();
-  const dirName = path3.basename(projectDir) || "docs";
-  const contentDir = path3.join(projectDir, options.content);
+  const contentDir = path5.join(projectDir, options.content);
   if (!fs2.existsSync(contentDir)) {
     fs2.mkdirSync(contentDir, { recursive: true });
-    console.log(chalk.green("✓"), "Created", contentDir);
+    console.log(chalk4.green("✓"), "Created", contentDir);
   }
-  const packageJsonPath = path3.join(projectDir, "package.json");
-  if (!fs2.existsSync(packageJsonPath)) {
-    fs2.writeFileSync(packageJsonPath, JSON.stringify(createPackageJson(dirName), null, 2) + `
-`);
-    console.log(chalk.green("✓"), "Created", packageJsonPath);
-  } else {
-    const existing = JSON.parse(fs2.readFileSync(packageJsonPath, "utf-8"));
-    const template = createPackageJson(dirName);
-    let updated = false;
-    if (existing.type !== "module") {
-      existing.type = "module";
-      updated = true;
-    }
-    if (!existing.scripts)
-      existing.scripts = {};
-    for (const [key, value] of Object.entries(template.scripts)) {
-      if (!existing.scripts[key]) {
-        existing.scripts[key] = value;
-        updated = true;
-      }
-    }
-    if (!existing.dependencies)
-      existing.dependencies = {};
-    for (const [key, value] of Object.entries(template.dependencies)) {
-      if (!existing.dependencies[key]) {
-        existing.dependencies[key] = value;
-        updated = true;
-      }
-    }
-    if (!existing.devDependencies)
-      existing.devDependencies = {};
-    for (const [key, value] of Object.entries(template.devDependencies)) {
-      if (!existing.devDependencies[key]) {
-        existing.devDependencies[key] = value;
-        updated = true;
-      }
-    }
-    if (updated) {
-      fs2.writeFileSync(packageJsonPath, JSON.stringify(existing, null, 2) + `
-`);
-      console.log(chalk.green("✓"), "Updated", packageJsonPath);
-    } else {
-      console.log(chalk.yellow("⚠"), packageJsonPath, "already has all required entries");
-    }
-  }
-  const configPath = path3.join(projectDir, "chronicle.yaml");
+  const configPath = path5.join(projectDir, "chronicle.yaml");
   if (!fs2.existsSync(configPath)) {
-    fs2.writeFileSync(configPath, stringify(createConfig()));
-    console.log(chalk.green("✓"), "Created", configPath);
+    fs2.writeFileSync(configPath, stringify(defaultConfig));
+    console.log(chalk4.green("✓"), "Created", configPath);
   } else {
-    console.log(chalk.yellow("⚠"), configPath, "already exists");
+    console.log(chalk4.yellow("⚠"), configPath, "already exists");
   }
   const contentFiles = fs2.readdirSync(contentDir);
   if (contentFiles.length === 0) {
-    const indexPath = path3.join(contentDir, "index.mdx");
+    const indexPath = path5.join(contentDir, "index.mdx");
     fs2.writeFileSync(indexPath, sampleMdx);
-    console.log(chalk.green("✓"), "Created", indexPath);
+    console.log(chalk4.green("✓"), "Created", indexPath);
   }
-  const gitignorePath = path3.join(projectDir, ".gitignore");
-  const gitignoreEntries = ["node_modules", "dist"];
+  const gitignorePath = path5.join(projectDir, ".gitignore");
+  const gitignoreEntries = ["node_modules", "dist", ".output"];
   if (fs2.existsSync(gitignorePath)) {
     const existing = fs2.readFileSync(gitignorePath, "utf-8");
     const missing = gitignoreEntries.filter((e) => !existing.includes(e));
@@ -500,151 +264,61 @@ var initCommand = new Command("init").description("Initialize a new Chronicle pr
 ${missing.join(`
 `)}
 `);
-      console.log(chalk.green("✓"), "Added", missing.join(", "), "to .gitignore");
+      console.log(chalk4.green("✓"), "Added", missing.join(", "), "to .gitignore");
     }
   } else {
     fs2.writeFileSync(gitignorePath, `${gitignoreEntries.join(`
 `)}
 `);
-    console.log(chalk.green("✓"), "Created .gitignore");
+    console.log(chalk4.green("✓"), "Created .gitignore");
   }
-  const pm = detectPackageManager();
-  console.log(chalk.cyan(`
-Installing dependencies with ${pm}...`));
-  execSync(`${pm} install`, { cwd: projectDir, stdio: "inherit" });
-  const runCmd = pm === "npm" ? "npx" : pm === "bun" ? "bunx" : `${pm} dlx`;
-  console.log(chalk.green(`
+  console.log(chalk4.green(`
 ✓ Chronicle initialized!`));
   console.log(`
-Run`, chalk.cyan(`${runCmd} chronicle dev`), "to start development server");
+Run`, chalk4.cyan("chronicle dev"), "to start development server");
 });
 
-// src/cli/commands/dev.ts
-import { Command as Command2 } from "commander";
-import chalk4 from "chalk";
-
-// src/cli/utils/config.ts
-import path4 from "path";
-import { parse } from "yaml";
-import chalk2 from "chalk";
-function resolveContentDir(contentFlag) {
-  if (contentFlag)
-    return path4.resolve(contentFlag);
-  if (process.env.CHRONICLE_CONTENT_DIR)
-    return path4.resolve(process.env.CHRONICLE_CONTENT_DIR);
-  return path4.resolve("content");
-}
-
-// src/cli/commands/dev.ts
-var devCommand = new Command2("dev").description("Start development server").option("-p, --port <port>", "Port number", "3000").option("-c, --content <path>", "Content directory").action(async (options) => {
+// src/cli/commands/serve.ts
+import chalk5 from "chalk";
+import { Command as Command4 } from "commander";
+var serveCommand = new Command4("serve").description("Build and start production server").option("-p, --port <port>", "Port number", "3000").option("-c, --content <path>", "Content directory").option("--preset <preset>", "Deploy preset (vercel, cloudflare, node-server)").action(async (options) => {
   const contentDir = resolveContentDir(options.content);
   const port = parseInt(options.port, 10);
-  process.env.CHRONICLE_PROJECT_ROOT = process.cwd();
-  process.env.CHRONICLE_CONTENT_DIR = contentDir;
-  console.log(chalk4.cyan("Starting dev server..."));
-  const { startDevServer: startDevServer2 } = await Promise.resolve().then(() => (init_dev(), exports_dev));
-  await startDevServer2({ port, root: PACKAGE_ROOT, contentDir });
-});
-
-// src/cli/commands/build.ts
-import { Command as Command3 } from "commander";
-import path8 from "path";
-import chalk6 from "chalk";
-var buildCommand = new Command3("build").description("Build for production").option("-c, --content <path>", "Content directory").option("-o, --outDir <path>", "Output directory", "dist").option("--adapter <adapter>", "Deploy adapter (vercel)").action(async (options) => {
-  const contentDir = resolveContentDir(options.content);
-  const outDir = path8.resolve(options.outDir);
-  process.env.CHRONICLE_PROJECT_ROOT = process.cwd();
-  process.env.CHRONICLE_CONTENT_DIR = contentDir;
-  console.log(chalk6.cyan("Building for production..."));
-  const { build } = await import("vite");
+  await linkContent(contentDir);
+  const { build, preview } = await import("vite");
   const { createViteConfig: createViteConfig2 } = await Promise.resolve().then(() => (init_vite_config(), exports_vite_config));
-  const baseConfig = await createViteConfig2({ root: PACKAGE_ROOT, contentDir });
-  console.log(chalk6.gray("Building client..."));
-  await build({
-    ...baseConfig,
-    build: {
-      outDir: path8.join(outDir, "client"),
-      ssrManifest: true,
-      rolldownOptions: {
-        input: path8.resolve(PACKAGE_ROOT, "src/server/index.html")
-      }
-    }
+  const config = await createViteConfig2({
+    packageRoot: PACKAGE_ROOT,
+    projectRoot: process.cwd(),
+    contentDir,
+    preset: options.preset
   });
-  const serverEntry = options.adapter === "vercel" ? path8.resolve(PACKAGE_ROOT, "src/server/entry-vercel.ts") : path8.resolve(PACKAGE_ROOT, "src/server/entry-prod.ts");
-  console.log(chalk6.gray("Building server..."));
-  await build({
-    ...baseConfig,
-    ssr: {
-      noExternal: true
-    },
-    build: {
-      outDir: path8.join(outDir, "server"),
-      ssr: serverEntry
-    }
+  console.log(chalk5.cyan("Building for production..."));
+  await build(config);
+  console.log(chalk5.cyan("Starting production server..."));
+  const server = await preview({
+    ...config,
+    preview: { port }
   });
-  console.log(chalk6.green("Build complete →"), outDir);
-  if (options.adapter === "vercel") {
-    const { buildVercelOutput: buildVercelOutput2 } = await Promise.resolve().then(() => (init_vercel(), exports_vercel));
-    await buildVercelOutput2({
-      distDir: outDir,
-      contentDir,
-      projectRoot: process.cwd()
-    });
-  }
+  server.printUrls();
 });
 
 // src/cli/commands/start.ts
-import { Command as Command4 } from "commander";
-import path10 from "path";
-import chalk8 from "chalk";
-var startCommand = new Command4("start").description("Start production server").option("-p, --port <port>", "Port number", "3000").option("-c, --content <path>", "Content directory").option("-d, --dist <path>", "Dist directory", "dist").action(async (options) => {
-  const contentDir = resolveContentDir(options.content);
-  const port = parseInt(options.port, 10);
-  const distDir = path10.resolve(options.dist);
-  process.env.CHRONICLE_PROJECT_ROOT = process.cwd();
-  process.env.CHRONICLE_CONTENT_DIR = contentDir;
-  console.log(chalk8.cyan("Starting production server..."));
-  const { startProdServer: startProdServer2 } = await Promise.resolve().then(() => (init_prod(), exports_prod));
-  await startProdServer2({ port, root: PACKAGE_ROOT, distDir });
-});
-
-// src/cli/commands/serve.ts
+import chalk6 from "chalk";
 import { Command as Command5 } from "commander";
-import path11 from "path";
-import chalk9 from "chalk";
-var serveCommand = new Command5("serve").description("Build and start production server").option("-p, --port <port>", "Port number", "3000").option("-c, --content <path>", "Content directory").option("-o, --outDir <path>", "Output directory", "dist").action(async (options) => {
+var startCommand = new Command5("start").description("Start production server").option("-p, --port <port>", "Port number", "3000").option("-c, --content <path>", "Content directory").action(async (options) => {
   const contentDir = resolveContentDir(options.content);
   const port = parseInt(options.port, 10);
-  const outDir = path11.resolve(options.outDir);
-  process.env.CHRONICLE_PROJECT_ROOT = process.cwd();
-  process.env.CHRONICLE_CONTENT_DIR = contentDir;
-  console.log(chalk9.cyan("Building for production..."));
-  const { build } = await import("vite");
+  await linkContent(contentDir);
+  console.log(chalk6.cyan("Starting production server..."));
+  const { preview } = await import("vite");
   const { createViteConfig: createViteConfig2 } = await Promise.resolve().then(() => (init_vite_config(), exports_vite_config));
-  const baseConfig = await createViteConfig2({ root: PACKAGE_ROOT, contentDir });
-  await build({
-    ...baseConfig,
-    build: {
-      outDir: path11.join(outDir, "client"),
-      ssrManifest: true,
-      rolldownOptions: {
-        input: path11.resolve(PACKAGE_ROOT, "src/server/index.html")
-      }
-    }
-  });
-  await build({
-    ...baseConfig,
-    ssr: {
-      noExternal: true
-    },
-    build: {
-      outDir: path11.join(outDir, "server"),
-      ssr: path11.resolve(PACKAGE_ROOT, "src/server/entry-prod.ts")
-    }
+  const config = await createViteConfig2({ packageRoot: PACKAGE_ROOT, projectRoot: process.cwd(), contentDir });
+  const server = await preview({
+    ...config,
+    preview: { port }
   });
-  console.log(chalk9.cyan("Starting production server..."));
-  const { startProdServer: startProdServer2 } = await Promise.resolve().then(() => (init_prod(), exports_prod));
-  await startProdServer2({ port, root: PACKAGE_ROOT, distDir: outDir });
+  server.printUrls();
 });
 
 // src/cli/index.ts