CommunityProgramación y desarrollogithub.com

samber/golang-pkg-go-dev

Búsqueda de paquetes y módulos Golang mediante `godig`, un cliente de la API de pkg.go.dev (CLI + servidor MCP). Úselo para obtener documentación, firmas de API, símbolos, ejemplos de uso, versiones, licencias, vulnerabilidades e importadores de cualquier biblioteca Go. Solo lectura, sin autenticación.

¿Qué es golang-pkg-go-dev?

Este skill proporciona acceso a la API de pkg.go.dev a través de la herramienta `godig`, que funciona tanto como CLI como servidor MCP (Model Context Protocol). Su propósito es responder preguntas sobre el ecosistema de paquetes Go publicado: documentación de paquetes, símbolos exportados, versiones disponibles, licencias, vulnerabilidades conocidas (CVE) y paquetes que importan un módulo. Está diseñado para usarse con asistentes de IA como Claude Code, Cursor o Codex, y todas las operaciones son de solo lectura, sin necesidad de autenticación. A diferencia de Context7 (que es un recurso de respaldo para documentación no indexada o no Go), `godig` está especializado exclusivamente en Go y debe preferirse para cualquier consulta sobre el ecosistema Go público. El skill incluye una tabla completa de comandos (overview, search, package info, symbol doc, versions, vulns, imported-by, entre otros) con flags de formato, filtrado, y control de versión. Se recomienda empezar siempre con el comando `overview` para obtener un resumen compacto antes de invocar comandos más pesados como `package doc` o `module readme`. La salida en Markdown (`-o md`) está optimizada para su visualización en chat de IA.

Compatible con✓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 Programación y desarrollo skills: steipete/bluebubbles, steipete/eightctl, steipete/blucli · View all 6 →

Preguntar en tu IA favorita

Abre un nuevo chat con esta habilidad de agente ya precargada.

Documentación

¿Qué hace golang-pkg-go-dev?

Dependencias: godig — go install github.com/samber/godig/cmd/godig@latest (o use un servidor MCP godig registrado / la instancia alojada en su lugar).

godig consulta la API de pkg.go.dev. Úselo para responder preguntas sobre paquetes y módulos Go: documentación, símbolos, versiones, importadores y vulnerabilidades. Funciona como CLI y como servidor MCP, y todas las operaciones son de solo lectura y no requieren autenticación.

Cuándo usar este skill

Actívelo en preguntas como:

  • "¿Qué versiones de github.com/samber/lo están disponibles?"
  • "¿Tiene golang.org/x/text vulnerabilidades conocidas?"
  • "Muéstrame la documentación / los símbolos del paquete X."
  • "¿Qué paquetes importan X?"
  • "Buscar paquetes Go sobre Y."

Elegir entre godig, gopls, Context7 y govulncheck

En resumen: godig responde preguntas sobre el ecosistema publicado (funciona incluso para paquetes que aún no están en su go.mod); gopls razona sobre su build local resuelta (go.sum, incluyendo forks replaceados); Context7 es un recurso de respaldo para documentación que no es Go o no indexada; govulncheck es la auditoría de vulnerabilidades de todo el árbol (→ samber/cc-skills-golang@golang-security). Consulte el skill samber/cc-skills-golang@golang-gopls para la conexión de gopls (servidor MCP, herramienta LSP nativa y CLI) con Claude Code, y la sección "godig vs gopls vs Context7 vs govulncheck" del skill samber/cc-skills-golang@golang-how-to para la matriz completa de tarea a herramienta.

Configuración

Instalación

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

Registrar el servidor MCP (opcional)

godig mcp se ejecuta sobre stdio por defecto, o HTTP transmisible con --transport http. El comando es independiente del harness — cualquier host compatible con MCP puede apuntar a él. Claude Code lo registra a través de su propia CLI:

stdio (el cliente lanza godig bajo demanda):

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

HTTP transmisible (servidor compartido en /mcp, por defecto :8080):

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

Instancia alojada (sin necesidad de instalación) — un servidor público se ejecuta en https://godig.samber.dev/mcp:

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

Otros harnesses compatibles con MCP (Cursor, Windsurf y otros) tienen cada uno su propio registro de servidor MCP — una entrada en su respectivo archivo de configuración que apunta al mismo comando godig mcp o URL alojada, no un formato de configuración compartido.

La CLI y el servidor MCP exponen las mismas operaciones con nombres coincidentes. Prefiera la CLI cuando godig esté instalado; la instancia alojada es un recurso de respaldo cuando no lo esté.

Comandos

Flags globales (todos los comandos): -o/--output table|json|raw|md (por defecto table — pase -o md para chat), --base-url (API de pkg.go.dev), --vuln-base-url (base de datos de vulnerabilidades Go, consultada por vulns y overview), --timeout, --log-level debug|info|warn|error|off. Todos también se pueden configurar mediante variables de entorno GODIG_*.

ComandoArgumentosFlags específicosPropósito
overview<ruta>--versionResumen compacto (metadatos, versiones, licencias, vulnerabilidades) — comience aquí
search<consulta>--symbol --limit --filterEncontrar paquetes (opcionalmente que exporten un símbolo)
package info<ruta>--module --versionMetadatos del paquete
package imports<ruta>--module --versionPaquetes que este paquete importa (lista simple)
package doc<ruta>--module --version --goos --goarch --format md|text|html|markdownDocumentación completa del paquete (GRANDE)
package examples<ruta>--module --version --goos --goarch --symbolEjemplos ejecutables (GRANDE; acote con --symbol)
package licenses<ruta>--module --versionArchivos de licencia, texto completo (GRANDE)
symbol doc<ruta> <símbolo>--module --version --goos --goarchFirma + documentación de un símbolo (eficiente en tokens)
symbol examples<ruta> <símbolo>--module --version --goos --goarchEjemplos ejecutables de un símbolo
symbols<ruta>--module --version --goos --goarch --limit --filterListar símbolos exportados
module info<ruta>--versionMetadatos del módulo
module licenses<ruta>--versionArchivos de licencia del módulo (GRANDE)
module readme<ruta>--versionREADME del módulo, Markdown completo (GRANDE)
dependencies<ruta>--versionDependencias de go.mod: requires / replaces / excludes / directiva go
packages<ruta>--version --limit --filterPaquetes contenidos en un módulo
versions<ruta>--limit --filterTodas las versiones, de más nueva a más antigua
major-versions<ruta>--limit --filter --exclude-pseudoVersiones principales (v1, v2…) que viven como módulos separados
imported-by<ruta>--module --version --limit --filterPaquetes que importan este
vulns<ruta>--version --limitVulnerabilidades conocidas (de la base de datos de vulnerabilidades Go)
mcp—--transport stdio|http --addr --cache-ttl --cache-sizeEjecutar como servidor MCP
version——Imprimir la versión / commit / fecha de compilación de godig

Cuando godig se ejecuta como servidor MCP, cada comando de datos anterior se expone como una operación del mismo nombre.

Códigos de salida: 0 éxito, 1 error de ejecución (red, paquete no encontrado), 2 error de uso — un argumento o flag faltante/inválido (p.ej., un --limit no positivo), o un grupo de comandos invocado sin subcomando (godig package). Verifique 2 para distinguir una llamada mal formada de una búsqueda fallida.

Salida completa -o md para cada comando: sample-output.md.

Consejos

  • Comience con overview — una llamada devuelve un resumen compacto (metadatos, versiones más recientes y recientes, tipos de licencia, vulnerabilidades). Recurra a doc/examples/module readme/licenses (GRANDE) solo cuando necesite el texto completo.
  • Pase siempre -o md para que los resultados se rendericen como Markdown (tablas, o documentación/README sin formato) en el chat. Existen otros formatos (table por defecto, json, raw) pero prefiera md aquí.
  • <ruta> es una ruta de importación completa, p.ej., github.com/samber/lo — pase como argumento posicional.
  • --version fija una versión de módulo específica (v1.5.0, latest, master, main); --module desambigua a qué módulo pertenece un paquete.
  • --filter reduce los resultados de listas en el servidor con una expresión booleana Go — consulte Sintaxis de filtro.
  • --goos/--goarch establecen el contexto de compilación de la documentación/símbolos (p.ej., linux/amd64).
  • Prefiera symbol doc/symbol examples sobre los package doc/package examples de todo el paquete cuando solo necesite un símbolo.

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.

Skills relacionados