code-auditor-mcp 3.4.18 → 3.5.0

package/dist/languages/go/analyzer-src/solid.go

@@ -0,0 +1,395 @@
+package analyzer
+
+import (
+	"go/ast"
+	"strings"
+)
+
+// SOLIDAnalyzer analyzes Go code for SOLID principle violations
+type SOLIDAnalyzer struct {
+	parser    *Parser
+	functions []Function
+	structs   []Struct
+	interfaces []Interface
+}
+
+// NewSOLIDAnalyzer creates a new SOLID analyzer
+func NewSOLIDAnalyzer(parser *Parser) *SOLIDAnalyzer {
+	return &SOLIDAnalyzer{
+		parser:     parser,
+		functions:  parser.ExtractFunctions(),
+		structs:    parser.ExtractStructs(),
+		interfaces: parser.ExtractInterfaces(),
+	}
+}
+
+// Analyze performs SOLID principle analysis
+func (s *SOLIDAnalyzer) Analyze() []Violation {
+	var violations []Violation
+
+	// Analyze Single Responsibility Principle
+	violations = append(violations, s.analyzeSRP()...)
+
+	// Analyze Open/Closed Principle
+	violations = append(violations, s.analyzeOCP()...)
+
+	// Analyze Liskov Substitution Principle
+	violations = append(violations, s.analyzeLSP()...)
+
+	// Analyze Interface Segregation Principle
+	violations = append(violations, s.analyzeISP()...)
+
+	// Analyze Dependency Inversion Principle
+	violations = append(violations, s.analyzeDIP()...)
+
+	return violations
+}
+
+// analyzeSRP analyzes Single Responsibility Principle violations
+func (s *SOLIDAnalyzer) analyzeSRP() []Violation {
+	var violations []Violation
+
+	// Check functions for too many responsibilities
+	for _, function := range s.functions {
+		responsibilities := s.countFunctionResponsibilities(function)
+		if responsibilities > 3 {
+			violations = append(violations, Violation{
+				File:     function.File,
+				Line:     function.StartLine,
+				Severity: "warning",
+				Message:  "Function has many parameters, returns, or high complexity",
+				Details: map[string]interface{}{
+					"function":        function.Name,
+					"responsibilities": responsibilities,
+					"principle":       "SRP",
+				},
+				Suggestion: "Consider breaking this function into smaller, more focused functions",
+				Analyzer:   "solid",
+				Category:   "single-responsibility",
+			})
+		}
+	}
+
+	// Check structs for too many responsibilities
+	for _, structInfo := range s.structs {
+		responsibilities := s.countStructResponsibilities(structInfo)
+		if responsibilities > 5 {
+			violations = append(violations, Violation{
+				File:     structInfo.File,
+				Line:     structInfo.StartLine,
+				Severity: "warning",
+				Message:  "Struct has many fields",
+				Details: map[string]interface{}{
+					"struct":          structInfo.Name,
+					"responsibilities": responsibilities,
+					"principle":       "SRP",
+					"fieldCount":      len(structInfo.Fields),
+				},
+				Suggestion: "Consider splitting this struct into smaller, more cohesive structs",
+				Analyzer:   "solid",
+				Category:   "single-responsibility",
+			})
+		}
+	}
+
+	return violations
+}
+
+// analyzeOCP analyzes Open/Closed Principle violations
+func (s *SOLIDAnalyzer) analyzeOCP() []Violation {
+	var violations []Violation
+
+	// Check for large switch/case statements that could benefit from polymorphism
+	for filePath, file := range s.parser.files {
+		ast.Inspect(file, func(n ast.Node) bool {
+			switch node := n.(type) {
+			case *ast.SwitchStmt:
+				caseCount := s.countSwitchCases(node)
+				if caseCount > 5 {
+					pos := s.parser.fileSet.Position(node.Pos())
+					violations = append(violations, Violation{
+						File:     filePath,
+						Line:     pos.Line,
+						Severity: "suggestion",
+						Message:  "Large switch statement detected - consider using polymorphism",
+						Details: map[string]interface{}{
+							"caseCount": caseCount,
+							"principle": "OCP",
+						},
+						Suggestion: "Consider using interfaces and polymorphism instead of large switch statements",
+						Analyzer:   "solid",
+						Category:   "open-closed",
+					})
+				}
+			case *ast.TypeSwitchStmt:
+				caseCount := s.countTypeSwitchCases(node)
+				if caseCount > 5 {
+					pos := s.parser.fileSet.Position(node.Pos())
+					violations = append(violations, Violation{
+						File:     filePath,
+						Line:     pos.Line,
+						Severity: "suggestion",
+						Message:  "Large type switch detected - consider using interfaces",
+						Details: map[string]interface{}{
+							"caseCount": caseCount,
+							"principle": "OCP",
+						},
+						Suggestion: "Consider using interfaces with method dispatch instead of type switches",
+						Analyzer:   "solid",
+						Category:   "open-closed",
+					})
+				}
+			}
+			return true
+		})
+	}
+
+	return violations
+}
+
+// analyzeLSP analyzes Liskov Substitution Principle violations.
+//
+// A method that calls panic() breaks substitutability: a caller holding the
+// interface (or embedding) has no way to recover from a panic the way it can
+// from an error return. The honest, directly-observable signal is "the method
+// body contains a panic() call" — we walk the AST for exactly that. We do not
+// (yet) resolve whether the method overrides a parent, so the message claims
+// only the panic, never the override.
+func (s *SOLIDAnalyzer) analyzeLSP() []Violation {
+	var violations []Violation
+
+	for filePath, file := range s.parser.files {
+		ast.Inspect(file, func(n ast.Node) bool {
+			funcDecl, ok := n.(*ast.FuncDecl)
+			if !ok {
+				return true
+			}
+			// LSP governs methods only — a free function has no supertype to
+			// violate. Test functions are test entry points, not production API.
+			if funcDecl.Recv == nil || funcDecl.Body == nil || isTestFunction(funcDecl.Name.Name) {
+				return true
+			}
+			if !methodCallsPanic(funcDecl) {
+				return true
+			}
+			pos := s.parser.fileSet.Position(funcDecl.Pos())
+			violations = append(violations, Violation{
+				File:     filePath,
+				Line:     pos.Line,
+				Severity: "warning",
+				Message:  "Method calls panic()",
+				Details: map[string]interface{}{
+					"function":  funcDecl.Name.Name,
+					"principle": "LSP",
+				},
+				Suggestion: "Return an error instead of panicking so the method stays substitutable",
+				Analyzer:   "solid",
+				Category:   "liskov-substitution",
+			})
+			return true
+		})
+	}
+
+	return violations
+}
+
+// analyzeISP analyzes Interface Segregation Principle violations
+func (s *SOLIDAnalyzer) analyzeISP() []Violation {
+	var violations []Violation
+
+	// Check for fat interfaces
+	for _, interfaceInfo := range s.interfaces {
+		if len(interfaceInfo.Methods) > 5 {
+			violations = append(violations, Violation{
+				File:     interfaceInfo.File,
+				Line:     interfaceInfo.StartLine,
+				Severity: "warning",
+				Message:  "Interface has many methods",
+				Details: map[string]interface{}{
+					"interface":   interfaceInfo.Name,
+					"methodCount": len(interfaceInfo.Methods),
+					"principle":   "ISP",
+				},
+				Suggestion: "Consider splitting this interface into smaller, more focused interfaces",
+				Analyzer:   "solid",
+				Category:   "interface-segregation",
+			})
+		}
+	}
+
+	return violations
+}
+
+// analyzeDIP analyzes Dependency Inversion Principle violations
+func (s *SOLIDAnalyzer) analyzeDIP() []Violation {
+	var violations []Violation
+
+	// Check for direct dependencies on concrete types instead of interfaces
+	for _, structInfo := range s.structs {
+		concreteDeps := s.countConcreteDependencies(structInfo)
+		if concreteDeps > 3 {
+			violations = append(violations, Violation{
+				File:     structInfo.File,
+				Line:     structInfo.StartLine,
+				Severity: "suggestion",
+				Message:  "Struct has many concrete-typed fields",
+				Details: map[string]interface{}{
+					"struct":             structInfo.Name,
+					"concreteDependencies": concreteDeps,
+					"principle":          "DIP",
+				},
+				Suggestion: "Consider depending on interfaces instead of concrete types",
+				Analyzer:   "solid",
+				Category:   "dependency-inversion",
+			})
+		}
+	}
+
+	return violations
+}
+
+// Helper methods for analysis
+
+func (s *SOLIDAnalyzer) countFunctionResponsibilities(function Function) int {
+	responsibilities := 1
+
+	// Count different types of operations
+	if function.Complexity > 10 {
+		responsibilities++
+	}
+
+	// Check for multiple return types (excluding error)
+	returns := strings.Split(function.ReturnType, ",")
+	if len(returns) > 2 {
+		responsibilities++
+	}
+
+	// Check parameter count
+	if len(function.Parameters) > 5 {
+		responsibilities++
+	}
+
+	return responsibilities
+}
+
+func (s *SOLIDAnalyzer) countStructResponsibilities(structInfo Struct) int {
+	responsibilities := 1
+
+	// Base on field count
+	fieldCount := len(structInfo.Fields)
+	if fieldCount > 10 {
+		responsibilities += 2
+	} else if fieldCount > 5 {
+		responsibilities++
+	}
+
+	// Check for mixed data types indicating different responsibilities
+	hasStrings := false
+	hasNumbers := false
+	hasCollections := false
+
+	for _, field := range structInfo.Fields {
+		switch {
+		case strings.Contains(field.Type, "string"):
+			hasStrings = true
+		case strings.Contains(field.Type, "int") || strings.Contains(field.Type, "float"):
+			hasNumbers = true
+		case strings.Contains(field.Type, "[]") || strings.Contains(field.Type, "map"):
+			hasCollections = true
+		}
+	}
+
+	mixedTypes := 0
+	if hasStrings {
+		mixedTypes++
+	}
+	if hasNumbers {
+		mixedTypes++
+	}
+	if hasCollections {
+		mixedTypes++
+	}
+
+	if mixedTypes > 2 {
+		responsibilities++
+	}
+
+	return responsibilities
+}
+
+func (s *SOLIDAnalyzer) countSwitchCases(switchStmt *ast.SwitchStmt) int {
+	caseCount := 0
+	if switchStmt.Body != nil {
+		for _, stmt := range switchStmt.Body.List {
+			if _, ok := stmt.(*ast.CaseClause); ok {
+				caseCount++
+			}
+		}
+	}
+	return caseCount
+}
+
+func (s *SOLIDAnalyzer) countTypeSwitchCases(typeSwitchStmt *ast.TypeSwitchStmt) int {
+	caseCount := 0
+	if typeSwitchStmt.Body != nil {
+		for _, stmt := range typeSwitchStmt.Body.List {
+			if _, ok := stmt.(*ast.CaseClause); ok {
+				caseCount++
+			}
+		}
+	}
+	return caseCount
+}
+
+func (s *SOLIDAnalyzer) countConcreteDependencies(structInfo Struct) int {
+	concreteDeps := 0
+
+	for _, field := range structInfo.Fields {
+		// Check if field type looks like a concrete type (not interface)
+		if !strings.Contains(field.Type, "interface") &&
+			!strings.HasPrefix(field.Type, "*") && // Pointers might be interfaces
+			!s.isBuiltinType(field.Type) {
+			concreteDeps++
+		}
+	}
+
+	return concreteDeps
+}
+
+func (s *SOLIDAnalyzer) isBuiltinType(typeName string) bool {
+	builtinTypes := []string{
+		"bool", "string", "int", "int8", "int16", "int32", "int64",
+		"uint", "uint8", "uint16", "uint32", "uint64", "uintptr",
+		"byte", "rune", "float32", "float64", "complex64", "complex128",
+	}
+
+	for _, builtin := range builtinTypes {
+		if typeName == builtin {
+			return true
+		}
+	}
+
+	return false
+}
+
+// methodCallsPanic reports whether a function body contains a direct panic()
+// call. It matches the exact call shape — a call expression whose function is
+// the identifier `panic` — so a helper that merely has "panic" in its name or
+// a doc comment does not trip it (the near-miss the old name-substring check
+// false-positived on).
+func methodCallsPanic(funcDecl *ast.FuncDecl) bool {
+	callsPanic := false
+	ast.Inspect(funcDecl.Body, func(n ast.Node) bool {
+		call, ok := n.(*ast.CallExpr)
+		if !ok {
+			return true
+		}
+		ident, ok := call.Fun.(*ast.Ident)
+		if ok && ident.Name == "panic" {
+			callsPanic = true
+			return false
+		}
+		return true
+	})
+	return callsPanic
+}

package/dist/languages/go/analyzer-src/testconventions.go

@@ -0,0 +1,25 @@
+package analyzer
+
+import "strings"
+
+// Go test conventions — mirrors languages/testConventions.ts.
+//
+// `go test` compiles only `*_test.go` files; within them the `testing` package
+// recognizes Test/Benchmark/Example/Fuzz-prefixed functions as entry points.
+// Test code is not production API: it is exempt from analysis and indexing the
+// same way the TypeScript pipeline exempts `.test.`/`.spec.` files. One
+// per-language convention, not a hardcoded TS/JS list.
+
+// isTestFile reports whether filePath is a Go test file (`*_test.go`).
+func isTestFile(filePath string) bool {
+	return strings.HasSuffix(filePath, "_test.go")
+}
+
+// isTestFunction reports whether name is a Go test function
+// (Test*/Benchmark*/Example*/Fuzz*).
+func isTestFunction(name string) bool {
+	return strings.HasPrefix(name, "Test") ||
+		strings.HasPrefix(name, "Benchmark") ||
+		strings.HasPrefix(name, "Example") ||
+		strings.HasPrefix(name, "Fuzz")
+}

package/dist/languages/go/analyzer-src/types.go

@@ -0,0 +1,148 @@
+package analyzer
+
+// AnalysisOptions represents options for the analysis
+type AnalysisOptions struct {
+	Analyzers   []string `json:"analyzers"`
+	MinSeverity string   `json:"minSeverity"`
+	Timeout     int      `json:"timeout"`
+	Language    string   `json:"language"`
+	Verbose     bool     `json:"verbose"`
+}
+
+// AnalysisResult represents the result of code analysis
+type AnalysisResult struct {
+	Violations   []Violation  `json:"violations"`
+	IndexEntries []IndexEntry `json:"indexEntries"`
+	Metrics      Metrics      `json:"metrics"`
+	Errors       []Error      `json:"errors"`
+}
+
+// Violation represents a code quality violation
+type Violation struct {
+	File        string                 `json:"file"`
+	Line        int                    `json:"line"`
+	Column      int                    `json:"column"`
+	Severity    string                 `json:"severity"`
+	Message     string                 `json:"message"`
+	Details     map[string]interface{} `json:"details,omitempty"`
+	Snippet     string                 `json:"snippet,omitempty"`
+	Suggestion  string                 `json:"suggestion,omitempty"`
+	Analyzer    string                 `json:"analyzer"`
+	Category    string                 `json:"category"`
+}
+
+// IndexEntry represents an entity in the code index
+type IndexEntry struct {
+	ID         string                 `json:"id"`
+	Name       string                 `json:"name"`
+	Type       string                 `json:"type"`
+	Language   string                 `json:"language"`
+	File       string                 `json:"file"`
+	Signature  string                 `json:"signature"`
+	Parameters []Parameter            `json:"parameters"`
+	Purpose    string                 `json:"purpose"`
+	Context    string                 `json:"context"`
+	StartLine  int                    `json:"startLine"`
+	EndLine    int                    `json:"endLine"`
+	Metadata   map[string]interface{} `json:"metadata,omitempty"`
+}
+
+// Parameter represents a function parameter
+type Parameter struct {
+	Name     string `json:"name"`
+	Type     string `json:"type"`
+	Optional bool   `json:"optional"`
+	Language string `json:"language"`
+}
+
+// Metrics represents analysis metrics
+type Metrics struct {
+	FilesAnalyzed int64 `json:"filesAnalyzed"`
+	ExecutionTime int64 `json:"executionTime"`
+}
+
+// Error represents an analysis error
+type Error struct {
+	Message string `json:"message"`
+	Type    string `json:"type"`
+	File    string `json:"file,omitempty"`
+	Line    int    `json:"line,omitempty"`
+}
+
+// EntityInfo represents information about a Go entity
+type EntityInfo struct {
+	Name       string
+	Type       string
+	File       string
+	StartLine  int
+	EndLine    int
+	Signature  string
+	Parameters []Parameter
+	ReturnType string
+	Purpose    string
+	Context    string
+	Receiver   string // For methods
+	Package    string
+}
+
+// Function represents a Go function
+type Function struct {
+	EntityInfo
+	IsMethod     bool
+	IsExported   bool
+	Complexity   int
+	Dependencies []string
+}
+
+// Struct represents a Go struct
+type Struct struct {
+	EntityInfo
+	Fields     []Field
+	Methods    []string
+	IsExported bool
+}
+
+// Interface represents a Go interface
+type Interface struct {
+	EntityInfo
+	Methods    []Method
+	IsExported bool
+}
+
+// Field represents a struct field
+type Field struct {
+	Name       string
+	Type       string
+	Tag        string
+	IsExported bool
+}
+
+// Method represents an interface method
+type Method struct {
+	Name       string
+	Signature  string
+	Parameters []Parameter
+	ReturnType string
+}
+
+// SOLIDViolation represents SOLID principle violations specific to Go
+type SOLIDViolation struct {
+	Principle   string // SRP, OCP, LSP, ISP, DIP
+	Entity      string
+	Description string
+	Suggestion  string
+	Severity    string
+	Examples    []string
+}
+
+// Package represents a Go package
+type Package struct {
+	Name      string
+	Path      string
+	Files     []string
+	Imports   []string
+	Exports   []string
+	Functions []Function
+	Structs   []Struct
+	Interfaces []Interface
+}

package/dist/languages/go/go.mod

@@ -0,0 +1,7 @@
+module code-auditor-go
+
+go 1.19
+
+replace code-auditor-go/analyzer => ./analyzer-src
+
+require code-auditor-go/analyzer v0.0.0-00010101000000-000000000000