fix: resolve command registration conflict causing LSP client startup failure

- Fixed duplicate command registration between LSP server and extension
- LSP server handles 'just-lsp.run_recipe' for internal protocol communication
- Extension provides 'justlang-lsp.run_recipe' for command palette access
- Added comprehensive documentation explaining both command systems
- Enhanced error logging for better debugging
- Added just-lsp-installer for improved server detection and installation

🤖 Generated with [Claude Code](https://claude.ai/code)

Co-Authored-By: Claude <[email protected]>

Author: elasticdotventures

README.md

@@ -1,9 +1,20 @@
 # JustLang-LSP Extension
 
 ## Overview
+
 JustLang-LSP is a Visual Studio Code extension designed to enhance the development experience by providing task automation and integration with JustLang syntax. It supports `Justfile` (any capitalization), `.justfile`, and `*.just` formats. This extension leverages the VS Code API to register commands and task providers, enabling seamless execution of tasks defined in JustLang files.
 
 This extension now includes a language client for the `just-lsp` language server, providing features like completion, diagnostics, and more.
+I ported my own 
+
+https://docs.pkgx.sh/
+#!/usr/bin/env -S pkgx +cargo rust-script
+https://github.com/pkgxdev/pkgx
+
+cargo install pkgx rust-script
+
+
+
 
 ## Features
 
@@ -19,10 +30,29 @@ This extension now includes a language client for the `just-lsp` language server
 ### VSCode Integration
 - **Task Provider Integration**: Automatically detects and registers tasks from JustLang files (`Justfile`, `.justfile`, or `*.just`)
 - **Recipe Execution**: Run recipes directly from the editor with live output streaming
-- **Command Registration**: Enhanced command palette integration with recipe execution
+- **Smart Command Registration**: Intelligent command handling with LSP server integration
 - **Syntax Highlighting**: Comprehensive syntax highlighting using TextMate grammar
 - **Language Configuration**: Smart bracket matching, auto-closing pairs, and comment handling
 
+#### Command System
+The extension provides two recipe execution commands:
+
+1. **LSP Server Command** (`just-lsp.run_recipe`): 
+   - Provided by the just-lsp language server
+   - Used internally for LSP protocol communication and code actions
+   - Triggered automatically by LSP server features (not directly accessible in command palette)
+
+2. **Extension Command** (`justlang-lsp.run_recipe`):
+   - Accessible via Command Palette (`Ctrl+Shift+P` / `Cmd+Shift+P`) → "Just: Run Recipe"
+   - Provides interactive recipe browser with descriptions and parameter prompts
+   - Shows recipe grouping, confirmation dialogs, and real-time execution output
+   - Available regardless of LSP server status
+
+**How to Access:**
+- **Command Palette**: `Ctrl+Shift+P` → "Just: Run Recipe" (uses extension command)
+- **LSP Features**: Code actions, hover actions, etc. (uses LSP server command)
+- **Task Provider**: VS Code Tasks panel (separate task-based execution)
+
 ## Requirements
 
 This extension requires the `just-lsp` language server to be installed on your system. You can install it by following the instructions in the [just-lsp repository](https://github.com/elasticdotventures/just-lsp).
@@ -99,5 +129,6 @@ This project is licensed under the MIT License. See the [LICENSE](LICENSE) file
 **Syntax Highlighting**: Syntax highlighting and language configuration features were adapted from the [wolfmah-vscode.just-syntax](https://github.com/wolfmah-vscode/just-syntax) repository under the Mozilla Public License 2.0 (MPL 2.0). See the [LICENSE](LICENSE) file for details.
 
 ## Additional Thanks 
+* https://github.com/terror/just-lsp (lsp)
 * Robert Neff - nefrob.vscode-just-syntax
 * skellock - skellock.just 

just-lsp-ng.pkgx

@@ -0,0 +1,8 @@
+#!/usr/bin/env -S pkgx rust-script
+//! ```cargo
+//! [dependencies]
+//! time = "0.1.25"
+//! ```
+fn main() {
+    println!("{}", time::now().rfc822z());
+}

package.json

@@ -223,22 +223,19 @@
     ],
     "commands": [
       {
-        "command": "justlang.formatDocument",
-        "title": "Just: Format Document"
-      },
-      {
-        "command": "justlang.runRecipe",
-        "title": "Just: Run Recipe"
-      },
-      {
-        "command": "just-lsp.run_recipe",
-        "title": "Just: Run Recipe (LSP)",
+        "command": "justlang-lsp.run_recipe",
+        "title": "Just: Run Recipe",
         "category": "Just"
       },
       {
         "command": "just-lsp.show_recipes",
         "title": "Just: Show All Recipes",
         "category": "Just"
+      },
+      {
+        "command": "just-lsp.install",
+        "title": "Just: Install/Update just-lsp Server",
+        "category": "Just"
       }
     ],
     "files": [

src/client.ts

@@ -2,6 +2,7 @@ import * as vscode from 'vscode';
 import { LanguageClient, LanguageClientOptions, ServerOptions, ErrorAction, CloseAction } from 'vscode-languageclient/node';
 import * as path from 'path';
 import * as fs from 'fs';
+import { JustLspInstaller } from './just-lsp-installer';
 
 function findExecutable(bin: string): string | null {
     const pathVar = process.env.PATH;
@@ -19,37 +20,30 @@ function findExecutable(bin: string): string | null {
 }
 
 // runs the justlsp binary 
-export function createLanguageClient(context: vscode.ExtensionContext): LanguageClient | null {
+export async function createLanguageClient(context: vscode.ExtensionContext): Promise<LanguageClient | null> {
     const config = vscode.workspace.getConfiguration('justlang-lsp');
+    const installer = new JustLspInstaller();
 
-    // Find the binary
-    const serverPath = config.get<string>('server.path') || findExecutable('just-lsp');
+    // Try to detect just-lsp using the new installer system
+    let serverPath = await installer.detectJustLsp();
 
-    // Check if debug logging is enabled (force enable during tests)
-    const isTestEnvironment = process.env.NODE_ENV === 'test' || process.env.VSCODE_TEST === '1';
-    const debugEnabled = isTestEnvironment || config.get<boolean>('debug.enabled', false);
-
-    // Check if the just-lsp binary is executable
-    try {
-        if (serverPath && fs.existsSync(serverPath)) {
-            fs.accessSync(serverPath, fs.constants.X_OK);
-        } else {
-            throw new Error('just-lsp binary not found');
+    // If not found, prompt for installation
+    if (!serverPath) {
+        const shouldInstall = await installer.promptInstallation();
+        if (shouldInstall) {
+            // Try detection again after installation
+            serverPath = await installer.detectJustLsp();
         }
-    } catch (err) {
-        vscode.window.showErrorMessage(
-            `just-lsp binary at ${serverPath} is not executable: ${err instanceof Error ? err.message : String(err)}`
-        );
-        console.error(`[justlang-lsp] just-lsp binary at ${serverPath} is not executable:`, err);
-        return null;
     }
 
     if (!serverPath) {
-        vscode.window.showErrorMessage(
-            'just-lsp executable not found. Please specify the path in your settings or ensure it is in your PATH.'
-        );
+        console.error('[justlang-lsp] just-lsp binary not found after detection and installation attempts');
         return null;
     }
+    
+    // Check if debug logging is enabled (force enable during tests)
+    const isTestEnvironment = process.env.NODE_ENV === 'test' || process.env.VSCODE_TEST === '1';
+    const debugEnabled = isTestEnvironment || config.get<boolean>('debug.enabled', false);
 
     console.log(`[justlang-lsp] Found just-lsp executable at: ${serverPath}`);
     console.log('[justlang-lsp] Preparing to launch language server process...');

src/commands.ts

@@ -1,6 +1,7 @@
 import * as vscode from 'vscode';
 import { LanguageClient } from 'vscode-languageclient/node';
 import { RecipeRunner } from './recipe-runner';
+import { JustLspInstaller } from './just-lsp-installer';
 
 let commandsRegistered = false;
 let recipeRunner: RecipeRunner | null = null;
@@ -21,8 +22,9 @@ export function registerCommands(context: vscode.ExtensionContext, client: Langu
         return;
     }
 
-    // Register the enhanced run recipe command with JSON parsing
-    const runRecipeCommand = vscode.commands.registerCommand('just-lsp.run_recipe', async (recipeName?: string, args?: string[]) => {
+    // Register the enhanced run recipe command with JSON parsing  
+    // Note: Use different name to avoid conflict with LSP server's executeCommandProvider
+    const runRecipeCommand = vscode.commands.registerCommand('justlang-lsp.run_recipe', async (recipeName?: string, args?: string[]) => {
         const runner = getRecipeRunner();
         if (!runner) {
             vscode.window.showErrorMessage('No workspace found for recipe execution');
@@ -61,7 +63,39 @@ export function registerCommands(context: vscode.ExtensionContext, client: Langu
         }
     });
 
-    context.subscriptions.push(runRecipeCommand, showRecipesCommand);
+    // Register install just-lsp command
+    const installJustLspCommand = vscode.commands.registerCommand('just-lsp.install', async () => {
+        const installer = new JustLspInstaller();
+        
+        // First check if already installed
+        const existingPath = await installer.detectJustLsp();
+        if (existingPath) {
+            const choice = await vscode.window.showInformationMessage(
+                `just-lsp is already installed at: ${existingPath}`,
+                'Reinstall',
+                'OK'
+            );
+            if (choice !== 'Reinstall') {
+                return;
+            }
+        }
+        
+        // Attempt installation
+        const result = await installer.installJustLsp();
+        if (result.success) {
+            const choice = await vscode.window.showInformationMessage(
+                `just-lsp installed successfully at: ${result.path}`,
+                'Reload Window'
+            );
+            if (choice === 'Reload Window') {
+                vscode.commands.executeCommand('workbench.action.reloadWindow');
+            }
+        } else {
+            vscode.window.showErrorMessage(`Installation failed: ${result.error}`);
+        }
+    });
+
+    context.subscriptions.push(runRecipeCommand, showRecipesCommand, installJustLspCommand);
     commandsRegistered = true;
     console.log('[justlang-lsp] Commands registered successfully');
 }

src/extension.ts

@@ -39,16 +39,27 @@ export function activate(context: vscode.ExtensionContext) {
             await stopLsp();
         }
         logger.info('Creating language client', 'Extension');
-        client = createLanguageClient(context);
+        client = await createLanguageClient(context);
         if (client) {
             logger.info('Language client created, starting...', 'Extension');
             try {
+                logger.info('About to call client.start()', 'Extension');
                 await client.start();
                 logger.info('Language client started successfully', 'Extension', { state: client.state });
-                registerCommands(context, client);
             } catch (err) {
-                logger.errorFromException(err, 'Language client failed to start', 'Extension');
-                vscode.window.showErrorMessage('justlang-lsp language client failed to start.');
+                const errorMessage = err instanceof Error ? err.message : String(err);
+                const errorStack = err instanceof Error ? err.stack : 'No stack trace available';
+                logger.error('Language client failed to start', 'Extension', {
+                    error: errorMessage,
+                    stack: errorStack,
+                    clientState: client?.state
+                });
+                console.error('[justlang-lsp] DETAILED START ERROR:', {
+                    message: errorMessage,
+                    stack: errorStack,
+                    error: err
+                });
+                vscode.window.showErrorMessage(`justlang-lsp language client failed to start: ${errorMessage}`);
             }
         } else {
             logger.error('Language client creation failed', 'Extension');
@@ -79,6 +90,9 @@ export function activate(context: vscode.ExtensionContext) {
         }
     });
 
+    // Register commands once during activation
+    registerCommands(context, null);
+
     if (enableLsp) {
         startLsp();
     } else {