@herb-tools/linter 0.4.2 → 0.5.0

package/dist/types/rules/erb-no-output-control-flow.d.ts

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

package/dist/types/rules/erb-prefer-image-tag-helper.d.ts

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

package/dist/types/rules/erb-require-whitespace-inside-tags.d.ts

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

package/dist/types/rules/erb-requires-trailing-newline.d.ts

@@ -0,0 +1,6 @@
+import { SourceRule } from "../types.js";
+import type { LintOffense, LintContext } from "../types.js";
+export declare class ERBRequiresTrailingNewlineRule extends SourceRule {
+    name: string;
+    check(source: string, context?: Partial<LintContext>): LintOffense[];
+}

package/dist/types/rules/html-anchor-require-href.d.ts

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

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

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

package/dist/types/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 { ParseResult } from "@herb-tools/core";
+export declare class HTMLAriaLevelMustBeValidRule extends ParserRule {
+    name: string;
+    check(result: ParseResult, context?: Partial<LintContext>): LintOffense[];
+}

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

package/dist/types/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/rules/parser-no-errors.d.ts

@@ -0,0 +1,8 @@
+import { ParserRule } from "../types.js";
+import type { LintOffense } from "../types.js";
+import type { ParseResult } from "@herb-tools/core";
+export declare class ParserNoErrorsRule extends ParserRule {
+    name: string;
+    check(result: ParseResult): LintOffense[];
+    private herbErrorToLintOffense;
+}

package/dist/types/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/rules/svg-tag-name-capitalization.d.ts

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

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

@@ -1,7 +1,8 @@
 import type { ThemeInput } from "@herb-tools/highlighter";
+export type FormatOption = "simple" | "detailed" | "json" | "github";
 export interface ParsedArguments {
     pattern: string;
-    formatOption: 'simple' | 'detailed';
+    formatOption: FormatOption;
     showTiming: boolean;
     theme: ThemeInput;
     wrapLines: boolean;

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

@@ -1,21 +1,22 @@
 import type { Diagnostic } from "@herb-tools/core";
+import type { FormatOption } from "./argument-parser.js";
 export interface ProcessedFile {
     filename: string;
-    diagnostic: Diagnostic;
+    offense: Diagnostic;
     content: string;
 }
 export interface ProcessingResult {
     totalErrors: number;
     totalWarnings: number;
-    filesWithIssues: number;
+    filesWithOffenses: number;
     ruleCount: number;
-    allDiagnostics: ProcessedFile[];
-    ruleViolations: Map<string, {
+    allOffenses: ProcessedFile[];
+    ruleOffenses: Map<string, {
         count: number;
         files: Set<string>;
     }>;
 }
 export declare class FileProcessor {
     private linter;
-    processFiles(files: string[]): Promise<ProcessingResult>;
+    processFiles(files: string[], formatOption?: FormatOption): Promise<ProcessingResult>;
 }

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

@@ -1,6 +1,6 @@
 import type { Diagnostic } from "@herb-tools/core";
 import type { ProcessedFile } from "../file-processor.js";
 export declare abstract class BaseFormatter {
-    abstract format(allDiagnostics: ProcessedFile[], isSingleFile?: boolean): Promise<void>;
-    abstract formatFile(filename: string, diagnostics: Diagnostic[]): void;
+    abstract format(allOffenses: ProcessedFile[], isSingleFile?: boolean): Promise<void>;
+    abstract formatFile(filename: string, offenses: Diagnostic[]): void;
 }

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

@@ -8,6 +8,6 @@ export declare class DetailedFormatter extends BaseFormatter {
     private wrapLines;
     private truncateLines;
     constructor(theme?: ThemeInput, wrapLines?: boolean, truncateLines?: boolean);
-    format(allDiagnostics: ProcessedFile[], isSingleFile?: boolean): Promise<void>;
-    formatFile(_filename: string, _diagnostics: Diagnostic[]): void;
+    format(allOffenses: ProcessedFile[], isSingleFile?: boolean): Promise<void>;
+    formatFile(_filename: string, _offenses: Diagnostic[]): void;
 }

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

@@ -0,0 +1,12 @@
+import { BaseFormatter } from "./base-formatter.js";
+import type { Diagnostic } from "@herb-tools/core";
+import type { ProcessedFile } from "../file-processor.js";
+export declare class GitHubActionsFormatter extends BaseFormatter {
+    private static readonly MESSAGE_ESCAPE_MAP;
+    private static readonly PARAM_ESCAPE_MAP;
+    format(allDiagnostics: ProcessedFile[]): Promise<void>;
+    formatFile(filename: string, diagnostics: Diagnostic[]): void;
+    private formatDiagnostic;
+    private escapeMessage;
+    private escapeParam;
+}

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

@@ -1,3 +1,5 @@
 export { BaseFormatter } from "./base-formatter.js";
 export { SimpleFormatter } from "./simple-formatter.js";
 export { DetailedFormatter } from "./detailed-formatter.js";
+export { JSONFormatter, type JSONOutput } from "./json-formatter.js";
+export { GitHubActionsFormatter } from "./github-actions-formatter.js";

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

@@ -0,0 +1,42 @@
+import { BaseFormatter } from "./base-formatter.js";
+import type { Diagnostic, SerializedDiagnostic } from "@herb-tools/core";
+import type { ProcessedFile } from "../file-processor.js";
+interface JSONOffense extends SerializedDiagnostic {
+    filename: string;
+}
+interface JSONSummary {
+    filesChecked: number;
+    filesWithOffenses: number;
+    totalErrors: number;
+    totalWarnings: number;
+    totalOffenses: number;
+    ruleCount: number;
+}
+interface JSONTiming {
+    startTime: string;
+    duration: number;
+}
+export interface JSONOutput {
+    offenses: JSONOffense[];
+    summary: JSONSummary | null;
+    timing: JSONTiming | null;
+    completed: boolean;
+    clean: boolean | null;
+    message: string | null;
+}
+interface JSONFormatOptions {
+    files: string[];
+    totalErrors: number;
+    totalWarnings: number;
+    filesWithOffenses: number;
+    ruleCount: number;
+    startTime: number;
+    startDate: Date;
+    showTiming: boolean;
+}
+export declare class JSONFormatter extends BaseFormatter {
+    format(allOffenses: ProcessedFile[]): Promise<void>;
+    formatWithSummary(allOffenses: ProcessedFile[], options: JSONFormatOptions): Promise<void>;
+    formatFile(_filename: string, _offenses: Diagnostic[]): void;
+}
+export {};

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

@@ -2,6 +2,6 @@ import { BaseFormatter } from "./base-formatter.js";
 import type { Diagnostic } from "@herb-tools/core";
 import type { ProcessedFile } from "../file-processor.js";
 export declare class SimpleFormatter extends BaseFormatter {
-    format(allDiagnostics: ProcessedFile[]): Promise<void>;
-    formatFile(filename: string, diagnostics: Diagnostic[]): void;
+    format(allOffenses: ProcessedFile[]): Promise<void>;
+    formatFile(filename: string, offenses: Diagnostic[]): void;
 }

package/dist/types/src/cli/output-manager.d.ts

@@ -0,0 +1,31 @@
+import type { ThemeInput } from "@herb-tools/highlighter";
+import type { FormatOption } from "./argument-parser.js";
+import type { ProcessingResult } from "./file-processor.js";
+interface OutputOptions {
+    formatOption: FormatOption;
+    theme: ThemeInput;
+    wrapLines: boolean;
+    truncateLines: boolean;
+    showTiming: boolean;
+    startTime: number;
+    startDate: Date;
+}
+interface LintResults extends ProcessingResult {
+    files: string[];
+}
+export declare class OutputManager {
+    private summaryReporter;
+    /**
+     * Output successful lint results
+     */
+    outputResults(results: LintResults, options: OutputOptions): Promise<void>;
+    /**
+     * Output informational message (like "no files found")
+     */
+    outputInfo(message: string, options: OutputOptions): void;
+    /**
+     * Output error message
+     */
+    outputError(message: string, options: OutputOptions): void;
+}
+export {};

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

@@ -2,12 +2,12 @@ export interface SummaryData {
     files: string[];
     totalErrors: number;
     totalWarnings: number;
-    filesWithViolations: number;
+    filesWithOffenses: number;
     ruleCount: number;
     startTime: number;
     startDate: Date;
     showTiming: boolean;
-    ruleViolations: Map<string, {
+    ruleOffenses: Map<string, {
         count: number;
         files: Set<string>;
     }>;
@@ -15,7 +15,7 @@ export interface SummaryData {
 export declare class SummaryReporter {
     private pluralize;
     displaySummary(data: SummaryData): void;
-    displayMostViolatedRules(ruleViolations: Map<string, {
+    displayMostViolatedRules(ruleOffenses: Map<string, {
         count: number;
         files: Set<string>;
     }>, limit?: number): void;

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

@@ -1,6 +1,8 @@
 export declare class CLI {
     private argumentParser;
     private fileProcessor;
-    private summaryReporter;
+    private outputManager;
+    private exitWithError;
+    private exitWithInfo;
     run(): Promise<void>;
 }

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

@@ -1,18 +1,33 @@
-import type { RuleClass, LintResult } from "./types.js";
-import type { DocumentNode } from "@herb-tools/core";
+import type { RuleClass, LintResult, LintContext } from "./types.js";
+import type { HerbBackend } from "@herb-tools/core";
 export declare class Linter {
     private rules;
+    private herb;
     private offenses;
     /**
      * Creates a new Linter instance.
-     * @param rules - Array of rule classes (not instances) to use. If not provided, uses default 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.
      */
-    constructor(rules?: RuleClass[]);
+    constructor(herb: HerbBackend, rules?: RuleClass[]);
     /**
      * Returns the default set of rule classes used by the linter.
      * @returns Array of rule classes
      */
     private getDefaultRules;
     getRuleCount(): number;
-    lint(document: DocumentNode): LintResult;
+    /**
+     * Type guard to check if a rule is a LexerRule
+     */
+    private isLexerRule;
+    /**
+     * Type guard to check if a rule is a SourceRule
+     */
+    private isSourceRule;
+    /**
+     * 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;
 }

package/dist/types/src/rules/erb-no-empty-tags.d.ts

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