code-auditor-mcp 5.0.1 → 5.2.0

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

@@ -1,311 +0,0 @@
-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 function/struct size (was the single-responsibility proxy)
-	violations = append(violations, s.analyzeFunctionSize()...)
-	violations = append(violations, s.analyzeStructSize()...)
-
-	// Analyze switch/type-switch size
-	violations = append(violations, s.analyzeSwitchSize()...)
-
-	// Analyze Liskov Substitution Principle
-	violations = append(violations, s.analyzeLSP()...)
-
-	// Analyze Interface Segregation Principle
-	violations = append(violations, s.analyzeISP()...)
-
-	return violations
-}
-
-// analyzeFunctionSize analyzes function *size* (`function-size`).
-//
-// Spec-49: the old `single-responsibility` category claimed the Single
-// Responsibility Principle from a composite of three size signals — complexity,
-// return count, and parameter count. "Responsibility" is semantic; the
-// syntax-only go/parser has no cohesion analysis, so the SRP reading is blocked
-// (see the ledger). What remains is the size signal under an honest name: a
-// function with high complexity AND multiple returns AND many parameters is
-// large in every dimension.
-func (s *SOLIDAnalyzer) analyzeFunctionSize() []Violation {
-	var violations []Violation
-
-	for _, function := range s.functions {
-		returns := strings.Split(function.ReturnType, ",")
-		// 2026-09-12 recalibration: complexity ceiling aligned to the 20-cyclomatic
-		// threshold, params aligned to the TS `parameter-count` default of 6. The
-		// rule is AND-combined (complexity + returns + params) so it stays conservative.
-		complex := function.Complexity > 20
-		multiReturn := len(returns) > 2
-		manyParams := len(function.Parameters) > 6
-		if complex && multiReturn && manyParams {
-			violations = append(violations, Violation{
-				File:     function.File,
-				Line:     function.StartLine,
-				Severity: "high",
-				Message:  "Function has many parameters, multiple returns, and high complexity",
-				Details: map[string]interface{}{
-					"function":   function.Name,
-					"complexity": function.Complexity,
-					"parameters": len(function.Parameters),
-					"returns":    len(returns),
-				},
-				Suggestion: "Consider breaking this function into smaller, more focused functions",
-				Analyzer:   "solid",
-				Rule:       "function-size",
-			})
-		}
-	}
-
-	return violations
-}
-
-// analyzeStructSize analyzes struct *size* (`struct-size`).
-//
-// Spec-49: the old `single-responsibility` struct variant claimed SRP from a
-// composite of field count and a `mixedTypes` substring heuristic. Two defects:
-// the composite score could never exceed 4 (the fire threshold was 5), so the
-// rule was dead code; and `strings.Contains(field.Type, "int")` false-matched
-// `*Point` (a pointer whose type name merely contains "int"). The SRP reading is
-// blocked; the honest size reading is a direct field count.
-func (s *SOLIDAnalyzer) analyzeStructSize() []Violation {
-	var violations []Violation
-
-	for _, structInfo := range s.structs {
-		// 2026-09-12 recalibration: 10 flags ordinary config/model structs; 15 is a god-struct.
-		if len(structInfo.Fields) > 15 {
-			violations = append(violations, Violation{
-				File:     structInfo.File,
-				Line:     structInfo.StartLine,
-				Severity: "high",
-				Message:  "Struct has many fields",
-				Details: map[string]interface{}{
-					"struct":     structInfo.Name,
-					"fieldCount": len(structInfo.Fields),
-				},
-				Suggestion: "Consider splitting this struct into smaller, more focused structs",
-				Analyzer:   "solid",
-				Rule:       "struct-size",
-			})
-		}
-	}
-
-	return violations
-}
-
-// analyzeSwitchSize analyzes switch/type-switch *size* (`switch-size`).
-//
-// Spec-49: the old `open-closed` category claimed to detect the Open/Closed
-// Principle from a raw case count. Case count is a size reading, not an OCP
-// reading — whether a switch is "closed to extension" depends on whether it
-// dispatches over a stable enum vs an extensible type, which the syntax-only
-// go/parser cannot resolve. The honest OCP computation is blocked (needs type
-// resolution); what remains is the size signal under an honest name.
-func (s *SOLIDAnalyzer) analyzeSwitchSize() []Violation {
-	var violations []Violation
-
-	// Check for large switch/type-switch statements (a size reading only).
-	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)
-				// 2026-09-12 recalibration: 5 flags idiomatic dispatch (HTTP status /
-				// command maps); 8 suggests table-driven lookup.
-				if caseCount > 8 {
-					pos := s.parser.fileSet.Position(node.Pos())
-					violations = append(violations, Violation{
-						File:     filePath,
-						Line:     pos.Line,
-						Severity: "high",
-						Message:  "Switch statement has many case clauses",
-						Details: map[string]interface{}{
-							"caseCount": caseCount,
-							"kind":      "switch",
-						},
-						Suggestion: "Consider consolidating related cases or a table-driven lookup if the switch grows unwieldy",
-						Analyzer:   "solid",
-						Rule:       "switch-size",
-					})
-				}
-			case *ast.TypeSwitchStmt:
-				caseCount := s.countTypeSwitchCases(node)
-				if caseCount > 8 {
-					pos := s.parser.fileSet.Position(node.Pos())
-					violations = append(violations, Violation{
-						File:     filePath,
-						Line:     pos.Line,
-						Severity: "high",
-						Message:  "Type switch has many case clauses",
-						Details: map[string]interface{}{
-							"caseCount": caseCount,
-							"kind":      "type-switch",
-						},
-						Suggestion: "Consider consolidating related cases; a type switch over a sealed set is maintainable, but an open set grows unwieldy",
-						Analyzer:   "solid",
-						Rule:       "switch-size",
-					})
-				}
-			}
-			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: "severe",
-				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",
-				Rule:       "liskov-substitution",
-			})
-			return true
-		})
-	}
-
-	return violations
-}
-
-// analyzeISP analyzes interface *size* (`interface-size`).
-//
-// Spec-49: the old `interface-segregation` category claimed to detect the
-// Interface Segregation Principle ("clients forced to depend on methods they do
-// not use") from a raw method count. Method count is a size reading, not a
-// segregation reading. The honest ISP computation (client-usage sets — which
-// callers use which disjoint subsets of an interface's methods) needs type
-// resolution / a call graph, which the syntax-only go/parser has not, so that
-// reading is blocked (see the ledger). What remains is the size signal under an
-// honest name.
-func (s *SOLIDAnalyzer) analyzeISP() []Violation {
-	var violations []Violation
-
-	for _, interfaceInfo := range s.interfaces {
-		// 2026-09-12 recalibration: 5 flags idiomatic Reader/Writer-style interfaces;
-		// 10 is where segregation is warranted.
-		if len(interfaceInfo.Methods) > 10 {
-			violations = append(violations, Violation{
-				File:     interfaceInfo.File,
-				Line:     interfaceInfo.StartLine,
-				Severity: "high",
-				Message:  "Interface has many methods",
-				Details: map[string]interface{}{
-					"interface":   interfaceInfo.Name,
-					"methodCount": len(interfaceInfo.Methods),
-					"principle":   "ISP",
-				},
-				Suggestion: "Consider splitting this large interface into smaller, more focused interfaces",
-				Analyzer:   "solid",
-				Rule:       "interface-size",
-			})
-		}
-	}
-
-	return violations
-}
-
-// Helper methods for analysis
-
-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
-}
-
-// 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

@@ -1,25 +0,0 @@
-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

@@ -1,156 +0,0 @@
-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"`
-
-	// Declared tenant-scoping inputs, resolved on the TypeScript side by
-	// buildOrgFilterTierSet (Tier 1 explicit orgFilterTables, Tier 2 configured
-	// schemas, Tier 3 DDL migrations) and handed to this syntax-only subprocess
-	// so it does not guess tenancy from a hardcoded word list.
-	OrgFilterTables  []string `json:"orgFilterTables"`
-	KnownTables      []string `json:"knownTables"`
-	OrgFilterColumns []string `json:"orgFilterColumns"`
-}
-
-// 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"`
-	Rule       string                 `json:"rule"`
-}
-
-// 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

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

package/dist/languages/go/main.go

@@ -1,203 +0,0 @@
-package main
-
-import (
-	"bufio"
-	"encoding/json"
-	"fmt"
-	"io"
-	"os"
-	"strings"
-
-	"code-auditor-go/analyzer"
-)
-
-// JSON-RPC request structure
-type Request struct {
-	Method string      `json:"method"`
-	Params interface{} `json:"params"`
-	ID     interface{} `json:"id"`
-}
-
-// JSON-RPC response structure
-type Response struct {
-	Result interface{} `json:"result,omitempty"`
-	Error  *RPCError   `json:"error,omitempty"`
-	ID     interface{} `json:"id"`
-}
-
-// RPC error structure
-type RPCError struct {
-	Code    int    `json:"code"`
-	Message string `json:"message"`
-}
-
-// Analysis parameters structure
-type AnalysisParams struct {
-	Files   []string                `json:"files"`
-	Options analyzer.AnalysisOptions `json:"options"`
-}
-
-// Content analysis parameters structure
-type ContentAnalysisParams struct {
-	File    string                  `json:"file"`
-	Content string                  `json:"content"`
-	Options analyzer.AnalysisOptions `json:"options"`
-}
-
-func main() {
-	// Log startup to stderr (won't interfere with JSON-RPC on stdout)
-	fmt.Fprintf(os.Stderr, "[GoAnalyzer] Starting Go analyzer server\n")
-	
-	// Create a buffered reader for stdin
-	reader := bufio.NewReader(os.Stdin)
-
-	for {
-		// Read a line from stdin
-		line, err := reader.ReadString('\n')
-		if err != nil {
-			if err == io.EOF {
-				fmt.Fprintf(os.Stderr, "[GoAnalyzer] EOF reached\n")
-				break
-			}
-			fmt.Fprintf(os.Stderr, "[GoAnalyzer] Read error: %v\n", err)
-			sendError(-1, fmt.Sprintf("Error reading input: %v", err), nil)
-			continue
-		}
-
-		line = strings.TrimSpace(line)
-		fmt.Fprintf(os.Stderr, "[GoAnalyzer] Received: %s\n", line)
-		
-		if line == "" {
-			fmt.Fprintf(os.Stderr, "[GoAnalyzer] Empty line, skipping\n")
-			continue
-		}
-
-		// Parse JSON-RPC request
-		var req Request
-		if err := json.Unmarshal([]byte(line), &req); err != nil {
-			fmt.Fprintf(os.Stderr, "[GoAnalyzer] Parse error: %v\n", err)
-			sendError(-32700, "Parse error", req.ID)
-			continue
-		}
-
-		fmt.Fprintf(os.Stderr, "[GoAnalyzer] Handling request: %s\n", req.Method)
-		// Handle the request
-		handleRequest(req)
-	}
-	fmt.Fprintf(os.Stderr, "[GoAnalyzer] Server shutting down\n")
-}
-
-func handleRequest(req Request) {
-	switch req.Method {
-	case "analyze":
-		handleAnalyze(req)
-	case "analyzeContent":
-		handleAnalyzeContent(req)
-	case "ping":
-		sendResult("pong", req.ID)
-	case "version":
-		sendResult("1.0.0", req.ID)
-	default:
-		sendError(-32601, "Method not found", req.ID)
-	}
-}
-
-func handleAnalyze(req Request) {
-	// Parse parameters
-	paramsBytes, err := json.Marshal(req.Params)
-	if err != nil {
-		sendError(-32602, "Invalid params", req.ID)
-		return
-	}
-
-	var params AnalysisParams
-	if err := json.Unmarshal(paramsBytes, &params); err != nil {
-		sendError(-32602, "Invalid params", req.ID)
-		return
-	}
-
-	// Filter Go files
-	var goFiles []string
-	for _, file := range params.Files {
-		if strings.HasSuffix(file, ".go") {
-			goFiles = append(goFiles, file)
-		}
-	}
-
-	if len(goFiles) == 0 {
-		sendError(-32603, "No Go files provided", req.ID)
-		return
-	}
-
-	// Create and run analyzer
-	goAnalyzer := analyzer.NewAnalyzer(params.Options)
-	result, err := goAnalyzer.Analyze(goFiles)
-	if err != nil {
-		sendError(-32603, fmt.Sprintf("Analysis failed: %v", err), req.ID)
-		return
-	}
-
-	// Send successful result
-	sendResult(result, req.ID)
-}
-
-func sendResult(result interface{}, id interface{}) {
-	response := Response{
-		Result: result,
-		ID:     id,
-	}
-	sendResponse(response)
-}
-
-func sendError(code int, message string, id interface{}) {
-	response := Response{
-		Error: &RPCError{
-			Code:    code,
-			Message: message,
-		},
-		ID: id,
-	}
-	sendResponse(response)
-}
-
-func sendResponse(response Response) {
-	data, err := json.Marshal(response)
-	if err != nil {
-		fmt.Fprintf(os.Stderr, "Error marshaling response: %v\n", err)
-		return
-	}
-
-	fmt.Println(string(data))
-}
-
-func handleAnalyzeContent(req Request) {
-	// Parse parameters
-	paramsBytes, err := json.Marshal(req.Params)
-	if err != nil {
-		sendError(-32602, "Invalid params", req.ID)
-		return
-	}
-
-	var params ContentAnalysisParams
-	if err := json.Unmarshal(paramsBytes, &params); err != nil {
-		sendError(-32602, "Invalid params", req.ID)
-		return
-	}
-
-	// Validate file extension
-	if !strings.HasSuffix(params.File, ".go") {
-		sendError(-32603, "Not a Go file", req.ID)
-		return
-	}
-
-	// Create and run analyzer with content
-	goAnalyzer := analyzer.NewAnalyzer(params.Options)
-	result, err := goAnalyzer.AnalyzeContent(params.File, params.Content)
-	if err != nil {
-		sendError(-32603, fmt.Sprintf("Content analysis failed: %v", err), req.ID)
-		return
-	}
-
-	// Send successful result
-	sendResult(result, req.ID)
-}