dotnet-local-tools

Gerenciamento de ferramentas locais do .NET com dotnet-tools.json para consistência de ferramentas entre ambientes de desenvolvimento e pipelines CI/CD.

O que é dotnet-local-tools?

Esta skill habilita o gerenciamento de ferramentas CLI do .NET de forma local por repositório, utilizando o arquivo `.config/dotnet-tools.json`. Ao contrário das ferramentas globais, as ferramentas locais permitem versionamento preciso e isolamento entre projetos, eliminando conflitos de versão e garantindo que toda a equipe e os ambientes de CI/CD utilizem exatamente os mesmos binários. A skill cobre desde a inicialização do manifesto com `dotnet new tool-manifest`, instalação, restauração e atualização de ferramentas como DocFX, dotnet-ef, ReportGenerator e CSharpier, até a integração completa com GitHub Actions e Azure Pipelines. Ela também inclui práticas recomendadas como fixar versões exatas com `rollForward: false`, configurar `isRoot: true` e usar Dependabot para atualizações automáticas. Suportada em qualquer plataforma que execute o .NET SDK, é essencial para equipes que buscam reprodutibilidade e padronização em seus fluxos de desenvolvimento.

Funciona com~Claude Code~Codex CLI~Cursor
npx skills add https://github.com/Aaronontheweb/dotnet-skills/tree/main/skills/local-tools

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

Ferramentas Locais do .NET

Quando Usar Esta Skill

Use esta skill quando:

  • Configurando ferramentas consistentes em toda a equipe de desenvolvimento
  • Garantindo que pipelines CI/CD usem as mesmas versões de ferramentas que o desenvolvimento local
  • Gerenciando ferramentas CLI específicas de projeto (docfx, incrementalist, dotnet-ef, etc.)
  • Evitando conflitos de versão de ferramentas globais entre projetos

O Que São Ferramentas Locais?

Ferramentas locais são ferramentas CLI do .NET que são instaladas e versionadas por repositório, em vez de globalmente. Elas são definidas em .config/dotnet-tools.json e restauradas com dotnet tool restore.

Ferramentas Locais vs Globais

AspectoFerramentas GlobaisFerramentas Locais
Instalaçãodotnet tool install -gdotnet tool restore
EscopoEm toda a máquinaPor repositório
Controle de versãoManualEm .config/dotnet-tools.json
CI/CDDeve instalar cada ferramentaUm único comando restore
ConflitosPode ter conflitos de versãoIsolado por projeto

Configurando Ferramentas Locais

Inicializar o Manifesto

# Criar .config/dotnet-tools.json
dotnet new tool-manifest

Isso cria:

.config/
└── dotnet-tools.json

Instalar Ferramentas Localmente

# Instalar uma ferramenta localmente
dotnet tool install docfx

# Instalar versão específica
dotnet tool install docfx --version 2.78.3

# Instalar de uma fonte específica
dotnet tool install MyTool --add-source https://mycompany.pkgs.visualstudio.com/_packaging/feed/nuget/v3/index.json

Restaurar Ferramentas

# Restaurar todas as ferramentas do manifesto
dotnet tool restore

Formato dotnet-tools.json

{
  "version": 1,
  "isRoot": true,
  "tools": {
    "docfx": {
      "version": "2.78.3",
      "commands": [
        "docfx"
      ],
      "rollForward": false
    },
    "dotnet-ef": {
      "version": "9.0.0",
      "commands": [
        "dotnet-ef"
      ],
      "rollForward": false
    },
    "incrementalist.cmd": {
      "version": "1.2.0",
      "commands": [
        "incrementalist"
      ],
      "rollForward": false
    },
    "dotnet-reportgenerator-globaltool": {
      "version": "5.4.1",
      "commands": [
        "reportgenerator"
      ],
      "rollForward": false
    }
  }
}

Campos

CampoDescrição
versionVersão do esquema do manifesto (sempre 1)
isRootMarca este como o manifesto raiz (impede busca em diretórios pai)
toolsDicionário de configurações de ferramentas
tools.<nome>.versionVersão exata a ser instalada
tools.<nome>.commandsComandos CLI que a ferramenta fornece
tools.<nome>.rollForwardPermitir versões mais recentes (geralmente false para reprodutibilidade)

Ferramentas Comuns

Documentação

# DocFX - Gerador de documentação de API
dotnet tool install docfx
"docfx": {
  "version": "2.78.3",
  "commands": ["docfx"],
  "rollForward": false
}

Uso:

dotnet docfx docfx.json
dotnet docfx serve _site

Entity Framework Core

# CLI do EF Core para migrações
dotnet tool install dotnet-ef
"dotnet-ef": {
  "version": "9.0.0",
  "commands": ["dotnet-ef"],
  "rollForward": false
}

Uso:

dotnet ef migrations add InitialCreate
dotnet ef database update

Cobertura de Código

# ReportGenerator para relatórios de cobertura
dotnet tool install dotnet-reportgenerator-globaltool
"dotnet-reportgenerator-globaltool": {
  "version": "5.4.1",
  "commands": ["reportgenerator"],
  "rollForward": false
}

Uso:

dotnet reportgenerator -reports:coverage.cobertura.xml -targetdir:coveragereport -reporttypes:Html

Builds Incrementais

# Incrementalist - constrói apenas projetos alterados
dotnet tool install incrementalist.cmd
"incrementalist.cmd": {
  "version": "1.2.0",
  "commands": ["incrementalist"],
  "rollForward": false
}

Uso:

# Obter projetos afetados por alterações desde o branch main
incrementalist --branch main

Formatação de Código

# CSharpier - Formatador opinativo de C#
dotnet tool install csharpier
"csharpier": {
  "version": "0.30.3",
  "commands": ["dotnet-csharpier"],
  "rollForward": false
}

Uso:

dotnet csharpier .
dotnet csharpier --check .  # Modo CI - falha se houver alterações necessárias

Análise de Código

# JB dotnet-inspect (requer licença)
dotnet tool install jb
"jb": {
  "version": "2024.3.4",
  "commands": ["jb"],
  "rollForward": false
}

Integração com CI/CD

GitHub Actions

jobs:
  build:
    runs-on: ubuntu-latest
    steps:
      - uses: actions/checkout@v4

      - name: Setup .NET
        uses: actions/setup-dotnet@v4
        with:
          global-json-file: global.json

      - name: Restore tools
        run: dotnet tool restore

      - name: Build
        run: dotnet build

      - name: Test with coverage
        run: dotnet test --collect:"XPlat Code Coverage"

      - name: Generate coverage report
        run: dotnet reportgenerator -reports:**/coverage.cobertura.xml -targetdir:coveragereport

      - name: Build documentation
        run: dotnet docfx docs/docfx.json

Azure Pipelines

steps:
  - task: UseDotNet@2
    inputs:
      useGlobalJson: true

  - script: dotnet tool restore
    displayName: 'Restore .NET tools'

  - script: dotnet build -c Release
    displayName: 'Build'

  - script: dotnet test -c Release --collect:"XPlat Code Coverage"
    displayName: 'Test'

  - script: dotnet reportgenerator -reports:**/coverage.cobertura.xml -targetdir:$(Build.ArtifactStagingDirectory)/coverage
    displayName: 'Generate coverage report'

Gerenciando Versões de Ferramentas

Atualizar uma Ferramenta

# Atualizar para a versão mais recente
dotnet tool update docfx

# Atualizar para uma versão específica
dotnet tool update docfx --version 2.79.0

Listar Ferramentas Instaladas

# Listar ferramentas locais
dotnet tool list

# Listar com verificação de desatualizadas
dotnet tool list --outdated

Remover uma Ferramenta

dotnet tool uninstall docfx

Melhores Práticas

1. Sempre Defina isRoot: true

Impede que o MSBuild procure por manifestos de ferramentas em diretórios pai:

{
  "version": 1,
  "isRoot": true,
  ...
}

2. Fixe Versões Exatas

Use "rollForward": false para builds reproduzíveis:

"docfx": {
  "version": "2.78.3",
  "rollForward": false
}

3. Restaure no CI Antes de Usar

Sempre execute dotnet tool restore antes de usar qualquer ferramenta local:

- run: dotnet tool restore
- run: dotnet docfx docs/docfx.json

4. Documente os Requisitos de Ferramentas

Adicione um comentário ou seção no README:

## Configuração de Desenvolvimento

1. Restaure as ferramentas: `dotnet tool restore`
2. Build: `dotnet build`
3. Teste: `dotnet test`

5. Use Dependabot para Atualizações

# .github/dependabot.yml
version: 2
updates:
  - package-ecosystem: "nuget"
    directory: "/"
    schedule:
      interval: "weekly"
    # Inclui ferramentas locais em .config/dotnet-tools.json

Solução de Problemas

Ferramenta Não Encontrada Após Restore

Certifique-se de que está executando a partir da raiz do repositório:

# Errado - executando de um subdiretório
cd src/MyApp
dotnet docfx  # Erro: ferramenta não encontrada

# Correto - execute da raiz da solução
cd ../..
dotnet docfx docs/docfx.json

Conflitos de Versão

Se você encontrar conflitos de versão, verifique:

  1. Ferramenta global com versão diferente: dotnet tool list -g
  2. Múltiplos manifestos de ferramentas: Procure por .config/dotnet-tools.json em diretórios pai

Limpando o Cache de Ferramentas

# Limpar cache de ferramentas NuGet
dotnet nuget locals all --clear

# Re-restaurar ferramentas
dotnet tool restore

Exemplo: Configuração Completa de Desenvolvimento

{
  "version": 1,
  "isRoot": true,
  "tools": {
    "docfx": {
      "version": "2.78.3",
      "commands": ["docfx"],
      "rollForward": false
    },
    "dotnet-ef": {
      "version": "9.0.0",
      "commands": ["dotnet-ef"],
      "rollForward": false
    },
    "dotnet-reportgenerator-globaltool": {
      "version": "5.4.1",
      "commands": ["reportgenerator"],
      "rollForward": false
    },
    "csharpier": {
      "version": "0.30.3",
      "commands": ["dotnet-csharpier"],
      "rollForward": false
    },
    "incrementalist.cmd": {
      "version": "1.2.0",
      "commands": ["incrementalist"],
      "rollForward": false
    }
  }
}

Fluxo de trabalho de desenvolvimento:

# Configuração inicial
dotnet tool restore

# Formatar código antes do commit
dotnet csharpier .

# Executar testes com cobertura
dotnet test --collect:"XPlat Code Coverage"
dotnet reportgenerator -reports:**/coverage.cobertura.xml -targetdir:coverage

# Construir documentação
dotnet docfx docs/docfx.json

# Verificar quais projetos mudaram (para repositórios grandes)
incrementalist --branch main

Individual skills in this repo

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

akka-hosting-actor-patterns

Patterns for building entity actors with Akka.Hosting - GenericChildPerEntityParent, message extractors, cluster sharding abstraction, akka-reminders, and ITimeProvider. Supports both local testing and clustered production modes.

akka-net-aspire-configuration

Configure Akka.NET with .NET Aspire for local development and production deployments. Covers actor system setup, clustering, persistence, Akka.Management integration, and Aspire orchestration patterns.

akka-net-best-practices

Critical Akka.NET best practices including EventStream vs DistributedPubSub, supervision strategies, error handling, Props vs DependencyResolver, work distribution patterns, and cluster/local mode abstractions for testability.

akka-net-management

Akka.Management for cluster bootstrapping, service discovery (Kubernetes, Azure, Config), health checks, and dynamic cluster formation without static seed nodes.

akka-net-testing-patterns

Write unit and integration tests for Akka.NET actors using modern Akka.Hosting.TestKit patterns. Covers dependency injection, TestProbes, persistence testing, and actor interaction verification. Includes guidance on when to use traditional TestKit.

api-design

Design stable, compatible public APIs using extend-only design principles. Manage API compatibility, wire compatibility, and versioning for NuGet packages and distributed systems.

aspire-configuration

Configure Aspire AppHost to emit explicit app config via environment variables; keep app code free of Aspire clients and service discovery.

aspire-integration-testing

Write integration tests using .NET Aspire

aspire-service-defaults

Create a shared ServiceDefaults project for Aspire applications. Centralizes OpenTelemetry, health checks, resilience, and service discovery configuration across all services.

crap-analysis

Analyze code coverage and CRAP (Change Risk Anti-Patterns) scores to identify high-risk code. Use OpenCover format with ReportGenerator for Risk Hotspots showing cyclomatic complexity and untested code paths.

csharp-concurrency-patterns

Choosing the right concurrency abstraction in .NET - from async/await for I/O to Channels for producer/consumer to Akka.NET for stateful entity management. Avoid locks and manual synchronization unless absolutely necessary.

database-performance

Database access patterns for performance. Separate read/write models, avoid N+1 queries, use AsNoTracking, apply row limits, and never do application-side joins. Works with EF Core and Dapper.

dependency-injection-patterns

Organize DI registrations using IServiceCollection extension methods. Group related services into composable Add* methods for clean Program.cs and reusable configuration in tests.

dotnet-devcert-trust

Diagnose and fix .NET HTTPS dev certificate trust issues on Linux. Covers the full certificate lifecycle from generation to system CA bundle inclusion, with distro-specific guidance for Ubuntu, Fedora, Arch, and WSL2.

dotnet-project-structure

Modern .NET project structure including .slnx solution format, Directory.Build.props, central package management, SourceLink, version management with RELEASE_NOTES.md, and SDK pinning with global.json.

dotnet-slopwatch

Use Slopwatch to detect LLM reward hacking in .NET code changes. Run after every code modification to catch disabled tests, suppressed warnings, empty catch blocks, and other shortcuts that mask real problems.

efcore-patterns

Entity Framework Core best practices including NoTracking by default, query splitting for navigation collections, migration management, dedicated migration services, and common pitfalls to avoid.

ilspy-decompile

Understand implementation details of .NET code by decompiling assemblies. Use when you want to see how a .NET API works internally, inspect NuGet package source, view framework implementation, or understand compiled .NET binaries.

mailpit-integration

Test email sending locally using Mailpit with .NET Aspire. Captures all outgoing emails without sending them. View rendered HTML, inspect headers, and verify delivery in integration tests.

marketplace-publishing

Workflow for publishing skills and agents to the dotnet-skills Claude Code marketplace. Covers adding new content, updating plugin.json, validation, and release tagging.

Habilidades Relacionadas