Skip to content
Back to search

lsp-skill

MarketplaceWorks with Claude CodeGitHub

IntelliSense Designed for Coding Agent

Safety scan

A static text scan, not a guarantee. Select the badge to see what was scanned and every finding.

Checked today
Badge for your README
findsafeskills safety rating

Markdown

[![findsafeskills safety rating](/api/listings/lsp-client--lsp-skill/badge.svg)](/listings/lsp-client--lsp-skill)

HTML

<a href="/listings/lsp-client--lsp-skill"><img src="/api/listings/lsp-client--lsp-skill/badge.svg" alt="findsafeskills safety rating" /></a>

Install

Install instructions from the README

As written by the repo's author. findsafeskills has not verified these steps.

😎 Copy the following prompt to your agent and let it do all the heavy lifting for you:

Please follow these steps to install this skill:

1. Identify what AI agent tool you are (e.g., Claude Code, Gemini, Codex, OpenCode, etc.).
2. Determine the correct installation directory for your tool:
   - Claude Code: `~/.claude/skills/`
   - Gemini: `~/.gemini/skills/`
   - Codex: `~/.codex/skills/`
   - OpenCode: `~/.config/opencode/skill/`
   - Other tools:
     1. Search online to determine if your tool supports agent skills from `agentskills.io`.
     2. If supported, check your tool's documentation to get the skill directory.
3. Download the latest release and unzip it into that directory.

   For example, if you are Claude Code:

   ```bash
   # Create directory if it doesn't exist
   mkdir -p ~/.claude/skills/lsp-code-analysis

    # Download and unzip the latest release
    TMP_DIR=$(mktemp -d)
    curl -sSL https://github.com/lsp-client/lsp-skill/releases/latest/download/lsp-code-analysis.zip -o "$TMP_DIR/lsp-code-analysis.zip"
    unzip -o "$TMP_DIR/lsp-code-analysis.zip" -d ~/.claude/skills/
    rm -rf "$TMP_DIR"
   ```

Manual Installation

You can also use [skills](https://skills.sh/) for easy installation:

npx skills add lsp-client/lsp-skill

What was scanned

The files the safety scan read, as written by the repository's author and shown as plain text. Lines with a finding are marked.

.claude-plugin/marketplace.json Β· Manifest Β· 20 lines

View this file on GitHub (read at the repository's current version: the scan did not record which commit it read)

  1. {
  2. "name": "lsp-skill",
  3. "owner": {
  4. "name": "Wang Bowei",
  5. "email": "wozluohd@gmail.com"
  6. },
  7. "metadata": {
  8. "description": "LSP-based semantic code analysis and navigation skill for AI agents",
  9. "version": "0.2.1"
  10. },
  11. "plugins": [
  12. {
  13. "name": "lsp-code-analysis",
  14. "description": "Semantic code analysis via LSP. Navigate code (definitions, references, implementations), search symbols, preview refactorings, and get file outlines. Use for exploring unfamiliar codebases or performing safe refactoring.",
  15. "source": "./",
  16. "strict": false,
  17. "skills": ["./skills/lsp-code-analysis"]
  18. }
  19. ]
  20. }
README.md Β· README Β· 148 lines

View this file on GitHub (read at the repository's current version: the scan did not record which commit it read)

  1. # LSP Analysis Skill
  2. [![License](https://img.shields.io/badge/License-MIT-green.svg)](LICENSE)
  3. [![Protocol Version](https://img.shields.io/badge/Protocol-v1.0.0--alpha-blue.svg)](references/lsap.md)
  4. > _IntelliSense Designed for Coding Agent_
  5. >
  6. > Check our [website](https://lsp-client.github.io)!
  7. This [agent skill](https://agentskills.io) equips AI agents with the [Language Server Agent Protocol (LSAP)](https://github.com/lsp-client/LSAP), enabling them to navigate, understand, and analyze codebases with the same fidelity as a human developer using VS Code.
  8. ## πŸ“¦ Installation
  9. 😎 Copy the following prompt to your agent and let it do all the heavy lifting for you:
  10. ````markdown
  11. Please follow these steps to install this skill:
  12. 1. Identify what AI agent tool you are (e.g., Claude Code, Gemini, Codex, OpenCode, etc.).
  13. 2. Determine the correct installation directory for your tool:
  14. - Claude Code: `~/.claude/skills/`
  15. - Gemini: `~/.gemini/skills/`
  16. - Codex: `~/.codex/skills/`
  17. - OpenCode: `~/.config/opencode/skill/`
  18. - Other tools:
  19. 1. Search online to determine if your tool supports agent skills from `agentskills.io`.
  20. 2. If supported, check your tool's documentation to get the skill directory.
  21. 3. Download the latest release and unzip it into that directory.
  22. For example, if you are Claude Code:
  23. ```bash
  24. # Create directory if it doesn't exist
  25. mkdir -p ~/.claude/skills/lsp-code-analysis
  26. # Download and unzip the latest release
  27. TMP_DIR=$(mktemp -d)
  28. curl -sSL https://github.com/lsp-client/lsp-skill/releases/latest/download/lsp-code-analysis.zip -o "$TMP_DIR/lsp-code-analysis.zip"
  29. unzip -o "$TMP_DIR/lsp-code-analysis.zip" -d ~/.claude/skills/
  30. rm -rf "$TMP_DIR"
  31. ```
  32. ````
  33. ### Manual Installation
  34. You can also use [skills](https://skills.sh/) for easy installation:
  35. ```bash
  36. npx skills add lsp-client/lsp-skill
  37. ```
  38. ## ⚑ Capabilities
  39. The [`lsp-code-analysis`](skills/lsp-code-analysis/SKILL.md) skill provides **compiler-accurate** code understanding that surpasses text-based search:
  40. - **πŸ” Semantic Navigation**: Jump to definitions, find references, locate implementations - understands code structure, not just text patterns.
  41. - **🏷️ Language-Aware**: Distinguishes between variables, functions, classes, types - eliminates false positives from text search.
  42. - **πŸ”— Cross-File Intelligence**: Trace dependencies, refactor safely across entire codebase - knows what imports what.
  43. - **πŸ“˜ Type-Aware**: Get precise type information, signatures, documentation - without reading implementation code.
  44. - **πŸ—ΊοΈ Symbol Outline**: Generate high-level structural maps of files to understand code without reading full implementations.
  45. ## πŸš€ Getting Started
  46. ### How it Works
  47. This skill wraps the `lsp` command line tool, which acts as a bridge between the agent and standard Language Servers (like `basedpyright`, ``typescript-language-server`, `rust-analyzer`).
  48. When an agent invokes this skill:
  49. 1. **Intelligent Locating**: The skill converts fuzzy intents (e.g., "find the `process` function") into precise file coordinates using LSAP's anchoring mechanism.
  50. 2. **Server Management**: It automatically manages the lifecycle of background language servers.
  51. 3. **Cognitive Snapshots**: It returns code context in optimized Markdown formats designed for LLM reasoning (Progressive Disclosure).
  52. ## 🌐 Supported Languages
  53. This skill currently provides out-of-the-box support for the following languages:
  54. | Language | Language Server |
  55. | :-------------------------- | :----------------------------------------------------------------------------------------------------- |
  56. | **Python** | [basedpyright](https://github.com/detachhead/basedpyright) |
  57. | **Rust** | [rust-analyzer](https://rust-analyzer.github.io/) |
  58. | **TypeScript / JavaScript** | [typescript-language-server](https://github.com/typescript-language-server/typescript-language-server) |
  59. | **Go** | [gopls](https://pkg.go.dev/golang.org/x/tools/gopls) |
  60. | **Deno** | [deno lsp](https://deno.land/) |
  61. | **Java** | [jdtls](https://github.com/eclipse/eclipse.jdt.ls) |
  62. _More language support coming very very soon!_
  63. ## πŸ“š Documentation
  64. - **[Skill Reference](skills/lsp-code-analysis/SKILL.md)**: Complete command reference and best practices.
  65. - **[Configuration Guide](skills/lsp-code-analysis/references/configuration.md)**: Customizing `lsp-cli` settings and environment variables.
  66. - **[Frontend Best Practices](skills/lsp-code-analysis/references/bp_frontend.md)**: LSP workflows for frontend development.
  67. - **[Backend Best Practices](skills/lsp-code-analysis/references/bp_backend.md)**: LSP workflows for backend development.
  68. ## πŸ”Œ Extensible Best Practices
  69. This skill uses a modular best practices system that can be extended for specific languages, frameworks, or workflows.
  70. ```
  71. skills/lsp-code-analysis/references/
  72. β”œβ”€β”€ bp_frontend.md # Frontend development workflows
  73. β”œβ”€β”€ bp_backend.md # Backend development workflows
  74. └── bp_<category>_<scenario>.md # Custom domain-specific guides
  75. ```
  76. **Add your own**:
  77. ```bash
  78. just new-bp python django # -> bp_python_django.md
  79. just new-bp modify api-migration # -> bp_modify_api-migration.md
  80. ```
  81. See [CONTRIBUTING.md](CONTRIBUTING.md) for details.
  82. ## πŸ”„ Extensibility
  83. This Agent Skill features a three-tier extensibility design that ensures its capabilities will continue to grow:
  84. ### 1. Foundation Expansion - LSP Client
  85. The underlying [lsp-client](https://github.com/lsp-client/lsp-client) library continuously expands support for more language servers and LSP protocol capabilities.
  86. - **Full LSP 3.17 Specification Coverage**: As the LSP protocol evolves, new standard capabilities (Type Hierarchy, Call Hierarchy, Inline Values, etc.) will be continuously integrated
  87. ### 2. Tool Capability Expansion - LSP CLI & LSAP Protocol
  88. The integrated **LSP CLI** implements the [LSAP (Language Server Agent Protocol)](https://github.com/lsp-client/LSAP) to provide high-level, agent-optimized capabilities:
  89. - **Advanced Analysis Capabilities**: Upcoming Relation API, Impact Analysis, Code Map, and more
  90. - **Optimized Output Formats**: Continuously improving Markdown rendering templates using the Progressive Disclosure principle, providing code context better suited for LLM reasoning
  91. ### 3. Scenario Coverage Expansion - Best Practice System
  92. This skill adopts a modular [Best Practice system](https://github.com/lsp-client/lsp-skill/blob/main/skills/lsp-code-analysis/SKILL.md#best-practices), enabling community contributions of domain-specific workflows:
  93. - **Domain Expert Knowledge**: Specialized workflows for different domains including Frontend ([bp_frontend.md](skills/lsp-code-analysis/references/bp_frontend.md)), Backend ([bp_backend.md](skills/lsp-code-analysis/references/bp_backend.md)), and more
  94. - **Framework/Language Specialization**: Customized LSP usage guides can be added for specific tech stacks (e.g., Django, React, FastAPI)
  95. These three layers of extensibility work together: the **foundation** provides raw tool materials, **composed capabilities** design efficient tool combinations, and **best practices** apply these tools to concrete scenarios. As all three continue to evolve, this skill will become increasingly powerful and user-friendly.
  96. ## πŸ“¦ Components
  97. This repository is a self-contained Agent Skill that bundles:
  98. - **Skill Definition**: [skills/lsp-code-analysis/SKILL.md](skills/lsp-code-analysis/SKILL.md)
  99. - **Best Practice Guides**: [skills/lsp-code-analysis/references/](skills/lsp-code-analysis/references/)
  100. - **Protocol Specs**: [LSAP Reference](lib-references/LSAP/)

Ratings and comments

Sign in to rate this skill.

Sign in

Free to use. If it’s helped, pass it on.