gitfamiliar 0.1.0

package/dist/chunk-DW2PHZVZ.js

@@ -0,0 +1,867 @@
+// src/git/client.ts
+import simpleGit from "simple-git";
+var GitClient = class {
+  git;
+  repoPath;
+  constructor(repoPath) {
+    this.repoPath = repoPath;
+    this.git = simpleGit(repoPath);
+  }
+  async isRepo() {
+    return this.git.checkIsRepo();
+  }
+  async getRepoRoot() {
+    return (await this.git.revparse(["--show-toplevel"])).trim();
+  }
+  async getRepoName() {
+    const root = await this.getRepoRoot();
+    return root.split("/").pop() || "unknown";
+  }
+  async listFiles() {
+    const result = await this.git.raw(["ls-files"]);
+    return result.trim().split("\n").filter(Boolean);
+  }
+  async getUserName() {
+    return (await this.git.raw(["config", "user.name"])).trim();
+  }
+  async getUserEmail() {
+    return (await this.git.raw(["config", "user.email"])).trim();
+  }
+  async getLog(args) {
+    return this.git.raw(["log", ...args]);
+  }
+  async blame(filePath, options = []) {
+    return this.git.raw(["blame", ...options, "--", filePath]);
+  }
+  async diff(args) {
+    return this.git.raw(["diff", ...args]);
+  }
+  async show(args) {
+    return this.git.raw(["show", ...args]);
+  }
+  async raw(args) {
+    return this.git.raw(args);
+  }
+  async getRemoteUrl() {
+    try {
+      const result = await this.git.raw(["remote", "get-url", "origin"]);
+      return result.trim();
+    } catch {
+      return null;
+    }
+  }
+};
+
+// src/git/identity.ts
+async function resolveUser(gitClient, userFlag) {
+  if (userFlag) {
+    if (userFlag.includes("@")) {
+      return { name: userFlag, email: userFlag };
+    }
+    return { name: userFlag, email: userFlag };
+  }
+  const name = await gitClient.getUserName();
+  const email = await gitClient.getUserEmail();
+  if (!name && !email) {
+    throw new Error(
+      "Could not determine git user. Set git config user.name/user.email or use --user flag."
+    );
+  }
+  return { name, email };
+}
+function getAuthorArgs(user) {
+  return ["--author", user.email || user.name];
+}
+function matchesUser(authorName, authorEmail, user) {
+  if (user.email && authorEmail) {
+    if (authorEmail.toLowerCase() === user.email.toLowerCase()) return true;
+  }
+  if (user.name && authorName) {
+    if (authorName.toLowerCase() === user.name.toLowerCase()) return true;
+  }
+  return false;
+}
+
+// src/filter/ignore.ts
+import ignore from "ignore";
+import { readFileSync, existsSync } from "fs";
+import { join } from "path";
+
+// src/filter/defaults.ts
+var DEFAULT_IGNORE_PATTERNS = `# Lock files
+package-lock.json
+yarn.lock
+pnpm-lock.yaml
+Gemfile.lock
+poetry.lock
+Cargo.lock
+composer.lock
+
+# Auto-generated
+*.generated.*
+*.min.js
+*.min.css
+*.map
+
+# Build outputs (if git-tracked)
+dist/
+build/
+.next/
+
+# Config that rarely needs understanding
+.eslintrc*
+.prettierrc*
+tsconfig.json
+`;
+
+// src/filter/ignore.ts
+function createFilter(repoRoot) {
+  const ig = ignore();
+  const ignorePath = join(repoRoot, ".gitfamiliarignore");
+  if (existsSync(ignorePath)) {
+    const content = readFileSync(ignorePath, "utf-8");
+    ig.add(content);
+  } else {
+    ig.add(DEFAULT_IGNORE_PATTERNS);
+  }
+  return (filePath) => !ig.ignores(filePath);
+}
+
+// src/utils/line-count.ts
+import { readFileSync as readFileSync2 } from "fs";
+import { join as join2 } from "path";
+function countLines(repoRoot, filePath) {
+  try {
+    const fullPath = join2(repoRoot, filePath);
+    const content = readFileSync2(fullPath, "utf-8");
+    if (content.length === 0) return 0;
+    return content.split("\n").length;
+  } catch {
+    return 0;
+  }
+}
+
+// src/core/file-tree.ts
+async function buildFileTree(gitClient, filter) {
+  const repoRoot = await gitClient.getRepoRoot();
+  const allFiles = await gitClient.listFiles();
+  const filteredFiles = allFiles.filter(filter);
+  const fileScores = filteredFiles.map((filePath) => ({
+    type: "file",
+    path: filePath,
+    lines: countLines(repoRoot, filePath),
+    score: 0
+  }));
+  return buildTreeFromFiles(fileScores);
+}
+function buildTreeFromFiles(files) {
+  const root = {
+    type: "folder",
+    path: "",
+    lines: 0,
+    score: 0,
+    fileCount: 0,
+    children: []
+  };
+  const folderMap = /* @__PURE__ */ new Map();
+  folderMap.set("", root);
+  for (const file of files) {
+    const parts = file.path.split("/");
+    let currentPath = "";
+    for (let i = 0; i < parts.length - 1; i++) {
+      const parentPath2 = currentPath;
+      currentPath = currentPath ? `${currentPath}/${parts[i]}` : parts[i];
+      if (!folderMap.has(currentPath)) {
+        const folder = {
+          type: "folder",
+          path: currentPath,
+          lines: 0,
+          score: 0,
+          fileCount: 0,
+          children: []
+        };
+        folderMap.set(currentPath, folder);
+        const parent2 = folderMap.get(parentPath2);
+        parent2.children.push(folder);
+      }
+    }
+    const parentPath = parts.length > 1 ? parts.slice(0, -1).join("/") : "";
+    const parent = folderMap.get(parentPath);
+    parent.children.push(file);
+  }
+  computeAggregates(root);
+  return root;
+}
+function computeAggregates(node) {
+  let totalLines = 0;
+  let totalFiles = 0;
+  for (const child of node.children) {
+    if (child.type === "file") {
+      totalLines += child.lines;
+      totalFiles += 1;
+    } else {
+      computeAggregates(child);
+      totalLines += child.lines;
+      totalFiles += child.fileCount;
+    }
+  }
+  node.lines = totalLines;
+  node.fileCount = totalFiles;
+}
+function walkFiles(node, visitor) {
+  if (node.type === "file") {
+    visitor(node);
+  } else {
+    for (const child of node.children) {
+      walkFiles(child, visitor);
+    }
+  }
+}
+function recomputeFolderScores(node, mode) {
+  let readCount = 0;
+  let totalFiles = 0;
+  let weightedScore = 0;
+  let totalLines = 0;
+  for (const child of node.children) {
+    if (child.type === "file") {
+      totalFiles += 1;
+      totalLines += child.lines;
+      weightedScore += child.score * child.lines;
+      if (child.score > 0) readCount += 1;
+    } else {
+      recomputeFolderScores(child, mode);
+      totalFiles += child.fileCount;
+      totalLines += child.lines;
+      weightedScore += child.score * child.lines;
+      readCount += child.readCount || 0;
+    }
+  }
+  node.fileCount = totalFiles;
+  node.readCount = readCount;
+  if (mode === "binary") {
+    node.score = totalFiles > 0 ? readCount / totalFiles : 0;
+  } else {
+    node.score = totalLines > 0 ? weightedScore / totalLines : 0;
+  }
+}
+
+// src/git/log.ts
+async function getFilesCommittedByUser(gitClient, user) {
+  const files = /* @__PURE__ */ new Set();
+  const queries = [];
+  if (user.email) {
+    queries.push(["--author", user.email]);
+  }
+  if (user.name && user.name !== user.email) {
+    queries.push(["--author", user.name]);
+  }
+  for (const authorArgs of queries) {
+    try {
+      const output = await gitClient.getLog([
+        ...authorArgs,
+        "--name-only",
+        "--pretty=format:",
+        "--all"
+      ]);
+      for (const line of output.split("\n")) {
+        const trimmed = line.trim();
+        if (trimmed) {
+          files.add(trimmed);
+        }
+      }
+    } catch {
+    }
+  }
+  return files;
+}
+async function getDetailedCommits(gitClient, user, filePath) {
+  const commits = [];
+  try {
+    const output = await gitClient.getLog([
+      ...getAuthorArgs(user),
+      "--numstat",
+      "--pretty=format:%H|%aI",
+      "--",
+      filePath
+    ]);
+    const lines = output.trim().split("\n");
+    let currentHash = "";
+    let currentDate = /* @__PURE__ */ new Date();
+    for (const line of lines) {
+      const trimmed = line.trim();
+      if (!trimmed) continue;
+      if (trimmed.includes("|")) {
+        const parts = trimmed.split("|");
+        currentHash = parts[0];
+        currentDate = new Date(parts[1]);
+      } else {
+        const statMatch = trimmed.match(/^(\d+|-)\t(\d+|-)\t(.+)$/);
+        if (statMatch && statMatch[3] === filePath) {
+          const added = statMatch[1] === "-" ? 0 : parseInt(statMatch[1], 10);
+          const deleted = statMatch[2] === "-" ? 0 : parseInt(statMatch[2], 10);
+          let fileSizeAtCommit = 1;
+          try {
+            const content = await gitClient.show([
+              `${currentHash}:${filePath}`
+            ]);
+            fileSizeAtCommit = Math.max(1, content.split("\n").length);
+          } catch {
+            fileSizeAtCommit = Math.max(1, added);
+          }
+          commits.push({
+            hash: currentHash,
+            date: currentDate,
+            addedLines: added,
+            deletedLines: deleted,
+            fileSizeAtCommit
+          });
+        }
+      }
+    }
+  } catch {
+  }
+  return commits;
+}
+async function getLastCommitDate(gitClient, user, filePath) {
+  try {
+    const output = await gitClient.getLog([
+      ...getAuthorArgs(user),
+      "-1",
+      "--pretty=format:%aI",
+      "--",
+      filePath
+    ]);
+    const trimmed = output.trim();
+    if (trimmed) {
+      return new Date(trimmed);
+    }
+  } catch {
+  }
+  return null;
+}
+
+// src/scoring/binary.ts
+function scoreBinary(tree, writtenFiles, reviewedFiles, filterMode, expiredFiles) {
+  walkFiles(tree, (file) => {
+    const isWritten = writtenFiles.has(file.path);
+    const isReviewed = reviewedFiles.has(file.path) && !writtenFiles.has(file.path);
+    const isExpired2 = expiredFiles?.has(file.path) ?? false;
+    file.isWritten = isWritten;
+    file.isReviewed = isReviewed;
+    file.isExpired = isExpired2;
+    if (isExpired2) {
+      file.score = 0;
+      return;
+    }
+    switch (filterMode) {
+      case "written":
+        file.score = isWritten ? 1 : 0;
+        break;
+      case "reviewed":
+        file.score = isReviewed ? 1 : 0;
+        break;
+      case "all":
+      default:
+        file.score = isWritten || isReviewed ? 1 : 0;
+        break;
+    }
+  });
+  recomputeFolderScores(tree, "binary");
+}
+
+// src/git/blame.ts
+async function getBlameData(gitClient, filePath) {
+  const authorMap = /* @__PURE__ */ new Map();
+  let totalLines = 0;
+  try {
+    const output = await gitClient.blame(filePath, ["-w", "--porcelain"]);
+    const lines = output.split("\n");
+    let currentName = "";
+    let currentEmail = "";
+    for (const line of lines) {
+      if (line.startsWith("author ")) {
+        currentName = line.slice("author ".length).trim();
+      } else if (line.startsWith("author-mail ")) {
+        currentEmail = line.slice("author-mail ".length).replace(/[<>]/g, "").trim();
+      } else if (line.startsWith("	")) {
+        if (currentEmail || currentName) {
+          totalLines++;
+          const key = `${currentEmail}|${currentName}`;
+          const existing = authorMap.get(key);
+          if (existing) {
+            existing.lines++;
+          } else {
+            authorMap.set(key, {
+              email: currentEmail,
+              name: currentName,
+              lines: 1
+            });
+          }
+        }
+      }
+    }
+  } catch {
+  }
+  return { entries: Array.from(authorMap.values()), totalLines };
+}
+async function getUserBlameLines(gitClient, filePath, user) {
+  const { entries, totalLines } = await getBlameData(gitClient, filePath);
+  let userLines = 0;
+  for (const entry of entries) {
+    if (matchesUser(entry.name, entry.email, user)) {
+      userLines += entry.lines;
+    }
+  }
+  return { userLines, totalLines };
+}
+
+// src/utils/batch.ts
+var DEFAULT_BATCH_SIZE = 10;
+async function processBatch(items, fn, batchSize = DEFAULT_BATCH_SIZE) {
+  for (let i = 0; i < items.length; i += batchSize) {
+    const batch = items.slice(i, i + batchSize);
+    await Promise.all(batch.map(fn));
+  }
+}
+
+// src/scoring/authorship.ts
+async function scoreAuthorship(tree, gitClient, user) {
+  const files = [];
+  walkFiles(tree, (file) => {
+    files.push({
+      path: file.path,
+      setScore: (s) => {
+        file.score = s;
+        file.blameScore = s;
+      }
+    });
+  });
+  await processBatch(files, async ({ path, setScore }) => {
+    const { userLines, totalLines } = await getUserBlameLines(
+      gitClient,
+      path,
+      user
+    );
+    setScore(totalLines > 0 ? userLines / totalLines : 0);
+  });
+  recomputeFolderScores(tree, "continuous");
+}
+
+// src/scoring/review-coverage.ts
+function scoreReviewCoverage(tree, reviewedFiles) {
+  walkFiles(tree, (file) => {
+    file.isReviewed = reviewedFiles.has(file.path);
+    file.score = file.isReviewed ? 1 : 0;
+  });
+  recomputeFolderScores(tree, "binary");
+}
+
+// src/utils/math.ts
+function sigmoid(x, k = 0.3) {
+  if (x <= 0) return 0;
+  return x / (x + k);
+}
+function recencyDecay(days, halfLife = 180) {
+  if (days <= 0) return 1;
+  const lambda = Math.LN2 / halfLife;
+  return Math.exp(-lambda * days);
+}
+function scopeFactor(filesInPR, attentionThreshold = 20) {
+  if (filesInPR <= 0) return 1;
+  return Math.min(1, attentionThreshold / filesInPR);
+}
+function normalizedDiff(added, deleted, fileSize) {
+  if (fileSize <= 0) return 0;
+  return (added + 0.5 * deleted) / fileSize;
+}
+function daysBetween(a, b) {
+  const ms = Math.abs(b.getTime() - a.getTime());
+  return ms / (1e3 * 60 * 60 * 24);
+}
+
+// src/scoring/weighted.ts
+var REVIEW_BASE_WEIGHTS = {
+  approved: 0.3,
+  commented: 0.15,
+  changes_requested: 0.35
+};
+function calculateCommitScore(commits, now) {
+  let raw = 0;
+  for (const c of commits) {
+    const nd = normalizedDiff(c.addedLines, c.deletedLines, c.fileSizeAtCommit);
+    raw += sigmoid(nd) * recencyDecay(daysBetween(now, c.date));
+  }
+  return Math.min(1, raw);
+}
+function calculateReviewScore(reviews, now) {
+  if (!reviews) return 0;
+  let raw = 0;
+  for (const r of reviews) {
+    const baseWeight = REVIEW_BASE_WEIGHTS[r.type] || 0.15;
+    raw += baseWeight * scopeFactor(r.filesInPR) * recencyDecay(daysBetween(now, r.date));
+  }
+  return Math.min(1, raw);
+}
+async function scoreWeighted(tree, gitClient, user, weights, reviewData, now) {
+  const currentDate = now || /* @__PURE__ */ new Date();
+  const files = [];
+  walkFiles(tree, (file) => {
+    files.push({
+      path: file.path,
+      setScores: (b, c, r, total) => {
+        file.blameScore = b;
+        file.commitScore = c;
+        file.reviewScore = r;
+        file.score = total;
+      }
+    });
+  });
+  await processBatch(files, async ({ path, setScores }) => {
+    const { userLines, totalLines } = await getUserBlameLines(
+      gitClient,
+      path,
+      user
+    );
+    const blameScore = totalLines > 0 ? userLines / totalLines : 0;
+    const commitScore = calculateCommitScore(
+      await getDetailedCommits(gitClient, user, path),
+      currentDate
+    );
+    const reviewScore = calculateReviewScore(
+      reviewData?.get(path),
+      currentDate
+    );
+    const total = weights.blame * blameScore + weights.commit * commitScore + weights.review * reviewScore;
+    setScores(blameScore, commitScore, reviewScore, total);
+  });
+  recomputeFolderScores(tree, "continuous");
+}
+
+// src/git/diff.ts
+async function getChangeRatio(gitClient, filePath, sinceCommit) {
+  try {
+    const output = await gitClient.diff([
+      "--numstat",
+      `${sinceCommit}..HEAD`,
+      "--",
+      filePath
+    ]);
+    const trimmed = output.trim();
+    if (!trimmed) return 0;
+    const match = trimmed.match(/^(\d+|-)\t(\d+|-)\t/);
+    if (!match) return 0;
+    const added = match[1] === "-" ? 0 : parseInt(match[1], 10);
+    const deleted = match[2] === "-" ? 0 : parseInt(match[2], 10);
+    const changedLines = added + deleted;
+    const currentContent = await gitClient.show([`HEAD:${filePath}`]);
+    const currentLines = Math.max(1, currentContent.split("\n").length);
+    return changedLines / currentLines;
+  } catch {
+    return 0;
+  }
+}
+async function getLastTouchCommit(gitClient, filePath, userEmail) {
+  try {
+    const output = await gitClient.getLog([
+      "--author",
+      userEmail,
+      "-1",
+      "--pretty=format:%H",
+      "--",
+      filePath
+    ]);
+    const hash = output.trim();
+    return hash || null;
+  } catch {
+    return null;
+  }
+}
+
+// src/scoring/expiration.ts
+function parseExpirationConfig(input) {
+  if (!input || input === "never") {
+    return { policy: "never" };
+  }
+  if (input.startsWith("time:")) {
+    const duration = parseDays(input.slice("time:".length));
+    return { policy: "time", duration };
+  }
+  if (input.startsWith("change:")) {
+    const threshold = parsePercentage(input.slice("change:".length));
+    return { policy: "change", threshold };
+  }
+  if (input.startsWith("combined:")) {
+    const parts = input.slice("combined:".length).split(":");
+    const duration = parseDays(parts[0]);
+    const threshold = parts[1] ? parsePercentage(parts[1]) : 0.5;
+    return { policy: "combined", duration, threshold };
+  }
+  return { policy: "never" };
+}
+function parseDays(s) {
+  const match = s.match(/^(\d+)d$/);
+  if (!match)
+    throw new Error(
+      `Invalid duration format: "${s}". Expected format like "180d".`
+    );
+  return parseInt(match[1], 10);
+}
+function parsePercentage(s) {
+  const match = s.match(/^(\d+)%$/);
+  if (!match)
+    throw new Error(
+      `Invalid percentage format: "${s}". Expected format like "50%".`
+    );
+  return parseInt(match[1], 10) / 100;
+}
+async function isExpired(gitClient, filePath, user, config, now) {
+  if (config.policy === "never") return false;
+  const currentDate = now || /* @__PURE__ */ new Date();
+  const email = user.email || user.name;
+  if (config.policy === "time" || config.policy === "combined") {
+    const lastTouch = await getLastCommitDate(gitClient, user, filePath);
+    if (lastTouch && config.duration) {
+      const daysSince = (currentDate.getTime() - lastTouch.getTime()) / (1e3 * 60 * 60 * 24);
+      if (daysSince > config.duration) return true;
+    }
+  }
+  if (config.policy === "change" || config.policy === "combined") {
+    const lastCommit = await getLastTouchCommit(gitClient, filePath, email);
+    if (lastCommit && config.threshold) {
+      const ratio = await getChangeRatio(gitClient, filePath, lastCommit);
+      if (ratio > config.threshold) return true;
+    }
+  }
+  return false;
+}
+async function getExpiredFiles(gitClient, files, user, config) {
+  if (config.policy === "never") return /* @__PURE__ */ new Set();
+  const expiredSet = /* @__PURE__ */ new Set();
+  await processBatch(files, async (filePath) => {
+    if (await isExpired(gitClient, filePath, user, config)) {
+      expiredSet.add(filePath);
+    }
+  });
+  return expiredSet;
+}
+
+// src/github/client.ts
+var GitHubClient = class {
+  token;
+  baseUrl = "https://api.github.com";
+  constructor(token) {
+    this.token = token;
+  }
+  async fetch(path) {
+    const url = `${this.baseUrl}${path}`;
+    const response = await fetch(url, {
+      headers: {
+        Authorization: `Bearer ${this.token}`,
+        Accept: "application/vnd.github.v3+json",
+        "User-Agent": "gitfamiliar"
+      }
+    });
+    if (!response.ok) {
+      if (response.status === 403) {
+        throw new Error("GitHub API rate limit exceeded. Please wait or use a token with higher limits.");
+      }
+      throw new Error(`GitHub API error: ${response.status} ${response.statusText}`);
+    }
+    return response.json();
+  }
+  /**
+   * Parse owner/repo from a git remote URL.
+   */
+  static parseRemoteUrl(url) {
+    let match = url.match(/github\.com[:/]([^/]+)\/([^/.]+)(\.git)?$/);
+    if (match) {
+      return { owner: match[1], repo: match[2] };
+    }
+    return null;
+  }
+  /**
+   * Get all files reviewed by a user across all PRs they reviewed.
+   */
+  async getReviewedFiles(owner, repo, username) {
+    const reviewedFiles = /* @__PURE__ */ new Map();
+    let page = 1;
+    const perPage = 100;
+    while (true) {
+      const searchResult = await this.fetch(
+        `/search/issues?q=type:pr+repo:${owner}/${repo}+reviewed-by:${username}&per_page=${perPage}&page=${page}`
+      );
+      if (!searchResult.items || searchResult.items.length === 0) break;
+      for (const item of searchResult.items) {
+        const prNumber = item.number;
+        const reviews = await this.fetch(
+          `/repos/${owner}/${repo}/pulls/${prNumber}/reviews`
+        );
+        const userReviews = reviews.filter(
+          (r) => r.user?.login?.toLowerCase() === username.toLowerCase()
+        );
+        if (userReviews.length === 0) continue;
+        const prFiles = await this.fetch(
+          `/repos/${owner}/${repo}/pulls/${prNumber}/files?per_page=100`
+        );
+        const fileCount = prFiles.length;
+        for (const review of userReviews) {
+          const reviewType = mapReviewState(review.state);
+          const reviewDate = new Date(review.submitted_at);
+          for (const prFile of prFiles) {
+            const filePath = prFile.filename;
+            const info = {
+              date: reviewDate,
+              type: reviewType,
+              filesInPR: fileCount
+            };
+            if (reviewedFiles.has(filePath)) {
+              reviewedFiles.get(filePath).push(info);
+            } else {
+              reviewedFiles.set(filePath, [info]);
+            }
+          }
+        }
+      }
+      if (searchResult.items.length < perPage) break;
+      page++;
+    }
+    return reviewedFiles;
+  }
+};
+function mapReviewState(state) {
+  switch (state.toUpperCase()) {
+    case "APPROVED":
+      return "approved";
+    case "CHANGES_REQUESTED":
+      return "changes_requested";
+    default:
+      return "commented";
+  }
+}
+
+// src/github/auth.ts
+import { execSync } from "child_process";
+function resolveGitHubToken() {
+  if (process.env.GITHUB_TOKEN) return process.env.GITHUB_TOKEN;
+  if (process.env.GH_TOKEN) return process.env.GH_TOKEN;
+  try {
+    const token = execSync("gh auth token", { encoding: "utf-8", stdio: ["pipe", "pipe", "pipe"] }).trim();
+    if (token) return token;
+  } catch {
+  }
+  return null;
+}
+
+// src/github/reviews.ts
+async function fetchReviewData(gitClient, username) {
+  const token = resolveGitHubToken();
+  if (!token) return null;
+  const remoteUrl = await gitClient.getRemoteUrl();
+  if (!remoteUrl) return null;
+  const parsed = GitHubClient.parseRemoteUrl(remoteUrl);
+  if (!parsed) return null;
+  if (!username) return null;
+  const ghUsername = username;
+  try {
+    const githubClient = new GitHubClient(token);
+    const reviewedFiles = await githubClient.getReviewedFiles(
+      parsed.owner,
+      parsed.repo,
+      ghUsername
+    );
+    const reviewedFileSet = new Set(reviewedFiles.keys());
+    return { reviewedFiles, reviewedFileSet };
+  } catch {
+    return null;
+  }
+}
+
+// src/core/familiarity.ts
+async function computeFamiliarity(options) {
+  const gitClient = new GitClient(options.repoPath);
+  if (!await gitClient.isRepo()) {
+    throw new Error(`"${options.repoPath}" is not a git repository.`);
+  }
+  const repoRoot = await gitClient.getRepoRoot();
+  const repoName = await gitClient.getRepoName();
+  const user = await resolveUser(gitClient, options.user);
+  const filter = createFilter(repoRoot);
+  const tree = await buildFileTree(gitClient, filter);
+  const writtenFiles = await getFilesCommittedByUser(gitClient, user);
+  let reviewData;
+  let reviewedFileSet = /* @__PURE__ */ new Set();
+  if (options.mode !== "authorship") {
+    const reviewResult = await fetchReviewData(gitClient, options.user);
+    if (reviewResult) {
+      reviewData = reviewResult.reviewedFiles;
+      reviewedFileSet = reviewResult.reviewedFileSet;
+    }
+  }
+  let expiredFiles;
+  if (options.expiration.policy !== "never") {
+    const allFiles = [];
+    walkFiles(tree, (f) => allFiles.push(f.path));
+    expiredFiles = await getExpiredFiles(
+      gitClient,
+      allFiles,
+      user,
+      options.expiration
+    );
+  }
+  switch (options.mode) {
+    case "binary":
+      scoreBinary(
+        tree,
+        writtenFiles,
+        reviewedFileSet,
+        options.filter,
+        expiredFiles
+      );
+      break;
+    case "authorship":
+      await scoreAuthorship(tree, gitClient, user);
+      break;
+    case "review-coverage":
+      if (reviewedFileSet.size === 0) {
+        console.error(
+          "Warning: No review data available. Set GITHUB_TOKEN or use --user with your GitHub username."
+        );
+      }
+      scoreReviewCoverage(tree, reviewedFileSet);
+      break;
+    case "weighted":
+      await scoreWeighted(tree, gitClient, user, options.weights, reviewData);
+      break;
+  }
+  return {
+    tree,
+    repoName,
+    userName: user.name || user.email,
+    mode: options.mode,
+    ...computeSummary(tree, writtenFiles, reviewedFileSet),
+    totalFiles: tree.fileCount
+  };
+}
+function computeSummary(tree, writtenFiles, reviewedFileSet) {
+  let writtenOnly = 0;
+  let reviewedOnly = 0;
+  let both = 0;
+  walkFiles(tree, (file) => {
+    const w = writtenFiles.has(file.path);
+    const r = reviewedFileSet.has(file.path);
+    if (w && r) both++;
+    else if (w) writtenOnly++;
+    else if (r) reviewedOnly++;
+  });
+  return {
+    writtenCount: writtenOnly + both,
+    reviewedCount: reviewedOnly + both,
+    bothCount: both
+  };
+}
+
+export {
+  parseExpirationConfig,
+  computeFamiliarity
+};
+//# sourceMappingURL=chunk-DW2PHZVZ.js.map