@latent-space-labs/open-auto-doc 0.3.2 → 0.3.4

package/dist/index.js

@@ -555,6 +555,26 @@ async function createCiWorkflow(params) {
     "utf-8"
   );
   p4.log.success(`Created ${path5.relative(gitRoot, workflowPath)}`);
+  if (token) {
+    try {
+      const origin = execSync3("git remote get-url origin", {
+        cwd: gitRoot,
+        encoding: "utf-8",
+        stdio: ["pipe", "pipe", "pipe"]
+      }).trim();
+      const match = origin.match(/github\.com[:/]([^/]+\/[^/.]+?)(?:\.git)?$/);
+      if (match) {
+        const octokit = new Octokit3({ auth: token });
+        await verifySecretsInteractive(octokit, [match[1]]);
+      } else {
+        showSecretsInstructions(false);
+      }
+    } catch {
+      showSecretsInstructions(false);
+    }
+  } else {
+    showSecretsInstructions(false);
+  }
   return { workflowPath, branch };
 }
 async function createCiWorkflowsMultiRepo(params) {
@@ -609,8 +629,92 @@ async function createCiWorkflowsMultiRepo(params) {
     return null;
   }
   p4.log.success(`Created workflows in ${createdRepos.length}/${config.repos.length} repositories`);
+  await verifySecretsInteractive(octokit, createdRepos);
   return { repos: createdRepos, branch };
 }
+var REQUIRED_SECRETS = ["ANTHROPIC_API_KEY", "DOCS_DEPLOY_TOKEN"];
+async function checkSecret(octokit, owner, repo, secretName) {
+  try {
+    await octokit.rest.actions.getRepoSecret({ owner, repo, secret_name: secretName });
+    return true;
+  } catch {
+    return false;
+  }
+}
+async function verifySecretsInteractive(octokit, repos) {
+  const shouldVerify = await p4.confirm({
+    message: "Would you like to verify secrets now? (you can add them later)",
+    initialValue: true
+  });
+  if (p4.isCancel(shouldVerify) || !shouldVerify) {
+    showSecretsInstructions(repos.length > 1);
+    return;
+  }
+  p4.note(
+    [
+      "Each source repo needs two Actions secrets:",
+      "",
+      "  ANTHROPIC_API_KEY   \u2014 Your Anthropic API key",
+      "  DOCS_DEPLOY_TOKEN   \u2014 GitHub PAT with repo scope",
+      "",
+      "To create the PAT:",
+      "  1. Go to https://github.com/settings/tokens",
+      "  2. Generate new token (classic) with 'repo' scope",
+      "  3. Copy the token and add it as DOCS_DEPLOY_TOKEN"
+    ].join("\n"),
+    "Required GitHub Secrets"
+  );
+  const summary = {};
+  for (const fullName of repos) {
+    const [owner, repoName] = fullName.split("/");
+    p4.log.step(`Add secrets to ${fullName}`);
+    p4.log.message(`  https://github.com/${fullName}/settings/secrets/actions`);
+    let allFound = false;
+    while (!allFound) {
+      await p4.text({
+        message: `Press enter when you've added the secrets to ${fullName}...`,
+        defaultValue: "",
+        placeholder: ""
+      });
+      const results = {};
+      for (const secret of REQUIRED_SECRETS) {
+        results[secret] = await checkSecret(octokit, owner, repoName, secret);
+      }
+      for (const secret of REQUIRED_SECRETS) {
+        if (results[secret]) {
+          p4.log.success(`${secret} \u2014 found`);
+        } else {
+          p4.log.warn(`${secret} \u2014 not found`);
+        }
+      }
+      summary[fullName] = results;
+      allFound = REQUIRED_SECRETS.every((s) => results[s]);
+      if (!allFound) {
+        const retry = await p4.confirm({
+          message: "Some secrets are missing. Would you like to try again?",
+          initialValue: true
+        });
+        if (p4.isCancel(retry) || !retry) break;
+      }
+    }
+  }
+  const lines = [];
+  let allGreen = true;
+  for (const fullName of repos) {
+    const parts = REQUIRED_SECRETS.map((s) => {
+      const ok = summary[fullName]?.[s] ?? false;
+      if (!ok) allGreen = false;
+      return ok ? `\u2713 ${s}` : `\u2717 ${s}`;
+    });
+    lines.push(`${fullName}  \u2014 ${parts.join("  ")}`);
+  }
+  if (allGreen) {
+    p4.note(lines.join("\n"), "All secrets verified!");
+  } else {
+    p4.note(lines.join("\n"), "Secret status");
+    p4.log.warn("Some secrets are still missing \u2014 workflows will fail until they are added.");
+  }
+}
 function showSecretsInstructions(multiRepo = false) {
   const repoNote = multiRepo ? "Add these secrets to EACH source repository:" : "Add these secrets to your GitHub repository:";
   p4.note(
@@ -2562,10 +2666,221 @@ function slugify22(name) {
   return name.toLowerCase().replace(/[^a-z0-9]+/g, "-").replace(/^-|-$/g, "");
 }
 
+// src/ui/progress-table.ts
+function isUnicodeSupported() {
+  if (process.platform === "win32") {
+    return Boolean(process.env.WT_SESSION) || // Windows Terminal
+    Boolean(process.env.TERMINUS_SUBLIME) || process.env.ConEmuTask === "{cmd::Cmder}" || process.env.TERM_PROGRAM === "Terminus-Sublime" || process.env.TERM_PROGRAM === "vscode" || process.env.TERM === "xterm-256color" || process.env.TERM === "alacritty" || process.env.TERMINAL_EMULATOR === "JetBrains-JediTerm";
+  }
+  return process.env.TERM !== "linux";
+}
+var unicode = isUnicodeSupported();
+var S_QUEUED = unicode ? "\u25CB" : "o";
+var S_DONE = unicode ? "\u2713" : "+";
+var S_FAILED = unicode ? "\u2717" : "x";
+var S_BAR = unicode ? "\u2502" : "|";
+var S_BULLET = unicode ? "\u25CF" : "*";
+var SPINNER_FRAMES = unicode ? ["\u25D2", "\u25D0", "\u25D3", "\u25D1"] : ["/", "-", "\\", "|"];
+var ESC = "\x1B[";
+var reset = `${ESC}0m`;
+var dim = (s) => `${ESC}2m${s}${reset}`;
+var green = (s) => `${ESC}32m${s}${reset}`;
+var red = (s) => `${ESC}31m${s}${reset}`;
+var magenta = (s) => `${ESC}35m${s}${reset}`;
+var cyan = (s) => `${ESC}36m${s}${reset}`;
+var bold = (s) => `${ESC}1m${s}${reset}`;
+var cursorUp = (n) => n > 0 ? `${ESC}${n}A` : "";
+var eraseLine = `${ESC}2K`;
+var hideCursor = `${ESC}?25l`;
+var showCursor = `${ESC}?25h`;
+var ANSI_RE = /\x1b\[[0-9;]*m/g;
+function stripAnsi(s) {
+  return s.replace(ANSI_RE, "");
+}
+function visibleLength(s) {
+  return stripAnsi(s).length;
+}
+function truncateAnsi(s, max) {
+  if (visibleLength(s) <= max) return s;
+  let visible = 0;
+  let result = "";
+  let i = 0;
+  const raw = s;
+  while (i < raw.length && visible < max - 1) {
+    if (raw[i] === "\x1B" && raw[i + 1] === "[") {
+      const end = raw.indexOf("m", i);
+      if (end !== -1) {
+        result += raw.slice(i, end + 1);
+        i = end + 1;
+        continue;
+      }
+    }
+    result += raw[i];
+    visible++;
+    i++;
+  }
+  return result + reset + dim("\u2026");
+}
+var ProgressTable = class {
+  repos;
+  states;
+  maxNameLen;
+  lineCount = 0;
+  interval = null;
+  spinnerIdx = 0;
+  isTTY;
+  exitHandler = null;
+  constructor(options) {
+    this.repos = options.repos;
+    this.states = /* @__PURE__ */ new Map();
+    this.maxNameLen = Math.max(...options.repos.map((r) => r.length), 4);
+    for (const repo of options.repos) {
+      this.states.set(repo, { status: "queued", message: "", summary: "", error: "" });
+    }
+    this.isTTY = process.stdout.isTTY === true;
+  }
+  start() {
+    if (this.isTTY) {
+      process.stdout.write(hideCursor);
+      this.exitHandler = () => process.stdout.write(showCursor);
+      process.on("exit", this.exitHandler);
+      this.render();
+      this.interval = setInterval(() => {
+        this.spinnerIdx = (this.spinnerIdx + 1) % SPINNER_FRAMES.length;
+        this.render();
+      }, 80);
+    } else {
+      const total = this.repos.length;
+      process.stdout.write(`Analyzing ${total} ${total === 1 ? "repository" : "repositories"}...
+`);
+    }
+  }
+  update(repo, patch) {
+    const state = this.states.get(repo);
+    if (!state) return;
+    const prevStatus = state.status;
+    if (patch.status !== void 0) state.status = patch.status;
+    if (patch.message !== void 0) state.message = patch.message;
+    if (patch.summary !== void 0) state.summary = patch.summary;
+    if (patch.error !== void 0) state.error = patch.error;
+    if (!this.isTTY && patch.status && patch.status !== prevStatus) {
+      if (patch.status === "done") {
+        process.stdout.write(`  ${S_DONE} ${repo}  ${state.summary}
+`);
+      } else if (patch.status === "failed") {
+        process.stdout.write(`  ${S_FAILED} ${repo}  ${state.error}
+`);
+      } else if (patch.status === "active" && prevStatus === "queued") {
+        process.stdout.write(`  ${S_QUEUED} ${repo}  Starting...
+`);
+      }
+    }
+  }
+  stop() {
+    if (this.interval) {
+      clearInterval(this.interval);
+      this.interval = null;
+    }
+    if (this.isTTY) {
+      this.render();
+      process.stdout.write(showCursor);
+      if (this.exitHandler) {
+        process.removeListener("exit", this.exitHandler);
+        this.exitHandler = null;
+      }
+    }
+  }
+  getSummary() {
+    let done = 0;
+    let failed = 0;
+    for (const state of this.states.values()) {
+      if (state.status === "done") done++;
+      else if (state.status === "failed") failed++;
+    }
+    return { done, failed, total: this.repos.length };
+  }
+  // ── Private rendering ────────────────────────────────────────────
+  render() {
+    const cols = process.stdout.columns || 80;
+    const lines = [];
+    const { done, failed, total } = this.getSummary();
+    const completed = done + failed;
+    lines.push(`${dim(S_BAR)}`);
+    lines.push(`${cyan(S_BULLET)}  ${bold(`Analyzing ${total} ${total === 1 ? "repository" : "repositories"}`)}`);
+    lines.push(`${dim(S_BAR)}  ${completed}/${total} complete`);
+    for (const repo of this.repos) {
+      const state = this.states.get(repo);
+      const paddedName = repo.padEnd(this.maxNameLen);
+      let line;
+      switch (state.status) {
+        case "queued":
+          line = `${dim(S_BAR)}  ${dim(S_QUEUED)} ${dim(paddedName)}  ${dim("Queued")}`;
+          break;
+        case "active": {
+          const frame = SPINNER_FRAMES[this.spinnerIdx];
+          line = `${dim(S_BAR)}  ${magenta(frame)} ${paddedName}  ${dim(state.message)}`;
+          break;
+        }
+        case "done":
+          line = `${dim(S_BAR)}  ${green(S_DONE)} ${paddedName}  ${state.summary}`;
+          break;
+        case "failed":
+          line = `${dim(S_BAR)}  ${red(S_FAILED)} ${paddedName}  ${red(state.error || "Failed")}`;
+          break;
+      }
+      if (visibleLength(line) > cols) {
+        line = truncateAnsi(line, cols);
+      }
+      lines.push(line);
+    }
+    lines.push(`${dim(S_BAR)}`);
+    let output = "";
+    if (this.lineCount > 0) {
+      output += cursorUp(this.lineCount);
+    }
+    for (const line of lines) {
+      output += eraseLine + line + "\n";
+    }
+    if (this.lineCount > lines.length) {
+      for (let i = 0; i < this.lineCount - lines.length; i++) {
+        output += eraseLine + "\n";
+      }
+      output += cursorUp(this.lineCount - lines.length);
+    }
+    this.lineCount = lines.length;
+    process.stdout.write(output);
+  }
+};
+function buildRepoSummary(result) {
+  const parts = [];
+  if (result.apiEndpoints.length > 0) {
+    parts.push(`${result.apiEndpoints.length} endpoint${result.apiEndpoints.length === 1 ? "" : "s"}`);
+  }
+  if (result.components.length > 0) {
+    parts.push(`${result.components.length} component${result.components.length === 1 ? "" : "s"}`);
+  }
+  if (result.diagrams.length > 0) {
+    parts.push(`${result.diagrams.length} diagram${result.diagrams.length === 1 ? "" : "s"}`);
+  }
+  if (result.dataModels.length > 0) {
+    parts.push(`${result.dataModels.length} model${result.dataModels.length === 1 ? "" : "s"}`);
+  }
+  return parts.length > 0 ? parts.join(", ") : "Analysis complete";
+}
+
 // src/commands/init.ts
 var __dirname2 = path8.dirname(fileURLToPath2(import.meta.url));
 async function initCommand(options) {
   p5.intro("open-auto-doc \u2014 AI-powered documentation generator");
+  const templateDir = resolveTemplateDir();
+  if (!fs8.existsSync(path8.join(templateDir, "package.json"))) {
+    p5.log.error(
+      `Site template not found at: ${templateDir}
+This usually means the npm package was not built correctly.
+Try reinstalling: npm install -g @latent-space-labs/open-auto-doc`
+    );
+    process.exit(1);
+  }
   let token = getGithubToken();
   if (!token) {
     p5.log.info("Let's connect your GitHub account.");
@@ -2629,17 +2944,12 @@ async function initCommand(options) {
     p5.log.error("No repositories were cloned.");
     process.exit(1);
   }
-  const analyzeSpinner = p5.spinner();
-  let completed = 0;
   const total = clones.length;
-  const repoStages = {};
-  const updateSpinner = () => {
-    const lines = Object.entries(repoStages).map(([name, status]) => `[${name}] ${status}`).join(" | ");
-    analyzeSpinner.message(`${completed}/${total} done \u2014 ${lines}`);
-  };
-  analyzeSpinner.start(`Analyzing ${total} ${total === 1 ? "repo" : "repos"} in parallel...`);
+  const progressTable = new ProgressTable({ repos: clones.map((c) => c.info.name) });
+  progressTable.start();
   const analysisPromises = clones.map(async (cloned) => {
     const repoName = cloned.info.name;
+    progressTable.update(repoName, { status: "active", message: "Starting..." });
     try {
       const result = await analyzeRepository({
         repoPath: cloned.localPath,
@@ -2648,26 +2958,24 @@ async function initCommand(options) {
         apiKey,
         model,
         onProgress: (stage, msg) => {
-          repoStages[repoName] = `${stage}: ${msg}`;
-          updateSpinner();
+          progressTable.update(repoName, { status: "active", message: `${stage}: ${msg}` });
         }
       });
-      completed++;
-      delete repoStages[repoName];
-      updateSpinner();
+      progressTable.update(repoName, { status: "done", summary: buildRepoSummary(result) });
       return { repo: repoName, result };
     } catch (err) {
-      completed++;
-      delete repoStages[repoName];
-      updateSpinner();
-      p5.log.warn(`[${repoName}] Analysis failed: ${err instanceof Error ? err.message : err}`);
+      const errMsg = err instanceof Error ? err.message : String(err);
+      progressTable.update(repoName, { status: "failed", error: errMsg });
+      p5.log.warn(`[${repoName}] Analysis failed: ${errMsg}`);
       return { repo: repoName, result: null };
     }
   });
   const settled = await Promise.all(analysisPromises);
+  progressTable.stop();
   const results = settled.filter((s) => s.result !== null).map((s) => s.result);
-  analyzeSpinner.stop(
-    `Analyzed ${results.length}/${total} repositories` + (results.length > 0 ? ` \u2014 ${results.reduce((n, r) => n + r.apiEndpoints.length, 0)} endpoints, ${results.reduce((n, r) => n + r.components.length, 0)} components, ${results.reduce((n, r) => n + r.diagrams.length, 0)} diagrams` : "")
+  const { done, failed } = progressTable.getSummary();
+  p5.log.step(
+    `Analyzed ${done}/${total} repositories` + (failed > 0 ? ` (${failed} failed)` : "") + (results.length > 0 ? ` \u2014 ${results.reduce((n, r) => n + r.apiEndpoints.length, 0)} endpoints, ${results.reduce((n, r) => n + r.components.length, 0)} components, ${results.reduce((n, r) => n + r.diagrams.length, 0)} diagrams` : "")
   );
   if (results.length === 0) {
     p5.log.error("No repositories were successfully analyzed.");
@@ -2693,8 +3001,6 @@ async function initCommand(options) {
   const genSpinner = p5.spinner();
   try {
     genSpinner.start("Scaffolding documentation site...");
-    const templateDir = resolveTemplateDir();
-    p5.log.info(`Using template from: ${templateDir}`);
     await scaffoldSite(outputDir, projectName, templateDir);
     genSpinner.stop("Site scaffolded");
   } catch (err) {
@@ -2776,23 +3082,25 @@ async function initCommand(options) {
     token,
     config
   });
-  if (ciResult) {
-    showSecretsInstructions(repos.length > 1);
-  }
   showVercelInstructions(deployResult.owner, deployResult.repoName);
   p5.outro(`Docs repo: https://github.com/${deployResult.owner}/${deployResult.repoName}`);
 }
 function resolveTemplateDir() {
   const candidates = [
+    path8.resolve(__dirname2, "site-template"),
+    // dist/site-template (npm global install)
     path8.resolve(__dirname2, "../../site-template"),
+    // monorepo: packages/site-template
     path8.resolve(__dirname2, "../../../site-template"),
+    // monorepo alt
     path8.resolve(__dirname2, "../../../../packages/site-template")
+    // monorepo from nested dist
   ];
   for (const candidate of candidates) {
     const pkgPath = path8.join(candidate, "package.json");
     if (fs8.existsSync(pkgPath)) return candidate;
   }
-  return path8.resolve(__dirname2, "../../site-template");
+  return path8.resolve(__dirname2, "site-template");
 }
 function cleanup(clones) {
   for (const clone of clones) {
@@ -2883,24 +3191,16 @@ async function generateCommand(options) {
     p6.log.error("No repositories were cloned.");
     process.exit(1);
   }
-  const analyzeSpinner = p6.spinner();
-  let completed = 0;
   const total = clones.length;
-  const repoStages = {};
-  const updateSpinner = () => {
-    const lines = Object.entries(repoStages).map(([name, status]) => `[${name}] ${status}`).join(" | ");
-    analyzeSpinner.message(`${completed}/${total} done \u2014 ${lines}`);
-  };
-  analyzeSpinner.start(`Analyzing ${total} ${total === 1 ? "repo" : "repos"} in parallel...`);
+  const progressTable = new ProgressTable({ repos: clones.map((c) => c.info.name) });
+  progressTable.start();
   const analysisPromises = clones.map(async (cloned) => {
     const repo = config.repos.find((r) => r.name === cloned.info.name);
     const repoName = repo.name;
-    const callbacks = {
-      onProgress: (stage, msg) => {
-        repoStages[repoName] = `${stage}: ${msg}`;
-        updateSpinner();
-      }
+    const onProgress = (stage, msg) => {
+      progressTable.update(repoName, { status: "active", message: `${stage}: ${msg}` });
     };
+    progressTable.update(repoName, { status: "active", message: "Starting..." });
     try {
       let result;
       if (incremental) {
@@ -2914,7 +3214,7 @@ async function generateCommand(options) {
             model,
             previousResult: cached.result,
             previousCommitSha: cached.commitSha,
-            ...callbacks
+            onProgress
           });
         } else {
           result = await analyzeRepository({
@@ -2923,7 +3223,7 @@ async function generateCommand(options) {
             repoUrl: repo.htmlUrl,
             apiKey,
             model,
-            ...callbacks
+            onProgress
           });
         }
       } else {
@@ -2933,7 +3233,7 @@ async function generateCommand(options) {
           repoUrl: repo.htmlUrl,
           apiKey,
           model,
-          ...callbacks
+          onProgress
         });
       }
       try {
@@ -2941,21 +3241,22 @@ async function generateCommand(options) {
         saveCache(cacheDir, repo.name, headSha, result);
       } catch {
       }
-      completed++;
-      delete repoStages[repoName];
-      updateSpinner();
+      progressTable.update(repoName, { status: "done", summary: buildRepoSummary(result) });
       return { repo: repoName, result };
     } catch (err) {
-      completed++;
-      delete repoStages[repoName];
-      updateSpinner();
-      p6.log.warn(`[${repoName}] Analysis failed: ${err instanceof Error ? err.message : err}`);
+      const errMsg = err instanceof Error ? err.message : String(err);
+      progressTable.update(repoName, { status: "failed", error: errMsg });
+      p6.log.warn(`[${repoName}] Analysis failed: ${errMsg}`);
       return { repo: repoName, result: null };
     }
   });
   const settled = await Promise.all(analysisPromises);
+  progressTable.stop();
   const freshResults = settled.filter((s) => s.result !== null).map((s) => s.result);
-  analyzeSpinner.stop(`Analyzed ${freshResults.length}/${total} ${total === 1 ? "repository" : "repositories"}`);
+  const { done: analyzedCount, failed: failedCount } = progressTable.getSummary();
+  p6.log.step(
+    `Analyzed ${analyzedCount}/${total} ${total === 1 ? "repository" : "repositories"}` + (failedCount > 0 ? ` (${failedCount} failed)` : "")
+  );
   const results = [...freshResults, ...cachedResults];
   if (results.length > 0) {
     let crossRepo;
@@ -3073,7 +3374,6 @@ async function setupCiCommand() {
     p8.cancel("Setup cancelled.");
     process.exit(0);
   }
-  showSecretsInstructions(isMultiRepo);
   if ("repos" in result) {
     p8.outro("Per-repo CI workflows created! Add the required secrets to each source repo.");
   } else {
@@ -3110,7 +3410,7 @@ async function logoutCommand() {
 
 // src/index.ts
 var program = new Command();
-program.name("open-auto-doc").description("Auto-generate beautiful documentation websites from GitHub repositories using AI").version("0.3.2");
+program.name("open-auto-doc").description("Auto-generate beautiful documentation websites from GitHub repositories using AI").version("0.3.4");
 program.command("init", { isDefault: true }).description("Initialize and generate documentation for your repositories").option("-o, --output <dir>", "Output directory", "docs-site").action(initCommand);
 program.command("generate").description("Regenerate documentation using existing configuration").option("--incremental", "Only re-analyze changed files (uses cached results)").option("--force", "Force full regeneration (ignore cache)").option("--repo <name>", "Only analyze this repo (uses cache for others)").action(generateCommand);
 program.command("deploy").description("Create a GitHub repo for docs and push (connect to Vercel for auto-deploy)").option("-d, --dir <path>", "Docs site directory").action(deployCommand);

package/dist/site-template/app/api/search/route.ts

@@ -0,0 +1,6 @@
+import { source } from "@/lib/source";
+import { createFromSource } from "fumadocs-core/search/server";
+
+export const { GET } = createFromSource(source, {
+  language: "english",
+});

package/dist/site-template/app/docs/[[...slug]]/page.tsx

@@ -0,0 +1,47 @@
+import { source } from "@/lib/source";
+import {
+  DocsBody,
+  DocsDescription,
+  DocsPage,
+  DocsTitle,
+} from "fumadocs-ui/layouts/docs/page";
+import { notFound } from "next/navigation";
+import { getMDXComponents } from "@/mdx-components";
+import type { Metadata } from "next";
+
+export default async function Page(props: {
+  params: Promise<{ slug?: string[] }>;
+}) {
+  const params = await props.params;
+  const page = source.getPage(params.slug);
+  if (!page) notFound();
+
+  const MDX = page.data.body;
+
+  return (
+    <DocsPage toc={page.data.toc} full={page.data.full}>
+      <DocsTitle>{page.data.title}</DocsTitle>
+      <DocsDescription>{page.data.description}</DocsDescription>
+      <DocsBody>
+        <MDX components={getMDXComponents()} />
+      </DocsBody>
+    </DocsPage>
+  );
+}
+
+export async function generateStaticParams() {
+  return source.generateParams();
+}
+
+export async function generateMetadata(props: {
+  params: Promise<{ slug?: string[] }>;
+}): Promise<Metadata> {
+  const params = await props.params;
+  const page = source.getPage(params.slug);
+  if (!page) notFound();
+
+  return {
+    title: page.data.title,
+    description: page.data.description,
+  };
+}

package/dist/site-template/app/docs/layout.tsx

@@ -0,0 +1,12 @@
+import { source } from "@/lib/source";
+import { DocsLayout } from "fumadocs-ui/layouts/docs";
+import { baseOptions } from "@/lib/layout.shared";
+import type { ReactNode } from "react";
+
+export default function Layout({ children }: { children: ReactNode }) {
+  return (
+    <DocsLayout tree={source.getPageTree()} {...baseOptions()}>
+      {children}
+    </DocsLayout>
+  );
+}

package/dist/site-template/app/global.css

@@ -0,0 +1,3 @@
+@import "tailwindcss";
+@import "fumadocs-ui/css/neutral.css";
+@import "fumadocs-ui/css/preset.css";

package/dist/site-template/app/layout.tsx

@@ -0,0 +1,21 @@
+import { RootProvider } from "fumadocs-ui/provider/next";
+import "./global.css";
+import { Inter } from "next/font/google";
+import type { ReactNode } from "react";
+
+const inter = Inter({ subsets: ["latin"] });
+
+export const metadata = {
+  title: "{{projectName}} Documentation",
+  description: "Auto-generated documentation for {{projectName}}",
+};
+
+export default function RootLayout({ children }: { children: ReactNode }) {
+  return (
+    <html lang="en" className={inter.className} suppressHydrationWarning>
+      <body className="flex min-h-screen flex-col">
+        <RootProvider>{children}</RootProvider>
+      </body>
+    </html>
+  );
+}

package/dist/site-template/app/page.tsx

@@ -0,0 +1,5 @@
+import { redirect } from "next/navigation";
+
+export default function RootPage() {
+  redirect("/docs");
+}

package/dist/site-template/components/mermaid.tsx

@@ -0,0 +1,62 @@
+"use client";
+
+import { useEffect, useId, useRef, useState } from "react";
+
+export function Mermaid({ code }: { code: string }) {
+  const id = useId().replace(/:/g, "m");
+  const containerRef = useRef<HTMLDivElement>(null);
+  const [svg, setSvg] = useState<string>("");
+  const [error, setError] = useState<string>("");
+
+  useEffect(() => {
+    let cancelled = false;
+
+    async function render() {
+      try {
+        const mermaid = (await import("mermaid")).default;
+        mermaid.initialize({
+          startOnLoad: false,
+          theme: "neutral",
+          securityLevel: "loose",
+        });
+        const { svg: rendered } = await mermaid.render(
+          `mermaid-${id}`,
+          code,
+        );
+        if (!cancelled) setSvg(rendered);
+      } catch (err) {
+        if (!cancelled)
+          setError(err instanceof Error ? err.message : "Diagram error");
+      }
+    }
+
+    render();
+    return () => {
+      cancelled = true;
+    };
+  }, [code, id]);
+
+  if (error) {
+    return (
+      <pre className="rounded-lg border bg-fd-card p-4 text-sm text-fd-muted-foreground overflow-x-auto">
+        <code>{code}</code>
+      </pre>
+    );
+  }
+
+  if (!svg) {
+    return (
+      <div className="flex items-center justify-center rounded-lg border bg-fd-card p-8 text-sm text-fd-muted-foreground">
+        Loading diagram...
+      </div>
+    );
+  }
+
+  return (
+    <div
+      ref={containerRef}
+      className="my-4 flex justify-center overflow-x-auto rounded-lg border bg-fd-card p-4 [&_svg]:max-w-full"
+      dangerouslySetInnerHTML={{ __html: svg }}
+    />
+  );
+}

package/dist/site-template/content/docs/index.mdx

@@ -0,0 +1,10 @@
+---
+title: Welcome
+description: Auto-generated documentation
+---
+
+# Welcome
+
+This documentation was auto-generated by [open-auto-doc](https://github.com/open-auto-doc).
+
+Browse the sidebar to explore the documentation.

package/dist/site-template/content/docs/meta.json

@@ -0,0 +1,3 @@
+{
+  "pages": ["index"]
+}

package/dist/site-template/lib/layout.shared.ts

@@ -0,0 +1,9 @@
+import type { BaseLayoutProps } from "fumadocs-ui/layouts/shared";
+
+export function baseOptions(): BaseLayoutProps {
+  return {
+    nav: {
+      title: "{{projectName}}",
+    },
+  };
+}

package/dist/site-template/lib/remark-mermaid.ts

@@ -0,0 +1,33 @@
+/**
+ * Remark plugin that transforms ```mermaid code blocks into <Mermaid /> JSX components.
+ * This runs before Shiki so the mermaid blocks never get syntax-highlighted as code.
+ */
+export function remarkMermaid() {
+  return (tree: any) => {
+    walk(tree);
+  };
+}
+
+function walk(node: any) {
+  if (!node.children) return;
+  for (let i = 0; i < node.children.length; i++) {
+    const child = node.children[i];
+    if (child.type === "code" && child.lang === "mermaid") {
+      node.children[i] = {
+        type: "mdxJsxFlowElement",
+        name: "Mermaid",
+        attributes: [
+          {
+            type: "mdxJsxAttribute",
+            name: "code",
+            value: child.value,
+          },
+        ],
+        children: [],
+        data: { _mdxExplicitJsx: true },
+      };
+    } else {
+      walk(child);
+    }
+  }
+}

package/dist/site-template/lib/source.ts

@@ -0,0 +1,7 @@
+import { docs } from "fumadocs-mdx:collections/server";
+import { loader } from "fumadocs-core/source";
+
+export const source = loader({
+  baseUrl: "/docs",
+  source: docs.toFumadocsSource(),
+});

package/dist/site-template/mdx-components.tsx

@@ -0,0 +1,11 @@
+import defaultMdxComponents from "fumadocs-ui/mdx";
+import type { MDXComponents } from "mdx/types";
+import { Mermaid } from "@/components/mermaid";
+
+export function getMDXComponents(components?: MDXComponents): MDXComponents {
+  return {
+    ...defaultMdxComponents,
+    Mermaid,
+    ...components,
+  };
+}

package/dist/site-template/next.config.mjs

@@ -0,0 +1,10 @@
+import { createMDX } from "fumadocs-mdx/next";
+
+const withMDX = createMDX();
+
+/** @type {import('next').NextConfig} */
+const config = {
+  reactStrictMode: true,
+};
+
+export default withMDX(config);

package/dist/site-template/package.json

@@ -0,0 +1,31 @@
+{
+  "name": "{{projectName}}-docs",
+  "version": "0.1.0",
+  "private": true,
+  "scripts": {
+    "dev": "next dev",
+    "build": "next build",
+    "start": "next start",
+    "postinstall": "fumadocs-mdx"
+  },
+  "dependencies": {
+    "next": "^16.0.0",
+    "react": "^19.0.0",
+    "react-dom": "^19.0.0",
+    "fumadocs-core": "^16.0.0",
+    "fumadocs-ui": "^16.0.0",
+    "fumadocs-mdx": "^14.0.0",
+    "mermaid": "^11.0.0",
+    "lucide-react": "^0.475.0",
+    "@types/mdx": "^2.0.13"
+  },
+  "devDependencies": {
+    "@tailwindcss/postcss": "^4.0.0",
+    "@types/node": "^22.12.0",
+    "@types/react": "^19.0.0",
+    "@types/react-dom": "^19.0.0",
+    "postcss": "^8.5.0",
+    "tailwindcss": "^4.0.0",
+    "typescript": "^5.7.0"
+  }
+}

package/dist/site-template/postcss.config.mjs

@@ -0,0 +1,7 @@
+const config = {
+  plugins: {
+    "@tailwindcss/postcss": {},
+  },
+};
+
+export default config;

package/dist/site-template/source.config.ts

@@ -0,0 +1,12 @@
+import { defineConfig, defineDocs } from "fumadocs-mdx/config";
+import { remarkMermaid } from "./lib/remark-mermaid";
+
+export const docs = defineDocs({
+  dir: "content/docs",
+});
+
+export default defineConfig({
+  mdxOptions: {
+    remarkPlugins: [remarkMermaid],
+  },
+});

package/dist/site-template/tsconfig.json

@@ -0,0 +1,32 @@
+{
+  "compilerOptions": {
+    "baseUrl": ".",
+    "target": "ESNext",
+    "lib": ["dom", "dom.iterable", "esnext"],
+    "allowJs": true,
+    "skipLibCheck": true,
+    "strict": true,
+    "forceConsistentCasingInFileNames": true,
+    "noEmit": true,
+    "esModuleInterop": true,
+    "module": "esnext",
+    "moduleResolution": "bundler",
+    "resolveJsonModule": true,
+    "isolatedModules": true,
+    "jsx": "react-jsx",
+    "incremental": true,
+    "paths": {
+      "@/*": ["./*"],
+      "fumadocs-mdx:collections/*": [".source/*"]
+    },
+    "plugins": [{ "name": "next" }]
+  },
+  "include": [
+    "next-env.d.ts",
+    "**/*.ts",
+    "**/*.tsx",
+    ".next/types/**/*.ts",
+    ".next/dev/types/**/*.ts"
+  ],
+  "exclude": ["node_modules"]
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@latent-space-labs/open-auto-doc",
-  "version": "0.3.2",
+  "version": "0.3.4",
   "description": "Auto-generate beautiful documentation websites from GitHub repositories using AI",
   "type": "module",
   "bin": {