@chappibunny/repolens 1.9.12 → 1.11.0

package/CHANGELOG.md

@@ -2,6 +2,86 @@
 
 All notable changes to RepoLens will be documented in this file.
 
+## 1.11.0
+
+### 🧙 Smart URL Parsing in Wizard
+
+The init wizard now intelligently parses URLs you paste, automatically extracting the right values:
+
+**Confluence:**
+- Paste a full page URL → wizard extracts base URL, space key, AND page ID
+- No more confusion between base URL vs page URL
+- Space key clearly explained (examples: `DOCS`, `ENG`, `~username` for personal)
+- Validates credentials immediately by testing connection to your space
+
+**Notion:**
+- Paste a full Notion page URL → wizard extracts the 32-char page ID automatically
+- Tests connection immediately and confirms your integration has access
+- Clear step-by-step instructions with browser auto-open for integrations page
+
+### 🌐 Multi-Language Scan Presets
+
+The wizard now supports **8 language/framework presets**:
+
+| # | Preset | Languages | Best For |
+|---|--------|-----------|----------|
+| 1 | **Universal** | All (JS, TS, Python, Go, Rust, Java, Ruby, PHP, C#, Swift, Kotlin, Scala, Vue, Svelte) | Polyglot projects |
+| 2 | Next.js / React | TypeScript, JavaScript | React frontends |
+| 3 | Express / Node.js | TypeScript, JavaScript | Node.js backends |
+| 4 | **Python** | Python | Django, Flask, FastAPI |
+| 5 | **Go** | Go | Standard Go layout |
+| 6 | **Rust** | Rust | Cargo projects |
+| 7 | **Java/Kotlin/Scala** | JVM languages | Maven/Gradle |
+| 8 | JavaScript/TypeScript | JS/TS only | Legacy JS projects |
+
+**Universal is now the default** — no more "0 modules detected" because of language mismatch!
+
+### 🔐 Critical .env Reminder
+
+After collecting credentials, the wizard now prominently displays:
+```
+┌────────────────────────────────────────────────────────────┐
+│ IMPORTANT: Your credentials are in .env but not loaded yet │
+│ Run this BEFORE 'repolens publish':                         │
+│                                                              │
+│   source .env                                               │
+└────────────────────────────────────────────────────────────┘
+```
+
+### 🧪 New Tests
+
+- 13 new tests for URL parsing functions (`parseConfluenceUrl`, `parseNotionInput`)
+- Total: 393 tests passing
+
+## 1.10.0
+
+### ✨ Interactive Init is Now Default
+
+- **`repolens init` is now fully interactive**: No more `--interactive` flag needed — the wizard runs by default
+- **Use `--quick` to skip the wizard**: For CI or minimal scaffolding, use `repolens init --quick`
+- **Comprehensive wizard**: Configures ALL publishers (Notion, Confluence, GitHub Wiki), not just Notion
+  - Collects credentials for each selected publisher
+  - Guides AI provider selection with environment validation
+  - Discord webhook configuration
+  - Branch filtering for Notion/Confluence publishing
+  - Shows clear summary of GitHub Actions secrets needed
+- **Credentials written to `.env`**: All collected credentials are saved locally (gitignored)
+- **Better validation**: Shows specific status for each credential (✓ set vs ○ needed)
+
+### 🤖 AI Setup from CLI
+
+- **Browser auto-open**: Wizard offers to open API key signup pages (OpenAI, Anthropic, Google) in your browser
+- **API key validation**: Tests your AI key immediately after you paste it — confirms it works before saving
+- **GitHub Token testing**: Validates existing `GITHUB_TOKEN` works with GitHub Models
+- **Clear feedback**: Shows ✓ valid / ⚠ invalid with specific error messages
+- **Writes all config**: `.env` now includes `REPOLENS_AI_ENABLED=true` and `REPOLENS_AI_PROVIDER=...`
+
+### 🔧 AI Diagnostics
+
+- **Better error messages**: AI failures now show the actual reason (e.g., "Missing API key (expected REPOLENS_AI_API_KEY)")
+- **Config logging**: First AI call logs the provider, model, and key prefix being used
+- **Workflow template updated**: Default workflow now shows both GitHub Models (free) AND OpenAI options with clear comments
+
 ## 1.9.12
 
 ### 🐛 Bug Fixes
@@ -149,7 +229,7 @@ Users without AI API keys now get production-quality documentation instead of sp
 - **Zero-config AI in CI**: When `ai.provider: github` is set in `.repolens.yml`, RepoLens uses the default `GITHUB_TOKEN` injected by GitHub Actions. No secrets to create or manage.
 - **Config-driven AI settings**: `ai.enabled`, `ai.provider`, `ai.model`, `ai.temperature`, and `ai.base_url` in `.repolens.yml` are now fully respected at runtime (env vars still take precedence). Previously these config values were ignored.
 - **Init wizard fixes**: Provider selection now uses correct runtime values (`github`, `openai_compatible`, `anthropic`, `google`) instead of mismatched labels. The wizard now emits `ai.provider` to the generated YAML. Added `github_wiki` to publisher choices.
-- **Demo AI upsell**: `repolens demo` now shows a hint about GitHub Models (free) when AI is not enabled, guiding users to `repolens init --interactive`.
+- **Demo AI upsell**: `repolens demo` now shows a hint about GitHub Models (free) when AI is not enabled, guiding users to `repolens init`.
 - **Uninstall command**: `repolens uninstall` removes all RepoLens-generated files (`.repolens/`, `.repolens.yml`, workflow, `.env.example`, `README.repolens.md`) with confirmation prompt and `--force` flag.
 - **Doctor validation**: `repolens doctor` now checks for `GITHUB_TOKEN` when provider is `github`, and `REPOLENS_AI_API_KEY` for other providers.
 
@@ -449,7 +529,7 @@ RepoLens v1.0.0 marks the first stable release with a frozen public API. All CLI
 ## 0.7.0
 
 ### ✨ New Features
-- **Interactive Init Wizard**: `repolens init --interactive` — step-by-step configuration wizard with scan presets (Next.js, Express, generic), publisher selection, AI provider setup, and branch filtering
+- **Interactive Init Wizard**: `repolens init` — step-by-step configuration wizard with scan presets (Next.js, Express, generic), publisher selection, AI provider setup, and branch filtering (now default behavior; use `--quick` to skip)
 - **Watch Mode**: `repolens watch` — watches source directories for changes and regenerates Markdown docs with 500ms debounce (no API calls)
 - **Enhanced Error Messages**: Centralized error catalog with actionable guidance — every error now shows what went wrong, why, and how to fix it
 - **Performance Monitoring**: Scan, render, and publish timing summary printed after every `publish` run

package/README.md

@@ -165,8 +165,8 @@ Step-by-step setup for publishers, AI features, Notion, Confluence, GitHub Wiki,
 
 | Command | Description |
 |---|---|
-| `npx @chappibunny/repolens init` | Scaffold config + GitHub Actions workflow |
-| `npx @chappibunny/repolens init --interactive` | Step-by-step configuration wizard |
+| `npx @chappibunny/repolens init` | **Interactive wizard** — configure publishers, AI, credentials |
+| `npx @chappibunny/repolens init --quick` | Minimal setup, skip wizard |
 | `npx @chappibunny/repolens publish` | Scan, generate, and publish documentation |
 | `npx @chappibunny/repolens demo` | Quick local preview — no API keys needed |
 | `npx @chappibunny/repolens doctor` | Validate your setup |

package/docs/ROADMAP.md

@@ -56,7 +56,7 @@ Everything below is live, tested, and available on npm.
 - ✅ User feedback via `repolens feedback` command
 
 ### Polish & Reliability (v0.7.0)
-- ✅ Interactive configuration wizard (`repolens init --interactive`)
+- ✅ Interactive configuration wizard (now default for `repolens init`)
 - ✅ Watch mode for local development (`repolens watch`)
 - ✅ Enhanced error messages with actionable guidance (centralized error catalog)
 - ✅ Performance monitoring (scan/render/publish timing summary)

package/docs/STABILITY.md

@@ -16,8 +16,8 @@ RepoLens follows semantic versioning (semver):
 
 | Command | Status | Description |
 |---------|--------|-------------|
-| `init` | Stable | Scaffold configuration and GitHub Actions workflow |
-| `init --interactive` | Stable | Step-by-step configuration wizard |
+| `init` | Stable | **Interactive wizard** — configure publishers, AI, credentials |
+| `init --quick` | Stable | Minimal scaffolding, skip wizard |
 | `doctor` | Stable | Validate repository setup |
 | `publish` | Stable | Scan, generate, and publish documentation |
 | `demo` | Stable | Generate local docs without API keys (quick preview) |
@@ -33,7 +33,7 @@ RepoLens follows semantic versioning (semver):
 |--------|-------|--------|-------------|
 | `--config <path>` | — | Stable | Path to `.repolens.yml` |
 | `--target <path>` | — | Stable | Target repository path (init, doctor, migrate) |
-| `--interactive` | — | Stable | Interactive mode for init |
+| `--quick` | — | Stable | Skip interactive wizard for init |
 | `--dry-run` | — | Stable | Preview changes without applying (migrate) |
 | `--force` | — | Stable | Skip confirmation prompts (migrate) |
 | `--verbose` | — | Stable | Enable verbose logging |

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@chappibunny/repolens",
-  "version": "1.9.12",
+  "version": "1.11.0",
   "description": "AI-assisted documentation intelligence system for technical and non-technical audiences",
   "license": "MIT",
   "type": "module",

package/src/ai/generate-sections.js

@@ -63,7 +63,7 @@ async function generateWithStructuredFallback(key, promptText, maxTokens, fallba
       if (md) return sanitizeAIOutput(md);
     }
     // If structured mode failed, fall through to plain-text
-    warn(`Structured AI failed for ${key}, trying plain-text mode...`);
+    warn(`Structured AI failed for ${key}: ${result.error || "invalid/empty response"}`);
   }
 
   // Plain-text AI fallback
@@ -76,7 +76,7 @@ async function generateWithStructuredFallback(key, promptText, maxTokens, fallba
   });
 
   if (!result.success) {
-    warn("AI generation failed, using fallback");
+    warn(`AI generation failed: ${result.error || "unknown error"}`);
     return fallbackFn();
   }
 

package/src/ai/provider.js

@@ -33,6 +33,9 @@ const AI_PRESETS = {
   },
 };
 
+// Module-level flag to log config only once
+let hasLoggedConfig = false;
+
 export async function generateText({ system, user, temperature, maxTokens, config, jsonMode, jsonSchema }) {
   // Check if AI is enabled (env var takes precedence, then config)
   const aiConfig = config?.ai || {};
@@ -69,14 +72,22 @@ export async function generateText({ system, user, temperature, maxTokens, confi
   
   // Validate configuration
   if (!apiKey) {
-    warn("REPOLENS_AI_API_KEY not set. AI features disabled.");
+    const keySource = provider === "github" ? "GITHUB_TOKEN or REPOLENS_AI_API_KEY" : "REPOLENS_AI_API_KEY";
+    warn(`AI: No API key found. Expected ${keySource} in environment.`);
     return {
       success: false,
-      error: "Missing API key",
+      error: `Missing API key (expected ${keySource})`,
       fallback: true
     };
   }
   
+  // Log configuration once per run
+  if (!hasLoggedConfig) {
+    const keyPreview = apiKey.substring(0, 8) + "...";
+    info(`AI Config: provider=${provider}, model=${model}, key=${keyPreview}`);
+    hasLoggedConfig = true;
+  }
+  
   if (!baseUrl && provider === "openai_compatible") {
     warn("REPOLENS_AI_BASE_URL not set. Using OpenAI default.");
   }

package/src/cli.js

@@ -134,10 +134,8 @@ function showPostGenerationAINotice() {
   info(`${fmt.cyan("│")}   ${fmt.yellow("•")} Developer Onboarding — getting started guide for new hires  ${fmt.cyan("│")}`);
   info(`${fmt.cyan("│")}                                                                  ${fmt.cyan("│")}`);
   info(`${fmt.cyan("│")} ${fmt.boldGreen("🆓 Enable for FREE with GitHub Models:")}                          ${fmt.cyan("│")}`);
-  info(`${fmt.cyan("│")}   ${fmt.green("export GITHUB_TOKEN=<your-token>")}                            ${fmt.cyan("│")}`);
-  info(`${fmt.cyan("│")}   ${fmt.green("repolens demo")}                                               ${fmt.cyan("│")}`);
-  info(`${fmt.cyan("│")}                                                                  ${fmt.cyan("│")}`);
-  info(`${fmt.cyan("│")} Or run: ${fmt.brightCyan("repolens init --interactive")} → select GitHub Models      ${fmt.cyan("│")}`);
+  info(`${fmt.cyan("│")}   Run: ${fmt.brightCyan("repolens init")} → the wizard will guide you through setup  ${fmt.cyan("│")}`);
+  info(`${fmt.cyan("│")}   Or quick preview: ${fmt.green("export GITHUB_TOKEN=<your-token> && repolens demo")}  ${fmt.cyan("│")}`);  
   info(`${fmt.cyan("└──────────────────────────────────────────────────────────────────┘")}`);
 }
 
@@ -242,7 +240,7 @@ Commands:
 Options:
   --config        Path to .repolens.yml (auto-discovered if not provided)
   --target        Target repository path for init/doctor/migrate
-  --interactive   Run init with step-by-step configuration wizard
+  --quick         Run init with minimal prompts (skip wizard)
   --dry-run       Preview migration changes without applying them
   --force         Skip interactive confirmation for migration
   --verbose       Enable verbose logging
@@ -250,8 +248,8 @@ Options:
   --help          Show this help message
 
 Examples:
-  repolens init                                 # Quick setup with auto-detection
-  repolens init --interactive                   # Step-by-step wizard
+  repolens init                                 # Full interactive wizard (recommended)
+  repolens init --quick                         # Minimal setup, skip wizard
   repolens init --target /tmp/my-repo
   repolens doctor --target /tmp/my-repo
   repolens migrate                              # Migrate workflows in current directory
@@ -295,7 +293,9 @@ async function main() {
   if (command === "init") {
     await printBanner();
     const targetDir = getArg("--target") || process.cwd();
-    const interactive = process.argv.includes("--interactive");
+    // Interactive is now the default; use --quick for minimal scaffolding
+    const quick = process.argv.includes("--quick") || process.argv.includes("--non-interactive");
+    const interactive = !quick;
     info(`Initializing RepoLens in: ${targetDir}`);
     
     const timer = startTimer("init");
@@ -598,7 +598,7 @@ async function main() {
       
       if (aiResult.enabled && aiResult.wasPrompted) {
         info(`\n🤖 AI-enhanced docs were generated using ${fmt.boldGreen("GitHub Models (FREE)")}`);
-        info("   To keep AI enabled permanently, run: repolens init --interactive");
+        info("   To keep AI enabled permanently, run: repolens init");
       } else if (aiResult.noToken) {
         // No GITHUB_TOKEN - show instructions
         showPostGenerationAINotice();

package/src/init.js

@@ -1,17 +1,245 @@
 import fs from "node:fs/promises";
 import path from "node:path";
 import { createInterface } from "node:readline/promises";
+import { exec } from "node:child_process";
 import { info, warn } from "./utils/logger.js";
 
 const PUBLISHER_CHOICES = ["markdown", "notion", "confluence", "github_wiki"];
+
+// ============================================================================
+// URL PARSING HELPERS
+// ============================================================================
+
+/**
+ * Parse a Confluence URL and extract base URL, space key, and page ID.
+ * Handles various URL formats:
+ *   - Full page URL: https://company.atlassian.net/wiki/spaces/DOCS/pages/123456/Page+Title
+ *   - Space URL: https://company.atlassian.net/wiki/spaces/DOCS
+ *   - Base URL: https://company.atlassian.net/wiki
+ * Returns: { baseUrl, spaceKey, pageId, isFullUrl }
+ */
+function parseConfluenceUrl(input) {
+  if (!input) return { baseUrl: null, spaceKey: null, pageId: null, isFullUrl: false };
+  
+  input = input.trim();
+  
+  // Remove query params and hash
+  const cleanUrl = input.split("?")[0].split("#")[0];
+  
+  try {
+    const url = new URL(cleanUrl);
+    const pathParts = url.pathname.split("/").filter(Boolean);
+    
+    // Find '/wiki' position
+    const wikiIndex = pathParts.indexOf("wiki");
+    if (wikiIndex === -1) {
+      // No /wiki in path - might just be base domain
+      return { 
+        baseUrl: `${url.protocol}//${url.host}/wiki`, 
+        spaceKey: null, 
+        pageId: null, 
+        isFullUrl: false 
+      };
+    }
+    
+    const baseUrl = `${url.protocol}//${url.host}/wiki`;
+    let spaceKey = null;
+    let pageId = null;
+    
+    // Look for /spaces/SPACE_KEY pattern
+    const spacesIndex = pathParts.indexOf("spaces");
+    if (spacesIndex !== -1 && pathParts[spacesIndex + 1]) {
+      spaceKey = pathParts[spacesIndex + 1];
+    }
+    
+    // Look for /pages/PAGE_ID pattern
+    const pagesIndex = pathParts.indexOf("pages");
+    if (pagesIndex !== -1 && pathParts[pagesIndex + 1]) {
+      pageId = pathParts[pagesIndex + 1];
+    }
+    
+    return {
+      baseUrl,
+      spaceKey,
+      pageId,
+      isFullUrl: Boolean(spaceKey || pageId),
+    };
+  } catch {
+    // Not a valid URL - return as-is
+    return { baseUrl: input, spaceKey: null, pageId: null, isFullUrl: false };
+  }
+}
+
+/**
+ * Parse a Notion URL or page ID and extract the page ID.
+ * Handles various formats:
+ *   - Full URL: https://www.notion.so/workspace/Page-Title-abc123def456
+ *   - Short URL: https://notion.so/abc123def456
+ *   - Just the page ID: abc123def456 or abc123-def456-...
+ * Returns: { pageId, isUrl }
+ */
+function parseNotionInput(input) {
+  if (!input) return { pageId: null, isUrl: false };
+  
+  input = input.trim();
+  
+  // Check if it looks like a URL
+  if (input.includes("notion.so") || input.includes("notion.site")) {
+    try {
+      const url = new URL(input.startsWith("http") ? input : `https://${input}`);
+      const pathParts = url.pathname.split("/").filter(Boolean);
+      
+      // The last path segment typically contains the page ID
+      // Format: "Page-Title-abc123def456ghi789" - ID is the last 32 hex chars
+      const lastPart = pathParts[pathParts.length - 1] || "";
+      
+      // Try to extract the 32-char hex ID from the end
+      const idMatch = lastPart.match(/([a-f0-9]{32})$/i);
+      if (idMatch) {
+        return { pageId: idMatch[1], isUrl: true };
+      }
+      
+      // Try format with dashes: abc123-def456-...
+      const dashedMatch = lastPart.match(/([a-f0-9]{8}-[a-f0-9]{4}-[a-f0-9]{4}-[a-f0-9]{4}-[a-f0-9]{12})$/i);
+      if (dashedMatch) {
+        return { pageId: dashedMatch[1].replace(/-/g, ""), isUrl: true };
+      }
+      
+      // Last segment might be the ID directly
+      const cleanId = lastPart.replace(/-/g, "");
+      if (/^[a-f0-9]{32}$/i.test(cleanId)) {
+        return { pageId: cleanId, isUrl: true };
+      }
+      
+      return { pageId: null, isUrl: true };
+    } catch {
+      return { pageId: null, isUrl: false };
+    }
+  }
+  
+  // Not a URL - might be raw page ID
+  const cleanId = input.replace(/-/g, "");
+  if (/^[a-f0-9]{32}$/i.test(cleanId)) {
+    return { pageId: cleanId, isUrl: false };
+  }
+  
+  // Return as-is (might be invalid)
+  return { pageId: input, isUrl: false };
+}
+
+/**
+ * Test Confluence credentials by fetching space info.
+ */
+async function testConfluenceCredentials(url, email, apiToken, spaceKey) {
+  try {
+    const auth = Buffer.from(`${email}:${apiToken}`).toString("base64");
+    const endpoint = `${url}/rest/api/space/${spaceKey}`;
+    
+    const controller = new AbortController();
+    const timeoutId = setTimeout(() => controller.abort(), 10000);
+    
+    const response = await fetch(endpoint, {
+      method: "GET",
+      headers: {
+        "Authorization": `Basic ${auth}`,
+        "Accept": "application/json",
+      },
+      signal: controller.signal,
+    });
+    
+    clearTimeout(timeoutId);
+    
+    if (response.ok) {
+      const data = await response.json();
+      return { success: true, spaceName: data.name };
+    }
+    
+    if (response.status === 401) {
+      return { success: false, error: "Invalid email or API token" };
+    }
+    if (response.status === 404) {
+      return { success: false, error: `Space '${spaceKey}' not found` };
+    }
+    
+    return { success: false, error: `API error ${response.status}` };
+  } catch (err) {
+    if (err.name === "AbortError") {
+      return { success: false, error: "Connection timed out" };
+    }
+    return { success: false, error: err.message };
+  }
+}
+
+/**
+ * Test Notion credentials by fetching page info.
+ */
+async function testNotionCredentials(token, pageId) {
+  try {
+    const endpoint = `https://api.notion.com/v1/pages/${pageId}`;
+    
+    const controller = new AbortController();
+    const timeoutId = setTimeout(() => controller.abort(), 10000);
+    
+    const response = await fetch(endpoint, {
+      method: "GET",
+      headers: {
+        "Authorization": `Bearer ${token}`,
+        "Notion-Version": "2022-06-28",
+      },
+      signal: controller.signal,
+    });
+    
+    clearTimeout(timeoutId);
+    
+    if (response.ok) {
+      return { success: true };
+    }
+    
+    const errorBody = await response.json().catch(() => ({}));
+    
+    if (response.status === 401) {
+      return { success: false, error: "Invalid token" };
+    }
+    if (response.status === 404) {
+      return { success: false, error: "Page not found — make sure your integration has access to this page" };
+    }
+    if (errorBody.code === "object_not_found") {
+      return { success: false, error: "Page not found — share the page with your integration first" };
+    }
+    
+    return { success: false, error: `API error ${response.status}: ${errorBody.message || ""}` };
+  } catch (err) {
+    if (err.name === "AbortError") {
+      return { success: false, error: "Connection timed out" };
+    }
+    return { success: false, error: err.message };
+  }
+}
 const AI_PROVIDERS = [
-  { value: "github",           label: "GitHub Models  (free in GitHub Actions)" },
-  { value: "openai_compatible", label: "OpenAI / Compatible  (GPT-5, GPT-4o, etc.)" },
-  { value: "anthropic",         label: "Anthropic  (Claude)" },
-  { value: "google",            label: "Google  (Gemini)" },
+  { value: "github",            label: "GitHub Models  (free in GitHub Actions)", signupUrl: null },
+  { value: "openai_compatible", label: "OpenAI / Compatible  (GPT-5, GPT-4o, etc.)", signupUrl: "https://platform.openai.com/api-keys" },
+  { value: "anthropic",         label: "Anthropic  (Claude)", signupUrl: "https://console.anthropic.com/settings/keys" },
+  { value: "google",            label: "Google  (Gemini)", signupUrl: "https://aistudio.google.com/app/apikey" },
 ];
+
+// All file extensions we can analyze
+const ALL_EXTENSIONS = "js,ts,jsx,tsx,mjs,cjs,py,go,rs,java,rb,php,cs,swift,kt,scala,vue,svelte";
+
 const SCAN_PRESETS = {
+  // Universal preset - scans ALL supported languages
+  universal: {
+    label: "Universal (all languages)",
+    description: "Scans all supported file types — best for polyglot projects",
+    include: [
+      `**/*.{${ALL_EXTENSIONS}}`,
+    ],
+    roots: ["src", "lib", "app", "pkg", "internal", "cmd", "packages"],
+  },
+  
+  // JavaScript/TypeScript ecosystems
   nextjs: {
+    label: "Next.js / React",
+    description: "React, Next.js, and frontend TypeScript projects",
     include: [
       "src/**/*.{ts,tsx,js,jsx}",
       "app/**/*.{ts,tsx,js,jsx}",
@@ -22,20 +250,65 @@ const SCAN_PRESETS = {
     roots: ["src", "app", "pages", "lib", "components"],
   },
   express: {
+    label: "Express / Node.js",
+    description: "Node.js backend APIs and Express servers",
     include: [
-      "src/**/*.{ts,js}",
+      "src/**/*.{ts,js,mjs,cjs}",
       "routes/**/*.{ts,js}",
       "controllers/**/*.{ts,js}",
       "models/**/*.{ts,js}",
       "middleware/**/*.{ts,js}",
+      "services/**/*.{ts,js}",
+    ],
+    roots: ["src", "routes", "controllers", "models", "services"],
+  },
+  
+  // Python ecosystem
+  python: {
+    label: "Python",
+    description: "Django, Flask, FastAPI, and general Python projects",
+    include: [
+      "**/*.py",
+    ],
+    roots: ["src", "app", "lib", "api", "core", "services", "models", "views", "utils"],
+  },
+  
+  // Go ecosystem
+  golang: {
+    label: "Go",
+    description: "Go modules with standard layout",
+    include: [
+      "**/*.go",
+    ],
+    roots: ["cmd", "pkg", "internal", "api", "server", "handlers"],
+  },
+  
+  // Rust ecosystem
+  rust: {
+    label: "Rust",
+    description: "Cargo projects and Rust libraries",
+    include: [
+      "**/*.rs",
     ],
-    roots: ["src", "routes", "controllers", "models"],
+    roots: ["src", "lib", "bin", "examples"],
   },
+  
+  // Java/JVM ecosystem
+  java: {
+    label: "Java / Kotlin / Scala",
+    description: "JVM projects (Maven/Gradle)",
+    include: [
+      "**/*.{java,kt,scala}",
+    ],
+    roots: ["src/main/java", "src/main/kotlin", "src/main/scala", "app", "core", "service"],
+  },
+  
+  // Legacy "generic" preserved but improved
   generic: {
+    label: "JavaScript/TypeScript only",
+    description: "Traditional JS/TS projects",
     include: [
-      "src/**/*.{ts,tsx,js,jsx,md}",
-      "app/**/*.{ts,tsx,js,jsx,md}",
-      "lib/**/*.{ts,tsx,js,jsx,md}",
+      "**/*.{ts,tsx,js,jsx,mjs,cjs}",
     ],
     roots: ["src", "app", "lib"],
   },
@@ -89,10 +362,14 @@ jobs:
           CONFLUENCE_API_TOKEN: \${{ secrets.CONFLUENCE_API_TOKEN }}
           CONFLUENCE_SPACE_KEY: \${{ secrets.CONFLUENCE_SPACE_KEY }}
           CONFLUENCE_PARENT_PAGE_ID: \${{ secrets.CONFLUENCE_PARENT_PAGE_ID }}
-          # AI-enhanced docs via GitHub Models (free)
+          # AI-enhanced docs: Choose ONE option below
           REPOLENS_AI_ENABLED: true
+          # Option A: GitHub Models (free — uses GITHUB_TOKEN)
           REPOLENS_AI_PROVIDER: github
           GITHUB_TOKEN: \${{ secrets.GITHUB_TOKEN }}
+          # Option B: OpenAI / Anthropic / Google (comment out Option A, uncomment below)
+          # REPOLENS_AI_API_KEY: \${{ secrets.REPOLENS_AI_API_KEY }}
+          # REPOLENS_AI_PROVIDER: openai_compatible  # or: anthropic, google
         run: npx @chappibunny/repolens@latest publish
 `;
 
@@ -283,6 +560,117 @@ async function dirExists(dirPath) {
   }
 }
 
+/**
+ * Open a URL in the default browser (cross-platform).
+ */
+function openUrl(url) {
+  const platform = process.platform;
+  let cmd;
+  if (platform === "darwin") {
+    cmd = `open "${url}"`;
+  } else if (platform === "win32") {
+    cmd = `start "" "${url}"`;
+  } else {
+    cmd = `xdg-open "${url}"`;
+  }
+  return new Promise((resolve) => {
+    exec(cmd, (err) => {
+      if (err) {
+        warn(`Could not open browser: ${err.message}`);
+        resolve(false);
+      } else {
+        resolve(true);
+      }
+    });
+  });
+}
+
+/**
+ * Test an AI API key by making a minimal request.
+ * Returns { success: true } or { success: false, error: string }.
+ */
+async function testAIKey(provider, apiKey) {
+  try {
+    const timeout = 15000;
+    const controller = new AbortController();
+    const timeoutId = setTimeout(() => controller.abort(), timeout);
+
+    let url, headers, body;
+
+    if (provider === "github") {
+      url = "https://models.inference.ai.azure.com/chat/completions";
+      headers = {
+        "Content-Type": "application/json",
+        "Authorization": `Bearer ${apiKey}`,
+      };
+      body = JSON.stringify({
+        model: "gpt-4o-mini",
+        messages: [{ role: "user", content: "Say OK" }],
+        max_tokens: 5,
+      });
+    } else if (provider === "openai_compatible") {
+      url = "https://api.openai.com/v1/chat/completions";
+      headers = {
+        "Content-Type": "application/json",
+        "Authorization": `Bearer ${apiKey}`,
+      };
+      body = JSON.stringify({
+        model: "gpt-4o-mini",
+        messages: [{ role: "user", content: "Say OK" }],
+        max_tokens: 5,
+      });
+    } else if (provider === "anthropic") {
+      url = "https://api.anthropic.com/v1/messages";
+      headers = {
+        "Content-Type": "application/json",
+        "x-api-key": apiKey,
+        "anthropic-version": "2023-06-01",
+      };
+      body = JSON.stringify({
+        model: "claude-sonnet-4-20250514",
+        max_tokens: 5,
+        messages: [{ role: "user", content: "Say OK" }],
+      });
+    } else if (provider === "google") {
+      url = `https://generativelanguage.googleapis.com/v1beta/models/gemini-2.0-flash:generateContent?key=${apiKey}`;
+      headers = { "Content-Type": "application/json" };
+      body = JSON.stringify({
+        contents: [{ parts: [{ text: "Say OK" }] }],
+        generationConfig: { maxOutputTokens: 5 },
+      });
+    } else {
+      return { success: false, error: "Unknown provider" };
+    }
+
+    const response = await fetch(url, {
+      method: "POST",
+      headers,
+      body,
+      signal: controller.signal,
+    });
+
+    clearTimeout(timeoutId);
+
+    if (response.ok) {
+      return { success: true };
+    }
+
+    const errorBody = await response.text().catch(() => "");
+    if (response.status === 401 || response.status === 403) {
+      return { success: false, error: "Invalid API key" };
+    }
+    if (response.status === 429) {
+      return { success: false, error: "Rate limited — but key is valid" };
+    }
+    return { success: false, error: `API error ${response.status}: ${errorBody.slice(0, 100)}` };
+  } catch (err) {
+    if (err.name === "AbortError") {
+      return { success: false, error: "Request timed out" };
+    }
+    return { success: false, error: err.message };
+  }
+}
+
 async function detectRepoStructure(repoRoot) {
   const detectedRoots = [];
 
@@ -482,7 +870,8 @@ async function promptNotionCredentials() {
   });
 
   try {
-    info("\n📝 Notion Setup (optional)");
+    info("\n📝 Quick Setup — Notion Publishing");
+    info("(Use 'repolens init' without --quick for full wizard)\n");
     const useNotion = await rl.question("Would you like to publish to Notion? (Y/n): ");
 
     if (useNotion.toLowerCase() === 'n') {
@@ -564,15 +953,20 @@ async function runInteractiveWizard(repoRoot) {
 
   try {
     info("\n🧙 Interactive Configuration Wizard\n");
+    info("This wizard will help you configure RepoLens for your project.");
+    info("Press Enter to accept defaults shown in parentheses.\n");
 
     // 1. Project name
     const defaultName = path.basename(repoRoot) || "my-project";
-    const projectName = (await ask(`Project name (${defaultName}): `)).trim() || defaultName;
+    const projectName = (await ask(`📦 Project name (${defaultName}): `)).trim() || defaultName;
 
     // 2. Publishers
-    info("\nSelect publishers (comma-separated numbers):");
-    PUBLISHER_CHOICES.forEach((p, i) => info(`  ${i + 1}. ${p}`));
-    const pubInput = (await ask(`Publishers [1,2,3] (default: 1): `)).trim() || "1";
+    info("\n📤 Select publishers (comma-separated numbers):");
+    PUBLISHER_CHOICES.forEach((p, i) => {
+      const desc = PUBLISHER_DESCRIPTIONS[p] || "";
+      info(`  ${i + 1}. ${p}${desc ? ` — ${desc}` : ""}`);
+    });
+    const pubInput = (await ask(`Publishers [1] (default: 1 markdown): `)).trim() || "1";
     const publishers = pubInput
       .split(",")
       .map((n) => parseInt(n.trim(), 10))
@@ -580,45 +974,388 @@ async function runInteractiveWizard(repoRoot) {
       .map((n) => PUBLISHER_CHOICES[n - 1]);
     if (publishers.length === 0) publishers.push("markdown");
 
-    // 3. AI
-    const enableAi = (await ask("\nEnable AI-enhanced documentation? (y/N): ")).trim().toLowerCase() === "y";
+    // 3. Collect credentials for each publisher
+    const credentials = {};
+    const githubSecretsNeeded = [];
+
+    // Notion setup
+    if (publishers.includes("notion")) {
+      info("\n📝 Notion Setup");
+      info("   ┌────────────────────────────────────────────────────────────┐");
+      info("   │ Step 1: Get your Integration Token                          │");
+      info("   │   → https://www.notion.so/my-integrations                   │");
+      info("   │   → Create new integration → Copy 'Internal Integration Token'│");
+      info("   │                                                              │");
+      info("   │ Step 2: Share your page with the integration                │");
+      info("   │   → Open the page in Notion                                  │");
+      info("   │   → Click '...' → 'Add connections' → Select your integration│");
+      info("   └────────────────────────────────────────────────────────────┘");
+      
+      const setupNow = (await ask("\n   Configure Notion credentials now? (Y/n): ")).trim().toLowerCase();
+      if (setupNow !== "n") {
+        // Token first
+        const openNotionPage = (await ask("   Open Notion integrations page in browser? (Y/n): ")).trim().toLowerCase();
+        if (openNotionPage !== "n") {
+          await openUrl("https://www.notion.so/my-integrations");
+          info("   Opening browser... Create or copy your integration token.\n");
+        }
+        
+        const token = (await ask("   NOTION_TOKEN (paste your secret_... token): ")).trim();
+        
+        if (!token) {
+          warn("   No token provided. Skipping Notion setup.");
+        } else {
+          // Page ID - accept URL or ID
+          info("\n   Now paste either:");
+          info("   • The full Notion page URL, OR");
+          info("   • Just the 32-character page ID\n");
+          const pageInput = (await ask("   NOTION_PARENT_PAGE_ID (URL or ID): ")).trim();
+          
+          const { pageId, isUrl } = parseNotionInput(pageInput);
+          
+          if (!pageId) {
+            warn("   Could not extract page ID from input. Please enter the 32-char ID directly.");
+            const retryId = (await ask("   Page ID: ")).trim();
+            if (retryId) {
+              const retryParsed = parseNotionInput(retryId);
+              if (retryParsed.pageId) {
+                credentials.notion = { token, parentPageId: retryParsed.pageId };
+              }
+            }
+          } else {
+            if (isUrl) {
+              info(`   ✓ Extracted page ID: ${pageId}`);
+            }
+            
+            // Test credentials
+            info("   Testing Notion connection...");
+            const testResult = await testNotionCredentials(token, pageId);
+            
+            if (testResult.success) {
+              info("   ✓ Connection successful! Your integration can access this page.");
+              credentials.notion = { token, parentPageId: pageId };
+            } else {
+              warn(`   ⚠ Connection failed: ${testResult.error}`);
+              info("   Common fixes:");
+              info("   • Make sure you shared the page with your integration");
+              info("   • Check that the token is correct (starts with 'secret_')");
+              const saveAnyway = (await ask("   Save credentials anyway? (y/N): ")).trim().toLowerCase();
+              if (saveAnyway === "y") {
+                credentials.notion = { token, parentPageId: pageId };
+                info("   ✓ Credentials saved (verify manually later)");
+              } else {
+                warn("   Skipping Notion setup. Configure manually later.");
+              }
+            }
+          }
+        }
+      }
+      githubSecretsNeeded.push("NOTION_TOKEN", "NOTION_PARENT_PAGE_ID");
+    }
+
+    // Confluence setup
+    if (publishers.includes("confluence")) {
+      info("\n📝 Confluence Setup");
+      info("   ┌────────────────────────────────────────────────────────────┐");
+      info("   │ You'll need:                                                │");
+      info("   │  • Base URL (e.g., https://company.atlassian.net/wiki)      │");
+      info("   │  • Email address for your Atlassian account                 │");
+      info("   │  • API token from: id.atlassian.com/manage-profile/security │");
+      info("   │  • Space key (e.g., DOCS, ENG, ~username for personal)      │");
+      info("   └────────────────────────────────────────────────────────────┘");
+      
+      const setupNow = (await ask("\n   Configure Confluence credentials now? (Y/n): ")).trim().toLowerCase();
+      if (setupNow !== "n") {
+        // Open API token page
+        const openAtlassian = (await ask("   Open Atlassian API token page in browser? (Y/n): ")).trim().toLowerCase();
+        if (openAtlassian !== "n") {
+          await openUrl("https://id.atlassian.com/manage-profile/security/api-tokens");
+          info("   Opening browser... Create an API token and copy it.\n");
+        }
+        
+        // Ask for URL first - it can contain space key and page ID
+        info("\n   Paste either:");
+        info("   • A full Confluence page URL (we'll extract the details), OR");
+        info("   • Just the base URL (e.g., https://company.atlassian.net/wiki)\n");
+        
+        const urlInput = (await ask("   CONFLUENCE_URL: ")).trim();
+        const parsed = parseConfluenceUrl(urlInput);
+        
+        let baseUrl = parsed.baseUrl;
+        let spaceKey = parsed.spaceKey;
+        let pageId = parsed.pageId;
+        
+        if (parsed.isFullUrl) {
+          info(`   ✓ Detected full URL! Extracted:`);
+          info(`     • Base URL: ${baseUrl}`);
+          if (spaceKey) info(`     • Space Key: ${spaceKey}`);
+          if (pageId) info(`     • Page ID: ${pageId}`);
+          
+          // Confirm extracted base URL
+          const confirmBase = (await ask(`\n   Use '${baseUrl}' as base URL? (Y/n): `)).trim().toLowerCase();
+          if (confirmBase === "n") {
+            baseUrl = (await ask("   Enter base URL: ")).trim();
+          }
+        } else if (!baseUrl || !baseUrl.includes("/wiki")) {
+          warn("   URL should include /wiki (e.g., https://company.atlassian.net/wiki)");
+          baseUrl = (await ask("   Enter base URL (with /wiki): ")).trim();
+        }
+        
+        // Email
+        const email = (await ask("   CONFLUENCE_EMAIL (your Atlassian email): ")).trim();
+        
+        // API Token
+        const apiToken = (await ask("   CONFLUENCE_API_TOKEN (paste from Atlassian): ")).trim();
+        
+        // Space Key - use extracted or ask
+        if (spaceKey) {
+          const confirmSpace = (await ask(`\n   Use space key '${spaceKey}'? (Y/n): `)).trim().toLowerCase();
+          if (confirmSpace === "n") {
+            info("   Space key examples: DOCS, ENG, DEV, ~username (personal)");
+            spaceKey = (await ask("   CONFLUENCE_SPACE_KEY: ")).trim();
+          }
+        } else {
+          info("\n   Space key is in the URL: /wiki/spaces/SPACE_KEY/...");
+          info("   Examples: DOCS, ENG, DEV, ~username (for personal spaces)");
+          spaceKey = (await ask("   CONFLUENCE_SPACE_KEY: ")).trim();
+        }
+        
+        // Page ID - use extracted or ask
+        if (pageId) {
+          const confirmPage = (await ask(`   Use page ID '${pageId}' as parent? (Y/n): `)).trim().toLowerCase();
+          if (confirmPage === "n") {
+            pageId = (await ask("   CONFLUENCE_PARENT_PAGE_ID (optional, press Enter to skip): ")).trim() || null;
+          }
+        } else {
+          info("\n   Parent page ID is in the URL: /wiki/spaces/.../pages/PAGE_ID/...");
+          info("   (Optional - leave blank to publish at space root)");
+          pageId = (await ask("   CONFLUENCE_PARENT_PAGE_ID: ")).trim() || null;
+        }
+        
+        // Validate required fields
+        if (!baseUrl || !email || !apiToken || !spaceKey) {
+          warn("   Missing required fields. Skipping Confluence setup.");
+        } else {
+          // Test connection
+          info("\n   Testing Confluence connection...");
+          const testResult = await testConfluenceCredentials(baseUrl, email, apiToken, spaceKey);
+          
+          if (testResult.success) {
+            info(`   ✓ Connection successful! Found space: "${testResult.spaceName}"`);
+            credentials.confluence = { url: baseUrl, email, apiToken, spaceKey, parentPageId: pageId };
+          } else {
+            warn(`   ⚠ Connection failed: ${testResult.error}`);
+            info("   Common issues:");
+            info("   • API token is for your Atlassian account (not Confluence)");
+            info("   • Space key is case-sensitive (check URL)");
+            info("   • Make sure you have access to the space");
+            const saveAnyway = (await ask("   Save credentials anyway? (y/N): ")).trim().toLowerCase();
+            if (saveAnyway === "y") {
+              credentials.confluence = { url: baseUrl, email, apiToken, spaceKey, parentPageId: pageId };
+              info("   ✓ Credentials saved (verify manually later)");
+            } else {
+              warn("   Skipping Confluence setup. Configure manually later.");
+            }
+          }
+        }
+      }
+      githubSecretsNeeded.push("CONFLUENCE_URL", "CONFLUENCE_EMAIL", "CONFLUENCE_API_TOKEN", "CONFLUENCE_SPACE_KEY", "CONFLUENCE_PARENT_PAGE_ID");
+    }
+
+    // GitHub Wiki setup
+    if (publishers.includes("github_wiki")) {
+      info("\n📝 GitHub Wiki Setup");
+      info("   Requires GITHUB_TOKEN with repo scope.");
+      if (process.env.GITHUB_TOKEN) {
+        info("   ✓ GITHUB_TOKEN is set in your environment");
+      } else {
+        warn("   GITHUB_TOKEN not found in environment.");
+        info("   For local use: export GITHUB_TOKEN=your_token");
+        info("   For GitHub Actions: Uses ${{ secrets.GITHUB_TOKEN }} automatically");
+      }
+      githubSecretsNeeded.push("GITHUB_TOKEN");
+    }
+
+    // 4. AI Configuration
+    info("\n🤖 AI-Enhanced Documentation");
+    info("   Adds natural language explanations for non-technical stakeholders.");
+    const enableAi = (await ask("   Enable AI features? (Y/n): ")).trim().toLowerCase() !== "n";
+    
     let aiProvider = null;
+    let aiApiKey = null;
+    
     if (enableAi) {
-      info("Select AI provider:");
-      AI_PROVIDERS.forEach((p, i) => info(`  ${i + 1}. ${p.label}`));
-      const aiInput = (await ask(`Provider [1] (default: 1 GitHub Models — free): `)).trim() || "1";
+      info("\n   Select AI provider:");
+      AI_PROVIDERS.forEach((p, i) => info(`     ${i + 1}. ${p.label}`));
+      const aiInput = (await ask(`   Provider [1] (default: 1 GitHub Models — free): `)).trim() || "1";
       const idx = parseInt(aiInput, 10);
       const chosen = AI_PROVIDERS[(idx >= 1 && idx <= AI_PROVIDERS.length) ? idx - 1 : 0];
       aiProvider = chosen.value;
+      
       if (aiProvider === "github") {
-        info("\n  ✨ Great choice! GitHub Models uses your existing GITHUB_TOKEN — no extra API key needed.");
-        info("     Works automatically in GitHub Actions with the free tier.");
+        info("\n   ✨ GitHub Models is free and uses your GITHUB_TOKEN.");
+        
+        // Check for existing token
+        const existingToken = process.env.GITHUB_TOKEN;
+        if (existingToken) {
+          info("   Testing your GITHUB_TOKEN...");
+          const testResult = await testAIKey("github", existingToken);
+          if (testResult.success) {
+            info("   ✓ GITHUB_TOKEN is valid — AI will work locally and in Actions");
+            credentials.ai = { provider: "github", useGitHubToken: true };
+          } else {
+            warn(`   ⚠ GITHUB_TOKEN test failed: ${testResult.error}`);
+            info("   AI will still work in GitHub Actions with ${{ secrets.GITHUB_TOKEN }}");
+          }
+        } else {
+          info("   No GITHUB_TOKEN found in environment.");
+          info("   In GitHub Actions: Works automatically with ${{ secrets.GITHUB_TOKEN }}");
+          info("   For local testing: export GITHUB_TOKEN=your_personal_access_token");
+        }
+        githubSecretsNeeded.push("GITHUB_TOKEN");
+        credentials.ai = { ...(credentials.ai || {}), provider: "github", enabled: true };
+      } else {
+        // Non-GitHub provider: help them get an API key
+        info(`\n   ${chosen.label} requires an API key.`);
+        
+        // Offer to open signup URL
+        if (chosen.signupUrl) {
+          const openBrowser = (await ask(`   Open ${chosen.value} signup page in browser? (Y/n): `)).trim().toLowerCase();
+          if (openBrowser !== "n") {
+            info(`   Opening ${chosen.signupUrl}...`);
+            await openUrl(chosen.signupUrl);
+            info("   Create an API key, then paste it below.\n");
+          }
+        }
+        
+        const keyInput = (await ask(`   Paste your API key (or press Enter to skip): `)).trim();
+        if (keyInput) {
+          info("   Testing your API key...");
+          const testResult = await testAIKey(aiProvider, keyInput);
+          
+          if (testResult.success) {
+            info("   ✓ API key is valid!");
+            aiApiKey = keyInput;
+            credentials.ai = { apiKey: keyInput, provider: aiProvider, enabled: true };
+          } else if (testResult.error === "Rate limited — but key is valid") {
+            info("   ✓ API key is valid (rate limited, but will work)");
+            aiApiKey = keyInput;
+            credentials.ai = { apiKey: keyInput, provider: aiProvider, enabled: true };
+          } else {
+            warn(`   ⚠ API key test failed: ${testResult.error}`);
+            const useAnyway = (await ask(`   Save this key anyway? (y/N): `)).trim().toLowerCase();
+            if (useAnyway === "y") {
+              aiApiKey = keyInput;
+              credentials.ai = { apiKey: keyInput, provider: aiProvider, enabled: true };
+            } else {
+              warn("   Skipping AI configuration. You can set REPOLENS_AI_API_KEY later.");
+            }
+          }
+        } else {
+          warn("   No API key provided. Set REPOLENS_AI_API_KEY in .env or GitHub secrets.");
+        }
+        githubSecretsNeeded.push("REPOLENS_AI_API_KEY");
       }
     }
 
-    // 4. Scan preset
-    info("\nScan preset:");
+    // 5. Scan preset - detect language from files in repo
+    info("\n📂 Language/Framework Preset");
+    info("   Determines which file types and directories to scan.\n");
+    
     const presetKeys = Object.keys(SCAN_PRESETS);
-    presetKeys.forEach((p, i) => info(`  ${i + 1}. ${p}`));
-    const presetInput = (await ask(`Preset [3] (default: 3 generic): `)).trim() || "3";
+    presetKeys.forEach((key, i) => {
+      const preset = SCAN_PRESETS[key];
+      const num = (i + 1).toString().padStart(2);
+      info(`   ${num}. ${preset.label}`);
+      info(`       ${preset.description}`);
+    });
+    
+    // Default to universal (index 0) since it works for everything
+    const defaultPresetIdx = 1;
+    const defaultPreset = presetKeys[defaultPresetIdx - 1];
+    const defaultLabel = SCAN_PRESETS[defaultPreset].label;
+    
+    const presetInput = (await ask(`\nPreset [${defaultPresetIdx}] (default: ${defaultPresetIdx} ${defaultLabel}): `)).trim() || String(defaultPresetIdx);
     const presetIdx = parseInt(presetInput, 10);
-    const presetKey = presetKeys[(presetIdx >= 1 && presetIdx <= presetKeys.length) ? presetIdx - 1 : 2];
+    const presetKey = presetKeys[(presetIdx >= 1 && presetIdx <= presetKeys.length) ? presetIdx - 1 : defaultPresetIdx - 1];
     const preset = SCAN_PRESETS[presetKey];
+    
+    info(`   ✓ Selected: ${preset.label}`);
 
-    // 5. Branch filtering
-    const branchInput = (await ask("\nBranches allowed to publish to Notion/Confluence (comma-separated, default: main): ")).trim() || "main";
+    // 6. Branch filtering
+    info("\n🌿 Branch Filtering");
+    info("   Limits which branches can publish to Notion/Confluence.");
+    const branchInput = (await ask("   Allowed branches (comma-separated, default: main): ")).trim() || "main";
     const branches = branchInput.split(",").map((b) => b.trim()).filter(Boolean);
 
-    // 6. Discord
-    const enableDiscord = (await ask("\nEnable Discord notifications? (y/N): ")).trim().toLowerCase() === "y";
+    // 7. Discord notifications
+    info("\n🔔 Discord Notifications");
+    const enableDiscord = (await ask("   Enable Discord notifications? (y/N): ")).trim().toLowerCase() === "y";
+    
+    let discordWebhook = null;
+    if (enableDiscord) {
+      info("   Get webhook URL from: Server Settings > Integrations > Webhooks");
+      discordWebhook = (await ask("   DISCORD_WEBHOOK_URL (leave blank to skip): ")).trim() || null;
+      if (discordWebhook) {
+        credentials.discord = { webhookUrl: discordWebhook };
+      }
+      githubSecretsNeeded.push("DISCORD_WEBHOOK_URL");
+    }
+
+    // Summary
+    info("\n" + "═".repeat(60));
+    info("📋 Configuration Summary");
+    info("═".repeat(60));
+    info(`   Project:    ${projectName}`);
+    info(`   Publishers: ${publishers.join(", ")}`);
+    info(`   AI:         ${enableAi ? `Enabled (${aiProvider})` : "Disabled"}`);
+    info(`   Scan:       ${preset.label}`);
+    info(`   Branches:   ${branches.join(", ")}`);
+    info(`   Discord:    ${enableDiscord ? "Enabled" : "Disabled"}`);
+
+    // GitHub secrets summary
+    const uniqueSecrets = [...new Set(githubSecretsNeeded)];
+    if (uniqueSecrets.length > 0) {
+      info("\n📌 GitHub Actions Secrets Required:");
+      info("   Add these at: https://github.com/YOUR_ORG/YOUR_REPO/settings/secrets/actions");
+      for (const secret of uniqueSecrets) {
+        const status = credentials[secret.toLowerCase().split("_")[0]] ? "✓" : "○";
+        info(`   ${status} ${secret}`);
+      }
+    }
 
-    info("\n✓ Wizard complete. Generating config...\n");
-    return { projectName, publishers, enableAi, aiProvider, preset, branches, enableDiscord };
+    info("\n" + "═".repeat(60));
+    
+    const proceed = (await ask("\nProceed with this configuration? (Y/n): ")).trim().toLowerCase();
+    if (proceed === "n") {
+      info("Configuration cancelled.");
+      return null;
+    }
+
+    info("\n✓ Wizard complete. Generating files...\n");
+    return { 
+      projectName, 
+      publishers, 
+      enableAi, 
+      aiProvider, 
+      preset, 
+      branches, 
+      enableDiscord,
+      credentials,
+      githubSecretsNeeded: uniqueSecrets
+    };
   } finally {
     rl.close();
   }
 }
 
+const PUBLISHER_DESCRIPTIONS = {
+  markdown: "Local files in .repolens/",
+  notion: "Notion workspace pages",
+  confluence: "Atlassian Confluence pages",
+  github_wiki: "Repository wiki pages",
+};
+
 /**
  * Build a .repolens.yml from wizard answers.
  */
@@ -719,16 +1456,73 @@ function buildWizardConfig(answers) {
   return lines.join("\n");
 }
 
+/**
+ * Build .env content from wizard credentials.
+ */
+function buildEnvFromCredentials(credentials) {
+  const lines = [];
+  
+  if (credentials.notion) {
+    lines.push("# Notion Publishing");
+    lines.push(`NOTION_TOKEN=${credentials.notion.token}`);
+    lines.push(`NOTION_PARENT_PAGE_ID=${credentials.notion.parentPageId}`);
+    lines.push(`NOTION_VERSION=2022-06-28`);
+    lines.push("");
+  }
+  
+  if (credentials.confluence) {
+    lines.push("# Confluence Publishing");
+    lines.push(`CONFLUENCE_URL=${credentials.confluence.url}`);
+    lines.push(`CONFLUENCE_EMAIL=${credentials.confluence.email}`);
+    lines.push(`CONFLUENCE_API_TOKEN=${credentials.confluence.apiToken}`);
+    lines.push(`CONFLUENCE_SPACE_KEY=${credentials.confluence.spaceKey}`);
+    if (credentials.confluence.parentPageId) {
+      lines.push(`CONFLUENCE_PARENT_PAGE_ID=${credentials.confluence.parentPageId}`);
+    }
+    lines.push("");
+  }
+  
+  if (credentials.ai?.enabled) {
+    lines.push("# AI Configuration");
+    lines.push(`REPOLENS_AI_ENABLED=true`);
+    if (credentials.ai.provider) {
+      lines.push(`REPOLENS_AI_PROVIDER=${credentials.ai.provider}`);
+    }
+    if (credentials.ai.apiKey) {
+      lines.push(`REPOLENS_AI_API_KEY=${credentials.ai.apiKey}`);
+    }
+    if (credentials.ai.provider === "github") {
+      lines.push("# GitHub Models uses GITHUB_TOKEN (set separately or auto-available in Actions)");
+    }
+    lines.push("");
+  }
+  
+  if (credentials.discord) {
+    lines.push("# Discord Notifications");
+    lines.push(`DISCORD_WEBHOOK_URL=${credentials.discord.webhookUrl}`);
+    lines.push("");
+  }
+  
+  return lines.join("\n");
+}
+
+// Export helper functions for testing
+export { parseConfluenceUrl, parseNotionInput };
+
 export async function runInit(targetDir = process.cwd(), options = {}) {
   const repoRoot = path.resolve(targetDir);
 
   // Ensure target directory exists
   await fs.mkdir(repoRoot, { recursive: true });
 
-  // Interactive wizard if --interactive flag is set
+  // Interactive wizard is now the default (--quick skips it)
   let wizardAnswers = null;
   if (options.interactive) {
     wizardAnswers = await runInteractiveWizard(repoRoot);
+    if (!wizardAnswers) {
+      // User cancelled the wizard
+      return;
+    }
   }
 
   // Prompt for Notion credentials interactively (only in non-wizard mode)
@@ -765,7 +1559,7 @@ export async function runInit(targetDir = process.cwd(), options = {}) {
     for (const root of detectedRoots) {
       info(`  - ${root}`);
     }
-  } else {
+  } else if (!wizardAnswers) {
     info(`No known roots detected. Falling back to default config.`);
   }
 
@@ -792,18 +1586,25 @@ export async function runInit(targetDir = process.cwd(), options = {}) {
     info(`Skipped existing ${envExamplePath}`);
   }
 
-  // Create .env file with collected credentials
-  if (notionCredentials && !envExists) {
+  // Create .env file with collected credentials (wizard mode)
+  if (wizardAnswers?.credentials && Object.keys(wizardAnswers.credentials).length > 0 && !envExists) {
+    const envContent = buildEnvFromCredentials(wizardAnswers.credentials);
+    if (envContent.trim()) {
+      await fs.writeFile(envPath, envContent, "utf8");
+      info(`✅ Created ${envPath} with your credentials`);
+      await ensureEnvInGitignore(repoRoot);
+    }
+  } 
+  // Legacy: Create .env file with Notion credentials (non-wizard mode)
+  else if (notionCredentials && !envExists) {
     const envContent = `NOTION_TOKEN=${notionCredentials.token}
 NOTION_PARENT_PAGE_ID=${notionCredentials.parentPageId}
 NOTION_VERSION=2022-06-28
 `;
     await fs.writeFile(envPath, envContent, "utf8");
     info(`✅ Created ${envPath} with your Notion credentials`);
-    
-    // Ensure .env is in .gitignore
     await ensureEnvInGitignore(repoRoot);
-  } else if (notionCredentials && envExists) {
+  } else if ((notionCredentials || wizardAnswers?.credentials) && envExists) {
     warn(`Skipped existing ${envPath} - your credentials were not overwritten`);
   }
 
@@ -815,7 +1616,53 @@ NOTION_VERSION=2022-06-28
   }
 
   info("\n✨ RepoLens initialization complete!\n");
-    if (hasGitHubToken && !wizardAnswers) {
+
+  // Wizard mode: Show tailored summary
+  if (wizardAnswers) {
+    info("📁 Files created:");
+    info("   • .repolens.yml — Configuration");
+    info("   • .github/workflows/repolens.yml — GitHub Actions workflow");
+    info("   • .env.example — Template for credentials");
+    if (wizardAnswers.credentials && Object.keys(wizardAnswers.credentials).length > 0) {
+      info("   • .env — Your credentials (gitignored)");
+    }
+    info("   • README.repolens.md — Getting started guide");
+
+    if (wizardAnswers.githubSecretsNeeded && wizardAnswers.githubSecretsNeeded.length > 0) {
+      info("\n🔐 GitHub Actions Secrets:");
+      info("   Add at: Settings → Secrets → Actions");
+      for (const secret of wizardAnswers.githubSecretsNeeded) {
+        info(`   • ${secret}`);
+      }
+    }
+
+    // Show .env sourcing instructions if credentials were collected
+    const hasLocalCredentials = wizardAnswers.credentials && Object.keys(wizardAnswers.credentials).length > 0;
+    
+    info("\n🚀 Next steps:");
+    if (hasLocalCredentials) {
+      info("   ┌────────────────────────────────────────────────────────────┐");
+      info("   │ IMPORTANT: Your credentials are in .env but not loaded yet │");
+      info("   │ Run this BEFORE 'repolens publish':                         │");
+      info("   │                                                              │");
+      info("   │   source .env                                               │");
+      info("   │                                                              │");
+      info("   │ This loads your credentials into the current shell.         │");
+      info("   └────────────────────────────────────────────────────────────┘");
+      info("");
+      info("   1. source .env                   ← Load your credentials");
+      info("   2. npx @chappibunny/repolens publish   ← Test locally");
+    } else {
+      info("   1. npx @chappibunny/repolens publish   ← Test locally");
+    }
+    info(`   ${hasLocalCredentials ? "3" : "2"}. Add GitHub secrets (see above)`);
+    info(`   ${hasLocalCredentials ? "4" : "3"}. Commit and push to trigger workflow`);
+    info(`   ${hasLocalCredentials ? "5" : "4"}. Run 'npx @chappibunny/repolens doctor' to validate setup`);
+    return;
+  }
+
+  // Non-wizard mode: Original output
+  if (hasGitHubToken && !wizardAnswers) {
     info("🤖 Detected GITHUB_TOKEN — AI-enhanced docs enabled via GitHub Models (free)");
     info("   Your workflow and config are pre-configured. No extra setup needed.\n");
   }