@herb-tools/linter 0.4.3 → 0.6.0

package/src/cli/file-processor.ts

@@ -4,32 +4,33 @@ import { Herb } from "@herb-tools/node-wasm"
 import { Linter } from "../linter.js"
 import { colorize } from "@herb-tools/highlighter"
 import type { Diagnostic } from "@herb-tools/core"
+import type { FormatOption } from "./argument-parser.js"
 
 export interface ProcessedFile {
   filename: string
-  diagnostic: Diagnostic
+  offense: Diagnostic
   content: string
 }
 
 export interface ProcessingResult {
   totalErrors: number
   totalWarnings: number
-  filesWithIssues: number
+  filesWithOffenses: number
   ruleCount: number
-  allDiagnostics: ProcessedFile[]
-  ruleViolations: Map<string, { count: number, files: Set<string> }>
+  allOffenses: ProcessedFile[]
+  ruleOffenses: Map<string, { count: number, files: Set<string> }>
 }
 
 export class FileProcessor {
   private linter: Linter | null = null
 
-  async processFiles(files: string[]): Promise<ProcessingResult> {
+  async processFiles(files: string[], formatOption: FormatOption = 'detailed'): Promise<ProcessingResult> {
     let totalErrors = 0
     let totalWarnings = 0
-    let filesWithIssues = 0
+    let filesWithOffenses = 0
     let ruleCount = 0
-    const allDiagnostics: ProcessedFile[] = []
-    const ruleViolations = new Map<string, { count: number, files: Set<string> }>()
+    const allOffenses: ProcessedFile[] = []
+    const ruleOffenses = new Map<string, { count: number, files: Set<string> }>()
 
     for (const filename of files) {
       const filePath = resolve(filename)
@@ -38,14 +39,21 @@ export class FileProcessor {
       const parseResult = Herb.parse(content)
 
       if (parseResult.errors.length > 0) {
-        console.error(`${colorize(filename, "cyan")} - ${colorize("Parse errors:", "brightRed")}`)
+        if (formatOption !== 'json' && formatOption !== 'github') {
+          console.error(`${colorize(filename, "cyan")} - ${colorize("Parse errors:", "brightRed")}`)
 
+          for (const error of parseResult.errors) {
+            console.error(`  ${colorize("✗", "brightRed")} ${error.message}`)
+          }
+        }
+
+        // Add parse errors to offenses for JSON output
         for (const error of parseResult.errors) {
-          console.error(`  ${colorize("✗", "brightRed")} ${error.message}`)
+          allOffenses.push({ filename, offense: error, content })
         }
 
         totalErrors++
-        filesWithIssues++
+        filesWithOffenses++
         continue
       }
 
@@ -60,25 +68,25 @@ export class FileProcessor {
       }
 
       if (lintResult.offenses.length === 0) {
-        if (files.length === 1) {
+        if (files.length === 1 && formatOption !== 'json' && formatOption !== 'github') {
           console.log(`${colorize("✓", "brightGreen")} ${colorize(filename, "cyan")} - ${colorize("No issues found", "green")}`)
         }
       } else {
         for (const offense of lintResult.offenses) {
-          allDiagnostics.push({ filename, diagnostic: offense, content })
+          allOffenses.push({ filename, offense: offense, content })
 
-          const ruleData = ruleViolations.get(offense.rule) || { count: 0, files: new Set() }
+          const ruleData = ruleOffenses.get(offense.rule) || { count: 0, files: new Set() }
           ruleData.count++
           ruleData.files.add(filename)
-          ruleViolations.set(offense.rule, ruleData)
+          ruleOffenses.set(offense.rule, ruleData)
         }
 
         totalErrors += lintResult.errors
         totalWarnings += lintResult.warnings
-        filesWithIssues++
+        filesWithOffenses++
       }
     }
 
-    return { totalErrors, totalWarnings, filesWithIssues, ruleCount, allDiagnostics, ruleViolations }
+    return { totalErrors, totalWarnings, filesWithOffenses, ruleCount, allOffenses, ruleOffenses }
   }
 }

package/src/cli/formatters/base-formatter.ts

@@ -3,9 +3,9 @@ import type { ProcessedFile } from "../file-processor.js"
 
 export abstract class BaseFormatter {
   abstract format(
-    allDiagnostics: ProcessedFile[],
+    allOffenses: ProcessedFile[],
     isSingleFile?: boolean
   ): Promise<void>
 
-  abstract formatFile(filename: string, diagnostics: Diagnostic[]): void
+  abstract formatFile(filename: string, offenses: Diagnostic[]): void
 }

package/src/cli/formatters/detailed-formatter.ts

@@ -18,8 +18,8 @@ export class DetailedFormatter extends BaseFormatter {
     this.truncateLines = truncateLines
   }
 
-  async format(allDiagnostics: ProcessedFile[], isSingleFile: boolean = false): Promise<void> {
-    if (allDiagnostics.length === 0) return
+  async format(allOffenses: ProcessedFile[], isSingleFile: boolean = false): Promise<void> {
+    if (allOffenses.length === 0) return
 
     if (!this.highlighter) {
       this.highlighter = new Highlighter(this.theme)
@@ -28,8 +28,8 @@ export class DetailedFormatter extends BaseFormatter {
 
     if (isSingleFile) {
       // For single file, use inline diagnostics with syntax highlighting
-      const { filename, content } = allDiagnostics[0]
-      const diagnostics = allDiagnostics.map(item => item.diagnostic)
+      const { filename, content } = allOffenses[0]
+      const diagnostics = allOffenses.map(item => item.offense)
 
       const highlighted = this.highlighter.highlight(filename, content, {
         diagnostics: diagnostics,
@@ -42,11 +42,11 @@ export class DetailedFormatter extends BaseFormatter {
       console.log(`\n${highlighted}`)
     } else {
       // For multiple files, show individual diagnostics with syntax highlighting
-      const totalMessageCount = allDiagnostics.length
+      const totalMessageCount = allOffenses.length
 
-      for (let i = 0; i < allDiagnostics.length; i++) {
-        const { filename, diagnostic, content } = allDiagnostics[i]
-        const formatted = this.highlighter.highlightDiagnostic(filename, diagnostic, content, { 
+      for (let i = 0; i < allOffenses.length; i++) {
+        const { filename, offense, content } = allOffenses[i]
+        const formatted = this.highlighter.highlightDiagnostic(filename, offense, content, { 
           contextLines: 2, 
           wrapLines: this.wrapLines,
           truncateLines: this.truncateLines
@@ -67,7 +67,7 @@ export class DetailedFormatter extends BaseFormatter {
     }
   }
 
-  formatFile(_filename: string, _diagnostics: Diagnostic[]): void {
+  formatFile(_filename: string, _offenses: Diagnostic[]): void {
     // Not used in detailed formatter
     throw new Error("formatFile is not implemented for DetailedFormatter")
   }

package/src/cli/formatters/github-actions-formatter.ts

@@ -0,0 +1,70 @@
+import { BaseFormatter } from "./base-formatter.js"
+
+import type { Diagnostic } from "@herb-tools/core"
+import type { ProcessedFile } from "../file-processor.js"
+
+// https://docs.github.com/en/actions/reference/workflows-and-actions/workflow-commands
+export class GitHubActionsFormatter extends BaseFormatter {
+  private static readonly MESSAGE_ESCAPE_MAP: Record<string, string> = {
+    '%': '%25',
+    '\n': '%0A',
+    '\r': '%0D'
+  }
+
+  private static readonly PARAM_ESCAPE_MAP: Record<string, string> = {
+    '%': '%25',
+    '\n': '%0A',
+    '\r': '%0D',
+    ':': '%3A',
+    ',': '%2C'
+  }
+
+  async format(allDiagnostics: ProcessedFile[]): Promise<void> {
+    for (const { filename, offense } of allDiagnostics) {
+      this.formatDiagnostic(filename, offense)
+    }
+
+    if (allDiagnostics.length > 0) {
+      console.log()
+    }
+  }
+
+  formatFile(filename: string, diagnostics: Diagnostic[]): void {
+    for (const diagnostic of diagnostics) {
+      this.formatDiagnostic(filename, diagnostic)
+    }
+  }
+
+  // GitHub Actions annotation format:
+  // ::{level} file={file},line={line},col={col}::{message}
+  //
+  private formatDiagnostic(filename: string, diagnostic: Diagnostic): void {
+    const level = diagnostic.severity === "error" ? "error" : "warning"
+    const { line, column } = diagnostic.location.start
+
+    const escapedFilename = this.escapeParam(filename)
+    const message = this.escapeMessage(diagnostic.message)
+
+    let fullMessage = message
+
+    if (diagnostic.code) {
+      fullMessage += ` [${diagnostic.code}]`
+    }
+
+    console.log(`\n::${level} file=${escapedFilename},line=${line},col=${column}::${fullMessage}`)
+  }
+
+  private escapeMessage(string: string): string {
+    return string.replace(
+      new RegExp(Object.keys(GitHubActionsFormatter.MESSAGE_ESCAPE_MAP).map(k => k.replace(/[.*+?^${}()|[\]\\]/g, '\\$&')).join('|'), 'g'),
+      match => GitHubActionsFormatter.MESSAGE_ESCAPE_MAP[match]
+    )
+  }
+
+  private escapeParam(string: string): string {
+    return string.replace(
+      new RegExp(Object.keys(GitHubActionsFormatter.PARAM_ESCAPE_MAP).map(k => k.replace(/[.*+?^${}()|[\]\\]/g, '\\$&')).join('|'), 'g'),
+      match => GitHubActionsFormatter.PARAM_ESCAPE_MAP[match]
+    )
+  }
+}

package/src/cli/formatters/index.ts

@@ -1,3 +1,5 @@
 export { BaseFormatter } from "./base-formatter.js"
 export { SimpleFormatter } from "./simple-formatter.js"
 export { DetailedFormatter } from "./detailed-formatter.js"
+export { JSONFormatter, type JSONOutput } from "./json-formatter.js"
+export { GitHubActionsFormatter } from "./github-actions-formatter.js"

package/src/cli/formatters/json-formatter.ts

@@ -0,0 +1,107 @@
+import { BaseFormatter } from "./base-formatter.js"
+
+import type { Diagnostic, SerializedDiagnostic } from "@herb-tools/core"
+import type { ProcessedFile } from "../file-processor.js"
+
+interface JSONOffense extends SerializedDiagnostic {
+  filename: string
+}
+
+interface JSONSummary {
+  filesChecked: number
+  filesWithOffenses: number
+  totalErrors: number
+  totalWarnings: number
+  totalOffenses: number
+  ruleCount: number
+}
+
+interface JSONTiming {
+  startTime: string
+  duration: number
+}
+
+export interface JSONOutput {
+  offenses: JSONOffense[]
+  summary: JSONSummary | null
+  timing: JSONTiming | null
+  completed: boolean
+  clean: boolean | null
+  message: string | null
+}
+
+interface JSONFormatOptions {
+  files: string[]
+  totalErrors: number
+  totalWarnings: number
+  filesWithOffenses: number
+  ruleCount: number
+  startTime: number
+  startDate: Date
+  showTiming: boolean
+}
+
+export class JSONFormatter extends BaseFormatter {
+  async format(allOffenses: ProcessedFile[]): Promise<void> {
+    const jsonOffenses: JSONOffense[] = allOffenses.map(({ filename, offense }) => ({
+      filename,
+      message: offense.message,
+      location: offense.location.toJSON(),
+      severity: offense.severity,
+      code: offense.code,
+      source: offense.source
+    }))
+
+    const output: JSONOutput = {
+      offenses: jsonOffenses,
+      summary: null,
+      timing: null,
+      completed: true,
+      clean: jsonOffenses.length === 0,
+      message: null
+    }
+
+    console.log(JSON.stringify(output, null, 2))
+  }
+
+  async formatWithSummary(allOffenses: ProcessedFile[], options: JSONFormatOptions): Promise<void> {
+    const jsonOffenses: JSONOffense[] = allOffenses.map(({ filename, offense }) => ({
+      filename,
+      message: offense.message,
+      location: offense.location.toJSON(),
+      severity: offense.severity,
+      code: offense.code,
+      source: offense.source
+    }))
+
+    const summary: JSONSummary = {
+      filesChecked: options.files.length,
+      filesWithOffenses: options.filesWithOffenses,
+      totalErrors: options.totalErrors,
+      totalWarnings: options.totalWarnings,
+      totalOffenses: options.totalErrors + options.totalWarnings,
+      ruleCount: options.ruleCount
+    }
+
+    const output: JSONOutput = {
+      offenses: jsonOffenses,
+      summary,
+      timing: null,
+      completed: true,
+      clean: options.totalErrors === 0 && options.totalWarnings === 0,
+      message: null
+    }
+
+    const duration = Date.now() - options.startTime
+    output.timing = options.showTiming ? {
+      startTime: options.startDate.toISOString(),
+      duration: duration
+    } : null
+
+    console.log(JSON.stringify(output, null, 2))
+  }
+
+  formatFile(_filename: string, _offenses: Diagnostic[]): void {
+    // Not used in JSON formatter, everything is handled in format()
+  }
+}

package/src/cli/formatters/simple-formatter.ts

@@ -6,34 +6,34 @@ import type { Diagnostic } from "@herb-tools/core"
 import type { ProcessedFile } from "../file-processor.js"
 
 export class SimpleFormatter extends BaseFormatter {
-  async format(allDiagnostics: ProcessedFile[]): Promise<void> {
-    if (allDiagnostics.length === 0) return
+  async format(allOffenses: ProcessedFile[]): Promise<void> {
+    if (allOffenses.length === 0) return
 
-    const groupedDiagnostics = new Map<string, Diagnostic[]>()
+    const groupedOffenses = new Map<string, Diagnostic[]>()
 
-    for (const { filename, diagnostic } of allDiagnostics) {
-      const diagnostics = groupedDiagnostics.get(filename) || []
-      diagnostics.push(diagnostic)
-      groupedDiagnostics.set(filename, diagnostics)
+    for (const { filename, offense } of allOffenses) {
+      const offenses = groupedOffenses.get(filename) || []
+      offenses.push(offense)
+      groupedOffenses.set(filename, offenses)
     }
 
-    for (const [filename, diagnostics] of groupedDiagnostics) {
+    for (const [filename, offenses] of groupedOffenses) {
       console.log("")
-      this.formatFile(filename, diagnostics)
+      this.formatFile(filename, offenses)
     }
   }
 
-  formatFile(filename: string, diagnostics: Diagnostic[]): void {
+  formatFile(filename: string, offenses: Diagnostic[]): void {
     console.log(`${colorize(filename, "cyan")}:`)
 
-    for (const diagnostic of diagnostics) {
-      const isError = diagnostic.severity === "error"
+    for (const offense of offenses) {
+      const isError = offense.severity === "error"
       const severity = isError ? colorize("✗", "brightRed") : colorize("⚠", "brightYellow")
-      const rule = colorize(`(${diagnostic.code})`, "blue")
-      const locationString = `${diagnostic.location.start.line}:${diagnostic.location.start.column}`
+      const rule = colorize(`(${offense.code})`, "blue")
+      const locationString = `${offense.location.start.line}:${offense.location.start.column}`
       const paddedLocation = locationString.padEnd(4) // Pad to 4 characters for alignment
 
-      console.log(`  ${colorize(paddedLocation, "gray")} ${severity} ${diagnostic.message} ${rule}`)
+      console.log(`  ${colorize(paddedLocation, "gray")} ${severity} ${offense.message} ${rule}`)
     }
     console.log("")
   }

package/src/cli/output-manager.ts

@@ -0,0 +1,143 @@
+import { SummaryReporter } from "./summary-reporter.js"
+import { SimpleFormatter, DetailedFormatter, GitHubActionsFormatter, type JSONOutput } from "./formatters/index.js"
+
+import type { ThemeInput } from "@herb-tools/highlighter"
+import type { FormatOption } from "./argument-parser.js"
+import type { ProcessingResult } from "./file-processor.js"
+
+interface OutputOptions {
+  formatOption: FormatOption
+  theme: ThemeInput
+  wrapLines: boolean
+  truncateLines: boolean
+  showTiming: boolean
+  startTime: number
+  startDate: Date
+}
+
+interface LintResults extends ProcessingResult {
+  files: string[]
+}
+
+export class OutputManager {
+  private summaryReporter = new SummaryReporter()
+
+  /**
+   * Output successful lint results
+   */
+  async outputResults(results: LintResults, options: OutputOptions): Promise<void> {
+    const { allOffenses, files, totalErrors, totalWarnings, filesWithOffenses, ruleCount, ruleOffenses } = results
+
+    if (options.formatOption === "github") {
+      const formatter = new GitHubActionsFormatter()
+      await formatter.format(allOffenses)
+    } else if (options.formatOption === "json") {
+      const output: JSONOutput = {
+        offenses: allOffenses.map(({ filename, offense }) => ({
+          filename,
+          message: offense.message,
+          location: offense.location.toJSON(),
+          severity: offense.severity,
+          code: offense.code,
+          source: offense.source
+        })),
+        summary: {
+          filesChecked: files.length,
+          filesWithOffenses,
+          totalErrors,
+          totalWarnings,
+          totalOffenses: totalErrors + totalWarnings,
+          ruleCount
+        },
+        timing: null,
+        completed: true,
+        clean: totalErrors === 0 && totalWarnings === 0,
+        message: null
+      }
+
+      const duration = Date.now() - options.startTime
+      output.timing = options.showTiming ? {
+        startTime: options.startDate.toISOString(),
+        duration: duration
+      } : null
+
+      console.log(JSON.stringify(output, null, 2))
+    } else {
+      const formatter = options.formatOption === "simple"
+        ? new SimpleFormatter()
+        : new DetailedFormatter(options.theme, options.wrapLines, options.truncateLines)
+
+      await formatter.format(allOffenses, files.length === 1)
+
+      this.summaryReporter.displayMostViolatedRules(ruleOffenses)
+      this.summaryReporter.displaySummary({
+        files,
+        totalErrors,
+        totalWarnings,
+        filesWithOffenses,
+        ruleCount,
+        startTime: options.startTime,
+        startDate: options.startDate,
+        showTiming: options.showTiming,
+        ruleOffenses
+      })
+    }
+  }
+
+  /**
+   * Output informational message (like "no files found")
+   */
+  outputInfo(message: string, options: OutputOptions): void {
+    if (options.formatOption === "github") {
+      // GitHub Actions format doesn't output anything for info messages
+    } else if (options.formatOption === "json") {
+      const output: JSONOutput = {
+        offenses: [],
+        summary: {
+          filesChecked: 0,
+          filesWithOffenses: 0,
+          totalErrors: 0,
+          totalWarnings: 0,
+          totalOffenses: 0,
+          ruleCount: 0
+        },
+        timing: null,
+        completed: false,
+        clean: null,
+        message
+      }
+
+      const duration = Date.now() - options.startTime
+      output.timing = options.showTiming ? {
+        startTime: options.startDate.toISOString(),
+        duration: duration
+      } : null
+
+      console.log(JSON.stringify(output, null, 2))
+    } else {
+      console.log(message)
+    }
+  }
+
+  /**
+   * Output error message
+   */
+  outputError(message: string, options: OutputOptions): void {
+    if (options.formatOption === "github") {
+      console.log(`::error::${message}`)
+    } else if (options.formatOption === "json") {
+      const output: JSONOutput = {
+        offenses: [],
+        summary: null,
+        timing: null,
+        completed: false,
+        clean: null,
+        message
+      }
+
+      console.log(JSON.stringify(output, null, 2))
+    } else {
+      console.error(message)
+    }
+  }
+}

package/src/cli/summary-reporter.ts

@@ -4,12 +4,12 @@ export interface SummaryData {
   files: string[]
   totalErrors: number
   totalWarnings: number
-  filesWithViolations: number
+  filesWithOffenses: number
   ruleCount: number
   startTime: number
   startDate: Date
   showTiming: boolean
-  ruleViolations: Map<string, { count: number, files: Set<string> }>
+  ruleOffenses: Map<string, { count: number, files: Set<string> }>
 }
 
 export class SummaryReporter {
@@ -18,13 +18,13 @@ export class SummaryReporter {
   }
 
   displaySummary(data: SummaryData): void {
-    const { files, totalErrors, totalWarnings, filesWithViolations, ruleCount, startTime, startDate, showTiming } = data
+    const { files, totalErrors, totalWarnings, filesWithOffenses, ruleCount, startTime, startDate, showTiming } = data
 
     console.log("\n")
     console.log(` ${colorize("Summary:", "bold")}`)
 
     // Calculate padding for alignment
-    const labelWidth = 12 // Width for the longest label "Violations"
+    const labelWidth = 12 // Width for the longest label "Offenses"
     const pad = (label: string) => label.padEnd(labelWidth)
 
     // Checked summary
@@ -33,13 +33,13 @@ export class SummaryReporter {
     // Files summary (for multiple files)
     if (files.length > 1) {
       const filesChecked = files.length
-      const filesClean = filesChecked - filesWithViolations
+      const filesClean = filesChecked - filesWithOffenses
 
       let filesSummary = ""
       let shouldDim = false
 
-      if (filesWithViolations > 0) {
-        filesSummary = `${colorize(colorize(`${filesWithViolations} with violations`, "brightRed"), "bold")} | ${colorize(colorize(`${filesClean} clean`, "green"), "bold")} ${colorize(colorize(`(${filesChecked} total)`, "gray"), "dim")}`
+      if (filesWithOffenses > 0) {
+        filesSummary = `${colorize(colorize(`${filesWithOffenses} with offenses`, "brightRed"), "bold")} | ${colorize(colorize(`${filesClean} clean`, "green"), "bold")} ${colorize(colorize(`(${filesChecked} total)`, "gray"), "dim")}`
       } else {
         filesSummary = `${colorize(colorize(`${filesChecked} clean`, "green"), "bold")} ${colorize(colorize(`(${filesChecked} total)`, "gray"), "dim")}`
         shouldDim = true
@@ -52,8 +52,8 @@ export class SummaryReporter {
       }
     }
 
-    // Violations summary with file count
-    let violationsSummary = ""
+    // Offenses summary with file count
+    let offensesSummary = ""
     const parts = []
 
     // Build the main part with errors and warnings
@@ -69,22 +69,22 @@ export class SummaryReporter {
     }
 
     if (parts.length === 0) {
-      violationsSummary = colorize(colorize("0 violations", "green"), "bold")
+      offensesSummary = colorize(colorize("0 offenses", "green"), "bold")
     } else {
-      violationsSummary = parts.join(" | ")
+      offensesSummary = parts.join(" | ")
       // Add total count and file count
       let detailText = ""
 
-      const totalViolations = totalErrors + totalWarnings
+      const totalOffenses = totalErrors + totalWarnings
 
-      if (filesWithViolations > 0) {
-        detailText = `${totalViolations} ${this.pluralize(totalViolations, "violation")} across ${filesWithViolations} ${this.pluralize(filesWithViolations, "file")}`
+      if (filesWithOffenses > 0) {
+        detailText = `${totalOffenses} ${this.pluralize(totalOffenses, "offense")} across ${filesWithOffenses} ${this.pluralize(filesWithOffenses, "file")}`
       }
 
-      violationsSummary += ` ${colorize(colorize(`(${detailText})`, "gray"), "dim")}`
+      offensesSummary += ` ${colorize(colorize(`(${detailText})`, "gray"), "dim")}`
     }
 
-    console.log(`  ${colorize(pad("Violations"), "gray")} ${violationsSummary}`)
+    console.log(`  ${colorize(pad("Offenses"), "gray")} ${offensesSummary}`)
 
     // Timing information (if enabled)
     if (showTiming) {
@@ -96,32 +96,32 @@ export class SummaryReporter {
     }
 
     // Success message for all files clean
-    if (filesWithViolations === 0 && files.length > 1) {
+    if (filesWithOffenses === 0 && files.length > 1) {
       console.log("")
       console.log(` ${colorize("✓", "brightGreen")} ${colorize("All files are clean!", "green")}`)
     }
   }
 
-  displayMostViolatedRules(ruleViolations: Map<string, { count: number, files: Set<string> }>, limit: number = 5): void {
-    if (ruleViolations.size === 0) return
+  displayMostViolatedRules(ruleOffenses: Map<string, { count: number, files: Set<string> }>, limit: number = 5): void {
+    if (ruleOffenses.size === 0) return
 
-    const allRules = Array.from(ruleViolations.entries()).sort((a, b) => b[1].count - a[1].count)
+    const allRules = Array.from(ruleOffenses.entries()).sort((a, b) => b[1].count - a[1].count)
     const displayedRules = allRules.slice(0, limit)
     const remainingRules = allRules.slice(limit)
 
-    const title = ruleViolations.size <= limit ? "Rule violations:" : "Most violated rules:"
+    const title = ruleOffenses.size <= limit ? "Rule offenses:" : "Most frequent rule offenses:"
     console.log(` ${colorize(title, "bold")}`)
 
     for (const [rule, data] of displayedRules) {
       const fileCount = data.files.size
-      const countText = `(${data.count} ${this.pluralize(data.count, "violation")} in ${fileCount} ${this.pluralize(fileCount, "file")})`
+      const countText = `(${data.count} ${this.pluralize(data.count, "offense")} in ${fileCount} ${this.pluralize(fileCount, "file")})`
       console.log(`  ${colorize(rule, "gray")} ${colorize(colorize(countText, "gray"), "dim")}`)
     }
 
     if (remainingRules.length > 0) {
-      const remainingViolationCount = remainingRules.reduce((sum, [_, data]) => sum + data.count, 0)
+      const remainingOffenseCount = remainingRules.reduce((sum, [_, data]) => sum + data.count, 0)
       const remainingRuleCount = remainingRules.length
-      console.log(colorize(colorize(`\n  ...and ${remainingRuleCount} more ${this.pluralize(remainingRuleCount, "rule")} with ${remainingViolationCount} ${this.pluralize(remainingViolationCount, "violation")}`, "gray"), "dim"))
+      console.log(colorize(colorize(`\n  ...and ${remainingRuleCount} more ${this.pluralize(remainingRuleCount, "rule")} with ${remainingOffenseCount} ${this.pluralize(remainingOffenseCount, "offense")}`, "gray"), "dim"))
     }
   }
 }