@latent-space-labs/open-auto-doc 0.4.1 → 0.5.0

package/README.md

@@ -0,0 +1,141 @@
+# open-auto-doc
+
+**One command. Beautiful docs. Auto-deployed.**
+
+Turn any GitHub repo into a fully hosted documentation site — powered by AI that actually reads your code.
+
+```bash
+npx @latent-space-labs/open-auto-doc
+```
+
+No config files. No manual writing. Just point it at your repos and get a production-ready docs site with architecture overviews, API references, component docs, and more.
+
+## Install
+
+```bash
+# Run directly with npx (no install needed)
+npx @latent-space-labs/open-auto-doc
+
+# Or install globally
+npm install -g @latent-space-labs/open-auto-doc
+```
+
+### Requirements
+
+- **Node.js 18+**
+- **A GitHub account** — works with public and private repos
+- **An [Anthropic API key](https://console.anthropic.com/)** — powers the AI analysis
+
+## Quick Start
+
+```bash
+# 1. Generate docs (interactive setup)
+npx @latent-space-labs/open-auto-doc
+
+# 2. Preview locally
+cd docs-site && npm run dev
+
+# 3. Deploy
+open-auto-doc deploy
+
+# 4. Auto-update on every push
+open-auto-doc setup-ci
+```
+
+The CLI walks you through GitHub auth, repo selection, and API key setup interactively.
+
+## What Gets Generated
+
+| Section | Contents |
+|---|---|
+| **Architecture Overview** | Tech stack, module breakdown, data flow diagrams, entry points, key patterns |
+| **Getting Started** | Prerequisites, install steps, quick start guide, config options |
+| **API Reference** | Endpoints with methods, params, request/response bodies, auth |
+| **Components** | UI components with props, usage examples, categories |
+| **Data Models** | Schemas with field types, constraints, relationships, ER diagrams |
+| **Business Logic** | Domain concepts, business rules, workflows |
+| **Configuration** | Config files, env vars, settings reference |
+| **Error Handling** | Error codes, common errors, debugging tips |
+
+Multi-repo setups also get **cross-repo analysis** — shared dependencies, API contracts, and relationship diagrams.
+
+## All Commands
+
+| Command | What it does |
+|---|---|
+| `open-auto-doc` | Full interactive setup: auth → pick repos → analyze → generate |
+| `open-auto-doc init -o <dir>` | Same, with custom output directory (default: `docs-site`) |
+| `open-auto-doc generate` | Re-analyze and regenerate using saved config |
+| `open-auto-doc generate --incremental` | Only re-analyze changed files |
+| `open-auto-doc deploy` | Create a GitHub repo for docs and push |
+| `open-auto-doc setup-ci` | Add GitHub Actions workflow for auto-updates |
+| `open-auto-doc setup-mcp` | Set up MCP server for Claude Code |
+| `open-auto-doc login` | Authenticate with GitHub |
+| `open-auto-doc logout` | Clear stored credentials |
+
+## MCP Server for AI Assistants
+
+open-auto-doc includes an [MCP (Model Context Protocol)](https://modelcontextprotocol.io/) server that lets AI assistants like Claude Code query your documentation directly. Instead of reading raw source files, the AI gets structured knowledge about your architecture, APIs, components, and data models.
+
+### How it works
+
+When you run `open-auto-doc init` or `generate`, the AI analysis results are cached as JSON in `<outputDir>/.autodoc-cache/`. The MCP server (`@latent-space-labs/open-auto-doc-mcp`) is a separate lightweight package that reads this cache and serves it over the Model Context Protocol via stdio.
+
+```
+open-auto-doc init → .autodoc-cache/*.json → MCP Server (stdio) → Claude Code
+```
+
+The server has no dependency on the analyzer or generator — it only reads JSON files, so `npx` startup is fast.
+
+### Setup
+
+```bash
+# Set up after generating docs
+open-auto-doc setup-mcp
+```
+
+This creates `.mcp.json` in your project root. Claude Code will automatically discover the tools:
+
+- `get_project_overview` — purpose, tech stack, summary stats
+- `search_documentation` — full-text search across all sections
+- `get_api_endpoints` — API endpoint details with params, auth, request/response
+- `get_components` — UI component documentation with props and usage
+- `get_data_models` — data model schemas with fields and relationships
+- `get_architecture` — modules, data flow, patterns, entry points
+- `get_diagram` — Mermaid diagrams (architecture, ER, flow)
+- `get_business_rules` — domain concepts, rules, and workflows
+
+Resources are also available at `docs://overview`, `docs://architecture`, `docs://getting-started`, and `docs://diagrams/{id}`.
+
+You can also configure `.mcp.json` manually:
+
+```json
+{
+  "mcpServers": {
+    "project-docs": {
+      "command": "npx",
+      "args": ["-y", "@latent-space-labs/open-auto-doc-mcp", "--project-dir", "."]
+    }
+  }
+}
+```
+
+## Language Support
+
+open-auto-doc is **language-agnostic**. It uses AI to understand code — not language-specific parsers. Works with TypeScript, JavaScript, Python, Go, Rust, Java, Kotlin, Ruby, PHP, C#, Swift, and more.
+
+## Privacy & Security
+
+- Your Anthropic API key is **only sent to the Anthropic API**
+- All code analysis runs **locally on your machine** (or in your own CI runner)
+- Credentials stored at `~/.open-auto-doc/credentials.json` with `0600` permissions
+- Run `open-auto-doc logout` to clear everything
+
+## Links
+
+- [GitHub](https://github.com/Latent-Space-Labs/open-auto-doc) — source code, issues, contributing
+- [Anthropic Console](https://console.anthropic.com/) — get an API key
+
+## License
+
+MIT

package/dist/index.js

@@ -4,10 +4,10 @@
 import { Command } from "commander";
 
 // src/commands/init.ts
-import * as p6 from "@clack/prompts";
-import fs9 from "fs";
+import * as p7 from "@clack/prompts";
+import fs10 from "fs";
 import net from "net";
-import path9 from "path";
+import path10 from "path";
 import { fileURLToPath as fileURLToPath2 } from "url";
 import { spawn } from "child_process";
 
@@ -528,7 +528,7 @@ function detectEntryFiles(flatFiles) {
     /^app\/page\.tsx$/,
     /^pages\/index\.\w+$/
   ];
-  return flatFiles.filter((f) => entryPatterns.some((p12) => p12.test(f)));
+  return flatFiles.filter((f) => entryPatterns.some((p13) => p13.test(f)));
 }
 var DEP_FILES = [
   {
@@ -1731,7 +1731,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((p12) => p12.test(entry.filePath))) {
+      if (patterns.some((p13) => p13.test(entry.filePath))) {
         affected.add(section);
       }
     }
@@ -2809,9 +2809,85 @@ function showSecretsInstructions(multiRepo = false) {
   );
 }
 
-// ../generator/dist/index.js
-import fs8 from "fs-extra";
+// src/commands/setup-mcp.ts
+import * as p6 from "@clack/prompts";
+import fs8 from "fs";
 import path8 from "path";
+var MCP_SERVER_KEY = "project-docs";
+function getMcpConfig() {
+  return {
+    command: "npx",
+    args: ["-y", "@latent-space-labs/open-auto-doc-mcp", "--project-dir", "."]
+  };
+}
+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.");
+    return;
+  }
+  writeMcpJson(process.cwd());
+}
+async function setupMcpCommand() {
+  p6.intro("open-auto-doc \u2014 MCP Server Setup");
+  const config = loadConfig();
+  if (!config) {
+    p6.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(
+      `No analysis cache found at ${cacheDir}.
+Run \`open-auto-doc init\` or \`open-auto-doc generate\` first.`
+    );
+    process.exit(1);
+  }
+  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.");
+    process.exit(1);
+  }
+  writeMcpJson(process.cwd());
+  p6.log.success("MCP server configured!");
+  p6.note(
+    [
+      "The following tools are now available in Claude Code:",
+      "",
+      "  get_project_overview    \u2014 Project summary and tech stack",
+      "  search_documentation    \u2014 Full-text search across all docs",
+      "  get_api_endpoints       \u2014 API endpoint details",
+      "  get_components          \u2014 UI component documentation",
+      "  get_data_models         \u2014 Data model schemas",
+      "  get_architecture        \u2014 Architecture and patterns",
+      "  get_diagram             \u2014 Mermaid diagrams",
+      "  get_business_rules      \u2014 Domain concepts and workflows"
+    ].join("\n"),
+    "Available MCP tools"
+  );
+  p6.outro("Open Claude Code in this project to start using the tools.");
+}
+function writeMcpJson(projectRoot) {
+  const mcpPath = path8.join(projectRoot, ".mcp.json");
+  let existing = {};
+  if (fs8.existsSync(mcpPath)) {
+    try {
+      existing = JSON.parse(fs8.readFileSync(mcpPath, "utf-8"));
+    } catch {
+    }
+  }
+  const mcpServers = existing.mcpServers ?? {};
+  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)}`);
+}
+
+// ../generator/dist/index.js
+import fs9 from "fs-extra";
+import path9 from "path";
 import { execSync as execSync6 } from "child_process";
 import fs23 from "fs-extra";
 import path23 from "path";
@@ -2820,26 +2896,26 @@ import { fileURLToPath } from "url";
 import fs33 from "fs-extra";
 import path33 from "path";
 async function scaffoldSite(outputDir, projectName, templateDir) {
-  await fs8.copy(templateDir, outputDir, {
+  await fs9.copy(templateDir, outputDir, {
     overwrite: true,
     filter: (src) => {
-      const basename = path8.basename(src);
+      const basename = path9.basename(src);
       return basename !== "node_modules" && basename !== ".next" && basename !== ".source" && basename !== "dist" && basename !== ".turbo";
     }
   });
   const filesToProcess = await findTextFiles(outputDir);
   for (const filePath of filesToProcess) {
     try {
-      let content = await fs8.readFile(filePath, "utf-8");
+      let content = await fs9.readFile(filePath, "utf-8");
       if (content.includes("{{projectName}}")) {
         content = content.replace(/\{\{projectName\}\}/g, projectName);
-        await fs8.writeFile(filePath, content, "utf-8");
+        await fs9.writeFile(filePath, content, "utf-8");
       }
     } catch {
     }
   }
-  const nodeModulesPath = path8.join(outputDir, "node_modules");
-  if (!fs8.existsSync(nodeModulesPath)) {
+  const nodeModulesPath = path9.join(outputDir, "node_modules");
+  if (!fs9.existsSync(nodeModulesPath)) {
     try {
       execSync6("npm install --ignore-scripts", {
         cwd: outputDir,
@@ -2847,7 +2923,7 @@ async function scaffoldSite(outputDir, projectName, templateDir) {
         timeout: 12e4
       });
     } catch (err) {
-      const hasNodeModules = fs8.existsSync(nodeModulesPath);
+      const hasNodeModules = fs9.existsSync(nodeModulesPath);
       if (!hasNodeModules) {
         throw new Error(`npm install failed: ${err instanceof Error ? err.message : err}`);
       }
@@ -2876,14 +2952,14 @@ async function findTextFiles(dir) {
   ]);
   const results = [];
   async function walk(currentDir) {
-    const entries = await fs8.readdir(currentDir, { withFileTypes: true });
+    const entries = await fs9.readdir(currentDir, { withFileTypes: true });
     for (const entry of entries) {
-      const fullPath = path8.join(currentDir, entry.name);
+      const fullPath = path9.join(currentDir, entry.name);
       if (entry.isDirectory()) {
         if (entry.name !== "node_modules" && entry.name !== ".next" && entry.name !== ".source") {
           await walk(fullPath);
         }
-      } else if (textExtensions.has(path8.extname(entry.name))) {
+      } else if (textExtensions.has(path9.extname(entry.name))) {
         results.push(fullPath);
       }
     }
@@ -3615,12 +3691,12 @@ function buildRepoSummary(result) {
 }
 
 // src/commands/init.ts
-var __dirname2 = path9.dirname(fileURLToPath2(import.meta.url));
+var __dirname2 = path10.dirname(fileURLToPath2(import.meta.url));
 async function initCommand(options) {
-  p6.intro("open-auto-doc \u2014 AI-powered documentation generator");
+  p7.intro("open-auto-doc \u2014 AI-powered documentation generator");
   const templateDir = resolveTemplateDir();
-  if (!fs9.existsSync(path9.join(templateDir, "package.json"))) {
-    p6.log.error(
+  if (!fs10.existsSync(path10.join(templateDir, "package.json"))) {
+    p7.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`
@@ -3629,53 +3705,53 @@ Try reinstalling: npm install -g @latent-space-labs/open-auto-doc`
   }
   let token = getGithubToken();
   if (!token) {
-    p6.log.info("Let's connect your GitHub account.");
+    p7.log.info("Let's connect your GitHub account.");
     token = await authenticateWithGithub();
     setGithubToken(token);
   } else {
-    p6.log.success("Using saved GitHub credentials.");
+    p7.log.success("Using saved GitHub credentials.");
   }
   const repos = await pickRepos(token);
-  p6.log.info(`Selected ${repos.length} ${repos.length === 1 ? "repository" : "repositories"}`);
+  p7.log.info(`Selected ${repos.length} ${repos.length === 1 ? "repository" : "repositories"}`);
   let projectName;
   if (repos.length > 1) {
-    const nameInput = await p6.text({
+    const nameInput = await p7.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 (p6.isCancel(nameInput)) {
-      p6.cancel("Operation cancelled");
+    if (p7.isCancel(nameInput)) {
+      p7.cancel("Operation cancelled");
       process.exit(0);
     }
     projectName = nameInput;
   }
   let apiKey = getAnthropicKey();
   if (!apiKey) {
-    const keyInput = await p6.text({
+    const keyInput = await p7.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 (p6.isCancel(keyInput)) {
-      p6.cancel("Operation cancelled");
+    if (p7.isCancel(keyInput)) {
+      p7.cancel("Operation cancelled");
       process.exit(0);
     }
     apiKey = keyInput;
-    const saveKey = await p6.confirm({
+    const saveKey = await p7.confirm({
       message: "Save API key for future use?"
     });
-    if (saveKey && !p6.isCancel(saveKey)) {
+    if (saveKey && !p7.isCancel(saveKey)) {
       setAnthropicKey(apiKey);
     }
   } else {
-    p6.log.success("Using saved Anthropic API key.");
+    p7.log.success("Using saved Anthropic API key.");
   }
-  const model = await p6.select({
+  const model = await p7.select({
     message: "Which model should analyze your repos?",
     options: [
       { value: "claude-sonnet-4-6", label: "Claude Sonnet 4.6", hint: "Fast & capable (recommended)" },
@@ -3683,12 +3759,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 (p6.isCancel(model)) {
-    p6.cancel("Operation cancelled");
+  if (p7.isCancel(model)) {
+    p7.cancel("Operation cancelled");
     process.exit(0);
   }
-  p6.log.info(`Using ${model}`);
-  const cloneSpinner = p6.spinner();
+  p7.log.info(`Using ${model}`);
+  const cloneSpinner = p7.spinner();
   cloneSpinner.start(`Cloning ${repos.length} repositories...`);
   const clones = [];
   for (const repo of repos) {
@@ -3697,12 +3773,12 @@ Try reinstalling: npm install -g @latent-space-labs/open-auto-doc`
       const cloned = cloneRepo(repo, token);
       clones.push(cloned);
     } catch (err) {
-      p6.log.warn(`Failed to clone ${repo.name}: ${err instanceof Error ? err.message : err}`);
+      p7.log.warn(`Failed to clone ${repo.name}: ${err instanceof Error ? err.message : err}`);
     }
   }
   cloneSpinner.stop(`Cloned ${clones.length}/${repos.length} repositories`);
   if (clones.length === 0) {
-    p6.log.error("No repositories were cloned.");
+    p7.log.error("No repositories were cloned.");
     process.exit(1);
   }
   const total = clones.length;
@@ -3730,7 +3806,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 });
-      p6.log.warn(`[${repoName}] Analysis failed: ${errMsg}`);
+      p7.log.warn(`[${repoName}] Analysis failed: ${errMsg}`);
       return { repo: repoName, result: null };
     }
   });
@@ -3738,17 +3814,17 @@ 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();
-  p6.log.step(
+  p7.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) {
-    p6.log.error("No repositories were successfully analyzed.");
+    p7.log.error("No repositories were successfully analyzed.");
     cleanup(clones);
     process.exit(1);
   }
   let crossRepo;
   if (results.length > 1) {
-    const crossSpinner = p6.spinner();
+    const crossSpinner = p7.spinner();
     crossSpinner.start("Analyzing cross-repository relationships...");
     try {
       crossRepo = await analyzeCrossRepos(results, apiKey, model, (text4) => {
@@ -3757,33 +3833,33 @@ Try reinstalling: npm install -g @latent-space-labs/open-auto-doc`
       crossSpinner.stop(`Cross-repo analysis complete \u2014 ${crossRepo.repoRelationships.length} relationships found`);
     } catch (err) {
       crossSpinner.stop("Cross-repo analysis failed (non-fatal)");
-      p6.log.warn(`Cross-repo error: ${err instanceof Error ? err.message : err}`);
+      p7.log.warn(`Cross-repo error: ${err instanceof Error ? err.message : err}`);
     }
   }
-  const outputDir = path9.resolve(options.output || "docs-site");
+  const outputDir = path10.resolve(options.output || "docs-site");
   if (!projectName) {
     projectName = results.length === 1 ? results[0].repoName : "My Project";
   }
-  const genSpinner = p6.spinner();
+  const genSpinner = p7.spinner();
   try {
     genSpinner.start("Scaffolding documentation site...");
     await scaffoldSite(outputDir, projectName, templateDir);
     genSpinner.stop("Site scaffolded");
   } catch (err) {
     genSpinner.stop("Scaffold failed");
-    p6.log.error(`Scaffold error: ${err instanceof Error ? err.stack || err.message : err}`);
+    p7.log.error(`Scaffold error: ${err instanceof Error ? err.stack || err.message : err}`);
     cleanup(clones);
     process.exit(1);
   }
   try {
     genSpinner.start("Writing documentation content...");
-    const contentDir = path9.join(outputDir, "content", "docs");
+    const contentDir = path10.join(outputDir, "content", "docs");
     await writeContent(contentDir, results, crossRepo);
     await writeMeta(contentDir, results, crossRepo);
     genSpinner.stop("Documentation content written");
   } catch (err) {
     genSpinner.stop("Content writing failed");
-    p6.log.error(`Content error: ${err instanceof Error ? err.stack || err.message : err}`);
+    p7.log.error(`Content error: ${err instanceof Error ? err.stack || err.message : err}`);
     cleanup(clones);
     process.exit(1);
   }
@@ -3805,31 +3881,37 @@ Try reinstalling: npm install -g @latent-space-labs/open-auto-doc`
   try {
     await runBuildCheck({ docsDir: outputDir, apiKey, model });
   } catch (err) {
-    p6.log.warn(`Build check skipped: ${err instanceof Error ? err.message : err}`);
+    p7.log.warn(`Build check skipped: ${err instanceof Error ? err.message : err}`);
+  }
+  p7.log.success("Documentation generated successfully!");
+  const shouldSetupMcp = await p7.confirm({
+    message: "Set up MCP server so Claude Code can query your docs?"
+  });
+  if (!p7.isCancel(shouldSetupMcp) && shouldSetupMcp) {
+    await setupMcpConfig({ outputDir });
   }
-  p6.log.success("Documentation generated successfully!");
   let devServer;
   const devPort = await findFreePort(3e3);
   try {
     devServer = startDevServer(outputDir, devPort);
-    p6.log.success(`Documentation site running at http://localhost:${devPort}`);
-    p6.log.info("Open the link above to preview your docs site.");
+    p7.log.success(`Documentation site running at http://localhost:${devPort}`);
+    p7.log.info("Open the link above to preview your docs site.");
   } catch {
-    p6.log.warn("Could not start preview server. You can run it manually:");
-    p6.log.info(`  cd ${path9.relative(process.cwd(), outputDir)} && npm run dev`);
+    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`);
   }
-  const shouldDeploy = await p6.confirm({
+  const shouldDeploy = await p7.confirm({
     message: "Would you like to deploy your docs to GitHub?"
   });
-  if (p6.isCancel(shouldDeploy) || !shouldDeploy) {
+  if (p7.isCancel(shouldDeploy) || !shouldDeploy) {
     if (devServer) {
       killDevServer(devServer);
     }
-    p6.note(
-      `cd ${path9.relative(process.cwd(), outputDir)} && npm run dev`,
+    p7.note(
+      `cd ${path10.relative(process.cwd(), outputDir)} && npm run dev`,
       "To start the dev server again"
     );
-    p6.outro("Done!");
+    p7.outro("Done!");
     return;
   }
   if (devServer) {
@@ -3841,26 +3923,26 @@ Try reinstalling: npm install -g @latent-space-labs/open-auto-doc`
     config
   });
   if (!deployResult) {
-    p6.note(
-      `cd ${path9.relative(process.cwd(), outputDir)} && npm run dev`,
+    p7.note(
+      `cd ${path10.relative(process.cwd(), outputDir)} && npm run dev`,
       "Next steps"
     );
-    p6.outro("Done!");
+    p7.outro("Done!");
     return;
   }
-  const shouldSetupCi = await p6.confirm({
+  const shouldSetupCi = await p7.confirm({
     message: "Would you like to set up CI to auto-update docs on every push?"
   });
-  if (p6.isCancel(shouldSetupCi) || !shouldSetupCi) {
+  if (p7.isCancel(shouldSetupCi) || !shouldSetupCi) {
     showVercelInstructions(deployResult.owner, deployResult.repoName);
-    p6.outro(`Docs repo: https://github.com/${deployResult.owner}/${deployResult.repoName}`);
+    p7.outro(`Docs repo: https://github.com/${deployResult.owner}/${deployResult.repoName}`);
     return;
   }
   const gitRoot = getGitRoot();
   if (!gitRoot) {
-    p6.log.warn("Not in a git repository \u2014 skipping CI setup. Run `open-auto-doc setup-ci` from your project root later.");
+    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);
-    p6.outro(`Docs repo: https://github.com/${deployResult.owner}/${deployResult.repoName}`);
+    p7.outro(`Docs repo: https://github.com/${deployResult.owner}/${deployResult.repoName}`);
     return;
   }
   const ciResult = await createCiWorkflow({
@@ -3871,24 +3953,24 @@ Try reinstalling: npm install -g @latent-space-labs/open-auto-doc`
     config
   });
   showVercelInstructions(deployResult.owner, deployResult.repoName);
-  p6.outro(`Docs repo: https://github.com/${deployResult.owner}/${deployResult.repoName}`);
+  p7.outro(`Docs repo: https://github.com/${deployResult.owner}/${deployResult.repoName}`);
 }
 function resolveTemplateDir() {
   const candidates = [
-    path9.resolve(__dirname2, "site-template"),
+    path10.resolve(__dirname2, "site-template"),
     // dist/site-template (npm global install)
-    path9.resolve(__dirname2, "../../site-template"),
+    path10.resolve(__dirname2, "../../site-template"),
     // monorepo: packages/site-template
-    path9.resolve(__dirname2, "../../../site-template"),
+    path10.resolve(__dirname2, "../../../site-template"),
     // monorepo alt
-    path9.resolve(__dirname2, "../../../../packages/site-template")
+    path10.resolve(__dirname2, "../../../../packages/site-template")
     // monorepo from nested dist
   ];
   for (const candidate of candidates) {
-    const pkgPath = path9.join(candidate, "package.json");
-    if (fs9.existsSync(pkgPath)) return candidate;
+    const pkgPath = path10.join(candidate, "package.json");
+    if (fs10.existsSync(pkgPath)) return candidate;
   }
-  return path9.resolve(__dirname2, "site-template");
+  return path10.resolve(__dirname2, "site-template");
 }
 function cleanup(clones) {
   for (const clone of clones) {
@@ -3931,26 +4013,26 @@ function killDevServer(child) {
 }
 
 // src/commands/generate.ts
-import * as p7 from "@clack/prompts";
-import path10 from "path";
+import * as p8 from "@clack/prompts";
+import path11 from "path";
 async function generateCommand(options) {
-  p7.intro("open-auto-doc \u2014 Regenerating documentation");
+  p8.intro("open-auto-doc \u2014 Regenerating documentation");
   const config = loadConfig();
   if (!config) {
-    p7.log.error("No .autodocrc.json found. Run `open-auto-doc init` first.");
+    p8.log.error("No .autodocrc.json found. Run `open-auto-doc init` first.");
     process.exit(1);
   }
   const token = getGithubToken();
   const apiKey = getAnthropicKey();
   if (!token) {
-    p7.log.error("Not authenticated. Run `open-auto-doc login` or set GITHUB_TOKEN env var.");
+    p8.log.error("Not authenticated. Run `open-auto-doc login` or set GITHUB_TOKEN env var.");
     process.exit(1);
   }
   if (!apiKey) {
-    p7.log.error("No Anthropic API key found. Run `open-auto-doc init` or set ANTHROPIC_API_KEY env var.");
+    p8.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 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)" },
@@ -3958,20 +4040,20 @@ async function generateCommand(options) {
       { value: "claude-opus-4-6", label: "Claude Opus 4.6", hint: "Most capable, slowest" }
     ]
   });
-  if (p7.isCancel(model)) {
-    p7.cancel("Cancelled.");
+  if (p8.isCancel(model)) {
+    p8.cancel("Cancelled.");
     process.exit(0);
   }
-  p7.log.info(`Using ${model}`);
+  p8.log.info(`Using ${model}`);
   const incremental = options.incremental && !options.force;
-  const cacheDir = path10.join(config.outputDir, ".autodoc-cache");
+  const cacheDir = path11.join(config.outputDir, ".autodoc-cache");
   const targetRepoName = options.repo;
   let reposToAnalyze = config.repos;
   const cachedResults = [];
   if (targetRepoName) {
     const targetRepo = config.repos.find((r) => r.name === targetRepoName);
     if (!targetRepo) {
-      p7.log.error(`Repo "${targetRepoName}" not found in config. Available: ${config.repos.map((r) => r.name).join(", ")}`);
+      p8.log.error(`Repo "${targetRepoName}" not found in config. Available: ${config.repos.map((r) => r.name).join(", ")}`);
       process.exit(1);
     }
     reposToAnalyze = [targetRepo];
@@ -3980,13 +4062,13 @@ async function generateCommand(options) {
       const cached = loadCache(cacheDir, repo.name);
       if (cached) {
         cachedResults.push(cached.result);
-        p7.log.info(`Using cached analysis for ${repo.name}`);
+        p8.log.info(`Using cached analysis for ${repo.name}`);
       } else {
-        p7.log.warn(`No cached analysis for ${repo.name} \u2014 its docs will be stale until it pushes`);
+        p8.log.warn(`No cached analysis for ${repo.name} \u2014 its docs will be stale until it pushes`);
       }
     }
   }
-  const cloneSpinner = p7.spinner();
+  const cloneSpinner = p8.spinner();
   cloneSpinner.start(`Cloning ${reposToAnalyze.length} ${reposToAnalyze.length === 1 ? "repository" : "repositories"}...`);
   const clones = [];
   for (const repo of reposToAnalyze) {
@@ -4005,12 +4087,12 @@ async function generateCommand(options) {
       );
       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}/${reposToAnalyze.length} ${reposToAnalyze.length === 1 ? "repository" : "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;
@@ -4085,7 +4167,7 @@ async function generateCommand(options) {
     } 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 };
     }
   });
@@ -4093,14 +4175,14 @@ 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();
-  p7.log.step(
+  p8.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 = p7.spinner();
+      const crossSpinner = p8.spinner();
       crossSpinner.start("Analyzing cross-repository relationships...");
       try {
         crossRepo = await analyzeCrossRepos(results, apiKey, model, (text4) => {
@@ -4109,66 +4191,66 @@ async function generateCommand(options) {
         crossSpinner.stop(`Cross-repo analysis complete \u2014 ${crossRepo.repoRelationships.length} relationships found`);
       } catch (err) {
         crossSpinner.stop("Cross-repo analysis failed (non-fatal)");
-        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 contentDir = path10.join(config.outputDir, "content", "docs");
+    const contentDir = path11.join(config.outputDir, "content", "docs");
     await writeContent(contentDir, results, crossRepo, changelogs.size > 0 ? changelogs : void 0);
     await writeMeta(contentDir, results, crossRepo, changelogs.size > 0 ? changelogs : void 0);
     try {
       await runBuildCheck({ docsDir: config.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 regenerated!");
+    p8.log.success("Documentation regenerated!");
   }
   for (const clone of clones) {
     cleanupClone(clone);
   }
-  p7.outro("Done!");
+  p8.outro("Done!");
 }
 
 // src/commands/deploy.ts
-import * as p8 from "@clack/prompts";
-import fs10 from "fs";
-import path11 from "path";
+import * as p9 from "@clack/prompts";
+import fs11 from "fs";
+import path12 from "path";
 function resolveDocsDir(config, dirOption) {
   if (dirOption) {
-    const resolved = path11.resolve(dirOption);
-    if (!fs10.existsSync(resolved)) {
-      p8.log.error(`Directory not found: ${resolved}`);
+    const resolved = path12.resolve(dirOption);
+    if (!fs11.existsSync(resolved)) {
+      p9.log.error(`Directory not found: ${resolved}`);
       process.exit(1);
     }
     return resolved;
   }
-  if (config?.outputDir && fs10.existsSync(path11.resolve(config.outputDir))) {
-    return path11.resolve(config.outputDir);
+  if (config?.outputDir && fs11.existsSync(path12.resolve(config.outputDir))) {
+    return path12.resolve(config.outputDir);
   }
-  if (fs10.existsSync(path11.resolve("docs-site"))) {
-    return path11.resolve("docs-site");
+  if (fs11.existsSync(path12.resolve("docs-site"))) {
+    return path12.resolve("docs-site");
   }
-  p8.log.error(
+  p9.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) {
-  p8.intro("open-auto-doc \u2014 Deploy docs to GitHub");
+  p9.intro("open-auto-doc \u2014 Deploy docs to GitHub");
   const token = getGithubToken();
   if (!token) {
-    p8.log.error("Not authenticated. Run `open-auto-doc login` first.");
+    p9.log.error("Not authenticated. Run `open-auto-doc login` first.");
     process.exit(1);
   }
   const config = loadConfig();
   const docsDir = resolveDocsDir(config, options.dir);
-  p8.log.info(`Docs directory: ${docsDir}`);
+  p9.log.info(`Docs directory: ${docsDir}`);
   if (config?.docsRepo) {
-    p8.log.info(`Docs repo already configured: ${config.docsRepo}`);
+    p9.log.info(`Docs repo already configured: ${config.docsRepo}`);
     const pushed = await pushUpdates({ token, docsDir, docsRepo: config.docsRepo });
     if (pushed) {
-      p8.outro("Docs updated! Vercel will auto-deploy from the push.");
+      p9.outro("Docs updated! Vercel will auto-deploy from the push.");
     } else {
-      p8.outro("Docs are up to date!");
+      p9.outro("Docs are up to date!");
     }
     return;
   }
@@ -4178,20 +4260,20 @@ async function deployCommand(options) {
     config: config || { repos: [], outputDir: docsDir }
   });
   if (!result) {
-    p8.cancel("Deploy cancelled.");
+    p9.cancel("Deploy cancelled.");
     process.exit(0);
   }
   showVercelInstructions(result.owner, result.repoName);
-  p8.outro(`Docs repo: https://github.com/${result.owner}/${result.repoName}`);
+  p9.outro(`Docs repo: https://github.com/${result.owner}/${result.repoName}`);
 }
 
 // src/commands/setup-ci.ts
-import * as p9 from "@clack/prompts";
+import * as p10 from "@clack/prompts";
 async function setupCiCommand() {
-  p9.intro("open-auto-doc \u2014 CI/CD Setup");
+  p10.intro("open-auto-doc \u2014 CI/CD Setup");
   const config = loadConfig();
   if (!config?.docsRepo) {
-    p9.log.error(
+    p10.log.error(
       "No docs repo configured. Run `open-auto-doc deploy` first to create a docs GitHub repo."
     );
     process.exit(1);
@@ -4199,12 +4281,12 @@ async function setupCiCommand() {
   const token = getGithubToken();
   const isMultiRepo = config.repos.length > 1;
   if (isMultiRepo && !token) {
-    p9.log.error("Not authenticated. Run `open-auto-doc login` first (needed to push workflows to source repos).");
+    p10.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) {
-    p9.log.error("Not in a git repository. Run this command from your project root.");
+    p10.log.error("Not in a git repository. Run this command from your project root.");
     process.exit(1);
   }
   const result = await createCiWorkflow({
@@ -4215,50 +4297,51 @@ async function setupCiCommand() {
     config
   });
   if (!result) {
-    p9.cancel("Setup cancelled.");
+    p10.cancel("Setup cancelled.");
     process.exit(0);
   }
   if ("repos" in result) {
-    p9.outro("Per-repo CI workflows created! Add the required secrets to each source repo.");
+    p10.outro("Per-repo CI workflows created! Add the required secrets to each source repo.");
   } else {
-    p9.outro("CI/CD workflow is ready! Commit and push to activate.");
+    p10.outro("CI/CD workflow is ready! Commit and push to activate.");
   }
 }
 
 // src/commands/login.ts
-import * as p10 from "@clack/prompts";
+import * as p11 from "@clack/prompts";
 async function loginCommand() {
-  p10.intro("open-auto-doc \u2014 GitHub Login");
+  p11.intro("open-auto-doc \u2014 GitHub Login");
   const existing = getGithubToken();
   if (existing) {
-    const overwrite = await p10.confirm({
+    const overwrite = await p11.confirm({
       message: "You're already logged in. Re-authenticate?"
     });
-    if (!overwrite || p10.isCancel(overwrite)) {
-      p10.cancel("Keeping existing credentials");
+    if (!overwrite || p11.isCancel(overwrite)) {
+      p11.cancel("Keeping existing credentials");
       return;
     }
   }
   const token = await authenticateWithGithub();
   setGithubToken(token);
-  p10.outro("Logged in successfully!");
+  p11.outro("Logged in successfully!");
 }
 
 // src/commands/logout.ts
-import * as p11 from "@clack/prompts";
+import * as p12 from "@clack/prompts";
 async function logoutCommand() {
-  p11.intro("open-auto-doc \u2014 Logout");
+  p12.intro("open-auto-doc \u2014 Logout");
   clearAll();
-  p11.outro("Credentials cleared. You've been logged out.");
+  p12.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.4.1");
+program.name("open-auto-doc").description("Auto-generate beautiful documentation websites from GitHub repositories using AI").version("0.5.0");
 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);
 program.command("setup-ci").description("Generate a GitHub Actions workflow for auto-updating docs").action(setupCiCommand);
+program.command("setup-mcp").description("Set up MCP server so Claude Code can query your docs").action(setupMcpCommand);
 program.command("login").description("Authenticate with GitHub").action(loginCommand);
 program.command("logout").description("Clear stored credentials").action(logoutCommand);
 program.parse();

package/package.json

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