@herb-tools/language-server 0.3.1 → 0.4.1

package/package.json

@@ -1,41 +1,42 @@
 {
   "name": "@herb-tools/language-server",
   "description": "Herb HTML+ERB Language Tools and Language Server Protocol integration.",
-  "version": "0.3.1",
+  "version": "0.4.1",
   "author": "Marco Roth",
   "license": "MIT",
   "engines": {
     "node": "*"
   },
+  "homepage": "https://herb-tools.dev",
   "bugs": "https://github.com/marcoroth/herb/issues/new?title=Package%20%60@herb-tools/language-server%60:%20",
   "repository": {
     "type": "git",
     "url": "https://github.com/marcoroth/herb.git",
     "directory": "javascript/packages/language-server"
   },
-  "main": "./dist/herb-language-server.cjs",
-  "module": "./dist/server.js",
-  "types": "./dist/types/server.d.ts",
+  "bin": {
+    "herb-language-server": "./bin/herb-language-server"
+  },
+  "main": "./dist/index.cjs",
+  "module": "./dist/index.js",
+  "require": "./dist/index.cjs",
+  "types": "./dist/types/index.d.ts",
   "exports": {
     "./package.json": "./package.json",
     ".": {
-      "types": "./dist/types/server.d.ts",
-      "import": "./dist/server.js",
-      "require": "./dist/herb-language-server.cjs",
-      "default": "./dist/server.js"
+      "types": "./dist/types/index.d.ts",
+      "import": "./dist/index.js",
+      "require": "./dist/index.cjs",
+      "default": "./dist/index.js"
     }
   },
-  "homepage": "https://herb-tools.dev",
-  "bin": {
-    "herb-language-server": "./bin/herb-language-server"
-  },
   "scripts": {
     "clean": "rimraf dist",
-    "prebuild": "yarn run clean",
-    "build": "tsc -b && rollup -c rollup.config.mjs",
-    "watch": "tsc -b -w",
-    "test": "echo 'TODO: add tests'",
-    "prepublishOnly": "yarn clean && yarn build && yarn test"
+    "build": "yarn clean && tsc -b && rollup -c",
+    "dev": "tsc -b -w",
+    "test": "vitest",
+    "test:run": "vitest run",
+    "prepublishOnly": "yarn clean && yarn build && yarn test:run"
   },
   "files": [
     "package.json",
@@ -45,17 +46,14 @@
     "dist/"
   ],
   "dependencies": {
-    "@herb-tools/node-wasm": "0.3.1",
+    "@herb-tools/formatter": "0.4.1",
+    "@herb-tools/linter": "0.4.1",
+    "@herb-tools/node-wasm": "0.4.1",
     "dedent": "^1.6.0",
-    "typescript": "^5.8.3",
     "vscode-languageserver": "^9.0.1",
     "vscode-languageserver-textdocument": "^1.0.12"
   },
   "devDependencies": {
-    "@rollup/plugin-commonjs": "^28.0.6",
-    "@rollup/plugin-typescript": "^12.1.3",
-    "@rollup/plugin-node-resolve": "^16.0.1",
-    "@rollup/plugin-json": "^6.1.0",
-    "rimraf": "^6.0.1"
+    "vitest": "^1.0.0"
   }
 }

package/src/cli.ts

@@ -0,0 +1,23 @@
+import { Server } from "./server"
+
+export class CLI {
+  private usage = `
+  Usage: herb-language-server [options]
+
+  Options:
+    --stdio          use stdio
+    --node-ipc       use node-ipc
+    --socket=<port>  use socket
+`
+
+  run() {
+    if (process.argv.length <= 2) {
+      console.error(`Error: Connection input stream is not set. Set command line parameters: '--node-ipc', '--stdio' or '--socket=<port>'`)
+      console.error(this.usage)
+      process.exit(1)
+    }
+
+    const server = new Server()
+    server.listen()
+  }
+}

package/src/config.ts

@@ -1,4 +1,12 @@
-export type HerbConfigOptions = {}
+export type HerbConfigOptions = {
+  formatter?: {
+    enabled?: boolean
+    include?: string[]
+    exclude?: string[]
+    indentWidth?: number
+    maxLineLength?: number
+  }
+}
 
 export type HerbLSPConfig = {
   version: string

package/src/diagnostics.ts

@@ -1,106 +1,49 @@
-import { Connection, Diagnostic, DiagnosticSeverity, Range, Position } from "vscode-languageserver/node"
 import { TextDocument } from "vscode-languageserver-textdocument"
-import { Herb, Visitor } from "@herb-tools/node-wasm"
+import { Connection, Diagnostic } from "vscode-languageserver/node"
 
+import { ParserService } from "./parser_service"
+import { LinterService } from "./linter_service"
 import { DocumentService } from "./document_service"
 
-import type { Node, HerbError } from "@herb-tools/node-wasm"
-
-class ErrorVisitor extends Visitor {
-  private diagnostics: Diagnostics
-  private textDocument: TextDocument
-
-  constructor(diagnostics: Diagnostics, textDocument: TextDocument) {
-    super()
-    this.diagnostics = diagnostics
-    this.textDocument = textDocument
-  }
-
-  visitChildNodes(node: Node) {
-    super.visitChildNodes(node)
-
-    node.errors.forEach(error => this.publishDiagnosticForError(error, node))
-  }
-
-  private publishDiagnosticForError(error: HerbError, node: Node): void {
-    this.diagnostics.pushDiagnostic(
-      error.message,
-      error.type,
-      this.rangeFromHerbError(error),
-      this.textDocument,
-      {
-        error: error.toJSON(),
-        node: node.toJSON()
-      },
-      DiagnosticSeverity.Error
-    )
-  }
-
-  private rangeFromHerbError(error: HerbError): Range {
-    return Range.create(
-      Position.create(error.location.start.line - 1, error.location.start.column),
-      Position.create(error.location.end.line - 1, error.location.end.column),
-    )
-  }
-}
-
 export class Diagnostics {
   private readonly connection: Connection
   private readonly documentService: DocumentService
-  private readonly diagnosticsSource = "Herb LSP "
+  private readonly parserService: ParserService
+  private readonly linterService: LinterService
   private diagnostics: Map<TextDocument, Diagnostic[]> = new Map()
 
   constructor(
     connection: Connection,
     documentService: DocumentService,
+    parserService: ParserService,
+    linterService: LinterService,
   ) {
     this.connection = connection
     this.documentService = documentService
+    this.parserService = parserService
+    this.linterService = linterService
   }
 
-  validate(textDocument: TextDocument) {
-    const content = textDocument.getText()
-    const result = Herb.parse(content)
-    const visitor = new ErrorVisitor(this, textDocument)
+  async validate(textDocument: TextDocument) {
+    const parseResult = this.parserService.parseDocument(textDocument)
+    const lintResult = await this.linterService.lintDocument(parseResult.document, textDocument)
 
-    result.visit(visitor)
+    const allDiagnostics = [
+      ...parseResult.diagnostics,
+      ...lintResult.diagnostics,
+    ]
 
+    this.diagnostics.set(textDocument, allDiagnostics)
     this.sendDiagnosticsFor(textDocument)
   }
 
-  refreshDocument(document: TextDocument) {
-    this.validate(document)
-  }
-
-  refreshAllDocuments() {
-    this.documentService.getAll().forEach((document) => {
-      this.refreshDocument(document)
-    })
+  async refreshDocument(document: TextDocument) {
+    await this.validate(document)
   }
 
-  pushDiagnostic(
-    message: string,
-    code: string,
-    range: Range,
-    textDocument: TextDocument,
-    data = {},
-    severity: DiagnosticSeverity = DiagnosticSeverity.Error,
-  ) {
-    const diagnostic: Diagnostic = {
-      source: this.diagnosticsSource,
-      severity,
-      range,
-      message,
-      code,
-      data,
-    }
-
-    const diagnostics = this.diagnostics.get(textDocument) || []
-    diagnostics.push(diagnostic)
-
-    this.diagnostics.set(textDocument, diagnostics)
-
-    return diagnostic
+  async refreshAllDocuments() {
+    const documents = this.documentService.getAll()
+    await Promise.all(documents.map(document => this.refreshDocument(document)))
   }
 
   private sendDiagnosticsFor(textDocument: TextDocument) {

package/src/formatting_service.ts

@@ -0,0 +1,150 @@
+import { Connection, TextDocuments, DocumentFormattingParams, TextEdit, Range, Position } from "vscode-languageserver/node"
+import { TextDocument } from "vscode-languageserver-textdocument"
+import { Formatter, defaultFormatOptions } from "@herb-tools/formatter"
+import { Project } from "./project"
+import { Settings } from "./settings"
+import { Config } from "./config"
+import { glob } from "glob"
+
+export class FormattingService {
+  private connection: Connection
+  private documents: TextDocuments<TextDocument>
+  private project: Project
+  private settings: Settings
+  private config?: Config
+
+  constructor(connection: Connection, documents: TextDocuments<TextDocument>, project: Project, settings: Settings) {
+    this.connection = connection
+    this.documents = documents
+    this.project = project
+    this.settings = settings
+  }
+
+  async initialize() {
+    try {
+      this.config = await Config.fromPathOrNew(this.project.projectPath)
+      this.connection.console.log("Herb formatter initialized successfully")
+    } catch (error) {
+      this.connection.console.error(`Failed to initialize Herb formatter: ${error}`)
+    }
+  }
+
+  async refreshConfig() {
+    this.config = await Config.fromPathOrNew(this.project.projectPath)
+  }
+
+  private async shouldFormatFile(filePath: string): Promise<boolean> {
+    if (!this.config?.options.formatter) {
+      return true
+    }
+
+    const formatter = this.config.options.formatter
+
+    // Check if formatting is disabled in project config
+    if (formatter.enabled === false) {
+      return false
+    }
+
+    // Check exclude patterns first
+    if (formatter.exclude) {
+      for (const pattern of formatter.exclude) {
+        try {
+          const matches = await new Promise<string[]>((resolve, reject) => {
+            glob(pattern, { cwd: this.project.projectPath }).then(resolve).catch(reject)
+          })
+
+          if (Array.isArray(matches) && matches.some((match: string) => filePath.includes(match) || filePath.endsWith(match))) {
+            return false
+          }
+        } catch (error) {
+          continue
+        }
+      }
+    }
+
+    if (formatter.include && formatter.include.length > 0) {
+      for (const pattern of formatter.include) {
+        try {
+          const matches = await new Promise<string[]>((resolve, reject) => {
+            glob(pattern, { cwd: this.project.projectPath }).then(resolve).catch(reject)
+          })
+          if (Array.isArray(matches) && matches.some((match: string) => filePath.includes(match) || filePath.endsWith(match))) {
+            return true
+          }
+        } catch (error) {
+          continue
+        }
+      }
+
+      return false
+    }
+
+    return true
+  }
+
+  private async getFormatterOptions(uri: string) {
+    const settings = await this.settings.getDocumentSettings(uri)
+
+    const projectFormatter = this.config?.options.formatter || {}
+
+    return {
+      indentWidth: projectFormatter.indentWidth ?? settings.formatter?.indentWidth ?? defaultFormatOptions.indentWidth,
+      maxLineLength: projectFormatter.maxLineLength ?? settings.formatter?.maxLineLength ?? defaultFormatOptions.maxLineLength
+    }
+  }
+
+  private async performFormatting(params: DocumentFormattingParams): Promise<TextEdit[]> {
+    const document = this.documents.get(params.textDocument.uri)
+
+    if (!document) {
+      return []
+    }
+
+    try {
+      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')) {
+        newText = newText + '\n'
+      }
+
+      if (newText === text) {
+        return []
+      }
+
+      const range: Range = {
+        start: Position.create(0, 0),
+        end: Position.create(document.lineCount, 0)
+      }
+
+      return [{ range, newText }]
+    } catch (error) {
+      this.connection.console.error(`Formatting failed: ${error}`)
+
+      return []
+    }
+  }
+
+  async formatDocument(params: DocumentFormattingParams): Promise<TextEdit[]> {
+    const settings = await this.settings.getDocumentSettings(params.textDocument.uri)
+
+    if (settings.formatter?.enabled === false) {
+      return []
+    }
+
+    const filePath = params.textDocument.uri.replace(/^file:\/\//, '')
+
+    if (!(await this.shouldFormatFile(filePath))) {
+      return []
+    }
+
+    return this.performFormatting(params)
+  }
+
+  async formatDocumentIgnoreConfig(params: DocumentFormattingParams): Promise<TextEdit[]> {
+    return this.performFormatting(params)
+  }
+}

package/src/herb-language-server.ts

@@ -0,0 +1,6 @@
+#!/usr/bin/env node
+
+import { CLI } from "./cli"
+
+const cli = new CLI()
+cli.run()

package/src/index.ts

@@ -0,0 +1,10 @@
+export * from "./server"
+export * from "./service"
+export * from "./config"
+export * from "./diagnostics"
+export * from "./document_service"
+export * from "./formatting_service"
+export * from "./project"
+export * from "./settings"
+export * from "./utils"
+export * from "./cli"

package/src/linter_service.ts

@@ -0,0 +1,63 @@
+import { Diagnostic, DiagnosticSeverity, Range, Position, CodeDescription } from "vscode-languageserver/node"
+import { TextDocument } from "vscode-languageserver-textdocument"
+import { Linter } from "@herb-tools/linter"
+
+import { Settings } from "./settings"
+
+import type { DocumentNode } from "@herb-tools/node-wasm"
+
+export interface LintServiceResult {
+  diagnostics: Diagnostic[]
+}
+
+export class LinterService {
+  private readonly settings: Settings
+  private readonly source = "Herb Linter "
+  private linter: Linter
+
+  constructor(settings: Settings) {
+    this.settings = settings
+    this.linter = new Linter()
+  }
+
+  async lintDocument(document: DocumentNode, textDocument: TextDocument): Promise<LintServiceResult> {
+    const settings = await this.settings.getDocumentSettings(textDocument.uri)
+    const linterEnabled = settings?.linter?.enabled ?? true
+
+    if (!linterEnabled) {
+      return { diagnostics: [] }
+    }
+
+    const lintResult = this.linter.lint(document)
+    const diagnostics: Diagnostic[] = []
+
+    lintResult.offenses.forEach(offense => {
+      const severity = offense.severity === "error"
+        ? DiagnosticSeverity.Error
+        : DiagnosticSeverity.Warning
+
+      const range = Range.create(
+        Position.create(offense.location.start.line - 1, offense.location.start.column),
+        Position.create(offense.location.end.line - 1, offense.location.end.column),
+      )
+
+      const codeDescription: CodeDescription = {
+        href: `https://herb-tools.dev/linter/rules/${offense.rule}`
+      }
+
+      const diagnostic: Diagnostic = {
+        source: this.source,
+        severity,
+        range,
+        message: offense.message,
+        code: offense.rule,
+        data: { rule: offense.rule },
+        codeDescription
+      }
+
+      diagnostics.push(diagnostic)
+    })
+
+    return { diagnostics }
+  }
+}

package/src/parser_service.ts

@@ -0,0 +1,59 @@
+import { Diagnostic, DiagnosticSeverity, Range, Position } from "vscode-languageserver/node"
+import { TextDocument } from "vscode-languageserver-textdocument"
+import { Herb, Visitor } from "@herb-tools/node-wasm"
+
+import type { Node, HerbError, DocumentNode } from "@herb-tools/node-wasm"
+
+class ErrorVisitor extends Visitor {
+  private readonly source = "Herb Parser "
+  public diagnostics: Diagnostic[] = []
+
+  visitChildNodes(node: Node) {
+    super.visitChildNodes(node)
+
+    node.errors.forEach(error => this.addDiagnosticForError(error, node))
+  }
+
+  private addDiagnosticForError(error: HerbError, node: Node): void {
+    const diagnostic: Diagnostic = {
+      source: this.source,
+      severity: DiagnosticSeverity.Error,
+      range: this.rangeFromHerbError(error),
+      message: error.message,
+      code: error.type,
+      data: {
+        error: error.toJSON(),
+        node: node.toJSON()
+      }
+    }
+
+    this.diagnostics.push(diagnostic)
+  }
+
+  private rangeFromHerbError(error: HerbError): Range {
+    return Range.create(
+      Position.create(error.location.start.line - 1, error.location.start.column),
+      Position.create(error.location.end.line - 1, error.location.end.column),
+    )
+  }
+}
+
+export interface ParseServiceResult {
+  document: DocumentNode
+  diagnostics: Diagnostic[]
+}
+
+export class ParserService {
+  parseDocument(textDocument: TextDocument): ParseServiceResult {
+    const content = textDocument.getText()
+    const result = Herb.parse(content)
+
+    const errorVisitor = new ErrorVisitor()
+    result.visit(errorVisitor)
+
+    return {
+      document: result.value,
+      diagnostics: errorVisitor.diagnostics
+    }
+  }
+}

package/src/project.ts

@@ -1,17 +1,19 @@
-import { Herb } from "@herb-tools/node-wasm"
+import { Herb, HerbBackend } from "@herb-tools/node-wasm"
 import { Connection } from "vscode-languageserver/node"
 
 export class Project {
   connection: Connection
   projectPath: string
+  herbBackend: HerbBackend
 
   constructor(connection: Connection, projectPath: string) {
     this.projectPath = projectPath
     this.connection = connection
+    this.herbBackend = Herb
   }
 
   async initialize() {
-    await Herb.load()
+    await this.herbBackend.load()
   }
 
   async refresh() {