diff --git a/README.md b/README.md index 30d7c00..a62e718 100644 --- a/README.md +++ b/README.md @@ -4,11 +4,15 @@ AI agent skills are reusable instruction sets that extend your coding assistant For generic skills, please visit [cc-skills](https://github.com/samber/cc-skills). + + > [!IMPORTANT] > Bootstrapped with Claude Code by distilling my Go project commits. **Edited, tested, reviewed and reworked by a human**. > > **No AI slop here.** AI-made skills are useless. + + image ## ๐Ÿš€ How to use @@ -146,7 +150,7 @@ These skills are designed as **atomic, cross-referencing units**. A skill may re โ”‚ safety โ”‚ โ”‚ dep-inject โ”‚ โ”‚ troubleshoot โ”‚ โ”‚ CI โ”‚ โ”‚ structs-ifaceโ”‚ โ”‚ data-structs โ”‚ โ”‚ observability โ”‚ โ”‚ stay-updated โ”‚ โ”‚ documentationโ”‚ โ”‚ database โ”‚ โ”‚ โ”‚ โ”‚ dep-management โ”‚ -โ”‚ lint โ”‚ โ”‚ modernize โ”‚ โ”‚ โ”‚ โ”‚ โ”‚ +โ”‚ lint โ”‚ โ”‚ modernize โ”‚ โ”‚ โ”‚ โ”‚ gopls โ”‚ โ”‚ security โ”‚ โ”‚ โ”‚ โ”‚ โ”‚ โ”‚ โ”‚ โ””โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”˜ โ””โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”˜ โ””โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”˜ โ””โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”˜ @@ -208,6 +212,7 @@ These skills are designed as **atomic, cross-referencing units**. A skill may re | | โœ… `golang-lint` | โšก ๐Ÿค– | -41% | 98 | 1,714 | 5,493 | | | โœ… `golang-observability` | โšก ๐Ÿค– โš™๏ธ | -37% | 161 | 2,921 | 18,453 | | | โœ… `golang-performance` | โšก ๐Ÿง  ๐Ÿค– | -39% | 130 | 2,190 | 18,190 | +| | โœ… `golang-gopls` | โšก | โ€” | 219 | 2,308 | 12,076 | | | โœ… `golang-pkg-go-dev` | โšก | โ€” | 185 | 2,693 | 4,302 | | | โœ… `golang-popular-libraries` | โšก | -30% | 61 | 893 | 4,287 | | | โœ… `golang-project-layout` | โšก | -38% | 69 | 1,510 | 5,718 | @@ -345,6 +350,10 @@ CI/CD pipeline configuration for Go projects using GitHub Actions. Build, test, Go module dependency strategies. go.mod conventions, versioning, replace directives, tool dependencies, and multi-module workspaces. +#### `golang-gopls` + +Semantic code intelligence for your local build via `gopls`, the official Go language server. Go-to-definition, find references, call/implementation hierarchy, workspace symbol search, diagnostics, safe rename, and refactors (extract/inline/fill/rewrite). Reachable via gopls's own MCP server, Claude Code's native `LSP` tool, or the `gopls` CLI. + #### `golang-pkg-go-dev` Go package and module exploration via `godig`, a pkg.go.dev API client (CLI + MCP server). Package docs, API references, symbols, code examples, versions, importers, licenses, and known vulnerabilities. Prefer over Context7 for Go packages. diff --git a/skills/golang-data-structures/SKILL.md b/skills/golang-data-structures/SKILL.md index 4fb90fe..6264d3f 100644 --- a/skills/golang-data-structures/SKILL.md +++ b/skills/golang-data-structures/SKILL.md @@ -6,7 +6,7 @@ license: MIT compatibility: Designed for Claude Code or similar AI coding agents, and for projects using Golang. metadata: author: samber - version: "1.1.5" + version: "1.1.6" openclaw: emoji: "๐Ÿ—ƒ" homepage: https://github.com/samber/cc-skills-golang @@ -156,7 +156,7 @@ For advanced data structures (trees, sets, queues, stacks) beyond the standard l - **`deckarep/golang-set`** โ€” thread-safe and non-thread-safe set implementations - **`gammazero/deque`** โ€” fast double-ended queue -When using third-party libraries, refer to their official documentation and code examples for current API signatures. For Go package docs, symbols, versions, importers, and known vulnerabilities, โ†’ See `samber/cc-skills-golang@golang-pkg-go-dev` skill (`godig`) โ€” prefer it over Context7 for Go package facts. To navigate this library's usage in your own code (definitions, call sites, diagnostics), โ†’ See `samber/cc-skills-golang@golang-how-to` skill (`gopls`). Context7 remains a fallback for docs not indexed on pkg.go.dev. +When using third-party libraries, refer to their official documentation and code examples for current API signatures. For Go package docs, symbols, versions, importers, and known vulnerabilities, โ†’ See `samber/cc-skills-golang@golang-pkg-go-dev` skill (`godig`) โ€” prefer it over Context7 for Go package facts. To navigate this library's usage in your own code (definitions, call sites, diagnostics), โ†’ See `samber/cc-skills-golang@golang-gopls` skill (`gopls`). Context7 remains a fallback for docs not indexed on pkg.go.dev. ## Cross-References diff --git a/skills/golang-google-wire/SKILL.md b/skills/golang-google-wire/SKILL.md index d6ecd23..5afdaa7 100644 --- a/skills/golang-google-wire/SKILL.md +++ b/skills/golang-google-wire/SKILL.md @@ -6,7 +6,7 @@ license: MIT compatibility: Designed for Claude Code or similar AI coding agents, and for projects using Golang. metadata: author: samber - version: "1.0.5" + version: "1.0.6" openclaw: emoji: "๐Ÿชก" homepage: https://github.com/samber/cc-skills-golang @@ -36,7 +36,7 @@ Note: `google/wire` was archived in August 2025 (feature-complete; bug fixes sti **Official Resources:** [pkg.go.dev](https://pkg.go.dev/github.com/google/wire) ยท [github.com/google/wire](https://github.com/google/wire) ยท [User Guide](https://github.com/google/wire/blob/main/docs/guide.md) ยท [Best Practices](https://github.com/google/wire/blob/main/docs/best-practices.md) -This skill is not exhaustive. Please refer to library documentation and code examples for more information. For Go package docs, symbols, versions, importers, and known vulnerabilities, โ†’ See `samber/cc-skills-golang@golang-pkg-go-dev` skill (`godig`) โ€” prefer it over Context7 for Go package facts. To navigate this library's usage in your own code (definitions, call sites, diagnostics), โ†’ See `samber/cc-skills-golang@golang-how-to` skill (`gopls`). Context7 remains a fallback for docs not indexed on pkg.go.dev. +This skill is not exhaustive. Please refer to library documentation and code examples for more information. For Go package docs, symbols, versions, importers, and known vulnerabilities, โ†’ See `samber/cc-skills-golang@golang-pkg-go-dev` skill (`godig`) โ€” prefer it over Context7 for Go package facts. To navigate this library's usage in your own code (definitions, call sites, diagnostics), โ†’ See `samber/cc-skills-golang@golang-gopls` skill (`gopls`). Context7 remains a fallback for docs not indexed on pkg.go.dev. ```bash go get -tool github.com/google/wire/cmd/wire@latest diff --git a/skills/golang-gopls/SKILL.md b/skills/golang-gopls/SKILL.md new file mode 100644 index 0000000..c0874a3 --- /dev/null +++ b/skills/golang-gopls/SKILL.md @@ -0,0 +1,92 @@ +--- +name: golang-gopls +description: "Golang semantic code intelligence via `gopls`, the official Go language server โ€” go-to-definition, find references, call/implementation hierarchy, workspace symbol search, package API discovery, diagnostics, safe rename, refactors (extract/inline/fill/rewrite code actions), formatting, and generated tests. Reaches an agent via gopls's own MCP server (`go_*` tools), Claude Code's native `LSP` tool, or the `gopls` CLI. Use when navigating or refactoring Go code โ€” jumping to a definition, finding call sites before a rename, understanding a file's or package's dependencies, running diagnostics after an edit, or extracting/inlining/renaming. Not for the published ecosystem โ€” packages not in your `go.mod`, versions, licenses, importers โ€” โ†’ See `samber/cc-skills-golang@golang-pkg-go-dev` skill (`godig`). Not for a whole-tree vulnerability audit โ†’ See `samber/cc-skills-golang@golang-security` skill (`govulncheck`)." +user-invocable: true +license: MIT +compatibility: Designed for Claude Code or similar AI coding agents. Requires the gopls binary (go install golang.org/x/tools/gopls@latest) v0.20+ on PATH. +metadata: + author: samber + version: "1.0.0" + openclaw: + emoji: "๐Ÿ›ฐ๏ธ" + homepage: https://github.com/samber/cc-skills-golang + requires: + bins: + - go + - gopls + install: + - kind: go + package: golang.org/x/tools/gopls@latest + bins: [gopls] + skill-library-version: "0.22.0" +allowed-tools: Read Edit Write Glob Grep Bash(go:*) Bash(golangci-lint:*) Bash(git:*) Agent Bash(gopls:*) LSP mcp__gopls__* +--- + +**Persona:** You are a Go engineer who reaches for semantic code intelligence instead of grep whenever a question is about the resolved build โ€” grep finds text, `gopls` finds meaning (types, call graphs, shadowing, implementation relationships). + +**Dependencies:** `gopls` โ€” `go install golang.org/x/tools/gopls@latest` (v0.20+). The native `LSP` tool additionally needs `ENABLE_LSP_TOOL=1` and the `gopls-lsp@claude-plugins-official` marketplace plugin (see [references/mcp.md](references/mcp.md)). + +`gopls` is the official Go language server. It only answers questions about **your specific, locally resolved build** โ€” your workspace plus every dependency exactly as pinned in `go.sum`, including `replace` directives. For a package that isn't part of that build (versions, docs, licenses, CVEs of something you haven't added yet), โ†’ See `samber/cc-skills-golang@golang-pkg-go-dev` skill (`godig`) instead. + +## Three ways to reach gopls + +Not interchangeable โ€” pick by what you already know and what you need back: + +- **gopls's own MCP server (preferred for most tasks)** โ€” purpose-built for agents: tools take names, file paths, and fuzzy queries instead of raw cursor positions. Register once per machine: `claude mcp add gopls -- gopls mcp`. Runs headless over stdio, no editor attached, only sees files saved to disk โ€” the right default for an agent-only workflow. See [references/mcp.md](references/mcp.md) for every tool. +- **The native `LSP` tool** โ€” Claude Code's built-in editor-style integration. Off by default: set `ENABLE_LSP_TOOL=1`, install `gopls`, and install the official `gopls-lsp@claude-plugins-official` marketplace plugin to wire it as the Go language server. Operations (`goToDefinition`, `findReferences`, `hover`, `documentSymbol`, `workspaceSymbol`, `goToImplementation`, call hierarchy) are keyed by `line`/`character`, so they're most useful once you already have a location โ€” typically right after a grep or a read. Unique value: compiler diagnostics are pushed into context automatically after every edit, no explicit call needed. +- **The `gopls` CLI** โ€” same engine, invoked as `gopls `. The Go team documents it as experimental and debugging-only โ€” "not efficient, complete, flexible, or officially supported." Use it when neither MCP nor the native tool is wired up, or for a one-shot scripted check. Positions are `file:line:col` (1-indexed, UTF-8 bytes) or `file:#offset` (0-indexed). See [references/cli.md](references/cli.md). + +**Preference order: MCP โ†’ native `LSP` โ†’ CLI.** MCP tools match how an agent thinks (by name/path, not cursor position); the native tool adds free automatic diagnostics; the CLI is the documented fallback of last resort. Wire as many as are available and let the task pick the tool โ€” a query you already have a `line:col` for is cheap via `LSP`, a "where is X" query is cheap via `go_search`, a quick unattended check is cheap via the CLI. + +## Capability โ†’ CLI โ†’ MCP โ†’ native LSP + +Full mapping of every capability to its CLI command, MCP tool, and native `LSP` op: [references/matrix.md](references/matrix.md). + +## Use cases + +- **Navigation** โ€” jump to a definition, an implementation, or trace a call graph before touching code you didn't write. Details: [references/features.md](references/features.md#navigation). +- **Code discovery** โ€” learn a workspace's shape (`go_workspace`), fuzzy-search a symbol you can't place exactly (`go_search`), or read a dependency's public surface (`go_package_api`) before using it. +- **Documentation** โ€” hover for type/doc/size info, signature help while calling a function, or browse rendered package docs (`source.doc`, including internal packages pkg.go.dev never sees). +- **Diagnostics & safety** โ€” compiler and analyzer errors after every edit (`go_diagnostics` / automatic with `LSP`), plus a lightweight `go_vulncheck` reachability check: once as a baseline right after detecting the workspace, and again after any `go.mod` change. +- **Formatting** โ€” canonical `gofmt`-equivalent formatting and import organization, both scriptable and code-action-driven. +- **Refactoring** โ€” safe rename (blocks a change that would break interface satisfaction), extract/inline, and the full `refactor.rewrite.*` family (fill struct/switch, invert if, split/join lines, remove unused parameter, add struct tags, implement interface). Full catalog with gotchas: [references/features.md](references/features.md#transformation). + +## Efficient workflows + +These Read/Edit workflows encode the order that avoids redundant queries and half-applied edits โ€” treat every step as required, not optional, even to save a round trip. + +- **Session start** โ€” call `go_workspace` once to detect whether this is a Go workspace at all; if it is, immediately follow with a baseline `go_vulncheck` to surface vulnerabilities the workspace already carries. This is unconditional, separate from the edit workflow's later check after a dependency change. + +**Read workflow** (understand before touching anything): + +1. `go_workspace` โ€” layout (module/workspace/GOPATH); same call as the session-start check above if it hasn't run yet. +2. `go_search` โ€” fuzzy-locate a type/function/variable by name. +3. `go_file_context` โ€” right after reading any Go file for the first time, see what it pulls in from the rest of its package; re-run if that file's dependencies change. +4. `go_package_api` โ€” a third-party dependency's or sibling package's public surface, without reading every file. + +**Edit workflow** (iterate until diagnostics are clean): + +1. Read first (workflow above). +2. `go_symbol_references` before modifying any definition โ€” judge the blast radius, then read every referencing file that needs a matching edit. +3. Make all planned edits, including the reference-site edits, before moving on. +4. `go_diagnostics` on every changed file โ€” mandatory after each modification, not an optional cleanup pass. +5. Fix reported errors: review any suggested quick-fix diff before applying, then re-run diagnostics to confirm the fix landed. Ignore hint/info diagnostics unrelated to the task. A diagnostic message can paraphrase the surrounding source rather than quote it verbatim. +6. Only if `go.mod` dependencies changed, run `go_vulncheck` on the whole workspace โ€” after diagnostics are clean, not before. +7. Run `go test ` โ€” not `./...` unless explicitly asked, since a full-repo run slows the iteration loop. + +**Gotchas worth knowing before you rely on a result:** + +- `references` results only reflect the **build configuration of the queried file** โ€” a query on `foo_windows.go` will not surface matches in `bar_linux.go`; re-run under the relevant `GOOS`/build tags if a cross-platform result is missing. +- `call_hierarchy` only shows **static** calls โ€” calls through function values or interface methods are invisible to it; corroborate with `references` when the call site matters. +- Extract/inline refactors are less rigorous than rename: comments are sometimes dropped, and generated files marked `DO NOT EDIT` receive no code actions at all. +- `refactor.rewrite.fillStruct` searches only the current file above the cursor and needs the struct's package already imported โ€” run `source.organizeImports` first if the type was just typed in. + +## gopls vs godig vs Context7 vs govulncheck + +`gopls` only reasons about code present and resolvable in the local build: + +- For anything not tied to that build (version history, license, ecosystem-wide importers, CVEs of a package not yet added) โ†’ See `samber/cc-skills-golang@golang-pkg-go-dev` skill (`godig`) โ€” it queries pkg.go.dev directly, no local checkout needed. +- For a comprehensive, whole-tree vulnerability audit (CI gates, periodic sweeps) rather than gopls's lightweight on-demand `go_vulncheck` โ†’ See `samber/cc-skills-golang@golang-security` skill (`govulncheck`). +- Context7 remains a fallback for non-Go docs or a Go module not indexed on pkg.go.dev. + +The full task-to-tool matrix lives in the `samber/cc-skills-golang@golang-how-to` skill's "`godig` vs gopls vs Context7 vs govulncheck" section. diff --git a/skills/golang-gopls/references/cli.md b/skills/golang-gopls/references/cli.md new file mode 100644 index 0000000..8f61ae7 --- /dev/null +++ b/skills/golang-gopls/references/cli.md @@ -0,0 +1,176 @@ +# `gopls` CLI reference + +The Go team documents this interface as experimental โ€” "not efficient, complete, flexible, or officially supported." Treat it as a debugging and one-shot-scripting fallback, not the primary way to drive `gopls`; prefer the MCP tools or the native `LSP` tool when either is available (see [mcp.md](mcp.md)). + +## Table of contents + +- [Position syntax](#position-syntax) +- [Global flags](#global-flags) +- [Shared write flags](#shared-write-flags) +- [Navigation commands](#navigation-commands) +- [Diagnostics](#diagnostics) +- [Transformation commands](#transformation-commands) +- [Code actions and code lenses](#code-actions-and-code-lenses) +- [Introspection](#introspection) +- [CodeAction kind reference](#codeaction-kind-reference) + +## Position syntax + +Two interchangeable formats locate a point in a file: + +- `file.go:line:column` โ€” both 1-indexed; columns count UTF-8 bytes, not runes or UTF-16 code units. Non-ASCII lines can disagree with what an editor reports if the editor counts differently. +- `file.go:#1234` โ€” a 0-indexed byte offset from the start of the file. + +```bash +gopls definition internal/cmd/definition.go:44:47 +gopls definition internal/cmd/definition.go:#1270 +``` + +## Global flags + +Flags accepted by `gopls` itself, before the subcommand: + +| Flag | Value | Purpose | +| --- | --- | --- | +| `-logfile=` | a file path, or the literal string `auto` | Log destination; `auto` picks a default output file instead of stderr | +| `-profile.cpu=` | a file path | Write a CPU profile to this file | +| `-profile.mem=` | a file path | Write a memory profile to this file | +| `-profile.alloc=` | a file path | Write an allocation profile to this file | +| `-profile.block=` | a file path | Write a blocking-profile to this file | +| `-profile.trace=` | a file path | Write an execution trace to this file | +| `-v`, `-verbose` | boolean flag, no value | Verbose output | +| `-vv`, `-veryverbose` | boolean flag, no value | Very verbose output | + +`gopls mcp` accepts its own, narrower flag set: `-listen=` (run over SSE/HTTP instead of stdio), `-logfile=` (defaults to stderr), and `-rpc.trace` (cannot be combined with `-listen`). + +## Shared write flags + +Every command that can modify source (`format`, `imports`, `rename`, `codeaction`, `codelens`, `execute`) accepts this same set โ€” each is a boolean flag, no value: + +| Flag | Purpose | +| --- | --- | +| `-w`, `-write` | Write the edited content back to the source file(s) | +| `-d`, `-diff` | Print a unified diff instead of writing | +| `-l`, `-list` | Print only the names of the files that would be/were edited | +| `-preserve` | Combined with `-w`: keep a copy of each original file before overwriting | + +None of these are mutually exclusive with each other; passing none of them just computes the edit without printing or writing it. + +## Navigation commands + +| Command | Flags | Example | Notes | +| --- | --- | --- | --- | +| `definition` | `-json` (boolean), `-markdown` (boolean) | `gopls definition helper/helper.go:8:6` | `-json` for structured output, `-markdown` to render doc comments as Markdown | +| `references` | `-d`, `-declaration` (boolean) | `gopls references helper/helper.go:8:6` | Includes the declaration itself in the results when set | +| `implementation` | none | `gopls implementation helper/helper.go:8:6` | โ€” | +| `call_hierarchy` | none | `gopls call_hierarchy helper/helper.go:8:6` | Static calls only | +| `symbols` | none | `gopls symbols helper/helper.go` | File-scoped outline | +| `workspace_symbol` | `-matcher=` โ€” one of `fuzzy`, `fastfuzzy`, `casesensitive`, `caseinsensitive` (default `caseinsensitive`) | `gopls workspace_symbol -matcher fuzzy 'wsymbols'` | Matching algorithm for the query | +| `signature` | none | `gopls signature helper/helper.go:8:6` | Function signature at position | +| `highlight` | none | `gopls highlight helper/helper.go:8:6` | Same-symbol identifier highlights | +| `folding_ranges` | none | `gopls folding_ranges helper/helper.go` | Collapsible regions | +| `links` | `-json` (boolean) | `gopls links internal/cmd/check.go` | Structured output when set | +| `prepare_rename` | none | `gopls prepare_rename helper/helper.go:8:6` | Validates a rename is possible at this position before attempting it | +| `semtok` | none | `gopls semtok internal/cmd/semtok.go` | Semantic token dump | + +## Diagnostics + +| Command | Flags | Example | +| --- | --- | --- | +| `check` | `-severity=` โ€” one of `hint`, `info`, `warning`, `error` (default `warning`); reports diagnostics at or above this severity | `gopls check -severity=error internal/cmd/check.go` | + +## Transformation commands + +All of these additionally accept the [shared write flags](#shared-write-flags) above. + +| Command | Positional args | Example | Notes | +| --- | --- | --- | --- | +| `format` | one or more `` (a file, or a range within one) | `gopls format -w internal/cmd/check.go` | Canonical `gofmt`-equivalent; ignores client formatting options | +| `imports` | `` | `gopls imports -w internal/cmd/check.go` | Adds/removes/sorts imports | +| `rename` | ` ` | `gopls rename helper/helper.go:8:6 Foo` | `` is a plain identifier โ€” validate first with `prepare_rename` if unsure | + +## Code actions and code lenses + +`codeaction` and `codelens` additionally accept the [shared write flags](#shared-write-flags). + +| Command | Extra flags | Notes | +| --- | --- | --- | +| `codeaction` | `-kind=` โ€” comma-separated list of kinds, see [CodeAction kind reference](#codeaction-kind-reference) below; `-title=` โ€” filter actions by title; `-exec` (boolean) โ€” execute the first match instead of only listing | `-kind=refactor` matches every kind nested under it (kinds are hierarchical); only one action executes per invocation โ€” there is no conflict resolution for applying more than one; actions of kind `source.test` are excluded unless explicitly requested via `-kind` | +| `codelens` | `-exec` (boolean) โ€” run the first matching lens instead of only listing | Takes ``, ``, or ` ` as positional args | +| `execute` | none beyond the shared write flags | Takes `<command> <json-argument>` โ€” sends a raw LSP `ExecuteCommand` request; gopls's command set (`command.Interface`) is unstable and may change between versions | + +```bash +# List available code actions for a range +gopls codeaction -kind=quickfix ./gopls/main.go + +# Execute the first matching action and show a diff +gopls codeaction -kind=quickfix -exec -diff ./gopls/main.go + +# Filter by title (regex) in addition to kind +gopls codeaction -kind=refactor.rewrite -title 'Fill struct' -exec -w file.go:12:3 + +# Code lenses: list, or run a specific one +gopls codelens a_test.go # list lenses in a file +gopls codelens a_test.go:10 # list lenses on line 10 +gopls codelens a_test.go "run test" # list gopls.run_tests commands +gopls codelens -exec a_test.go:10 "run test" # run a specific test + +# Execute a raw LSP ExecuteCommand +gopls execute gopls.add_import '{"ImportPath": "fmt", "URI": "file:///hello.go"}' +gopls execute gopls.run_tests '{"URI": "file:///a_test.go", "Tests": ["Test"]}' +gopls execute gopls.list_known_packages '{"URI": "file:///hello.go"}' +``` + +## Introspection + +| Command | Flags | Notes | +| --- | --- | --- | +| `stats` | `-anon` (boolean) | JSON summary of workspace info relevant to performance; populates the file cache as a side effect. `-anon` redacts fields that could leak user/file names or source text | +| `version` | none | Print gopls version info | +| `api-json` | none | Print gopls' full API surface as JSON | +| `bug` | none | Report a bug in gopls | +| `licenses` | none | Print licenses of bundled software | + +```bash +gopls stats +gopls stats -anon +gopls version +gopls api-json +gopls bug +gopls licenses +``` + +## CodeAction kind reference + +Passed to `-kind` on `codeaction` (comma-separated, hierarchical โ€” `refactor` matches all `refactor.*`): + +``` +gopls.doc.features +quickfix +refactor +refactor.extract +refactor.extract.constant +refactor.extract.function +refactor.extract.method +refactor.extract.toNewFile +refactor.extract.variable +refactor.inline +refactor.inline.call +refactor.rewrite +refactor.rewrite.changeQuote +refactor.rewrite.fillStruct +refactor.rewrite.fillSwitch +refactor.rewrite.invertIf +refactor.rewrite.joinLines +refactor.rewrite.removeUnusedParam +refactor.rewrite.splitLines +source +source.assembly +source.doc +source.fixAll +source.freesymbols +source.organizeImports +source.test +``` + +A few additional kinds exist beyond this `-kind`-documented set but are reachable only through editor UI or `execute`/code lens, not by name filter: `refactor.extract.variable-all`, `refactor.extract.constant-all`, `refactor.inline.variable`, `refactor.rewrite.moveParamLeft`, `refactor.rewrite.moveParamRight`, `refactor.rewrite.eliminateDotImport`, `refactor.rewrite.addTags`, `refactor.rewrite.removeTags`, `refactor.rewrite.implementInterface`, `source.addTest`, `source.splitPackage`, `source.toggleCompilerOptDetails`. See [features.md](features.md#transformation) for what each one does. diff --git a/skills/golang-gopls/references/features.md b/skills/golang-gopls/references/features.md new file mode 100644 index 0000000..e71b0f0 --- /dev/null +++ b/skills/golang-gopls/references/features.md @@ -0,0 +1,136 @@ +# gopls feature catalog + +Source: [tip.golang.org/gopls/features](https://tip.golang.org/gopls/features/). Each entry names the LSP request or `CodeAction` kind so a specific behavior can be looked up in the upstream docs by exact term. + +## Table of contents + +- [Navigation](#navigation) +- [Passive (always-on)](#passive-always-on) +- [Diagnostics](#diagnostics) +- [Transformation](#transformation) +- [Web-based features](#web-based-features) +- [Non-Go files](#non-go-files) +- [Completion](#completion) + +## Navigation + +**Definition** (`textDocument/definition`, CLI `gopls definition`) โ€” jumps to a symbol's declaration. Handles more than plain identifiers: on an import path it lists the imported package's declarations; on a `go:linkname` directive it finds the linked symbol; on a `go:embed` pattern it finds the embedded file; on a doc-comment link it follows the reference; on a non-Go function it can return the assembly implementation; on `return` it locates the named result variables; on `goto`/`break`/`continue` it finds the target label or block. Already at the declaration โ†’ most clients reinterpret the request as "find references" instead. + +**Type Definition** (`textDocument/typeDefinition`, no CLI equivalent) โ€” jumps to the _named type_ underlying a symbol, unwrapping pointer, array, slice, channel, and map constructors first. For `x chan []*T`, this reports the definition of `T`. Only works on symbols, not arbitrary expressions. + +**References** (`textDocument/references`, CLI `gopls references`) โ€” lists every use of a symbol. For an interface method, this includes concrete implementations; for a package declaration, it includes both direct imports and other files' package clauses; for an embedded field, it reports only field references (use Type Definition to find references to the type itself). **Scoping gotcha:** results reflect only the build configuration of the queried file โ€” a query issued against `foo_windows.go` will not surface a match in `bar_linux.go`. Built-in symbols (`int`, `append`) are rejected as too numerous to be useful. + +**Implementation** (`textDocument/implementation`, CLI `gopls implementation`) โ€” on an interface, returns concrete implementations and sub-interfaces; on a concrete type, returns interfaces it satisfies; on an interface method, returns the concrete methods satisfying it, and vice versa. Matching uses method sets for types and signatures for functions. Generic types are treated as wildcards: a candidate is included if _any_ instantiation would allow one to implement the other, without full unification checking. LSP's built-in bias toward subtypes makes this query directionally asymmetric โ€” for full bidirectional traversal, use Type Hierarchy instead. + +**Document Symbol** (`textDocument/documentSymbol`, CLI `gopls symbols`) โ€” outline of a single file's top-level declarations. File-scoped; use Symbol for cross-file search. + +**Symbol / Workspace Symbol** (`workspace/symbol`, CLI `gopls workspace_symbol`) โ€” fuzzy search across the whole workspace. Default matcher is `fastFuzzy` (FZF-inspired), so abbreviations and typos still match โ€” `DocSym` matches `DocumentSymbol`. Controlled by the `symbolMatcher`, `symbolStyle`, and `symbolScope` settings (see [settings.md](settings.md)); `directoryFilters` excludes directories from the search. + +**Selection Range** (`textDocument/selectionRange`, no CLI equivalent) โ€” expands or contracts the current selection along syntactic boundaries (expression โ†’ statement โ†’ block โ†’ function). Useful for selecting exactly the region an Extract refactor needs. + +**Call Hierarchy** (`textDocument/prepareCallHierarchy` + `callHierarchyItem/incomingCalls`/`outgoingCalls`, CLI `gopls call_hierarchy`) โ€” shows a function's callers and callees as a static graph. **Only static calls are included** โ€” calls made through a function value or an interface method are invisible, since detecting them isn't analytically tractable. Corroborate with References when a dynamically-dispatched call site matters. Invoke on the function declaration's name. + +**Type Hierarchy** (`textDocument/prepareTypeHierarchy` + `typeHierarchyItem/subtypes`/`typeHierarchy/supertypes`, no CLI equivalent yet) โ€” bidirectional view of the subtyping relation: which types implement an interface, and which interfaces a type satisfies. Resolves the asymmetry Implementation has. Limited to **named types** (unlike Implementation, which also matches unnamed function types); alias types are excluded; function-local types are visible only within the same package. + +## Passive (always-on) + +These need no explicit invocation โ€” they fire continuously as an editor session progresses. Most degrade if the surrounding package has build errors, since they depend on successful type-checking. + +**Hover** (`textDocument/hover`) โ€” symbol name/kind/type/value, doc comment (with clickable doc links like `[fmt.Printf]`), promoted methods from embedded fields, struct field size/offset and wasted-space percentage (flagged at โ‰ฅ20% waste), expanded `//go:embed` patterns, `//go:linkname` targets, and which Go release introduced a given stdlib symbol. Controlled by `hoverKind` (verbosity) and `linkTarget` (base URI for doc links). + +**Signature Help** (`textDocument/signatureHelp`) โ€” parameter names/types/docs for the function being called, with the active parameter highlighted; works even while the cursor sits inside the function name, not just inside the parens. + +**Document Highlight** (`textDocument/documentHighlight`) โ€” highlights every identifier referring to the same symbol in view, plus related tokens: named results and their return statements, loop control keywords (`for`/`break`/`continue`), switch tokens, a function and its own return statements. Read vs. write references are typically color-coded differently by the client. + +**Inlay Hint** (`textDocument/inlayHint`) โ€” inline annotations, off by default (visual clutter), toggled per-kind via the `hints` setting: `parameterNames` (call-site argument labels), `assignVariableTypes`, `compositeLiteralFields`, `compositeLiteralTypes`, `constantValues` (including computed `iota` values), `functionTypeParameters` (generic instantiations), `rangeVariableTypes`. + +**Semantic Tokens** (`textDocument/semanticTokens`) โ€” richer syntax coloring than naive lexing: token types (`function`, `keyword`, `macro`, `method`, `namespace`, `number`, `operator`, `parameter`, `string`, `type`, `typeParameter`, `variable`, โ€ฆ) plus modifiers including a custom `shadowing` modifier that flags shadowed declarations. Off by default due to type-checking latency (`semanticTokens` setting); `noSemanticString`/`noSemanticNumber` let a client opt out of just those two kinds if it prefers its own lexical highlighting for them. + +**Folding Range** (`textDocument/foldingRange`) โ€” collapsible regions for large comments, functions, and blocks. + +**Document Link** (`textDocument/documentLink`) โ€” turns URLs in doc comments and import declarations into clickable links (imports link to their pkg.go.dev page). Controlled by `importShortcut` and `linkTarget`. + +## Diagnostics + +Three sources, distinguished by the LSP diagnostic's `source` field: + +1. **Compilation errors** โ€” gopls doesn't invoke the real compiler; it runs `go list` for package metadata (`source: "go list"`) then mimics the compiler front-end itself: read, scan, parse, type-check (`source: "compiler"`). +2. **Analysis findings** โ€” the `go vet` analysis framework plus gopls's own analyzers, each reporting under its own analyzer name as `source`. The `printf` analyzer (format-string/argument mismatches) is a representative example. +3. **Compiler optimization details** โ€” off by default; toggled per-package with the `source.toggleCompilerOptDetails` code action. Surfaces escape-analysis results, nil-check elimination, and inlining decisions. Only available on packages that are otherwise error-free. + +**Recomputation timing:** open-file compile errors update within tens of milliseconds of a keystroke. Workspace-wide analysis diagnostics recompute after roughly a second of idle time, tunable via `diagnosticsDelay`; `diagnosticsTrigger` can switch this to save-triggered instead of edit-triggered. Clients can also request diagnostics explicitly (`textDocument/diagnostic`, "pull diagnostics") if initialized with `pullDiagnostics: true` โ€” off by default for performance. + +**Notable quick fixes**, offered as code actions attached to a diagnostic: + +- `fillreturns` โ€” heuristically completes an incomplete `return` statement. +- `stubMissingInterfaceMethods` โ€” generates stub methods when a concrete type doesn't yet satisfy a required interface. +- `StubMissingCalledFunction` โ€” creates a stub for an undefined function/method, inferring its signature from the call site. +- `CreateUndeclared` โ€” declares a missing variable or function based on how it's used. +- Fixes marked `source.fixAll` are considered unconditionally safe; most editors offer a single shortcut to apply all of them at once. + +CLI: `gopls check <file>` (`-severity=hint|info|warning|error`, default `warning`). + +## Transformation + +Three underlying mechanisms: **Formatting** and **Rename** are primary LSP requests; most everything else is a **CodeAction** (requested per-range, returns either a direct edit or a lazily-computed command); a handful of dependency-management actions are **CodeLenses** instead. + +**Formatting** (`textDocument/formatting`, CLI `gopls format`) โ€” canonical Go formatting; client-supplied formatting options are ignored. `gofumpt: true` switches to `mvdan.cc/gofumpt`'s stricter rules. + +**Organize Imports** (`source.organizeImports`, CLI `gopls imports`) โ€” removes unused/duplicate imports, adds missing ones (via workspace-wide heuristics โ€” occasionally surprising), sorts them. The `local` setting groups a path prefix as "local," matching `goimports -local`. Most editors run this on save; disable per-language if that's unwanted. + +**Rename** (`textDocument/rename`, CLI `gopls rename`) โ€” two-stage: `prepareRename` reports the current name, then `rename` applies the change everywhere. Refuses renames that would introduce shadowing or break interface satisfaction. Special positions unlock extra behavior: + +- Rename a **method's receiver declaration** โ†’ renames the receiver identifier across every method of that type; rename a receiver **use** โ†’ renames only that one variable. +- Rename the **package name in a `package` clause** โ†’ moves every file in the package to a new directory (subpackages stay put unless `renameMovesSubpackages` is set); refused across module boundaries or into an existing package. +- Rename the **`func` keyword** of a declaration โ†’ lets you edit the whole signature; parameter/result count and types must stay the same (no adding/removing parameters this way โ€” see `refactor.rewrite.removeUnusedParam`/`moveParamLeft`/`moveParamRight` for that). + +**Extract** (`refactor.extract.*`) โ€” replaces a selection with a reference to a new declaration: + +- `refactor.extract.variable` / `.constant` โ€” one new local binding for the selected expression, plus `-all` variants that rewrite every occurrence within the enclosing function. +- `refactor.extract.function` / `.method` โ€” turns one or more complete statements into a call to a new function (or method, on the same receiver, if extracted inside a method). +- `refactor.extract.toNewFile` (gopls โ‰ฅ v0.17.0) โ€” moves selected top-level declarations into a new file, adding imports as needed; the new filename derives from the first declared symbol. + +Extract is less rigorous than Rename/Inline: comments are sometimes dropped, and files carrying a `DO NOT EDIT` generated-code marker receive no code actions at all. + +**Inline** (`refactor.inline.*`): + +- `refactor.inline.call` โ€” replaces a call with the function body, substituting parameters for arguments. Works only for static calls to accessible functions/methods (not through a function value or interface method, not to unexported names outside the package, not into `internal` packages, not for generic functions). Preserves side-effect ordering (introduces `var`s when an argument must not be duplicated or reordered), keeps qualified references correct (`Printf` โ†’ `fmt.Printf` with the import added), keeps implicit conversions explicit, and never drops a variable's last use. `defer` bodies stay wrapped in a closure since defer semantics are tied to function boundaries. +- `refactor.inline.variable` โ€” replaces a local variable's use with its initializer expression; refuses if an identifier in that initializer has been shadowed since the declaration. + +**Miscellaneous rewrites** (`refactor.rewrite.*`): + +- `removeUnusedParam` โ€” the `unusedparams` analyzer offers renaming to `_` (trivial) or a full signature change that also updates every caller, preserving side-effecting arguments. +- `moveParamLeft` / `moveParamRight` โ€” reorders one parameter, updating every call site. +- `changeQuote` โ€” toggles a string literal between raw (`` `...` ``) and interpreted (`"..."`) form; idempotent to apply twice. +- `invertIf` โ€” negates a plain `if`/`else` condition (no `else if` chain) and swaps the two blocks. +- `splitLines` / `joinLines` โ€” expands or collapses a bracketed list (composite literal, call arguments, signature) one item per line; skipped for lists that already contain `//` comments or have fewer than two items. +- `fillStruct` โ€” populates missing struct-literal fields, matching field names to in-scope variables/constants/functions where possible, zero value otherwise. Searches only the current file, above the cursor โ€” run `source.organizeImports` first if the struct type was just introduced. +- `fillSwitch` โ€” adds missing cases for an enum-like set of named constants, or for a type switch (one case per concrete type implementing the interface, plus a default that panics on an unexpected type). +- `eliminateDotImport` โ€” removes a dot import and qualifies every reference, offered only when no name collision would result. +- `addTags` / `removeTags` โ€” adds or removes struct field tags (e.g. `json`); interactive clients can choose the naming transform (`camelCase`, `snake_case`, `lisp-case`, `PascalCase`, `Title Case`). +- `implementInterface` โ€” adds placeholder method declarations so a named type satisfies a chosen interface (defaults to `error`); interactive-dialog only, gopls-specific. + +**Add Test For Function** (`source.addTest`) โ€” generates a table-driven test for the selected function/method, creating the `_test.go` file if needed (copying copyright/build-constraint comments), using an external `p_test` package to encourage testing exported API only, naming results `got`/`got2`/โ€ฆ, comparing against `want`/`want2`/โ€ฆ, and adding a `wantErr bool` field when the final result is `error`. For a method, searches the package for a constructor (preferring `NewT` for type `T`). A leading `context.Context` parameter gets `t.Context()` on Go 1.24+, `context.Background()` otherwise. + +## Web-based features + +gopls runs a small localhost web server (LSP `window/showDocument`) for reports too rich for inline editor UI. Every endpoint URL embeds a random auth token; restarting gopls invalidates old links and shows a disconnected banner on any page still open. + +- **Package Documentation** (`source.doc`) โ€” a pkgsite-style rendered view of a package's docs, including **internal, unpublished packages** pkg.go.dev never sees. Symbol links jump the editor to the source declaration; reload without saving to see current edits reflected. +- **Free Symbols** (`source.freesymbols`) โ€” lists the symbols a selection references but doesn't define itself, grouped as imported (with doc links), local, or package-level โ€” the exact input list an Extract Function/Method refactor would need. +- **Assembly** (`source.assembly`) โ€” the compiled assembly listing for a function, source-line-linked, recompiled on each reload. Architecture follows the file's build tags (e.g. `foo_amd64.go`). Not yet supported for generic functions, `func init`, or functions in test packages. +- **Split Package** (`source.splitPackage`) โ€” an interactive dependency-graph tool for planning how to break a package into smaller, acyclic components. It visualizes the split but does not yet perform the actual code movement/renaming. + +All of these send edits/navigation back to the editor via `showDocument`, which works even against modified-but-unsaved source. + +## Non-Go files + +**Templates** (`text/template`/`html/template`) โ€” disabled until `templateExtensions` lists at least one extension (templates have no canonical extension of their own); the editor also needs to associate that extension with the `tmpl`/`gotmpl` language ID (e.g. VS Code's `files.associations`). Inside `{{ }}` delimiters: diagnostics (parse errors; missing functions are not flagged), full syntax highlighting, definitions and references (all templates share one global scope), and completions. Hover, semantic tokens, symbol search, and document highlight are not yet implemented. Custom delimiters other than `{{`/`}}` are not understood. + +**go.mod / go.work** โ€” hover, hints, vulncheck-driven diagnostics, and code lenses (add dependency, upgrade dependency, tidy, run `govulncheck`) are supported; the upstream page marks the fine-grained behavior of each as still under documentation, so verify current behavior directly against a `go.mod` file in an editor session rather than relying on an exhaustive list here. + +**Assembly (`.s`) files** โ€” basic support exists; treat as best-effort. + +## Completion + +Upstream documentation for this feature is a stub as of this writing (tracked as [golang/go#62022](https://github.com/golang/go/issues/62022)) โ€” rely on empirical behavior plus these known settings rather than a documented spec: `usePlaceholders` (fills in placeholder parameter names on completion), `completeFunctionCalls` (adds trailing parentheses, on by default), `completeUnimported` and `matcher`/`deepCompletion`-style settings shape whether not-yet-imported packages and nested field/method completions are offered. See [settings.md](settings.md) for the full settings surface. diff --git a/skills/golang-gopls/references/matrix.md b/skills/golang-gopls/references/matrix.md new file mode 100644 index 0000000..b6ffaf3 --- /dev/null +++ b/skills/golang-gopls/references/matrix.md @@ -0,0 +1,35 @@ +# Capability โ†’ CLI โ†’ MCP โ†’ native LSP + +Every gopls capability, mapped to its CLI command, MCP tool, and native `LSP` tool operation where one exists. `โ€”` means that surface has no path to this capability. + +| Capability | CLI | MCP tool | Native LSP op | +| --- | --- | --- | --- | +| Workspace layout (module/workspace/GOPATH) | `gopls stats` | `go_workspace` | โ€” | +| Fuzzy-find a symbol by name, workspace-wide | `gopls workspace_symbol <query>` | `go_search` | `workspaceSymbol` | +| Go to definition | `gopls definition f:l:c` | โ€” (use `go_file_context`/`go_package_api`) | `goToDefinition` | +| Go to type definition | โ€” (unsupported) | โ€” | `goToTypeDefinition` | +| Find all references | `gopls references f:l:c` | `go_symbol_references` | `findReferences` | +| Implements / implemented-by | `gopls implementation f:l:c` | โ€” | `goToImplementation` | +| Full subtype/supertype tree | โ€” (not yet supported) | โ€” | Type Hierarchy | +| Call graph (callers/callees) | `gopls call_hierarchy f:l:c` | โ€” | Call Hierarchy | +| Expand/contract selection along syntax boundaries | โ€” (unsupported) | โ€” | `selectionRange` (editor gesture, no agent-invoked path) | +| File's own symbols (outline) | `gopls symbols <file>` | `go_file_context` | `documentSymbol` | +| A package's public API | โ€” | `go_package_api` | (hover per-symbol) | +| A file's intra-package dependencies | โ€” | `go_file_context` | โ€” | +| Hover info (type, doc, size/offset) | โ€” | โ€” | `hover` | +| Signature help | `gopls signature f:l:c` | โ€” | signature help | +| Same-symbol identifier highlights | `gopls highlight f:l:c` | โ€” | `documentHighlight` (not in the native tool's fixed op list) | +| Semantic tokens (rich syntax coloring) | `gopls semtok <file>` | โ€” | `semanticTokens` (editor-automatic, not agent-invoked) | +| Folding ranges (collapsible regions) | `gopls folding_ranges <file>` | โ€” | `foldingRange` (editor-automatic, not agent-invoked) | +| Document links (URLs in doc comments/imports) | `gopls links <file>` | โ€” | `documentLink` (editor-automatic, not agent-invoked) | +| Compiler + analyzer diagnostics | `gopls check <file>` | `go_diagnostics` | automatic, pushed after every edit | +| Vulnerability reachability (current build) | โ€” | `go_vulncheck` | โ€” | +| Safe rename (symbol, receiver, package move, signature) | `gopls rename -w f:l:c NewName` | `go_rename_symbol` | rename | +| Organize / fix imports | `gopls imports -w <file>` | โ€” | `source.organizeImports` code action | +| Format | `gopls format -w <file>` | โ€” | `textDocument/formatting` | +| Refactor (extract, inline, fill, rewrite โ€” see [features.md](features.md)) | `gopls codeaction -kind=<kind> -exec -w <file>` | โ€” | code action | +| Generate a test for a function | `gopls codelens -exec <file:line> "..."` (via `source.addTest`) | โ€” | code action / code lens | +| Rendered package documentation (incl. internal packages) | โ€” | โ€” | `source.doc` code action โ†’ browser report | +| Free symbols of a selection (inputs before extracting) | โ€” | โ€” | `source.freesymbols` code action โ†’ browser report | +| Assembly listing for a function | โ€” | โ€” | `source.assembly` code action โ†’ browser report | +| Split-package dependency planning | โ€” | โ€” | `source.splitPackage` code action โ†’ browser report | diff --git a/skills/golang-gopls/references/mcp.md b/skills/golang-gopls/references/mcp.md new file mode 100644 index 0000000..fbeb98e --- /dev/null +++ b/skills/golang-gopls/references/mcp.md @@ -0,0 +1,75 @@ +# gopls MCP server & native `LSP` tool reference + +## Table of contents + +- [Starting the server](#starting-the-server) +- [Registering with Claude Code](#registering-with-claude-code) +- [MCP tools](#mcp-tools) +- [The native `LSP` tool](#the-native-lsp-tool) +- [What the MCP server can and cannot do](#what-the-mcp-server-can-and-cannot-do) + +## Starting the server + +A standalone gopls instance speaking MCP over stdin/stdout, launched fresh per session, no LSP client involved: + +```bash +gopls mcp +``` + +Only sees files as they exist **on disk** โ€” an edit made through a different tool but not yet saved is invisible to it. This is the right mode for an agent-only workflow with no attached editor. + +## Registering with Claude Code + +```bash +claude mcp add gopls -- gopls mcp +``` + +## MCP tools + +Eight tools, all keyed by name/path/query rather than cursor position โ€” this is the main ergonomic difference from the native `LSP` tool. + +| Tool | Purpose | Example | +| --- | --- | --- | +| `go_workspace` | Learn the workspace's overall structure โ€” module, multi-module workspace, or GOPATH project. Call this first, once per session. | `go_workspace({})` | +| `go_vulncheck` | On-demand reachability check: which known vulnerabilities does the _current_ build actually reach. Run right after `go_workspace` if in a Go workspace, and again after any `go.mod` change. | `go_vulncheck({"pattern":"./..."})` | +| `go_search` | Fuzzy search for a type, function, or variable by name across the workspace โ€” use when you don't know the exact location. | `go_search({"query":"server"})` | +| `go_file_context` | Summarize a file's dependencies on other files in the _same package_. Run this immediately after reading any Go file for the first time. | `go_file_context({"file":"/path/to/server.go"})` | +| `go_package_api` | Show a package's public API โ€” most valuable for third-party dependencies or sibling packages in a monorepo you haven't read file-by-file. | `go_package_api({"packagePaths":["example.com/internal/storage"]})` | +| `go_symbol_references` | Find every reference to a symbol โ€” run before modifying any definition to gauge the blast radius. | `go_symbol_references({"file":"/path/to/server.go","symbol":"Server.Run"})` | +| `go_diagnostics` | Build/analysis errors for the given files โ€” mandatory after every edit. | `go_diagnostics({"files":["/path/to/server.go"]})` | +| `go_rename_symbol` | Rename a symbol and every reference to it, workspace-wide, with the same safety checks as LSP rename (blocks changes that would break interface satisfaction). | โ€” | + +See [SKILL.md](../SKILL.md#efficient-workflows) for the Read/Edit workflow order these tools are designed to be chained in. + +## The native `LSP` tool + +Claude Code's built-in editor-style integration โ€” a different mechanism from the MCP server above, worth wiring in addition to it, not instead of it. + +**Enabling it:** + +1. Set the environment variable `ENABLE_LSP_TOOL=1` (off by default). +2. Install `gopls` (`go install golang.org/x/tools/gopls@latest`). +3. Install the official `gopls-lsp@claude-plugins-official` marketplace plugin to wire `gopls` as the Go language server backing the tool. + +**Operations**, all keyed by `line`/`character` rather than name/path: + +- `goToDefinition` +- `findReferences` +- `hover` +- `documentSymbol` +- `workspaceSymbol` +- `goToImplementation` +- call hierarchy + +Because these need a location up front, they're most efficient once you already have one โ€” right after a grep or a file read โ€” rather than as the first move in an investigation (that's what `go_search` on the MCP server is for). + +**Its unique value:** compiler diagnostics are pushed into context **automatically after every edit**, with no explicit diagnostics call needed โ€” the MCP server's `go_diagnostics` requires an explicit invocation each time. + +## What the MCP server can and cannot do + +The gopls MCP server wraps LSP functionality with these boundaries: + +- **Can**: read files from the filesystem and return their contents; execute `go` commands to load package metadata (which may reach `proxy.golang.org` and write to the local Go module/build cache); write to gopls's own cache/configuration files; upload telemetry if the user has opted in. +- **Cannot**: make arbitrary writes to the source tree outside of the edits a tool call explicitly returns; make arbitrary network requests beyond what `go` itself needs to resolve the build. + +Either mode โ€” MCP or native `LSP` โ€” only ever reasons about code that is present and resolvable in the local build: the workspace plus every dependency exactly as pinned in `go.sum`, including `replace` directives. For anything outside that boundary, โ†’ See `samber/cc-skills-golang@golang-pkg-go-dev` skill (`godig`). diff --git a/skills/golang-gopls/references/settings.md b/skills/golang-gopls/references/settings.md new file mode 100644 index 0000000..931faed --- /dev/null +++ b/skills/golang-gopls/references/settings.md @@ -0,0 +1,80 @@ +# gopls settings reference + +Source: [tip.golang.org/gopls/settings](https://tip.golang.org/gopls/settings). Settings are passed via the LSP client's `initializationOptions` (editor-specific config file/UI) โ€” there is no `gopls.json` read from the workspace by default. Full canonical list: `gopls api-json`. Store the settings in CLAUDE.md. + +## Table of contents + +- [Build](#build) +- [Formatting](#formatting) +- [Diagnostics](#diagnostics) +- [Documentation](#documentation) +- [Inlay hints](#inlay-hints) +- [Navigation](#navigation) + +## Build + +| Setting | Type | Default | Purpose | +| --- | --- | --- | --- | +| `buildFlags` | `[]string` | `[]` | Extra flags for the build system, most commonly `-tags=<tag>` to bring build-tagged files into scope | +| `env` | `map[string]string` | `{}` | Environment variables for external commands gopls shells out to (`go list`, etc.) | +| `directoryFilters` | `[]string` | `["-**/node_modules"]` | Include/exclude workspace directories from loading and from workspace-symbol search, using `+`/`-` prefixed glob patterns | +| `expandWorkspaceToModule` | `bool` | `true` | Whether the enclosing module (not just the opened directory) counts as "workspace" for diagnostics scope | +| `templateExtensions` | `[]string` | `[]` | File extensions treated as Go template files (templates have no canonical extension, so this is empty by default) | + +**When it matters:** a symbol behind a build tag (`//go:build integration`) is invisible to `references`/`go_search` until `buildFlags: ["-tags=integration"]` is set โ€” this is the same root cause as the References build-configuration scoping gotcha in [features.md](features.md#navigation). + +## Formatting + +| Setting | Type | Default | Purpose | +| --- | --- | --- | --- | +| `local` | `string` | `""` | Import path prefix treated as "local" for import grouping/sort order โ€” equivalent to `goimports -local` | +| `gofumpt` | `bool` | `false` | Format with `mvdan.cc/gofumpt`'s stricter ruleset instead of plain `gofmt` | + +## Diagnostics + +| Setting | Type | Default | Purpose | +| --- | --- | --- | --- | +| `analyses` | `map[string]bool` | `{}` | Enable/disable individual analyzers by name (the `go vet`-based framework plus gopls's own) | +| `staticcheck` | `bool` | `false` | Enable the staticcheck.io analyzer suite in addition to the built-in analyzers | +| `vulncheck` | enum: `Off`\|`Imports`\|`Prompt` | `"Prompt"` (or `"Off"` in some client defaults) | Whether/how vulnerability-driven diagnostics on `go.mod` run | +| `diagnosticsDelay` | `time.Duration` | `"1s"` | Idle time after an edit before workspace-wide analysis diagnostics recompute (open-file compile errors update sooner regardless) | +| `diagnosticsTrigger` | enum: `Edit`\|`Save` | `"Edit"` | Whether diagnostics recompute on every edit or only on save | +| `pullDiagnostics` | `bool` | `false` | Let the client request diagnostics on demand (`textDocument/diagnostic`) instead of only receiving pushed updates | + +**When it matters:** a large monorepo with `diagnosticsTrigger: "Edit"` (the default) can feel laggy under `diagnosticsDelay: "1s"` on every keystroke pause โ€” switching to `"Save"` trades immediacy for fewer full-workspace recomputations. Turning on `staticcheck` surfaces a materially different (larger) set of findings than the default analyzer set โ€” expect more `go_diagnostics`/`gopls check` output afterward, not a regression. + +## Documentation + +| Setting | Type | Default | Purpose | +| --- | --- | --- | --- | +| `hoverKind` | enum: `FullDocumentation`\|`SingleLine`\|`Structured`\|`NoDocumentation`\|`SynopsisDocumentation` | `"FullDocumentation"` | How much doc text Hover renders | +| `linksInHover` | `bool` | `true` | Whether hover markdown includes doc-comment links | +| `linkTarget` | `string` | `"pkg.go.dev"` | Base host used when generating documentation links (hover, Document Link, diagnostics) | + +## Inlay hints + +| Setting | Type | Default | Purpose | +| --- | --- | --- | --- | +| `hints` | `map[string]bool` | `{}` (all off) | Enables specific inlay hint kinds โ€” keys are `parameterNames`, `assignVariableTypes`, `compositeLiteralFields`, `compositeLiteralTypes`, `constantValues`, `functionTypeParameters`, `rangeVariableTypes` | + +Example: + +```json +"hints": { + "parameterNames": true, + "assignVariableTypes": true +} +``` + +## Navigation + +| Setting | Type | Default | Purpose | +| --- | --- | --- | --- | +| `symbolMatcher` | enum: `FastFuzzy`\|`Fuzzy`\|`CaseSensitive`\|`CaseInsensitive` | `"FastFuzzy"` | Matching algorithm for `workspace/symbol` / `go_search` | +| `symbolScope` | enum: `all`\|`workspace` | `"all"` | Whether symbol search covers only workspace packages or every loaded package (including dependencies) | +| `symbolStyle` | enum | โ€” | How matched symbols are qualified in the response (package-qualified vs. bare) | +| `codelenses` | `map[string]bool` | โ€” | Enables/disables individual code lenses (e.g. `generate`, `tidy`, `vendor`, `run_tests`) | + +--- + +For the complete, always-current settings surface (including experimental and client-specific keys), see `gopls api-json` or the upstream settings page linked above โ€” this table covers the settings most likely to change how navigation, diagnostics, or refactors behave day-to-day, not the full API. diff --git a/skills/golang-graphql/SKILL.md b/skills/golang-graphql/SKILL.md index d2aa5d7..c9952aa 100644 --- a/skills/golang-graphql/SKILL.md +++ b/skills/golang-graphql/SKILL.md @@ -6,7 +6,7 @@ license: MIT compatibility: Designed for Claude Code or similar AI coding agents, and for projects using Golang. metadata: author: samber - version: "0.1.0" + version: "0.1.1" openclaw: emoji: "๐Ÿ”ฎ" homepage: https://github.com/samber/cc-skills-golang @@ -31,7 +31,7 @@ allowed-tools: Read Edit Write Glob Grep Bash(go:*) Bash(golangci-lint:*) Bash(g Both major libraries are schema-first: write SDL (`.graphql` files), bind Go resolvers. Choose based on project size and team preferences. -This skill is not exhaustive. Refer to each library's official documentation and code examples for current API signatures. For Go package docs, symbols, versions, importers, and known vulnerabilities, โ†’ See `samber/cc-skills-golang@golang-pkg-go-dev` skill (`godig`) โ€” prefer it over Context7 for Go package facts. To navigate this library's usage in your own code (definitions, call sites, diagnostics), โ†’ See `samber/cc-skills-golang@golang-how-to` skill (`gopls`). Context7 remains a fallback for docs not indexed on pkg.go.dev. +This skill is not exhaustive. Refer to each library's official documentation and code examples for current API signatures. For Go package docs, symbols, versions, importers, and known vulnerabilities, โ†’ See `samber/cc-skills-golang@golang-pkg-go-dev` skill (`godig`) โ€” prefer it over Context7 for Go package facts. To navigate this library's usage in your own code (definitions, call sites, diagnostics), โ†’ See `samber/cc-skills-golang@golang-gopls` skill (`gopls`). Context7 remains a fallback for docs not indexed on pkg.go.dev. ## Library Choice diff --git a/skills/golang-grpc/SKILL.md b/skills/golang-grpc/SKILL.md index 727df82..9943afe 100644 --- a/skills/golang-grpc/SKILL.md +++ b/skills/golang-grpc/SKILL.md @@ -6,7 +6,7 @@ license: MIT compatibility: Designed for Claude Code or similar AI coding agents, and for projects using Golang. metadata: author: samber - version: "1.1.6" + version: "1.1.7" openclaw: emoji: "๐ŸŒ" homepage: https://github.com/samber/cc-skills-golang @@ -38,7 +38,7 @@ allowed-tools: Read Edit Write Glob Grep Bash(go:*) Bash(golangci-lint:*) Bash(g Treat gRPC as a pure transport layer โ€” keep it separate from business logic. The official Go implementation is `google.golang.org/grpc`. -This skill is not exhaustive. Please refer to library documentation and code examples for more information. For Go package docs, symbols, versions, importers, and known vulnerabilities, โ†’ See `samber/cc-skills-golang@golang-pkg-go-dev` skill (`godig`) โ€” prefer it over Context7 for Go package facts. To navigate this library's usage in your own code (definitions, call sites, diagnostics), โ†’ See `samber/cc-skills-golang@golang-how-to` skill (`gopls`). Context7 remains a fallback for docs not indexed on pkg.go.dev. +This skill is not exhaustive. Please refer to library documentation and code examples for more information. For Go package docs, symbols, versions, importers, and known vulnerabilities, โ†’ See `samber/cc-skills-golang@golang-pkg-go-dev` skill (`godig`) โ€” prefer it over Context7 for Go package facts. To navigate this library's usage in your own code (definitions, call sites, diagnostics), โ†’ See `samber/cc-skills-golang@golang-gopls` skill (`gopls`). Context7 remains a fallback for docs not indexed on pkg.go.dev. ## Quick Reference diff --git a/skills/golang-how-to/SKILL.md b/skills/golang-how-to/SKILL.md index 7bf6dcf..ca3b248 100644 --- a/skills/golang-how-to/SKILL.md +++ b/skills/golang-how-to/SKILL.md @@ -6,7 +6,7 @@ license: MIT compatibility: Designed for Claude Code or similar AI coding agents. Requires git. metadata: author: samber - version: "1.1.0" + version: "1.2.0" openclaw: emoji: "๐Ÿงญ" homepage: https://github.com/samber/cc-skills-golang @@ -61,6 +61,7 @@ For each task, load the **primary skill** and all applicable **secondary skills* | Set up CI/CD pipeline | `golang-continuous-integration` | `golang-lint`, `golang-security` | | Choose a library | `golang-popular-libraries` | relevant library-specific skill | | Look up a package's docs, versions, importers, or CVEs | `golang-pkg-go-dev` | `golang-dependency-management` | +| Navigate, diagnose, or refactor local code (definitions, references, rename) | `golang-gopls` | โ€” | | Adopt new Go language features | `golang-modernize` | `golang-lint` | | Use samber/lo (slice/map helpers) | `golang-samber-lo` | `golang-data-structures`, `golang-performance` | | Use samber/oops (structured errors) | `golang-samber-oops` | `golang-error-handling` | @@ -71,16 +72,9 @@ All skill identifiers above are short forms of `samber/cc-skills-golang@<name>`. ## Code navigation with gopls -`gopls` gives semantic code intelligence for Go โ€” go-to-definition, find references, diagnostics, package API, symbol search. It reaches an agent through two different mechanisms; they solve different problems and are worth wiring both. +`gopls` gives semantic code intelligence for Go โ€” go-to-definition, find references, diagnostics, package API, symbol search, refactoring. โ†’ See `samber/cc-skills-golang@golang-gopls` skill for the three ways to reach it (its own MCP server, the native `LSP` tool, and its CLI), the full capability matrix, and efficient read/edit workflows. -**gopls's own MCP server** โ€” built for AI agents specifically, and the default choice for most tasks. Register it with `claude mcp add gopls -- gopls mcp` (requires `gopls` v0.20+ on PATH; the detached `gopls mcp` mode only sees saved files, which is fine for an agent-only workflow with no attached editor). Its tools take names, paths, and queries rather than raw cursor positions, so they fit how an agent naturally asks questions. Two workflows: - -- **Read** โ€” `go_workspace` first, to learn the workspace layout (module/workspace/GOPATH). `go_search` fuzzy-finds a symbol by name. `go_file_context` shows a file's intra-package dependencies โ€” use it right after reading any Go file for the first time. `go_package_api` shows a package's public API โ€” most useful for third-party dependencies or other packages in a monorepo. -- **Edit** โ€” before touching a symbol's definition, `go_symbol_references` finds every call site so you can judge the blast radius. After every edit, `go_diagnostics` on the changed files is mandatory โ€” fix what it reports, then re-run it. If the edit touched `go.mod` dependencies, `go_vulncheck` afterwards checks the whole workspace for reachable vulnerabilities in the new dependency graph. Then run `go test <packagePath>` for the changed packages โ€” not `./...` unless asked, since a full-repo run slows down the iteration loop. - -**The native `LSP` tool** โ€” Claude Code's built-in editor-style integration. It is **not enabled by default**: set `ENABLE_LSP_TOOL=1`, install `gopls`, and wire it as the Go language server by installing the official `gopls-lsp@claude-plugins-official` marketplace plugin. Its operations (`goToDefinition`, `findReferences`, `hover`, `documentSymbol`, `workspaceSymbol`, `goToImplementation`, call hierarchy) are keyed by `line`/`character`, so they're most useful once you already have a location โ€” typically right after a grep or read โ€” rather than as a first search. Its unique value the MCP server doesn't replicate: compiler diagnostics get pushed into context automatically after every edit, with no explicit `go_diagnostics` call needed. - -Either way, `gopls` only reasons about code that is present and resolvable in the local build: your workspace plus every dependency exactly as pinned in `go.sum` (including `replace` directives). `go_vulncheck` only flags what your _current_ build actually reaches โ€” for a specific published package/version you haven't added yet, or for a comprehensive whole-tree `govulncheck` audit, see `samber/cc-skills-golang@golang-pkg-go-dev` and `samber/cc-skills-golang@golang-security` respectively. For any fact that isn't tied to your local build โ€” version history, licenses, ecosystem-wide importers โ€” use `golang-pkg-go-dev` (`godig`). See the `godig` vs gopls vs Context7 vs govulncheck section below for the full boundary. +`gopls` only reasons about code that is present and resolvable in the local build: your workspace plus every dependency exactly as pinned in `go.sum` (including `replace` directives). For any fact that isn't tied to your local build โ€” version history, licenses, ecosystem-wide importers, a package you haven't added yet โ€” use `golang-pkg-go-dev` (`godig`). See the `godig` vs gopls vs Context7 vs govulncheck section below for the full boundary. ## `godig` vs gopls vs Context7 vs govulncheck @@ -88,19 +82,20 @@ Four tools can answer "is this dependency OK to use," and they don't overlap as - **Context7** is a general-purpose, cross-language documentation fetcher โ€” useful when no more specific source exists. For a Go package or module, `godig` is almost always the better choice: it pulls **structured, Go-specific data** straight from pkg.go.dev โ€” exact versions, exported symbols with signatures, runnable examples, `imported-by`, and known vulnerabilities โ€” rather than Context7's generic scraped/curated docs, which don't expose that structure and can lag or miss lesser-known Go modules. Reach for Context7 only when a dependency's documentation genuinely doesn't exist or isn't indexed on pkg.go.dev. - **`godig`** answers questions about the **published ecosystem**: any Go package or module, whether or not it's in your `go.mod` yet โ€” it calls the remote pkg.go.dev API and never touches your local checkout. Its `vulns` command reports CVEs known for a package/version in isolation, regardless of whether your build actually reaches the vulnerable code path. -- **`gopls`** (via its MCP server, or the native `LSP` tool) answers questions about **your specific build**: your code plus every dependency exactly as pinned in `go.sum`, including `replace` directives pointing at forks or local paths โ€” neither `godig` nor Context7 can see that. Its `go_vulncheck` operation runs a single, on-demand reachability check against the workspace as it stands right now. +- **`gopls`** (โ†’ `samber/cc-skills-golang@golang-gopls`, via its MCP server, the native `LSP` tool, or its CLI) answers questions about **your specific build**: your code plus every dependency exactly as pinned in `go.sum`, including `replace` directives pointing at forks or local paths โ€” neither `godig` nor Context7 can see that. Its `go_vulncheck` operation runs a single, on-demand reachability check against the workspace as it stands right now. - **`govulncheck`** (the standalone CLI, wrapped by the `samber/cc-skills-golang@golang-security` skill) is the whole-tree audit: it walks the entire module's call graph to confirm which known vulnerabilities are actually reachable, and is the tool of record for CI gates and periodic security sweeps โ€” `gopls`'s `go_vulncheck` is a lighter-weight, single-shot version of the same analysis for use mid-edit. Pick by task: | Task | Tool | How | | --- | --- | --- | -| Find where a symbol is defined in your own repo | `gopls` | `go_search`, then `go_file_context` | -| Understand a file's intra-package dependencies | `gopls` | `go_file_context` | -| Jump into a dependency's exact resolved source (incl. forks/`replace`d versions) | `gopls` | `go_package_api`, or the native `LSP` tool's `goToDefinition` | -| Find every call site in your own code that references a dependency's symbol | `gopls` | `go_symbol_references` โ€” `godig`'s `imported-by` only lists public _packages_, not call sites in your repo | -| Get compiler diagnostics right after an edit | `gopls` | `go_diagnostics` (MCP), or automatic with the native `LSP` tool | -| Check whether your current build can reach a known vulnerability, mid-edit | `gopls` | `go_vulncheck` | +| Find where a symbol is defined in your own repo | `gopls` | `samber/cc-skills-golang@golang-gopls` โ€” `go_search`, then `go_file_context` | +| Understand a file's intra-package dependencies | `gopls` | `samber/cc-skills-golang@golang-gopls` โ€” `go_file_context` | +| Jump into a dependency's exact resolved source (incl. forks/`replace`d versions) | `gopls` | `samber/cc-skills-golang@golang-gopls` โ€” `go_package_api`, or the native `LSP` tool's `goToDefinition` | +| Find every call site in your own code that references a dependency's symbol | `gopls` | `samber/cc-skills-golang@golang-gopls` โ€” `go_symbol_references` โ€” `godig`'s `imported-by` only lists public _packages_, not call sites in your repo | +| Get compiler diagnostics right after an edit | `gopls` | `samber/cc-skills-golang@golang-gopls` โ€” `go_diagnostics` (MCP), or automatic with the native `LSP` tool | +| Check whether your current build can reach a known vulnerability, mid-edit | `gopls` | `samber/cc-skills-golang@golang-gopls` โ€” `go_vulncheck` | +| Rename, extract, inline, or otherwise refactor local code | `gopls` | `samber/cc-skills-golang@golang-gopls` โ€” safe rename, `refactor.*` code actions | | Whole-tree vulnerability audit across the module (CI, periodic sweep) | `govulncheck` | `samber/cc-skills-golang@golang-security` skill โ€” `govulncheck ./...` | | List available versions of a published package | `godig` | `godig versions <path>` | | Check known CVEs for a package/version you haven't added yet | `godig` | `godig vulns <path>` | @@ -123,7 +118,7 @@ Full catalog with "use when" hooks: [by-category.md](references/by-category.md) | Code Quality | `golang-code-style` `golang-documentation` `golang-error-handling` `golang-lint` `golang-naming` `golang-safety` `golang-security` `golang-structs-interfaces` | | Architecture & Design | `golang-concurrency` `golang-context` `golang-data-structures` `golang-database` `golang-dependency-injection` `golang-design-patterns` `golang-modernize` | | QA & Performance | `golang-benchmark` `golang-observability` `golang-performance` `golang-testing` `golang-troubleshooting` | -| Project Setup | `golang-cli` `golang-continuous-integration` `golang-dependency-management` `golang-pkg-go-dev` `golang-popular-libraries` `golang-project-layout` `golang-stay-updated` | +| Project Setup | `golang-cli` `golang-continuous-integration` `golang-dependency-management` `golang-gopls` `golang-pkg-go-dev` `golang-popular-libraries` `golang-project-layout` `golang-stay-updated` | | APIs | `golang-graphql` `golang-grpc` `golang-swagger` | | Dependency Injection | `golang-dependency-injection` `golang-google-wire` `golang-uber-dig` `golang-uber-fx` `golang-samber-do` | | Frameworks | `golang-spf13-cobra` `golang-spf13-viper` | @@ -142,7 +137,7 @@ Key clusters and their owners: - **Errors**: `golang-error-handling` (idioms) ยท `golang-samber-oops` (structured errors) ยท `golang-safety` (prevent panics) - **Style**: `golang-code-style` ยท `golang-naming` ยท `golang-lint` ยท `golang-documentation` - **CLI**: `golang-cli` (architecture) ยท `golang-spf13-cobra` (command tree) ยท `golang-spf13-viper` (config layering) -- **Package lookup**: `golang-pkg-go-dev` (query pkg.go.dev for an existing path: versions/docs/symbols/importers/CVEs) ยท `golang-popular-libraries` (which library to adopt) ยท `golang-dependency-management` (manage go.mod) ยท `golang-security` (whole-tree CVE scan) +- **Package lookup**: `golang-pkg-go-dev` (query pkg.go.dev for an existing path: versions/docs/symbols/importers/CVEs) ยท `golang-gopls` (navigate/refactor your locally resolved build) ยท `golang-popular-libraries` (which library to adopt) ยท `golang-dependency-management` (manage go.mod) ยท `golang-security` (whole-tree CVE scan) - **Gap โ€” type vs arch**: `golang-structs-interfaces` (type design) vs `golang-design-patterns` (architectural patterns) - **Gap โ€” goroutine vs cancel**: `golang-concurrency` + `golang-context` โ€” load both when cancelling goroutines via context - **Gap โ€” correctness vs threat**: `golang-safety` (internal bugs) vs `golang-security` (external threats) diff --git a/skills/golang-how-to/references/disambiguation.md b/skills/golang-how-to/references/disambiguation.md index c063588..d65ba13 100644 --- a/skills/golang-how-to/references/disambiguation.md +++ b/skills/golang-how-to/references/disambiguation.md @@ -223,7 +223,7 @@ These four skills all touch "third-party packages", but each owns a different st | Skill | Unique territory | Does NOT own | | --- | --- | --- | -| `samber/cc-skills-golang@golang-pkg-go-dev` | Querying pkg.go.dev for a known path: available versions, docs/symbols/examples, importers (`imported-by`), licenses, known CVEs โ€” via the `godig` CLI/MCP | Deciding which library to pick, editing go.mod, scanning your own tree, navigating local/resolved code (โ†’ `gopls`) | +| `samber/cc-skills-golang@golang-pkg-go-dev` | Querying pkg.go.dev for a known path: available versions, docs/symbols/examples, importers (`imported-by`), licenses, known CVEs โ€” via the `godig` CLI/MCP | Deciding which library to pick, editing go.mod, scanning your own tree, navigating local/resolved code (โ†’ `samber/cc-skills-golang@golang-gopls`) | | `samber/cc-skills-golang@golang-popular-libraries` | Recommending a library for a use case; stdlib-vs-third-party judgment | Looking up facts about a specific published package | | `samber/cc-skills-golang@golang-dependency-management` | Editing go.mod: `go get`, upgrading, pinning, `replace`/`exclude`, workspaces | Browsing a package's docs or version history | | `samber/cc-skills-golang@golang-security` | Whole-tree vulnerability scanning with `govulncheck`, remediation across the module | Checking one module's CVEs without scanning the tree | @@ -241,4 +241,4 @@ These four skills all touch "third-party packages", but each owns a different st > Note: this skill cross-references the other three in its body (and they reference it back). Prefer `golang-pkg-go-dev` over Context7 for any Go package fact-lookup. -**Sub-boundary โ€” `godig` vs `gopls`:** both touch third-party code, but `godig` queries the remote pkg.go.dev index (works for packages not yet added to the project, no local build needed) while `gopls` (its MCP server, or the native `LSP` tool) reasons about your actual resolved build in `go.sum` (including `replace`d forks). "Where is `Foo` defined in my repo?" or "find every call site of this dependency's function in my code" โ†’ `gopls` (`go_search`/`go_symbol_references`), not `golang-pkg-go-dev` โ€” godig has no visibility into local, unpublished code or call sites inside your own repo. "Does this package I haven't added yet have known CVEs?" โ†’ `golang-pkg-go-dev` (`vulns`); "can my current build actually reach a vulnerability in a dependency I already use?" โ†’ `gopls` (`go_vulncheck`) or `golang-security` (`govulncheck` whole-tree). See the `samber/cc-skills-golang@golang-how-to` skill's "Code navigation with gopls" and "`godig` vs gopls vs Context7 vs govulncheck" sections for the full breakdown. +**Sub-boundary โ€” `godig` vs `gopls`:** both touch third-party code, but `godig` queries the remote pkg.go.dev index (works for packages not yet added to the project, no local build needed) while `gopls` (โ†’ `samber/cc-skills-golang@golang-gopls`, via its MCP server, the native `LSP` tool, or its CLI) reasons about your actual resolved build in `go.sum` (including `replace`d forks). "Where is `Foo` defined in my repo?" or "find every call site of this dependency's function in my code" โ†’ `golang-gopls` (`go_search`/`go_symbol_references`), not `golang-pkg-go-dev` โ€” godig has no visibility into local, unpublished code or call sites inside your own repo. "Does this package I haven't added yet have known CVEs?" โ†’ `golang-pkg-go-dev` (`vulns`); "can my current build actually reach a vulnerability in a dependency I already use?" โ†’ `golang-gopls` (`go_vulncheck`) or `golang-security` (`govulncheck` whole-tree). See the `samber/cc-skills-golang@golang-gopls` skill for the full gopls reference, and the `samber/cc-skills-golang@golang-how-to` skill's "`godig` vs gopls vs Context7 vs govulncheck" section for the full breakdown. diff --git a/skills/golang-pkg-go-dev/SKILL.md b/skills/golang-pkg-go-dev/SKILL.md index ecc77af..9e522a8 100644 --- a/skills/golang-pkg-go-dev/SKILL.md +++ b/skills/golang-pkg-go-dev/SKILL.md @@ -1,12 +1,12 @@ --- name: golang-pkg-go-dev -description: "Golang package and module documentation and exploration via `godig`, a pkg.go.dev API client (CLI + MCP server) โ€” package docs, API references, symbols, code examples, available versions, importers (who imports a package), licenses, and known vulnerabilities. Read-only, no auth. Use for looking up any Go/Golang library's documentation, API signatures, usage examples, which versions exist, whether a dependency has CVEs, or who imports a package โ€” prefer this over Context7 for any Go package or module. Triggers on: how to use a Go library, Go API docs, import usage, code examples, pkg.go.dev. Not for upgrading dependencies (โ†’ See `samber/cc-skills-golang@golang-dependency-management` skill) or choosing a library (โ†’ See `samber/cc-skills-golang@golang-popular-libraries` skill). Not for local symbols, or for navigating an already-used dependency's resolved source, call sites, or generic instantiations โ€” use the built-in LSP tool (gopls) for those." +description: "Golang package and module documentation and exploration via `godig`, a pkg.go.dev API client (CLI + MCP server) โ€” package docs, API references, symbols, code examples, available versions, importers (who imports a package), licenses, and known vulnerabilities. Read-only, no auth. Use for looking up any Go/Golang library's documentation, API signatures, usage examples, which versions exist, whether a dependency has CVEs, or who imports a package โ€” prefer this over Context7 for any Go package or module. Triggers on: how to use a Go library, Go API docs, import usage, code examples, pkg.go.dev. Not for upgrading dependencies (โ†’ See `samber/cc-skills-golang@golang-dependency-management` skill) or choosing a library (โ†’ See `samber/cc-skills-golang@golang-popular-libraries` skill). Not for local symbols, or for navigating an already-used dependency's resolved source, call sites, or generic instantiations โ€” โ†’ See `samber/cc-skills-golang@golang-gopls` skill for those." user-invocable: true license: MIT compatibility: Designed for Claude Code or similar AI coding agents. Requires the godig CLI (go install github.com/samber/godig/cmd/godig@latest) or access to a godig MCP server, and internet access to reach the pkg.go.dev API. metadata: author: samber - version: "1.2.0" + version: "1.3.0" openclaw: emoji: "๐Ÿ”Ž" homepage: https://github.com/samber/cc-skills-golang @@ -40,7 +40,7 @@ Trigger on questions like: ## Choosing between `godig`, gopls, Context7, and govulncheck -In short: `godig` answers questions about the **published ecosystem** (works even for packages not yet in your `go.mod`); `gopls` reasons about **your locally resolved build** (`go.sum`, including `replace`d forks); Context7 is a fallback for non-Go or unindexed docs; `govulncheck` is the whole-tree vulnerability audit (โ†’ `samber/cc-skills-golang@golang-security`). See the `samber/cc-skills-golang@golang-how-to` skill's "`godig` vs gopls vs Context7 vs govulncheck" section for the full task-to-tool matrix, and its "Code navigation with gopls" section for wiring `gopls` (MCP server and native `LSP` tool) with Claude Code. +In short: `godig` answers questions about the **published ecosystem** (works even for packages not yet in your `go.mod`); `gopls` reasons about **your locally resolved build** (`go.sum`, including `replace`d forks); Context7 is a fallback for non-Go or unindexed docs; `govulncheck` is the whole-tree vulnerability audit (โ†’ `samber/cc-skills-golang@golang-security`). See the `samber/cc-skills-golang@golang-gopls` skill for wiring `gopls` (MCP server, native `LSP` tool, and CLI) with Claude Code, and the `samber/cc-skills-golang@golang-how-to` skill's "`godig` vs gopls vs Context7 vs govulncheck" section for the full task-to-tool matrix. ## Setup diff --git a/skills/golang-popular-libraries/SKILL.md b/skills/golang-popular-libraries/SKILL.md index 29c007e..0d13e8d 100644 --- a/skills/golang-popular-libraries/SKILL.md +++ b/skills/golang-popular-libraries/SKILL.md @@ -6,7 +6,7 @@ license: MIT compatibility: Designed for Claude Code or similar AI coding agents, and for projects using Golang. metadata: author: samber - version: "1.1.7" + version: "1.1.8" openclaw: emoji: "๐Ÿ“š" homepage: https://github.com/samber/cc-skills-golang @@ -38,7 +38,7 @@ When recommending libraries, prioritize: Find more libraries here: <https://github.com/avelino/awesome-go> -This skill is not exhaustive. Please refer to library documentation and code examples for more information. When exploring a candidate library, โ†’ See `samber/cc-skills-golang@golang-pkg-go-dev` skill (`godig`) for docs, symbols, versions, importers, and known vulnerabilities โ€” prefer it over Context7 for Go package facts. Once a candidate is added to your build, โ†’ See `samber/cc-skills-golang@golang-how-to` skill (`gopls`) to browse its actual resolved source and compare candidates side by side. Context7 remains a fallback for docs not indexed on pkg.go.dev. +This skill is not exhaustive. Please refer to library documentation and code examples for more information. When exploring a candidate library, โ†’ See `samber/cc-skills-golang@golang-pkg-go-dev` skill (`godig`) for docs, symbols, versions, importers, and known vulnerabilities โ€” prefer it over Context7 for Go package facts. Once a candidate is added to your build, โ†’ See `samber/cc-skills-golang@golang-gopls` skill (`gopls`) to browse its actual resolved source and compare candidates side by side. Context7 remains a fallback for docs not indexed on pkg.go.dev. ## General Guidelines diff --git a/skills/golang-samber-do/SKILL.md b/skills/golang-samber-do/SKILL.md index ff03ef6..1a42026 100644 --- a/skills/golang-samber-do/SKILL.md +++ b/skills/golang-samber-do/SKILL.md @@ -6,7 +6,7 @@ license: MIT compatibility: Designed for Claude Code or similar AI coding agents, and for projects using Golang. metadata: author: samber - version: "1.2.3" + version: "1.2.4" openclaw: emoji: "๐Ÿ’‰" homepage: https://github.com/samber/cc-skills-golang @@ -30,7 +30,7 @@ Type-safe dependency injection toolkit for Go based on Go 1.18+ generics. - [do.samber.dev](https://do.samber.dev) - [github.com/samber/do/v2](https://github.com/samber/do) -This skill is not exhaustive. Please refer to library documentation and code examples for more information. For Go package docs, symbols, versions, importers, and known vulnerabilities, โ†’ See `samber/cc-skills-golang@golang-pkg-go-dev` skill (`godig`) โ€” prefer it over Context7 for Go package facts. To navigate this library's usage in your own code (definitions, call sites, diagnostics), โ†’ See `samber/cc-skills-golang@golang-how-to` skill (`gopls`). Context7 remains a fallback for docs not indexed on pkg.go.dev. +This skill is not exhaustive. Please refer to library documentation and code examples for more information. For Go package docs, symbols, versions, importers, and known vulnerabilities, โ†’ See `samber/cc-skills-golang@golang-pkg-go-dev` skill (`godig`) โ€” prefer it over Context7 for Go package facts. To navigate this library's usage in your own code (definitions, call sites, diagnostics), โ†’ See `samber/cc-skills-golang@golang-gopls` skill (`gopls`). Context7 remains a fallback for docs not indexed on pkg.go.dev. DO NOT USE v1 OF THIS LIBRARY. INSTALL v2 INSTEAD: diff --git a/skills/golang-samber-hot/SKILL.md b/skills/golang-samber-hot/SKILL.md index aac3ef1..4da42a2 100644 --- a/skills/golang-samber-hot/SKILL.md +++ b/skills/golang-samber-hot/SKILL.md @@ -6,7 +6,7 @@ license: MIT compatibility: Designed for Claude Code or similar AI coding agents, and for projects using Golang. metadata: author: samber - version: "1.0.5" + version: "1.0.6" openclaw: emoji: "๐Ÿ”ฅ" homepage: https://github.com/samber/cc-skills-golang @@ -29,7 +29,7 @@ Generic, type-safe in-memory caching library for Go 1.22+ with 9 eviction algori - [pkg.go.dev/github.com/samber/hot](https://pkg.go.dev/github.com/samber/hot) - [github.com/samber/hot](https://github.com/samber/hot) -This skill is not exhaustive. Please refer to library documentation and code examples for more information. For Go package docs, symbols, versions, importers, and known vulnerabilities, โ†’ See `samber/cc-skills-golang@golang-pkg-go-dev` skill (`godig`) โ€” prefer it over Context7 for Go package facts. To navigate this library's usage in your own code (definitions, call sites, diagnostics), โ†’ See `samber/cc-skills-golang@golang-how-to` skill (`gopls`). Context7 remains a fallback for docs not indexed on pkg.go.dev. +This skill is not exhaustive. Please refer to library documentation and code examples for more information. For Go package docs, symbols, versions, importers, and known vulnerabilities, โ†’ See `samber/cc-skills-golang@golang-pkg-go-dev` skill (`godig`) โ€” prefer it over Context7 for Go package facts. To navigate this library's usage in your own code (definitions, call sites, diagnostics), โ†’ See `samber/cc-skills-golang@golang-gopls` skill (`gopls`). Context7 remains a fallback for docs not indexed on pkg.go.dev. ```bash go get -u github.com/samber/hot diff --git a/skills/golang-samber-lo/SKILL.md b/skills/golang-samber-lo/SKILL.md index eb4655d..4d33c7f 100644 --- a/skills/golang-samber-lo/SKILL.md +++ b/skills/golang-samber-lo/SKILL.md @@ -6,7 +6,7 @@ license: MIT compatibility: Designed for Claude Code or similar AI coding agents, and for projects using Golang. metadata: author: samber - version: "1.1.2" + version: "1.1.3" openclaw: emoji: "๐Ÿงฐ" homepage: https://github.com/samber/cc-skills-golang @@ -30,7 +30,7 @@ Lodash-inspired, generics-first utility library with 500+ type-safe helpers for - [lo.samber.dev](https://lo.samber.dev) - [pkg.go.dev/github.com/samber/lo](https://pkg.go.dev/github.com/samber/lo) -This skill is not exhaustive. Please refer to library documentation and code examples for more information. For Go package docs, symbols, versions, importers, and known vulnerabilities, โ†’ See `samber/cc-skills-golang@golang-pkg-go-dev` skill (`godig`) โ€” prefer it over Context7 for Go package facts. To navigate this library's usage in your own code (definitions, call sites, diagnostics), โ†’ See `samber/cc-skills-golang@golang-how-to` skill (`gopls`). Context7 remains a fallback for docs not indexed on pkg.go.dev. +This skill is not exhaustive. Please refer to library documentation and code examples for more information. For Go package docs, symbols, versions, importers, and known vulnerabilities, โ†’ See `samber/cc-skills-golang@golang-pkg-go-dev` skill (`godig`) โ€” prefer it over Context7 for Go package facts. To navigate this library's usage in your own code (definitions, call sites, diagnostics), โ†’ See `samber/cc-skills-golang@golang-gopls` skill (`gopls`). Context7 remains a fallback for docs not indexed on pkg.go.dev. ## Why samber/lo diff --git a/skills/golang-samber-mo/SKILL.md b/skills/golang-samber-mo/SKILL.md index 300e447..e93ec96 100644 --- a/skills/golang-samber-mo/SKILL.md +++ b/skills/golang-samber-mo/SKILL.md @@ -6,7 +6,7 @@ license: MIT compatibility: Designed for Claude Code or similar AI coding agents, and for projects using Golang. metadata: author: samber - version: "1.0.6" + version: "1.0.7" openclaw: emoji: "๐ŸŽญ" homepage: https://github.com/samber/cc-skills-golang @@ -31,7 +31,7 @@ Go 1.18+ library providing type-safe monadic types with zero dependencies. Inspi - [pkg.go.dev/github.com/samber/mo](https://pkg.go.dev/github.com/samber/mo) - [github.com/samber/mo](https://github.com/samber/mo) -This skill is not exhaustive. Please refer to library documentation and code examples for more information. For Go package docs, symbols, versions, importers, and known vulnerabilities, โ†’ See `samber/cc-skills-golang@golang-pkg-go-dev` skill (`godig`) โ€” prefer it over Context7 for Go package facts. To navigate this library's usage in your own code (definitions, call sites, diagnostics), โ†’ See `samber/cc-skills-golang@golang-how-to` skill (`gopls`). Context7 remains a fallback for docs not indexed on pkg.go.dev. +This skill is not exhaustive. Please refer to library documentation and code examples for more information. For Go package docs, symbols, versions, importers, and known vulnerabilities, โ†’ See `samber/cc-skills-golang@golang-pkg-go-dev` skill (`godig`) โ€” prefer it over Context7 for Go package facts. To navigate this library's usage in your own code (definitions, call sites, diagnostics), โ†’ See `samber/cc-skills-golang@golang-gopls` skill (`gopls`). Context7 remains a fallback for docs not indexed on pkg.go.dev. ```bash go get github.com/samber/mo diff --git a/skills/golang-samber-oops/SKILL.md b/skills/golang-samber-oops/SKILL.md index cdd5260..de62547 100644 --- a/skills/golang-samber-oops/SKILL.md +++ b/skills/golang-samber-oops/SKILL.md @@ -6,7 +6,7 @@ license: MIT compatibility: Designed for Claude Code or similar AI coding agents, and for projects using Golang. metadata: author: samber - version: "1.1.5" + version: "1.1.6" openclaw: emoji: "๐Ÿ’ฅ" homepage: https://github.com/samber/cc-skills-golang @@ -34,7 +34,7 @@ Standard Go errors lack context โ€” you see `connection failed` but not which us - **Public messages** โ€” user-safe messages separate from technical details - **Low-cardinality messages** โ€” variable data in `.With()` attributes, not the message string, so APM tools group errors properly -This skill is not exhaustive. Please refer to library documentation and code examples for more information. For Go package docs, symbols, versions, importers, and known vulnerabilities, โ†’ See `samber/cc-skills-golang@golang-pkg-go-dev` skill (`godig`) โ€” prefer it over Context7 for Go package facts. To navigate this library's usage in your own code (definitions, call sites, diagnostics), โ†’ See `samber/cc-skills-golang@golang-how-to` skill (`gopls`). Context7 remains a fallback for docs not indexed on pkg.go.dev. +This skill is not exhaustive. Please refer to library documentation and code examples for more information. For Go package docs, symbols, versions, importers, and known vulnerabilities, โ†’ See `samber/cc-skills-golang@golang-pkg-go-dev` skill (`godig`) โ€” prefer it over Context7 for Go package facts. To navigate this library's usage in your own code (definitions, call sites, diagnostics), โ†’ See `samber/cc-skills-golang@golang-gopls` skill (`gopls`). Context7 remains a fallback for docs not indexed on pkg.go.dev. ## Core pattern: Error builder chain diff --git a/skills/golang-samber-ro/SKILL.md b/skills/golang-samber-ro/SKILL.md index 71da975..287b83c 100644 --- a/skills/golang-samber-ro/SKILL.md +++ b/skills/golang-samber-ro/SKILL.md @@ -6,7 +6,7 @@ license: MIT compatibility: Designed for Claude Code or similar AI coding agents, and for projects using Golang. metadata: author: samber - version: "1.1.2" + version: "1.1.3" openclaw: emoji: "๐Ÿ‘" homepage: https://github.com/samber/cc-skills-golang @@ -32,7 +32,7 @@ Go implementation of [ReactiveX](https://reactivex.io/). Generics-first, type-sa - [ro.samber.dev](https://ro.samber.dev) - [pkg.go.dev/github.com/samber/ro](https://pkg.go.dev/github.com/samber/ro) -This skill is not exhaustive. Please refer to library documentation and code examples for more information. For Go package docs, symbols, versions, importers, and known vulnerabilities, โ†’ See `samber/cc-skills-golang@golang-pkg-go-dev` skill (`godig`) โ€” prefer it over Context7 for Go package facts. To navigate this library's usage in your own code (definitions, call sites, diagnostics), โ†’ See `samber/cc-skills-golang@golang-how-to` skill (`gopls`). Context7 remains a fallback for docs not indexed on pkg.go.dev. +This skill is not exhaustive. Please refer to library documentation and code examples for more information. For Go package docs, symbols, versions, importers, and known vulnerabilities, โ†’ See `samber/cc-skills-golang@golang-pkg-go-dev` skill (`godig`) โ€” prefer it over Context7 for Go package facts. To navigate this library's usage in your own code (definitions, call sites, diagnostics), โ†’ See `samber/cc-skills-golang@golang-gopls` skill (`gopls`). Context7 remains a fallback for docs not indexed on pkg.go.dev. ## Why samber/ro (Streams vs Slices) diff --git a/skills/golang-samber-slog/SKILL.md b/skills/golang-samber-slog/SKILL.md index 6860003..eb68620 100644 --- a/skills/golang-samber-slog/SKILL.md +++ b/skills/golang-samber-slog/SKILL.md @@ -6,7 +6,7 @@ license: MIT compatibility: Designed for Claude Code or similar AI coding agents, and for projects using Golang. metadata: author: samber - version: "1.0.6" + version: "1.0.7" openclaw: emoji: "๐Ÿชต" homepage: https://github.com/samber/cc-skills-golang @@ -62,7 +62,7 @@ allowed-tools: Read Edit Write Glob Grep Bash(go:*) Bash(golangci-lint:*) Bash(g - [github.com/samber/slog-sampling](https://github.com/samber/slog-sampling) โ€” throughput control - [github.com/samber/slog-formatter](https://github.com/samber/slog-formatter) โ€” attribute transformation -This skill is not exhaustive. Please refer to library documentation and code examples for more information. For Go package docs, symbols, versions, importers, and known vulnerabilities, โ†’ See `samber/cc-skills-golang@golang-pkg-go-dev` skill (`godig`) โ€” prefer it over Context7 for Go package facts. To navigate this library's usage in your own code (definitions, call sites, diagnostics), โ†’ See `samber/cc-skills-golang@golang-how-to` skill (`gopls`). Context7 remains a fallback for docs not indexed on pkg.go.dev. +This skill is not exhaustive. Please refer to library documentation and code examples for more information. For Go package docs, symbols, versions, importers, and known vulnerabilities, โ†’ See `samber/cc-skills-golang@golang-pkg-go-dev` skill (`godig`) โ€” prefer it over Context7 for Go package facts. To navigate this library's usage in your own code (definitions, call sites, diagnostics), โ†’ See `samber/cc-skills-golang@golang-gopls` skill (`gopls`). Context7 remains a fallback for docs not indexed on pkg.go.dev. ## The Pipeline Model diff --git a/skills/golang-spf13-cobra/SKILL.md b/skills/golang-spf13-cobra/SKILL.md index a256fbc..3df0c10 100644 --- a/skills/golang-spf13-cobra/SKILL.md +++ b/skills/golang-spf13-cobra/SKILL.md @@ -6,7 +6,7 @@ license: MIT compatibility: Designed for Claude Code or similar AI coding agents, and for projects using Golang. metadata: author: samber - version: "1.0.3" + version: "1.0.4" openclaw: emoji: "๐Ÿ" homepage: https://github.com/samber/cc-skills-golang @@ -36,7 +36,7 @@ Cobra is the de facto standard for Go CLI applications. It provides the command/ - [github.com/spf13/cobra](https://github.com/spf13/cobra) - [cobra.dev](https://cobra.dev) -This skill is not exhaustive. Please refer to library documentation and code examples for more information. For Go package docs, symbols, versions, importers, and known vulnerabilities, โ†’ See `samber/cc-skills-golang@golang-pkg-go-dev` skill (`godig`) โ€” prefer it over Context7 for Go package facts. To navigate this library's usage in your own code (definitions, call sites, diagnostics), โ†’ See `samber/cc-skills-golang@golang-how-to` skill (`gopls`). Context7 remains a fallback for docs not indexed on pkg.go.dev. +This skill is not exhaustive. Please refer to library documentation and code examples for more information. For Go package docs, symbols, versions, importers, and known vulnerabilities, โ†’ See `samber/cc-skills-golang@golang-pkg-go-dev` skill (`godig`) โ€” prefer it over Context7 for Go package facts. To navigate this library's usage in your own code (definitions, call sites, diagnostics), โ†’ See `samber/cc-skills-golang@golang-gopls` skill (`gopls`). Context7 remains a fallback for docs not indexed on pkg.go.dev. ```bash go get github.com/spf13/cobra@latest diff --git a/skills/golang-spf13-viper/SKILL.md b/skills/golang-spf13-viper/SKILL.md index ab6039c..8fa37ff 100644 --- a/skills/golang-spf13-viper/SKILL.md +++ b/skills/golang-spf13-viper/SKILL.md @@ -6,7 +6,7 @@ license: MIT compatibility: Designed for Claude Code or similar AI coding agents, and for projects using Golang. metadata: author: samber - version: "1.0.3" + version: "1.0.4" openclaw: emoji: "๐Ÿ”ง" homepage: https://github.com/samber/cc-skills-golang @@ -29,7 +29,7 @@ Viper resolves configuration values from multiple sources in a fixed precedence - [pkg.go.dev/github.com/spf13/viper](https://pkg.go.dev/github.com/spf13/viper) - [github.com/spf13/viper](https://github.com/spf13/viper) -This skill is not exhaustive. Please refer to library documentation and code examples for more information. For Go package docs, symbols, versions, importers, and known vulnerabilities, โ†’ See `samber/cc-skills-golang@golang-pkg-go-dev` skill (`godig`) โ€” prefer it over Context7 for Go package facts. To navigate this library's usage in your own code (definitions, call sites, diagnostics), โ†’ See `samber/cc-skills-golang@golang-how-to` skill (`gopls`). Context7 remains a fallback for docs not indexed on pkg.go.dev. +This skill is not exhaustive. Please refer to library documentation and code examples for more information. For Go package docs, symbols, versions, importers, and known vulnerabilities, โ†’ See `samber/cc-skills-golang@golang-pkg-go-dev` skill (`godig`) โ€” prefer it over Context7 for Go package facts. To navigate this library's usage in your own code (definitions, call sites, diagnostics), โ†’ See `samber/cc-skills-golang@golang-gopls` skill (`gopls`). Context7 remains a fallback for docs not indexed on pkg.go.dev. ```bash go get github.com/spf13/viper@latest diff --git a/skills/golang-stretchr-testify/SKILL.md b/skills/golang-stretchr-testify/SKILL.md index bc2fb79..daade12 100644 --- a/skills/golang-stretchr-testify/SKILL.md +++ b/skills/golang-stretchr-testify/SKILL.md @@ -6,7 +6,7 @@ license: MIT compatibility: Designed for Claude Code or similar AI coding agents, and for projects using Golang. metadata: author: samber - version: "1.2.2" + version: "1.2.3" openclaw: emoji: "โœ…" homepage: https://github.com/samber/cc-skills-golang @@ -33,7 +33,7 @@ allowed-tools: Read Edit Write Glob Grep Bash(go:*) Bash(golangci-lint:*) Bash(g testify complements Go's `testing` package with readable assertions, mocks, and suites. It does not replace `testing` โ€” always use `*testing.T` as the entry point. -This skill is not exhaustive. Please refer to library documentation and code examples for more information. For Go package docs, symbols, versions, importers, and known vulnerabilities, โ†’ See `samber/cc-skills-golang@golang-pkg-go-dev` skill (`godig`) โ€” prefer it over Context7 for Go package facts. To navigate this library's usage in your own code (definitions, call sites, diagnostics), โ†’ See `samber/cc-skills-golang@golang-how-to` skill (`gopls`). Context7 remains a fallback for docs not indexed on pkg.go.dev. +This skill is not exhaustive. Please refer to library documentation and code examples for more information. For Go package docs, symbols, versions, importers, and known vulnerabilities, โ†’ See `samber/cc-skills-golang@golang-pkg-go-dev` skill (`godig`) โ€” prefer it over Context7 for Go package facts. To navigate this library's usage in your own code (definitions, call sites, diagnostics), โ†’ See `samber/cc-skills-golang@golang-gopls` skill (`gopls`). Context7 remains a fallback for docs not indexed on pkg.go.dev. ## assert vs require diff --git a/skills/golang-swagger/SKILL.md b/skills/golang-swagger/SKILL.md index 01cf8bc..e1e69a4 100644 --- a/skills/golang-swagger/SKILL.md +++ b/skills/golang-swagger/SKILL.md @@ -6,7 +6,7 @@ license: MIT compatibility: Designed for Claude Code or similar AI coding agents. Requires go and swag CLI. metadata: author: samber - version: "1.0.3" + version: "1.0.4" openclaw: emoji: "๐Ÿ“‹" homepage: https://github.com/samber/cc-skills-golang @@ -223,6 +223,6 @@ type CreateUserRequest struct { - โ†’ See `samber/cc-skills-golang@golang-security` for securing the Swagger UI endpoint in production (disable or gate with auth middleware). - โ†’ See `samber/cc-skills-golang@golang-grpc` for gRPC โ€” use grpc-gateway with its own OpenAPI generator instead of swag. -This skill is not exhaustive. Refer to the swaggo/swag documentation and code examples for up-to-date API signatures and usage patterns. For Go package docs, symbols, versions, importers, and known vulnerabilities, โ†’ See `samber/cc-skills-golang@golang-pkg-go-dev` skill (`godig`) โ€” prefer it over Context7 for Go package facts. To navigate this library's usage in your own code (definitions, call sites, diagnostics), โ†’ See `samber/cc-skills-golang@golang-how-to` skill (`gopls`). Context7 remains a fallback for docs not indexed on pkg.go.dev. +This skill is not exhaustive. Refer to the swaggo/swag documentation and code examples for up-to-date API signatures and usage patterns. For Go package docs, symbols, versions, importers, and known vulnerabilities, โ†’ See `samber/cc-skills-golang@golang-pkg-go-dev` skill (`godig`) โ€” prefer it over Context7 for Go package facts. To navigate this library's usage in your own code (definitions, call sites, diagnostics), โ†’ See `samber/cc-skills-golang@golang-gopls` skill (`gopls`). Context7 remains a fallback for docs not indexed on pkg.go.dev. If you encounter a bug or unexpected behavior in swag, open an issue at <https://github.com/swaggo/swag/issues>. diff --git a/skills/golang-uber-dig/SKILL.md b/skills/golang-uber-dig/SKILL.md index 9dabc49..9ef809b 100644 --- a/skills/golang-uber-dig/SKILL.md +++ b/skills/golang-uber-dig/SKILL.md @@ -6,7 +6,7 @@ license: MIT compatibility: Designed for Claude Code or similar AI coding agents, and for projects using Golang. metadata: author: samber - version: "1.1.2" + version: "1.1.3" openclaw: emoji: "โ›" homepage: https://github.com/samber/cc-skills-golang @@ -29,7 +29,7 @@ Reflection-based DI toolkit, designed to power application frameworks (it is the - [pkg.go.dev/go.uber.org/dig](https://pkg.go.dev/go.uber.org/dig) - [github.com/uber-go/dig](https://github.com/uber-go/dig) -This skill is not exhaustive. Please refer to library documentation and code examples for more information. For Go package docs, symbols, versions, importers, and known vulnerabilities, โ†’ See `samber/cc-skills-golang@golang-pkg-go-dev` skill (`godig`) โ€” prefer it over Context7 for Go package facts. To navigate this library's usage in your own code (definitions, call sites, diagnostics), โ†’ See `samber/cc-skills-golang@golang-how-to` skill (`gopls`). Context7 remains a fallback for docs not indexed on pkg.go.dev. +This skill is not exhaustive. Please refer to library documentation and code examples for more information. For Go package docs, symbols, versions, importers, and known vulnerabilities, โ†’ See `samber/cc-skills-golang@golang-pkg-go-dev` skill (`godig`) โ€” prefer it over Context7 for Go package facts. To navigate this library's usage in your own code (definitions, call sites, diagnostics), โ†’ See `samber/cc-skills-golang@golang-gopls` skill (`gopls`). Context7 remains a fallback for docs not indexed on pkg.go.dev. ```bash go get go.uber.org/dig diff --git a/skills/golang-uber-fx/SKILL.md b/skills/golang-uber-fx/SKILL.md index 1316aaa..44c914b 100644 --- a/skills/golang-uber-fx/SKILL.md +++ b/skills/golang-uber-fx/SKILL.md @@ -6,7 +6,7 @@ license: MIT compatibility: Designed for Claude Code or similar AI coding agents, and for projects using Golang. metadata: author: samber - version: "1.1.2" + version: "1.1.3" openclaw: emoji: "๐Ÿญ" homepage: https://github.com/samber/cc-skills-golang @@ -30,7 +30,7 @@ Application framework combining a reflection-based DI container (built on `uber- - [uber-go.github.io/fx](https://uber-go.github.io/fx/) - [github.com/uber-go/fx](https://github.com/uber-go/fx) -This skill is not exhaustive. Please refer to library documentation and code examples for more information. For Go package docs, symbols, versions, importers, and known vulnerabilities, โ†’ See `samber/cc-skills-golang@golang-pkg-go-dev` skill (`godig`) โ€” prefer it over Context7 for Go package facts. To navigate this library's usage in your own code (definitions, call sites, diagnostics), โ†’ See `samber/cc-skills-golang@golang-how-to` skill (`gopls`). Context7 remains a fallback for docs not indexed on pkg.go.dev. +This skill is not exhaustive. Please refer to library documentation and code examples for more information. For Go package docs, symbols, versions, importers, and known vulnerabilities, โ†’ See `samber/cc-skills-golang@golang-pkg-go-dev` skill (`godig`) โ€” prefer it over Context7 for Go package facts. To navigate this library's usage in your own code (definitions, call sites, diagnostics), โ†’ See `samber/cc-skills-golang@golang-gopls` skill (`gopls`). Context7 remains a fallback for docs not indexed on pkg.go.dev. ```bash go get go.uber.org/fx