@eduardbar/drift 0.9.0 → 1.0.0

package/src/cli.ts

@@ -1,11 +1,12 @@
 #!/usr/bin/env node
+// drift-ignore-file
 import { Command } from 'commander'
 import { writeFileSync } from 'node:fs'
 import { resolve } from 'node:path'
 import { createRequire } from 'node:module'
 const require = createRequire(import.meta.url)
 const { version: VERSION } = require('../package.json') as { version: string }
-import { analyzeProject } from './analyzer.js'
+import { analyzeProject, analyzeFile, TrendAnalyzer, BlameAnalyzer } from './analyzer.js'
 import { buildReport, formatMarkdown, formatAIOutput } from './reporter.js'
 import { printConsole, printDiff } from './printer.js'
 import { loadConfig } from './config.js'
@@ -14,7 +15,7 @@ import { computeDiff } from './diff.js'
 import { generateHtmlReport } from './report.js'
 import { generateBadge } from './badge.js'
 import { emitCIAnnotations, printCISummary } from './ci.js'
-import { TrendAnalyzer, BlameAnalyzer } from './analyzer.js'
+import { applyFixes, type FixResult } from './fix.js'
 
 const program = new Command()
 
@@ -177,7 +178,7 @@ program
     process.stderr.write(`\nAnalyzing trend in ${resolvedPath}...\n`)
     
     const config = await loadConfig(resolvedPath)
-    const analyzer = new TrendAnalyzer(resolvedPath, config)
+    const analyzer = new TrendAnalyzer(resolvedPath, analyzeProject, config)
     
     const trendData = await analyzer.analyzeTrend({
       period: period as 'week' | 'month' | 'quarter' | 'year',
@@ -198,7 +199,7 @@ program
     process.stderr.write(`\nAnalyzing blame in ${resolvedPath}...\n`)
     
     const config = await loadConfig(resolvedPath)
-    const analyzer = new BlameAnalyzer(resolvedPath, config)
+    const analyzer = new BlameAnalyzer(resolvedPath, analyzeProject, analyzeFile, config)
     
     const blameData = await analyzer.analyzeBlame({
       target: target as 'file' | 'rule' | 'overall' | undefined,
@@ -209,4 +210,52 @@ program
     process.stdout.write(JSON.stringify(blameData, null, 2) + '\n')
   })
 
+program
+  .command('fix [path]')
+  .description('Auto-fix safe issues (debug-leftover console.*, catch-swallow)')
+  .option('--rule <rule>', 'Fix only a specific rule')
+  .option('--dry-run', 'Show what would change without writing files')
+  .action(async (targetPath: string | undefined, options: { rule?: string; dryRun?: boolean }) => {
+    const resolvedPath = resolve(targetPath ?? '.')
+    const config = await loadConfig(resolvedPath)
+
+    const results = await applyFixes(resolvedPath, config, {
+      rule: options.rule,
+      dryRun: options.dryRun,
+    })
+
+    if (results.length === 0) {
+      console.log('No fixable issues found.')
+      return
+    }
+
+    const applied = results.filter(r => r.applied)
+
+    if (options.dryRun) {
+      console.log(`\ndrift fix --dry-run: ${results.length} fixable issues found\n`)
+    } else {
+      console.log(`\ndrift fix: ${applied.length} fixes applied\n`)
+    }
+
+    // Group by file for clean output
+    const byFile = new Map<string, FixResult[]>()
+    for (const r of results) {
+      if (!byFile.has(r.file)) byFile.set(r.file, [])
+      byFile.get(r.file)!.push(r)
+    }
+
+    for (const [file, fileResults] of byFile) {
+      const relPath = file.replace(resolvedPath + '/', '').replace(resolvedPath + '\\', '')
+      console.log(`  ${relPath}`)
+      for (const r of fileResults) {
+        const status = r.applied ? (options.dryRun ? 'would fix' : 'fixed') : 'skipped'
+        console.log(`    [${r.rule}] line ${r.line}: ${r.description} — ${status}`)
+      }
+    }
+
+    if (!options.dryRun && applied.length > 0) {
+      console.log(`\n${applied.length} issue(s) fixed. Re-run drift scan to verify.`)
+    }
+  })
+
 program.parse()

package/src/config.ts

@@ -36,7 +36,7 @@ export async function loadConfig(projectRoot: string): Promise<DriftConfig | und
       const config: DriftConfig = mod.default ?? mod
 
       return config
-    } catch {
+    } catch { // drift-ignore
       // drift-ignore: catch-swallow — config is optional; load failure is non-fatal
     }
   }

package/src/fix.ts

@@ -0,0 +1,154 @@
+import { readFileSync, writeFileSync, statSync } from 'node:fs'
+import { resolve } from 'node:path'
+import { analyzeProject, analyzeFile } from './analyzer.js'
+import type { DriftIssue, DriftConfig } from './types.js'
+import { Project } from 'ts-morph'
+
+export interface FixResult {
+  file: string
+  rule: string
+  line: number
+  description: string
+  applied: boolean
+}
+
+const FIXABLE_RULES = new Set(['debug-leftover', 'catch-swallow'])
+
+function isConsoleDebug(issue: DriftIssue): boolean {
+  // debug-leftover for console.* has messages like "console.log left in production code."
+  // Unresolved markers start with "Unresolved marker"
+  return issue.rule === 'debug-leftover' && !issue.message.startsWith('Unresolved marker')
+}
+
+function isFixable(issue: DriftIssue): boolean {
+  if (issue.rule === 'debug-leftover') return isConsoleDebug(issue)
+  return FIXABLE_RULES.has(issue.rule)
+}
+
+function fixDebugLeftover(lines: string[], line: number): string[] {
+  // line is 1-based, lines is 0-based
+  return [...lines.slice(0, line - 1), ...lines.slice(line)]
+}
+
+function fixCatchSwallow(lines: string[], line: number): string[] {
+  // line is 1-based — points to the catch (...) line
+  let openBraceLine = line - 1 // convert to 0-based index
+
+  // Find the opening { of the catch block (same line or next few lines)
+  for (let i = openBraceLine; i < Math.min(openBraceLine + 3, lines.length); i++) { // drift-ignore
+    if (lines[i].includes('{')) {
+      openBraceLine = i
+      break
+    }
+  }
+
+  const indentMatch = lines[openBraceLine].match(/^(\s*)/)
+  const indent = indentMatch ? indentMatch[1] + '  ' : '  '
+
+  return [
+    ...lines.slice(0, openBraceLine + 1),
+    `${indent}// TODO: handle error`, // drift-ignore
+    ...lines.slice(openBraceLine + 1),
+  ]
+}
+
+function applyFixToLines(
+  lines: string[],
+  issue: DriftIssue
+): { newLines: string[]; description: string } | null {
+  if (issue.rule === 'debug-leftover' && isConsoleDebug(issue)) {
+    return {
+      newLines: fixDebugLeftover(lines, issue.line),
+      description: `remove ${issue.message.split(' ')[0]} statement`,
+    }
+  }
+
+  if (issue.rule === 'catch-swallow') {
+    return {
+      newLines: fixCatchSwallow(lines, issue.line),
+      description: 'add TODO comment to empty catch block',
+    }
+  }
+
+  return null
+}
+
+export async function applyFixes(
+  targetPath: string,
+  config?: DriftConfig,
+  options?: { rule?: string; dryRun?: boolean }
+): Promise<FixResult[]> {
+  const resolvedPath = resolve(targetPath)
+  const dryRun = options?.dryRun ?? false
+
+  // Determine if target is a file or directory
+  let fileReports
+  const stat = statSync(resolvedPath)
+
+  if (stat.isFile()) {
+    const project = new Project({
+      skipAddingFilesFromTsConfig: true,
+      compilerOptions: { allowJs: true, jsx: 1 },
+    })
+    const sourceFile = project.addSourceFileAtPath(resolvedPath)
+    fileReports = [analyzeFile(sourceFile)]
+  } else {
+    fileReports = analyzeProject(resolvedPath, config)
+  }
+
+  // Collect fixable issues, optionally filtered by rule
+  const fixableByFile = new Map<string, DriftIssue[]>()
+
+  for (const report of fileReports) {
+    const fixableIssues = report.issues.filter(issue => {
+      if (!isFixable(issue)) return false
+      if (options?.rule && issue.rule !== options.rule) return false
+      return true
+    })
+
+    if (fixableIssues.length > 0) {
+      fixableByFile.set(report.path, fixableIssues)
+    }
+  }
+
+  const results: FixResult[] = []
+
+  for (const [filePath, issues] of fixableByFile) {
+    const content = readFileSync(filePath, 'utf8')
+    let lines = content.split('\n')
+
+    // Sort issues by line descending to avoid line number drift after fixes
+    const sortedIssues = [...issues].sort((a, b) => b.line - a.line)
+
+    // Track line offset caused by deletions (debug-leftover removes lines)
+    // We process top-to-bottom after sorting descending, so no offset needed per issue
+    for (const issue of sortedIssues) {
+      const fixResult = applyFixToLines(lines, issue)
+
+      if (fixResult) {
+        results.push({
+          file: filePath,
+          rule: issue.rule,
+          line: issue.line,
+          description: fixResult.description,
+          applied: true,
+        })
+        lines = fixResult.newLines
+      } else {
+        results.push({
+          file: filePath,
+          rule: issue.rule,
+          line: issue.line,
+          description: 'no fix available',
+          applied: false,
+        })
+      }
+    }
+
+    if (!dryRun) {
+      writeFileSync(filePath, lines.join('\n'), 'utf8')
+    }
+  }
+
+  return results
+}

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 }
+  }
+}