@chappibunny/repolens 1.6.0 → 1.6.1

package/README.md

@@ -25,7 +25,7 @@ RepoLens scans your repository, generates living architecture documentation, and
 
 > **Try it now** — no installation required. Run `npx @chappibunny/repolens demo` on any repo for an instant local preview.
 
-[![RepoLens Demo](https://img.youtube.com/vi/hNd7xim_rTE/maxresdefault.jpg)](https://youtu.be/hNd7xim_rTE)
+[![RepoLens Demo](https://img.youtube.com/vi/Lpyg0dGsiws/maxresdefault.jpg)](https://youtu.be/Lpyg0dGsiws)
 
 ▶️ *Click to watch on YouTube*
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@chappibunny/repolens",
-  "version": "1.6.0",
+  "version": "1.6.1",
   "description": "AI-assisted documentation intelligence system for technical and non-technical audiences",
   "license": "MIT",
   "type": "module",
@@ -64,10 +64,8 @@
     "js-yaml": "^4.1.0",
     "node-fetch": "^3.3.2"
   },
-  "optionalDependencies": {
-    "@mermaid-js/mermaid-cli": "^11.12.0"
-  },
   "devDependencies": {
+    "tinyexec": "1.0.2",
     "vitest": "^4.0.18"
   }
 }

package/src/ai/generate-sections.js

@@ -736,20 +736,31 @@ function inferFlowsFromDepGraph(depGraph) {
 
 function describeRoot(root) {
   const lower = root.toLowerCase().replace(/\/$/, "");
+  // Check the last segment for nested paths like src/core, src/analyzers
+  const lastSeg = lower.split("/").pop();
   if (/^src$|^lib$/.test(lower)) return "Application source code";
-  if (/^test|^__test|^spec/.test(lower)) return "Test suites";
-  if (/^doc/.test(lower)) return "Documentation";
-  if (/^bin$|^scripts?$/.test(lower)) return "CLI entry points and scripts";
-  if (/^config/.test(lower)) return "Configuration files";
-  if (/^public$|^static$|^assets$/.test(lower)) return "Static assets";
-  if (/^dist$|^build$|^out$/.test(lower)) return "Build output";
-  if (/^\.github$/.test(lower)) return "GitHub Actions and workflows";
-  if (/^api$/.test(lower)) return "API definitions";
-  if (/^components?$/.test(lower)) return "Shared UI components";
-  if (/^pages?$|^views?$|^screens?$/.test(lower)) return "Application pages/views";
-  if (/^utils?$|^helpers?$/.test(lower)) return "Utility functions";
-  if (/^services?$/.test(lower)) return "Service layer";
-  if (/^hooks?$/.test(lower)) return "Custom hooks";
+  if (/^test|^__test|^spec/.test(lastSeg)) return "Test suites";
+  if (/^doc/.test(lastSeg)) return "Documentation";
+  if (/^bin$|^scripts?$/.test(lastSeg)) return "CLI entry points and scripts";
+  if (/^config/.test(lastSeg)) return "Configuration files";
+  if (/^public$|^static$|^assets$/.test(lastSeg)) return "Static assets";
+  if (/^dist$|^build$|^out$/.test(lastSeg)) return "Build output";
+  if (/^\.github$/.test(lastSeg)) return "GitHub Actions and workflows";
+  if (/^api$|^endpoint/.test(lastSeg)) return "API definitions";
+  if (/^components?$|^ui$/.test(lastSeg)) return "Shared UI components";
+  if (/^pages?$|^views?$|^screens?$/.test(lastSeg)) return "Application pages/views";
+  if (/^utils?$|^helpers?$/.test(lastSeg)) return "Utility functions";
+  if (/^services?$/.test(lastSeg)) return "Service layer";
+  if (/^hooks?$/.test(lastSeg)) return "Custom hooks";
+  if (/^core$|^kernel$|^engine$/.test(lastSeg)) return "Core logic and foundations";
+  if (/^analyz/.test(lastSeg)) return "Code analysis and detection";
+  if (/^render/.test(lastSeg)) return "Rendering and output formatting";
+  if (/^publish/.test(lastSeg)) return "Publishing and distribution";
+  if (/^deliver/.test(lastSeg)) return "Content delivery";
+  if (/^integrat/.test(lastSeg)) return "Third-party integrations";
+  if (/^plugin/.test(lastSeg)) return "Plugin and extension system";
+  if (/^ai$|^ml$|^llm$/.test(lastSeg)) return "AI/ML features and providers";
+  if (/^middleware/.test(lastSeg)) return "Middleware pipeline";
   return "Project files";
 }
 

package/src/analyzers/context-builder.js

@@ -97,12 +97,28 @@ export function buildAIContext(scanResult, config) {
 function inferModuleType(modulePath) {
   const lower = modulePath.toLowerCase();
   
-  if (lower.includes("api")) return "api";
-  if (lower.includes("component")) return "ui";
-  if (lower.includes("lib") || lower.includes("util")) return "library";
+  if (lower.includes("test") || lower.includes("spec") || lower.includes("__test")) return "test";
+  if (lower.includes("api") || lower.includes("endpoint")) return "api";
+  if (lower.includes("component") || lower.includes("widget")) return "ui";
+  if (lower.includes("lib") || lower.includes("util") || lower.includes("helper") || lower.includes("common") || lower.includes("shared")) return "library";
   if (lower.includes("hook")) return "hooks";
-  if (lower.includes("store") || lower.includes("state")) return "state";
-  if (lower.includes("page") || lower.includes("route")) return "route";
+  if (lower.includes("store") || lower.includes("state") || lower.includes("redux") || lower.includes("zustand")) return "state";
+  if (lower.includes("page") || lower.includes("route") || lower.includes("view")) return "route";
+  if (lower.includes("config") || lower.includes("setting") || lower.includes("env")) return "config";
+  if (lower.includes("core") || lower.includes("kernel") || lower.includes("foundation")) return "core";
+  if (lower.includes("render") || lower.includes("template") || lower.includes("format")) return "renderer";
+  if (lower.includes("publish") || lower.includes("output") || lower.includes("export")) return "publisher";
+  if (lower.includes("analyz") || lower.includes("inspect") || lower.includes("detect")) return "analyzer";
+  if (lower.includes("plugin") || lower.includes("extension") || lower.includes("addon")) return "plugin";
+  if (lower.includes("deliver") || lower.includes("dispatch") || lower.includes("send")) return "delivery";
+  if (lower.includes("doc") || lower.includes("generate")) return "documentation";
+  if (lower.includes("integrat") || lower.includes("connect") || lower.includes("adapter")) return "integration";
+  if (lower.includes("cli") || lower.includes("command") || lower.includes("bin")) return "cli";
+  if (lower.includes("ai") || lower.includes("ml") || lower.includes("model") || lower.includes("prompt")) return "ai";
+  if (lower.includes("auth") || lower.includes("login") || lower.includes("session")) return "auth";
+  if (lower.includes("data") || lower.includes("db") || lower.includes("model") || lower.includes("schema")) return "data";
+  if (lower.includes("middleware")) return "middleware";
+  if (lower.includes("service")) return "service";
   if (lower.includes("app")) return "app";
   
   return "other";
@@ -110,21 +126,31 @@ function inferModuleType(modulePath) {
 
 function inferArchitecturalPatterns(modules) {
   const patterns = [];
+  const keys = modules.map(m => m.key.toLowerCase());
   
-  const hasAppRouter = modules.some(m => m.key.includes("app/"));
-  const hasPagesRouter = modules.some(m => m.key.includes("pages/"));
-  const hasComponents = modules.some(m => m.key.includes("component"));
-  const hasLib = modules.some(m => m.key.includes("lib"));
-  const hasHooks = modules.some(m => m.key.includes("hook"));
-  const hasStore = modules.some(m => m.key.includes("store") || m.key.includes("state"));
-  const hasApi = modules.some(m => m.key.includes("api"));
-  
-  if (hasAppRouter) patterns.push("Next.js App Router");
-  if (hasPagesRouter) patterns.push("Next.js Pages Router");
-  if (hasComponents && hasLib) patterns.push("Layered component architecture");
-  if (hasHooks) patterns.push("React hooks pattern");
-  if (hasStore) patterns.push("Centralized state management");
-  if (hasApi) patterns.push("API route pattern");
+  const has = (keyword) => keys.some(k => k.includes(keyword));
+  
+  // Web framework patterns
+  if (has("app/")) patterns.push("Next.js App Router");
+  if (has("pages/")) patterns.push("Next.js Pages Router");
+  if (has("component") && has("lib")) patterns.push("Layered component architecture");
+  if (has("hook")) patterns.push("React hooks pattern");
+  if (has("store") || has("state") || has("redux") || has("zustand")) patterns.push("Centralized state management");
+  
+  // General patterns
+  if (has("api") || has("endpoint")) patterns.push("API route pattern");
+  if (has("core") || has("kernel")) patterns.push("Core/kernel architecture");
+  if (has("plugin") || has("extension")) patterns.push("Plugin system");
+  if (has("middleware")) patterns.push("Middleware pipeline");
+  if (has("render") || has("template")) patterns.push("Renderer pipeline");
+  if (has("publish") || has("output")) patterns.push("Multi-output publishing");
+  if (has("analyz") || has("detect") || has("inspect")) patterns.push("Analysis pipeline");
+  if (has("cli") || has("command") || has("bin")) patterns.push("CLI tool architecture");
+  if (has("util") || has("helper") || has("lib")) patterns.push("Shared utility layer");
+  if (has("integrat") || has("adapter") || has("connect")) patterns.push("Integration adapters");
+  if (has("ai") || has("prompt") || has("provider")) patterns.push("AI/LLM integration");
+  if (has("deliver") || has("dispatch")) patterns.push("Delivery pipeline");
+  if (has("test") || has("spec")) patterns.push("Dedicated test infrastructure");
   
   return patterns;
 }

package/src/analyzers/domain-inference.js

@@ -32,7 +32,7 @@ const DEFAULT_DOMAIN_HINTS = [
     description: "Payment processing and subscription management"
   },
   { 
-    match: ["api", "endpoint", "route", "handler", "controller", "middleware"], 
+    match: ["api", "endpoint", "handler", "controller", "middleware"], 
     domain: "API Layer",
     description: "Backend API endpoints and request handling"
   },
@@ -75,6 +75,61 @@ const DEFAULT_DOMAIN_HINTS = [
     match: ["job", "queue", "worker", "cron", "task", "scheduler", "background"],
     domain: "Background Jobs",
     description: "Background processing, job queues, and scheduled tasks"
+  },
+  {
+    match: ["core", "kernel", "foundation", "engine"],
+    domain: "Core Engine",
+    description: "Core business logic and foundational modules"
+  },
+  {
+    match: ["render", "template", "format", "output"],
+    domain: "Rendering & Output",
+    description: "Content rendering, formatting, and output generation"
+  },
+  {
+    match: ["publish", "deploy", "release", "distribute"],
+    domain: "Publishing & Delivery",
+    description: "Content and artifact publishing, deployment, and distribution"
+  },
+  {
+    match: ["analyz", "inspect", "detect", "lint", "scan", "parse"],
+    domain: "Analysis & Detection",
+    description: "Code analysis, pattern detection, and static inspection"
+  },
+  {
+    match: ["plugin", "extension", "addon", "module"],
+    domain: "Plugin System",
+    description: "Extensibility framework, plugins, and add-ons"
+  },
+  {
+    match: ["deliver", "dispatch", "send", "transport"],
+    domain: "Delivery",
+    description: "Content delivery and distribution channels"
+  },
+  {
+    match: ["doc", "generate", "markdown", "readme"],
+    domain: "Documentation",
+    description: "Documentation generation and management"
+  },
+  {
+    match: ["integrat", "connect", "adapter", "bridge", "gateway"],
+    domain: "Integrations",
+    description: "Third-party service integrations and adapters"
+  },
+  {
+    match: ["cli", "command", "bin", "terminal", "shell", "prompt"],
+    domain: "CLI & Commands",
+    description: "Command-line interface and terminal commands"
+  },
+  {
+    match: ["ai", "ml", "llm", "gpt", "openai", "anthropic", "gemini"],
+    domain: "AI & Machine Learning",
+    description: "AI/ML integration, LLM providers, and intelligent features"
+  },
+  {
+    match: ["service", "provider", "client", "sdk"],
+    domain: "Services",
+    description: "Service layer, providers, and external client SDKs"
   }
 ];
 

package/src/core/scan.js

@@ -29,13 +29,22 @@ function isExpressRoute(content) {
 }
 
 function isReactRouterFile(content) {
-  // Detect React Router patterns
-  return content.includes("<Route") || content.includes("createBrowserRouter") || content.includes("createRoutesFromElements");
+  // Detect React Router patterns — require import evidence, not just string mentions
+  const hasImport = /import\s+.*?from\s+['"]react-router/.test(content)
+    || /require\s*\(\s*['"]react-router/.test(content);
+  const hasJSX = /<Route\s/.test(content);
+  const hasFactory = /createBrowserRouter\s*\(/.test(content)
+    || /createRoutesFromElements\s*\(/.test(content);
+  return hasImport || hasJSX || hasFactory;
 }
 
 function isVueRouterFile(content) {
-  // Detect Vue Router patterns  
-  return (content.includes("createRouter") || content.includes("VueRouter")) && content.includes("routes");
+  // Detect Vue Router patterns — require import evidence, not just string mentions
+  const hasImport = /import\s+.*?from\s+['"]vue-router/.test(content)
+    || /require\s*\(\s*['"]vue-router/.test(content);
+  const hasConstructor = /new\s+VueRouter\s*\(/.test(content);
+  const hasFactory = /createRouter\s*\(/.test(content) && hasImport;
+  return hasImport || hasConstructor || hasFactory;
 }
 
 function isNextPage(file) {
@@ -159,6 +168,10 @@ async function extractRepoMetadata(repoRoot) {
     if (allDeps["nestjs"] || allDeps["@nestjs/core"]) metadata.frameworks.push("NestJS");
     if (allDeps["svelte"]) metadata.frameworks.push("Svelte");
     if (allDeps["solid-js"]) metadata.frameworks.push("Solid");
+    if (allDeps["hono"]) metadata.frameworks.push("Hono");
+    if (allDeps["koa"]) metadata.frameworks.push("Koa");
+    if (allDeps["hapi"] || allDeps["@hapi/hapi"]) metadata.frameworks.push("Hapi");
+    if (allDeps["electron"]) metadata.frameworks.push("Electron");
 
     // Detect test frameworks
     if (allDeps["vitest"]) metadata.testFrameworks.push("Vitest");
@@ -166,6 +179,7 @@ async function extractRepoMetadata(repoRoot) {
     if (allDeps["mocha"]) metadata.testFrameworks.push("Mocha");
     if (allDeps["playwright"]) metadata.testFrameworks.push("Playwright");
     if (allDeps["cypress"]) metadata.testFrameworks.push("Cypress");
+    if (allDeps["ava"]) metadata.testFrameworks.push("Ava");
 
     // Detect build tools
     if (allDeps["vite"]) metadata.buildTools.push("Vite");
@@ -173,9 +187,25 @@ async function extractRepoMetadata(repoRoot) {
     if (allDeps["rollup"]) metadata.buildTools.push("Rollup");
     if (allDeps["esbuild"]) metadata.buildTools.push("esbuild");
     if (allDeps["turbo"]) metadata.buildTools.push("Turborepo");
+    if (allDeps["tsup"]) metadata.buildTools.push("tsup");
+    if (allDeps["swc"] || allDeps["@swc/core"]) metadata.buildTools.push("SWC");
+    if (allDeps["parcel"]) metadata.buildTools.push("Parcel");
 
-    // Detect TypeScript
+    // Detect languages
     if (allDeps["typescript"]) metadata.languages.add("TypeScript");
+
+    // Infer JavaScript if package.json exists (any npm project uses JS/Node)
+    metadata.languages.add("JavaScript");
+
+    // Detect Node.js runtime indicators
+    const hasNodeEngines = pkg.engines && pkg.engines.node;
+    const hasBin = pkg.bin != null;
+    const hasNodeDeps = allDeps["node-fetch"] || allDeps["fs-extra"] || allDeps["dotenv"]
+      || allDeps["commander"] || allDeps["yargs"] || allDeps["chalk"]
+      || allDeps["inquirer"] || allDeps["ora"] || allDeps["execa"];
+    if (hasNodeEngines || hasBin || hasNodeDeps || pkg.type === "module") {
+      metadata.languages.add("Node.js");
+    }
   } catch {
     // No package.json or invalid JSON
   }
@@ -241,30 +271,29 @@ function extractExpressRoutes(content) {
 
 function extractReactRoutes(content, file) {
   const routes = [];
+  const lines = content.split("\n");
   
   // Match <Route path="..." />
   const routePattern = /<Route\s+[^>]*path\s*=\s*['"`]([^'"`]+)['"`][^>]*\/?>/gi;
   let match;
 
   while ((match = routePattern.exec(content)) !== null) {
-    const [, path] = match;
-    routes.push({
-      file,
-      path,
-      framework: "React Router"
-    });
+    const [, routePath] = match;
+    if (isValidRoutePath(routePath)) {
+      routes.push({ file, path: routePath, framework: "React Router" });
+    }
   }
 
-  // Match path: "..." in route objects  
-  const objectPattern = /path\s*:\s*['"`]([^'"`]+)['"`]/gi;
-  while ((match = objectPattern.exec(content)) !== null) {
-    const [, path] = match;
-    if (!routes.some(r => r.path === path)) {
-      routes.push({
-        file,
-        path,
-        framework: "React Router"
-      });
+  // Match path: "..." in route objects (skip comment lines)
+  for (const line of lines) {
+    const trimmed = line.trim();
+    if (trimmed.startsWith("//") || trimmed.startsWith("*") || trimmed.startsWith("/*")) continue;
+    const objectMatch = /path\s*:\s*['"`]([^'"`]+)['"`]/i.exec(trimmed);
+    if (objectMatch) {
+      const routePath = objectMatch[1];
+      if (isValidRoutePath(routePath) && !routes.some(r => r.path === routePath)) {
+        routes.push({ file, path: routePath, framework: "React Router" });
+      }
     }
   }
 
@@ -273,23 +302,31 @@ function extractReactRoutes(content, file) {
 
 function extractVueRoutes(content, file) {
   const routes = [];
-  
-  // Match path: '...' or path: "..." in Vue router definitions
-  const pathPattern = /path\s*:\s*['"`]([^'"`]+)['"`]/gi;
-  let match;
-
-  while ((match = pathPattern.exec(content)) !== null) {
-    const [, path] = match;
-    routes.push({
-      file,
-      path,
-      framework: "Vue Router"
-    });
+  const lines = content.split("\n");
+
+  // Match path: '...' or path: "..." in Vue router definitions (skip comment lines)
+  for (const line of lines) {
+    const trimmed = line.trim();
+    if (trimmed.startsWith("//") || trimmed.startsWith("*") || trimmed.startsWith("/*")) continue;
+    const match = /path\s*:\s*['"`]([^'"`]+)['"`]/i.exec(trimmed);
+    if (match) {
+      const routePath = match[1];
+      if (isValidRoutePath(routePath) && !routes.some(r => r.path === routePath)) {
+        routes.push({ file, path: routePath, framework: "Vue Router" });
+      }
+    }
   }
 
   return routes;
 }
 
+function isValidRoutePath(p) {
+  // Filter out placeholder/documentation strings and non-path values
+  if (!p || p === "..." || p === "*" || p.length > 200) return false;
+  // Must look like a URL path (starts with / or is a relative segment)
+  return p.startsWith("/") || /^[a-zA-Z0-9]/.test(p);
+}
+
 export async function scanRepo(cfg) {
   const repoRoot = cfg.__repoRoot;
 

package/src/docs/generate-doc-set.js

@@ -208,7 +208,7 @@ async function generateDocument(docPlan, context) {
       return renderApiSurfaceOriginal(config, scanResult);
       
     case "data_flows":
-      return await generateDataFlows(flows, aiContext, { depGraph, scanResult: hookScanResult });
+      return await generateDataFlows(flows, aiContext, { depGraph, scanResult });
       
     case "arch_diff":
       if (!diffData) {

package/src/renderers/renderMap.js

@@ -90,15 +90,23 @@ function buildModuleGraph(modules, depGraph) {
 
 /**
  * Find which module a file belongs to.
+ * Edge keys from the dep graph are extensionless (e.g. "src/core/config")
+ * while module keys may include extensions (e.g. "src/core/config.js").
+ * We try both direct match and extension-stripped match.
  */
 function findModuleForFile(fileKey, modules) {
   const normalized = fileKey.replace(/\\/g, "/");
-  // Find the most specific (longest) matching module key
   let bestMatch = null;
   for (const mod of modules) {
-    if (normalized.startsWith(mod.key) || normalized.startsWith(mod.key + "/")) {
-      if (!bestMatch || mod.key.length > bestMatch.length) {
-        bestMatch = mod.key;
+    const modKey = mod.key;
+    // Direct match (with or without extension)
+    if (normalized === modKey || normalized === modKey.replace(/\.[^/.]+$/, "")) {
+      return modKey;
+    }
+    // Prefix match: file is inside this module
+    if (normalized.startsWith(modKey + "/") || normalized.startsWith(modKey.replace(/\.[^/.]+$/, "") + "/")) {
+      if (!bestMatch || modKey.length > bestMatch.length) {
+        bestMatch = modKey;
       }
     }
   }
@@ -107,13 +115,25 @@ function findModuleForFile(fileKey, modules) {
 
 function categorizeModule(key) {
   const normalized = key.toLowerCase();
-  if (normalized.includes("core")) return "core";
-  if (normalized.includes("publisher")) return "integration";
-  if (normalized.includes("renderer")) return "business";
-  if (normalized.includes("delivery")) return "integration";
-  if (normalized.includes("util")) return "util";
-  if (normalized.includes("test")) return "test";
-  if (normalized.includes("bin")) return "cli";
+  if (normalized.includes("test") || normalized.includes("spec")) return "test";
+  if (normalized.includes("core") || normalized.includes("kernel")) return "core";
+  if (normalized.includes("analyz") || normalized.includes("detect") || normalized.includes("inspect")) return "analyzer";
+  if (normalized.includes("render") || normalized.includes("format") || normalized.includes("template")) return "renderer";
+  if (normalized.includes("publish") || normalized.includes("output")) return "publisher";
+  if (normalized.includes("deliver") || normalized.includes("dispatch")) return "delivery";
+  if (normalized.includes("integrat") || normalized.includes("connect") || normalized.includes("adapter")) return "integration";
+  if (normalized.includes("util") || normalized.includes("helper") || normalized.includes("lib") || normalized.includes("common")) return "util";
+  if (normalized.includes("ai") || normalized.includes("llm") || normalized.includes("prompt")) return "ai";
+  if (normalized.includes("doc") || normalized.includes("generate")) return "docs";
+  if (normalized.includes("plugin") || normalized.includes("extension")) return "plugin";
+  if (normalized.includes("config") || normalized.includes("setting")) return "config";
+  if (normalized.includes("cli") || normalized.includes("bin") || normalized.includes("command")) return "cli";
+  if (normalized.includes("api") || normalized.includes("endpoint")) return "api";
+  if (normalized.includes("component") || normalized.includes("ui")) return "ui";
+  if (normalized.includes("page") || normalized.includes("route") || normalized.includes("view")) return "page";
+  if (normalized.includes("store") || normalized.includes("state")) return "state";
+  if (normalized.includes("middleware")) return "middleware";
+  if (normalized.includes("service")) return "service";
   return "other";
 }
 
@@ -122,8 +142,21 @@ function generateUnicodeArchitectureDiagram(nodes, relationships) {
   const categories = {
     cli: { icon: "🎯", label: "CLI Entry", nodes: [] },
     core: { icon: "⚙️", label: "Core Logic", nodes: [] },
-    business: { icon: "📋", label: "Business Logic", nodes: [] },
+    config: { icon: "🔧", label: "Configuration", nodes: [] },
+    analyzer: { icon: "🔍", label: "Analysis", nodes: [] },
+    ai: { icon: "🤖", label: "AI / ML", nodes: [] },
+    docs: { icon: "📝", label: "Documentation", nodes: [] },
+    renderer: { icon: "📋", label: "Rendering", nodes: [] },
+    publisher: { icon: "📤", label: "Publishing", nodes: [] },
+    delivery: { icon: "📬", label: "Delivery", nodes: [] },
     integration: { icon: "🔌", label: "Integration", nodes: [] },
+    plugin: { icon: "🧩", label: "Plugins", nodes: [] },
+    api: { icon: "🌐", label: "API Layer", nodes: [] },
+    ui: { icon: "🖼️", label: "UI Components", nodes: [] },
+    page: { icon: "📄", label: "Pages / Routes", nodes: [] },
+    state: { icon: "💾", label: "State Management", nodes: [] },
+    middleware: { icon: "🔀", label: "Middleware", nodes: [] },
+    service: { icon: "⚡", label: "Services", nodes: [] },
     util: { icon: "🛠️", label: "Utilities", nodes: [] },
     test: { icon: "✅", label: "Testing", nodes: [] },
     other: { icon: "📦", label: "Other", nodes: [] }
@@ -235,5 +268,53 @@ export function renderSystemMap(scan, config, depGraph) {
     ""
   ];
 
+  // Add key connections summary when we have relationships
+  if (relationships.length > 0) {
+    lines.push("---", "", "## Key Connections", "");
+
+    // Find most-depended-on modules (highest in-degree)
+    const inDegree = new Map();
+    const outDegree = new Map();
+    for (const rel of relationships) {
+      inDegree.set(rel.to, (inDegree.get(rel.to) || 0) + (rel.weight || 1));
+      outDegree.set(rel.from, (outDegree.get(rel.from) || 0) + (rel.weight || 1));
+    }
+
+    const topDeps = [...inDegree.entries()]
+      .sort((a, b) => b[1] - a[1])
+      .slice(0, 5);
+
+    if (topDeps.length > 0) {
+      lines.push("**Most depended-on modules** (highest import count):", "");
+      lines.push("| Module | Imported by |");
+      lines.push("|--------|------------|");
+      for (const [nodeId, count] of topDeps) {
+        const node = nodes.find(n => n.id === nodeId);
+        if (node) {
+          lines.push(`| \`${node.label}\` | ${count} module${count !== 1 ? "s" : ""} |`);
+        }
+      }
+      lines.push("");
+    }
+
+    // Find modules with highest out-degree (most dependencies)
+    const topConsumers = [...outDegree.entries()]
+      .sort((a, b) => b[1] - a[1])
+      .slice(0, 5);
+
+    if (topConsumers.length > 0) {
+      lines.push("**Most dependent modules** (highest dependency count):", "");
+      lines.push("| Module | Depends on |");
+      lines.push("|--------|-----------|");
+      for (const [nodeId, count] of topConsumers) {
+        const node = nodes.find(n => n.id === nodeId);
+        if (node) {
+          lines.push(`| \`${node.label}\` | ${count} module${count !== 1 ? "s" : ""} |`);
+        }
+      }
+      lines.push("");
+    }
+  }
+
   return lines.join("\n");
 }