@chappibunny/repolens 0.4.3 → 0.6.2

package/src/publishers/confluence.js

@@ -0,0 +1,428 @@
+import fetch from "node-fetch";
+import fs from "node:fs/promises";
+import path from "node:path";
+import { log, info, warn } from "../utils/logger.js";
+import { fetchWithRetry } from "../utils/retry.js";
+import { getCurrentBranch, getBranchQualifiedTitle } from "../utils/branch.js";
+
+/**
+ * Confluence Publisher for RepoLens
+ * 
+ * Supports: Atlassian Cloud (REST API v1)
+ * Content Format: Storage Format (Confluence's HTML-like format)
+ * Authentication: Email + API Token
+ * 
+ * Environment Variables Required:
+ * - CONFLUENCE_URL: Your Confluence base URL (e.g., https://your-company.atlassian.net/wiki)
+ * - CONFLUENCE_EMAIL: Your Atlassian account email
+ * - CONFLUENCE_API_TOKEN: API token from https://id.atlassian.com/manage-profile/security/api-tokens
+ * - CONFLUENCE_SPACE_KEY: Space key where docs will be published (e.g., DOCS, ENG)
+ * - CONFLUENCE_PARENT_PAGE_ID: Parent page ID under which RepoLens docs will be created
+ */
+
+function confluenceHeaders() {
+  const email = process.env.CONFLUENCE_EMAIL;
+  const token = process.env.CONFLUENCE_API_TOKEN;
+
+  if (!email || !token) {
+    throw new Error(
+      "Missing CONFLUENCE_EMAIL or CONFLUENCE_API_TOKEN. " +
+      "Set these environment variables or GitHub Actions secrets. " +
+      "Get your API token from: https://id.atlassian.com/manage-profile/security/api-tokens"
+    );
+  }
+
+  // Basic Auth for Atlassian Cloud: base64(email:api_token)
+  const auth = Buffer.from(`${email}:${token}`).toString("base64");
+
+  return {
+    Authorization: `Basic ${auth}`,
+    "Content-Type": "application/json",
+    Accept: "application/json"
+  };
+}
+
+function getConfluenceBaseUrl() {
+  const url = process.env.CONFLUENCE_URL;
+  if (!url) {
+    throw new Error(
+      "Missing CONFLUENCE_URL. Set this to your Confluence base URL. " +
+      "Examples:\n" +
+      "  - Cloud: https://your-company.atlassian.net/wiki\n" +
+      "  - Server: https://confluence.yourcompany.com"
+    );
+  }
+  
+  // Normalize URL (remove trailing slash, ensure /wiki for Cloud)
+  let normalized = url.replace(/\/+$/, "");
+  
+  // For Atlassian Cloud, ensure /wiki is present
+  if (normalized.includes("atlassian.net") && !normalized.endsWith("/wiki")) {
+    normalized = `${normalized}/wiki`;
+  }
+  
+  return normalized;
+}
+
+async function confluenceRequest(method, endpoint, body = null) {
+  const baseUrl = getConfluenceBaseUrl();
+  const url = `${baseUrl}/rest/api${endpoint}`;
+  
+  log(`Confluence API: ${method} ${endpoint}`);
+  
+  const res = await fetchWithRetry(
+    url,
+    {
+      method,
+      headers: confluenceHeaders(),
+      body: body ? JSON.stringify(body) : undefined
+    },
+    {
+      retries: 3,
+      baseDelayMs: 1000,
+      maxDelayMs: 5000,
+      label: `Confluence ${method} ${endpoint}`
+    }
+  );
+
+  if (!res.ok) {
+    const text = await res.text();
+    let errorMsg = `Confluence API error ${res.status}: ${text}`;
+    
+    // Provide helpful error messages
+    if (res.status === 401) {
+      errorMsg += "\n\nAuthentication failed. Please check:\n" +
+        "  1. CONFLUENCE_EMAIL is correct\n" +
+        "  2. CONFLUENCE_API_TOKEN is valid (generate new one if needed)\n" +
+        "  3. For Cloud: Use your Atlassian account email\n" +
+        "  4. For Server: Use your username instead of email";
+    } else if (res.status === 404) {
+      errorMsg += "\n\nPage or space not found. Please check:\n" +
+        "  1. CONFLUENCE_SPACE_KEY is correct\n" +
+        "  2. CONFLUENCE_PARENT_PAGE_ID exists\n" +
+        "  3. You have access to this space";
+    } else if (res.status === 403) {
+      errorMsg += "\n\nPermission denied. Please ensure:\n" +
+        "  1. Your Confluence user has edit permissions in the space\n" +
+        "  2. The space is not restricted";
+    }
+    
+    throw new Error(errorMsg);
+  }
+
+  return await res.json();
+}
+
+// Cache management (similar to Notion)
+const CACHE_DIR = path.join(process.cwd(), ".cache");
+
+function getCacheFile() {
+  const branch = getCurrentBranch();
+  return path.join(CACHE_DIR, `confluence-pages-${branch}.json`);
+}
+
+async function readCache() {
+  try {
+    const cacheFile = getCacheFile();
+    const raw = await fs.readFile(cacheFile, "utf8");
+    return JSON.parse(raw);
+  } catch {
+    return {};
+  }
+}
+
+async function writeCache(cache) {
+  await fs.mkdir(CACHE_DIR, { recursive: true });
+  const cacheFile = getCacheFile();
+  await fs.writeFile(cacheFile, JSON.stringify(cache, null, 2), "utf8");
+}
+
+// Convert Markdown to Confluence Storage Format
+function markdownToConfluenceStorage(markdown) {
+  // Basic Markdown → Storage Format conversion
+  // Storage Format is Confluence's HTML-like format
+  
+  // STEP 1: Extract and convert code blocks FIRST (before escaping)
+  const codeBlocks = [];
+  let html = markdown.replace(/```(\w+)?\n([\s\S]+?)```/g, (match, lang, code) => {
+    const language = lang || "none";
+    const placeholder = `<<<CODE_BLOCK_${codeBlocks.length}>>>`;
+    codeBlocks.push(`<ac:structured-macro ac:name="code"><ac:parameter ac:name="language">${language}</ac:parameter><ac:plain-text-body><![CDATA[${code}]]></ac:plain-text-body></ac:structured-macro>`);
+    return placeholder;
+  });
+  
+  // STEP 2: Now escape HTML entities (won't affect code blocks)
+  html = html
+    .replace(/&/g, "&amp;")
+    .replace(/</g, "&lt;")
+    .replace(/>/g, "&gt;")
+    
+    // Headers
+    .replace(/^### (.+)$/gm, "<h3>$1</h3>")
+    .replace(/^## (.+)$/gm, "<h2>$1</h2>")
+    .replace(/^# (.+)$/gm, "<h1>$1</h1>")
+    
+    // Bold
+    .replace(/\*\*(.+?)\*\*/g, "<strong>$1</strong>")
+    
+    // Italic
+    .replace(/\*(.+?)\*/g, "<em>$1</em>")
+    
+    // Inline code
+    .replace(/`(.+?)`/g, "<code>$1</code>")
+    
+    // Links
+    .replace(/\[([^\]]+)\]\(([^)]+)\)/g, '<a href="$2">$1</a>')
+    
+    // Horizontal rules
+    .replace(/^---$/gm, "<hr />")
+    
+    // Lists - unordered
+    .replace(/^- (.+)$/gm, "<ul><li>$1</li></ul>")
+    
+    // Lists - ordered
+    .replace(/^\d+\. (.+)$/gm, "<ol><li>$1</li></ol>")
+    
+    // Paragraphs (lines followed by blank line)
+    .replace(/^([^<\n].+)$/gm, "<p>$1</p>")
+    
+    // Clean up consecutive list tags
+    .replace(/<\/ul>\s*<ul>/g, "")
+    .replace(/<\/ol>\s*<ol>/g, "")
+    
+    // Line breaks
+    .replace(/\n/g, "");
+
+  // STEP 3: Restore code blocks
+  codeBlocks.forEach((block, index) => {
+    html = html.replace(`&lt;&lt;&lt;CODE_BLOCK_${index}&gt;&gt;&gt;`, block);
+  });
+
+  return html;
+}
+
+// Find existing page by title
+async function findPageByTitle(spaceKey, title) {
+  try {
+    const result = await confluenceRequest(
+      "GET",
+      `/content?spaceKey=${spaceKey}&title=${encodeURIComponent(title)}&expand=version`
+    );
+    
+    if (result.results && result.results.length > 0) {
+      return result.results[0];
+    }
+    return null;
+  } catch (err) {
+    warn(`Could not search for existing page "${title}": ${err.message}`);
+    return null;
+  }
+}
+
+// Create a new Confluence page
+async function createPage(spaceKey, parentPageId, title, storageContent) {
+  const body = {
+    type: "page",
+    title: title,
+    space: { key: spaceKey },
+    body: {
+      storage: {
+        value: storageContent,
+        representation: "storage"
+      }
+    }
+  };
+
+  // Add parent if specified
+  if (parentPageId) {
+    body.ancestors = [{ id: parentPageId }];
+  }
+
+  const page = await confluenceRequest("POST", "/content", body);
+  info(`✓ Created Confluence page: ${title}`);
+  return page;
+}
+
+// Update an existing Confluence page
+async function updatePage(pageId, title, storageContent, currentVersion) {
+  const body = {
+    version: {
+      number: currentVersion + 1
+    },
+    title: title,
+    type: "page",
+    body: {
+      storage: {
+        value: storageContent,
+        representation: "storage"
+      }
+    }
+  };
+
+  const page = await confluenceRequest("PUT", `/content/${pageId}`, body);
+  info(`✓ Updated Confluence page: ${title} (v${currentVersion + 1})`);
+  return page;
+}
+
+// Publish a single document page
+async function publishPage(cfg, key, markdown, cache) {
+  const spaceKey = process.env.CONFLUENCE_SPACE_KEY;
+  const parentPageId = process.env.CONFLUENCE_PARENT_PAGE_ID;
+  
+  if (!spaceKey) {
+    throw new Error("Missing CONFLUENCE_SPACE_KEY environment variable");
+  }
+
+  // Get human-readable title
+  const titleMap = {
+    system_overview: "System Overview",
+    module_catalog: "Module Catalog",
+    api_surface: "API Surface",
+    route_map: "Route Map",
+    system_map: "System Map",
+    arch_diff: "Architecture Diff",
+    executive_summary: "Executive Summary",
+    business_domains: "Business Domains",
+    architecture_overview: "Architecture Overview",
+    data_flows: "Data Flows",
+    change_impact: "Change Impact",
+    developer_onboarding: "Developer Onboarding"
+  };
+
+  let title = titleMap[key] || key;
+  
+  // Add project prefix if configured
+  if (cfg.project?.docs_title_prefix) {
+    title = `${cfg.project.docs_title_prefix} — ${title}`;
+  }
+
+  // Add branch qualifier for non-main branches
+  const currentBranch = getCurrentBranch();
+  title = getBranchQualifiedTitle(title, currentBranch, cfg);
+
+  // Convert Markdown to Confluence Storage Format
+  const storageContent = markdownToConfluenceStorage(markdown);
+
+  // Check cache first
+  let existingPage = cache[key];
+  
+  // If not in cache, search by title
+  if (!existingPage) {
+    existingPage = await findPageByTitle(spaceKey, title);
+    
+    if (existingPage) {
+      // Found it, update cache
+      cache[key] = {
+        id: existingPage.id,
+        title: existingPage.title,
+        version: existingPage.version.number
+      };
+      // Update existingPage to match cache structure (version as number)
+      existingPage = cache[key];
+    }
+  } else {
+    // Verify cached page still exists
+    try {
+      const verified = await confluenceRequest("GET", `/content/${existingPage.id}?expand=version`);
+      existingPage.version = verified.version.number;
+    } catch (err) {
+      warn(`Cached page ${existingPage.id} not found, will create new page`);
+      existingPage = null;
+      delete cache[key];
+    }
+  }
+
+  let page;
+  if (existingPage) {
+    // Update existing page
+    page = await updatePage(existingPage.id, title, storageContent, existingPage.version);
+  } else {
+    // Create new page
+    page = await createPage(spaceKey, parentPageId, title, storageContent);
+  }
+
+  // Update cache
+  cache[key] = {
+    id: page.id,
+    title: page.title,
+    version: page.version.number
+  };
+
+  return page;
+}
+
+// Main export: Publish all pages to Confluence
+export async function publishToConfluence(cfg, renderedPages) {
+  const baseUrl = getConfluenceBaseUrl();
+  const spaceKey = process.env.CONFLUENCE_SPACE_KEY;
+  
+  info(`Publishing to Confluence: ${baseUrl}`);
+  info(`Space: ${spaceKey}`);
+
+  // Load cache
+  const cache = await readCache();
+
+  // Publish each page
+  const published = [];
+  for (const [key, markdown] of Object.entries(renderedPages)) {
+    try {
+      const page = await publishPage(cfg, key, markdown, cache);
+      published.push({
+        key,
+        pageId: page.id,
+        url: `${baseUrl}/pages/viewpage.action?pageId=${page.id}`
+      });
+    } catch (err) {
+      warn(`Failed to publish ${key}: ${err.message}`);
+      throw err; // Re-throw to signal publishing failure
+    }
+  }
+
+  // Save cache
+  await writeCache(cache);
+
+  // Print summary
+  info(`\n📚 Published ${published.length} pages to Confluence:`);
+  published.forEach(p => {
+    info(`   ${p.key}: ${p.url}`);
+  });
+
+  return published;
+}
+
+// Helper: Check if Confluence secrets are configured
+export function hasConfluenceSecrets() {
+  return !!(
+    process.env.CONFLUENCE_URL &&
+    process.env.CONFLUENCE_EMAIL &&
+    process.env.CONFLUENCE_API_TOKEN &&
+    process.env.CONFLUENCE_SPACE_KEY
+  );
+}
+
+// Helper: Validate Confluence configuration
+export function validateConfluenceConfig() {
+  const missing = [];
+  
+  if (!process.env.CONFLUENCE_URL) missing.push("CONFLUENCE_URL");
+  if (!process.env.CONFLUENCE_EMAIL) missing.push("CONFLUENCE_EMAIL");
+  if (!process.env.CONFLUENCE_API_TOKEN) missing.push("CONFLUENCE_API_TOKEN");
+  if (!process.env.CONFLUENCE_SPACE_KEY) missing.push("CONFLUENCE_SPACE_KEY");
+  
+  if (missing.length > 0) {
+    return {
+      valid: false,
+      missing: missing,
+      message: `Missing required Confluence environment variables: ${missing.join(", ")}\n\n` +
+        "Get started:\n" +
+        "  1. Get API token: https://id.atlassian.com/manage-profile/security/api-tokens\n" +
+        "  2. Set CONFLUENCE_URL to your Confluence base URL\n" +
+        "  3. Set CONFLUENCE_EMAIL to your Atlassian account email\n" +
+        "  4. Set CONFLUENCE_API_TOKEN to your API token\n" +
+        "  5. Set CONFLUENCE_SPACE_KEY to your space key (e.g., DOCS, ENG)\n" +
+        "  6. (Optional) Set CONFLUENCE_PARENT_PAGE_ID for nested docs"
+    };
+  }
+  
+  return { valid: true };
+}

package/src/publishers/index.js

@@ -1,15 +1,27 @@
 import { publishToNotion } from "./publish.js";
 import { publishToMarkdown } from "./markdown.js";
-import { shouldPublishToNotion, getCurrentBranch } from "../utils/branch.js";
+import { publishToConfluence, hasConfluenceSecrets } from "./confluence.js";
+import { shouldPublishToNotion, shouldPublishToConfluence, getCurrentBranch } from "../utils/branch.js";
 import { info, warn } from "../utils/logger.js";
+import { trackPublishing } from "../utils/telemetry.js";
+import { collectMetrics } from "../utils/metrics.js";
+import {
+  sendDiscordNotification,
+  buildDocUpdateNotification,
+  shouldNotify,
+} from "../integrations/discord.js";
+import path from "node:path";
 
 function hasNotionSecrets() {
   return !!process.env.NOTION_TOKEN && !!process.env.NOTION_PARENT_PAGE_ID;
 }
 
-export async function publishDocs(cfg, renderedPages) {
+export async function publishDocs(cfg, renderedPages, scanResult) {
   const publishers = cfg.publishers || ["markdown", "notion"];
   const currentBranch = getCurrentBranch();
+  const publishedTo = [];
+  let publishStatus = "success";
+  let notionUrl = null;
 
   // Always try Notion publishing if secrets are configured
   if (publishers.includes("notion") || hasNotionSecrets()) {
@@ -18,7 +30,17 @@ export async function publishDocs(cfg, renderedPages) {
       info("To enable Notion publishing, set these environment variables or GitHub Actions secrets");
     } else if (shouldPublishToNotion(cfg, currentBranch)) {
       info(`Publishing to Notion from branch: ${currentBranch}`);
-      await publishToNotion(cfg, renderedPages);
+      try {
+        await publishToNotion(cfg, renderedPages);
+        publishedTo.push("notion");
+        // Build Notion URL if published
+        if (process.env.NOTION_PARENT_PAGE_ID) {
+          notionUrl = `https://notion.so/${process.env.NOTION_PARENT_PAGE_ID}`;
+        }
+      } catch (err) {
+        publishStatus = "failure";
+        throw err;
+      }
     } else {
       const allowedBranches = cfg.notion?.branches?.join(", ") || "none configured";
       warn(`Skipping Notion publish: branch "${currentBranch}" not in allowed list (${allowedBranches})`);
@@ -26,8 +48,94 @@ export async function publishDocs(cfg, renderedPages) {
     }
   }
 
+  // Confluence publishing (opt-in if secrets configured)
+  if (publishers.includes("confluence") || hasConfluenceSecrets()) {
+    if (!hasConfluenceSecrets()) {
+      info("Skipping Confluence publish: Required environment variables not configured");
+      info("To enable Confluence publishing, set CONFLUENCE_URL, CONFLUENCE_EMAIL, CONFLUENCE_API_TOKEN, and CONFLUENCE_SPACE_KEY");
+    } else if (shouldPublishToConfluence(cfg, currentBranch)) {
+      info(`Publishing to Confluence from branch: ${currentBranch}`);
+      try {
+        await publishToConfluence(cfg, renderedPages);
+        publishedTo.push("confluence");
+      } catch (err) {
+        publishStatus = "failure";
+        throw err;
+      }
+    } else {
+      const allowedBranches = cfg.confluence?.branches?.join(", ") || "none configured";
+      warn(`Skipping Confluence publish: branch "${currentBranch}" not in allowed list (${allowedBranches})`);
+      info("To publish from this branch, add it to confluence.branches in .repolens.yml");
+    }
+  }
+
   // Always generate markdown output
   if (publishers.includes("markdown") || !publishers.includes("notion")) {
-    await publishToMarkdown(cfg, renderedPages);
+    try {
+      await publishToMarkdown(cfg, renderedPages);
+      publishedTo.push("markdown");
+    } catch (err) {
+      publishStatus = "failure";
+      throw err;
+    }
+  }
+
+  // Collect metrics and send Discord notification
+  try {
+    info("Collecting documentation metrics...");
+    const docsPath = path.join(process.cwd(), ".repolens");
+    const historyPath = path.join(docsPath, "metrics-history.json");
+    
+    const metrics = await collectMetrics(scanResult, renderedPages, docsPath, historyPath);
+    
+    // Send Discord notification if configured
+      const webhookUrl = process.env.DISCORD_WEBHOOK_URL;
+      const discordConfig = cfg.discord || {};
+      const discordEnabled = discordConfig.enabled !== false; // Default true if webhook configured
+      const notifyOn = discordConfig.notifyOn || "significant";
+      const significantThreshold = discordConfig.significantThreshold || 10;
+      
+      // Check if we should send notification for this branch
+      const allowedBranches = discordConfig.branches || [currentBranch]; // Default to current branch
+      const branchAllowed = allowedBranches.some(pattern => {
+        if (pattern.includes("*")) {
+          const regex = new RegExp(`^${pattern.replace(/\*/g, ".*")}$`);
+          return regex.test(currentBranch);
+        }
+        return pattern === currentBranch;
+      });
+      
+      if (webhookUrl && discordEnabled && branchAllowed) {
+        // Calculate change percent (if we have history)
+        const changePercent = metrics.history.length >= 2
+          ? Math.abs(metrics.history[metrics.history.length - 1].coverage - metrics.history[metrics.history.length - 2].coverage)
+          : undefined;
+        
+        if (shouldNotify(changePercent, notifyOn, significantThreshold)) {
+        const notification = buildDocUpdateNotification({
+          branch: currentBranch,
+          commitSha: process.env.GITHUB_SHA || process.env.CI_COMMIT_SHA,
+          commitMessage: process.env.GITHUB_EVENT_NAME === "push"
+            ? process.env.GITHUB_EVENT_HEAD_COMMIT_MESSAGE
+            : undefined,
+          filesScanned: scanResult.filesCount,
+          modulesDetected: scanResult.modules?.length || 0,
+          coverage: metrics.coverage.overall,
+          notionUrl,
+          });
+          
+          await sendDiscordNotification(webhookUrl, notification);
+        } else {
+          info(`Skipping Discord notification: change ${changePercent?.toFixed(1) || 0}% below threshold ${significantThreshold}%`);
+        }
+    } else if (!webhookUrl && discordConfig.enabled !== false) {
+      info("Discord webhook not configured. Set DISCORD_WEBHOOK_URL environment variable to enable notifications.");
+    }
+  } catch (err) {
+    warn(`Failed to send notifications: ${err.message}`);
+    // Don't fail the whole publish if notifications fail
   }
+  
+  // Track publishing metrics
+  trackPublishing(publishedTo, publishStatus);
 }

package/src/publishers/notion.js

@@ -3,6 +3,7 @@ import fs from "node:fs/promises";
 import path from "node:path";
 import { log } from "../utils/logger.js";
 import { fetchWithRetry } from "../utils/retry.js";
+import { executeNotionRequest } from "../utils/rate-limit.js";
 
 function notionHeaders() {
   const token = process.env.NOTION_TOKEN;
@@ -20,23 +21,25 @@ function notionHeaders() {
 }
 
 async function notionRequest(method, url, body) {
-  const res = await fetchWithRetry(`https://api.notion.com/v1${url}`, {
-    method,
-    headers: notionHeaders(),
-    body: body ? JSON.stringify(body) : undefined
-  }, {
-    retries: 3,
-    baseDelayMs: 500,
-    maxDelayMs: 4000,
-    label: `Notion ${method} ${url}`
-  });
+  return await executeNotionRequest(async () => {
+    const res = await fetchWithRetry(`https://api.notion.com/v1${url}`, {
+      method,
+      headers: notionHeaders(),
+      body: body ? JSON.stringify(body) : undefined
+    }, {
+      retries: 3,
+      baseDelayMs: 500,
+      maxDelayMs: 4000,
+      label: `Notion ${method} ${url}`
+    });
 
-  if (!res.ok) {
-    const text = await res.text();
-    throw new Error(`Notion API error ${res.status}: ${text}`);
-  }
+    if (!res.ok) {
+      const text = await res.text();
+      throw new Error(`Notion API error ${res.status}: ${text}`);
+    }
 
-  return await res.json();
+    return await res.json();
+  });
 }
 
 const CACHE_DIR = path.join(process.cwd(), ".cache");
@@ -322,4 +325,5 @@ export async function replacePageContent(pageId, markdown) {
       children: chunk
     });
   }
-}
+}
+

package/src/publishers/publish.js

@@ -8,7 +8,7 @@ export async function publishToNotion(cfg, renderedPages) {
     throw new Error("Missing NOTION_PARENT_PAGE_ID in tools/repolens/.env");
   }
 
-  const prefix = cfg.project.docs_title_prefix || "RepoLens";
+  const prefix = cfg.project.docs_title_prefix || "Documentation";
   const currentBranch = getCurrentBranch();
   const includeBranchInTitle = cfg.notion?.includeBranchInTitle !== false; // Default true
 

package/src/renderers/render.js

@@ -43,6 +43,16 @@ export function renderSystemOverview(cfg, scan) {
   return [
     `# ${cfg.project.name} — System Overview`,
     ``,
+    `\`\`\``,
+    `██████╗ ███████╗██████╗  ██████╗ ██╗     ███████╗███╗   ██╗███████╗`,
+    `██╔══██╗██╔════╝██╔══██╗██╔═══██╗██║     ██╔════╝████╗  ██║██╔════╝`,
+    `██████╔╝█████╗  ██████╔╝██║   ██║██║     █████╗  ██╔██╗ ██║███████╗`,
+    `██╔══██╗██╔══╝  ██╔═══╝ ██║   ██║██║     ██╔══╝  ██║╚██╗██║╚════██║`,
+    `██║  ██║███████╗██║     ╚██████╔╝███████╗███████╗██║ ╚████║███████║`,
+    `╚═╝  ╚═╝╚══════╝╚═╝      ╚═════╝ ╚══════╝╚══════╝╚═╝  ╚═══╝╚══════╝`,
+    `          🔍 Repository Intelligence by RABITAI 🐰`,
+    `\`\`\``,
+    ``,
     `What is this? This page provides a high-level snapshot of your codebase structure, showing what technologies you're using and how your code is organized.`,
     ``,
     `📊 Last Updated: ${new Date().toLocaleDateString("en-US", { month: "long", day: "numeric", year: "numeric" })}`,
@@ -238,9 +248,29 @@ export function renderRouteMap(cfg, scan) {
 
   if (!scan.pages?.length && !scan.api?.length) {
     lines.push(
-      `## No Routes Detected`,
+      `## 🔍 Route Detection Status`,
+      ``,
+      `No routes were auto-detected in this scan. RABITAI currently supports:`,
+      ``,
+      `✅ **Fully Supported:**`,
+      `- Next.js pages (\`pages/\` and \`app/\` directories)`,
+      `- Next.js API routes (\`pages/api/\` and App Router)`,
+      `- Express.js routes (\`app.get\`, \`router.post\`, etc.)`,
+      `- React Router (\`<Route>\` components)`,
+      `- Vue Router (\`routes\` array definitions)`,
+      ``,
+      `⏳ **Coming Soon:**`,
+      `- Fastify routes`,
+      `- NestJS controllers`,
+      `- GraphQL endpoints`,
+      `- tRPC procedures`,
+      ``,
+      `💡 **Your project may:**`,
+      `- Use a different routing framework (let us know!)`,
+      `- Have routes outside the scanned directories`,
+      `- Use dynamic routing patterns we haven't detected yet`,
       ``,
-      `RepoLens looks for Next.js pages and API routes. If you're using a different framework, routes might not be auto-detected yet.`,
+      `📬 **Request Support:** Open an issue at [github.com/CHAPIBUNNY/repolens](https://github.com/CHAPIBUNNY/repolens/issues) to request your framework!`,
       ``
     );
   }