A Golang implementation of the Meta-Configuration Protocol (MCP) for language server integration and code governance enforcement through AST-based deep analysis.

This project implements a governance system for Go code that leverages deep Abstract Syntax Tree (AST) analysis to enforce organizational coding standards. It provides both a JSON-RPC server exposing governance rules and client libraries for validation.

graph TD
    A[Go Source Code] -->|Submitted for validation| B[MCP Server]
    B -->|AST Analysis| C[Analyzer Engine]
    C -->|Detects Issues| D[Validation Results]
    D -->|Returns to| E[Developer/CI]
    F[Governance Rules] -->|Loaded by| B

• Deep AST-based Code Analysis: Beyond simple pattern matching, understands code structure
• Multiple Rule Categories: Enforces standards for error handling, API design, concurrency, security, and organization standards
• Precise Issue Reporting: Provides exact file location (line, column) for detected issues
• Flexible Validation: Supports both CLI-based and server-based validation workflows
• Modular Architecture: Easily extend with new rule categories

• MCP Server: JSON-RPC server that exposes governance rules
• Client Library: Go client for communicating with the MCP server
• AST Analyzer: Deep code inspection based on Go's AST package
• CLI Tools: Command-line interface for validation and testing
• Test Suite: Comprehensive test cases for each rule category

1. Error Handling: Enforces proper error checking and handling
2. API Design: Validates API contracts, context usage, and parameter patterns
3. Concurrency: Detects race conditions and ensures proper synchronization
4. Security: Identifies weak cryptography, SQL injection risks, and credentials handling
5. Organizational Standards: Enforces coding style and architectural patterns

# Standard pattern-based validation
go run cmd/mcplsp/main.go validate path/to/file.go error_handling,api_design

# Deep AST-based analysis
go run cmd/mcplsp/main.go -deep validate path/to/file.go error_handling,api_design

go run cmd/ast-analyzer/main.go analyze --file path/to/file.go --rules error_handling

# Test all rule categories
./scripts/test-governance.sh

# Compare standard vs. deep validation
./scripts/compare-validation.sh

go-mcp-lsp/
├── cmd/
│   ├── mcplsp/       # CLI tool for MCP validation
│   └── ast-analyzer/ # CLI for AST-based code analysis
├── pkg/
│   ├── analyzer/     # Deep AST analysis engine
│   │   └── ast/      # AST-based code inspection
│   └── mcpclient/    # MCP client for JSON-RPC communication
├── server/
│   └── mcpserver/    # MCP server exposing governance rules
│       └── rules/    # Rule definitions by category
├── testdata/        # Test files for all rule categories
└── scripts/         # Test and validation scripts

• Go 1.19 or higher
• Understanding of Go's AST package for rule development

# Clone the repository
git clone https://github.com/yourorg/go-mcp-lsp
cd go-mcp-lsp

# Build the CLI tools
go build -o bin/mcplsp cmd/mcplsp/main.go
go build -o bin/ast-analyzer cmd/ast-analyzer/main.go

# Run tests
go test ./...

1. Define the rule in the appropriate category under server/mcpserver/rules/
2. Implement AST-based detection in pkg/analyzer/ast/analyzer.go
3. Add test cases in testdata/
4. Update the CLI to expose the new rule category

This project is licensed under the MIT License - see the LICENSE file for details.

Contributions are welcome! Please feel free to submit a Pull Request.

1. Fork the repository
2. Create your feature branch (git checkout -b feature/amazing-feature)
3. Commit your changes (git commit -m 'Add some amazing feature')
4. Push to the branch (git push origin feature/amazing-feature)
5. Open a Pull Request