commit-report 1.0.0

package/dist/index.js

@@ -0,0 +1,1572 @@
+#!/usr/bin/env node
+
+// src/cli/index.ts
+import { Command } from "commander";
+import chalk3 from "chalk";
+import { checkbox } from "@inquirer/prompts";
+
+// src/scanner/index.ts
+import { readdir, access } from "fs/promises";
+import { join, basename } from "path";
+import { execSync } from "child_process";
+import ora from "ora";
+import { confirm } from "@inquirer/prompts";
+var IGNORE_DIRS = /* @__PURE__ */ new Set([
+  "node_modules",
+  ".git",
+  "vendor",
+  "dist",
+  "build",
+  ".cache",
+  ".next",
+  ".nuxt",
+  "__pycache__",
+  "target"
+]);
+async function scanRepositories(options) {
+  const spinner = ora("\u626B\u63CF\u4ED3\u5E93\u4E2D...").start();
+  const repos = [];
+  let deepScanConfirmed = false;
+  async function scan(dir, depth) {
+    if (depth > options.maxDepth && !deepScanConfirmed) {
+      spinner.stop();
+      const shouldContinue = await confirm({
+        message: `\u626B\u63CF\u6DF1\u5EA6\u5DF2\u8D85\u8FC7 ${options.maxDepth} \u5C42\uFF0C\u662F\u5426\u7EE7\u7EED\uFF1F`,
+        default: false
+      });
+      if (!shouldContinue) {
+        return;
+      }
+      deepScanConfirmed = true;
+      spinner.start("\u7EE7\u7EED\u626B\u63CF\u4E2D...");
+    }
+    try {
+      const gitDir = join(dir, ".git");
+      await access(gitDir);
+      const repoInfo = getRepoInfo(dir);
+      if (repoInfo) {
+        repos.push(repoInfo);
+        spinner.text = `\u626B\u63CF\u4ED3\u5E93\u4E2D... \u5DF2\u627E\u5230 ${repos.length} \u4E2A`;
+      }
+      return;
+    } catch {
+    }
+    try {
+      const entries = await readdir(dir, { withFileTypes: true });
+      for (const entry of entries) {
+        if (!entry.isDirectory()) continue;
+        if (IGNORE_DIRS.has(entry.name)) continue;
+        if (entry.name.startsWith(".") && entry.name !== ".git") continue;
+        await scan(join(dir, entry.name), depth + 1);
+      }
+    } catch {
+    }
+  }
+  await scan(options.targetDir, 0);
+  if (repos.length > 0) {
+    spinner.succeed(`\u627E\u5230 ${repos.length} \u4E2A Git \u4ED3\u5E93`);
+  } else {
+    spinner.fail("\u672A\u627E\u5230 Git \u4ED3\u5E93");
+  }
+  return repos;
+}
+function getRepoInfo(repoPath) {
+  try {
+    const countStr = execSync("git rev-list --count HEAD", {
+      cwd: repoPath,
+      stdio: ["pipe", "pipe", "ignore"],
+      encoding: "utf-8"
+    }).trim();
+    const commitCount = parseInt(countStr, 10) || 0;
+    const name = basename(repoPath);
+    return {
+      path: repoPath,
+      name,
+      commitCount
+    };
+  } catch {
+    return null;
+  }
+}
+
+// src/analyzer/index.ts
+import ora2 from "ora";
+import chalk from "chalk";
+
+// src/analyzer/git-log-parser.ts
+import { execSync as execSync2 } from "child_process";
+import { readFile } from "fs/promises";
+import { join as join2 } from "path";
+import ig from "ignore";
+var COMMIT_SEPARATOR = "---COMMITX_SEP---";
+var FIELD_SEPARATOR = "|";
+var FORMAT = `${COMMIT_SEPARATOR}%H${FIELD_SEPARATOR}%an${FIELD_SEPARATOR}%ae${FIELD_SEPARATOR}%aI${FIELD_SEPARATOR}%s`;
+async function parseGitLog(repoPath, timeRange, author) {
+  const ignoreFilter = await loadGitignore(repoPath);
+  const args = [
+    "git",
+    "log",
+    `--format="${FORMAT}"`,
+    "--numstat"
+  ];
+  if (timeRange) {
+    args.push(`--since="${timeRange.from.toISOString()}"`);
+    args.push(`--until="${timeRange.to.toISOString()}"`);
+  }
+  if (author) {
+    args.push(`--author="${author}"`);
+  }
+  let output;
+  try {
+    output = execSync2(args.join(" "), {
+      cwd: repoPath,
+      encoding: "utf-8",
+      maxBuffer: 100 * 1024 * 1024,
+      // 100MB buffer for large repos
+      stdio: ["pipe", "pipe", "ignore"]
+    });
+  } catch {
+    return [];
+  }
+  if (!output.trim()) {
+    return [];
+  }
+  return parseOutput(output, ignoreFilter);
+}
+function parseOutput(output, ignoreFilter) {
+  const commits = [];
+  const blocks = output.split(COMMIT_SEPARATOR).filter((b) => b.trim());
+  for (const block of blocks) {
+    const lines = block.trim().split("\n");
+    if (lines.length === 0) continue;
+    const headerLine = lines[0].replace(/^"|"$/g, "");
+    const parts = headerLine.split(FIELD_SEPARATOR);
+    if (parts.length < 5) continue;
+    const [hash, authorName, email, dateStr, ...messageParts] = parts;
+    const message = messageParts.join(FIELD_SEPARATOR);
+    const files = [];
+    for (let i = 1; i < lines.length; i++) {
+      const line = lines[i].trim();
+      if (!line) continue;
+      const tabParts = line.split("	");
+      if (tabParts.length !== 3) continue;
+      const [addedStr, deletedStr, filePath] = tabParts;
+      const added = addedStr === "-" ? 0 : parseInt(addedStr, 10) || 0;
+      const deleted = deletedStr === "-" ? 0 : parseInt(deletedStr, 10) || 0;
+      if (ignoreFilter.ignores(filePath)) continue;
+      files.push({ added, deleted, path: filePath });
+    }
+    commits.push({
+      hash,
+      author: authorName,
+      email,
+      date: new Date(dateStr),
+      message,
+      files
+    });
+  }
+  return commits;
+}
+async function loadGitignore(repoPath) {
+  const ignoreInstance = ig();
+  try {
+    const content = await readFile(join2(repoPath, ".gitignore"), "utf-8");
+    ignoreInstance.add(content);
+  } catch {
+  }
+  ignoreInstance.add([
+    "package-lock.json",
+    "pnpm-lock.yaml",
+    "yarn.lock"
+  ]);
+  return ignoreInstance;
+}
+
+// src/analyzer/stats-calculator.ts
+import { extname } from "path";
+function calculateStats(commits) {
+  if (commits.length === 0) {
+    return emptyStats();
+  }
+  const sorted = [...commits].sort(
+    (a, b) => a.date.getTime() - b.date.getTime()
+  );
+  let totalLinesAdded = 0;
+  let totalLinesDeleted = 0;
+  const allFilePaths = /* @__PURE__ */ new Set();
+  const authorMap = /* @__PURE__ */ new Map();
+  const fileTypeMap = /* @__PURE__ */ new Map();
+  const directoryMap = /* @__PURE__ */ new Map();
+  const directoryCommitSet = /* @__PURE__ */ new Map();
+  const hourlyDistribution = new Array(24).fill(0);
+  const dailyHeatmap = {};
+  const dailyCounts = /* @__PURE__ */ new Map();
+  for (const commit of sorted) {
+    const hour = commit.date.getHours();
+    hourlyDistribution[hour]++;
+    const dateKey = formatDateKey(commit.date);
+    dailyHeatmap[dateKey] = (dailyHeatmap[dateKey] || 0) + 1;
+    dailyCounts.set(dateKey, (dailyCounts.get(dateKey) || 0) + 1);
+    const authorKey = commit.email.toLowerCase();
+    let authorStat = authorMap.get(authorKey);
+    if (!authorStat) {
+      authorStat = {
+        name: commit.author,
+        email: commit.email,
+        commits: 0,
+        linesAdded: 0,
+        linesDeleted: 0,
+        lastActiveDate: commit.date
+      };
+      authorMap.set(authorKey, authorStat);
+    }
+    authorStat.commits++;
+    authorStat.lastActiveDate = commit.date;
+    for (const file of commit.files) {
+      totalLinesAdded += file.added;
+      totalLinesDeleted += file.deleted;
+      allFilePaths.add(file.path);
+      authorStat.linesAdded += file.added;
+      authorStat.linesDeleted += file.deleted;
+      const ext = extname(file.path).toLowerCase() || "(\u65E0\u6269\u5C55\u540D)";
+      let ftStat = fileTypeMap.get(ext);
+      if (!ftStat) {
+        ftStat = { extension: ext, added: 0, deleted: 0, fileCount: 0 };
+        fileTypeMap.set(ext, ftStat);
+      }
+      ftStat.added += file.added;
+      ftStat.deleted += file.deleted;
+      const topDir = getTopDirectory(file.path);
+      let dirStat = directoryMap.get(topDir);
+      if (!dirStat) {
+        dirStat = { path: topDir, commits: 0, linesChanged: 0 };
+        directoryMap.set(topDir, dirStat);
+        directoryCommitSet.set(topDir, /* @__PURE__ */ new Set());
+      }
+      dirStat.linesChanged += file.added + file.deleted;
+      directoryCommitSet.get(topDir).add(commit.hash);
+    }
+  }
+  for (const [dir, commitSet] of directoryCommitSet) {
+    const dirStat = directoryMap.get(dir);
+    if (dirStat) {
+      dirStat.commits = commitSet.size;
+    }
+  }
+  const fileCountByExt = /* @__PURE__ */ new Map();
+  for (const filePath of allFilePaths) {
+    const ext = extname(filePath).toLowerCase() || "(\u65E0\u6269\u5C55\u540D)";
+    if (!fileCountByExt.has(ext)) {
+      fileCountByExt.set(ext, /* @__PURE__ */ new Set());
+    }
+    fileCountByExt.get(ext).add(filePath);
+  }
+  for (const [ext, files] of fileCountByExt) {
+    const ftStat = fileTypeMap.get(ext);
+    if (ftStat) {
+      ftStat.fileCount = files.size;
+    }
+  }
+  let busiestDay = { date: "", count: 0 };
+  for (const [date, count] of dailyCounts) {
+    if (count > busiestDay.count) {
+      busiestDay = { date, count };
+    }
+  }
+  const authors = Array.from(authorMap.values()).sort(
+    (a, b) => b.commits - a.commits
+  );
+  const fileTypes = Array.from(fileTypeMap.values()).sort(
+    (a, b) => b.added + b.deleted - (a.added + a.deleted)
+  );
+  const directories = Array.from(directoryMap.values()).sort((a, b) => b.linesChanged - a.linesChanged).slice(0, 10);
+  return {
+    totalCommits: sorted.length,
+    linesAdded: totalLinesAdded,
+    linesDeleted: totalLinesDeleted,
+    filesChanged: allFilePaths.size,
+    firstCommitDate: sorted[0].date,
+    lastCommitDate: sorted[sorted.length - 1].date,
+    busiestDay,
+    authors,
+    fileTypes,
+    directories,
+    hourlyDistribution,
+    dailyHeatmap,
+    quality: calculateQualityMetrics(sorted),
+    timePatterns: calculateTimePatterns(sorted),
+    trends: calculateTrends(sorted),
+    collaboration: calculateCollaboration(sorted),
+    messageStats: calculateMessageStats(sorted),
+    authorFileTypeContributions: calculateAuthorFileTypeContributions(sorted)
+  };
+}
+function mergeStats(statsList) {
+  if (statsList.length === 0) return emptyStats();
+  if (statsList.length === 1) return statsList[0];
+  const merged = emptyStats();
+  for (const stats of statsList) {
+    merged.totalCommits += stats.totalCommits;
+    merged.linesAdded += stats.linesAdded;
+    merged.linesDeleted += stats.linesDeleted;
+    merged.filesChanged += stats.filesChanged;
+    if (!merged.firstCommitDate || stats.firstCommitDate < merged.firstCommitDate) {
+      merged.firstCommitDate = stats.firstCommitDate;
+    }
+    if (!merged.lastCommitDate || stats.lastCommitDate > merged.lastCommitDate) {
+      merged.lastCommitDate = stats.lastCommitDate;
+    }
+    for (let i = 0; i < 24; i++) {
+      merged.hourlyDistribution[i] += stats.hourlyDistribution[i];
+    }
+    for (const [date, count] of Object.entries(stats.dailyHeatmap)) {
+      merged.dailyHeatmap[date] = (merged.dailyHeatmap[date] || 0) + count;
+    }
+    for (const author of stats.authors) {
+      const existing = merged.authors.find(
+        (a) => a.email.toLowerCase() === author.email.toLowerCase()
+      );
+      if (existing) {
+        existing.commits += author.commits;
+        existing.linesAdded += author.linesAdded;
+        existing.linesDeleted += author.linesDeleted;
+        if (author.lastActiveDate > existing.lastActiveDate) {
+          existing.lastActiveDate = author.lastActiveDate;
+        }
+      } else {
+        merged.authors.push({ ...author });
+      }
+    }
+    for (const ft of stats.fileTypes) {
+      const existing = merged.fileTypes.find(
+        (f) => f.extension === ft.extension
+      );
+      if (existing) {
+        existing.added += ft.added;
+        existing.deleted += ft.deleted;
+        existing.fileCount += ft.fileCount;
+      } else {
+        merged.fileTypes.push({ ...ft });
+      }
+    }
+    for (const dir of stats.directories) {
+      const existing = merged.directories.find((d) => d.path === dir.path);
+      if (existing) {
+        existing.commits += dir.commits;
+        existing.linesChanged += dir.linesChanged;
+      } else {
+        merged.directories.push({ ...dir });
+      }
+    }
+    merged.quality.avgFilesPerCommit += stats.quality.avgFilesPerCommit;
+    merged.quality.avgLinesPerCommit += stats.quality.avgLinesPerCommit;
+    merged.quality.churnRate += stats.quality.churnRate;
+    for (const hf of stats.quality.hotFiles) {
+      const existing = merged.quality.hotFiles.find((h) => h.path === hf.path);
+      if (existing) {
+        existing.modifyCount += hf.modifyCount;
+        for (const author of hf.authors) {
+          if (!existing.authors.includes(author)) {
+            existing.authors.push(author);
+          }
+        }
+      } else {
+        merged.quality.hotFiles.push({ ...hf, authors: [...hf.authors] });
+      }
+    }
+    for (let i = 0; i < 7; i++) {
+      merged.timePatterns.weekdayDistribution[i] += stats.timePatterns.weekdayDistribution[i];
+    }
+    for (const wp of stats.trends.weeklyTrend) {
+      const existing = merged.trends.weeklyTrend.find((w) => w.week === wp.week);
+      if (existing) {
+        existing.commits += wp.commits;
+        existing.linesAdded += wp.linesAdded;
+        existing.linesDeleted += wp.linesDeleted;
+      } else {
+        merged.trends.weeklyTrend.push({ ...wp });
+      }
+    }
+    for (const cp of stats.trends.cumulativeLines) {
+      const existing = merged.trends.cumulativeLines.find(
+        (c) => c.date === cp.date
+      );
+      if (existing) {
+        existing.netLines += cp.netLines;
+      } else {
+        merged.trends.cumulativeLines.push({ ...cp });
+      }
+    }
+    for (const sf of stats.collaboration.soloFiles) {
+      const existing = merged.collaboration.soloFiles.find(
+        (s) => s.path === sf.path
+      );
+      if (existing) {
+        existing.commits += sf.commits;
+      } else {
+        merged.collaboration.soloFiles.push({ ...sf });
+      }
+    }
+    for (const ch of stats.collaboration.collaborationHotspots) {
+      const existing = merged.collaboration.collaborationHotspots.find(
+        (c) => c.path === ch.path
+      );
+      if (existing) {
+        existing.totalCommits += ch.totalCommits;
+        existing.authorCount = Math.max(existing.authorCount, ch.authorCount);
+      } else {
+        merged.collaboration.collaborationHotspots.push({ ...ch });
+      }
+    }
+    for (const [type, count] of Object.entries(stats.messageStats.typeDistribution)) {
+      merged.messageStats.typeDistribution[type] = (merged.messageStats.typeDistribution[type] || 0) + count;
+    }
+    merged.messageStats.avgMessageLength += stats.messageStats.avgMessageLength;
+  }
+  let busiestDay = { date: "", count: 0 };
+  for (const [date, count] of Object.entries(merged.dailyHeatmap)) {
+    if (count > busiestDay.count) {
+      busiestDay = { date, count };
+    }
+  }
+  merged.busiestDay = busiestDay;
+  merged.authors.sort((a, b) => b.commits - a.commits);
+  merged.fileTypes.sort(
+    (a, b) => b.added + b.deleted - (a.added + a.deleted)
+  );
+  merged.directories.sort((a, b) => b.linesChanged - a.linesChanged);
+  merged.directories = merged.directories.slice(0, 10);
+  const repoCount = statsList.length;
+  merged.quality.avgFilesPerCommit /= repoCount;
+  merged.quality.avgLinesPerCommit /= repoCount;
+  merged.quality.churnRate /= repoCount;
+  merged.quality.hotFiles.sort((a, b) => b.modifyCount - a.modifyCount);
+  merged.quality.hotFiles = merged.quality.hotFiles.slice(0, 10);
+  const totalWeekdayCommits = merged.timePatterns.weekdayDistribution.reduce(
+    (a, b) => a + b,
+    0
+  );
+  if (totalWeekdayCommits > 0) {
+    merged.timePatterns.weekendCommits = (merged.timePatterns.weekdayDistribution[5] + merged.timePatterns.weekdayDistribution[6]) / totalWeekdayCommits;
+  }
+  merged.trends.weeklyTrend.sort((a, b) => a.week.localeCompare(b.week));
+  merged.trends.cumulativeLines.sort((a, b) => a.date.localeCompare(b.date));
+  let cumulative = 0;
+  for (const point of merged.trends.cumulativeLines) {
+    cumulative += point.netLines;
+    point.netLines = cumulative;
+  }
+  merged.collaboration.soloFiles.sort((a, b) => b.commits - a.commits);
+  merged.collaboration.soloFiles = merged.collaboration.soloFiles.slice(0, 10);
+  merged.collaboration.collaborationHotspots.sort(
+    (a, b) => b.totalCommits - a.totalCommits
+  );
+  merged.collaboration.collaborationHotspots = merged.collaboration.collaborationHotspots.slice(0, 10);
+  merged.messageStats.avgMessageLength /= repoCount;
+  const contributionMap = /* @__PURE__ */ new Map();
+  for (const stats of statsList) {
+    for (const contrib of stats.authorFileTypeContributions) {
+      const key = `${contrib.email.toLowerCase()}|||${contrib.extension}`;
+      const existing = contributionMap.get(key);
+      if (existing) {
+        existing.linesAdded += contrib.linesAdded;
+        existing.linesDeleted += contrib.linesDeleted;
+        existing.commits += contrib.commits;
+        existing.fileCount += contrib.fileCount;
+      } else {
+        contributionMap.set(key, { ...contrib });
+      }
+    }
+  }
+  merged.authorFileTypeContributions = Array.from(contributionMap.values()).sort((a, b) => {
+    const totalA = a.linesAdded + a.linesDeleted;
+    const totalB = b.linesAdded + b.linesDeleted;
+    return totalB - totalA;
+  }).slice(0, 20);
+  return merged;
+}
+function emptyStats() {
+  return {
+    totalCommits: 0,
+    linesAdded: 0,
+    linesDeleted: 0,
+    filesChanged: 0,
+    firstCommitDate: /* @__PURE__ */ new Date(),
+    lastCommitDate: /* @__PURE__ */ new Date(),
+    busiestDay: { date: "", count: 0 },
+    authors: [],
+    fileTypes: [],
+    directories: [],
+    hourlyDistribution: new Array(24).fill(0),
+    dailyHeatmap: {},
+    quality: emptyQualityMetrics(),
+    timePatterns: emptyTimePatterns(),
+    trends: emptyTrendData(),
+    collaboration: emptyCollaborationMetrics(),
+    messageStats: emptyMessageStats(),
+    authorFileTypeContributions: []
+  };
+}
+function getTopDirectory(filePath) {
+  const parts = filePath.split("/");
+  return parts.length > 1 ? parts[0] : "(\u6839\u76EE\u5F55)";
+}
+function formatDateKey(date) {
+  const y = date.getFullYear();
+  const m = String(date.getMonth() + 1).padStart(2, "0");
+  const d = String(date.getDate()).padStart(2, "0");
+  return `${y}-${m}-${d}`;
+}
+function calculateQualityMetrics(commits) {
+  if (commits.length === 0) {
+    return emptyQualityMetrics();
+  }
+  const totalFiles = commits.reduce((sum, c) => sum + c.files.length, 0);
+  const avgFilesPerCommit = totalFiles / commits.length;
+  const totalLines = commits.reduce(
+    (sum, c) => sum + c.files.reduce((s, f) => s + f.added + f.deleted, 0),
+    0
+  );
+  const avgLinesPerCommit = totalLines / commits.length;
+  const totalAdded = commits.reduce(
+    (sum, c) => sum + c.files.reduce((s, f) => s + f.added, 0),
+    0
+  );
+  const totalDeleted = commits.reduce(
+    (sum, c) => sum + c.files.reduce((s, f) => s + f.deleted, 0),
+    0
+  );
+  const churnRate = totalAdded > 0 ? totalDeleted / totalAdded : 0;
+  const fileModifyMap = /* @__PURE__ */ new Map();
+  for (const commit of commits) {
+    for (const file of commit.files) {
+      const entry = fileModifyMap.get(file.path) || { count: 0, authors: /* @__PURE__ */ new Set() };
+      entry.count++;
+      entry.authors.add(commit.author);
+      fileModifyMap.set(file.path, entry);
+    }
+  }
+  const hotFiles = Array.from(fileModifyMap.entries()).map(([path, data]) => ({
+    path,
+    modifyCount: data.count,
+    authors: Array.from(data.authors)
+  })).sort((a, b) => b.modifyCount - a.modifyCount).slice(0, 10);
+  return { avgFilesPerCommit, avgLinesPerCommit, churnRate, hotFiles };
+}
+function calculateTimePatterns(commits) {
+  if (commits.length === 0) {
+    return emptyTimePatterns();
+  }
+  const weekdayDistribution = new Array(7).fill(0);
+  for (const commit of commits) {
+    const day = commit.date.getDay();
+    const idx = day === 0 ? 6 : day - 1;
+    weekdayDistribution[idx]++;
+  }
+  const weekendCommits = (weekdayDistribution[5] + weekdayDistribution[6]) / commits.length;
+  const sorted = [...commits].sort(
+    (a, b) => a.date.getTime() - b.date.getTime()
+  );
+  let totalInterval = 0;
+  for (let i = 1; i < sorted.length; i++) {
+    totalInterval += sorted[i].date.getTime() - sorted[i - 1].date.getTime();
+  }
+  const avgCommitInterval = sorted.length > 1 ? totalInterval / (sorted.length - 1) / 36e5 : 0;
+  const { longestStreak, currentStreak } = calculateStreaks(sorted);
+  return {
+    weekdayDistribution,
+    weekendCommits,
+    avgCommitInterval,
+    longestStreak,
+    currentStreak
+  };
+}
+function calculateStreaks(sortedCommits) {
+  if (sortedCommits.length === 0) {
+    return { longestStreak: 0, currentStreak: 0 };
+  }
+  const uniqueDates = /* @__PURE__ */ new Set();
+  for (const commit of sortedCommits) {
+    uniqueDates.add(formatDateKey(commit.date));
+  }
+  const sortedDates = Array.from(uniqueDates).sort();
+  if (sortedDates.length === 0) {
+    return { longestStreak: 0, currentStreak: 0 };
+  }
+  let longestStreak = 1;
+  let currentStreakCount = 1;
+  let tempStreak = 1;
+  for (let i = 1; i < sortedDates.length; i++) {
+    const prevDate = new Date(sortedDates[i - 1]);
+    const currDate = new Date(sortedDates[i]);
+    const diffDays = Math.round(
+      (currDate.getTime() - prevDate.getTime()) / (1e3 * 60 * 60 * 24)
+    );
+    if (diffDays === 1) {
+      tempStreak++;
+    } else {
+      tempStreak = 1;
+    }
+    longestStreak = Math.max(longestStreak, tempStreak);
+  }
+  const today = formatDateKey(/* @__PURE__ */ new Date());
+  const lastCommitDate = sortedDates[sortedDates.length - 1];
+  const lastDate = new Date(lastCommitDate);
+  const todayDate = new Date(today);
+  const daysSinceLastCommit = Math.round(
+    (todayDate.getTime() - lastDate.getTime()) / (1e3 * 60 * 60 * 24)
+  );
+  if (daysSinceLastCommit <= 1) {
+    currentStreakCount = 1;
+    for (let i = sortedDates.length - 2; i >= 0; i--) {
+      const currDate = new Date(sortedDates[i + 1]);
+      const prevDate = new Date(sortedDates[i]);
+      const diffDays = Math.round(
+        (currDate.getTime() - prevDate.getTime()) / (1e3 * 60 * 60 * 24)
+      );
+      if (diffDays === 1) {
+        currentStreakCount++;
+      } else {
+        break;
+      }
+    }
+  } else {
+    currentStreakCount = 0;
+  }
+  return { longestStreak, currentStreak: currentStreakCount };
+}
+function getWeekKey(date) {
+  const d = new Date(date);
+  d.setHours(0, 0, 0, 0);
+  d.setDate(d.getDate() + 4 - (d.getDay() || 7));
+  const yearStart = new Date(d.getFullYear(), 0, 1);
+  const weekNo = Math.ceil(
+    ((d.getTime() - yearStart.getTime()) / 864e5 + 1) / 7
+  );
+  return `${d.getFullYear()}-W${String(weekNo).padStart(2, "0")}`;
+}
+function calculateTrends(commits) {
+  if (commits.length === 0) {
+    return emptyTrendData();
+  }
+  const weekMap = /* @__PURE__ */ new Map();
+  for (const commit of commits) {
+    const week = getWeekKey(commit.date);
+    const entry = weekMap.get(week) || {
+      week,
+      commits: 0,
+      linesAdded: 0,
+      linesDeleted: 0
+    };
+    entry.commits++;
+    for (const file of commit.files) {
+      entry.linesAdded += file.added;
+      entry.linesDeleted += file.deleted;
+    }
+    weekMap.set(week, entry);
+  }
+  const weeklyTrend = Array.from(weekMap.values()).sort(
+    (a, b) => a.week.localeCompare(b.week)
+  );
+  const dailyNet = /* @__PURE__ */ new Map();
+  for (const commit of commits) {
+    const dateKey = formatDateKey(commit.date);
+    const net = commit.files.reduce((sum, f) => sum + f.added - f.deleted, 0);
+    dailyNet.set(dateKey, (dailyNet.get(dateKey) || 0) + net);
+  }
+  let cumulative = 0;
+  const cumulativeLines = Array.from(dailyNet.entries()).sort(([a], [b]) => a.localeCompare(b)).map(([date, net]) => {
+    cumulative += net;
+    return { date, netLines: cumulative };
+  });
+  return { weeklyTrend, cumulativeLines };
+}
+function calculateCollaboration(commits) {
+  if (commits.length === 0) {
+    return emptyCollaborationMetrics();
+  }
+  const fileAuthors = /* @__PURE__ */ new Map();
+  const fileCommits = /* @__PURE__ */ new Map();
+  for (const commit of commits) {
+    for (const file of commit.files) {
+      const authors = fileAuthors.get(file.path) || /* @__PURE__ */ new Set();
+      authors.add(commit.email.toLowerCase());
+      fileAuthors.set(file.path, authors);
+      fileCommits.set(file.path, (fileCommits.get(file.path) || 0) + 1);
+    }
+  }
+  const soloFiles = [];
+  const collaborationHotspots = [];
+  for (const [path, authors] of fileAuthors) {
+    const commitCount = fileCommits.get(path) || 0;
+    if (authors.size === 1 && commitCount >= 3) {
+      soloFiles.push({
+        path,
+        author: Array.from(authors)[0],
+        commits: commitCount
+      });
+    } else if (authors.size >= 2 && commitCount >= 5) {
+      collaborationHotspots.push({
+        path,
+        authorCount: authors.size,
+        totalCommits: commitCount
+      });
+    }
+  }
+  return {
+    soloFiles: soloFiles.sort((a, b) => b.commits - a.commits).slice(0, 10),
+    collaborationHotspots: collaborationHotspots.sort((a, b) => b.totalCommits - a.totalCommits).slice(0, 10)
+  };
+}
+function calculateMessageStats(commits) {
+  if (commits.length === 0) {
+    return emptyMessageStats();
+  }
+  const typeDistribution = {};
+  let totalLength = 0;
+  const typeRegex = /^(feat|fix|docs|style|refactor|test|chore|perf|ci|build|revert)(\(.+\))?:/i;
+  for (const commit of commits) {
+    totalLength += commit.message.length;
+    const match = commit.message.match(typeRegex);
+    if (match) {
+      const type = match[1].toLowerCase();
+      typeDistribution[type] = (typeDistribution[type] || 0) + 1;
+    } else {
+      typeDistribution["other"] = (typeDistribution["other"] || 0) + 1;
+    }
+  }
+  return {
+    typeDistribution,
+    avgMessageLength: totalLength / commits.length
+  };
+}
+function calculateAuthorFileTypeContributions(commits) {
+  if (commits.length === 0) {
+    return [];
+  }
+  const contributionMap = /* @__PURE__ */ new Map();
+  const uniqueFilesMap = /* @__PURE__ */ new Map();
+  for (const commit of commits) {
+    for (const file of commit.files) {
+      const ext = extname(file.path).toLowerCase() || "(\u65E0\u6269\u5C55\u540D)";
+      const key = `${commit.email.toLowerCase()}|||${ext}`;
+      let contribution = contributionMap.get(key);
+      if (!contribution) {
+        contribution = {
+          author: commit.author,
+          email: commit.email,
+          extension: ext,
+          linesAdded: 0,
+          linesDeleted: 0,
+          commits: 0,
+          fileCount: 0
+        };
+        contributionMap.set(key, contribution);
+        uniqueFilesMap.set(key, /* @__PURE__ */ new Set());
+      }
+      contribution.linesAdded += file.added;
+      contribution.linesDeleted += file.deleted;
+      uniqueFilesMap.get(key).add(file.path);
+    }
+  }
+  const commitCountMap = /* @__PURE__ */ new Map();
+  for (const commit of commits) {
+    for (const file of commit.files) {
+      const ext = extname(file.path).toLowerCase() || "(\u65E0\u6269\u5C55\u540D)";
+      const key = `${commit.email.toLowerCase()}|||${ext}`;
+      if (!commitCountMap.has(key)) {
+        commitCountMap.set(key, /* @__PURE__ */ new Set());
+      }
+      commitCountMap.get(key).add(commit.hash);
+    }
+  }
+  for (const [key, contribution] of contributionMap) {
+    contribution.commits = commitCountMap.get(key)?.size || 0;
+    contribution.fileCount = uniqueFilesMap.get(key)?.size || 0;
+  }
+  return Array.from(contributionMap.values()).sort((a, b) => {
+    const totalA = a.linesAdded + a.linesDeleted;
+    const totalB = b.linesAdded + b.linesDeleted;
+    return totalB - totalA;
+  }).slice(0, 20);
+}
+function emptyQualityMetrics() {
+  return {
+    avgFilesPerCommit: 0,
+    avgLinesPerCommit: 0,
+    churnRate: 0,
+    hotFiles: []
+  };
+}
+function emptyTimePatterns() {
+  return {
+    weekdayDistribution: new Array(7).fill(0),
+    weekendCommits: 0,
+    avgCommitInterval: 0,
+    longestStreak: 0,
+    currentStreak: 0
+  };
+}
+function emptyTrendData() {
+  return {
+    weeklyTrend: [],
+    cumulativeLines: []
+  };
+}
+function emptyCollaborationMetrics() {
+  return {
+    soloFiles: [],
+    collaborationHotspots: []
+  };
+}
+function emptyMessageStats() {
+  return {
+    typeDistribution: {},
+    avgMessageLength: 0
+  };
+}
+
+// src/analyzer/advanced/team-health.ts
+function calculateTeamHealth(commits) {
+  if (commits.length === 0) {
+    return emptyTeamHealth();
+  }
+  const authorFiles = buildAuthorFilesMap(commits);
+  const fileAuthors = buildFileAuthorsMap(commits);
+  if (fileAuthors.size === 0) {
+    return emptyTeamHealth();
+  }
+  const authorScores = calculateAuthorScores(authorFiles, fileAuthors);
+  const criticalAuthors = authorScores.filter((a) => a.knowledgeScore > 10);
+  const totalUniqueFiles = criticalAuthors.reduce(
+    (sum, a) => sum + a.uniqueFiles.length,
+    0
+  );
+  const knowledgeDistribution = 1 - totalUniqueFiles / fileAuthors.size;
+  const busFactor = criticalAuthors.length;
+  const riskLevel = busFactor === 1 ? "high" : busFactor <= 3 ? "medium" : "low";
+  return {
+    busFactor,
+    criticalAuthors,
+    knowledgeDistribution,
+    riskLevel
+  };
+}
+function buildAuthorFilesMap(commits) {
+  const map = /* @__PURE__ */ new Map();
+  for (const commit of commits) {
+    const authorKey = `${commit.author} <${commit.email}>`;
+    if (!map.has(authorKey)) {
+      map.set(authorKey, /* @__PURE__ */ new Set());
+    }
+    const files = map.get(authorKey);
+    for (const file of commit.files) {
+      files.add(file.path);
+    }
+  }
+  return map;
+}
+function buildFileAuthorsMap(commits) {
+  const map = /* @__PURE__ */ new Map();
+  for (const commit of commits) {
+    const authorKey = `${commit.author} <${commit.email}>`;
+    for (const file of commit.files) {
+      if (!map.has(file.path)) {
+        map.set(file.path, /* @__PURE__ */ new Map());
+      }
+      const authors = map.get(file.path);
+      authors.set(authorKey, (authors.get(authorKey) || 0) + 1);
+    }
+  }
+  return map;
+}
+function calculateAuthorScores(authorFiles, fileAuthors) {
+  const scores = [];
+  for (const [authorKey, files] of authorFiles) {
+    const uniqueFiles = [];
+    const dominantFiles = [];
+    for (const filePath of files) {
+      const authors = fileAuthors.get(filePath);
+      const authorCount = authors.size;
+      if (authorCount === 1) {
+        uniqueFiles.push(filePath);
+        continue;
+      }
+      const authorCommits = authors.get(authorKey) || 0;
+      const totalCommits = Array.from(authors.values()).reduce((a, b) => a + b, 0);
+      if (authorCommits / totalCommits > 0.5) {
+        dominantFiles.push(filePath);
+      }
+    }
+    const knowledgeScore = (uniqueFiles.length * 2 + dominantFiles.length) / fileAuthors.size * 100;
+    const [name, email] = parseAuthorKey(authorKey);
+    scores.push({
+      name,
+      email,
+      uniqueFiles,
+      dominantFiles,
+      knowledgeScore
+    });
+  }
+  return scores;
+}
+function parseAuthorKey(authorKey) {
+  const match = authorKey.match(/^(.+) <(.+)>$/);
+  if (match) {
+    return [match[1], match[2]];
+  }
+  return [authorKey, ""];
+}
+function emptyTeamHealth() {
+  return {
+    busFactor: 0,
+    criticalAuthors: [],
+    knowledgeDistribution: 1,
+    riskLevel: "low"
+  };
+}
+
+// src/analyzer/advanced/code-stability.ts
+function calculateStability(commits) {
+  if (commits.length === 0) {
+    return emptyStability();
+  }
+  const fileStats = /* @__PURE__ */ new Map();
+  for (const commit of commits) {
+    for (const file of commit.files) {
+      const stat2 = fileStats.get(file.path) || { added: 0, deleted: 0, modifyCount: 0 };
+      stat2.added += file.added;
+      stat2.deleted += file.deleted;
+      stat2.modifyCount++;
+      fileStats.set(file.path, stat2);
+    }
+  }
+  const fileChurnRate = Array.from(fileStats.entries()).map(([path, { added, deleted, modifyCount }]) => ({
+    path,
+    added,
+    deleted,
+    churnRate: added > 0 ? deleted / added : 0,
+    modifyCount,
+    isUnstable: deleted / Math.max(added, 1) > 0.5
+  })).sort((a, b) => b.churnRate - a.churnRate).slice(0, 20);
+  const dirStats = /* @__PURE__ */ new Map();
+  for (const commit of commits) {
+    for (const file of commit.files) {
+      const dir = getTopDirectory2(file.path);
+      const stat2 = dirStats.get(dir) || { added: 0, deleted: 0, files: /* @__PURE__ */ new Set() };
+      stat2.added += file.added;
+      stat2.deleted += file.deleted;
+      stat2.files.add(file.path);
+      dirStats.set(dir, stat2);
+    }
+  }
+  const directoryChurnRate = Array.from(dirStats.entries()).map(([path, { added, deleted, files }]) => ({
+    path,
+    churnRate: added > 0 ? deleted / added : 0,
+    totalChanges: added + deleted,
+    fileCount: files.size
+  })).sort((a, b) => b.churnRate - a.churnRate).slice(0, 10);
+  const revertCommits = commits.filter((c) => /revert|rollback/i.test(c.message)).length;
+  const revertRate = revertCommits / commits.length;
+  const fixCommits = commits.filter((c) => /^fix(\(.+\))?:/i.test(c.message)).length;
+  const fixCommitRate = fixCommits / commits.length;
+  const avgChurnRate = fileChurnRate.length > 0 ? fileChurnRate.reduce((sum, f) => sum + f.churnRate, 0) / fileChurnRate.length : 0;
+  const stabilityScore = Math.max(
+    0,
+    Math.round(100 - (avgChurnRate * 50 + revertRate * 100 + fixCommitRate * 50))
+  );
+  return {
+    fileChurnRate,
+    directoryChurnRate,
+    revertRate: Math.round(revertRate * 100) / 100,
+    fixCommitRate: Math.round(fixCommitRate * 100) / 100,
+    stabilityScore
+  };
+}
+function getTopDirectory2(filePath) {
+  const parts = filePath.split("/");
+  return parts.length > 1 ? parts[0] : "(\u6839\u76EE\u5F55)";
+}
+function emptyStability() {
+  return {
+    fileChurnRate: [],
+    directoryChurnRate: [],
+    revertRate: 0,
+    fixCommitRate: 0,
+    stabilityScore: 100
+  };
+}
+
+// src/analyzer/advanced/work-pressure.ts
+function calculateWorkPressure(commits) {
+  if (commits.length === 0) {
+    return emptyWorkPressure();
+  }
+  let lateNightCommits = 0;
+  let earlyMorningCommits = 0;
+  let weekendCommits = 0;
+  const holidayMap = /* @__PURE__ */ new Map();
+  const holidays = getHolidays();
+  for (const commit of commits) {
+    const hour = commit.date.getHours();
+    const day = commit.date.getDay();
+    const dateKey = formatDate(commit.date);
+    if (hour >= 23 || hour < 2) {
+      lateNightCommits++;
+    }
+    if (hour >= 2 && hour < 6) {
+      earlyMorningCommits++;
+    }
+    if (day === 0 || day === 6) {
+      weekendCommits++;
+    }
+    const holiday = holidays.get(dateKey);
+    if (holiday) {
+      const entry = holidayMap.get(dateKey) || { name: holiday, commits: 0 };
+      entry.commits++;
+      holidayMap.set(dateKey, entry);
+    }
+  }
+  const holidayCommits = Array.from(holidayMap.entries()).map(([date, { name, commits: commits2 }]) => ({ date, holidayName: name, commits: commits2 })).sort((a, b) => b.commits - a.commits);
+  const holidayTotal = holidayCommits.reduce((sum, h) => sum + h.commits, 0);
+  const offHoursCount = lateNightCommits + earlyMorningCommits + weekendCommits + holidayTotal;
+  const offHoursRate = offHoursCount / commits.length;
+  const lateNightWeight = lateNightCommits / commits.length * 40;
+  const earlyMorningWeight = earlyMorningCommits / commits.length * 30;
+  const weekendWeight = weekendCommits / commits.length * 20;
+  const holidayWeight = (holidayCommits.length > 0 ? 1 : 0) * 10;
+  const pressureScore = Math.round(lateNightWeight + earlyMorningWeight + weekendWeight + holidayWeight);
+  return {
+    lateNightCommits,
+    earlyMorningCommits,
+    weekendCommits,
+    holidayCommits,
+    pressureScore,
+    offHoursRate: Math.round(offHoursRate * 1e3) / 1e3
+  };
+}
+function emptyWorkPressure() {
+  return {
+    lateNightCommits: 0,
+    earlyMorningCommits: 0,
+    weekendCommits: 0,
+    holidayCommits: [],
+    pressureScore: 0,
+    offHoursRate: 0
+  };
+}
+function getHolidays() {
+  const holidays = /* @__PURE__ */ new Map();
+  const dates2024 = [
+    ["2024-01-01", "\u5143\u65E6"],
+    ["2024-02-10", "\u6625\u8282"],
+    ["2024-02-11", "\u6625\u8282"],
+    ["2024-02-12", "\u6625\u8282"],
+    ["2024-04-04", "\u6E05\u660E\u8282"],
+    ["2024-04-05", "\u6E05\u660E\u8282"],
+    ["2024-04-06", "\u6E05\u660E\u8282"],
+    ["2024-05-01", "\u52B3\u52A8\u8282"],
+    ["2024-05-02", "\u52B3\u52A8\u8282"],
+    ["2024-05-03", "\u52B3\u52A8\u8282"],
+    ["2024-06-10", "\u7AEF\u5348\u8282"],
+    ["2024-09-15", "\u4E2D\u79CB\u8282"],
+    ["2024-09-16", "\u4E2D\u79CB\u8282"],
+    ["2024-09-17", "\u4E2D\u79CB\u8282"],
+    ["2024-10-01", "\u56FD\u5E86\u8282"],
+    ["2024-10-02", "\u56FD\u5E86\u8282"],
+    ["2024-10-03", "\u56FD\u5E86\u8282"]
+  ];
+  const dates2025 = [
+    ["2025-01-01", "\u5143\u65E6"],
+    ["2025-01-29", "\u6625\u8282"],
+    ["2025-01-30", "\u6625\u8282"],
+    ["2025-01-31", "\u6625\u8282"],
+    ["2025-04-04", "\u6E05\u660E\u8282"],
+    ["2025-04-05", "\u6E05\u660E\u8282"],
+    ["2025-04-06", "\u6E05\u660E\u8282"],
+    ["2025-05-01", "\u52B3\u52A8\u8282"],
+    ["2025-05-02", "\u52B3\u52A8\u8282"],
+    ["2025-05-03", "\u52B3\u52A8\u8282"],
+    ["2025-05-31", "\u7AEF\u5348\u8282"],
+    ["2025-10-01", "\u56FD\u5E86\u8282"],
+    ["2025-10-02", "\u56FD\u5E86\u8282"],
+    ["2025-10-06", "\u4E2D\u79CB\u8282"]
+  ];
+  const dates2026 = [
+    ["2026-01-01", "\u5143\u65E6"],
+    ["2026-02-17", "\u6625\u8282"],
+    ["2026-02-18", "\u6625\u8282"],
+    ["2026-02-19", "\u6625\u8282"],
+    ["2026-04-05", "\u6E05\u660E\u8282"],
+    ["2026-05-01", "\u52B3\u52A8\u8282"],
+    ["2026-06-19", "\u7AEF\u5348\u8282"],
+    ["2026-09-25", "\u4E2D\u79CB\u8282"],
+    ["2026-10-01", "\u56FD\u5E86\u8282"],
+    ["2026-10-02", "\u56FD\u5E86\u8282"]
+  ];
+  [...dates2024, ...dates2025, ...dates2026].forEach(([date, name]) => {
+    holidays.set(date, name);
+  });
+  return holidays;
+}
+function formatDate(date) {
+  return date.toISOString().split("T")[0];
+}
+
+// src/analyzer/advanced/contributor-churn.ts
+function calculateContributorChurn(commits) {
+  if (commits.length === 0) {
+    return emptyContributorChurn();
+  }
+  const authorLastCommit = /* @__PURE__ */ new Map();
+  for (const commit of commits) {
+    const key = commit.email.toLowerCase();
+    const existing = authorLastCommit.get(key);
+    if (!existing) {
+      authorLastCommit.set(key, {
+        name: commit.author,
+        email: commit.email,
+        lastDate: commit.date,
+        firstDate: commit.date,
+        totalCommits: 1
+      });
+    } else {
+      if (commit.date > existing.lastDate) {
+        existing.lastDate = commit.date;
+      }
+      if (commit.date < existing.firstDate) {
+        existing.firstDate = commit.date;
+      }
+      existing.totalCommits++;
+    }
+  }
+  const now = /* @__PURE__ */ new Date();
+  const active = [];
+  const occasional = [];
+  const dormant = [];
+  const lost = [];
+  const newJoiners = [];
+  for (const [, author] of authorLastCommit) {
+    const daysSinceLast = Math.floor((now.getTime() - author.lastDate.getTime()) / (1e3 * 60 * 60 * 24));
+    const daysSinceFirst = Math.floor((now.getTime() - author.firstDate.getTime()) / (1e3 * 60 * 60 * 24));
+    const detail = {
+      name: author.name,
+      email: author.email,
+      lastCommitDate: author.lastDate,
+      daysSinceLastCommit: daysSinceLast,
+      totalCommits: author.totalCommits
+    };
+    if (daysSinceFirst < 30) {
+      newJoiners.push(detail);
+    }
+    if (daysSinceLast < 30) {
+      active.push(detail);
+    } else if (daysSinceLast < 90) {
+      occasional.push(detail);
+    } else if (daysSinceLast < 180) {
+      dormant.push(detail);
+    } else {
+      lost.push(detail);
+    }
+  }
+  const totalAuthors = authorLastCommit.size;
+  const churnRate = totalAuthors > 0 ? lost.length / totalAuthors : 0;
+  const retentionRate = totalAuthors > 0 ? active.length / totalAuthors : 0;
+  const growthRate = totalAuthors > 0 ? newJoiners.length / totalAuthors : 0;
+  return {
+    active: active.sort((a, b) => b.totalCommits - a.totalCommits),
+    occasional: occasional.sort((a, b) => a.daysSinceLastCommit - b.daysSinceLastCommit),
+    dormant: dormant.sort((a, b) => a.daysSinceLastCommit - b.daysSinceLastCommit),
+    lost: lost.sort((a, b) => b.totalCommits - a.totalCommits),
+    newJoiners: newJoiners.sort((a, b) => a.daysSinceLastCommit - b.daysSinceLastCommit),
+    churnRate: Math.round(churnRate * 1e3) / 1e3,
+    retentionRate: Math.round(retentionRate * 1e3) / 1e3,
+    growthRate: Math.round(growthRate * 1e3) / 1e3
+  };
+}
+function emptyContributorChurn() {
+  return {
+    active: [],
+    occasional: [],
+    dormant: [],
+    lost: [],
+    newJoiners: [],
+    churnRate: 0,
+    retentionRate: 0,
+    growthRate: 0
+  };
+}
+
+// src/analyzer/advanced/collaboration.ts
+var MAX_FILES_PER_COMMIT = 50;
+function calculateAdvancedCollaboration(commits) {
+  if (commits.length === 0) {
+    return emptyCollaboration();
+  }
+  const fileModifyCount = /* @__PURE__ */ new Map();
+  for (const commit of commits) {
+    commit.files.forEach((f) => {
+      fileModifyCount.set(f.path, (fileModifyCount.get(f.path) || 0) + 1);
+    });
+  }
+  const tightCoupling = detectTightCoupling(commits, fileModifyCount);
+  const pairProgramming = detectPairProgramming(commits);
+  const avgCoupling = tightCoupling.length > 0 ? tightCoupling.reduce((sum, p) => sum + p.coupling, 0) / tightCoupling.length : 0;
+  const couplingScore = Math.min(100, Math.round(avgCoupling * 100));
+  return {
+    tightCoupling,
+    frequentPairs: [],
+    // 简化版：跳过 24h 窗口分析
+    pairProgramming,
+    couplingScore
+  };
+}
+function detectTightCoupling(commits, fileModifyCount) {
+  const coCommitPairs = /* @__PURE__ */ new Map();
+  for (const commit of commits) {
+    const files = commit.files.map((f) => f.path).slice(0, MAX_FILES_PER_COMMIT).sort();
+    for (let i = 0; i < files.length; i++) {
+      for (let j = i + 1; j < files.length; j++) {
+        const pairKey = `${files[i]}|||${files[j]}`;
+        const existing = coCommitPairs.get(pairKey) || {
+          count: 0,
+          file1: files[i],
+          file2: files[j]
+        };
+        existing.count++;
+        coCommitPairs.set(pairKey, existing);
+      }
+    }
+  }
+  const tightCoupling = Array.from(coCommitPairs.values()).map(({ file1, file2, count }) => {
+    const count1 = fileModifyCount.get(file1) || 1;
+    const count2 = fileModifyCount.get(file2) || 1;
+    const coupling = count / Math.min(count1, count2);
+    return {
+      file1,
+      file2,
+      coOccurrence: count,
+      coupling
+    };
+  }).filter((p) => p.coOccurrence >= 3).sort((a, b) => b.coupling - a.coupling).slice(0, 20);
+  return tightCoupling;
+}
+function detectPairProgramming(commits) {
+  const fileAuthors = /* @__PURE__ */ new Map();
+  for (const commit of commits) {
+    for (const file of commit.files) {
+      if (!fileAuthors.has(file.path)) {
+        fileAuthors.set(file.path, /* @__PURE__ */ new Map());
+      }
+      const authorMap = fileAuthors.get(file.path);
+      const email = commit.email.toLowerCase();
+      authorMap.set(email, (authorMap.get(email) || 0) + 1);
+    }
+  }
+  const authorPairMap = /* @__PURE__ */ new Map();
+  for (const [filePath, authorMap] of fileAuthors) {
+    if (authorMap.size >= 2) {
+      const sortedAuthors = Array.from(authorMap.entries()).sort((a, b) => b[1] - a[1]).slice(0, 2);
+      if (sortedAuthors.length === 2) {
+        const [a1, a2] = [sortedAuthors[0][0], sortedAuthors[1][0]].sort();
+        const pairKey = `${a1}|||${a2}`;
+        const existing = authorPairMap.get(pairKey) || {
+          author1: a1,
+          author2: a2,
+          files: /* @__PURE__ */ new Set(),
+          count: 0
+        };
+        existing.files.add(filePath);
+        existing.count++;
+        authorPairMap.set(pairKey, existing);
+      }
+    }
+  }
+  const pairProgramming = Array.from(authorPairMap.values()).filter((p) => p.files.size >= 3).map((p) => ({
+    author1: p.author1,
+    author2: p.author2,
+    sharedFiles: Array.from(p.files),
+    collaborationCount: p.count
+  })).sort((a, b) => b.collaborationCount - a.collaborationCount).slice(0, 10);
+  return pairProgramming;
+}
+function emptyCollaboration() {
+  return {
+    tightCoupling: [],
+    frequentPairs: [],
+    pairProgramming: [],
+    couplingScore: 0
+  };
+}
+
+// src/analyzer/advanced/index.ts
+function calculateAdvancedStats(commits) {
+  return {
+    teamHealth: calculateTeamHealth(commits),
+    stability: calculateStability(commits),
+    workPressure: calculateWorkPressure(commits),
+    contributorChurn: calculateContributorChurn(commits),
+    advancedCollaboration: calculateAdvancedCollaboration(commits)
+  };
+}
+
+// src/analyzer/index.ts
+async function analyzeRepos(options) {
+  const { repos, timeRange, author } = options;
+  const spinner = ora2("\u5206\u6790\u63D0\u4EA4\u8BB0\u5F55...").start();
+  const allStats = [];
+  for (let i = 0; i < repos.length; i++) {
+    const repo = repos[i];
+    spinner.text = `\u5206\u6790\u63D0\u4EA4\u8BB0\u5F55 (${i + 1}/${repos.length}) - ${repo.name}`;
+    try {
+      const commits = await parseGitLog(repo.path, timeRange, author);
+      if (commits.length > 1e5) {
+        spinner.info(
+          chalk.yellow(`${repo.name} \u5305\u542B ${commits.length.toLocaleString()} \u6761\u63D0\u4EA4\uFF0C\u5904\u7406\u53EF\u80FD\u9700\u8981\u4E00\u4E9B\u65F6\u95F4...`)
+        );
+        spinner.start();
+      }
+      const stats = calculateStats(commits);
+      const advancedStats = calculateAdvancedStats(commits);
+      const fullStats = {
+        ...stats,
+        ...advancedStats
+      };
+      allStats.push(fullStats);
+    } catch (error) {
+      spinner.warn(
+        chalk.yellow(
+          `\u8DF3\u8FC7\u4ED3\u5E93 ${repo.name}: ${error instanceof Error ? error.message : "\u672A\u77E5\u9519\u8BEF"}`
+        )
+      );
+      spinner.start();
+    }
+  }
+  const merged = mergeStats(allStats);
+  spinner.succeed(
+    `\u5206\u6790\u5B8C\u6210: ${merged.totalCommits.toLocaleString()} \u6761\u63D0\u4EA4, ${merged.authors.length} \u4F4D\u4F5C\u8005, +${merged.linesAdded.toLocaleString()} / -${merged.linesDeleted.toLocaleString()} \u884C`
+  );
+  return merged;
+}
+
+// src/reporter/index.ts
+import { writeFile } from "fs/promises";
+import { resolve as resolve2 } from "path";
+import chalk2 from "chalk";
+import ora3 from "ora";
+import open from "open";
+
+// src/reporter/html-builder.ts
+import { readFile as readFile2 } from "fs/promises";
+import { resolve, dirname } from "path";
+import { fileURLToPath } from "url";
+async function buildHtml(stats, options) {
+  const template = await loadTemplate();
+  const reportData = {
+    stats: serializeStats(stats),
+    generatedAt: (/* @__PURE__ */ new Date()).toLocaleString("zh-CN"),
+    timeRange: options.timeRange ? {
+      from: options.timeRange.from.toISOString().split("T")[0],
+      to: options.timeRange.to.toISOString().split("T")[0]
+    } : null,
+    repos: options.repoNames
+  };
+  const jsonData = JSON.stringify(reportData).replace(/</g, "\\u003c").replace(/>/g, "\\u003e").replace(/&/g, "\\u0026");
+  return template.replace("__REPORT_DATA__", jsonData);
+}
+function serializeStats(stats) {
+  const serializeAuthorDetail = (author) => ({
+    ...author,
+    lastCommitDate: author.lastCommitDate.toISOString()
+  });
+  return {
+    ...stats,
+    firstCommitDate: stats.firstCommitDate.toISOString(),
+    lastCommitDate: stats.lastCommitDate.toISOString(),
+    authors: stats.authors.map((a) => ({
+      ...a,
+      lastActiveDate: a.lastActiveDate.toISOString()
+    })),
+    contributorChurn: stats.contributorChurn ? {
+      ...stats.contributorChurn,
+      active: stats.contributorChurn.active.map(serializeAuthorDetail),
+      occasional: stats.contributorChurn.occasional.map(serializeAuthorDetail),
+      dormant: stats.contributorChurn.dormant.map(serializeAuthorDetail),
+      lost: stats.contributorChurn.lost.map(serializeAuthorDetail),
+      newJoiners: stats.contributorChurn.newJoiners.map(serializeAuthorDetail)
+    } : void 0
+  };
+}
+async function loadTemplate() {
+  const currentDir = dirname(fileURLToPath(import.meta.url));
+  const possiblePaths = [
+    resolve(currentDir, "../templates/report.html"),
+    resolve(currentDir, "../../templates/report.html"),
+    resolve(currentDir, "../../../templates/report.html")
+  ];
+  for (const templatePath of possiblePaths) {
+    try {
+      return await readFile2(templatePath, "utf-8");
+    } catch {
+    }
+  }
+  throw new Error("\u65E0\u6CD5\u627E\u5230 HTML \u6A21\u677F\u6587\u4EF6");
+}
+
+// src/reporter/index.ts
+async function generateReport(stats, options) {
+  const spinner = ora3("\u751F\u6210\u62A5\u544A...").start();
+  try {
+    const html = await buildHtml(stats, options);
+    const outputPath = resolve2(process.cwd(), options.outputPath);
+    await writeFile(outputPath, html, "utf-8");
+    spinner.succeed(`\u62A5\u544A\u5DF2\u751F\u6210: ${chalk2.cyan(outputPath)}`);
+    if (options.autoOpen) {
+      await open(outputPath);
+      console.log(chalk2.green("\u2713 \u5DF2\u5728\u6D4F\u89C8\u5668\u4E2D\u6253\u5F00"));
+    }
+  } catch (error) {
+    spinner.fail("\u751F\u6210\u62A5\u544A\u5931\u8D25");
+    throw error;
+  }
+}
+
+// src/cli/time-utils.ts
+var PERIOD_REGEX = /^(\d+)(d|m|y)$/;
+function parsePeriod(period) {
+  if (period === "all") {
+    return null;
+  }
+  const match = PERIOD_REGEX.exec(period);
+  if (!match) {
+    throw new Error(`\u65E0\u6548\u7684\u65F6\u95F4\u9884\u8BBE: "${period}"\uFF0C\u652F\u6301\u683C\u5F0F: 7d, 1m, 3m, 6m, 1y, all`);
+  }
+  const amount = parseInt(match[1], 10);
+  const unit = match[2];
+  const to = /* @__PURE__ */ new Date();
+  const from = /* @__PURE__ */ new Date();
+  switch (unit) {
+    case "d":
+      from.setDate(from.getDate() - amount);
+      break;
+    case "m":
+      from.setMonth(from.getMonth() - amount);
+      break;
+    case "y":
+      from.setFullYear(from.getFullYear() - amount);
+      break;
+  }
+  return { from, to };
+}
+function parseDate(dateStr) {
+  const date = new Date(dateStr);
+  if (isNaN(date.getTime())) {
+    throw new Error(`\u65E0\u6548\u7684\u65E5\u671F\u683C\u5F0F: "${dateStr}"\uFF0C\u8BF7\u4F7F\u7528 YYYY-MM-DD \u683C\u5F0F`);
+  }
+  return date;
+}
+function resolveTimeRange(opts) {
+  if (opts.from || opts.to) {
+    const to = opts.to ? parseDate(opts.to) : /* @__PURE__ */ new Date();
+    const from = opts.from ? parseDate(opts.from) : (() => {
+      const d = new Date(to);
+      d.setMonth(d.getMonth() - 3);
+      return d;
+    })();
+    if (from > to) {
+      throw new Error("\u8D77\u59CB\u65E5\u671F\u4E0D\u80FD\u665A\u4E8E\u7ED3\u675F\u65E5\u671F");
+    }
+    return { from, to };
+  }
+  return parsePeriod(opts.period);
+}
+
+// src/cli/index.ts
+var program = new Command();
+program.name("commit-report").description("Git \u63D0\u4EA4\u7EDF\u8BA1\u5DE5\u5177\uFF0C\u751F\u6210\u53EF\u89C6\u5316 HTML \u62A5\u544A").version("1.0.0").argument("[directory]", "\u8981\u626B\u63CF\u7684\u76EE\u5F55\u8DEF\u5F84", process.cwd()).option("-p, --period <period>", "\u65F6\u95F4\u9884\u8BBE (7d/1m/3m/6m/1y/all)", "all").option("-f, --from <date>", "\u8D77\u59CB\u65E5\u671F (YYYY-MM-DD)").option("-t, --to <date>", "\u7ED3\u675F\u65E5\u671F (YYYY-MM-DD)").option("-a, --author <name>", "\u8FC7\u6EE4\u4F5C\u8005").option("-o, --output <file>", "\u8F93\u51FA\u6587\u4EF6\u540D", "commit-report.html").option("--no-open", "\u4E0D\u81EA\u52A8\u6253\u5F00\u6D4F\u89C8\u5668").option("-d, --depth <number>", "\u6700\u5927\u626B\u63CF\u6DF1\u5EA6", "20").action(async (directory, opts) => {
+  try {
+    await run(directory, opts);
+  } catch (error) {
+    if (error instanceof Error && error.message === "USER_CANCEL") {
+      console.log(chalk3.yellow("\n\u5DF2\u53D6\u6D88\u64CD\u4F5C"));
+      process.exit(0);
+    }
+    console.error(chalk3.red(`
+\u9519\u8BEF: ${error instanceof Error ? error.message : String(error)}`));
+    process.exit(1);
+  }
+});
+async function run(directory, opts) {
+  await checkGitInstalled();
+  const timeRange = resolveTimeRange(opts);
+  const repos = await scanRepositories({
+    targetDir: directory,
+    maxDepth: Number(opts.depth)
+  });
+  if (repos.length === 0) {
+    console.log(chalk3.red("\u672A\u627E\u5230 Git \u4ED3\u5E93"));
+    process.exit(1);
+  }
+  let selectedRepos;
+  if (repos.length === 1) {
+    selectedRepos = repos;
+    console.log(chalk3.cyan(`\u627E\u5230 1 \u4E2A Git \u4ED3\u5E93: ${repos[0].name}`));
+  } else {
+    console.log(chalk3.cyan(`
+\u627E\u5230 ${repos.length} \u4E2A Git \u4ED3\u5E93:
+`));
+    const selected = await checkbox({
+      message: "\u9009\u62E9\u8981\u5206\u6790\u7684\u4ED3\u5E93\uFF08\u7A7A\u683C\u9009\u62E9\uFF0C\u56DE\u8F66\u786E\u8BA4\uFF09",
+      choices: repos.map((repo) => ({
+        name: `${repo.name} (${repo.commitCount} commits)`,
+        value: repo.path,
+        checked: true
+      }))
+    });
+    if (selected.length === 0) {
+      console.log(chalk3.yellow("\u672A\u9009\u62E9\u4EFB\u4F55\u4ED3\u5E93"));
+      process.exit(0);
+    }
+    selectedRepos = repos.filter((r) => selected.includes(r.path));
+  }
+  const timeRangeText = timeRange ? `${formatDate2(timeRange.from)} ~ ${formatDate2(timeRange.to)}` : "\u6240\u6709\u63D0\u4EA4";
+  console.log(
+    chalk3.gray(
+      `
+\u5DF2\u9009\u62E9 ${selectedRepos.length} \u4E2A\u4ED3\u5E93\uFF0C\u65F6\u95F4\u8303\u56F4\uFF1A${timeRangeText}
+`
+    )
+  );
+  const stats = await analyzeRepos({
+    repos: selectedRepos,
+    timeRange,
+    author: opts.author
+  });
+  if (stats.totalCommits === 0) {
+    console.log(chalk3.yellow("\u8BE5\u65F6\u95F4\u6BB5\u65E0\u63D0\u4EA4\u8BB0\u5F55"));
+  }
+  await generateReport(stats, {
+    outputPath: opts.output,
+    autoOpen: opts.open,
+    timeRange,
+    repoNames: selectedRepos.map((r) => r.name)
+  });
+}
+async function checkGitInstalled() {
+  const { execSync: execSync3 } = await import("child_process");
+  try {
+    execSync3("git --version", { stdio: "ignore" });
+  } catch {
+    console.error(chalk3.red("\u8BF7\u5148\u5B89\u88C5 Git"));
+    process.exit(1);
+  }
+}
+function formatDate2(date) {
+  return date.toISOString().split("T")[0];
+}
+process.on("SIGINT", () => {
+  console.log(chalk3.yellow("\n\u5DF2\u53D6\u6D88\u64CD\u4F5C"));
+  process.exit(0);
+});
+program.parse();
+//# sourceMappingURL=index.js.map