@raystack/chronicle 0.5.4 → 0.6.0

package/dist/cli/index.js

@@ -91,8 +91,9 @@ async function readChronicleConfig(projectRoot, configPath) {
   }
 }
 async function createViteConfig(options) {
-  const { packageRoot, projectRoot, contentDir, configPath, preset } = options;
+  const { packageRoot, projectRoot, configPath, preset } = options;
   const rawConfig = await readChronicleConfig(projectRoot, configPath);
+  const contentMirror = path4.resolve(packageRoot, ".content");
   return {
     root: packageRoot,
     configFile: false,
@@ -134,9 +135,9 @@ async function createViteConfig(options) {
     ],
     resolve: {
       alias: {
-        "@": path4.resolve(packageRoot, "src")
+        "@": path4.resolve(packageRoot, "src"),
+        tslib: "tslib/tslib.es6.js"
       },
-      conditions: ["module-sync", "import", "node"],
       dedupe: [
         "react",
         "react-dom",
@@ -147,11 +148,11 @@ async function createViteConfig(options) {
     },
     server: {
       fs: {
-        allow: [packageRoot, projectRoot, contentDir]
+        allow: [packageRoot, projectRoot, contentMirror]
       }
     },
     define: {
-      __CHRONICLE_CONTENT_DIR__: JSON.stringify(contentDir),
+      __CHRONICLE_CONTENT_DIR__: JSON.stringify(contentMirror),
       __CHRONICLE_PROJECT_ROOT__: JSON.stringify(projectRoot),
       __CHRONICLE_CONFIG_RAW__: JSON.stringify(rawConfig)
     },
@@ -199,6 +200,7 @@ import chalk from "chalk";
 import { parse } from "yaml";
 
 // src/types/config.ts
+import uniqBy from "lodash/uniqBy.js";
 import { z } from "zod";
 var logoSchema = z.object({
   light: z.string().optional(),
@@ -237,16 +239,10 @@ var apiSchema = z.object({
   name: z.string(),
   spec: z.string(),
   basePath: z.string(),
+  icon: z.string().optional(),
   server: apiServerSchema,
   auth: apiAuthSchema.optional()
 });
-var footerSchema = z.object({
-  copyright: z.string().optional(),
-  links: z.array(navLinkSchema).optional()
-});
-var llmsSchema = z.object({
-  enabled: z.boolean().optional()
-});
 var googleAnalyticsSchema = z.object({
   measurementId: z.string()
 });
@@ -259,21 +255,112 @@ var telemetrySchema = z.object({
   serviceName: z.string().optional(),
   port: z.number().int().min(1).max(65535).default(9090)
 });
-var chronicleConfigSchema = z.object({
+var siteSchema = z.object({
   title: z.string(),
-  description: z.string().optional(),
+  description: z.string().optional()
+});
+var DIR_NAME_PATTERN = /^[a-zA-Z0-9][a-zA-Z0-9._-]*$/;
+var dirNameSchema = z.string().min(1).refine((s) => DIR_NAME_PATTERN.test(s) && s !== "." && s !== "..", {
+  message: 'dir must start with a letter or digit and contain only letters, digits, ".", "_", or "-"'
+});
+var contentEntrySchema = z.object({
+  dir: dirNameSchema,
+  label: z.string().min(1),
+  icon: z.string().optional()
+});
+var badgeVariantSchema = z.enum([
+  "accent",
+  "warning",
+  "danger",
+  "success",
+  "neutral",
+  "gradient"
+]);
+var badgeSchema = z.object({
+  label: z.string().min(1),
+  variant: badgeVariantSchema.default("accent")
+});
+var latestSchema = z.object({
+  label: z.string().min(1),
+  landing: z.boolean().optional()
+});
+var versionSchema = z.object({
+  dir: dirNameSchema,
+  label: z.string().min(1),
+  badge: badgeSchema.optional(),
+  landing: z.boolean().optional(),
+  content: z.array(contentEntrySchema).min(1),
+  api: z.array(apiSchema).optional()
+});
+var allUnique = (items, key) => uniqBy(items, key).length === items.length;
+var RESERVED_ROUTE_SEGMENTS = [
+  "api",
+  "apis",
+  "og",
+  "llms.txt",
+  "robots.txt",
+  "sitemap.xml"
+];
+var chronicleConfigSchema = z.object({
+  site: siteSchema,
   url: z.string().optional(),
-  content: z.string().optional(),
+  content: z.array(contentEntrySchema).min(1),
+  latest: latestSchema.optional(),
+  versions: z.array(versionSchema).optional(),
   preset: z.string().optional(),
   logo: logoSchema.optional(),
   theme: themeSchema.optional(),
   navigation: navigationSchema.optional(),
   search: searchSchema.optional(),
-  footer: footerSchema.optional(),
   api: z.array(apiSchema).optional(),
-  llms: llmsSchema.optional(),
   analytics: analyticsSchema.optional(),
   telemetry: telemetrySchema.optional()
+}).strict().refine((cfg) => allUnique(cfg.content, (c) => c.dir), {
+  message: "content[].dir must be unique",
+  path: ["content"]
+}).refine((cfg) => !cfg.versions || allUnique(cfg.versions, (v) => v.dir), {
+  message: "versions[].dir must be unique",
+  path: ["versions"]
+}).refine((cfg) => !cfg.versions || cfg.versions.every((v) => allUnique(v.content, (c) => c.dir)), {
+  message: "versions[].content[].dir must be unique within each version",
+  path: ["versions"]
+}).refine((cfg) => !cfg.versions || cfg.versions.length === 0 || !!cfg.latest, {
+  message: "latest is required when versions are declared",
+  path: ["latest"]
+}).refine((cfg) => {
+  if (!cfg.versions)
+    return true;
+  const contentDirs = new Set(cfg.content.map((c) => c.dir));
+  return !cfg.versions.some((v) => contentDirs.has(v.dir));
+}, {
+  message: "versions[].dir must not overlap with content[].dir — the URL segment would be shadowed",
+  path: ["versions"]
+}).superRefine((cfg, ctx) => {
+  const reserved = new Set(RESERVED_ROUTE_SEGMENTS);
+  const message = `dir must not be a reserved route segment: ${RESERVED_ROUTE_SEGMENTS.join(", ")}`;
+  cfg.content.forEach((c, i) => {
+    if (reserved.has(c.dir)) {
+      ctx.addIssue({ code: "custom", message, path: ["content", i, "dir"] });
+    }
+  });
+  cfg.versions?.forEach((v, vi) => {
+    if (reserved.has(v.dir)) {
+      ctx.addIssue({
+        code: "custom",
+        message,
+        path: ["versions", vi, "dir"]
+      });
+    }
+    v.content.forEach((c, ci) => {
+      if (reserved.has(c.dir)) {
+        ctx.addIssue({
+          code: "custom",
+          message,
+          path: ["versions", vi, "content", ci, "dir"]
+        });
+      }
+    });
+  });
 });
 // src/cli/utils/config.ts
 function resolveConfigPath(configPath) {
@@ -299,20 +386,13 @@ function validateConfig(raw, configPath) {
   if (!result.success) {
     console.log(chalk.red(`Error: Invalid chronicle.yaml at '${configPath}'`));
     for (const issue of result.error.issues) {
-      const path2 = issue.path.join(".");
-      console.log(chalk.gray(`  ${path2 ? `${path2}: ` : ""}${issue.message}`));
+      const issuePath = issue.path.join(".");
+      console.log(chalk.gray(`  ${issuePath ? `${issuePath}: ` : ""}${issue.message}`));
     }
     process.exit(1);
   }
   return result.data;
 }
-function resolveContentDir(config2, configPath, contentFlag) {
-  if (contentFlag)
-    return path.resolve(contentFlag);
-  if (config2.content)
-    return path.resolve(path.dirname(configPath), config2.content);
-  return path.resolve("content");
-}
 function resolvePreset(config2, presetFlag) {
   return presetFlag ?? config2.preset;
 }
@@ -320,9 +400,9 @@ async function loadCLIConfig(configPath, options) {
   const resolvedConfigPath = resolveConfigPath(configPath) ?? path.join(process.cwd(), "chronicle.yaml");
   const raw = await readConfig(resolvedConfigPath);
   const config2 = validateConfig(raw, resolvedConfigPath);
-  const contentDir = resolveContentDir(config2, resolvedConfigPath, options?.content);
+  const projectRoot = path.dirname(resolvedConfigPath);
   const preset = resolvePreset(config2, options?.preset);
-  return { config: config2, configPath: resolvedConfigPath, contentDir, preset };
+  return { config: config2, configPath: resolvedConfigPath, projectRoot, preset };
 }
 
 // src/cli/utils/resolve.ts
@@ -333,36 +413,116 @@ var PACKAGE_ROOT = path2.resolve(path2.dirname(fileURLToPath(import.meta.url)),
 // src/cli/utils/scaffold.ts
 import fs2 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);
+
+// src/lib/config.ts
+import { parse as parse2 } from "yaml";
+var defaultConfig = chronicleConfigSchema.parse({
+  site: { title: "Documentation" },
+  content: [{ dir: "docs", label: "Docs" }],
+  theme: { name: "default" },
+  search: { enabled: true, placeholder: "Search..." }
+});
+function getLatestContentRoots(config2) {
+  return config2.content.map((c) => ({
+    versionDir: null,
+    versionLabel: config2.latest?.label ?? null,
+    contentDir: c.dir,
+    contentLabel: c.label,
+    contentIcon: c.icon,
+    fsPath: `content/${c.dir}`,
+    urlPrefix: `/${c.dir}`
+  }));
+}
+function getVersionContentRoots(config2, versionDir) {
+  const version = config2.versions?.find((v) => v.dir === versionDir);
+  if (!version)
+    return [];
+  return version.content.map((c) => ({
+    versionDir: version.dir,
+    versionLabel: version.label,
+    contentDir: c.dir,
+    contentLabel: c.label,
+    contentIcon: c.icon,
+    fsPath: `versions/${version.dir}/${c.dir}`,
+    urlPrefix: `/${version.dir}/${c.dir}`
+  }));
+}
+
+// src/cli/utils/scaffold.ts
+async function buildContentMirror(mirrorRoot, projectRoot, config2) {
+  await removeMirror(mirrorRoot);
+  await fs2.mkdir(mirrorRoot, { recursive: true });
+  for (const root of getLatestContentRoots(config2)) {
+    const source = path3.resolve(projectRoot, root.fsPath);
+    const dest = path3.join(mirrorRoot, root.contentDir);
+    await mirrorTree(source, dest);
+  }
+  for (const version of config2.versions ?? []) {
+    const versionMirror = path3.join(mirrorRoot, version.dir);
+    await fs2.mkdir(versionMirror, { recursive: true });
+    for (const root of getVersionContentRoots(config2, version.dir)) {
+      const source = path3.resolve(projectRoot, root.fsPath);
+      const dest = path3.join(versionMirror, root.contentDir);
+      await mirrorTree(source, dest);
+    }
+  }
+}
+function linkContent(projectRoot, config2) {
+  return buildContentMirror(path3.join(PACKAGE_ROOT, ".content"), projectRoot, config2);
+}
+async function mirrorTree(source, dest) {
+  let entries;
   try {
-    const existing = await fs2.readlink(linkPath);
-    if (existing === target)
+    entries = await fs2.readdir(source, { withFileTypes: true });
+  } catch (error) {
+    const err = error;
+    if (err.code === "ENOENT") {
+      throw new Error(`Content directory not found: ${source}`);
+    }
+    throw error;
+  }
+  await fs2.mkdir(dest, { recursive: true });
+  for (const entry of entries) {
+    const sourcePath = path3.join(source, entry.name);
+    const destPath = path3.join(dest, entry.name);
+    if (entry.isDirectory()) {
+      await mirrorTree(sourcePath, destPath);
+    } else if (entry.isFile() || entry.isSymbolicLink()) {
+      await fs2.symlink(sourcePath, destPath);
+    }
+  }
+}
+async function removeMirror(mirrorRoot) {
+  try {
+    const stat = await fs2.lstat(mirrorRoot);
+    if (stat.isSymbolicLink() || stat.isFile()) {
+      await fs2.unlink(mirrorRoot);
+    } else if (stat.isDirectory()) {
+      await fs2.rm(mirrorRoot, { recursive: true, force: true });
+    }
+  } catch (error) {
+    if (error.code === "ENOENT")
       return;
-    await fs2.unlink(linkPath);
-  } catch {}
-  await fs2.symlink(target, linkPath);
+    throw error;
+  }
 }
 
 // src/cli/commands/build.ts
-var buildCommand = new Command("build").description("Build for production").option("--content <path>", "Content directory").option("--config <path>", "Path to chronicle.yaml").option("--preset <preset>", "Deploy preset (vercel, cloudflare, node-server)").action(async (options) => {
-  const { contentDir, configPath, preset } = await loadCLIConfig(options.config, {
-    content: options.content,
+var buildCommand = new Command("build").description("Build for production").option("--config <path>", "Path to chronicle.yaml").option("--preset <preset>", "Deploy preset (vercel, cloudflare, node-server)").action(async (options) => {
+  const { config: config2, projectRoot, configPath, preset } = await loadCLIConfig(options.config, {
     preset: options.preset
   });
-  await linkContent(contentDir);
+  await linkContent(projectRoot, config2);
   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 config2 = await createViteConfig2({
+  const viteConfig = await createViteConfig2({
     packageRoot: PACKAGE_ROOT,
-    projectRoot: process.cwd(),
-    contentDir,
+    projectRoot,
     configPath,
     preset
   });
-  const builder = await createBuilder({ ...config2, builder: {} });
+  const builder = await createBuilder({ ...viteConfig, builder: {} });
   await builder.buildApp();
   console.log(chalk2.green("Build complete"));
   console.log(chalk2.cyan("Run `chronicle start` to start the server"));
@@ -371,17 +531,17 @@ var buildCommand = new Command("build").description("Build for production").opti
 // 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("--content <path>", "Content directory").option("--config <path>", "Path to chronicle.yaml").option("--host <host>", "Host address", "localhost").action(async (options) => {
-  const { contentDir, configPath } = await loadCLIConfig(options.config, { content: options.content });
+var devCommand = new Command2("dev").description("Start development server").option("-p, --port <port>", "Port number", "3000").option("--config <path>", "Path to chronicle.yaml").option("--host <host>", "Host address", "localhost").action(async (options) => {
+  const { config: config2, projectRoot, configPath } = await loadCLIConfig(options.config);
   const port = parseInt(options.port, 10);
-  await linkContent(contentDir);
+  await linkContent(projectRoot, config2);
   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 config2 = await createViteConfig2({ packageRoot: PACKAGE_ROOT, projectRoot: process.cwd(), contentDir, configPath });
+  const viteConfig = await createViteConfig2({ packageRoot: PACKAGE_ROOT, projectRoot, configPath });
   const server = await createServer({
-    ...config2,
-    server: { ...config2.server, port, host: options.host }
+    ...viteConfig,
+    server: { ...viteConfig.server, port, host: options.host }
   });
   await server.listen();
   server.printUrls();
@@ -393,9 +553,12 @@ 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",
+var defaultInitConfig = {
+  site: {
+    title: "My Documentation",
+    description: "Documentation powered by Chronicle"
+  },
+  content: [{ dir: "docs", label: "Docs" }],
   theme: { name: "default" },
   search: { enabled: true, placeholder: "Search documentation..." }
 };
@@ -409,44 +572,61 @@ order: 1
 
 This is your documentation home page.
 `;
-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 contentDir = path5.join(projectDir, options.content);
+var GITIGNORE_ENTRIES = ["node_modules", "dist", ".output"];
+function runInit(projectDir) {
+  const events = [];
+  const defaultDir = defaultInitConfig.content[0].dir;
+  const contentDir = path5.join(projectDir, "content", defaultDir);
   if (!fs4.existsSync(contentDir)) {
     fs4.mkdirSync(contentDir, { recursive: true });
-    console.log(chalk4.green("✓"), "Created", contentDir);
+    events.push({ type: "created", path: contentDir });
   }
   const configPath = path5.join(projectDir, "chronicle.yaml");
   if (!fs4.existsSync(configPath)) {
-    fs4.writeFileSync(configPath, stringify(defaultConfig));
-    console.log(chalk4.green("✓"), "Created", configPath);
+    fs4.writeFileSync(configPath, stringify(defaultInitConfig));
+    events.push({ type: "created", path: configPath });
   } else {
-    console.log(chalk4.yellow("⚠"), configPath, "already exists");
+    events.push({ type: "skipped", path: configPath, detail: "already exists" });
   }
   const contentFiles = fs4.readdirSync(contentDir);
   if (contentFiles.length === 0) {
     const indexPath = path5.join(contentDir, "index.mdx");
     fs4.writeFileSync(indexPath, sampleMdx);
-    console.log(chalk4.green("✓"), "Created", indexPath);
+    events.push({ type: "created", path: indexPath });
   }
   const gitignorePath = path5.join(projectDir, ".gitignore");
-  const gitignoreEntries = ["node_modules", "dist", ".output"];
   if (fs4.existsSync(gitignorePath)) {
     const existing = fs4.readFileSync(gitignorePath, "utf-8");
-    const missing = gitignoreEntries.filter((e) => !existing.includes(e));
+    const existingLines = new Set(existing.split(/\r?\n/).map((l) => l.trim()).filter(Boolean));
+    const missing = GITIGNORE_ENTRIES.filter((e) => !existingLines.has(e));
     if (missing.length > 0) {
       fs4.appendFileSync(gitignorePath, `
 ${missing.join(`
 `)}
 `);
-      console.log(chalk4.green("✓"), "Added", missing.join(", "), "to .gitignore");
+      events.push({ type: "updated", path: gitignorePath, detail: missing.join(", ") });
     }
   } else {
-    fs4.writeFileSync(gitignorePath, `${gitignoreEntries.join(`
+    fs4.writeFileSync(gitignorePath, `${GITIGNORE_ENTRIES.join(`
 `)}
 `);
-    console.log(chalk4.green("✓"), "Created .gitignore");
+    events.push({ type: "created", path: gitignorePath });
+  }
+  return events;
+}
+function formatEvent(e) {
+  if (e.type === "skipped") {
+    return `${chalk4.yellow("⚠")} ${e.path}${e.detail ? ` ${e.detail}` : ""}`;
   }
+  if (e.type === "updated") {
+    return `${chalk4.green("✓")} Updated ${e.path}${e.detail ? ` (+${e.detail})` : ""}`;
+  }
+  return `${chalk4.green("✓")} Created ${e.path}`;
+}
+var initCommand = new Command3("init").description("Initialize a new Chronicle project").action(() => {
+  const events = runInit(process.cwd());
+  for (const e of events)
+    console.log(formatEvent(e));
   console.log(chalk4.green(`
 ✓ Chronicle initialized!`));
   console.log(`
@@ -456,27 +636,25 @@ Run`, chalk4.cyan("chronicle dev"), "to start development server");
 // 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("--content <path>", "Content directory").option("--config <path>", "Path to chronicle.yaml").option("--host <host>", "Host address", "localhost").option("--preset <preset>", "Deploy preset (vercel, cloudflare, node-server)").action(async (options) => {
-  const { contentDir, configPath, preset } = await loadCLIConfig(options.config, {
-    content: options.content,
+var serveCommand = new Command4("serve").description("Build and start production server").option("-p, --port <port>", "Port number", "3000").option("--config <path>", "Path to chronicle.yaml").option("--host <host>", "Host address", "localhost").option("--preset <preset>", "Deploy preset (vercel, cloudflare, node-server)").action(async (options) => {
+  const { config: config2, projectRoot, configPath, preset } = await loadCLIConfig(options.config, {
     preset: options.preset
   });
   const port = parseInt(options.port, 10);
-  await linkContent(contentDir);
+  await linkContent(projectRoot, config2);
   const { build, preview } = await import("vite");
   const { createViteConfig: createViteConfig2 } = await Promise.resolve().then(() => (init_vite_config(), exports_vite_config));
-  const config2 = await createViteConfig2({
+  const viteConfig = await createViteConfig2({
     packageRoot: PACKAGE_ROOT,
-    projectRoot: process.cwd(),
-    contentDir,
+    projectRoot,
     configPath,
     preset
   });
   console.log(chalk5.cyan("Building for production..."));
-  await build(config2);
+  await build(viteConfig);
   console.log(chalk5.cyan("Starting production server..."));
   const server = await preview({
-    ...config2,
+    ...viteConfig,
     preview: { port, host: options.host }
   });
   server.printUrls();
@@ -485,16 +663,16 @@ var serveCommand = new Command4("serve").description("Build and start production
 // src/cli/commands/start.ts
 import chalk6 from "chalk";
 import { Command as Command5 } from "commander";
-var startCommand = new Command5("start").description("Start production server").option("-p, --port <port>", "Port number", "3000").option("--content <path>", "Content directory").option("--host <host>", "Host address", "localhost").action(async (options) => {
-  const { contentDir, configPath } = await loadCLIConfig(undefined, { content: options.content });
+var startCommand = new Command5("start").description("Start production server").option("-p, --port <port>", "Port number", "3000").option("--config <path>", "Path to chronicle.yaml").option("--host <host>", "Host address", "localhost").action(async (options) => {
+  const { config: config2, projectRoot, configPath } = await loadCLIConfig(options.config);
   const port = parseInt(options.port, 10);
-  await linkContent(contentDir);
+  await linkContent(projectRoot, config2);
   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 config2 = await createViteConfig2({ packageRoot: PACKAGE_ROOT, projectRoot: process.cwd(), contentDir, configPath });
+  const viteConfig = await createViteConfig2({ packageRoot: PACKAGE_ROOT, projectRoot, configPath });
   const server = await preview({
-    ...config2,
+    ...viteConfig,
     preview: { port, host: options.host }
   });
   server.printUrls();

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@raystack/chronicle",
-  "version": "0.5.4",
+  "version": "0.6.0",
   "description": "Config-driven documentation framework",
   "license": "Apache-2.0",
   "type": "module",
@@ -16,7 +16,8 @@
   },
   "scripts": {
     "build:cli": "bun build-cli.ts",
-    "lint": "biome lint src/"
+    "lint": "biome lint src/",
+    "test": "bun test"
   },
   "devDependencies": {
     "@biomejs/biome": "^2.3.13",
@@ -41,20 +42,20 @@
     "@opentelemetry/resources": "^2.6.1",
     "@opentelemetry/sdk-metrics": "^2.6.1",
     "@opentelemetry/semantic-conventions": "^1.40.0",
-    "@raystack/apsara": "0.55.1",
+    "@raystack/apsara": "1.0.0-rc.4",
     "@shikijs/rehype": "^4.0.2",
     "@vitejs/plugin-react": "^6.0.1",
+    "beautiful-mermaid": "^1.1.3",
     "chalk": "^5.6.2",
     "class-variance-authority": "^0.7.1",
     "codemirror": "^6.0.2",
     "commander": "^14.0.2",
-    "fumadocs-core": "16.6.15",
-    "fumadocs-mdx": "14.2.6",
+    "fumadocs-core": "16.8.1",
+    "fumadocs-mdx": "14.3.1",
     "glob": "^11.0.0",
     "gray-matter": "^4.0.3",
     "h3": "^2.0.1-rc.16",
     "lodash": "^4.17.23",
-    "mermaid": "^11.13.0",
     "minisearch": "^7.2.0",
     "nitro": "3.0.260311-beta",
     "openapi-types": "^12.1.3",
@@ -68,6 +69,7 @@
     "remark-parse": "^11.0.0",
     "satori": "^0.25.0",
     "slugify": "^1.6.6",
+    "std-env": "^4.1.0",
     "unified": "^11.0.5",
     "unist-util-visit": "^5.1.0",
     "vite": "8.0.3",

package/src/cli/commands/build.ts

@@ -6,33 +6,30 @@ import { linkContent } from '@/cli/utils/scaffold';
 
 export const buildCommand = new Command('build')
   .description('Build for production')
-  .option('--content <path>', 'Content directory')
   .option('--config <path>', 'Path to chronicle.yaml')
   .option(
     '--preset <preset>',
     'Deploy preset (vercel, cloudflare, node-server)'
   )
   .action(async options => {
-    const { contentDir, configPath, preset } = await loadCLIConfig(options.config, {
-      content: options.content,
+    const { config, projectRoot, configPath, preset } = await loadCLIConfig(options.config, {
       preset: options.preset,
     });
-    await linkContent(contentDir);
+    await linkContent(projectRoot, config);
 
     console.log(chalk.cyan('Building for production...'));
 
     const { createBuilder } = await import('vite');
     const { createViteConfig } = await import('@/server/vite-config');
 
-    const config = await createViteConfig({
+    const viteConfig = await createViteConfig({
       packageRoot: PACKAGE_ROOT,
-      projectRoot: process.cwd(),
-      contentDir,
+      projectRoot,
       configPath,
       preset
     });
 
-    const builder = await createBuilder({ ...config, builder: {} });
+    const builder = await createBuilder({ ...viteConfig, builder: {} });
     await builder.buildApp();
 
     console.log(chalk.green('Build complete'));

package/src/cli/commands/dev.ts

@@ -7,24 +7,23 @@ import { linkContent } from '@/cli/utils/scaffold';
 export const devCommand = new Command('dev')
   .description('Start development server')
   .option('-p, --port <port>', 'Port number', '3000')
-  .option('--content <path>', 'Content directory')
   .option('--config <path>', 'Path to chronicle.yaml')
   .option('--host <host>', 'Host address', 'localhost')
   .action(async options => {
-    const { contentDir, configPath } = await loadCLIConfig(options.config, { content: options.content });
+    const { config, projectRoot, configPath } = await loadCLIConfig(options.config);
     const port = parseInt(options.port, 10);
 
-    await linkContent(contentDir);
+    await linkContent(projectRoot, config);
 
     console.log(chalk.cyan('Starting dev server...'));
 
     const { createServer } = await import('vite');
     const { createViteConfig } = await import('@/server/vite-config');
 
-    const config = await createViteConfig({ packageRoot: PACKAGE_ROOT, projectRoot: process.cwd(), contentDir, configPath });
+    const viteConfig = await createViteConfig({ packageRoot: PACKAGE_ROOT, projectRoot, configPath });
     const server = await createServer({
-      ...config,
-      server: { ...config.server, port, host: options.host }
+      ...viteConfig,
+      server: { ...viteConfig.server, port, host: options.host }
     });
 
     await server.listen();