@herb-tools/linter 0.7.4 → 0.8.0

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

@@ -29,7 +29,15 @@ export class DetailedFormatter extends BaseFormatter {
 
     if (isSingleFile) {
       const { filename, content } = allOffenses[0]
-      const diagnostics = allOffenses.map(item => item.offense)
+      const diagnostics = allOffenses.map(item => {
+        if (item.autocorrectable && item.offense.code) {
+          return {
+            ...item.offense,
+            message: `${item.offense.message} ${colorize(colorize("[Correctable]", "green"), "bold")}`
+          }
+        }
+        return item.offense
+      })
 
       const highlighted = this.highlighter.highlight(filename, content, {
         diagnostics: diagnostics,
@@ -44,8 +52,18 @@ export class DetailedFormatter extends BaseFormatter {
       const totalMessageCount = allOffenses.length
 
       for (let i = 0; i < allOffenses.length; i++) {
-        const { filename, offense, content } = allOffenses[i]
-        const formatted = this.highlighter.highlightDiagnostic(filename, offense, content, {
+        const { filename, offense, content, autocorrectable } = allOffenses[i]
+
+        let modifiedOffense = offense
+
+        if (autocorrectable && offense.code) {
+          modifiedOffense = {
+            ...offense,
+            message: `${offense.message} ${colorize(colorize("[Correctable]", "green"), "bold")}`
+          }
+        }
+
+        const formatted = this.highlighter.highlightDiagnostic(filename, modifiedOffense, content, {
           contextLines: 2,
           wrapLines: this.wrapLines,
           truncateLines: this.truncateLines

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

@@ -79,7 +79,23 @@ export class GitHubActionsFormatter extends BaseFormatter {
   // ::{level} file={file},line={line},col={col},title={title}::{message}
   //
   private formatDiagnostic(filename: string, diagnostic: Diagnostic, codePreview: string = ""): void {
-    const level = diagnostic.severity === "error" ? "error" : "warning"
+    let level: string
+
+    switch (diagnostic.severity) {
+      case "error":
+        level = "error"
+        break
+      case "warning":
+        level = "warning"
+        break
+      case "info":
+      case "hint":
+        level = "notice"
+        break
+      default:
+        level = "warning"
+    }
+
     const { line, column } = diagnostic.location.start
 
     const escapedFilename = this.escapeParam(filename)

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

@@ -12,6 +12,9 @@ interface JSONSummary {
   filesWithOffenses: number
   totalErrors: number
   totalWarnings: number
+  totalInfo: number
+  totalHints: number
+  totalIgnored: number
   totalOffenses: number
   ruleCount: number
 }
@@ -34,6 +37,9 @@ interface JSONFormatOptions {
   files: string[]
   totalErrors: number
   totalWarnings: number
+  totalInfo: number
+  totalHints: number
+  totalIgnored: number
   filesWithOffenses: number
   ruleCount: number
   startTime: number
@@ -79,6 +85,9 @@ export class JSONFormatter extends BaseFormatter {
       filesWithOffenses: options.filesWithOffenses,
       totalErrors: options.totalErrors,
       totalWarnings: options.totalWarnings,
+      totalInfo: options.totalInfo,
+      totalHints: options.totalHints,
+      totalIgnored: options.totalIgnored,
       totalOffenses: options.totalErrors + options.totalWarnings,
       ruleCount: options.ruleCount
     }

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

@@ -9,17 +9,17 @@ export class SimpleFormatter extends BaseFormatter {
   async format(allOffenses: ProcessedFile[]): Promise<void> {
     if (allOffenses.length === 0) return
 
-    const groupedOffenses = new Map<string, Diagnostic[]>()
+    const groupedOffenses = new Map<string, ProcessedFile[]>()
 
-    for (const { filename, offense } of allOffenses) {
-      const offenses = groupedOffenses.get(filename) || []
-      offenses.push(offense)
-      groupedOffenses.set(filename, offenses)
+    for (const processedFile of allOffenses) {
+      const offenses = groupedOffenses.get(processedFile.filename) || []
+      offenses.push(processedFile)
+      groupedOffenses.set(processedFile.filename, offenses)
     }
 
-    for (const [filename, offenses] of groupedOffenses) {
+    for (const [filename, processedFiles] of groupedOffenses) {
       console.log("")
-      this.formatFile(filename, offenses)
+      this.formatFileProcessed(filename, processedFiles)
     }
   }
 
@@ -31,10 +31,26 @@ export class SimpleFormatter extends BaseFormatter {
       const severity = isError ? colorize("✗", "brightRed") : colorize("⚠", "brightYellow")
       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
+      const paddedLocation = locationString.padEnd(4)
 
       console.log(`  ${colorize(paddedLocation, "gray")} ${severity} ${offense.message} ${rule}`)
     }
     console.log("")
   }
+
+  formatFileProcessed(filename: string, processedFiles: ProcessedFile[]): void {
+    console.log(`${colorize(filename, "cyan")}:`)
+
+    for (const { offense, autocorrectable } of processedFiles) {
+      const isError = offense.severity === "error"
+      const severity = isError ? colorize("✗", "brightRed") : colorize("⚠", "brightYellow")
+      const rule = colorize(`(${offense.code})`, "blue")
+      const locationString = `${offense.location.start.line}:${offense.location.start.column}`
+      const paddedLocation = locationString.padEnd(4)
+      const correctable = autocorrectable ? colorize(colorize(" [Correctable]", "green"), "bold") : ""
+
+      console.log(`  ${colorize(paddedLocation, "gray")} ${severity} ${offense.message} ${rule}${correctable}`)
+    }
+    console.log("")
+  }
 }

package/src/cli/output-manager.ts

@@ -27,7 +27,9 @@ export class OutputManager {
    * Output successful lint results
    */
   async outputResults(results: LintResults, options: OutputOptions): Promise<void> {
-    const { allOffenses, files, totalErrors, totalWarnings, filesWithOffenses, ruleCount, ruleOffenses } = results
+    const { allOffenses, files, totalErrors, totalWarnings, totalInfo, totalHints, totalIgnored, totalWouldBeIgnored, filesWithOffenses, ruleCount, ruleOffenses, context } = results
+
+    const autofixableCount = allOffenses.filter(offense => offense.autocorrectable).length
 
     if (options.useGitHubActions) {
       const githubFormatter = new GitHubActionsFormatter(options.wrapLines, options.truncateLines)
@@ -45,12 +47,18 @@ export class OutputManager {
           files,
           totalErrors,
           totalWarnings,
+          totalInfo,
+          totalHints,
+          totalIgnored,
+          totalWouldBeIgnored,
           filesWithOffenses,
           ruleCount,
           startTime: options.startTime,
           startDate: options.startDate,
           showTiming: options.showTiming,
-          ruleOffenses
+          ruleOffenses,
+          autofixableCount,
+          ignoreDisableComments: context?.ignoreDisableComments,
         })
       }
     } else if (options.formatOption === "json") {
@@ -68,6 +76,9 @@ export class OutputManager {
           filesWithOffenses,
           totalErrors,
           totalWarnings,
+          totalInfo,
+          totalHints,
+          totalIgnored,
           totalOffenses: totalErrors + totalWarnings,
           ruleCount
         },
@@ -96,12 +107,18 @@ export class OutputManager {
         files,
         totalErrors,
         totalWarnings,
+        totalInfo,
+        totalHints,
+        totalIgnored,
+        totalWouldBeIgnored,
         filesWithOffenses,
         ruleCount,
         startTime: options.startTime,
         startDate: options.startDate,
         showTiming: options.showTiming,
-        ruleOffenses
+        ruleOffenses,
+        autofixableCount,
+        ignoreDisableComments: context?.ignoreDisableComments,
       })
     }
   }
@@ -120,6 +137,9 @@ export class OutputManager {
           filesWithOffenses: 0,
           totalErrors: 0,
           totalWarnings: 0,
+          totalInfo: 0,
+          totalHints: 0,
+          totalIgnored: 0,
           totalOffenses: 0,
           ruleCount: 0
         },

package/src/cli/summary-reporter.ts

@@ -4,12 +4,18 @@ export interface SummaryData {
   files: string[]
   totalErrors: number
   totalWarnings: number
+  totalInfo?: number
+  totalHints?: number
+  totalIgnored: number
+  totalWouldBeIgnored?: number
   filesWithOffenses: number
   ruleCount: number
   startTime: number
   startDate: Date
   showTiming: boolean
   ruleOffenses: Map<string, { count: number, files: Set<string> }>
+  autofixableCount: number
+  ignoreDisableComments?: boolean
 }
 
 export class SummaryReporter {
@@ -18,7 +24,7 @@ export class SummaryReporter {
   }
 
   displaySummary(data: SummaryData): void {
-    const { files, totalErrors, totalWarnings, filesWithOffenses, ruleCount, startTime, startDate, showTiming } = data
+    const { files, totalErrors, totalWarnings, totalInfo = 0, totalHints = 0, totalIgnored, totalWouldBeIgnored, filesWithOffenses, ruleCount, startTime, startDate, showTiming, autofixableCount, ignoreDisableComments } = data
 
     console.log("\n")
     console.log(` ${colorize("Summary:", "bold")}`)
@@ -62,6 +68,18 @@ export class SummaryReporter {
       parts.push(colorize(colorize(`${totalWarnings} ${this.pluralize(totalWarnings, "warning")}`, "green"), "bold"))
     }
 
+    if (totalInfo > 0) {
+      parts.push(colorize(colorize(`${totalInfo} info`, "brightBlue"), "bold"))
+    }
+
+    if (totalHints > 0) {
+      parts.push(colorize(colorize(`${totalHints} ${this.pluralize(totalHints, "hint")}`, "gray"), "bold"))
+    }
+
+    if (totalIgnored > 0) {
+      parts.push(colorize(colorize(`${totalIgnored} ignored`, "gray"), "bold"))
+    }
+
     if (parts.length === 0) {
       offensesSummary = colorize(colorize("0 offenses", "green"), "bold")
     } else {
@@ -69,17 +87,36 @@ export class SummaryReporter {
 
       let detailText = ""
 
-      const totalOffenses = totalErrors + totalWarnings
+      const totalOffenses = totalErrors + totalWarnings + totalInfo + totalHints
 
       if (filesWithOffenses > 0) {
         detailText = `${totalOffenses} ${this.pluralize(totalOffenses, "offense")} across ${filesWithOffenses} ${this.pluralize(filesWithOffenses, "file")}`
       }
 
-      offensesSummary += ` ${colorize(colorize(`(${detailText})`, "gray"), "dim")}`
+      if (detailText) {
+        offensesSummary += ` ${colorize(colorize(`(${detailText})`, "gray"), "dim")}`
+      }
     }
 
     console.log(`  ${colorize(pad("Offenses"), "gray")} ${offensesSummary}`)
 
+    if (ignoreDisableComments && totalWouldBeIgnored && totalWouldBeIgnored > 0) {
+      const message = `${colorize(colorize(`${totalWouldBeIgnored} additional ${this.pluralize(totalWouldBeIgnored, "offense")} reported (would have been ignored)`, "cyan"), "bold")}`
+      console.log(`  ${colorize(pad("Note"), "gray")} ${message}`)
+    }
+
+    const totalOffenses = totalErrors + totalWarnings + totalInfo + totalHints
+
+    if (autofixableCount > 0 || totalOffenses > 0) {
+      let fixableLine = `${colorize(colorize(`${totalOffenses} ${this.pluralize(totalOffenses, "offense")}`, "brightRed"), "bold")}`
+
+      if (autofixableCount > 0) {
+        fixableLine += ` | ${colorize(colorize(`${autofixableCount} autocorrectable using \`--fix\``, "green"), "bold")}`
+      }
+
+      console.log(`  ${colorize(pad("Fixable"), "gray")} ${fixableLine}`)
+    }
+
     if (showTiming) {
       const duration = Date.now() - startTime
       const timeString = startDate.toTimeString().split(' ')[0]

package/src/cli.ts

@@ -1,11 +1,17 @@
 import { glob } from "glob"
 import { Herb } from "@herb-tools/node-wasm"
+import { Config, addHerbExtensionRecommendation, getExtensionsJsonRelativePath } from "@herb-tools/config"
+
 import { existsSync, statSync } from "fs"
 import { dirname, resolve, relative } from "path"
 
-import { ArgumentParser, type FormatOption } from "./cli/argument-parser.js"
+import { ArgumentParser } from "./cli/argument-parser.js"
 import { FileProcessor } from "./cli/file-processor.js"
 import { OutputManager } from "./cli/output-manager.js"
+import { version } from "../package.json"
+
+import type { ProcessingContext } from "./cli/file-processor.js"
+import type { FormatOption } from "./cli/argument-parser.js"
 
 export * from "./cli/index.js"
 
@@ -19,44 +25,6 @@ export class CLI {
     return this.projectPath
   }
 
-  protected findProjectRoot(startPath: string): string {
-    let currentPath = resolve(startPath)
-
-    if (existsSync(currentPath) && statSync(currentPath).isFile()) {
-      currentPath = dirname(currentPath)
-    }
-
-    const projectIndicators = [
-      'package.json',
-      'Gemfile',
-      '.git',
-      'tsconfig.json',
-      'composer.json',
-      'pyproject.toml',
-      'requirements.txt',
-      '.herb.yml'
-    ]
-
-    while (currentPath !== '/') {
-      for (const indicator of projectIndicators) {
-        if (existsSync(resolve(currentPath, indicator))) {
-          return currentPath
-        }
-      }
-
-      const parentPath = dirname(currentPath)
-      if (parentPath === currentPath) {
-        break
-      }
-
-      currentPath = parentPath
-    }
-
-    return existsSync(startPath) && statSync(startPath).isDirectory()
-      ? startPath
-      : dirname(startPath)
-  }
-
   protected exitWithError(message: string, formatOption: FormatOption, exitCode: number = 1) {
     this.outputManager.outputError(message, {
       formatOption,
@@ -87,7 +55,8 @@ export class CLI {
     process.exit(exitCode)
   }
 
-  protected determineProjectPath(pattern: string | undefined): void {
+  protected determineProjectPath(patterns: string[]): void {
+    const pattern = patterns[0]
     if (pattern) {
       const resolvedPattern = resolve(pattern)
 
@@ -97,15 +66,15 @@ export class CLI {
         if (stats.isDirectory()) {
           this.projectPath = resolvedPattern
         } else {
-          this.projectPath = this.findProjectRoot(resolvedPattern)
+          this.projectPath = dirname(resolvedPattern)
         }
       }
     }
   }
 
-  protected adjustPattern(pattern: string | undefined): string {
+  protected adjustPattern(pattern: string | undefined, configGlobPattern: string): string {
     if (!pattern) {
-      return '**/*.html.erb'
+      return configGlobPattern
     }
 
     const resolvedPattern = resolve(pattern)
@@ -114,7 +83,7 @@ export class CLI {
       const stats = statSync(resolvedPattern)
 
       if (stats.isDirectory()) {
-        return '**/*.html.erb'
+        return configGlobPattern
       } else if (stats.isFile()) {
         return relative(this.projectPath, resolvedPattern)
       }
@@ -123,8 +92,43 @@ export class CLI {
     return pattern
   }
 
+  protected async resolvePatternToFiles(pattern: string, config: Config, force: boolean): Promise<{ files: string[], explicitFile: string | undefined }> {
+    const resolvedPattern = resolve(pattern)
+    const isExplicitFile = existsSync(resolvedPattern) && statSync(resolvedPattern).isFile()
+    let explicitFile: string | undefined
+
+    if (isExplicitFile) {
+      explicitFile = pattern
+    }
+
+    const filesConfig = config.getFilesConfigForTool('linter')
+    const configGlobPattern = filesConfig.include && filesConfig.include.length > 0
+      ? (filesConfig.include.length === 1 ? filesConfig.include[0] : `{${filesConfig.include.join(',')}}`)
+      : '**/*.html.erb'
+    const adjustedPattern = this.adjustPattern(pattern, configGlobPattern)
+
+    let files = await glob(adjustedPattern, {
+      cwd: this.projectPath,
+      ignore: filesConfig.exclude || []
+    })
+
+    if (explicitFile && files.length === 0) {
+      if (!force) {
+        console.error(`⚠️  File ${explicitFile} is excluded by configuration patterns.`)
+        console.error(`   Use --force to lint it anyway.\n`)
+        process.exit(0)
+      } else {
+        console.log(`⚠️  Forcing linter on excluded file: ${explicitFile}`)
+        console.log()
+        files = [adjustedPattern]
+      }
+    }
+
+    return { files, explicitFile }
+  }
+
   protected async beforeProcess(): Promise<void> {
-    await Herb.load()
+    // Hook for subclasses to add custom output before processing
   }
 
   protected async afterProcess(_results: any, _outputOptions: any): Promise<void> {
@@ -132,14 +136,41 @@ export class CLI {
   }
 
   async run() {
+    await Herb.load()
+
     const startTime = Date.now()
     const startDate = new Date()
 
-    let { pattern, formatOption, showTiming, theme, wrapLines, truncateLines, useGitHubActions } = this.argumentParser.parse(process.argv)
+    let { patterns, configFile, formatOption, showTiming, theme, wrapLines, truncateLines, useGitHubActions, fix, ignoreDisableComments, force, init, loadCustomRules } = this.argumentParser.parse(process.argv)
+
+    this.determineProjectPath(patterns)
+
+    if (init) {
+      const configPath = configFile || this.projectPath
+
+      if (Config.exists(configPath)) {
+        const fullPath = configFile || Config.configPathFromProjectPath(this.projectPath)
+        console.error(`\n✗ Configuration file already exists at ${fullPath}`)
+        console.error(`  Use --config-file to specify a different location.\n`)
+        process.exit(1)
+      }
+
+      const config = await Config.loadForCLI(configPath, version, true)
+      const extensionAdded = addHerbExtensionRecommendation(this.projectPath)
 
-    this.determineProjectPath(pattern)
+      console.log(`\n✓ Configuration initialized at ${config.path}`)
 
-    pattern = this.adjustPattern(pattern)
+      if (extensionAdded) {
+        console.log(`✓ VSCode extension recommended in ${getExtensionsJsonRelativePath()}`)
+      }
+
+      console.log(`  Edit this file to customize linter and formatter settings.\n`)
+      process.exit(0)
+    }
+
+    const silent = formatOption === 'json'
+    const config = await Config.load(configFile || this.projectPath, { version, exitOnError: true, createIfMissing: false, silent })
+    const linterConfig = config.options.linter || {}
 
     const outputOptions = {
       formatOption,
@@ -155,15 +186,69 @@ export class CLI {
     try {
       await this.beforeProcess()
 
-      const files = await glob(pattern, { cwd: this.projectPath })
+      if (linterConfig.enabled === false && !force) {
+        this.exitWithInfo("Linter is disabled in .herb.yml configuration. Use --force to lint anyway.", formatOption, 0, { startTime, startDate, showTiming })
+      }
+
+      if (force && linterConfig.enabled === false) {
+        console.log("⚠️  Forcing linter run (disabled in .herb.yml)")
+        console.log()
+      }
+
+      let files: string[]
+      let explicitFiles: string[] = []
+
+      if (patterns.length === 0) {
+        files = await config.findFilesForTool('linter', this.projectPath)
+      } else {
+        const allFiles: string[] = []
+
+        for (const pattern of patterns) {
+          const { files: patternFiles, explicitFile } = await this.resolvePatternToFiles(pattern, config, force)
+
+          if (patternFiles.length === 0) {
+            console.error(`✗ No files found matching pattern: ${pattern}`)
+            process.exit(1)
+          }
+
+          allFiles.push(...patternFiles)
+          if (explicitFile) {
+            explicitFiles.push(explicitFile)
+          }
+        }
+
+        files = [...new Set(allFiles)]
+      }
 
       if (files.length === 0) {
-        this.exitWithInfo(`No files found matching pattern: ${pattern}`, formatOption, 0, { startTime, startDate, showTiming })
+        this.exitWithInfo(`No files found matching patterns: ${patterns.join(', ') || 'from config'}`, formatOption, 0, { startTime, startDate, showTiming })
+      }
+
+      let processingConfig = config
+
+      if (force && explicitFiles.length > 0) {
+        const modifiedConfig = Object.create(Object.getPrototypeOf(config))
+        Object.assign(modifiedConfig, config)
+
+        modifiedConfig.config = {
+          ...config.config,
+          linter: {
+            ...config.config.linter,
+            exclude: []
+          }
+        }
+
+        processingConfig = modifiedConfig
       }
 
-      const context = {
+      const context: ProcessingContext = {
         projectPath: this.projectPath,
-        pattern: pattern
+        pattern: patterns.join(' '),
+        fix,
+        ignoreDisableComments,
+        linterConfig,
+        config: processingConfig,
+        loadCustomRules
       }
 
       const results = await this.fileProcessor.processFiles(files, formatOption, context)