@herb-tools/linter 0.8.9 → 0.9.0

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

@@ -1,6 +1,8 @@
-import { colorize } from "@herb-tools/highlighter"
+import { colorize, hyperlink, TextFormatter } from "@herb-tools/highlighter"
 
 import { BaseFormatter } from "./base-formatter.js"
+import { ruleDocumentationUrl } from "../../urls.js"
+import { fileUrl } from "../file-url.js"
 
 import type { Diagnostic } from "@herb-tools/core"
 import type { ProcessedFile } from "../file-processor.js"
@@ -24,33 +26,41 @@ export class SimpleFormatter extends BaseFormatter {
   }
 
   formatFile(filename: string, offenses: Diagnostic[]): void {
-    console.log(`${colorize(filename, "cyan")}:`)
+    const filenameText = colorize(filename, "cyan")
+    const filenameLink = hyperlink(filenameText, fileUrl(filename))
+    console.log(`${filenameLink}:`)
 
     for (const offense of offenses) {
       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 ruleText = `(${offense.code})`
+      const rule = offense.code ? hyperlink(ruleText, ruleDocumentationUrl(offense.code)) : ruleText
+      const { line, column } = offense.location.start
+      const locationString = `${line}:${column}`
+      const paddedLocation = colorize(locationString.padEnd(4), "gray")
+      const message = TextFormatter.highlightBackticks(offense.message)
 
-      console.log(`  ${colorize(paddedLocation, "gray")} ${severity} ${offense.message} ${rule}`)
+      console.log(`  ${paddedLocation} ${severity} ${message} ${rule}`)
     }
-    console.log("")
   }
 
   formatFileProcessed(filename: string, processedFiles: ProcessedFile[]): void {
-    console.log(`${colorize(filename, "cyan")}:`)
+    const filenameText = colorize(filename, "cyan")
+    const filenameLink = hyperlink(filenameText, fileUrl(filename))
+    console.log(`${filenameLink}:`)
 
     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 ruleText = `(${offense.code})`
+      const rule = offense.code ? hyperlink(ruleText, ruleDocumentationUrl(offense.code)) : ruleText
+      const { line, column } = offense.location.start
+      const locationString = `${line}:${column}`
+      const paddedLocation = colorize(locationString.padEnd(4), "gray")
       const correctable = autocorrectable ? colorize(colorize(" [Correctable]", "green"), "bold") : ""
+      const message = TextFormatter.highlightBackticks(offense.message)
 
-      console.log(`  ${colorize(paddedLocation, "gray")} ${severity} ${offense.message} ${rule}${correctable}`)
+      console.log(`  ${paddedLocation} ${severity} ${message} ${rule}${correctable}`)
     }
-    console.log("")
   }
 }

package/src/cli/index.ts

@@ -3,4 +3,6 @@ export { FileProcessor } from "./file-processor.js"
 export { SummaryReporter } from "./summary-reporter.js"
 export { OutputManager } from "./output-manager.js"
 
+export type { WorkerInput, WorkerResult, WorkerOffense } from "./lint-worker.js"
+
 export * from "./formatters/index.js"

package/src/cli/lint-worker.ts

@@ -0,0 +1,208 @@
+import { workerData, parentPort } from "node:worker_threads"
+import { readFileSync, writeFileSync } from "node:fs"
+import { resolve } from "node:path"
+
+import { Herb } from "@herb-tools/node-wasm"
+import { Config } from "@herb-tools/config"
+
+import { Diagnostic } from "@herb-tools/core"
+import { Linter } from "../linter.js"
+import { loadCustomRules } from "../loader.js"
+
+export interface WorkerInput {
+  files: string[]
+  projectPath: string
+  configPath?: string
+  fix: boolean
+  fixUnsafe: boolean
+  ignoreDisableComments: boolean
+  loadCustomRules: boolean
+}
+
+export interface WorkerOffense {
+  filename: string
+  offense: Diagnostic
+  content: string
+  autocorrectable: boolean
+}
+
+export interface WorkerResult {
+  totalErrors: number
+  totalWarnings: number
+  totalInfo: number
+  totalHints: number
+  totalIgnored: number
+  totalWouldBeIgnored: number
+  filesWithOffenses: number
+  filesFixed: number
+  ruleCount: number
+  offenses: WorkerOffense[]
+  ruleOffenses: [string, { count: number, files: string[] }][]
+  fixMessages: string[]
+  error?: string
+}
+
+async function run() {
+  const data = workerData as WorkerInput
+
+  await Herb.load()
+
+  const config = await Config.load(data.configPath || data.projectPath, {
+    exitOnError: false,
+    createIfMissing: false,
+    silent: true
+  })
+
+  let customRules = undefined
+
+  if (data.loadCustomRules) {
+    try {
+      const result = await loadCustomRules({ baseDir: data.projectPath, silent: true })
+      customRules = result.rules
+    } catch {
+      // Silently ignore custom rule loading failures in workers
+    }
+  }
+
+  const linter = Linter.from(Herb, config, customRules)
+
+  let totalErrors = 0
+  let totalWarnings = 0
+  let totalInfo = 0
+  let totalHints = 0
+  let totalIgnored = 0
+  let totalWouldBeIgnored = 0
+  let filesWithOffenses = 0
+  let filesFixed = 0
+
+  const ruleCount = linter.getRuleCount()
+  const allOffenses: WorkerOffense[] = []
+  const ruleOffenses = new Map<string, { count: number, files: Set<string> }>()
+  const fixMessages: string[] = []
+
+  const isRuleAutocorrectable = (ruleName: string): boolean => {
+    const ruleClass = linter.rules.find(
+      (rule) => rule.ruleName === ruleName
+    )
+
+    if (!ruleClass) return false
+
+    // TODO: fix types
+    return (ruleClass as any).autocorrectable === true
+  }
+
+  for (const filename of data.files) {
+    const filePath = data.projectPath ? resolve(data.projectPath, filename) : resolve(filename)
+    let content = readFileSync(filePath, "utf-8")
+
+    const lintResult = linter.lint(content, {
+      fileName: filename,
+      ignoreDisableComments: data.ignoreDisableComments
+    })
+
+    if (data.fix && lintResult.offenses.length > 0) {
+      const autofixResult = linter.autofix(content, {
+        fileName: filename,
+        ignoreDisableComments: data.ignoreDisableComments
+      }, undefined, { includeUnsafe: data.fixUnsafe })
+
+      if (autofixResult.fixed.length > 0) {
+        writeFileSync(filePath, autofixResult.source, "utf-8")
+        filesFixed++
+        fixMessages.push(`${filename}\t${autofixResult.fixed.length}`)
+      }
+
+      content = autofixResult.source
+
+      for (const offense of autofixResult.unfixed) {
+        allOffenses.push({
+          filename,
+          offense,
+          content,
+          autocorrectable: 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(o => o.severity === "error").length
+        totalWarnings += autofixResult.unfixed.filter(o => o.severity === "warning").length
+        totalInfo += autofixResult.unfixed.filter(o => o.severity === "info").length
+        totalHints += autofixResult.unfixed.filter(o => o.severity === "hint").length
+        filesWithOffenses++
+      }
+    } else if (lintResult.offenses.length > 0) {
+      for (const offense of lintResult.offenses) {
+        allOffenses.push({
+          filename,
+          offense,
+          content,
+          autocorrectable: 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)
+      }
+
+      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 serializedRuleOffenses: [string, { count: number, files: string[] }][] =
+    Array.from(ruleOffenses.entries()).map(
+      ([rule, data]) => [rule, { count: data.count, files: Array.from(data.files) }]
+    )
+
+  const result: WorkerResult = {
+    totalErrors,
+    totalWarnings,
+    totalInfo,
+    totalHints,
+    totalIgnored,
+    totalWouldBeIgnored,
+    filesWithOffenses,
+    filesFixed,
+    ruleCount,
+    offenses: allOffenses,
+    ruleOffenses: serializedRuleOffenses,
+    fixMessages
+  }
+
+  parentPort!.postMessage(result)
+}
+
+run().catch(error => {
+  const errorResult: WorkerResult = {
+    totalErrors: 0,
+    totalWarnings: 0,
+    totalInfo: 0,
+    totalHints: 0,
+    totalIgnored: 0,
+    totalWouldBeIgnored: 0,
+    filesWithOffenses: 0,
+    filesFixed: 0,
+    ruleCount: 0,
+    offenses: [],
+    ruleOffenses: [],
+    fixMessages: [],
+    error: error instanceof Error ? error.message : String(error)
+  }
+
+  parentPort!.postMessage(errorResult)
+})

package/src/cli/summary-reporter.ts

@@ -1,4 +1,6 @@
-import { colorize } from "@herb-tools/highlighter"
+import { colorize, hyperlink } from "@herb-tools/highlighter"
+
+import { ruleDocumentationUrl } from "../urls.js"
 
 export interface SummaryData {
   files: string[]
@@ -39,20 +41,14 @@ export class SummaryReporter {
       const filesClean = filesChecked - filesWithOffenses
 
       let filesSummary = ""
-      let shouldDim = false
 
       if (filesWithOffenses > 0) {
-        filesSummary = `${colorize(colorize(`${filesWithOffenses} with offenses`, "brightRed"), "bold")} | ${colorize(colorize(`${filesClean} clean`, "green"), "bold")} ${colorize(colorize(`(${filesChecked} total)`, "gray"), "dim")}`
+        filesSummary = `${colorize(colorize(`${filesWithOffenses} with offenses`, "brightRed"), "bold")} | ${colorize(colorize(`${filesClean} clean`, "green"), "bold")} ${colorize(`(${filesChecked} total)`, "gray")}`
       } else {
-        filesSummary = `${colorize(colorize(`${filesChecked} clean`, "green"), "bold")} ${colorize(colorize(`(${filesChecked} total)`, "gray"), "dim")}`
-        shouldDim = true
+        filesSummary = `${colorize(colorize(`${filesChecked} clean`, "green"), "bold")} ${colorize(`(${filesChecked} total)`, "gray")}`
       }
 
-      if (shouldDim) {
-        console.log(colorize(`  ${colorize(pad("Files"), "gray")} ${filesSummary}`, "dim"))
-      } else {
-        console.log(`  ${colorize(pad("Files"), "gray")} ${filesSummary}`)
-      }
+      console.log(`  ${colorize(pad("Files"), "gray")} ${filesSummary}`)
     }
 
     let offensesSummary = ""
@@ -69,7 +65,7 @@ export class SummaryReporter {
     }
 
     if (totalInfo > 0) {
-      parts.push(colorize(colorize(`${totalInfo} info`, "brightBlue"), "bold"))
+      parts.push(colorize(colorize(`${totalInfo} info`, "cyan"), "bold"))
     }
 
     if (totalHints > 0) {
@@ -94,7 +90,7 @@ export class SummaryReporter {
       }
 
       if (detailText) {
-        offensesSummary += ` ${colorize(colorize(`(${detailText})`, "gray"), "dim")}`
+        offensesSummary += ` ${colorize(`(${detailText})`, "gray")}`
       }
     }
 
@@ -122,7 +118,7 @@ export class SummaryReporter {
       const timeString = startDate.toTimeString().split(' ')[0]
 
       console.log(`  ${colorize(pad("Start at"), "gray")} ${colorize(timeString, "cyan")}`)
-      console.log(`  ${colorize(pad("Duration"), "gray")} ${colorize(`${duration}ms`, "cyan")} ${colorize(colorize(`(${ruleCount} ${this.pluralize(ruleCount, "rule")})`, "gray"), "dim")}`)
+      console.log(`  ${colorize(pad("Duration"), "gray")} ${colorize(`${duration}ms`, "cyan")} ${colorize(`(${ruleCount} ${this.pluralize(ruleCount, "rule")})`, "gray")}`)
     }
 
     if (filesWithOffenses === 0 && files.length > 1) {
@@ -139,18 +135,21 @@ export class SummaryReporter {
     const remainingRules = allRules.slice(limit)
 
     const title = ruleOffenses.size <= limit ? "Rule offenses:" : "Most frequent rule offenses:"
+    console.log("\n")
     console.log(` ${colorize(title, "bold")}`)
 
     for (const [rule, data] of displayedRules) {
       const fileCount = data.files.size
       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")}`)
+      const ruleText = colorize(rule, "white")
+      const ruleLink = hyperlink(ruleText, ruleDocumentationUrl(rule))
+      console.log(`  ${ruleLink} ${colorize(countText, "gray")}`)
     }
 
     if (remainingRules.length > 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 ${remainingOffenseCount} ${this.pluralize(remainingOffenseCount, "offense")}`, "gray"), "dim"))
+      console.log(colorize(`\n  ...and ${remainingRuleCount} more ${this.pluralize(remainingRuleCount, "rule")} with ${remainingOffenseCount} ${this.pluralize(remainingOffenseCount, "offense")}`, "gray"))
     }
   }
 }

package/src/cli.ts

@@ -144,7 +144,7 @@ export class CLI {
     const startTime = Date.now()
     const startDate = new Date()
 
-    let { patterns, configFile, formatOption, showTiming, theme, wrapLines, truncateLines, useGitHubActions, fix, fixUnsafe, ignoreDisableComments, force, init, loadCustomRules, failLevel } = this.argumentParser.parse(process.argv)
+    const { patterns, configFile, formatOption, showTiming, theme, wrapLines, truncateLines, useGitHubActions, fix, fixUnsafe, ignoreDisableComments, force, init, loadCustomRules, failLevel, jobs } = this.argumentParser.parse(process.argv)
 
     this.determineProjectPath(patterns)
 
@@ -199,7 +199,7 @@ export class CLI {
       }
 
       let files: string[]
-      let explicitFiles: string[] = []
+      const explicitFiles: string[] = []
 
       if (patterns.length === 0) {
         files = await config.findFilesForTool('linter', this.projectPath)
@@ -246,13 +246,15 @@ export class CLI {
 
       const context: ProcessingContext = {
         projectPath: this.projectPath,
+        configPath: configFile,
         pattern: patterns.join(' '),
         fix,
         fixUnsafe,
         ignoreDisableComments,
         linterConfig,
         config: processingConfig,
-        loadCustomRules
+        loadCustomRules,
+        jobs
       }
 
       const results = await this.fileProcessor.processFiles(files, formatOption, context)

package/src/custom-rule-loader.ts

@@ -75,10 +75,16 @@ export class CustomRuleLoader {
       const cacheBustedUrl = `${fileUrl}?t=${Date.now()}`
       const module = await import(cacheBustedUrl)
 
-      if (module.default && this.isValidRuleClass(module.default)) {
+      if (this.isValidRuleClass(module.default)) {
         return [module.default]
       }
 
+      if (this.hasDeprecatedNameProperty(module.default)) {
+        const name = new module.default().name
+        console.error(`Error: Custom rule in "${filePath}" sets 'name' as an instance property, which is no longer supported. Use 'static ruleName = "${name}"' instead.`)
+        process.exit(1)
+      }
+
       if (!this.silent) {
         console.warn(`Warning: No valid default export found in "${filePath}". Custom rules must use default export.`)
       }
@@ -96,12 +102,22 @@ export class CustomRuleLoader {
    * Type guard to check if an export is a valid rule class
    */
   private isValidRuleClass(value: any): value is RuleClass {
+    if (!value) return false
     if (typeof value !== 'function') return false
     if (!value.prototype) return false
 
-    const instance = new value()
+    return typeof value.ruleName === 'string' && typeof value.prototype.check === 'function'
+  }
 
-    return typeof instance.check === 'function' && typeof instance.name === 'string'
+  /**
+   * Check for usage of deprecated 'name' property instead of 'static ruleName'
+   */
+  private hasDeprecatedNameProperty(value: any): boolean {
+    if (!value) return false
+    if (typeof value !== 'function') return false
+
+    const instance = new value()
+    return Object.prototype.hasOwnProperty.call(instance, 'name')
   }
 
   /**
@@ -142,8 +158,7 @@ export class CustomRuleLoader {
     for (const filePath of ruleFiles) {
       const rules = await this.loadRuleFile(filePath)
       for (const RuleClass of rules) {
-        const instance = new RuleClass()
-        const ruleName = instance.name
+        const ruleName = RuleClass.ruleName
 
         if (seenNames.has(ruleName)) {
           const firstPath = seenNames.get(ruleName)!

package/src/herb-disable-comment-utils.ts

@@ -2,9 +2,6 @@
  * Utilities for parsing herb:disable comments
  */
 
-import { isERBCommentNode } from "@herb-tools/core"
-import type { Node } from "@herb-tools/core"
-
 /**
  * Information about a single rule name in a herb:disable comment
  */

package/src/index.ts

@@ -2,4 +2,5 @@ export * from "./linter.js"
 export * from "./rules/index.js"
 export * from "./types.js"
 
+export { ruleDocumentationUrl } from "./urls.js"
 export { rules } from "./rules.js"