cli-lsp-client 1.14.1 → 1.16.0

package/bin/cli-lsp-client

@@ -0,0 +1,64 @@
+#!/bin/sh
+set -e
+
+if [ -n "$CLI_LSP_CLIENT_BIN_PATH" ]; then
+    resolved="$CLI_LSP_CLIENT_BIN_PATH"
+else
+    # Get the real path of this script, resolving symlinks
+    script_path="$0"
+    while [ -L "$script_path" ]; do
+        link_target="$(readlink "$script_path")"
+        case "$link_target" in
+            /*) script_path="$link_target" ;;
+            *) script_path="$(dirname "$script_path")/$link_target" ;;
+        esac
+    done
+    script_dir="$(dirname "$script_path")"
+    script_dir="$(cd "$script_dir" && pwd)"
+
+    # Detect platform and architecture
+    case "$(uname -s)" in
+        Darwin) platform="darwin" ;;
+        Linux) platform="linux" ;;
+        MINGW*|CYGWIN*|MSYS*) platform="win32" ;;
+        *) platform="$(uname -s | tr '[:upper:]' '[:lower:]')" ;;
+    esac
+
+    case "$(uname -m)" in
+        x86_64|amd64) arch="x64" ;;
+        aarch64) arch="arm64" ;;
+        armv7l) arch="arm" ;;
+        *) arch="$(uname -m)" ;;
+    esac
+
+    name="cli-lsp-client-${platform}-${arch}"
+    binary="cli-lsp-client"
+    [ "$platform" = "win32" ] && binary="cli-lsp-client.exe"
+
+    # Search for binary starting from script location
+    resolved=""
+    current_dir="$script_dir"
+    while [ "$current_dir" != "/" ]; do
+        # Check dist/ first (for local development)
+        candidate="$current_dir/dist/$name/bin/$binary"
+        if [ -f "$candidate" ]; then
+            resolved="$candidate"
+            break
+        fi
+        # Then check node_modules/ (for production installs)
+        candidate="$current_dir/node_modules/$name/bin/$binary"
+        if [ -f "$candidate" ]; then
+            resolved="$candidate"
+            break
+        fi
+        current_dir="$(dirname "$current_dir")"
+    done
+
+    if [ -z "$resolved" ]; then
+        printf "Failed to find %s binary for your platform\n" "$name" >&2
+        exit 1
+    fi
+fi
+
+# Execute the binary
+exec "$resolved" "$@"

package/bin/cli-lsp-client.cmd

@@ -0,0 +1,57 @@
+@echo off
+setlocal enabledelayedexpansion
+
+if defined CLI_LSP_CLIENT_BIN_PATH (
+    set "resolved=%CLI_LSP_CLIENT_BIN_PATH%"
+    goto :execute
+)
+
+rem Get the directory of this script
+set "script_dir=%~dp0"
+set "script_dir=%script_dir:~0,-1%"
+
+rem Detect architecture
+if "%PROCESSOR_ARCHITECTURE%"=="AMD64" (
+    set "arch=x64"
+) else if "%PROCESSOR_ARCHITECTURE%"=="ARM64" (
+    set "arch=arm64"
+) else (
+    set "arch=x64"
+)
+
+set "name=cli-lsp-client-windows-!arch!"
+set "binary=cli-lsp-client.exe"
+
+rem Search for the binary
+set "resolved="
+set "current_dir=%script_dir%"
+
+:search_loop
+rem Check dist/ first (for local development)
+set "candidate=%current_dir%\dist\%name%\bin\%binary%"
+if exist "%candidate%" (
+    set "resolved=%candidate%"
+    goto :execute
+)
+
+rem Then check node_modules/ (for production installs)
+set "candidate=%current_dir%\node_modules\%name%\bin\%binary%"
+if exist "%candidate%" (
+    set "resolved=%candidate%"
+    goto :execute
+)
+
+for %%i in ("%current_dir%") do set "parent_dir=%%~dpi"
+set "parent_dir=%parent_dir:~0,-1%"
+
+if "%current_dir%"=="%parent_dir%" goto :not_found
+set "current_dir=%parent_dir%"
+goto :search_loop
+
+:not_found
+echo Failed to find %name% binary for your platform >&2
+exit /b 1
+
+:execute
+start /b /wait "" "%resolved%" %*
+exit /b %ERRORLEVEL%

package/package.json

@@ -1,53 +1,28 @@
 {
   "name": "cli-lsp-client",
-  "version": "1.14.1",
+  "version": "1.16.0",
+  "description": "CLI tool supporting claude code hooks for fast LSP diagnostics with background daemon and multi-project support",
   "repository": {
     "type": "git",
     "url": "git+https://github.com/eli0shin/cli-lsp-client.git"
   },
-  "main": "src/cli.ts",
-  "devDependencies": {
-    "@eslint/js": "^9.33.0",
-    "@modelcontextprotocol/sdk": "^1.17.3",
-    "@types/bun": "latest",
-    "@types/node": "latest",
-    "eslint": "^9.33.0",
-    "eslint-config-prettier": "10.1.8",
-    "eslint-import-resolver-typescript": "^4.4.4",
-    "eslint-plugin-import-x": "^4.16.1",
-    "eslint-plugin-unused-imports": "^4.1.4",
-    "globals": "^16.3.0",
-    "prettier": "3.6.2",
-    "typescript": "latest",
-    "typescript-eslint": "^8.39.1",
-    "vscode-jsonrpc": "^8.2.1",
-    "vscode-languageserver-types": "^3.17.5",
-    "zod": "3.25"
-  },
-  "bin": {
-    "cli-lsp-client": "cli-lsp-client"
-  },
   "bugs": {
     "url": "https://github.com/eli0shin/cli-lsp-client/issues"
   },
-  "description": "CLI tool supporting claude code hooks for fast LSP diagnostics with background daemon and multi-project support",
-  "files": [
-    "cli-lsp-client"
-  ],
   "homepage": "https://github.com/eli0shin/cli-lsp-client#readme",
   "license": "MIT",
+  "bin": {
+    "cli-lsp-client": "./bin/cli-lsp-client"
+  },
   "scripts": {
-    "build": "bun build src/cli.ts --compile --outfile cli-lsp-client",
-    "dev": "bun run src/cli.ts",
-    "typecheck": "bun tsc --noEmit",
-    "lint": "eslint .",
-    "lint:fix": "eslint . --fix",
-    "format": "prettier --check .",
-    "format:fix": "prettier --write .",
-    "test": "bun test",
-    "test:watch": "bun test tests/ --watch",
-    "prepublishOnly": "bun test && bun run build",
-    "postinstall": "node scripts/postinstall.js"
+    "preinstall": "node ./preinstall.mjs",
+    "postinstall": "node ./postinstall.mjs"
   },
-  "type": "module"
-}
+  "optionalDependencies": {
+    "cli-lsp-client-windows-x64": "1.15.0",
+    "cli-lsp-client-linux-arm64": "1.15.0",
+    "cli-lsp-client-linux-x64": "1.15.0",
+    "cli-lsp-client-darwin-x64": "1.15.0",
+    "cli-lsp-client-darwin-arm64": "1.15.0"
+  }
+}

package/postinstall.mjs

@@ -0,0 +1,145 @@
+#!/usr/bin/env node
+
+import fs from "fs"
+import path from "path"
+import os from "os"
+import { fileURLToPath } from "url"
+import { createRequire } from "module"
+
+const __dirname = path.dirname(fileURLToPath(import.meta.url))
+const require = createRequire(import.meta.url)
+
+// Skip postinstall when running from source (dev/CI)
+function shouldSkipPostinstall() {
+  const packageRoot = path.join(__dirname, "..")
+  const srcDir = path.join(packageRoot, "src")
+  if (fs.existsSync(srcDir)) {
+    console.log("Skipping postinstall (running from source)")
+    return true
+  }
+  return false
+}
+
+function detectPlatformAndArch() {
+  let platform
+  switch (os.platform()) {
+    case "darwin":
+      platform = "darwin"
+      break
+    case "linux":
+      platform = "linux"
+      break
+    case "win32":
+      platform = "windows"
+      break
+    default:
+      platform = os.platform()
+  }
+
+  let arch
+  switch (os.arch()) {
+    case "x64":
+      arch = "x64"
+      break
+    case "arm64":
+      arch = "arm64"
+      break
+    default:
+      arch = os.arch()
+  }
+
+  return { platform, arch }
+}
+
+function findBinary() {
+  const { platform, arch } = detectPlatformAndArch()
+  const packageName = `cli-lsp-client-${platform}-${arch}`
+  const binary = platform === "windows" ? "cli-lsp-client.exe" : "cli-lsp-client"
+
+  try {
+    const packageJsonPath = require.resolve(`${packageName}/package.json`)
+    const packageDir = path.dirname(packageJsonPath)
+    const binaryPath = path.join(packageDir, "bin", binary)
+
+    if (!fs.existsSync(binaryPath)) {
+      throw new Error(`Binary not found at ${binaryPath}`)
+    }
+
+    return binaryPath
+  } catch (error) {
+    throw new Error(`Could not find package ${packageName}: ${error.message}`)
+  }
+}
+
+async function regenerateWindowsCmdWrappers() {
+  console.log("Windows + npm: Rebuilding bin links")
+
+  try {
+    const { execSync } = require("child_process")
+    const pkgPath = path.join(__dirname, "..")
+
+    const isGlobal = process.env.npm_config_global === "true" || pkgPath.includes(path.join("npm", "node_modules"))
+
+    const cmd = `npm rebuild cli-lsp-client --ignore-scripts${isGlobal ? " -g" : ""}`
+    const opts = {
+      stdio: "inherit",
+      shell: true,
+      ...(isGlobal ? {} : { cwd: path.join(pkgPath, "..", "..") }),
+    }
+
+    execSync(cmd, opts)
+    console.log("Successfully rebuilt npm bin links")
+  } catch (error) {
+    console.error("Error rebuilding npm links:", error.message)
+  }
+}
+
+async function stopExistingDaemons() {
+  try {
+    const { spawn } = require("child_process")
+    const child = spawn("cli-lsp-client", ["stop-all"], { stdio: "inherit" })
+    child.on("error", () => {})
+  } catch (error) {
+    // Ignore errors - daemon might not be running
+  }
+}
+
+async function main() {
+  if (shouldSkipPostinstall()) {
+    return
+  }
+
+  try {
+    if (os.platform() === "win32") {
+      if (process.env.npm_config_user_agent?.startsWith("npm")) {
+        await regenerateWindowsCmdWrappers()
+      }
+      await stopExistingDaemons()
+      return
+    }
+
+    const binaryPath = findBinary()
+    const binScript = path.join(__dirname, "..", "bin", "cli-lsp-client")
+
+    // Create symlink to actual binary
+    if (fs.existsSync(binScript)) {
+      fs.unlinkSync(binScript)
+    }
+
+    fs.symlinkSync(binaryPath, binScript)
+    console.log(`Binary symlinked: ${binScript} -> ${binaryPath}`)
+
+    // Stop existing daemons
+    await stopExistingDaemons()
+  } catch (error) {
+    console.error("Failed to create binary symlink:", error.message)
+    process.exit(1)
+  }
+}
+
+try {
+  main()
+} catch (error) {
+  console.error("Postinstall error:", error.message)
+  process.exit(0)
+}

package/preinstall.mjs

@@ -0,0 +1,41 @@
+#!/usr/bin/env node
+
+import fs from "fs"
+import path from "path"
+import os from "os"
+import { fileURLToPath } from "url"
+
+const __dirname = path.dirname(fileURLToPath(import.meta.url))
+
+function main() {
+  if (os.platform() !== "win32") {
+    console.log("Non-Windows platform, skipping preinstall")
+    return
+  }
+
+  console.log("Windows: Modifying package.json bin entry")
+
+  const packageJsonPath = path.join(__dirname, "..", "package.json")
+  const packageJson = JSON.parse(fs.readFileSync(packageJsonPath, "utf8"))
+
+  // Point to .cmd file on Windows
+  packageJson.bin = {
+    "cli-lsp-client": "./bin/cli-lsp-client.cmd",
+  }
+
+  fs.writeFileSync(packageJsonPath, JSON.stringify(packageJson, null, 2))
+  console.log("Updated package.json bin to use cli-lsp-client.cmd")
+
+  // Remove Unix script
+  const unixScript = path.join(__dirname, "..", "bin", "cli-lsp-client")
+  if (fs.existsSync(unixScript)) {
+    fs.unlinkSync(unixScript)
+  }
+}
+
+try {
+  main()
+} catch (error) {
+  console.error("Preinstall error:", error.message)
+  process.exit(0)
+}

package/LICENSE

@@ -1,21 +0,0 @@
-MIT License
-
-Copyright (c) 2025 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

@@ -1,554 +0,0 @@
-# cli-lsp-client
-
-CLI tool for getting LSP diagnostics. Uses a background daemon to keep LSP servers running.
-
-## Features
-
-- Get diagnostics from LSP servers
-- Get hover information for symbols (functions, variables, types)
-- Background daemon for fast repeated requests
-- Built in Claude Code hook to provide feedback on file edit tool calls
-- Comprehensive daemon management (`list`, `stop-all` commands)
-- Multi-project support with isolated daemon instances per directory
-- [Custom language server support via config files](#custom-language-servers-config-file)
-
-## 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`)                                                                 |
-| GraphQL               | `graphql-language-service-cli` | ✓ (via bunx)                         | `.graphql`, `.gql`                                                                                                                           |
-| **R**                 | **R languageserver**           | **✗**                                | **`.r`, `.R`, `.rmd`, `.Rmd` - see [R Installation](#r-installation-guide) below**                                                           |
-| **C#**                | **OmniSharp-Roslyn**           | **✗**                                | **`.cs` - see [C# Installation](#c-installation-guide) below**                                                                               |
-| **Swift**             | **SourceKit-LSP**              | **✗**                                | **`.swift` - see [Swift Configuration](#swift-configuration) below**                                                                         |
-| 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
-
-### MCP Server
-
-Add as an MCP server to enable Claude to access symbol definitions and hover information:
-
-```bash
-claude mcp add lsp --scope user -- bunx cli-lsp-client mcp-server
-```
-
-### Real-time Diagnostics Hook
-
-Get instant diagnostic feedback for TypeScript, Python, JSON, CSS, YAML, Bash, GraphQL, R, C#, Swift, Go, Java, and Lua files as you edit in Claude Code.
-
-#### Setup
-
-Configure Claude Code to use the built-in hook command:
-
-```json
-{
-  "$schema": "https://json.schemastore.org/claude-code-settings.json",
-  "hooks": {
-    "SessionStart": [
-      {
-        "matcher": "startup|resume",
-        "hooks": [
-          {
-            "type": "command",
-            "command": "npx -y cli-lsp-client start"
-          }
-        ]
-      }
-    ],
-    "PostToolUse": [
-      {
-        "matcher": "Edit|MultiEdit|Write",
-        "hooks": [
-          {
-            "type": "command",
-            "command": "npx -y cli-lsp-client claude-code-hook"
-          }
-        ]
-      }
-    ]
-  }
-}
-```
-
-#### How It Works
-
-- **SessionStart**: Automatically starts LSP servers when Claude Code starts for faster initial diagnostics
-- **PostToolUse**: Runs diagnostics after each file edit (Edit, MultiEdit, Write tools)
-- Built-in file filtering for all supported languages (16 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
-```
-
-## Custom Language Servers (Config File)
-
-You can extend the built-in language servers by creating a custom configuration file. This allows you to add support for any LSP server not included by default.
-
-### Configuration File
-
-Create a config file at `~/.config/cli-lsp-client/settings.json` (default location) or use `--config-file` to specify a custom path:
-
-```json
-{
-  "servers": [
-    {
-      "id": "svelte",
-      "extensions": [".svelte"],
-      "rootPatterns": ["svelte.config.js", "package.json"],
-      "command": ["bunx", "svelte-language-server", "--stdio"],
-      "env": {
-        "NODE_ENV": "development"
-      },
-      "initialization": {
-        "settings": {
-          "svelte": {
-            "compilerWarnings": true
-          }
-        }
-      }
-    }
-  ],
-  "languageExtensions": {
-    ".svelte": "svelte"
-  }
-}
-```
-
-### Using Custom Config
-
-**Default config file location:**
-
-```bash
-# Uses ~/.config/cli-lsp-client/settings.json automatically
-npx cli-lsp-client diagnostics Component.svelte
-```
-
-**Custom config file location:**
-
-```bash
-# Specify custom config file path
-npx cli-lsp-client --config-file ./my-config.json diagnostics Component.svelte
-npx cli-lsp-client --config-file ./my-config.json hover Component.svelte myFunction
-npx cli-lsp-client --config-file ./my-config.json status
-```
-
-**Important:** When using `--config-file`, you must include it on every command. The CLI automatically restarts the daemon when switching between different config files to ensure the correct language servers are loaded.
-
-### Config File Schema
-
-- `servers`: Array of custom language server definitions
-  - `id`: Unique identifier for the server
-  - `extensions`: File extensions this server handles (e.g. `[".svelte"]`)
-  - `rootPatterns`: Files/patterns used to detect project root (e.g. `["package.json"]`)
-  - `command`: Command array to start the LSP server (e.g. `["bunx", "svelte-language-server", "--stdio"]`)
-  - `env`: Optional environment variables for the server process
-  - `initialization`: Optional LSP initialization parameters
-
-- `languageExtensions`: Maps file extensions to LSP language identifiers
-
-## 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
-npx cli-lsp-client diagnostics analysis.R
-npx cli-lsp-client diagnostics Program.cs
-
-# Check Swift files (requires config file)
-npx cli-lsp-client diagnostics Sources/App/main.swift
-```
-
-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
-```
-
-### Get Hover Information
-
-```bash
-# Get hover info for a function
-npx cli-lsp-client hover src/main.ts myFunction
-
-# Get hover info for a variable or type
-npx cli-lsp-client hover app.py MyClass
-npx cli-lsp-client hover analysis.R mean
-npx cli-lsp-client hover Program.cs Console
-
-# Get hover info for Swift symbols (requires config file)
-npx cli-lsp-client hover Sources/App/main.swift greetUser
-```
-
-````bash
-$ npx cli-lsp-client hover src/client.ts runCommand
-Location: src/client.ts:370:17
-```typescript
-export function runCommand(command: string, commandArgs: string[]): Promise<void>
-````
-
-````
-
-### Daemon Management
-
-```bash
-# Check daemon status with uptime and running language servers
-npx cli-lsp-client status
-
-# List all running daemons across directories
-npx cli-lsp-client list
-
-# Stop current directory's daemon
-npx cli-lsp-client stop
-
-# Stop all daemons across all directories (useful after package updates)
-npx cli-lsp-client stop-all
-
-# Show version
-npx cli-lsp-client --version
-
-# Show help
-npx cli-lsp-client help
-````
-
-The `status` command shows the current daemon's uptime and running language servers:
-
-```bash
-$ npx cli-lsp-client status
-LSP Daemon Status
-================
-PID: 33502
-Uptime: 1m 38s
-
-Language Servers:
-- typescript (.) - running 1m 33s
-- pyright (.) - running 1m 10s
-
-Total: 2 language servers running
-```
-
-The `list` command shows all running daemon instances with their working directories, PIDs, and status:
-
-```bash
-$ npx cli-lsp-client list
-
-Running Daemons:
-================
-Hash   | PID   | Status    | Working Directory
-----------------------------------------------------------
-h0gx9u | 12345 | ● Running | /Users/user/project-a
-94yi9w | 12346 | ● Running | /Users/user/project-b
-
-2/2 daemon(s) running
-```
-
-Use `stop-all` when updating the CLI package to ensure all old daemon processes are terminated and fresh ones spawn with the updated code.
-
-## 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).
-
-## R Installation Guide
-
-The R language server requires R runtime and the `languageserver` package:
-
-### Installation Steps
-
-1. **Install R**: Download and install R from [CRAN](https://cran.r-project.org/) or use a package manager:
-
-   **macOS (Homebrew)**:
-
-   ```bash
-   brew install r
-   ```
-
-   **Ubuntu/Debian**:
-
-   ```bash
-   sudo apt-get update
-   sudo apt-get install r-base
-   ```
-
-   **Windows**: Download installer from [CRAN Windows](https://cran.r-project.org/bin/windows/base/)
-
-2. **Install R languageserver package**: Open R and run:
-
-   ```r
-   install.packages("languageserver")
-   ```
-
-   Or from command line:
-
-   ```bash
-   R --slave -e 'install.packages("languageserver", repos="https://cran.rstudio.com/")'
-   ```
-
-### Verification
-
-Test that the language server works:
-
-```bash
-R --slave -e 'languageserver::run()'
-```
-
-### Project Detection
-
-The R LSP automatically detects R projects based on these files:
-
-- `DESCRIPTION` (R packages)
-- `NAMESPACE` (R packages)
-- `.Rproj` (RStudio projects)
-- `renv.lock` (renv dependency management)
-- Any `.r`, `.R`, `.rmd`, `.Rmd` files
-
-For more information, see the [R languageserver documentation](https://github.com/REditorSupport/languageserver).
-
-## C# Installation Guide
-
-The C# language server requires .NET SDK and OmniSharp-Roslyn:
-
-### Installation Steps
-
-1. **Install .NET SDK**: Download .NET 6.0+ from [Microsoft .NET](https://dotnet.microsoft.com/download) or use a package manager:
-
-   **macOS (Homebrew)**:
-
-   ```bash
-   brew install dotnet
-   ```
-
-   **Ubuntu/Debian**:
-
-   ```bash
-   # Add Microsoft package repository
-   wget https://packages.microsoft.com/config/ubuntu/$(lsb_release -rs)/packages-microsoft-prod.deb -O packages-microsoft-prod.deb
-   sudo dpkg -i packages-microsoft-prod.deb
-   sudo apt-get update
-   sudo apt-get install -y dotnet-sdk-8.0
-   ```
-
-   **Windows**: Download installer from [.NET Downloads](https://dotnet.microsoft.com/download)
-
-2. **Install OmniSharp-Roslyn**: Download the latest release from [OmniSharp releases](https://github.com/OmniSharp/omnisharp-roslyn/releases):
-
-   **Automatic script** (recommended):
-
-   ```bash
-   # Download and extract OmniSharp to ~/.omnisharp/
-   mkdir -p ~/.omnisharp
-   curl -L https://github.com/OmniSharp/omnisharp-roslyn/releases/latest/download/omnisharp-osx-arm64-net6.0.tar.gz | tar -xz -C ~/.omnisharp/
-
-   # Create symlink to make omnisharp available in PATH
-   sudo ln -sf ~/.omnisharp/OmniSharp /usr/local/bin/omnisharp
-   ```
-
-   **Manual installation**:
-   - Download the appropriate release for your platform (Windows: `omnisharp-win-x64-net6.0.zip`, Linux: `omnisharp-linux-x64-net6.0.tar.gz`)
-   - Extract to a directory (e.g., `~/.omnisharp/`)
-   - Add the executable to your PATH or create a symlink
-
-3. **Set environment variables**:
-
-   **Fish shell**:
-
-   ```bash
-   set -Ux DOTNET_ROOT ~/.dotnet
-   ```
-
-   **Bash/Zsh**:
-
-   ```bash
-   echo 'export DOTNET_ROOT=~/.dotnet' >> ~/.bashrc  # or ~/.zshrc
-   source ~/.bashrc  # or ~/.zshrc
-   ```
-
-   **Note**: `DOTNET_ROOT` must be set in your shell environment for the C# language server to work. The CLI will only load OmniSharp if this environment variable is defined. Restart your terminal after setting the environment variable to ensure it's available.
-
-### Verification
-
-Test that OmniSharp works:
-
-```bash
-# Verify DOTNET_ROOT is set
-echo $DOTNET_ROOT
-
-# Test OmniSharp command
-omnisharp --help
-```
-
-### Project Detection
-
-The C# LSP automatically detects C# projects based on these files:
-
-- `*.sln` (Solution files)
-- `*.csproj` (Project files)
-- `project.json` (Legacy project files)
-- `global.json` (.NET global configuration)
-- Any `.cs` files
-
-For more information, see the [OmniSharp documentation](https://github.com/OmniSharp/omnisharp-roslyn).
-
-## Swift Configuration
-
-Swift language support is available through SourceKit-LSP, which is included with Xcode Command Line Tools. Support for swift and other LSPs can be added via a config file.
-
-### Prerequisites
-
-**macOS (with Xcode Command Line Tools)**:
-
-```bash
-# Check if SourceKit-LSP is available
-xcrun --find sourcekit-lsp
-```
-
-**Alternative toolchains**: If using Swift toolchains from swift.org, SourceKit-LSP is included and can be run with:
-
-```bash
-xcrun --toolchain swift sourcekit-lsp
-```
-
-### Configuration
-
-Create a config file at `~/.config/cli-lsp-client/settings.json`:
-
-```json
-{
-  "servers": [
-    {
-      "id": "sourcekit_lsp",
-      "extensions": [".swift"],
-      "rootPatterns": ["Package.swift", ".xcodeproj", ".xcworkspace"],
-      "command": ["xcrun", "sourcekit-lsp"],
-      "env": {}
-    }
-  ],
-  "languageExtensions": {
-    ".swift": "swift"
-  }
-}
-```
-
-For more information about SourceKit-LSP, see the [official documentation](https://github.com/swiftlang/sourcekit-lsp).
-
-### Additional Commands
-
-```bash
-# Start LSP servers for current directory (faster subsequent requests)
-npx cli-lsp-client start
-
-# Start servers for specific directory
-npx cli-lsp-client start /path/to/project
-
-# View daemon log file path
-npx cli-lsp-client logs
-```
-
-## Examples
-
-```bash
-# Check a specific file
-npx cli-lsp-client diagnostics src/main.ts
-
-# Get hover info for a symbol
-npx cli-lsp-client hover src/main.ts myFunction
-
-# List all daemon instances
-npx cli-lsp-client list
-
-# Stop all daemons after package update
-npx cli-lsp-client stop-all
-```
-
-## 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/src/cli.ts

@@ -1,236 +0,0 @@
-#!/usr/bin/env bun
-
-import path from 'path';
-import { z } from 'zod';
-import { startDaemon } from './daemon.js';
-import { runCommand, sendToExistingDaemon } from './client.js';
-import { formatDiagnosticsPlain } from './lsp/formatter.js';
-import type { Diagnostic } from './lsp/types.js';
-import { HELP_MESSAGE } from './constants.js';
-import { ensureDaemonRunning } from './utils.js';
-import { startMcpServer } from './mcp/server.js';
-import packageJson from '../package.json' with { type: 'json' };
-
-// Schema for Claude Code PostToolUse hook payload
-const HookDataSchema = z.object({
-  session_id: z.string().optional(),
-  transcript_path: z.string().optional(),
-  cwd: z.string().optional(),
-  hook_event_name: z.string().optional(),
-  tool_name: z.string().optional(),
-  tool_input: z
-    .object({
-      file_path: z.string().optional(),
-      content: z.string().optional(),
-    })
-    .optional(),
-  tool_response: z.any().optional(),
-});
-
-export async function handleClaudeCodeHook(
-  filePath: string
-): Promise<{ hasIssues: boolean; output: string; daemonFailed?: boolean }> {
-  // 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',
-    '.r',
-    '.R',
-    '.rmd',
-    '.Rmd',
-    '.cs',
-  ];
-  const ext = path.extname(filePath);
-  if (!supportedExts.includes(ext)) {
-    return { hasIssues: false, output: '' };
-  }
-
-  // Get diagnostics (suppress errors to stdout)
-  try {
-    // Ensure daemon is running
-    const daemonStarted = await ensureDaemonRunning();
-
-    if (!daemonStarted) {
-      // Failed to start daemon - return with flag so caller can handle
-      return {
-        hasIssues: false,
-        output:
-          'Failed to start LSP daemon. Please try running "cli-lsp-client stop" and retry.',
-        daemonFailed: true,
-      };
-    }
-
-    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: '' };
-  }
-}
-
-function showHelp(): void {
-  process.stdout.write(HELP_MESSAGE + '\n');
-}
-
-type ParsedArgs = {
-  command: string;
-  commandArgs: string[];
-  configFile?: string;
-};
-
-function parseArgs(args: string[]): ParsedArgs {
-  let configFile: string | undefined;
-  const filteredArgs: string[] = [];
-  
-  for (let i = 0; i < args.length; i++) {
-    const arg = args[i];
-    
-    if (arg === '--config-file') {
-      if (i + 1 >= args.length) {
-        process.stderr.write('Error: --config-file requires a path argument\n');
-        process.exit(1);
-      }
-      configFile = args[i + 1];
-      i++; // Skip the next argument since it's the config file path
-    } else if (arg.startsWith('--config-file=')) {
-      configFile = arg.split('=', 2)[1];
-      if (!configFile) {
-        process.stderr.write('Error: --config-file= requires a path after the equals sign\n');
-        process.exit(1);
-      }
-    } else {
-      filteredArgs.push(arg);
-    }
-  }
-  
-  const command = filteredArgs[0] || 'status';
-  const commandArgs = filteredArgs.slice(1);
-  
-  return { command, commandArgs, configFile };
-}
-
-async function run(): Promise<void> {
-  const rawArgs = process.argv.slice(2);
-  const { command, commandArgs, configFile } = parseArgs(rawArgs);
-
-  // Check if we're being invoked to run as daemon
-  if (process.env.LSPCLI_DAEMON_MODE === '1') {
-    await startDaemon();
-    return;
-  }
-
-  // Handle help command directly (no daemon needed)
-  if (command === 'help' || command === '--help' || command === '-h') {
-    showHelp();
-    return;
-  }
-
-  // Handle version command directly (no daemon needed)
-  if (command === 'version' || command === '--version' || command === '-v') {
-    process.stdout.write(packageJson.version + '\n');
-    return;
-  }
-
-  // Handle mcp-server command directly (starts MCP server)
-  if (command === 'mcp-server') {
-    await startMcpServer();
-    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 parseResult = HookDataSchema.safeParse(JSON.parse(stdinData));
-      if (!parseResult.success) {
-        process.exit(0); // Invalid JSON format, silently exit
-      }
-      const hookData = parseResult.data;
-      // Extract file_path from PostToolUse tool_input
-      const filePath = hookData.tool_input?.file_path;
-
-      if (!filePath) {
-        process.exit(0); // No file path, silently exit
-      }
-
-      const result = await handleClaudeCodeHook(filePath);
-      if (result.daemonFailed) {
-        // Daemon failed to start - exit with status 1 to show error to user
-        process.stderr.write(result.output + '\n');
-        process.exit(1);
-      }
-      if (result.hasIssues) {
-        process.stderr.write(result.output + '\n');
-        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, configFile);
-}
-
-export { run };
-
-if (import.meta.main) {
-  run();
-}