Skip to content
Back to search

cclsp

Claude Code LSP: enhance your Claude Code experience with non-IDE dependent LSP integration.

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/ktnyt--cclsp/badge.svg)](/listings/ktnyt--cclsp)

HTML

<a href="/listings/ktnyt--cclsp"><img src="/api/listings/ktnyt--cclsp/badge.svg" alt="findsafeskills safety rating" /></a>

Install

i

Install instructions from the README

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

cclsp provides an interactive setup wizard that automates the entire configuration process. Choose your preferred method:

Automated Setup (Recommended)

Run the interactive setup wizard:

# One-time setup (no installation required)
npx cclsp@latest setup

# For user-wide configuration
npx cclsp@latest setup --user

The setup wizard will:

1. **πŸ” Auto-detect languages** in your project by scanning files 2. **πŸ“‹ Show pre-selected LSP servers** based on detected languages 3. **πŸ“¦ Display installation requirements** with detailed guides 4. **⚑ Install LSPs automatically** (optional, with user confirmation) 5. **πŸ”— Add to Claude MCP** (optional, with user confirmation) 6. **βœ… Verify setup** and show available tools

Setup Options

- **Project Configuration** (default): Creates `.claude/cclsp.json` in current directory - **User Configuration** (`--user`): Creates global config in `~/.config/claude/cclsp.json`

Manual Setup

If you prefer manual configuration:

1. **Install cclsp**:

   npm install -g cclsp

2. **Install language servers** (see [Language Server Installation](#language-server-installation))

3. **Create configuration file**:

   # Use the interactive generator
   cclsp setup

   # Or create manually (see Configuration section)

4. **Add to Claude MCP**:

   claude mcp add cclsp npx cclsp@latest --env CCLSP_CONFIG_PATH=/path/to/cclsp.json

Language Server Installation

The setup wizard shows installation commands for each LSP, but you can also install them manually:

<details> <summary>πŸ“¦ Common Language Servers</summary>

TypeScript/JavaScript

npm install -g typescript-language-server typescript

Python

pip install "python-lsp-server[all]"
# Or basic installation: pip install python-lsp-server

Go

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

Rust

rustup component add rust-analyzer
rustup component add rust-src

C/C++

# Ubuntu/Debian
sudo apt install clangd

# macOS
brew install llvm

# Windows: Download from LLVM releases

Ruby

gem install solargraph

PHP

npm install -g intelephense

For more languages and detailed instructions, run `npx cclsp@latest setup` and select "Show detailed installation guides".

</details>

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.

README.md Β· README Β· 685 lines

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

  1. [![MseeP.ai Security Assessment Badge](https://mseep.net/pr/ktnyt-cclsp-badge.png)](https://mseep.ai/app/ktnyt-cclsp)
  2. # cclsp - not your average LSP adapter
  3. [![npm version](https://badge.fury.io/js/cclsp.svg)](https://www.npmjs.com/package/cclsp)
  4. [![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg)](https://opensource.org/licenses/MIT)
  5. [![Node.js Version](https://img.shields.io/node/v/cclsp.svg)](https://nodejs.org)
  6. [![CI](https://github.com/ktnyt/cclsp/actions/workflows/ci.yml/badge.svg)](https://github.com/ktnyt/cclsp/actions/workflows/ci.yml)
  7. [![npm downloads](https://img.shields.io/npm/dm/cclsp.svg)](https://www.npmjs.com/package/cclsp)
  8. [![PRs Welcome](https://img.shields.io/badge/PRs-welcome-brightgreen.svg)](CONTRIBUTING.md)
  9. **cclsp** is a Model Context Protocol (MCP) server that seamlessly integrates LLM-based coding agents with Language Server Protocol (LSP) servers. LLM-based coding agents often struggle with providing accurate line/column numbers, which makes naive attempts to integrate with LSP servers fragile and frustrating. cclsp solves this by intelligently trying multiple position combinations and providing robust symbol resolution that just works, no matter how your AI assistant counts lines.
  10. ## Setup & Usage Demo
  11. https://github.com/user-attachments/assets/52980f32-64d6-4b78-9cbf-18d6ae120cdd
  12. ## Table of Contents
  13. - [Why cclsp?](#why-cclsp)
  14. - [Features](#features)
  15. - [πŸ“‹ Prerequisites](#-prerequisites)
  16. - [⚑ Setup](#-setup)
  17. - [Automated Setup (Recommended)](#automated-setup-recommended)
  18. - [Claude Code Quick Setup](#claude-code-quick-setup)
  19. - [Manual Setup](#manual-setup)
  20. - [Language Server Installation](#language-server-installation)
  21. - [Verification](#verification)
  22. - [πŸš€ Usage](#-usage)
  23. - [As MCP Server](#as-mcp-server)
  24. - [Configuration](#configuration)
  25. - [πŸ› οΈ Development](#️-development)
  26. - [πŸ”§ MCP Tools](#-mcp-tools)
  27. - [`find_definition`](#find_definition)
  28. - [`find_references`](#find_references)
  29. - [`rename_symbol`](#rename_symbol)
  30. - [`rename_symbol_strict`](#rename_symbol_strict)
  31. - [`get_diagnostics`](#get_diagnostics)
  32. - [`restart_server`](#restart_server)
  33. - [πŸ’‘ Real-world Examples](#-real-world-examples)
  34. - [Finding Function Definitions](#finding-function-definitions)
  35. - [Finding All References](#finding-all-references)
  36. - [Renaming Symbols](#renaming-symbols)
  37. - [πŸ” Troubleshooting](#-troubleshooting)
  38. - [🀝 Contributing](#-contributing)
  39. - [πŸ“„ License](#-license)
  40. ## Why cclsp?
  41. When using AI-powered coding assistants like Claude, you often need to navigate codebases to understand symbol relationships. **cclsp** bridges the gap between Language Server Protocol capabilities and Model Context Protocol, enabling:
  42. - πŸ” **Instant symbol navigation** - Jump to definitions without manually searching
  43. - πŸ“š **Complete reference finding** - Find all usages of functions, variables, and types
  44. - ✏️ **Safe symbol renaming** - Rename across entire codebases with confidence
  45. - 🌍 **Universal language support** - Works with any LSP-compatible language server
  46. - πŸ€– **AI-friendly interface** - Designed for LLMs to understand and use effectively
  47. ## Features
  48. - **Go to Definition**: Find where symbols are defined
  49. - **Find References**: Locate all references to a symbol
  50. - **Multi-language Support**: Configurable LSP servers for different file types
  51. - **TypeScript**: Built-in support via typescript-language-server
  52. - **Python**: Support via python-lsp-server (pylsp)
  53. - **Go**: Support via gopls
  54. - **And many more**: Extensive language server configurations
  55. ## πŸ“‹ Prerequisites
  56. - Node.js 18+ or Bun runtime
  57. - Language servers for your target languages (installed separately)
  58. ## ⚑ Setup
  59. cclsp provides an interactive setup wizard that automates the entire configuration process. Choose your preferred method:
  60. ### Automated Setup (Recommended)
  61. Run the interactive setup wizard:
  62. ```bash
  63. # One-time setup (no installation required)
  64. npx cclsp@latest setup
  65. # For user-wide configuration
  66. npx cclsp@latest setup --user
  67. ```
  68. The setup wizard will:
  69. 1. **πŸ” Auto-detect languages** in your project by scanning files
  70. 2. **πŸ“‹ Show pre-selected LSP servers** based on detected languages
  71. 3. **πŸ“¦ Display installation requirements** with detailed guides
  72. 4. **⚑ Install LSPs automatically** (optional, with user confirmation)
  73. 5. **πŸ”— Add to Claude MCP** (optional, with user confirmation)
  74. 6. **βœ… Verify setup** and show available tools
  75. #### Setup Options
  76. - **Project Configuration** (default): Creates `.claude/cclsp.json` in current directory
  77. - **User Configuration** (`--user`): Creates global config in `~/.config/claude/cclsp.json`
  78. ### Manual Setup
  79. If you prefer manual configuration:
  80. 1. **Install cclsp**:
  81. ```bash
  82. npm install -g cclsp
  83. ```
  84. 2. **Install language servers** (see [Language Server Installation](#language-server-installation))
  85. 3. **Create configuration file**:
  86. ```bash
  87. # Use the interactive generator
  88. cclsp setup
  89. # Or create manually (see Configuration section)
  90. ```
  91. 4. **Add to Claude MCP**:
  92. ```bash
  93. claude mcp add cclsp npx cclsp@latest --env CCLSP_CONFIG_PATH=/path/to/cclsp.json
  94. ```
  95. ### Language Server Installation
  96. The setup wizard shows installation commands for each LSP, but you can also install them manually:
  97. <details>
  98. <summary>πŸ“¦ Common Language Servers</summary>
  99. #### TypeScript/JavaScript
  100. ```bash
  101. npm install -g typescript-language-server typescript
  102. ```
  103. #### Python
  104. ```bash
  105. pip install "python-lsp-server[all]"
  106. # Or basic installation: pip install python-lsp-server
  107. ```
  108. #### Go
  109. ```bash
  110. go install golang.org/x/tools/gopls@latest
  111. ```
  112. #### Rust
  113. ```bash
  114. rustup component add rust-analyzer
  115. rustup component add rust-src
  116. ```
  117. #### C/C++
  118. ```bash
  119. # Ubuntu/Debian
  120. sudo apt install clangd
  121. # macOS
  122. brew install llvm
  123. # Windows: Download from LLVM releases
  124. ```
  125. #### Ruby
  126. ```bash
  127. gem install solargraph
  128. ```
  129. #### PHP
  130. ```bash
  131. npm install -g intelephense
  132. ```
  133. For more languages and detailed instructions, run `npx cclsp@latest setup` and select "Show detailed installation guides".
  134. </details>
  135. ## πŸš€ Usage
  136. ### As MCP Server
  137. Configure in your MCP client (e.g., Claude Code):
  138. #### Using npm package (after global install)
  139. ```json
  140. {
  141. "mcpServers": {
  142. "cclsp": {
  143. "command": "cclsp",
  144. "env": {
  145. "CCLSP_CONFIG_PATH": "/path/to/your/cclsp.json"
  146. }
  147. }
  148. }
  149. }
  150. ```
  151. #### Using local installation
  152. ```json
  153. {
  154. "mcpServers": {
  155. "cclsp": {
  156. "command": "node",
  157. "args": ["/path/to/cclsp/dist/index.js"],
  158. "env": {
  159. "CCLSP_CONFIG_PATH": "/path/to/your/cclsp.json"
  160. }
  161. }
  162. }
  163. }
  164. ```
  165. ### Configuration
  166. #### Interactive Configuration Generator
  167. For easy setup, use the interactive configuration generator:
  168. ```bash
  169. # Using npx (recommended for one-time setup)
  170. npx cclsp@latest setup
  171. # If installed globally
  172. cclsp setup
  173. # Or run directly with the development version
  174. bun run setup
  175. ```
  176. The interactive tool will:
  177. - Show you all available language servers
  178. - Let you select which ones to configure with intuitive controls:
  179. - **Navigation**: ↑/↓ arrow keys or Ctrl+P/Ctrl+N (Emacs-style)
  180. - **Selection**: Space to toggle, A to toggle all, I to invert selection
  181. - **Confirm**: Enter to proceed
  182. - Display installation instructions for your selected languages
  183. - Generate the configuration file automatically
  184. - Show you the final configuration
  185. #### Manual Configuration
  186. Alternatively, create an `cclsp.json` configuration file manually:
  187. ```json
  188. {
  189. "servers": [
  190. {
  191. "extensions": ["py", "pyi"],
  192. "command": ["uvx", "--from", "python-lsp-server", "pylsp"],
  193. "rootDir": ".",
  194. "initializationOptions": {
  195. "settings": {
  196. "pylsp": {
  197. "plugins": {
  198. "jedi_completion": { "enabled": true },
  199. "jedi_definition": { "enabled": true },
  200. "jedi_hover": { "enabled": true },
  201. "jedi_references": { "enabled": true },
  202. "jedi_signature_help": { "enabled": true },
  203. "jedi_symbols": { "enabled": true },
  204. "pylint": { "enabled": false },
  205. "pycodestyle": { "enabled": false },
  206. "pyflakes": { "enabled": false }
  207. }
  208. }
  209. }
  210. }
  211. },
  212. {
  213. "extensions": ["js", "ts", "jsx", "tsx"],
  214. "command": ["npx", "--", "typescript-language-server", "--stdio"],
  215. "rootDir": "."
  216. }
  217. ]
  218. }
  219. ```
  220. **Configuration Options:**
  221. - `extensions`: Array of file extensions this server handles
  222. - `command`: Command array to spawn the LSP server
  223. - `rootDir`: Working directory for the LSP server (optional, defaults to ".")
  224. - `restartInterval`: Auto-restart interval in minutes (optional)
  225. - `initializationOptions`: LSP server initialization options (optional)
  226. The `initializationOptions` field allows you to customize how each LSP server initializes. This is particularly useful for servers like `pylsp` (Python) that have extensive plugin configurations, or servers like `devsense-php-ls` that require specific settings.
  227. <details>
  228. <summary>πŸ“‹ More Language Server Examples</summary>
  229. ```json
  230. {
  231. "servers": [
  232. {
  233. "extensions": ["go"],
  234. "command": ["gopls"],
  235. "rootDir": "."
  236. },
  237. {
  238. "extensions": ["rs"],
  239. "command": ["rust-analyzer"],
  240. "rootDir": "."
  241. },
  242. {
  243. "extensions": ["c", "cpp", "cc", "h", "hpp"],
  244. "command": ["clangd"],
  245. "rootDir": "."
  246. },
  247. {
  248. "extensions": ["java"],
  249. "command": ["jdtls"],
  250. "rootDir": "."
  251. },
  252. {
  253. "extensions": ["rb"],
  254. "command": ["solargraph", "stdio"],
  255. "rootDir": "."
  256. },
  257. {
  258. "extensions": ["php"],
  259. "command": ["intelephense", "--stdio"],
  260. "rootDir": "."
  261. },
  262. {
  263. "extensions": ["cs"],
  264. "command": ["omnisharp", "-lsp"],
  265. "rootDir": "."
  266. },
  267. {
  268. "extensions": ["swift"],
  269. "command": ["sourcekit-lsp"],
  270. "rootDir": "."
  271. }
  272. ]
  273. }
  274. ```
  275. </details>
  276. ## πŸ› οΈ Development
  277. ```bash
  278. # Run in development mode
  279. bun run dev
  280. # Run tests
  281. bun test
  282. # Run manual integration test
  283. bun run test:manual
  284. # Lint code
  285. bun run lint
  286. # Format code
  287. bun run format
  288. # Type check
  289. bun run typecheck
  290. ```
  291. ## πŸ”§ MCP Tools
  292. The server exposes these MCP tools:
  293. ### `find_definition`
  294. Find the definition of a symbol by name and kind in a file. Returns definitions for all matching symbols.
  295. **Parameters:**
  296. - `file_path`: The path to the file
  297. - `symbol_name`: The name of the symbol
  298. - `symbol_kind`: The kind of symbol (function, class, variable, method, etc.) (optional)
  299. ### `find_references`
  300. Find all references to a symbol across the entire workspace. Returns references for all matching symbols.
  301. **Parameters:**
  302. - `file_path`: The path to the file where the symbol is defined
  303. - `symbol_name`: The name of the symbol
  304. - `symbol_kind`: The kind of symbol (function, class, variable, method, etc.) (optional)
  305. - `include_declaration`: Whether to include the declaration (optional, default: true)
  306. ### `rename_symbol`
  307. Rename a symbol by name and kind in a file. **This tool now applies the rename to all affected files by default.** If multiple symbols match, returns candidate positions and suggests using rename_symbol_strict.
  308. **Parameters:**
  309. - `file_path`: The path to the file
  310. - `symbol_name`: The name of the symbol
  311. - `symbol_kind`: The kind of symbol (function, class, variable, method, etc.) (optional)
  312. - `new_name`: The new name for the symbol
  313. - `dry_run`: If true, only preview the changes without applying them (optional, default: false)
  314. **Note:** When `dry_run` is false (default), the tool will:
  315. - Apply the rename to all affected files
  316. - Create backup files with `.bak` extension
  317. - Return the list of modified files
  318. ### `rename_symbol_strict`
  319. Rename a symbol at a specific position in a file. Use this when rename_symbol returns multiple candidates. **This tool now applies the rename to all affected files by default.**
  320. **Parameters:**
  321. - `file_path`: The path to the file
  322. - `line`: The line number (1-indexed)
  323. - `character`: The character position in the line (1-indexed)
  324. - `new_name`: The new name for the symbol
  325. - `dry_run`: If true, only preview the changes without applying them (optional, default: false)
  326. ### `get_diagnostics`
  327. Get language diagnostics (errors, warnings, hints) for a file. Uses LSP textDocument/diagnostic to pull current diagnostics.
  328. **Parameters:**
  329. - `file_path`: The path to the file to get diagnostics for
  330. ### `restart_server`
  331. Manually restart LSP servers. Can restart servers for specific file extensions or all running servers.
  332. **Parameters:**
  333. - `extensions`: Array of file extensions to restart servers for (e.g., ["ts", "tsx"]). If not provided, all servers will be restarted (optional)
  334. ## πŸ’‘ Real-world Examples
  335. ### Finding Function Definitions
  336. When Claude needs to understand how a function works:
  337. ```
  338. Claude: Let me find the definition of the `processRequest` function
  339. > Using cclsp.find_definition with symbol_name="processRequest", symbol_kind="function"
  340. Result: Found definition at src/handlers/request.ts:127:1
  341. ```
  342. ### Finding All References
  343. When refactoring or understanding code impact:
  344. ```
  345. Claude: I'll find all places where `CONFIG_PATH` is used
  346. > Using cclsp.find_references with symbol_name="CONFIG_PATH"
  347. Results: Found 5 references:
  348. - src/config.ts:10:1 (declaration)
  349. - src/index.ts:45:15
  350. - src/utils/loader.ts:23:8
  351. - tests/config.test.ts:15:10
  352. - tests/config.test.ts:89:12
  353. ```
  354. ### Renaming Symbols
  355. Safe refactoring across the entire codebase (now with actual file modification!):
  356. ```
  357. Claude: I'll rename `getUserData` to `fetchUserProfile`
  358. > Using cclsp.rename_symbol with symbol_name="getUserData", new_name="fetchUserProfile"
  359. Result: Successfully renamed getUserData (function) to "fetchUserProfile".
  360. Modified files:
  361. - src/api/user.ts
  362. - src/services/auth.ts
  363. - src/components/UserProfile.tsx
  364. ... (12 files total)
  365. ```
  366. Preview changes before applying (using dry_run):
  367. ```
  368. Claude: Let me first preview what will be renamed
  369. > Using cclsp.rename_symbol with symbol_name="getUserData", new_name="fetchUserProfile", dry_run=true
  370. Result: [DRY RUN] Would rename getUserData (function) to "fetchUserProfile":
  371. File: src/api/user.ts
  372. - Line 55, Column 10 to Line 55, Column 21: "fetchUserProfile"
  373. File: src/services/auth.ts
  374. - Line 123, Column 15 to Line 123, Column 26: "fetchUserProfile"
  375. ... (12 files total)
  376. ```
  377. When multiple symbols match:
  378. ```
  379. Claude: I'll rename the `data` variable to `userData`
  380. > Using cclsp.rename_symbol with symbol_name="data", new_name="userData"
  381. Result: Multiple symbols found matching "data". Please use rename_symbol_strict with one of these positions:
  382. - data (variable) at line 45, character 10
  383. - data (parameter) at line 89, character 25
  384. - data (property) at line 112, character 5
  385. > Using cclsp.rename_symbol_strict with line=45, character=10, new_name="userData"
  386. Result: Successfully renamed symbol at line 45, character 10 to "userData".
  387. Modified files:
  388. - src/utils/parser.ts
  389. ```
  390. ### Checking File Diagnostics
  391. When analyzing code quality:
  392. ```
  393. Claude: Let me check for any errors or warnings in this file
  394. > Using cclsp.get_diagnostics
  395. Results: Found 3 diagnostics:
  396. - Error [TS2304]: Cannot find name 'undefinedVar' (Line 10, Column 5)
  397. - Warning [no-unused-vars]: 'config' is defined but never used (Line 25, Column 10)
  398. - Hint: Consider using const instead of let (Line 30, Column 1)
  399. ```
  400. ### Restarting LSP Servers
  401. When LSP servers become unresponsive or configuration changes:
  402. ```
  403. Claude: The TypeScript server seems unresponsive, let me restart it
  404. > Using cclsp.restart_server with extensions ["ts", "tsx"]
  405. Result: Successfully restarted 1 LSP server(s)
  406. Restarted servers:
  407. β€’ typescript-language-server --stdio (ts, tsx)
  408. ```
  409. Or restart all servers:
  410. ```
  411. Claude: I'll restart all LSP servers to ensure they're working properly
  412. > Using cclsp.restart_server
  413. Result: Successfully restarted 2 LSP server(s)
  414. Restarted servers:
  415. β€’ typescript-language-server --stdio (ts, tsx)
  416. β€’ pylsp (py)
  417. ```
  418. ## πŸ” Troubleshooting
  419. ### Known Issues
  420. <details>
  421. <summary>🐍 Python LSP Server (pylsp) Performance Degradation</summary>
  422. **Problem**: The Python Language Server (pylsp) may become slow or unresponsive after extended use (several hours), affecting symbol resolution and code navigation.
  423. **Symptoms**:
  424. - Slow or missing "go to definition" results for Python files
  425. - Delayed or incomplete symbol references
  426. - General responsiveness issues with Python code analysis
  427. **Solution**: Use the auto-restart feature to periodically restart the pylsp server:
  428. Add `restartInterval` to your Python server configuration:
  429. ```json
  430. {
  431. "servers": [
  432. {
  433. "extensions": ["py", "pyi"],
  434. "command": ["pylsp"],
  435. "restartInterval": 5
  436. }
  437. ]
  438. }
  439. ```
  440. This will automatically restart the Python LSP server every 5 minutes, maintaining optimal performance for long coding sessions.
  441. **Alternative**: You can also manually restart servers using the `restart_server` tool when needed:
  442. - Restart specific server: `restart_server` with `extensions: ["py"]`
  443. - Restart all servers: `restart_server` without parameters
  444. **Note**: The setup wizard automatically configures this for Python servers when detected.
  445. </details>
  446. ### Common Issues
  447. <details>
  448. <summary>πŸ”§ LSP server not starting</summary>
  449. **Problem**: Error message about LSP server not found
  450. **Solution**: Ensure the language server is installed:
  451. ```bash
  452. # For TypeScript
  453. npm install -g typescript-language-server
  454. # For Python
  455. pip install python-lsp-server
  456. # For Go
  457. go install golang.org/x/tools/gopls@latest
  458. ```
  459. </details>
  460. <details>
  461. <summary>πŸ”§ Configuration not loading</summary>
  462. **Problem**: cclsp uses default TypeScript configuration only
  463. **Solution**: Check that:
  464. 1. Your config file is named `cclsp.json` (not `cclsp.config.json`)
  465. 2. The `CCLSP_CONFIG_PATH` environment variable points to the correct file
  466. 3. The JSON syntax is valid
  467. </details>
  468. <details>
  469. <summary>πŸ”§ Symbol not found errors</summary>
  470. **Problem**: "Go to definition" returns no results
  471. **Solution**:
  472. 1. Ensure the file is saved and part of the project
  473. 2. Check that the language server supports the file type
  474. 3. Some language servers need a few seconds to index the project
  475. </details>
  476. ## 🀝 Contributing
  477. We welcome contributions! Here's how you can help:
  478. ### Reporting Issues
  479. Found a bug or have a feature request? [Open an issue](https://github.com/ktnyt/cclsp/issues) with:
  480. - Clear description of the problem
  481. - Steps to reproduce
  482. - Expected vs actual behavior
  483. - Your environment (OS, Node version, etc.)
  484. ### Adding Language Support
  485. Want to add support for a new language?
  486. 1. Find the LSP server for your language
  487. 2. Test the configuration locally
  488. 3. Submit a PR with:
  489. - Updated README examples
  490. - Test files if possible
  491. - Configuration documentation
  492. ### Code Contributions
  493. 1. Fork the repository
  494. 2. Create a feature branch: `git checkout -b feature/amazing-feature`
  495. 3. Make your changes
  496. 4. Run tests: `bun test`
  497. 5. Commit: `git commit -m '✨ feat: add amazing feature'`
  498. 6. Push: `git push origin feature/amazing-feature`
  499. 7. Open a Pull Request
  500. ## πŸ“„ License
  501. MIT

Ratings and comments

Sign in to rate this skill.

Sign in

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