Generated banner for Lsp Setup
Generated logo for Lsp Setup

Lsp Setup

GitHubOfficialFirst committed by brunoborgesDistributed by GitHub

  • Skill
  • Tool integration
  • Software development
  • MIT
  • Low risk

From the author

Enable code intelligence (go-to-definition, find-references, hover, type info) for any programming language by installing and configuring an LSP server for Copilot CLI. Detects the OS, installs the right server, and generates the JSON configuration (user-level or repo-level). Use when you need deeper code understanding and no LSP server is configured, or when the user asks to set up, install, or configure an LSP server.
— the description by brunoborges

AutoGineer summary

Written by AutoGineer from the skill’s own files, not by the author

The lsp-setup skill streamlines the process of enabling code intelligence features like go-to-definition, find-references, and hover information within the Copilot CLI environment. It handles the end-to-end workflow of identifying the required LSP server for a specific programming language, detecting the host operating system, installing the necessary binary, and generating the appropriate JSON configuration file at either the user or repository level.

What it does

  • Detects the host operating system to determine the correct installation path.
  • Installs the appropriate LSP server binary for the requested programming language.
  • Generates or updates JSON configuration files for Copilot CLI.
  • Supports both user-level and repository-level configuration scopes.
  • Verifies that the installed LSP binary is accessible via the system PATH.
  • Provides guidance on restarting the CLI session to apply new configurations.

When to use it

  • When you need deeper code understanding features like go-to-definition or hover.
  • When a project lacks an LSP server configuration for its specific language.
  • When you need to add support for a new language to your Copilot CLI environment.
  • When you are asked to set up, install, or configure an LSP server.

Advantages

  • Reduces manual configuration errors by automating JSON structure generation.
  • Ensures consistent LSP setup across different operating systems.
  • Maintains existing configurations by merging new entries rather than overwriting files.
  • Provides clear verification steps to ensure the server is correctly integrated.

Usage examples

“Set up LSP for TypeScript.”
The agent will identify the typescript-language-server, install it via npm, and update the configuration file with the correct file extensions and command arguments.
“I need go-to-definition for my Java project.”
The agent will guide you through installing jdtls, configuring the JVM arguments, and setting up the workspace directory for Java semantic navigation.

Install

  1. Download the skill as a ZIP:

    https://autogineer.com/agent-skills/github/lsp-setup/download
  2. Unzip it into the cross-client skills folder of your project:

    mkdir -p .agents/skills && unzip lsp-setup.zip -d .agents/skills

Documentation by brunoborges

LSP Setup for GitHub Copilot CLI

UTILITY SKILL — installs and configures Language Server Protocol servers for Copilot CLI. USE FOR: "setup LSP", "install language server", "configure LSP for Java", "add TypeScript LSP", "enable code intelligence", "I need go-to-definition", "find references not working", "need better code understanding" DO NOT USE FOR: general coding tasks, IDE/editor LSP configuration, non-Copilot-CLI setups

Workflow

  1. Ask the language — use ask_user to ask which programming language(s) the user wants LSP support for

  2. Detect the OS — run uname -s (or check for Windows via $env:OS / %OS%) to determine macOS, Linux, or Windows

  3. Look up the LSP server — read references/lsp-servers.md for known servers, install commands, and config snippets (for Java, also read references/java-jdtls.md)

  4. Ask scope — use ask_user to ask whether the config should be user-level (~/.copilot/lsp-config.json) or repo-level (.github/lsp.json)

  5. Install the server — run the appropriate install command for the detected OS

  6. Write the config — merge the new server entry into the chosen config file (~/.copilot/lsp-config.json for user-level; .github/lsp.json for repo-level). Create the file if missing and preserve existing entries.

  7. Verify — confirm the LSP binary is on $PATH and the config file is valid JSON

Configuration Format

Copilot CLI reads LSP configuration from user-level or repo-level locations, and repo-level config takes precedence over user-level config:

  • User-level: ~/.copilot/lsp-config.json

  • Repo-level: .github/lsp.json (a bare lsp.json at the repo root is not read: with Copilot CLI 1.0.95, copilot lsp list listed servers from .github/lsp.json but not from a root lsp.json)

The JSON structure:

{
  "lspServers": {
    "<server-key>": {
      "command": "<binary>",
      "args": ["--stdio"],
      "fileExtensions": {
        ".<ext>": "<languageId>",
        ".<ext2>": "<languageId>"
      }
    }
  }
}
Key rules
  • command is the binary name (must be on $PATH) or an absolute path.

  • args almost always includes "--stdio" to use standard I/O transport.

  • fileExtensions maps each file extension (with leading dot) to a Language ID.

  • Multiple servers can coexist in lspServers.

  • When merging into an existing file, never overwrite other server entries — only add or update the target language key.

Behavior

  • Always use ask_user with choices when asking the user to pick a language or scope.

  • If the language is not listed in references/lsp-servers.md, search the web for "<language> LSP server" and guide the user through manual configuration.

  • If a package manager is not available (e.g. no Homebrew on macOS), suggest alternative install methods from the reference file.

  • After installation, run which <binary> (or where.exe on Windows) to confirm the binary is accessible.

  • Show the user the final config JSON before writing it.

  • If the config file already exists, read it first and merge — do not clobber.

Verification

After setup, tell the user:

  1. Type /exit to quit Copilot CLI — this is required so the new LSP configuration is loaded on next launch

  2. Re-launch copilot in a project with files of the configured language

  3. Run /lsp to check the server status

  4. Try code intelligence features like go-to-definition or hover

Java

For Java semantic navigation, prefer the lsp tool (goToDefinition, findReferences, hover, incomingCalls) over grep/view once a server is configured. LSP is optional for Java and is not a prerequisite for build or runtime diagnostics. See references/java-jdtls.md for setup details and troubleshooting.

Files

references/java-jdtls.md

Java code intelligence with jdtls

Details for the Java entry in lsp-servers.md. LSP is optional for Java: builds, tests and runtime diagnostics work without it.

JDKs: two different things

  • jdtls runtime JDK: jdtls needs a recent JDK (21+ for current releases) found via JAVA_HOME or PATH.

  • Project JDK: the version your code targets (maven.compiler.release, java.toolchain). Install a matching JDK too; if jdtls cannot find one, it falls back to its own runtime and may report false errors for newer language features.

Project import

  • Maven: jdtls reads pom.xml (multi-module supported). Run ./mvnw -q compile once so dependencies are in ~/.m2.

  • Gradle: jdtls uses the Gradle wrapper (gradlew) if present. Run ./gradlew classes once.

  • Open Copilot CLI at the repository root (or the module root) so the build file is found.

  • After large pom.xml / build.gradle edits, restart the session (/exit, relaunch) so the project is re-imported.

Workspace (data) directory

-data .jdtls-workspace keeps the index per project, avoiding cross-project classpath contamination. Delete it to reset a stale index; git-ignore it. Never share one data dir between two running jdtls instances.

Performance

  • Heap: --jvm-arg=-Xmx2G is enough for most projects; raise to 4G for very large multi-module builds.

  • The first start indexes and may take 30-60s or more; workspaceSymbol can be empty meanwhile. Fall back to grep briefly.

  • Keep one Java server configured at a time.

Lombok and annotation processors

jdtls does not see Lombok-generated members (@Getter, builders) unless the Lombok agent is passed to the JVM, e.g. --jvm-arg=-javaagent:<path-to>/lombok.jar (this path is machine-specific; set it in user-level config, not in a committed repo file). MapStruct, Immutables and other processors need annotation processing enabled and generated sources produced by a prior build. Treat "cannot resolve method" errors on generated code as possible false positives and confirm with ./mvnw compile or ./gradlew classes.

What lsp operations give for Java

OperationUse
goToDefinition / goToImplementationjump to a type, or to implementations of an interface
findReferencesall usages, resolving overloads and imports
incomingCalls / outgoingCallscall hierarchy
hovertype info and Javadoc
documentSymbol / workspaceSymboloutline of a file, or search types by name
renamesemantic rename across files

Parameters are 1-based line and character, except documentSymbol (file only) and workspaceSymbol (query). Prefer lsp first for symbol questions; use grep for non-symbol text (properties, log messages).

Troubleshooting

SymptomFix
/lsp shows no Java servercheck which jdtls and config location; restart the session
Unresolved imports everywhererun the Maven/Gradle build once; delete .jdtls-workspace
Server exits immediatelycheck the JDK version used by jdtls (java -version); confirm wrapper flags with jdtls --help
Out-of-memory or slowraise -Xmx; close other Java servers
Wrong language-level errorsinstall the project's JDK and make sure the build file declares it

Provenance

Adapted from jdubois/dr-jskill (references/JDTLS.md, assets/lsp.json), read at commit 29e71996048e4086bfa389268a3c6c2e49ea3f25. Contributed here by its original author (Julien Dubois, sole copyright holder of dr-jskill) under this repository's MIT license; it remains available upstream under Apache-2.0. Reworked and condensed; no host-specific paths.

Requirements and compatibility

Written for: GitHub Copilot

Works with: Claude Code, Claude apps, OpenAI Codex, GitHub Copilot, Cursor, Gemini CLI, Kiro, OpenCode, Goose, Amp, Roo Code, JetBrains Junie, Factory Droid, Devin (ex-Windsurf), Mistral Vibe, OpenHands, Letta

“Works with” means the tool reads the open Agent Skills format; a skill written for one tool may use features others lack.

Security

What our scanner noticed· Low risk

  • Instructions that use the network

A static scan is not a guarantee. Skills are third-party content: review a skill before you let an agent use it.

Attribution and licence

First committed by
GitHub avatar of brunoborgesbrunoborges
Publisher
GitHub (Official)
Distributed by
GitHub
Source
github/awesome-copilot · skills/lsp-setup · commit 797337f
Licence
MIT License (redistribution allowed)
  • LICENSE (added by AutoGineer from LICENSE)
  • ATTRIBUTION.md (written by AutoGineer)
Synced
Contributors
brunoborges, jdubois, compnerd

AutoGineer is not affiliated with or endorsed by brunoborges or GitHub.

Download ZIP

The ZIP holds the skill’s files, its licence files and an ATTRIBUTION.md. Download lsp-setup.zip