barodoc 10.0.9 → 10.0.10

package/dist/chunk-RSVNAYIQ.js

@@ -0,0 +1,518 @@
+// src/runtime/project.ts
+import crypto from "crypto";
+import { createRequire } from "module";
+import fs from "fs-extra";
+import path from "path";
+import { fileURLToPath } from "url";
+import { execa } from "execa";
+import pc from "picocolors";
+var BARODOC_DIR = ".barodoc";
+var __dirname = path.dirname(fileURLToPath(import.meta.url));
+var EXCLUDE_FROM_TEMP = /* @__PURE__ */ new Set([
+  "cac",
+  "execa",
+  "chokidar",
+  "fs-extra",
+  "picocolors"
+]);
+function findMonorepoRoot(barodocPkgRoot) {
+  let dir = barodocPkgRoot;
+  while (dir !== path.parse(dir).root) {
+    const ws = path.join(dir, "pnpm-workspace.yaml");
+    const marker = path.join(dir, "packages", "barodoc", "package.json");
+    if (fs.existsSync(ws) && fs.existsSync(marker)) {
+      return dir;
+    }
+    dir = path.dirname(dir);
+  }
+  return null;
+}
+function barodocMonorepoPackageDir(monorepoRoot, name) {
+  if (!name.startsWith("@barodoc/")) return null;
+  const rest = name.slice("@barodoc/".length);
+  const abs = path.join(monorepoRoot, "packages", rest);
+  return fs.existsSync(path.join(abs, "package.json")) ? abs : null;
+}
+function toFileDep(projectDir, targetDir) {
+  let rel = path.relative(projectDir, targetDir);
+  if (!rel.startsWith(".")) rel = `./${rel}`;
+  return `file:${rel.split(path.sep).join("/")}`;
+}
+function collectPluginNames(config) {
+  const plugins = config.plugins ?? [];
+  const out = [];
+  for (const p of plugins) {
+    const name = Array.isArray(p) ? p[0] : p;
+    if (typeof name === "string") out.push(name);
+  }
+  return [...new Set(out)];
+}
+function resolveDepVersion(name, ver, projectDir, barodocPkgRoot, monorepoRoot, req) {
+  if (monorepoRoot) {
+    const pkgDir = barodocMonorepoPackageDir(monorepoRoot, name);
+    if (pkgDir) return toFileDep(projectDir, pkgDir);
+  }
+  if (ver.startsWith("workspace:")) {
+    try {
+      const resolved = path.dirname(
+        req.resolve(`${name}/package.json`, { paths: [barodocPkgRoot] })
+      );
+      return toFileDep(projectDir, resolved);
+    } catch {
+      throw new Error(
+        `Cannot resolve ${name} for quick mode. Install barodoc from npm or run from the Barodoc monorepo.`
+      );
+    }
+  }
+  return ver;
+}
+function resolveExtraPlugin(name, projectDir, barodocPkgRoot, monorepoRoot, req) {
+  if (monorepoRoot) {
+    const pkgDir = barodocMonorepoPackageDir(monorepoRoot, name);
+    if (pkgDir) return toFileDep(projectDir, pkgDir);
+  }
+  if (name.startsWith("@barodoc/")) {
+    try {
+      const resolved = path.dirname(
+        req.resolve(`${name}/package.json`, { paths: [barodocPkgRoot] })
+      );
+      return toFileDep(projectDir, resolved);
+    } catch {
+      return "*";
+    }
+  }
+  return "*";
+}
+function resolveTempPackageJsonSync(projectDir, config, barodocPkgRoot, monorepoRoot) {
+  const raw = fs.readJsonSync(path.join(barodocPkgRoot, "package.json"));
+  const req = createRequire(path.join(barodocPkgRoot, "package.json"));
+  const deps = {};
+  for (const [name, ver] of Object.entries(raw.dependencies)) {
+    if (EXCLUDE_FROM_TEMP.has(name)) continue;
+    deps[name] = resolveDepVersion(
+      name,
+      ver,
+      projectDir,
+      barodocPkgRoot,
+      monorepoRoot,
+      req
+    );
+  }
+  for (const pluginName of collectPluginNames(config)) {
+    if (deps[pluginName]) continue;
+    deps[pluginName] = resolveExtraPlugin(
+      pluginName,
+      projectDir,
+      barodocPkgRoot,
+      monorepoRoot,
+      req
+    );
+  }
+  return {
+    name: "barodoc-temp",
+    private: true,
+    type: "module",
+    dependencies: deps
+  };
+}
+async function materializeWorkspacePackagesAsTarballs(projectDir, deps, monorepoRoot) {
+  const packDir = path.join(projectDir, ".barodoc-packs");
+  const packNpmCache = path.join(projectDir, ".npm-pack-cache");
+  const stageRoot = path.join(packDir, ".stage");
+  await fs.remove(stageRoot).catch(() => {
+  });
+  await fs.ensureDir(packDir);
+  await fs.ensureDir(packNpmCache);
+  const toPack = [];
+  for (const name of Object.keys(deps)) {
+    if (!name.startsWith("@barodoc/")) continue;
+    const spec = deps[name];
+    if (!spec.startsWith("file:")) continue;
+    const rel = spec.replace(/^file:/, "").replace(/^\.\//, "");
+    const absPath = path.resolve(projectDir, rel);
+    try {
+      const st = await fs.stat(absPath);
+      if (!st.isDirectory()) continue;
+    } catch {
+      continue;
+    }
+    if (!await fs.pathExists(path.join(absPath, "package.json"))) continue;
+    toPack.push(name);
+  }
+  const tgzByPackage = /* @__PURE__ */ new Map();
+  for (const name of toPack) {
+    const spec = deps[name];
+    const rel = spec.replace(/^file:/, "").replace(/^\.\//, "");
+    const srcDir = path.resolve(projectDir, rel);
+    const folder = name.slice("@barodoc/".length);
+    const stageDir = path.join(stageRoot, folder);
+    await fs.remove(stageDir).catch(() => {
+    });
+    await fs.copy(srcDir, stageDir, {
+      filter: (p) => !p.split(path.sep).includes("node_modules"),
+      overwrite: true
+    });
+    const pjPath = path.join(stageDir, "package.json");
+    const pj = await fs.readJSON(pjPath);
+    for (const sect of [
+      "dependencies",
+      "peerDependencies",
+      "optionalDependencies",
+      "devDependencies"
+    ]) {
+      const o = pj[sect];
+      if (!o) continue;
+      for (const [depName, depVer] of Object.entries(o)) {
+        if (!depName.startsWith("@barodoc/")) continue;
+        if (depVer !== "workspace:*" && !String(depVer).startsWith("workspace:")) {
+          continue;
+        }
+        const depDir = barodocMonorepoPackageDir(monorepoRoot, depName);
+        if (!depDir) continue;
+        const ver = fs.readJsonSync(path.join(depDir, "package.json")).version;
+        o[depName] = ver;
+      }
+    }
+    await fs.writeJSON(pjPath, pj, { spaces: 2 });
+    const { stdout } = await execa(
+      "npm",
+      ["pack", "--pack-destination", packDir, "--cache", packNpmCache],
+      { cwd: stageDir }
+    );
+    const lines = stdout.trim().split(/\r?\n/).map((l) => l.trim()).filter(Boolean);
+    const tgz = lines[lines.length - 1];
+    if (!tgz) {
+      throw new Error(`npm pack produced no tarball for ${name}`);
+    }
+    tgzByPackage.set(name, tgz);
+  }
+  await fs.remove(stageRoot).catch(() => {
+  });
+  const next = { ...deps };
+  for (const name of toPack) {
+    const tgz = tgzByPackage.get(name);
+    if (!tgz) continue;
+    const tgzAbs = path.join(packDir, tgz);
+    let relOut = path.relative(projectDir, tgzAbs);
+    if (!relOut.startsWith(".")) relOut = `./${relOut}`;
+    next[name] = `file:${relOut.split(path.sep).join("/")}`;
+  }
+  return next;
+}
+function hashQuickModeDeps(pkgJson, monorepoRoot) {
+  const lines = Object.keys(pkgJson.dependencies).sort().map((k) => `${k}@${pkgJson.dependencies[k]}`);
+  const parts = [lines.join("\n")];
+  if (monorepoRoot) {
+    for (const name of Object.keys(pkgJson.dependencies)) {
+      if (!name.startsWith("@barodoc/")) continue;
+      const dir = barodocMonorepoPackageDir(monorepoRoot, name);
+      if (!dir) continue;
+      const pj = path.join(dir, "package.json");
+      if (!fs.existsSync(pj)) continue;
+      const v = fs.readJsonSync(pj);
+      parts.push(`${name}:src@${v.version ?? "0.0.0"}`);
+    }
+  }
+  return crypto.createHash("sha256").update(parts.join("\n")).digest("hex");
+}
+function isCustomProject(dir) {
+  return fs.existsSync(path.join(dir, "astro.config.mjs")) || fs.existsSync(path.join(dir, "astro.config.ts")) || fs.existsSync(path.join(dir, "astro.config.js"));
+}
+async function loadProjectConfig(dir, configFile) {
+  const configPath = configFile ? path.resolve(dir, configFile) : path.join(dir, "barodoc.config.json");
+  if (fs.existsSync(configPath)) {
+    const content = await fs.readFile(configPath, "utf-8");
+    return {
+      config: JSON.parse(content),
+      configPath
+    };
+  }
+  return {
+    config: getDefaultConfig(),
+    configPath: null
+  };
+}
+function getDefaultConfig() {
+  return {
+    name: "Documentation",
+    navigation: [],
+    i18n: {
+      defaultLocale: "en",
+      locales: ["en"]
+    },
+    search: {
+      enabled: true
+    }
+  };
+}
+async function createProject(options) {
+  const { root, docsDir, config } = options;
+  const projectDir = path.join(root, BARODOC_DIR);
+  console.log(pc.dim(`Creating temporary project in ${BARODOC_DIR}/`));
+  await fs.ensureDir(projectDir);
+  const nodeModulesPath = path.join(projectDir, "node_modules");
+  if (await fs.pathExists(nodeModulesPath)) {
+    const st = await fs.lstat(nodeModulesPath);
+    if (st.isSymbolicLink()) {
+      await fs.remove(nodeModulesPath);
+    }
+  }
+  const barodocPkgRoot = path.join(__dirname, "..");
+  const monorepoRoot = findMonorepoRoot(barodocPkgRoot);
+  const pkgSync = resolveTempPackageJsonSync(
+    projectDir,
+    config,
+    barodocPkgRoot,
+    monorepoRoot
+  );
+  const hash = hashQuickModeDeps(pkgSync, monorepoRoot);
+  const hashFile = path.join(projectDir, ".barodoc-deps-hash");
+  const astroMarker = path.join(nodeModulesPath, "astro", "package.json");
+  let prevHash = "";
+  try {
+    prevHash = await fs.readFile(hashFile, "utf8");
+  } catch {
+    prevHash = "";
+  }
+  const needInstall = !await fs.pathExists(astroMarker) || prevHash !== hash;
+  if (needInstall) {
+    if (await fs.pathExists(nodeModulesPath)) {
+      await fs.remove(nodeModulesPath);
+    }
+    await fs.remove(path.join(projectDir, ".barodoc-packs")).catch(() => {
+    });
+    await fs.remove(path.join(projectDir, ".npm-pack-cache")).catch(() => {
+    });
+    console.log(pc.dim("  Installing dependencies in .barodoc/ (npm install)\u2026"));
+    let pkgFinal = pkgSync;
+    if (monorepoRoot) {
+      pkgFinal = {
+        ...pkgSync,
+        dependencies: await materializeWorkspacePackagesAsTarballs(
+          projectDir,
+          pkgSync.dependencies,
+          monorepoRoot
+        )
+      };
+    }
+    await fs.writeJSON(path.join(projectDir, "package.json"), pkgFinal, {
+      spaces: 2
+    });
+    const npmCache = path.join(projectDir, ".npm-cache");
+    await fs.ensureDir(npmCache);
+    await execa(
+      "npm",
+      [
+        "install",
+        "--no-fund",
+        "--no-audit",
+        "--legacy-peer-deps",
+        "--cache",
+        npmCache
+      ],
+      {
+        cwd: projectDir,
+        stdio: "inherit"
+      }
+    );
+    await fs.writeFile(hashFile, hash, "utf8");
+  }
+  await fs.remove(path.join(projectDir, "src"));
+  await fs.remove(path.join(projectDir, "public"));
+  await fs.remove(path.join(projectDir, "overrides"));
+  await fs.writeJSON(path.join(projectDir, "barodoc.config.json"), config, {
+    spaces: 2
+  });
+  await fs.writeJSON(
+    path.join(projectDir, "tsconfig.json"),
+    {
+      extends: "astro/tsconfigs/strict",
+      compilerOptions: {
+        jsx: "react-jsx",
+        jsxImportSource: "react"
+      }
+    },
+    { spaces: 2 }
+  );
+  const contentDir = path.join(projectDir, "src/content");
+  await fs.ensureDir(contentDir);
+  const docsAbsolute = path.resolve(root, docsDir);
+  const docsLink = path.join(contentDir, "docs");
+  if (fs.existsSync(docsAbsolute)) {
+    await fs.copy(docsAbsolute, docsLink);
+  } else {
+    await fs.ensureDir(docsLink);
+  }
+  const blogDir = path.join(root, "blog");
+  const blogLink = path.join(contentDir, "blog");
+  if (fs.existsSync(blogDir)) {
+    await fs.copy(blogDir, blogLink);
+  }
+  const changelogDir = path.join(root, "changelog");
+  const changelogLink = path.join(contentDir, "changelog");
+  if (fs.existsSync(changelogDir)) {
+    await fs.copy(changelogDir, changelogLink);
+  }
+  if (config.sections) {
+    for (const section of config.sections) {
+      const sectionDir = path.join(root, section.slug);
+      const sectionDest = path.join(contentDir, section.slug);
+      if (fs.existsSync(sectionDir)) {
+        await fs.copy(sectionDir, sectionDest);
+        console.log(pc.dim(`  Copied ${section.slug}/ section`));
+      }
+    }
+  }
+  const pagesDir = path.join(root, "pages");
+  const pagesDest = path.join(contentDir, "pages");
+  if (fs.existsSync(pagesDir)) {
+    await fs.copy(pagesDir, pagesDest);
+    console.log(pc.dim("  Copied pages/ directory"));
+  }
+  await fs.writeFile(
+    path.join(contentDir, "config.ts"),
+    generateContentConfig(config),
+    "utf-8"
+  );
+  const publicDir = path.join(root, "public");
+  const publicLink = path.join(projectDir, "public");
+  if (fs.existsSync(publicDir)) {
+    await fs.symlink(publicDir, publicLink, "dir");
+  } else {
+    await fs.ensureDir(publicLink);
+  }
+  const overridesDir = path.join(root, "overrides");
+  const overridesLink = path.join(projectDir, "overrides");
+  if (fs.existsSync(overridesDir)) {
+    await fs.symlink(overridesDir, overridesLink, "dir");
+    console.log(pc.dim("  Linked overrides/ directory"));
+  }
+  await fs.writeFile(
+    path.join(projectDir, "astro.config.mjs"),
+    generateAstroConfigFile(config),
+    "utf-8"
+  );
+  return projectDir;
+}
+async function cleanupProject(root) {
+  const projectDir = path.join(root, BARODOC_DIR);
+  if (fs.existsSync(projectDir)) {
+    await fs.remove(projectDir);
+  }
+}
+function generateAstroConfigFile(config) {
+  const siteLine = config.site ? `
+  site: ${JSON.stringify(config.site)},` : "";
+  const baseLine = config.base ? `
+  base: ${JSON.stringify(config.base)},` : "";
+  return `import { defineConfig } from "astro/config";
+import barodoc from "@barodoc/core";
+import docsTheme from "@barodoc/theme-docs/theme";
+
+export default defineConfig({${siteLine}${baseLine}
+  integrations: [
+    barodoc({
+      config: "./barodoc.config.json",
+      theme: docsTheme(),
+    }),
+  ],
+  vite: {
+    resolve: {
+      preserveSymlinks: false,
+      dedupe: ["react", "react-dom"],
+    },
+    optimizeDeps: {
+      include: ["mermaid"],
+      exclude: [
+        "fsevents",
+        "lightningcss",
+        "@tailwindcss/oxide",
+        "@barodoc/core",
+      ],
+    },
+    ssr: {
+      external: [
+        "fsevents",
+        "lightningcss",
+        "mermaid",
+        "d3-array",
+        "d3-contour",
+      ],
+      noExternal: [/^@barodoc\\//],
+    },
+  },
+});
+`;
+}
+var contentSchema = `z.object({
+    title: z.string().optional(),
+    description: z.string().optional(),
+    tags: z.array(z.string()).optional(),
+    related: z.array(z.string()).optional(),
+    category: z.string().optional(),
+    api_reference: z.boolean().optional(),
+    difficulty: z.enum(["beginner", "intermediate", "advanced"]).optional(),
+    lastUpdated: z.date().optional(),
+    since: z.string().optional(),
+    deprecated: z.union([z.boolean(), z.string()]).optional(),
+    experimental: z.boolean().optional(),
+    changelogUrl: z.string().optional(),
+    slides: z.boolean().optional(),
+  })`;
+function generateContentConfig(config) {
+  const collections = [
+    `docs: defineCollection({ type: "content", schema: ${contentSchema} })`,
+    `blog: defineCollection({
+  type: "content",
+  schema: z.object({
+    title: z.string(),
+    description: z.string().optional(),
+    excerpt: z.string().optional(),
+    date: z.coerce.date().optional(),
+    author: z.string().optional(),
+    image: z.string().optional(),
+    tags: z.array(z.string()).optional(),
+  }),
+})`,
+    `changelog: defineCollection({
+  type: "content",
+  schema: z.object({
+    title: z.string().optional(),
+    version: z.string(),
+    date: z.coerce.date(),
+  }),
+})`,
+    `pages: defineCollection({ type: "content", schema: ${contentSchema} })`
+  ];
+  const sections = config.sections ?? [];
+  for (const section of sections) {
+    collections.push(
+      `${section.slug}: defineCollection({ type: "content", schema: ${contentSchema} })`
+    );
+  }
+  return `import { defineCollection, z } from "astro:content";
+
+export const collections = {
+  ${collections.join(",\n  ")},
+};
+`;
+}
+function findDocsDir(root) {
+  const candidates = ["docs", "content", "src/content/docs"];
+  for (const candidate of candidates) {
+    const fullPath = path.join(root, candidate);
+    if (fs.existsSync(fullPath)) {
+      return candidate;
+    }
+  }
+  return "docs";
+}
+
+export {
+  isCustomProject,
+  loadProjectConfig,
+  createProject,
+  cleanupProject,
+  generateAstroConfigFile,
+  findDocsDir
+};

package/dist/cli.js

@@ -6,21 +6,19 @@ import {
   generateAstroConfigFile,
   isCustomProject,
   loadProjectConfig
-} from "./chunk-IOJKPHZD.js";
+} from "./chunk-RSVNAYIQ.js";
 
 // src/cli.ts
 import cac from "cac";
 import pc10 from "picocolors";
 
 // package.json
-var version = "10.0.9";
+var version = "10.0.10";
 
 // src/commands/serve.ts
 import path from "path";
 import pc from "picocolors";
 import { dev } from "astro";
-import barodoc from "@barodoc/core";
-import docsTheme from "@barodoc/theme-docs/theme";
 async function serve(dir, options) {
   const root = !dir || dir === "." ? path.resolve(process.cwd()) : path.resolve(process.cwd(), dir);
   console.log();
@@ -51,28 +49,11 @@ async function serve(dir, options) {
   console.log();
   const devServer = await dev({
     root: projectDir,
-    configFile: false,
-    integrations: [
-      barodoc({
-        config: "./barodoc.config.json",
-        theme: docsTheme()
-      })
-    ],
-    vite: {
-      resolve: {
-        preserveSymlinks: true
-      },
-      ssr: {
-        noExternal: [/^@barodoc\//]
-      }
-    },
     server: {
       port: options.port,
       host: options.host ? true : void 0,
       open: options.open
-    },
-    ...config.site ? { site: config.site } : {},
-    ...config.base ? { base: config.base } : {}
+    }
   });
   process.on("SIGINT", async () => {
     console.log();
@@ -87,8 +68,6 @@ import pc2 from "picocolors";
 import fs from "fs-extra";
 import { execa } from "execa";
 import { build as astroBuild } from "astro";
-import barodoc2 from "@barodoc/core";
-import docsTheme2 from "@barodoc/theme-docs/theme";
 async function build(dir, options) {
   const root = !dir || dir === "." ? path2.resolve(process.cwd()) : path2.resolve(process.cwd(), dir);
   const outputDir = path2.resolve(root, options.output);
@@ -117,24 +96,7 @@ async function build(dir, options) {
     console.log(pc2.dim("Building site..."));
     await astroBuild({
       root: projectDir,
-      configFile: false,
-      integrations: [
-        barodoc2({
-          config: "./barodoc.config.json",
-          theme: docsTheme2()
-        })
-      ],
-      vite: {
-        resolve: {
-          preserveSymlinks: true
-        },
-        ssr: {
-          noExternal: true
-        }
-      },
-      logLevel: "info",
-      ...config.site ? { site: config.site } : {},
-      ...config.base ? { base: config.base } : {}
+      logLevel: "info"
     });
     console.log();
     console.log(pc2.dim("Generating search index..."));

package/dist/index.d.ts

@@ -9,8 +9,9 @@ interface ProjectOptions {
 }
 /**
  * Create temporary Astro project for quick mode.
- * Only generates config files and content symlinks — no node_modules needed.
- * Astro is invoked programmatically from the CLI process.
+ * Uses a dedicated `npm install` under `.barodoc/` (not a symlink to the CLI
+ * or monorepo root `node_modules`) so quick mode matches real installs and
+ * avoids hoisted dev-tooling conflicts.
  */
 declare function createProject(options: ProjectOptions): Promise<string>;
 /**

package/dist/index.js

@@ -1,7 +1,7 @@
 import {
   cleanupProject,
   createProject
-} from "./chunk-IOJKPHZD.js";
+} from "./chunk-RSVNAYIQ.js";
 
 // src/index.ts
 export * from "@barodoc/core";

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "barodoc",
-  "version": "10.0.9",
+  "version": "10.0.10",
   "description": "Documentation framework powered by Astro",
   "type": "module",
   "bin": {
@@ -31,19 +31,20 @@
     "picocolors": "^1.1.1",
     "react": "^19.0.0",
     "react-dom": "^19.0.0",
+    "scheduler": "^0.27.0",
     "rst-compiler": "^0.5.7",
     "tailwindcss": "^4.0.0",
     "zod": "^3.24.0",
     "zod-to-json-schema": "^3.25.1",
-    "@barodoc/core": "10.0.9",
     "@barodoc/plugin-analytics": "10.0.9",
     "@barodoc/plugin-docsearch": "10.0.3",
     "@barodoc/plugin-llms-txt": "10.0.9",
-    "@barodoc/plugin-og-image": "9.0.3",
-    "@barodoc/plugin-openapi": "10.0.4",
     "@barodoc/plugin-pwa": "10.0.3",
+    "@barodoc/core": "10.0.9",
+    "@barodoc/plugin-og-image": "9.0.3",
     "@barodoc/plugin-rss": "10.0.3",
     "@barodoc/plugin-search": "10.0.9",
+    "@barodoc/plugin-openapi": "10.0.4",
     "@barodoc/plugin-sitemap": "10.0.9",
     "@barodoc/theme-docs": "10.0.9"
   },

package/dist/chunk-IOJKPHZD.js

@@ -1,241 +0,0 @@
-// src/runtime/project.ts
-import fs from "fs-extra";
-import path from "path";
-import { fileURLToPath } from "url";
-import pc from "picocolors";
-var BARODOC_DIR = ".barodoc";
-var __dirname = path.dirname(fileURLToPath(import.meta.url));
-function findCliNodeModules() {
-  let best = null;
-  let dir = __dirname;
-  while (dir !== path.parse(dir).root) {
-    const candidate = path.join(dir, "node_modules");
-    if (fs.existsSync(candidate) && fs.existsSync(path.join(candidate, "@barodoc", "theme-docs"))) {
-      best = candidate;
-    }
-    dir = path.dirname(dir);
-  }
-  if (!best) {
-    throw new Error(
-      "Could not locate node_modules for barodoc runtime dependencies"
-    );
-  }
-  return best;
-}
-function isCustomProject(dir) {
-  return fs.existsSync(path.join(dir, "astro.config.mjs")) || fs.existsSync(path.join(dir, "astro.config.ts")) || fs.existsSync(path.join(dir, "astro.config.js"));
-}
-async function loadProjectConfig(dir, configFile) {
-  const configPath = configFile ? path.resolve(dir, configFile) : path.join(dir, "barodoc.config.json");
-  if (fs.existsSync(configPath)) {
-    const content = await fs.readFile(configPath, "utf-8");
-    return {
-      config: JSON.parse(content),
-      configPath
-    };
-  }
-  return {
-    config: getDefaultConfig(),
-    configPath: null
-  };
-}
-function getDefaultConfig() {
-  return {
-    name: "Documentation",
-    navigation: [],
-    i18n: {
-      defaultLocale: "en",
-      locales: ["en"]
-    },
-    search: {
-      enabled: true
-    }
-  };
-}
-async function createProject(options) {
-  const { root, docsDir, config } = options;
-  const projectDir = path.join(root, BARODOC_DIR);
-  console.log(pc.dim(`Creating temporary project in ${BARODOC_DIR}/`));
-  await fs.remove(projectDir);
-  await fs.ensureDir(projectDir);
-  const cliNodeModules = findCliNodeModules();
-  await fs.symlink(cliNodeModules, path.join(projectDir, "node_modules"), "junction");
-  await fs.writeJSON(
-    path.join(projectDir, "package.json"),
-    { name: "barodoc-temp", private: true },
-    { spaces: 2 }
-  );
-  await fs.writeJSON(path.join(projectDir, "barodoc.config.json"), config, {
-    spaces: 2
-  });
-  await fs.writeJSON(
-    path.join(projectDir, "tsconfig.json"),
-    {
-      extends: "astro/tsconfigs/strict",
-      compilerOptions: {
-        jsx: "react-jsx",
-        jsxImportSource: "react"
-      }
-    },
-    { spaces: 2 }
-  );
-  const contentDir = path.join(projectDir, "src/content");
-  await fs.ensureDir(contentDir);
-  const docsAbsolute = path.resolve(root, docsDir);
-  const docsLink = path.join(contentDir, "docs");
-  if (fs.existsSync(docsAbsolute)) {
-    await fs.copy(docsAbsolute, docsLink);
-  } else {
-    await fs.ensureDir(docsLink);
-  }
-  const blogDir = path.join(root, "blog");
-  const blogLink = path.join(contentDir, "blog");
-  if (fs.existsSync(blogDir)) {
-    await fs.copy(blogDir, blogLink);
-  }
-  const changelogDir = path.join(root, "changelog");
-  const changelogLink = path.join(contentDir, "changelog");
-  if (fs.existsSync(changelogDir)) {
-    await fs.copy(changelogDir, changelogLink);
-  }
-  if (config.sections) {
-    for (const section of config.sections) {
-      const sectionDir = path.join(root, section.slug);
-      const sectionDest = path.join(contentDir, section.slug);
-      if (fs.existsSync(sectionDir)) {
-        await fs.copy(sectionDir, sectionDest);
-        console.log(pc.dim(`  Copied ${section.slug}/ section`));
-      }
-    }
-  }
-  const pagesDir = path.join(root, "pages");
-  const pagesDest = path.join(contentDir, "pages");
-  if (fs.existsSync(pagesDir)) {
-    await fs.copy(pagesDir, pagesDest);
-    console.log(pc.dim("  Copied pages/ directory"));
-  }
-  await fs.writeFile(
-    path.join(contentDir, "config.ts"),
-    generateContentConfig(config),
-    "utf-8"
-  );
-  const publicDir = path.join(root, "public");
-  const publicLink = path.join(projectDir, "public");
-  if (fs.existsSync(publicDir)) {
-    await fs.symlink(publicDir, publicLink, "dir");
-  } else {
-    await fs.ensureDir(publicLink);
-  }
-  const overridesDir = path.join(root, "overrides");
-  const overridesLink = path.join(projectDir, "overrides");
-  if (fs.existsSync(overridesDir)) {
-    await fs.symlink(overridesDir, overridesLink, "dir");
-    console.log(pc.dim("  Linked overrides/ directory"));
-  }
-  return projectDir;
-}
-async function cleanupProject(root) {
-  const projectDir = path.join(root, BARODOC_DIR);
-  if (fs.existsSync(projectDir)) {
-    await fs.remove(projectDir);
-  }
-}
-function generateAstroConfigFile(config) {
-  const siteLine = config.site ? `
-  site: ${JSON.stringify(config.site)},` : "";
-  const baseLine = config.base ? `
-  base: ${JSON.stringify(config.base)},` : "";
-  return `import { defineConfig } from "astro/config";
-import barodoc from "@barodoc/core";
-import docsTheme from "@barodoc/theme-docs/theme";
-
-export default defineConfig({${siteLine}${baseLine}
-  integrations: [
-    barodoc({
-      config: "./barodoc.config.json",
-      theme: docsTheme(),
-    }),
-  ],
-  vite: {
-    resolve: {
-      preserveSymlinks: true,
-    },
-    ssr: {
-      noExternal: true,
-    },
-  },
-});
-`;
-}
-var contentSchema = `z.object({
-    title: z.string().optional(),
-    description: z.string().optional(),
-    tags: z.array(z.string()).optional(),
-    related: z.array(z.string()).optional(),
-    category: z.string().optional(),
-    api_reference: z.boolean().optional(),
-    difficulty: z.enum(["beginner", "intermediate", "advanced"]).optional(),
-    lastUpdated: z.date().optional(),
-    since: z.string().optional(),
-    deprecated: z.union([z.boolean(), z.string()]).optional(),
-    experimental: z.boolean().optional(),
-    changelogUrl: z.string().optional(),
-    slides: z.boolean().optional(),
-  })`;
-function generateContentConfig(config) {
-  const collections = [
-    `docs: defineCollection({ type: "content", schema: ${contentSchema} })`,
-    `blog: defineCollection({
-  type: "content",
-  schema: z.object({
-    title: z.string(),
-    description: z.string().optional(),
-    excerpt: z.string().optional(),
-    date: z.coerce.date().optional(),
-    author: z.string().optional(),
-    image: z.string().optional(),
-    tags: z.array(z.string()).optional(),
-  }),
-})`,
-    `changelog: defineCollection({
-  type: "content",
-  schema: z.object({
-    title: z.string().optional(),
-    version: z.string(),
-    date: z.coerce.date(),
-  }),
-})`,
-    `pages: defineCollection({ type: "content", schema: ${contentSchema} })`
-  ];
-  const sections = config.sections ?? [];
-  for (const section of sections) {
-    collections.push(
-      `${section.slug}: defineCollection({ type: "content", schema: ${contentSchema} })`
-    );
-  }
-  return `import { defineCollection, z } from "astro:content";
-
-export const collections = {
-  ${collections.join(",\n  ")},
-};
-`;
-}
-function findDocsDir(root) {
-  const candidates = ["docs", "content", "src/content/docs"];
-  for (const candidate of candidates) {
-    const fullPath = path.join(root, candidate);
-    if (fs.existsSync(fullPath)) {
-      return candidate;
-    }
-  }
-  return "docs";
-}
-
-export {
-  isCustomProject,
-  loadProjectConfig,
-  createProject,
-  cleanupProject,
-  generateAstroConfigFile,
-  findDocsDir
-};