cc-dev-template 0.1.79 → 0.1.80

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "cc-dev-template",
-  "version": "0.1.79",
+  "version": "0.1.80",
   "description": "Structured AI-assisted development framework for Claude Code",
   "bin": {
     "cc-dev-template": "./bin/install.js"

package/src/commands/done.md

@@ -1,5 +1,5 @@
 ---
-description: End a session - sync documentation and commit work
+description: End a session - sync documentation, commit, and push
 argument-hint: [next task]
 ---
 

package/src/skills/setup-lsp/SKILL.md

@@ -0,0 +1,15 @@
+---
+name: setup-lsp
+description: Set up LSP language servers for the current project. Use when the user says "setup LSP", "configure LSP", "enable LSP", "install language servers", or "add code intelligence". Use "verify" argument after restart to confirm LSP is working.
+disable-model-invocation: true
+argument-hint: "[verify]"
+---
+
+# Setup LSP
+
+Configure LSP (Language Server Protocol) for the current project so Claude Code uses precise code intelligence instead of grep-based search.
+
+| Argument | Action |
+|----------|--------|
+| No argument | Read `references/step-1-scan.md` |
+| `verify` | Read `references/step-3-verify.md` |

package/src/skills/setup-lsp/references/lsp-registry.md

@@ -0,0 +1,148 @@
+# LSP Registry
+
+## Language Detection
+
+Detect languages by file extensions AND project config files. Config files are more reliable — a `go.mod` is definitive proof of Go usage; a stray `.go` file might not be.
+
+| Config File | Language |
+|-------------|----------|
+| `package.json`, `tsconfig.json`, `jsconfig.json` | TypeScript/JavaScript |
+| `pyproject.toml`, `setup.py`, `setup.cfg`, `requirements.txt`, `Pipfile` | Python |
+| `go.mod` | Go |
+| `Cargo.toml` | Rust |
+| `pom.xml`, `build.gradle`, `build.gradle.kts` | Java |
+| `*.csproj`, `*.sln` | C# |
+| `composer.json` | PHP |
+| `Package.swift` | Swift |
+| `build.gradle.kts` with `kotlin` | Kotlin |
+| `CMakeLists.txt`, `Makefile` with `.c`/`.cpp` | C/C++ |
+
+| Extension | Language |
+|-----------|----------|
+| `.ts`, `.tsx`, `.js`, `.jsx`, `.mts`, `.cts`, `.mjs`, `.cjs` | TypeScript/JavaScript |
+| `.py`, `.pyi` | Python |
+| `.go` | Go |
+| `.rs` | Rust |
+| `.java` | Java |
+| `.cs` | C# |
+| `.php` | PHP |
+| `.swift` | Swift |
+| `.kt`, `.kts` | Kotlin |
+| `.c`, `.h`, `.cpp`, `.cc`, `.cxx`, `.hpp`, `.hxx` | C/C++ |
+| `.lua` | Lua |
+
+## Language Server Details
+
+Each entry: plugin name, binary command, install command, and verification command.
+
+| Language | Plugin | Binary | Install | Verify |
+|----------|--------|--------|---------|--------|
+| TypeScript/JS | `typescript-lsp` | `typescript-language-server` | `npm i -g typescript-language-server typescript` | `which typescript-language-server` |
+| Python | `pyright-lsp` | `pyright-langserver` | `npm i -g pyright` | `which pyright-langserver` |
+| Go | `gopls-lsp` | `gopls` | `go install golang.org/x/tools/gopls@latest` | `which gopls` |
+| Rust | `rust-analyzer-lsp` | `rust-analyzer` | `rustup component add rust-analyzer` | `which rust-analyzer` |
+| Java | `jdtls-lsp` | `jdtls` | `brew install jdtls` | `which jdtls` |
+| C/C++ | `clangd-lsp` | `clangd` | `brew install llvm` | `which clangd` |
+| C# | `csharp-lsp` | `csharp-ls` | `dotnet tool install -g csharp-ls` | `which csharp-ls` |
+| PHP | `php-lsp` | `intelephense` | `npm i -g intelephense` | `which intelephense` |
+| Kotlin | `kotlin-lsp` | `kotlin-lsp` | Install from GitHub releases | `which kotlin-lsp` |
+| Swift | `swift-lsp` | `sourcekit-lsp` | Included with Xcode | `which sourcekit-lsp` |
+| Lua | `lua-lsp` | `lua-language-server` | Install from GitHub releases | `which lua-language-server` |
+
+## Plugin Naming Convention
+
+Plugins are referenced as `{plugin-name}@{marketplace}`. The official marketplace is `claude-plugins-official`.
+
+Example: `typescript-lsp@claude-plugins-official`
+
+## Known Issue: Official Marketplace Plugin Cache Bug
+
+As of early 2026, there is a known bug (GitHub #15148) where plugins installed from `claude-plugins-official` cache only a `README.md` — missing the `.lsp.json` server configuration. This can cause `"No LSP server available for file type"` errors.
+
+**Primary workaround:** Use the `Piebald-AI/claude-code-lsps` community marketplace, which properly structures plugins with `.lsp.json` files and supports additional languages (Ruby, PowerShell, HTML/CSS, Vue, etc.).
+
+```
+claude plugin marketplace add Piebald-AI/claude-code-lsps
+claude plugin install {plugin-name}
+```
+
+**Fallback workaround:** Manually create `.lsp.json` in the cached plugin directory. The `.lsp.json` format:
+
+```json
+{
+  "language-id": {
+    "command": "language-server-binary",
+    "args": ["--stdio"],
+    "extensionToLanguage": {
+      ".ext": "language-id"
+    }
+  }
+}
+```
+
+Example for TypeScript (`~/.claude/plugins/cache/claude-plugins-official/typescript-lsp/1.0.0/.lsp.json`):
+
+```json
+{
+  "typescript": {
+    "command": "typescript-language-server",
+    "args": ["--stdio"],
+    "extensionToLanguage": {
+      ".ts": "typescript",
+      ".tsx": "typescriptreact",
+      ".js": "javascript",
+      ".jsx": "javascriptreact",
+      ".mts": "typescript",
+      ".cts": "typescript",
+      ".mjs": "javascript",
+      ".cjs": "javascript"
+    }
+  }
+}
+```
+
+Example for Python (`~/.claude/plugins/cache/claude-plugins-official/pyright-lsp/1.0.0/.lsp.json`):
+
+```json
+{
+  "python": {
+    "command": "pyright-langserver",
+    "args": ["--stdio"],
+    "extensionToLanguage": {
+      ".py": "python",
+      ".pyi": "python"
+    }
+  }
+}
+```
+
+Example for Go (`~/.claude/plugins/cache/claude-plugins-official/gopls-lsp/1.0.0/.lsp.json`):
+
+```json
+{
+  "go": {
+    "command": "gopls",
+    "args": [],
+    "extensionToLanguage": {
+      ".go": "go"
+    }
+  }
+}
+```
+
+## LSP Operations
+
+Claude Code's LSP tool provides these operations. All use the same `LSP` tool — the operation is chosen based on what the agent needs.
+
+| Operation | What It Does | Use When |
+|-----------|-------------|----------|
+| `workspaceSymbol` | Search for a symbol across the entire project | Finding where something is defined |
+| `goToDefinition` | Jump to the exact definition of a symbol | Navigating to source code |
+| `goToImplementation` | Find concrete implementations of interfaces | Understanding polymorphism |
+| `findReferences` | Find every usage of a symbol | Impact analysis before refactoring |
+| `hover` | Get type signature and docs for a symbol | Understanding types without reading files |
+| `documentSymbol` | List all symbols in a file | Getting an overview of a file's structure |
+| `incomingCalls` | Trace what calls a function | Understanding callers |
+| `outgoingCalls` | Trace what a function calls | Understanding dependencies |
+
+Not every language server supports every operation. If an operation returns no results, it may be unsupported for that language — fall back to Grep.

package/src/skills/setup-lsp/references/step-1-scan.md

@@ -0,0 +1,28 @@
+# Step 1: Scan the Codebase
+
+Determine which languages are used in this project and which LSP servers to install.
+
+## Detect Languages
+
+Read `references/lsp-registry.md` for the detection tables.
+
+1. Use Glob to check for config files first (they are definitive): `go.mod`, `Cargo.toml`, `package.json`, `tsconfig.json`, `pyproject.toml`, `setup.py`, `requirements.txt`, `pom.xml`, `build.gradle`, `*.csproj`, `*.sln`, `composer.json`, `Package.swift`, `CMakeLists.txt`
+2. Then check file extensions as a secondary signal: `.py`, `.ts`, `.go`, `.rs`, `.java`, `.cs`, `.php`, `.swift`, `.kt`, `.c`, `.cpp`, `.lua`
+3. Check existing LSP configuration — read `.claude/settings.json` if it exists to see what's already configured
+
+## Check Prerequisites
+
+Run `claude --version` to verify Claude Code version is 2.0.74 or later.
+
+## Present Findings
+
+Show the user:
+- Which languages were detected and how (config file vs extension)
+- Which LSP servers are recommended for each language
+- Which language server binaries are already installed (check with `which`)
+- Which Claude Code plugins are already installed (check `~/.claude/plugins/installed_plugins.json` if it exists)
+- Any languages detected but not supported by available LSP plugins
+
+Ask the user to confirm which LSPs to install. They may want to skip some languages.
+
+Read `references/step-2-install-configure.md`.

package/src/skills/setup-lsp/references/step-2-install-configure.md

@@ -0,0 +1,85 @@
+# Step 2: Install and Configure
+
+Read `references/lsp-registry.md` for install commands, plugin names, and known issues.
+
+## Install Language Server Binaries
+
+For each confirmed language, check if the binary is already installed (`which <binary>`). Install only what's missing using the install commands from the registry.
+
+Verify each installation succeeded by running the verify command from the registry.
+
+## Install and Enable Claude Code Plugins
+
+For each language, install the Claude Code plugin:
+
+```
+claude plugin install <plugin-name>
+```
+
+If this fails with "Plugin not found in any marketplace", update the marketplace catalog first:
+
+```
+claude plugin marketplace update claude-plugins-official
+```
+
+If plugins still fail or produce errors about missing LSP server configuration, follow the workaround in `references/lsp-registry.md` under "Known Issue: Official Marketplace Plugin Cache Bug" — try the Piebald-AI community marketplace, or manually create `.lsp.json` files using the examples in the registry.
+
+## Configure Project-Level Settings
+
+Create or update `.claude/settings.json` in the project root (NOT `~/.claude/settings.json`).
+
+Merge these settings, preserving any existing configuration:
+
+```json
+{
+  "env": {
+    "ENABLE_LSP_TOOL": "1"
+  },
+  "enabledPlugins": {
+    "<plugin-name>@<marketplace>": true
+  }
+}
+```
+
+Add an `enabledPlugins` entry for each installed plugin. Use the correct marketplace name (either `claude-plugins-official` or `Piebald-AI/claude-code-lsps`).
+
+## Update CLAUDE.md
+
+Read the project's root `CLAUDE.md`. Append the following section if no LSP instructions exist yet. If LSP instructions already exist, update them to match this format.
+
+Tailor the snippet to the languages actually installed — list the language servers that were set up:
+
+```markdown
+## Code Intelligence (LSP)
+
+This project has LSP language servers configured for: [list languages].
+
+Prefer LSP over Grep/Read for code navigation — LSP returns exact, structural results instantly:
+
+| Task | LSP Operation |
+|------|--------------|
+| Find where a symbol is defined | `workspaceSymbol` or `goToDefinition` |
+| Find all usages of a symbol | `findReferences` |
+| Get type info without reading the file | `hover` |
+| List all symbols in a file | `documentSymbol` |
+| Find implementations of an interface | `goToImplementation` |
+| Trace callers/callees of a function | `incomingCalls` / `outgoingCalls` |
+
+Use Grep only for text/pattern searches (comments, strings, config values, regex patterns).
+
+After writing or editing code, check LSP diagnostics and fix type errors before proceeding.
+```
+
+## Tell the User to Restart
+
+LSP servers initialize at startup. The plugins just installed require a full restart of Claude Code to take effect.
+
+Tell the user:
+
+1. Exit Claude Code
+2. Restart Claude Code in this project directory
+3. Run `/setup-lsp verify` to confirm LSP is working
+
+**IMPORTANT: You are not done. You MUST read and complete the next step. The workflow is incomplete without it.**
+
+Read `references/step-4-reflect.md` now.

package/src/skills/setup-lsp/references/step-3-verify.md

@@ -0,0 +1,43 @@
+# Step 3: Verify LSP
+
+This step runs after the user restarts Claude Code and invokes `/setup-lsp verify`.
+
+## Check LSP is Available
+
+1. Read `.claude/settings.json` to confirm `ENABLE_LSP_TOOL` and `enabledPlugins` are set
+2. Try a `workspaceSymbol` search for a common symbol in the project (pick any function or class name visible in the codebase)
+
+If `workspaceSymbol` returns results, LSP is working.
+
+## Test Operations
+
+Run a quick smoke test — try 3-4 different LSP operations against real symbols in the codebase:
+
+- `workspaceSymbol` — search for a known class or function name
+- `documentSymbol` — list symbols in a file that clearly has functions/classes
+- `hover` — get type info on a symbol
+- `findReferences` — find usages of a commonly-used function
+
+Report which operations succeeded and which returned no results. Some operations may not be supported by all language servers — that's expected.
+
+## If LSP is Not Working
+
+Check these in order:
+
+1. **"LSP tool not available"** — `ENABLE_LSP_TOOL` is not set. Verify `.claude/settings.json` has it under `env`
+2. **"No server available for file type"** — the plugin is installed but its `.lsp.json` config is missing (known bug). Read `references/lsp-registry.md` under "Known Issue" for the manual `.lsp.json` fix
+3. **Plugin is disabled** — run `claude plugin list` to check status. Run `claude plugin enable <name>` if disabled
+4. **Binary not in PATH** — verify with `which <binary>`. The language server must be in PATH when Claude Code starts
+
+After fixing, the user needs to restart Claude Code again and re-run `/setup-lsp verify`.
+
+## Report Results
+
+Tell the user:
+- Which LSP servers are active
+- Which operations were tested and their results
+- Any operations that didn't work (with explanation)
+
+**IMPORTANT: You are not done. You MUST read and complete the next step. The workflow is incomplete without it.**
+
+Read `references/step-4-reflect.md` now.

package/src/skills/setup-lsp/references/step-4-reflect.md

@@ -0,0 +1,22 @@
+# Step 4: Reflect
+
+**IMPORTANT: This step is mandatory. The setup-lsp workflow is not complete until this step is finished. Do not skip this.**
+
+## Assess
+
+- Were any install commands wrong, outdated, or platform-specific in a way the registry didn't account for?
+- Did any plugin installations fail? What was the cause and fix?
+- Did the official marketplace plugin cache bug occur? Was the workaround effective?
+- Were there languages detected that had no available LSP plugin?
+- Did the CLAUDE.md snippet accurately reflect the operations that actually worked?
+- Was any step confusing, missing information, or in the wrong order?
+
+## Act
+
+If any instructions were wrong, incomplete, or misleading — identify the specific file, read it, and apply the fix.
+
+Apply the tribal knowledge test: only add information that a fresh Claude instance would not already know. Standard tool usage (npm install, which, etc.) does not need documenting. Workarounds for bugs, non-obvious configuration details, and platform-specific gotchas do.
+
+## Report
+
+Tell the user what you changed and why, or confirm that no updates were needed.