@herb-tools/linter 0.7.4 → 0.8.0

package/dist/types/rules/rule-utils.d.ts

@@ -1,7 +1,7 @@
 import { Visitor, Location } from "@herb-tools/core";
-import type { HTMLAttributeNode, HTMLAttributeValueNode, HTMLOpenTagNode, LexResult, Token, Node } from "@herb-tools/core";
+import type { HTMLAttributeNode, HTMLAttributeValueNode, HTMLElementNode, HTMLOpenTagNode, LexResult, Token, Node } from "@herb-tools/core";
 import type * as Nodes from "@herb-tools/core";
-import type { LintOffense, LintSeverity, LintContext } from "../types.js";
+import type { UnboundLintOffense, LintContext, BaseAutofixContext } from "../types.js";
 export declare enum ControlFlowType {
     CONDITIONAL = 0,
     LOOP = 1
@@ -9,35 +9,37 @@ export declare enum ControlFlowType {
 /**
  * Base visitor class that provides common functionality for rule visitors
  */
-export declare abstract class BaseRuleVisitor extends Visitor {
-    readonly offenses: LintOffense[];
+export declare abstract class BaseRuleVisitor<TAutofixContext extends BaseAutofixContext = BaseAutofixContext> extends Visitor {
+    readonly offenses: UnboundLintOffense<TAutofixContext>[];
     protected ruleName: string;
     protected context: LintContext;
     constructor(ruleName: string, context?: Partial<LintContext>);
     /**
-     * Helper method to create a lint offense
+     * Helper method to create an unbound lint offense (without severity).
+     * The Linter will bind severity based on the rule's config.
      */
-    protected createOffense(message: string, location: Location, severity?: LintSeverity): LintOffense;
+    protected createOffense(message: string, location: Location, autofixContext?: TAutofixContext): UnboundLintOffense<TAutofixContext>;
     /**
      * Helper method to add an offense to the offenses array
      */
-    protected addOffense(message: string, location: Location, severity?: LintSeverity): void;
+    protected addOffense(message: string, location: Location, autofixContext?: TAutofixContext): void;
 }
 /**
  * Mixin that adds control flow tracking capabilities to rule visitors
  * This allows rules to track state across different control flow structures
  * like if/else branches, loops, etc.
  *
+ * @template TAutofixContext - Type for autofix context (node + custom data)
  * @template TControlFlowState - Type for state passed between onEnterControlFlow and onExitControlFlow
  * @template TBranchState - Type for state passed between onEnterBranch and onExitBranch
  */
-export declare abstract class ControlFlowTrackingVisitor<TControlFlowState = any, TBranchState = any> extends BaseRuleVisitor {
+export declare abstract class ControlFlowTrackingVisitor<TAutofixContext extends BaseAutofixContext = BaseAutofixContext, TControlFlowState = any, TBranchState = any> extends BaseRuleVisitor<TAutofixContext> {
     protected isInControlFlow: boolean;
     protected currentControlFlowType: ControlFlowType | null;
     /**
      * Handle visiting a control flow node with proper scope management
      */
-    protected handleControlFlowNode(node: Node, controlFlowType: ControlFlowType, visitChildren: () => void): void;
+    protected handleControlFlowNode(_node: Node, controlFlowType: ControlFlowType, visitChildren: () => void): void;
     /**
      * Handle visiting a branch node (like else, when) with proper scope management
      */
@@ -64,7 +66,7 @@ export declare function getAttributes(node: HTMLOpenTagNode): HTMLAttributeNode[
 /**
  * Gets the tag name from an HTML tag node (lowercased)
  */
-export declare function getTagName(node: HTMLOpenTagNode): string | null;
+export declare function getTagName(node: HTMLElementNode | HTMLOpenTagNode | null | undefined): string | null;
 /**
  * Gets the attribute name from an HTMLAttributeNode (lowercased)
  * Returns null if the attribute name contains dynamic content (ERB)
@@ -210,7 +212,7 @@ export declare function isBooleanAttribute(attributeName: string): boolean;
  * - checkDynamicAttributeStaticValue()  - name="data-<%= key %>" value="foo"
  * - checkDynamicAttributeDynamicValue() - name="data-<%= key %>" value="<%= value %>"
  */
-export declare abstract class AttributeVisitorMixin extends BaseRuleVisitor {
+export declare abstract class AttributeVisitorMixin<TAutofixContext extends BaseAutofixContext = BaseAutofixContext> extends BaseRuleVisitor<TAutofixContext> {
     constructor(ruleName: string, context?: Partial<LintContext>);
     visitHTMLOpenTagNode(node: HTMLOpenTagNode): void;
     private checkAttributesOnNode;
@@ -242,19 +244,20 @@ export declare function forEachAttribute(node: HTMLOpenTagNode, callback: (attri
 /**
  * Base lexer visitor class that provides common functionality for lexer-based rule visitors
  */
-export declare abstract class BaseLexerRuleVisitor {
-    readonly offenses: LintOffense[];
+export declare abstract class BaseLexerRuleVisitor<TAutofixContext extends BaseAutofixContext = BaseAutofixContext> {
+    readonly offenses: UnboundLintOffense<TAutofixContext>[];
     protected ruleName: string;
     protected context: LintContext;
     constructor(ruleName: string, context?: Partial<LintContext>);
     /**
-     * Helper method to create a lint offense for lexer rules
+     * Helper method to create an unbound lint offense (without severity).
+     * The Linter will bind severity based on the rule's config.
      */
-    protected createOffense(message: string, location: Location, severity?: LintSeverity): LintOffense;
+    protected createOffense(message: string, location: Location, autofixContext?: TAutofixContext): UnboundLintOffense<TAutofixContext>;
     /**
      * Helper method to add an offense to the offenses array
      */
-    protected addOffense(message: string, location: Location, severity?: LintSeverity): void;
+    protected addOffense(message: string, location: Location, autofixContext?: TAutofixContext): void;
     /**
      * Main entry point for lexer rule visitors
      * @param lexResult - The lexer result containing tokens and source
@@ -274,19 +277,20 @@ export declare abstract class BaseLexerRuleVisitor {
 /**
  * Base source visitor class that provides common functionality for source-based rule visitors
  */
-export declare abstract class BaseSourceRuleVisitor {
-    readonly offenses: LintOffense[];
+export declare abstract class BaseSourceRuleVisitor<TAutofixContext extends BaseAutofixContext = BaseAutofixContext> {
+    readonly offenses: UnboundLintOffense<TAutofixContext>[];
     protected ruleName: string;
     protected context: LintContext;
     constructor(ruleName: string, context?: Partial<LintContext>);
     /**
-     * Helper method to create a lint offense for source rules
+     * Helper method to create an unbound lint offense (without severity).
+     * The Linter will bind severity based on the rule's config.
      */
-    protected createOffense(message: string, location: Location, severity?: LintSeverity): LintOffense;
+    protected createOffense(message: string, location: Location, autofixContext?: TAutofixContext): UnboundLintOffense<TAutofixContext>;
     /**
      * Helper method to add an offense to the offenses array
      */
-    protected addOffense(message: string, location: Location, severity?: LintSeverity): void;
+    protected addOffense(message: string, location: Location, autofixContext?: TAutofixContext): void;
     /**
      * Main entry point for source rule visitors
      * @param source - The raw source code
@@ -297,8 +301,51 @@ export declare abstract class BaseSourceRuleVisitor {
      * Override this method to implement source-level checks
      */
     protected abstract visitSource(source: string): void;
-    /**
-     * Helper method to create a location for a specific position in the source
-     */
-    protected createLocationAt(source: string, position: number): Location;
 }
+/**
+ * Autofix utilities for applying string replacements
+ */
+/**
+ * Checks if two locations are equal
+ * @param a - First location
+ * @param b - Second location
+ * @returns true if locations are equal
+ */
+export declare function locationsEqual(a: Location, b: Location): boolean;
+/**
+ * Finds a node in the AST that has a specific location
+ * Uses direct recursive traversal for reliability
+ * @param root - The root node to search from
+ * @param location - The location to match
+ * @param predicate - Optional predicate function to filter nodes (e.g., isERBNode)
+ * @returns The matching node or null if not found
+ */
+export declare function findNodeByLocation(root: Node, location: Location, predicate?: (node: Node) => boolean): any;
+/**
+ * AST Navigation Utilities
+ * These utilities help navigate the AST tree for complex autofix operations
+ */
+/**
+ * Finds the parent node of a given child node in the AST
+ * @param root - The root node to search from (typically the document node)
+ * @param target - The child node to find the parent of
+ * @returns The parent node, or null if not found
+ *
+ * @example
+ * const parent = findParent(result.value, offense.autofixContext.node)
+ * if (parent?.type === "AST_HTML_ELEMENT_NODE") {
+ *   // Modify parent...
+ * }
+ */
+export declare function findParent(root: Node, target: Node): Node | null;
+export declare const DOCUMENT_ONLY_TAG_NAMES: Set<string>;
+export declare const HTML_ONLY_TAG_NAMES: Set<string>;
+export declare const HEAD_ONLY_TAG_NAMES: Set<string>;
+export declare const HEAD_AND_BODY_TAG_NAMES: Set<string>;
+export declare function isDocumentOnlyTag(tagName: string): boolean;
+export declare function isHtmlOnlyTag(tagName: string): boolean;
+export declare function isHeadOnlyTag(tagName: string): boolean;
+export declare function isHeadAndBodyTag(tagName: string): boolean;
+export declare function isBodyOnlyTag(tagName: string): boolean;
+export declare function isBodyTag(tagName: string): boolean;
+export declare function isHeadTag(tagName: string): boolean;

package/dist/types/rules/svg-tag-name-capitalization.d.ts

@@ -1,7 +1,16 @@
 import { ParserRule } from "../types.js";
-import type { LintOffense, LintContext } from "../types.js";
-import type { ParseResult } from "@herb-tools/core";
-export declare class SVGTagNameCapitalizationRule extends ParserRule {
+import type { UnboundLintOffense, LintOffense, LintContext, BaseAutofixContext, Mutable, FullRuleConfig } from "../types.js";
+import type { HTMLOpenTagNode, HTMLCloseTagNode, ParseResult } from "@herb-tools/core";
+interface SVGTagNameCapitalizationAutofixContext extends BaseAutofixContext {
+    node: Mutable<HTMLOpenTagNode | HTMLCloseTagNode>;
+    currentTagName: string;
+    correctCamelCase: string;
+}
+export declare class SVGTagNameCapitalizationRule extends ParserRule<SVGTagNameCapitalizationAutofixContext> {
+    static autocorrectable: boolean;
     name: string;
-    check(result: ParseResult, context?: Partial<LintContext>): LintOffense[];
+    get defaultConfig(): FullRuleConfig;
+    check(result: ParseResult, context?: Partial<LintContext>): UnboundLintOffense<SVGTagNameCapitalizationAutofixContext>[];
+    autofix(offense: LintOffense<SVGTagNameCapitalizationAutofixContext>, result: ParseResult, _context?: Partial<LintContext>): ParseResult | null;
 }
+export {};

package/dist/types/rules.d.ts

@@ -0,0 +1,2 @@
+import type { RuleClass } from "./types.js";
+export declare const rules: RuleClass[];

package/dist/types/src/cli/argument-parser.d.ts

@@ -1,16 +1,22 @@
 import type { ThemeInput } from "@herb-tools/highlighter";
 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 declare class ArgumentParser {
     private readonly usage;
     parse(argv: string[]): ParsedArguments;
-    private getFilePattern;
+    private getFilePatterns;
 }

package/dist/types/src/cli/file-processor.d.ts

@@ -1,18 +1,31 @@
+import { Config } from "@herb-tools/config";
 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, {
@@ -23,5 +36,7 @@ export interface ProcessingResult {
 }
 export declare class FileProcessor {
     private linter;
+    private customRulesLoaded;
+    private isRuleAutocorrectable;
     processFiles(files: string[], formatOption?: FormatOption, context?: ProcessingContext): Promise<ProcessingResult>;
 }

package/dist/types/src/cli/formatters/json-formatter.d.ts

@@ -9,6 +9,9 @@ interface JSONSummary {
     filesWithOffenses: number;
     totalErrors: number;
     totalWarnings: number;
+    totalInfo: number;
+    totalHints: number;
+    totalIgnored: number;
     totalOffenses: number;
     ruleCount: number;
 }
@@ -28,6 +31,9 @@ interface JSONFormatOptions {
     files: string[];
     totalErrors: number;
     totalWarnings: number;
+    totalInfo: number;
+    totalHints: number;
+    totalIgnored: number;
     filesWithOffenses: number;
     ruleCount: number;
     startTime: number;

package/dist/types/src/cli/formatters/simple-formatter.d.ts

@@ -4,4 +4,5 @@ import type { ProcessedFile } from "../file-processor.js";
 export declare class SimpleFormatter extends BaseFormatter {
     format(allOffenses: ProcessedFile[]): Promise<void>;
     formatFile(filename: string, offenses: Diagnostic[]): void;
+    formatFileProcessed(filename: string, processedFiles: ProcessedFile[]): void;
 }

package/dist/types/src/cli/summary-reporter.d.ts

@@ -2,6 +2,10 @@ export interface SummaryData {
     files: string[];
     totalErrors: number;
     totalWarnings: number;
+    totalInfo?: number;
+    totalHints?: number;
+    totalIgnored: number;
+    totalWouldBeIgnored?: number;
     filesWithOffenses: number;
     ruleCount: number;
     startTime: number;
@@ -11,6 +15,8 @@ export interface SummaryData {
         count: number;
         files: Set<string>;
     }>;
+    autofixableCount: number;
+    ignoreDisableComments?: boolean;
 }
 export declare class SummaryReporter {
     private pluralize;

package/dist/types/src/cli.d.ts

@@ -1,6 +1,8 @@
-import { ArgumentParser, type FormatOption } from "./cli/argument-parser.js";
+import { Config } from "@herb-tools/config";
+import { ArgumentParser } from "./cli/argument-parser.js";
 import { FileProcessor } from "./cli/file-processor.js";
 import { OutputManager } from "./cli/output-manager.js";
+import type { FormatOption } from "./cli/argument-parser.js";
 export * from "./cli/index.js";
 export declare class CLI {
     protected argumentParser: ArgumentParser;
@@ -8,15 +10,18 @@ export declare class CLI {
     protected outputManager: OutputManager;
     protected projectPath: string;
     getProjectPath(): string;
-    protected findProjectRoot(startPath: string): string;
     protected exitWithError(message: string, formatOption: FormatOption, exitCode?: number): void;
     protected exitWithInfo(message: string, formatOption: FormatOption, exitCode?: number, timingData?: {
         startTime: number;
         startDate: Date;
         showTiming: boolean;
     }): void;
-    protected determineProjectPath(pattern: string | undefined): void;
-    protected adjustPattern(pattern: string | undefined): string;
+    protected determineProjectPath(patterns: string[]): void;
+    protected adjustPattern(pattern: string | undefined, configGlobPattern: string): string;
+    protected resolvePatternToFiles(pattern: string, config: Config, force: boolean): Promise<{
+        files: string[];
+        explicitFile: string | undefined;
+    }>;
     protected beforeProcess(): Promise<void>;
     protected afterProcess(_results: any, _outputOptions: any): Promise<void>;
     run(): Promise<void>;

package/dist/types/src/custom-rule-loader.d.ts

@@ -0,0 +1,62 @@
+import type { RuleClass } from "./types.js";
+export interface CustomRuleLoaderOptions {
+    /**
+     * Base directory to search for custom rules
+     * Defaults to current working directory
+     */
+    baseDir?: string;
+    /**
+     * Glob patterns to search for custom rule files
+     * Defaults to looking in common locations
+     */
+    patterns?: string[];
+    /**
+     * Whether to suppress errors when loading custom rules
+     * Defaults to false
+     */
+    silent?: boolean;
+}
+/**
+ * Loads custom linter rules from the user's project
+ */
+export declare class CustomRuleLoader {
+    private baseDir;
+    private patterns;
+    private silent;
+    constructor(options?: CustomRuleLoaderOptions);
+    /**
+     * Discovers custom rule files in the project
+     */
+    discoverRuleFiles(): Promise<string[]>;
+    /**
+     * Loads a single rule file
+     */
+    loadRuleFile(filePath: string): Promise<RuleClass[]>;
+    /**
+     * Type guard to check if an export is a valid rule class
+     */
+    private isValidRuleClass;
+    /**
+     * Loads all custom rules from the project
+     */
+    loadRules(): Promise<RuleClass[]>;
+    /**
+     * Loads all custom rules and returns detailed information about each rule
+     */
+    loadRulesWithInfo(): Promise<{
+        rules: RuleClass[];
+        ruleInfo: Array<{
+            name: string;
+            path: string;
+        }>;
+        duplicateWarnings: string[];
+    }>;
+    /**
+     * Static helper to check if custom rules exist in a project
+     */
+    static hasCustomRules(baseDir?: string): Promise<boolean>;
+    /**
+     * Static helper to load custom rules and merge with default rules
+     */
+    static loadAndMergeRules(defaultRules: RuleClass[], options?: CustomRuleLoaderOptions): Promise<RuleClass[]>;
+}

package/dist/types/src/herb-disable-comment-utils.d.ts

@@ -0,0 +1,69 @@
+/**
+ * Utilities for parsing herb:disable comments
+ */
+/**
+ * Information about a single rule name in a herb:disable comment
+ */
+export interface HerbDisableRuleName {
+    /** The rule name */
+    name: string;
+    /** The starting offset of this rule name within the content/line */
+    offset: number;
+    /** The length of the rule name */
+    length: number;
+}
+/**
+ * Result of parsing a herb:disable comment
+ */
+export interface HerbDisableComment {
+    /** The full matched string */
+    match: string;
+    /** Array of rule names specified in the comment */
+    ruleNames: string[];
+    /** Array of rule name information with positions */
+    ruleNameDetails: HerbDisableRuleName[];
+    /** The original rules string (e.g., "rule1, rule2") */
+    rulesString: string;
+}
+/**
+ * Parse a herb:disable comment from ERB comment content.
+ * Use this when you have the content inside <%# ... %> (e.g., from ERBContentNode.content.value)
+ *
+ * @param content - The content string (without <%# %> delimiters)
+ * @returns Parsed comment data or null if not a valid herb:disable comment
+ *
+ * @example
+ * ```ts
+ * const result = parseHerbDisableContent("herb:disable rule1, rule2")
+ * // { match: "herb:disable rule1, rule2", ruleNames: ["rule1", "rule2"], rulesString: "rule1, rule2" }
+ * ```
+ */
+export declare function parseHerbDisableContent(content: string): HerbDisableComment | null;
+/**
+ * Parse a herb:disable comment from a full source line.
+ * Use this when you have a complete line that may contain <%# herb:disable ... %>
+ *
+ * @param line - The source line that may contain a herb:disable comment
+ * @returns Parsed comment data or null if not a valid herb:disable comment
+ *
+ * @example
+ * ```ts
+ * const result = parseHerbDisableLine("<div>test</div> <%# herb:disable rule1, rule2 %>")
+ * // { match: "<%# herb:disable rule1, rule2 %>", ruleNames: ["rule1", "rule2"], rulesString: "rule1, rule2" }
+ * ```
+ */
+export declare function parseHerbDisableLine(line: string): HerbDisableComment | null;
+/**
+ * Check if an ERB comment content contains a herb:disable directive.
+ *
+ * @param content - The content string (without <%# %> delimiters)
+ * @returns true if the content contains a herb:disable directive
+ */
+export declare function isHerbDisableContent(content: string): boolean;
+/**
+ * Check if a source line contains a herb:disable comment.
+ *
+ * @param line - The source line
+ * @returns true if the line contains a herb:disable comment
+ */
+export declare function isHerbDisableLine(line: string): boolean;

package/dist/types/src/index.d.ts

@@ -1,3 +1,4 @@
 export * from "./linter.js";
 export * from "./rules/index.js";
 export * from "./types.js";
+export { rules } from "./rules.js";

package/dist/types/src/linter.d.ts

@@ -1,20 +1,89 @@
-import type { RuleClass, Rule, LexerRule, SourceRule, LintResult, LintOffense, LintContext } from "./types.js";
+import type { RuleClass, Rule, LexerRule, SourceRule, LintResult, LintOffense, UnboundLintOffense, LintContext, AutofixResult } from "./types.js";
 import type { HerbBackend } from "@herb-tools/core";
+import type { RuleConfig, Config } from "@herb-tools/config";
+export interface LinterOptions {
+    /**
+     * Array of rule classes to use. If not provided, uses default rules.
+     */
+    rules?: RuleClass[];
+    /**
+     * Whether to load custom rules from the project.
+     * Defaults to false for backward compatibility.
+     */
+    loadCustomRules?: boolean;
+    /**
+     * Base directory to search for custom rules.
+     * Defaults to current working directory.
+     */
+    customRulesBaseDir?: string;
+    /**
+     * Custom glob patterns to search for rule files.
+     */
+    customRulesPatterns?: string[];
+    /**
+     * Whether to suppress custom rule loading errors.
+     * Defaults to false.
+     */
+    silentCustomRules?: boolean;
+}
 export declare class Linter {
     protected rules: RuleClass[];
+    protected allAvailableRules: RuleClass[];
     protected herb: HerbBackend;
     protected offenses: LintOffense[];
+    protected config?: Config;
+    /**
+     * Creates a new Linter instance with automatic rule filtering based on config.
+     *
+     * @param herb - The Herb backend instance for parsing and lexing
+     * @param config - Optional full Config instance for rule filtering, severity overrides, and path-based filtering
+     * @param customRules - Optional array of custom rules to include alongside built-in rules
+     * @returns A configured Linter instance
+     */
+    static from(herb: HerbBackend, config?: Config, customRules?: RuleClass[]): Linter;
     /**
      * Creates a new Linter instance.
+     *
+     * For most use cases, prefer `Linter.from()` which handles config-based filtering.
+     * Use this constructor directly when you need explicit control over rules.
+     *
      * @param herb - The Herb backend instance for parsing and lexing
      * @param rules - Array of rule classes (Parser/AST or Lexer) to use. If not provided, uses default rules.
+     * @param config - Optional full Config instance for severity overrides and path-based rule filtering
+     * @param allAvailableRules - Optional array of ALL available rules (including disabled) for herb:disable validation
+     */
+    constructor(herb: HerbBackend, rules?: RuleClass[], config?: Config, allAvailableRules?: RuleClass[]);
+    /**
+     * Filters rules based on default config and optional user config overrides.
+     *
+     * Priority:
+     * 1. User config override (if rule config exists in userRulesConfig)
+     * 2. Default config from rule's defaultConfig getter
+     *
+     * @param allRules - All available rule classes to filter from
+     * @param userRulesConfig - Optional user configuration for rules
+     * @returns Filtered array of rule classes that should be enabled
      */
-    constructor(herb: HerbBackend, rules?: RuleClass[]);
+    static filterRulesByConfig(allRules: RuleClass[], userRulesConfig?: Record<string, RuleConfig>): RuleClass[];
     /**
      * Returns the default set of rule classes used by the linter.
-     * @returns Array of rule classes
+     * These are the rules enabled when no custom rules are provided.
+     * Filters all available rules to only include those enabled by default.
+     * @returns Array of default rule classes
      */
     protected getDefaultRules(): RuleClass[];
+    /**
+     * Returns all available rule classes that can be referenced in herb:disable comments.
+     * This includes all rules that exist, regardless of whether they're currently enabled.
+     * Includes both built-in rules and any loaded custom rules.
+     * @returns Array of all available rule classes
+     */
+    protected getAvailableRules(): RuleClass[];
+    /**
+     * Meta-linting rules for herb:disable comments cannot be disabled
+     * This ensures that invalid herb:disable comments are always caught
+     */
+    protected get nonExcludableRules(): string[];
     getRuleCount(): number;
     /**
      * Type guard to check if a rule is a LexerRule
@@ -24,10 +93,37 @@ export declare class Linter {
      * Type guard to check if a rule is a SourceRule
      */
     protected isSourceRule(rule: Rule): rule is SourceRule;
+    /**
+     * Execute a single rule and return its unbound offenses.
+     * Handles rule type checking (Lexer/Parser/Source) and isEnabled checks.
+     */
+    private executeRule;
+    private filterOffenses;
     /**
      * Lint source code using Parser/AST, Lexer, and Source rules.
      * @param source - The source code to lint
      * @param context - Optional context for linting (e.g., fileName for distinguishing files vs snippets)
      */
     lint(source: string, context?: Partial<LintContext>): LintResult;
+    /**
+     * Bind severity to unbound offenses based on rule's defaultConfig and user config overrides.
+     *
+     * Priority:
+     * 1. User config severity override (if specified in config)
+     * 2. Rule's default severity (from defaultConfig.severity)
+     *
+     * @param unboundOffenses - Array of offenses without severity
+     * @param ruleName - Name of the rule that produced the offenses
+     * @returns Array of offenses with severity bound
+     */
+    protected bindSeverity(unboundOffenses: UnboundLintOffense[], ruleName: string): LintOffense[];
+    /**
+     * Automatically fix offenses in the source code.
+     * Uses AST mutation for parser rules and token mutation for lexer rules.
+     * @param source - The source code to fix
+     * @param context - Optional context for linting (e.g., fileName)
+     * @param offensesToFix - Optional array of specific offenses to fix. If not provided, all fixable offenses will be fixed.
+     * @returns AutofixResult containing the corrected source and lists of fixed/unfixed offenses
+     */
+    autofix(source: string, context?: Partial<LintContext>, offensesToFix?: LintOffense[]): AutofixResult;
 }

package/dist/types/src/loader.d.ts

@@ -0,0 +1,20 @@
+export * from "./index.js";
+export { CustomRuleLoader } from "./custom-rule-loader.js";
+export type { CustomRuleLoaderOptions } from "./custom-rule-loader.js";
+import type { RuleClass } from "./types.js";
+/**
+ * Loads custom rules from the filesystem.
+ * Only available in Node.js environments.
+ */
+export declare function loadCustomRules(options?: {
+    baseDir?: string;
+    patterns?: string[];
+    silent?: boolean;
+}): Promise<{
+    rules: RuleClass[];
+    ruleInfo: Array<{
+        name: string;
+        path: string;
+    }>;
+    warnings: string[];
+}>;

package/dist/types/src/rules/erb-comment-syntax.d.ts

@@ -0,0 +1,14 @@
+import { ParserRule, BaseAutofixContext, Mutable } from "../types.js";
+import type { UnboundLintOffense, LintOffense, LintContext, FullRuleConfig } from "../types.js";
+import type { ParseResult, ERBContentNode } from "@herb-tools/core";
+interface ERBCommentSyntaxAutofixContext extends BaseAutofixContext {
+    node: Mutable<ERBContentNode>;
+}
+export declare class ERBCommentSyntax extends ParserRule<ERBCommentSyntaxAutofixContext> {
+    static autocorrectable: boolean;
+    name: string;
+    get defaultConfig(): FullRuleConfig;
+    check(result: ParseResult, context?: Partial<LintContext>): UnboundLintOffense<ERBCommentSyntaxAutofixContext>[];
+    autofix(offense: LintOffense<ERBCommentSyntaxAutofixContext>, result: ParseResult, _context?: Partial<LintContext>): ParseResult | null;
+}
+export {};

package/dist/types/src/rules/erb-no-case-node-children.d.ts

@@ -0,0 +1,8 @@
+import { ParserRule } from "../types.js";
+import type { UnboundLintOffense, LintContext, FullRuleConfig } from "../types.js";
+import type { ParseResult } from "@herb-tools/core";
+export declare class ERBNoCaseNodeChildrenRule extends ParserRule {
+    name: string;
+    get defaultConfig(): FullRuleConfig;
+    check(result: ParseResult, context?: Partial<LintContext>): UnboundLintOffense[];
+}