@latent-space-labs/open-auto-doc 0.5.1 → 0.5.2

package/dist/index.js

@@ -4,7 +4,7 @@
 import { Command } from "commander";
 
 // src/commands/init.ts
-import * as p7 from "@clack/prompts";
+import * as p8 from "@clack/prompts";
 import fs10 from "fs";
 import net from "net";
 import path10 from "path";
@@ -39,10 +39,10 @@ Opening ${deviceData.verification_uri} in your browser...`,
   } catch {
     p.log.warn(`Could not open browser. Please visit: ${deviceData.verification_uri}`);
   }
-  const spinner8 = p.spinner();
-  spinner8.start("Waiting for GitHub authorization...");
+  const spinner9 = p.spinner();
+  spinner9.start("Waiting for GitHub authorization...");
   const token = await pollForToken(deviceData.device_code, deviceData.interval);
-  spinner8.stop("GitHub authentication successful!");
+  spinner9.stop("GitHub authentication successful!");
   return token;
 }
 async function pollForToken(deviceCode, interval) {
@@ -127,6 +127,14 @@ function setAnthropicKey(key) {
   creds.anthropicKey = key;
   writeCredentials(creds);
 }
+function getVercelToken() {
+  return process.env.VERCEL_TOKEN || readCredentials().vercelToken;
+}
+function setVercelToken(token) {
+  const creds = readCredentials();
+  creds.vercelToken = token;
+  writeCredentials(creds);
+}
 function clearAll() {
   if (fs.existsSync(CREDENTIALS_FILE)) {
     fs.unlinkSync(CREDENTIALS_FILE);
@@ -164,8 +172,8 @@ import { Octokit } from "@octokit/rest";
 import * as p2 from "@clack/prompts";
 async function pickRepos(token) {
   const octokit = new Octokit({ auth: token });
-  const spinner8 = p2.spinner();
-  spinner8.start("Fetching your repositories...");
+  const spinner9 = p2.spinner();
+  spinner9.start("Fetching your repositories...");
   const repos = [];
   let page = 1;
   while (true) {
@@ -190,7 +198,7 @@ async function pickRepos(token) {
     if (data.length < 100) break;
     page++;
   }
-  spinner8.stop(`Found ${repos.length} repositories`);
+  spinner9.stop(`Found ${repos.length} repositories`);
   const selected = await p2.multiselect({
     message: "Select repositories to document",
     options: repos.slice(0, 50).map((r) => ({
@@ -292,8 +300,8 @@ async function createAndPushDocsRepo(params) {
     ]
   });
   if (p3.isCancel(visibility)) return null;
-  const spinner8 = p3.spinner();
-  spinner8.start(`Creating GitHub repo ${owner}/${repoName}...`);
+  const spinner9 = p3.spinner();
+  spinner9.start(`Creating GitHub repo ${owner}/${repoName}...`);
   let repoUrl;
   try {
     if (isOrg) {
@@ -305,7 +313,7 @@ async function createAndPushDocsRepo(params) {
         auto_init: false
       });
       repoUrl = data.clone_url;
-      spinner8.stop(`Created ${data.full_name}`);
+      spinner9.stop(`Created ${data.full_name}`);
     } else {
       const { data } = await octokit.rest.repos.createForAuthenticatedUser({
         name: repoName,
@@ -314,10 +322,10 @@ async function createAndPushDocsRepo(params) {
         auto_init: false
       });
       repoUrl = data.clone_url;
-      spinner8.stop(`Created ${data.full_name}`);
+      spinner9.stop(`Created ${data.full_name}`);
     }
   } catch (err) {
-    spinner8.stop("Failed to create repo.");
+    spinner9.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 {
@@ -325,7 +333,7 @@ async function createAndPushDocsRepo(params) {
     }
     return null;
   }
-  spinner8.start("Pushing docs to GitHub...");
+  spinner9.start("Pushing docs to GitHub...");
   try {
     const gitignorePath = path4.join(docsDir, ".gitignore");
     if (!fs4.existsSync(gitignorePath)) {
@@ -344,9 +352,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);
-    spinner8.stop("Pushed to GitHub.");
+    spinner9.stop("Pushed to GitHub.");
   } catch (err) {
-    spinner8.stop("Git push failed.");
+    spinner9.stop("Git push failed.");
     p3.log.error(`${err instanceof Error ? err.message : err}`);
     return null;
   }
@@ -357,8 +365,8 @@ async function createAndPushDocsRepo(params) {
 }
 async function pushUpdates(params) {
   const { token, docsDir, docsRepo } = params;
-  const spinner8 = p3.spinner();
-  spinner8.start("Pushing updates to docs repo...");
+  const spinner9 = p3.spinner();
+  spinner9.start("Pushing updates to docs repo...");
   try {
     if (!fs4.existsSync(path4.join(docsDir, ".git"))) {
       exec("git init", docsDir);
@@ -367,16 +375,16 @@ async function pushUpdates(params) {
     exec("git add -A", docsDir);
     try {
       exec("git diff --cached --quiet", docsDir);
-      spinner8.stop("No changes to push.");
+      spinner9.stop("No changes to push.");
       return false;
     } catch {
     }
     exec('git commit -m "Update documentation"', docsDir);
     exec("git push -u origin main", docsDir);
-    spinner8.stop("Pushed updates to docs repo.");
+    spinner9.stop("Pushed updates to docs repo.");
     return true;
   } catch (err) {
-    spinner8.stop("Push failed.");
+    spinner9.stop("Push failed.");
     p3.log.error(`${err instanceof Error ? err.message : err}`);
     return false;
   }
@@ -397,8 +405,197 @@ function showVercelInstructions(owner, repoName) {
   );
 }
 
-// src/actions/build-check.ts
+// src/actions/vercel-action.ts
 import * as p4 from "@clack/prompts";
+var VERCEL_API = "https://api.vercel.com";
+async function vercelFetch(path13, token, options = {}) {
+  const { method = "GET", body, teamId } = options;
+  const url = new URL(path13, VERCEL_API);
+  if (teamId) {
+    url.searchParams.set("teamId", teamId);
+  }
+  const res = await fetch(url.toString(), {
+    method,
+    headers: {
+      Authorization: `Bearer ${token}`,
+      "Content-Type": "application/json"
+    },
+    ...body ? { body: JSON.stringify(body) } : {}
+  });
+  const data = await res.json().catch(() => ({}));
+  return { ok: res.ok, status: res.status, data };
+}
+async function authenticateVercel() {
+  const existing = getVercelToken();
+  if (existing) {
+    const { ok: ok2 } = await vercelFetch(
+      "/v2/user",
+      existing
+    );
+    if (ok2) {
+      p4.log.success("Using saved Vercel token.");
+      return existing;
+    }
+    p4.log.warn("Saved Vercel token is invalid.");
+  }
+  p4.log.info(
+    "Create a Vercel token at: https://vercel.com/account/tokens"
+  );
+  const tokenInput = await p4.text({
+    message: "Enter your Vercel token",
+    placeholder: "xxxxxxxxxxxxxxxxxxxxxxxx",
+    validate: (v) => {
+      if (!v || v.trim().length === 0) return "Token is required";
+    }
+  });
+  if (p4.isCancel(tokenInput)) return null;
+  const token = tokenInput.trim();
+  const { ok, data } = await vercelFetch(
+    "/v2/user",
+    token
+  );
+  if (!ok) {
+    p4.log.error("Invalid Vercel token. Please check and try again.");
+    return null;
+  }
+  p4.log.success(`Authenticated as ${data.user?.username ?? "Vercel user"}`);
+  const save = await p4.confirm({
+    message: "Save Vercel token for future use?"
+  });
+  if (!p4.isCancel(save) && save) {
+    setVercelToken(token);
+  }
+  return token;
+}
+async function deployToVercel(params) {
+  const { token, githubOwner, githubRepo, docsDir, config } = params;
+  const { data: userData } = await vercelFetch(
+    "/v2/user",
+    token
+  );
+  const userId = userData.user?.id;
+  const { data: teamsData } = await vercelFetch(
+    "/v2/teams",
+    token
+  );
+  const teams = teamsData.teams ?? [];
+  let teamId;
+  if (teams.length > 0) {
+    const scopeOptions = [
+      { value: "__personal__", label: userData.user?.username ?? "Personal", hint: "Personal account" },
+      ...teams.map((t) => ({ value: t.id, label: t.name || t.slug, hint: "Team" }))
+    ];
+    const selectedScope = await p4.select({
+      message: "Which Vercel scope should own this project?",
+      options: scopeOptions
+    });
+    if (p4.isCancel(selectedScope)) return null;
+    if (selectedScope !== "__personal__") {
+      teamId = selectedScope;
+    }
+  }
+  const spinner9 = p4.spinner();
+  spinner9.start("Creating Vercel project...");
+  const repoSlug = `${githubOwner}/${githubRepo}`;
+  const createProject = async () => {
+    return vercelFetch(
+      "/v10/projects",
+      token,
+      {
+        method: "POST",
+        teamId,
+        body: {
+          name: githubRepo,
+          framework: "nextjs",
+          gitRepository: {
+            type: "github",
+            repo: repoSlug
+          }
+        }
+      }
+    );
+  };
+  let projectRes = await createProject();
+  if (!projectRes.ok && (projectRes.status === 400 || projectRes.status === 403)) {
+    spinner9.stop("GitHub integration required.");
+    const errorData = projectRes.data;
+    const errorMsg = errorData?.error?.message || "Vercel cannot access your GitHub repo.";
+    p4.log.warn(errorMsg);
+    p4.log.info(
+      "Install the Vercel GitHub App: https://github.com/apps/vercel"
+    );
+    const retry = await p4.confirm({
+      message: "Have you installed the Vercel GitHub App? Retry?"
+    });
+    if (p4.isCancel(retry) || !retry) return null;
+    spinner9.start("Retrying project creation...");
+    projectRes = await createProject();
+  }
+  if (!projectRes.ok) {
+    spinner9.stop("Failed to create Vercel project.");
+    const errorData = projectRes.data;
+    p4.log.error(
+      `Vercel API error (${projectRes.status}): ${errorData?.error?.message || JSON.stringify(errorData)}`
+    );
+    return null;
+  }
+  const project = projectRes.data;
+  const projectId = project.id;
+  const projectName = project.name;
+  spinner9.stop(`Created Vercel project: ${projectName}`);
+  spinner9.start("Waiting for first deployment...");
+  const maxWaitMs = 5 * 60 * 1e3;
+  const pollIntervalMs = 5e3;
+  const startTime = Date.now();
+  let deploymentUrl;
+  while (Date.now() - startTime < maxWaitMs) {
+    const { ok: deploymentsOk, data: deploymentsData } = await vercelFetch(
+      `/v6/deployments?projectId=${projectId}&limit=1`,
+      token,
+      { teamId }
+    );
+    if (deploymentsOk) {
+      const deployments = deploymentsData.deployments ?? [];
+      if (deployments.length > 0) {
+        const deployment = deployments[0];
+        const state = deployment.state?.toUpperCase();
+        if (state === "READY") {
+          deploymentUrl = `https://${deployment.url}`;
+          break;
+        } else if (state === "ERROR" || state === "CANCELED") {
+          spinner9.stop("Deployment failed.");
+          p4.log.warn(
+            `Check the Vercel dashboard: https://vercel.com/${teamId ? `team/${teamId}` : "dashboard"}/${projectName}`
+          );
+          return null;
+        }
+        const elapsed = Math.round((Date.now() - startTime) / 1e3);
+        spinner9.message(`Waiting for deployment... (${state}, ${elapsed}s)`);
+      }
+    }
+    await new Promise((resolve) => setTimeout(resolve, pollIntervalMs));
+  }
+  if (!deploymentUrl) {
+    spinner9.stop("Deployment is still in progress.");
+    const dashboardUrl = `https://vercel.com/${teamId ? `team/${teamId}` : "dashboard"}/${projectName}`;
+    p4.log.warn(
+      `Timed out waiting for deployment. Check status at: ${dashboardUrl}`
+    );
+    const projectUrl2 = `https://vercel.com/${teamId ? `team/${teamId}` : "dashboard"}/${projectName}`;
+    return { projectUrl: projectUrl2, deploymentUrl: dashboardUrl };
+  }
+  spinner9.stop(`Deployed successfully!`);
+  const projectUrl = `https://vercel.com/${teamId ? `team/${teamId}` : "dashboard"}/${projectName}`;
+  try {
+    const updatedConfig = { ...config, vercelUrl: deploymentUrl };
+    saveConfig(updatedConfig);
+  } catch {
+  }
+  return { projectUrl, deploymentUrl };
+}
+
+// src/actions/build-check.ts
+import * as p5 from "@clack/prompts";
 import { execSync as execSync4 } from "child_process";
 
 // ../analyzer/dist/index.js
@@ -528,7 +725,7 @@ function detectEntryFiles(flatFiles) {
     /^app\/page\.tsx$/,
     /^pages\/index\.\w+$/
   ];
-  return flatFiles.filter((f) => entryPatterns.some((p13) => p13.test(f)));
+  return flatFiles.filter((f) => entryPatterns.some((p14) => p14.test(f)));
 }
 var DEP_FILES = [
   {
@@ -782,9 +979,9 @@ var EFFICIENCY_HINTS = `
 - NEVER use angle-bracket placeholders like <your-api-key> or <repository-url> in your output. Use backtick-wrapped text instead: \`your-api-key\`, \`repository-url\`. Angle brackets break MDX parsing.
 - When including code examples with triple backticks, ensure the opening and closing fence markers start at column 0 (no leading spaces before the backtick fence).`;
 var FILLER_PATTERNS = /^(let me|i'll|i need to|i want to|i should|i will|now i'll|now let me|now i need|first,? i|next,? i|okay|alright)/i;
-function truncateAtWord(text4, max) {
-  if (text4.length <= max) return text4;
-  const truncated = text4.slice(0, max);
+function truncateAtWord(text5, max) {
+  if (text5.length <= max) return text5;
+  const truncated = text5.slice(0, max);
   const lastSpace = truncated.lastIndexOf(" ");
   return (lastSpace > max * 0.5 ? truncated.slice(0, lastSpace) : truncated) + "...";
 }
@@ -1731,7 +1928,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((p13) => p13.test(entry.filePath))) {
+      if (patterns.some((p14) => p14.test(entry.filePath))) {
         affected.add(section);
       }
     }
@@ -2422,43 +2619,43 @@ function extractErrorSummary(output, maxLines = 30) {
 }
 async function runBuildCheck(options) {
   const { docsDir, apiKey, model, maxAttempts = 3 } = options;
-  const spinner8 = p4.spinner();
-  spinner8.start("Verifying documentation build...");
+  const spinner9 = p5.spinner();
+  spinner9.start("Verifying documentation build...");
   for (let attempt = 1; attempt <= maxAttempts; attempt++) {
     const { success, output } = runBuild(docsDir);
     if (success) {
-      spinner8.stop("Documentation build verified");
+      spinner9.stop("Documentation build verified");
       return { success: true, attempts: attempt };
     }
-    spinner8.stop("Build errors detected");
+    spinner9.stop("Build errors detected");
     const errorSummary = extractErrorSummary(output);
-    p4.log.warn(`Build error output:
+    p5.log.warn(`Build error output:
 ${errorSummary}`);
     if (attempt >= maxAttempts) {
-      p4.log.warn(
+      p5.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.start(`AI is diagnosing and fixing build errors (attempt ${attempt}/${maxAttempts})...`);
+    spinner9.start(`AI is diagnosing and fixing build errors (attempt ${attempt}/${maxAttempts})...`);
     try {
       const result = await fixMdxBuildErrors(
         docsDir,
         truncateErrors(output),
         apiKey,
         model,
-        (text4) => spinner8.message(text4)
+        (text5) => spinner9.message(text5)
       );
       if (!result.fixed) {
-        spinner8.stop("AI fixer could not resolve the build errors");
-        p4.log.warn(result.summary);
+        spinner9.stop("AI fixer could not resolve the build errors");
+        p5.log.warn(result.summary);
         return { success: false, attempts: attempt, lastErrors: output };
       }
-      spinner8.stop(`Fixed ${result.filesChanged.length} file(s): ${result.summary}`);
-      spinner8.start("Re-verifying build...");
+      spinner9.stop(`Fixed ${result.filesChanged.length} file(s): ${result.summary}`);
+      spinner9.start("Re-verifying build...");
     } catch (err) {
-      spinner8.stop("AI fixer encountered an error");
-      p4.log.warn(`Fixer error: ${err instanceof Error ? err.message : err}`);
+      spinner9.stop("AI fixer encountered an error");
+      p5.log.warn(`Fixer error: ${err instanceof Error ? err.message : err}`);
       return { success: false, attempts: attempt, lastErrors: output };
     }
   }
@@ -2466,7 +2663,7 @@ ${errorSummary}`);
 }
 
 // src/actions/setup-ci-action.ts
-import * as p5 from "@clack/prompts";
+import * as p6 from "@clack/prompts";
 import { execSync as execSync5 } from "child_process";
 import fs7 from "fs";
 import path7 from "path";
@@ -2609,14 +2806,14 @@ async function createCiWorkflow(params) {
     });
   }
   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({
+  p6.log.info(`Docs repo: ${docsRepoUrl}`);
+  p6.log.info(`Output directory: ${relativeOutputDir}`);
+  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
   });
-  if (p5.isCancel(branch)) return null;
+  if (p6.isCancel(branch)) return null;
   const workflowDir = path7.join(gitRoot, ".github", "workflows");
   const workflowPath = path7.join(workflowDir, "update-docs.yml");
   fs7.mkdirSync(workflowDir, { recursive: true });
@@ -2625,7 +2822,7 @@ async function createCiWorkflow(params) {
     generateWorkflow(branch, docsRepoUrl, relativeOutputDir),
     "utf-8"
   );
-  p5.log.success(`Created ${path7.relative(gitRoot, workflowPath)}`);
+  p6.log.success(`Created ${path7.relative(gitRoot, workflowPath)}`);
   if (token) {
     try {
       const origin = execSync5("git remote get-url origin", {
@@ -2651,19 +2848,19 @@ async function createCiWorkflow(params) {
 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({
+  p6.log.info(`Setting up CI for ${config.repos.length} repositories`);
+  p6.log.info(`Docs repo: ${docsRepoUrl}`);
+  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
   });
-  if (p5.isCancel(branch)) return null;
+  if (p6.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}...`);
+    const spinner9 = p6.spinner();
+    spinner9.start(`Pushing workflow to ${repo.fullName}...`);
     try {
       const [owner, repoName] = repo.fullName.split("/");
       const workflowContent = generatePerRepoWorkflow(branch, repo.name, docsRepoUrl);
@@ -2689,17 +2886,17 @@ async function createCiWorkflowsMultiRepo(params) {
         ...existingSha ? { sha: existingSha } : {}
       });
       createdRepos.push(repo.fullName);
-      spinner8.stop(`Created workflow in ${repo.fullName}`);
+      spinner9.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}`);
+      spinner9.stop(`Failed for ${repo.fullName}`);
+      p6.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.");
+    p6.log.error("Failed to create workflows in any repository.");
     return null;
   }
-  p5.log.success(`Created workflows in ${createdRepos.length}/${config.repos.length} repositories`);
+  p6.log.success(`Created workflows in ${createdRepos.length}/${config.repos.length} repositories`);
   await verifySecretsInteractive(octokit, createdRepos);
   return { repos: createdRepos, branch };
 }
@@ -2713,15 +2910,15 @@ async function checkSecret(octokit, owner, repo, secretName) {
   }
 }
 async function verifySecretsInteractive(octokit, repos) {
-  const shouldVerify = await p5.confirm({
+  const shouldVerify = await p6.confirm({
     message: "Would you like to verify secrets now? (you can add them later)",
     initialValue: true
   });
-  if (p5.isCancel(shouldVerify) || !shouldVerify) {
+  if (p6.isCancel(shouldVerify) || !shouldVerify) {
     showSecretsInstructions(repos.length > 1);
     return;
   }
-  p5.note(
+  p6.note(
     [
       "Each source repo needs two Actions secrets:",
       "",
@@ -2738,11 +2935,11 @@ async function verifySecretsInteractive(octokit, repos) {
   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`);
+    p6.log.step(`Add secrets to ${fullName}`);
+    p6.log.message(`  https://github.com/${fullName}/settings/secrets/actions`);
     let allFound = false;
     while (!allFound) {
-      await p5.text({
+      await p6.text({
         message: `Press enter when you've added the secrets to ${fullName}...`,
         defaultValue: "",
         placeholder: ""
@@ -2753,19 +2950,19 @@ async function verifySecretsInteractive(octokit, repos) {
       }
       for (const secret of REQUIRED_SECRETS) {
         if (results[secret]) {
-          p5.log.success(`${secret} \u2014 found`);
+          p6.log.success(`${secret} \u2014 found`);
         } else {
-          p5.log.warn(`${secret} \u2014 not found`);
+          p6.log.warn(`${secret} \u2014 not found`);
         }
       }
       summary[fullName] = results;
       allFound = REQUIRED_SECRETS.every((s) => results[s]);
       if (!allFound) {
-        const retry = await p5.confirm({
+        const retry = await p6.confirm({
           message: "Some secrets are missing. Would you like to try again?",
           initialValue: true
         });
-        if (p5.isCancel(retry) || !retry) break;
+        if (p6.isCancel(retry) || !retry) break;
       }
     }
   }
@@ -2780,15 +2977,15 @@ async function verifySecretsInteractive(octokit, repos) {
     lines.push(`${fullName}  \u2014 ${parts.join("  ")}`);
   }
   if (allGreen) {
-    p5.note(lines.join("\n"), "All secrets verified!");
+    p6.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.");
+    p6.note(lines.join("\n"), "Secret status");
+    p6.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(
+  p6.note(
     [
       repoNote,
       "(Settings \u2192 Secrets and variables \u2192 Actions \u2192 New repository secret)",
@@ -2810,7 +3007,7 @@ function showSecretsInstructions(multiRepo = false) {
 }
 
 // src/commands/setup-mcp.ts
-import * as p6 from "@clack/prompts";
+import * as p7 from "@clack/prompts";
 import fs8 from "fs";
 import path8 from "path";
 var MCP_SERVER_KEY = "project-docs";
@@ -2823,23 +3020,23 @@ function getMcpConfig() {
 async function setupMcpConfig(opts) {
   const cacheDir = path8.join(opts.outputDir, ".autodoc-cache");
   if (!fs8.existsSync(cacheDir)) {
-    p6.log.warn("No analysis cache found \u2014 skipping MCP setup. Run setup-mcp after generating docs.");
+    p7.log.warn("No analysis cache found \u2014 skipping MCP setup. Run setup-mcp after generating docs.");
     return;
   }
   writeMcpJson(process.cwd());
 }
 async function setupMcpCommand() {
-  p6.intro("open-auto-doc \u2014 MCP Server Setup");
+  p7.intro("open-auto-doc \u2014 MCP Server Setup");
   const config = loadConfig();
   if (!config) {
-    p6.log.error(
+    p7.log.error(
       "No .autodocrc.json found. Run `open-auto-doc init` first to generate documentation."
     );
     process.exit(1);
   }
   const cacheDir = path8.join(config.outputDir, ".autodoc-cache");
   if (!fs8.existsSync(cacheDir)) {
-    p6.log.error(
+    p7.log.error(
       `No analysis cache found at ${cacheDir}.
 Run \`open-auto-doc init\` or \`open-auto-doc generate\` first.`
     );
@@ -2847,12 +3044,12 @@ Run \`open-auto-doc init\` or \`open-auto-doc generate\` first.`
   }
   const cacheFiles = fs8.readdirSync(cacheDir).filter((f) => f.endsWith("-analysis.json"));
   if (cacheFiles.length === 0) {
-    p6.log.error("Cache directory exists but contains no analysis files.");
+    p7.log.error("Cache directory exists but contains no analysis files.");
     process.exit(1);
   }
   writeMcpJson(process.cwd());
-  p6.log.success("MCP server configured!");
-  p6.note(
+  p7.log.success("MCP server configured!");
+  p7.note(
     [
       "The following tools are now available in Claude Code:",
       "",
@@ -2867,7 +3064,7 @@ Run \`open-auto-doc init\` or \`open-auto-doc generate\` first.`
     ].join("\n"),
     "Available MCP tools"
   );
-  p6.outro("Open Claude Code in this project to start using the tools.");
+  p7.outro("Open Claude Code in this project to start using the tools.");
 }
 function writeMcpJson(projectRoot) {
   const mcpPath = path8.join(projectRoot, ".mcp.json");
@@ -2882,7 +3079,7 @@ function writeMcpJson(projectRoot) {
   mcpServers[MCP_SERVER_KEY] = getMcpConfig();
   const merged = { ...existing, mcpServers };
   fs8.writeFileSync(mcpPath, JSON.stringify(merged, null, 2) + "\n");
-  p6.log.step(`Wrote ${path8.relative(projectRoot, mcpPath)}`);
+  p7.log.step(`Wrote ${path8.relative(projectRoot, mcpPath)}`);
 }
 
 // ../generator/dist/index.js
@@ -3055,9 +3252,9 @@ Handlebars.registerHelper("join", (arr, sep) => {
   if (!Array.isArray(arr)) return "";
   return arr.join(typeof sep === "string" ? sep : ", ");
 });
-Handlebars.registerHelper("pipeEscape", (text4) => {
-  if (typeof text4 !== "string") return "";
-  return text4.replace(/\|/g, "\\|");
+Handlebars.registerHelper("pipeEscape", (text5) => {
+  if (typeof text5 !== "string") return "";
+  return text5.replace(/\|/g, "\\|");
 });
 var templatesLoaded = false;
 var templates = {};
@@ -3693,10 +3890,10 @@ function buildRepoSummary(result) {
 // src/commands/init.ts
 var __dirname2 = path10.dirname(fileURLToPath2(import.meta.url));
 async function initCommand(options) {
-  p7.intro("open-auto-doc \u2014 AI-powered documentation generator");
+  p8.intro("open-auto-doc \u2014 AI-powered documentation generator");
   const templateDir = resolveTemplateDir();
   if (!fs10.existsSync(path10.join(templateDir, "package.json"))) {
-    p7.log.error(
+    p8.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`
@@ -3705,53 +3902,53 @@ Try reinstalling: npm install -g @latent-space-labs/open-auto-doc`
   }
   let token = getGithubToken();
   if (!token) {
-    p7.log.info("Let's connect your GitHub account.");
+    p8.log.info("Let's connect your GitHub account.");
     token = await authenticateWithGithub();
     setGithubToken(token);
   } else {
-    p7.log.success("Using saved GitHub credentials.");
+    p8.log.success("Using saved GitHub credentials.");
   }
   const repos = await pickRepos(token);
-  p7.log.info(`Selected ${repos.length} ${repos.length === 1 ? "repository" : "repositories"}`);
+  p8.log.info(`Selected ${repos.length} ${repos.length === 1 ? "repository" : "repositories"}`);
   let projectName;
   if (repos.length > 1) {
-    const nameInput = await p7.text({
+    const nameInput = await p8.text({
       message: "What would you like to name this project?",
       placeholder: "My Project",
       validate: (v) => {
         if (!v || v.trim().length === 0) return "Project name is required";
       }
     });
-    if (p7.isCancel(nameInput)) {
-      p7.cancel("Operation cancelled");
+    if (p8.isCancel(nameInput)) {
+      p8.cancel("Operation cancelled");
       process.exit(0);
     }
     projectName = nameInput;
   }
   let apiKey = getAnthropicKey();
   if (!apiKey) {
-    const keyInput = await p7.text({
+    const keyInput = await p8.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 (p7.isCancel(keyInput)) {
-      p7.cancel("Operation cancelled");
+    if (p8.isCancel(keyInput)) {
+      p8.cancel("Operation cancelled");
       process.exit(0);
     }
     apiKey = keyInput;
-    const saveKey = await p7.confirm({
+    const saveKey = await p8.confirm({
       message: "Save API key for future use?"
     });
-    if (saveKey && !p7.isCancel(saveKey)) {
+    if (saveKey && !p8.isCancel(saveKey)) {
       setAnthropicKey(apiKey);
     }
   } else {
-    p7.log.success("Using saved Anthropic API key.");
+    p8.log.success("Using saved Anthropic API key.");
   }
-  const model = await p7.select({
+  const model = await p8.select({
     message: "Which model should analyze your repos?",
     options: [
       { value: "claude-sonnet-4-6", label: "Claude Sonnet 4.6", hint: "Fast & capable (recommended)" },
@@ -3759,12 +3956,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 (p7.isCancel(model)) {
-    p7.cancel("Operation cancelled");
+  if (p8.isCancel(model)) {
+    p8.cancel("Operation cancelled");
     process.exit(0);
   }
-  p7.log.info(`Using ${model}`);
-  const cloneSpinner = p7.spinner();
+  p8.log.info(`Using ${model}`);
+  const cloneSpinner = p8.spinner();
   cloneSpinner.start(`Cloning ${repos.length} repositories...`);
   const clones = [];
   for (const repo of repos) {
@@ -3773,12 +3970,12 @@ Try reinstalling: npm install -g @latent-space-labs/open-auto-doc`
       const cloned = cloneRepo(repo, token);
       clones.push(cloned);
     } catch (err) {
-      p7.log.warn(`Failed to clone ${repo.name}: ${err instanceof Error ? err.message : err}`);
+      p8.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) {
-    p7.log.error("No repositories were cloned.");
+    p8.log.error("No repositories were cloned.");
     process.exit(1);
   }
   const total = clones.length;
@@ -3806,7 +4003,7 @@ Try reinstalling: npm install -g @latent-space-labs/open-auto-doc`
     } catch (err) {
       const errMsg = err instanceof Error ? err.message : String(err);
       progressTable.update(repoName, { status: "failed", error: errMsg });
-      p7.log.warn(`[${repoName}] Analysis failed: ${errMsg}`);
+      p8.log.warn(`[${repoName}] Analysis failed: ${errMsg}`);
       return { repo: repoName, result: null };
     }
   });
@@ -3814,40 +4011,40 @@ Try reinstalling: npm install -g @latent-space-labs/open-auto-doc`
   progressTable.stop();
   const results = settled.filter((s) => s.result !== null).map((s) => s.result);
   const { done, failed } = progressTable.getSummary();
-  p7.log.step(
+  p8.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) {
-    p7.log.error("No repositories were successfully analyzed.");
+    p8.log.error("No repositories were successfully analyzed.");
     cleanup(clones);
     process.exit(1);
   }
   let crossRepo;
   if (results.length > 1) {
-    const crossSpinner = p7.spinner();
+    const crossSpinner = p8.spinner();
     crossSpinner.start("Analyzing cross-repository relationships...");
     try {
-      crossRepo = await analyzeCrossRepos(results, apiKey, model, (text4) => {
-        crossSpinner.message(text4.slice(0, 80));
+      crossRepo = await analyzeCrossRepos(results, apiKey, model, (text5) => {
+        crossSpinner.message(text5.slice(0, 80));
       });
       crossSpinner.stop(`Cross-repo analysis complete \u2014 ${crossRepo.repoRelationships.length} relationships found`);
     } catch (err) {
       crossSpinner.stop("Cross-repo analysis failed (non-fatal)");
-      p7.log.warn(`Cross-repo error: ${err instanceof Error ? err.message : err}`);
+      p8.log.warn(`Cross-repo error: ${err instanceof Error ? err.message : err}`);
     }
   }
   const outputDir = path10.resolve(options.output || "docs-site");
   if (!projectName) {
     projectName = results.length === 1 ? results[0].repoName : "My Project";
   }
-  const genSpinner = p7.spinner();
+  const genSpinner = p8.spinner();
   try {
     genSpinner.start("Scaffolding documentation site...");
     await scaffoldSite(outputDir, projectName, templateDir);
     genSpinner.stop("Site scaffolded");
   } catch (err) {
     genSpinner.stop("Scaffold failed");
-    p7.log.error(`Scaffold error: ${err instanceof Error ? err.stack || err.message : err}`);
+    p8.log.error(`Scaffold error: ${err instanceof Error ? err.stack || err.message : err}`);
     cleanup(clones);
     process.exit(1);
   }
@@ -3859,7 +4056,7 @@ Try reinstalling: npm install -g @latent-space-labs/open-auto-doc`
     genSpinner.stop("Documentation content written");
   } catch (err) {
     genSpinner.stop("Content writing failed");
-    p7.log.error(`Content error: ${err instanceof Error ? err.stack || err.message : err}`);
+    p8.log.error(`Content error: ${err instanceof Error ? err.stack || err.message : err}`);
     cleanup(clones);
     process.exit(1);
   }
@@ -3881,37 +4078,37 @@ Try reinstalling: npm install -g @latent-space-labs/open-auto-doc`
   try {
     await runBuildCheck({ docsDir: outputDir, apiKey, model });
   } catch (err) {
-    p7.log.warn(`Build check skipped: ${err instanceof Error ? err.message : err}`);
+    p8.log.warn(`Build check skipped: ${err instanceof Error ? err.message : err}`);
   }
-  p7.log.success("Documentation generated successfully!");
-  const shouldSetupMcp = await p7.confirm({
+  p8.log.success("Documentation generated successfully!");
+  const shouldSetupMcp = await p8.confirm({
     message: "Set up MCP server so Claude Code can query your docs?"
   });
-  if (!p7.isCancel(shouldSetupMcp) && shouldSetupMcp) {
+  if (!p8.isCancel(shouldSetupMcp) && shouldSetupMcp) {
     await setupMcpConfig({ outputDir });
   }
   let devServer;
   const devPort = await findFreePort(3e3);
   try {
     devServer = startDevServer(outputDir, devPort);
-    p7.log.success(`Documentation site running at http://localhost:${devPort}`);
-    p7.log.info("Open the link above to preview your docs site.");
+    p8.log.success(`Documentation site running at http://localhost:${devPort}`);
+    p8.log.info("Open the link above to preview your docs site.");
   } catch {
-    p7.log.warn("Could not start preview server. You can run it manually:");
-    p7.log.info(`  cd ${path10.relative(process.cwd(), outputDir)} && npm run dev`);
+    p8.log.warn("Could not start preview server. You can run it manually:");
+    p8.log.info(`  cd ${path10.relative(process.cwd(), outputDir)} && npm run dev`);
   }
-  const shouldDeploy = await p7.confirm({
+  const shouldDeploy = await p8.confirm({
     message: "Would you like to deploy your docs to GitHub?"
   });
-  if (p7.isCancel(shouldDeploy) || !shouldDeploy) {
+  if (p8.isCancel(shouldDeploy) || !shouldDeploy) {
     if (devServer) {
       killDevServer(devServer);
     }
-    p7.note(
+    p8.note(
       `cd ${path10.relative(process.cwd(), outputDir)} && npm run dev`,
       "To start the dev server again"
     );
-    p7.outro("Done!");
+    p8.outro("Done!");
     return;
   }
   if (devServer) {
@@ -3923,26 +4120,50 @@ Try reinstalling: npm install -g @latent-space-labs/open-auto-doc`
     config
   });
   if (!deployResult) {
-    p7.note(
+    p8.note(
       `cd ${path10.relative(process.cwd(), outputDir)} && npm run dev`,
       "Next steps"
     );
-    p7.outro("Done!");
+    p8.outro("Done!");
     return;
   }
-  const shouldSetupCi = await p7.confirm({
+  let vercelDeployed = false;
+  const shouldDeployVercel = await p8.confirm({
+    message: "Would you like to deploy to Vercel? (auto-deploys on every push)"
+  });
+  if (!p8.isCancel(shouldDeployVercel) && shouldDeployVercel) {
+    const vercelToken = await authenticateVercel();
+    if (vercelToken) {
+      const vercelResult = await deployToVercel({
+        token: vercelToken,
+        githubOwner: deployResult.owner,
+        githubRepo: deployResult.repoName,
+        docsDir: outputDir,
+        config
+      });
+      if (vercelResult) {
+        p8.log.success(`Live at: ${vercelResult.deploymentUrl}`);
+        vercelDeployed = true;
+      }
+    }
+  }
+  const shouldSetupCi = await p8.confirm({
     message: "Would you like to set up CI to auto-update docs on every push?"
   });
-  if (p7.isCancel(shouldSetupCi) || !shouldSetupCi) {
-    showVercelInstructions(deployResult.owner, deployResult.repoName);
-    p7.outro(`Docs repo: https://github.com/${deployResult.owner}/${deployResult.repoName}`);
+  if (p8.isCancel(shouldSetupCi) || !shouldSetupCi) {
+    if (!vercelDeployed) {
+      showVercelInstructions(deployResult.owner, deployResult.repoName);
+    }
+    p8.outro(`Docs repo: https://github.com/${deployResult.owner}/${deployResult.repoName}`);
     return;
   }
   const gitRoot = getGitRoot();
   if (!gitRoot) {
-    p7.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);
-    p7.outro(`Docs repo: https://github.com/${deployResult.owner}/${deployResult.repoName}`);
+    p8.log.warn("Not in a git repository \u2014 skipping CI setup. Run `open-auto-doc setup-ci` from your project root later.");
+    if (!vercelDeployed) {
+      showVercelInstructions(deployResult.owner, deployResult.repoName);
+    }
+    p8.outro(`Docs repo: https://github.com/${deployResult.owner}/${deployResult.repoName}`);
     return;
   }
   const ciResult = await createCiWorkflow({
@@ -3952,8 +4173,10 @@ Try reinstalling: npm install -g @latent-space-labs/open-auto-doc`
     token,
     config
   });
-  showVercelInstructions(deployResult.owner, deployResult.repoName);
-  p7.outro(`Docs repo: https://github.com/${deployResult.owner}/${deployResult.repoName}`);
+  if (!vercelDeployed) {
+    showVercelInstructions(deployResult.owner, deployResult.repoName);
+  }
+  p8.outro(`Docs repo: https://github.com/${deployResult.owner}/${deployResult.repoName}`);
 }
 function resolveTemplateDir() {
   const candidates = [
@@ -4013,26 +4236,26 @@ function killDevServer(child) {
 }
 
 // src/commands/generate.ts
-import * as p8 from "@clack/prompts";
+import * as p9 from "@clack/prompts";
 import path11 from "path";
 async function generateCommand(options) {
-  p8.intro("open-auto-doc \u2014 Regenerating documentation");
+  p9.intro("open-auto-doc \u2014 Regenerating documentation");
   const config = loadConfig();
   if (!config) {
-    p8.log.error("No .autodocrc.json found. Run `open-auto-doc init` first.");
+    p9.log.error("No .autodocrc.json found. Run `open-auto-doc init` first.");
     process.exit(1);
   }
   const token = getGithubToken();
   const apiKey = getAnthropicKey();
   if (!token) {
-    p8.log.error("Not authenticated. Run `open-auto-doc login` or set GITHUB_TOKEN env var.");
+    p9.log.error("Not authenticated. Run `open-auto-doc login` or set GITHUB_TOKEN env var.");
     process.exit(1);
   }
   if (!apiKey) {
-    p8.log.error("No Anthropic API key found. Run `open-auto-doc init` or set ANTHROPIC_API_KEY env var.");
+    p9.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 p8.select({
+  const model = await p9.select({
     message: "Which model should analyze your repos?",
     options: [
       { value: "claude-sonnet-4-6", label: "Claude Sonnet 4.6", hint: "Fast & capable (recommended)" },
@@ -4040,11 +4263,11 @@ async function generateCommand(options) {
       { value: "claude-opus-4-6", label: "Claude Opus 4.6", hint: "Most capable, slowest" }
     ]
   });
-  if (p8.isCancel(model)) {
-    p8.cancel("Cancelled.");
+  if (p9.isCancel(model)) {
+    p9.cancel("Cancelled.");
     process.exit(0);
   }
-  p8.log.info(`Using ${model}`);
+  p9.log.info(`Using ${model}`);
   const incremental = options.incremental && !options.force;
   const cacheDir = path11.join(config.outputDir, ".autodoc-cache");
   const targetRepoName = options.repo;
@@ -4053,7 +4276,7 @@ async function generateCommand(options) {
   if (targetRepoName) {
     const targetRepo = config.repos.find((r) => r.name === targetRepoName);
     if (!targetRepo) {
-      p8.log.error(`Repo "${targetRepoName}" not found in config. Available: ${config.repos.map((r) => r.name).join(", ")}`);
+      p9.log.error(`Repo "${targetRepoName}" not found in config. Available: ${config.repos.map((r) => r.name).join(", ")}`);
       process.exit(1);
     }
     reposToAnalyze = [targetRepo];
@@ -4062,13 +4285,13 @@ async function generateCommand(options) {
       const cached = loadCache(cacheDir, repo.name);
       if (cached) {
         cachedResults.push(cached.result);
-        p8.log.info(`Using cached analysis for ${repo.name}`);
+        p9.log.info(`Using cached analysis for ${repo.name}`);
       } else {
-        p8.log.warn(`No cached analysis for ${repo.name} \u2014 its docs will be stale until it pushes`);
+        p9.log.warn(`No cached analysis for ${repo.name} \u2014 its docs will be stale until it pushes`);
       }
     }
   }
-  const cloneSpinner = p8.spinner();
+  const cloneSpinner = p9.spinner();
   cloneSpinner.start(`Cloning ${reposToAnalyze.length} ${reposToAnalyze.length === 1 ? "repository" : "repositories"}...`);
   const clones = [];
   for (const repo of reposToAnalyze) {
@@ -4087,12 +4310,12 @@ async function generateCommand(options) {
       );
       clones.push(cloned);
     } catch (err) {
-      p8.log.warn(`Failed to clone ${repo.name}: ${err instanceof Error ? err.message : err}`);
+      p9.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) {
-    p8.log.error("No repositories were cloned.");
+    p9.log.error("No repositories were cloned.");
     process.exit(1);
   }
   const total = clones.length;
@@ -4167,7 +4390,7 @@ async function generateCommand(options) {
     } catch (err) {
       const errMsg = err instanceof Error ? err.message : String(err);
       progressTable.update(repoName, { status: "failed", error: errMsg });
-      p8.log.warn(`[${repoName}] Analysis failed: ${errMsg}`);
+      p9.log.warn(`[${repoName}] Analysis failed: ${errMsg}`);
       return { repo: repoName, result: null };
     }
   });
@@ -4175,23 +4398,23 @@ async function generateCommand(options) {
   progressTable.stop();
   const freshResults = settled.filter((s) => s.result !== null).map((s) => s.result);
   const { done: analyzedCount, failed: failedCount } = progressTable.getSummary();
-  p8.log.step(
+  p9.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 = p8.spinner();
+      const crossSpinner = p9.spinner();
       crossSpinner.start("Analyzing cross-repository relationships...");
       try {
-        crossRepo = await analyzeCrossRepos(results, apiKey, model, (text4) => {
-          crossSpinner.message(text4.slice(0, 80));
+        crossRepo = await analyzeCrossRepos(results, apiKey, model, (text5) => {
+          crossSpinner.message(text5.slice(0, 80));
         });
         crossSpinner.stop(`Cross-repo analysis complete \u2014 ${crossRepo.repoRelationships.length} relationships found`);
       } catch (err) {
         crossSpinner.stop("Cross-repo analysis failed (non-fatal)");
-        p8.log.warn(`Cross-repo error: ${err instanceof Error ? err.message : err}`);
+        p9.log.warn(`Cross-repo error: ${err instanceof Error ? err.message : err}`);
       }
     }
     const contentDir = path11.join(config.outputDir, "content", "docs");
@@ -4200,25 +4423,25 @@ async function generateCommand(options) {
     try {
       await runBuildCheck({ docsDir: config.outputDir, apiKey, model });
     } catch (err) {
-      p8.log.warn(`Build check skipped: ${err instanceof Error ? err.message : err}`);
+      p9.log.warn(`Build check skipped: ${err instanceof Error ? err.message : err}`);
     }
-    p8.log.success("Documentation regenerated!");
+    p9.log.success("Documentation regenerated!");
   }
   for (const clone of clones) {
     cleanupClone(clone);
   }
-  p8.outro("Done!");
+  p9.outro("Done!");
 }
 
 // src/commands/deploy.ts
-import * as p9 from "@clack/prompts";
+import * as p10 from "@clack/prompts";
 import fs11 from "fs";
 import path12 from "path";
 function resolveDocsDir(config, dirOption) {
   if (dirOption) {
     const resolved = path12.resolve(dirOption);
     if (!fs11.existsSync(resolved)) {
-      p9.log.error(`Directory not found: ${resolved}`);
+      p10.log.error(`Directory not found: ${resolved}`);
       process.exit(1);
     }
     return resolved;
@@ -4229,28 +4452,28 @@ function resolveDocsDir(config, dirOption) {
   if (fs11.existsSync(path12.resolve("docs-site"))) {
     return path12.resolve("docs-site");
   }
-  p9.log.error(
+  p10.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) {
-  p9.intro("open-auto-doc \u2014 Deploy docs to GitHub");
+  p10.intro("open-auto-doc \u2014 Deploy docs to GitHub");
   const token = getGithubToken();
   if (!token) {
-    p9.log.error("Not authenticated. Run `open-auto-doc login` first.");
+    p10.log.error("Not authenticated. Run `open-auto-doc login` first.");
     process.exit(1);
   }
   const config = loadConfig();
   const docsDir = resolveDocsDir(config, options.dir);
-  p9.log.info(`Docs directory: ${docsDir}`);
+  p10.log.info(`Docs directory: ${docsDir}`);
   if (config?.docsRepo) {
-    p9.log.info(`Docs repo already configured: ${config.docsRepo}`);
+    p10.log.info(`Docs repo already configured: ${config.docsRepo}`);
     const pushed = await pushUpdates({ token, docsDir, docsRepo: config.docsRepo });
     if (pushed) {
-      p9.outro("Docs updated! Vercel will auto-deploy from the push.");
+      p10.outro("Docs updated! Vercel will auto-deploy from the push.");
     } else {
-      p9.outro("Docs are up to date!");
+      p10.outro("Docs are up to date!");
     }
     return;
   }
@@ -4260,20 +4483,40 @@ async function deployCommand(options) {
     config: config || { repos: [], outputDir: docsDir }
   });
   if (!result) {
-    p9.cancel("Deploy cancelled.");
+    p10.cancel("Deploy cancelled.");
     process.exit(0);
   }
+  const shouldDeployVercel = await p10.confirm({
+    message: "Would you like to deploy to Vercel? (auto-deploys on every push)"
+  });
+  if (!p10.isCancel(shouldDeployVercel) && shouldDeployVercel) {
+    const vercelToken = await authenticateVercel();
+    if (vercelToken) {
+      const vercelResult = await deployToVercel({
+        token: vercelToken,
+        githubOwner: result.owner,
+        githubRepo: result.repoName,
+        docsDir,
+        config: config || { repos: [], outputDir: docsDir }
+      });
+      if (vercelResult) {
+        p10.log.success(`Live at: ${vercelResult.deploymentUrl}`);
+        p10.outro(`Docs repo: https://github.com/${result.owner}/${result.repoName}`);
+        return;
+      }
+    }
+  }
   showVercelInstructions(result.owner, result.repoName);
-  p9.outro(`Docs repo: https://github.com/${result.owner}/${result.repoName}`);
+  p10.outro(`Docs repo: https://github.com/${result.owner}/${result.repoName}`);
 }
 
 // src/commands/setup-ci.ts
-import * as p10 from "@clack/prompts";
+import * as p11 from "@clack/prompts";
 async function setupCiCommand() {
-  p10.intro("open-auto-doc \u2014 CI/CD Setup");
+  p11.intro("open-auto-doc \u2014 CI/CD Setup");
   const config = loadConfig();
   if (!config?.docsRepo) {
-    p10.log.error(
+    p11.log.error(
       "No docs repo configured. Run `open-auto-doc deploy` first to create a docs GitHub repo."
     );
     process.exit(1);
@@ -4281,12 +4524,12 @@ async function setupCiCommand() {
   const token = getGithubToken();
   const isMultiRepo = config.repos.length > 1;
   if (isMultiRepo && !token) {
-    p10.log.error("Not authenticated. Run `open-auto-doc login` first (needed to push workflows to source repos).");
+    p11.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) {
-    p10.log.error("Not in a git repository. Run this command from your project root.");
+    p11.log.error("Not in a git repository. Run this command from your project root.");
     process.exit(1);
   }
   const result = await createCiWorkflow({
@@ -4297,46 +4540,46 @@ async function setupCiCommand() {
     config
   });
   if (!result) {
-    p10.cancel("Setup cancelled.");
+    p11.cancel("Setup cancelled.");
     process.exit(0);
   }
   if ("repos" in result) {
-    p10.outro("Per-repo CI workflows created! Add the required secrets to each source repo.");
+    p11.outro("Per-repo CI workflows created! Add the required secrets to each source repo.");
   } else {
-    p10.outro("CI/CD workflow is ready! Commit and push to activate.");
+    p11.outro("CI/CD workflow is ready! Commit and push to activate.");
   }
 }
 
 // src/commands/login.ts
-import * as p11 from "@clack/prompts";
+import * as p12 from "@clack/prompts";
 async function loginCommand() {
-  p11.intro("open-auto-doc \u2014 GitHub Login");
+  p12.intro("open-auto-doc \u2014 GitHub Login");
   const existing = getGithubToken();
   if (existing) {
-    const overwrite = await p11.confirm({
+    const overwrite = await p12.confirm({
       message: "You're already logged in. Re-authenticate?"
     });
-    if (!overwrite || p11.isCancel(overwrite)) {
-      p11.cancel("Keeping existing credentials");
+    if (!overwrite || p12.isCancel(overwrite)) {
+      p12.cancel("Keeping existing credentials");
       return;
     }
   }
   const token = await authenticateWithGithub();
   setGithubToken(token);
-  p11.outro("Logged in successfully!");
+  p12.outro("Logged in successfully!");
 }
 
 // src/commands/logout.ts
-import * as p12 from "@clack/prompts";
+import * as p13 from "@clack/prompts";
 async function logoutCommand() {
-  p12.intro("open-auto-doc \u2014 Logout");
+  p13.intro("open-auto-doc \u2014 Logout");
   clearAll();
-  p12.outro("Credentials cleared. You've been logged out.");
+  p13.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.5.1");
+program.name("open-auto-doc").description("Auto-generate beautiful documentation websites from GitHub repositories using AI").version("0.5.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)").option("--repo <name>", "Only analyze this repo (uses cache for others)").action(generateCommand);
 program.command("deploy").description("Create a GitHub repo for docs and push (connect to Vercel for auto-deploy)").option("-d, --dir <path>", "Docs site directory").action(deployCommand);

package/package.json

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