@marlinjai/clearify 1.5.0

package/dist/node/chunk-NXQNNLGC.js

@@ -0,0 +1,395 @@
+import {
+  parseOpenAPISpec
+} from "./chunk-B2Q23JW3.js";
+import {
+  loadUserConfig,
+  resolveConfig,
+  resolveSections
+} from "./chunk-IBK35HZR.js";
+import {
+  buildSectionData
+} from "./chunk-L24ILRSX.js";
+
+// src/vite-plugin/index.ts
+import { resolve } from "path";
+import { existsSync, readFileSync } from "fs";
+var VIRTUAL_CONFIG = "virtual:clearify/config";
+var RESOLVED_VIRTUAL_CONFIG = "\0" + VIRTUAL_CONFIG;
+var VIRTUAL_ROUTES = "virtual:clearify/routes";
+var RESOLVED_VIRTUAL_ROUTES = "\0" + VIRTUAL_ROUTES;
+var VIRTUAL_NAVIGATION = "virtual:clearify/navigation";
+var RESOLVED_VIRTUAL_NAVIGATION = "\0" + VIRTUAL_NAVIGATION;
+var VIRTUAL_SEARCH_INDEX = "virtual:clearify/search-index";
+var RESOLVED_VIRTUAL_SEARCH_INDEX = "\0" + VIRTUAL_SEARCH_INDEX;
+var VIRTUAL_MERMAID_SVGS = "virtual:clearify/mermaid-svgs";
+var RESOLVED_VIRTUAL_MERMAID_SVGS = "\0" + VIRTUAL_MERMAID_SVGS;
+var VIRTUAL_OPENAPI_SPEC = "virtual:clearify/openapi-spec";
+var RESOLVED_VIRTUAL_OPENAPI_SPEC = "\0" + VIRTUAL_OPENAPI_SPEC;
+function clearifyPlugin(options = {}) {
+  let config;
+  let userRoot;
+  let resolvedViteConfig;
+  let visibleSections;
+  let sectionDataList;
+  let allRoutes;
+  let allSectionNavigations;
+  let allSearchEntries;
+  let mermaidSvgData = options.mermaidSvgs ?? {};
+  function refreshDocs() {
+    const changelogPath = resolve(userRoot, "CHANGELOG.md");
+    sectionDataList = visibleSections.map(
+      (section) => buildSectionData(section, changelogPath, config.navigation)
+    );
+    allRoutes = sectionDataList.flatMap((sd) => sd.routes);
+    allSectionNavigations = sectionDataList.map((sd) => sd.navigation);
+    let idCounter = 0;
+    allSearchEntries = sectionDataList.flatMap(
+      (sd) => sd.searchEntries.map((entry) => ({ ...entry, id: idCounter++ }))
+    );
+    if (config.openapi?.spec && config.openapi.generatePages !== false) {
+      const basePath = config.openapi.basePath ?? "/api";
+      const specData = loadOpenAPISpecData();
+      if (specData) {
+        let opAnchor2 = function(tag, method, opPath) {
+          const slug = `${method.toLowerCase()}${opPath.replace(/[{}]/g, "")}`;
+          return `${basePath}#tag/${encodeURIComponent(tag)}/${slug}`;
+        };
+        var opAnchor = opAnchor2;
+        const tagGroups = parseOpenAPISpec(specData);
+        const METHOD_COLORS = {
+          GET: "#22c55e",
+          POST: "#3b82f6",
+          PUT: "#f59e0b",
+          DELETE: "#ef4444",
+          PATCH: "#8b5cf6"
+        };
+        const navItems = tagGroups.map((group) => ({
+          label: group.tag,
+          children: group.operations.map((op) => ({
+            label: `${op.summary}`,
+            path: opAnchor2(group.tag, op.method, op.path),
+            badge: op.method,
+            badgeColor: METHOD_COLORS[op.method] ?? "var(--clearify-primary)"
+          }))
+        }));
+        const apiNavSection = {
+          id: "api",
+          label: "API Reference",
+          basePath,
+          navigation: navItems
+        };
+        allSectionNavigations.push(apiNavSection);
+        allRoutes.push({
+          path: `${basePath}/*`,
+          filePath: "",
+          componentPath: "@clearify/theme/components/OpenAPIPage",
+          frontmatter: { title: "API Reference", description: "API documentation" },
+          sectionId: "api"
+        });
+        for (const group of tagGroups) {
+          for (const op of group.operations) {
+            allSearchEntries.push({
+              id: idCounter++,
+              path: opAnchor2(group.tag, op.method, op.path),
+              title: `${op.method} ${op.path}`,
+              description: op.summary,
+              content: `${op.method} ${op.path} - ${op.summary}`,
+              sectionId: "api",
+              sectionLabel: "API Reference"
+            });
+          }
+        }
+      }
+    }
+  }
+  function generateRoutesCode() {
+    const imports = [];
+    const routeEntries = [];
+    allRoutes.forEach((route, i) => {
+      const varName = `Route${i}`;
+      if (route.componentPath) {
+        imports.push(`const ${varName} = () => import('${route.componentPath}');`);
+      } else {
+        imports.push(`const ${varName} = () => import(/* @vite-ignore */ '${route.filePath}');`);
+      }
+      routeEntries.push(
+        `  { path: ${JSON.stringify(route.path)}, component: ${varName}, frontmatter: ${JSON.stringify(route.frontmatter)} }`
+      );
+    });
+    return `${imports.join("\n")}
+export default [
+${routeEntries.join(",\n")}
+];`;
+  }
+  function getAllDocFiles() {
+    const files = [];
+    for (const route of allRoutes) {
+      if (route.filePath.endsWith(".md") || route.filePath.endsWith(".mdx")) {
+        files.push(route.filePath);
+      }
+    }
+    return files;
+  }
+  let cachedSpecData = null;
+  let specDataInitialized = false;
+  function loadOpenAPISpecData() {
+    if (specDataInitialized) return cachedSpecData;
+    specDataInitialized = true;
+    const specPath = config.openapi?.spec;
+    if (!specPath) {
+      cachedSpecData = null;
+      return null;
+    }
+    const resolvedPath = resolve(userRoot, specPath);
+    if (!existsSync(resolvedPath)) {
+      cachedSpecData = null;
+      return null;
+    }
+    try {
+      const content = readFileSync(resolvedPath, "utf-8");
+      const isYaml = /\.ya?ml$/i.test(resolvedPath);
+      if (isYaml) {
+        try {
+          cachedSpecData = JSON.parse(content);
+          return cachedSpecData;
+        } catch {
+          console.warn("  YAML OpenAPI specs require js-yaml for page generation. Install it or use a JSON spec.");
+          cachedSpecData = null;
+          return null;
+        }
+      }
+      cachedSpecData = JSON.parse(content);
+      return cachedSpecData;
+    } catch {
+      cachedSpecData = null;
+      return null;
+    }
+  }
+  function loadOpenAPISpec() {
+    const specPath = config.openapi?.spec;
+    if (!specPath) {
+      return "export default null;";
+    }
+    const resolvedPath = resolve(userRoot, specPath);
+    if (!existsSync(resolvedPath)) {
+      console.warn(`  OpenAPI spec not found: ${resolvedPath}`);
+      return "export default null;";
+    }
+    try {
+      const content = readFileSync(resolvedPath, "utf-8");
+      const isYaml = /\.ya?ml$/i.test(resolvedPath);
+      if (isYaml) {
+        return `export default ${JSON.stringify(content)};`;
+      }
+      JSON.parse(content);
+      return `export default ${content};`;
+    } catch (err) {
+      console.warn(`  Failed to load OpenAPI spec: ${resolvedPath}`, err instanceof Error ? err.message : err);
+      return "export default null;";
+    }
+  }
+  const mainPlugin = {
+    name: "clearify",
+    enforce: "pre",
+    async configResolved(viteConfig) {
+      resolvedViteConfig = viteConfig;
+      userRoot = options.root ?? process.cwd();
+      const userConfig = await loadUserConfig(userRoot);
+      config = resolveConfig(userConfig, userRoot);
+      const allSections = resolveSections(config, userRoot);
+      const isDev = resolvedViteConfig.command === "serve";
+      visibleSections = isDev ? allSections : allSections.filter((s) => !s.draft);
+      refreshDocs();
+    },
+    resolveId(id) {
+      if (id === VIRTUAL_CONFIG) return RESOLVED_VIRTUAL_CONFIG;
+      if (id === VIRTUAL_ROUTES) return RESOLVED_VIRTUAL_ROUTES;
+      if (id === VIRTUAL_NAVIGATION) return RESOLVED_VIRTUAL_NAVIGATION;
+      if (id === VIRTUAL_SEARCH_INDEX) return RESOLVED_VIRTUAL_SEARCH_INDEX;
+      if (id === VIRTUAL_MERMAID_SVGS) return RESOLVED_VIRTUAL_MERMAID_SVGS;
+      if (id === VIRTUAL_OPENAPI_SPEC) return RESOLVED_VIRTUAL_OPENAPI_SPEC;
+      return null;
+    },
+    load(id) {
+      if (id === RESOLVED_VIRTUAL_CONFIG) {
+        return `export default ${JSON.stringify(config)};`;
+      }
+      if (id === RESOLVED_VIRTUAL_ROUTES) {
+        return generateRoutesCode();
+      }
+      if (id === RESOLVED_VIRTUAL_NAVIGATION) {
+        return `export default ${JSON.stringify(allSectionNavigations)};`;
+      }
+      if (id === RESOLVED_VIRTUAL_SEARCH_INDEX) {
+        return `export default ${JSON.stringify(allSearchEntries)};`;
+      }
+      if (id === RESOLVED_VIRTUAL_MERMAID_SVGS) {
+        return `export default ${JSON.stringify(mermaidSvgData)};`;
+      }
+      if (id === RESOLVED_VIRTUAL_OPENAPI_SPEC) {
+        return loadOpenAPISpec();
+      }
+      return null;
+    },
+    configureServer(server) {
+      for (const section of visibleSections) {
+        server.watcher.add(section.docsDir);
+      }
+      const changelogPath = resolve(userRoot, "CHANGELOG.md");
+      if (existsSync(changelogPath)) {
+        server.watcher.add(changelogPath);
+      }
+      if (config.openapi?.spec) {
+        const openapiPath = resolve(userRoot, config.openapi.spec);
+        if (existsSync(openapiPath)) {
+          server.watcher.add(openapiPath);
+        }
+        server.watcher.on("change", (changedPath) => {
+          if (changedPath === openapiPath) {
+            specDataInitialized = false;
+            cachedSpecData = null;
+            refreshDocs();
+            const specMod = server.moduleGraph.getModuleById(RESOLVED_VIRTUAL_OPENAPI_SPEC);
+            if (specMod) server.moduleGraph.invalidateModule(specMod);
+            const routesMod = server.moduleGraph.getModuleById(RESOLVED_VIRTUAL_ROUTES);
+            if (routesMod) server.moduleGraph.invalidateModule(routesMod);
+            const navMod = server.moduleGraph.getModuleById(RESOLVED_VIRTUAL_NAVIGATION);
+            if (navMod) server.moduleGraph.invalidateModule(navMod);
+            const searchMod = server.moduleGraph.getModuleById(RESOLVED_VIRTUAL_SEARCH_INDEX);
+            if (searchMod) server.moduleGraph.invalidateModule(searchMod);
+            server.ws.send({ type: "full-reload" });
+          }
+        });
+      }
+      const mermaidStrategy = options.mermaidStrategy ?? config.mermaid?.strategy ?? "client";
+      if (mermaidStrategy === "build") {
+        let renderer = null;
+        const fileMermaidHashes = /* @__PURE__ */ new Map();
+        const warmUp = async () => {
+          try {
+            const { MermaidRenderer } = await import("./core/mermaid-renderer.js");
+            const { mermaidContentHash } = await import("./core/mermaid-utils.js");
+            const { setPreRenderedMermaidSvgs } = await import("./core/remark-mermaid.js");
+            const cacheDir = resolve(userRoot, "node_modules/.cache/clearify-mermaid");
+            renderer = new MermaidRenderer({ cacheDir });
+            await renderer.launch();
+            const docFiles = getAllDocFiles();
+            const definitions = /* @__PURE__ */ new Map();
+            const mermaidRegex = /```mermaid\s*\n([\s\S]*?)```/g;
+            for (const filePath of docFiles) {
+              if (!existsSync(filePath)) continue;
+              const content = readFileSync(filePath, "utf-8");
+              const hashes = /* @__PURE__ */ new Set();
+              let match;
+              while ((match = mermaidRegex.exec(content)) !== null) {
+                const def = match[1].trim();
+                const hash = mermaidContentHash(def);
+                definitions.set(hash, def);
+                hashes.add(hash);
+              }
+              fileMermaidHashes.set(filePath, hashes);
+            }
+            if (definitions.size === 0) {
+              console.log("  No mermaid diagrams found.");
+              return;
+            }
+            const rendered = await renderer.renderBatch(definitions);
+            const svgRecord = {};
+            const svgMap = /* @__PURE__ */ new Map();
+            for (const [hash, data] of rendered) {
+              svgRecord[hash] = data;
+              svgMap.set(hash, data);
+            }
+            mermaidSvgData = svgRecord;
+            setPreRenderedMermaidSvgs(svgMap);
+            const mermaidMod = server.moduleGraph.getModuleById(RESOLVED_VIRTUAL_MERMAID_SVGS);
+            if (mermaidMod) server.moduleGraph.invalidateModule(mermaidMod);
+            server.ws.send({ type: "full-reload" });
+            console.log(`  Mermaid warm-up complete (${rendered.size} diagrams)`);
+          } catch (err) {
+            console.warn("  Mermaid warm-up failed:", err instanceof Error ? err.message : err);
+          }
+        };
+        setTimeout(warmUp, 100);
+        server.httpServer?.on("close", async () => {
+          if (renderer) {
+            await renderer.close();
+            renderer = null;
+          }
+        });
+        server.watcher.on("change", async (filePath) => {
+          if (!filePath.endsWith(".md") && !filePath.endsWith(".mdx")) return;
+          if (!renderer) return;
+          try {
+            const { mermaidContentHash } = await import("./core/mermaid-utils.js");
+            const { setPreRenderedMermaidSvgs } = await import("./core/remark-mermaid.js");
+            const content = readFileSync(filePath, "utf-8");
+            const mermaidRegex = /```mermaid\s*\n([\s\S]*?)```/g;
+            const currentHashes = /* @__PURE__ */ new Set();
+            const newDefinitions = /* @__PURE__ */ new Map();
+            let match;
+            while ((match = mermaidRegex.exec(content)) !== null) {
+              const def = match[1].trim();
+              const hash = mermaidContentHash(def);
+              currentHashes.add(hash);
+              if (!mermaidSvgData[hash]) {
+                newDefinitions.set(hash, def);
+              }
+            }
+            fileMermaidHashes.set(filePath, currentHashes);
+            if (newDefinitions.size > 0) {
+              const rendered = await renderer.renderBatch(newDefinitions);
+              for (const [hash, data] of rendered) {
+                mermaidSvgData[hash] = data;
+              }
+              const svgMap = new Map(Object.entries(mermaidSvgData));
+              setPreRenderedMermaidSvgs(svgMap);
+              const mermaidMod = server.moduleGraph.getModuleById(RESOLVED_VIRTUAL_MERMAID_SVGS);
+              if (mermaidMod) server.moduleGraph.invalidateModule(mermaidMod);
+            }
+          } catch (err) {
+            console.warn("  Mermaid incremental render failed:", err instanceof Error ? err.message : err);
+          }
+        });
+      }
+      server.watcher.on("all", (event, path) => {
+        const isChangelog = path === changelogPath;
+        const isInSection = visibleSections.some((s) => path.startsWith(s.docsDir));
+        if (!isChangelog && !isInSection) return;
+        if (!path.endsWith(".md") && !path.endsWith(".mdx")) return;
+        if (event === "add" || event === "unlink" || event === "change") {
+          refreshDocs();
+          const routesMod = server.moduleGraph.getModuleById(RESOLVED_VIRTUAL_ROUTES);
+          const navMod = server.moduleGraph.getModuleById(RESOLVED_VIRTUAL_NAVIGATION);
+          const searchMod = server.moduleGraph.getModuleById(RESOLVED_VIRTUAL_SEARCH_INDEX);
+          if (routesMod) server.moduleGraph.invalidateModule(routesMod);
+          if (navMod) server.moduleGraph.invalidateModule(navMod);
+          if (searchMod) server.moduleGraph.invalidateModule(searchMod);
+          server.ws.send({ type: "full-reload" });
+        }
+      });
+    }
+  };
+  const headInjectionPlugin = {
+    name: "clearify-head-injection",
+    transformIndexHtml(html) {
+      const tags = [];
+      if (config.customCss) {
+        const cssPath = resolve(userRoot, config.customCss);
+        const href = `/@fs/${cssPath}`;
+        tags.push(`<link rel="stylesheet" href="${href}" />`);
+      }
+      if (config.headTags && config.headTags.length > 0) {
+        tags.push(...config.headTags);
+      }
+      if (tags.length === 0) return html;
+      return html.replace("</head>", `    ${tags.join("\n    ")}
+  </head>`);
+    }
+  };
+  return [mainPlugin, headInjectionPlugin];
+}
+
+export {
+  clearifyPlugin
+};

package/dist/node/chunk-PRTER35L.js

@@ -0,0 +1,48 @@
+import {
+  mermaidContentHash
+} from "./chunk-SCZZB7OE.js";
+
+// src/core/remark-mermaid.ts
+import { visit } from "unist-util-visit";
+var preRenderedSvgs = null;
+function setPreRenderedMermaidSvgs(svgs) {
+  preRenderedSvgs = svgs;
+}
+function clearPreRenderedMermaidSvgs() {
+  preRenderedSvgs = null;
+}
+function remarkMermaidToComponent() {
+  return (tree) => {
+    visit(tree, "code", (node, index, parent) => {
+      if (node.lang !== "mermaid" || !parent || index === void 0) return;
+      if (preRenderedSvgs) {
+        const hash = mermaidContentHash(node.value);
+        if (preRenderedSvgs.has(hash)) {
+          const element2 = {
+            type: "mdxJsxFlowElement",
+            name: "MermaidStatic",
+            attributes: [
+              { type: "mdxJsxAttribute", name: "diagramHash", value: hash }
+            ],
+            children: []
+          };
+          parent.children[index] = element2;
+          return;
+        }
+      }
+      const element = {
+        type: "mdxJsxFlowElement",
+        name: "Mermaid",
+        attributes: [],
+        children: [{ type: "text", value: node.value }]
+      };
+      parent.children[index] = element;
+    });
+  };
+}
+
+export {
+  setPreRenderedMermaidSvgs,
+  clearPreRenderedMermaidSvgs,
+  remarkMermaidToComponent
+};

package/dist/node/chunk-SCZZB7OE.js

@@ -0,0 +1,9 @@
+// src/core/mermaid-utils.ts
+import { createHash } from "crypto";
+function mermaidContentHash(definition) {
+  return createHash("sha256").update(definition.trim()).digest("hex").slice(0, 16);
+}
+
+export {
+  mermaidContentHash
+};

package/dist/node/chunk-V7LLYIRO.js

@@ -0,0 +1,8 @@
+// src/types/index.ts
+function defineConfig(config) {
+  return config;
+}
+
+export {
+  defineConfig
+};

package/dist/node/chunk-WT5W333R.js

@@ -0,0 +1,136 @@
+import {
+  loadUserConfig,
+  resolveConfig,
+  resolveSections
+} from "./chunk-IBK35HZR.js";
+import {
+  scanDocs
+} from "./chunk-L24ILRSX.js";
+
+// src/node/check.ts
+import { resolve } from "path";
+import { readFileSync, existsSync } from "fs";
+async function checkLinks() {
+  const userRoot = process.cwd();
+  const userConfig = await loadUserConfig(userRoot);
+  const config = resolveConfig(userConfig, userRoot);
+  const sections = resolveSections(config, userRoot);
+  const validRoutes = /* @__PURE__ */ new Set();
+  const allDocs = [];
+  for (const section of sections) {
+    const docs = scanDocs(section.docsDir, section.exclude, section.basePath);
+    for (const doc of docs) {
+      validRoutes.add(doc.routePath);
+      allDocs.push(doc);
+    }
+  }
+  validRoutes.add("/");
+  const changelogPath = resolve(userRoot, "CHANGELOG.md");
+  if (existsSync(changelogPath)) {
+    validRoutes.add("/changelog");
+  }
+  const expandedRoutes = new Set(validRoutes);
+  for (const route of validRoutes) {
+    expandedRoutes.add(route.replace(/\/$/, ""));
+    if (route !== "/") expandedRoutes.add(route + "/");
+  }
+  const mdLinkRegex = /\[(?:[^\]]*)\]\(([^)]+)\)/g;
+  const hrefRegex = /href=["']([^"']+)["']/g;
+  const brokenLinks = [];
+  for (const doc of allDocs) {
+    if (!existsSync(doc.filePath)) continue;
+    const content = readFileSync(doc.filePath, "utf-8");
+    const lines = content.split("\n");
+    for (let i = 0; i < lines.length; i++) {
+      const line = lines[i];
+      const lineNum = i + 1;
+      if (line.trimStart().startsWith("```")) continue;
+      for (const regex of [mdLinkRegex, hrefRegex]) {
+        regex.lastIndex = 0;
+        let match;
+        while ((match = regex.exec(line)) !== null) {
+          const rawLink = match[1].split(/[\s"'#]/)[0];
+          if (!rawLink || rawLink.startsWith("http://") || rawLink.startsWith("https://") || rawLink.startsWith("#") || rawLink.startsWith("mailto:") || rawLink.startsWith("tel:") || rawLink.startsWith("//") || rawLink.startsWith("{") || rawLink.startsWith("data:")) {
+            continue;
+          }
+          if (/\.(png|jpe?g|gif|svg|webp|ico|pdf|zip|tar|gz)$/i.test(rawLink)) {
+            continue;
+          }
+          let normalized = rawLink;
+          normalized = normalized.replace(/\.(mdx?|html?)$/, "");
+          if (!normalized.startsWith("/")) {
+            const docDir = doc.routePath.substring(0, doc.routePath.lastIndexOf("/")) || "/";
+            normalized = docDir === "/" ? "/" + normalized : docDir + "/" + normalized;
+          }
+          const check = normalized === "/" ? "/" : normalized.replace(/\/$/, "");
+          const checkNoIndex = check.replace(/\/index$/, "") || "/";
+          if (!expandedRoutes.has(check) && !expandedRoutes.has(checkNoIndex)) {
+            const suggestion = findClosest(check, validRoutes);
+            brokenLinks.push({
+              file: doc.filePath,
+              line: lineNum,
+              link: rawLink,
+              ...suggestion ? { suggestion } : {}
+            });
+          }
+        }
+      }
+    }
+  }
+  if (brokenLinks.length === 0) {
+    console.log("\n  No broken links found.\n");
+    return;
+  }
+  console.log(`
+  Found ${brokenLinks.length} broken link${brokenLinks.length === 1 ? "" : "s"}:
+`);
+  const byFile = /* @__PURE__ */ new Map();
+  for (const bl of brokenLinks) {
+    const relative = bl.file.replace(userRoot + "/", "");
+    if (!byFile.has(relative)) byFile.set(relative, []);
+    byFile.get(relative).push(bl);
+  }
+  for (const [file, links] of byFile) {
+    console.log(`  ${file}`);
+    for (const link of links) {
+      const suggestion = link.suggestion ? ` (did you mean ${link.suggestion}?)` : "";
+      console.log(`    line ${link.line}: ${link.link}${suggestion}`);
+    }
+    console.log();
+  }
+  process.exitCode = 1;
+}
+function findClosest(target, routes) {
+  let best;
+  let bestScore = Infinity;
+  const targetSegments = target.split("/").filter(Boolean);
+  for (const route of routes) {
+    const routeSegments = route.split("/").filter(Boolean);
+    const dist = levenshtein(target, route);
+    const common = targetSegments.filter((s) => routeSegments.includes(s)).length;
+    const score = dist - common * 2;
+    if (score < bestScore) {
+      bestScore = score;
+      best = route;
+    }
+  }
+  if (best && bestScore < target.length * 0.6) return best;
+  return void 0;
+}
+function levenshtein(a, b) {
+  const m = a.length;
+  const n = b.length;
+  const dp = Array.from({ length: m + 1 }, () => Array(n + 1).fill(0));
+  for (let i = 0; i <= m; i++) dp[i][0] = i;
+  for (let j = 0; j <= n; j++) dp[0][j] = j;
+  for (let i = 1; i <= m; i++) {
+    for (let j = 1; j <= n; j++) {
+      dp[i][j] = a[i - 1] === b[j - 1] ? dp[i - 1][j - 1] : 1 + Math.min(dp[i - 1][j], dp[i][j - 1], dp[i - 1][j - 1]);
+    }
+  }
+  return dp[m][n];
+}
+
+export {
+  checkLinks
+};

package/dist/node/cli/index.d.ts

@@ -0,0 +1,2 @@
+
+export {  }

package/dist/node/cli/index.js

@@ -0,0 +1,41 @@
+// src/cli/index.ts
+import cac from "cac";
+var cli = cac("clearify");
+cli.command("dev", "Start development server").option("--port <port>", "Port to listen on").option("--host", "Expose to network").action(async (options) => {
+  const { createServer } = await import("../node/index.js");
+  const server = await createServer({
+    port: options.port,
+    host: options.host
+  });
+  await server.listen();
+  console.log(`
+  Clearify dev server running at:
+`);
+  server.printUrls();
+  console.log();
+});
+cli.command("build", "Build static documentation site").action(async () => {
+  const { build } = await import("../node/index.js");
+  await build();
+});
+cli.command("init", "Scaffold a docs folder").option("--no-internal", "Skip creating the internal docs section").action(async (options) => {
+  const { init } = await import("../node/index.js");
+  await init({ noInternal: options.noInternal });
+});
+cli.command("check", "Check for broken internal links").action(async () => {
+  const { checkLinks } = await import("../node/check.js");
+  await checkLinks();
+});
+cli.command("openapi:generate", "Generate OpenAPI spec from NestJS app").option("--module <path>", "Path to NestJS app module", { default: "./src/app.module.ts" }).option("--output <path>", "Output path for spec file", { default: "./docs/openapi.json" }).option("--title <title>", "API documentation title").option("--description <desc>", "API documentation description").option("--version <version>", "API version").action(async (options) => {
+  const { generateSpec } = await import("../presets/nestjs.js");
+  await generateSpec({
+    appModule: options.module,
+    output: options.output,
+    title: options.title,
+    description: options.description,
+    version: options.version
+  });
+});
+cli.help();
+cli.version("1.5.0");
+cli.parse();

package/dist/node/core/config.d.ts

@@ -0,0 +1,9 @@
+import { ClearifyConfig, ResolvedSection } from '../types/index.js';
+export { defineConfig } from '../types/index.js';
+
+declare const defaultConfig: ClearifyConfig;
+declare function loadUserConfig(root: string): Promise<Partial<ClearifyConfig>>;
+declare function resolveConfig(userConfig?: Partial<ClearifyConfig>, root?: string): ClearifyConfig;
+declare function resolveSections(config: ClearifyConfig, root: string): ResolvedSection[];
+
+export { defaultConfig, loadUserConfig, resolveConfig, resolveSections };

package/dist/node/core/config.js

@@ -0,0 +1,16 @@
+import {
+  defaultConfig,
+  loadUserConfig,
+  resolveConfig,
+  resolveSections
+} from "../chunk-IBK35HZR.js";
+import {
+  defineConfig
+} from "../chunk-V7LLYIRO.js";
+export {
+  defaultConfig,
+  defineConfig,
+  loadUserConfig,
+  resolveConfig,
+  resolveSections
+};