Language Server: Herb Linter Fix-on-save (marcoroth#758)

This pull request introduces the functionality for the Herb Language
Server to be able to autofix Herb Linter offenses on save.

This builds on the new `--fix` option in the Herb Linter (introduced in
marcoroth#622), which can automatically correct offenses without formatting the
rest of the document.

If both `Fix-on-Save` and `Format-on-Save` are active, the Language
Server will first fix the offenses and then format the document.


https://github.com/user-attachments/assets/070bd0a4-4551-4527-9b0c-01a3e3d44df3

The Visual Studio Code Extension also exposes a new "Fix on save"
toggle:

<img width="2016" height="679" alt="CleanShot 2025-11-01 at 02 15 50@2x"
src="https://github.com/user-attachments/assets/2fbfa731-d3ad-4b97-a953-c565c136dc7b"
/>

Author: marcoroth

javascript/packages/language-server/src/autofix_service.ts

@@ -0,0 +1,46 @@
+import { Connection, TextEdit } from "vscode-languageserver/node"
+import { TextDocument } from "vscode-languageserver-textdocument"
+
+import { Herb } from "@herb-tools/node-wasm"
+import { Linter } from "@herb-tools/linter"
+import { Config } from "@herb-tools/config"
+
+import { getFullDocumentRange } from "./utils"
+
+export class AutofixService {
+  private connection: Connection
+  private linter: Linter
+
+  constructor(connection: Connection, config?: Config) {
+    this.connection = connection
+    this.linter = this.buildLinter(config)
+  }
+
+  setConfig(config: Config) {
+    this.linter = this.buildLinter(config)
+  }
+
+  private buildLinter(config?: Config) {
+    return Linter.from(Herb, config)
+  }
+
+  async autofix(document: TextDocument): Promise<TextEdit[]> {
+    try {
+      const text = document.getText()
+      const lintResult = this.linter.lint(text, { fileName: document.uri })
+      const offensesToFix = lintResult.offenses
+
+      if (offensesToFix.length === 0) return []
+
+      const autofixResult = this.linter.autofix(text, { fileName: document.uri }, offensesToFix)
+
+      if (autofixResult.source === text) return []
+
+      return [{ range: getFullDocumentRange(document), newText: autofixResult.source }]
+    } catch (error) {
+      this.connection.console.error(`[Autofix] Failed: ${error}`)
+
+      return []
+    }
+  }
+}

javascript/packages/language-server/src/code_action_service.ts

@@ -1,14 +1,24 @@
-import { CodeAction, CodeActionKind, Diagnostic, Range, TextEdit, WorkspaceEdit, CreateFile, TextDocumentEdit, OptionalVersionedTextDocumentIdentifier } from "vscode-languageserver/node"
+import { CodeAction, CodeActionKind, CodeActionParams, Diagnostic, Range, Position, TextEdit, WorkspaceEdit, CreateFile, TextDocumentEdit, OptionalVersionedTextDocumentIdentifier } from "vscode-languageserver/node"
+import { TextDocument } from "vscode-languageserver-textdocument"
+
 import { Config } from "@herb-tools/config"
 import { Project } from "./project"
+import { Herb } from "@herb-tools/node-wasm"
+import { Linter } from "@herb-tools/linter"
+
+import { getFullDocumentRange } from "./utils"
+
+import type { LintOffense } from "@herb-tools/linter"
 
 export class CodeActionService {
   private project: Project
   private config?: Config
+  private linter: Linter
 
   constructor(project: Project, config?: Config) {
     this.project = project
     this.config = config
+    this.linter = Linter.from(Herb, config)
   }
 
   setConfig(config: Config) {
@@ -65,14 +75,74 @@ export class CodeActionService {
     return actions.concat(disableAllActions)
   }
 
+  autofixCodeActions(params: CodeActionParams, document: TextDocument): CodeAction[] {
+    if (this.config && !this.config.isLinterEnabled) {
+      return []
+    }
+
+    const codeActions: CodeAction[] = []
+    const text = document.getText()
+
+    const lintResult = this.linter.lint(text, { fileName: document.uri })
+    const offenses = lintResult.offenses
+
+    const relevantDiagnostics = params.context.diagnostics.filter(diagnostic => {
+      return diagnostic.source === "Herb Linter " && this.isInRange(diagnostic.range, params.range)
+    })
+
+    for (const diagnostic of relevantDiagnostics) {
+      const offense = offenses.find(offense => this.rangesEqual(this.offenseToRange(offense), diagnostic.range) && offense.rule === diagnostic.code)
+
+      if (!offense) {
+        continue
+      }
+
+      const fixResult = this.linter.autofix(text, { fileName: document.uri }, [offense])
+
+      if (fixResult.fixed.length > 0 && fixResult.source !== text) {
+        const codeAction: CodeAction = {
+          title: `Herb Linter: Fix "${offense.message}"`,
+          kind: CodeActionKind.QuickFix,
+          diagnostics: [diagnostic],
+          edit: this.createDocumentEdit(document, fixResult.source)
+        }
+
+        codeActions.push(codeAction)
+      }
+    }
+
+    const allFixableOffenses = offenses.filter(offense => {
+      const fixResult = this.linter.autofix(text, { fileName: document.uri }, [offense])
+
+      return fixResult.fixed.length > 0
+    })
+
+    if (allFixableOffenses.length > 0) {
+      const fixAllResult = this.linter.autofix(text, { fileName: document.uri }, allFixableOffenses)
+
+      if (fixAllResult.fixed.length > 0 && fixAllResult.source !== text) {
+        const fixAllAction: CodeAction = {
+          title: `Herb Linter: Fix all ${fixAllResult.fixed.length} autocorrectable offense${fixAllResult.fixed.length === 1 ? '' : 's'}`,
+          kind: CodeActionKind.SourceFixAll,
+          edit: this.createDocumentEdit(document, fixAllResult.source)
+        }
+
+        codeActions.push(fixAllAction)
+      }
+    }
+
+    return codeActions
+  }
+
+
   private createDisableLineAction(uri: string, diagnostic: Diagnostic, ruleName: string, documentText: string): CodeAction | null {
     const line = diagnostic.range.start.line
     const edit = this.createDisableCommentEdit(uri, line, ruleName, documentText)
 
     if (!edit) return null
 
     const action: CodeAction = {
-      title: `Herb: Disable \`${ruleName}\` for this line`,
+      title: `Herb Linter: Disable \`${ruleName}\` for this line`,
       kind: CodeActionKind.QuickFix,
       diagnostics: [diagnostic],
       edit,
@@ -88,7 +158,7 @@ export class CodeActionService {
     if (!edit) return null
 
     const action: CodeAction = {
-      title: "Herb: Disable all linter rules for this line",
+      title: "Herb Linter: Disable all linter rules for this line",
       kind: CodeActionKind.QuickFix,
       diagnostics: [diagnostic],
       edit,
@@ -161,7 +231,7 @@ export class CodeActionService {
     const configUri = `file://${configPath}`
 
     const action: CodeAction = {
-      title: `Herb: Disable \`${ruleName}\` in \`.herb.yml\``,
+      title: `Herb Linter: Disable \`${ruleName}\` in \`.herb.yml\``,
       kind: CodeActionKind.QuickFix,
       diagnostics: [diagnostic],
       edit,
@@ -265,4 +335,38 @@ export class CodeActionService {
       return null
     }
   }
+
+  private createDocumentEdit(document: TextDocument, newText: string): WorkspaceEdit {
+    return {
+      changes: {
+        [document.uri]: [{
+          range: getFullDocumentRange(document),
+          newText
+        }]
+      }
+    }
+  }
+
+  private offenseToRange(offense: LintOffense): Range {
+    return {
+      start: Position.create(offense.location.start.line - 1, offense.location.start.column),
+      end: Position.create(offense.location.end.line - 1, offense.location.end.column)
+    }
+  }
+
+  private rangesEqual(r1: Range, r2: Range): boolean {
+    return (
+      r1.start.line === r2.start.line &&
+      r1.start.character === r2.start.character &&
+      r1.end.line === r2.end.line &&
+      r1.end.character === r2.end.character
+    )
+  }
+
+  private isInRange(diagnosticRange: Range, requestedRange: Range): boolean {
+    if (diagnosticRange.start.line > requestedRange.end.line) return false
+    if (diagnosticRange.end.line < requestedRange.start.line) return false
+
+    return true
+  }
 }

javascript/packages/language-server/src/document_save_service.ts

@@ -0,0 +1,48 @@
+import { Connection, TextEdit, TextDocumentSaveReason } from "vscode-languageserver/node"
+import { TextDocument } from "vscode-languageserver-textdocument"
+
+import { Settings } from "./settings"
+import { AutofixService } from "./autofix_service"
+import { FormattingService } from "./formatting_service"
+
+export class DocumentSaveService {
+  private connection: Connection
+  private settings: Settings
+  private autofixService: AutofixService
+  private formattingService: FormattingService
+
+  constructor(connection: Connection, settings: Settings, autofixService: AutofixService, formattingService: FormattingService) {
+    this.connection = connection
+    this.settings = settings
+    this.autofixService = autofixService
+    this.formattingService = formattingService
+  }
+
+  async applyFixesAndFormatting(document: TextDocument, reason: TextDocumentSaveReason): Promise<TextEdit[]> {
+    const settings = await this.settings.getDocumentSettings(document.uri)
+    const fixOnSave = settings?.linter?.fixOnSave !== false
+    const formatterEnabled = settings?.formatter?.enabled ?? false
+
+    this.connection.console.log(`[DocumentSave] fixOnSave=${fixOnSave}, formatterEnabled=${formatterEnabled}`)
+
+    let autofixEdits: TextEdit[] = []
+
+    if (fixOnSave) {
+      autofixEdits = await this.autofixService.autofix(document)
+    }
+
+    if (!formatterEnabled) return autofixEdits
+
+    if (autofixEdits.length === 0) {
+      return this.formattingService.formatOnSave(document, reason)
+    }
+
+    const autofixedDocument: TextDocument = {
+      ...document,
+      uri: document.uri,
+      getText: () => autofixEdits[0].newText,
+    }
+
+    return this.formattingService.formatOnSave(autofixedDocument, reason)
+  }
+}

javascript/packages/language-server/src/document_service.ts

@@ -7,9 +7,6 @@ export class DocumentService {
 
   constructor(connection: Connection) {
     this.documents = new TextDocuments(TextDocument)
-
-    // Make the text document manager listen on the connection
-    // for open, change and close text document events
     this.documents.listen(connection)
   }
 

javascript/packages/language-server/src/formatting_service.ts

@@ -1,4 +1,4 @@
-import { Connection, TextDocuments, DocumentFormattingParams, DocumentRangeFormattingParams, TextEdit, Range, Position } from "vscode-languageserver/node"
+import { Connection, TextDocuments, DocumentFormattingParams, DocumentRangeFormattingParams, TextEdit, Range, Position, TextDocumentSaveReason } from "vscode-languageserver/node"
 import { TextDocument } from "vscode-languageserver-textdocument"
 import { Formatter, defaultFormatOptions } from "@herb-tools/formatter"
 import { Project } from "./project"
@@ -41,6 +41,25 @@ export class FormattingService {
     }
   }
 
+  async formatOnSave(document: TextDocument, reason: TextDocumentSaveReason): Promise<TextEdit[]> {
+    this.connection.console.log(`[Formatting] formatOnSave called for ${document.uri}`)
+
+    if (reason !== TextDocumentSaveReason.Manual) {
+      this.connection.console.log(`[Formatting] Skipping: reason=${reason} (not manual)`)
+      return []
+    }
+
+    const filePath = document.uri.replace(/^file:\/\//, '')
+
+    if (!this.shouldFormatFile(filePath)) {
+      this.connection.console.log(`[Formatting] Skipping: file not in formatter config`)
+
+      return []
+    }
+
+    return this.performFormatting({ textDocument: { uri: document.uri }, options: { tabSize: 2, insertSpaces: true } })
+  }
+
   private shouldFormatFile(filePath: string): boolean {
     if (filePath.endsWith('.herb.yml')) return false
     if (!this.config) return true
@@ -68,10 +87,10 @@ export class FormattingService {
     }
 
     try {
+      const text = document.getText()
       const options = await this.getFormatterOptions(params.textDocument.uri)
       const formatter = new Formatter(this.project.herbBackend, options)
 
-      const text = document.getText()
       let newText = formatter.format(text)
 
       if (!newText.endsWith('\n')) {