samber/golang-pkg-go-dev

Recherche de paquets et modules Golang via `godig`, un client API pkg.go.dev (CLI + serveur MCP). À utiliser pour la documentation, les signatures d'API, les symboles, les exemples d'utilisation, les versions, les licences, la présence de CVE dans une dépendance ou les importateurs d'un paquet Go — à privilégier par rapport à Context7 pour tout paquet ou module Go. Lecture seule, sans authentification.

Qu'est-ce que golang-pkg-go-dev ?

Cette compétence permet aux agents d'IA et aux développeurs d'interroger l'écosystème Go publié en utilisant `godig`, un client CLI et serveur MCP qui appelle l'API de pkg.go.dev. Elle est conçue pour répondre à des questions sur n'importe quel paquet ou module Go, qu'il soit dans votre `go.mod` ou non : documentation, signatures de symboles, versions disponibles, licences, vulnérabilités connues (CVE), paquets qui importent un module donné, et plus encore. Toutes les opérations sont en lecture seule et ne nécessitent aucune authentification, ce qui permet de l'utiliser en toute sécurité dans des chaînes d'outils automatisées. Elle est disponible sous forme de CLI (`go install`) ou de serveur MCP (mode stdio ou HTTP streamable), avec une instance hébergée publique pour un accès sans installation. Elle est compatible avec Claude Code, Cursor, Windsurf et tout hôte capable de MCP, en privilégiant le format de sortie Markdown pour un affichage optimal dans le chat. Elle se distingue de `gopls` (qui analyse votre build local), de Context7 (pour les documentations non Go ou non indexées) et de `govulncheck` (audit complet de l'arbre des dépendances), et ne doit pas être utilisée pour la mise à jour des dépendances, le choix de bibliothèques ou l'analyse des symboles locaux.

Compatible avec✓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 Développement et programmation skills: steipete/bluebubbles, steipete/eightctl, steipete/blucli · View all 6 →

Demander à votre IA préférée

Ouvre une nouvelle conversation avec cette compétence d'agent déjà préchargée.

Documentation

Que fait golang-pkg-go-dev ?

Dépendances : godig — go install github.com/samber/godig/cmd/godig@latest (ou utilisez un serveur MCP godig enregistré / l'instance hébergée à la place).

godig interroge l'API de pkg.go.dev. Utilisez-le pour répondre à des questions sur les paquets et modules Go : documentation, symboles, versions, importateurs et vulnérabilités. Il fonctionne en CLI et en serveur MCP, et toutes les opérations sont en lecture seule et ne nécessitent aucune authentification.

Quand utiliser cette compétence

Déclenchez-la pour des questions comme :

  • « Quelles versions de github.com/samber/lo sont disponibles ? »
  • « Est-ce que golang.org/x/text a des vulnérabilités connues ? »
  • « Montre-moi la documentation / les symboles du paquet X. »
  • « Quels paquets importent X ? »
  • « Cherche des paquets Go pour Y. »

Choisir entre godig, gopls, Context7 et govulncheck

En bref : godig répond aux questions sur l'écosystème publié (fonctionne même pour les paquets pas encore dans votre go.mod) ; gopls raisonne sur votre build local résolu (go.sum, incluant les forks replace) ; Context7 est une solution de repli pour les documentations non Go ou non indexées ; govulncheck est l'audit de vulnérabilité sur l'arbre entier (→ samber/cc-skills-golang@golang-security). Voir la compétence samber/cc-skills-golang@golang-gopls pour connecter gopls (serveur MCP, outil LSP natif et CLI) avec Claude Code, et la section « godig vs gopls vs Context7 vs govulncheck » de la compétence samber/cc-skills-golang@golang-how-to pour la matrice tâche-à-outil complète.

Installation

Installer

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

Enregistrer le serveur MCP (optionnel)

godig mcp fonctionne par défaut sur stdio, ou HTTP streamable avec --transport http. La commande est indépendante de l'hôte — tout hôte compatible MCP peut l'utiliser. Claude Code l'enregistre via sa propre CLI :

stdio (le client lance godig à la demande) :

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

HTTP streamable (serveur partagé sur /mcp, défaut :8080) :

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

Instance hébergée (pas d'installation nécessaire) — un serveur public tourne à https://godig.samber.dev/mcp :

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

Les autres hôtes compatibles MCP (Cursor, Windsurf, etc.) ont chacun leur propre méthode d'enregistrement — une entrée dans leur fichier de configuration pointant vers la même commande godig mcp ou URL hébergée, pas un format de configuration partagé.

La CLI et le serveur MCP exposent les mêmes opérations sous des noms correspondants. Privilégiez la CLI lorsque godig est installé ; l'instance hébergée est un repli lorsqu'il ne l'est pas.

Commandes

Drapeaux globaux (toutes les commandes) : -o/--output table|json|raw|md (défaut table — passez -o md pour le chat), --base-url (API pkg.go.dev), --vuln-base-url (base de données de vulnérabilités Go, consultée par vulns et overview), --timeout, --log-level debug|info|warn|error|off. Tous sont également configurables via les variables d'environnement GODIG_*.

CommandeArgumentsDrapeaux spécifiquesObjectif
overview<chemin>--versionRésumé compact (métadonnées, versions, licences, vulnérabilités) — commencez ici
search<requête>--symbol --limit --filterTrouver des paquets (exportant éventuellement un symbole)
package info<chemin>--module --versionMétadonnées du paquet
package imports<chemin>--module --versionPaquets importés par ce paquet (liste simple)
package doc<chemin>--module --version --goos --goarch --format md|text|html|markdownDocumentation complète du paquet (VOLUMINEUX)
package examples<chemin>--module --version --goos --goarch --symbolExemples exécutables (VOLUMINEUX ; précisez avec --symbol)
package licenses<chemin>--module --versionFichiers de licence, texte intégral (VOLUMINEUX)
symbol doc<chemin> <symbole>--module --version --goos --goarchSignature et documentation d'un symbole (économe en tokens)
symbol examples<chemin> <symbole>--module --version --goos --goarchExemples exécutables d'un symbole
symbols<chemin>--module --version --goos --goarch --limit --filterLister les symboles exportés
module info<chemin>--versionMétadonnées du module
module licenses<chemin>--versionFichiers de licence du module (VOLUMINEUX)
module readme<chemin>--versionREADME du module, Markdown complet (VOLUMINEUX)
dependencies<chemin>--versionDépendances go.mod : requires / replaces / excludes / directive go
packages<chemin>--version --limit --filterPaquets contenus dans un module
versions<chemin>--limit --filterToutes les versions, de la plus récente à la plus ancienne
major-versions<chemin>--limit --filter --exclude-pseudoVersions majeures (v1, v2…) vivant comme modules séparés
imported-by<chemin>--module --version --limit --filterPaquets qui importent celui-ci
vulns<chemin>--version --limitVulnérabilités connues (depuis la base de vulnérabilités Go)
mcp—--transport stdio|http --addr --cache-ttl --cache-sizeExécuter en tant que serveur MCP
version——Afficher la version / le commit / la date de build de godig

Lorsque godig s'exécute en tant que serveur MCP, chaque commande de données ci-dessus est exposée comme une opération du même nom.

Codes de sortie : 0 succès, 1 erreur d'exécution (réseau, paquet non trouvé), 2 erreur d'utilisation — un argument ou drapeau manquant/invalide (par exemple un --limit non positif), ou un groupe de commandes invoqué sans sous-commande (godig package). Vérifiez 2 pour distinguer un appel mal formé d'une recherche infructueuse.

Sortie complète -o md pour chaque commande : sample-output.md.

Astuces

  • Commencez par overview — un seul appel retourne un résumé compact (métadonnées, versions récentes + dernières, types de licence, vulnérabilités). Utilisez doc/examples/module readme/licenses (VOLUMINEUX) seulement lorsque le texte complet est nécessaire.
  • Passez toujours -o md pour que les résultats soient rendus en Markdown (tableaux, ou documentation/README brut) dans le chat. D'autres formats existent (table par défaut, json, raw) mais préférez md ici.
  • <chemin> est un chemin d'import complet, par exemple github.com/samber/lo — passez-le comme argument positionnel.
  • --version verrouille une version spécifique du module (v1.5.0, latest, master, main) ; --module désambiguïse à quel module appartient un paquet.
  • --filter réduit les résultats côté serveur avec une expression booléenne Go — voir Syntaxe de filtre.
  • --goos/--goarch définissent le contexte de build de la documentation/des symboles (par exemple linux/amd64).
  • Privilégiez symbol doc/symbol examples au lieu des package doc/package examples à l'échelle du paquet lorsque vous n'avez besoin que d'un seul symbole.

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 associés