@herb-tools/language-server 0.3.0 → 0.4.0

package/package.json

@@ -1,46 +1,55 @@
 {
   "name": "@herb-tools/language-server",
-  "description": "Powerful and seamless HTML-aware ERB parsing and tooling.",
-  "version": "0.3.0",
+  "description": "Herb HTML+ERB Language Tools and Language Server Protocol integration.",
+  "version": "0.4.0",
   "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"
   },
-  "homepage": "https://herb-tools.dev",
   "bin": {
-    "herb-language-server": "./dist/herb-language-server"
+    "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/index.d.ts",
+      "import": "./dist/index.js",
+      "require": "./dist/index.cjs",
+      "default": "./dist/index.js"
+    }
   },
   "scripts": {
     "clean": "rimraf dist",
-    "prebuild": "yarn run clean",
-    "build": "tsc -b && rollup -c rollup.config.mjs",
-    "postbuild": "node scripts/executable.mjs",
-    "watch": "tsc -b -w",
-    "test": "echo 'TODO'",
+    "build": "yarn clean && tsc -b && rollup -c",
+    "dev": "tsc -b -w",
+    "test": "echo 'TODO: add tests'",
     "prepublishOnly": "yarn clean && yarn build && yarn test"
   },
   "files": [
-    "dist"
+    "package.json",
+    "README.md",
+    "src/",
+    "bin/",
+    "dist/"
   ],
   "dependencies": {
-    "@herb-tools/node-wasm": "0.3.0",
+    "@herb-tools/formatter": "0.4.0",
+    "@herb-tools/linter": "0.4.0",
+    "@herb-tools/node-wasm": "0.4.0",
     "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"
   }
 }

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

@@ -0,0 +1,109 @@
+export type HerbConfigOptions = {
+  formatter?: {
+    enabled?: boolean
+    include?: string[]
+    exclude?: string[]
+    indentWidth?: number
+    maxLineLength?: number
+  }
+}
+
+export type HerbLSPConfig = {
+  version: string
+  createdAt: string
+  updatedAt: string
+  options: HerbConfigOptions
+}
+
+import path from "path"
+import { version } from "../package.json"
+import { promises as fs } from "fs"
+
+export class Config {
+  static configPath = ".herb-lsp/config.json"
+
+  public readonly path: string
+  public config: HerbLSPConfig
+
+  constructor(projectPath: string, config: HerbLSPConfig) {
+    this.path = Config.configPathFromProjectPath(projectPath)
+    this.config = config
+  }
+
+  get version(): string {
+    return this.config.version
+  }
+
+  get createdAt(): Date {
+    return new Date(this.config.createdAt)
+  }
+
+  get updatedAt(): Date {
+    return new Date(this.config.updatedAt)
+  }
+
+  get options(): HerbConfigOptions {
+    return this.config.options
+  }
+
+  public toJSON() {
+    return JSON.stringify(this.config, null, "  ")
+  }
+
+  private updateTimestamp() {
+    this.config.updatedAt = new Date().toISOString()
+  }
+
+  private updateVersion() {
+    this.config.version = version
+  }
+
+  async write() {
+    this.updateVersion()
+    this.updateTimestamp()
+
+    const folder = path.dirname(this.path)
+
+    fs.stat(folder)
+      .then(() => {})
+      .catch(async () => await fs.mkdir(folder))
+      .finally(async () => await fs.writeFile(this.path, this.toJSON()))
+  }
+
+  async read() {
+    return await fs.readFile(this.path, "utf8")
+  }
+
+  static configPathFromProjectPath(projectPath: string) {
+    return path.join(projectPath, this.configPath)
+  }
+
+  static async fromPathOrNew(projectPath: string) {
+    try {
+      return await this.fromPath(projectPath)
+    } catch (error: any) {
+      return Config.newConfig(projectPath)
+    }
+  }
+
+  static async fromPath(projectPath: string) {
+    const configPath = Config.configPathFromProjectPath(projectPath)
+
+    try {
+      const config = JSON.parse(await fs.readFile(configPath, "utf8"))
+
+      return new Config(projectPath, config)
+    } catch (error: any) {
+      throw new Error(`Error reading config file at: ${configPath}. Error: ${error.message}`)
+    }
+  }
+
+  static newConfig(projectPath: string): Config {
+    return new Config(projectPath, {
+      version,
+      createdAt: new Date().toISOString(),
+      updatedAt: new Date().toISOString(),
+      options: {}
+    })
+  }
+}

package/src/diagnostics.ts

@@ -0,0 +1,59 @@
+import { TextDocument } from "vscode-languageserver-textdocument"
+import { Connection, Diagnostic } from "vscode-languageserver/node"
+
+import { ParserService } from "./parser_service"
+import { LinterService } from "./linter_service"
+import { DocumentService } from "./document_service"
+
+export class Diagnostics {
+  private readonly connection: Connection
+  private readonly documentService: DocumentService
+  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
+  }
+
+  async validate(textDocument: TextDocument) {
+    const parseResult = this.parserService.parseDocument(textDocument)
+    const lintResult = await this.linterService.lintDocument(parseResult.document, textDocument)
+
+    const allDiagnostics = [
+      ...parseResult.diagnostics,
+      ...lintResult.diagnostics,
+    ]
+
+    this.diagnostics.set(textDocument, allDiagnostics)
+    this.sendDiagnosticsFor(textDocument)
+  }
+
+  async refreshDocument(document: TextDocument) {
+    await this.validate(document)
+  }
+
+  async refreshAllDocuments() {
+    const documents = this.documentService.getAll()
+    await Promise.all(documents.map(document => this.refreshDocument(document)))
+  }
+
+  private sendDiagnosticsFor(textDocument: TextDocument) {
+    const diagnostics = this.diagnostics.get(textDocument) || []
+
+    this.connection.sendDiagnostics({
+      uri: textDocument.uri,
+      diagnostics,
+    })
+
+    this.diagnostics.delete(textDocument)
+  }
+}

package/src/document_service.ts

@@ -0,0 +1,35 @@
+import { Connection, TextDocuments } from "vscode-languageserver/node"
+import { TextDocument } from "vscode-languageserver-textdocument"
+
+export class DocumentService {
+  public documents: TextDocuments<TextDocument>
+  document?: TextDocument
+
+  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)
+  }
+
+  get(uri: string) {
+    return this.documents.get(uri)
+  }
+
+  getAll() {
+    return this.documents.all()
+  }
+
+  get onDidChangeContent() {
+    return this.documents.onDidChangeContent
+  }
+
+  get onDidOpen() {
+    return this.documents.onDidOpen
+  }
+
+  get onDidClose() {
+    return this.documents.onDidClose
+  }
+}

package/src/formatting_service.ts

@@ -0,0 +1,151 @@
+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) {
+    // Get VS Code settings
+    const settings = await this.settings.getDocumentSettings(uri)
+
+    // Get project config options
+    const projectFormatter = this.config?.options.formatter || {}
+
+    // Merge options with precedence: project config > VS Code settings > defaults
+    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()
+      const newText = formatter.format(text)
+
+      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[]> {
+    // Check VS Code settings first
+    const settings = await this.settings.getDocumentSettings(params.textDocument.uri)
+
+    if (settings.formatter?.enabled === false) {
+      return []
+    }
+
+    // Check project config and file patterns
+    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

@@ -0,0 +1,22 @@
+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 this.herbBackend.load()
+  }
+
+  async refresh() {
+    // TODO
+  }
+}