litclaude-ai 0.3.3 → 0.3.6

package/plugins/litclaude/skills/lsp-setup/references/julia/README.md

@@ -0,0 +1,62 @@
+# Julia — LSP setup (Claude Code / LitClaude)
+
+- **Recommended server:** `julia --startup-file=no --history-file=no -e "using LanguageServer; runserver()"`
+- **Extensions:** `.jl`
+- **Install hint:** `julia -e 'using Pkg; Pkg.add("LanguageServer")'`
+
+The PATH executable is `julia`; LanguageServer.jl is launched through the `-e` snippet, not as its own binary.
+
+## Install
+
+Install Julia (juliaup recommended), then add the `LanguageServer` package:
+
+- **macOS:** `brew install juliaup && juliaup add release`
+- **Linux:** `curl -fsSL https://install.julialang.org | sh` (installs juliaup)
+- **Windows:** `winget install julia -s msstore` (installs juliaup)
+
+Then add the package — ideally into a shared `@lsp` environment so it is not tied to one project:
+
+```bash
+julia --project=@lsp -e 'using Pkg; Pkg.add("LanguageServer")'
+```
+
+Confirm Julia resolves (the LSP binary IS `julia`):
+
+```bash
+command -v julia
+```
+
+## Configure
+
+Add a `julia` entry to `plugins/litclaude/.lsp.json`:
+
+```json
+{
+  "julia": {
+    "command": ["julia", "--startup-file=no", "--history-file=no", "-e", "using LanguageServer; runserver()"],
+    "extensionToLanguage": {
+      ".jl": "julia"
+    }
+  }
+}
+```
+
+Claude Code routes `.jl` edits to the Julia language server via the map. To pin
+which environment hosts LanguageServer.jl, export `JULIA_PROJECT=@lsp` in the
+shell that launches Claude Code.
+
+## Alternatives
+
+- The VS Code Julia extension bundles the same LanguageServer.jl server.
+
+## Troubleshooting
+- **PATH:** `julia` on PATH (not a `julials` binary); reopen shell after juliaup install.
+- **First run precompiles — be patient:** the initial launch compiles LanguageServer.jl and may take minutes with no output; do not kill it. Subsequent starts are fast.
+- **Package not found:** `LanguageServer` must be installed in the environment the server runs in (e.g. `@lsp`); add it there and set `JULIA_PROJECT`.
+
+## Verify
+
+```bash
+node --experimental-strip-types ../../scripts/verify-lsp.ts path/to/file.jl
+# or: bun ../../scripts/verify-lsp.ts path/to/file.jl
+```

package/plugins/litclaude/skills/lsp-setup/references/kotlin/README.md

@@ -0,0 +1,68 @@
+# Kotlin — LSP setup (Claude Code / LitClaude)
+
+- **Recommended server:** `kotlin-lsp`
+- **Extensions:** `.kt .kts`
+- **Install hint:** `https://github.com/Kotlin/kotlin-lsp`
+
+## Install
+
+The official **JetBrains Kotlin LSP** is pre-release. Download a build from the [Kotlin/kotlin-lsp](https://github.com/Kotlin/kotlin-lsp) releases and put the `kotlin-lsp` launcher on PATH.
+
+- **macOS:** Download the release archive, extract, then symlink the launcher: `ln -s /path/to/kotlin-lsp/kotlin-lsp.sh /usr/local/bin/kotlin-lsp`
+- **Linux:** Same as macOS — extract the release and place/symlink `kotlin-lsp` on PATH.
+- **Windows:** Extract the release and add the directory containing `kotlin-lsp.bat` to PATH (invoke as `kotlin-lsp`).
+
+Requires a **JDK** on the machine to run the server.
+
+Confirm it resolves:
+
+```bash
+command -v kotlin-lsp
+```
+
+## Configure
+
+Add a `kotlin` entry to `plugins/litclaude/.lsp.json`:
+
+```json
+{
+  "kotlin": {
+    "command": ["kotlin-lsp"],
+    "extensionToLanguage": {
+      ".kt": "kotlin",
+      ".kts": "kotlin"
+    }
+  }
+}
+```
+
+Claude Code routes `.kt`/`.kts` edits to `kotlin-lsp` via the map. If the server
+cannot find a Java runtime, export `JAVA_HOME` in the launching shell:
+
+```bash
+export JAVA_HOME=/Library/Java/JavaVirtualMachines/temurin-17.jdk/Contents/Home
+```
+
+The server resolves classpath from Gradle/Maven; keep the build descriptor
+importable.
+
+## Alternatives
+
+**`fwcd/kotlin-language-server`** — older community server. Still usable but less
+actively maintained than the official JetBrains one; set the `command` to its
+launcher if you prefer it.
+
+## Troubleshooting
+
+- **PATH:** `kotlin-lsp` on PATH; reopen shell after install.
+- **Pre-release churn:** the JetBrains server is early; pin a known-good release and expect occasional breakage.
+- **No JDK:** server fails to start — install a JDK and/or set `JAVA_HOME`.
+- **Slow first import:** Gradle resolution on first open can be slow on large projects; let it complete.
+- **`.kts` scripts:** build/script files resolve more slowly than `.kt` sources; this is expected.
+
+## Verify
+
+```bash
+node --experimental-strip-types ../../scripts/verify-lsp.ts path/to/File.kt
+# or: bun ../../scripts/verify-lsp.ts path/to/File.kt
+```

package/plugins/litclaude/skills/lsp-setup/references/lua/README.md

@@ -0,0 +1,64 @@
+# Lua — LSP setup (Claude Code / LitClaude)
+
+- **Recommended server:** `lua-language-server`
+- **Extensions:** `.lua`
+- **Install hint:** `https://github.com/LuaLS/lua-language-server`
+
+## Install
+
+See `https://github.com/LuaLS/lua-language-server`.
+
+- **macOS:** `brew install lua-language-server`
+- **Linux:** download a release from GitHub, or `pacman -S lua-language-server` (Arch) / AUR
+- **Windows:** download a release from the GitHub releases page and add its `bin` to PATH
+
+Confirm it resolves:
+
+```bash
+command -v lua-language-server
+```
+
+## Configure
+
+Add a `lua` entry to `plugins/litclaude/.lsp.json`:
+
+```json
+{
+  "lua": {
+    "command": ["lua-language-server"],
+    "extensionToLanguage": {
+      ".lua": "lua"
+    }
+  }
+}
+```
+
+Claude Code routes `.lua` edits to `lua-language-server` via the map. Deeper
+behavior (Neovim runtime libraries, the Lua runtime version, allowed globals)
+is configured through a project `.luarc.json` rather than `.lsp.json`. For
+Neovim config work, a `.luarc.json` like the following resolves `vim` globals and
+the stdlib:
+
+```json
+{
+  "runtime": { "version": "LuaJIT" },
+  "workspace": { "library": ["/usr/share/nvim/runtime/lua"] },
+  "diagnostics": { "globals": ["vim"] }
+}
+```
+
+## Alternatives
+
+None.
+
+## Troubleshooting
+- **PATH:** `lua-language-server` must be on PATH; reopen the shell after install.
+- **Undefined `vim` global:** add `vim` to `diagnostics.globals` and set `workspace.library` in `.luarc.json` (see above) for Neovim work.
+- **Wrong runtime version:** set `runtime.version` (`LuaJIT`, `Lua 5.4`, etc.) to match your interpreter, or stdlib functions report as undefined.
+
+## Verify
+
+```bash
+node --experimental-strip-types ../../scripts/verify-lsp.ts path/to/file.lua
+# or: bun ../../scripts/verify-lsp.ts path/to/file.lua
+```

package/plugins/litclaude/skills/lsp-setup/references/php/README.md

@@ -0,0 +1,56 @@
+# PHP — LSP setup (Claude Code / LitClaude)
+
+- **Recommended server:** `intelephense --stdio`
+- **Extensions:** `.php`
+- **Install hint:** `npm install -g intelephense`
+
+## Install
+
+Intelephense is a Node package, so Node.js (and npm) must be installed first.
+
+- **macOS:** `npm install -g intelephense`
+- **Linux:** `npm install -g intelephense`
+- **Windows:** `npm install -g intelephense`
+
+Confirm it resolves:
+
+```bash
+command -v intelephense
+```
+
+## Configure
+
+Add a `php` entry to `plugins/litclaude/.lsp.json`:
+
+```json
+{
+  "php": {
+    "command": ["intelephense", "--stdio"],
+    "extensionToLanguage": {
+      ".php": "php"
+    }
+  }
+}
+```
+
+Claude Code routes `.php` edits to `intelephense` via the map. Intelephense's
+premium features (rename, find-all-implementations, etc.) require a licence key,
+which is passed through the editor's LSP `initializationOptions` rather than
+`.lsp.json`. Without a key the server runs fine in free mode.
+
+## Alternatives
+
+**phpactor** — pure-PHP, no Node dependency. Set the `command` to
+`["phpactor", "language-server"]`.
+
+## Troubleshooting
+- **PATH:** `intelephense` must be on PATH; reopen the shell after a global npm install. If missing, check `npm bin -g` is on PATH.
+- **No Node:** Intelephense fails to start without Node.js. Install Node, then reinstall.
+- **Wrong PHP version inference:** set `intelephense.environment.phpVersion` (via your editor's init options) to match your project.
+
+## Verify
+
+```bash
+node --experimental-strip-types ../../scripts/verify-lsp.ts path/to/file.php
+# or: bun ../../scripts/verify-lsp.ts path/to/file.php
+```

package/plugins/litclaude/skills/lsp-setup/references/python/README.md

@@ -0,0 +1,68 @@
+# Python — LSP setup (Claude Code / LitClaude)
+
+- **Recommended server:** `basedpyright-langserver --stdio`
+- **Extensions:** `.py .pyi`
+- **Install hint:** `pip install basedpyright`
+
+## Install
+
+- **macOS:** `pip install basedpyright` (or `uv tool install basedpyright`)
+- **Linux:** `pip install basedpyright` (or `uv tool install basedpyright`)
+- **Windows:** `pip install basedpyright`
+
+Prefer `uv tool install basedpyright` when the project uses uv — it keeps the
+server isolated from project venvs and always on PATH.
+
+Confirm it resolves:
+
+```bash
+command -v basedpyright-langserver
+```
+
+## Configure
+
+Add a `python` entry to `plugins/litclaude/.lsp.json`. LitClaude keys each entry
+by language name with a `command` array and an `extensionToLanguage` map:
+
+```json
+{
+  "python": {
+    "command": ["basedpyright-langserver", "--stdio"],
+    "extensionToLanguage": {
+      ".py": "python",
+      ".pyi": "python"
+    }
+  }
+}
+```
+
+Claude Code routes `.py`/`.pyi` edits to this server via the extension map.
+Type-check strictness lives in `pyrightconfig.json` or `[tool.basedpyright]` in
+`pyproject.toml`, not in `.lsp.json`.
+
+## Choosing a server
+
+Type checkers and the linter serve different roles. Run a type server, and
+optionally `ruff` ALONGSIDE it (not instead). Set the `command` accordingly:
+
+| command                              | install                | role                                    |
+| ------------------------------------ | ---------------------- | --------------------------------------- |
+| `["basedpyright-langserver", "--stdio"]` | `pip install basedpyright` | strictest types, **default**       |
+| `["pyright-langserver", "--stdio"]`  | `pip install pyright`  | upstream Microsoft type checker         |
+| `["ty", "server"]`                   | `pip install ty`       | Astral, very fast, pre-1.0/experimental |
+| `["ruff", "server"]`                 | `pip install ruff`     | lint + format only, complements a type server |
+
+Recommended: keep `basedpyright` as the `python` entry. `ruff` does not
+type-check, so if you want lint diagnostics too run it as a separate tool rather
+than replacing the type server.
+
+## Troubleshooting
+- **PATH:** `basedpyright-langserver` must be on PATH; reopen shell after install. `uv tool install` writes to `~/.local/bin`.
+- **Wrong interpreter / missing imports:** the server must see the project venv. Set `python.pythonPath` / `venvPath` in `pyrightconfig.json`, or activate the venv before launching.
+
+## Verify
+
+```bash
+node --experimental-strip-types ../../scripts/verify-lsp.ts path/to/file.py
+# or: bun ../../scripts/verify-lsp.ts path/to/file.py
+```

package/plugins/litclaude/skills/lsp-setup/references/ruby/README.md

@@ -0,0 +1,62 @@
+# Ruby — LSP setup (Claude Code / LitClaude)
+
+- **Recommended server:** `rubocop --lsp`
+- **Extensions:** `.rb .rake .gemspec .ru`
+- **Install hint:** `gem install rubocop`
+
+> **Note:** the executable invoked is **`rubocop`** (`rubocop --lsp`). RuboCop must be installed: `gem install rubocop`.
+
+## Install
+
+- **macOS:** `gem install rubocop`
+- **Linux:** `gem install rubocop`
+- **Windows:** `gem install rubocop`
+
+In a Bundler project, prefer adding `rubocop` to the `Gemfile` and running via `bundle exec`.
+
+Confirm it resolves (check `rubocop`, since that is what runs):
+
+```bash
+command -v rubocop
+```
+
+## Configure
+
+Add a `ruby` entry to `plugins/litclaude/.lsp.json`:
+
+```json
+{
+  "ruby": {
+    "command": ["rubocop", "--lsp"],
+    "extensionToLanguage": {
+      ".rb": "ruby",
+      ".rake": "ruby",
+      ".gemspec": "ruby",
+      ".ru": "ruby"
+    }
+  }
+}
+```
+
+Claude Code routes these extensions to `rubocop --lsp` via the map. Behavior is
+driven by your `.rubocop.yml`; the server surfaces RuboCop diagnostics,
+formatting, and code actions over LSP.
+
+## Alternatives
+
+- **Shopify `ruby-lsp`** — the standalone `ruby-lsp` executable, richer navigation than RuboCop alone. Set the `command` to `["ruby-lsp"]`.
+- **`solargraph`** — older completion/type server; install with `gem install solargraph`, set the `command` to `["solargraph", "stdio"]`.
+
+## Troubleshooting
+
+- **PATH:** `rubocop` on PATH (that is the invoked binary); reopen shell after install.
+- **`rubocop` not found:** install RuboCop with `gem install rubocop`.
+- **Bundler mismatch:** if the project pins RuboCop in its `Gemfile`, run inside the bundle so versions match.
+- **No diagnostics:** check `.rubocop.yml` is valid and not disabling everything.
+
+## Verify
+
+```bash
+node --experimental-strip-types ../../scripts/verify-lsp.ts path/to/file.rb
+# or: bun ../../scripts/verify-lsp.ts path/to/file.rb
+```

package/plugins/litclaude/skills/lsp-setup/references/rust/README.md

@@ -0,0 +1,61 @@
+# Rust — LSP setup (Claude Code / LitClaude)
+
+- **Recommended server:** `rust-analyzer`
+- **Extensions:** `.rs`
+- **Install hint:** `rustup component add rust-analyzer`
+
+## Install
+
+- **macOS:** `rustup component add rust-analyzer` (or `brew install rust-analyzer`)
+- **Linux:** `rustup component add rust-analyzer`
+- **Windows:** `rustup component add rust-analyzer`
+
+The rustup component is the recommended path — it stays pinned to your toolchain.
+`rust-analyzer` also needs the `rust-src` component to index the standard library
+(`rustup component add rust-src`).
+
+Confirm it resolves:
+
+```bash
+command -v rust-analyzer
+```
+
+## Configure
+
+Add a `rust` entry to `plugins/litclaude/.lsp.json`:
+
+```json
+{
+  "rust": {
+    "command": ["rust-analyzer"],
+    "extensionToLanguage": {
+      ".rs": "rust"
+    }
+  }
+}
+```
+
+Claude Code routes `.rs` edits to `rust-analyzer` via the extension map. Options
+such as switching the check command to clippy live in `rust-analyzer` settings
+consumed by your editor, not in `.lsp.json`.
+
+## Alternatives
+
+None — `rust-analyzer` is the official and sole Rust language server.
+
+## Troubleshooting
+- **PATH:** `rust-analyzer` must be on PATH; reopen shell after install. The rustup shim lives in `~/.cargo/bin`.
+- **Exits while loading rust-src:** if rust-analyzer crashes during stdlib indexing, reinstall the source component:
+
+  ```bash
+  rustup component remove rust-src && rustup component add rust-src
+  ```
+
+- **No proc-macro / build script support:** ensure the project builds with `cargo check`; rust-analyzer reuses the same toolchain.
+
+## Verify
+
+```bash
+node --experimental-strip-types ../../scripts/verify-lsp.ts path/to/file.rs
+# or: bun ../../scripts/verify-lsp.ts path/to/file.rs
+```

package/plugins/litclaude/skills/lsp-setup/references/swift/README.md

@@ -0,0 +1,60 @@
+# Swift — LSP setup (Claude Code / LitClaude)
+
+- **Recommended server:** `sourcekit-lsp`
+- **Extensions:** `.swift .objc .objcpp`
+- **Install hint:** `Included with Xcode or the Swift toolchain`
+
+## Install
+
+`sourcekit-lsp` ships with the Swift toolchain — no separate install.
+
+- **macOS:** `xcode-select --install` (or install full Xcode). It resolves to the active toolchain selected by `xcode-select`.
+- **Linux:** Install a swift.org toolchain (`sourcekit-lsp` ships inside it); add the toolchain's `usr/bin` to PATH.
+- **Windows:** Install the swift.org Windows toolchain; `sourcekit-lsp` is bundled.
+
+Confirm it resolves:
+
+```bash
+command -v sourcekit-lsp
+```
+
+## Configure
+
+Add a `swift` entry to `plugins/litclaude/.lsp.json`:
+
+```json
+{
+  "swift": {
+    "command": ["sourcekit-lsp"],
+    "extensionToLanguage": {
+      ".swift": "swift",
+      ".objc": "objective-c",
+      ".objcpp": "objective-cpp"
+    }
+  }
+}
+```
+
+Claude Code routes these extensions to `sourcekit-lsp` via the map. For best
+results the project needs a **SwiftPM `Package.swift`** or a
+`compile_commands.json` compilation database so the server can resolve modules.
+
+## Alternatives
+
+**No mainstream alternative.** `sourcekit-lsp` is the official Apple/swift.org
+server and the only practical choice.
+
+## Troubleshooting
+
+- **PATH:** `sourcekit-lsp` on PATH; reopen shell after install (or after `xcode-select -s`).
+- **Wrong toolchain (macOS):** point `xcode-select` at the right Xcode/toolchain; mismatches cause stale or missing results.
+- **No `Package.swift` / compile db:** add a SwiftPM manifest or generate `compile_commands.json` for accurate indexing.
+- **Objective-C (`.objc`/`.objcpp`):** needs a compilation database to resolve headers and frameworks.
+- **First build slow:** the server builds the module graph on first open; wait for it.
+
+## Verify
+
+```bash
+node --experimental-strip-types ../../scripts/verify-lsp.ts path/to/File.swift
+# or: bun ../../scripts/verify-lsp.ts path/to/File.swift
+```

package/plugins/litclaude/skills/lsp-setup/references/terraform/README.md

@@ -0,0 +1,61 @@
+# Terraform — LSP setup (Claude Code / LitClaude)
+
+- **Recommended server:** `terraform-ls serve`
+- **Extensions:** `.tf .tfvars`
+- **Install hint:** See https://github.com/hashicorp/terraform-ls
+
+## Install
+
+- **macOS:** `brew install hashicorp/tap/terraform-ls`
+- **Linux:** download a release from https://github.com/hashicorp/terraform-ls/releases and place `terraform-ls` on PATH (or `apt`/`dnf` via the HashiCorp repo)
+- **Windows:** `choco install terraform-ls` (or download a release zip)
+
+`terraform-ls` requires the `terraform` binary itself to be installed and on PATH.
+
+Confirm both resolve:
+
+```bash
+command -v terraform-ls
+command -v terraform
+```
+
+## Configure
+
+Add a `terraform` entry to `plugins/litclaude/.lsp.json`:
+
+```json
+{
+  "terraform": {
+    "command": ["terraform-ls", "serve"],
+    "extensionToLanguage": {
+      ".tf": "terraform",
+      ".tfvars": "terraform-vars"
+    }
+  }
+}
+```
+
+Claude Code routes `.tf`/`.tfvars` edits to `terraform-ls` via the map.
+Provider/module completion comes from schemas generated by `terraform init`; run
+it in each module root before expecting full completion:
+
+```bash
+terraform init
+```
+
+## Alternatives
+
+- `tflint` standalone for opinionated linting (complements the LSP).
+- `terraform fmt` for formatting.
+
+## Troubleshooting
+- **PATH:** `terraform-ls` AND `terraform` both on PATH; reopen shell after install.
+- **No provider completion:** run `terraform init` so the `.terraform/` schema cache exists.
+- **`.tfvars` not analyzed:** open the containing module so the server has root context.
+
+## Verify
+
+```bash
+node --experimental-strip-types ../../scripts/verify-lsp.ts path/to/file.tf
+# or: bun ../../scripts/verify-lsp.ts path/to/file.tf
+```

package/plugins/litclaude/skills/lsp-setup/references/typescript/README.md

@@ -0,0 +1,77 @@
+# TypeScript / JavaScript — LSP setup (Claude Code / LitClaude)
+
+- **Recommended server:** `typescript-language-server --stdio`
+- **Extensions:** `.ts .tsx .js .jsx .mjs .cjs .mts .cts`
+- **Install hint:** `npm install -g typescript-language-server typescript`
+
+## Install
+
+- **macOS:** `npm install -g typescript-language-server typescript`
+- **Linux:** `npm install -g typescript-language-server typescript`
+- **Windows:** `npm install -g typescript-language-server typescript` (PowerShell or cmd)
+
+`typescript-language-server` is only a thin wrapper — it needs the `typescript`
+package (`tsserver`) present too, either globally or in the project's
+`node_modules`. Always install both.
+
+Confirm it resolves:
+
+```bash
+command -v typescript-language-server
+```
+
+## Configure
+
+LitClaude declares language servers in `plugins/litclaude/.lsp.json`. Each entry
+is keyed by language name and holds a `command` array plus an
+`extensionToLanguage` map. TypeScript/JavaScript already ships in the default
+config:
+
+```json
+{
+  "typescript": {
+    "command": ["typescript-language-server", "--stdio"],
+    "extensionToLanguage": {
+      ".ts": "typescript",
+      ".tsx": "typescriptreact",
+      ".js": "javascript",
+      ".jsx": "javascriptreact",
+      ".mjs": "javascript",
+      ".cjs": "javascript"
+    }
+  }
+}
+```
+
+Add `.mts`/`.cts` to `extensionToLanguage` if your project uses them. Claude Code
+resolves the server for an edited file by matching its extension against these
+maps.
+
+## Alternatives
+
+Swap the `command` for your toolchain. Keep the same `.lsp.json` shape and adjust
+`extensionToLanguage` to cover the extensions that server should own:
+
+| command                                   | when to choose                          |
+| ----------------------------------------- | --------------------------------------- |
+| `["deno", "lsp"]`                         | Deno projects (handles `.ts/.tsx/.js`)  |
+| `["biome", "lsp-proxy", "--stdio"]`       | Biome lint/format as the LSP            |
+| `["vscode-eslint-language-server", "--stdio"]` | ESLint diagnostics                 |
+| `["oxlint", "--lsp"]`                     | fast Oxc-based linting                  |
+| `["vue-language-server", "--stdio"]`      | `.vue` single-file components           |
+| `["svelteserver", "--stdio"]`             | `.svelte` files                         |
+| `["astro-ls", "--stdio"]`                 | `.astro` files                          |
+
+`eslint` install: `npm i -g vscode-langservers-extracted`. To run Deno instead
+of the default, replace the `typescript` entry's `command` with `["deno", "lsp"]`.
+
+## Troubleshooting
+- **PATH:** `typescript-language-server` must be on PATH; reopen shell after `npm i -g`. Check your global bin with `npm bin -g`.
+- **Missing tsserver:** errors like "Could not find tsserver" mean the `typescript` package is absent — install it globally or in the project.
+
+## Verify
+
+```bash
+node --experimental-strip-types ../../scripts/verify-lsp.ts path/to/file.ts
+# or: bun ../../scripts/verify-lsp.ts path/to/file.ts
+```