gitfamiliar 0.1.1 → 0.3.0

package/dist/bin/gitfamiliar.js

@@ -1,8 +1,16 @@
 #!/usr/bin/env node
 import {
+  GitClient,
+  GitHubClient,
+  buildFileTree,
   computeFamiliarity,
-  parseExpirationConfig
-} from "../chunk-DW2PHZVZ.js";
+  createFilter,
+  parseExpirationConfig,
+  processBatch,
+  resolveGitHubToken,
+  resolveUser,
+  walkFiles
+} from "../chunk-N6J2OJKF.js";
 
 // src/cli/index.ts
 import { Command } from "commander";
@@ -26,34 +34,66 @@ function parseOptions(raw, repoPath) {
     weights = parseWeights(raw.weights);
   }
   const expiration = raw.expiration ? parseExpirationConfig(raw.expiration) : DEFAULT_EXPIRATION;
+  let user;
+  if (raw.user && raw.user.length === 1) {
+    user = raw.user[0];
+  } else if (raw.user && raw.user.length > 1) {
+    user = raw.user;
+  }
+  let hotspot;
+  if (raw.hotspot !== void 0 && raw.hotspot !== false) {
+    if (raw.hotspot === "team") {
+      hotspot = "team";
+    } else {
+      hotspot = "personal";
+    }
+  }
+  const windowDays = raw.window ? parseInt(raw.window, 10) : void 0;
   return {
     mode,
-    user: raw.user,
+    user,
     filter,
     expiration,
     html: raw.html || false,
     weights,
-    repoPath
+    repoPath,
+    team: raw.team || false,
+    teamCoverage: raw.teamCoverage || false,
+    hotspot,
+    window: windowDays,
+    githubUrl: raw.githubUrl,
+    checkGithub: raw.checkGithub || false
   };
 }
 function validateMode(mode) {
-  const valid = ["binary", "authorship", "review-coverage", "weighted"];
+  const valid = [
+    "binary",
+    "authorship",
+    "review-coverage",
+    "weighted"
+  ];
   if (!valid.includes(mode)) {
-    throw new Error(`Invalid mode: "${mode}". Valid modes: ${valid.join(", ")}`);
+    throw new Error(
+      `Invalid mode: "${mode}". Valid modes: ${valid.join(", ")}`
+    );
   }
   return mode;
 }
 function validateFilter(filter) {
   const valid = ["all", "written", "reviewed"];
   if (!valid.includes(filter)) {
-    throw new Error(`Invalid filter: "${filter}". Valid filters: ${valid.join(", ")}`);
+    throw new Error(
+      `Invalid filter: "${filter}". Valid filters: ${valid.join(", ")}`
+    );
   }
   return filter;
 }
 function parseWeights(s) {
   const parts = s.split(",").map(Number);
   if (parts.length !== 3 || parts.some(isNaN)) {
-    throw new Error(`Invalid weights: "${s}". Expected format: "0.5,0.35,0.15"`);
+    throw new Error(
+      `Invalid weights: "${s}". Expected format: "0.5,0.35,0.15"`
+    );
   }
   const sum = parts[0] + parts[1] + parts[2];
   if (Math.abs(sum - 1) > 0.01) {
@@ -299,11 +339,11 @@ function scoreColor(score) {
   return d3.interpolateRgb('#f5a623', '#27ae60')(t);
 }
 
-function getFileScore(file) {
-  if (mode !== 'binary') return file.score;
-  if (currentFilter === 'written') return file.isWritten ? 1 : 0;
-  if (currentFilter === 'reviewed') return file.isReviewed ? 1 : 0;
-  return file.score;
+function getNodeScore(node) {
+  if (mode !== 'binary') return node.score;
+  if (currentFilter === 'written') return node.isWritten ? 1 : 0;
+  if (currentFilter === 'reviewed') return node.isReviewed ? 1 : 0;
+  return node.score;
 }
 
 function findNode(node, path) {
@@ -317,17 +357,23 @@ function findNode(node, path) {
   return null;
 }
 
-function flattenFiles(node) {
-  const files = [];
-  function walk(n) {
-    if (n.type === 'file') {
-      files.push(n);
-    } else if (n.children) {
-      n.children.forEach(walk);
-    }
+function totalLines(node) {
+  if (node.type === 'file') return Math.max(1, node.lines);
+  if (!node.children) return 1;
+  let sum = 0;
+  for (const c of node.children) sum += totalLines(c);
+  return Math.max(1, sum);
+}
+
+function buildHierarchy(node) {
+  if (node.type === 'file') {
+    return { name: node.path.split('/').pop(), data: node, value: Math.max(1, node.lines) };
   }
-  walk(node);
-  return files;
+  return {
+    name: node.path.split('/').pop() || node.path,
+    data: node,
+    children: (node.children || []).map(c => buildHierarchy(c)),
+  };
 }
 
 function render() {
@@ -344,18 +390,13 @@ function render() {
   const targetNode = currentPath ? findNode(rawData, currentPath) : rawData;
   if (!targetNode) return;
 
+  const children = targetNode.children || [];
+  if (children.length === 0) return;
+
+  // Build full nested hierarchy from the current target
   const hierarchyData = {
     name: targetNode.path || 'root',
-    children: (targetNode.children || []).map(function buildChild(c) {
-      if (c.type === 'file') {
-        return { name: c.path.split('/').pop(), data: c, value: Math.max(1, c.lines) };
-      }
-      return {
-        name: c.path.split('/').pop(),
-        data: c,
-        children: (c.children || []).map(buildChild),
-      };
-    }),
+    children: children.map(c => buildHierarchy(c)),
   };
 
   const root = d3.hierarchy(hierarchyData)
@@ -365,7 +406,7 @@ function render() {
   d3.treemap()
     .size([width, height])
     .padding(2)
-    .paddingTop(18)
+    .paddingTop(20)
     .round(true)(root);
 
   const svg = d3.select('#treemap')
@@ -375,77 +416,94 @@ function render() {
 
   const tooltip = document.getElementById('tooltip');
 
-  // Draw groups (folders)
+  const nodes = root.descendants().filter(d => d.depth > 0);
+
   const groups = svg.selectAll('g')
-    .data(root.descendants().filter(d => d.depth > 0))
+    .data(nodes)
     .join('g')
     .attr('transform', d => \`translate(\${d.x0},\${d.y0})\`);
 
+  // Rect
   groups.append('rect')
     .attr('width', d => Math.max(0, d.x1 - d.x0))
     .attr('height', d => Math.max(0, d.y1 - d.y0))
     .attr('fill', d => {
-      if (d.data.data) {
-        const score = d.children ? d.data.data.score : getFileScore(d.data.data);
-        return scoreColor(score);
-      }
-      return '#333';
+      if (!d.data.data) return '#333';
+      return scoreColor(getNodeScore(d.data.data));
     })
-    .attr('opacity', d => d.children ? 0.3 : 0.85)
+    .attr('opacity', d => d.children ? 0.35 : 0.88)
     .attr('stroke', '#1a1a2e')
-    .attr('stroke-width', 1)
+    .attr('stroke-width', d => d.children ? 1 : 0.5)
     .attr('rx', 2)
-    .style('cursor', d => d.children ? 'pointer' : 'default')
+    .style('cursor', d => (d.data.data && d.data.data.type === 'folder') ? 'pointer' : 'default')
     .on('click', (event, d) => {
-      if (d.children && d.data.data && d.data.data.type === 'folder') {
+      if (d.data.data && d.data.data.type === 'folder') {
+        event.stopPropagation();
         zoomTo(d.data.data.path);
       }
     })
-    .on('mouseover', (event, d) => {
+    .on('mouseover', function(event, d) {
       if (!d.data.data) return;
-      const data = d.data.data;
-      const name = data.path || d.data.name;
-      const score = d.children ? data.score : getFileScore(data);
-      let html = \`<strong>\${name}</strong><br>Score: \${Math.round(score * 100)}%<br>Lines: \${data.lines}\`;
-      if (data.type === 'folder') {
-        html += \`<br>Files: \${data.fileCount}\`;
-      }
-      if (data.blameScore !== undefined) {
-        html += \`<br>Blame: \${Math.round(data.blameScore * 100)}%\`;
-      }
-      if (data.commitScore !== undefined) {
-        html += \`<br>Commit: \${Math.round(data.commitScore * 100)}%\`;
-      }
-      if (data.reviewScore !== undefined) {
-        html += \`<br>Review: \${Math.round(data.reviewScore * 100)}%\`;
-      }
-      tooltip.innerHTML = html;
-      tooltip.style.display = 'block';
+      d3.select(this).attr('opacity', d.children ? 0.5 : 1).attr('stroke', '#fff');
+      showTooltip(d.data.data, event);
     })
     .on('mousemove', (event) => {
-      tooltip.style.left = (event.pageX + 12) + 'px';
-      tooltip.style.top = (event.pageY - 12) + 'px';
+      tooltip.style.left = (event.pageX + 14) + 'px';
+      tooltip.style.top = (event.pageY - 14) + 'px';
     })
-    .on('mouseout', () => {
+    .on('mouseout', function(event, d) {
+      d3.select(this).attr('opacity', d.children ? 0.35 : 0.88).attr('stroke', '#1a1a2e');
       tooltip.style.display = 'none';
     });
 
   // Labels
   groups.append('text')
     .attr('x', 4)
-    .attr('y', 13)
+    .attr('y', 14)
     .attr('fill', '#fff')
-    .attr('font-size', '11px')
+    .attr('font-size', d => d.children ? '11px' : '10px')
     .attr('font-weight', d => d.children ? 'bold' : 'normal')
+    .style('pointer-events', 'none')
     .text(d => {
-      const w = (d.x1 - d.x0);
+      const w = d.x1 - d.x0;
+      const h = d.y1 - d.y0;
       const name = d.data.name || '';
-      if (w < 40) return '';
-      if (w < name.length * 7) return name.slice(0, Math.floor(w / 7)) + '..';
+      if (w < 36 || h < 18) return '';
+      const maxChars = Math.floor((w - 8) / 6.5);
+      if (name.length > maxChars) return name.slice(0, maxChars - 1) + '\\u2026';
       return name;
     });
 }
 
+function showTooltip(data, event) {
+  const tooltip = document.getElementById('tooltip');
+  const name = data.path || '';
+  const score = getNodeScore(data);
+  let html = '<strong>' + name + '</strong>';
+  html += '<br>Score: ' + Math.round(score * 100) + '%';
+  html += '<br>Lines: ' + data.lines.toLocaleString();
+  if (data.type === 'folder') {
+    html += '<br>Files: ' + data.fileCount;
+    html += '<br><em style="color:#5eadf7">Click to drill down \\u25B6</em>';
+  }
+  if (data.blameScore !== undefined) {
+    html += '<br>Blame: ' + Math.round(data.blameScore * 100) + '%';
+  }
+  if (data.commitScore !== undefined) {
+    html += '<br>Commit: ' + Math.round(data.commitScore * 100) + '%';
+  }
+  if (data.reviewScore !== undefined) {
+    html += '<br>Review: ' + Math.round(data.reviewScore * 100) + '%';
+  }
+  if (data.isExpired) {
+    html += '<br><span style="color:#e94560">Expired</span>';
+  }
+  tooltip.innerHTML = html;
+  tooltip.style.display = 'block';
+  tooltip.style.left = (event.pageX + 14) + 'px';
+  tooltip.style.top = (event.pageY - 14) + 'px';
+}
+
 function zoomTo(path) {
   currentPath = path;
   updateBreadcrumb();
@@ -487,13 +545,1728 @@ async function generateAndOpenHTML(result, repoPath) {
   await openBrowser(outputPath);
 }
 
-// src/cli/index.ts
-function createProgram() {
-  const program2 = new Command();
-  program2.name("gitfamiliar").description("Visualize your code familiarity from Git history").version("0.1.0").option("-m, --mode <mode>", "Scoring mode: binary, authorship, review-coverage, weighted", "binary").option("-u, --user <user>", "Git user name or email (defaults to git config)").option("-f, --filter <filter>", "Filter mode: all, written, reviewed", "all").option("-e, --expiration <policy>", "Expiration policy: never, time:180d, change:50%, combined:365d:50%", "never").option("--html", "Generate HTML treemap report", false).option("-w, --weights <weights>", 'Weights for weighted mode: blame,commit,review (e.g., "0.5,0.35,0.15")').action(async (rawOptions) => {
-    try {
-      const repoPath = process.cwd();
-      const options = parseOptions(rawOptions, repoPath);
+// src/git/contributors.ts
+var COMMIT_SEP = "GITFAMILIAR_SEP";
+async function getAllContributors(gitClient, minCommits = 1) {
+  const output = await gitClient.getLog([
+    "--all",
+    `--format=%aN|%aE`
+  ]);
+  const counts = /* @__PURE__ */ new Map();
+  for (const line of output.trim().split("\n")) {
+    if (!line.includes("|")) continue;
+    const [name, email] = line.split("|", 2);
+    if (!name || !email) continue;
+    const key = email.toLowerCase();
+    const existing = counts.get(key);
+    if (existing) {
+      existing.count++;
+    } else {
+      counts.set(key, { name: name.trim(), email: email.trim(), count: 1 });
+    }
+  }
+  return Array.from(counts.values()).filter((c) => c.count >= minCommits).sort((a, b) => b.count - a.count).map((c) => ({ name: c.name, email: c.email }));
+}
+async function bulkGetFileContributors(gitClient, trackedFiles) {
+  const output = await gitClient.getLog([
+    "--all",
+    "--name-only",
+    `--format=${COMMIT_SEP}%aN|%aE`
+  ]);
+  const result = /* @__PURE__ */ new Map();
+  let currentAuthor = "";
+  for (const line of output.split("\n")) {
+    if (line.startsWith(COMMIT_SEP)) {
+      const parts = line.slice(COMMIT_SEP.length).split("|", 2);
+      currentAuthor = parts[0]?.trim() || "";
+      continue;
+    }
+    const filePath = line.trim();
+    if (!filePath || !currentAuthor) continue;
+    if (!trackedFiles.has(filePath)) continue;
+    let contributors = result.get(filePath);
+    if (!contributors) {
+      contributors = /* @__PURE__ */ new Set();
+      result.set(filePath, contributors);
+    }
+    contributors.add(currentAuthor);
+  }
+  return result;
+}
+
+// src/core/team-coverage.ts
+async function computeTeamCoverage(options) {
+  const gitClient = new GitClient(options.repoPath);
+  if (!await gitClient.isRepo()) {
+    throw new Error(`"${options.repoPath}" is not a git repository.`);
+  }
+  const repoRoot = await gitClient.getRepoRoot();
+  const repoName = await gitClient.getRepoName();
+  const filter = createFilter(repoRoot);
+  const tree = await buildFileTree(gitClient, filter);
+  const trackedFiles = /* @__PURE__ */ new Set();
+  walkFiles(tree, (f) => trackedFiles.add(f.path));
+  const fileContributors = await bulkGetFileContributors(gitClient, trackedFiles);
+  const allContributors = await getAllContributors(gitClient);
+  const coverageTree = buildCoverageTree(tree, fileContributors);
+  const riskFiles = [];
+  walkCoverageFiles(coverageTree, (f) => {
+    if (f.contributorCount <= 1) {
+      riskFiles.push(f);
+    }
+  });
+  riskFiles.sort((a, b) => a.contributorCount - b.contributorCount);
+  return {
+    tree: coverageTree,
+    repoName,
+    totalContributors: allContributors.length,
+    totalFiles: tree.fileCount,
+    riskFiles,
+    overallBusFactor: calculateBusFactor(fileContributors)
+  };
+}
+function classifyRisk(contributorCount) {
+  if (contributorCount <= 1) return "risk";
+  if (contributorCount <= 3) return "moderate";
+  return "safe";
+}
+function buildCoverageTree(node, fileContributors) {
+  const children = [];
+  for (const child of node.children) {
+    if (child.type === "file") {
+      const contributors = fileContributors.get(child.path);
+      const names = contributors ? Array.from(contributors) : [];
+      children.push({
+        type: "file",
+        path: child.path,
+        lines: child.lines,
+        contributorCount: names.length,
+        contributors: names,
+        riskLevel: classifyRisk(names.length)
+      });
+    } else {
+      children.push(buildCoverageTree(child, fileContributors));
+    }
+  }
+  const fileScores = [];
+  walkCoverageFiles({ type: "folder", path: "", lines: 0, fileCount: 0, avgContributors: 0, busFactor: 0, riskLevel: "safe", children }, (f) => {
+    fileScores.push(f);
+  });
+  const totalContributors = fileScores.reduce((sum, f) => sum + f.contributorCount, 0);
+  const avgContributors = fileScores.length > 0 ? totalContributors / fileScores.length : 0;
+  const folderFileContributors = /* @__PURE__ */ new Map();
+  for (const f of fileScores) {
+    folderFileContributors.set(f.path, new Set(f.contributors));
+  }
+  const busFactor = calculateBusFactor(folderFileContributors);
+  return {
+    type: "folder",
+    path: node.path,
+    lines: node.lines,
+    fileCount: node.fileCount,
+    avgContributors: Math.round(avgContributors * 10) / 10,
+    busFactor,
+    riskLevel: classifyRisk(busFactor),
+    children
+  };
+}
+function walkCoverageFiles(node, visitor) {
+  if (node.type === "file") {
+    visitor(node);
+  } else {
+    for (const child of node.children) {
+      walkCoverageFiles(child, visitor);
+    }
+  }
+}
+function calculateBusFactor(fileContributors) {
+  const totalFiles = fileContributors.size;
+  if (totalFiles === 0) return 0;
+  const target = Math.ceil(totalFiles * 0.5);
+  const contributorFiles = /* @__PURE__ */ new Map();
+  for (const [file, contributors] of fileContributors) {
+    for (const contributor of contributors) {
+      let files = contributorFiles.get(contributor);
+      if (!files) {
+        files = /* @__PURE__ */ new Set();
+        contributorFiles.set(contributor, files);
+      }
+      files.add(file);
+    }
+  }
+  const coveredFiles = /* @__PURE__ */ new Set();
+  let count = 0;
+  while (coveredFiles.size < target && contributorFiles.size > 0) {
+    let bestContributor = "";
+    let bestNewFiles = 0;
+    for (const [contributor, files2] of contributorFiles) {
+      let newFiles = 0;
+      for (const file of files2) {
+        if (!coveredFiles.has(file)) newFiles++;
+      }
+      if (newFiles > bestNewFiles) {
+        bestNewFiles = newFiles;
+        bestContributor = contributor;
+      }
+    }
+    if (bestNewFiles === 0) break;
+    const files = contributorFiles.get(bestContributor);
+    for (const file of files) {
+      coveredFiles.add(file);
+    }
+    contributorFiles.delete(bestContributor);
+    count++;
+  }
+  return count;
+}
+
+// src/cli/output/coverage-terminal.ts
+import chalk2 from "chalk";
+function riskBadge(level) {
+  switch (level) {
+    case "risk":
+      return chalk2.bgRed.white(" RISK ");
+    case "moderate":
+      return chalk2.bgYellow.black(" MOD  ");
+    case "safe":
+      return chalk2.bgGreen.black(" SAFE ");
+    default:
+      return level;
+  }
+}
+function riskColor(level) {
+  switch (level) {
+    case "risk":
+      return chalk2.red;
+    case "moderate":
+      return chalk2.yellow;
+    default:
+      return chalk2.green;
+  }
+}
+function renderFolder2(node, indent, maxDepth) {
+  const lines = [];
+  const sorted = [...node.children].sort((a, b) => {
+    if (a.type !== b.type) return a.type === "folder" ? -1 : 1;
+    return a.path.localeCompare(b.path);
+  });
+  for (const child of sorted) {
+    if (child.type === "folder") {
+      const prefix = "  ".repeat(indent);
+      const name = (child.path.split("/").pop() || child.path) + "/";
+      const color = riskColor(child.riskLevel);
+      lines.push(
+        `${prefix}${chalk2.bold(name.padEnd(24))} ${String(child.avgContributors).padStart(4)} avg    ${String(child.busFactor).padStart(2)}       ${riskBadge(child.riskLevel)}`
+      );
+      if (indent < maxDepth) {
+        lines.push(...renderFolder2(child, indent + 1, maxDepth));
+      }
+    }
+  }
+  return lines;
+}
+function renderCoverageTerminal(result) {
+  console.log("");
+  console.log(
+    chalk2.bold(
+      `GitFamiliar \u2014 Team Coverage (${result.totalFiles} files, ${result.totalContributors} contributors)`
+    )
+  );
+  console.log("");
+  const bfColor = result.overallBusFactor <= 1 ? chalk2.red : result.overallBusFactor <= 2 ? chalk2.yellow : chalk2.green;
+  console.log(`Overall Bus Factor: ${bfColor.bold(String(result.overallBusFactor))}`);
+  console.log("");
+  if (result.riskFiles.length > 0) {
+    console.log(chalk2.red.bold(`Risk Files (0-1 contributors):`));
+    const displayFiles = result.riskFiles.slice(0, 20);
+    for (const file of displayFiles) {
+      const count = file.contributorCount;
+      const names = file.contributors.join(", ");
+      const label = count === 0 ? chalk2.red("0 people") : chalk2.yellow(`1 person  (${names})`);
+      console.log(`  ${file.path.padEnd(40)} ${label}`);
+    }
+    if (result.riskFiles.length > 20) {
+      console.log(
+        chalk2.gray(`  ... and ${result.riskFiles.length - 20} more`)
+      );
+    }
+    console.log("");
+  } else {
+    console.log(chalk2.green("No high-risk files found."));
+    console.log("");
+  }
+  console.log(chalk2.bold("Folder Coverage:"));
+  console.log(
+    chalk2.gray(
+      `  ${"Folder".padEnd(24)} ${"Avg Contrib".padStart(11)}  ${"Bus Factor".padStart(10)}   Risk`
+    )
+  );
+  const folderLines = renderFolder2(result.tree, 1, 2);
+  for (const line of folderLines) {
+    console.log(line);
+  }
+  console.log("");
+}
+
+// src/cli/output/coverage-html.ts
+import { writeFileSync as writeFileSync2 } from "fs";
+import { join as join2 } from "path";
+function generateCoverageHTML(result) {
+  const dataJson = JSON.stringify(result.tree);
+  const riskFilesJson = JSON.stringify(result.riskFiles);
+  return `<!DOCTYPE html>
+<html lang="en">
+<head>
+<meta charset="UTF-8">
+<meta name="viewport" content="width=device-width, initial-scale=1.0">
+<title>GitFamiliar \u2014 Team Coverage \u2014 ${result.repoName}</title>
+<style>
+  * { margin: 0; padding: 0; box-sizing: border-box; }
+  body {
+    font-family: -apple-system, BlinkMacSystemFont, 'Segoe UI', Roboto, sans-serif;
+    background: #1a1a2e;
+    color: #e0e0e0;
+    overflow: hidden;
+  }
+  #header {
+    padding: 16px 24px;
+    background: #16213e;
+    border-bottom: 1px solid #0f3460;
+    display: flex;
+    align-items: center;
+    justify-content: space-between;
+  }
+  #header h1 { font-size: 18px; color: #e94560; }
+  #header .info { font-size: 14px; color: #a0a0a0; }
+  #breadcrumb {
+    padding: 8px 24px;
+    background: #16213e;
+    font-size: 13px;
+    border-bottom: 1px solid #0f3460;
+  }
+  #breadcrumb span { cursor: pointer; color: #5eadf7; }
+  #breadcrumb span:hover { text-decoration: underline; }
+  #breadcrumb .sep { color: #666; margin: 0 4px; }
+  #main { display: flex; height: calc(100vh - 90px); }
+  #treemap { flex: 1; }
+  #sidebar {
+    width: 300px;
+    background: #16213e;
+    border-left: 1px solid #0f3460;
+    overflow-y: auto;
+    padding: 16px;
+  }
+  #sidebar h3 { font-size: 14px; margin-bottom: 12px; color: #e94560; }
+  #sidebar .risk-file {
+    padding: 6px 0;
+    border-bottom: 1px solid #0f3460;
+    font-size: 12px;
+  }
+  #sidebar .risk-file .path { color: #e0e0e0; word-break: break-all; }
+  #sidebar .risk-file .meta { color: #888; margin-top: 2px; }
+  #tooltip {
+    position: absolute;
+    pointer-events: none;
+    background: rgba(22, 33, 62, 0.95);
+    border: 1px solid #0f3460;
+    border-radius: 6px;
+    padding: 10px 14px;
+    font-size: 13px;
+    line-height: 1.6;
+    display: none;
+    z-index: 100;
+    max-width: 320px;
+  }
+  #legend {
+    position: absolute;
+    bottom: 16px;
+    left: 16px;
+    background: rgba(22, 33, 62, 0.9);
+    border: 1px solid #0f3460;
+    border-radius: 6px;
+    padding: 10px;
+    font-size: 12px;
+  }
+  #legend .row { display: flex; align-items: center; gap: 6px; margin: 3px 0; }
+  #legend .swatch { width: 14px; height: 14px; border-radius: 3px; }
+</style>
+</head>
+<body>
+<div id="header">
+  <h1>GitFamiliar \u2014 Team Coverage \u2014 ${result.repoName}</h1>
+  <div class="info">${result.totalFiles} files | ${result.totalContributors} contributors | Bus Factor: ${result.overallBusFactor}</div>
+</div>
+<div id="breadcrumb"><span onclick="zoomTo('')">root</span></div>
+<div id="main">
+  <div id="treemap"></div>
+  <div id="sidebar">
+    <h3>Risk Files (0-1 contributors)</h3>
+    <div id="risk-list"></div>
+  </div>
+</div>
+<div id="tooltip"></div>
+<div id="legend">
+  <div>Contributors</div>
+  <div class="row"><div class="swatch" style="background:#e94560"></div> 0\u20131 (Risk)</div>
+  <div class="row"><div class="swatch" style="background:#f5a623"></div> 2\u20133 (Moderate)</div>
+  <div class="row"><div class="swatch" style="background:#27ae60"></div> 4+ (Safe)</div>
+</div>
+
+<script src="https://d3js.org/d3.v7.min.js"></script>
+<script>
+const rawData = ${dataJson};
+const riskFiles = ${riskFilesJson};
+let currentPath = '';
+
+function coverageColor(count) {
+  if (count <= 0) return '#e94560';
+  if (count === 1) return '#d63c57';
+  if (count <= 3) return '#f5a623';
+  return '#27ae60';
+}
+
+function folderColor(riskLevel) {
+  switch (riskLevel) {
+    case 'risk': return '#e94560';
+    case 'moderate': return '#f5a623';
+    default: return '#27ae60';
+  }
+}
+
+function findNode(node, path) {
+  if (node.path === path) return node;
+  if (node.children) {
+    for (const child of node.children) {
+      const found = findNode(child, path);
+      if (found) return found;
+    }
+  }
+  return null;
+}
+
+function buildHierarchy(node) {
+  if (node.type === 'file') {
+    return { name: node.path.split('/').pop(), data: node, value: Math.max(1, node.lines) };
+  }
+  return {
+    name: node.path.split('/').pop() || node.path,
+    data: node,
+    children: (node.children || []).map(c => buildHierarchy(c)),
+  };
+}
+
+function render() {
+  const container = document.getElementById('treemap');
+  container.innerHTML = '';
+
+  const headerH = document.getElementById('header').offsetHeight;
+  const breadcrumbH = document.getElementById('breadcrumb').offsetHeight;
+  const width = container.offsetWidth;
+  const height = window.innerHeight - headerH - breadcrumbH;
+
+  const targetNode = currentPath ? findNode(rawData, currentPath) : rawData;
+  if (!targetNode || !targetNode.children || targetNode.children.length === 0) return;
+
+  const hierarchyData = {
+    name: targetNode.path || 'root',
+    children: targetNode.children.map(c => buildHierarchy(c)),
+  };
+
+  const root = d3.hierarchy(hierarchyData)
+    .sum(d => d.value || 0)
+    .sort((a, b) => (b.value || 0) - (a.value || 0));
+
+  d3.treemap()
+    .size([width, height])
+    .padding(2)
+    .paddingTop(20)
+    .round(true)(root);
+
+  const svg = d3.select('#treemap')
+    .append('svg')
+    .attr('width', width)
+    .attr('height', height);
+
+  const tooltip = document.getElementById('tooltip');
+  const nodes = root.descendants().filter(d => d.depth > 0);
+
+  const groups = svg.selectAll('g')
+    .data(nodes)
+    .join('g')
+    .attr('transform', d => \`translate(\${d.x0},\${d.y0})\`);
+
+  groups.append('rect')
+    .attr('width', d => Math.max(0, d.x1 - d.x0))
+    .attr('height', d => Math.max(0, d.y1 - d.y0))
+    .attr('fill', d => {
+      if (!d.data.data) return '#333';
+      if (d.data.data.type === 'file') return coverageColor(d.data.data.contributorCount);
+      return folderColor(d.data.data.riskLevel);
+    })
+    .attr('opacity', d => d.children ? 0.35 : 0.88)
+    .attr('stroke', '#1a1a2e')
+    .attr('stroke-width', d => d.children ? 1 : 0.5)
+    .attr('rx', 2)
+    .style('cursor', d => (d.data.data && d.data.data.type === 'folder') ? 'pointer' : 'default')
+    .on('click', (event, d) => {
+      if (d.data.data && d.data.data.type === 'folder') {
+        event.stopPropagation();
+        zoomTo(d.data.data.path);
+      }
+    })
+    .on('mouseover', function(event, d) {
+      if (!d.data.data) return;
+      d3.select(this).attr('opacity', d.children ? 0.5 : 1).attr('stroke', '#fff');
+      showTooltip(d.data.data, event);
+    })
+    .on('mousemove', (event) => {
+      tooltip.style.left = (event.pageX + 14) + 'px';
+      tooltip.style.top = (event.pageY - 14) + 'px';
+    })
+    .on('mouseout', function(event, d) {
+      d3.select(this).attr('opacity', d.children ? 0.35 : 0.88).attr('stroke', '#1a1a2e');
+      tooltip.style.display = 'none';
+    });
+
+  groups.append('text')
+    .attr('x', 4)
+    .attr('y', 14)
+    .attr('fill', '#fff')
+    .attr('font-size', d => d.children ? '11px' : '10px')
+    .attr('font-weight', d => d.children ? 'bold' : 'normal')
+    .style('pointer-events', 'none')
+    .text(d => {
+      const w = d.x1 - d.x0;
+      const h = d.y1 - d.y0;
+      const name = d.data.name || '';
+      if (w < 36 || h < 18) return '';
+      const maxChars = Math.floor((w - 8) / 6.5);
+      if (name.length > maxChars) return name.slice(0, maxChars - 1) + '\\u2026';
+      return name;
+    });
+}
+
+function showTooltip(data, event) {
+  const tooltip = document.getElementById('tooltip');
+  let html = '<strong>' + data.path + '</strong>';
+  if (data.type === 'file') {
+    html += '<br>Contributors: ' + data.contributorCount;
+    if (data.contributors.length > 0) {
+      html += '<br>' + data.contributors.slice(0, 8).join(', ');
+      if (data.contributors.length > 8) html += ', ...';
+    }
+    html += '<br>Lines: ' + data.lines.toLocaleString();
+  } else {
+    html += '<br>Files: ' + data.fileCount;
+    html += '<br>Avg Contributors: ' + data.avgContributors;
+    html += '<br>Bus Factor: ' + data.busFactor;
+    html += '<br><em style="color:#5eadf7">Click to drill down \\u25B6</em>';
+  }
+  tooltip.innerHTML = html;
+  tooltip.style.display = 'block';
+  tooltip.style.left = (event.pageX + 14) + 'px';
+  tooltip.style.top = (event.pageY - 14) + 'px';
+}
+
+function zoomTo(path) {
+  currentPath = path;
+  const el = document.getElementById('breadcrumb');
+  const parts = path ? path.split('/') : [];
+  let html = '<span onclick="zoomTo(\\'\\')">root</span>';
+  let accumulated = '';
+  for (const part of parts) {
+    accumulated = accumulated ? accumulated + '/' + part : part;
+    const p = accumulated;
+    html += '<span class="sep">/</span><span onclick="zoomTo(\\'' + p + '\\')">' + part + '</span>';
+  }
+  el.innerHTML = html;
+  render();
+}
+
+// Render risk sidebar
+function renderRiskSidebar() {
+  const container = document.getElementById('risk-list');
+  if (riskFiles.length === 0) {
+    container.innerHTML = '<div style="color:#888">No high-risk files found.</div>';
+    return;
+  }
+  let html = '';
+  for (const f of riskFiles.slice(0, 50)) {
+    const countLabel = f.contributorCount === 0 ? '0 people' : '1 person (' + f.contributors[0] + ')';
+    html += '<div class="risk-file"><div class="path">' + f.path + '</div><div class="meta">' + countLabel + '</div></div>';
+  }
+  if (riskFiles.length > 50) {
+    html += '<div style="color:#888;padding:8px 0">... and ' + (riskFiles.length - 50) + ' more</div>';
+  }
+  container.innerHTML = html;
+}
+
+window.addEventListener('resize', render);
+renderRiskSidebar();
+render();
+</script>
+</body>
+</html>`;
+}
+async function generateAndOpenCoverageHTML(result, repoPath) {
+  const html = generateCoverageHTML(result);
+  const outputPath = join2(repoPath, "gitfamiliar-coverage.html");
+  writeFileSync2(outputPath, html, "utf-8");
+  console.log(`Coverage report generated: ${outputPath}`);
+  await openBrowser(outputPath);
+}
+
+// src/core/multi-user.ts
+async function computeMultiUser(options) {
+  const gitClient = new GitClient(options.repoPath);
+  if (!await gitClient.isRepo()) {
+    throw new Error(`"${options.repoPath}" is not a git repository.`);
+  }
+  const repoName = await gitClient.getRepoName();
+  let userNames;
+  if (options.team) {
+    const contributors = await getAllContributors(gitClient, 3);
+    userNames = contributors.map((c) => c.name);
+    if (userNames.length === 0) {
+      throw new Error("No contributors found with 3+ commits.");
+    }
+    console.log(`Found ${userNames.length} contributors with 3+ commits`);
+  } else if (Array.isArray(options.user)) {
+    userNames = options.user;
+  } else if (options.user) {
+    userNames = [options.user];
+  } else {
+    const user = await resolveUser(gitClient);
+    userNames = [user.name || user.email];
+  }
+  const results = [];
+  await processBatch(
+    userNames,
+    async (userName) => {
+      const userOptions = {
+        ...options,
+        user: userName,
+        team: false,
+        teamCoverage: false
+      };
+      const result = await computeFamiliarity(userOptions);
+      results.push({ userName, result });
+    },
+    3
+  );
+  const users = results.map((r) => ({
+    name: r.result.userName,
+    email: ""
+  }));
+  const tree = mergeResults(results);
+  const userSummaries = results.map((r) => ({
+    user: { name: r.result.userName, email: "" },
+    writtenCount: r.result.writtenCount,
+    reviewedCount: r.result.reviewedCount,
+    overallScore: r.result.tree.score
+  }));
+  return {
+    tree,
+    repoName,
+    users,
+    mode: options.mode,
+    totalFiles: results[0]?.result.totalFiles || 0,
+    userSummaries
+  };
+}
+function mergeResults(results) {
+  if (results.length === 0) {
+    return {
+      type: "folder",
+      path: "",
+      lines: 0,
+      score: 0,
+      fileCount: 0,
+      userScores: [],
+      children: []
+    };
+  }
+  const baseTree = results[0].result.tree;
+  const fileScoresMap = /* @__PURE__ */ new Map();
+  for (const { result } of results) {
+    const userName = result.userName;
+    walkFiles(result.tree, (file) => {
+      let scores = fileScoresMap.get(file.path);
+      if (!scores) {
+        scores = [];
+        fileScoresMap.set(file.path, scores);
+      }
+      scores.push({
+        user: { name: userName, email: "" },
+        score: file.score,
+        isWritten: file.isWritten,
+        isReviewed: file.isReviewed
+      });
+    });
+  }
+  return convertFolder(baseTree, fileScoresMap, results);
+}
+function convertFolder(node, fileScoresMap, results) {
+  const children = [];
+  for (const child of node.children) {
+    if (child.type === "file") {
+      const userScores2 = fileScoresMap.get(child.path) || [];
+      const avgScore2 = userScores2.length > 0 ? userScores2.reduce((sum, s) => sum + s.score, 0) / userScores2.length : 0;
+      children.push({
+        type: "file",
+        path: child.path,
+        lines: child.lines,
+        score: avgScore2,
+        userScores: userScores2
+      });
+    } else {
+      children.push(convertFolder(child, fileScoresMap, results));
+    }
+  }
+  const userScores = results.map(({ result }) => {
+    const folderNode = findFolderInTree(result.tree, node.path);
+    return {
+      user: { name: result.userName, email: "" },
+      score: folderNode?.score || 0
+    };
+  });
+  const avgScore = userScores.length > 0 ? userScores.reduce((sum, s) => sum + s.score, 0) / userScores.length : 0;
+  return {
+    type: "folder",
+    path: node.path,
+    lines: node.lines,
+    score: avgScore,
+    fileCount: node.fileCount,
+    userScores,
+    children
+  };
+}
+function findFolderInTree(node, targetPath) {
+  if (node.type === "folder") {
+    if (node.path === targetPath) return node;
+    for (const child of node.children) {
+      const found = findFolderInTree(child, targetPath);
+      if (found) return found;
+    }
+  }
+  return null;
+}
+
+// src/cli/output/multi-user-terminal.ts
+import chalk3 from "chalk";
+var BAR_WIDTH2 = 20;
+var FILLED_CHAR2 = "\u2588";
+var EMPTY_CHAR2 = "\u2591";
+function makeBar2(score, width = BAR_WIDTH2) {
+  const filled = Math.round(score * width);
+  const empty = width - filled;
+  const bar = FILLED_CHAR2.repeat(filled) + EMPTY_CHAR2.repeat(empty);
+  if (score >= 0.8) return chalk3.green(bar);
+  if (score >= 0.5) return chalk3.yellow(bar);
+  if (score > 0) return chalk3.red(bar);
+  return chalk3.gray(bar);
+}
+function formatPercent2(score) {
+  return `${Math.round(score * 100)}%`;
+}
+function getModeLabel2(mode) {
+  switch (mode) {
+    case "binary":
+      return "Binary mode";
+    case "authorship":
+      return "Authorship mode";
+    case "review-coverage":
+      return "Review Coverage mode";
+    case "weighted":
+      return "Weighted mode";
+    default:
+      return mode;
+  }
+}
+function truncateName(name, maxLen) {
+  if (name.length <= maxLen) return name;
+  return name.slice(0, maxLen - 1) + "\u2026";
+}
+function renderFolder3(node, indent, maxDepth, nameWidth) {
+  const lines = [];
+  const sorted = [...node.children].sort((a, b) => {
+    if (a.type !== b.type) return a.type === "folder" ? -1 : 1;
+    return a.path.localeCompare(b.path);
+  });
+  for (const child of sorted) {
+    if (child.type === "folder") {
+      const prefix = "  ".repeat(indent);
+      const name = (child.path.split("/").pop() || child.path) + "/";
+      const displayName = truncateName(name, nameWidth).padEnd(nameWidth);
+      const scores = child.userScores.map((s) => formatPercent2(s.score).padStart(5)).join("  ");
+      lines.push(`${prefix}${chalk3.bold(displayName)}  ${scores}`);
+      if (indent < maxDepth) {
+        lines.push(...renderFolder3(child, indent + 1, maxDepth, nameWidth));
+      }
+    }
+  }
+  return lines;
+}
+function renderMultiUserTerminal(result) {
+  const { tree, repoName, mode, userSummaries, totalFiles } = result;
+  console.log("");
+  console.log(
+    chalk3.bold(
+      `GitFamiliar \u2014 ${repoName} (${getModeLabel2(mode)}, ${userSummaries.length} users)`
+    )
+  );
+  console.log("");
+  console.log(chalk3.bold("Overall:"));
+  for (const summary of userSummaries) {
+    const name = truncateName(summary.user.name, 14).padEnd(14);
+    const bar = makeBar2(summary.overallScore);
+    const pct = formatPercent2(summary.overallScore);
+    if (mode === "binary") {
+      console.log(
+        `  ${name} ${bar}  ${pct.padStart(4)} (${summary.writtenCount + summary.reviewedCount}/${totalFiles} files)`
+      );
+    } else {
+      console.log(`  ${name} ${bar}  ${pct.padStart(4)}`);
+    }
+  }
+  console.log("");
+  const nameWidth = 20;
+  const headerNames = userSummaries.map((s) => truncateName(s.user.name, 7).padStart(7)).join("  ");
+  console.log(
+    chalk3.bold("Folders:") + " ".repeat(nameWidth - 4) + headerNames
+  );
+  const folderLines = renderFolder3(tree, 1, 2, nameWidth);
+  for (const line of folderLines) {
+    console.log(line);
+  }
+  console.log("");
+}
+
+// src/cli/output/multi-user-html.ts
+import { writeFileSync as writeFileSync3 } from "fs";
+import { join as join3 } from "path";
+function generateMultiUserHTML(result) {
+  const dataJson = JSON.stringify(result.tree);
+  const summariesJson = JSON.stringify(result.userSummaries);
+  const usersJson = JSON.stringify(result.users.map((u) => u.name));
+  return `<!DOCTYPE html>
+<html lang="en">
+<head>
+<meta charset="UTF-8">
+<meta name="viewport" content="width=device-width, initial-scale=1.0">
+<title>GitFamiliar \u2014 ${result.repoName} \u2014 Multi-User</title>
+<style>
+  * { margin: 0; padding: 0; box-sizing: border-box; }
+  body {
+    font-family: -apple-system, BlinkMacSystemFont, 'Segoe UI', Roboto, sans-serif;
+    background: #1a1a2e;
+    color: #e0e0e0;
+    overflow: hidden;
+  }
+  #header {
+    padding: 16px 24px;
+    background: #16213e;
+    border-bottom: 1px solid #0f3460;
+    display: flex;
+    align-items: center;
+    justify-content: space-between;
+  }
+  #header h1 { font-size: 18px; color: #e94560; }
+  #header .controls { display: flex; align-items: center; gap: 12px; }
+  #header select {
+    padding: 4px 12px;
+    border: 1px solid #0f3460;
+    background: #1a1a2e;
+    color: #e0e0e0;
+    border-radius: 4px;
+    font-size: 13px;
+  }
+  #header .info { font-size: 14px; color: #a0a0a0; }
+  #breadcrumb {
+    padding: 8px 24px;
+    background: #16213e;
+    font-size: 13px;
+    border-bottom: 1px solid #0f3460;
+  }
+  #breadcrumb span { cursor: pointer; color: #5eadf7; }
+  #breadcrumb span:hover { text-decoration: underline; }
+  #breadcrumb .sep { color: #666; margin: 0 4px; }
+  #treemap { width: 100%; }
+  #tooltip {
+    position: absolute;
+    pointer-events: none;
+    background: rgba(22, 33, 62, 0.95);
+    border: 1px solid #0f3460;
+    border-radius: 6px;
+    padding: 10px 14px;
+    font-size: 13px;
+    line-height: 1.6;
+    display: none;
+    z-index: 100;
+    max-width: 350px;
+  }
+  #legend {
+    position: absolute;
+    bottom: 16px;
+    right: 16px;
+    background: rgba(22, 33, 62, 0.9);
+    border: 1px solid #0f3460;
+    border-radius: 6px;
+    padding: 10px;
+    font-size: 12px;
+  }
+  #legend .gradient-bar {
+    width: 120px; height: 12px;
+    background: linear-gradient(to right, #e94560, #f5a623, #27ae60);
+    border-radius: 3px; margin: 4px 0;
+  }
+  #legend .labels { display: flex; justify-content: space-between; font-size: 10px; color: #888; }
+</style>
+</head>
+<body>
+<div id="header">
+  <h1>GitFamiliar \u2014 ${result.repoName}</h1>
+  <div class="controls">
+    <span style="color:#888;font-size:13px;">View as:</span>
+    <select id="userSelect" onchange="changeUser()"></select>
+    <div class="info">${result.mode} mode | ${result.totalFiles} files</div>
+  </div>
+</div>
+<div id="breadcrumb"><span onclick="zoomTo('')">root</span></div>
+<div id="treemap"></div>
+<div id="tooltip"></div>
+<div id="legend">
+  <div>Familiarity</div>
+  <div class="gradient-bar"></div>
+  <div class="labels"><span>0%</span><span>50%</span><span>100%</span></div>
+</div>
+
+<script src="https://d3js.org/d3.v7.min.js"></script>
+<script>
+const rawData = ${dataJson};
+const userNames = ${usersJson};
+const summaries = ${summariesJson};
+let currentUser = 0;
+let currentPath = '';
+
+// Populate user selector
+const select = document.getElementById('userSelect');
+userNames.forEach((name, i) => {
+  const opt = document.createElement('option');
+  opt.value = i;
+  const summary = summaries[i];
+  opt.textContent = name + ' (' + Math.round(summary.overallScore * 100) + '%)';
+  select.appendChild(opt);
+});
+
+function changeUser() {
+  currentUser = parseInt(select.value);
+  render();
+}
+
+function scoreColor(score) {
+  if (score <= 0) return '#e94560';
+  if (score >= 1) return '#27ae60';
+  if (score < 0.5) {
+    const t = score / 0.5;
+    return d3.interpolateRgb('#e94560', '#f5a623')(t);
+  }
+  const t = (score - 0.5) / 0.5;
+  return d3.interpolateRgb('#f5a623', '#27ae60')(t);
+}
+
+function getUserScore(node) {
+  if (!node.userScores || node.userScores.length === 0) return node.score;
+  const s = node.userScores[currentUser];
+  return s ? s.score : 0;
+}
+
+function findNode(node, path) {
+  if (node.path === path) return node;
+  if (node.children) {
+    for (const child of node.children) {
+      const found = findNode(child, path);
+      if (found) return found;
+    }
+  }
+  return null;
+}
+
+function buildHierarchy(node) {
+  if (node.type === 'file') {
+    return { name: node.path.split('/').pop(), data: node, value: Math.max(1, node.lines) };
+  }
+  return {
+    name: node.path.split('/').pop() || node.path,
+    data: node,
+    children: (node.children || []).map(c => buildHierarchy(c)),
+  };
+}
+
+function render() {
+  const container = document.getElementById('treemap');
+  container.innerHTML = '';
+
+  const headerH = document.getElementById('header').offsetHeight;
+  const breadcrumbH = document.getElementById('breadcrumb').offsetHeight;
+  const width = window.innerWidth;
+  const height = window.innerHeight - headerH - breadcrumbH;
+
+  const targetNode = currentPath ? findNode(rawData, currentPath) : rawData;
+  if (!targetNode || !targetNode.children || targetNode.children.length === 0) return;
+
+  const hierarchyData = {
+    name: targetNode.path || 'root',
+    children: targetNode.children.map(c => buildHierarchy(c)),
+  };
+
+  const root = d3.hierarchy(hierarchyData)
+    .sum(d => d.value || 0)
+    .sort((a, b) => (b.value || 0) - (a.value || 0));
+
+  d3.treemap()
+    .size([width, height])
+    .padding(2)
+    .paddingTop(20)
+    .round(true)(root);
+
+  const svg = d3.select('#treemap')
+    .append('svg')
+    .attr('width', width)
+    .attr('height', height);
+
+  const tooltip = document.getElementById('tooltip');
+  const nodes = root.descendants().filter(d => d.depth > 0);
+
+  const groups = svg.selectAll('g')
+    .data(nodes)
+    .join('g')
+    .attr('transform', d => \`translate(\${d.x0},\${d.y0})\`);
+
+  groups.append('rect')
+    .attr('width', d => Math.max(0, d.x1 - d.x0))
+    .attr('height', d => Math.max(0, d.y1 - d.y0))
+    .attr('fill', d => {
+      if (!d.data.data) return '#333';
+      return scoreColor(getUserScore(d.data.data));
+    })
+    .attr('opacity', d => d.children ? 0.35 : 0.88)
+    .attr('stroke', '#1a1a2e')
+    .attr('stroke-width', d => d.children ? 1 : 0.5)
+    .attr('rx', 2)
+    .style('cursor', d => (d.data.data && d.data.data.type === 'folder') ? 'pointer' : 'default')
+    .on('click', (event, d) => {
+      if (d.data.data && d.data.data.type === 'folder') {
+        event.stopPropagation();
+        zoomTo(d.data.data.path);
+      }
+    })
+    .on('mouseover', function(event, d) {
+      if (!d.data.data) return;
+      d3.select(this).attr('opacity', d.children ? 0.5 : 1).attr('stroke', '#fff');
+      showTooltip(d.data.data, event);
+    })
+    .on('mousemove', (event) => {
+      tooltip.style.left = (event.pageX + 14) + 'px';
+      tooltip.style.top = (event.pageY - 14) + 'px';
+    })
+    .on('mouseout', function(event, d) {
+      d3.select(this).attr('opacity', d.children ? 0.35 : 0.88).attr('stroke', '#1a1a2e');
+      tooltip.style.display = 'none';
+    });
+
+  groups.append('text')
+    .attr('x', 4)
+    .attr('y', 14)
+    .attr('fill', '#fff')
+    .attr('font-size', d => d.children ? '11px' : '10px')
+    .attr('font-weight', d => d.children ? 'bold' : 'normal')
+    .style('pointer-events', 'none')
+    .text(d => {
+      const w = d.x1 - d.x0;
+      const h = d.y1 - d.y0;
+      const name = d.data.name || '';
+      if (w < 36 || h < 18) return '';
+      const maxChars = Math.floor((w - 8) / 6.5);
+      if (name.length > maxChars) return name.slice(0, maxChars - 1) + '\\u2026';
+      return name;
+    });
+}
+
+function showTooltip(data, event) {
+  const tooltip = document.getElementById('tooltip');
+  let html = '<strong>' + (data.path || 'root') + '</strong>';
+
+  if (data.userScores && data.userScores.length > 0) {
+    html += '<table style="margin-top:6px;width:100%">';
+    data.userScores.forEach((s, i) => {
+      const isCurrent = (i === currentUser);
+      const style = isCurrent ? 'font-weight:bold;color:#5eadf7' : '';
+      html += '<tr style="' + style + '"><td>' + userNames[i] + '</td><td style="text-align:right">' + Math.round(s.score * 100) + '%</td></tr>';
+    });
+    html += '</table>';
+  }
+
+  if (data.type === 'folder') {
+    html += '<br>Files: ' + data.fileCount;
+    html += '<br><em style="color:#5eadf7">Click to drill down \\u25B6</em>';
+  } else {
+    html += '<br>Lines: ' + data.lines.toLocaleString();
+  }
+
+  tooltip.innerHTML = html;
+  tooltip.style.display = 'block';
+  tooltip.style.left = (event.pageX + 14) + 'px';
+  tooltip.style.top = (event.pageY - 14) + 'px';
+}
+
+function zoomTo(path) {
+  currentPath = path;
+  const el = document.getElementById('breadcrumb');
+  const parts = path ? path.split('/') : [];
+  let html = '<span onclick="zoomTo(\\'\\')">root</span>';
+  let accumulated = '';
+  for (const part of parts) {
+    accumulated = accumulated ? accumulated + '/' + part : part;
+    const p = accumulated;
+    html += '<span class="sep">/</span><span onclick="zoomTo(\\'' + p + '\\')">' + part + '</span>';
+  }
+  el.innerHTML = html;
+  render();
+}
+
+window.addEventListener('resize', render);
+render();
+</script>
+</body>
+</html>`;
+}
+async function generateAndOpenMultiUserHTML(result, repoPath) {
+  const html = generateMultiUserHTML(result);
+  const outputPath = join3(repoPath, "gitfamiliar-multiuser.html");
+  writeFileSync3(outputPath, html, "utf-8");
+  console.log(`Multi-user report generated: ${outputPath}`);
+  await openBrowser(outputPath);
+}
+
+// src/git/change-frequency.ts
+var COMMIT_SEP2 = "GITFAMILIAR_FREQ_SEP";
+async function bulkGetChangeFrequency(gitClient, days, trackedFiles) {
+  const sinceDate = `${days} days ago`;
+  const output = await gitClient.getLog([
+    "--all",
+    `--since=${sinceDate}`,
+    "--name-only",
+    `--format=${COMMIT_SEP2}%aI`
+  ]);
+  const result = /* @__PURE__ */ new Map();
+  let currentDate = null;
+  for (const line of output.split("\n")) {
+    if (line.startsWith(COMMIT_SEP2)) {
+      const dateStr = line.slice(COMMIT_SEP2.length).trim();
+      currentDate = dateStr ? new Date(dateStr) : null;
+      continue;
+    }
+    const filePath = line.trim();
+    if (!filePath || !trackedFiles.has(filePath)) continue;
+    let entry = result.get(filePath);
+    if (!entry) {
+      entry = { commitCount: 0, lastChanged: null };
+      result.set(filePath, entry);
+    }
+    entry.commitCount++;
+    if (currentDate && (!entry.lastChanged || currentDate > entry.lastChanged)) {
+      entry.lastChanged = currentDate;
+    }
+  }
+  return result;
+}
+
+// src/core/hotspot.ts
+var DEFAULT_WINDOW = 90;
+async function computeHotspots(options) {
+  const gitClient = new GitClient(options.repoPath);
+  if (!await gitClient.isRepo()) {
+    throw new Error(`"${options.repoPath}" is not a git repository.`);
+  }
+  const repoName = await gitClient.getRepoName();
+  const repoRoot = await gitClient.getRepoRoot();
+  const filter = createFilter(repoRoot);
+  const tree = await buildFileTree(gitClient, filter);
+  const timeWindow = options.window || DEFAULT_WINDOW;
+  const isTeamMode = options.hotspot === "team";
+  const trackedFiles = /* @__PURE__ */ new Set();
+  walkFiles(tree, (f) => trackedFiles.add(f.path));
+  const changeFreqMap = await bulkGetChangeFrequency(gitClient, timeWindow, trackedFiles);
+  let familiarityMap;
+  let userName;
+  if (isTeamMode) {
+    familiarityMap = await computeTeamAvgFamiliarity(gitClient, trackedFiles, options);
+  } else {
+    const userFlag = Array.isArray(options.user) ? options.user[0] : options.user;
+    const result = await computeFamiliarity({ ...options, team: false, teamCoverage: false });
+    userName = result.userName;
+    familiarityMap = /* @__PURE__ */ new Map();
+    walkFiles(result.tree, (f) => {
+      familiarityMap.set(f.path, f.score);
+    });
+  }
+  let maxFreq = 0;
+  for (const entry of changeFreqMap.values()) {
+    if (entry.commitCount > maxFreq) maxFreq = entry.commitCount;
+  }
+  const hotspotFiles = [];
+  for (const filePath of trackedFiles) {
+    const freq = changeFreqMap.get(filePath);
+    const changeFrequency = freq?.commitCount || 0;
+    const lastChanged = freq?.lastChanged || null;
+    const familiarity = familiarityMap.get(filePath) || 0;
+    const normalizedFreq = maxFreq > 0 ? changeFrequency / maxFreq : 0;
+    const risk = normalizedFreq * (1 - familiarity);
+    let lines = 0;
+    walkFiles(tree, (f) => {
+      if (f.path === filePath) lines = f.lines;
+    });
+    hotspotFiles.push({
+      path: filePath,
+      lines,
+      familiarity,
+      changeFrequency,
+      lastChanged,
+      risk,
+      riskLevel: classifyHotspotRisk(risk)
+    });
+  }
+  hotspotFiles.sort((a, b) => b.risk - a.risk);
+  const summary = { critical: 0, high: 0, medium: 0, low: 0 };
+  for (const f of hotspotFiles) {
+    summary[f.riskLevel]++;
+  }
+  return {
+    files: hotspotFiles,
+    repoName,
+    userName,
+    hotspotMode: isTeamMode ? "team" : "personal",
+    timeWindow,
+    summary
+  };
+}
+function classifyHotspotRisk(risk) {
+  if (risk >= 0.6) return "critical";
+  if (risk >= 0.4) return "high";
+  if (risk >= 0.2) return "medium";
+  return "low";
+}
+async function computeTeamAvgFamiliarity(gitClient, trackedFiles, options) {
+  const contributors = await getAllContributors(gitClient, 1);
+  const totalContributors = Math.max(1, contributors.length);
+  const fileContributors = await bulkGetFileContributors(gitClient, trackedFiles);
+  const result = /* @__PURE__ */ new Map();
+  for (const filePath of trackedFiles) {
+    const contribs = fileContributors.get(filePath);
+    const count = contribs ? contribs.size : 0;
+    result.set(filePath, Math.min(1, count / Math.max(1, totalContributors * 0.3)));
+  }
+  return result;
+}
+
+// src/cli/output/hotspot-terminal.ts
+import chalk4 from "chalk";
+function riskBadge2(level) {
+  switch (level) {
+    case "critical":
+      return chalk4.bgRed.white.bold(" CRIT ");
+    case "high":
+      return chalk4.bgRedBright.white(" HIGH ");
+    case "medium":
+      return chalk4.bgYellow.black("  MED ");
+    case "low":
+      return chalk4.bgGreen.black("  LOW ");
+  }
+}
+function riskColor2(level) {
+  switch (level) {
+    case "critical":
+      return chalk4.red;
+    case "high":
+      return chalk4.redBright;
+    case "medium":
+      return chalk4.yellow;
+    case "low":
+      return chalk4.green;
+  }
+}
+function renderHotspotTerminal(result) {
+  const { files, repoName, hotspotMode, timeWindow, summary, userName } = result;
+  console.log("");
+  const modeLabel = hotspotMode === "team" ? "Team Hotspots" : "Personal Hotspots";
+  const userLabel = userName ? ` (${userName})` : "";
+  console.log(
+    chalk4.bold(`GitFamiliar \u2014 ${modeLabel}${userLabel} \u2014 ${repoName}`)
+  );
+  console.log(chalk4.gray(`  Time window: last ${timeWindow} days`));
+  console.log("");
+  const activeFiles = files.filter((f) => f.changeFrequency > 0);
+  if (activeFiles.length === 0) {
+    console.log(chalk4.gray("  No files changed in the time window."));
+    console.log("");
+    return;
+  }
+  const displayCount = Math.min(30, activeFiles.length);
+  const topFiles = activeFiles.slice(0, displayCount);
+  console.log(
+    chalk4.gray(
+      `  ${"Rank".padEnd(5)} ${"File".padEnd(42)} ${"Familiarity".padStart(11)} ${"Changes".padStart(8)} ${"Risk".padStart(6)}  Level`
+    )
+  );
+  console.log(chalk4.gray("  " + "\u2500".repeat(90)));
+  for (let i = 0; i < topFiles.length; i++) {
+    const f = topFiles[i];
+    const rank = String(i + 1).padEnd(5);
+    const path = truncate(f.path, 42).padEnd(42);
+    const fam = `${Math.round(f.familiarity * 100)}%`.padStart(11);
+    const changes = String(f.changeFrequency).padStart(8);
+    const risk = f.risk.toFixed(2).padStart(6);
+    const color = riskColor2(f.riskLevel);
+    const badge = riskBadge2(f.riskLevel);
+    console.log(
+      `  ${color(rank)}${path} ${fam} ${changes} ${color(risk)}  ${badge}`
+    );
+  }
+  if (activeFiles.length > displayCount) {
+    console.log(
+      chalk4.gray(`  ... and ${activeFiles.length - displayCount} more files`)
+    );
+  }
+  console.log("");
+  console.log(chalk4.bold("Summary:"));
+  if (summary.critical > 0) {
+    console.log(
+      `  ${chalk4.red.bold(`\u{1F534} Critical Risk: ${summary.critical} files`)}`
+    );
+  }
+  if (summary.high > 0) {
+    console.log(
+      `  ${chalk4.redBright(`\u{1F7E0} High Risk: ${summary.high} files`)}`
+    );
+  }
+  if (summary.medium > 0) {
+    console.log(
+      `  ${chalk4.yellow(`\u{1F7E1} Medium Risk: ${summary.medium} files`)}`
+    );
+  }
+  console.log(
+    `  ${chalk4.green(`\u{1F7E2} Low Risk: ${summary.low} files`)}`
+  );
+  console.log("");
+  if (summary.critical > 0 || summary.high > 0) {
+    console.log(
+      chalk4.gray(
+        "  Recommendation: Focus code review and knowledge transfer on critical/high risk files."
+      )
+    );
+    console.log("");
+  }
+}
+function truncate(s, maxLen) {
+  if (s.length <= maxLen) return s;
+  return s.slice(0, maxLen - 1) + "\u2026";
+}
+
+// src/cli/output/hotspot-html.ts
+import { writeFileSync as writeFileSync4 } from "fs";
+import { join as join4 } from "path";
+function generateHotspotHTML(result) {
+  const activeFiles = result.files.filter((f) => f.changeFrequency > 0);
+  const dataJson = JSON.stringify(
+    activeFiles.map((f) => ({
+      path: f.path,
+      lines: f.lines,
+      familiarity: f.familiarity,
+      changeFrequency: f.changeFrequency,
+      risk: f.risk,
+      riskLevel: f.riskLevel
+    }))
+  );
+  const modeLabel = result.hotspotMode === "team" ? "Team Hotspots" : "Personal Hotspots";
+  const userLabel = result.userName ? ` (${result.userName})` : "";
+  return `<!DOCTYPE html>
+<html lang="en">
+<head>
+<meta charset="UTF-8">
+<meta name="viewport" content="width=device-width, initial-scale=1.0">
+<title>GitFamiliar \u2014 ${modeLabel} \u2014 ${result.repoName}</title>
+<style>
+  * { margin: 0; padding: 0; box-sizing: border-box; }
+  body {
+    font-family: -apple-system, BlinkMacSystemFont, 'Segoe UI', Roboto, sans-serif;
+    background: #1a1a2e;
+    color: #e0e0e0;
+    overflow: hidden;
+  }
+  #header {
+    padding: 16px 24px;
+    background: #16213e;
+    border-bottom: 1px solid #0f3460;
+    display: flex;
+    align-items: center;
+    justify-content: space-between;
+  }
+  #header h1 { font-size: 18px; color: #e94560; }
+  #header .info { font-size: 14px; color: #a0a0a0; }
+  #main { display: flex; height: calc(100vh - 60px); }
+  #chart { flex: 1; position: relative; }
+  #sidebar {
+    width: 320px;
+    background: #16213e;
+    border-left: 1px solid #0f3460;
+    overflow-y: auto;
+    padding: 16px;
+  }
+  #sidebar h3 { font-size: 14px; margin-bottom: 12px; color: #e94560; }
+  .hotspot-item {
+    padding: 8px 0;
+    border-bottom: 1px solid #0f3460;
+    font-size: 12px;
+  }
+  .hotspot-item .path { color: #e0e0e0; word-break: break-all; }
+  .hotspot-item .meta { color: #888; margin-top: 2px; }
+  .hotspot-item .risk-badge {
+    display: inline-block;
+    padding: 1px 6px;
+    border-radius: 3px;
+    font-size: 10px;
+    font-weight: bold;
+    margin-left: 4px;
+  }
+  .risk-critical { background: #e94560; color: white; }
+  .risk-high { background: #f07040; color: white; }
+  .risk-medium { background: #f5a623; color: black; }
+  .risk-low { background: #27ae60; color: white; }
+  #tooltip {
+    position: absolute;
+    pointer-events: none;
+    background: rgba(22, 33, 62, 0.95);
+    border: 1px solid #0f3460;
+    border-radius: 6px;
+    padding: 10px 14px;
+    font-size: 13px;
+    line-height: 1.6;
+    display: none;
+    z-index: 100;
+    max-width: 350px;
+  }
+  #zone-labels { position: absolute; pointer-events: none; }
+  .zone-label {
+    position: absolute;
+    font-size: 12px;
+    color: rgba(255,255,255,0.15);
+    font-weight: bold;
+  }
+</style>
+</head>
+<body>
+<div id="header">
+  <h1>GitFamiliar \u2014 ${modeLabel}${userLabel} \u2014 ${result.repoName}</h1>
+  <div class="info">${result.timeWindow}-day window | ${activeFiles.length} active files | Summary: ${result.summary.critical} critical, ${result.summary.high} high</div>
+</div>
+<div id="main">
+  <div id="chart">
+    <div id="zone-labels"></div>
+  </div>
+  <div id="sidebar">
+    <h3>Top Hotspots</h3>
+    <div id="hotspot-list"></div>
+  </div>
+</div>
+<div id="tooltip"></div>
+
+<script src="https://d3js.org/d3.v7.min.js"></script>
+<script>
+const data = ${dataJson};
+const margin = { top: 30, right: 30, bottom: 60, left: 70 };
+
+function riskColor(level) {
+  switch(level) {
+    case 'critical': return '#e94560';
+    case 'high': return '#f07040';
+    case 'medium': return '#f5a623';
+    default: return '#27ae60';
+  }
+}
+
+function render() {
+  const container = document.getElementById('chart');
+  const svg = container.querySelector('svg');
+  if (svg) svg.remove();
+
+  const width = container.offsetWidth;
+  const height = container.offsetHeight;
+  const innerW = width - margin.left - margin.right;
+  const innerH = height - margin.top - margin.bottom;
+
+  const maxFreq = d3.max(data, d => d.changeFrequency) || 1;
+
+  const x = d3.scaleLinear().domain([0, 1]).range([0, innerW]);
+  const y = d3.scaleLinear().domain([0, maxFreq * 1.1]).range([innerH, 0]);
+  const r = d3.scaleSqrt()
+    .domain([0, d3.max(data, d => d.lines) || 1])
+    .range([3, 20]);
+
+  const svgEl = d3.select('#chart')
+    .append('svg')
+    .attr('width', width)
+    .attr('height', height);
+
+  const g = svgEl.append('g')
+    .attr('transform', 'translate(' + margin.left + ',' + margin.top + ')');
+
+  // Danger zone background (top-left quadrant)
+  g.append('rect')
+    .attr('x', 0)
+    .attr('y', 0)
+    .attr('width', x(0.3))
+    .attr('height', y(maxFreq * 0.3))
+    .attr('fill', 'rgba(233, 69, 96, 0.06)');
+
+  // X axis
+  g.append('g')
+    .attr('transform', 'translate(0,' + innerH + ')')
+    .call(d3.axisBottom(x).ticks(5).tickFormat(d => Math.round(d * 100) + '%'))
+    .selectAll('text,line,path').attr('stroke', '#555').attr('fill', '#888');
+
+  svgEl.append('text')
+    .attr('x', margin.left + innerW / 2)
+    .attr('y', height - 10)
+    .attr('text-anchor', 'middle')
+    .attr('fill', '#888')
+    .attr('font-size', '13px')
+    .text('Familiarity \\u2192');
+
+  // Y axis
+  g.append('g')
+    .call(d3.axisLeft(y).ticks(6))
+    .selectAll('text,line,path').attr('stroke', '#555').attr('fill', '#888');
+
+  svgEl.append('text')
+    .attr('transform', 'rotate(-90)')
+    .attr('x', -(margin.top + innerH / 2))
+    .attr('y', 16)
+    .attr('text-anchor', 'middle')
+    .attr('fill', '#888')
+    .attr('font-size', '13px')
+    .text('Change Frequency (commits) \\u2192');
+
+  // Zone labels
+  const labels = document.getElementById('zone-labels');
+  labels.innerHTML = '';
+  const dangerLabel = document.createElement('div');
+  dangerLabel.className = 'zone-label';
+  dangerLabel.style.left = (margin.left + 8) + 'px';
+  dangerLabel.style.top = (margin.top + 8) + 'px';
+  dangerLabel.textContent = 'DANGER ZONE';
+  dangerLabel.style.color = 'rgba(233,69,96,0.25)';
+  dangerLabel.style.fontSize = '16px';
+  labels.appendChild(dangerLabel);
+
+  const safeLabel = document.createElement('div');
+  safeLabel.className = 'zone-label';
+  safeLabel.style.right = (320 + 40) + 'px';
+  safeLabel.style.bottom = (margin.bottom + 16) + 'px';
+  safeLabel.textContent = 'SAFE ZONE';
+  safeLabel.style.color = 'rgba(39,174,96,0.2)';
+  safeLabel.style.fontSize = '16px';
+  labels.appendChild(safeLabel);
+
+  const tooltip = document.getElementById('tooltip');
+
+  // Data points
+  g.selectAll('circle')
+    .data(data)
+    .join('circle')
+    .attr('cx', d => x(d.familiarity))
+    .attr('cy', d => y(d.changeFrequency))
+    .attr('r', d => r(d.lines))
+    .attr('fill', d => riskColor(d.riskLevel))
+    .attr('opacity', 0.7)
+    .attr('stroke', 'none')
+    .style('cursor', 'pointer')
+    .on('mouseover', function(event, d) {
+      d3.select(this).attr('opacity', 1).attr('stroke', '#fff').attr('stroke-width', 2);
+      tooltip.innerHTML =
+        '<strong>' + d.path + '</strong>' +
+        '<br>Familiarity: ' + Math.round(d.familiarity * 100) + '%' +
+        '<br>Changes: ' + d.changeFrequency + ' commits' +
+        '<br>Risk: ' + d.risk.toFixed(2) + ' (' + d.riskLevel + ')' +
+        '<br>Lines: ' + d.lines.toLocaleString();
+      tooltip.style.display = 'block';
+      tooltip.style.left = (event.pageX + 14) + 'px';
+      tooltip.style.top = (event.pageY - 14) + 'px';
+    })
+    .on('mousemove', (event) => {
+      tooltip.style.left = (event.pageX + 14) + 'px';
+      tooltip.style.top = (event.pageY - 14) + 'px';
+    })
+    .on('mouseout', function() {
+      d3.select(this).attr('opacity', 0.7).attr('stroke', 'none');
+      tooltip.style.display = 'none';
+    });
+}
+
+// Sidebar
+function renderSidebar() {
+  const container = document.getElementById('hotspot-list');
+  const top = data.slice(0, 30);
+  if (top.length === 0) {
+    container.innerHTML = '<div style="color:#888">No active files in time window.</div>';
+    return;
+  }
+  let html = '';
+  for (let i = 0; i < top.length; i++) {
+    const f = top[i];
+    const badgeClass = 'risk-' + f.riskLevel;
+    html += '<div class="hotspot-item">' +
+      '<div class="path">' + (i + 1) + '. ' + f.path +
+      ' <span class="risk-badge ' + badgeClass + '">' + f.riskLevel.toUpperCase() + '</span></div>' +
+      '<div class="meta">Fam: ' + Math.round(f.familiarity * 100) + '% | Changes: ' + f.changeFrequency + ' | Risk: ' + f.risk.toFixed(2) + '</div>' +
+      '</div>';
+  }
+  container.innerHTML = html;
+}
+
+window.addEventListener('resize', render);
+renderSidebar();
+render();
+</script>
+</body>
+</html>`;
+}
+async function generateAndOpenHotspotHTML(result, repoPath) {
+  const html = generateHotspotHTML(result);
+  const outputPath = join4(repoPath, "gitfamiliar-hotspot.html");
+  writeFileSync4(outputPath, html, "utf-8");
+  console.log(`Hotspot report generated: ${outputPath}`);
+  await openBrowser(outputPath);
+}
+
+// src/github/check.ts
+async function checkGitHubConnection(repoPath, githubUrl) {
+  const gitClient = new GitClient(repoPath);
+  if (!await gitClient.isRepo()) {
+    console.error("Error: Not a git repository.");
+    process.exit(1);
+  }
+  const remoteUrl = await gitClient.getRemoteUrl();
+  if (!remoteUrl) {
+    console.error("Error: No git remote found.");
+    process.exit(1);
+  }
+  console.log(`Remote URL:   ${remoteUrl}`);
+  const parsed = GitHubClient.parseRemoteUrl(remoteUrl, githubUrl);
+  if (!parsed) {
+    console.error("Error: Could not parse remote URL as a GitHub repository.");
+    process.exit(1);
+  }
+  console.log(`Hostname:     ${parsed.hostname}`);
+  console.log(`Repository:   ${parsed.owner}/${parsed.repo}`);
+  console.log(`API Base URL: ${parsed.apiBaseUrl}`);
+  const token = resolveGitHubToken(parsed.hostname);
+  if (!token) {
+    console.error(
+      "\nNo GitHub token found. Please set GITHUB_TOKEN or run: gh auth login" + (parsed.hostname !== "github.com" ? ` --hostname ${parsed.hostname}` : "")
+    );
+    process.exit(1);
+  }
+  console.log(`Token:        ****${token.slice(-4)}`);
+  console.log("\nVerifying API connectivity...");
+  try {
+    const client = new GitHubClient(token, parsed.apiBaseUrl);
+    const user = await client.verifyConnection();
+    console.log(`Authenticated as: ${user.login}${user.name ? ` (${user.name})` : ""}`);
+    console.log("\nGitHub connection OK.");
+  } catch (error) {
+    console.error(`
+API connection failed: ${error.message}`);
+    process.exit(1);
+  }
+}
+
+// src/cli/index.ts
+function collect(value, previous) {
+  return previous.concat([value]);
+}
+function createProgram() {
+  const program2 = new Command();
+  program2.name("gitfamiliar").description("Visualize your code familiarity from Git history").version("0.1.1").option(
+    "-m, --mode <mode>",
+    "Scoring mode: binary, authorship, review-coverage, weighted",
+    "binary"
+  ).option(
+    "-u, --user <user>",
+    "Git user name or email (repeatable for comparison)",
+    collect,
+    []
+  ).option(
+    "-f, --filter <filter>",
+    "Filter mode: all, written, reviewed",
+    "all"
+  ).option(
+    "-e, --expiration <policy>",
+    "Expiration policy: never, time:180d, change:50%, combined:365d:50%",
+    "never"
+  ).option("--html", "Generate HTML treemap report", false).option(
+    "-w, --weights <weights>",
+    'Weights for weighted mode: blame,commit,review (e.g., "0.5,0.35,0.15")'
+  ).option("--team", "Compare all contributors", false).option(
+    "--team-coverage",
+    "Show team coverage map (bus factor analysis)",
+    false
+  ).option("--hotspot [mode]", "Hotspot analysis: personal (default) or team").option(
+    "--window <days>",
+    "Time window for hotspot analysis in days (default: 90)"
+  ).option(
+    "--github-url <hostname>",
+    "GitHub Enterprise hostname (e.g. ghe.example.com). Auto-detected from git remote if omitted."
+  ).option(
+    "--check-github",
+    "Verify GitHub API connectivity and show connection info",
+    false
+  ).action(async (rawOptions) => {
+    try {
+      const repoPath = process.cwd();
+      const options = parseOptions(rawOptions, repoPath);
+      if (options.checkGithub) {
+        await checkGitHubConnection(repoPath, options.githubUrl);
+        return;
+      }
+      if (options.hotspot) {
+        const result2 = await computeHotspots(options);
+        if (options.html) {
+          await generateAndOpenHotspotHTML(result2, repoPath);
+        } else {
+          renderHotspotTerminal(result2);
+        }
+        return;
+      }
+      if (options.teamCoverage) {
+        const result2 = await computeTeamCoverage(options);
+        if (options.html) {
+          await generateAndOpenCoverageHTML(result2, repoPath);
+        } else {
+          renderCoverageTerminal(result2);
+        }
+        return;
+      }
+      const isMultiUser = options.team || Array.isArray(options.user) && options.user.length > 1;
+      if (isMultiUser) {
+        const result2 = await computeMultiUser(options);
+        if (options.html) {
+          await generateAndOpenMultiUserHTML(result2, repoPath);
+        } else {
+          renderMultiUserTerminal(result2);
+        }
+        return;
+      }
       const result = await computeFamiliarity(options);
       if (options.html) {
         await generateAndOpenHTML(result, repoPath);