@sankalpmukim/hadolint-lsp 0.1.0

package/LICENSE

@@ -0,0 +1,17 @@
+GNU GENERAL PUBLIC LICENSE
+Version 3, 29 June 2007
+
+Copyright (C) 2023 Sankalp Mukim
+
+This program is free software: you can redistribute it and/or modify
+it under the terms of the GNU General Public License as published by
+the Free Software Foundation, either version 3 of the License, or
+(at your option) any later version.
+
+This program is distributed in the hope that it will be useful,
+but WITHOUT ANY WARRANTY; without even the implied warranty of
+MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+GNU General Public License for more details.
+
+You should have received a copy of the GNU General Public License
+along with this program.  If not, see <https://www.gnu.org/licenses/>.

package/README.md

@@ -0,0 +1,207 @@
+# Hadolint LSP
+
+A Language Server Protocol implementation for Hadolint, the Dockerfile linter.
+
+## Installation
+
+```bash
+npx @sankalpmukim/hadolint-lsp
+```
+
+Or install globally:
+
+```bash
+npm install -g @sankalpmukim/hadolint-lsp
+```
+
+## OpenCode Integration
+
+To use hadolint-lsp with OpenCode, add it to your `opencode.json` configuration file:
+
+### Local Configuration
+
+Add to your project-local `opencode.json`:
+
+```json
+{
+  "$schema": "https://opencode.ai/config.json",
+  "lsp": {
+    "hadolint": {
+      "command": ["npx", "-y", "@sankalpmukim/hadolint-lsp", "--stdio"],
+      "extensions": ["Dockerfile", "dockerfile"]
+    }
+  }
+}
+```
+
+### Global Configuration
+
+Add to your global OpenCode config (usually at `~/.config/opencode/opencode.json`):
+
+```json
+{
+  "$schema": "https://opencode.ai/config.json",
+  "lsp": {
+    "hadolint": {
+      "command": ["npx", "-y", "@sankalpmukim/hadolint-lsp", "--stdio"],
+      "extensions": ["Dockerfile", "dockerfile"]
+    }
+  }
+}
+```
+
+If you have installed @sankalpmukim/hadolint-lsp globally, you can use:
+
+```json
+{
+  "$schema": "https://opencode.ai/config.json",
+  "lsp": {
+    "hadolint": {
+      "command": ["hadolint-lsp", "--stdio"],
+      "extensions": ["Dockerfile", "dockerfile"]
+    }
+  }
+}
+```
+
+### Notes
+
+- The LSP server communicates via stdio, so the `--stdio` flag is important
+- The `extensions` array specifies which file extensions the LSP should handle
+- OpenCode will automatically start the LSP server when you open a Dockerfile
+- Make sure `hadolint` is available in your PATH (see Requirements section)
+
+## Requirements
+
+This LSP server requires [hadolint](https://github.com/hadolint/hadolint) to be installed and available in your PATH.
+
+Install hadolint:
+
+```bash
+# On macOS
+brew install hadolint
+
+# On Linux
+wget -O /usr/local/bin/hadolint https://github.com/hadolint/hadolint/releases/latest/download/hadolint-Linux-x86_64
+chmod +x /usr/local/bin/hadolint
+
+# Or using Docker (but LSP will not work with Docker)
+docker pull hadolint/hadolint
+```
+
+## Usage
+
+### Editor Integration
+
+#### VS Code
+
+Create or edit `.vscode/settings.json`:
+
+```json
+{
+  "dockerfile.languageserver": {
+    "dockerfile-language-server-node": {
+      "command": "@sankalpmukim/hadolint-lsp"
+    }
+  }
+}
+```
+
+Or use with Docker extension that supports LSP.
+
+#### Vim/Neovim
+
+With [nvim-lspconfig](https://github.com/neovim/nvim-lspconfig):
+
+```lua
+require'lspconfig'.hadolint_lsp.setup{
+  cmd = { "@sankalpmukim/hadolint-lsp" },
+  filetypes = { "dockerfile" },
+  root_dir = require('lspconfig').util.root_pattern(".hadolint.yaml"),
+}
+```
+
+#### Emacs
+
+With [lsp-mode](https://github.com/emacs-lsp/lsp-mode):
+
+```elisp
+(use-package lsp-mode
+  :config
+  (lsp-register-client
+    (make-lsp-client :new-connection (lsp-stdio-connection "@sankalpmukim/hadolint-lsp")
+                     :major-modes '(dockerfile-mode)
+                     :server-id 'hadolint-lsp)))
+```
+
+### Features
+
+- Real-time Dockerfile linting
+- Diagnostic highlighting
+- Error, warning, info, and style level detection
+- Supports all Hadolint rules
+- Respects inline ignore pragmas (`# hadolint ignore=DLxxxx`)
+
+## Configuration
+
+The LSP server respects Hadolint configuration files:
+- `.hadolint.yaml` in the project root
+- `$XDG_CONFIG_HOME/hadolint.yaml`
+- `$HOME/.config/hadolint.yaml`
+- `$HOME/.hadolint.yaml`
+
+Example `.hadolint.yaml`:
+
+```yaml
+failure-threshold: warning
+ignored:
+  - DL3008
+override:
+  error:
+    - DL3006
+  warning:
+    - DL3015
+```
+
+## Testing
+
+Run the test suite:
+
+```bash
+npm test
+```
+
+The test suite covers:
+- Hadolint integration
+- Severity mapping
+- Diagnostic generation
+- Package structure validation
+- Executable verification
+
+All tests should pass (17 total tests as of v0.1.0).
+
+## Development
+
+```bash
+# Install dependencies
+npm install
+
+# Run tests
+npm test
+
+# Run in development mode
+node src/index.js --stdio
+```
+
+## License
+
+GPL-3.0
+
+## Contributing
+
+Contributions are welcome! Please feel free to submit a Pull Request.
+
+## Related
+
+- [Hadolint](https://github.com/hadolint/hadolint) - The Dockerfile linter
+- [Language Server Protocol](https://microsoft.github.io/language-server-protocol/)

package/package.json

@@ -0,0 +1,37 @@
+{
+  "name": "@sankalpmukim/hadolint-lsp",
+  "version": "0.1.0",
+  "description": "Language Server Protocol implementation for Hadolint",
+  "main": "src/index.js",
+  "bin": {
+    "hadolint-lsp": "src/index.js"
+  },
+  "files": [
+    "src"
+  ],
+  "scripts": {
+    "test": "node test/run-tests.js",
+    "test:coverage": "node test/run-tests.js --coverage"
+  },
+  "keywords": [
+    "lsp",
+    "language-server",
+    "hadolint",
+    "dockerfile",
+    "docker"
+  ],
+  "author": "Sankalp Mukim",
+  "license": "GPL-3.0",
+  "homepage": "https://github.com/sankalpmukim/hadolint-lsp",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/sankalpmukim/hadolint-lsp.git"
+  },
+  "engines": {
+    "node": ">=16.0.0"
+  },
+  "dependencies": {
+    "vscode-languageserver": "^8.1.0",
+    "vscode-languageserver-textdocument": "^1.0.11"
+  }
+}

package/src/index.js

@@ -0,0 +1,164 @@
+#!/usr/bin/env node
+const {
+  createConnection,
+  TextDocuments,
+  Diagnostic,
+  DiagnosticSeverity,
+  ProposedFeatures,
+  InitializeParams,
+  DidChangeConfigurationNotification,
+  CompletionItem,
+  CompletionItemKind,
+  TextDocumentPositionParams,
+  TextDocumentSyncKind,
+  InitializeResult
+} = require('vscode-languageserver/node');
+
+const {
+  TextDocument
+} = require('vscode-languageserver-textdocument');
+
+const { spawn } = require('child_process');
+const { readFileSync, unlinkSync, writeFileSync, existsSync } = require('fs');
+const { tmpdir } = require('os');
+const { join } = require('path');
+
+const connection = createConnection(ProposedFeatures.all);
+const documents = new TextDocuments(TextDocument);
+
+let hasConfigurationCapability = false;
+let hasWorkspaceFolderCapability = false;
+
+connection.onInitialize((params) => {
+  const capabilities = params.capabilities;
+  hasConfigurationCapability = !!(
+    capabilities.workspace && !!capabilities.workspace.configuration
+  );
+  hasWorkspaceFolderCapability = !!(
+    capabilities.workspace && !!capabilities.workspace.workspaceFolders
+  );
+
+  const result = {
+    capabilities: {
+      textDocumentSync: TextDocumentSyncKind.Incremental,
+      completionProvider: {
+        resolveProvider: true
+      }
+    }
+  };
+  return result;
+});
+
+connection.onInitialized(() => {
+  if (hasConfigurationCapability) {
+    connection.client.register(
+      DidChangeConfigurationNotification.type,
+      undefined
+    );
+  }
+});
+
+async function runHadolint(content) {
+  return new Promise((resolve, reject) => {
+    const tmpFile = join(tmpdir(), `hadolint-lsp-${Date.now()}`);
+    writeFileSync(tmpFile, content, 'utf-8');
+
+    const hadolint = spawn('hadolint', ['--format', 'json', tmpFile], {
+      stdio: ['ignore', 'pipe', 'pipe']
+    });
+
+    let stdout = '';
+    let stderr = '';
+
+    hadolint.stdout.on('data', (data) => {
+      stdout += data.toString();
+    });
+
+    hadolint.stderr.on('data', (data) => {
+      stderr += data.toString();
+    });
+
+    hadolint.on('close', (code) => {
+      try {
+        if (existsSync(tmpFile)) {
+          unlinkSync(tmpFile);
+        }
+      } catch (e) {
+      }
+
+      if (stdout) {
+        try {
+          const results = JSON.parse(stdout);
+          const diagnostics = results.map((result) => {
+            const severity = mapSeverity(result.level);
+            return {
+              range: {
+                start: { line: result.line - 1, character: 0 },
+                end: { line: result.line - 1, character: 100 }
+              },
+              severity: severity,
+              code: result.code,
+              message: result.message,
+              source: 'hadolint'
+            };
+          });
+          resolve(diagnostics);
+        } catch (e) {
+          resolve([]);
+        }
+      } else {
+        resolve([]);
+      }
+    });
+
+    hadolint.on('error', (err) => {
+      try {
+        if (existsSync(tmpFile)) {
+          unlinkSync(tmpFile);
+        }
+      } catch (e) {
+      }
+      resolve([]);
+    });
+  });
+}
+
+function mapSeverity(level) {
+  switch (level.toLowerCase()) {
+    case 'error':
+      return DiagnosticSeverity.Error;
+    case 'warning':
+      return DiagnosticSeverity.Warning;
+    case 'info':
+      return DiagnosticSeverity.Information;
+    case 'style':
+      return DiagnosticSeverity.Hint;
+    default:
+      return DiagnosticSeverity.Warning;
+  }
+}
+
+documents.onDidChangeContent(async (change) => {
+  const text = change.document.getText();
+  const diagnostics = await runHadolint(text);
+  connection.sendDiagnostics({
+    uri: change.document.uri,
+    diagnostics
+  });
+});
+
+documents.listen(connection);
+
+connection.onCompletion(
+  (_textDocumentPosition) => {
+    return [];
+  }
+);
+
+connection.onCompletionResolve(
+  (item) => {
+    return item;
+  }
+);
+
+connection.listen();