@herb-tools/linter 0.7.4 → 0.8.0

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

@@ -1,7 +1,7 @@
 import { ParserRule } from "../types.js"
 import { AttributeVisitorMixin, VALID_ARIA_ROLES, StaticAttributeStaticValueParams } from "./rule-utils.js"
 
-import type { LintOffense, LintContext } from "../types.js"
+import type { UnboundLintOffense, LintContext, FullRuleConfig } from "../types.js"
 import type { ParseResult } from "@herb-tools/core"
 
 class AriaRoleMustBeValid extends AttributeVisitorMixin {
@@ -13,7 +13,6 @@ class AriaRoleMustBeValid extends AttributeVisitorMixin {
     this.addOffense(
       `The \`role\` attribute must be a valid ARIA role. Role \`${attributeValue}\` is not recognized.`,
       attributeNode.location,
-      "error"
     )
   }
 }
@@ -21,7 +20,14 @@ class AriaRoleMustBeValid extends AttributeVisitorMixin {
 export class HTMLAriaRoleMustBeValidRule extends ParserRule {
   name = "html-aria-role-must-be-valid"
 
-  check(result: ParseResult, context?: Partial<LintContext>): LintOffense[] {
+  get defaultConfig(): FullRuleConfig {
+    return {
+      enabled: true,
+      severity: "error"
+    }
+  }
+
+  check(result: ParseResult, context?: Partial<LintContext>): UnboundLintOffense[] {
     const visitor = new AriaRoleMustBeValid(this.name, context)
 
     visitor.visit(result.value)

package/src/rules/html-attribute-double-quotes.ts

@@ -1,11 +1,16 @@
-import { ParserRule } from "../types.js"
+import { ParserRule, BaseAutofixContext, Mutable } from "../types.js"
 import { AttributeVisitorMixin, StaticAttributeStaticValueParams, StaticAttributeDynamicValueParams, getAttributeValueQuoteType, hasAttributeValue } from "./rule-utils.js"
 import { filterLiteralNodes } from "@herb-tools/core"
 
-import type { LintOffense, LintContext } from "../types.js"
-import type { ParseResult } from "@herb-tools/core"
+import type { UnboundLintOffense, LintOffense, LintContext, FullRuleConfig } from "../types.js"
+import type { ParseResult, HTMLAttributeNode } from "@herb-tools/core"
 
-class AttributeDoubleQuotesVisitor extends AttributeVisitorMixin {
+interface AttributeDoubleQuotesAutofixContext extends BaseAutofixContext {
+  node: Mutable<HTMLAttributeNode>
+  valueContent: string
+}
+
+class AttributeDoubleQuotesVisitor extends AttributeVisitorMixin<AttributeDoubleQuotesAutofixContext> {
   protected checkStaticAttributeStaticValue({ attributeName, attributeValue, attributeNode }: StaticAttributeStaticValueParams) {
     if (!hasAttributeValue(attributeNode)) return
     if (getAttributeValueQuoteType(attributeNode) !== "single") return
@@ -14,7 +19,10 @@ class AttributeDoubleQuotesVisitor extends AttributeVisitorMixin {
     this.addOffense(
       `Attribute \`${attributeName}\` uses single quotes. Prefer double quotes for HTML attribute values: \`${attributeName}="${attributeValue}"\`.`,
       attributeNode.value!.location,
-      "warning"
+      {
+        node: attributeNode,
+        valueContent: attributeValue
+      }
     )
   }
 
@@ -26,19 +34,45 @@ class AttributeDoubleQuotesVisitor extends AttributeVisitorMixin {
     this.addOffense(
       `Attribute \`${attributeName}\` uses single quotes. Prefer double quotes for HTML attribute values: \`${attributeName}="${combinedValue}"\`.`,
       attributeNode.value!.location,
-      "warning"
+      {
+        node: attributeNode,
+        valueContent: combinedValue || ""
+      }
     )
   }
 }
 
-export class HTMLAttributeDoubleQuotesRule extends ParserRule {
+export class HTMLAttributeDoubleQuotesRule extends ParserRule<AttributeDoubleQuotesAutofixContext> {
+  static autocorrectable = true
   name = "html-attribute-double-quotes"
 
-  check(result: ParseResult, context?: Partial<LintContext>): LintOffense[] {
+  get defaultConfig(): FullRuleConfig {
+    return {
+      enabled: true,
+      severity: "warning"
+    }
+  }
+
+  check(result: ParseResult, context?: Partial<LintContext>): UnboundLintOffense<AttributeDoubleQuotesAutofixContext>[] {
     const visitor = new AttributeDoubleQuotesVisitor(this.name, context)
 
     visitor.visit(result.value)
 
     return visitor.offenses
   }
+
+  autofix(offense: LintOffense<AttributeDoubleQuotesAutofixContext>, result: ParseResult, _context?: Partial<LintContext>): ParseResult | null {
+    if (!offense.autofixContext) return null
+
+    const { node: { value } } = offense.autofixContext
+
+    if (!value) return null
+    if (!value.open_quote) return  null
+    if (!value.close_quote) return  null
+
+    value.open_quote.value = '"'
+    value.close_quote.value = '"'
+
+    return result
+  }
 }

package/src/rules/html-attribute-equals-spacing.ts

@@ -1,10 +1,14 @@
 import { BaseRuleVisitor } from "./rule-utils.js"
-import { ParserRule } from "../types.js"
+import { ParserRule, BaseAutofixContext, Mutable } from "../types.js"
 
-import type { LintOffense, LintContext } from "../types.js"
+import type { UnboundLintOffense, LintOffense, LintContext, FullRuleConfig } from "../types.js"
 import type { ParseResult, HTMLAttributeNode } from "@herb-tools/core"
 
-class HTMLAttributeEqualsSpacingVisitor extends BaseRuleVisitor {
+interface AttributeEqualsSpacingAutofixContext extends BaseAutofixContext {
+  node: Mutable<HTMLAttributeNode>
+}
+
+class HTMLAttributeEqualsSpacingVisitor extends BaseRuleVisitor<AttributeEqualsSpacingAutofixContext> {
   visitHTMLAttributeNode(attribute: HTMLAttributeNode): void {
     if (!attribute.equals || !attribute.name || !attribute.value) {
       return
@@ -14,7 +18,7 @@ class HTMLAttributeEqualsSpacingVisitor extends BaseRuleVisitor {
       this.addOffense(
         "Remove whitespace before `=` in HTML attribute",
         attribute.equals.location,
-        "error"
+        { node: attribute }
       )
     }
 
@@ -22,20 +26,40 @@ class HTMLAttributeEqualsSpacingVisitor extends BaseRuleVisitor {
       this.addOffense(
         "Remove whitespace after `=` in HTML attribute",
         attribute.equals.location,
-        "error"
+        { node: attribute }
       )
     }
   }
 }
 
-export class HTMLAttributeEqualsSpacingRule extends ParserRule {
+export class HTMLAttributeEqualsSpacingRule extends ParserRule<AttributeEqualsSpacingAutofixContext> {
+  static autocorrectable = true
   name = "html-attribute-equals-spacing"
 
-  check(result: ParseResult, context?: Partial<LintContext>): LintOffense[] {
+  get defaultConfig(): FullRuleConfig {
+    return {
+      enabled: true,
+      severity: "error"
+    }
+  }
+
+  check(result: ParseResult, context?: Partial<LintContext>): UnboundLintOffense<AttributeEqualsSpacingAutofixContext>[] {
     const visitor = new HTMLAttributeEqualsSpacingVisitor(this.name, context)
 
     visitor.visit(result.value)
 
     return visitor.offenses
   }
+
+  autofix(offense: LintOffense<AttributeEqualsSpacingAutofixContext>, result: ParseResult, _context?: Partial<LintContext>): ParseResult | null {
+    if (!offense.autofixContext) return null
+
+    const { node: { equals } } = offense.autofixContext
+
+    if (!equals) return null
+
+    equals.value = "="
+
+    return result
+  }
 }

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

@@ -1,10 +1,16 @@
-import { ParserRule } from "../types.js"
+import { Token, Location } from "@herb-tools/core"
+import { ParserRule, BaseAutofixContext, Mutable } from "../types.js"
 import { AttributeVisitorMixin, StaticAttributeStaticValueParams, StaticAttributeDynamicValueParams } from "./rule-utils.js"
 
-import type { LintOffense, LintContext } from "../types.js"
-import type { HTMLAttributeNode, HTMLAttributeValueNode, ParseResult } from "@herb-tools/core"
+import type { UnboundLintOffense, LintOffense, LintContext, FullRuleConfig } from "../types.js"
+import type { HTMLAttributeNode, ParseResult,  } from "@herb-tools/core"
 
-class AttributeValuesRequireQuotesVisitor extends AttributeVisitorMixin {
+interface AttributeValuesRequireQuotesAutofixContext extends BaseAutofixContext {
+  node: Mutable<HTMLAttributeNode>
+  unquotedValue: string
+}
+
+class AttributeValuesRequireQuotesVisitor extends AttributeVisitorMixin<AttributeValuesRequireQuotesAutofixContext> {
   protected checkStaticAttributeStaticValue({ attributeName, attributeValue, attributeNode }: StaticAttributeStaticValueParams): void {
     if (this.hasAttributeValue(attributeNode)) return
     if (this.isQuoted(attributeNode)) return
@@ -12,7 +18,10 @@ class AttributeValuesRequireQuotesVisitor extends AttributeVisitorMixin {
     this.addOffense(
       `Attribute value should be quoted: \`${attributeName}="${attributeValue}"\`. Always wrap attribute values in quotes.`,
       attributeNode.value!.location,
-      "error"
+      {
+        node: attributeNode,
+        unquotedValue: attributeValue
+      }
     )
   }
 
@@ -23,7 +32,10 @@ class AttributeValuesRequireQuotesVisitor extends AttributeVisitorMixin {
     this.addOffense(
       `Attribute value should be quoted: \`${attributeName}="${combinedValue}"\`. Always wrap attribute values in quotes.`,
       attributeNode.value!.location,
-      "error"
+      {
+        node: attributeNode,
+        unquotedValue: combinedValue || ""
+      }
     )
   }
 
@@ -32,20 +44,54 @@ class AttributeValuesRequireQuotesVisitor extends AttributeVisitorMixin {
   }
 
   private isQuoted(attributeNode: HTMLAttributeNode): boolean {
-    const valueNode = attributeNode.value as HTMLAttributeValueNode
+    const valueNode = attributeNode.value
 
-    return valueNode.quoted
+    return valueNode ? valueNode.quoted : false
   }
 }
 
-export class HTMLAttributeValuesRequireQuotesRule extends ParserRule {
+export class HTMLAttributeValuesRequireQuotesRule extends ParserRule<AttributeValuesRequireQuotesAutofixContext> {
+  static autocorrectable = true
   name = "html-attribute-values-require-quotes"
 
-  check(result: ParseResult, context?: Partial<LintContext>): LintOffense[] {
+  get defaultConfig(): FullRuleConfig {
+    return {
+      enabled: true,
+      severity: "error"
+    }
+  }
+
+  check(result: ParseResult, context?: Partial<LintContext>): UnboundLintOffense<AttributeValuesRequireQuotesAutofixContext>[] {
     const visitor = new AttributeValuesRequireQuotesVisitor(this.name, context)
 
     visitor.visit(result.value)
 
     return visitor.offenses
   }
+
+  autofix(offense: LintOffense<AttributeValuesRequireQuotesAutofixContext>, result: ParseResult, _context?: Partial<LintContext>): ParseResult | null {
+    if (!offense.autofixContext) return null
+
+    const { node: { value } } = offense.autofixContext
+
+    if (!value) return null
+
+    const quote = Token.from({ type: "TOKEN_QUOTE", value: '"', location: Location.zero, range: [0, 0] })
+
+    if (value.open_quote) {
+      value.open_quote.value = '"'
+    } else {
+      value.open_quote = quote
+    }
+
+    if (value.close_quote) {
+      value.close_quote.value = '"'
+    } else {
+      value.close_quote = quote
+    }
+
+    value.quoted = true
+
+    return result
+  }
 }

package/src/rules/html-avoid-both-disabled-and-aria-disabled.ts

@@ -1,7 +1,7 @@
 import { ParserRule } from "../types.js"
 import { BaseRuleVisitor, getTagName, hasAttribute, getAttributes, findAttributeByName } from "./rule-utils.js"
 
-import type { LintOffense, LintContext } from "../types.js"
+import type { UnboundLintOffense, LintContext, FullRuleConfig } from "../types.js"
 import type { HTMLOpenTagNode, HTMLAttributeValueNode, ParseResult, Node } from "@herb-tools/core"
 
 const ELEMENTS_WITH_NATIVE_DISABLED_ATTRIBUTE_SUPPORT = new Set([
@@ -32,7 +32,6 @@ class AvoidBothDisabledAndAriaDisabledVisitor extends BaseRuleVisitor {
       this.addOffense(
         "aria-disabled may be used in place of native HTML disabled to allow tab-focus on an otherwise ignored element. Setting both attributes is contradictory and confusing. Choose either disabled or aria-disabled, not both.",
         node.tag_name!.location,
-        "error"
       )
     }
   }
@@ -56,7 +55,14 @@ class AvoidBothDisabledAndAriaDisabledVisitor extends BaseRuleVisitor {
 export class HTMLAvoidBothDisabledAndAriaDisabledRule extends ParserRule {
   name = "html-avoid-both-disabled-and-aria-disabled"
 
-  check(result: ParseResult, context?: Partial<LintContext>): LintOffense[] {
+  get defaultConfig(): FullRuleConfig {
+    return {
+      enabled: true,
+      severity: "error"
+    }
+  }
+
+  check(result: ParseResult, context?: Partial<LintContext>): UnboundLintOffense[] {
     const visitor = new AvoidBothDisabledAndAriaDisabledVisitor(this.name, context)
 
     visitor.visit(result.value)

package/src/rules/html-body-only-elements.ts

@@ -0,0 +1,60 @@
+import { ParserRule } from "../types.js"
+import { BaseRuleVisitor, getTagName, isBodyOnlyTag } from "./rule-utils.js"
+
+import type { UnboundLintOffense, LintContext, FullRuleConfig } from "../types.js"
+import type { HTMLElementNode, ParseResult } from "@herb-tools/core"
+
+class HTMLBodyOnlyElementsVisitor extends BaseRuleVisitor {
+  private elementStack: string[] = []
+
+  visitHTMLElementNode(node: HTMLElementNode): void {
+    const tagName = getTagName(node.open_tag)?.toLowerCase()
+    if (!tagName) return
+
+    this.checkBodyOnlyElement(node, tagName)
+
+    this.elementStack.push(tagName)
+    this.visitChildNodes(node)
+    this.elementStack.pop()
+  }
+
+  private checkBodyOnlyElement(node: HTMLElementNode, tagName: string): void {
+    if (this.insideBody) return
+    if (!this.insideHead) return
+    if (!isBodyOnlyTag(tagName)) return
+
+    this.addOffense(
+      `Element \`<${tagName}>\` must be placed inside the \`<body>\` tag.`,
+      node.location,
+    )
+  }
+
+  private get insideBody(): boolean {
+    return this.elementStack.includes("body")
+  }
+
+  private get insideHead(): boolean {
+    return this.elementStack.includes("head")
+  }
+}
+
+export class HTMLBodyOnlyElementsRule extends ParserRule {
+  static autocorrectable = false
+  name = "html-body-only-elements"
+
+  get defaultConfig(): FullRuleConfig {
+    return {
+      enabled: true,
+      severity: "error",
+      exclude: ["**/*.xml", "**/*.xml.erb"]
+    }
+  }
+
+  check(result: ParseResult, context?: Partial<LintContext>): UnboundLintOffense[] {
+    const visitor = new HTMLBodyOnlyElementsVisitor(this.name, context)
+
+    visitor.visit(result.value)
+
+    return visitor.offenses
+  }
+}

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

@@ -1,11 +1,15 @@
-import { ParserRule } from "../types.js"
+import { ParserRule, BaseAutofixContext, Mutable } from "../types.js"
 import { AttributeVisitorMixin, StaticAttributeStaticValueParams, StaticAttributeDynamicValueParams, isBooleanAttribute, hasAttributeValue } from "./rule-utils.js"
 import { IdentityPrinter } from "@herb-tools/printer"
 
-import type { LintOffense, LintContext } from "../types.js"
+import type { UnboundLintOffense, LintOffense, LintContext, FullRuleConfig } from "../types.js"
 import type { ParseResult, HTMLAttributeNode } from "@herb-tools/core"
 
-class BooleanAttributesNoValueVisitor extends AttributeVisitorMixin {
+interface BooleanAttributeAutofixContext extends BaseAutofixContext {
+  node: Mutable<HTMLAttributeNode>
+}
+
+class BooleanAttributesNoValueVisitor extends AttributeVisitorMixin<BooleanAttributeAutofixContext> {
   protected checkStaticAttributeStaticValue({ originalAttributeName, attributeNode }: StaticAttributeStaticValueParams) {
     this.checkAttribute(originalAttributeName, attributeNode)
   }
@@ -21,19 +25,40 @@ class BooleanAttributesNoValueVisitor extends AttributeVisitorMixin {
     this.addOffense(
       `Boolean attribute \`${IdentityPrinter.print(attributeNode.name)}\` should not have a value. Use \`${attributeName.toLowerCase()}\` instead of \`${IdentityPrinter.print(attributeNode)}\`.`,
       attributeNode.value!.location,
-      "error"
+      {
+        node: attributeNode
+      }
     )
   }
 }
 
-export class HTMLBooleanAttributesNoValueRule extends ParserRule {
+export class HTMLBooleanAttributesNoValueRule extends ParserRule<BooleanAttributeAutofixContext> {
+  static autocorrectable = true
   name = "html-boolean-attributes-no-value"
 
-  check(result: ParseResult, context?: Partial<LintContext>): LintOffense[] {
+  get defaultConfig(): FullRuleConfig {
+    return {
+      enabled: true,
+      severity: "error"
+    }
+  }
+
+  check(result: ParseResult, context?: Partial<LintContext>): UnboundLintOffense<BooleanAttributeAutofixContext>[] {
     const visitor = new BooleanAttributesNoValueVisitor(this.name, context)
 
     visitor.visit(result.value)
 
     return visitor.offenses
   }
+
+  autofix(offense: LintOffense<BooleanAttributeAutofixContext>, result: ParseResult, _context?: Partial<LintContext>): ParseResult | null {
+    if (!offense.autofixContext) return null
+
+    const { node } = offense.autofixContext
+
+    node.equals = null
+    node.value = null
+
+    return result
+  }
 }

package/src/rules/html-head-only-elements.ts

@@ -0,0 +1,65 @@
+import { ParserRule } from "../types"
+import { BaseRuleVisitor, getTagName, isHeadOnlyTag } from "./rule-utils"
+
+import type { ParseResult, HTMLElementNode } from "@herb-tools/core"
+import type { UnboundLintOffense, LintContext, FullRuleConfig } from "../types"
+
+class HeadOnlyElementsVisitor extends BaseRuleVisitor {
+  private elementStack: string[] = []
+
+  visitHTMLElementNode(node: HTMLElementNode): void {
+    const tagName = getTagName(node)?.toLowerCase()
+    if (!tagName) return
+
+    this.checkHeadOnlyElement(node, tagName)
+
+    this.elementStack.push(tagName)
+    this.visitChildNodes(node)
+    this.elementStack.pop()
+  }
+
+  private checkHeadOnlyElement(node: HTMLElementNode, tagName: string): void {
+    if (this.insideHead) return
+    if (!this.insideBody) return
+    if (!isHeadOnlyTag(tagName)) return
+    if (tagName === "title" && this.insideSVG) return
+
+    this.addOffense(
+      `Element \`<${tagName}>\` must be placed inside the \`<head>\` tag.`,
+      node.location,
+    )
+  }
+
+  private get insideHead(): boolean {
+    return this.elementStack.includes("head")
+  }
+
+  private get insideBody(): boolean {
+    return this.elementStack.includes("body")
+  }
+
+  private get insideSVG(): boolean {
+    return this.elementStack.includes("svg")
+  }
+}
+
+export class HTMLHeadOnlyElementsRule extends ParserRule {
+  static autocorrectable = false
+  name = "html-head-only-elements"
+
+  get defaultConfig(): FullRuleConfig {
+    return {
+      enabled: true,
+      severity: "error",
+      exclude: ["**/*.xml", "**/*.xml.erb"]
+    }
+  }
+
+  check(result: ParseResult, context?: Partial<LintContext>): UnboundLintOffense[] {
+    const visitor = new HeadOnlyElementsVisitor(this.name, context)
+
+    visitor.visit(result.value)
+
+    return visitor.offenses
+  }
+}

package/src/rules/html-iframe-has-title.ts

@@ -1,7 +1,7 @@
 import { ParserRule } from "../types.js"
 import { BaseRuleVisitor, getTagName, getAttribute, getAttributeValue } from "./rule-utils.js"
 
-import type { LintOffense, LintContext } from "../types.js"
+import type { UnboundLintOffense, LintContext, FullRuleConfig } from "../types.js"
 import type { HTMLOpenTagNode, ParseResult } from "@herb-tools/core"
 
 class IframeHasTitleVisitor extends BaseRuleVisitor {
@@ -31,7 +31,6 @@ class IframeHasTitleVisitor extends BaseRuleVisitor {
       this.addOffense(
         "`<iframe>` elements must have a `title` attribute that describes the content of the frame for screen reader users.",
         node.location,
-        "error"
       )
 
       return
@@ -43,7 +42,6 @@ class IframeHasTitleVisitor extends BaseRuleVisitor {
       this.addOffense(
         "`<iframe>` elements must have a `title` attribute that describes the content of the frame for screen reader users.",
         node.location,
-        "error"
       )
     }
   }
@@ -52,7 +50,14 @@ class IframeHasTitleVisitor extends BaseRuleVisitor {
 export class HTMLIframeHasTitleRule extends ParserRule {
   name = "html-iframe-has-title"
 
-  check(result: ParseResult, context?: Partial<LintContext>): LintOffense[] {
+  get defaultConfig(): FullRuleConfig {
+    return {
+      enabled: true,
+      severity: "error"
+    }
+  }
+
+  check(result: ParseResult, context?: Partial<LintContext>): UnboundLintOffense[] {
     const visitor = new IframeHasTitleVisitor(this.name, context)
 
     visitor.visit(result.value)

package/src/rules/html-img-require-alt.ts

@@ -1,7 +1,7 @@
 import { BaseRuleVisitor, getTagName, hasAttribute } from "./rule-utils.js"
 
 import { ParserRule } from "../types.js"
-import type { LintOffense, LintContext } from "../types.js"
+import type { UnboundLintOffense, LintContext, FullRuleConfig } from "../types.js"
 import type { HTMLOpenTagNode, ParseResult } from "@herb-tools/core"
 
 class ImgRequireAltVisitor extends BaseRuleVisitor {
@@ -20,8 +20,7 @@ class ImgRequireAltVisitor extends BaseRuleVisitor {
     if (!hasAttribute(node, "alt")) {
       this.addOffense(
         'Missing required `alt` attribute on `<img>` tag. Add `alt=""` for decorative images or `alt="description"` for informative images.',
-        node.tag_name!.location,
-        "error"
+        node.tag_name!.location
       )
     }
   }
@@ -30,7 +29,14 @@ class ImgRequireAltVisitor extends BaseRuleVisitor {
 export class HTMLImgRequireAltRule extends ParserRule {
   name = "html-img-require-alt"
 
-  check(result: ParseResult, context?: Partial<LintContext>): LintOffense[] {
+  get defaultConfig(): FullRuleConfig {
+    return {
+      enabled: true,
+      severity: "error"
+    }
+  }
+
+  check(result: ParseResult, context?: Partial<LintContext>): UnboundLintOffense[] {
     const visitor = new ImgRequireAltVisitor(this.name, context)
     visitor.visit(result.value)
     return visitor.offenses

package/src/rules/html-input-require-autocomplete.ts

@@ -0,0 +1,85 @@
+import { getTagName } from "@herb-tools/core"
+import { BaseRuleVisitor, getAttribute, getAttributeValue, getStaticAttributeValueContent } from "./rule-utils.js"
+import { ParserRule } from "../types.js"
+
+import type { UnboundLintOffense, LintContext, FullRuleConfig } from "../types.js"
+import type { ParseResult, HTMLOpenTagNode } from "@herb-tools/core"
+
+class HTMLInputRequireAutocompleteVisitor extends BaseRuleVisitor {
+  readonly HTML_INPUT_TYPES_REQUIRING_AUTOCOMPLETE = new Set([
+    "color",
+    "date",
+    "datetime-local",
+    "email",
+    "month",
+    "number",
+    "password",
+    "range",
+    "search",
+    "tel",
+    "text",
+    "time",
+    "url",
+    "week",
+  ])
+
+  visitHTMLOpenTagNode(node: HTMLOpenTagNode): void {
+    this.checkInputTag(node)
+  }
+
+  private checkInputTag(node: HTMLOpenTagNode): void {
+    if (!this.isInputTag(node) || this.hasAutocomplete(node)) return
+
+    const typeAttribute = getAttribute(node, "type");
+    if (!typeAttribute) return
+
+    const typeValue = getStaticAttributeValueContent(typeAttribute)
+    if (!typeValue) return
+
+    if (!this.HTML_INPUT_TYPES_REQUIRING_AUTOCOMPLETE.has(typeValue)) return
+
+    this.addOffense(
+      "Add an `autocomplete` attribute to improve form accessibility. Use a specific value (e.g., `autocomplete=\"email\"`), `autocomplete=\"on\"` for defaults, or `autocomplete=\"off\"` to disable.",
+      node.location
+    )
+  }
+
+  private hasAutocomplete(node: HTMLOpenTagNode) {
+    const autocompleteAttribute = getAttribute(node, "autocomplete");
+    if (!autocompleteAttribute) return false
+
+    const autocompleteValue = getAttributeValue(autocompleteAttribute)
+    if (!autocompleteValue) return false
+
+    return true
+  }
+
+  private isInputTag(node: HTMLOpenTagNode) {
+    const tagName = getTagName(node);
+
+    if (tagName === "input") {
+      return true
+    } else {
+      return false
+    }
+  }
+}
+
+export class HTMLInputRequireAutocompleteRule extends ParserRule {
+  name = "html-input-require-autocomplete"
+
+  get defaultConfig(): FullRuleConfig {
+    return {
+      enabled: true,
+      severity: "error"
+    }
+  }
+
+  check(result: ParseResult, context?: Partial<LintContext>): UnboundLintOffense[] {
+    const visitor = new HTMLInputRequireAutocompleteVisitor(this.name, context)
+
+    visitor.visit(result.value)
+
+    return visitor.offenses
+  }
+}