@herb-tools/linter 0.7.5 → 0.8.0

package/src/cli/argument-parser.ts

@@ -1,9 +1,6 @@
 import dedent from "dedent"
 
 import { parseArgs } from "util"
-import { statSync } from "fs"
-import { join } from "path"
-
 import { Herb } from "@herb-tools/node-wasm"
 
 import { THEME_NAMES, DEFAULT_THEME } from "@herb-tools/highlighter"
@@ -14,37 +11,48 @@ import { name, version, dependencies } from "../../package.json"
 export type FormatOption = "simple" | "detailed" | "json"
 
 export interface ParsedArguments {
-  pattern: string
+  patterns: string[]
+  configFile?: string
   formatOption: FormatOption
   showTiming: boolean
   theme: ThemeInput
   wrapLines: boolean
   truncateLines: boolean
   useGitHubActions: boolean
+  fix: boolean
+  ignoreDisableComments: boolean
+  force: boolean
+  init: boolean
+  loadCustomRules: boolean
 }
 
 export class ArgumentParser {
   private readonly usage = dedent`
-    Usage: herb-lint [file|glob-pattern|directory] [options]
+    Usage: herb-lint [files|directories|glob-patterns...] [options]
 
     Arguments:
-      file             Single file to lint
-      glob-pattern     Files to lint (defaults to **/*.html.erb)
-      directory        Directory to lint (automatically appends **/*.html.erb)
+      files            Files, directories, or glob patterns to lint (defaults to configured extensions in .herb.yml)
+                       Multiple arguments are supported (e.g., herb-lint file1.erb file2.erb dir/ "**/*.erb")
 
     Options:
-      -h, --help       show help
-      -v, --version    show version
-      --format         output format (simple|detailed|json) [default: detailed]
-      --simple         use simple output format (shortcut for --format simple)
-      --json           use JSON output format (shortcut for --format json)
-      --github         enable GitHub Actions annotations (combines with --format)
-      --no-github      disable GitHub Actions annotations (even in GitHub Actions environment)
-      --theme          syntax highlighting theme (${THEME_NAMES.join("|")}) or path to custom theme file [default: ${DEFAULT_THEME}]
-      --no-color       disable colored output
-      --no-timing      hide timing information
-      --no-wrap-lines  disable line wrapping
-      --truncate-lines enable line truncation (mutually exclusive with line wrapping)
+      -h, --help                    show help
+      -v, --version                 show version
+      --init                        create a .herb.yml configuration file in the current directory
+      -c, --config-file <path>      explicitly specify path to .herb.yml config file
+      --force                       force linting even if disabled in .herb.yml
+      --fix                         automatically fix auto-correctable offenses
+      --ignore-disable-comments     report offenses even when suppressed with <%# herb:disable %> comments
+      --format                      output format (simple|detailed|json) [default: detailed]
+      --simple                      use simple output format (shortcut for --format simple)
+      --json                        use JSON output format (shortcut for --format json)
+      --github                      enable GitHub Actions annotations (combines with --format)
+      --no-github                   disable GitHub Actions annotations (even in GitHub Actions environment)
+      --no-custom-rules             disable loading custom rules from project (custom rules are loaded by default from .herb/rules/**/*.{mjs,js})
+      --theme                       syntax highlighting theme (${THEME_NAMES.join("|")}) or path to custom theme file [default: ${DEFAULT_THEME}]
+      --no-color                    disable colored output
+      --no-timing                   hide timing information
+      --no-wrap-lines               disable line wrapping
+      --truncate-lines              enable line truncation (mutually exclusive with line wrapping)
   `
 
   parse(argv: string[]): ParsedArguments {
@@ -53,6 +61,11 @@ export class ArgumentParser {
       options: {
         help: { type: "boolean", short: "h" },
         version: { type: "boolean", short: "v" },
+        init: { type: "boolean" },
+        "config-file": { type: "string", short: "c" },
+        force: { type: "boolean" },
+        fix: { type: "boolean" },
+        "ignore-disable-comments": { type: "boolean" },
         format: { type: "string" },
         simple: { type: "boolean" },
         json: { type: "boolean" },
@@ -62,7 +75,8 @@ export class ArgumentParser {
         "no-color": { type: "boolean" },
         "no-timing": { type: "boolean" },
         "no-wrap-lines": { type: "boolean" },
-        "truncate-lines": { type: "boolean" }
+        "truncate-lines": { type: "boolean" },
+        "no-custom-rules": { type: "boolean" }
       },
       allowPositionals: true
     })
@@ -122,23 +136,18 @@ export class ArgumentParser {
     }
 
     const theme = values.theme || DEFAULT_THEME
-    const pattern = this.getFilePattern(positionals)
-
-    return { pattern, formatOption, showTiming, theme, wrapLines, truncateLines, useGitHubActions }
+    const patterns = this.getFilePatterns(positionals)
+    const fix = values.fix || false
+    const force = !!values.force
+    const ignoreDisableComments = values["ignore-disable-comments"] || false
+    const configFile = values["config-file"]
+    const init = values.init || false
+    const loadCustomRules = !values["no-custom-rules"]
+
+    return { patterns, configFile, formatOption, showTiming, theme, wrapLines, truncateLines, useGitHubActions, fix, ignoreDisableComments, force, init, loadCustomRules }
   }
 
-  private getFilePattern(positionals: string[]): string {
-    let pattern = positionals.length > 0 ? positionals[0] : "**/*.html.erb"
-
-    try {
-      const stat = statSync(pattern)
-      if (stat.isDirectory()) {
-        pattern = join(pattern, "**/*.html.erb")
-      }
-    } catch {
-      // Not a file/directory, treat as glob pattern
-    }
-
-    return pattern
+  private getFilePatterns(positionals: string[]): string[] {
+    return positionals
   }
 }

package/src/cli/file-processor.ts

@@ -1,26 +1,42 @@
-import { readFileSync } from "fs"
-import { resolve } from "path"
 import { Herb } from "@herb-tools/node-wasm"
 import { Linter } from "../linter.js"
+import { loadCustomRules } from "../loader.js"
+import { Config } from "@herb-tools/config"
+
+import { readFileSync, writeFileSync } from "fs"
+import { resolve } from "path"
 import { colorize } from "@herb-tools/highlighter"
+
 import type { Diagnostic } from "@herb-tools/core"
 import type { FormatOption } from "./argument-parser.js"
+import type { HerbConfigOptions } from "@herb-tools/config"
 
 export interface ProcessedFile {
   filename: string
   offense: Diagnostic
   content: string
+  autocorrectable?: boolean
 }
 
 export interface ProcessingContext {
   projectPath?: string
   pattern?: string
+  fix?: boolean
+  ignoreDisableComments?: boolean
+  linterConfig?: HerbConfigOptions['linter']
+  config?: Config
+  loadCustomRules?: boolean
 }
 
 export interface ProcessingResult {
   totalErrors: number
   totalWarnings: number
+  totalInfo: number
+  totalHints: number
+  totalIgnored: number
+  totalWouldBeIgnored?: number
   filesWithOffenses: number
+  filesFixed: number
   ruleCount: number
   allOffenses: ProcessedFile[]
   ruleOffenses: Map<string, { count: number, files: Set<string> }>
@@ -29,55 +45,146 @@ export interface ProcessingResult {
 
 export class FileProcessor {
   private linter: Linter | null = null
+  private customRulesLoaded: boolean = false
+
+  private isRuleAutocorrectable(ruleName: string): boolean {
+    if (!this.linter) return false
+
+    const RuleClass = (this.linter as any).rules.find((rule: any) => {
+      const instance = new rule()
+
+      return instance.name === ruleName
+    })
+
+    if (!RuleClass) return false
+
+    return RuleClass.autocorrectable === true
+  }
 
   async processFiles(files: string[], formatOption: FormatOption = 'detailed', context?: ProcessingContext): Promise<ProcessingResult> {
     let totalErrors = 0
     let totalWarnings = 0
+    let totalInfo = 0
+    let totalHints = 0
+    let totalIgnored = 0
+    let totalWouldBeIgnored = 0
     let filesWithOffenses = 0
+    let filesFixed = 0
     let ruleCount = 0
+
     const allOffenses: ProcessedFile[] = []
     const ruleOffenses = new Map<string, { count: number, files: Set<string> }>()
 
-    for (const filename of files) {
-      const filePath = context?.projectPath ? resolve(context.projectPath, filename) : resolve(filename)
-      const content = readFileSync(filePath, "utf-8")
-      const parseResult = Herb.parse(content)
-
-      if (parseResult.errors.length > 0) {
-        if (formatOption !== 'json') {
-          console.error(`${colorize(filename, "cyan")} - ${colorize("Parse errors:", "brightRed")}`)
-
-          for (const error of parseResult.errors) {
-            console.error(`  ${colorize("✗", "brightRed")} ${error.message}`)
+    if (!this.linter) {
+      let customRules = undefined
+      let customRuleInfo: Array<{ name: string, path: string }> = []
+      let customRuleWarnings: string[] = []
+
+      if (context?.loadCustomRules && !this.customRulesLoaded) {
+        try {
+          const result = await loadCustomRules({
+            baseDir: context.projectPath,
+            silent: formatOption === 'json'
+          })
+
+          customRules = result.rules
+          customRuleInfo = result.ruleInfo
+          customRuleWarnings = result.warnings
+
+          this.customRulesLoaded = true
+
+          if (customRules.length > 0 && formatOption !== 'json') {
+            const ruleText = customRules.length === 1 ? 'rule' : 'rules'
+            console.log(colorize(`\nLoaded ${customRules.length} custom ${ruleText}:`, "green"))
+
+            for (const { name, path } of customRuleInfo) {
+              const relativePath = context.projectPath ? path.replace(context.projectPath + '/', '') : path
+              console.log(colorize(`  • ${name}`, "cyan") + colorize(` (${relativePath})`, "dim"))
+            }
+
+            if (customRuleWarnings.length > 0) {
+              console.log()
+              for (const warning of customRuleWarnings) {
+                console.warn(colorize(`  ⚠ ${warning}`, "yellow"))
+              }
+            }
+
+            console.log()
+          }
+        } catch (error) {
+          if (formatOption !== 'json') {
+            console.warn(colorize(`Warning: Failed to load custom rules: ${error}`, "yellow"))
           }
         }
-
-        for (const error of parseResult.errors) {
-          allOffenses.push({ filename, offense: error, content })
-        }
-
-        totalErrors++
-        filesWithOffenses++
-        continue
       }
 
-      if (!this.linter) {
-        this.linter = new Linter(Herb)
-      }
+      this.linter = Linter.from(Herb, context?.config, customRules)
+    }
 
-      const lintResult = this.linter.lint(content, { fileName: filename })
+    for (const filename of files) {
+      const filePath = context?.projectPath ? resolve(context.projectPath, filename) : resolve(filename)
+      let content = readFileSync(filePath, "utf-8")
+
+      const lintResult = this.linter.lint(content, {
+        fileName: filename,
+        ignoreDisableComments: context?.ignoreDisableComments
+      })
 
       if (ruleCount === 0) {
         ruleCount = this.linter.getRuleCount()
       }
 
-      if (lintResult.offenses.length === 0) {
+      if (context?.fix && lintResult.offenses.length > 0) {
+        const autofixResult = this.linter.autofix(content, {
+          fileName: filename,
+          ignoreDisableComments: context?.ignoreDisableComments
+        })
+
+        if (autofixResult.fixed.length > 0) {
+          writeFileSync(filePath, autofixResult.source, "utf-8")
+
+          filesFixed++
+
+          if (formatOption !== 'json') {
+            console.log(`${colorize("✓", "brightGreen")} ${colorize(filename, "cyan")} - ${colorize(`Fixed ${autofixResult.fixed.length} offense(s)`, "green")}`)
+          }
+        }
+
+        content = autofixResult.source
+
+        for (const offense of autofixResult.unfixed) {
+          allOffenses.push({
+            filename,
+            offense: offense,
+            content,
+            autocorrectable: this.isRuleAutocorrectable(offense.rule)
+          })
+
+          const ruleData = ruleOffenses.get(offense.rule) || { count: 0, files: new Set() }
+          ruleData.count++
+          ruleData.files.add(filename)
+          ruleOffenses.set(offense.rule, ruleData)
+        }
+
+        if (autofixResult.unfixed.length > 0) {
+          totalErrors += autofixResult.unfixed.filter(offense => offense.severity === "error").length
+          totalWarnings += autofixResult.unfixed.filter(offense => offense.severity === "warning").length
+          totalInfo += autofixResult.unfixed.filter(offense => offense.severity === "info").length
+          totalHints += autofixResult.unfixed.filter(offense => offense.severity === "hint").length
+          filesWithOffenses++
+        }
+      } else if (lintResult.offenses.length === 0) {
         if (files.length === 1 && formatOption !== 'json') {
           console.log(`${colorize("✓", "brightGreen")} ${colorize(filename, "cyan")} - ${colorize("No issues found", "green")}`)
         }
       } else {
         for (const offense of lintResult.offenses) {
-          allOffenses.push({ filename, offense: offense, content })
+          allOffenses.push({
+            filename,
+            offense: offense,
+            content,
+            autocorrectable: this.isRuleAutocorrectable(offense.rule)
+          })
 
           const ruleData = ruleOffenses.get(offense.rule) || { count: 0, files: new Set() }
           ruleData.count++
@@ -87,10 +194,34 @@ export class FileProcessor {
 
         totalErrors += lintResult.errors
         totalWarnings += lintResult.warnings
+        totalInfo += lintResult.offenses.filter(o => o.severity === "info").length
+        totalHints += lintResult.offenses.filter(o => o.severity === "hint").length
         filesWithOffenses++
       }
+      totalIgnored += lintResult.ignored
+      if (lintResult.wouldBeIgnored) {
+        totalWouldBeIgnored += lintResult.wouldBeIgnored
+      }
+    }
+
+    const result: ProcessingResult = {
+      totalErrors,
+      totalWarnings,
+      totalInfo,
+      totalHints,
+      totalIgnored,
+      filesWithOffenses,
+      filesFixed,
+      ruleCount,
+      allOffenses,
+      ruleOffenses,
+      context
+    }
+
+    if (totalWouldBeIgnored > 0) {
+      result.totalWouldBeIgnored = totalWouldBeIgnored
     }
 
-    return { totalErrors, totalWarnings, filesWithOffenses, ruleCount, allOffenses, ruleOffenses, context }
+    return result
   }
 }

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