NetContextServer

by willibrandon
Verified
MIT License
12
  • Linux
  • Apple

local-only server

The server can only run on the client’s local machine because it depends on local resources.

Integrations

  • Provides deep codebase understanding for .NET projects, including semantic code search, project structure navigation, and test coverage analysis.

  • Enables package analysis for NuGet dependencies, including visualization of transitive dependencies, update recommendations, and security issue identification.

  • Leverages Azure OpenAI for semantic code search capabilities, finding code based on meaning rather than exact text matches.

Servidor de contexto de red

🔍 Potencie su asistente de codificación de IA con una comprensión profunda de la base de código .NET

NetContextServer permite a los asistentes de programación de IA, como VS Code, comprender a fondo su código .NET mediante el Protocolo de Contexto de Modelo (MCP) . Esto se traduce en sugerencias de código más precisas, mejores respuestas a sus preguntas y una experiencia de programación más productiva.

✨ Características principales

  • Búsqueda de código semántico : encuentra código describiendo lo que estás buscando en lenguaje natural
  • 🔍 Navegación inteligente : ayuda a las herramientas de IA a comprender la estructura y las dependencias de tu proyecto
  • 🛡️ Seguridad incorporada : acceso seguro a archivos con protección automática de datos confidenciales
  • Integración con VS Code : configuración perfecta con VS Code para una mejor asistencia en la codificación
  • 📦 Análisis de paquetes : comprenda sus dependencias y obtenga recomendaciones de actualizaciones
    • 🔍 Visualización de dependencias profundas : vea dependencias transitivas con gráficos interactivos codificados por colores
    • 🧩 Agrupación inteligente : Agrupe visualmente los paquetes relacionados para una navegación más sencilla
    • 📊 Recomendaciones de actualización : Identifique paquetes obsoletos y problemas de seguridad
  • 📊 Análisis de cobertura de pruebas : información detallada sobre la cobertura de sus pruebas
    • 🎯 Compatibilidad con múltiples formatos : analiza datos de cobertura de Coverlet, LCOV y Cobertura XML
    • 📈 Informes detallados : porcentajes de cobertura a nivel de archivo y seguimiento de líneas descubiertas
    • Cobertura de sucursales : Realice un seguimiento de la cobertura de sucursales a nivel de método cuando esté disponible
    • 💡 Recomendaciones inteligentes : obtenga sugerencias para mejorar la cobertura de las pruebas
  • Rápido y eficiente : indexación rápida y tiempos de respuesta para bases de código grandes

🚀 Inicio rápido

  1. Clonar y construir :
git clone https://github.com/willibrandon/NetContextServer.git cd NetContextServer dotnet build
  1. Configurar (opcional, para búsqueda semántica):
# Set Azure OpenAI credentials in environment: AZURE_OPENAI_ENDPOINT=your_endpoint AZURE_OPENAI_API_KEY=your_key
  1. Comience a usar :
# Point to your project dotnet run --project src/NetContextClient/NetContextClient.csproj -- set-base-dir --directory "path/to/your/project" # Try semantic search dotnet run --project src/NetContextClient/NetContextClient.csproj -- semantic-search --query "find authentication logic"

👉 Lea nuestra Guía de inicio para obtener instrucciones de configuración detalladas y las mejores prácticas.

🔌 Integración con VS Code

  1. Abrir Visual Studio Code
  2. Presione Ctrl + Shift + P (o Cmd + Shift + P en macOS)
  3. Escriba "Configurar servidor MCP"
  4. Ingresar:
{ "command": "dotnet", "args": ["run", "--project", "path/to/NetContextServer/src/NetContextServer/NetContextServer.csproj"] }

¡Ahora VS Code puede comprender tu código base! Intenta hacerle preguntas como:

  • "Enumerar todos los archivos fuente .NET en este directorio del proyecto"
  • "Buscar coincidencias de texto exactas en los archivos de código"
  • Analizar los paquetes NuGet en todos los proyectos
  • Obtener la lista actual de patrones ignorados
  • "Agregue estos patrones de ignorancia: .generated.cs, bin/ "
  • "Enumerar todos los archivos .csproj en este directorio"
  • "Muéstrame el contenido de este archivo"
  • "¿Cuál es el directorio base actual para las operaciones con archivos?"
  • "Ayúdenme a pensar en el diseño del sistema de autenticación"
  • "Documentar mi razonamiento sobre esta decisión arquitectónica"
  • Analizar la cobertura de pruebas de MyService.cs
  • "Muéstrame las líneas descubiertas en el módulo de autenticación"
  • "¿Cuál es el porcentaje general de cobertura de la prueba?"
  • "¿Qué archivos tienen la cobertura de prueba más baja?"

📚 Documentación

Características

  • 📁 Listado de proyectos y archivos : enumera todos los proyectos y archivos fuente de tu solución
  • 🔍 Búsqueda de código : busca en tu base de código patrones o textos específicos
  • 🧠 Búsqueda semántica : busque código según el significado, no solo coincidencias exactas de texto
  • 📖 Acceso al contenido de archivos : lee archivos fuente con controles de seguridad y límites de tamaño
  • 🛡️ Seguridad : protecciones integradas para archivos confidenciales y acceso a directorios
  • 🎯 Gestión de patrones : ignora patrones flexibles para controlar el acceso a archivos
  • 📊 Análisis de cobertura : analice y analice los datos de cobertura de las pruebas
    • Informes de cobertura : Compatibilidad con formatos Coverlet JSON, LCOV y Cobertura XML
    • Cobertura de línea : rastrea qué líneas están cubiertas por las pruebas
    • Cobertura de rama : Supervisar la cobertura de rama a nivel de método
    • 💡 Recomendaciones : Obtenga sugerencias prácticas para mejorar la cobertura
  • 💭 Pensamiento Estructurado : Documentar y validar el razonamiento sobre operaciones complejas
    • Razonamiento optimizado por IA : basado en la investigación de Anthropic sobre la mejora de la resolución de problemas de LLM
    • 📋 Planificación de tareas : Divida los problemas complejos en pasos manejables
    • Cumplimiento de políticas : verificar las soluciones según las pautas del proyecto
    • 🔄 Análisis de resultados de herramientas : procese los resultados de otras herramientas antes de tomar las siguientes acciones
    • 📝 Documentación de decisiones : Mantener registros de auditoría de las decisiones arquitectónicas

Construyendo desde la fuente

  1. Clonar el repositorio:
git clone https://github.com/willibrandon/NetContextServer.git cd NetContextServer
  1. Construya la solución:
dotnet build
  1. Ejecutar las pruebas (opcional):
dotnet test

Comandos de ejecución

Utilice el cliente para interactuar con su base de código:

dotnet run --project src/NetContextClient/NetContextClient.csproj -- <command> [options]

Configuración del entorno

Para la funcionalidad de búsqueda semántica, debe configurar las siguientes variables de entorno:

  • AZURE_OPENAI_ENDPOINT : la URL de su punto de conexión de Azure OpenAI
  • AZURE_OPENAI_API_KEY : Su clave de API de Azure OpenAI

Uso

Comandos básicos

  1. Establecer directorio base :
dotnet run --project src/NetContextClient/NetContextClient.csproj -- set-base-dir --directory "D:\YourProject"
  1. Obtener directorio base :
dotnet run --project src/NetContextClient/NetContextClient.csproj -- get-base-dir
  1. Obtener información de la versión :
dotnet run --project src/NetContextClient/NetContextClient.csproj -- version
  1. Lista de proyectos :
dotnet run --project src/NetContextClient/NetContextClient.csproj -- list-projects-in-dir --directory "D:\YourProject\src"
  1. Lista de archivos fuente :
dotnet run --project src/NetContextClient/NetContextClient.csproj -- list-source-files --project-dir "D:\YourProject\src\YourProject"
  1. Analizar paquetes :
# Set your base directory first dotnet run --project src/NetContextClient/NetContextClient.csproj -- set-base-dir --directory "path/to/your/project" # Run the package analysis dotnet run --project src/NetContextClient/NetContextClient.csproj -- analyze-packages

Ejemplo de salida:

Project: MyProject.csproj Found 2 package(s): - ✅ Newtonsoft.Json (13.0.1) Used in 5 location(s) Dependencies: └─ Newtonsoft.Json └─ System.* └─ System.ComponentModel - 🔄 Microsoft.Extensions.DependencyInjection (5.0.2 → 6.0.1) Update available: 6.0.1 Dependencies: └─ Microsoft.Extensions.DependencyInjection └─ Microsoft.* └─ Microsoft.Extensions.DependencyInjection.Abstractions
  1. Analizar la cobertura de la prueba :
# Set your base directory first dotnet run --project src/NetContextClient/NetContextClient.csproj -- set-base-dir --directory "path/to/your/project" # Analyze coverage from a Coverlet JSON report dotnet run --project src/NetContextClient/NetContextClient.csproj -- coverage-analysis --report-path "TestResults/coverage.json" # Get a coverage summary dotnet run --project src/NetContextClient/NetContextClient.csproj -- coverage-summary --report-path "TestResults/coverage.json"

Ejemplo de resultado del análisis de cobertura:

[{ "filePath": "src/MyProject/Services/UserService.cs", "coveragePercentage": 85.3, "uncoveredLines": [42, 43, 88], "branchCoverage": { "ValidateUser()": 75.0, "GetUserById()": 100.0 }, "recommendation": "Consider adding tests for the user validation error paths" } ]

Comandos de búsqueda

  1. Búsqueda de texto :
dotnet run --project src/NetContextClient/NetContextClient.csproj -- search-code --text "authentication"
  1. Búsqueda semántica :
# Search with default number of results (5) dotnet run --project src/NetContextClient/NetContextClient.csproj -- semantic-search --query "handle user authentication" # Search with custom number of results dotnet run --project src/NetContextClient/NetContextClient.csproj -- semantic-search --query "database connection string" --top 10

La función de búsqueda semántica:

  • Utiliza incrustaciones para encontrar código según el significado
  • Devuelve fragmentos de código clasificados por relevancia
  • Muestra números de línea y puntuaciones de similitud
  • Indexa automáticamente su código en la primera búsqueda

Gestión de patrones

  1. Agregar patrones ignorados :
dotnet run --project src/NetContextClient/NetContextClient.csproj -- add-ignore-patterns --patterns "*.txt" "*.log"
  1. Ver patrones actuales :
dotnet run --project src/NetContextClient/NetContextClient.csproj -- get-ignore-patterns
  1. Eliminar patrones específicos :
dotnet run --project src/NetContextClient/NetContextClient.csproj -- remove-ignore-patterns --patterns "*.txt"
  1. Patrones de usuario claros :
dotnet run --project src/NetContextClient/NetContextClient.csproj -- clear-ignore-patterns
  1. Ver ubicación del archivo de estado :
dotnet run --project src/NetContextClient/NetContextClient.csproj -- get-state-file-location

Patrones de ignorar predeterminados

Los siguientes patrones se ignoran de forma predeterminada para proteger la información confidencial:

  • *.env - Archivos de entorno
  • appsettings.*.json - Configuración de la aplicación
  • *.pfx - Archivos de certificado
  • *.key - Archivos de claves
  • *.pem - Archivos PEM
  • *password* - Archivos que contienen "contraseña" en el nombre
  • *secret* - Archivos que contienen "secreto" en el nombre

Características de seguridad

  1. Seguridad de ruta : solo se puede acceder a los archivos dentro del directorio base especificado
  2. Validación de patrones : Ignorar los patrones validados para una sintaxis adecuada
  3. Límites de tamaño : los contenidos de archivos grandes se truncan para evitar problemas de memoria
  4. Protección de archivos confidenciales : los patrones integrados protegen los archivos confidenciales comunes

Ejemplo de flujo de trabajo

  1. Establezca el directorio base para su proyecto:
dotnet run --project src/NetContextClient/NetContextClient.csproj -- set-base-dir --directory "D:\Projects\MyApp"
  1. Compruebe la versión y configuración del servidor:
dotnet run --project src/NetContextClient/NetContextClient.csproj -- version
  1. Configurar patrones de ignoración personalizados:
dotnet run --project src/NetContextClient/NetContextClient.csproj -- add-ignore-patterns --patterns "*.generated.cs" "*.designer.cs"
  1. Listado de todos los proyectos:
dotnet run --project src/NetContextClient/NetContextClient.csproj -- list-projects-in-dir --directory "D:\Projects\MyApp\src"
  1. Analice las dependencias de los paquetes de su proyecto:
dotnet run --project src/NetContextClient/NetContextClient.csproj -- analyze-packages
  1. Buscar código relacionado con la autenticación:
dotnet run --project src/NetContextClient/NetContextClient.csproj -- semantic-search --query "user authentication and authorization logic"

Integración con herramientas de codificación de IA

NetContextServer implementa el Protocolo de contexto de modelo (MCP) , lo que permite una integración perfecta con asistentes de codificación de IA que admiten este protocolo, como:

  • VS Code : proporciona a su asistente de IA el contexto completo de su base de código para una generación de código y asistencia más precisas.
  • Otras herramientas compatibles con MCP : cualquier herramienta que implemente el Protocolo de contexto de modelo puede conectarse a NetContextServer

Para usar con VS Code:

  1. Configurar VS Code para utilizar NetContextServer como su proveedor MCP
  2. Disfrute de una asistencia de código mejorada con un contexto de base de código completo

Para probar y depurar las interacciones de MCP, puede usar el Inspector de Protocolo de Contexto de Modelo , una herramienta visual de pruebas que le ayuda a inspeccionar y validar las comunicaciones entre clientes y servidores de MCP. Consulte la documentación del inspector para obtener más información sobre sus características y capacidades.

NetContextServer permite que los colaboradores de IA soliciten información específica sobre su base de código, lo que hace que las sugerencias de la IA sean más relevantes y precisas para la estructura de su proyecto específico y sus patrones de codificación.

Manejo de errores

El servidor proporciona mensajes de error claros para escenarios comunes:

  • Directorio no encontrado
  • Acceso denegado (fuera del directorio base)
  • Patrones no válidos
  • Se excedieron los límites de tamaño de archivo
  • Tipos de archivos restringidos
  • Variables de entorno faltantes para la búsqueda semántica

Contribuyendo

  1. Bifurcar el repositorio
  2. Crear una rama de características
  3. Confirme sus cambios
  4. Empujar hacia la rama
  5. Crear una solicitud de extracción

Licencia

Este proyecto está licenciado bajo la licencia MIT: consulte el archivo de LICENCIA para obtener más detalles.

-
security - not tested
A
license - permissive license
-
quality - not tested

NetContextServer permite a los asistentes de programación de IA, como Cursor AI, comprender a fondo su código .NET mediante el Protocolo de Contexto de Modelo (MCP). Esto se traduce en sugerencias de código más precisas, mejores respuestas a sus preguntas y una experiencia de programación más productiva.

  1. ✨ Key Features
    1. 🚀 Quick Start
      1. 🔌 Integration with VS Code
        1. 📚 Documentation
          1. Features
            1. Building from Source
              1. Running Commands
                1. Environment Setup
              2. Usage
                1. Basic Commands
                2. Search Commands
                3. Pattern Management
                4. Default Ignore Patterns
              3. Security Features
                1. Example Workflow
                  1. Integration with AI Coding Tools
                    1. Error Handling
                      1. Contributing
                        1. License
                          ID: 3lmc69lqm7