@latent-space-labs/open-auto-doc 0.3.3 → 0.3.5

package/dist/index.js

@@ -4,9 +4,9 @@
 import { Command } from "commander";
 
 // src/commands/init.ts
-import * as p5 from "@clack/prompts";
-import fs8 from "fs";
-import path8 from "path";
+import * as p6 from "@clack/prompts";
+import fs9 from "fs";
+import path9 from "path";
 import { fileURLToPath as fileURLToPath2 } from "url";
 
 // src/auth/device-flow.ts
@@ -37,10 +37,10 @@ Opening ${deviceData.verification_uri} in your browser...`,
   } catch {
     p.log.warn(`Could not open browser. Please visit: ${deviceData.verification_uri}`);
   }
-  const spinner7 = p.spinner();
-  spinner7.start("Waiting for GitHub authorization...");
+  const spinner8 = p.spinner();
+  spinner8.start("Waiting for GitHub authorization...");
   const token = await pollForToken(deviceData.device_code, deviceData.interval);
-  spinner7.stop("GitHub authentication successful!");
+  spinner8.stop("GitHub authentication successful!");
   return token;
 }
 async function pollForToken(deviceCode, interval) {
@@ -162,8 +162,8 @@ import { Octokit } from "@octokit/rest";
 import * as p2 from "@clack/prompts";
 async function pickRepos(token) {
   const octokit = new Octokit({ auth: token });
-  const spinner7 = p2.spinner();
-  spinner7.start("Fetching your repositories...");
+  const spinner8 = p2.spinner();
+  spinner8.start("Fetching your repositories...");
   const repos = [];
   let page = 1;
   while (true) {
@@ -188,7 +188,7 @@ async function pickRepos(token) {
     if (data.length < 100) break;
     page++;
   }
-  spinner7.stop(`Found ${repos.length} repositories`);
+  spinner8.stop(`Found ${repos.length} repositories`);
   const selected = await p2.multiselect({
     message: "Select repositories to document",
     options: repos.slice(0, 50).map((r) => ({
@@ -289,8 +289,8 @@ async function createAndPushDocsRepo(params) {
     ]
   });
   if (p3.isCancel(visibility)) return null;
-  const spinner7 = p3.spinner();
-  spinner7.start(`Creating GitHub repo ${owner}/${repoName}...`);
+  const spinner8 = p3.spinner();
+  spinner8.start(`Creating GitHub repo ${owner}/${repoName}...`);
   let repoUrl;
   try {
     if (isOrg) {
@@ -302,7 +302,7 @@ async function createAndPushDocsRepo(params) {
         auto_init: false
       });
       repoUrl = data.clone_url;
-      spinner7.stop(`Created ${data.full_name}`);
+      spinner8.stop(`Created ${data.full_name}`);
     } else {
       const { data } = await octokit.rest.repos.createForAuthenticatedUser({
         name: repoName,
@@ -311,10 +311,10 @@ async function createAndPushDocsRepo(params) {
         auto_init: false
       });
       repoUrl = data.clone_url;
-      spinner7.stop(`Created ${data.full_name}`);
+      spinner8.stop(`Created ${data.full_name}`);
     }
   } catch (err) {
-    spinner7.stop("Failed to create repo.");
+    spinner8.stop("Failed to create repo.");
     if (err?.status === 422) {
       p3.log.error(`Repository "${repoName}" already exists. Choose a different name or delete it first.`);
     } else {
@@ -322,7 +322,7 @@ async function createAndPushDocsRepo(params) {
     }
     return null;
   }
-  spinner7.start("Pushing docs to GitHub...");
+  spinner8.start("Pushing docs to GitHub...");
   try {
     const gitignorePath = path4.join(docsDir, ".gitignore");
     if (!fs4.existsSync(gitignorePath)) {
@@ -341,9 +341,9 @@ async function createAndPushDocsRepo(params) {
     exec(`git remote add origin ${pushUrl}`, docsDir);
     exec("git push -u origin main", docsDir);
     exec("git remote set-url origin " + repoUrl, docsDir);
-    spinner7.stop("Pushed to GitHub.");
+    spinner8.stop("Pushed to GitHub.");
   } catch (err) {
-    spinner7.stop("Git push failed.");
+    spinner8.stop("Git push failed.");
     p3.log.error(`${err instanceof Error ? err.message : err}`);
     return null;
   }
@@ -354,8 +354,8 @@ async function createAndPushDocsRepo(params) {
 }
 async function pushUpdates(params) {
   const { token, docsDir, docsRepo } = params;
-  const spinner7 = p3.spinner();
-  spinner7.start("Pushing updates to docs repo...");
+  const spinner8 = p3.spinner();
+  spinner8.start("Pushing updates to docs repo...");
   try {
     if (!fs4.existsSync(path4.join(docsDir, ".git"))) {
       exec("git init", docsDir);
@@ -364,16 +364,16 @@ async function pushUpdates(params) {
     exec("git add -A", docsDir);
     try {
       exec("git diff --cached --quiet", docsDir);
-      spinner7.stop("No changes to push.");
+      spinner8.stop("No changes to push.");
       return false;
     } catch {
     }
     exec('git commit -m "Update documentation"', docsDir);
     exec("git push -u origin main", docsDir);
-    spinner7.stop("Pushed updates to docs repo.");
+    spinner8.stop("Pushed updates to docs repo.");
     return true;
   } catch (err) {
-    spinner7.stop("Push failed.");
+    spinner8.stop("Push failed.");
     p3.log.error(`${err instanceof Error ? err.message : err}`);
     return false;
   }
@@ -394,353 +394,13 @@ function showVercelInstructions(owner, repoName) {
   );
 }
 
-// src/actions/setup-ci-action.ts
+// src/actions/build-check.ts
 import * as p4 from "@clack/prompts";
-import { execSync as execSync3 } from "child_process";
-import fs5 from "fs";
-import path5 from "path";
-import { Octokit as Octokit3 } from "@octokit/rest";
-function getGitRoot() {
-  try {
-    return execSync3("git rev-parse --show-toplevel", {
-      encoding: "utf-8",
-      stdio: ["pipe", "pipe", "pipe"]
-    }).trim();
-  } catch {
-    return null;
-  }
-}
-function generateWorkflow(branch, docsRepoUrl, outputDir) {
-  return `name: Update Documentation
-
-on:
-  push:
-    branches: [${branch}]
-  workflow_dispatch:
-
-jobs:
-  update-docs:
-    runs-on: ubuntu-latest
-    steps:
-      - name: Checkout source repo
-        uses: actions/checkout@v4
-        with:
-          fetch-depth: 0
-
-      - name: Setup Node.js
-        uses: actions/setup-node@v4
-        with:
-          node-version: 20
-
-      - name: Cache analysis results
-        uses: actions/cache@v4
-        with:
-          path: .autodoc-cache
-          key: autodoc-cache-\${{ github.sha }}
-          restore-keys: |
-            autodoc-cache-
-
-      - name: Install open-auto-doc
-        run: npm install -g @latent-space-labs/open-auto-doc
-
-      - name: Generate documentation
-        env:
-          ANTHROPIC_API_KEY: \${{ secrets.ANTHROPIC_API_KEY }}
-          GITHUB_TOKEN: \${{ secrets.GITHUB_TOKEN }}
-        run: open-auto-doc generate --incremental
-
-      - name: Clone docs repo
-        run: |
-          git clone https://x-access-token:\${{ secrets.DOCS_DEPLOY_TOKEN }}@${docsRepoUrl.replace("https://", "")} docs-repo
-
-      - name: Copy updated content
-        run: |
-          # Copy content and any updated config, preserving the docs repo git history
-          rsync -av --delete \\
-            --exclude '.git' \\
-            --exclude 'node_modules' \\
-            --exclude '.next' \\
-            --exclude '.source' \\
-            ${outputDir}/ docs-repo/
-
-      - name: Push to docs repo
-        run: |
-          cd docs-repo
-          git config user.name "github-actions[bot]"
-          git config user.email "github-actions[bot]@users.noreply.github.com"
-          git add -A
-          # Only commit and push if there are changes
-          if git diff --cached --quiet; then
-            echo "No documentation changes to push."
-          else
-            git commit -m "Update documentation from \${{ github.repository }}@\${{ github.sha }}"
-            git push
-          fi
-`;
-}
-function generatePerRepoWorkflow(branch, repoName, docsRepoUrl) {
-  return `name: Update Documentation
-
-on:
-  push:
-    branches: [${branch}]
-  workflow_dispatch:
-
-jobs:
-  update-docs:
-    runs-on: ubuntu-latest
-    steps:
-      - name: Checkout source repo
-        uses: actions/checkout@v4
-        with:
-          fetch-depth: 0
-
-      - name: Setup Node.js
-        uses: actions/setup-node@v4
-        with:
-          node-version: 20
-
-      - name: Install open-auto-doc
-        run: npm install -g @latent-space-labs/open-auto-doc
-
-      - name: Clone docs repo
-        run: |
-          git clone https://x-access-token:\${{ secrets.DOCS_DEPLOY_TOKEN }}@${docsRepoUrl.replace("https://", "")} docs-site
-
-      - name: Generate documentation
-        env:
-          ANTHROPIC_API_KEY: \${{ secrets.ANTHROPIC_API_KEY }}
-          GITHUB_TOKEN: \${{ secrets.DOCS_DEPLOY_TOKEN }}
-        run: open-auto-doc generate --repo ${repoName} --incremental
-
-      - name: Push to docs repo
-        run: |
-          cd docs-site
-          git config user.name "github-actions[bot]"
-          git config user.email "github-actions[bot]@users.noreply.github.com"
-          git add -A
-          if git diff --cached --quiet; then
-            echo "No documentation changes to push."
-          else
-            git commit -m "Update docs from \${{ github.repository }}@\${{ github.sha }}"
-            git pull --rebase origin main || true
-            git push
-          fi
-`;
-}
-async function createCiWorkflow(params) {
-  const { gitRoot, docsRepoUrl, outputDir, token, config } = params;
-  if (config && config.repos.length > 1 && token) {
-    return createCiWorkflowsMultiRepo({
-      token,
-      config,
-      docsRepoUrl
-    });
-  }
-  const relativeOutputDir = path5.relative(gitRoot, path5.resolve(outputDir));
-  p4.log.info(`Docs repo: ${docsRepoUrl}`);
-  p4.log.info(`Output directory: ${relativeOutputDir}`);
-  const branch = await p4.text({
-    message: "Which branch should trigger doc updates?",
-    initialValue: "main",
-    validate: (v) => v.length === 0 ? "Branch name is required" : void 0
-  });
-  if (p4.isCancel(branch)) return null;
-  const workflowDir = path5.join(gitRoot, ".github", "workflows");
-  const workflowPath = path5.join(workflowDir, "update-docs.yml");
-  fs5.mkdirSync(workflowDir, { recursive: true });
-  fs5.writeFileSync(
-    workflowPath,
-    generateWorkflow(branch, docsRepoUrl, relativeOutputDir),
-    "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) {
-  const { token, config, docsRepoUrl } = params;
-  const octokit = new Octokit3({ auth: token });
-  p4.log.info(`Setting up CI for ${config.repos.length} repositories`);
-  p4.log.info(`Docs repo: ${docsRepoUrl}`);
-  const branch = await p4.text({
-    message: "Which branch should trigger doc updates?",
-    initialValue: "main",
-    validate: (v) => v.length === 0 ? "Branch name is required" : void 0
-  });
-  if (p4.isCancel(branch)) return null;
-  const createdRepos = [];
-  const workflowPath = ".github/workflows/update-docs.yml";
-  for (const repo of config.repos) {
-    const spinner7 = p4.spinner();
-    spinner7.start(`Pushing workflow to ${repo.fullName}...`);
-    try {
-      const [owner, repoName] = repo.fullName.split("/");
-      const workflowContent = generatePerRepoWorkflow(branch, repo.name, docsRepoUrl);
-      const contentBase64 = Buffer.from(workflowContent).toString("base64");
-      let existingSha;
-      try {
-        const { data } = await octokit.rest.repos.getContent({
-          owner,
-          repo: repoName,
-          path: workflowPath
-        });
-        if (!Array.isArray(data) && data.type === "file") {
-          existingSha = data.sha;
-        }
-      } catch {
-      }
-      await octokit.rest.repos.createOrUpdateFileContents({
-        owner,
-        repo: repoName,
-        path: workflowPath,
-        message: "Add auto-documentation CI workflow",
-        content: contentBase64,
-        ...existingSha ? { sha: existingSha } : {}
-      });
-      createdRepos.push(repo.fullName);
-      spinner7.stop(`Created workflow in ${repo.fullName}`);
-    } catch (err) {
-      spinner7.stop(`Failed for ${repo.fullName}`);
-      p4.log.warn(`Could not push workflow to ${repo.fullName}: ${err?.message || err}`);
-    }
-  }
-  if (createdRepos.length === 0) {
-    p4.log.error("Failed to create workflows in any repository.");
-    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(
-    [
-      repoNote,
-      "(Settings \u2192 Secrets and variables \u2192 Actions \u2192 New repository secret)",
-      "",
-      "  ANTHROPIC_API_KEY   \u2014 Your Anthropic API key",
-      "  DOCS_DEPLOY_TOKEN   \u2014 GitHub PAT with repo scope",
-      "                        (needed to push to the docs repo)",
-      "",
-      "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",
-      "",
-      "Note: GITHUB_TOKEN is automatically provided by GitHub Actions",
-      "      (used for reading the source repo during analysis)."
-    ].join("\n"),
-    "Required GitHub Secrets"
-  );
-}
+import { execSync as execSync4 } from "child_process";
 
 // ../analyzer/dist/index.js
-import fs6 from "fs";
-import path6 from "path";
+import fs5 from "fs";
+import path5 from "path";
 import ignore from "ignore";
 import fs22 from "fs";
 import path22 from "path";
@@ -751,9 +411,9 @@ import path42 from "path";
 import { query } from "@anthropic-ai/claude-agent-sdk";
 import fs52 from "fs";
 import path52 from "path";
-import { execSync as execSync4 } from "child_process";
-import fs62 from "fs";
-import path62 from "path";
+import { execSync as execSync3 } from "child_process";
+import fs6 from "fs";
+import path6 from "path";
 var DEFAULT_IGNORES = [
   "node_modules",
   ".git",
@@ -775,26 +435,26 @@ function buildFileTree(rootPath, maxDepth = 6) {
   const ig = loadGitignore(rootPath);
   const flatFiles = [];
   function walk(dirPath, depth) {
-    const name = path6.basename(dirPath);
-    const node = { path: path6.relative(rootPath, dirPath) || ".", name, type: "directory", children: [] };
+    const name = path5.basename(dirPath);
+    const node = { path: path5.relative(rootPath, dirPath) || ".", name, type: "directory", children: [] };
     if (depth > maxDepth) return node;
     let entries;
     try {
-      entries = fs6.readdirSync(dirPath, { withFileTypes: true });
+      entries = fs5.readdirSync(dirPath, { withFileTypes: true });
     } catch {
       return node;
     }
     for (const entry of entries.sort((a, b) => a.name.localeCompare(b.name))) {
-      const rel = path6.relative(rootPath, path6.join(dirPath, entry.name));
+      const rel = path5.relative(rootPath, path5.join(dirPath, entry.name));
       if (ig.ignores(rel) || ig.ignores(rel + "/")) continue;
       if (entry.isDirectory()) {
-        const child = walk(path6.join(dirPath, entry.name), depth + 1);
+        const child = walk(path5.join(dirPath, entry.name), depth + 1);
         node.children.push(child);
       } else if (entry.isFile()) {
-        const ext = path6.extname(entry.name).slice(1);
+        const ext = path5.extname(entry.name).slice(1);
         let size;
         try {
-          size = fs6.statSync(path6.join(dirPath, entry.name)).size;
+          size = fs5.statSync(path5.join(dirPath, entry.name)).size;
         } catch {
         }
         flatFiles.push(rel);
@@ -815,9 +475,9 @@ function buildFileTree(rootPath, maxDepth = 6) {
 function loadGitignore(rootPath) {
   const ig = ignore.default();
   ig.add(DEFAULT_IGNORES);
-  const gitignorePath = path6.join(rootPath, ".gitignore");
-  if (fs6.existsSync(gitignorePath)) {
-    const content = fs6.readFileSync(gitignorePath, "utf-8");
+  const gitignorePath = path5.join(rootPath, ".gitignore");
+  if (fs5.existsSync(gitignorePath)) {
+    const content = fs5.readFileSync(gitignorePath, "utf-8");
     ig.add(content);
   }
   return ig;
@@ -845,7 +505,7 @@ function detectLanguages(flatFiles) {
   };
   const langs = /* @__PURE__ */ new Set();
   for (const file of flatFiles) {
-    const ext = path6.extname(file).slice(1);
+    const ext = path5.extname(file).slice(1);
     if (extMap[ext]) langs.add(extMap[ext]);
   }
   return Array.from(langs);
@@ -865,7 +525,7 @@ function detectEntryFiles(flatFiles) {
     /^app\/page\.tsx$/,
     /^pages\/index\.\w+$/
   ];
-  return flatFiles.filter((f) => entryPatterns.some((p11) => p11.test(f)));
+  return flatFiles.filter((f) => entryPatterns.some((p12) => p12.test(f)));
 }
 var DEP_FILES = [
   {
@@ -1731,7 +1391,7 @@ var SECTION_PATTERNS = {
 };
 function computeDiff(repoPath, fromSha) {
   try {
-    const output = execSync4(`git diff --name-status ${fromSha}..HEAD`, {
+    const output = execSync3(`git diff --name-status ${fromSha}..HEAD`, {
       cwd: repoPath,
       encoding: "utf-8",
       stdio: ["pipe", "pipe", "pipe"]
@@ -1766,7 +1426,7 @@ function classifyChanges(entries, staticAnalysis) {
   const affected = /* @__PURE__ */ new Set();
   for (const entry of entries) {
     for (const [section, patterns] of Object.entries(SECTION_PATTERNS)) {
-      if (patterns.some((p11) => p11.test(entry.filePath))) {
+      if (patterns.some((p12) => p12.test(entry.filePath))) {
         affected.add(section);
       }
     }
@@ -1784,7 +1444,7 @@ function classifyChanges(entries, staticAnalysis) {
   };
 }
 function getHeadSha(repoPath) {
-  return execSync4("git rev-parse HEAD", {
+  return execSync3("git rev-parse HEAD", {
     cwd: repoPath,
     encoding: "utf-8"
   }).trim();
@@ -2130,40 +1790,503 @@ Do NOT use file tools \u2014 all information is provided above.`,
     maxTurns: 5
   });
 }
+var fixerOutputSchema = {
+  type: "object",
+  properties: {
+    fixed: { type: "boolean" },
+    filesChanged: {
+      type: "array",
+      items: { type: "string" }
+    },
+    summary: { type: "string" }
+  },
+  required: ["fixed", "filesChanged", "summary"]
+};
+var SYSTEM_PROMPT = `You are an MDX build-error fixer for Fumadocs documentation sites.
+
+You will receive Next.js / Fumadocs build error output. Your job is to find and fix the broken MDX files so the build succeeds.
+
+## Common errors you must handle
+
+1. **Unescaped JSX characters** \u2014 \`{\`, \`}\`, \`<\`, \`>\` outside of code blocks/fences must be escaped as \`\\{\`, \`\\}\`, \`&lt;\`, \`&gt;\` (or wrapped in backticks).
+2. **Invalid Shiki language identifiers** \u2014 Code fences with unsupported language tags (e.g. \`\`\`env\`\`\`, \`\`\`conf\`\`\`, \`\`\`plaintext\`\`\`) should be changed to a supported language or removed (use \`\`\`text\`\`\` or plain \`\`\`\`\`\` as fallback).
+3. **Malformed Mermaid diagrams** \u2014 Syntax errors inside \`\`\`mermaid\`\`\` blocks (unclosed quotes, invalid node IDs, missing arrows).
+4. **Unclosed code fences** \u2014 Missing closing \`\`\`\`\`\` causing the rest of the file to be parsed as code.
+5. **Invalid frontmatter** \u2014 Malformed YAML in \`---\` blocks (bad indentation, unquoted special characters).
+6. **HTML comments** \u2014 \`<!-- -->\` is not valid in MDX; remove or convert to JSX comments \`{/* */}\`.
+7. **Unescaped pipes in tables** \u2014 Pipes inside table cells that break table parsing.
+8. **Import/export statements** \u2014 Invalid or unnecessary import/export statements in MDX files.
+
+## Rules
+
+- ONLY edit files inside \`content/docs/\`. Never touch other project files.
+- Read the error output carefully to identify the exact file(s) and line(s).
+- Use Read to examine the broken file, then Edit to fix it.
+- After fixing, set \`fixed: true\` and list all changed file paths in \`filesChanged\`.
+- If you cannot identify or fix the error, set \`fixed: false\` and explain why in \`summary\`.
+- Be surgical: fix only what's broken, don't rewrite entire files.`;
+async function fixMdxBuildErrors(docsDir, buildErrors, apiKey, model, onAgentMessage) {
+  return runAgent({
+    onAgentMessage,
+    systemPrompt: SYSTEM_PROMPT,
+    prompt: `The following build errors occurred when building this Fumadocs documentation site.
+Diagnose and fix the MDX files causing these errors.
+
+## Build Error Output
+\`\`\`
+${buildErrors}
+\`\`\`
+
+Read the failing files, identify the issues, and use Edit to fix them.
+Only edit files inside content/docs/.`,
+    cwd: docsDir,
+    apiKey,
+    model,
+    outputSchema: fixerOutputSchema,
+    allowedTools: ["Read", "Glob", "Grep", "Edit"],
+    maxTurns: 20,
+    retryOnMaxTurns: false
+  });
+}
 var CACHE_VERSION = 2;
 function slugify(name) {
   return name.replace(/[^a-zA-Z0-9_-]/g, "_");
 }
-function cacheFilePath(cacheDir, repoSlug) {
-  return path62.join(cacheDir, `${slugify(repoSlug)}-analysis.json`);
+function cacheFilePath(cacheDir, repoSlug) {
+  return path6.join(cacheDir, `${slugify(repoSlug)}-analysis.json`);
+}
+function saveCache(cacheDir, repoSlug, commitSha, result) {
+  fs6.mkdirSync(cacheDir, { recursive: true });
+  const cache = {
+    version: CACHE_VERSION,
+    commitSha,
+    timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+    result
+  };
+  fs6.writeFileSync(cacheFilePath(cacheDir, repoSlug), JSON.stringify(cache), "utf-8");
+}
+function loadCache(cacheDir, repoSlug) {
+  const filePath = cacheFilePath(cacheDir, repoSlug);
+  if (!fs6.existsSync(filePath)) return null;
+  try {
+    const raw = JSON.parse(fs6.readFileSync(filePath, "utf-8"));
+    if (raw.version !== CACHE_VERSION) return null;
+    if (!raw.commitSha || !raw.result) return null;
+    return raw;
+  } catch {
+    return null;
+  }
+}
+
+// src/actions/build-check.ts
+function runBuild(docsDir) {
+  try {
+    execSync4("npx fumadocs-mdx", { cwd: docsDir, stdio: "pipe", timeout: 6e4 });
+    execSync4("npm run build", { cwd: docsDir, stdio: "pipe", timeout: 3e5 });
+    return { success: true, output: "" };
+  } catch (err) {
+    const error = err;
+    const stdout = error.stdout?.toString() || "";
+    const stderr = error.stderr?.toString() || "";
+    const output = `${stdout}
+${stderr}`.trim();
+    return { success: false, output };
+  }
+}
+function truncateErrors(output, max = 8e3) {
+  if (output.length <= max) return output;
+  return output.slice(0, max) + "\n\n... (truncated)";
+}
+async function runBuildCheck(options) {
+  const { docsDir, apiKey, model, maxAttempts = 3 } = options;
+  const spinner8 = p4.spinner();
+  spinner8.start("Verifying documentation build...");
+  for (let attempt = 1; attempt <= maxAttempts; attempt++) {
+    const { success, output } = runBuild(docsDir);
+    if (success) {
+      spinner8.stop("Documentation build verified");
+      return { success: true, attempts: attempt };
+    }
+    if (attempt >= maxAttempts) {
+      spinner8.stop("Build check failed after all attempts");
+      p4.log.warn(
+        "Documentation build has errors that could not be auto-fixed.\nYour docs site may still work \u2014 some errors are non-fatal.\nYou can fix remaining issues manually and run `npm run build` in the docs directory."
+      );
+      return { success: false, attempts: attempt, lastErrors: output };
+    }
+    spinner8.message(`Build errors detected \u2014 AI is diagnosing and fixing (attempt ${attempt}/${maxAttempts})...`);
+    try {
+      const result = await fixMdxBuildErrors(
+        docsDir,
+        truncateErrors(output),
+        apiKey,
+        model,
+        (text4) => spinner8.message(text4)
+      );
+      if (!result.fixed) {
+        spinner8.stop("AI fixer could not resolve the build errors");
+        p4.log.warn(result.summary);
+        return { success: false, attempts: attempt, lastErrors: output };
+      }
+      p4.log.info(`Fixed ${result.filesChanged.length} file(s): ${result.summary}`);
+      spinner8.start("Re-verifying build...");
+    } catch (err) {
+      spinner8.stop("AI fixer encountered an error");
+      p4.log.warn(`Fixer error: ${err instanceof Error ? err.message : err}`);
+      return { success: false, attempts: attempt, lastErrors: output };
+    }
+  }
+  return { success: false, attempts: maxAttempts };
+}
+
+// src/actions/setup-ci-action.ts
+import * as p5 from "@clack/prompts";
+import { execSync as execSync5 } from "child_process";
+import fs7 from "fs";
+import path7 from "path";
+import { Octokit as Octokit3 } from "@octokit/rest";
+function getGitRoot() {
+  try {
+    return execSync5("git rev-parse --show-toplevel", {
+      encoding: "utf-8",
+      stdio: ["pipe", "pipe", "pipe"]
+    }).trim();
+  } catch {
+    return null;
+  }
+}
+function generateWorkflow(branch, docsRepoUrl, outputDir) {
+  return `name: Update Documentation
+
+on:
+  push:
+    branches: [${branch}]
+  workflow_dispatch:
+
+jobs:
+  update-docs:
+    runs-on: ubuntu-latest
+    steps:
+      - name: Checkout source repo
+        uses: actions/checkout@v4
+        with:
+          fetch-depth: 0
+
+      - name: Setup Node.js
+        uses: actions/setup-node@v4
+        with:
+          node-version: 20
+
+      - name: Cache analysis results
+        uses: actions/cache@v4
+        with:
+          path: .autodoc-cache
+          key: autodoc-cache-\${{ github.sha }}
+          restore-keys: |
+            autodoc-cache-
+
+      - name: Install open-auto-doc
+        run: npm install -g @latent-space-labs/open-auto-doc
+
+      - name: Generate documentation
+        env:
+          ANTHROPIC_API_KEY: \${{ secrets.ANTHROPIC_API_KEY }}
+          GITHUB_TOKEN: \${{ secrets.GITHUB_TOKEN }}
+        run: open-auto-doc generate --incremental
+
+      - name: Clone docs repo
+        run: |
+          git clone https://x-access-token:\${{ secrets.DOCS_DEPLOY_TOKEN }}@${docsRepoUrl.replace("https://", "")} docs-repo
+
+      - name: Copy updated content
+        run: |
+          # Copy content and any updated config, preserving the docs repo git history
+          rsync -av --delete \\
+            --exclude '.git' \\
+            --exclude 'node_modules' \\
+            --exclude '.next' \\
+            --exclude '.source' \\
+            ${outputDir}/ docs-repo/
+
+      - name: Push to docs repo
+        run: |
+          cd docs-repo
+          git config user.name "github-actions[bot]"
+          git config user.email "github-actions[bot]@users.noreply.github.com"
+          git add -A
+          # Only commit and push if there are changes
+          if git diff --cached --quiet; then
+            echo "No documentation changes to push."
+          else
+            git commit -m "Update documentation from \${{ github.repository }}@\${{ github.sha }}"
+            git push
+          fi
+`;
+}
+function generatePerRepoWorkflow(branch, repoName, docsRepoUrl) {
+  return `name: Update Documentation
+
+on:
+  push:
+    branches: [${branch}]
+  workflow_dispatch:
+
+jobs:
+  update-docs:
+    runs-on: ubuntu-latest
+    steps:
+      - name: Checkout source repo
+        uses: actions/checkout@v4
+        with:
+          fetch-depth: 0
+
+      - name: Setup Node.js
+        uses: actions/setup-node@v4
+        with:
+          node-version: 20
+
+      - name: Install open-auto-doc
+        run: npm install -g @latent-space-labs/open-auto-doc
+
+      - name: Clone docs repo
+        run: |
+          git clone https://x-access-token:\${{ secrets.DOCS_DEPLOY_TOKEN }}@${docsRepoUrl.replace("https://", "")} docs-site
+
+      - name: Generate documentation
+        env:
+          ANTHROPIC_API_KEY: \${{ secrets.ANTHROPIC_API_KEY }}
+          GITHUB_TOKEN: \${{ secrets.DOCS_DEPLOY_TOKEN }}
+        run: open-auto-doc generate --repo ${repoName} --incremental
+
+      - name: Push to docs repo
+        run: |
+          cd docs-site
+          git config user.name "github-actions[bot]"
+          git config user.email "github-actions[bot]@users.noreply.github.com"
+          git add -A
+          if git diff --cached --quiet; then
+            echo "No documentation changes to push."
+          else
+            git commit -m "Update docs from \${{ github.repository }}@\${{ github.sha }}"
+            git pull --rebase origin main || true
+            git push
+          fi
+`;
+}
+async function createCiWorkflow(params) {
+  const { gitRoot, docsRepoUrl, outputDir, token, config } = params;
+  if (config && config.repos.length > 1 && token) {
+    return createCiWorkflowsMultiRepo({
+      token,
+      config,
+      docsRepoUrl
+    });
+  }
+  const relativeOutputDir = path7.relative(gitRoot, path7.resolve(outputDir));
+  p5.log.info(`Docs repo: ${docsRepoUrl}`);
+  p5.log.info(`Output directory: ${relativeOutputDir}`);
+  const branch = await p5.text({
+    message: "Which branch should trigger doc updates?",
+    initialValue: "main",
+    validate: (v) => v.length === 0 ? "Branch name is required" : void 0
+  });
+  if (p5.isCancel(branch)) return null;
+  const workflowDir = path7.join(gitRoot, ".github", "workflows");
+  const workflowPath = path7.join(workflowDir, "update-docs.yml");
+  fs7.mkdirSync(workflowDir, { recursive: true });
+  fs7.writeFileSync(
+    workflowPath,
+    generateWorkflow(branch, docsRepoUrl, relativeOutputDir),
+    "utf-8"
+  );
+  p5.log.success(`Created ${path7.relative(gitRoot, workflowPath)}`);
+  if (token) {
+    try {
+      const origin = execSync5("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 };
 }
-function saveCache(cacheDir, repoSlug, commitSha, result) {
-  fs62.mkdirSync(cacheDir, { recursive: true });
-  const cache = {
-    version: CACHE_VERSION,
-    commitSha,
-    timestamp: (/* @__PURE__ */ new Date()).toISOString(),
-    result
-  };
-  fs62.writeFileSync(cacheFilePath(cacheDir, repoSlug), JSON.stringify(cache), "utf-8");
+async function createCiWorkflowsMultiRepo(params) {
+  const { token, config, docsRepoUrl } = params;
+  const octokit = new Octokit3({ auth: token });
+  p5.log.info(`Setting up CI for ${config.repos.length} repositories`);
+  p5.log.info(`Docs repo: ${docsRepoUrl}`);
+  const branch = await p5.text({
+    message: "Which branch should trigger doc updates?",
+    initialValue: "main",
+    validate: (v) => v.length === 0 ? "Branch name is required" : void 0
+  });
+  if (p5.isCancel(branch)) return null;
+  const createdRepos = [];
+  const workflowPath = ".github/workflows/update-docs.yml";
+  for (const repo of config.repos) {
+    const spinner8 = p5.spinner();
+    spinner8.start(`Pushing workflow to ${repo.fullName}...`);
+    try {
+      const [owner, repoName] = repo.fullName.split("/");
+      const workflowContent = generatePerRepoWorkflow(branch, repo.name, docsRepoUrl);
+      const contentBase64 = Buffer.from(workflowContent).toString("base64");
+      let existingSha;
+      try {
+        const { data } = await octokit.rest.repos.getContent({
+          owner,
+          repo: repoName,
+          path: workflowPath
+        });
+        if (!Array.isArray(data) && data.type === "file") {
+          existingSha = data.sha;
+        }
+      } catch {
+      }
+      await octokit.rest.repos.createOrUpdateFileContents({
+        owner,
+        repo: repoName,
+        path: workflowPath,
+        message: "Add auto-documentation CI workflow",
+        content: contentBase64,
+        ...existingSha ? { sha: existingSha } : {}
+      });
+      createdRepos.push(repo.fullName);
+      spinner8.stop(`Created workflow in ${repo.fullName}`);
+    } catch (err) {
+      spinner8.stop(`Failed for ${repo.fullName}`);
+      p5.log.warn(`Could not push workflow to ${repo.fullName}: ${err?.message || err}`);
+    }
+  }
+  if (createdRepos.length === 0) {
+    p5.log.error("Failed to create workflows in any repository.");
+    return null;
+  }
+  p5.log.success(`Created workflows in ${createdRepos.length}/${config.repos.length} repositories`);
+  await verifySecretsInteractive(octokit, createdRepos);
+  return { repos: createdRepos, branch };
 }
-function loadCache(cacheDir, repoSlug) {
-  const filePath = cacheFilePath(cacheDir, repoSlug);
-  if (!fs62.existsSync(filePath)) return null;
+var REQUIRED_SECRETS = ["ANTHROPIC_API_KEY", "DOCS_DEPLOY_TOKEN"];
+async function checkSecret(octokit, owner, repo, secretName) {
   try {
-    const raw = JSON.parse(fs62.readFileSync(filePath, "utf-8"));
-    if (raw.version !== CACHE_VERSION) return null;
-    if (!raw.commitSha || !raw.result) return null;
-    return raw;
+    await octokit.rest.actions.getRepoSecret({ owner, repo, secret_name: secretName });
+    return true;
   } catch {
-    return null;
+    return false;
+  }
+}
+async function verifySecretsInteractive(octokit, repos) {
+  const shouldVerify = await p5.confirm({
+    message: "Would you like to verify secrets now? (you can add them later)",
+    initialValue: true
+  });
+  if (p5.isCancel(shouldVerify) || !shouldVerify) {
+    showSecretsInstructions(repos.length > 1);
+    return;
+  }
+  p5.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("/");
+    p5.log.step(`Add secrets to ${fullName}`);
+    p5.log.message(`  https://github.com/${fullName}/settings/secrets/actions`);
+    let allFound = false;
+    while (!allFound) {
+      await p5.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]) {
+          p5.log.success(`${secret} \u2014 found`);
+        } else {
+          p5.log.warn(`${secret} \u2014 not found`);
+        }
+      }
+      summary[fullName] = results;
+      allFound = REQUIRED_SECRETS.every((s) => results[s]);
+      if (!allFound) {
+        const retry = await p5.confirm({
+          message: "Some secrets are missing. Would you like to try again?",
+          initialValue: true
+        });
+        if (p5.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) {
+    p5.note(lines.join("\n"), "All secrets verified!");
+  } else {
+    p5.note(lines.join("\n"), "Secret status");
+    p5.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:";
+  p5.note(
+    [
+      repoNote,
+      "(Settings \u2192 Secrets and variables \u2192 Actions \u2192 New repository secret)",
+      "",
+      "  ANTHROPIC_API_KEY   \u2014 Your Anthropic API key",
+      "  DOCS_DEPLOY_TOKEN   \u2014 GitHub PAT with repo scope",
+      "                        (needed to push to the docs repo)",
+      "",
+      "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",
+      "",
+      "Note: GITHUB_TOKEN is automatically provided by GitHub Actions",
+      "      (used for reading the source repo during analysis)."
+    ].join("\n"),
+    "Required GitHub Secrets"
+  );
+}
 
 // ../generator/dist/index.js
-import fs7 from "fs-extra";
-import path7 from "path";
-import { execSync as execSync5 } from "child_process";
+import fs8 from "fs-extra";
+import path8 from "path";
+import { execSync as execSync6 } from "child_process";
 import fs23 from "fs-extra";
 import path23 from "path";
 import Handlebars from "handlebars";
@@ -2171,40 +2294,40 @@ import { fileURLToPath } from "url";
 import fs33 from "fs-extra";
 import path33 from "path";
 async function scaffoldSite(outputDir, projectName, templateDir) {
-  await fs7.copy(templateDir, outputDir, {
+  await fs8.copy(templateDir, outputDir, {
     overwrite: true,
     filter: (src) => {
-      const basename = path7.basename(src);
+      const basename = path8.basename(src);
       return basename !== "node_modules" && basename !== ".next" && basename !== ".source" && basename !== "dist" && basename !== ".turbo";
     }
   });
   const filesToProcess = await findTextFiles(outputDir);
   for (const filePath of filesToProcess) {
     try {
-      let content = await fs7.readFile(filePath, "utf-8");
+      let content = await fs8.readFile(filePath, "utf-8");
       if (content.includes("{{projectName}}")) {
         content = content.replace(/\{\{projectName\}\}/g, projectName);
-        await fs7.writeFile(filePath, content, "utf-8");
+        await fs8.writeFile(filePath, content, "utf-8");
       }
     } catch {
     }
   }
-  const nodeModulesPath = path7.join(outputDir, "node_modules");
-  if (!fs7.existsSync(nodeModulesPath)) {
+  const nodeModulesPath = path8.join(outputDir, "node_modules");
+  if (!fs8.existsSync(nodeModulesPath)) {
     try {
-      execSync5("npm install --ignore-scripts", {
+      execSync6("npm install --ignore-scripts", {
         cwd: outputDir,
         stdio: "pipe",
         timeout: 12e4
       });
     } catch (err) {
-      const hasNodeModules = fs7.existsSync(nodeModulesPath);
+      const hasNodeModules = fs8.existsSync(nodeModulesPath);
       if (!hasNodeModules) {
         throw new Error(`npm install failed: ${err instanceof Error ? err.message : err}`);
       }
     }
     try {
-      execSync5("npx fumadocs-mdx", { cwd: outputDir, stdio: "pipe", timeout: 3e4 });
+      execSync6("npx fumadocs-mdx", { cwd: outputDir, stdio: "pipe", timeout: 3e4 });
     } catch {
     }
   }
@@ -2227,14 +2350,14 @@ async function findTextFiles(dir) {
   ]);
   const results = [];
   async function walk(currentDir) {
-    const entries = await fs7.readdir(currentDir, { withFileTypes: true });
+    const entries = await fs8.readdir(currentDir, { withFileTypes: true });
     for (const entry of entries) {
-      const fullPath = path7.join(currentDir, entry.name);
+      const fullPath = path8.join(currentDir, entry.name);
       if (entry.isDirectory()) {
         if (entry.name !== "node_modules" && entry.name !== ".next" && entry.name !== ".source") {
           await walk(fullPath);
         }
-      } else if (textExtensions.has(path7.extname(entry.name))) {
+      } else if (textExtensions.has(path8.extname(entry.name))) {
         results.push(fullPath);
       }
     }
@@ -2666,13 +2789,215 @@ 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));
+var __dirname2 = path9.dirname(fileURLToPath2(import.meta.url));
 async function initCommand(options) {
-  p5.intro("open-auto-doc \u2014 AI-powered documentation generator");
+  p6.intro("open-auto-doc \u2014 AI-powered documentation generator");
   const templateDir = resolveTemplateDir();
-  if (!fs8.existsSync(path8.join(templateDir, "package.json"))) {
-    p5.log.error(
+  if (!fs9.existsSync(path9.join(templateDir, "package.json"))) {
+    p6.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`
@@ -2681,38 +3006,38 @@ Try reinstalling: npm install -g @latent-space-labs/open-auto-doc`
   }
   let token = getGithubToken();
   if (!token) {
-    p5.log.info("Let's connect your GitHub account.");
+    p6.log.info("Let's connect your GitHub account.");
     token = await authenticateWithGithub();
     setGithubToken(token);
   } else {
-    p5.log.success("Using saved GitHub credentials.");
+    p6.log.success("Using saved GitHub credentials.");
   }
   const repos = await pickRepos(token);
-  p5.log.info(`Selected ${repos.length} ${repos.length === 1 ? "repository" : "repositories"}`);
+  p6.log.info(`Selected ${repos.length} ${repos.length === 1 ? "repository" : "repositories"}`);
   let apiKey = getAnthropicKey();
   if (!apiKey) {
-    const keyInput = await p5.text({
+    const keyInput = await p6.text({
       message: "Enter your Anthropic API key",
       placeholder: "sk-ant-...",
       validate: (v) => {
         if (!v || !v.startsWith("sk-ant-")) return "Please enter a valid Anthropic API key";
       }
     });
-    if (p5.isCancel(keyInput)) {
-      p5.cancel("Operation cancelled");
+    if (p6.isCancel(keyInput)) {
+      p6.cancel("Operation cancelled");
       process.exit(0);
     }
     apiKey = keyInput;
-    const saveKey = await p5.confirm({
+    const saveKey = await p6.confirm({
       message: "Save API key for future use?"
     });
-    if (saveKey && !p5.isCancel(saveKey)) {
+    if (saveKey && !p6.isCancel(saveKey)) {
       setAnthropicKey(apiKey);
     }
   } else {
-    p5.log.success("Using saved Anthropic API key.");
+    p6.log.success("Using saved Anthropic API key.");
   }
-  const model = await p5.select({
+  const model = await p6.select({
     message: "Which model should analyze your repos?",
     options: [
       { value: "claude-sonnet-4-6", label: "Claude Sonnet 4.6", hint: "Fast & capable (recommended)" },
@@ -2720,12 +3045,12 @@ Try reinstalling: npm install -g @latent-space-labs/open-auto-doc`
       { value: "claude-opus-4-6", label: "Claude Opus 4.6", hint: "Most capable, slowest" }
     ]
   });
-  if (p5.isCancel(model)) {
-    p5.cancel("Operation cancelled");
+  if (p6.isCancel(model)) {
+    p6.cancel("Operation cancelled");
     process.exit(0);
   }
-  p5.log.info(`Using ${model}`);
-  const cloneSpinner = p5.spinner();
+  p6.log.info(`Using ${model}`);
+  const cloneSpinner = p6.spinner();
   cloneSpinner.start(`Cloning ${repos.length} repositories...`);
   const clones = [];
   for (const repo of repos) {
@@ -2734,25 +3059,20 @@ Try reinstalling: npm install -g @latent-space-labs/open-auto-doc`
       const cloned = cloneRepo(repo, token);
       clones.push(cloned);
     } catch (err) {
-      p5.log.warn(`Failed to clone ${repo.name}: ${err instanceof Error ? err.message : err}`);
+      p6.log.warn(`Failed to clone ${repo.name}: ${err instanceof Error ? err.message : err}`);
     }
   }
   cloneSpinner.stop(`Cloned ${clones.length}/${repos.length} repositories`);
   if (clones.length === 0) {
-    p5.log.error("No repositories were cloned.");
+    p6.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,
@@ -2761,35 +3081,33 @@ Try reinstalling: npm install -g @latent-space-labs/open-auto-doc`
         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 });
+      p6.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();
+  p6.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.");
+    p6.log.error("No repositories were successfully analyzed.");
     cleanup(clones);
     process.exit(1);
   }
   let crossRepo;
   if (results.length > 1) {
-    const crossSpinner = p5.spinner();
+    const crossSpinner = p6.spinner();
     crossSpinner.start("Analyzing cross-repository relationships...");
     try {
       crossRepo = await analyzeCrossRepos(results, apiKey, model, (text4) => {
@@ -2798,31 +3116,31 @@ Try reinstalling: npm install -g @latent-space-labs/open-auto-doc`
       crossSpinner.stop(`Cross-repo analysis complete \u2014 ${crossRepo.repoRelationships.length} relationships found`);
     } catch (err) {
       crossSpinner.stop("Cross-repo analysis failed (non-fatal)");
-      p5.log.warn(`Cross-repo error: ${err instanceof Error ? err.message : err}`);
+      p6.log.warn(`Cross-repo error: ${err instanceof Error ? err.message : err}`);
     }
   }
-  const outputDir = path8.resolve(options.output || "docs-site");
+  const outputDir = path9.resolve(options.output || "docs-site");
   const projectName = results.length === 1 ? results[0].repoName : "My Project";
-  const genSpinner = p5.spinner();
+  const genSpinner = p6.spinner();
   try {
     genSpinner.start("Scaffolding documentation site...");
     await scaffoldSite(outputDir, projectName, templateDir);
     genSpinner.stop("Site scaffolded");
   } catch (err) {
     genSpinner.stop("Scaffold failed");
-    p5.log.error(`Scaffold error: ${err instanceof Error ? err.stack || err.message : err}`);
+    p6.log.error(`Scaffold error: ${err instanceof Error ? err.stack || err.message : err}`);
     cleanup(clones);
     process.exit(1);
   }
   try {
     genSpinner.start("Writing documentation content...");
-    const contentDir = path8.join(outputDir, "content", "docs");
+    const contentDir = path9.join(outputDir, "content", "docs");
     await writeContent(contentDir, results, crossRepo);
     await writeMeta(contentDir, results, crossRepo);
     genSpinner.stop("Documentation content written");
   } catch (err) {
     genSpinner.stop("Content writing failed");
-    p5.log.error(`Content error: ${err instanceof Error ? err.stack || err.message : err}`);
+    p6.log.error(`Content error: ${err instanceof Error ? err.stack || err.message : err}`);
     cleanup(clones);
     process.exit(1);
   }
@@ -2840,16 +3158,21 @@ Try reinstalling: npm install -g @latent-space-labs/open-auto-doc`
   } catch {
   }
   cleanup(clones);
-  p5.log.success("Documentation generated successfully!");
-  const shouldDeploy = await p5.confirm({
+  try {
+    await runBuildCheck({ docsDir: outputDir, apiKey, model });
+  } catch (err) {
+    p6.log.warn(`Build check skipped: ${err instanceof Error ? err.message : err}`);
+  }
+  p6.log.success("Documentation generated successfully!");
+  const shouldDeploy = await p6.confirm({
     message: "Would you like to deploy your docs to GitHub?"
   });
-  if (p5.isCancel(shouldDeploy) || !shouldDeploy) {
-    p5.note(
-      `cd ${path8.relative(process.cwd(), outputDir)} && npm run dev`,
+  if (p6.isCancel(shouldDeploy) || !shouldDeploy) {
+    p6.note(
+      `cd ${path9.relative(process.cwd(), outputDir)} && npm run dev`,
       "Next steps"
     );
-    p5.outro("Done!");
+    p6.outro("Done!");
     return;
   }
   const deployResult = await createAndPushDocsRepo({
@@ -2858,26 +3181,26 @@ Try reinstalling: npm install -g @latent-space-labs/open-auto-doc`
     config
   });
   if (!deployResult) {
-    p5.note(
-      `cd ${path8.relative(process.cwd(), outputDir)} && npm run dev`,
+    p6.note(
+      `cd ${path9.relative(process.cwd(), outputDir)} && npm run dev`,
       "Next steps"
     );
-    p5.outro("Done!");
+    p6.outro("Done!");
     return;
   }
-  const shouldSetupCi = await p5.confirm({
+  const shouldSetupCi = await p6.confirm({
     message: "Would you like to set up CI to auto-update docs on every push?"
   });
-  if (p5.isCancel(shouldSetupCi) || !shouldSetupCi) {
+  if (p6.isCancel(shouldSetupCi) || !shouldSetupCi) {
     showVercelInstructions(deployResult.owner, deployResult.repoName);
-    p5.outro(`Docs repo: https://github.com/${deployResult.owner}/${deployResult.repoName}`);
+    p6.outro(`Docs repo: https://github.com/${deployResult.owner}/${deployResult.repoName}`);
     return;
   }
   const gitRoot = getGitRoot();
   if (!gitRoot) {
-    p5.log.warn("Not in a git repository \u2014 skipping CI setup. Run `open-auto-doc setup-ci` from your project root later.");
+    p6.log.warn("Not in a git repository \u2014 skipping CI setup. Run `open-auto-doc setup-ci` from your project root later.");
     showVercelInstructions(deployResult.owner, deployResult.repoName);
-    p5.outro(`Docs repo: https://github.com/${deployResult.owner}/${deployResult.repoName}`);
+    p6.outro(`Docs repo: https://github.com/${deployResult.owner}/${deployResult.repoName}`);
     return;
   }
   const ciResult = await createCiWorkflow({
@@ -2888,24 +3211,24 @@ Try reinstalling: npm install -g @latent-space-labs/open-auto-doc`
     config
   });
   showVercelInstructions(deployResult.owner, deployResult.repoName);
-  p5.outro(`Docs repo: https://github.com/${deployResult.owner}/${deployResult.repoName}`);
+  p6.outro(`Docs repo: https://github.com/${deployResult.owner}/${deployResult.repoName}`);
 }
 function resolveTemplateDir() {
   const candidates = [
-    path8.resolve(__dirname2, "site-template"),
+    path9.resolve(__dirname2, "site-template"),
     // dist/site-template (npm global install)
-    path8.resolve(__dirname2, "../../site-template"),
+    path9.resolve(__dirname2, "../../site-template"),
     // monorepo: packages/site-template
-    path8.resolve(__dirname2, "../../../site-template"),
+    path9.resolve(__dirname2, "../../../site-template"),
     // monorepo alt
-    path8.resolve(__dirname2, "../../../../packages/site-template")
+    path9.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;
+    const pkgPath = path9.join(candidate, "package.json");
+    if (fs9.existsSync(pkgPath)) return candidate;
   }
-  return path8.resolve(__dirname2, "site-template");
+  return path9.resolve(__dirname2, "site-template");
 }
 function cleanup(clones) {
   for (const clone of clones) {
@@ -2914,26 +3237,26 @@ function cleanup(clones) {
 }
 
 // src/commands/generate.ts
-import * as p6 from "@clack/prompts";
-import path9 from "path";
+import * as p7 from "@clack/prompts";
+import path10 from "path";
 async function generateCommand(options) {
-  p6.intro("open-auto-doc \u2014 Regenerating documentation");
+  p7.intro("open-auto-doc \u2014 Regenerating documentation");
   const config = loadConfig();
   if (!config) {
-    p6.log.error("No .autodocrc.json found. Run `open-auto-doc init` first.");
+    p7.log.error("No .autodocrc.json found. Run `open-auto-doc init` first.");
     process.exit(1);
   }
   const token = getGithubToken();
   const apiKey = getAnthropicKey();
   if (!token) {
-    p6.log.error("Not authenticated. Run `open-auto-doc login` or set GITHUB_TOKEN env var.");
+    p7.log.error("Not authenticated. Run `open-auto-doc login` or set GITHUB_TOKEN env var.");
     process.exit(1);
   }
   if (!apiKey) {
-    p6.log.error("No Anthropic API key found. Run `open-auto-doc init` or set ANTHROPIC_API_KEY env var.");
+    p7.log.error("No Anthropic API key found. Run `open-auto-doc init` or set ANTHROPIC_API_KEY env var.");
     process.exit(1);
   }
-  const model = await p6.select({
+  const model = await p7.select({
     message: "Which model should analyze your repos?",
     options: [
       { value: "claude-sonnet-4-6", label: "Claude Sonnet 4.6", hint: "Fast & capable (recommended)" },
@@ -2941,20 +3264,20 @@ async function generateCommand(options) {
       { value: "claude-opus-4-6", label: "Claude Opus 4.6", hint: "Most capable, slowest" }
     ]
   });
-  if (p6.isCancel(model)) {
-    p6.cancel("Cancelled.");
+  if (p7.isCancel(model)) {
+    p7.cancel("Cancelled.");
     process.exit(0);
   }
-  p6.log.info(`Using ${model}`);
+  p7.log.info(`Using ${model}`);
   const incremental = options.incremental && !options.force;
-  const cacheDir = path9.join(config.outputDir, ".autodoc-cache");
+  const cacheDir = path10.join(config.outputDir, ".autodoc-cache");
   const targetRepoName = options.repo;
   let reposToAnalyze = config.repos;
   const cachedResults = [];
   if (targetRepoName) {
     const targetRepo = config.repos.find((r) => r.name === targetRepoName);
     if (!targetRepo) {
-      p6.log.error(`Repo "${targetRepoName}" not found in config. Available: ${config.repos.map((r) => r.name).join(", ")}`);
+      p7.log.error(`Repo "${targetRepoName}" not found in config. Available: ${config.repos.map((r) => r.name).join(", ")}`);
       process.exit(1);
     }
     reposToAnalyze = [targetRepo];
@@ -2963,13 +3286,13 @@ async function generateCommand(options) {
       const cached = loadCache(cacheDir, repo.name);
       if (cached) {
         cachedResults.push(cached.result);
-        p6.log.info(`Using cached analysis for ${repo.name}`);
+        p7.log.info(`Using cached analysis for ${repo.name}`);
       } else {
-        p6.log.warn(`No cached analysis for ${repo.name} \u2014 its docs will be stale until it pushes`);
+        p7.log.warn(`No cached analysis for ${repo.name} \u2014 its docs will be stale until it pushes`);
       }
     }
   }
-  const cloneSpinner = p6.spinner();
+  const cloneSpinner = p7.spinner();
   cloneSpinner.start(`Cloning ${reposToAnalyze.length} ${reposToAnalyze.length === 1 ? "repository" : "repositories"}...`);
   const clones = [];
   for (const repo of reposToAnalyze) {
@@ -2988,32 +3311,24 @@ async function generateCommand(options) {
       );
       clones.push(cloned);
     } catch (err) {
-      p6.log.warn(`Failed to clone ${repo.name}: ${err instanceof Error ? err.message : err}`);
+      p7.log.warn(`Failed to clone ${repo.name}: ${err instanceof Error ? err.message : err}`);
     }
   }
   cloneSpinner.stop(`Cloned ${clones.length}/${reposToAnalyze.length} ${reposToAnalyze.length === 1 ? "repository" : "repositories"}`);
   if (clones.length === 0) {
-    p6.log.error("No repositories were cloned.");
+    p7.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) {
@@ -3027,7 +3342,7 @@ async function generateCommand(options) {
             model,
             previousResult: cached.result,
             previousCommitSha: cached.commitSha,
-            ...callbacks
+            onProgress
           });
         } else {
           result = await analyzeRepository({
@@ -3036,7 +3351,7 @@ async function generateCommand(options) {
             repoUrl: repo.htmlUrl,
             apiKey,
             model,
-            ...callbacks
+            onProgress
           });
         }
       } else {
@@ -3046,7 +3361,7 @@ async function generateCommand(options) {
           repoUrl: repo.htmlUrl,
           apiKey,
           model,
-          ...callbacks
+          onProgress
         });
       }
       try {
@@ -3054,26 +3369,27 @@ 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 });
+      p7.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();
+  p7.log.step(
+    `Analyzed ${analyzedCount}/${total} ${total === 1 ? "repository" : "repositories"}` + (failedCount > 0 ? ` (${failedCount} failed)` : "")
+  );
   const results = [...freshResults, ...cachedResults];
   if (results.length > 0) {
     let crossRepo;
     if (results.length > 1) {
-      const crossSpinner = p6.spinner();
+      const crossSpinner = p7.spinner();
       crossSpinner.start("Analyzing cross-repository relationships...");
       try {
         crossRepo = await analyzeCrossRepos(results, apiKey, model, (text4) => {
@@ -3082,61 +3398,66 @@ async function generateCommand(options) {
         crossSpinner.stop(`Cross-repo analysis complete \u2014 ${crossRepo.repoRelationships.length} relationships found`);
       } catch (err) {
         crossSpinner.stop("Cross-repo analysis failed (non-fatal)");
-        p6.log.warn(`Cross-repo error: ${err instanceof Error ? err.message : err}`);
+        p7.log.warn(`Cross-repo error: ${err instanceof Error ? err.message : err}`);
       }
     }
-    const contentDir = path9.join(config.outputDir, "content", "docs");
+    const contentDir = path10.join(config.outputDir, "content", "docs");
     await writeContent(contentDir, results, crossRepo);
     await writeMeta(contentDir, results, crossRepo);
-    p6.log.success("Documentation regenerated!");
+    try {
+      await runBuildCheck({ docsDir: config.outputDir, apiKey, model });
+    } catch (err) {
+      p7.log.warn(`Build check skipped: ${err instanceof Error ? err.message : err}`);
+    }
+    p7.log.success("Documentation regenerated!");
   }
   for (const clone of clones) {
     cleanupClone(clone);
   }
-  p6.outro("Done!");
+  p7.outro("Done!");
 }
 
 // src/commands/deploy.ts
-import * as p7 from "@clack/prompts";
-import fs9 from "fs";
-import path10 from "path";
+import * as p8 from "@clack/prompts";
+import fs10 from "fs";
+import path11 from "path";
 function resolveDocsDir(config, dirOption) {
   if (dirOption) {
-    const resolved = path10.resolve(dirOption);
-    if (!fs9.existsSync(resolved)) {
-      p7.log.error(`Directory not found: ${resolved}`);
+    const resolved = path11.resolve(dirOption);
+    if (!fs10.existsSync(resolved)) {
+      p8.log.error(`Directory not found: ${resolved}`);
       process.exit(1);
     }
     return resolved;
   }
-  if (config?.outputDir && fs9.existsSync(path10.resolve(config.outputDir))) {
-    return path10.resolve(config.outputDir);
+  if (config?.outputDir && fs10.existsSync(path11.resolve(config.outputDir))) {
+    return path11.resolve(config.outputDir);
   }
-  if (fs9.existsSync(path10.resolve("docs-site"))) {
-    return path10.resolve("docs-site");
+  if (fs10.existsSync(path11.resolve("docs-site"))) {
+    return path11.resolve("docs-site");
   }
-  p7.log.error(
+  p8.log.error(
     "Could not find docs site directory. Use --dir to specify the path, or run `open-auto-doc init` first."
   );
   process.exit(1);
 }
 async function deployCommand(options) {
-  p7.intro("open-auto-doc \u2014 Deploy docs to GitHub");
+  p8.intro("open-auto-doc \u2014 Deploy docs to GitHub");
   const token = getGithubToken();
   if (!token) {
-    p7.log.error("Not authenticated. Run `open-auto-doc login` first.");
+    p8.log.error("Not authenticated. Run `open-auto-doc login` first.");
     process.exit(1);
   }
   const config = loadConfig();
   const docsDir = resolveDocsDir(config, options.dir);
-  p7.log.info(`Docs directory: ${docsDir}`);
+  p8.log.info(`Docs directory: ${docsDir}`);
   if (config?.docsRepo) {
-    p7.log.info(`Docs repo already configured: ${config.docsRepo}`);
+    p8.log.info(`Docs repo already configured: ${config.docsRepo}`);
     const pushed = await pushUpdates({ token, docsDir, docsRepo: config.docsRepo });
     if (pushed) {
-      p7.outro("Docs updated! Vercel will auto-deploy from the push.");
+      p8.outro("Docs updated! Vercel will auto-deploy from the push.");
     } else {
-      p7.outro("Docs are up to date!");
+      p8.outro("Docs are up to date!");
     }
     return;
   }
@@ -3146,20 +3467,20 @@ async function deployCommand(options) {
     config: config || { repos: [], outputDir: docsDir }
   });
   if (!result) {
-    p7.cancel("Deploy cancelled.");
+    p8.cancel("Deploy cancelled.");
     process.exit(0);
   }
   showVercelInstructions(result.owner, result.repoName);
-  p7.outro(`Docs repo: https://github.com/${result.owner}/${result.repoName}`);
+  p8.outro(`Docs repo: https://github.com/${result.owner}/${result.repoName}`);
 }
 
 // src/commands/setup-ci.ts
-import * as p8 from "@clack/prompts";
+import * as p9 from "@clack/prompts";
 async function setupCiCommand() {
-  p8.intro("open-auto-doc \u2014 CI/CD Setup");
+  p9.intro("open-auto-doc \u2014 CI/CD Setup");
   const config = loadConfig();
   if (!config?.docsRepo) {
-    p8.log.error(
+    p9.log.error(
       "No docs repo configured. Run `open-auto-doc deploy` first to create a docs GitHub repo."
     );
     process.exit(1);
@@ -3167,12 +3488,12 @@ async function setupCiCommand() {
   const token = getGithubToken();
   const isMultiRepo = config.repos.length > 1;
   if (isMultiRepo && !token) {
-    p8.log.error("Not authenticated. Run `open-auto-doc login` first (needed to push workflows to source repos).");
+    p9.log.error("Not authenticated. Run `open-auto-doc login` first (needed to push workflows to source repos).");
     process.exit(1);
   }
   const gitRoot = getGitRoot();
   if (!isMultiRepo && !gitRoot) {
-    p8.log.error("Not in a git repository. Run this command from your project root.");
+    p9.log.error("Not in a git repository. Run this command from your project root.");
     process.exit(1);
   }
   const result = await createCiWorkflow({
@@ -3183,46 +3504,46 @@ async function setupCiCommand() {
     config
   });
   if (!result) {
-    p8.cancel("Setup cancelled.");
+    p9.cancel("Setup cancelled.");
     process.exit(0);
   }
   if ("repos" in result) {
-    p8.outro("Per-repo CI workflows created! Add the required secrets to each source repo.");
+    p9.outro("Per-repo CI workflows created! Add the required secrets to each source repo.");
   } else {
-    p8.outro("CI/CD workflow is ready! Commit and push to activate.");
+    p9.outro("CI/CD workflow is ready! Commit and push to activate.");
   }
 }
 
 // src/commands/login.ts
-import * as p9 from "@clack/prompts";
+import * as p10 from "@clack/prompts";
 async function loginCommand() {
-  p9.intro("open-auto-doc \u2014 GitHub Login");
+  p10.intro("open-auto-doc \u2014 GitHub Login");
   const existing = getGithubToken();
   if (existing) {
-    const overwrite = await p9.confirm({
+    const overwrite = await p10.confirm({
       message: "You're already logged in. Re-authenticate?"
     });
-    if (!overwrite || p9.isCancel(overwrite)) {
-      p9.cancel("Keeping existing credentials");
+    if (!overwrite || p10.isCancel(overwrite)) {
+      p10.cancel("Keeping existing credentials");
       return;
     }
   }
   const token = await authenticateWithGithub();
   setGithubToken(token);
-  p9.outro("Logged in successfully!");
+  p10.outro("Logged in successfully!");
 }
 
 // src/commands/logout.ts
-import * as p10 from "@clack/prompts";
+import * as p11 from "@clack/prompts";
 async function logoutCommand() {
-  p10.intro("open-auto-doc \u2014 Logout");
+  p11.intro("open-auto-doc \u2014 Logout");
   clearAll();
-  p10.outro("Credentials cleared. You've been logged out.");
+  p11.outro("Credentials cleared. You've been logged out.");
 }
 
 // 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.3");
+program.name("open-auto-doc").description("Auto-generate beautiful documentation websites from GitHub repositories using AI").version("0.3.5");
 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);