@eduardbar/drift 1.0.0 → 1.2.0

package/packages/vscode-drift/src/extension.ts

@@ -1,90 +1,116 @@
+// drift-ignore-file
+
 import * as vscode from 'vscode'
 import { analyzeFilePath } from './analyzer'
 import { DriftDiagnosticsProvider } from './diagnostics'
 import { DriftTreeProvider } from './treeview'
 import { DriftStatusBarItem } from './statusbar'
+import { DriftCodeActionProvider } from './code-actions'
 import type { FileReport } from '@eduardbar/drift'
 
 const SUPPORTED_LANGUAGES = ['typescript', 'typescriptreact', 'javascript', 'javascriptreact']
 
+async function analyzeAndUpdate(
+  document: vscode.TextDocument,
+  diagnostics: DriftDiagnosticsProvider,
+  treeProvider: DriftTreeProvider,
+  reportCache: Map<string, FileReport>,
+  statusBar: DriftStatusBarItem
+): Promise<void> {
+  const config = vscode.workspace.getConfiguration('drift')
+  if (!config.get<boolean>('enable', true)) return
+
+  if (!SUPPORTED_LANGUAGES.includes(document.languageId)) return
+  if (document.uri.scheme !== 'file') return
+
+  const filePath = document.uri.fsPath
+
+  const report = await analyzeFilePath(filePath)
+  if (!report) return
+
+  diagnostics.update(report)
+  treeProvider.updateFile(report)
+  reportCache.set(filePath, report)
+  statusBar.update(Array.from(reportCache.values()))
+}
+
+async function scanWorkspace(
+  diagnostics: DriftDiagnosticsProvider,
+  treeProvider: DriftTreeProvider,
+  reportCache: Map<string, FileReport>,
+  statusBar: DriftStatusBarItem
+): Promise<void> {
+  const files = await vscode.workspace.findFiles(
+    '**/*.{ts,tsx,js,jsx}',
+    '**/node_modules/**'
+  )
+
+  vscode.window.withProgress(
+    {
+      location: vscode.ProgressLocation.Notification,
+      title: 'drift: Scanning workspace...',
+      cancellable: false,
+    },
+    async (progress) => {
+      const total = files.length
+      let done = 0
+
+      for (const file of files) {
+        const report = await analyzeFilePath(file.fsPath)
+        if (report) {
+          diagnostics.update(report)
+          treeProvider.updateFile(report)
+          reportCache.set(file.fsPath, report)
+        }
+        done++
+        progress.report({ increment: (done / total) * 100 })
+      }
+
+      statusBar.update(Array.from(reportCache.values()))
+      vscode.window.showInformationMessage(`drift: ${total} files scanned.`)
+    }
+  )
+}
+
+function clearDiagnostics(
+  diagnostics: DriftDiagnosticsProvider,
+  treeProvider: DriftTreeProvider,
+  reportCache: Map<string, FileReport>,
+  statusBar: DriftStatusBarItem
+): void {
+  diagnostics.clear()
+  treeProvider.clearAll()
+  reportCache.clear()
+  statusBar.update([])
+}
+
 export function activate(context: vscode.ExtensionContext): void {
   const diagnostics = new DriftDiagnosticsProvider()
   const treeProvider = new DriftTreeProvider()
   const statusBar = new DriftStatusBarItem()
+  const codeActions = new DriftCodeActionProvider()
 
-  // Registrar TreeView
   const treeView = vscode.window.createTreeView('driftIssues', {
     treeDataProvider: treeProvider,
     showCollapseAll: true,
   })
 
-  // Cache de reports para la status bar
   const reportCache = new Map<string, FileReport>()
 
-  async function analyzeAndUpdate(document: vscode.TextDocument): Promise<void> {
-    const config = vscode.workspace.getConfiguration('drift')
-    if (!config.get<boolean>('enable', true)) return
-
-    if (!SUPPORTED_LANGUAGES.includes(document.languageId)) return
-    if (document.uri.scheme !== 'file') return
-
-    const filePath = document.uri.fsPath
-
-    const report = await analyzeFilePath(filePath)
-    if (!report) return
-
-    diagnostics.update(report)
-    treeProvider.updateFile(report)
-    reportCache.set(filePath, report)
-    statusBar.update(Array.from(reportCache.values()))
-  }
-
-  // Trigger: al guardar
-  const onSave = vscode.workspace.onDidSaveTextDocument(analyzeAndUpdate)
-
-  // Comando: scan workspace
-  const scanCmd = vscode.commands.registerCommand('drift.scanWorkspace', async () => {
-    const files = await vscode.workspace.findFiles(
-      '**/*.{ts,tsx,js,jsx}',
-      '**/node_modules/**'
-    )
-
-    vscode.window.withProgress(
-      {
-        location: vscode.ProgressLocation.Notification,
-        title: 'drift: Scanning workspace...',
-        cancellable: false,
-      },
-      async (progress) => {
-        const total = files.length
-        let done = 0
-
-        for (const file of files) {
-          const report = await analyzeFilePath(file.fsPath)
-          if (report) {
-            diagnostics.update(report)
-            treeProvider.updateFile(report)
-            reportCache.set(file.fsPath, report)
-          }
-          done++
-          progress.report({ increment: (done / total) * 100 })
-        }
+  const onSave = vscode.workspace.onDidSaveTextDocument(
+    (doc) => analyzeAndUpdate(doc, diagnostics, treeProvider, reportCache, statusBar)
+  )
 
-        statusBar.update(Array.from(reportCache.values()))
-        vscode.window.showInformationMessage(`drift: ${total} files scanned.`)
-      }
-    )
-  })
+  const scanCmd = vscode.commands.registerCommand(
+    'drift.scanWorkspace',
+    () => scanWorkspace(diagnostics, treeProvider, reportCache, statusBar)
+  )
 
-  // Comando: clear
-  const clearCmd = vscode.commands.registerCommand('drift.clearDiagnostics', () => {
-    diagnostics.clear()
-    treeProvider.clearAll()
-    reportCache.clear()
-    statusBar.update([])
-  })
+  const clearCmd = vscode.commands.registerCommand(
+    'drift.clearDiagnostics',
+    () => clearDiagnostics(diagnostics, treeProvider, reportCache, statusBar)
+  )
 
-  // Comando: go to issue (desde TreeView click)
   const goToCmd = vscode.commands.registerCommand(
     'drift.goToIssue',
     async (filePath: string, line: number) => {
@@ -97,6 +123,14 @@ export function activate(context: vscode.ExtensionContext): void {
     }
   )
 
+  const codeActionRegistration = vscode.languages.registerCodeActionsProvider(
+    SUPPORTED_LANGUAGES.map((language) => ({ language })),
+    codeActions,
+    {
+      providedCodeActionKinds: [vscode.CodeActionKind.QuickFix],
+    },
+  )
+
   context.subscriptions.push(
     { dispose: () => diagnostics.dispose() },
     { dispose: () => statusBar.dispose() },
@@ -105,6 +139,7 @@ export function activate(context: vscode.ExtensionContext): void {
     scanCmd,
     clearCmd,
     goToCmd,
+    codeActionRegistration,
   )
 }
 

package/packages/vscode-drift/src/statusbar.ts

@@ -1,13 +1,21 @@
 import * as vscode from 'vscode'
 import type { FileReport } from '@eduardbar/drift'
 
+const STATUSBAR_PRIORITY = 100
+
+const SCORE_THRESHOLDS = {
+  WARNING: 50,
+  ERROR: 30,
+  WARNING_BG: 60,
+}
+
 export class DriftStatusBarItem {
   private item: vscode.StatusBarItem
 
   constructor() {
-    this.item = vscode.window.createStatusBarItem(
+    this.item = vscode.createStatusBarItem(
       vscode.StatusBarAlignment.Right,
-      100
+      STATUSBAR_PRIORITY
     )
     this.item.command = 'drift.scanWorkspace'
     this.item.tooltip = 'Click to scan workspace'
@@ -27,12 +35,12 @@ export class DriftStatusBarItem {
     const totalIssues = reports.reduce((sum, r) => sum + r.issues.length, 0)
     const hasErrors = reports.some(r => r.issues.some(i => i.severity === 'error'))
 
-    const icon = hasErrors ? '$(error)' : totalScore < 50 ? '$(warning)' : '$(check)'
+    const icon = hasErrors ? '$(error)' : totalScore < SCORE_THRESHOLDS.WARNING ? '$(warning)' : '$(check)'
     this.item.text = `${icon} drift ${totalScore}/100 · ${totalIssues} issues`
 
-    if (hasErrors || totalScore < 30) {
+    if (hasErrors || totalScore < SCORE_THRESHOLDS.ERROR) {
       this.item.backgroundColor = new vscode.ThemeColor('statusBarItem.errorBackground')
-    } else if (totalScore < 60) {
+    } else if (totalScore < SCORE_THRESHOLDS.WARNING_BG) {
       this.item.backgroundColor = new vscode.ThemeColor('statusBarItem.warningBackground')
     } else {
       this.item.backgroundColor = undefined

package/packages/vscode-drift/src/treeview.ts

@@ -1,3 +1,5 @@
+// drift-ignore-file
+
 import * as vscode from 'vscode'
 import * as path from 'path'
 import type { FileReport } from '@eduardbar/drift'

package/src/analyzer.ts

@@ -1,7 +1,7 @@
 // drift-ignore-file
 import * as path from 'node:path'
 import { Project } from 'ts-morph'
-import type { DriftIssue, FileReport, DriftConfig } from './types.js'
+import type { DriftIssue, FileReport, DriftConfig, LoadedPlugin, PluginRuleContext } from './types.js'
 
 // Rules
 import { isFileIgnored } from './rules/shared.js'
@@ -15,15 +15,12 @@ import {
   detectCatchSwallow,
   detectMissingReturnTypes,
 } from './rules/phase0-basic.js'
-import {
-  detectHighComplexity,
-  detectDeepNesting,
-  detectTooManyParams,
-  detectHighCoupling,
-  detectPromiseStyleMix,
-  detectMagicNumbers,
-  detectCommentContradiction,
-} from './rules/phase1-complexity.js'
+import { detectHighComplexity } from './rules/complexity.js'
+import { detectDeepNesting, detectTooManyParams } from './rules/nesting.js'
+import { detectHighCoupling } from './rules/coupling.js'
+import { detectPromiseStyleMix } from './rules/promise.js'
+import { detectMagicNumbers } from './rules/magic.js'
+import { detectCommentContradiction } from './rules/comments.js'
 import {
   detectDeadFiles,
   detectUnusedExports,
@@ -34,6 +31,11 @@ import {
   detectLayerViolations,
   detectCrossBoundaryImports,
 } from './rules/phase3-arch.js'
+import {
+  detectControllerNoDb,
+  detectServiceNoHttp,
+  detectMaxFunctionLines,
+} from './rules/phase3-configurable.js'
 import {
   detectOverCommented,
   detectHardcodedConfig,
@@ -46,6 +48,7 @@ import {
   fingerprintFunction,
   calculateScore,
 } from './rules/phase8-semantic.js'
+import { loadPlugins } from './plugins.js'
 
 // Git analyzers (re-exported as part of the public API)
 export { TrendAnalyzer } from './git/trend.js'
@@ -81,21 +84,113 @@ export const RULE_WEIGHTS: Record<string, { severity: DriftIssue['severity']; we
   // Phase 3b/c: layer and module boundary enforcement (require drift.config.ts)
   'layer-violation':          { severity: 'error',   weight: 16 },
   'cross-boundary-import':    { severity: 'warning', weight: 10 },
+  'controller-no-db':         { severity: 'warning', weight: 11 },
+  'service-no-http':          { severity: 'warning', weight: 11 },
+  'max-function-lines':       { severity: 'warning', weight: 9 },
   // Phase 5: AI authorship heuristics
   'over-commented':                { severity: 'info',    weight: 4  },
   'hardcoded-config':              { severity: 'warning', weight: 10 },
   'inconsistent-error-handling':   { severity: 'warning', weight: 8  },
   'unnecessary-abstraction':       { severity: 'warning', weight: 7  },
   'naming-inconsistency':          { severity: 'warning', weight: 6  },
+  'ai-code-smell':                 { severity: 'warning', weight: 12 },
   // Phase 8: semantic duplication
   'semantic-duplication':          { severity: 'warning', weight: 12 },
+  'plugin-error':                  { severity: 'warning', weight: 4  },
+}
+
+const AI_SMELL_SIGNALS = new Set([
+  'over-commented',
+  'hardcoded-config',
+  'inconsistent-error-handling',
+  'unnecessary-abstraction',
+  'naming-inconsistency',
+  'comment-contradiction',
+  'promise-style-mix',
+  'any-abuse',
+])
+
+function detectAICodeSmell(issues: DriftIssue[], filePath: string): DriftIssue[] {
+  const signalCounts = new Map<string, number>()
+  for (const issue of issues) {
+    if (!AI_SMELL_SIGNALS.has(issue.rule)) continue
+    signalCounts.set(issue.rule, (signalCounts.get(issue.rule) ?? 0) + 1)
+  }
+
+  const totalSignals = [...signalCounts.values()].reduce((sum, count) => sum + count, 0)
+  if (totalSignals < 3) return []
+
+  const triggers = [...signalCounts.entries()]
+    .sort((a, b) => b[1] - a[1])
+    .slice(0, 3)
+    .map(([rule, count]) => `${rule} x${count}`)
+
+  return [{
+    rule: 'ai-code-smell',
+    severity: 'warning',
+    message: `Aggregated AI smell signals detected (${totalSignals}): ${triggers.join(', ')}`,
+    line: 1,
+    column: 1,
+    snippet: path.basename(filePath),
+  }]
+}
+
+function runPluginRules(
+  file: import('ts-morph').SourceFile,
+  loadedPlugins: LoadedPlugin[],
+  config: DriftConfig | undefined,
+  projectRoot: string,
+): DriftIssue[] {
+  if (loadedPlugins.length === 0) return []
+  const context: PluginRuleContext = {
+    projectRoot,
+    filePath: file.getFilePath(),
+    config,
+  }
+
+  const issues: DriftIssue[] = []
+  for (const loaded of loadedPlugins) {
+    for (const rule of loaded.plugin.rules) {
+      try {
+        const detected = rule.detect(file, context) ?? []
+        for (const issue of detected) {
+          issues.push({
+            ...issue,
+            rule: issue.rule || `${loaded.plugin.name}/${rule.name}`,
+            severity: issue.severity ?? (rule.severity ?? 'warning'),
+          })
+        }
+      } catch (error) {
+        issues.push({
+          rule: 'plugin-error',
+          severity: 'warning',
+          message: `Plugin '${loaded.id}' rule '${rule.name}' failed: ${error instanceof Error ? error.message : String(error)}`,
+          line: 1,
+          column: 1,
+          snippet: file.getBaseName(),
+        })
+      }
+    }
+  }
+  return issues
 }
 
 // ---------------------------------------------------------------------------
 // Per-file analysis
 // ---------------------------------------------------------------------------
 
-export function analyzeFile(file: import('ts-morph').SourceFile): FileReport {
+export function analyzeFile(
+  file: import('ts-morph').SourceFile,
+  options?: DriftConfig | {
+    config?: DriftConfig
+    loadedPlugins?: LoadedPlugin[]
+    projectRoot?: string
+  },
+): FileReport {
+  const normalizedOptions = (options && typeof options === 'object' && ('config' in options || 'loadedPlugins' in options || 'projectRoot' in options))
+    ? options
+    : { config: (options && typeof options === 'object' ? options : undefined) as DriftConfig | undefined }
+
   if (isFileIgnored(file)) {
     return {
       path: file.getFilePath(),
@@ -127,8 +222,21 @@ export function analyzeFile(file: import('ts-morph').SourceFile): FileReport {
     ...detectInconsistentErrorHandling(file),
     ...detectUnnecessaryAbstraction(file),
     ...detectNamingInconsistency(file),
+    // Configurable architecture rules
+    ...detectControllerNoDb(file, normalizedOptions?.config),
+    ...detectServiceNoHttp(file, normalizedOptions?.config),
+    ...detectMaxFunctionLines(file, normalizedOptions?.config),
+    // Plugin rules
+    ...runPluginRules(
+      file,
+      normalizedOptions?.loadedPlugins ?? [],
+      normalizedOptions?.config,
+      normalizedOptions?.projectRoot ?? path.dirname(file.getFilePath()),
+    ),
   ]
 
+  issues.push(...detectAICodeSmell(issues, file.getFilePath()))
+
   return {
     path: file.getFilePath(),
     issues,
@@ -161,9 +269,14 @@ export function analyzeProject(targetPath: string, config?: DriftConfig): FileRe
   ])
 
   const sourceFiles = project.getSourceFiles()
+  const pluginRuntime = loadPlugins(targetPath, config?.plugins)
 
   // Phase 1: per-file analysis
-  const reports: FileReport[] = sourceFiles.map(analyzeFile)
+  const reports: FileReport[] = sourceFiles.map((file) => analyzeFile(file, {
+    config,
+    loadedPlugins: pluginRuntime.plugins,
+    projectRoot: targetPath,
+  }))
   const reportByPath = new Map<string, FileReport>()
   for (const r of reports) reportByPath.set(r.path, r)
 
@@ -227,6 +340,25 @@ export function analyzeProject(targetPath: string, config?: DriftConfig): FileRe
     }
   }
 
+  // Plugin load failures are surfaced as synthetic report entries.
+  if (pluginRuntime.errors.length > 0) {
+    for (const err of pluginRuntime.errors) {
+      const pluginIssue: DriftIssue = {
+        rule: 'plugin-error',
+        severity: 'warning',
+        message: `Failed to load plugin '${err.pluginId}': ${err.message}`,
+        line: 1,
+        column: 1,
+        snippet: err.pluginId,
+      }
+      reports.push({
+        path: path.join(targetPath, '.drift-plugin-errors', `${err.pluginId}.plugin`),
+        issues: [pluginIssue],
+        score: calculateScore([pluginIssue], RULE_WEIGHTS),
+      })
+    }
+  }
+
   // ── Phase 2: dead-file + unused-export + unused-dependency ─────────────────
   const deadFiles = detectDeadFiles(sourceFiles, allImportedPaths, RULE_WEIGHTS)
   for (const [sfPath, issue] of deadFiles) {

package/src/badge.ts

@@ -3,19 +3,40 @@ import type {} from './types.js'
 const LEFT_WIDTH = 47
 const CHAR_WIDTH = 7
 const PADDING = 16
+const SVG_SCALE = 10
+
+const GRADE_THRESHOLDS = {
+  LOW: 20,
+  MODERATE: 45,
+  HIGH: 70,
+}
+
+const GRADE_COLORS = {
+  LOW: '#4c1',
+  MODERATE: '#dfb317',
+  HIGH: '#fe7d37',
+  CRITICAL: '#e05d44',
+}
+
+const GRADE_LABELS = {
+  LOW: 'LOW',
+  MODERATE: 'MODERATE',
+  HIGH: 'HIGH',
+  CRITICAL: 'CRITICAL',
+}
 
 function scoreColor(score: number): string {
-  if (score < 20) return '#4c1'
-  if (score < 45) return '#dfb317'
-  if (score < 70) return '#fe7d37'
-  return '#e05d44'
+  if (score < GRADE_THRESHOLDS.LOW) return GRADE_COLORS.LOW
+  if (score < GRADE_THRESHOLDS.MODERATE) return GRADE_COLORS.MODERATE
+  if (score < GRADE_THRESHOLDS.HIGH) return GRADE_COLORS.HIGH
+  return GRADE_COLORS.CRITICAL
 }
 
 function scoreLabel(score: number): string {
-  if (score < 20) return 'LOW'
-  if (score < 45) return 'MODERATE'
-  if (score < 70) return 'HIGH'
-  return 'CRITICAL'
+  if (score < GRADE_THRESHOLDS.LOW) return GRADE_LABELS.LOW
+  if (score < GRADE_THRESHOLDS.MODERATE) return GRADE_LABELS.MODERATE
+  if (score < GRADE_THRESHOLDS.HIGH) return GRADE_LABELS.HIGH
+  return GRADE_LABELS.CRITICAL
 }
 
 function rightWidth(text: string): number {
@@ -32,10 +53,11 @@ export function generateBadge(score: number): string {
   const leftCenterX = LEFT_WIDTH / 2
   const rightCenterX = LEFT_WIDTH + rWidth / 2
 
-  // shields.io pattern: font-size="110" + scale(.1) = effective 11px
-  // all X/Y coords are ×10
-  const leftTextWidth = (LEFT_WIDTH - 10) * 10
-  const rightTextWidth = (rWidth - PADDING) * 10
+  const leftTextWidth = (LEFT_WIDTH - PADDING) * SVG_SCALE
+  const rightTextWidth = (rWidth - PADDING) * SVG_SCALE
+
+  const leftCenterXScaled = leftCenterX * SVG_SCALE
+  const rightCenterXScaled = rightCenterX * SVG_SCALE
 
   return `<svg xmlns="http://www.w3.org/2000/svg" xmlns:xlink="http://www.w3.org/1999/xlink" width="${totalWidth}" height="20">
   <linearGradient id="s" x2="0" y2="100%">
@@ -51,10 +73,10 @@ export function generateBadge(score: number): string {
     <rect width="${totalWidth}" height="20" fill="url(#s)"/>
   </g>
   <g fill="#fff" text-anchor="middle" font-family="DejaVu Sans,Verdana,Geneva,sans-serif" font-size="110">
-    <text x="${leftCenterX * 10}" y="150" fill="#010101" fill-opacity=".3" transform="scale(.1)" textLength="${leftTextWidth}" lengthAdjust="spacing">drift</text>
-    <text x="${leftCenterX * 10}" y="140" transform="scale(.1)" textLength="${leftTextWidth}" lengthAdjust="spacing">drift</text>
-    <text x="${rightCenterX * 10}" y="150" fill="#010101" fill-opacity=".3" transform="scale(.1)" textLength="${rightTextWidth}" lengthAdjust="spacing">${valueText}</text>
-    <text x="${rightCenterX * 10}" y="140" transform="scale(.1)" textLength="${rightTextWidth}" lengthAdjust="spacing">${valueText}</text>
+    <text x="${leftCenterXScaled}" y="150" fill="#010101" fill-opacity=".3" transform="scale(.1)" textLength="${leftTextWidth}" lengthAdjust="spacing">drift</text>
+    <text x="${leftCenterXScaled}" y="140" transform="scale(.1)" textLength="${leftTextWidth}" lengthAdjust="spacing">drift</text>
+    <text x="${rightCenterXScaled}" y="150" fill="#010101" fill-opacity=".3" transform="scale(.1)" textLength="${rightTextWidth}" lengthAdjust="spacing">${valueText}</text>
+    <text x="${rightCenterXScaled}" y="140" transform="scale(.1)" textLength="${rightTextWidth}" lengthAdjust="spacing">${valueText}</text>
   </g>
 </svg>`
 }

package/src/ci.ts

@@ -2,6 +2,15 @@ import { writeFileSync } from 'node:fs'
 import { relative } from 'node:path'
 import type { DriftReport } from './types.js'
 
+const GRADE_THRESHOLDS = {
+  A: 80,
+  B: 60,
+  C: 40,
+  D: 20,
+}
+
+const TOP_FILES_LIMIT = 10
+
 function encodeMessage(msg: string): string {
   return msg
     .replace(/%/g, '%25')
@@ -18,10 +27,10 @@ function severityToAnnotation(s: string): 'error' | 'warning' | 'notice' {
 }
 
 function scoreLabel(score: number): string {
-  if (score >= 80) return 'A'
-  if (score >= 60) return 'B'
-  if (score >= 40) return 'C'
-  if (score >= 20) return 'D'
+  if (score >= GRADE_THRESHOLDS.A) return 'A'
+  if (score >= GRADE_THRESHOLDS.B) return 'B'
+  if (score >= GRADE_THRESHOLDS.C) return 'C'
+  if (score >= GRADE_THRESHOLDS.D) return 'D'
   return 'F'
 }
 
@@ -38,28 +47,40 @@ export function emitCIAnnotations(report: DriftReport): void {
   }
 }
 
-export function printCISummary(report: DriftReport): void {
-  const summaryPath = process.env['GITHUB_STEP_SUMMARY']
-  if (!summaryPath) return
-
-  const score = report.totalScore
-  const grade = scoreLabel(score)
-
+function countIssuesBySeverity(report: DriftReport): { errors: number; warnings: number; info: number } {
   let errors = 0
   let warnings = 0
   let info = 0
 
   for (const file of report.files) {
-    for (const issue of file.issues) {
-      if (issue.severity === 'error') errors++
-      else if (issue.severity === 'warning') warnings++
-      else info++
-    }
+    countFileIssues(file, { errors: () => errors++, warnings: () => warnings++, info: () => info++ })
   }
 
+  return { errors, warnings, info }
+}
+
+function countFileIssues(
+  file: { issues: Array<{ severity: string }> },
+  counters: { errors: () => void; warnings: () => void; info: () => void },
+): void {
+  for (const issue of file.issues) {
+    if (issue.severity === 'error') counters.errors()
+    else if (issue.severity === 'warning') counters.warnings()
+    else counters.info()
+  }
+}
+
+export function printCISummary(report: DriftReport): void {
+  const summaryPath = process.env['GITHUB_STEP_SUMMARY']
+  if (!summaryPath) return
+
+  const score = report.totalScore
+  const grade = scoreLabel(score)
+  const { errors, warnings, info } = countIssuesBySeverity(report)
+
   const sorted = [...report.files]
     .sort((a, b) => b.issues.length - a.issues.length)
-    .slice(0, 10)
+    .slice(0, TOP_FILES_LIMIT)
 
   const rows = sorted
     .map((f) => {