cli-lsp-client 1.0.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2024 cli-lsp-client
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,181 @@
+# cli-lsp-client
+
+CLI tool for getting LSP diagnostics. Uses a background daemon to keep LSP servers running.
+
+## Features
+
+- Get diagnostics from LSP servers
+- Background daemon for fast repeated requests
+- Built in Claude Code hook to provide feedback on file edit tool calls
+
+## Supported Languages
+
+| Language | LSP Server | Auto-installed | Notes |
+|----------|------------|----------------|-------|
+| TypeScript/JavaScript | `typescript-language-server` | ✓ (via bunx) | `.ts`, `.tsx`, `.js`, `.jsx`, `.mjs`, `.cjs`, `.mts`, `.cts` |
+| Python | `pyright-langserver` | ✓ (via bunx) | `.py`, `.pyi` |
+| JSON | `vscode-json-language-server` | ✓ (via vscode-langservers-extracted) | `.json`, `.jsonc` - includes schema validation |
+| CSS | `vscode-css-language-server` | ✓ (via vscode-langservers-extracted) | `.css`, `.scss`, `.sass`, `.less` |
+| YAML | `yaml-language-server` | ✓ (via bunx) | `.yaml`, `.yml` - includes schema validation |
+| Bash/Shell | `bash-language-server` | ✓ (via bunx) | `.sh`, `.bash`, `.zsh` - **requires shellcheck** (`brew install shellcheck`) |
+| Go | `gopls` | ✗ | Requires manual install: `go install golang.org/x/tools/gopls@latest` |
+| Java | `jdtls` (Eclipse JDT) | ✗ | `.java` - see [Java Installation](#java-installation-guide) below |
+| Lua | `lua-language-server` | ✗ | `.lua` - requires manual install via package manager (brew, scoop) or from [releases](https://github.com/LuaLS/lua-language-server/releases) |
+
+
+## How It Works
+
+- Daemon starts automatically when needed
+- LSP servers spawn based on file type  
+- Finds project roots using config files (tsconfig.json, etc.)
+- Servers stay running for subsequent requests
+
+## Claude Code Integration
+
+### Real-time Diagnostics Hook
+
+Get instant diagnostic feedback for TypeScript, Python, Go, JSON, CSS, YAML, Bash, Java, and Lua files as you edit in Claude Code.
+
+#### Setup
+
+Configure Claude Code to use the built-in hook command:
+
+```bash
+{
+  "$schema": "https://json.schemastore.org/claude-code-settings.json",
+  "hooks": {
+    "PostToolUse": [
+      {
+        "matcher": "Edit|MultiEdit|Write",
+        "hooks": [
+          {
+            "type": "command",
+            "command": "npx -y cli-lsp-client claude-code-hook"
+          }
+        ]
+      }
+    ]
+  }
+}
+```
+
+#### How It Works
+
+- Automatically runs diagnostics after each file edit
+- Built-in file filtering for all supported languages (11 file types)
+- Shows errors, warnings, and hints inline
+- Graceful error handling - never breaks your editing experience
+- Uses the same fast daemon as the regular diagnostics command
+
+#### Example Output
+
+When you save a file with errors, you'll see immediate feedback:
+
+```
+Edit operation feedback:
+- [npx -y cli-lsp-client claude-code-hook]: 
+ERROR at line 3, column 9:
+  Type 'number' is not assignable to type 'string'.
+  Source: typescript
+  Code: 2322
+```
+
+## Usage
+
+### Get Diagnostics
+
+```bash
+# Check a TypeScript file
+npx cli-lsp-client diagnostics src/example.ts
+
+# Check any supported file type
+npx cli-lsp-client diagnostics app.py
+npx cli-lsp-client diagnostics main.go
+```
+
+Exit codes: 0 for no issues, 2 for issues found.
+
+```bash
+$ npx cli-lsp-client diagnostics error.ts
+ERROR at line 5, column 20:
+  Argument of type 'string' is not assignable to parameter of type 'number'.
+  Source: typescript
+  Code: 2345
+```
+
+### Other Commands
+
+```bash
+# Check daemon status
+npx cli-lsp-client status
+
+# Stop daemon (it will auto-restart when needed)
+npx cli-lsp-client stop
+```
+
+## Java Installation Guide
+
+Eclipse JDT Language Server requires Java 17+ and manual setup:
+
+### Installation Steps
+
+1. **Download**: Get the latest server from [Eclipse JDT.LS downloads](http://download.eclipse.org/jdtls/snapshots/)
+2. **Extract**: Unpack to your preferred location (e.g., `/opt/jdtls/`)
+3. **Create wrapper script** named `jdtls` in your PATH:
+
+```bash
+#!/bin/bash
+java -Declipse.application=org.eclipse.jdt.ls.core.id1 \
+     -Dosgi.bundles.defaultStartLevel=4 \
+     -Declipse.product=org.eclipse.jdt.ls.core.product \
+     -Xms1g -Xmx2G \
+     -jar /opt/jdtls/plugins/org.eclipse.equinox.launcher_*.jar \
+     -configuration /opt/jdtls/config_linux \
+     -data "${1:-$HOME/workspace}" \
+     --add-modules=ALL-SYSTEM \
+     --add-opens java.base/java.util=ALL-UNNAMED \
+     --add-opens java.base/java.lang=ALL-UNNAMED "$@"
+```
+
+4. **Make executable**: `chmod +x /usr/local/bin/jdtls`
+
+### Alternative Installation Methods
+
+**Homebrew (macOS/Linux)**:
+```bash
+brew install jdtls
+```
+
+**Arch Linux**:
+```bash
+pacman -S jdtls
+```
+
+### Configuration Notes
+
+- Replace `config_linux` with `config_mac` on macOS or `config_win` on Windows
+- Adjust the `-data` workspace path as needed
+- Requires Java 17 or higher to run
+
+For detailed setup instructions, see the [official Eclipse JDT.LS documentation](https://github.com/eclipse-jdtls/eclipse.jdt.ls).
+
+## Examples
+
+```bash
+# Check a specific file
+npx cli-lsp-client diagnostics src/main.ts
+```
+
+## Development
+
+### Installation
+
+```bash
+# Install dependencies and build
+bun install
+bun run build    # Build executable
+bun run typecheck
+bun test
+```
+
+Add new LSP servers in `src/lsp/servers.ts`.

package/package.json

@@ -0,0 +1,42 @@
+{
+  "name": "cli-lsp-client",
+  "version": "1.0.0",
+  "description": "A Bun CLI daemon application",
+  "type": "module",
+  "main": "src/cli.ts",
+  "bin": {
+    "cli-lsp-client": "cli-lsp-client"
+  },
+  "files": [
+    "cli-lsp-client"
+  ],
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/eli0shin/cli-lsp-client.git"
+  },
+  "homepage": "https://github.com/eli0shin/cli-lsp-client#readme",
+  "bugs": {
+    "url": "https://github.com/eli0shin/cli-lsp-client/issues"
+  },
+  "scripts": {
+    "build": "bun build src/cli.ts --compile --outfile cli-lsp-client",
+    "dev": "bun run src/cli.ts",
+    "typecheck": "bun --bun tsc --noEmit",
+    "test": "bun test",
+    "test:watch": "bun test tests/ --watch",
+    "prepublish": "bun test && bun run build"
+  },
+  "devDependencies": {
+    "@types/bun": "latest",
+    "@types/node": "latest",
+    "typescript": "latest"
+  },
+  "peerDependencies": {
+    "typescript": "^5.0.0"
+  },
+  "dependencies": {
+    "pyright": "^1.1.403",
+    "vscode-jsonrpc": "^8.2.1",
+    "vscode-languageserver-types": "^3.17.5"
+  }
+}

package/src/cli.ts

@@ -0,0 +1,113 @@
+#!/usr/bin/env bun
+
+import path from 'path';
+import { startDaemon } from './daemon.js';
+import { runCommand } from './client.js';
+import { formatDiagnosticsPlain } from './lsp/formatter.js';
+import type { Diagnostic } from './lsp/types.js';
+
+export async function handleClaudeCodeHook(filePath: string): Promise<{ hasIssues: boolean; output: string }> {
+  // Check if file exists
+  if (!await Bun.file(filePath).exists()) {
+    return { hasIssues: false, output: '' };
+  }
+  
+  // Filter supported file types
+  const supportedExts = [
+    '.ts', '.tsx', '.js', '.jsx', '.mjs', '.cjs', '.mts', '.cts',
+    '.py', '.pyi',
+    '.go',
+    '.json', '.jsonc',
+    '.css', '.scss', '.sass', '.less',
+    '.yaml', '.yml',
+    '.sh', '.bash', '.zsh',
+    '.java',
+    '.lua',
+    '.graphql', '.gql'
+  ];
+  const ext = path.extname(filePath);
+  if (!supportedExts.includes(ext)) {
+    return { hasIssues: false, output: '' };
+  }
+  
+  // Get diagnostics (suppress errors to stdout)
+  try {
+    const { sendToExistingDaemon } = await import('./client.js');
+    const result = await sendToExistingDaemon('diagnostics', [filePath]);
+    
+    // The diagnostics command returns an array of diagnostics
+    if (!Array.isArray(result) || result.length === 0) {
+      return { hasIssues: false, output: '' };
+    }
+    
+    const diagnostics = result as Diagnostic[];
+    
+    // Format output for Claude Code hook (plain text, no ANSI codes)
+    const formatted = formatDiagnosticsPlain(filePath, diagnostics);
+    return { hasIssues: true, output: formatted || '' };
+  } catch (error) {
+    // Silently fail - don't break Claude Code experience
+    return { hasIssues: false, output: '' };
+  }
+}
+
+async function run(): Promise<void> {
+  const args = process.argv.slice(2);
+  const command = args[0] || 'status';
+  const commandArgs = args.slice(1);
+
+  // Check if we're being invoked to run as daemon
+  if (process.env.LSPCLI_DAEMON_MODE === '1') {
+    await startDaemon();
+    return;
+  }
+
+  // Handle claude-code-hook command directly (reads JSON from stdin)
+  if (command === 'claude-code-hook') {
+    try {
+      // Read JSON from stdin
+      const stdinData = await new Promise<string>((resolve, reject) => {
+        let data = '';
+        process.stdin.on('data', (chunk) => {
+          data += chunk.toString();
+        });
+        process.stdin.on('end', () => {
+          resolve(data);
+        });
+        process.stdin.on('error', reject);
+      });
+
+      if (!stdinData.trim()) {
+        process.exit(0); // No input, silently exit
+      }
+
+      // Parse the JSON to get the file path
+      const hookData = JSON.parse(stdinData);
+      // Handle both PostToolUse format (tool_input.file_path) and simple format (file_path)
+      const filePath = hookData.tool_input?.file_path || hookData.file_path || hookData.filePath;
+      
+      if (!filePath) {
+        process.exit(0); // No file path, silently exit
+      }
+
+      const result = await handleClaudeCodeHook(filePath);
+      if (result.hasIssues) {
+        console.error(result.output);
+        process.exit(2);
+      }
+      process.exit(0);
+    } catch (error) {
+      // Silently fail for hook commands to not break Claude Code
+      process.exit(0);
+    }
+  }
+
+  // All other user commands are handled by the client (which auto-starts daemon if needed)
+  await runCommand(command, commandArgs);
+}
+
+export { run };
+
+if (import.meta.main) {
+  run();
+}