gimpact 0.1.2

package/dist/index.js

@@ -0,0 +1,2061 @@
+#!/usr/bin/env node
+
+// src/cli/index.ts
+import * as p from "@clack/prompts";
+import chalk7 from "chalk";
+
+// src/core/analysis/filters/file-pattern-filter.ts
+import { simpleGit } from "simple-git";
+var DEFAULT_EXCLUDE_PATTERNS = [
+  // Lock files
+  "**/*.lock",
+  "**/package-lock.json",
+  "**/yarn.lock",
+  "**/pnpm-lock.yaml",
+  "**/uv.lock",
+  "**/Cargo.lock",
+  "**/Gemfile.lock",
+  "**/Pipfile.lock",
+  "**/poetry.lock",
+  "**/composer.lock",
+  "**/go.sum",
+  "**/go.mod",
+  // Build outputs
+  "**/node_modules/**",
+  "**/dist/**",
+  "**/build/**",
+  "**/out/**",
+  "**/.next/**",
+  "**/.nuxt/**",
+  "**/.cache/**",
+  "**/coverage/**",
+  "**/.coverage/**",
+  // Generated files
+  "**/openapi.json",
+  "**/openapi.yaml",
+  "**/openapi.yml",
+  "**/*.generated.*",
+  "**/*.pb.go",
+  "**/*.pb.ts",
+  "**/*.pb.js",
+  // IDE and editor files
+  "**/.idea/**",
+  "**/.vscode/**",
+  "**/.DS_Store",
+  "**/Thumbs.db",
+  // Logs and temporary files
+  "**/*.log",
+  "**/*.tmp",
+  "**/*.temp"
+];
+function matchesPattern(filePath, patterns) {
+  for (const pattern of patterns) {
+    if (matchesGlob(filePath, pattern)) {
+      return true;
+    }
+  }
+  return false;
+}
+function matchesGlob(filePath, pattern) {
+  const normalizedPath = filePath.replace(/^\.\//, "");
+  let normalizedPattern = pattern.replace(/^\.\//, "");
+  normalizedPattern = normalizedPattern.replace(/\*\*/g, "\0RECURSIVE\0");
+  let regexPattern = normalizedPattern.replace(/[.+^$()|[\]\\]/g, "\\$&").replace(/\*/g, "[^/]*").replace(/\?/g, ".");
+  regexPattern = regexPattern.replace(/\0RECURSIVE\0/g, ".*?");
+  const originalPattern = pattern.replace(/^\.\//, "");
+  if (!originalPattern.startsWith("/") && !originalPattern.startsWith("**")) {
+    regexPattern = `.*?${regexPattern}`;
+  }
+  try {
+    const regex = new RegExp(`^${regexPattern}$`);
+    return regex.test(normalizedPath);
+  } catch (_error) {
+    return false;
+  }
+}
+async function areGitIgnored(filePaths, git) {
+  if (filePaths.length === 0) {
+    return /* @__PURE__ */ new Set();
+  }
+  try {
+    const result = await git.checkIgnore(filePaths);
+    return new Set(result);
+  } catch {
+    return /* @__PURE__ */ new Set();
+  }
+}
+var FilePatternFilter = class {
+  excludePatterns;
+  includeDirectory;
+  respectGitignore;
+  repoRoot;
+  gitClient = null;
+  constructor(excludePatterns = [], respectGitignore = true, repoRoot = process.cwd(), includeDirectory) {
+    this.excludePatterns = [...DEFAULT_EXCLUDE_PATTERNS, ...excludePatterns];
+    this.respectGitignore = respectGitignore;
+    this.repoRoot = repoRoot;
+    this.includeDirectory = includeDirectory;
+  }
+  /**
+   * Get or create git client instance
+   */
+  getGitClient() {
+    if (!this.gitClient) {
+      this.gitClient = simpleGit(this.repoRoot);
+    }
+    return this.gitClient;
+  }
+  /**
+   * Check if a file should be excluded (pattern matching only, no git check)
+   */
+  shouldExcludeByPattern(filePath) {
+    if (this.includeDirectory) {
+      const normalizedDir = this.includeDirectory.replace(/^\.\//, "").replace(/\/$/, "");
+      const normalizedPath = filePath.replace(/^\.\//, "");
+      const isInDirectory = normalizedPath === normalizedDir || normalizedPath.startsWith(`${normalizedDir}/`);
+      if (!isInDirectory) {
+        return true;
+      }
+    }
+    return matchesPattern(filePath, this.excludePatterns);
+  }
+  /**
+   * Filter ownership analysis result
+   */
+  async filter(result) {
+    const filteredFiles = {};
+    const filteredDirectories = {};
+    const filteredAuthors = {};
+    const filesToCheckGitIgnore = [];
+    const fileOwnershipMap = /* @__PURE__ */ new Map();
+    for (const [filePath, fileOwnership] of Object.entries(result.files)) {
+      if (this.shouldExcludeByPattern(filePath)) {
+        continue;
+      }
+      if (this.respectGitignore) {
+        filesToCheckGitIgnore.push(filePath);
+        fileOwnershipMap.set(filePath, fileOwnership);
+      } else {
+        filteredFiles[filePath] = fileOwnership;
+      }
+    }
+    if (this.respectGitignore && filesToCheckGitIgnore.length > 0) {
+      const gitClient = this.getGitClient();
+      const ignoredFiles = await areGitIgnored(filesToCheckGitIgnore, gitClient);
+      for (const filePath of filesToCheckGitIgnore) {
+        if (!ignoredFiles.has(filePath)) {
+          const fileOwnership = fileOwnershipMap.get(filePath);
+          if (fileOwnership) {
+            filteredFiles[filePath] = fileOwnership;
+          }
+        }
+      }
+    }
+    const directoryFileCounts = {};
+    for (const [filePath, fileOwnership] of Object.entries(filteredFiles)) {
+      const directory = this.getDirectory(filePath);
+      if (!directoryFileCounts[directory]) {
+        directoryFileCounts[directory] = {};
+      }
+      const owner = fileOwnership.owner;
+      directoryFileCounts[directory][owner] = (directoryFileCounts[directory][owner] || 0) + 1;
+    }
+    for (const [directory, ownerCounts] of Object.entries(directoryFileCounts)) {
+      if (this.includeDirectory) {
+        const normalizedDir = this.includeDirectory.replace(/^\.\//, "").replace(/\/$/, "");
+        const normalizedDirectory = directory.replace(/^\.\//, "").replace(/\/$/, "");
+        if (!normalizedDirectory.startsWith(`${normalizedDir}/`) && normalizedDirectory !== normalizedDir) {
+          continue;
+        }
+      }
+      let primaryOwner = "";
+      let maxFiles = 0;
+      for (const [owner, count] of Object.entries(ownerCounts)) {
+        if (count > maxFiles) {
+          maxFiles = count;
+          primaryOwner = owner;
+        }
+      }
+      if (primaryOwner) {
+        const totalFiles = Object.values(ownerCounts).reduce((sum, count) => sum + count, 0);
+        const totalLines = Object.entries(filteredFiles).filter(([path]) => this.getDirectory(path) === directory).reduce((sum, [, ownership]) => sum + ownership.totalLines, 0);
+        filteredDirectories[directory] = {
+          directory,
+          owner: primaryOwner,
+          share: totalFiles > 0 ? Math.round(maxFiles / totalFiles * 100) : 0,
+          ownerFiles: maxFiles,
+          totalFiles,
+          totalLines
+        };
+      }
+    }
+    for (const [filePath, fileOwnership] of Object.entries(filteredFiles)) {
+      const owner = fileOwnership.owner;
+      if (!filteredAuthors[owner]) {
+        filteredAuthors[owner] = {
+          author: owner,
+          files: [],
+          totalFiles: 0,
+          totalLines: 0
+        };
+      }
+      filteredAuthors[owner].files.push({
+        file: filePath,
+        lines: fileOwnership.ownerLines,
+        share: fileOwnership.share
+      });
+      filteredAuthors[owner].totalFiles++;
+      filteredAuthors[owner].totalLines += fileOwnership.ownerLines;
+    }
+    for (const author of Object.values(filteredAuthors)) {
+      author.files.sort((a, b) => b.lines - a.lines);
+    }
+    return {
+      files: filteredFiles,
+      directories: filteredDirectories,
+      authors: filteredAuthors
+    };
+  }
+  getDirectory(filePath) {
+    const lastSlashIndex = filePath.lastIndexOf("/");
+    if (lastSlashIndex === -1) {
+      return "./";
+    }
+    return filePath.substring(0, lastSlashIndex + 1);
+  }
+};
+
+// src/core/analysis/filters/filter-chain.ts
+var FilterChain = class {
+  filters = [];
+  addFilter(filter) {
+    this.filters.push(filter);
+    return this;
+  }
+  apply(data) {
+    return this.filters.reduce((result, filter) => filter.apply(result), data);
+  }
+  isEmpty() {
+    return this.filters.length === 0;
+  }
+};
+
+// src/core/analysis/filters/min-commits-filter.ts
+var MinCommitsFilter = class {
+  constructor(minCommits) {
+    this.minCommits = minCommits;
+  }
+  apply(result) {
+    if (Array.isArray(result)) {
+      return result.filter((item) => item.stats.commits >= this.minCommits);
+    } else {
+      const filteredStats = {};
+      const filteredEfficiency = {};
+      for (const [author, authorStats] of Object.entries(result.stats)) {
+        if (authorStats.commits >= this.minCommits) {
+          filteredStats[author] = authorStats;
+          if (result.efficiency[author]) {
+            filteredEfficiency[author] = result.efficiency[author];
+          }
+        }
+      }
+      return {
+        stats: filteredStats,
+        efficiency: filteredEfficiency
+      };
+    }
+  }
+};
+
+// src/core/analysis/log-parsers/aggregate-log-parser.ts
+function parseAggregateStats(log, authors) {
+  const stats = {};
+  const authorFiles = {};
+  const lines = log.split("\n");
+  let currentAuthor = "";
+  const authorFilter = authors?.map((a) => a.toLowerCase());
+  for (const line of lines) {
+    const trimmedLine = line.trim();
+    if (trimmedLine.length === 0) {
+      continue;
+    }
+    if (trimmedLine.includes("	")) {
+      const parts = trimmedLine.split("	");
+      const insertions = parseInt(parts[0], 10) || 0;
+      const deletions = parseInt(parts[1], 10) || 0;
+      const filePath = parts[2];
+      if (currentAuthor && stats[currentAuthor]) {
+        stats[currentAuthor].insertions += insertions;
+        stats[currentAuthor].deletions += deletions;
+        if (filePath) {
+          authorFiles[currentAuthor].add(filePath);
+        }
+      }
+    } else {
+      currentAuthor = trimmedLine;
+      if (authorFilter && !authorFilter.includes(currentAuthor.toLowerCase())) {
+        currentAuthor = "";
+        continue;
+      }
+      if (!stats[currentAuthor]) {
+        stats[currentAuthor] = {
+          commits: 0,
+          insertions: 0,
+          deletions: 0,
+          filesTouched: 0
+        };
+        authorFiles[currentAuthor] = /* @__PURE__ */ new Set();
+      }
+      stats[currentAuthor].commits++;
+    }
+  }
+  for (const author of Object.keys(stats)) {
+    stats[author].filesTouched = authorFiles[author]?.size ?? 0;
+  }
+  return stats;
+}
+
+// src/core/analysis/log-parsers/efficiency-log-parser.ts
+function parseEfficiencyLog(log) {
+  const commits = [];
+  const lines = log.split("\n");
+  let currentCommit = null;
+  for (const line of lines) {
+    const trimmedLine = line.trim();
+    if (trimmedLine.length === 0) {
+      continue;
+    }
+    if (trimmedLine.includes("|") && !trimmedLine.includes("	")) {
+      if (currentCommit) {
+        commits.push(currentCommit);
+      }
+      const parts = trimmedLine.split("|");
+      if (parts.length >= 2) {
+        currentCommit = {
+          author: parts[0],
+          date: new Date(parts[1]),
+          insertions: 0,
+          deletions: 0,
+          files: []
+        };
+      }
+    } else if (trimmedLine.includes("	") && currentCommit) {
+      const parts = trimmedLine.split("	");
+      const insertions = parseInt(parts[0], 10) || 0;
+      const deletions = parseInt(parts[1], 10) || 0;
+      const filePath = parts[2];
+      currentCommit.insertions += insertions;
+      currentCommit.deletions += deletions;
+      if (filePath) {
+        currentCommit.files.push(filePath);
+      }
+    }
+  }
+  if (currentCommit) {
+    commits.push(currentCommit);
+  }
+  return commits;
+}
+
+// src/core/analysis/log-parsers/ownership-log-parser.ts
+function parseOwnershipStats(log, authors) {
+  const fileAuthorLines = {};
+  const fileLastCommitDates = {};
+  const lines = log.split("\n");
+  let currentAuthor = "";
+  let currentCommitDate = null;
+  const authorFilter = authors?.map((a) => a.toLowerCase());
+  for (const line of lines) {
+    const trimmedLine = line.trim();
+    if (trimmedLine.length === 0) {
+      continue;
+    }
+    if (trimmedLine.startsWith("AUTHOR:")) {
+      const authorPart = trimmedLine.replace("AUTHOR:", "").trim();
+      if (authorPart.includes("|DATE:")) {
+        const parts = authorPart.split("|DATE:");
+        currentAuthor = parts[0].trim();
+        const dateStr = parts[1]?.trim();
+        if (dateStr) {
+          currentCommitDate = new Date(dateStr);
+          if (Number.isNaN(currentCommitDate.getTime())) {
+            currentCommitDate = null;
+          }
+        } else {
+          currentCommitDate = null;
+        }
+      } else {
+        currentAuthor = authorPart;
+        currentCommitDate = null;
+      }
+      fetch("http://127.0.0.1:7242/ingest/f771081e-8bc3-4743-9457-44201273bd79", {
+        method: "POST",
+        headers: { "Content-Type": "application/json" },
+        body: JSON.stringify({
+          location: "ownership-log-parser.ts:30",
+          message: "Author line parsed",
+          data: { currentAuthor, isEmpty: !currentAuthor, length: currentAuthor.length },
+          timestamp: Date.now(),
+          sessionId: "debug-session",
+          runId: "run1",
+          hypothesisId: "B"
+        })
+      }).catch(() => {
+      });
+      if (authorFilter && !authorFilter.includes(currentAuthor.toLowerCase())) {
+        currentAuthor = "";
+      }
+    } else if (trimmedLine.includes("	") && currentAuthor) {
+      const parts = trimmedLine.split("	");
+      if (parts.length >= 3) {
+        const insertions = parseInt(parts[0], 10) || 0;
+        const deletions = parseInt(parts[1], 10) || 0;
+        let filePath = parts[2];
+        if (!filePath) {
+          continue;
+        }
+        const originalFilePath = filePath;
+        filePath = normalizeRenameNotation(filePath);
+        fetch("http://127.0.0.1:7242/ingest/f771081e-8bc3-4743-9457-44201273bd79", {
+          method: "POST",
+          headers: { "Content-Type": "application/json" },
+          body: JSON.stringify({
+            location: "ownership-log-parser.ts:42",
+            message: "File path parsed",
+            data: {
+              originalFilePath,
+              normalizedFilePath: filePath,
+              hasRenameNotation: originalFilePath.includes("{") && originalFilePath.includes("=>"),
+              currentAuthor,
+              isEmpty: !currentAuthor
+            },
+            timestamp: Date.now(),
+            sessionId: "debug-session",
+            runId: "run1",
+            hypothesisId: "A"
+          })
+        }).catch(() => {
+        });
+        if (!filePath) {
+          continue;
+        }
+        const linesChanged = insertions + deletions;
+        if (!fileAuthorLines[filePath]) {
+          fileAuthorLines[filePath] = {};
+        }
+        fileAuthorLines[filePath][currentAuthor] = (fileAuthorLines[filePath][currentAuthor] || 0) + linesChanged;
+        if (currentCommitDate) {
+          const existingDate = fileLastCommitDates[filePath];
+          if (!existingDate || currentCommitDate > existingDate) {
+            fileLastCommitDates[filePath] = currentCommitDate;
+          }
+        }
+      }
+    }
+  }
+  const fileOwnership = {};
+  const directoryOwnership = {};
+  const authorOwnership = {};
+  for (const [file, authorLines] of Object.entries(fileAuthorLines)) {
+    const totalLines = Object.values(authorLines).reduce((sum, lines2) => sum + lines2, 0);
+    let primaryOwner = "";
+    let maxLines = -1;
+    for (const [author, lines2] of Object.entries(authorLines)) {
+      if (!author || author.trim() === "") {
+        continue;
+      }
+      if (lines2 > maxLines) {
+        maxLines = lines2;
+        primaryOwner = author;
+      }
+    }
+    if (!primaryOwner) {
+      continue;
+    }
+    fetch("http://127.0.0.1:7242/ingest/f771081e-8bc3-4743-9457-44201273bd79", {
+      method: "POST",
+      headers: { "Content-Type": "application/json" },
+      body: JSON.stringify({
+        location: "ownership-log-parser.ts:77",
+        message: "Primary owner calculated",
+        data: {
+          file,
+          primaryOwner,
+          isEmpty: !primaryOwner,
+          hasRenameNotation: file.includes("{ => }"),
+          authorKeys: Object.keys(authorLines)
+        },
+        timestamp: Date.now(),
+        sessionId: "debug-session",
+        runId: "run1",
+        hypothesisId: "C"
+      })
+    }).catch(() => {
+    });
+    const share = totalLines > 0 ? Math.round(maxLines / totalLines * 100) : 0;
+    fileOwnership[file] = {
+      file,
+      owner: primaryOwner,
+      share,
+      ownerLines: maxLines,
+      totalLines,
+      authors: { ...authorLines },
+      lastCommitDate: fileLastCommitDates[file]
+    };
+    const directory = getDirectory(file);
+    fetch("http://127.0.0.1:7242/ingest/f771081e-8bc3-4743-9457-44201273bd79", {
+      method: "POST",
+      headers: { "Content-Type": "application/json" },
+      body: JSON.stringify({
+        location: "ownership-log-parser.ts:94",
+        message: "Directory extracted",
+        data: { file, directory, hasRenameNotation: directory.includes("{ => }") },
+        timestamp: Date.now(),
+        sessionId: "debug-session",
+        runId: "run1",
+        hypothesisId: "D"
+      })
+    }).catch(() => {
+    });
+    if (!directoryOwnership[directory]) {
+      directoryOwnership[directory] = {};
+    }
+    directoryOwnership[directory][file] = maxLines;
+    if (!authorOwnership[primaryOwner]) {
+      authorOwnership[primaryOwner] = {
+        author: primaryOwner,
+        files: [],
+        totalFiles: 0,
+        totalLines: 0
+      };
+    }
+    authorOwnership[primaryOwner].files.push({
+      file,
+      lines: maxLines,
+      share
+    });
+    authorOwnership[primaryOwner].totalFiles++;
+    authorOwnership[primaryOwner].totalLines += maxLines;
+  }
+  const directoryResult = {};
+  for (const [directory, files] of Object.entries(directoryOwnership)) {
+    const fileList = Object.keys(files);
+    const totalFiles = fileList.length;
+    const authorFileCounts = {};
+    for (const file of fileList) {
+      const ownership = fileOwnership[file];
+      if (ownership) {
+        authorFileCounts[ownership.owner] = (authorFileCounts[ownership.owner] || 0) + 1;
+      }
+    }
+    let primaryOwner = "";
+    let maxFiles = 0;
+    for (const [author, count] of Object.entries(authorFileCounts)) {
+      if (!author || author.trim() === "") {
+        continue;
+      }
+      if (count > maxFiles) {
+        maxFiles = count;
+        primaryOwner = author;
+      }
+    }
+    if (!primaryOwner) {
+      continue;
+    }
+    fetch("http://127.0.0.1:7242/ingest/f771081e-8bc3-4743-9457-44201273bd79", {
+      method: "POST",
+      headers: { "Content-Type": "application/json" },
+      body: JSON.stringify({
+        location: "ownership-log-parser.ts:140",
+        message: "Directory owner calculated",
+        data: {
+          directory,
+          primaryOwner,
+          isEmpty: !primaryOwner,
+          hasRenameNotation: directory.includes("{ => }"),
+          authorFileCounts
+        },
+        timestamp: Date.now(),
+        sessionId: "debug-session",
+        runId: "run1",
+        hypothesisId: "C"
+      })
+    }).catch(() => {
+    });
+    const share = totalFiles > 0 ? Math.round(maxFiles / totalFiles * 100) : 0;
+    const totalLines = fileList.reduce(
+      (sum, file) => sum + (fileOwnership[file]?.totalLines || 0),
+      0
+    );
+    directoryResult[directory] = {
+      directory,
+      owner: primaryOwner,
+      share,
+      ownerFiles: maxFiles,
+      totalFiles,
+      totalLines
+    };
+  }
+  for (const author of Object.values(authorOwnership)) {
+    author.files.sort((a, b) => b.lines - a.lines);
+  }
+  return {
+    files: fileOwnership,
+    directories: directoryResult,
+    authors: authorOwnership
+  };
+}
+function normalizeRenameNotation(filePath) {
+  const renamePattern = /\{[^}]*\s*=>\s*([^}]*)\}/g;
+  let result = filePath;
+  let hasEmptyRename = false;
+  result = result.replace(renamePattern, (_match, newPath) => {
+    const normalized = newPath.trim();
+    if (!normalized) {
+      hasEmptyRename = true;
+      return "";
+    }
+    return normalized;
+  });
+  if (hasEmptyRename && result.startsWith("/")) {
+    if (result === "/" || result.match(/^\/[^/]*$/)) {
+      return "";
+    }
+  }
+  return result;
+}
+function getDirectory(filePath) {
+  const lastSlashIndex = filePath.lastIndexOf("/");
+  if (lastSlashIndex === -1) {
+    return "./";
+  }
+  return filePath.substring(0, lastSlashIndex + 1);
+}
+
+// src/core/time/formatter.ts
+function formatDateForGit(date) {
+  return date.toISOString().split("T")[0];
+}
+
+// src/core/time/period-identifier.ts
+function getWeekNumber(date) {
+  const d = new Date(Date.UTC(date.getFullYear(), date.getMonth(), date.getDate()));
+  const dayNum = d.getUTCDay() || 7;
+  d.setUTCDate(d.getUTCDate() + 4 - dayNum);
+  const yearStart = new Date(Date.UTC(d.getUTCFullYear(), 0, 1));
+  const weekNo = Math.ceil(((d.getTime() - yearStart.getTime()) / 864e5 + 1) / 7);
+  return `${d.getUTCFullYear()}-W${String(weekNo).padStart(2, "0")}`;
+}
+function getMonthIdentifier(date) {
+  const year = date.getFullYear();
+  const month = String(date.getMonth() + 1).padStart(2, "0");
+  return `${year}-${month}`;
+}
+function getPeriodIdentifier(date, periodUnit) {
+  switch (periodUnit) {
+    case "daily":
+      return formatDateForGit(date);
+    case "weekly":
+      return getWeekNumber(date);
+    case "monthly":
+      return getMonthIdentifier(date);
+  }
+}
+
+// src/core/time/validator.ts
+function validateTimeRange(since, until) {
+  if (since && until && since > until) {
+    throw new Error("--since date must be before --until date");
+  }
+  const now = /* @__PURE__ */ new Date();
+  if (since && since > now) {
+    throw new Error("--since date cannot be in the future");
+  }
+  if (until && until > now) {
+    throw new Error("--until date cannot be in the future");
+  }
+}
+
+// src/core/analysis/log-parsers/period-log-parser.ts
+function parsePeriodStats(log, periodUnit, authors) {
+  const grouped = /* @__PURE__ */ new Map();
+  const lines = log.split("\n");
+  let currentAuthor = "";
+  let currentPeriod = "";
+  const authorFilter = authors?.map((a) => a.toLowerCase());
+  for (const line of lines) {
+    const trimmedLine = line.trim();
+    if (trimmedLine.length === 0) {
+      continue;
+    }
+    if (trimmedLine.includes("	")) {
+      const parts = trimmedLine.split("	");
+      const insertions = parseInt(parts[0], 10) || 0;
+      const deletions = parseInt(parts[1], 10) || 0;
+      if (currentAuthor && currentPeriod) {
+        if (!grouped.has(currentPeriod)) {
+          grouped.set(currentPeriod, /* @__PURE__ */ new Map());
+        }
+        const periodMap = grouped.get(currentPeriod);
+        if (!periodMap.has(currentAuthor)) {
+          periodMap.set(currentAuthor, {
+            commits: 0,
+            insertions: 0,
+            deletions: 0,
+            filesTouched: 0
+          });
+        }
+        const stats = periodMap.get(currentAuthor);
+        stats.insertions += insertions;
+        stats.deletions += deletions;
+        stats.filesTouched++;
+      }
+    } else {
+      const parts = trimmedLine.split("|");
+      if (parts.length === 2) {
+        currentAuthor = parts[0];
+        const dateStr = parts[1];
+        const commitDate = new Date(dateStr);
+        if (authorFilter && !authorFilter.includes(currentAuthor.toLowerCase())) {
+          currentAuthor = "";
+          currentPeriod = "";
+          continue;
+        }
+        currentPeriod = getPeriodIdentifier(commitDate, periodUnit);
+        if (!grouped.has(currentPeriod)) {
+          grouped.set(currentPeriod, /* @__PURE__ */ new Map());
+        }
+        const periodMap = grouped.get(currentPeriod);
+        if (!periodMap.has(currentAuthor)) {
+          periodMap.set(currentAuthor, {
+            commits: 0,
+            insertions: 0,
+            deletions: 0,
+            filesTouched: 0
+          });
+        }
+        const stats = periodMap.get(currentAuthor);
+        stats.commits++;
+      }
+    }
+  }
+  return convertToSortedArray(grouped);
+}
+function convertToSortedArray(grouped) {
+  const result = [];
+  for (const [period, authorMap] of grouped.entries()) {
+    for (const [author, stats] of authorMap.entries()) {
+      result.push({ period, author, stats });
+    }
+  }
+  result.sort((a, b) => {
+    if (a.period !== b.period) {
+      return b.period.localeCompare(a.period);
+    }
+    const impactA = a.stats.insertions + a.stats.deletions;
+    const impactB = b.stats.insertions + b.stats.deletions;
+    return impactB - impactA;
+  });
+  return result;
+}
+
+// src/core/constants/analysis-mode.constants.ts
+var DEFAULT_MODE = "aggregate";
+var VALID_MODES = ["aggregate", "periodic", "ownership"];
+
+// src/core/constants/efficiency-thresholds.constants.ts
+var EFFICIENCY_THRESHOLDS = {
+  /** Below this is considered "Micro Commits" */
+  MICRO: 10,
+  /** Good range lower bound */
+  OPTIMAL_MIN: 30,
+  /** Good range upper bound */
+  OPTIMAL_MAX: 150,
+  /** Above this is considered "Huge" */
+  HUGE: 500
+};
+
+// src/core/constants/period-unit.constants.ts
+var VALID_PERIOD_UNITS = ["daily", "weekly", "monthly"];
+var DEFAULT_PERIOD_UNIT = "daily";
+
+// src/core/constants/index.ts
+var DEFAULT_DAYS = 30;
+
+// src/core/analysis/metrics/efficiency-metric.ts
+function getEfficiencyLabel(efficiency) {
+  if (efficiency < EFFICIENCY_THRESHOLDS.MICRO) {
+    return "\u{1F7E1} Micro";
+  }
+  if (efficiency >= EFFICIENCY_THRESHOLDS.OPTIMAL_MIN && efficiency <= EFFICIENCY_THRESHOLDS.OPTIMAL_MAX) {
+    return "\u2705 Optimal";
+  }
+  if (efficiency > EFFICIENCY_THRESHOLDS.HUGE) {
+    return "\u{1F6A8} Huge";
+  }
+  if (efficiency > EFFICIENCY_THRESHOLDS.OPTIMAL_MAX) {
+    return "\u26A0\uFE0F High Load";
+  }
+  return "\u{1F7E1} Small";
+}
+function classifyCommitSize(linesChanged) {
+  if (linesChanged <= EFFICIENCY_THRESHOLDS.MICRO) {
+    return "micro";
+  }
+  if (linesChanged < EFFICIENCY_THRESHOLDS.OPTIMAL_MIN) {
+    return "small";
+  }
+  if (linesChanged <= EFFICIENCY_THRESHOLDS.OPTIMAL_MAX) {
+    return "optimal";
+  }
+  if (linesChanged <= EFFICIENCY_THRESHOLDS.HUGE) {
+    return "high";
+  }
+  return "huge";
+}
+function analyzeAuthorEfficiency(authorName, commits) {
+  const authorCommits = commits.filter((c) => c.author === authorName);
+  const distribution = {
+    micro: 0,
+    small: 0,
+    optimal: 0,
+    high: 0,
+    huge: 0
+  };
+  if (authorCommits.length === 0) {
+    return {
+      author: authorName,
+      efficiency: 0,
+      efficiencyLabel: getEfficiencyLabel(0),
+      distribution,
+      totalCommits: 0
+    };
+  }
+  let totalDelta = 0;
+  for (const commit of authorCommits) {
+    const linesChanged = commit.insertions + commit.deletions;
+    totalDelta += linesChanged;
+    const bucket = classifyCommitSize(linesChanged);
+    distribution[bucket]++;
+  }
+  const efficiency = Math.round(totalDelta / authorCommits.length);
+  return {
+    author: authorName,
+    efficiency,
+    efficiencyLabel: getEfficiencyLabel(efficiency),
+    distribution,
+    totalCommits: authorCommits.length
+  };
+}
+function analyzeAllEfficiency(commits) {
+  const authors = /* @__PURE__ */ new Set();
+  for (const commit of commits) {
+    authors.add(commit.author);
+  }
+  const result = {};
+  for (const author of authors) {
+    result[author] = analyzeAuthorEfficiency(author, commits);
+  }
+  return result;
+}
+
+// src/core/config/query-builder.ts
+function buildLogQuery(opts) {
+  const query = {
+    branch: opts.branch
+  };
+  if (opts.timeRange.since || opts.timeRange.until || opts.timeRange.days) {
+    if (opts.timeRange.since) {
+      validateTimeRange(opts.timeRange.since, opts.timeRange.until);
+      query.since = formatDateForGit(opts.timeRange.since);
+    } else if (opts.timeRange.days) {
+      query.since = `${opts.timeRange.days} days ago`;
+    }
+    if (opts.timeRange.until) {
+      query.until = formatDateForGit(opts.timeRange.until);
+    }
+  }
+  return query;
+}
+
+// src/core/config/resolver.ts
+function resolveOptions(options) {
+  return {
+    timeRange: {
+      ...{ days: DEFAULT_DAYS },
+      ...options.timeRange
+    },
+    mode: options.mode ?? DEFAULT_MODE,
+    periodUnit: options.periodUnit ?? DEFAULT_PERIOD_UNIT,
+    branch: options.branch
+  };
+}
+
+// src/core/analysis/modes/aggregate-mode.ts
+var AggregateMode = class {
+  async handle(options, gitClient, originalOptions) {
+    const { since, until, branch } = buildLogQuery(options);
+    let aggregateLog = "";
+    let efficiencyLog = "";
+    try {
+      [aggregateLog, efficiencyLog] = await Promise.all([
+        gitClient.getAggregateLog(since, until, branch),
+        gitClient.getStabilityLog(since, until, branch)
+      ]);
+    } catch (error) {
+      if (error instanceof Error && error.message.includes("does not have any commits")) {
+        return {
+          stats: {},
+          efficiency: {}
+        };
+      }
+      throw error;
+    }
+    const stats = parseAggregateStats(aggregateLog, originalOptions.authors);
+    const commits = parseEfficiencyLog(efficiencyLog);
+    const authorFilter = originalOptions.authors?.map((a) => a.toLowerCase());
+    const filteredCommits = authorFilter ? commits.filter((c) => authorFilter.includes(c.author.toLowerCase())) : commits;
+    const efficiency = analyzeAllEfficiency(filteredCommits);
+    return {
+      stats,
+      efficiency
+    };
+  }
+};
+
+// src/core/analysis/modes/ownership-mode.ts
+var OwnershipMode = class {
+  async handle(options, gitClient, originalOptions) {
+    const { since, until, branch } = buildLogQuery(options);
+    let fileAuthorLog = "";
+    try {
+      fileAuthorLog = await gitClient.getFileAuthorLog(
+        since,
+        until,
+        branch,
+        originalOptions.directory
+      );
+    } catch (error) {
+      if (error instanceof Error && error.message.includes("does not have any commits")) {
+        return {
+          files: {},
+          directories: {},
+          authors: {}
+        };
+      }
+      throw error;
+    }
+    const result = parseOwnershipStats(fileAuthorLog, originalOptions.authors);
+    return result;
+  }
+};
+
+// src/core/analysis/modes/periodic-mode.ts
+var PeriodicMode = class {
+  async handle(options, gitClient, originalOptions) {
+    const { since, until, branch } = buildLogQuery(options);
+    let log = "";
+    try {
+      log = await gitClient.getPeriodicLog(since, until, branch);
+    } catch (error) {
+      if (error instanceof Error && error.message.includes("does not have any commits")) {
+        return [];
+      }
+      throw error;
+    }
+    return parsePeriodStats(log, options.periodUnit, originalOptions.authors);
+  }
+};
+
+// src/core/analysis/modes/mode-registry.ts
+var modeRegistry = /* @__PURE__ */ new Map([
+  ["aggregate", new AggregateMode()],
+  ["periodic", new PeriodicMode()],
+  ["ownership", new OwnershipMode()]
+]);
+
+// src/core/git/client.ts
+import { simpleGit as simpleGit2 } from "simple-git";
+var GitClientImpl = class {
+  git;
+  constructor(git) {
+    this.git = git ?? simpleGit2();
+  }
+  async isRepository() {
+    return this.git.checkIsRepo();
+  }
+  /**
+   * Get aggregate stats log (author name only)
+   * Used for total contribution analysis
+   */
+  async getAggregateLog(since, until, branch) {
+    const args = ["log", "--numstat", "--pretty=format:%aN"];
+    if (branch) args.push(branch);
+    if (since) args.push(`--since=${since}`);
+    if (until) args.push(`--until=${until}`);
+    return this.git.raw(args);
+  }
+  /**
+   * Get periodic stats log (author name with commit date)
+   * Used for time-based grouped analysis
+   */
+  async getPeriodicLog(since, until, branch) {
+    const args = ["log", "--numstat", "--pretty=format:%aN|%cd", "--date=iso"];
+    if (branch) args.push(branch);
+    if (since) args.push(`--since=${since}`);
+    if (until) args.push(`--until=${until}`);
+    return this.git.raw(args);
+  }
+  /**
+   * Get stability analysis log (author name with commit date and file changes)
+   * Used for efficiency and churn rate analysis
+   * Format: author|date followed by numstat lines
+   */
+  async getStabilityLog(since, until, branch) {
+    const args = ["log", "--numstat", "--pretty=format:%aN|%cd", "--date=iso", "--reverse"];
+    if (branch) args.push(branch);
+    if (since) args.push(`--since=${since}`);
+    if (until) args.push(`--until=${until}`);
+    return this.git.raw(args);
+  }
+  /**
+   * Get file-author log with numstat (author name followed by file changes with line counts)
+   * Used for ownership analysis
+   * Format: AUTHOR:<name>|DATE:<date> followed by numstat lines (insertions\tdeletions\tfilepath)
+   * The AUTHOR: prefix ensures author names are not confused with file paths
+   */
+  async getFileAuthorLog(since, until, branch, directory) {
+    const args = ["log", "--numstat", "--pretty=format:AUTHOR:%aN|DATE:%cd", "--date=iso"];
+    if (branch) args.push(branch);
+    if (since) {
+      if (since.includes("days ago") || since.includes("day ago")) {
+        args.push(`--since=${since}`);
+      } else {
+        args.push(`--since=${since}`);
+      }
+    }
+    if (until) {
+      if (until.includes("days ago") || until.includes("day ago")) {
+        args.push(`--until=${until}`);
+      } else {
+        args.push(`--until=${until}`);
+      }
+    }
+    if (directory) {
+      args.push("--");
+      args.push(directory);
+    }
+    return this.git.raw(args);
+  }
+  /**
+   * Get commit-files log (commit hash followed by file paths)
+   * Used for temporal coupling analysis (files changed together)
+   * Format: COMMIT:<hash> followed by file paths (one per line)
+   */
+  async getCommitFilesLog(since, until, branch) {
+    const args = ["log", "--name-only", "--pretty=format:COMMIT:%H"];
+    if (branch) args.push(branch);
+    if (since) args.push(`--since=${since}`);
+    if (until) args.push(`--until=${until}`);
+    return this.git.raw(args);
+  }
+};
+
+// src/core/git/client-factory.ts
+function createGitClient(git) {
+  return new GitClientImpl(git);
+}
+
+// src/core/analysis/orchestrator.ts
+async function analyzeContributions(options = {}, gitClient) {
+  const client = gitClient ?? createGitClient();
+  const isRepo = await client.isRepository();
+  if (!isRepo) {
+    throw new Error("Not a git repository. Please run this command in a git repository.");
+  }
+  const resolvedOpts = resolveOptions(options);
+  const mode = modeRegistry.get(resolvedOpts.mode);
+  if (!mode) {
+    throw new Error(`Unknown analysis mode: ${resolvedOpts.mode}`);
+  }
+  let result = await mode.handle(resolvedOpts, client, {
+    authors: options.authors,
+    directory: options.directory
+  });
+  if (resolvedOpts.mode === "ownership") {
+    const filePatternFilter = new FilePatternFilter(
+      options.excludePatterns,
+      options.respectGitignore !== false,
+      // default to true
+      process.cwd(),
+      void 0
+      // Don't filter by directory here since it's already filtered at Git log level
+    );
+    result = await filePatternFilter.filter(result);
+  } else {
+    const filterChain = new FilterChain();
+    if (options.minCommits !== void 0 && options.minCommits > 1) {
+      filterChain.addFilter(new MinCommitsFilter(options.minCommits));
+    }
+    if (!filterChain.isEmpty()) {
+      result = filterChain.apply(result);
+    }
+  }
+  return result;
+}
+
+// src/cli/commands/command-builder.ts
+import { Command } from "commander";
+function addCommonOptions(command) {
+  return command.option(
+    "-d, --days <number>",
+    `number of days to analyze (default: ${DEFAULT_DAYS})`,
+    (val) => parseInt(val, 10)
+  ).option("-s, --since <date>", "start date (YYYY-MM-DD)", (val) => new Date(val)).option("-u, --until <date>", "end date (YYYY-MM-DD)", (val) => new Date(val)).option(
+    "-a, --authors <names...>",
+    "filter by specific author names (can specify multiple). Enables deep-dive stability analysis"
+  ).option("-b, --branch <name>", "analyze specific branch (default: current branch)").option(
+    "-c, --min-commits <number>",
+    "minimum number of commits to include an author (default: 1)",
+    (val) => parseInt(val, 10)
+  );
+}
+function createCommand() {
+  const program = new Command();
+  program.name("gimpact").description("Visualize Git contribution impact by developer").version("0.1.0").option(
+    "-d, --days <number>",
+    `number of days to analyze (default: ${DEFAULT_DAYS})`,
+    (val) => parseInt(val, 10)
+  ).option("-s, --since <date>", "start date (YYYY-MM-DD)", (val) => new Date(val)).option("-u, --until <date>", "end date (YYYY-MM-DD)", (val) => new Date(val)).option(
+    "-m, --mode <type>",
+    `analysis mode: ${VALID_MODES.join(", ")} (default: aggregate)`,
+    "aggregate"
+  ).option(
+    "-p, --period-unit <type>",
+    `period unit for periodic mode: ${VALID_PERIOD_UNITS.join(", ")} (default: daily)`,
+    "daily"
+  ).option(
+    "-a, --authors <names...>",
+    "filter by specific author names (can specify multiple). Enables deep-dive stability analysis"
+  ).option("-b, --branch <name>", "analyze specific branch (default: current branch)").option(
+    "-c, --min-commits <number>",
+    "minimum number of commits to include an author (default: 1)",
+    (val) => parseInt(val, 10)
+  ).action(() => {
+  });
+  addCommonOptions(
+    program.command("summary").description("Show aggregate report with all analyses (default)")
+  ).action(() => {
+  });
+  addCommonOptions(program.command("daily").description("Show daily periodic report")).action(
+    () => {
+    }
+  );
+  addCommonOptions(program.command("weekly").description("Show weekly periodic report")).action(
+    () => {
+    }
+  );
+  addCommonOptions(program.command("monthly").description("Show monthly periodic report")).action(
+    () => {
+    }
+  );
+  addCommonOptions(
+    program.command("ownership").description("Show code ownership analysis (files, directories, authors)").option(
+      "--exclude-patterns <patterns...>",
+      'additional glob patterns to exclude from analysis (e.g., "**/*.lock" "**/dist/**")'
+    ).option(
+      "--no-respect-gitignore",
+      "include files that are ignored by .gitignore (default: respect .gitignore)"
+    ).option(
+      "--directory <path>",
+      'filter by directory path (only include files in this directory, e.g., "packages/cli/src")'
+    )
+  ).action(() => {
+  });
+  return program;
+}
+function parseArgs(program) {
+  program.parse(process.argv);
+  const args = program.args;
+  let subcommand = "summary";
+  if (args.length > 0 && args[0]) {
+    const validSubcommands = [
+      "summary",
+      "daily",
+      "weekly",
+      "monthly",
+      "ownership"
+    ];
+    if (validSubcommands.includes(args[0])) {
+      subcommand = args[0];
+    }
+  }
+  const subcommandCommand = subcommand !== "summary" ? program.commands.find((cmd) => cmd.name() === subcommand) : null;
+  const mainOpts = program.opts();
+  const subOpts = subcommandCommand ? subcommandCommand.opts() : {};
+  const opts = { ...mainOpts, ...subOpts };
+  return {
+    subcommand,
+    days: opts.days,
+    since: opts.since,
+    until: opts.until,
+    mode: opts.mode,
+    periodUnit: opts.periodUnit,
+    authors: opts.authors,
+    branch: opts.branch,
+    minCommits: opts.minCommits,
+    excludePatterns: opts.excludePatterns,
+    respectGitignore: opts.respectGitignore,
+    directory: opts.directory
+  };
+}
+
+// src/cli/commands/subcommand-registry.ts
+var subcommandToMode = {
+  summary: { mode: "aggregate" },
+  daily: { mode: "periodic", periodUnit: "daily" },
+  weekly: { mode: "periodic", periodUnit: "weekly" },
+  monthly: { mode: "periodic", periodUnit: "monthly" },
+  ownership: { mode: "ownership" }
+};
+
+// src/cli/adapters/options-adapter.ts
+function adaptToAnalyzerOptions(options) {
+  const subcommandConfig = subcommandToMode[options.subcommand];
+  const mode = subcommandConfig.mode;
+  const periodUnit = subcommandConfig.periodUnit ?? options.periodUnit;
+  const analyzerOptions = {
+    timeRange: {},
+    mode,
+    periodUnit,
+    branch: options.branch
+  };
+  if (options.authors && options.authors.length > 0) {
+    analyzerOptions.authors = options.authors;
+  }
+  if (options.since || options.until) {
+    if (options.since) {
+      analyzerOptions.timeRange.since = options.since;
+    }
+    if (options.until) {
+      analyzerOptions.timeRange.until = options.until;
+    }
+  } else if (options.days) {
+    analyzerOptions.timeRange.days = options.days;
+  } else {
+    analyzerOptions.timeRange.days = DEFAULT_DAYS;
+  }
+  if (options.minCommits !== void 0) {
+    analyzerOptions.minCommits = options.minCommits;
+  }
+  if (options.excludePatterns && options.excludePatterns.length > 0) {
+    analyzerOptions.excludePatterns = options.excludePatterns;
+  }
+  if (options.respectGitignore !== void 0) {
+    analyzerOptions.respectGitignore = options.respectGitignore;
+  }
+  if (options.directory) {
+    analyzerOptions.directory = options.directory;
+  }
+  return analyzerOptions;
+}
+
+// src/cli/adapters/time-range-formatter.ts
+function buildTimeRangeDescription(options) {
+  if (options.since && options.until) {
+    return `${options.since.toISOString().split("T")[0]} to ${options.until.toISOString().split("T")[0]}`;
+  }
+  if (options.since) {
+    return `Since ${options.since.toISOString().split("T")[0]}`;
+  }
+  if (options.until) {
+    return `Until ${options.until.toISOString().split("T")[0]}`;
+  }
+  const days = options.days ?? DEFAULT_DAYS;
+  return `Last ${days} day${days === 1 ? "" : "s"}`;
+}
+
+// src/cli/output/components/bar-renderer.ts
+function renderBar(count, maxCount, maxWidth) {
+  if (maxCount === 0) return "";
+  const width = Math.round(count / maxCount * maxWidth);
+  return "\u2593".repeat(width);
+}
+
+// src/cli/output/components/summary-row.ts
+import chalk from "chalk";
+function createSummaryRow(data) {
+  const row = [
+    chalk.bold(`\u{1F4CA} Total (${data.timeRangeDescription})`),
+    chalk.bold(chalk.cyan(data.totalCommits.toString())),
+    chalk.bold(chalk.green(`+${data.totalInsertions.toLocaleString()}`)),
+    chalk.bold(chalk.red(`-${data.totalDeletions.toLocaleString()}`))
+  ];
+  if (data.totalFiles !== void 0) {
+    row.push(chalk.bold(chalk.blue(data.totalFiles.toString())));
+  }
+  if (data.additionalInfo) {
+    row.push(chalk.bold(chalk.yellow(data.additionalInfo)));
+  }
+  return row;
+}
+
+// src/cli/output/components/table-builder.ts
+import Table from "cli-table3";
+function createTable(config) {
+  return new Table({
+    head: config.head,
+    colAligns: config.colAligns || [],
+    style: {
+      head: ["cyan"],
+      border: ["gray"]
+    }
+  });
+}
+
+// src/cli/output/printers/aggregate-printer.ts
+import chalk2 from "chalk";
+var AggregatePrinter = class {
+  print(result, timeRangeDescription) {
+    this.printAggregateStats(result.stats, timeRangeDescription);
+    this.printEfficiencyAnalysis(result.efficiency);
+  }
+  printAggregateStats(stats, timeRangeDescription) {
+    const sortedAuthors = Object.entries(stats).sort((a, b) => {
+      const impactA = a[1].insertions + a[1].deletions;
+      const impactB = b[1].insertions + b[1].deletions;
+      return impactB - impactA;
+    });
+    if (sortedAuthors.length === 0) {
+      console.log(chalk2.yellow(`
+\u26A0 No commits found in the specified time range.
+`));
+      return;
+    }
+    const table = createTable({
+      head: [
+        chalk2.bold("Author"),
+        chalk2.bold("Commits"),
+        chalk2.bold("Insertions"),
+        chalk2.bold("Deletions"),
+        chalk2.bold("Files")
+      ],
+      colAligns: ["left", "right", "right", "right", "right"]
+    });
+    const totalCommits = sortedAuthors.reduce((sum, [, data]) => sum + data.commits, 0);
+    const totalInsertions = sortedAuthors.reduce((sum, [, data]) => sum + data.insertions, 0);
+    const totalDeletions = sortedAuthors.reduce((sum, [, data]) => sum + data.deletions, 0);
+    const totalFiles = sortedAuthors.reduce((sum, [, data]) => sum + data.filesTouched, 0);
+    for (const [author, data] of sortedAuthors) {
+      table.push([
+        author,
+        chalk2.white(data.commits.toString()),
+        chalk2.green(`+${data.insertions.toLocaleString()}`),
+        chalk2.red(`-${data.deletions.toLocaleString()}`),
+        chalk2.blue(data.filesTouched.toString())
+      ]);
+    }
+    table.push(
+      createSummaryRow({
+        totalCommits,
+        totalInsertions,
+        totalDeletions,
+        totalFiles,
+        timeRangeDescription
+      })
+    );
+    console.log(`
+${table.toString()}
+`);
+  }
+  printEfficiencyAnalysis(efficiency) {
+    const authors = Object.keys(efficiency);
+    if (authors.length === 0) {
+      return;
+    }
+    const totalDist = {
+      micro: 0,
+      small: 0,
+      optimal: 0,
+      high: 0,
+      huge: 0
+    };
+    let totalCommits = 0;
+    let totalLines = 0;
+    for (const author of authors) {
+      const stats = efficiency[author];
+      totalDist.micro += stats.distribution.micro;
+      totalDist.small += stats.distribution.small;
+      totalDist.optimal += stats.distribution.optimal;
+      totalDist.high += stats.distribution.high;
+      totalDist.huge += stats.distribution.huge;
+      totalCommits += stats.totalCommits;
+      totalLines += stats.efficiency * stats.totalCommits;
+    }
+    const avgEfficiency = totalCommits > 0 ? Math.round(totalLines / totalCommits) : 0;
+    console.log(chalk2.bold.cyan("\u26A1 Commit Size Distribution (All Authors)"));
+    console.log(chalk2.dim(`   Average: ${avgEfficiency} lines/commit`));
+    console.log(chalk2.dim(`   Total: ${totalCommits} commits
+`));
+    const maxCount = Math.max(
+      totalDist.micro,
+      totalDist.small,
+      totalDist.optimal,
+      totalDist.high,
+      totalDist.huge
+    );
+    const maxBarWidth = 30;
+    const buckets = [
+      {
+        label: "Micro",
+        range: "0-10",
+        count: totalDist.micro,
+        indicator: "\u{1F7E1}",
+        color: chalk2.yellow
+      },
+      {
+        label: "Small",
+        range: "11-30",
+        count: totalDist.small,
+        indicator: "\u{1F7E1}",
+        color: chalk2.yellow
+      },
+      {
+        label: "Optimal",
+        range: "31-150",
+        count: totalDist.optimal,
+        indicator: "\u2705",
+        color: chalk2.green
+      },
+      {
+        label: "High",
+        range: "151-500",
+        count: totalDist.high,
+        indicator: "\u26A0\uFE0F",
+        color: chalk2.hex("#FFA500")
+      },
+      { label: "Huge", range: "500+", count: totalDist.huge, indicator: "\u{1F6A8}", color: chalk2.red }
+    ];
+    for (const bucket of buckets) {
+      const bar = renderBar(bucket.count, maxCount, maxBarWidth);
+      const paddedRange = bucket.range.padStart(7);
+      const countStr = bucket.count.toString().padStart(3);
+      console.log(
+        chalk2.gray(`   ${paddedRange}  `) + bucket.color(bar.padEnd(maxBarWidth)) + chalk2.gray(` ${countStr} `) + bucket.indicator
+      );
+    }
+    console.log("");
+  }
+};
+
+// src/cli/output/printers/ownership-printer.ts
+import chalk5 from "chalk";
+
+// src/cli/output/utils/ownership-formatter.ts
+import chalk4 from "chalk";
+
+// src/cli/output/utils/tree-formatter.ts
+import chalk3 from "chalk";
+function buildDirectoryTree(files) {
+  const root = {
+    name: ".",
+    path: ".",
+    type: "directory",
+    children: []
+  };
+  for (const [filePath, ownership] of Object.entries(files)) {
+    const parts = filePath.split("/").filter((p2) => p2.length > 0);
+    let current = root;
+    for (let i = 0; i < parts.length; i++) {
+      const part = parts[i];
+      const isFile = i === parts.length - 1;
+      const currentPath = parts.slice(0, i + 1).join("/");
+      let node = current.children.find((child) => child.name === part);
+      if (!node) {
+        node = {
+          name: part,
+          path: currentPath,
+          type: isFile ? "file" : "directory",
+          children: []
+        };
+        current.children.push(node);
+      }
+      if (isFile) {
+        node.owner = ownership.owner;
+        node.share = ownership.share;
+        node.lines = ownership.totalLines;
+        node.fileOwnership = ownership;
+        node.lastCommitDate = ownership.lastCommitDate;
+      }
+      current = node;
+    }
+  }
+  function sortNode(node) {
+    node.children.sort((a, b) => {
+      if (a.type !== b.type) {
+        return a.type === "directory" ? -1 : 1;
+      }
+      return a.name.localeCompare(b.name);
+    });
+    for (const child of node.children) {
+      sortNode(child);
+    }
+  }
+  sortNode(root);
+  return root;
+}
+function calculateDirectoryStats(node) {
+  if (node.type === "file") {
+    const owner = node.owner || "";
+    return {
+      totalFiles: 1,
+      totalLines: node.lines || 0,
+      ownerCounts: owner ? { [owner]: 1 } : {}
+    };
+  }
+  let totalFiles = 0;
+  let totalLines = 0;
+  const ownerCounts = {};
+  let latestCommitDate;
+  for (const child of node.children) {
+    const stats = calculateDirectoryStats(child);
+    totalFiles += stats.totalFiles;
+    totalLines += stats.totalLines;
+    for (const [owner, count] of Object.entries(stats.ownerCounts)) {
+      ownerCounts[owner] = (ownerCounts[owner] || 0) + count;
+    }
+    if (child.lastCommitDate) {
+      if (!latestCommitDate || child.lastCommitDate > latestCommitDate) {
+        latestCommitDate = child.lastCommitDate;
+      }
+    }
+  }
+  let primaryOwner = "";
+  let maxFiles = 0;
+  for (const [owner, count] of Object.entries(ownerCounts)) {
+    if (count > maxFiles) {
+      maxFiles = count;
+      primaryOwner = owner;
+    }
+  }
+  node.owner = primaryOwner;
+  node.share = totalFiles > 0 ? Math.round(maxFiles / totalFiles * 100) : 0;
+  node.files = maxFiles;
+  node.totalFiles = totalFiles;
+  node.lines = totalLines;
+  node.lastCommitDate = latestCommitDate;
+  return { totalFiles, totalLines, ownerCounts };
+}
+
+// src/cli/output/utils/ownership-formatter.ts
+function formatNumber(num) {
+  if (num >= 1e3) {
+    const k = num / 1e3;
+    return k % 1 === 0 ? `${k}k` : `${k.toFixed(1)}k`;
+  }
+  return num.toString();
+}
+function getDensityIndicator(share) {
+  if (share > 80) {
+    return "\u2588";
+  }
+  if (share > 50) {
+    return "\u2593";
+  }
+  return "\u2591";
+}
+function calculateColumnWidths(terminalWidth) {
+  const minTerminalWidth = 80;
+  const effectiveWidth = Math.max(terminalWidth || minTerminalWidth, minTerminalWidth);
+  const treeConnectorSpace = 12;
+  const pathWidth = Math.min(40, Math.floor((effectiveWidth - treeConnectorSpace) * 0.4));
+  const ownerWidth = 20;
+  const shareWidth = 6;
+  const linesWidth = 8;
+  return {
+    pathWidth,
+    ownerWidth,
+    shareWidth,
+    linesWidth
+  };
+}
+function stripAnsi(str) {
+  return str.replace(/\x1b\[[0-9;]*m/g, "");
+}
+function padRight(str, width) {
+  const visibleLength = stripAnsi(str).length;
+  const padding = Math.max(0, width - visibleLength);
+  return str + " ".repeat(padding);
+}
+function padLeft(str, width) {
+  const visibleLength = stripAnsi(str).length;
+  const padding = Math.max(0, width - visibleLength);
+  return " ".repeat(padding) + str;
+}
+function isTestOrSnapshotPath(path) {
+  const lowerPath = path.toLowerCase();
+  return lowerPath.includes("__snapshots__") || lowerPath.includes(".snap") || lowerPath.includes(".test.") || lowerPath.includes(".spec.") || lowerPath.includes("__tests__") || lowerPath.includes("__test__") || lowerPath.includes("/test/") || lowerPath.includes("/tests/") || lowerPath.includes("/spec/") || lowerPath.includes("/specs/");
+}
+function shouldCollapseTrivialFolder(node) {
+  return (node.lines || 0) < 100;
+}
+function flattenSingleChildPaths(node) {
+  const flattened = {
+    ...node,
+    children: []
+  };
+  for (const child of node.children) {
+    if (child.type === "directory" && child.children.length === 1) {
+      const singleChild = child.children[0];
+      if (singleChild.type === "directory") {
+        const flattenedChild = flattenSingleChildPaths(singleChild);
+        flattenedChild.name = `${child.name}/${singleChild.name}`;
+        flattenedChild.path = singleChild.path;
+        flattened.children.push(flattenedChild);
+        continue;
+      }
+    }
+    const processedChild = flattenSingleChildPaths(child);
+    flattened.children.push(processedChild);
+  }
+  return flattened;
+}
+function calculateKnowledgeConcentrationAreas(node, concentrationAreas, directory) {
+  if (node.type === "directory" && node.owner && node.share === 100 && (node.lines || 0) >= 500) {
+    if (directory) {
+      const normalizedDir = directory.replace(/^\.\//, "").replace(/\/$/, "");
+      const normalizedPath = node.path.replace(/^\.\//, "");
+      if (normalizedPath !== normalizedDir && !normalizedPath.startsWith(`${normalizedDir}/`) && !normalizedDir.startsWith(`${normalizedPath}/`)) {
+      } else {
+        concentrationAreas.push({
+          path: node.path,
+          owner: node.owner,
+          share: node.share,
+          lines: node.lines || 0
+        });
+      }
+    } else {
+      concentrationAreas.push({
+        path: node.path,
+        owner: node.owner,
+        share: node.share,
+        lines: node.lines || 0
+      });
+    }
+  }
+  for (const child of node.children) {
+    if (child.type === "directory") {
+      calculateKnowledgeConcentrationAreas(child, concentrationAreas, directory);
+    }
+  }
+}
+function formatRelativeTime(date) {
+  const now = /* @__PURE__ */ new Date();
+  const diffMs = now.getTime() - date.getTime();
+  const diffDays = Math.floor(diffMs / (1e3 * 60 * 60 * 24));
+  if (diffDays === 0) {
+    return "today";
+  }
+  if (diffDays === 1) {
+    return "1d ago";
+  }
+  if (diffDays < 7) {
+    return `${diffDays}d ago`;
+  }
+  if (diffDays < 30) {
+    const weeks = Math.floor(diffDays / 7);
+    return `${weeks}w ago`;
+  }
+  if (diffDays < 365) {
+    const months = Math.floor(diffDays / 30);
+    return `${months}mo ago`;
+  }
+  const years = Math.floor(diffDays / 365);
+  return `${years}y ago`;
+}
+function printKnowledgeConcentration(tree, columnWidths, directory) {
+  const concentrationAreas = [];
+  calculateKnowledgeConcentrationAreas(tree, concentrationAreas, directory);
+  if (concentrationAreas.length === 0) {
+    return;
+  }
+  concentrationAreas.sort((a, b) => b.lines - a.lines);
+  const topConcentrations = concentrationAreas.slice(0, 3);
+  console.log(chalk4.bold.cyan("\u{1F4CA} Top Knowledge Concentration (Density)"));
+  for (let i = 0; i < topConcentrations.length; i++) {
+    const concentration = topConcentrations[i];
+    const displayPath = concentration.path.replace(/^\.\//, "");
+    const maxPathWidth = columnWidths.pathWidth - 5;
+    const truncatedPath = displayPath.length > maxPathWidth ? `${displayPath.slice(0, maxPathWidth - 3)}...` : displayPath;
+    const pathDisplay = padRight(`\u{1F4C2} ${truncatedPath}`, columnWidths.pathWidth);
+    const ownerDisplay = padRight(chalk4.bold(concentration.owner), columnWidths.ownerWidth);
+    const shareDisplay = padLeft(`${concentration.share}%`, columnWidths.shareWidth);
+    const linesDisplay = padLeft(formatNumber(concentration.lines), columnWidths.linesWidth);
+    console.log(
+      `  ${i + 1}. ${pathDisplay} ${chalk4.red.bold("\u2588")} ${ownerDisplay} ${chalk4.dim(`[${shareDisplay} / ${linesDisplay} lines]`)}`
+    );
+  }
+  console.log("");
+}
+function printHeader(columnWidths) {
+  const pathHeader = padRight("DIRECTORY / FOLDER", columnWidths.pathWidth);
+  const ownerHeader = padRight("OWNER", columnWidths.ownerWidth);
+  const shareHeader = padRight("SHARE", columnWidths.shareWidth);
+  const linesHeader = padRight("LINES", columnWidths.linesWidth);
+  console.log(`${pathHeader} ${ownerHeader} ${shareHeader} ${linesHeader}`);
+  const separator = "\u2500".repeat(
+    columnWidths.pathWidth + columnWidths.ownerWidth + columnWidths.shareWidth + columnWidths.linesWidth + 3
+  );
+  console.log(chalk4.dim(`\u2500\u2500\u2500\u252C${separator}`));
+}
+function formatDirectoryName(name, maxWidth) {
+  const displayName = name.startsWith(".") ? name : name;
+  const fullName = `\u{1F4C2} ${displayName}/`;
+  const visibleLength = stripAnsi(fullName).length;
+  if (visibleLength <= maxWidth) {
+    return fullName;
+  }
+  const truncated = `${fullName.slice(0, maxWidth - 3)}...`;
+  return truncated;
+}
+function printOwnershipTree(files, options = {}) {
+  const { maxDepth = Infinity, directory } = options;
+  const tree = buildDirectoryTree(files);
+  calculateDirectoryStats(tree);
+  const flattenedTree = flattenSingleChildPaths(tree);
+  calculateDirectoryStats(flattenedTree);
+  const terminalWidth = process.stdout.columns || 80;
+  const columnWidths = calculateColumnWidths(terminalWidth);
+  console.log(chalk4.bold.cyan("\u{1F4C1} Logic Distribution (Knowledge base)"));
+  console.log(
+    chalk4.dim("   Density: ") + chalk4.red.bold("\u2588 Solo (>80%)") + chalk4.dim(" | ") + chalk4.yellow.bold("\u2593 Focused (>50%)") + chalk4.dim(" | ") + chalk4.green.bold("\u2591 Distributed")
+  );
+  console.log("");
+  printKnowledgeConcentration(flattenedTree, columnWidths, directory);
+  printHeader(columnWidths);
+  function printNode(node, prefix, isLast, depth, isRoot = false) {
+    if (depth > maxDepth) {
+      return;
+    }
+    if (isRoot) {
+      let children = node.children.filter((child) => child.type === "directory");
+      if (directory) {
+        const normalizedDir = directory.replace(/^\.\//, "").replace(/\/$/, "");
+        const dirParts = normalizedDir.split("/");
+        const firstDirPart = dirParts[0];
+        children = children.filter((child) => {
+          const normalizedPath = child.path.replace(/^\.\//, "");
+          return normalizedPath === firstDirPart || normalizedPath.startsWith(`${firstDirPart}/`);
+        });
+      }
+      const processedChildren = [];
+      let trivialGroup = [];
+      for (let i = 0; i < children.length; i++) {
+        const child = children[i];
+        const isTrivial = shouldCollapseTrivialFolder(child);
+        if (isTrivial) {
+          trivialGroup.push(child);
+        } else {
+          if (trivialGroup.length > 0) {
+            const trivialPrefix = "";
+            console.log(
+              trivialPrefix + chalk4.dim(
+                `\u2514\u2500\u2500 [+ ${trivialGroup.length} minor folder${trivialGroup.length !== 1 ? "s" : ""}]`
+              )
+            );
+            trivialGroup = [];
+          }
+          processedChildren.push(child);
+        }
+      }
+      if (trivialGroup.length > 0) {
+        console.log(
+          chalk4.dim(
+            `\u2514\u2500\u2500 [+ ${trivialGroup.length} minor folder${trivialGroup.length !== 1 ? "s" : ""}]`
+          )
+        );
+      }
+      for (let i = 0; i < processedChildren.length; i++) {
+        const child = processedChildren[i];
+        const isLastChild = i === processedChildren.length - 1;
+        printNode(child, "", isLastChild, depth + 1, false);
+      }
+      return;
+    }
+    if (node.type === "directory") {
+      if (directory) {
+        const normalizedDir = directory.replace(/^\.\//, "").replace(/\/$/, "");
+        const normalizedPath = node.path.replace(/^\.\//, "");
+        if (normalizedPath !== normalizedDir && !normalizedPath.startsWith(`${normalizedDir}/`) && !normalizedDir.startsWith(`${normalizedPath}/`)) {
+          return;
+        }
+      }
+      const isTrivial = shouldCollapseTrivialFolder(node);
+      if (!isTrivial) {
+        if (node.owner && node.share !== void 0 && node.lines !== void 0) {
+          const densityIndicator = getDensityIndicator(node.share);
+          const displayName = formatDirectoryName(
+            node.name,
+            columnWidths.pathWidth - prefix.length - 4
+          );
+          const pathDisplay = padRight(
+            prefix + (isLast ? "\u2514\u2500\u2500 " : "\u251C\u2500\u2500 ") + displayName,
+            columnWidths.pathWidth
+          );
+          let ownerDisplay = padRight(chalk4.bold(node.owner), columnWidths.ownerWidth);
+          let shareDisplay = padLeft(`${node.share}%`, columnWidths.shareWidth);
+          let linesDisplay = padLeft(formatNumber(node.lines), columnWidths.linesWidth);
+          let dateDisplay = "";
+          if (node.lastCommitDate) {
+            const relativeTime = formatRelativeTime(node.lastCommitDate);
+            dateDisplay = ` / ${relativeTime}`;
+          }
+          if (directory && isTestOrSnapshotPath(node.path)) {
+            ownerDisplay = padRight(chalk4.gray(node.owner), columnWidths.ownerWidth);
+            shareDisplay = padLeft(chalk4.gray(`${node.share}%`), columnWidths.shareWidth);
+            linesDisplay = padLeft(chalk4.gray(formatNumber(node.lines)), columnWidths.linesWidth);
+            const grayPathDisplay = padRight(
+              chalk4.gray(prefix + (isLast ? "\u2514\u2500\u2500 " : "\u251C\u2500\u2500 ") + displayName),
+              columnWidths.pathWidth
+            );
+            console.log(
+              `${grayPathDisplay} ${ownerDisplay} ${shareDisplay} ${linesDisplay}${chalk4.gray(dateDisplay)}`
+            );
+          } else {
+            let coloredIndicator = densityIndicator;
+            if (node.share > 80) {
+              coloredIndicator = chalk4.red.bold(densityIndicator);
+            } else if (node.share > 50) {
+              coloredIndicator = chalk4.yellow.bold(densityIndicator);
+            } else {
+              coloredIndicator = chalk4.green.bold(densityIndicator);
+            }
+            console.log(
+              `${pathDisplay} ${coloredIndicator} ${ownerDisplay} ${shareDisplay} ${linesDisplay}${chalk4.dim(dateDisplay)}`
+            );
+          }
+        }
+        if (node.children.length > 0) {
+          const childPrefix = prefix + (isLast ? "    " : "\u2502   ");
+          let visibleChildren = node.children.filter((child) => child.type === "directory");
+          if (directory) {
+            const normalizedDir = directory.replace(/^\.\//, "").replace(/\/$/, "");
+            visibleChildren = visibleChildren.filter((child) => {
+              const normalizedPath = child.path.replace(/^\.\//, "");
+              return normalizedPath === normalizedDir || normalizedPath.startsWith(`${normalizedDir}/`) || normalizedDir.startsWith(`${normalizedPath}/`);
+            });
+          }
+          const processedChildren = [];
+          let trivialGroup = [];
+          for (let i = 0; i < visibleChildren.length; i++) {
+            const child = visibleChildren[i];
+            const isTrivialChild = shouldCollapseTrivialFolder(child);
+            if (isTrivialChild) {
+              trivialGroup.push(child);
+            } else {
+              if (trivialGroup.length > 0) {
+                console.log(
+                  childPrefix + chalk4.dim(
+                    `\u2514\u2500\u2500 [+ ${trivialGroup.length} minor folder${trivialGroup.length !== 1 ? "s" : ""}]`
+                  )
+                );
+                trivialGroup = [];
+              }
+              processedChildren.push(child);
+            }
+          }
+          if (trivialGroup.length > 0) {
+            console.log(
+              childPrefix + chalk4.dim(
+                `\u2514\u2500\u2500 [+ ${trivialGroup.length} minor folder${trivialGroup.length !== 1 ? "s" : ""}]`
+              )
+            );
+          }
+          for (let i = 0; i < processedChildren.length; i++) {
+            const child = processedChildren[i];
+            const isLastChild = i === processedChildren.length - 1;
+            printNode(child, childPrefix, isLastChild, depth + 1, false);
+          }
+          if (node.children.some((child) => child.type === "file")) {
+            const fileCount = node.children.filter((child) => child.type === "file").length;
+            console.log(
+              childPrefix + chalk4.dim(`\u2514\u2500\u2500 ... ${fileCount} file${fileCount !== 1 ? "s" : ""}`)
+            );
+          }
+        }
+      }
+    }
+  }
+  printNode(flattenedTree, "", true, 0, true);
+  console.log("");
+}
+
+// src/cli/output/printers/ownership-printer.ts
+var OwnershipPrinter = class {
+  directory;
+  constructor(directory) {
+    this.directory = directory;
+  }
+  print(result, _timeRangeDescription) {
+    this.printFileOwnershipTree(result.files);
+  }
+  printFileOwnershipTree(files) {
+    const fileEntries = Object.values(files);
+    if (fileEntries.length === 0) {
+      console.log(chalk5.yellow(`
+\u26A0 No files found in the specified time range.
+`));
+      return;
+    }
+    const filesRecord = {};
+    for (const file of fileEntries) {
+      filesRecord[file.file] = file;
+    }
+    printOwnershipTree(filesRecord, {
+      maxDepth: 10,
+      directory: this.directory
+    });
+  }
+};
+
+// src/cli/output/printers/period-printer.ts
+import chalk6 from "chalk";
+var PeriodPrinter = class {
+  constructor(periodUnit) {
+    this.periodUnit = periodUnit;
+  }
+  print(result, timeRangeDescription) {
+    if (result.length === 0) {
+      console.log(chalk6.yellow(`
+\u26A0 No commits found in the specified time range.
+`));
+      return;
+    }
+    const periodLabel = this.periodUnit === "daily" ? "Date" : this.periodUnit === "weekly" ? "Week" : "Month";
+    const table = createTable({
+      head: [
+        chalk6.bold(periodLabel),
+        chalk6.bold("Author"),
+        chalk6.bold("Commits"),
+        chalk6.bold("Insertions"),
+        chalk6.bold("Deletions"),
+        chalk6.bold("Total Impact")
+      ],
+      colAligns: ["left", "left", "right", "right", "right", "right"]
+    });
+    const uniqueAuthors = new Set(result.map((s) => s.author)).size;
+    const uniquePeriods = new Set(result.map((s) => s.period)).size;
+    const totalCommits = result.reduce((sum, s) => sum + s.stats.commits, 0);
+    const totalInsertions = result.reduce((sum, s) => sum + s.stats.insertions, 0);
+    const totalDeletions = result.reduce((sum, s) => sum + s.stats.deletions, 0);
+    for (const item of result) {
+      const totalImpact = item.stats.insertions + item.stats.deletions;
+      table.push([
+        chalk6.cyan(item.period),
+        item.author,
+        chalk6.white(item.stats.commits.toString()),
+        chalk6.green(`+${item.stats.insertions.toLocaleString()}`),
+        chalk6.red(`-${item.stats.deletions.toLocaleString()}`),
+        chalk6.bold(totalImpact.toLocaleString())
+      ]);
+    }
+    table.push(
+      createSummaryRow({
+        totalCommits,
+        totalInsertions,
+        totalDeletions,
+        timeRangeDescription,
+        additionalInfo: `${uniqueAuthors} authors / ${uniquePeriods} ${periodLabel.toLowerCase()}s`
+      })
+    );
+    console.log(`
+${table.toString()}
+`);
+  }
+};
+
+// src/cli/output/printers/printer-factory.ts
+function createPrinter(mode, periodUnit = "daily", directory) {
+  switch (mode) {
+    case "aggregate":
+      return new AggregatePrinter();
+    case "periodic":
+      return new PeriodPrinter(periodUnit);
+    case "ownership":
+      return new OwnershipPrinter(directory);
+    default:
+      throw new Error(`Unknown analysis mode: ${mode}`);
+  }
+}
+
+// src/cli/validators/cli-options-validator.ts
+function validateCLIOptions(options) {
+  if (!VALID_MODES.includes(options.mode)) {
+    return {
+      success: false,
+      error: `Invalid --mode value: ${options.mode}. Must be one of: ${VALID_MODES.join(", ")}`
+    };
+  }
+  if (options.periodUnit && !VALID_PERIOD_UNITS.includes(options.periodUnit)) {
+    return {
+      success: false,
+      error: `Invalid --period-unit value: ${options.periodUnit}. Must be one of: ${VALID_PERIOD_UNITS.join(", ")}`
+    };
+  }
+  if (options.since || options.until) {
+    try {
+      validateTimeRange(options.since, options.until);
+    } catch (error) {
+      return {
+        success: false,
+        error: error instanceof Error ? error.message : "Invalid time range"
+      };
+    }
+  }
+  if (options.days !== void 0 && options.days <= 0) {
+    return {
+      success: false,
+      error: "--days must be a positive number"
+    };
+  }
+  return { success: true };
+}
+
+// src/cli/index.ts
+async function main() {
+  const program = createCommand();
+  const rawOptions = parseArgs(program);
+  const options = {
+    ...rawOptions,
+    mode: rawOptions.mode || "aggregate"
+  };
+  const validationResult = validateCLIOptions(options);
+  if (!validationResult.success) {
+    console.error(chalk7.red(validationResult.error));
+    process.exit(1);
+  }
+  const analyzerOptions = adaptToAnalyzerOptions(options);
+  const timeRangeDescription = buildTimeRangeDescription(options);
+  p.intro(chalk7.bgCyan(chalk7.black(" gimpact ")));
+  const s = p.spinner();
+  s.start("Analyzing Git repository...");
+  try {
+    const stats = await analyzeContributions(analyzerOptions);
+    s.stop("Analysis complete!");
+    const printer = createPrinter(
+      analyzerOptions.mode || "aggregate",
+      analyzerOptions.periodUnit,
+      analyzerOptions.directory
+    );
+    printer.print(stats, timeRangeDescription);
+    p.outro(chalk7.green("\u2713 Done!"));
+  } catch (error) {
+    s.stop("Analysis failed");
+    p.cancel(chalk7.red(error instanceof Error ? error.message : "Unknown error occurred"));
+    process.exit(1);
+  }
+}
+main().catch((error) => {
+  console.error(chalk7.red("Fatal error:"), error);
+  process.exit(1);
+});