commit-report 1.0.1 → 1.0.2

package/dist/index.js

@@ -94,31 +94,34 @@ import ora2 from "ora";
 import chalk from "chalk";
 
 // src/analyzer/git-log-parser.ts
-import { execSync as execSync2 } from "child_process";
+import { execFileSync } from "child_process";
 import { readFile } from "fs/promises";
 import { join as join2 } from "path";
 import ig from "ignore";
 var COMMIT_SEPARATOR = "---COMMITX_SEP---";
+var COMMIT_END = "---COMMITX_END---";
 var FIELD_SEPARATOR = "|";
-var FORMAT = `${COMMIT_SEPARATOR}%H${FIELD_SEPARATOR}%an${FIELD_SEPARATOR}%ae${FIELD_SEPARATOR}%aI${FIELD_SEPARATOR}%s`;
+var FORMAT = `${COMMIT_SEPARATOR}%H${FIELD_SEPARATOR}%P${FIELD_SEPARATOR}%an${FIELD_SEPARATOR}%ae${FIELD_SEPARATOR}%aI${FIELD_SEPARATOR}%s%n%B${COMMIT_END}`;
 async function parseGitLog(repoPath, timeRange, author) {
   const ignoreFilter = await loadGitignore(repoPath);
   const args = [
-    "git",
     "log",
-    `--format="${FORMAT}"`,
-    "--numstat"
+    `--format=${FORMAT}`,
+    "--raw",
+    "--numstat",
+    "--find-renames",
+    "--find-copies"
   ];
   if (timeRange) {
-    args.push(`--since="${timeRange.from.toISOString()}"`);
-    args.push(`--until="${timeRange.to.toISOString()}"`);
+    args.push(`--since=${timeRange.from.toISOString()}`);
+    args.push(`--until=${timeRange.to.toISOString()}`);
   }
   if (author) {
-    args.push(`--author="${author}"`);
+    args.push(`--author=${author}`);
   }
   let output;
   try {
-    output = execSync2(args.join(" "), {
+    output = execFileSync("git", args, {
       cwd: repoPath,
       encoding: "utf-8",
       maxBuffer: 100 * 1024 * 1024,
@@ -137,16 +140,23 @@ 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 endIndex = block.indexOf(COMMIT_END);
+    const metadataText = endIndex >= 0 ? block.slice(0, endIndex) : block;
+    const changesText = endIndex >= 0 ? block.slice(endIndex + COMMIT_END.length) : "";
+    const metadataLines = metadataText.trim().split("\n");
+    if (metadataLines.length === 0) continue;
+    const headerLine = metadataLines[0].replace(/^"|"$/g, "");
     const parts = headerLine.split(FIELD_SEPARATOR);
-    if (parts.length < 5) continue;
-    const [hash, authorName, email, dateStr, ...messageParts] = parts;
+    if (parts.length < 6) continue;
+    const [hash, parentHashText, authorName, email, dateStr, ...messageParts] = parts;
     const message = messageParts.join(FIELD_SEPARATOR);
+    const body = metadataLines.slice(1).join("\n").trim();
+    const parentHashes = parentHashText.trim() ? parentHashText.trim().split(/\s+/) : [];
+    const changeLines = changesText.trim().split("\n");
+    const statusByPath = parseFileStatuses(changeLines);
     const files = [];
-    for (let i = 1; i < lines.length; i++) {
-      const line = lines[i].trim();
+    for (const rawLine of changeLines) {
+      const line = rawLine.trim();
       if (!line) continue;
       const tabParts = line.split("	");
       if (tabParts.length !== 3) continue;
@@ -154,7 +164,13 @@ function parseOutput(output, ignoreFilter) {
       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 });
+      const status = statusByPath.get(filePath);
+      files.push({
+        added,
+        deleted,
+        path: filePath,
+        ...status && { status }
+      });
     }
     commits.push({
       hash,
@@ -162,11 +178,38 @@ function parseOutput(output, ignoreFilter) {
       email,
       date: new Date(dateStr),
       message,
+      body,
+      parentHashes,
       files
     });
   }
   return commits;
 }
+function parseFileStatuses(lines) {
+  const statusByPath = /* @__PURE__ */ new Map();
+  for (const line of lines) {
+    if (!line.startsWith(":")) continue;
+    const parts = line.trim().split("	");
+    if (parts.length < 2) continue;
+    const metadata = parts[0].split(/\s+/);
+    const statusToken = metadata[4] || "";
+    const status = normalizeStatus(statusToken);
+    const path = status === "renamed" || status === "copied" ? parts[2] || parts[1] : parts[1];
+    if (path) {
+      statusByPath.set(path, status);
+    }
+  }
+  return statusByPath;
+}
+function normalizeStatus(statusToken) {
+  const type = statusToken[0];
+  if (type === "A") return "added";
+  if (type === "M") return "modified";
+  if (type === "D") return "deleted";
+  if (type === "R") return "renamed";
+  if (type === "C") return "copied";
+  return "unknown";
+}
 async function loadGitignore(repoPath) {
   const ignoreInstance = ig();
   try {
@@ -183,377 +226,524 @@ async function loadGitignore(repoPath) {
 }
 
 // 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 hourlyByAuthor = /* @__PURE__ */ new Map();
-  const dailyCounts = /* @__PURE__ */ new Map();
-  for (const commit of sorted) {
-    const hour = commit.date.getHours();
-    hourlyDistribution[hour]++;
-    if (!hourlyByAuthor.has(hour)) {
-      hourlyByAuthor.set(hour, /* @__PURE__ */ new Map());
-    }
-    const hourAuthors = hourlyByAuthor.get(hour);
-    hourAuthors.set(commit.author, (hourAuthors.get(commit.author) || 0) + 1);
-    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);
+import { extname as extname2 } from "path";
+
+// src/analyzer/tech-debt/ai-detector.ts
+import { readFile as readFile2 } from "fs/promises";
+import { join as join3 } from "path";
+import { existsSync } from "fs";
+function calculateAIScore(commit) {
+  return evaluateAIScore(commit).score;
+}
+function evaluateAIScore(commit) {
+  let score = 0;
+  const reasons = [];
+  const totalLines = commit.files.reduce((sum, f) => sum + f.added, 0);
+  const addedFiles = commit.files.filter((file) => file.status === "added").length;
+  if (mentionsAITool(commit.message) || mentionsAITool(commit.body || "")) {
+    score += 55;
+    reasons.push("AI \u5DE5\u5177\u5173\u952E\u8BCD");
+  }
+  if (mentionsGeneratedOutput(commit.message) || mentionsGeneratedOutput(commit.body || "")) {
+    score += 15;
+    reasons.push("\u751F\u6210\u4EA7\u7269\u5173\u952E\u8BCD");
+  }
+  if (totalLines > 100 && commit.files.length >= 3 && addedFiles / commit.files.length > 0.6) {
+    score += 20;
+    reasons.push("\u5927\u6279\u91CF\u65B0\u589E\u6587\u4EF6");
+  }
+  if (totalLines > 80 && commit.files.reduce((sum, f) => sum + f.deleted, 0) <= totalLines * 0.05) {
+    score += 15;
+    reasons.push("\u4F4E\u5220\u9664\u7387\u5927\u65B0\u589E");
+  }
+  if (totalLines > 1e3 && commit.files.length > 10 && isGenericMessage(commit.message)) {
+    score += 40;
+    reasons.push("\u5927\u578B\u901A\u7528\u63D0\u4EA4");
+  } else if (totalLines > 500) {
+    score += 20;
+    reasons.push("\u5927\u578B\u63D0\u4EA4");
+  }
+  const anomalousFiles = commit.files.filter((f) => hasAnomalousNaming(f.path));
+  if (anomalousFiles.length > 0) {
+    score += Math.min(30, anomalousFiles.length / commit.files.length * 30);
+    reasons.push("\u5F02\u5E38\u547D\u540D");
+  }
+  return { score: Math.min(100, score), reasons };
+}
+async function detectAICode(commits, repoPath) {
+  const suspiciousFiles = [];
+  for (const commit of commits) {
+    const totalLines = commit.files.reduce((sum, f) => sum + f.added, 0);
+    if (totalLines > 1e3 && commit.files.length > 10) {
+      if (isGenericMessage(commit.message)) {
+        suspiciousFiles.push({
+          commit: commit.hash,
+          reason: "large-commit-generic-message",
+          score: 80,
+          description: `\u5927\u578B\u63D0\u4EA4\uFF08${totalLines}\u884C\uFF09\u914D\u5408\u901A\u7528\u63D0\u4EA4\u4FE1\u606F`
+        });
+      }
     }
-    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());
+      if (hasAnomalousNaming(file.path)) {
+        suspiciousFiles.push({
+          file: file.path,
+          reason: "anomalous-naming",
+          score: 60,
+          description: "\u547D\u540D\u6A21\u5F0F\u5F02\u5E38\uFF08\u5982 function1, temp1\uFF09"
+        });
       }
-      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 uniqueFiles = new Set(commits.flatMap((c) => c.files.map((f) => f.path)));
+  const filesToCheck = Array.from(uniqueFiles).slice(0, 50);
+  for (const filePath of filesToCheck) {
+    const fullPath = join3(repoPath, filePath);
+    if (!existsSync(fullPath)) continue;
+    try {
+      const content = await readFile2(fullPath, "utf-8");
+      const commentDensity = calculateCommentDensity(content);
+      if (commentDensity > 0.3) {
+        suspiciousFiles.push({
+          file: filePath,
+          reason: "excessive-comments",
+          score: 70,
+          description: `\u6CE8\u91CA\u5BC6\u5EA6\u8FC7\u9AD8\uFF08${(commentDensity * 100).toFixed(1)}%\uFF09`
+        });
+      }
+    } catch {
     }
   }
-  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());
+  const uniqueSuspicious = Array.from(
+    new Map(suspiciousFiles.map((f) => [f.file || f.commit, f])).values()
+  );
+  return {
+    suspiciousFiles: uniqueSuspicious.sort((a, b) => b.score - a.score).slice(0, 20),
+    totalSuspicious: uniqueSuspicious.length
+  };
+}
+function isGenericMessage(message) {
+  const genericPatterns = [
+    /^fix$/i,
+    /^update$/i,
+    /^refactor$/i,
+    /^fix bug$/i,
+    /^update code$/i,
+    /^bug fix$/i,
+    /^minor fix$/i,
+    /^wip$/i,
+    /^temp$/i,
+    /^test$/i
+  ];
+  const normalized = message.trim().toLowerCase();
+  return genericPatterns.some((pattern) => pattern.test(normalized));
+}
+function mentionsAITool(text) {
+  const aiPatterns = [
+    /\bai\b/i,
+    /\bcopilot\b/i,
+    /\bclaude\b/i,
+    /\bcursor\b/i,
+    /\bchatgpt\b/i,
+    /\bgpt[-\s]?\d*\b/i
+  ];
+  return aiPatterns.some((pattern) => pattern.test(text));
+}
+function mentionsGeneratedOutput(text) {
+  return /\bgenerated\b|\bcodegen\b|\bauto[-\s]?generated\b/i.test(text);
+}
+function hasAnomalousNaming(path) {
+  const anomalousPatterns = [
+    /function\d+/i,
+    /temp\d+/i,
+    /test\d+/i,
+    /file\d+/i,
+    /component\d+/i,
+    /generated/i,
+    /auto[-_]?generated/i,
+    /untitled/i,
+    /copy\d*/i
+  ];
+  return anomalousPatterns.some((pattern) => pattern.test(path));
+}
+function calculateCommentDensity(content) {
+  const lines = content.split("\n");
+  let commentLines = 0;
+  let codeLines = 0;
+  for (const line of lines) {
+    const trimmed = line.trim();
+    if (!trimmed) continue;
+    if (trimmed.startsWith("//") || trimmed.startsWith("/*") || trimmed.startsWith("*") || trimmed.startsWith("#")) {
+      commentLines++;
+    } else {
+      codeLines++;
     }
-    fileCountByExt.get(ext).add(filePath);
   }
-  for (const [ext, files] of fileCountByExt) {
-    const ftStat = fileTypeMap.get(ext);
-    if (ftStat) {
-      ftStat.fileCount = files.size;
-    }
+  const totalLines = commentLines + codeLines;
+  return totalLines > 0 ? commentLines / totalLines : 0;
+}
+
+// src/analyzer/ai-stats-calculator.ts
+function calculateAIMetrics(commits) {
+  if (commits.length === 0) {
+    return {
+      aiMetrics: { totalAILines: 0, totalLines: 0, aiPercentage: 0, suspiciousCommits: 0, highAICommits: [] },
+      authorAIStats: [],
+      directoryAIStats: [],
+      aiTrends: []
+    };
   }
-  let busiestDay = { date: "", count: 0 };
-  for (const [date, count] of dailyCounts) {
-    if (count > busiestDay.count) {
-      busiestDay = { date, count };
+  const aiCommits = [];
+  const authorAIMap = /* @__PURE__ */ new Map();
+  const directoryAIMap = /* @__PURE__ */ new Map();
+  const weeklyAIMap = /* @__PURE__ */ new Map();
+  let totalAILines = 0;
+  let totalLines = 0;
+  let suspiciousCommits = 0;
+  for (const commit of commits) {
+    const aiEvaluation = evaluateAIScore(commit);
+    const aiScore = aiEvaluation.score;
+    const commitLines = commit.files.reduce((sum, f) => sum + f.added, 0);
+    const estimatedAILines = Math.round(commitLines * aiScore / 100);
+    totalLines += commitLines;
+    totalAILines += estimatedAILines;
+    if (aiScore > 50) {
+      suspiciousCommits++;
+      aiCommits.push({
+        hash: commit.hash,
+        author: commit.author,
+        date: commit.date,
+        aiScore,
+        estimatedAILines,
+        linesAdded: commitLines,
+        filesCount: commit.files.length,
+        message: commit.message,
+        reasons: aiEvaluation.reasons
+      });
     }
-  }
-  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);
-  const hourlyByAuthorArray = Array.from({ length: 24 }, (_, hour) => {
-    const authorMap2 = hourlyByAuthor.get(hour);
-    const authors2 = {};
-    if (authorMap2) {
-      authorMap2.forEach((count, author) => {
-        authors2[author] = count;
+    const authorKey = commit.email.toLowerCase();
+    const authorData = authorAIMap.get(authorKey) || { aiLines: 0, totalLines: 0 };
+    authorData.aiLines += estimatedAILines;
+    authorData.totalLines += commitLines;
+    authorAIMap.set(authorKey, authorData);
+    for (const file of commit.files) {
+      const dir = getTopDirectory(file.path);
+      const fileAILines = Math.round(file.added * aiScore / 100);
+      const dirData = directoryAIMap.get(dir) || {
+        aiLines: 0,
+        totalLines: 0,
+        commits: /* @__PURE__ */ new Set(),
+        lastModified: commit.date
+      };
+      dirData.aiLines += fileAILines;
+      dirData.totalLines += file.added;
+      dirData.commits.add(commit.hash);
+      if (commit.date > dirData.lastModified) {
+        dirData.lastModified = commit.date;
+      }
+      directoryAIMap.set(dir, dirData);
+    }
+    const week = getWeekKey(commit.date);
+    const weekData = weeklyAIMap.get(week) || { aiLines: 0, totalLines: 0 };
+    weekData.aiLines += estimatedAILines;
+    weekData.totalLines += commitLines;
+    weeklyAIMap.set(week, weekData);
+  }
+  const aiMetrics = {
+    totalAILines,
+    totalLines,
+    aiPercentage: totalLines > 0 ? totalAILines / totalLines * 100 : 0,
+    suspiciousCommits,
+    highAICommits: aiCommits.sort((a, b) => b.aiScore - a.aiScore).slice(0, 20)
+  };
+  const authorAIStats = [];
+  const authorMap = /* @__PURE__ */ new Map();
+  for (const commit of commits) {
+    authorMap.set(commit.email.toLowerCase(), { name: commit.author, email: commit.email });
+  }
+  for (const [authorKey, data] of authorAIMap) {
+    const author = authorMap.get(authorKey);
+    if (author) {
+      authorAIStats.push({
+        author: author.name,
+        email: author.email,
+        aiLines: data.aiLines,
+        totalLines: data.totalLines,
+        aiPercentage: data.totalLines > 0 ? data.aiLines / data.totalLines * 100 : 0
       });
     }
+  }
+  const directoryAIStats = [];
+  for (const [path, data] of directoryAIMap) {
+    const aiPercentage = data.totalLines > 0 ? data.aiLines / data.totalLines * 100 : 0;
+    const isHighRisk = data.commits.size > 50 && aiPercentage > 60;
+    directoryAIStats.push({
+      path,
+      displayPath: path,
+      commits: data.commits.size,
+      aiLines: data.aiLines,
+      totalLines: data.totalLines,
+      aiPercentage,
+      lastModified: data.lastModified,
+      isHighRisk
+    });
+  }
+  const aiTrends = Array.from(weeklyAIMap.entries()).map(([week, data]) => ({
+    week,
+    aiLines: data.aiLines,
+    totalLines: data.totalLines,
+    aiPercentage: data.totalLines > 0 ? data.aiLines / data.totalLines * 100 : 0
+  })).sort((a, b) => a.week.localeCompare(b.week));
+  return {
+    aiMetrics,
+    authorAIStats: authorAIStats.sort((a, b) => b.aiPercentage - a.aiPercentage),
+    directoryAIStats: directoryAIStats.sort((a, b) => b.aiPercentage - a.aiPercentage),
+    aiTrends
+  };
+}
+function getTopDirectory(filePath) {
+  const parts = filePath.split("/");
+  return parts.length > 1 ? parts[0] : "(\u6839\u76EE\u5F55)";
+}
+function getWeekKey(date) {
+  const year = date.getFullYear();
+  const startOfYear = new Date(year, 0, 1);
+  const days = Math.floor((date.getTime() - startOfYear.getTime()) / (24 * 60 * 60 * 1e3));
+  const week = Math.ceil((days + startOfYear.getDay() + 1) / 7);
+  return `${year}-W${week.toString().padStart(2, "0")}`;
+}
+
+// src/analyzer/stats-utils.ts
+function getTopDirectory2(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}`;
+}
+
+// src/analyzer/extended-stats.ts
+var MAX_FILES_PER_COMMIT_FOR_PAIRS = 80;
+var MAX_DIRS_FOR_MATRIX = 12;
+function calculateChangeSizeDistribution(commits) {
+  if (commits.length === 0) {
     return {
-      count: hourlyDistribution[hour],
-      authors: authors2
+      buckets: emptyBuckets(),
+      avgChangeSize: 0,
+      medianChangeSize: 0,
+      p95ChangeSize: 0,
+      largeCommits: []
     };
-  });
+  }
+  const sizes = [];
+  const commitInfo = [];
+  for (const commit of commits) {
+    let total2 = 0;
+    for (const f of commit.files) total2 += f.added + f.deleted;
+    sizes.push(total2);
+    commitInfo.push({
+      hash: commit.hash,
+      author: commit.author,
+      date: commit.date,
+      message: commit.message,
+      totalLines: total2,
+      filesCount: commit.files.length
+    });
+  }
+  const counts = { XS: 0, S: 0, M: 0, L: 0, XL: 0 };
+  for (const size of sizes) {
+    if (size < 10) counts.XS++;
+    else if (size < 50) counts.S++;
+    else if (size < 200) counts.M++;
+    else if (size < 1e3) counts.L++;
+    else counts.XL++;
+  }
+  const total = sizes.length;
+  const buckets = [
+    { label: "XS", range: "<10", count: counts.XS, percentage: pct(counts.XS, total) },
+    { label: "S", range: "10-49", count: counts.S, percentage: pct(counts.S, total) },
+    { label: "M", range: "50-199", count: counts.M, percentage: pct(counts.M, total) },
+    { label: "L", range: "200-999", count: counts.L, percentage: pct(counts.L, total) },
+    { label: "XL", range: "\u22651000", count: counts.XL, percentage: pct(counts.XL, total) }
+  ];
+  const sorted = [...sizes].sort((a, b) => a - b);
+  const avgChangeSize = sizes.reduce((a, b) => a + b, 0) / sizes.length;
+  const medianChangeSize = sorted[Math.floor(sorted.length / 2)] ?? 0;
+  const p95ChangeSize = sorted[Math.floor(sorted.length * 0.95)] ?? 0;
+  const largeCommits = commitInfo.sort((a, b) => b.totalLines - a.totalLines).slice(0, 20);
   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,
-    hourlyByAuthor: hourlyByAuthorArray,
-    quality: calculateQualityMetrics(sorted),
-    timePatterns: calculateTimePatterns(sorted),
-    trends: calculateTrends(sorted),
-    collaboration: calculateCollaboration(sorted),
-    messageStats: calculateMessageStats(sorted),
-    authorFileTypeContributions: calculateAuthorFileTypeContributions(sorted)
+    buckets,
+    avgChangeSize,
+    medianChangeSize,
+    p95ChangeSize,
+    largeCommits
   };
 }
-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;
+function calculateDirectoryCoupling(commits) {
+  if (commits.length === 0) {
+    return { pairs: [], matrix: [], directories: [] };
+  }
+  const dirCommitCount = /* @__PURE__ */ new Map();
+  const pairMap = /* @__PURE__ */ new Map();
+  for (const commit of commits) {
+    const files = commit.files.slice(0, MAX_FILES_PER_COMMIT_FOR_PAIRS);
+    const dirs = /* @__PURE__ */ new Set();
+    for (const f of files) dirs.add(getTopDirectory2(f.path));
+    const dirArr = Array.from(dirs).sort();
+    for (const d of dirArr) {
+      dirCommitCount.set(d, (dirCommitCount.get(d) || 0) + 1);
     }
-    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 (let i = 0; i < dirArr.length; i++) {
+      for (let j = i + 1; j < dirArr.length; j++) {
+        const key = `${dirArr[i]}|||${dirArr[j]}`;
+        const existing = pairMap.get(key) || { dir1: dirArr[i], dir2: dirArr[j], count: 0 };
+        existing.count++;
+        pairMap.set(key, existing);
       }
     }
-    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;
+  }
+  const pairs = Array.from(pairMap.values()).map(({ dir1, dir2, count }) => {
+    const c1 = dirCommitCount.get(dir1) || 1;
+    const c2 = dirCommitCount.get(dir2) || 1;
+    const coupling = count / Math.min(c1, c2);
+    return { dir1, dir2, coOccurrence: count, coupling };
+  }).filter((p) => p.coOccurrence >= 2).sort((a, b) => b.coupling - a.coupling).slice(0, 30);
+  const topDirs = Array.from(dirCommitCount.entries()).sort((a, b) => b[1] - a[1]).slice(0, MAX_DIRS_FOR_MATRIX).map(([d]) => d);
+  const matrix = [];
+  for (const d1 of topDirs) {
+    for (const d2 of topDirs) {
+      if (d1 === d2) {
+        matrix.push({ dir1: d1, dir2: d2, value: dirCommitCount.get(d1) || 0 });
       } else {
-        merged.fileTypes.push({ ...ft });
+        const key = d1 < d2 ? `${d1}|||${d2}` : `${d2}|||${d1}`;
+        matrix.push({ dir1: d1, dir2: d2, value: pairMap.get(key)?.count || 0 });
       }
     }
-    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 });
-      }
+  }
+  return {
+    pairs,
+    matrix,
+    directories: topDirs
+  };
+}
+function calculateAIQualityRisk(commits) {
+  if (commits.length === 0) {
+    return {
+      files: [],
+      scatter: [],
+      summary: { highAIHighChurn: 0, highAILowChurn: 0, lowAIHighChurn: 0, lowAILowChurn: 0 }
+    };
+  }
+  const fileMap = /* @__PURE__ */ new Map();
+  for (const commit of commits) {
+    const aiScore = calculateAIScore(commit);
+    for (const file of commit.files) {
+      const lines = file.added + file.deleted;
+      const entry = fileMap.get(file.path) || {
+        added: 0,
+        deleted: 0,
+        modifyCount: 0,
+        weightedAI: 0,
+        weight: 0
+      };
+      entry.added += file.added;
+      entry.deleted += file.deleted;
+      entry.modifyCount++;
+      const w = Math.max(lines, 1);
+      entry.weightedAI += aiScore * w;
+      entry.weight += w;
+      fileMap.set(file.path, entry);
     }
-    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() {
+  const files = [];
+  const scatter = [];
+  let highAIHighChurn = 0, highAILowChurn = 0, lowAIHighChurn = 0, lowAILowChurn = 0;
+  for (const [path, data] of fileMap) {
+    const avgAI = data.weight > 0 ? data.weightedAI / data.weight : 0;
+    const churnRate = data.added > 0 ? data.deleted / data.added : 0;
+    const totalLines = data.added + data.deleted;
+    if (data.modifyCount < 2 && totalLines < 50) continue;
+    const riskScore = avgAI / 100 * Math.min(churnRate, 2) * Math.log2(data.modifyCount + 1) * 50;
+    files.push({
+      path,
+      aiScore: avgAI,
+      churnRate,
+      modifyCount: data.modifyCount,
+      totalLines,
+      riskScore
+    });
+    scatter.push({ path, aiScore: avgAI, churnRate, modifyCount: data.modifyCount });
+    const highAI = avgAI > 50;
+    const highChurn = churnRate > 0.5;
+    if (highAI && highChurn) highAIHighChurn++;
+    else if (highAI) highAILowChurn++;
+    else if (highChurn) lowAIHighChurn++;
+    else lowAILowChurn++;
+  }
+  files.sort((a, b) => b.riskScore - a.riskScore);
   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: []
+    files: files.slice(0, 20),
+    scatter: scatter.slice(0, 500),
+    // 限制散点数
+    summary: { highAIHighChurn, highAILowChurn, lowAIHighChurn, lowAILowChurn }
   };
 }
-function getTopDirectory(filePath) {
-  const parts = filePath.split("/");
-  return parts.length > 1 ? parts[0] : "(\u6839\u76EE\u5F55)";
+function emptyBuckets() {
+  return [
+    { label: "XS", range: "<10", count: 0, percentage: 0 },
+    { label: "S", range: "10-49", count: 0, percentage: 0 },
+    { label: "M", range: "50-199", count: 0, percentage: 0 },
+    { label: "L", range: "200-999", count: 0, percentage: 0 },
+    { label: "XL", range: "\u22651000", count: 0, percentage: 0 }
+  ];
 }
-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 pct(part, total) {
+  return total > 0 ? part / total * 100 : 0;
+}
+
+// src/analyzer/stats-metrics.ts
+import { extname } from "path";
+function calculateCommitDetails(commits) {
+  return commits.map((commit) => {
+    let linesAdded = 0;
+    let linesDeleted = 0;
+    for (const file of commit.files) {
+      linesAdded += file.added;
+      linesDeleted += file.deleted;
+    }
+    return {
+      hash: commit.hash,
+      author: commit.author,
+      email: commit.email,
+      repoName: "",
+      date: commit.date,
+      message: commit.message,
+      linesAdded,
+      linesDeleted,
+      files: commit.files.map((file) => ({ ...file }))
+    };
+  });
 }
 function calculateQualityMetrics(commits) {
   if (commits.length === 0) {
     return emptyQualityMetrics();
   }
-  const totalFiles = commits.reduce((sum, c) => sum + c.files.length, 0);
+  const totalFiles = commits.reduce((sum, commit) => sum + commit.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),
+    (sum, commit) => sum + commit.files.reduce((s, file) => s + file.added + file.deleted, 0),
     0
   );
   const avgLinesPerCommit = totalLines / commits.length;
   const totalAdded = commits.reduce(
-    (sum, c) => sum + c.files.reduce((s, f) => s + f.added, 0),
+    (sum, commit) => sum + commit.files.reduce((s, file) => s + file.added, 0),
     0
   );
   const totalDeleted = commits.reduce(
-    (sum, c) => sum + c.files.reduce((s, f) => s + f.deleted, 0),
+    (sum, commit) => sum + commit.files.reduce((s, file) => s + file.deleted, 0),
     0
   );
   const churnRate = totalAdded > 0 ? totalDeleted / totalAdded : 0;
@@ -621,77 +811,13 @@ function calculateTimePatterns(commits) {
     weekdayByAuthor: weekdayByAuthorArray
   };
 }
-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 week = getWeekKey2(commit.date);
     const entry = weekMap.get(week) || {
       week,
       commits: 0,
@@ -711,7 +837,7 @@ function calculateTrends(commits) {
   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);
+    const net = commit.files.reduce((sum, file) => sum + file.added - file.deleted, 0);
     dailyNet.set(dateKey, (dailyNet.get(dateKey) || 0) + net);
   }
   let cumulative = 0;
@@ -817,53 +943,545 @@ function calculateAuthorFileTypeContributions(commits) {
       if (!commitCountMap.has(key)) {
         commitCountMap.set(key, /* @__PURE__ */ new Set());
       }
-      commitCountMap.get(key).add(commit.hash);
+      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
+  };
+}
+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 getWeekKey2(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")}`;
+}
+
+// src/analyzer/stats-empty.ts
+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: [],
+    commitDetails: []
+  };
+}
+
+// src/analyzer/stats-calculator.ts
+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 hourlyByAuthor = /* @__PURE__ */ new Map();
+  const dailyCounts = /* @__PURE__ */ new Map();
+  for (const commit of sorted) {
+    const hour = commit.date.getHours();
+    hourlyDistribution[hour]++;
+    if (!hourlyByAuthor.has(hour)) {
+      hourlyByAuthor.set(hour, /* @__PURE__ */ new Map());
+    }
+    const hourAuthors = hourlyByAuthor.get(hour);
+    hourAuthors.set(commit.author, (hourAuthors.get(commit.author) || 0) + 1);
+    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 = extname2(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 = getTopDirectory2(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 = extname2(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);
+  const hourlyByAuthorArray = Array.from({ length: 24 }, (_, hour) => {
+    const authorMap2 = hourlyByAuthor.get(hour);
+    const authors2 = {};
+    if (authorMap2) {
+      authorMap2.forEach((count, author) => {
+        authors2[author] = count;
+      });
+    }
+    return {
+      count: hourlyDistribution[hour],
+      authors: authors2
+    };
+  });
+  const aiStats = calculateAIMetrics(sorted);
+  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,
+    hourlyByAuthor: hourlyByAuthorArray,
+    quality: calculateQualityMetrics(sorted),
+    timePatterns: calculateTimePatterns(sorted),
+    trends: calculateTrends(sorted),
+    collaboration: calculateCollaboration(sorted),
+    messageStats: calculateMessageStats(sorted),
+    authorFileTypeContributions: calculateAuthorFileTypeContributions(sorted),
+    commitDetails: calculateCommitDetails(sorted),
+    aiMetrics: aiStats.aiMetrics,
+    authorAIStats: aiStats.authorAIStats,
+    directoryAIStats: aiStats.directoryAIStats,
+    aiTrends: aiStats.aiTrends,
+    changeSizeDistribution: calculateChangeSizeDistribution(sorted),
+    directoryCoupling: calculateDirectoryCoupling(sorted),
+    aiQualityRisk: calculateAIQualityRisk(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;
+    merged.commitDetails.push(...stats.commitDetails);
+  }
+  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;
+  merged.commitDetails.sort((a, b) => a.date.getTime() - b.date.getTime());
+  mergeAIStats(merged, statsList);
+  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 });
+      }
     }
   }
-  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) => {
+  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 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 mergeAIStats(merged, statsList) {
+  const aiStatsList = statsList.filter((stats) => stats.aiMetrics);
+  if (aiStatsList.length === 0) return;
+  const highAICommits = [];
+  const authorMap = /* @__PURE__ */ new Map();
+  const directoryMap = /* @__PURE__ */ new Map();
+  const trendMap = /* @__PURE__ */ new Map();
+  let totalAILines = 0;
+  let totalLines = 0;
+  let suspiciousCommits = 0;
+  for (const stats of aiStatsList) {
+    const metrics = stats.aiMetrics;
+    totalAILines += metrics.totalAILines;
+    totalLines += metrics.totalLines;
+    suspiciousCommits += metrics.suspiciousCommits;
+    highAICommits.push(...metrics.highAICommits);
+    for (const author of stats.authorAIStats || []) {
+      const key = author.email.toLowerCase();
+      const existing = authorMap.get(key);
+      if (existing) {
+        existing.aiLines += author.aiLines;
+        existing.totalLines += author.totalLines;
+        existing.aiPercentage = calculatePercentage(existing.aiLines, existing.totalLines);
+      } else {
+        authorMap.set(key, { ...author });
+      }
+    }
+    for (const directory of stats.directoryAIStats || []) {
+      const key = directory.repoName ? `${directory.repoName}|||${directory.path}` : directory.path;
+      const displayPath = directory.repoName ? `${directory.repoName} / ${directory.path}` : directory.displayPath || directory.path;
+      const existing = directoryMap.get(key);
+      if (existing) {
+        existing.commits += directory.commits;
+        existing.aiLines += directory.aiLines;
+        existing.totalLines += directory.totalLines;
+        existing.aiPercentage = calculatePercentage(existing.aiLines, existing.totalLines);
+        existing.displayPath = displayPath;
+        existing.lastModified = new Date(directory.lastModified) > new Date(existing.lastModified) ? directory.lastModified : existing.lastModified;
+        existing.isHighRisk = existing.commits > 50 && existing.aiPercentage > 60;
+      } else {
+        directoryMap.set(key, { ...directory, displayPath });
+      }
+    }
+    for (const trend of stats.aiTrends || []) {
+      const existing = trendMap.get(trend.week);
+      if (existing) {
+        existing.aiLines += trend.aiLines;
+        existing.totalLines += trend.totalLines;
+        existing.aiPercentage = calculatePercentage(existing.aiLines, existing.totalLines);
+      } else {
+        trendMap.set(trend.week, { ...trend });
+      }
+    }
+  }
+  merged.aiMetrics = {
+    totalAILines,
+    totalLines,
+    aiPercentage: calculatePercentage(totalAILines, totalLines),
+    suspiciousCommits,
+    highAICommits: highAICommits.sort((a, b) => b.aiScore - a.aiScore).slice(0, 20)
   };
+  merged.authorAIStats = Array.from(authorMap.values()).sort((a, b) => b.aiPercentage - a.aiPercentage);
+  merged.directoryAIStats = Array.from(directoryMap.values()).sort((a, b) => b.aiPercentage - a.aiPercentage);
+  merged.aiTrends = Array.from(trendMap.values()).sort((a, b) => a.week.localeCompare(b.week));
 }
-function emptyMessageStats() {
-  return {
-    typeDistribution: {},
-    avgMessageLength: 0
-  };
+function calculatePercentage(part, total) {
+  return total > 0 ? part / total * 100 : 0;
 }
 
 // src/analyzer/advanced/team-health.ts
@@ -992,7 +1610,7 @@ function calculateStability(commits) {
   const dirStats = /* @__PURE__ */ new Map();
   for (const commit of commits) {
     for (const file of commit.files) {
-      const dir = getTopDirectory2(file.path);
+      const dir = getTopDirectory3(file.path);
       const stat2 = dirStats.get(dir) || { added: 0, deleted: 0, files: /* @__PURE__ */ new Set() };
       stat2.added += file.added;
       stat2.deleted += file.deleted;
@@ -1023,7 +1641,7 @@ function calculateStability(commits) {
     stabilityScore
   };
 }
-function getTopDirectory2(filePath) {
+function getTopDirectory3(filePath) {
   const parts = filePath.split("/");
   return parts.length > 1 ? parts[0] : "(\u6839\u76EE\u5F55)";
 }
@@ -1350,6 +1968,658 @@ function calculateAdvancedStats(commits) {
   };
 }
 
+// src/analyzer/tech-debt/risk-scorer.ts
+function calculateRiskScores(commits) {
+  if (commits.length === 0) return [];
+  const fileMap = /* @__PURE__ */ new Map();
+  for (const commit of commits) {
+    for (const file of commit.files) {
+      if (!fileMap.has(file.path)) {
+        fileMap.set(file.path, {
+          path: file.path,
+          commits: [],
+          authors: /* @__PURE__ */ new Set(),
+          totalAdded: 0,
+          totalDeleted: 0,
+          lastModified: commit.date
+        });
+      }
+      const data = fileMap.get(file.path);
+      data.commits.push(commit);
+      data.authors.add(commit.author);
+      data.totalAdded += file.added;
+      data.totalDeleted += file.deleted;
+      if (commit.date > data.lastModified) {
+        data.lastModified = commit.date;
+      }
+    }
+  }
+  const riskFiles = [];
+  for (const [path, data] of fileMap) {
+    const complexity = calculateComplexity(data);
+    const churnRate = calculateChurnRate(data, commits.length);
+    const testCoverage = estimateTestCoverage(path, fileMap);
+    const knowledgeRisk = calculateKnowledgeRisk(data);
+    const riskScore = complexity * 0.3 + churnRate * 100 * 0.25 + (100 - testCoverage) * 0.2 + knowledgeRisk * 0.15 + (data.totalAdded > 500 ? 10 : 0);
+    riskFiles.push({
+      path,
+      riskScore: Math.min(riskScore, 100),
+      complexity,
+      churnRate,
+      testCoverage,
+      knowledgeRisk,
+      primaryAuthor: getMostActiveAuthor(data),
+      lastModified: data.lastModified
+    });
+  }
+  return riskFiles.sort((a, b) => b.riskScore - a.riskScore);
+}
+function calculateComplexity(data) {
+  const linesOfCode = data.totalAdded;
+  if (linesOfCode > 1e3) return 90;
+  if (linesOfCode > 500) return 70;
+  if (linesOfCode > 300) return 50;
+  if (linesOfCode > 100) return 30;
+  return 10;
+}
+function calculateChurnRate(data, totalCommits) {
+  return data.commits.length / totalCommits;
+}
+function estimateTestCoverage(path, fileMap) {
+  const testPatterns = [".test.", ".spec.", "__tests__", "/test/", "/tests/"];
+  const isTestFile = testPatterns.some((pattern) => path.includes(pattern));
+  if (isTestFile) return 100;
+  const baseName = path.replace(/\.(ts|js|tsx|jsx)$/, "");
+  const possibleTestFiles = [
+    `${baseName}.test.ts`,
+    `${baseName}.test.js`,
+    `${baseName}.spec.ts`,
+    `${baseName}.spec.js`
+  ];
+  for (const testFile of possibleTestFiles) {
+    if (fileMap.has(testFile)) {
+      return 80;
+    }
+  }
+  const dir = path.split("/").slice(0, -1).join("/");
+  for (const [filePath] of fileMap) {
+    if (filePath.startsWith(dir) && testPatterns.some((p) => filePath.includes(p))) {
+      return 40;
+    }
+  }
+  return 0;
+}
+function calculateKnowledgeRisk(data) {
+  const authorCount = data.authors.size;
+  if (authorCount === 1) return 100;
+  if (authorCount === 2) return 60;
+  if (authorCount === 3) return 30;
+  return 10;
+}
+function getMostActiveAuthor(data) {
+  const authorCommits = /* @__PURE__ */ new Map();
+  for (const commit of data.commits) {
+    authorCommits.set(commit.author, (authorCommits.get(commit.author) || 0) + 1);
+  }
+  let maxAuthor = "";
+  let maxCommits = 0;
+  for (const [author, count] of authorCommits) {
+    if (count > maxCommits) {
+      maxCommits = count;
+      maxAuthor = author;
+    }
+  }
+  return maxAuthor;
+}
+
+// src/analyzer/tech-debt/duplication.ts
+import { readFile as readFile3 } from "fs/promises";
+import { join as join4 } from "path";
+import { readdirSync, statSync } from "fs";
+import { createHash } from "crypto";
+async function detectDuplication(repoPath) {
+  const codeFiles = findCodeFiles(repoPath);
+  const fileHashes = /* @__PURE__ */ new Map();
+  const fileSizes = /* @__PURE__ */ new Map();
+  for (const file of codeFiles.slice(0, 100)) {
+    try {
+      const content = await readFile3(file, "utf-8");
+      const normalized = normalizeCode(content);
+      const hash = simpleHash(normalized);
+      if (!fileHashes.has(hash)) {
+        fileHashes.set(hash, []);
+      }
+      fileHashes.get(hash).push(file.replace(repoPath, "").replace(/^[/\\]/, ""));
+      fileSizes.set(file, content.split("\n").length);
+    } catch {
+    }
+  }
+  const clusters = [];
+  for (const [hash, files] of fileHashes) {
+    if (files.length > 1) {
+      const lines = fileSizes.get(join4(repoPath, files[0])) || 0;
+      clusters.push({
+        files,
+        similarity: 100,
+        lines
+      });
+    }
+  }
+  const fileScores = /* @__PURE__ */ new Map();
+  for (const cluster of clusters) {
+    for (const file of cluster.files) {
+      fileScores.set(file, (fileScores.get(file) || 0) + cluster.lines);
+    }
+  }
+  const sortedScores = Array.from(fileScores.entries()).map(([file, score]) => ({ file, score })).sort((a, b) => b.score - a.score);
+  return {
+    clusters: clusters.sort((a, b) => b.lines - a.lines).slice(0, 10),
+    fileScores: sortedScores.slice(0, 20)
+  };
+}
+function findCodeFiles(dir, maxDepth = 3, currentDepth = 0) {
+  if (currentDepth > maxDepth) return [];
+  const files = [];
+  const ignorePatterns = ["node_modules", ".git", "dist", "build", "coverage", ".next"];
+  try {
+    const entries = readdirSync(dir);
+    for (const entry of entries) {
+      if (ignorePatterns.includes(entry)) continue;
+      const fullPath = join4(dir, entry);
+      try {
+        const stat2 = statSync(fullPath);
+        if (stat2.isDirectory()) {
+          files.push(...findCodeFiles(fullPath, maxDepth, currentDepth + 1));
+        } else if (stat2.isFile() && isCodeFile(entry)) {
+          files.push(fullPath);
+        }
+      } catch {
+      }
+    }
+  } catch {
+  }
+  return files;
+}
+function isCodeFile(filename) {
+  const codeExtensions = [".ts", ".js", ".tsx", ".jsx", ".py", ".java", ".go", ".rs", ".cpp", ".c"];
+  return codeExtensions.some((ext) => filename.endsWith(ext));
+}
+function normalizeCode(content) {
+  return content.replace(/\/\/.*$/gm, "").replace(/\/\*[\s\S]*?\*\//g, "").replace(/\s+/g, " ").trim();
+}
+function simpleHash(content) {
+  return createHash("md5").update(content).digest("hex");
+}
+
+// src/analyzer/tech-debt/prioritizer.ts
+function prioritizeActions(riskFiles) {
+  const actionItems = riskFiles.map((file) => {
+    const impact = calculateImpact(file);
+    const effort = estimateEffort(file);
+    const priority = file.riskScore * impact / Math.max(effort, 1);
+    return {
+      file: file.path,
+      riskLevel: getRiskLevel(file.riskScore),
+      impact,
+      effort,
+      priority,
+      suggestedAction: generateSuggestion(file),
+      owner: file.primaryAuthor
+    };
+  });
+  return actionItems.sort((a, b) => b.priority - a.priority).slice(0, 10);
+}
+function calculateImpact(file) {
+  let impact = 50;
+  if (file.churnRate > 0.5) impact += 20;
+  if (file.knowledgeRisk > 70) impact += 15;
+  if (file.testCoverage < 30) impact += 15;
+  return Math.min(impact, 100);
+}
+function estimateEffort(file) {
+  let effort = 1;
+  if (file.complexity > 70) effort += 2;
+  if (file.complexity > 50) effort += 1;
+  if (file.knowledgeRisk > 70) effort += 1;
+  return effort;
+}
+function getRiskLevel(score) {
+  if (score >= 80) return "critical";
+  if (score >= 60) return "high";
+  if (score >= 40) return "medium";
+  return "low";
+}
+function generateSuggestion(file) {
+  const suggestions = [];
+  if (file.complexity > 70) {
+    suggestions.push("\u62C6\u5206\u4E3A\u591A\u4E2A\u5C0F\u6587\u4EF6");
+  }
+  if (file.testCoverage < 30) {
+    suggestions.push("\u589E\u52A0\u5355\u5143\u6D4B\u8BD5\u8986\u76D6");
+  }
+  if (file.knowledgeRisk > 70) {
+    suggestions.push("\u8FDB\u884C\u77E5\u8BC6\u5206\u4EAB\u548C\u4EE3\u7801\u5BA1\u67E5");
+  }
+  if (file.churnRate > 0.5) {
+    suggestions.push("\u91CD\u6784\u4EE5\u63D0\u9AD8\u7A33\u5B9A\u6027");
+  }
+  if (suggestions.length === 0) {
+    suggestions.push("\u4EE3\u7801\u5BA1\u67E5\u548C\u6587\u6863\u5B8C\u5584");
+  }
+  return suggestions.join("\uFF1B");
+}
+
+// src/analyzer/tech-debt/index.ts
+async function calculateTechDebt(commits, repoPath) {
+  if (commits.length === 0) {
+    return emptyTechDebt();
+  }
+  const riskFiles = calculateRiskScores(commits);
+  const aiDetection = await detectAICode(commits, repoPath);
+  const duplication = await detectDuplication(repoPath);
+  const actionItems = prioritizeActions(riskFiles);
+  const radar = calculateRadarDimensions(riskFiles, aiDetection, duplication);
+  const trends = calculateTrends2(commits);
+  return {
+    radar,
+    highRiskFiles: riskFiles.slice(0, 10),
+    aiDetection,
+    duplication,
+    trends,
+    actionItems
+  };
+}
+function calculateRadarDimensions(riskFiles, aiDetection, duplication) {
+  const avgComplexity = riskFiles.length > 0 ? riskFiles.reduce((sum, f) => sum + f.complexity, 0) / riskFiles.length : 0;
+  const avgDuplication = duplication.fileScores.length > 0 ? duplication.fileScores.reduce((sum, file) => sum + file.score, 0) / duplication.fileScores.length : 0;
+  const avgTestCoverage = riskFiles.length > 0 ? riskFiles.reduce((sum, f) => sum + f.testCoverage, 0) / riskFiles.length : 100;
+  const avgKnowledgeRisk = riskFiles.length > 0 ? riskFiles.reduce((sum, f) => sum + f.knowledgeRisk, 0) / riskFiles.length : 0;
+  const avgChurnRate = riskFiles.length > 0 ? riskFiles.reduce((sum, f) => sum + f.churnRate, 0) / riskFiles.length : 0;
+  return [
+    {
+      dimension: "Complexity",
+      score: Math.min(avgComplexity, 100),
+      riskLevel: avgComplexity > 70 ? "high" : avgComplexity > 40 ? "medium" : "low",
+      description: "\u4EE3\u7801\u590D\u6742\u5EA6",
+      affectedFiles: riskFiles.filter((f) => f.complexity > 70).length
+    },
+    {
+      dimension: "Duplication",
+      score: Math.min(avgDuplication / 10, 100),
+      riskLevel: avgDuplication > 700 ? "high" : avgDuplication > 400 ? "medium" : "low",
+      description: "\u4EE3\u7801\u91CD\u590D\u5EA6",
+      affectedFiles: duplication.fileScores.filter((file) => file.score > 100).length
+    },
+    {
+      dimension: "Test Coverage",
+      score: 100 - avgTestCoverage,
+      riskLevel: avgTestCoverage < 30 ? "high" : avgTestCoverage < 60 ? "medium" : "low",
+      description: "\u6D4B\u8BD5\u8986\u76D6\u7387",
+      affectedFiles: riskFiles.filter((f) => f.testCoverage < 30).length
+    },
+    {
+      dimension: "Documentation",
+      score: aiDetection.suspiciousFiles.filter((file) => file.reason === "excessive-comments").length * 10,
+      riskLevel: aiDetection.suspiciousFiles.length > 10 ? "high" : aiDetection.suspiciousFiles.length > 5 ? "medium" : "low",
+      description: "\u6587\u6863\u5B8C\u6574\u6027",
+      affectedFiles: aiDetection.suspiciousFiles.length
+    },
+    {
+      dimension: "Stability",
+      score: avgChurnRate * 100,
+      riskLevel: avgChurnRate > 0.7 ? "high" : avgChurnRate > 0.4 ? "medium" : "low",
+      description: "\u4EE3\u7801\u7A33\u5B9A\u6027",
+      affectedFiles: riskFiles.filter((f) => f.churnRate > 0.7).length
+    },
+    {
+      dimension: "Knowledge Risk",
+      score: avgKnowledgeRisk,
+      riskLevel: avgKnowledgeRisk > 70 ? "high" : avgKnowledgeRisk > 40 ? "medium" : "low",
+      description: "\u77E5\u8BC6\u96C6\u4E2D\u5EA6",
+      affectedFiles: riskFiles.filter((f) => f.knowledgeRisk > 70).length
+    }
+  ];
+}
+function calculateTrends2(commits) {
+  const sorted = [...commits].sort((a, b) => a.date.getTime() - b.date.getTime());
+  const trends = [];
+  const interval = Math.max(1, Math.floor(sorted.length / 20));
+  for (let i = 0; i < sorted.length; i += interval) {
+    const chunk = sorted.slice(Math.max(0, i - interval), i + 1);
+    const debt = chunk.reduce((sum, c) => {
+      const largeFiles = c.files.filter((f) => f.added > 100).length;
+      return sum + largeFiles;
+    }, 0);
+    trends.push({
+      date: sorted[i].date.toISOString().split("T")[0],
+      debt
+    });
+  }
+  return trends;
+}
+function emptyTechDebt() {
+  return {
+    radar: [],
+    highRiskFiles: [],
+    aiDetection: { suspiciousFiles: [], totalSuspicious: 0 },
+    duplication: { clusters: [], fileScores: [] },
+    trends: [],
+    actionItems: []
+  };
+}
+
+// src/analyzer/engineering-metrics.ts
+import { execFileSync as execFileSync2 } from "child_process";
+var CONVENTIONAL_RE = /^(feat|fix|docs|style|refactor|test|chore|perf|ci|build|revert)(\([^)]+\))?!?:\s+\S/i;
+var SCOPED_CONVENTIONAL_RE = /^(feat|fix|docs|style|refactor|test|chore|perf|ci|build|revert)\([^)]+\)!?:\s+\S/i;
+var FIX_RE = /^fix(\([^)]+\))?!?:\s+\S/i;
+var REVIEW_TRAILER_RE = /^(Co-authored-by|Signed-off-by):\s*(.*?)\s*<([^<>]+)>$/gim;
+var DEFAULT_OWNERSHIP_FILE_LIMIT = 200;
+var OWNERSHIP_EXTENSIONS = /* @__PURE__ */ new Set([
+  ".c",
+  ".cpp",
+  ".css",
+  ".go",
+  ".h",
+  ".html",
+  ".java",
+  ".js",
+  ".jsx",
+  ".md",
+  ".py",
+  ".rs",
+  ".scss",
+  ".ts",
+  ".tsx",
+  ".vue"
+]);
+function calculateEngineeringMetrics(commits, repoPath) {
+  return {
+    ...repoPath && {
+      codeOwnership: calculateCodeOwnership(repoPath, {
+        candidateFiles: selectOwnershipCandidates(commits)
+      })
+    },
+    bugFixHotFiles: calculateBugFixHotFiles(commits),
+    reviewQuality: calculateReviewQuality(commits),
+    commitQuality: calculateCommitQuality(commits),
+    changeMix: calculateChangeMix(commits)
+  };
+}
+function calculateCodeOwnership(repoPath, options = {}) {
+  const trackedFiles = listTrackedFiles(repoPath);
+  const trackedSet = new Set(trackedFiles);
+  const maxFiles = options.maxFiles ?? DEFAULT_OWNERSHIP_FILE_LIMIT;
+  const candidates = options.candidateFiles ? options.candidateFiles.filter((file) => trackedSet.has(file)) : trackedFiles;
+  const filesToBlame = candidates.filter(isOwnershipTargetFile).slice(0, maxFiles);
+  const files = [];
+  for (const filePath of filesToBlame) {
+    const ownership = calculateFileOwnership(repoPath, filePath);
+    if (ownership) {
+      files.push(ownership);
+    }
+  }
+  files.sort((a, b) => {
+    if (b.ownerLines !== a.ownerLines) return b.ownerLines - a.ownerLines;
+    return b.ownershipRatio - a.ownershipRatio;
+  });
+  return {
+    totalFiles: files.length,
+    files
+  };
+}
+function calculateBugFixHotFiles(commits) {
+  const hotFileMap = /* @__PURE__ */ new Map();
+  let fixCommitCount = 0;
+  for (const commit of commits) {
+    if (!FIX_RE.test(commit.message)) continue;
+    fixCommitCount++;
+    for (const file of commit.files) {
+      const entry = hotFileMap.get(file.path) || {
+        fixCount: 0,
+        lastFixDate: commit.date,
+        fixAuthors: /* @__PURE__ */ new Set()
+      };
+      entry.fixCount++;
+      entry.fixAuthors.add(commit.author);
+      if (commit.date > entry.lastFixDate) {
+        entry.lastFixDate = commit.date;
+      }
+      hotFileMap.set(file.path, entry);
+    }
+  }
+  const hotFiles = Array.from(hotFileMap.entries()).map(([path, data]) => ({
+    path,
+    fixCount: data.fixCount,
+    lastFixDate: data.lastFixDate,
+    fixAuthors: Array.from(data.fixAuthors)
+  })).sort((a, b) => {
+    if (b.fixCount !== a.fixCount) return b.fixCount - a.fixCount;
+    return b.lastFixDate.getTime() - a.lastFixDate.getTime();
+  }).slice(0, 20);
+  return { fixCommitCount, hotFiles };
+}
+function calculateReviewQuality(commits) {
+  const reviewerMap = /* @__PURE__ */ new Map();
+  let mergeCommitCount = 0;
+  let reviewedMergeCount = 0;
+  let order = 0;
+  for (const commit of commits) {
+    if (!isMergeCommit(commit)) continue;
+    mergeCommitCount++;
+    const reviewers2 = parseReviewers(commit.body || commit.message);
+    if (reviewers2.length > 0) {
+      reviewedMergeCount++;
+    }
+    for (const reviewer of reviewers2) {
+      const key = reviewer.email.toLowerCase();
+      const existing = reviewerMap.get(key);
+      if (existing) {
+        existing.commits++;
+      } else {
+        reviewerMap.set(key, {
+          ...reviewer,
+          commits: 1,
+          firstSeenIndex: order
+        });
+        order++;
+      }
+    }
+  }
+  const reviewers = Array.from(reviewerMap.values()).sort((a, b) => {
+    if (b.commits !== a.commits) return b.commits - a.commits;
+    return a.firstSeenIndex - b.firstSeenIndex;
+  }).map(({ firstSeenIndex, ...reviewer }) => reviewer);
+  return {
+    mergeCommitCount,
+    reviewedMergeCount,
+    reviewParticipationRate: mergeCommitCount > 0 ? roundRatio(reviewedMergeCount / mergeCommitCount) : 0,
+    reviewers
+  };
+}
+function calculateCommitQuality(commits) {
+  if (commits.length === 0) {
+    return {
+      score: 0,
+      conventionalRate: 0,
+      scopeCoverageRate: 0,
+      averageMessageLength: 0,
+      typeDistribution: {}
+    };
+  }
+  let conventionalCount = 0;
+  let scopedCount = 0;
+  let totalLength = 0;
+  const typeDistribution = {};
+  for (const commit of commits) {
+    totalLength += commit.message.length;
+    const conventionalMatch = commit.message.match(CONVENTIONAL_RE);
+    if (conventionalMatch) {
+      conventionalCount++;
+      const type = conventionalMatch[1].toLowerCase();
+      typeDistribution[type] = (typeDistribution[type] || 0) + 1;
+    } else {
+      typeDistribution.other = (typeDistribution.other || 0) + 1;
+    }
+    if (SCOPED_CONVENTIONAL_RE.test(commit.message)) {
+      scopedCount++;
+    }
+  }
+  const averageMessageLength = roundTo(totalLength / commits.length, 1);
+  const conventionalRate = roundRatio(conventionalCount / commits.length);
+  const scopeCoverageRate = roundRatio(scopedCount / commits.length);
+  const messageLengthScore = Math.min(averageMessageLength / 24, 1);
+  const score = Math.round(
+    conventionalRate * 60 + scopeCoverageRate * 25 + messageLengthScore * 15
+  );
+  return {
+    score,
+    conventionalRate,
+    scopeCoverageRate,
+    averageMessageLength,
+    typeDistribution
+  };
+}
+function calculateChangeMix(commits) {
+  let createdFiles = 0;
+  let deletedFiles = 0;
+  let modifiedFiles = 0;
+  for (const commit of commits) {
+    for (const file of commit.files) {
+      if (file.status === "added" || file.status === "copied") {
+        createdFiles++;
+      } else if (file.status === "deleted") {
+        deletedFiles++;
+      } else {
+        modifiedFiles++;
+      }
+    }
+  }
+  const total = createdFiles + deletedFiles + modifiedFiles;
+  return {
+    createdFiles,
+    deletedFiles,
+    modifiedFiles,
+    featureRatio: total > 0 ? roundRatio((createdFiles + deletedFiles) / total) : 0,
+    refactorRatio: total > 0 ? roundRatio(modifiedFiles / total) : 0
+  };
+}
+function selectOwnershipCandidates(commits) {
+  const fileCounts = /* @__PURE__ */ new Map();
+  for (const commit of commits) {
+    for (const file of commit.files) {
+      fileCounts.set(file.path, (fileCounts.get(file.path) || 0) + 1);
+    }
+  }
+  return Array.from(fileCounts.entries()).sort((a, b) => {
+    if (b[1] !== a[1]) return b[1] - a[1];
+    return a[0].localeCompare(b[0]);
+  }).map(([file]) => file);
+}
+function listTrackedFiles(repoPath) {
+  let output = "";
+  try {
+    output = execFileSync2("git", ["ls-files", "-z"], {
+      cwd: repoPath,
+      encoding: "utf-8",
+      maxBuffer: 100 * 1024 * 1024,
+      stdio: ["pipe", "pipe", "ignore"]
+    });
+  } catch {
+    return [];
+  }
+  return output.split("\0").filter((path) => path && !isIgnoredOwnershipFile(path));
+}
+function calculateFileOwnership(repoPath, filePath) {
+  let output = "";
+  try {
+    output = execFileSync2("git", ["blame", "HEAD", "--line-porcelain", "--", filePath], {
+      cwd: repoPath,
+      encoding: "utf-8",
+      maxBuffer: 100 * 1024 * 1024,
+      stdio: ["pipe", "pipe", "ignore"]
+    });
+  } catch {
+    return null;
+  }
+  const contributors = parseBlameContributors(output);
+  const totalLines = Array.from(contributors.values()).reduce(
+    (sum, contributor) => sum + contributor.lines,
+    0
+  );
+  if (totalLines === 0) return null;
+  const sortedContributors = Array.from(
+    contributors.values()
+  ).map((contributor) => ({
+    ...contributor,
+    ratio: contributor.lines / totalLines
+  })).sort((a, b) => b.lines - a.lines);
+  const owner = sortedContributors[0];
+  return {
+    path: filePath,
+    ownerName: owner.name,
+    ownerEmail: owner.email,
+    ownerLines: owner.lines,
+    totalLines,
+    ownershipRatio: owner.ratio,
+    contributors: sortedContributors
+  };
+}
+function parseBlameContributors(output) {
+  const contributors = /* @__PURE__ */ new Map();
+  let currentName = "";
+  for (const line of output.split("\n")) {
+    if (line.startsWith("author ")) {
+      currentName = line.slice("author ".length);
+    } else if (line.startsWith("author-mail ")) {
+      const email = line.slice("author-mail ".length).replace(/^<|>$/g, "").toLowerCase();
+      const key = email || currentName;
+      const existing = contributors.get(key) || {
+        name: currentName || email,
+        email,
+        lines: 0
+      };
+      existing.lines++;
+      contributors.set(key, existing);
+    }
+  }
+  return contributors;
+}
+function parseReviewers(body) {
+  const reviewers = [];
+  const seen = /* @__PURE__ */ new Set();
+  REVIEW_TRAILER_RE.lastIndex = 0;
+  let match = REVIEW_TRAILER_RE.exec(body);
+  while (match) {
+    const name = match[2].trim();
+    const email = match[3].trim().toLowerCase();
+    if (!seen.has(email)) {
+      reviewers.push({ name, email, commits: 0 });
+      seen.add(email);
+    }
+    match = REVIEW_TRAILER_RE.exec(body);
+  }
+  return reviewers;
+}
+function isMergeCommit(commit) {
+  return (commit.parentHashes?.length || 0) > 1 || /^Merge\b/i.test(commit.message);
+}
+function isIgnoredOwnershipFile(filePath) {
+  return /(^|\/)(package-lock\.json|pnpm-lock\.yaml|yarn\.lock)$/.test(filePath);
+}
+function isOwnershipTargetFile(filePath) {
+  if (isIgnoredOwnershipFile(filePath)) return false;
+  const extension = filePath.includes(".") ? filePath.slice(filePath.lastIndexOf(".")).toLowerCase() : "";
+  return OWNERSHIP_EXTENSIONS.has(extension);
+}
+function roundRatio(value) {
+  return roundTo(value, 2);
+}
+function roundTo(value, digits) {
+  const factor = 10 ** digits;
+  return Math.round(value * factor) / factor;
+}
+
 // src/analyzer/index.ts
 async function analyzeRepos(options) {
   const { repos, timeRange, author } = options;
@@ -1368,10 +2638,30 @@ async function analyzeRepos(options) {
       }
       const stats = calculateStats(commits);
       const advancedStats = calculateAdvancedStats(commits);
+      let techDebt;
+      let engineering;
+      if (repos.length === 1) {
+        spinner.text = `\u5206\u6790\u6280\u672F\u503A - ${repo.name}`;
+        techDebt = await calculateTechDebt(commits, repo.path);
+        spinner.text = `\u5206\u6790\u5DE5\u7A0B\u8D28\u91CF - ${repo.name}`;
+        engineering = calculateEngineeringMetrics(commits, repo.path);
+      }
       const fullStats = {
         ...stats,
-        ...advancedStats
+        ...advancedStats,
+        ...techDebt && { techDebt },
+        ...engineering && { engineering }
       };
+      fullStats.commitDetails.forEach((commit) => {
+        commit.repoName = repo.name;
+      });
+      fullStats.aiMetrics?.highAICommits.forEach((commit) => {
+        commit.repoName = repo.name;
+      });
+      fullStats.directoryAIStats?.forEach((directory) => {
+        directory.repoName = repo.name;
+        directory.displayPath = repos.length > 1 ? `${repo.name} / ${directory.path}` : directory.path;
+      });
       allStats.push(fullStats);
     } catch (error) {
       spinner.warn(
@@ -1397,11 +2687,32 @@ import ora3 from "ora";
 import open from "open";
 
 // src/reporter/html-builder.ts
-import { readFile as readFile2 } from "fs/promises";
+import { readFile as readFile4 } from "fs/promises";
 import { resolve, dirname } from "path";
 import { fileURLToPath } from "url";
+var REPORT_SCRIPT_FILES = [
+  "report-scripts/01-core.html",
+  "report-scripts/00-filter-state.html",
+  "report-scripts/00-advanced-derived.html",
+  "report-scripts/00-report-controls.html",
+  "report-scripts/02-commit-details.html",
+  "report-scripts/03-basic-charts.html",
+  "report-scripts/04-trend-charts.html",
+  "report-scripts/05-tables-team-stability.html",
+  "report-scripts/06-pressure-churn.html",
+  "report-scripts/08-engineering.html",
+  "report-scripts/09-extensions.html",
+  "report-scripts/07-collab-debt-ai.html",
+  "report-scripts/10-runtime.html"
+];
+var REPORT_SECTION_FILES = [
+  "report-sections/01-overview.html",
+  "report-sections/02-advanced.html"
+];
 async function buildHtml(stats, options) {
-  const template = await loadTemplate();
+  const template = await loadTemplateFile("report.html");
+  const reportSections = await loadTemplateParts(REPORT_SECTION_FILES);
+  const reportScript = await loadReportScript();
   const reportData = {
     stats: serializeStats(stats),
     generatedAt: (/* @__PURE__ */ new Date()).toLocaleString("zh-CN"),
@@ -1412,7 +2723,7 @@ async function buildHtml(stats, options) {
     repos: options.repoNames
   };
   const jsonData = JSON.stringify(reportData).replace(/</g, "\\u003c").replace(/>/g, "\\u003e").replace(/&/g, "\\u0026");
-  return template.replace("__REPORT_DATA__", jsonData);
+  return template.replace("__REPORT_DATA__", jsonData).replace("__REPORT_SECTIONS__", reportSections).replace("__REPORT_SCRIPT__", reportScript);
 }
 function serializeStats(stats) {
   const serializeAuthorDetail = (author) => ({
@@ -1427,6 +2738,10 @@ function serializeStats(stats) {
       ...a,
       lastActiveDate: a.lastActiveDate.toISOString()
     })),
+    commitDetails: stats.commitDetails.map((commit) => ({
+      ...commit,
+      date: commit.date.toISOString()
+    })),
     contributorChurn: stats.contributorChurn ? {
       ...stats.contributorChurn,
       active: stats.contributorChurn.active.map(serializeAuthorDetail),
@@ -1434,23 +2749,39 @@ function serializeStats(stats) {
       dormant: stats.contributorChurn.dormant.map(serializeAuthorDetail),
       lost: stats.contributorChurn.lost.map(serializeAuthorDetail),
       newJoiners: stats.contributorChurn.newJoiners.map(serializeAuthorDetail)
+    } : void 0,
+    changeSizeDistribution: stats.changeSizeDistribution ? {
+      ...stats.changeSizeDistribution,
+      largeCommits: stats.changeSizeDistribution.largeCommits.map((c) => ({
+        ...c,
+        date: c.date.toISOString()
+      }))
     } : void 0
   };
 }
-async function loadTemplate() {
+async function loadReportScript() {
+  return loadTemplateParts(REPORT_SCRIPT_FILES);
+}
+async function loadTemplateParts(fileNames) {
+  const parts = await Promise.all(
+    fileNames.map((fileName) => loadTemplateFile(fileName))
+  );
+  return parts.join("\n");
+}
+async function loadTemplateFile(fileName) {
   const currentDir = dirname(fileURLToPath(import.meta.url));
   const possiblePaths = [
-    resolve(currentDir, "../templates/report.html"),
-    resolve(currentDir, "../../templates/report.html"),
-    resolve(currentDir, "../../../templates/report.html")
+    resolve(currentDir, "../templates", fileName),
+    resolve(currentDir, "../../templates", fileName),
+    resolve(currentDir, "../../../templates", fileName)
   ];
   for (const templatePath of possiblePaths) {
     try {
-      return await readFile2(templatePath, "utf-8");
+      return await readFile4(templatePath, "utf-8");
     } catch {
     }
   }
-  throw new Error("\u65E0\u6CD5\u627E\u5230 HTML \u6A21\u677F\u6587\u4EF6");
+  throw new Error(`\u65E0\u6CD5\u627E\u5230 HTML \u6A21\u677F\u6587\u4EF6: ${fileName}`);
 }
 
 // src/reporter/index.ts
@@ -1523,7 +2854,7 @@ function resolveTimeRange(opts) {
 
 // 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) => {
+program.name("commit-report").description("Git \u63D0\u4EA4\u7EDF\u8BA1\u5DE5\u5177\uFF0C\u751F\u6210\u53EF\u89C6\u5316 HTML \u62A5\u544A").version("1.0.1").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) {
@@ -1593,9 +2924,9 @@ async function run(directory, opts) {
   });
 }
 async function checkGitInstalled() {
-  const { execSync: execSync3 } = await import("child_process");
+  const { execSync: execSync2 } = await import("child_process");
   try {
-    execSync3("git --version", { stdio: "ignore" });
+    execSync2("git --version", { stdio: "ignore" });
   } catch {
     console.error(chalk3.red("\u8BF7\u5148\u5B89\u88C5 Git"));
     process.exit(1);