samber/golang-pkg-go-dev

Consulta de pacotes e módulos Go via `godig`, um cliente da API pkg.go.dev (CLI + servidor MCP). Use para documentação, assinaturas de API, símbolos, exemplos de uso, versões, licenças, vulnerabilidades e dependências de qualquer biblioteca Go. Somente leitura, sem autenticação.

O que é golang-pkg-go-dev?

Esta skill fornece acesso completo ao ecossistema publicado de pacotes Go por meio do `godig`, uma ferramenta CLI e servidor MCP que consulta a API do pkg.go.dev. Ela permite que agentes de IA (como Claude Code, Cursor ou Codex) obtenham informações detalhadas sobre qualquer pacote ou módulo Go — incluindo documentação, símbolos exportados, versões disponíveis, licenças, dependências, pacotes que importam um determinado pacote, vulnerabilidades conhecidas e muito mais. Todas as operações são somente leitura e não requerem autenticação, funcionando mesmo para pacotes que ainda não estão no `go.mod` do projeto. A skill oferece uma ampla gama de comandos especializados (como `overview` para um resumo compacto, `symbol doc` para documentação de um símbolo específico, `vulns` para vulnerabilidades), e pode ser usada via CLI direta ou como servidor MCP registrado em qualquer host compatível com MCP (Claude Code, Cursor, Windsurf, etc.). É particularmente útil para evitar chamadas desnecessárias a ferramentas como Context7 para pacotes Go, e deve ser preferida para consultas sobre o ecossistema público, enquanto ferramentas como `gopls` são mais adequadas para análise do código local do projeto.

Funciona com✓Claude Code✓Codex CLI✓Cursor✓Windsurf
npx skills add https://github.com/samber/cc-skills-golang/tree/main/skills/golang-pkg-go-dev

Installed? Explore more Programação e Desenvolvimento skills: steipete/bluebubbles, steipete/eightctl, steipete/blucli · View all 6 →

Perguntar na sua IA favorita

Abre um novo chat com esta habilidade de agente já pré-carregada.

Documentação

O que golang-pkg-go-dev faz?

Dependências: godig — go install github.com/samber/godig/cmd/godig@latest (ou use um servidor MCP godig registrado / a instância hospedada como alternativa).

godig consulta a API do pkg.go.dev. Use-a para responder perguntas sobre pacotes e módulos Go: documentação, símbolos, versões, importadores e vulnerabilidades. Funciona como CLI e como servidor MCP, e todas as operações são somente leitura e não precisam de autenticação.

Quando usar esta skill

Disparar em perguntas como:

  • "Quais versões do github.com/samber/lo estão disponíveis?"
  • "O golang.org/x/text tem vulnerabilidades conhecidas?"
  • "Mostre a documentação / símbolos do pacote X."
  • "Quais pacotes importam X?"
  • "Pesquise pacotes Go por Y."

Escolhendo entre godig, gopls, Context7 e govulncheck

Em resumo: godig responde perguntas sobre o ecossistema publicado (funciona mesmo para pacotes que ainda não estão no seu go.mod); gopls raciocina sobre seu build local resolvido (go.sum, incluindo forks com replace); Context7 é uma alternativa para documentação não-Go ou não indexada; govulncheck é a auditoria de vulnerabilidades da árvore inteira (→ samber/cc-skills-golang@golang-security). Veja a skill samber/cc-skills-golang@golang-gopls para conectar gopls (servidor MCP, ferramenta nativa LSP e CLI) com Claude Code, e a seção "godig vs gopls vs Context7 vs govulncheck" da skill samber/cc-skills-golang@golang-how-to para a matriz completa de tarefa-para-ferramenta.

Configuração

Instalação

go install github.com/samber/godig/cmd/godig@latest

Registrar o servidor MCP (opcional)

godig mcp executa sobre stdio por padrão, ou HTTP transmissível com --transport http. O comando é independente de plataforma — qualquer host compatível com MCP pode apontar para ele. Claude Code o registra via sua própria CLI:

stdio (o cliente inicia o godig sob demanda):

claude mcp add pkg-go-dev -- godig mcp

HTTP transmissível (servidor compartilhado em /mcp, padrão :8080):

godig mcp --transport http --addr :8080
claude mcp add --transport http pkg-go-dev http://localhost:8080/mcp

Instância hospedada (sem instalação necessária) — um servidor público roda em https://godig.samber.dev/mcp:

claude mcp add --transport http pkg-go-dev https://godig.samber.dev/mcp

Outras plataformas compatíveis com MCP (Cursor, Windsurf e outras) cada uma tem seu próprio registro de servidor MCP — uma entrada em seu respectivo arquivo de configurações apontando para o mesmo comando godig mcp ou URL hospedada, não um formato de configuração compartilhado.

O CLI e o servidor MCP expõem as mesmas operações com nomes correspondentes. Prefira o CLI quando godig estiver instalado; a instância hospedada é uma alternativa quando não estiver.

Comandos

Flags globais (todos os comandos): -o/--output table|json|raw|md (padrão table — use -o md para chat), --base-url (API pkg.go.dev), --vuln-base-url (banco de dados de vulnerabilidades Go, consultado por vulns e overview), --timeout, --log-level debug|info|warn|error|off. Todos também podem ser definidos via variáveis de ambiente GODIG_*.

ComandoArgumentosFlags específicasPropósito
overview<caminho>--versionResumo compacto (metadados, versões, licenças, vulnerabilidades) — comece por aqui
search<consulta>--symbol --limit --filterEncontrar pacotes (opcionalmente exportando um símbolo)
package info<caminho>--module --versionMetadados do pacote
package imports<caminho>--module --versionPacotes que este pacote importa (lista simples)
package doc<caminho>--module --version --goos --goarch --format md|text|html|markdownDocumentação completa do pacote (GRANDE)
package examples<caminho>--module --version --goos --goarch --symbolExemplos executáveis (GRANDE; escopo com --symbol)
package licenses<caminho>--module --versionArquivos de licença, texto completo (GRANDE)
symbol doc<caminho> <símbolo>--module --version --goos --goarchAssinatura + documentação de um símbolo (econômico em tokens)
symbol examples<caminho> <símbolo>--module --version --goos --goarchExemplos executáveis de um símbolo
symbols<caminho>--module --version --goos --goarch --limit --filterListar símbolos exportados
module info<caminho>--versionMetadados do módulo
module licenses<caminho>--versionArquivos de licença do módulo (GRANDE)
module readme<caminho>--versionREADME do módulo, Markdown completo (GRANDE)
dependencies<caminho>--versionDependências go.mod: requires / replaces / excludes / diretiva go
packages<caminho>--version --limit --filterPacotes contidos em um módulo
versions<caminho>--limit --filterTodas as versões, da mais nova para a mais antiga
major-versions<caminho>--limit --filter --exclude-pseudoVersões principais (v1, v2…) que existem como módulos separados
imported-by<caminho>--module --version --limit --filterPacotes que importam este
vulns<caminho>--version --limitVulnerabilidades conhecidas (do banco de vulnerabilidades Go)
mcp—--transport stdio|http --addr --cache-ttl --cache-sizeExecutar como servidor MCP
version——Exibir versão / commit / data de compilação do godig

Quando godig executa como servidor MCP, cada comando de dados acima é exposto como uma operação de mesmo nome.

Códigos de saída: 0 sucesso, 1 erro de execução (rede, pacote não encontrado), 2 erro de uso — um argumento ou flag ausente/inválido (ex.: um --limit não positivo), ou um grupo de comandos invocado sem subcomando (godig package). Verifique 2 para distinguir uma chamada malformada de uma consulta que falhou.

Saída completa -o md para cada comando: sample-output.md.

Dicas

  • Comece com overview — uma chamada retorna um resumo compacto (metadados, versões mais recentes + recentes, tipos de licença, vulnerabilidades). Recorra a doc/examples/module readme/licenses (GRANDE) apenas quando o texto completo for necessário.
  • Sempre use -o md para que os resultados sejam renderizados como Markdown (tabelas, ou documentação/README brutos) no chat. Outros formatos existem (table padrão, json, raw), mas prefira md aqui.
  • <caminho> é um caminho de importação completo, ex.: github.com/samber/lo — passe-o como argumento posicional.
  • --version fixa uma versão específica do módulo (v1.5.0, latest, master, main); --module desambigua a qual módulo um pacote pertence.
  • --filter estreita os resultados da lista no lado do servidor com uma expressão booleana Go — veja Sintaxe de filtro.
  • --goos/--goarch definem o contexto de compilação da documentação/símbolos (ex.: linux/amd64).
  • Prefira symbol doc/symbol examples em vez de package doc/package examples no nível do pacote quando você precisar apenas de um símbolo específico.

Individual skills in this repo

This repo contains 20 individual skills — each has its own dedicated page.

samber/golang-benchmark

Golang benchmarking, profiling, and performance measurement. Use when writing, running, or comparing Go benchmarks, profiling hot paths with pprof, interpreting CPU/memory/trace profiles, analyzing results with benchstat, setting up CI benchmark regression detection, or investigating production performance with Prometheus runtime metrics. Also use when the developer needs deep analysis on a specific performance indicator - this skill provides the measurement methodology, while `samber/cc-skills-golang@golang-performance` provides the optimization patterns.

samber/golang-cli

Golang CLI application development. Use when building, modifying, or reviewing a Go CLI tool — especially for command structure, flag handling, configuration layering, version embedding, exit codes, I/O patterns, signal handling, shell completion, argument validation, and CLI unit testing. Also triggers when code uses cobra, viper, or urfave/cli. For cobra-specific APIs → See `samber/cc-skills-golang@golang-spf13-cobra` skill; for viper configuration layering → See `samber/cc-skills-golang@golang-spf13-viper` skill.

samber/golang-code-style

Golang code style conventions — line length and breaking, variable declarations, control flow clarity, when comments help vs hurt. Use when writing or reviewing Go code, asking about style or clarity, or establishing project coding standards. Not for naming conventions (→ See `samber/cc-skills-golang@golang-naming` skill), linter configuration (→ See `samber/cc-skills-golang@golang-lint` skill), or doc comments (→ See `samber/cc-skills-golang@golang-documentation` skill).

samber/golang-concurrency

Golang concurrency patterns. Use when writing or reviewing concurrent Go code involving goroutines, channels, select, locks, sync primitives, errgroup, singleflight, worker pools, or fan-out/fan-in pipelines. Also triggers when you detect goroutine leaks, race conditions, channel ownership issues, or need to choose between channels and mutexes.

samber/golang-context

Idiomatic context.Context usage in Golang — propagation through API boundaries, cancellation, timeouts and deadlines, request-scoped values, context.WithoutCancel for background work outliving requests. Apply when designing context propagation across layers, debugging leaked or unexpired contexts, choosing between context.Background/TODO/WithoutCancel, or storing values in context. Not for code that merely accepts ctx as first parameter.

samber/golang-continuous-integration

CI/CD pipeline configuration using GitHub Actions for Golang projects — testing, linting, SAST, security scanning, code coverage, Dependabot, Renovate, GoReleaser, code review automation, and release pipelines. Use when setting up or improving Go project CI, configuring GitHub Actions workflows, adding linters or security scanners, automating dependency updates, or adding quality gates.

samber/golang-database

Comprehensive guide for Go database access — parameterized queries, struct scanning, NULLable columns, transactions, isolation levels, SELECT FOR UPDATE, connection pool, batch processing, context propagation, and migration tooling. Use when writing, reviewing, or debugging Golang code that interacts with PostgreSQL, MariaDB, MySQL, or SQLite; for database testing; or for questions about database/sql, sqlx, or pgx. Does NOT generate database schemas or migration SQL.

samber/golang-data-structures

Golang data structures — slices (internals, capacity growth, preallocation, slices package), maps (internals, hash buckets, maps package), arrays, container/list/heap/ring, strings.Builder vs bytes.Buffer, generic collections, pointers (unsafe.Pointer, weak.Pointer), and copy semantics. Use when choosing or optimizing Go data structures, implementing generic containers, using container/ packages, unsafe or weak pointers, or questioning slice/map internals.

samber/golang-dependency-injection

Comprehensive guide for dependency injection (DI) in Golang. Covers why DI matters (testability, loose coupling, separation of concerns, lifecycle management), manual constructor injection, and DI library comparison (google/wire, uber-go/dig, uber-go/fx, samber/do). Use this skill when designing service architecture, setting up dependency injection, refactoring tightly coupled code, managing singletons or service factories, or when the user asks about inversion of control, service containers, or wiring dependencies in Go. For a specific DI library, → See `samber/cc-skills-golang@golang-google-wire`, `samber/cc-skills-golang@golang-uber-dig`, `samber/cc-skills-golang@golang-uber-fx`, or `samber/cc-skills-golang@golang-samber-do` skills.

samber/golang-dependency-management

Dependency management strategies for Golang projects — go.mod management, installing/upgrading packages, Minimal Version Selection, vulnerability scanning, outdated dependency tracking, binary size analysis, Dependabot/Renovate setup, conflict resolution, and go.work workspaces. Use when adding, removing, or upgrading Go dependencies, auditing vulnerabilities, resolving version conflicts, or setting up automated dependency updates.

samber/golang-design-patterns

Idiomatic Golang design patterns — functional options, constructors, error flow and cascading, resource management and lifecycle, graceful shutdown, resilience, architecture, dependency injection, data handling, streaming, and more. Apply when explicitly choosing between architectural patterns, implementing functional options, designing constructor APIs, setting up graceful shutdown, applying resilience patterns, or asking which idiomatic Go pattern fits a specific problem.

samber/golang-documentation

Comprehensive documentation guide for Golang projects, covering godoc comments, README, CONTRIBUTING, CHANGELOG, Go Playground, Example tests, API docs, and llms.txt. Use when writing or reviewing doc comments, documentation, adding code examples, setting up doc sites, or discussing documentation best practices. Triggers for both libraries and applications/CLIs.

samber/golang-error-handling

Idiomatic Golang error handling — creation, wrapping with %w, errors.Is/As, errors.Join, custom error types, sentinel errors, panic/recover, the single handling rule, structured logging with slog, HTTP request logging middleware, and samber/oops for production errors. Built to make logs usable at scale with log aggregation 3rd-party tools. Apply when creating, wrapping, inspecting, or logging errors in Go code. For samber/oops specifics → See `samber/cc-skills-golang@golang-samber-oops` skill; for slog handler ecosystem → See `samber/cc-skills-golang@golang-samber-slog` skill.

samber/golang-google-wire

Compile-time dependency injection in Golang using google/wire — wire.NewSet, wire.Build, wire.Bind (interface→concrete), wire.Struct, wire.Value, wire.InterfaceValue, wire.FieldsOf, cleanup functions, //go:build wireinject injector files, and generated wire_gen.go. Apply when using or adopting google/wire, when the codebase imports `github.com/google/wire`, or when wiring an application graph at compile time via `wire.Build`. For runtime DI with reflection, see `samber/cc-skills-golang@golang-uber-dig` skill.

samber/golang-gopls

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`).

samber/golang-graphql

Implements GraphQL APIs in Golang using gqlgen or graphql-go. Apply when building GraphQL servers, designing schemas, writing resolvers, handling subscriptions, or integrating GraphQL with existing Go HTTP services. Also apply when the codebase imports `github.com/99designs/gqlgen` or `github.com/graph-gophers/graphql-go`.

samber/golang-grpc

Provides gRPC usage guidelines, protobuf organization, and production-ready patterns for Golang microservices. Use when implementing, reviewing, or debugging gRPC servers/clients, writing proto files, setting up interceptors, handling gRPC errors with status codes, configuring TLS/mTLS, testing with bufconn, or working with streaming RPCs.

samber/golang-how-to

Golang skills orchestrator — always active on any Golang coding, review, debug, or setup task. Reads the task context and loads the most relevant skills from samber/cc-skills-golang, often multiple at once: writing a gRPC service loads golang-grpc + golang-testing + golang-error-handling; debugging a panic loads golang-troubleshooting + golang-safety; auditing security loads golang-security + golang-lint + golang-safety. Also: disambiguates competing clusters when two skills seem to overlap (performance vs benchmark vs troubleshooting, samber/lo vs mo vs ro, DI cluster, safety vs security), and configures the project's agent-config file (CLAUDE.md, AGENTS.md, GEMINI.md, Cursor rules, or Copilot instructions) to force-trigger skills in a project (/golang-how-to configure).

samber/golang-lint

Linting best practices and golangci-lint configuration for Golang projects — running linters, configuring .golangci.yml, suppressing warnings with nolint directives, interpreting lint output, and selecting linters. Use when configuring golangci-lint, asking about lint warnings or nolint suppressions, setting up code quality tooling, or choosing linters. Also use when the user mentions golangci-lint, go vet, staticcheck, or revive.

samber/golang-modernize

Modernize Golang code to use recent language features, standard library improvements, and idiomatic patterns. Trigger proactively when writing or reviewing Go code and old-style patterns are detected, or when encountering a deprecation warning. Also use when the user explicitly asks for modernization, a Go version upgrade, or a CI/tooling refresh.

Habilidades Relacionadas