@herb-tools/linter 0.4.2 → 0.4.3

package/dist/types/src/rules/html-aria-attribute-must-be-valid.d.ts

@@ -1,6 +1,7 @@
-import type { LintOffense, Rule } from "../types.js";
+import { ParserRule } from "../types.js";
+import type { LintOffense, LintContext } from "../types.js";
 import type { Node } from "@herb-tools/core";
-export declare class HTMLAriaAttributeMustBeValid implements Rule {
+export declare class HTMLAriaAttributeMustBeValid extends ParserRule {
     name: string;
-    check(node: Node): LintOffense[];
+    check(node: Node, context?: Partial<LintContext>): LintOffense[];
 }

package/dist/types/src/rules/html-aria-level-must-be-valid.d.ts

@@ -0,0 +1,7 @@
+import { ParserRule } from "../types.js";
+import type { LintOffense, LintContext } from "../types.js";
+import type { Node } from "@herb-tools/core";
+export declare class HTMLAriaLevelMustBeValidRule extends ParserRule {
+    name: string;
+    check(node: Node, context?: Partial<LintContext>): LintOffense[];
+}

package/dist/types/src/rules/html-aria-role-heading-requires-level.d.ts

@@ -1,6 +1,7 @@
-import type { Rule, LintOffense } from "../types.js";
+import { ParserRule } from "../types.js";
+import type { LintOffense, LintContext } from "../types.js";
 import type { Node } from "@herb-tools/core";
-export declare class HTMLAriaRoleHeadingRequiresLevelRule implements Rule {
+export declare class HTMLAriaRoleHeadingRequiresLevelRule extends ParserRule {
     name: string;
-    check(node: Node): LintOffense[];
+    check(node: Node, context?: Partial<LintContext>): LintOffense[];
 }

package/dist/types/src/rules/html-aria-role-must-be-valid.d.ts

@@ -1,6 +1,7 @@
-import type { Rule, LintOffense } from "../types.js";
+import { ParserRule } from "../types.js";
+import type { LintOffense, LintContext } from "../types.js";
 import type { Node } from "@herb-tools/core";
-export declare class HTMLAriaRoleMustBeValidRule implements Rule {
+export declare class HTMLAriaRoleMustBeValidRule extends ParserRule {
     name: string;
-    check(node: Node): LintOffense[];
+    check(node: Node, context?: Partial<LintContext>): LintOffense[];
 }

package/dist/types/src/rules/html-attribute-double-quotes.d.ts

@@ -1,6 +1,7 @@
-import type { Rule, LintOffense } from "../types.js";
+import { ParserRule } from "../types.js";
+import type { LintOffense, LintContext } from "../types.js";
 import type { Node } from "@herb-tools/core";
-export declare class HTMLAttributeDoubleQuotesRule implements Rule {
+export declare class HTMLAttributeDoubleQuotesRule extends ParserRule {
     name: string;
-    check(node: Node): LintOffense[];
+    check(node: Node, context?: Partial<LintContext>): LintOffense[];
 }

package/dist/types/src/rules/html-attribute-values-require-quotes.d.ts

@@ -1,6 +1,7 @@
-import type { Rule, LintOffense } from "../types.js";
+import { ParserRule } from "../types.js";
+import type { LintOffense, LintContext } from "../types.js";
 import type { Node } from "@herb-tools/core";
-export declare class HTMLAttributeValuesRequireQuotesRule implements Rule {
+export declare class HTMLAttributeValuesRequireQuotesRule extends ParserRule {
     name: string;
-    check(node: Node): LintOffense[];
+    check(node: Node, context?: Partial<LintContext>): LintOffense[];
 }

package/dist/types/src/rules/html-boolean-attributes-no-value.d.ts

@@ -1,6 +1,7 @@
-import type { Rule, LintOffense } from "../types.js";
+import { ParserRule } from "../types.js";
+import type { LintOffense, LintContext } from "../types.js";
 import type { Node } from "@herb-tools/core";
-export declare class HTMLBooleanAttributesNoValueRule implements Rule {
+export declare class HTMLBooleanAttributesNoValueRule extends ParserRule {
     name: string;
-    check(node: Node): LintOffense[];
+    check(node: Node, context?: Partial<LintContext>): LintOffense[];
 }

package/dist/types/src/rules/html-img-require-alt.d.ts

@@ -1,6 +1,7 @@
-import type { Rule, LintOffense } from "../types.js";
+import { ParserRule } from "../types.js";
+import type { LintOffense, LintContext } from "../types.js";
 import type { Node } from "@herb-tools/core";
-export declare class HTMLImgRequireAltRule implements Rule {
+export declare class HTMLImgRequireAltRule extends ParserRule {
     name: string;
-    check(node: Node): LintOffense[];
+    check(node: Node, context?: Partial<LintContext>): LintOffense[];
 }

package/dist/types/src/rules/html-no-block-inside-inline.d.ts

@@ -1,6 +1,7 @@
-import type { Rule, LintOffense } from "../types.js";
+import { ParserRule } from "../types.js";
+import type { LintOffense, LintContext } from "../types.js";
 import type { Node } from "@herb-tools/core";
-export declare class HTMLNoBlockInsideInlineRule implements Rule {
+export declare class HTMLNoBlockInsideInlineRule extends ParserRule {
     name: string;
-    check(node: Node): LintOffense[];
+    check(node: Node, context?: Partial<LintContext>): LintOffense[];
 }

package/dist/types/src/rules/html-no-duplicate-attributes.d.ts

@@ -1,6 +1,7 @@
-import type { Rule, LintOffense } from "../types.js";
+import { ParserRule } from "../types.js";
+import type { LintOffense, LintContext } from "../types.js";
 import type { Node } from "@herb-tools/core";
-export declare class HTMLNoDuplicateAttributesRule implements Rule {
+export declare class HTMLNoDuplicateAttributesRule extends ParserRule {
     name: string;
-    check(node: Node): LintOffense[];
+    check(node: Node, context?: Partial<LintContext>): LintOffense[];
 }

package/dist/types/src/rules/html-no-duplicate-ids.d.ts

@@ -1,6 +1,7 @@
+import { ParserRule } from "../types";
 import type { Node } from "@herb-tools/core";
-import type { LintOffense, Rule } from "../types";
-export declare class HTMLNoDuplicateIdsRule implements Rule {
+import type { LintOffense, LintContext } from "../types";
+export declare class HTMLNoDuplicateIdsRule extends ParserRule {
     name: string;
-    check(node: Node): LintOffense[];
+    check(node: Node, context?: Partial<LintContext>): LintOffense[];
 }

package/dist/types/src/rules/html-no-empty-headings.d.ts

@@ -1,6 +1,7 @@
-import type { Rule, LintOffense } from "../types.js";
+import { ParserRule } from "../types.js";
+import type { LintOffense, LintContext } from "../types.js";
 import type { Node } from "@herb-tools/core";
-export declare class HTMLNoEmptyHeadingsRule implements Rule {
+export declare class HTMLNoEmptyHeadingsRule extends ParserRule {
     name: string;
-    check(node: Node): LintOffense[];
+    check(node: Node, context?: Partial<LintContext>): LintOffense[];
 }

package/dist/types/src/rules/html-no-nested-links.d.ts

@@ -1,6 +1,7 @@
-import type { Rule, LintOffense } from "../types.js";
+import { ParserRule } from "../types.js";
+import type { LintOffense, LintContext } from "../types.js";
 import type { Node } from "@herb-tools/core";
-export declare class HTMLNoNestedLinksRule implements Rule {
+export declare class HTMLNoNestedLinksRule extends ParserRule {
     name: string;
-    check(node: Node): LintOffense[];
+    check(node: Node, context?: Partial<LintContext>): LintOffense[];
 }

package/dist/types/src/rules/html-tag-name-lowercase.d.ts

@@ -1,6 +1,7 @@
-import type { Rule, LintOffense } from "../types.js";
+import { ParserRule } from "../types.js";
+import type { LintOffense, LintContext } from "../types.js";
 import type { Node } from "@herb-tools/core";
-export declare class HTMLTagNameLowercaseRule implements Rule {
+export declare class HTMLTagNameLowercaseRule extends ParserRule {
     name: string;
-    check(node: Node): LintOffense[];
+    check(node: Node, context?: Partial<LintContext>): LintOffense[];
 }

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

@@ -1,6 +1,9 @@
 export * from "./erb-no-empty-tags.js";
 export * from "./erb-no-output-control-flow.js";
+export * from "./erb-prefer-image-tag-helper.js";
+export * from "./erb-requires-trailing-newline.js";
 export * from "./html-anchor-require-href.js";
+export * from "./html-aria-level-must-be-valid.js";
 export * from "./html-aria-role-heading-requires-level.js";
 export * from "./html-aria-role-must-be-valid.js";
 export * from "./html-attribute-double-quotes.js";

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

@@ -1,13 +1,14 @@
-import { Visitor } from "@herb-tools/core";
-import type { HTMLAttributeNode, HTMLOpenTagNode, HTMLSelfCloseTagNode, Location } from "@herb-tools/core";
-import type { LintOffense, LintSeverity } from "../types.js";
+import { Visitor, Location } from "@herb-tools/core";
+import type { HTMLAttributeNode, HTMLOpenTagNode, HTMLSelfCloseTagNode, LexResult, Token } from "@herb-tools/core";
+import type { LintOffense, LintSeverity, LintContext } from "../types.js";
 /**
  * Base visitor class that provides common functionality for rule visitors
  */
 export declare abstract class BaseRuleVisitor extends Visitor {
     readonly offenses: LintOffense[];
     protected ruleName: string;
-    constructor(ruleName: string);
+    protected context: LintContext;
+    constructor(ruleName: string, context?: Partial<LintContext>);
     /**
      * Helper method to create a lint offense
      */
@@ -67,6 +68,10 @@ export declare const SVG_CAMEL_CASE_ELEMENTS: Set<string>;
 export declare const SVG_LOWERCASE_TO_CAMELCASE: Map<string, string>;
 export declare const VALID_ARIA_ROLES: Set<string>;
 export declare const ARIA_ATTRIBUTES: Set<string>;
+/**
+ * Helper function to create a location at the end of the source with a 1-character range
+ */
+export declare function createEndOfFileLocation(source: string): Location;
 /**
  * Checks if an element is inline
  */
@@ -85,6 +90,7 @@ export declare function isBooleanAttribute(attributeName: string): boolean;
  * and attribute iteration logic. Provides simplified interface with extracted attribute info.
  */
 export declare abstract class AttributeVisitorMixin extends BaseRuleVisitor {
+    constructor(ruleName: string, context?: Partial<LintContext>);
     visitHTMLOpenTagNode(node: HTMLOpenTagNode): void;
     visitHTMLSelfCloseTagNode(node: HTMLSelfCloseTagNode): void;
     private checkAttributesOnNode;
@@ -98,3 +104,66 @@ export declare function isAttributeValueQuoted(attributeNode: HTMLAttributeNode)
  * Iterates over all attributes of a tag node, calling the callback for each attribute
  */
 export declare function forEachAttribute(node: HTMLOpenTagNode | HTMLSelfCloseTagNode, callback: (attributeNode: HTMLAttributeNode) => void): void;
+/**
+ * Base lexer visitor class that provides common functionality for lexer-based rule visitors
+ */
+export declare abstract class BaseLexerRuleVisitor {
+    readonly offenses: LintOffense[];
+    protected ruleName: string;
+    protected context: LintContext;
+    constructor(ruleName: string, context?: Partial<LintContext>);
+    /**
+     * Helper method to create a lint offense for lexer rules
+     */
+    protected createOffense(message: string, location: Location, severity?: LintSeverity): LintOffense;
+    /**
+     * Helper method to add an offense to the offenses array
+     */
+    protected addOffense(message: string, location: Location, severity?: LintSeverity): void;
+    /**
+     * Main entry point for lexer rule visitors
+     * @param lexResult - The lexer result containing tokens and source
+     */
+    visit(lexResult: LexResult): void;
+    /**
+     * Visit all tokens
+     * Override this method to implement token-level checks
+     */
+    protected visitTokens(tokens: Token[]): void;
+    /**
+     * Visit individual tokens
+     * Override this method to implement per-token checks
+     */
+    protected visitToken(_token: Token): void;
+}
+/**
+ * Base source visitor class that provides common functionality for source-based rule visitors
+ */
+export declare abstract class BaseSourceRuleVisitor {
+    readonly offenses: LintOffense[];
+    protected ruleName: string;
+    protected context: LintContext;
+    constructor(ruleName: string, context?: Partial<LintContext>);
+    /**
+     * Helper method to create a lint offense for source rules
+     */
+    protected createOffense(message: string, location: Location, severity?: LintSeverity): LintOffense;
+    /**
+     * Helper method to add an offense to the offenses array
+     */
+    protected addOffense(message: string, location: Location, severity?: LintSeverity): void;
+    /**
+     * Main entry point for source rule visitors
+     * @param source - The raw source code
+     */
+    visit(source: string): void;
+    /**
+     * Visit the source code directly
+     * 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;
+}

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

@@ -1,6 +1,7 @@
-import type { Rule, LintOffense } from "../types.js";
+import { ParserRule } from "../types.js";
+import type { LintOffense, LintContext } from "../types.js";
 import type { Node } from "@herb-tools/core";
-export declare class SVGTagNameCapitalizationRule implements Rule {
+export declare class SVGTagNameCapitalizationRule extends ParserRule {
     name: string;
-    check(node: Node): LintOffense[];
+    check(node: Node, context?: Partial<LintContext>): LintOffense[];
 }

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

@@ -1,4 +1,4 @@
-import { Node, Diagnostic } from "@herb-tools/core";
+import { Node, Diagnostic, LexResult } from "@herb-tools/core";
 import type { defaultRules } from "./default-rules.js";
 export type LintSeverity = "error" | "warning";
 /**
@@ -15,12 +15,55 @@ export interface LintResult {
     errors: number;
     warnings: number;
 }
-export interface Rule {
-    name: string;
-    check(node: Node): LintOffense[];
+export declare abstract class ParserRule {
+    static type: "parser";
+    abstract name: string;
+    abstract check(node: Node, context?: Partial<LintContext>): LintOffense[];
+}
+export declare abstract class LexerRule {
+    static type: "lexer";
+    abstract name: string;
+    abstract check(lexResult: LexResult, context?: Partial<LintContext>): LintOffense[];
+}
+export interface LexerRuleConstructor {
+    type: "lexer";
+    new (): LexerRule;
 }
 /**
- * Type representing a rule class constructor.
+ * Complete lint context with all properties defined.
+ * Use Partial<LintContext> when passing context to rules.
+ */
+export interface LintContext {
+    fileName: string | undefined;
+}
+/**
+ * Default context object with all keys defined but set to undefined
+ */
+export declare const DEFAULT_LINT_CONTEXT: LintContext;
+export declare abstract class SourceRule {
+    static type: "source";
+    abstract name: string;
+    abstract check(source: string, context?: Partial<LintContext>): LintOffense[];
+}
+export interface SourceRuleConstructor {
+    type: "source";
+    new (): SourceRule;
+}
+/**
+ * Type representing a parser/AST rule class constructor.
  * The Linter accepts rule classes rather than instances for better performance and memory usage.
+ * Parser rules are the default and don't require static properties.
+ */
+export type ParserRuleClass = (new () => ParserRule) & {
+    type?: "parser";
+};
+export type LexerRuleClass = LexerRuleConstructor;
+export type SourceRuleClass = SourceRuleConstructor;
+/**
+ * Union type for any rule instance (Parser/AST, Lexer, or Source)
+ */
+export type Rule = ParserRule | LexerRule | SourceRule;
+/**
+ * Union type for any rule class (Parser/AST, Lexer, or Source)
  */
-export type RuleClass = new () => Rule;
+export type RuleClass = ParserRuleClass | LexerRuleClass | SourceRuleClass;

package/dist/types/types.d.ts

@@ -1,4 +1,4 @@
-import { Node, Diagnostic } from "@herb-tools/core";
+import { Node, Diagnostic, LexResult } from "@herb-tools/core";
 import type { defaultRules } from "./default-rules.js";
 export type LintSeverity = "error" | "warning";
 /**
@@ -15,12 +15,55 @@ export interface LintResult {
     errors: number;
     warnings: number;
 }
-export interface Rule {
-    name: string;
-    check(node: Node): LintOffense[];
+export declare abstract class ParserRule {
+    static type: "parser";
+    abstract name: string;
+    abstract check(node: Node, context?: Partial<LintContext>): LintOffense[];
+}
+export declare abstract class LexerRule {
+    static type: "lexer";
+    abstract name: string;
+    abstract check(lexResult: LexResult, context?: Partial<LintContext>): LintOffense[];
+}
+export interface LexerRuleConstructor {
+    type: "lexer";
+    new (): LexerRule;
 }
 /**
- * Type representing a rule class constructor.
+ * Complete lint context with all properties defined.
+ * Use Partial<LintContext> when passing context to rules.
+ */
+export interface LintContext {
+    fileName: string | undefined;
+}
+/**
+ * Default context object with all keys defined but set to undefined
+ */
+export declare const DEFAULT_LINT_CONTEXT: LintContext;
+export declare abstract class SourceRule {
+    static type: "source";
+    abstract name: string;
+    abstract check(source: string, context?: Partial<LintContext>): LintOffense[];
+}
+export interface SourceRuleConstructor {
+    type: "source";
+    new (): SourceRule;
+}
+/**
+ * Type representing a parser/AST rule class constructor.
  * The Linter accepts rule classes rather than instances for better performance and memory usage.
+ * Parser rules are the default and don't require static properties.
+ */
+export type ParserRuleClass = (new () => ParserRule) & {
+    type?: "parser";
+};
+export type LexerRuleClass = LexerRuleConstructor;
+export type SourceRuleClass = SourceRuleConstructor;
+/**
+ * Union type for any rule instance (Parser/AST, Lexer, or Source)
+ */
+export type Rule = ParserRule | LexerRule | SourceRule;
+/**
+ * Union type for any rule class (Parser/AST, Lexer, or Source)
  */
-export type RuleClass = new () => Rule;
+export type RuleClass = ParserRuleClass | LexerRuleClass | SourceRuleClass;

package/docs/rules/README.md

@@ -6,9 +6,12 @@ This page contains documentation for all Herb Linter rules.
 
 - [`erb-no-empty-tags`](./erb-no-empty-tags.md) - Disallow empty ERB tags
 - [`erb-no-output-control-flow`](./erb-no-output-control-flow.md) - Prevents outputting control flow blocks
+- [`erb-prefer-image-tag-helper`](./erb-prefer-image-tag-helper.md) - Prefer `image_tag` helper over `<img>` with ERB expressions
 - [`erb-require-whitespace-inside-tags`](./erb-require-whitespace-inside-tags.md) - Requires whitespace around erb tags
+- [`erb-requires-trailing-newline`](./erb-requires-trailing-newline.md) - Enforces that all HTML+ERB template files end with exactly one trailing newline character.
 - [`html-anchor-require-href`](./html-anchor-require-href.md) - Requires an href attribute on anchor tags
 - [`html-aria-attribute-must-be-valid`](./html-aria-attribute-must-be-valid.md) - Disallow invalid or unknown `aria-*` attributes.
+- [`html-aria-level-must-be-valid`](./html-aria-level-must-be-valid.md) - `aria-level` must be between 1 and 6
 - [`html-aria-role-heading-requires-level`](./html-aria-role-heading-requires-level.md) - Requires `aria-level` when supplying a `role`
 - [`html-aria-role-must-be-valid`](./html-aria-role-must-be-valid.md) - The `role` attribute must have a valid WAI-ARIA Role.
 - [`html-attribute-double-quotes`](./html-attribute-double-quotes.md) - Enforces double quotes for attribute values
@@ -16,8 +19,8 @@ This page contains documentation for all Herb Linter rules.
 - [`html-boolean-attributes-no-value`](./html-boolean-attributes-no-value.md) - Prevents values on boolean attributes
 - [`html-img-require-alt`](./html-img-require-alt.md) - Requires alt attributes on img tags
 - [`html-no-block-inside-inline`](./html-no-block-inside-inline.md) - Prevents block-level elements inside inline elements
-- [`html-no-duplicate-ids`](./html-no-duplicate-ids.md) - Prevents duplicate IDs within a document
 - [`html-no-duplicate-attributes`](./html-no-duplicate-attributes.md) - Prevents duplicate attributes on HTML elements
+- [`html-no-duplicate-ids`](./html-no-duplicate-ids.md) - Prevents duplicate IDs within a document
 - [`html-no-nested-links`](./html-no-nested-links.md) - Prevents nested anchor tags
 - [`html-tag-name-lowercase`](./html-tag-name-lowercase.md) - Enforces lowercase tag names in HTML
 - [`svg-tag-name-capitalization`](./svg-tag-name-capitalization.md) - Enforces proper camelCase capitalization for SVG elements

package/docs/rules/erb-prefer-image-tag-helper.md

@@ -0,0 +1,65 @@
+# Linter Rule: Prefer `image_tag` helper over `<img>` with ERB expressions
+
+**Rule:** `erb-prefer-image-tag-helper`
+
+## Description
+
+Prefer using Rails' `image_tag` helper over manual `<img>` tags with dynamic ERB expressions like `image_path` or `asset_path`.
+
+## Rationale
+
+The `image_tag` helper provides several advantages over manual `<img>` tags with dynamic ERB expressions. It properly escapes the `src` value to prevent XSS vulnerabilities and ensures consistent rendering across different contexts. Using `image_tag` also reduces template complexity by eliminating the need for manual string interpolation and makes it easier to add additional attributes like `alt`, `class`, or `data-*` attributes in a clean, readable way. Additionally, it prevents common interpolation issues that can arise when mixing ERB expressions with static text in attribute values.
+
+## Examples
+
+### ✅ Good
+
+```erb
+<!-- Simple image_tag usage -->
+<%= image_tag "logo.png", alt: "Logo" %>
+<%= image_tag "banner.jpg", alt: "Banner", class: "hero-image" %>
+<%= image_tag "icon.svg", alt: "Icon", size: "24x24" %>
+
+<!-- Dynamic expressions -->
+<%= image_tag user.avatar.url, alt: "User avatar" %>
+
+<!-- Mixed content using string interpolation -->
+<%= image_tag "#{root_url}/banner.jpg", alt: "Banner" %>
+<%= image_tag "#{base_url}#{image_path('icon.png')}", alt: "Icon" %>
+
+<!-- Static image paths are fine -->
+<img src="/static/logo.png" alt="Logo">
+```
+
+### 🚫 Bad
+
+```erb
+<!-- Single ERB expressions -->
+<img src="<%= image_path("logo.png") %>" alt="Logo">
+
+<img src="<%= asset_path("banner.jpg") %>" alt="Banner">
+
+<img src="<%= user.avatar.url %>" alt="User avatar">
+
+<img src="<%= product.image %>" alt="Product image">
+
+
+<!-- Mixed ERB and text content -->
+<img src="<%= Rails.application.routes.url_helpers.root_url %>/icon.png" alt="Logo">
+
+<img src="<%= root_url %>/banner.jpg" alt="Banner">
+
+<img src="<%= admin_path %>/icon.png" alt="Admin icon">
+
+
+<!-- Multiple ERB expressions -->
+<img src="<%= base_url %><%= image_path("logo.png") %>" alt="Logo">
+
+<img src="<%= root_path %><%= "icon.png" %>" alt="Icon">
+```
+
+## References
+
+* [Rails `image_tag` helper documentation](https://api.rubyonrails.org/classes/ActionView/Helpers/AssetTagHelper.html#method-i-image_tag)
+* [Rails `image_path` helper documentation](https://api.rubyonrails.org/classes/ActionView/Helpers/AssetUrlHelper.html#method-i-image_path)
+* [Rails `asset_path` helper documentation](https://api.rubyonrails.org/classes/ActionView/Helpers/AssetUrlHelper.html#method-i-asset_path)

package/docs/rules/erb-requires-trailing-newline.md

@@ -0,0 +1,37 @@
+# Linter Rule: Enforce trailing newline
+
+**Rule:** `erb-requires-trailing-newline`
+
+## Description
+
+This rule enforces that all HTML+ERB template files end with exactly one trailing newline character. This is a formatting convention widely adopted across many languages and tools.
+
+## Rationale
+
+Ensuring HTML+ERB files end with a single trailing newline aligns with POSIX conventions, where text files should end with a newline character.
+
+This practice avoids unnecessary diffs from editors or formatters that auto-insert final newlines, improving compatibility with command-line tools and version control systems. It also helps maintain a clean, predictable structure across view files.
+
+Trailing newlines are a common convention in Ruby and are enforced by tools like RuboCop and many Git-based workflows.
+
+## Examples
+
+### ✅ Good
+
+```
+<%= render partial: "header" %>
+<%= render partial: "footer" %>
+```
+
+### 🚫 Bad
+
+```erb
+<%= render partial: "header" %>
+<%= render partial: "footer" %>▌
+```
+
+## References
+
+- [POSIX: Text files and trailing newlines](https://pubs.opengroup.org/onlinepubs/9699919799/basedefs/V1_chap03.html#tag_03_206)
+- [Git: Trailing newlines and diffs](https://git-scm.com/docs/git-diff#_generating_patches_with_p)
+- [EditorConfig: `insert_final_newline`](https://github.com/editorconfig/editorconfig/wiki/EditorConfig-Properties#insert_final_newline)

package/docs/rules/html-anchor-require-href.md

@@ -4,7 +4,7 @@
 
 ## Description
 
-Disallow the use of anchor tags without anhref attribute in HTML templates. Use if you want to perform an action without having the user navigated to a new URL.
+Disallow the use of anchor tags without an `href` attribute in HTML templates. Use if you want to perform an action without having the user navigated to a new URL.
 
 ## Rationale
 

package/docs/rules/html-aria-level-must-be-valid.md

@@ -0,0 +1,37 @@
+# Linter Rule: `aria-level` must be between 1 and 6
+
+**Rule:** `html-aria-level-must-be-valid`
+
+## Description
+
+Ensure that the value of the `aria-level` attribute is a valid heading level: an integer between `1` and `6`. This attribute is used with `role="heading"` to indicate a heading level for non-semantic elements like `<div>` or `<span>`.
+
+## Rationale
+
+The WAI-ARIA specification defines `aria-level` as an integer between `1` (highest/most important) and `6` (lowest/subheading). Any other value is invalid and may confuse screen readers or fail accessibility audits.
+
+## Examples
+
+### ✅ Good
+
+```erb
+<div role="heading" aria-level="1">Main</div>
+<div role="heading" aria-level="6">Footnote</div>
+```
+
+### 🚫 Bad
+
+```erb
+<div role="heading" aria-level="-1">Negative</div>
+
+<div role="heading" aria-level="0">Main</div>
+
+<div role="heading" aria-level="7">Too deep</div>
+
+<div role="heading" aria-level="foo">Invalid</div>
+```
+
+## References
+
+- [ARIA: `heading` role](https://developer.mozilla.org/en-US/docs/Web/Accessibility/ARIA/Reference/Roles/heading_role)
+- [ARIA: `aria-level` attribute](https://developer.mozilla.org/en-US/docs/Web/Accessibility/ARIA/Reference/Attributes/aria-level)

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@herb-tools/linter",
-  "version": "0.4.2",
+  "version": "0.4.3",
   "description": "HTML+ERB linter for validating HTML structure and enforcing best practices",
   "license": "MIT",
   "homepage": "https://herb-tools.dev",
@@ -33,9 +33,9 @@
     }
   },
   "dependencies": {
-    "@herb-tools/core": "0.4.2",
-    "@herb-tools/highlighter": "0.4.2",
-    "@herb-tools/node-wasm": "0.4.2",
+    "@herb-tools/core": "0.4.3",
+    "@herb-tools/highlighter": "0.4.3",
+    "@herb-tools/node-wasm": "0.4.3",
     "glob": "^11.0.3"
   },
   "files": [

package/src/cli/file-processor.ts

@@ -50,12 +50,11 @@ export class FileProcessor {
       }
 
       if (!this.linter) {
-        this.linter = new Linter()
+        this.linter = new Linter(Herb)
       }
 
-      const lintResult = this.linter.lint(parseResult.value)
+      const lintResult = this.linter.lint(content, { fileName: filename })
 
-      // Get rule count on first file
       if (ruleCount === 0) {
         ruleCount = this.linter.getRuleCount()
       }
@@ -65,7 +64,6 @@ export class FileProcessor {
           console.log(`${colorize("✓", "brightGreen")} ${colorize(filename, "cyan")} - ${colorize("No issues found", "green")}`)
         }
       } else {
-        // Collect messages for later display
         for (const offense of lintResult.offenses) {
           allDiagnostics.push({ filename, diagnostic: offense, content })