cli-lsp-client 1.5.0 → 1.7.0

package/README.md

@@ -10,26 +10,30 @@ CLI tool for getting LSP diagnostics. Uses a background daemon to keep LSP serve
 - 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`) |
-| 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) |
-
+| 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  
+- LSP servers spawn based on file type
 - Finds project roots using config files (tsconfig.json, etc.)
 - Servers stay running for subsequent requests
 
@@ -37,7 +41,7 @@ CLI tool for getting LSP diagnostics. Uses a background daemon to keep LSP serve
 
 ### 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.
+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
 
@@ -77,7 +81,7 @@ Configure Claude Code to use the built-in hook command:
 
 - **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 (11 file types)
+- 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
@@ -88,13 +92,79 @@ When you save a file with errors, you'll see immediate feedback:
 
 ```
 Edit operation feedback:
-- [npx -y cli-lsp-client claude-code-hook]: 
+- [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
@@ -106,6 +176,11 @@ 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.
@@ -126,15 +201,21 @@ 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
+````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
 
@@ -156,7 +237,7 @@ 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:
 
@@ -181,7 +262,7 @@ $ npx cli-lsp-client list
 
 Running Daemons:
 ================
-Hash   | PID   | Status    | Working Directory             
+Hash   | PID   | Status    | Working Directory
 ----------------------------------------------------------
 h0gx9u | 12345 | ● Running | /Users/user/project-a
 94yi9w | 12346 | ● Running | /Users/user/project-b
@@ -220,11 +301,13 @@ java -Declipse.application=org.eclipse.jdt.ls.core.id1 \
 ### Alternative Installation Methods
 
 **Homebrew (macOS/Linux)**:
+
 ```bash
 brew install jdtls
 ```
 
 **Arch Linux**:
+
 ```bash
 pacman -S jdtls
 ```
@@ -237,6 +320,188 @@ pacman -S jdtls
 
 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
@@ -246,7 +511,7 @@ npx cli-lsp-client start
 # Start servers for specific directory
 npx cli-lsp-client start /path/to/project
 
-# View daemon logs
+# View daemon log file path
 npx cli-lsp-client logs
 ```
 

package/package.json

@@ -1,43 +1,52 @@
 {
   "name": "cli-lsp-client",
-  "version": "1.5.0",
-  "description": "CLI tool for fast LSP diagnostics with background daemon and multi-project support",
-  "type": "module",
+  "version": "1.7.0",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/eli0shin/cli-lsp-client.git"
+  },
   "main": "src/cli.ts",
-  "license": "MIT",
+  "devDependencies": {
+    "@eslint/js": "^9.33.0",
+    "@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": "^4.0.17"
+  },
   "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"
   ],
-  "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"
-  },
+  "license": "MIT",
   "scripts": {
     "build": "bun build src/cli.ts --compile --outfile cli-lsp-client",
     "dev": "bun run src/cli.ts",
-    "typecheck": "bun --bun tsc --noEmit",
+    "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",
-    "prepublish": "bun test && bun run build"
+    "prepublishOnly": "bun test && bun run build",
+    "postinstall": "node scripts/postinstall.js"
   },
-  "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"
-  }
+  "type": "module"
 }

package/src/cli.ts

@@ -1,6 +1,7 @@
 #!/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';
@@ -9,70 +10,146 @@ import { HELP_MESSAGE } from './constants.js';
 import { ensureDaemonRunning } from './utils.js';
 import packageJson from '../package.json' with { type: 'json' };
 
-export async function handleClaudeCodeHook(filePath: string): Promise<{ hasIssues: boolean; output: string; daemonFailed?: boolean }> {
+// 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()) {
+  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',
+    '.ts',
+    '.tsx',
+    '.js',
+    '.jsx',
+    '.mjs',
+    '.cjs',
+    '.mts',
+    '.cts',
+    '.py',
+    '.pyi',
     '.go',
-    '.json', '.jsonc',
-    '.css', '.scss', '.sass', '.less',
-    '.yaml', '.yml',
-    '.sh', '.bash', '.zsh',
+    '.json',
+    '.jsonc',
+    '.css',
+    '.scss',
+    '.sass',
+    '.less',
+    '.yaml',
+    '.yml',
+    '.sh',
+    '.bash',
+    '.zsh',
     '.java',
     '.lua',
-    '.graphql', '.gql'
+    '.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 
+      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) {
+  } catch (_error) {
     // Silently fail - don't break Claude Code experience
     return { hasIssues: false, output: '' };
   }
 }
 
 function showHelp(): void {
-  console.log(HELP_MESSAGE);
+  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 args = process.argv.slice(2);
-  const command = args[0] || 'status';
-  const commandArgs = args.slice(1);
+  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') {
@@ -88,7 +165,7 @@ async function run(): Promise<void> {
 
   // Handle version command directly (no daemon needed)
   if (command === 'version' || command === '--version' || command === '-v') {
-    console.log(packageJson.version);
+    process.stdout.write(packageJson.version + '\n');
     return;
   }
 
@@ -112,10 +189,14 @@ async function run(): Promise<void> {
       }
 
       // 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;
-      
+      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
       }
@@ -123,22 +204,22 @@ async function run(): Promise<void> {
       const result = await handleClaudeCodeHook(filePath);
       if (result.daemonFailed) {
         // Daemon failed to start - exit with status 1 to show error to user
-        console.error(result.output);
+        process.stderr.write(result.output + '\n');
         process.exit(1);
       }
       if (result.hasIssues) {
-        console.error(result.output);
+        process.stderr.write(result.output + '\n');
         process.exit(2);
       }
       process.exit(0);
-    } catch (error) {
+    } 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);
+  await runCommand(command, commandArgs, configFile);
 }
 
 export { run };