home / skills / openclaw / skills / gopls-lsp

gopls-lsp skill

safe

This skill augments Go development with gopls, delivering code intelligence, diagnostics, and refactoring support for .go files.

npx playbooks add skill openclaw/skills --skill gopls-lsp

Review the files below or copy the command above to add this skill to your agents.

Files (2)

SKILL.md

2.2 KB

---
name: gopls-lsp
description: Go language server (gopls) providing code intelligence, refactoring, and analysis for .go files. Use when working with Go code that needs autocomplete, go-to-definition, find references, error detection, or refactoring support.
---

# gopls LSP

Go language server integration providing comprehensive code intelligence through gopls (the official Go language server).

## Capabilities

- **Code intelligence**: Autocomplete, go-to-definition, find references
- **Error detection**: Real-time diagnostics for compilation errors and issues
- **Refactoring**: Rename symbols, extract function, organize imports
- **Analysis**: Static analysis, code suggestions, unused code detection
- **Supported extensions**: `.go`

## Installation

Install gopls using the Go toolchain:

```bash
go install golang.org/x/tools/gopls@latest
```

**Important**: Make sure `$GOPATH/bin` (or `$HOME/go/bin`) is in your PATH.

Verify installation:
```bash
gopls version
```

## Usage

The language server runs automatically in LSP-compatible editors. For manual operations:

### Format code
```bash
gofmt -w file.go
```

### Run linter
```bash
go vet ./...
```

### Build and test
```bash
go build ./...
go test ./...
```

## Configuration

Create `gopls.yaml` in your project or workspace for custom settings:

```yaml
analyses:
  unusedparams: true
  shadow: true
completeUnimported: true
staticcheck: true
```

Or configure via environment:
```bash
export GOPLS_CONFIG='{"staticcheck": true, "analyses": {"unusedparams": true}}'
```

## Integration Pattern

When editing Go code:
1. gopls provides real-time diagnostics in LSP editors
2. Run `go fmt` or `gofmt` to format code
3. Use `go vet` for additional static analysis
4. Run tests with `go test` before committing

## Common Go Commands

- `go mod init <module>` - Initialize Go module
- `go mod tidy` - Clean up dependencies
- `go get <package>` - Add dependency
- `go build` - Compile packages
- `go run main.go` - Run program
- `go test` - Run tests
- `go vet` - Report suspicious constructs

## More Information

- [gopls Documentation](https://pkg.go.dev/golang.org/x/tools/gopls)
- [GitHub Repository](https://github.com/golang/tools/tree/master/gopls)
- [Go Official Documentation](https://go.dev/doc/)

Overview

This skill integrates the Go language server (gopls) to provide code intelligence, refactoring, and static analysis for .go files. It delivers autocomplete, go-to-definition, find-references, real-time diagnostics, and common refactor operations to speed up development and reduce errors. The skill is designed to work in any LSP-compatible editor or automated toolchain that invokes gopls.

How this skill works

gopls runs as a language server and communicates with editors or tools over the Language Server Protocol to provide contextual information about Go source files. It inspects syntax trees, type information, and module metadata to produce completions, symbol locations, diagnostics, and suggested code actions like renames or extract-function. You can customize behavior via a gopls.yaml or environment configuration for analyses, staticcheck, and import completion.

When to use it

Active Go development in an LSP-compatible editor (VS Code, Neovim, etc.).
When you need fast, accurate autocomplete and go-to-definition navigation.
Before committing code to catch compile-time and static analysis issues early.
When performing bulk refactors like renames, extract function, or organizing imports.
To surface unused code, shadowed variables, and other static warnings.

Best practices

Install gopls with the Go toolchain and ensure $GOPATH/bin or $HOME/go/bin is in PATH.
Enable staticcheck and relevant analyses in gopls.yaml for stricter diagnostics.
Run gofmt or go fmt as part of save or commit hooks to keep formatting consistent.
Use go vet and go test in CI to complement gopls diagnostics with additional checks.
Keep go.mod tidy and run go mod tidy regularly to avoid module resolution issues.

Example use cases

Autocomplete and quick documentation lookup while writing new functions or interfaces.
Rename a function or type across a codebase safely using the LSP rename action.
Find all references to a symbol to assess impact before changing an API.
Detect and fix unused variables or imports reported by gopls and staticcheck.
Run quick local analysis during CI runs and fail builds on new diagnostics.

FAQ

How do I install gopls?

Install with the Go toolchain: go install golang.org/x/tools/gopls@latest and ensure your Go bin directory is in PATH. Verify with gopls version.

How do I enable stricter checks like staticcheck?

Enable staticcheck and specific analyses in a gopls.yaml in the workspace or set GOPLS_CONFIG environment variable with the desired JSON settings.