claude-git-hooks 2.33.0 → 2.33.1

package/CHANGELOG.md

@@ -5,6 +5,19 @@ Todos los cambios notables en este proyecto se documentarán en este archivo.
 El formato está basado en [Keep a Changelog](https://keepachangelog.com/en/1.0.0/),
 y este proyecto adhiere a [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
 
+## [2.33.1] - 2026-03-26
+
+### 🔧 Changed
+- Improved WSL Claude CLI detection to resolve Claude's path via login shell when installed via nvm or user-scoped npm prefix
+- Added support for detecting Claude CLI in non-default WSL distros when the default distro is docker-desktop or similar
+- Switched to execFileSync for WSL distro listing to avoid cmd.exe quote mangling issues
+- Updated README-NPM with release workflow commands documentation and WSL troubleshooting guide
+
+### 🐛 Fixed
+- Fixed Claude CLI not being detected on Windows when running from Git Bash with Claude installed inside WSL via nvm (#120)
+- Fixed WSL distro detection failing due to UTF-16LE encoding from wsl.exe output
+
+
 ## [2.33.0] - 2026-03-20
 
 ### ✨ Added

package/lib/commands/helpers.js

@@ -18,6 +18,7 @@ import os from 'os';
 import https from 'https';
 import { fileURLToPath } from 'url';
 import { dirname } from 'path';
+import { getRunningWSLDistros } from '../utils/claude-client.js';
 
 // Why: ES6 modules don't have __dirname, need to recreate it
 const __filename = fileURLToPath(import.meta.url);
@@ -130,9 +131,46 @@ export function isWindows() {
     return os.platform() === 'win32' || process.env.OS === 'Windows_NT';
 }
 
+/**
+ * Resolve Claude's absolute path inside WSL via login shell
+ * Why: If Claude is installed via nvm or user-scoped npm prefix in WSL,
+ * it's only in PATH when .bashrc/.profile is sourced (login/interactive shell).
+ * A bare `wsl claude` runs a non-interactive shell that skips profile loading.
+ *
+ * @param {string|null} distro - WSL distro name (null = default distro)
+ * @returns {string|null} Absolute Linux path to claude binary, or null
+ */
+export function resolveClaudePathInWSL(distro = null) {
+    const distroFlag = distro ? `-d "${distro}" ` : '';
+    try {
+        const resolvedPath = execSync(`wsl ${distroFlag}bash -lc "which claude"`, {
+            encoding: 'utf8',
+            stdio: ['pipe', 'pipe', 'ignore'],
+            timeout: 10000
+        }).trim();
+
+        if (resolvedPath && resolvedPath.startsWith('/')) {
+            // Verify the resolved path actually works
+            execSync(`wsl ${distroFlag}${resolvedPath} --version`, {
+                stdio: 'ignore',
+                timeout: 10000
+            });
+            return resolvedPath;
+        }
+        return null;
+    } catch (e) {
+        return null;
+    }
+}
+
 /**
  * Get Claude command based on platform
  * Why: On Windows, try native Claude first, then WSL as fallback
+ * Strategy:
+ *   1. Native Windows `claude` (installed via npm/scoop/choco on Windows)
+ *   2. Direct `wsl claude` (Claude in WSL default PATH)
+ *   3. WSL login-shell resolution (Claude installed via nvm or custom PATH in WSL)
+ *   4. Non-default distro scan (default may be docker-desktop, not Ubuntu)
  * @returns {string}
  */
 export function getClaudeCommand() {
@@ -142,8 +180,37 @@ export function getClaudeCommand() {
             execSync('claude --version', { stdio: 'ignore', timeout: 3000 });
             return 'claude';
         } catch (e) {
-            // Fallback to WSL
-            return 'wsl claude';
+            // Try direct WSL (Claude in default non-interactive PATH)
+            try {
+                execSync('wsl claude --version', { stdio: 'ignore', timeout: 10000 });
+                return 'wsl claude';
+            } catch (e2) {
+                // Try WSL with login shell (Claude installed via nvm or custom PATH)
+                const resolvedPath = resolveClaudePathInWSL();
+                if (resolvedPath) {
+                    return `wsl ${resolvedPath}`;
+                }
+
+                // Strategy 4: Non-default WSL distro (e.g., default is docker-desktop)
+                const distros = getRunningWSLDistros('wsl');
+                for (const distro of distros) {
+                    try {
+                        execSync(`wsl -d "${distro}" claude --version`, {
+                            stdio: 'ignore',
+                            timeout: 10000
+                        });
+                        return `wsl -d "${distro}" claude`;
+                    } catch (distroError) {
+                        const resolved = resolveClaudePathInWSL(distro);
+                        if (resolved) {
+                            return `wsl -d "${distro}" ${resolved}`;
+                        }
+                    }
+                }
+
+                // All attempts failed — return best-effort fallback
+                return 'wsl claude';
+            }
         }
     }
     return 'claude';

package/lib/utils/claude-client.js

@@ -15,7 +15,7 @@
  * - claude-diagnostics: Error detection and formatting
  */
 
-import { spawn, execSync } from 'child_process';
+import { spawn, execSync, execFileSync } from 'child_process';
 import fs from 'fs/promises';
 import path from 'path';
 import os from 'os';
@@ -70,6 +70,37 @@ const isWSLAvailable = () => {
     }
 };
 
+/**
+ * Get running WSL distros, excluding Docker-internal ones
+ * Why: The default WSL distro may be docker-desktop (which doesn't have Claude).
+ * We need to find the actual Linux distro (e.g., Ubuntu) where Claude is installed.
+ *
+ * @param {string} wslPath - Absolute path to wsl.exe
+ * @returns {string[]} List of running non-Docker distro names
+ */
+export const getRunningWSLDistros = (wslPath) => {
+    try {
+        // Use execFileSync to bypass cmd.exe shell quoting — args passed directly to wsl.exe
+        const raw = execFileSync(wslPath, ['-l', '--running', '-q'], {
+            timeout: 5000,
+            stdio: ['pipe', 'pipe', 'ignore']
+        });
+        // Why UTF-16LE: wsl.exe is a native Windows executable that outputs Unicode in Windows' default
+        // encoding (UTF-16LE), not UTF-8. The null bytes (\0) are BOM artifacts and padding characters
+        // from the UTF-16LE encoding that must be stripped to get clean distro names.
+        const output = raw.toString('utf16le');
+        return output
+            .split(/\r?\n/)
+            .map((s) => s.replace(/\0/g, '').trim())
+            .filter((s) => s && !s.toLowerCase().includes('docker'));
+    } catch (e) {
+        logger.debug('claude-client - getRunningWSLDistros', 'Failed to list WSL distros', {
+            error: e.message
+        });
+        return [];
+    }
+};
+
 /**
  * Get Claude command configuration for current platform
  * Why: On Windows, try native Claude first, then WSL as fallback
@@ -112,11 +143,12 @@ const getClaudeCommand = () => {
         // Node 24: Resolve wsl.exe absolute path to avoid shell: true
         const wslPath = which('wsl');
         if (wslPath) {
+            const wslCheckTimeout = config.system.wslCheckTimeout || 15000;
+
+            // Strategy 1: Direct `wsl claude` (Claude in default non-interactive PATH)
+            // Use execFileSync to bypass cmd.exe — args passed directly to wsl.exe without quote mangling
             try {
-                // Verify Claude exists in WSL
-                // Increased timeout from 5s to 15s to handle system load better
-                const wslCheckTimeout = config.system.wslCheckTimeout || 15000;
-                execSync(`"${wslPath}" claude --version`, {
+                execFileSync(wslPath, ['claude', '--version'], {
                     stdio: 'ignore',
                     timeout: wslCheckTimeout
                 });
@@ -125,11 +157,9 @@ const getClaudeCommand = () => {
                 });
                 return { command: wslPath, args: ['claude'] };
             } catch (wslError) {
-                // Differentiate error types for accurate user feedback
                 const errorMsg = wslError.message || '';
-                const wslCheckTimeout = config.system.wslCheckTimeout || 15000;
 
-                // Timeout: Transient system load issue
+                // Timeout: Transient system load issue — don't try fallback
                 if (errorMsg.includes('ETIMEDOUT')) {
                     throw new ClaudeClientError(
                         'Timeout connecting to WSL - system under heavy load',
@@ -146,30 +176,132 @@ const getClaudeCommand = () => {
                     );
                 }
 
-                // Not found: Claude CLI missing in WSL
-                if (errorMsg.includes('ENOENT') || errorMsg.includes('command not found')) {
-                    throw new ClaudeClientError('Claude CLI not found in WSL', {
-                        context: {
-                            platform: 'Windows',
-                            wslPath,
-                            error: 'ENOENT',
-                            suggestion:
-                                'Install Claude in WSL: wsl -e bash -c "npm install -g @anthropic-ai/claude-cli"'
-                        }
+                // Not a timeout — try login-shell fallback below
+                logger.debug(
+                    'claude-client - getClaudeCommand',
+                    'Direct wsl claude failed, trying login-shell resolution',
+                    { error: errorMsg }
+                );
+            }
+
+            // Strategy 2: WSL login-shell resolution (Claude installed via nvm or custom PATH)
+            // Why: `wsl claude` runs a non-interactive shell that doesn't source .bashrc/.profile,
+            // so Claude installed via nvm or user-scoped npm prefix won't be in PATH.
+            // `bash -lc "which claude"` sources the login profile to resolve the full path.
+            // Why execFileSync: cmd.exe strips inner quotes from `bash -lc "which claude"`,
+            // causing bash to receive `which` and `claude` as separate args. execFileSync bypasses
+            // cmd.exe and passes arguments directly, preserving multi-word argument boundaries.
+            try {
+                const resolvedPath = execFileSync(
+                    wslPath,
+                    ['bash', '-lc', 'which claude'],
+                    {
+                        encoding: 'utf8',
+                        stdio: ['pipe', 'pipe', 'ignore'],
+                        timeout: wslCheckTimeout
+                    }
+                ).trim();
+
+                if (resolvedPath && resolvedPath.startsWith('/')) {
+                    // Verify: run the resolved path via login shell (node may also require login shell)
+                    execFileSync(wslPath, ['bash', '-lc', `${resolvedPath} --version`], {
+                        stdio: 'ignore',
+                        timeout: wslCheckTimeout
                     });
+                    logger.debug(
+                        'claude-client - getClaudeCommand',
+                        'Using WSL Claude CLI via login-shell resolution',
+                        { wslPath, claudePath: resolvedPath }
+                    );
+                    // Return loginShell so executeClaude wraps the call in bash -lc
+                    return { command: wslPath, args: [], loginShell: { path: resolvedPath } };
                 }
+            } catch (loginShellError) {
+                logger.debug(
+                    'claude-client - getClaudeCommand',
+                    'WSL login-shell resolution failed',
+                    { error: loginShellError.message }
+                );
+            }
 
-                // Generic error: Other WSL issues
-                throw new ClaudeClientError('Failed to verify Claude CLI in WSL', {
-                    context: {
-                        platform: 'Windows',
-                        wslPath,
-                        error: errorMsg,
-                        suggestion:
-                            'Check WSL is functioning: wsl --version, or skip analysis: git commit --no-verify'
+            // Strategy 3: Non-default WSL distro (e.g., default is docker-desktop)
+            // Why: If the default WSL distro is docker-desktop or another minimal distro,
+            // Claude may be installed in a different distro like Ubuntu.
+            const distros = getRunningWSLDistros(wslPath);
+            logger.debug(
+                'claude-client - getClaudeCommand',
+                'Trying non-default WSL distros',
+                { distros }
+            );
+
+            for (const distro of distros) {
+                // Try direct call in this distro
+                try {
+                    execFileSync(wslPath, ['-d', distro, 'claude', '--version'], {
+                        stdio: 'ignore',
+                        timeout: wslCheckTimeout
+                    });
+                    logger.debug(
+                        'claude-client - getClaudeCommand',
+                        'Using WSL Claude CLI in distro',
+                        { wslPath, distro }
+                    );
+                    return { command: wslPath, args: ['-d', distro, 'claude'] };
+                } catch (distroError) {
+                    // Try login-shell resolution in this distro
+                    try {
+                        const resolved = execFileSync(
+                            wslPath,
+                            ['-d', distro, 'bash', '-lc', 'which claude'],
+                            {
+                                encoding: 'utf8',
+                                stdio: ['pipe', 'pipe', 'ignore'],
+                                timeout: wslCheckTimeout
+                            }
+                        ).trim();
+
+                        if (resolved && resolved.startsWith('/')) {
+                            execFileSync(
+                                wslPath,
+                                ['-d', distro, 'bash', '-lc', `${resolved} --version`],
+                                {
+                                    stdio: 'ignore',
+                                    timeout: wslCheckTimeout
+                                }
+                            );
+                            logger.debug(
+                                'claude-client - getClaudeCommand',
+                                'Using WSL Claude CLI via login-shell in distro',
+                                { wslPath, distro, claudePath: resolved }
+                            );
+                            // Return loginShell so executeClaude wraps the call in bash -lc
+                            return {
+                                command: wslPath,
+                                args: ['-d', distro],
+                                loginShell: { path: resolved }
+                            };
+                        }
+                    } catch (distroLoginError) {
+                        logger.debug(
+                            'claude-client - getClaudeCommand',
+                            `Distro ${distro} does not have Claude`,
+                            { error: distroLoginError.message }
+                        );
                     }
-                });
+                }
             }
+
+            // All strategies failed
+            throw new ClaudeClientError('Claude CLI not found in WSL', {
+                context: {
+                    platform: 'Windows',
+                    wslPath,
+                    error: 'Claude not found via direct call or login-shell resolution',
+                    triedDistros: distros,
+                    suggestion:
+                        'Install Claude in WSL: wsl -e bash -c "npm install -g @anthropic-ai/claude-cli"'
+                }
+            });
         }
 
         throw new ClaudeClientError('Claude CLI not found in Windows or WSL', {
@@ -212,18 +344,26 @@ const getClaudeCommand = () => {
 const executeClaude = (prompt, { timeout = 120000, allowedTools = [], model = null } = {}) =>
     new Promise((resolve, reject) => {
         // Get platform-specific command
-        const { command, args } = getClaudeCommand();
+        const { command, args, loginShell } = getClaudeCommand();
 
-        // Add allowed tools if specified (for MCP tools)
+        // Build final args — handling differs for login-shell (WSL via bash -lc) vs direct invocation
         const finalArgs = [...args];
-        if (allowedTools.length > 0) {
-            // Format: --allowedTools "mcp__github__create_pull_request,mcp__github__get_file_contents"
-            finalArgs.push('--allowedTools', allowedTools.join(','));
-        }
-
-        // Add model override if specified
-        if (model) {
-            finalArgs.push('--model', model);
+        if (loginShell) {
+            // Why: When claude is found via WSL login-shell (e.g. nvm-installed node), it must be
+            // executed inside bash --login so that .profile/.bashrc set up the correct PATH.
+            // All CLI flags are embedded in the bash -c command string (no spaces in flag values).
+            const claudeParts = [loginShell.path];
+            if (allowedTools.length > 0) claudeParts.push(`--allowedTools ${allowedTools.join(',')}`);
+            if (model) claudeParts.push(`--model ${model}`);
+            finalArgs.push('bash', '-lc', claudeParts.join(' '));
+        } else {
+            if (allowedTools.length > 0) {
+                // Format: --allowedTools "mcp__github__create_pull_request,mcp__github__get_file_contents"
+                finalArgs.push('--allowedTools', allowedTools.join(','));
+            }
+            if (model) {
+                finalArgs.push('--model', model);
+            }
         }
 
         // CRITICAL FIX: Windows .cmd/.bat file handling

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "claude-git-hooks",
-    "version": "2.33.0",
+    "version": "2.33.1",
     "description": "Git hooks with Claude CLI for code analysis and automatic commit messages",
     "type": "module",
     "bin": {