@eduardbar/drift 0.9.1 → 1.1.0

package/src/git/blame.ts

@@ -0,0 +1,279 @@
+// drift-ignore-file
+import * as fs from 'node:fs'
+import * as path from 'node:path'
+import type { SourceFile } from 'ts-morph'
+import type { FileReport, DriftConfig, BlameAttribution, DriftBlameReport } from '../types.js'
+import { assertGitRepo, execGit, analyzeFilePath } from './helpers.js'
+import { buildReport } from '../reporter.js'
+import { RULE_WEIGHTS } from '../analyzer.js'
+
+interface GitBlameEntry {
+  hash: string
+  author: string
+  email: string
+  line: string
+}
+
+function parseGitBlame(blameOutput: string): GitBlameEntry[] {
+  const entries: GitBlameEntry[] = []
+  const lines = blameOutput.split('\n')
+  let i = 0
+
+  while (i < lines.length) {
+    const headerLine = lines[i]
+    if (!headerLine || headerLine.trim() === '') { i++; continue }
+
+    // Porcelain blame format: first line is "<hash> <orig-line> <final-line> [<num-lines>]"
+    const headerMatch = headerLine.match(/^([0-9a-f]{40})\s/)
+    if (!headerMatch) { i++; continue }
+
+    const hash = headerMatch[1]!
+    let author = ''
+    let email = ''
+    let codeLine = ''
+    i++
+
+    while (i < lines.length && !lines[i]!.match(/^[0-9a-f]{40}\s/)) {
+      const l = lines[i]!
+      if (l.startsWith('author ')) author = l.slice(7).trim()
+      else if (l.startsWith('author-mail ')) email = l.slice(12).replace(/[<>]/g, '').trim()
+      else if (l.startsWith('\t')) codeLine = l.slice(1)
+      i++
+    }
+
+    entries.push({ hash, author, email, line: codeLine })
+  }
+
+  return entries
+}
+
+export class BlameAnalyzer {
+  private readonly projectPath: string
+  private readonly config: DriftConfig | undefined
+  private readonly analyzeProjectFn: (targetPath: string, config?: DriftConfig) => FileReport[]
+  private readonly analyzeFileFn: (sf: SourceFile) => FileReport
+
+  constructor(
+    projectPath: string,
+    analyzeProjectFn: (targetPath: string, config?: DriftConfig) => FileReport[],
+    analyzeFileFn: (sf: SourceFile) => FileReport,
+    config?: DriftConfig,
+  ) {
+    this.projectPath = projectPath
+    this.analyzeProjectFn = analyzeProjectFn
+    this.analyzeFileFn = analyzeFileFn
+    this.config = config
+  }
+
+  /** Blame a single file: returns per-author attribution. */
+  static async analyzeFileBlame(
+    filePath: string,
+    analyzeFileFn: (sf: SourceFile) => FileReport,
+  ): Promise<BlameAttribution[]> {
+    const dir = path.dirname(filePath)
+    assertGitRepo(dir)
+
+    const blameOutput = execGit(`git blame --porcelain "${filePath}"`, dir)
+    const entries = parseGitBlame(blameOutput)
+
+    // Analyse issues in the file
+    const report = analyzeFilePath(filePath, analyzeFileFn)
+
+    // Map line numbers of issues to authors
+    const issuesByLine = new Map<number, number>()
+    for (const issue of report.issues) {
+      issuesByLine.set(issue.line, (issuesByLine.get(issue.line) ?? 0) + 1)
+    }
+
+    // Aggregate by author
+    const byAuthor = new Map<string, BlameAttribution>()
+    entries.forEach((entry, idx) => {
+      const key = entry.email || entry.author
+      if (!byAuthor.has(key)) {
+        byAuthor.set(key, {
+          author: entry.author,
+          email: entry.email,
+          commits: 0,
+          linesChanged: 0,
+          issuesIntroduced: 0,
+          avgScoreImpact: 0,
+        })
+      }
+      const attr = byAuthor.get(key)!
+      attr.linesChanged++
+      const lineNum = idx + 1
+      if (issuesByLine.has(lineNum)) {
+        attr.issuesIntroduced += issuesByLine.get(lineNum)!
+      }
+    })
+
+    // Count unique commits per author
+    const commitsByAuthor = new Map<string, Set<string>>()
+    for (const entry of entries) {
+      const key = entry.email || entry.author
+      if (!commitsByAuthor.has(key)) commitsByAuthor.set(key, new Set())
+      commitsByAuthor.get(key)!.add(entry.hash)
+    }
+
+    const total = entries.length || 1
+    const results: BlameAttribution[] = []
+    for (const [key, attr] of byAuthor) {
+      attr.commits = commitsByAuthor.get(key)?.size ?? 0
+      attr.avgScoreImpact = (attr.linesChanged / total) * report.score
+      results.push(attr)
+    }
+
+    return results.sort((a, b) => b.issuesIntroduced - a.issuesIntroduced)
+  }
+
+  /** Blame for a specific rule across all files in targetPath. */
+  static async analyzeRuleBlame(
+    rule: string,
+    targetPath: string,
+    analyzeFileFn: (sf: SourceFile) => FileReport,
+  ): Promise<BlameAttribution[]> {
+    assertGitRepo(targetPath)
+
+    const tsFiles = fs
+      .readdirSync(targetPath, { recursive: true, encoding: 'utf8' })
+      .filter((f): f is string => (f.endsWith('.ts') || f.endsWith('.tsx') || f.endsWith('.js') || f.endsWith('.jsx')) && !f.includes('node_modules') && !f.endsWith('.d.ts'))
+      .map(f => path.join(targetPath, f))
+      
+
+    const combined = new Map<string, BlameAttribution>()
+    const commitsByAuthor = new Map<string, Set<string>>()
+
+    for (const file of tsFiles) {
+      let blameEntries: GitBlameEntry[] = []
+      try {
+        const blameOutput = execGit(`git blame --porcelain "${file}"`, targetPath)
+        blameEntries = parseGitBlame(blameOutput)
+      } catch { continue }
+
+      const report = analyzeFilePath(file, analyzeFileFn)
+      const issuesByLine = new Map<number, number>()
+      for (const issue of report.issues) {
+        issuesByLine.set(issue.line, (issuesByLine.get(issue.line) ?? 0) + 1)
+      }
+
+      blameEntries.forEach((entry, idx) => {
+        const key = entry.email || entry.author
+        if (!combined.has(key)) {
+          combined.set(key, {
+            author: entry.author,
+            email: entry.email,
+            commits: 0,
+            linesChanged: 0,
+            issuesIntroduced: 0,
+            avgScoreImpact: 0,
+          })
+          commitsByAuthor.set(key, new Set())
+        }
+        const attr = combined.get(key)!
+        attr.linesChanged++
+        commitsByAuthor.get(key)!.add(entry.hash)
+        const lineNum = idx + 1
+        if (issuesByLine.has(lineNum)) {
+          attr.issuesIntroduced += issuesByLine.get(lineNum)!
+          attr.avgScoreImpact += report.score * (1 / (blameEntries.length || 1))
+        }
+      })
+    }
+
+    for (const [key, attr] of combined) {
+      attr.commits = commitsByAuthor.get(key)?.size ?? 0
+    }
+
+    return Array.from(combined.values()).sort((a, b) => b.issuesIntroduced - a.issuesIntroduced)
+  }
+
+  /** Overall blame across all files and rules. */
+  static async analyzeOverallBlame(
+    targetPath: string,
+    analyzeFileFn: (sf: SourceFile) => FileReport,
+  ): Promise<BlameAttribution[]> {
+    assertGitRepo(targetPath)
+
+    const tsFiles = fs
+      .readdirSync(targetPath, { recursive: true, encoding: 'utf8' })
+      .filter((f): f is string => (f.endsWith('.ts') || f.endsWith('.tsx') || f.endsWith('.js') || f.endsWith('.jsx')) && !f.includes('node_modules') && !f.endsWith('.d.ts'))
+      .map(f => path.join(targetPath, f))
+
+    const combined = new Map<string, BlameAttribution>()
+    const commitsByAuthor = new Map<string, Set<string>>()
+
+    for (const file of tsFiles) {
+      let blameEntries: GitBlameEntry[] = []
+      try {
+        const blameOutput = execGit(`git blame --porcelain "${file}"`, targetPath)
+        blameEntries = parseGitBlame(blameOutput)
+      } catch { continue }
+
+      const report = analyzeFilePath(file, analyzeFileFn)
+      const issuesByLine = new Map<number, number>()
+      for (const issue of report.issues) {
+        issuesByLine.set(issue.line, (issuesByLine.get(issue.line) ?? 0) + 1)
+      }
+
+      blameEntries.forEach((entry, idx) => {
+        const key = entry.email || entry.author
+        if (!combined.has(key)) {
+          combined.set(key, {
+            author: entry.author,
+            email: entry.email,
+            commits: 0,
+            linesChanged: 0,
+            issuesIntroduced: 0,
+            avgScoreImpact: 0,
+          })
+          commitsByAuthor.set(key, new Set())
+        }
+        const attr = combined.get(key)!
+        attr.linesChanged++
+        commitsByAuthor.get(key)!.add(entry.hash)
+        const lineNum = idx + 1
+        if (issuesByLine.has(lineNum)) {
+          attr.issuesIntroduced += issuesByLine.get(lineNum)!
+          attr.avgScoreImpact += report.score * (1 / (blameEntries.length || 1))
+        }
+      })
+    }
+
+    for (const [key, attr] of combined) {
+      attr.commits = commitsByAuthor.get(key)?.size ?? 0
+    }
+
+    return Array.from(combined.values()).sort((a, b) => b.issuesIntroduced - a.issuesIntroduced)
+  }
+
+  // --- Instance method -------------------------------------------------------
+
+  async analyzeBlame(options: {
+    target?: 'file' | 'rule' | 'overall'
+    top?: number
+    filePath?: string
+    rule?: string
+  }): Promise<DriftBlameReport> {
+    assertGitRepo(this.projectPath)
+
+    let blame: BlameAttribution[] = []
+    const mode = options.target ?? 'overall'
+
+    if (mode === 'file' && options.filePath) {
+      blame = await BlameAnalyzer.analyzeFileBlame(options.filePath, this.analyzeFileFn)
+    } else if (mode === 'rule' && options.rule) {
+      blame = await BlameAnalyzer.analyzeRuleBlame(options.rule, this.projectPath, this.analyzeFileFn)
+    } else {
+      blame = await BlameAnalyzer.analyzeOverallBlame(this.projectPath, this.analyzeFileFn)
+    }
+
+    if (options.top) {
+      blame = blame.slice(0, options.top)
+    }
+
+    const currentFiles = this.analyzeProjectFn(this.projectPath, this.config)
+    const baseReport = buildReport(this.projectPath, currentFiles)
+
+    return { ...baseReport, blame }
+  }
+}

package/src/git/helpers.ts

@@ -0,0 +1,198 @@
+// drift-ignore-file
+import * as fs from 'node:fs'
+import * as path from 'node:path'
+import * as os from 'node:os'
+import * as crypto from 'node:crypto'
+import { execSync } from 'node:child_process'
+import { Project } from 'ts-morph'
+import type { SourceFile } from 'ts-morph'
+import type { FileReport, DriftConfig, HistoricalAnalysis } from '../types.js'
+
+/**
+ * Analyse a file given its absolute path string.
+ * Accepts analyzeFile as a parameter to avoid circular dependency.
+ */
+export function analyzeFilePath(
+  filePath: string,
+  analyzeFile: (sf: SourceFile) => FileReport,
+): FileReport {
+  const proj = new Project({
+    skipAddingFilesFromTsConfig: true,
+    compilerOptions: { allowJs: true },
+  })
+  const sf = proj.addSourceFileAtPath(filePath)
+  return analyzeFile(sf)
+}
+
+/**
+ * Execute a git command synchronously and return stdout.
+ * Throws a descriptive error if the command fails or git is not available.
+ */
+export function execGit(cmd: string, cwd: string): string {
+  try {
+    return execSync(cmd, { cwd, encoding: 'utf8', stdio: ['pipe', 'pipe', 'pipe'] }).trim()
+  } catch (err) {
+    const msg = err instanceof Error ? err.message : String(err)
+    throw new Error(`Git command failed: ${cmd}\n${msg}`)
+  }
+}
+
+/**
+ * Verify the given directory is a git repository.
+ * Throws if git is not available or the directory is not a repo.
+ */
+export function assertGitRepo(cwd: string): void {
+  try {
+    execGit('git rev-parse --is-inside-work-tree', cwd)
+  } catch {
+    throw new Error(`Directory is not a git repository: ${cwd}`)
+  }
+}
+
+/**
+ * Analyse a single file as it existed at a given commit hash.
+ * Writes the blob to a temp file, runs analyzeFile, then cleans up.
+ */
+export async function analyzeFileAtCommit( // drift-ignore
+  filePath: string,
+  commitHash: string,
+  projectRoot: string,
+  analyzeFile: (sf: SourceFile) => FileReport,
+): Promise<FileReport> {
+  const relPath = path.relative(projectRoot, filePath).replace(/\\/g, '/')
+  const blob = execGit(`git show ${commitHash}:${relPath}`, projectRoot)
+
+  const tmpFile = path.join(os.tmpdir(), `drift-${crypto.randomBytes(8).toString('hex')}.ts`)
+  try {
+    fs.writeFileSync(tmpFile, blob, 'utf8')
+    const report = analyzeFilePath(tmpFile, analyzeFile)
+    // Replace temp path with original for readable output
+    return { ...report, path: filePath }
+  } finally {
+    try { fs.unlinkSync(tmpFile) } catch { /* ignore cleanup errors */ } // drift-ignore
+  }
+}
+
+/**
+ * Analyse ALL TypeScript files in the project snapshot at a given commit.
+ * Uses `git ls-tree` to enumerate every file in the tree, writes them to a
+ * temp directory, then runs `analyzeProject` on that full snapshot.
+ */
+export async function analyzeSingleCommit( // drift-ignore
+  commitHash: string,
+  targetPath: string,
+  analyzeProject: (targetPath: string, config?: DriftConfig) => FileReport[],
+  config?: DriftConfig,
+): Promise<HistoricalAnalysis> {
+  // 1. Commit metadata
+  const meta = execGit(
+    `git show --no-patch --format="%H|%aI|%an|%s" ${commitHash}`,
+    targetPath,
+  )
+  const [hash, dateStr, author, ...msgParts] = meta.split('|')
+  const message = msgParts.join('|').trim()
+  const commitDate = new Date(dateStr ?? '')
+
+  // 2. All .ts/.tsx files tracked at this commit (no diffs, full tree)
+  const allFiles = execGit(
+    `git ls-tree -r ${commitHash} --name-only`,
+    targetPath,
+  )
+    .split('\n')
+    .filter(
+      f =>
+        (f.endsWith('.ts') || f.endsWith('.tsx') || f.endsWith('.js') || f.endsWith('.jsx')) &&
+        !f.endsWith('.d.ts') &&
+        !f.includes('node_modules') &&
+        !f.startsWith('dist/'),
+    )
+
+  if (allFiles.length === 0) {
+    return {
+      commitHash: hash ?? commitHash,
+      commitDate,
+      author: author ?? '',
+      message,
+      files: [],
+      totalScore: 0,
+      averageScore: 0,
+    }
+  }
+
+  // 3. Write snapshot to temp directory
+  const tmpDir = path.join(os.tmpdir(), `drift-${(hash ?? commitHash).slice(0, 8)}`)
+  fs.mkdirSync(tmpDir, { recursive: true })
+
+  for (const relPath of allFiles) {
+    try {
+      const content = execGit(`git show ${commitHash}:${relPath}`, targetPath)
+      const destPath = path.join(tmpDir, relPath)
+      fs.mkdirSync(path.dirname(destPath), { recursive: true })
+      fs.writeFileSync(destPath, content, 'utf-8')
+    } catch { // drift-ignore
+      // skip files that can't be read (binary, deleted in partial clone, etc.)
+    }
+  }
+
+  // 4. Analyse the full project snapshot
+  const fileReports = analyzeProject(tmpDir, config)
+  const totalScore = fileReports.reduce((sum, r) => sum + r.score, 0)
+  const averageScore = fileReports.length > 0 ? totalScore / fileReports.length : 0
+
+  // 5. Cleanup
+  try {
+    fs.rmSync(tmpDir, { recursive: true, force: true })
+  } catch { // drift-ignore
+    // non-fatal — temp dirs are cleaned by the OS eventually
+  }
+
+  return {
+    commitHash: hash ?? commitHash,
+    commitDate,
+    author: author ?? '',
+    message,
+    files: fileReports,
+    totalScore,
+    averageScore,
+  }
+}
+
+/**
+ * Run historical analysis over all commits since a given date.
+ * Returns results ordered chronologically (oldest first).
+ */
+export async function analyzeHistoricalCommits(
+  sinceDate: Date,
+  targetPath: string,
+  maxCommits: number,
+  analyzeProject: (targetPath: string, config?: DriftConfig) => FileReport[],
+  config?: DriftConfig,
+  maxSamples: number = 10,
+): Promise<HistoricalAnalysis[]> {
+  assertGitRepo(targetPath)
+
+  const isoDate = sinceDate.toISOString()
+  const raw = execGit(
+    `git log --since="${isoDate}" --format="%H" --max-count=${maxCommits}`,
+    targetPath,
+  )
+
+  if (!raw) return []
+
+  const hashes = raw.split('\n').filter(Boolean)
+
+  // Sample: distribute evenly across the range
+  const sampled = hashes.length <= maxSamples
+    ? hashes
+    : Array.from({ length: maxSamples }, (_, i) =>
+        hashes[Math.floor(i * (hashes.length - 1) / (maxSamples - 1))]
+      )
+
+  const analyses = await Promise.all(
+    sampled.map(h => analyzeSingleCommit(h, targetPath, analyzeProject, config).catch(() => null)),
+  )
+
+  return analyses
+    .filter((a): a is HistoricalAnalysis => a !== null)
+    .sort((a, b) => a.commitDate.getTime() - b.commitDate.getTime())
+}

package/src/git/trend.ts

@@ -0,0 +1,117 @@
+// drift-ignore-file
+
+import type { FileReport, DriftConfig, TrendDataPoint, DriftTrendReport } from '../types.js'
+import { assertGitRepo, analyzeHistoricalCommits } from './helpers.js'
+import { buildReport } from '../reporter.js'
+
+export class TrendAnalyzer {
+  private readonly projectPath: string
+  private readonly config: DriftConfig | undefined
+  private readonly analyzeProjectFn: (targetPath: string, config?: DriftConfig) => FileReport[]
+
+  constructor(
+    projectPath: string,
+    analyzeProjectFn: (targetPath: string, config?: DriftConfig) => FileReport[],
+    config?: DriftConfig,
+  ) {
+    this.projectPath = projectPath
+    this.analyzeProjectFn = analyzeProjectFn
+    this.config = config
+  }
+
+  // --- Static utility methods -----------------------------------------------
+
+  static calculateMovingAverage(data: TrendDataPoint[], windowSize: number): number[] {
+    return data.map((_, i) => {
+      const start = Math.max(0, i - windowSize + 1)
+      const window = data.slice(start, i + 1)
+      return window.reduce((s, p) => s + p.score, 0) / window.length
+    })
+  }
+
+  static linearRegression(data: TrendDataPoint[]): { slope: number; intercept: number; r2: number } {
+    const n = data.length
+    if (n < 2) return { slope: 0, intercept: data[0]?.score ?? 0, r2: 0 }
+
+    const xs = data.map((_, i) => i)
+    const ys = data.map(p => p.score)
+
+    const xMean = xs.reduce((s, x) => s + x, 0) / n
+    const yMean = ys.reduce((s, y) => s + y, 0) / n
+
+    const ssXX = xs.reduce((s, x) => s + (x - xMean) ** 2, 0)
+    const ssXY = xs.reduce((s, x, i) => s + (x - xMean) * (ys[i]! - yMean), 0)
+    const ssYY = ys.reduce((s, y) => s + (y - yMean) ** 2, 0)
+
+    const slope = ssXX === 0 ? 0 : ssXY / ssXX
+    const intercept = yMean - slope * xMean
+    const r2 = ssYY === 0 ? 1 : (ssXY ** 2) / (ssXX * ssYY)
+
+    return { slope, intercept, r2 }
+  }
+
+  /** Generate a simple horizontal ASCII bar chart (one bar per data point). */
+  static generateTrendChart(data: TrendDataPoint[]): string {
+    if (data.length === 0) return '(no data)'
+
+    const maxScore = Math.max(...data.map(p => p.score), 1)
+    const chartWidth = 40
+
+    const lines = data.map(p => {
+      const barLen = Math.round((p.score / maxScore) * chartWidth)
+      const bar = '█'.repeat(barLen)
+      const dateStr = p.date.toISOString().slice(0, 10)
+      return `${dateStr} │${bar.padEnd(chartWidth)} ${p.score.toFixed(1)}`
+    })
+
+    return lines.join('\n')
+  }
+
+  // --- Instance method -------------------------------------------------------
+
+  async analyzeTrend(options: {
+    period?: 'week' | 'month' | 'quarter' | 'year'
+    since?: string
+    until?: string
+  }): Promise<DriftTrendReport> {
+    assertGitRepo(this.projectPath)
+
+    const periodDays: Record<string, number> = {
+      week: 7, month: 30, quarter: 90, year: 365,
+    }
+    const days = periodDays[options.period ?? 'month'] ?? 30
+    const sinceDate = options.since
+      ? new Date(options.since)
+      : new Date(Date.now() - days * 24 * 60 * 60 * 1000)
+
+    const historicalAnalyses = await analyzeHistoricalCommits(
+      sinceDate,
+      this.projectPath,
+      100,
+      this.analyzeProjectFn,
+      this.config,
+      10,
+    )
+
+    const trendPoints: TrendDataPoint[] = historicalAnalyses.map(h => ({
+      date: h.commitDate,
+      score: h.averageScore,
+      fileCount: h.files.length,
+      avgIssuesPerFile: h.files.length > 0
+        ? h.files.reduce((s, f) => s + f.issues.length, 0) / h.files.length
+        : 0,
+    }))
+
+    const regression = TrendAnalyzer.linearRegression(trendPoints)
+
+    // Current state report
+    const currentFiles = this.analyzeProjectFn(this.projectPath, this.config)
+    const baseReport = buildReport(this.projectPath, currentFiles)
+
+    return {
+      ...baseReport,
+      trend: trendPoints,
+      regression,
+    }
+  }
+}

package/src/git.ts

@@ -13,22 +13,23 @@ import { randomUUID } from 'node:crypto'
  *
  * Throws if the directory is not a git repo or the ref is invalid.
  */
-export function extractFilesAtRef(projectPath: string, ref: string): string {
-  // Verify git repo
+function verifyGitRepo(projectPath: string): void {
   try {
     execSync('git rev-parse --git-dir', { cwd: projectPath, stdio: 'pipe' })
   } catch {
     throw new Error(`Not a git repository: ${projectPath}`)
   }
+}
 
-  // Verify ref exists
+function verifyRefExists(projectPath: string, ref: string): void {
   try {
     execSync(`git rev-parse --verify ${ref}`, { cwd: projectPath, stdio: 'pipe' })
   } catch {
     throw new Error(`Invalid git ref: '${ref}'. Run 'git log --oneline' to see available commits.`)
   }
+}
 
-  // List all .ts files tracked at this ref (excluding .d.ts)
+function listTsFilesAtRef(projectPath: string, ref: string): string[] {
   let fileList: string
   try {
     fileList = execSync(
@@ -39,36 +40,44 @@ export function extractFilesAtRef(projectPath: string, ref: string): string {
     throw new Error(`Failed to list files at ref '${ref}'`)
   }
 
-  const tsFiles = fileList
+  return fileList
     .split('\n')
     .map(f => f.trim())
-    .filter(f => f.endsWith('.ts') && !f.endsWith('.d.ts'))
+    .filter(f => (f.endsWith('.ts') || f.endsWith('.tsx') || f.endsWith('.js') || f.endsWith('.jsx')) && !f.endsWith('.d.ts'))
+}
+
+function extractFile(projectPath: string, ref: string, filePath: string, tempDir: string): void {
+  let content: string
+  try {
+    content = execSync(
+      `git show ${ref}:${filePath}`,
+      { cwd: projectPath, encoding: 'utf-8', stdio: 'pipe' }
+    )
+  } catch {
+    return
+  }
+
+  const destPath = join(tempDir, filePath.split('/').join(sep))
+  const destDir = destPath.substring(0, destPath.lastIndexOf(sep))
+  mkdirSync(destDir, { recursive: true })
+  writeFileSync(destPath, content, 'utf-8')
+}
+
+export function extractFilesAtRef(projectPath: string, ref: string): string {
+  verifyGitRepo(projectPath)
+  verifyRefExists(projectPath, ref)
+
+  const tsFiles = listTsFilesAtRef(projectPath, ref)
 
   if (tsFiles.length === 0) {
     throw new Error(`No TypeScript files found at ref '${ref}'`)
   }
 
-  // Create temp directory
   const tempDir = join(tmpdir(), `drift-diff-${randomUUID()}`)
   mkdirSync(tempDir, { recursive: true })
 
-  // Extract each file
   for (const filePath of tsFiles) {
-    let content: string
-    try {
-      content = execSync(
-        `git show ${ref}:${filePath}`,
-        { cwd: projectPath, encoding: 'utf-8', stdio: 'pipe' }
-      )
-    } catch {
-      // File may not exist at this ref — skip
-      continue
-    }
-
-    const destPath = join(tempDir, filePath.split('/').join(sep))
-    const destDir = destPath.substring(0, destPath.lastIndexOf(sep))
-    mkdirSync(destDir, { recursive: true })
-    writeFileSync(destPath, content, 'utf-8')
+    extractFile(projectPath, ref, filePath, tempDir)
   }
 
   return tempDir
@@ -86,7 +95,7 @@ export function cleanupTempDir(tempDir: string): void {
 /**
  * Get the short hash of a git ref for display purposes.
  */
-export function resolveRefHash(projectPath: string, ref: string): string {
+function resolveRefHash(projectPath: string, ref: string): string {
   try {
     return execSync(
       `git rev-parse --short ${ref}`,