@herb-tools/linter 0.8.10 → 0.9.1

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,26 @@ export * from "./linter.js"
 export * from "./rules/index.js"
 export * from "./types.js"
 
+export { ruleDocumentationUrl } from "./urls.js"
 export { rules } from "./rules.js"
+
+export {
+  findAttributeByName,
+  getAttribute,
+  getAttributeName,
+  getAttributes,
+  getAttributeValue,
+  getAttributeValueNodes,
+  getAttributeValueQuoteType,
+  getCombinedAttributeNameString,
+  getStaticAttributeValue,
+  getStaticAttributeValueContent,
+  getTagName,
+  hasAttribute,
+  hasAttributeValue,
+  hasDynamicAttributeName,
+  hasDynamicAttributeValue,
+  hasStaticAttributeValue,
+  hasStaticAttributeValueContent,
+  isAttributeValueQuoted,
+} from "@herb-tools/core"

package/src/linter.ts

@@ -1,16 +1,19 @@
-import { Location } from "@herb-tools/core"
-import { IdentityPrinter } from "@herb-tools/printer"
 import picomatch from "picomatch"
 
+import { Location } from "@herb-tools/core"
+import { IdentityPrinter, IndentPrinter } from "@herb-tools/printer"
+
 import { rules } from "./rules.js"
 import { findNodeByLocation } from "./rules/rule-utils.js"
 import { parseHerbDisableLine } from "./herb-disable-comment-utils.js"
 import { hasLinterIgnoreDirective } from "./linter-ignore.js"
+import { ParseCache } from "./parse-cache.js"
 
 import { ParserNoErrorsRule } from "./rules/parser-no-errors.js"
+
 import { DEFAULT_RULE_CONFIG } from "./types.js"
 
-import type { RuleClass, Rule, ParserRule, LexerRule, SourceRule, LintResult, LintOffense, UnboundLintOffense, LintContext, AutofixResult } from "./types.js"
+import type { RuleClass, ParserRuleClass, LexerRuleClass, SourceRuleClass, Rule, ParserRule, LexerRule, SourceRule, LintResult, LintOffense, UnboundLintOffense, LintContext, AutofixResult } from "./types.js"
 import type { ParseResult, LexResult, HerbBackend } from "@herb-tools/core"
 import type { RuleConfig, Config } from "@herb-tools/config"
 
@@ -45,9 +48,10 @@ export interface LinterOptions {
 }
 
 export class Linter {
-  protected rules: RuleClass[]
+  public rules: RuleClass[]
   protected allAvailableRules: RuleClass[]
   protected herb: HerbBackend
+  protected parseCache: ParseCache
   protected offenses: LintOffense[]
   protected config?: Config
 
@@ -81,6 +85,7 @@ export class Linter {
    */
   constructor(herb: HerbBackend, rules?: RuleClass[], config?: Config, allAvailableRules?: RuleClass[]) {
     this.herb = herb
+    this.parseCache = new ParseCache(herb)
     this.config = config
     this.rules = rules !== undefined ? rules : this.getDefaultRules()
     this.allAvailableRules = allAvailableRules !== undefined ? allAvailableRules : this.rules
@@ -104,10 +109,9 @@ export class Linter {
   ): RuleClass[] {
     return allRules.filter(ruleClass => {
       const instance = new ruleClass()
-      const ruleName = instance.name
 
       const defaultEnabled = instance.defaultConfig?.enabled ?? DEFAULT_RULE_CONFIG.enabled
-      const userRuleConfig = userRulesConfig?.[ruleName]
+      const userRuleConfig = userRulesConfig?.[ruleClass.ruleName]
 
       if (userRuleConfig !== undefined) {
         return userRuleConfig.enabled !== false
@@ -156,18 +160,29 @@ export class Linter {
     return this.rules.length
   }
 
+  protected findRuleClass(ruleName: string): RuleClass | undefined {
+    return this.rules.find(ruleClass => ruleClass.ruleName === ruleName)
+  }
+
+  /**
+   * Type guard to check if a rule class is a LexerRule class
+   */
+  protected isLexerRuleClass(ruleClass: RuleClass): ruleClass is LexerRuleClass {
+    return ruleClass.type === "lexer"
+  }
+
   /**
-   * Type guard to check if a rule is a LexerRule
+   * Type guard to check if a rule class is a SourceRule class
    */
-  protected isLexerRule(rule: Rule): rule is LexerRule {
-    return (rule.constructor as any).type === "lexer"
+  protected isSourceRuleClass(ruleClass: RuleClass): ruleClass is SourceRuleClass {
+    return ruleClass.type === "source"
   }
 
   /**
-   * Type guard to check if a rule is a SourceRule
+   * Type guard to check if a rule class is a ParserRule class
    */
-  protected isSourceRule(rule: Rule): rule is SourceRule {
-    return (rule.constructor as any).type === "source"
+  protected isParserRuleClass(ruleClass: RuleClass): ruleClass is ParserRuleClass {
+    return ruleClass.type === "parser" || ruleClass.type === undefined
   }
 
   /**
@@ -175,19 +190,22 @@ export class Linter {
    * Handles rule type checking (Lexer/Parser/Source) and isEnabled checks.
    */
   private executeRule(
+    ruleClass: RuleClass,
     rule: Rule,
     parseResult: ParseResult,
     lexResult: LexResult,
     source: string,
     context?: Partial<LintContext>
   ): UnboundLintOffense[] {
+    const ruleName = rule.ruleName
+
     if (this.config && context?.fileName) {
-      if (!this.config.isRuleEnabledForPath(rule.name, context.fileName)) {
+      if (!this.config.isRuleEnabledForPath(ruleName, context.fileName)) {
         return []
       }
     }
 
-    if (context?.fileName && !this.config?.linter?.rules?.[rule.name]?.exclude) {
+    if (context?.fileName && !this.config?.linter?.rules?.[ruleName]?.exclude) {
       const defaultExclude = rule.defaultConfig?.exclude ?? DEFAULT_RULE_CONFIG.exclude
 
       if (defaultExclude && defaultExclude.length > 0) {
@@ -202,34 +220,40 @@ export class Linter {
     let isEnabled = true
     let ruleOffenses: UnboundLintOffense[]
 
-    if (this.isLexerRule(rule)) {
-      if (rule.isEnabled) {
-        isEnabled = rule.isEnabled(lexResult, context)
+    if (this.isLexerRuleClass(ruleClass)) {
+      const lexerRule = rule as LexerRule
+
+      if (lexerRule.isEnabled) {
+        isEnabled = lexerRule.isEnabled(lexResult, context)
       }
 
       if (isEnabled) {
-        ruleOffenses = (rule as LexerRule).check(lexResult, context)
+        ruleOffenses = lexerRule.check(lexResult, context)
       } else {
         ruleOffenses = []
       }
 
-    } else if (this.isSourceRule(rule)) {
-      if (rule.isEnabled) {
-        isEnabled = rule.isEnabled(source, context)
+    } else if (this.isSourceRuleClass(ruleClass)) {
+      const sourceRule = rule as SourceRule
+
+      if (sourceRule.isEnabled) {
+        isEnabled = sourceRule.isEnabled(source, context)
       }
 
       if (isEnabled) {
-        ruleOffenses = (rule as SourceRule).check(source, context)
+        ruleOffenses = sourceRule.check(source, context)
       } else {
         ruleOffenses = []
       }
     } else {
-      if (rule.isEnabled) {
-        isEnabled = rule.isEnabled(parseResult, context)
+      const parserRule = rule as ParserRule
+
+      if (parserRule.isEnabled) {
+        isEnabled = parserRule.isEnabled(parseResult, context)
       }
 
       if (isEnabled) {
-        ruleOffenses = (rule as ParserRule).check(parseResult, context)
+        ruleOffenses = parserRule.check(parseResult, context)
       } else {
         ruleOffenses = []
       }
@@ -303,7 +327,7 @@ export class Linter {
     let ignoredCount = 0
     let wouldBeIgnoredCount = 0
 
-    const parseResult = this.herb.parse(source, { track_whitespace: true })
+    const parseResult = this.parseCache.get(source)
 
     // Check for file-level ignore directive using visitor
     if (hasLinterIgnoreDirective(parseResult)) {
@@ -323,22 +347,13 @@ export class Linter {
     const herbDisableCache = new Map<number, string[]>()
 
     if (hasParserErrors) {
-      const hasParserRule = this.rules.find(RuleClass => (new RuleClass()).name === "parser-no-errors")
+      const hasParserRule = this.findRuleClass("parser-no-errors")
 
       if (hasParserRule) {
         const rule = new ParserNoErrorsRule()
         const offenses = rule.check(parseResult)
         this.offenses.push(...offenses)
       }
-
-      return {
-        offenses: this.offenses,
-        errors: this.offenses.filter(o => o.severity === "error").length,
-        warnings: this.offenses.filter(o => o.severity === "warning").length,
-        info: this.offenses.filter(o => o.severity === "info").length,
-        hints: this.offenses.filter(o => o.severity === "hint").length,
-        ignored: 0
-      }
     }
 
     for (let i = 0; i < sourceLines.length; i++) {
@@ -352,24 +367,31 @@ export class Linter {
 
     context = {
       ...context,
-      validRuleNames: this.getAvailableRules().map(RuleClass => new RuleClass().name),
+      validRuleNames: this.getAvailableRules().map(ruleClass => ruleClass.ruleName),
       ignoredOffensesByLine
     }
 
-    const regularRules = this.rules.filter(RuleClass => {
-      const rule = new RuleClass()
+    const regularRules = this.rules.filter(ruleClass => ruleClass.ruleName !== "herb-disable-comment-unnecessary")
 
-      return rule.name !== "herb-disable-comment-unnecessary"
-    })
+    for (const ruleClass of regularRules) {
+      const rule = new ruleClass()
+      const parserOptions = this.isParserRuleClass(ruleClass) ? (rule as ParserRule).parserOptions : {}
+      const parseResult = this.parseCache.get(source, parserOptions)
+
+      // Skip parser rules whose parse result has errors (parser-no-errors handled above)
+      // Skip lexer/source rules when the default parse has errors
+      if (this.isParserRuleClass(ruleClass)) {
+        if (parseResult.recursiveErrors().length > 0) continue
+      } else if (hasParserErrors) {
+        continue
+      }
 
-    for (const RuleClass of regularRules) {
-      const rule = new RuleClass()
-      const unboundOffenses = this.executeRule(rule, parseResult, lexResult, source, context)
-      const boundOffenses = this.bindSeverity(unboundOffenses, rule.name)
+      const unboundOffenses = this.executeRule(ruleClass, rule, parseResult, lexResult, source, context)
+      const boundOffenses = this.bindSeverity(unboundOffenses, ruleClass.ruleName)
 
       const { kept, ignored, wouldBeIgnored } = this.filterOffenses(
         boundOffenses,
-        rule.name,
+        ruleClass.ruleName,
         ignoredOffensesByLine,
         herbDisableCache,
         context?.ignoreDisableComments
@@ -380,16 +402,13 @@ export class Linter {
       this.offenses.push(...kept)
     }
 
-    const unnecessaryRuleClass = this.rules.find(RuleClass => {
-      const rule = new RuleClass()
-
-      return rule.name === "herb-disable-comment-unnecessary"
-    })
+    const unnecessaryRuleClass = this.findRuleClass("herb-disable-comment-unnecessary")
 
     if (unnecessaryRuleClass) {
       const unnecessaryRule = new unnecessaryRuleClass() as ParserRule
+      const parseResult = this.parseCache.get(source, unnecessaryRule.parserOptions)
       const unboundOffenses = unnecessaryRule.check(parseResult, context)
-      const boundOffenses = this.bindSeverity(unboundOffenses, unnecessaryRule.name)
+      const boundOffenses = this.bindSeverity(unboundOffenses, unnecessaryRuleClass.ruleName)
 
       this.offenses.push(...boundOffenses)
     }
@@ -429,19 +448,16 @@ export class Linter {
    * @returns Array of offenses with severity bound
    */
   protected bindSeverity(unboundOffenses: UnboundLintOffense[], ruleName: string): LintOffense[] {
-    const RuleClass = this.rules.find(rule => {
-      const instance = new rule()
-      return instance.name === ruleName
-    })
+    const ruleClass = this.findRuleClass(ruleName)
 
-    if (!RuleClass) {
+    if (!ruleClass) {
       return unboundOffenses.map(offense => ({
         ...offense,
         severity: "error" as const
       }))
     }
 
-    const ruleInstance = new RuleClass()
+    const ruleInstance = new ruleClass()
     const defaultSeverity = ruleInstance.defaultConfig?.severity ?? DEFAULT_RULE_CONFIG.severity
 
     const userRuleConfig = this.config?.linter?.rules?.[ruleName]
@@ -449,7 +465,7 @@ export class Linter {
 
     return unboundOffenses.map(offense => ({
       ...offense,
-      severity
+      severity: offense.severity ?? severity
     }))
   }
 
@@ -472,17 +488,13 @@ export class Linter {
     const sourceOffenses: LintOffense[] = []
 
     for (const offense of lintResult.offenses) {
-      const RuleClass = this.rules.find(rule => {
-        const instance = new rule()
-
-        return instance.name === offense.rule
-      })
+      const ruleClass = this.findRuleClass(offense.rule)
 
-      if (!RuleClass) continue
+      if (!ruleClass) continue
 
-      if ((RuleClass as any).type === "lexer") {
+      if (this.isLexerRuleClass(ruleClass)) {
         lexerOffenses.push(offense)
-      } else if ((RuleClass as any).type === "source") {
+      } else if (this.isSourceRuleClass(ruleClass)) {
         sourceOffenses.push(offense)
       } else {
         parserOffenses.push(offense)
@@ -494,19 +506,20 @@ export class Linter {
     const unfixed: LintOffense[] = []
 
     if (parserOffenses.length > 0) {
-      const parseResult = this.herb.parse(currentSource, { track_whitespace: true })
+      const parseResult = this.parseCache.get(currentSource)
+      let needsReindent = false
 
       for (const offense of parserOffenses) {
-        const RuleClass = this.rules.find(rule => new rule().name === offense.rule)
+        const ruleClass = this.findRuleClass(offense.rule)
 
-        if (!RuleClass) {
+        if (!ruleClass) {
           unfixed.push(offense)
 
           continue
         }
 
-        const rule = new RuleClass() as ParserRule
-        const isUnsafe = (RuleClass as any).unsafeAutocorrectable === true
+        const rule = new ruleClass() as ParserRule
+        const isUnsafe = (ruleClass as any).unsafeAutocorrectable === true || offense.autofixContext?.unsafe === true
 
         if (!rule.autofix) {
           unfixed.push(offense)
@@ -543,14 +556,21 @@ export class Linter {
 
         if (fixedResult) {
           fixed.push(offense)
+
+          if (this.isParserRuleClass(ruleClass) && ruleClass.reindentAfterAutofix === true) {
+            needsReindent = true
+          }
         } else {
           unfixed.push(offense)
         }
       }
 
       if (fixed.length > 0) {
-        const printer = new IdentityPrinter()
-        currentSource = printer.print(parseResult.value)
+        if (needsReindent) {
+          currentSource = new IndentPrinter().print(parseResult.value)
+        } else {
+          currentSource = new IdentityPrinter().print(parseResult.value)
+        }
       }
     }
 
@@ -564,15 +584,15 @@ export class Linter {
       })
 
       for (const offense of sortedSourceOffenses) {
-        const RuleClass = this.rules.find(rule => new rule().name === offense.rule)
+        const ruleClass = this.findRuleClass(offense.rule)
 
-        if (!RuleClass) {
+        if (!ruleClass) {
           unfixed.push(offense)
           continue
         }
 
-        const rule = new RuleClass() as SourceRule
-        const isUnsafe = (RuleClass as any).unsafeAutocorrectable === true
+        const rule = new ruleClass() as SourceRule
+        const isUnsafe = (ruleClass as any).unsafeAutocorrectable === true || offense.autofixContext?.unsafe === true
 
         if (!rule.autofix) {
           unfixed.push(offense)
@@ -602,4 +622,3 @@ export class Linter {
     }
   }
 }
-

package/src/parse-cache.ts

@@ -0,0 +1,39 @@
+import { DEFAULT_PARSER_OPTIONS } from "@herb-tools/core"
+import { DEFAULT_LINTER_PARSER_OPTIONS } from "./types.js"
+
+import type { ParseResult, HerbBackend, ParserOptions } from "@herb-tools/core"
+
+export class ParseCache {
+  private herb: HerbBackend
+  private cache = new Map<string, ParseResult>()
+
+  constructor(herb: HerbBackend) {
+    this.herb = herb
+  }
+
+  get(source: string, parserOptions: Partial<ParserOptions> = {}): ParseResult {
+    const effectiveOptions = this.resolveOptions(parserOptions)
+    const key = source + JSON.stringify(effectiveOptions)
+
+    let result = this.cache.get(key)
+
+    if (!result) {
+      result = this.herb.parse(source, effectiveOptions)
+      this.cache.set(key, result)
+    }
+
+    return result
+  }
+
+  clear(): void {
+    this.cache.clear()
+  }
+
+  resolveOptions(parserOptions: Partial<ParserOptions>): ParserOptions {
+    return {
+      ...DEFAULT_PARSER_OPTIONS,
+      ...DEFAULT_LINTER_PARSER_OPTIONS,
+      ...parserOptions
+    }
+  }
+}