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

package/dist/index.js

@@ -4,7 +4,7 @@
 import { Command } from "commander";
 
 // src/commands/init.ts
-import * as p3 from "@clack/prompts";
+import * as p5 from "@clack/prompts";
 import fs8 from "fs";
 import path8 from "path";
 import { fileURLToPath as fileURLToPath2 } from "url";
@@ -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 spinner6 = p.spinner();
-  spinner6.start("Waiting for GitHub authorization...");
+  const spinner7 = p.spinner();
+  spinner7.start("Waiting for GitHub authorization...");
   const token = await pollForToken(deviceData.device_code, deviceData.interval);
-  spinner6.stop("GitHub authentication successful!");
+  spinner7.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 spinner6 = p2.spinner();
-  spinner6.start("Fetching your repositories...");
+  const spinner7 = p2.spinner();
+  spinner7.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++;
   }
-  spinner6.stop(`Found ${repos.length} repositories`);
+  spinner7.stop(`Found ${repos.length} repositories`);
   const selected = await p2.multiselect({
     message: "Select repositories to document",
     options: repos.slice(0, 50).map((r) => ({
@@ -205,22 +205,451 @@ async function pickRepos(token) {
   return repos.filter((r) => selected.includes(r.fullName));
 }
 
-// ../analyzer/dist/index.js
+// src/config.ts
 import fs3 from "fs";
 import path3 from "path";
-import ignore from "ignore";
-import fs22 from "fs";
-import path22 from "path";
-import fs32 from "fs";
-import path32 from "path";
+function loadConfig() {
+  for (const candidate of [
+    path3.resolve(".autodocrc.json"),
+    path3.resolve("docs-site", ".autodocrc.json")
+  ]) {
+    if (fs3.existsSync(candidate)) {
+      try {
+        return JSON.parse(fs3.readFileSync(candidate, "utf-8"));
+      } catch {
+      }
+    }
+  }
+  return null;
+}
+function saveConfig(config) {
+  fs3.writeFileSync(
+    path3.resolve(".autodocrc.json"),
+    JSON.stringify(config, null, 2)
+  );
+  if (config.outputDir && fs3.existsSync(config.outputDir)) {
+    fs3.writeFileSync(
+      path3.join(config.outputDir, ".autodocrc.json"),
+      JSON.stringify(config, null, 2)
+    );
+  }
+}
+
+// src/actions/deploy-action.ts
+import * as p3 from "@clack/prompts";
+import { execSync as execSync2 } from "child_process";
 import fs4 from "fs";
 import path4 from "path";
-import { query } from "@anthropic-ai/claude-agent-sdk";
+import { Octokit as Octokit2 } from "@octokit/rest";
+function exec(cmd, cwd) {
+  return execSync2(cmd, { cwd, encoding: "utf-8", stdio: ["pipe", "pipe", "pipe"] }).trim();
+}
+function getGitHubUsername(octokit) {
+  return octokit.rest.users.getAuthenticated().then((res) => res.data.login);
+}
+async function createAndPushDocsRepo(params) {
+  const { token, docsDir, config } = params;
+  const octokit = new Octokit2({ auth: token });
+  const username = await getGitHubUsername(octokit);
+  let orgs = [];
+  try {
+    const { data } = await octokit.rest.orgs.listForAuthenticatedUser({ per_page: 100 });
+    orgs = data;
+  } catch {
+  }
+  const ownerOptions = [
+    { value: username, label: username, hint: "Personal account" },
+    ...orgs.map((org) => ({ value: org.login, label: org.login, hint: "Organization" }))
+  ];
+  let owner = username;
+  if (ownerOptions.length > 1) {
+    const selected = await p3.select({
+      message: "Where should the docs repo be created?",
+      options: ownerOptions
+    });
+    if (p3.isCancel(selected)) return null;
+    owner = selected;
+  }
+  const isOrg = owner !== username;
+  const defaultName = config?.repos?.[0] ? `${config.repos[0].name}-docs` : "my-project-docs";
+  const repoName = await p3.text({
+    message: "Name for the docs GitHub repo:",
+    initialValue: defaultName,
+    validate: (v) => {
+      if (!v || v.length === 0) return "Repo name is required";
+      if (!/^[a-zA-Z0-9._-]+$/.test(v)) return "Invalid repo name";
+    }
+  });
+  if (p3.isCancel(repoName)) return null;
+  const visibility = await p3.select({
+    message: "Repository visibility:",
+    options: [
+      { value: "public", label: "Public" },
+      { value: "private", label: "Private" }
+    ]
+  });
+  if (p3.isCancel(visibility)) return null;
+  const spinner7 = p3.spinner();
+  spinner7.start(`Creating GitHub repo ${owner}/${repoName}...`);
+  let repoUrl;
+  try {
+    if (isOrg) {
+      const { data } = await octokit.rest.repos.createInOrg({
+        org: owner,
+        name: repoName,
+        private: visibility === "private",
+        description: "Auto-generated documentation site",
+        auto_init: false
+      });
+      repoUrl = data.clone_url;
+      spinner7.stop(`Created ${data.full_name}`);
+    } else {
+      const { data } = await octokit.rest.repos.createForAuthenticatedUser({
+        name: repoName,
+        private: visibility === "private",
+        description: "Auto-generated documentation site",
+        auto_init: false
+      });
+      repoUrl = data.clone_url;
+      spinner7.stop(`Created ${data.full_name}`);
+    }
+  } catch (err) {
+    spinner7.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 {
+      p3.log.error(`GitHub API error: ${err?.message || err}`);
+    }
+    return null;
+  }
+  spinner7.start("Pushing docs to GitHub...");
+  try {
+    const gitignorePath = path4.join(docsDir, ".gitignore");
+    if (!fs4.existsSync(gitignorePath)) {
+      fs4.writeFileSync(gitignorePath, "node_modules/\n.next/\n.source/\n");
+    }
+    if (!fs4.existsSync(path4.join(docsDir, ".git"))) {
+      exec("git init -b main", docsDir);
+    }
+    exec("git add -A", docsDir);
+    exec('git commit -m "Initial documentation site"', docsDir);
+    try {
+      exec("git remote remove origin", docsDir);
+    } catch {
+    }
+    const pushUrl = repoUrl.replace("https://", `https://${token}@`);
+    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.");
+  } catch (err) {
+    spinner7.stop("Git push failed.");
+    p3.log.error(`${err instanceof Error ? err.message : err}`);
+    return null;
+  }
+  const updatedConfig = { ...config };
+  updatedConfig.docsRepo = repoUrl;
+  saveConfig(updatedConfig);
+  return { repoUrl, owner, repoName };
+}
+async function pushUpdates(params) {
+  const { token, docsDir, docsRepo } = params;
+  const spinner7 = p3.spinner();
+  spinner7.start("Pushing updates to docs repo...");
+  try {
+    if (!fs4.existsSync(path4.join(docsDir, ".git"))) {
+      exec("git init", docsDir);
+      exec(`git remote add origin ${docsRepo}`, docsDir);
+    }
+    exec("git add -A", docsDir);
+    try {
+      exec("git diff --cached --quiet", docsDir);
+      spinner7.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.");
+    return true;
+  } catch (err) {
+    spinner7.stop("Push failed.");
+    p3.log.error(`${err instanceof Error ? err.message : err}`);
+    return false;
+  }
+}
+function showVercelInstructions(owner, repoName) {
+  p3.note(
+    [
+      "Connect your docs repo to Vercel for automatic deployments:",
+      "",
+      "  1. Go to https://vercel.com/new",
+      "  2. Click 'Import Git Repository'",
+      `  3. Select '${owner}/${repoName}'`,
+      "  4. Click 'Deploy'",
+      "",
+      "Once connected, Vercel will auto-deploy on every push to the docs repo."
+    ].join("\n"),
+    "Vercel Setup"
+  );
+}
+
+// src/actions/setup-ci-action.ts
+import * as p4 from "@clack/prompts";
+import { execSync as execSync3 } from "child_process";
 import fs5 from "fs";
 import path5 from "path";
-import { execSync as execSync2 } from "child_process";
+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)}`);
+  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`);
+  return { repos: createdRepos, branch };
+}
+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"
+  );
+}
+
+// ../analyzer/dist/index.js
 import fs6 from "fs";
 import path6 from "path";
+import ignore from "ignore";
+import fs22 from "fs";
+import path22 from "path";
+import fs32 from "fs";
+import path32 from "path";
+import fs42 from "fs";
+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";
 var DEFAULT_IGNORES = [
   "node_modules",
   ".git",
@@ -242,26 +671,26 @@ function buildFileTree(rootPath, maxDepth = 6) {
   const ig = loadGitignore(rootPath);
   const flatFiles = [];
   function walk(dirPath, depth) {
-    const name = path3.basename(dirPath);
-    const node = { path: path3.relative(rootPath, dirPath) || ".", name, type: "directory", children: [] };
+    const name = path6.basename(dirPath);
+    const node = { path: path6.relative(rootPath, dirPath) || ".", name, type: "directory", children: [] };
     if (depth > maxDepth) return node;
     let entries;
     try {
-      entries = fs3.readdirSync(dirPath, { withFileTypes: true });
+      entries = fs6.readdirSync(dirPath, { withFileTypes: true });
     } catch {
       return node;
     }
     for (const entry of entries.sort((a, b) => a.name.localeCompare(b.name))) {
-      const rel = path3.relative(rootPath, path3.join(dirPath, entry.name));
+      const rel = path6.relative(rootPath, path6.join(dirPath, entry.name));
       if (ig.ignores(rel) || ig.ignores(rel + "/")) continue;
       if (entry.isDirectory()) {
-        const child = walk(path3.join(dirPath, entry.name), depth + 1);
+        const child = walk(path6.join(dirPath, entry.name), depth + 1);
         node.children.push(child);
       } else if (entry.isFile()) {
-        const ext = path3.extname(entry.name).slice(1);
+        const ext = path6.extname(entry.name).slice(1);
         let size;
         try {
-          size = fs3.statSync(path3.join(dirPath, entry.name)).size;
+          size = fs6.statSync(path6.join(dirPath, entry.name)).size;
         } catch {
         }
         flatFiles.push(rel);
@@ -282,9 +711,9 @@ function buildFileTree(rootPath, maxDepth = 6) {
 function loadGitignore(rootPath) {
   const ig = ignore.default();
   ig.add(DEFAULT_IGNORES);
-  const gitignorePath = path3.join(rootPath, ".gitignore");
-  if (fs3.existsSync(gitignorePath)) {
-    const content = fs3.readFileSync(gitignorePath, "utf-8");
+  const gitignorePath = path6.join(rootPath, ".gitignore");
+  if (fs6.existsSync(gitignorePath)) {
+    const content = fs6.readFileSync(gitignorePath, "utf-8");
     ig.add(content);
   }
   return ig;
@@ -312,7 +741,7 @@ function detectLanguages(flatFiles) {
   };
   const langs = /* @__PURE__ */ new Set();
   for (const file of flatFiles) {
-    const ext = path3.extname(file).slice(1);
+    const ext = path6.extname(file).slice(1);
     if (extMap[ext]) langs.add(extMap[ext]);
   }
   return Array.from(langs);
@@ -332,7 +761,7 @@ function detectEntryFiles(flatFiles) {
     /^app\/page\.tsx$/,
     /^pages\/index\.\w+$/
   ];
-  return flatFiles.filter((f) => entryPatterns.some((p9) => p9.test(f)));
+  return flatFiles.filter((f) => entryPatterns.some((p11) => p11.test(f)));
 }
 var DEP_FILES = [
   {
@@ -494,14 +923,14 @@ var SOURCE_EXTENSIONS = /* @__PURE__ */ new Set([
 ]);
 var MAX_FILES = 200;
 function buildImportGraph(repoPath, flatFiles) {
-  const sourceFiles = flatFiles.filter((f) => SOURCE_EXTENSIONS.has(path4.extname(f))).slice(0, MAX_FILES);
+  const sourceFiles = flatFiles.filter((f) => SOURCE_EXTENSIONS.has(path42.extname(f))).slice(0, MAX_FILES);
   const edges = [];
   const fileSet = new Set(flatFiles);
   for (const file of sourceFiles) {
-    const fullPath = path4.join(repoPath, file);
+    const fullPath = path42.join(repoPath, file);
     let content;
     try {
-      content = fs4.readFileSync(fullPath, "utf-8");
+      content = fs42.readFileSync(fullPath, "utf-8");
     } catch {
       continue;
     }
@@ -527,14 +956,14 @@ function buildImportGraph(repoPath, flatFiles) {
   return { edges, moduleClusters };
 }
 function resolveImport(repoPath, fromFile, importPath, fileSet) {
-  const dir = path4.dirname(fromFile);
-  const resolved = path4.normalize(path4.join(dir, importPath));
+  const dir = path42.dirname(fromFile);
+  const resolved = path42.normalize(path42.join(dir, importPath));
   if (fileSet.has(resolved)) return resolved;
   for (const ext of [".ts", ".tsx", ".js", ".jsx", ".mjs"]) {
     if (fileSet.has(resolved + ext)) return resolved + ext;
   }
   for (const ext of [".ts", ".tsx", ".js", ".jsx"]) {
-    const indexPath = path4.join(resolved, `index${ext}`);
+    const indexPath = path42.join(resolved, `index${ext}`);
     if (fileSet.has(indexPath)) return indexPath;
   }
   return null;
@@ -1137,8 +1566,8 @@ Do NOT read more than 10-12 files total.`,
     outputSchema: repoInitSchema,
     maxTurns: 15
   });
-  const claudeMdPath = path5.join(repoPath, "CLAUDE.md");
-  fs5.writeFileSync(claudeMdPath, result.content, "utf-8");
+  const claudeMdPath = path52.join(repoPath, "CLAUDE.md");
+  fs52.writeFileSync(claudeMdPath, result.content, "utf-8");
   const updatedClaudeMd = readClaudeMd(repoPath);
   return {
     ...staticAnalysis,
@@ -1198,7 +1627,7 @@ var SECTION_PATTERNS = {
 };
 function computeDiff(repoPath, fromSha) {
   try {
-    const output = execSync2(`git diff --name-status ${fromSha}..HEAD`, {
+    const output = execSync4(`git diff --name-status ${fromSha}..HEAD`, {
       cwd: repoPath,
       encoding: "utf-8",
       stdio: ["pipe", "pipe", "pipe"]
@@ -1233,7 +1662,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((p9) => p9.test(entry.filePath))) {
+      if (patterns.some((p11) => p11.test(entry.filePath))) {
         affected.add(section);
       }
     }
@@ -1251,7 +1680,7 @@ function classifyChanges(entries, staticAnalysis) {
   };
 }
 function getHeadSha(repoPath) {
-  return execSync2("git rev-parse HEAD", {
+  return execSync4("git rev-parse HEAD", {
     cwd: repoPath,
     encoding: "utf-8"
   }).trim();
@@ -1602,23 +2031,23 @@ function slugify(name) {
   return name.replace(/[^a-zA-Z0-9_-]/g, "_");
 }
 function cacheFilePath(cacheDir, repoSlug) {
-  return path6.join(cacheDir, `${slugify(repoSlug)}-analysis.json`);
+  return path62.join(cacheDir, `${slugify(repoSlug)}-analysis.json`);
 }
 function saveCache(cacheDir, repoSlug, commitSha, result) {
-  fs6.mkdirSync(cacheDir, { recursive: true });
+  fs62.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");
+  fs62.writeFileSync(cacheFilePath(cacheDir, repoSlug), JSON.stringify(cache), "utf-8");
 }
 function loadCache(cacheDir, repoSlug) {
   const filePath = cacheFilePath(cacheDir, repoSlug);
-  if (!fs6.existsSync(filePath)) return null;
+  if (!fs62.existsSync(filePath)) return null;
   try {
-    const raw = JSON.parse(fs6.readFileSync(filePath, "utf-8"));
+    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;
@@ -1630,7 +2059,7 @@ function loadCache(cacheDir, repoSlug) {
 // ../generator/dist/index.js
 import fs7 from "fs-extra";
 import path7 from "path";
-import { execSync as execSync3 } from "child_process";
+import { execSync as execSync5 } from "child_process";
 import fs23 from "fs-extra";
 import path23 from "path";
 import Handlebars from "handlebars";
@@ -1659,7 +2088,7 @@ async function scaffoldSite(outputDir, projectName, templateDir) {
   const nodeModulesPath = path7.join(outputDir, "node_modules");
   if (!fs7.existsSync(nodeModulesPath)) {
     try {
-      execSync3("npm install --ignore-scripts", {
+      execSync5("npm install --ignore-scripts", {
         cwd: outputDir,
         stdio: "pipe",
         timeout: 12e4
@@ -1671,7 +2100,7 @@ async function scaffoldSite(outputDir, projectName, templateDir) {
       }
     }
     try {
-      execSync3("npx fumadocs-mdx", { cwd: outputDir, stdio: "pipe", timeout: 3e4 });
+      execSync5("npx fumadocs-mdx", { cwd: outputDir, stdio: "pipe", timeout: 3e4 });
     } catch {
     }
   }
@@ -2136,41 +2565,41 @@ function slugify22(name) {
 // src/commands/init.ts
 var __dirname2 = path8.dirname(fileURLToPath2(import.meta.url));
 async function initCommand(options) {
-  p3.intro("open-auto-doc \u2014 AI-powered documentation generator");
+  p5.intro("open-auto-doc \u2014 AI-powered documentation generator");
   let token = getGithubToken();
   if (!token) {
-    p3.log.info("Let's connect your GitHub account.");
+    p5.log.info("Let's connect your GitHub account.");
     token = await authenticateWithGithub();
     setGithubToken(token);
   } else {
-    p3.log.success("Using saved GitHub credentials.");
+    p5.log.success("Using saved GitHub credentials.");
   }
   const repos = await pickRepos(token);
-  p3.log.info(`Selected ${repos.length} ${repos.length === 1 ? "repository" : "repositories"}`);
+  p5.log.info(`Selected ${repos.length} ${repos.length === 1 ? "repository" : "repositories"}`);
   let apiKey = getAnthropicKey();
   if (!apiKey) {
-    const keyInput = await p3.text({
+    const keyInput = await p5.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 (p3.isCancel(keyInput)) {
-      p3.cancel("Operation cancelled");
+    if (p5.isCancel(keyInput)) {
+      p5.cancel("Operation cancelled");
       process.exit(0);
     }
     apiKey = keyInput;
-    const saveKey = await p3.confirm({
+    const saveKey = await p5.confirm({
       message: "Save API key for future use?"
     });
-    if (saveKey && !p3.isCancel(saveKey)) {
+    if (saveKey && !p5.isCancel(saveKey)) {
       setAnthropicKey(apiKey);
     }
   } else {
-    p3.log.success("Using saved Anthropic API key.");
+    p5.log.success("Using saved Anthropic API key.");
   }
-  const model = await p3.select({
+  const model = await p5.select({
     message: "Which model should analyze your repos?",
     options: [
       { value: "claude-sonnet-4-6", label: "Claude Sonnet 4.6", hint: "Fast & capable (recommended)" },
@@ -2178,12 +2607,12 @@ async function initCommand(options) {
       { value: "claude-opus-4-6", label: "Claude Opus 4.6", hint: "Most capable, slowest" }
     ]
   });
-  if (p3.isCancel(model)) {
-    p3.cancel("Operation cancelled");
+  if (p5.isCancel(model)) {
+    p5.cancel("Operation cancelled");
     process.exit(0);
   }
-  p3.log.info(`Using ${model}`);
-  const cloneSpinner = p3.spinner();
+  p5.log.info(`Using ${model}`);
+  const cloneSpinner = p5.spinner();
   cloneSpinner.start(`Cloning ${repos.length} repositories...`);
   const clones = [];
   for (const repo of repos) {
@@ -2192,15 +2621,15 @@ async function initCommand(options) {
       const cloned = cloneRepo(repo, token);
       clones.push(cloned);
     } catch (err) {
-      p3.log.warn(`Failed to clone ${repo.name}: ${err instanceof Error ? err.message : err}`);
+      p5.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) {
-    p3.log.error("No repositories were cloned.");
+    p5.log.error("No repositories were cloned.");
     process.exit(1);
   }
-  const analyzeSpinner = p3.spinner();
+  const analyzeSpinner = p5.spinner();
   let completed = 0;
   const total = clones.length;
   const repoStages = {};
@@ -2231,7 +2660,7 @@ async function initCommand(options) {
       completed++;
       delete repoStages[repoName];
       updateSpinner();
-      p3.log.warn(`[${repoName}] Analysis failed: ${err instanceof Error ? err.message : err}`);
+      p5.log.warn(`[${repoName}] Analysis failed: ${err instanceof Error ? err.message : err}`);
       return { repo: repoName, result: null };
     }
   });
@@ -2241,13 +2670,13 @@ async function initCommand(options) {
     `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` : "")
   );
   if (results.length === 0) {
-    p3.log.error("No repositories were successfully analyzed.");
+    p5.log.error("No repositories were successfully analyzed.");
     cleanup(clones);
     process.exit(1);
   }
   let crossRepo;
   if (results.length > 1) {
-    const crossSpinner = p3.spinner();
+    const crossSpinner = p5.spinner();
     crossSpinner.start("Analyzing cross-repository relationships...");
     try {
       crossRepo = await analyzeCrossRepos(results, apiKey, model, (text4) => {
@@ -2256,21 +2685,21 @@ async function initCommand(options) {
       crossSpinner.stop(`Cross-repo analysis complete \u2014 ${crossRepo.repoRelationships.length} relationships found`);
     } catch (err) {
       crossSpinner.stop("Cross-repo analysis failed (non-fatal)");
-      p3.log.warn(`Cross-repo error: ${err instanceof Error ? err.message : err}`);
+      p5.log.warn(`Cross-repo error: ${err instanceof Error ? err.message : err}`);
     }
   }
   const outputDir = path8.resolve(options.output || "docs-site");
   const projectName = results.length === 1 ? results[0].repoName : "My Project";
-  const genSpinner = p3.spinner();
+  const genSpinner = p5.spinner();
   try {
     genSpinner.start("Scaffolding documentation site...");
     const templateDir = resolveTemplateDir();
-    p3.log.info(`Using template from: ${templateDir}`);
+    p5.log.info(`Using template from: ${templateDir}`);
     await scaffoldSite(outputDir, projectName, templateDir);
     genSpinner.stop("Site scaffolded");
   } catch (err) {
     genSpinner.stop("Scaffold failed");
-    p3.log.error(`Scaffold error: ${err instanceof Error ? err.stack || err.message : err}`);
+    p5.log.error(`Scaffold error: ${err instanceof Error ? err.stack || err.message : err}`);
     cleanup(clones);
     process.exit(1);
   }
@@ -2282,34 +2711,76 @@ async function initCommand(options) {
     genSpinner.stop("Documentation content written");
   } catch (err) {
     genSpinner.stop("Content writing failed");
-    p3.log.error(`Content error: ${err instanceof Error ? err.stack || err.message : err}`);
+    p5.log.error(`Content error: ${err instanceof Error ? err.stack || err.message : err}`);
     cleanup(clones);
     process.exit(1);
   }
+  const config = {
+    repos: repos.map((r) => ({
+      name: r.name,
+      fullName: r.fullName,
+      cloneUrl: r.cloneUrl,
+      htmlUrl: r.htmlUrl
+    })),
+    outputDir
+  };
   try {
-    const config = {
-      repos: repos.map((r) => ({
-        name: r.name,
-        fullName: r.fullName,
-        cloneUrl: r.cloneUrl,
-        htmlUrl: r.htmlUrl
-      })),
-      outputDir
-    };
-    const configJson = JSON.stringify(config, null, 2);
-    fs8.writeFileSync(path8.join(outputDir, ".autodocrc.json"), configJson);
-    const cwdConfig = path8.resolve(".autodocrc.json");
-    if (cwdConfig !== path8.join(outputDir, ".autodocrc.json")) {
-      fs8.writeFileSync(cwdConfig, configJson);
-    }
+    saveConfig(config);
   } catch {
   }
   cleanup(clones);
-  p3.note(
-    `cd ${path8.relative(process.cwd(), outputDir)} && npm run dev`,
-    "Next steps"
-  );
-  p3.outro("Documentation generated successfully!");
+  p5.log.success("Documentation generated successfully!");
+  const shouldDeploy = await p5.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`,
+      "Next steps"
+    );
+    p5.outro("Done!");
+    return;
+  }
+  const deployResult = await createAndPushDocsRepo({
+    token,
+    docsDir: outputDir,
+    config
+  });
+  if (!deployResult) {
+    p5.note(
+      `cd ${path8.relative(process.cwd(), outputDir)} && npm run dev`,
+      "Next steps"
+    );
+    p5.outro("Done!");
+    return;
+  }
+  const shouldSetupCi = await p5.confirm({
+    message: "Would you like to set up CI to auto-update docs on every push?"
+  });
+  if (p5.isCancel(shouldSetupCi) || !shouldSetupCi) {
+    showVercelInstructions(deployResult.owner, deployResult.repoName);
+    p5.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.");
+    showVercelInstructions(deployResult.owner, deployResult.repoName);
+    p5.outro(`Docs repo: https://github.com/${deployResult.owner}/${deployResult.repoName}`);
+    return;
+  }
+  const ciResult = await createCiWorkflow({
+    gitRoot,
+    docsRepoUrl: deployResult.repoUrl,
+    outputDir,
+    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 = [
@@ -2330,31 +2801,26 @@ function cleanup(clones) {
 }
 
 // src/commands/generate.ts
-import * as p4 from "@clack/prompts";
-import fs9 from "fs";
+import * as p6 from "@clack/prompts";
 import path9 from "path";
 async function generateCommand(options) {
-  p4.intro("open-auto-doc \u2014 Regenerating documentation");
-  let configPath = path9.resolve(".autodocrc.json");
-  if (!fs9.existsSync(configPath)) {
-    configPath = path9.resolve("docs-site", ".autodocrc.json");
-  }
-  if (!fs9.existsSync(configPath)) {
-    p4.log.error("No .autodocrc.json found. Run `open-auto-doc init` first.");
+  p6.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.");
     process.exit(1);
   }
-  const config = JSON.parse(fs9.readFileSync(configPath, "utf-8"));
   const token = getGithubToken();
   const apiKey = getAnthropicKey();
   if (!token) {
-    p4.log.error("Not authenticated. Run `open-auto-doc login` or set GITHUB_TOKEN env var.");
+    p6.log.error("Not authenticated. Run `open-auto-doc login` or set GITHUB_TOKEN env var.");
     process.exit(1);
   }
   if (!apiKey) {
-    p4.log.error("No Anthropic API key found. Run `open-auto-doc init` or set ANTHROPIC_API_KEY env var.");
+    p6.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 p4.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)" },
@@ -2362,17 +2828,38 @@ async function generateCommand(options) {
       { value: "claude-opus-4-6", label: "Claude Opus 4.6", hint: "Most capable, slowest" }
     ]
   });
-  if (p4.isCancel(model)) {
-    p4.cancel("Cancelled.");
+  if (p6.isCancel(model)) {
+    p6.cancel("Cancelled.");
     process.exit(0);
   }
-  p4.log.info(`Using ${model}`);
+  p6.log.info(`Using ${model}`);
   const incremental = options.incremental && !options.force;
   const cacheDir = path9.join(config.outputDir, ".autodoc-cache");
-  const cloneSpinner = p4.spinner();
-  cloneSpinner.start(`Cloning ${config.repos.length} repositories...`);
+  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(", ")}`);
+      process.exit(1);
+    }
+    reposToAnalyze = [targetRepo];
+    for (const repo of config.repos) {
+      if (repo.name === targetRepoName) continue;
+      const cached = loadCache(cacheDir, repo.name);
+      if (cached) {
+        cachedResults.push(cached.result);
+        p6.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`);
+      }
+    }
+  }
+  const cloneSpinner = p6.spinner();
+  cloneSpinner.start(`Cloning ${reposToAnalyze.length} ${reposToAnalyze.length === 1 ? "repository" : "repositories"}...`);
   const clones = [];
-  for (const repo of config.repos) {
+  for (const repo of reposToAnalyze) {
     cloneSpinner.message(`Cloning ${repo.name}...`);
     try {
       const cloned = cloneRepo(
@@ -2388,15 +2875,15 @@ async function generateCommand(options) {
       );
       clones.push(cloned);
     } catch (err) {
-      p4.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}/${config.repos.length} repositories`);
+  cloneSpinner.stop(`Cloned ${clones.length}/${reposToAnalyze.length} ${reposToAnalyze.length === 1 ? "repository" : "repositories"}`);
   if (clones.length === 0) {
-    p4.log.error("No repositories were cloned.");
+    p6.log.error("No repositories were cloned.");
     process.exit(1);
   }
-  const analyzeSpinner = p4.spinner();
+  const analyzeSpinner = p6.spinner();
   let completed = 0;
   const total = clones.length;
   const repoStages = {};
@@ -2462,17 +2949,18 @@ async function generateCommand(options) {
       completed++;
       delete repoStages[repoName];
       updateSpinner();
-      p4.log.warn(`[${repoName}] Analysis failed: ${err instanceof Error ? err.message : err}`);
+      p6.log.warn(`[${repoName}] Analysis failed: ${err instanceof Error ? err.message : err}`);
       return { repo: repoName, result: null };
     }
   });
   const settled = await Promise.all(analysisPromises);
-  const results = settled.filter((s) => s.result !== null).map((s) => s.result);
-  analyzeSpinner.stop(`Analyzed ${results.length}/${total} repositories`);
+  const freshResults = settled.filter((s) => s.result !== null).map((s) => s.result);
+  analyzeSpinner.stop(`Analyzed ${freshResults.length}/${total} ${total === 1 ? "repository" : "repositories"}`);
+  const results = [...freshResults, ...cachedResults];
   if (results.length > 0) {
     let crossRepo;
     if (results.length > 1) {
-      const crossSpinner = p4.spinner();
+      const crossSpinner = p6.spinner();
       crossSpinner.start("Analyzing cross-repository relationships...");
       try {
         crossRepo = await analyzeCrossRepos(results, apiKey, model, (text4) => {
@@ -2481,396 +2969,150 @@ 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)");
-        p4.log.warn(`Cross-repo error: ${err instanceof Error ? err.message : err}`);
+        p6.log.warn(`Cross-repo error: ${err instanceof Error ? err.message : err}`);
       }
     }
     const contentDir = path9.join(config.outputDir, "content", "docs");
     await writeContent(contentDir, results, crossRepo);
     await writeMeta(contentDir, results, crossRepo);
-    p4.log.success("Documentation regenerated!");
+    p6.log.success("Documentation regenerated!");
   }
   for (const clone of clones) {
     cleanupClone(clone);
   }
-  p4.outro("Done!");
+  p6.outro("Done!");
 }
 
 // src/commands/deploy.ts
-import * as p5 from "@clack/prompts";
-import { execSync as execSync4 } from "child_process";
-import fs10 from "fs";
+import * as p7 from "@clack/prompts";
+import fs9 from "fs";
 import path10 from "path";
-import { Octokit as Octokit2 } from "@octokit/rest";
-function loadConfig() {
-  for (const candidate of [
-    path10.resolve(".autodocrc.json"),
-    path10.resolve("docs-site", ".autodocrc.json")
-  ]) {
-    if (fs10.existsSync(candidate)) {
-      try {
-        return JSON.parse(fs10.readFileSync(candidate, "utf-8"));
-      } catch {
-      }
-    }
-  }
-  return null;
-}
-function saveConfig(config) {
-  fs10.writeFileSync(
-    path10.resolve(".autodocrc.json"),
-    JSON.stringify(config, null, 2)
-  );
-  if (config.outputDir && fs10.existsSync(config.outputDir)) {
-    fs10.writeFileSync(
-      path10.join(config.outputDir, ".autodocrc.json"),
-      JSON.stringify(config, null, 2)
-    );
-  }
-}
 function resolveDocsDir(config, dirOption) {
   if (dirOption) {
     const resolved = path10.resolve(dirOption);
-    if (!fs10.existsSync(resolved)) {
-      p5.log.error(`Directory not found: ${resolved}`);
+    if (!fs9.existsSync(resolved)) {
+      p7.log.error(`Directory not found: ${resolved}`);
       process.exit(1);
     }
     return resolved;
   }
-  if (config?.outputDir && fs10.existsSync(path10.resolve(config.outputDir))) {
+  if (config?.outputDir && fs9.existsSync(path10.resolve(config.outputDir))) {
     return path10.resolve(config.outputDir);
   }
-  if (fs10.existsSync(path10.resolve("docs-site"))) {
+  if (fs9.existsSync(path10.resolve("docs-site"))) {
     return path10.resolve("docs-site");
   }
-  p5.log.error(
+  p7.log.error(
     "Could not find docs site directory. Use --dir to specify the path, or run `open-auto-doc init` first."
   );
   process.exit(1);
 }
-function getGitHubUsername(octokit) {
-  return octokit.rest.users.getAuthenticated().then((res) => res.data.login);
-}
-function exec(cmd, cwd) {
-  return execSync4(cmd, { cwd, encoding: "utf-8", stdio: ["pipe", "pipe", "pipe"] }).trim();
-}
 async function deployCommand(options) {
-  p5.intro("open-auto-doc \u2014 Deploy docs to GitHub");
+  p7.intro("open-auto-doc \u2014 Deploy docs to GitHub");
   const token = getGithubToken();
   if (!token) {
-    p5.log.error("Not authenticated. Run `open-auto-doc login` first.");
+    p7.log.error("Not authenticated. Run `open-auto-doc login` first.");
     process.exit(1);
   }
   const config = loadConfig();
   const docsDir = resolveDocsDir(config, options.dir);
-  p5.log.info(`Docs directory: ${docsDir}`);
-  const octokit = new Octokit2({ auth: token });
+  p7.log.info(`Docs directory: ${docsDir}`);
   if (config?.docsRepo) {
-    p5.log.info(`Docs repo already configured: ${config.docsRepo}`);
-    const spinner7 = p5.spinner();
-    spinner7.start("Pushing updates to docs repo...");
-    try {
-      if (!fs10.existsSync(path10.join(docsDir, ".git"))) {
-        exec("git init", docsDir);
-        exec(`git remote add origin ${config.docsRepo}`, docsDir);
-      }
-      exec("git add -A", docsDir);
-      try {
-        exec("git diff --cached --quiet", docsDir);
-        spinner7.stop("No changes to push.");
-        p5.outro("Docs are up to date!");
-        return;
-      } catch {
-      }
-      exec('git commit -m "Update documentation"', docsDir);
-      exec("git push -u origin main", docsDir);
-      spinner7.stop("Pushed updates to docs repo.");
-    } catch (err) {
-      spinner7.stop("Push failed.");
-      p5.log.error(`${err instanceof Error ? err.message : err}`);
-      process.exit(1);
+    p7.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.");
+    } else {
+      p7.outro("Docs are up to date!");
     }
-    p5.outro("Docs updated! Vercel will auto-deploy from the push.");
     return;
   }
-  const username = await getGitHubUsername(octokit);
-  const defaultName = config?.repos?.[0] ? `${config.repos[0].name}-docs` : "my-project-docs";
-  const repoName = await p5.text({
-    message: "Name for the docs GitHub repo:",
-    initialValue: defaultName,
-    validate: (v) => {
-      if (!v || v.length === 0) return "Repo name is required";
-      if (!/^[a-zA-Z0-9._-]+$/.test(v)) return "Invalid repo name";
-    }
-  });
-  if (p5.isCancel(repoName)) {
-    p5.cancel("Deploy cancelled.");
-    process.exit(0);
-  }
-  const visibility = await p5.select({
-    message: "Repository visibility:",
-    options: [
-      { value: "public", label: "Public" },
-      { value: "private", label: "Private" }
-    ]
+  const result = await createAndPushDocsRepo({
+    token,
+    docsDir,
+    config: config || { repos: [], outputDir: docsDir }
   });
-  if (p5.isCancel(visibility)) {
-    p5.cancel("Deploy cancelled.");
+  if (!result) {
+    p7.cancel("Deploy cancelled.");
     process.exit(0);
   }
-  const spinner6 = p5.spinner();
-  spinner6.start(`Creating GitHub repo ${username}/${repoName}...`);
-  let repoUrl;
-  try {
-    const { data } = await octokit.rest.repos.createForAuthenticatedUser({
-      name: repoName,
-      private: visibility === "private",
-      description: "Auto-generated documentation site",
-      auto_init: false
-    });
-    repoUrl = data.clone_url;
-    spinner6.stop(`Created ${data.full_name}`);
-  } catch (err) {
-    spinner6.stop("Failed to create repo.");
-    if (err?.status === 422) {
-      p5.log.error(`Repository "${repoName}" already exists. Choose a different name or delete it first.`);
-    } else {
-      p5.log.error(`GitHub API error: ${err?.message || err}`);
-    }
-    process.exit(1);
-  }
-  spinner6.start("Pushing docs to GitHub...");
-  try {
-    const gitignorePath = path10.join(docsDir, ".gitignore");
-    if (!fs10.existsSync(gitignorePath)) {
-      fs10.writeFileSync(gitignorePath, "node_modules/\n.next/\n.source/\n");
-    }
-    if (!fs10.existsSync(path10.join(docsDir, ".git"))) {
-      exec("git init -b main", docsDir);
-    }
-    exec("git add -A", docsDir);
-    exec('git commit -m "Initial documentation site"', docsDir);
-    try {
-      exec("git remote remove origin", docsDir);
-    } catch {
-    }
-    const pushUrl = repoUrl.replace("https://", `https://${token}@`);
-    exec(`git remote add origin ${pushUrl}`, docsDir);
-    exec("git push -u origin main", docsDir);
-    exec("git remote set-url origin " + repoUrl, docsDir);
-    spinner6.stop("Pushed to GitHub.");
-  } catch (err) {
-    spinner6.stop("Git push failed.");
-    p5.log.error(`${err instanceof Error ? err.message : err}`);
-    process.exit(1);
-  }
-  const updatedConfig = config || {
-    repos: [],
-    outputDir: docsDir
-  };
-  updatedConfig.docsRepo = repoUrl;
-  saveConfig(updatedConfig);
-  p5.note(
-    [
-      "Connect your docs repo to Vercel for automatic deployments:",
-      "",
-      "  1. Go to https://vercel.com/new",
-      "  2. Click 'Import Git Repository'",
-      `  3. Select '${username}/${repoName}'`,
-      "  4. Click 'Deploy'",
-      "",
-      "Once connected, Vercel will auto-deploy on every push to the docs repo."
-    ].join("\n"),
-    "Vercel Setup"
-  );
-  p5.outro(`Docs repo: https://github.com/${username}/${repoName}`);
+  showVercelInstructions(result.owner, result.repoName);
+  p7.outro(`Docs repo: https://github.com/${result.owner}/${result.repoName}`);
 }
 
 // src/commands/setup-ci.ts
-import * as p6 from "@clack/prompts";
-import { execSync as execSync5 } from "child_process";
-import fs11 from "fs";
-import path11 from "path";
-function getGitRoot() {
-  try {
-    return execSync5("git rev-parse --show-toplevel", {
-      encoding: "utf-8",
-      stdio: ["pipe", "pipe", "pipe"]
-    }).trim();
-  } catch {
-    return null;
-  }
-}
-function loadConfig2() {
-  for (const candidate of [
-    path11.resolve(".autodocrc.json"),
-    path11.resolve("docs-site", ".autodocrc.json")
-  ]) {
-    if (fs11.existsSync(candidate)) {
-      try {
-        return JSON.parse(fs11.readFileSync(candidate, "utf-8"));
-      } 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
-`;
-}
+import * as p8 from "@clack/prompts";
 async function setupCiCommand() {
-  p6.intro("open-auto-doc \u2014 CI/CD Setup");
-  const gitRoot = getGitRoot();
-  if (!gitRoot) {
-    p6.log.error("Not in a git repository. Run this command from your project root.");
-    process.exit(1);
-  }
-  const config = loadConfig2();
+  p8.intro("open-auto-doc \u2014 CI/CD Setup");
+  const config = loadConfig();
   if (!config?.docsRepo) {
-    p6.log.error(
+    p8.log.error(
       "No docs repo configured. Run `open-auto-doc deploy` first to create a docs GitHub repo."
     );
     process.exit(1);
   }
-  const outputDir = config.outputDir ? path11.relative(gitRoot, path11.resolve(config.outputDir)) : "docs-site";
-  p6.log.info(`Docs repo: ${config.docsRepo}`);
-  p6.log.info(`Output directory: ${outputDir}`);
-  const branch = await p6.text({
-    message: "Which branch should trigger doc updates?",
-    initialValue: "main",
-    validate: (v) => v.length === 0 ? "Branch name is required" : void 0
+  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).");
+    process.exit(1);
+  }
+  const gitRoot = getGitRoot();
+  if (!isMultiRepo && !gitRoot) {
+    p8.log.error("Not in a git repository. Run this command from your project root.");
+    process.exit(1);
+  }
+  const result = await createCiWorkflow({
+    gitRoot: gitRoot || process.cwd(),
+    docsRepoUrl: config.docsRepo,
+    outputDir: config.outputDir || "docs-site",
+    token: token || void 0,
+    config
   });
-  if (p6.isCancel(branch)) {
-    p6.cancel("Setup cancelled.");
+  if (!result) {
+    p8.cancel("Setup cancelled.");
     process.exit(0);
   }
-  const workflowDir = path11.join(gitRoot, ".github", "workflows");
-  const workflowPath = path11.join(workflowDir, "update-docs.yml");
-  fs11.mkdirSync(workflowDir, { recursive: true });
-  fs11.writeFileSync(
-    workflowPath,
-    generateWorkflow(branch, config.docsRepo, outputDir),
-    "utf-8"
-  );
-  p6.log.success(`Created ${path11.relative(gitRoot, workflowPath)}`);
-  p6.note(
-    [
-      "Add these secrets to your GitHub repository:",
-      "(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"
-  );
-  p6.outro("CI/CD workflow is ready! Commit and push to activate.");
+  showSecretsInstructions(isMultiRepo);
+  if ("repos" in result) {
+    p8.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.");
+  }
 }
 
 // src/commands/login.ts
-import * as p7 from "@clack/prompts";
+import * as p9 from "@clack/prompts";
 async function loginCommand() {
-  p7.intro("open-auto-doc \u2014 GitHub Login");
+  p9.intro("open-auto-doc \u2014 GitHub Login");
   const existing = getGithubToken();
   if (existing) {
-    const overwrite = await p7.confirm({
+    const overwrite = await p9.confirm({
       message: "You're already logged in. Re-authenticate?"
     });
-    if (!overwrite || p7.isCancel(overwrite)) {
-      p7.cancel("Keeping existing credentials");
+    if (!overwrite || p9.isCancel(overwrite)) {
+      p9.cancel("Keeping existing credentials");
       return;
     }
   }
   const token = await authenticateWithGithub();
   setGithubToken(token);
-  p7.outro("Logged in successfully!");
+  p9.outro("Logged in successfully!");
 }
 
 // src/commands/logout.ts
-import * as p8 from "@clack/prompts";
+import * as p10 from "@clack/prompts";
 async function logoutCommand() {
-  p8.intro("open-auto-doc \u2014 Logout");
+  p10.intro("open-auto-doc \u2014 Logout");
   clearAll();
-  p8.outro("Credentials cleared. You've been logged out.");
+  p10.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.0");
+program.name("open-auto-doc").description("Auto-generate beautiful documentation websites from GitHub repositories using AI").version("0.3.2");
 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)").action(generateCommand);
+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);
 program.command("setup-ci").description("Generate a GitHub Actions workflow for auto-updating docs").action(setupCiCommand);
 program.command("login").description("Authenticate with GitHub").action(loginCommand);