path: root/pkg/semantic/server.go

package semantic

import (
	"encoding/json"
	"fmt"
	"sync"

	"github.com/xlgmokha/mcp/pkg/mcp"
)

// SemanticOperations provides semantic analysis operations
type SemanticOperations struct {
	lspManager    *LSPManager
	symbolManager *SymbolManager
	projectManager *ProjectManager
	mu            sync.RWMutex
}

// NewSemanticOperations creates a new SemanticOperations helper
func NewSemanticOperations() (*SemanticOperations, error) {
	lspManager := NewLSPManager()
	projectManager := NewProjectManager()
	symbolManager := NewSymbolManager(lspManager, projectManager)
	
	return &SemanticOperations{
		lspManager:     lspManager,
		symbolManager:  symbolManager,
		projectManager: projectManager,
	}, nil
}

// New creates a new Semantic MCP server
func New() (*mcp.Server, error) {
	semantic, err := NewSemanticOperations()
	if err != nil {
		return nil, err
	}
	
	builder := mcp.NewServerBuilder("mcp-semantic", "1.0.0")

// Add semantic_find_symbol tool
	builder.AddTool(mcp.NewTool("semantic_find_symbol", "Find symbols by name, type, or pattern across the project", map[string]interface{}{
		"type": "object",
		"properties": map[string]interface{}{
			"query": map[string]interface{}{
				"type":        "string",
				"description": "Symbol name or pattern to search for",
			},
			"symbol_type": map[string]interface{}{
				"type":        "string",
				"description": "Type of symbol to search for (function, class, variable, etc.)",
				"enum":        []string{"function", "class", "variable", "interface", "type", "constant", "module"},
			},
			"language": map[string]interface{}{
				"type":        "string",
				"description": "Programming language to filter by (optional)",
				"enum":        []string{"go", "rust", "typescript", "javascript", "python", "java", "cpp"},
			},
			"case_sensitive": map[string]interface{}{
				"type":        "boolean",
				"description": "Whether the search should be case sensitive (default: false)",
			},
			"exact_match": map[string]interface{}{
				"type":        "boolean",
				"description": "Whether to match the exact symbol name (default: false, allows partial matches)",
			},
		},
		"required": []string{"query"},
	}, func(req mcp.CallToolRequest) (mcp.CallToolResult, error) {
		return semantic.handleFindSymbol(req)
	}))

	// Add semantic_get_overview tool
	builder.AddTool(mcp.NewTool("semantic_get_overview", "Get a high-level overview of symbols and structure in a file or directory", map[string]interface{}{
		"type": "object",
		"properties": map[string]interface{}{
			"path": map[string]interface{}{
				"type":        "string",
				"description": "File or directory path to analyze",
			},
			"depth": map[string]interface{}{
				"type":        "integer",
				"description": "Depth of analysis (1=top-level only, 2=include immediate children, etc.) (default: 2)",
				"minimum":     1,
				"maximum":     5,
			},
			"include_private": map[string]interface{}{
				"type":        "boolean",
				"description": "Include private/internal symbols (default: false)",
			},
			"group_by": map[string]interface{}{
				"type":        "string",
				"description": "How to group the results (type, file, module) (default: type)",
				"enum":        []string{"type", "file", "module"},
			},
		},
		"required": []string{"path"},
	}, func(req mcp.CallToolRequest) (mcp.CallToolResult, error) {
		return semantic.handleGetOverview(req)
	}))

	// Add semantic_get_definition tool
	builder.AddTool(mcp.NewTool("semantic_get_definition", "Get the definition location and details for a specific symbol", map[string]interface{}{
		"type": "object",
		"properties": map[string]interface{}{
			"symbol": map[string]interface{}{
				"type":        "string",
				"description": "Symbol name to find definition for",
			},
			"file": map[string]interface{}{
				"type":        "string",
				"description": "File path where the symbol is referenced (helps with context)",
			},
			"line": map[string]interface{}{
				"type":        "integer",
				"description": "Line number where the symbol is referenced (optional, for better precision)",
				"minimum":     1,
			},
			"column": map[string]interface{}{
				"type":        "integer",
				"description": "Column number where the symbol is referenced (optional, for better precision)",
				"minimum":     1,
			},
			"include_signature": map[string]interface{}{
				"type":        "boolean",
				"description": "Include full function/method signature (default: true)",
			},
		},
		"required": []string{"symbol"},
	}, func(req mcp.CallToolRequest) (mcp.CallToolResult, error) {
		return semantic.handleGetDefinition(req)
	}))

	// Add semantic_get_references tool
	builder.AddTool(mcp.NewTool("semantic_get_references", "Find all references to a specific symbol across the project", map[string]interface{}{
		"type": "object",
		"properties": map[string]interface{}{
			"symbol": map[string]interface{}{
				"type":        "string",
				"description": "Symbol name to find references for",
			},
			"file": map[string]interface{}{
				"type":        "string",
				"description": "File path where the symbol is defined (helps with context)",
			},
			"line": map[string]interface{}{
				"type":        "integer",
				"description": "Line number where the symbol is defined (optional, for better precision)",
				"minimum":     1,
			},
			"include_declaration": map[string]interface{}{
				"type":        "boolean",
				"description": "Include the symbol declaration in results (default: true)",
			},
			"scope": map[string]interface{}{
				"type":        "string",
				"description": "Scope of search (file, directory, project) (default: project)",
				"enum":        []string{"file", "directory", "project"},
			},
		},
		"required": []string{"symbol"},
	}, func(req mcp.CallToolRequest) (mcp.CallToolResult, error) {
		return semantic.handleGetReferences(req)
	}))

	// Add semantic_get_call_hierarchy tool
	builder.AddTool(mcp.NewTool("semantic_get_call_hierarchy", "Get the call hierarchy (callers and callees) for a function or method", map[string]interface{}{
		"type": "object",
		"properties": map[string]interface{}{
			"symbol": map[string]interface{}{
				"type":        "string",
				"description": "Function or method name to analyze",
			},
			"file": map[string]interface{}{
				"type":        "string",
				"description": "File path where the function is defined",
			},
			"line": map[string]interface{}{
				"type":        "integer",
				"description": "Line number where the function is defined (optional)",
				"minimum":     1,
			},
			"direction": map[string]interface{}{
				"type":        "string",
				"description": "Direction of call hierarchy (incoming=who calls this, outgoing=what this calls, both) (default: both)",
				"enum":        []string{"incoming", "outgoing", "both"},
			},
			"depth": map[string]interface{}{
				"type":        "integer",
				"description": "Depth of call hierarchy to retrieve (default: 3)",
				"minimum":     1,
				"maximum":     10,
			},
		},
		"required": []string{"symbol", "file"},
	}, func(req mcp.CallToolRequest) (mcp.CallToolResult, error) {
		return semantic.handleGetCallHierarchy(req)
	}))

	// Add semantic_analyze_dependencies tool
	builder.AddTool(mcp.NewTool("semantic_analyze_dependencies", "Analyze dependencies and relationships between modules, files, or symbols", map[string]interface{}{
		"type": "object",
		"properties": map[string]interface{}{
			"path": map[string]interface{}{
				"type":        "string",
				"description": "Path to analyze (file, directory, or project root)",
			},
			"analysis_type": map[string]interface{}{
				"type":        "string",
				"description": "Type of dependency analysis to perform (default: imports)",
				"enum":        []string{"imports", "exports", "modules", "symbols", "circular"},
			},
			"include_external": map[string]interface{}{
				"type":        "boolean",
				"description": "Include external/third-party dependencies (default: false)",
			},
			"format": map[string]interface{}{
				"type":        "string",
				"description": "Output format (tree, graph, list) (default: tree)",
				"enum":        []string{"tree", "graph", "list"},
			},
			"max_depth": map[string]interface{}{
				"type":        "integer",
				"description": "Maximum depth of dependency analysis (default: 5)",
				"minimum":     1,
				"maximum":     20,
			},
		},
		"required": []string{"path"},
	}, func(req mcp.CallToolRequest) (mcp.CallToolResult, error) {
		return semantic.handleAnalyzeDependencies(req)
	}))

	return builder.Build(), nil
}


// handleFindSymbol finds symbols by name, type, or pattern across the project
func (semantic *SemanticOperations) handleFindSymbol(req mcp.CallToolRequest) (mcp.CallToolResult, error) {
	semantic.mu.RLock()
	defer semantic.mu.RUnlock()

	var args struct {
		Name            string   `json:"name"`                      // Symbol path or pattern
		Kind            string   `json:"kind,omitempty"`            // function, class, variable, etc.
		Scope           string   `json:"scope,omitempty"`           // project, file, directory
		Language        string   `json:"language,omitempty"`        // Optional language filter
		IncludeChildren bool     `json:"include_children,omitempty"` // Include child symbols
		MaxResults      int      `json:"max_results,omitempty"`     // Limit results
	}

	argsBytes, _ := json.Marshal(req.Arguments)
	if err := json.Unmarshal(argsBytes, &args); err != nil {
		return mcp.CallToolResult{}, fmt.Errorf("invalid arguments: %w", err)
	}

	if args.Name == "" {
		return mcp.CallToolResult{}, fmt.Errorf("name is required")
	}

	// Set defaults
	if args.Scope == "" {
		args.Scope = "project"
	}
	if args.MaxResults == 0 {
		args.MaxResults = 50
	}

	// Build query
	query := SymbolQuery{
		Name:            args.Name,
		Kind:            SymbolKind(args.Kind),
		Scope:           args.Scope,
		Language:        args.Language,
		IncludeChildren: args.IncludeChildren,
		MaxResults:      args.MaxResults,
	}

	// Find symbols
	symbols, err := semantic.symbolManager.FindSymbols(query)
	if err != nil {
		return mcp.CallToolResult{}, fmt.Errorf("failed to find symbols: %w", err)
	}

	// Format response
	responseData := map[string]interface{}{
		"symbols":     symbols,
		"total_found": len(symbols),
		"query":       query,
	}

	responseJSON, _ := json.MarshalIndent(responseData, "", "  ")

	return mcp.CallToolResult{
		Content: []mcp.Content{
			mcp.TextContent{
				Type: "text",
				Text: fmt.Sprintf("Found %d symbols matching '%s':\n\n%s", 
					len(symbols), args.Name, string(responseJSON)),
			},
		},
	}, nil
}

// handleGetOverview gets high-level symbol overview of files or directories
func (semantic *SemanticOperations) handleGetOverview(req mcp.CallToolRequest) (mcp.CallToolResult, error) {
	semantic.mu.RLock()
	defer semantic.mu.RUnlock()

	var args struct {
		Path           string   `json:"path"`                      // File or directory path
		Depth          int      `json:"depth,omitempty"`           // How deep to analyze
		IncludeKinds   []string `json:"include_kinds,omitempty"`   // Filter symbol types
		ExcludePrivate bool     `json:"exclude_private,omitempty"` // Skip private symbols
	}

	argsBytes, _ := json.Marshal(req.Arguments)
	if err := json.Unmarshal(argsBytes, &args); err != nil {
		return mcp.CallToolResult{}, fmt.Errorf("invalid arguments: %w", err)
	}

	if args.Path == "" {
		return mcp.CallToolResult{}, fmt.Errorf("path is required")
	}

	// Set defaults
	if args.Depth == 0 {
		args.Depth = 2
	}

	// Get overview
	overview, err := semantic.symbolManager.GetOverview(args.Path, args.Depth, args.IncludeKinds, args.ExcludePrivate)
	if err != nil {
		return mcp.CallToolResult{}, fmt.Errorf("failed to get overview: %w", err)
	}

	// Format response
	responseJSON, _ := json.MarshalIndent(overview, "", "  ")

	return mcp.CallToolResult{
		Content: []mcp.Content{
			mcp.TextContent{
				Type: "text",
				Text: fmt.Sprintf("Symbol overview for '%s':\n\n%s", args.Path, string(responseJSON)),
			},
		},
	}, nil
}

// handleGetDefinition gets detailed information about a symbol's definition
func (semantic *SemanticOperations) handleGetDefinition(req mcp.CallToolRequest) (mcp.CallToolResult, error) {
	semantic.mu.RLock()
	defer semantic.mu.RUnlock()

	var args struct {
		Symbol              string `json:"symbol"`                        // Target symbol
		IncludeSignature    bool   `json:"include_signature,omitempty"`    // Include full signature
		IncludeDocumentation bool   `json:"include_documentation,omitempty"` // Include comments/docs
		IncludeDependencies bool   `json:"include_dependencies,omitempty"` // Include what this symbol uses
	}

	argsBytes, _ := json.Marshal(req.Arguments)
	if err := json.Unmarshal(argsBytes, &args); err != nil {
		return mcp.CallToolResult{}, fmt.Errorf("invalid arguments: %w", err)
	}

	if args.Symbol == "" {
		return mcp.CallToolResult{}, fmt.Errorf("symbol is required")
	}

	// Get definition
	definition, err := semantic.symbolManager.GetDefinition(args.Symbol, args.IncludeSignature, args.IncludeDocumentation, args.IncludeDependencies)
	if err != nil {
		return mcp.CallToolResult{}, fmt.Errorf("failed to get definition: %w", err)
	}

	// Format response
	responseJSON, _ := json.MarshalIndent(definition, "", "  ")

	return mcp.CallToolResult{
		Content: []mcp.Content{
			mcp.TextContent{
				Type: "text",
				Text: fmt.Sprintf("Definition for symbol '%s':\n\n%s", args.Symbol, string(responseJSON)),
			},
		},
	}, nil
}

// handleGetReferences finds all places where a symbol is used
func (semantic *SemanticOperations) handleGetReferences(req mcp.CallToolRequest) (mcp.CallToolResult, error) {
	semantic.mu.RLock()
	defer semantic.mu.RUnlock()

	var args struct {
		Symbol              string   `json:"symbol"`                        // Target symbol
		IncludeDefinitions  bool     `json:"include_definitions,omitempty"` // Include definition location
		ContextLines        int      `json:"context_lines,omitempty"`       // Lines of context around usage
		FilterByKind        []string `json:"filter_by_kind,omitempty"`      // Type of references
		Language            string   `json:"language,omitempty"`            // Language filter
		IncludeExternal     bool     `json:"include_external,omitempty"`    // Include external package references
	}

	argsBytes, _ := json.Marshal(req.Arguments)
	if err := json.Unmarshal(argsBytes, &args); err != nil {
		return mcp.CallToolResult{}, fmt.Errorf("invalid arguments: %w", err)
	}

	if args.Symbol == "" {
		return mcp.CallToolResult{}, fmt.Errorf("symbol is required")
	}

	// Set defaults
	if args.ContextLines == 0 {
		args.ContextLines = 3
	}

	// Get references
	references, err := semantic.symbolManager.GetReferences(args.Symbol, args.IncludeDefinitions, args.ContextLines, args.FilterByKind, args.Language, args.IncludeExternal)
	if err != nil {
		return mcp.CallToolResult{}, fmt.Errorf("failed to get references: %w", err)
	}

	// Format response
	responseData := map[string]interface{}{
		"symbol":          args.Symbol,
		"references":      references.References,
		"total_found":     len(references.References),
		"definition":      references.Definition,
		"context_lines":   args.ContextLines,
		"include_external": args.IncludeExternal,
	}

	responseJSON, _ := json.MarshalIndent(responseData, "", "  ")

	return mcp.CallToolResult{
		Content: []mcp.Content{
			mcp.TextContent{
				Type: "text",
				Text: fmt.Sprintf("Found %d references for symbol '%s':\n\n%s", 
					len(references.References), args.Symbol, string(responseJSON)),
			},
		},
	}, nil
}

// handleGetCallHierarchy understands calling relationships (what calls this, what this calls)
func (semantic *SemanticOperations) handleGetCallHierarchy(req mcp.CallToolRequest) (mcp.CallToolResult, error) {
	semantic.mu.RLock()
	defer semantic.mu.RUnlock()

	var args struct {
		Symbol          string `json:"symbol"`                    // Target symbol
		Direction       string `json:"direction,omitempty"`       // "incoming", "outgoing", "both"
		MaxDepth        int    `json:"max_depth,omitempty"`       // How many levels deep
		IncludeExternal bool   `json:"include_external,omitempty"` // Include calls to external packages
		Language        string `json:"language,omitempty"`        // Language filter
	}

	argsBytes, _ := json.Marshal(req.Arguments)
	if err := json.Unmarshal(argsBytes, &args); err != nil {
		return mcp.CallToolResult{}, fmt.Errorf("invalid arguments: %w", err)
	}

	if args.Symbol == "" {
		return mcp.CallToolResult{}, fmt.Errorf("symbol is required")
	}

	// Set defaults
	if args.Direction == "" {
		args.Direction = "both"
	}
	if args.MaxDepth == 0 {
		args.MaxDepth = 3
	}

	// Get call hierarchy
	hierarchy, err := semantic.symbolManager.GetCallHierarchy(args.Symbol, args.Direction, args.MaxDepth, args.IncludeExternal, args.Language)
	if err != nil {
		return mcp.CallToolResult{}, fmt.Errorf("failed to get call hierarchy: %w", err)
	}

	// Format response
	responseJSON, _ := json.MarshalIndent(hierarchy, "", "  ")

	return mcp.CallToolResult{
		Content: []mcp.Content{
			mcp.TextContent{
				Type: "text",
				Text: fmt.Sprintf("Call hierarchy for symbol '%s' (direction: %s, depth: %d):\n\n%s", 
					args.Symbol, args.Direction, args.MaxDepth, string(responseJSON)),
			},
		},
	}, nil
}

// handleAnalyzeDependencies analyzes symbol dependencies and relationships  
func (semantic *SemanticOperations) handleAnalyzeDependencies(req mcp.CallToolRequest) (mcp.CallToolResult, error) {
	semantic.mu.RLock()
	defer semantic.mu.RUnlock()

	var args struct {
		Scope           string `json:"scope"`                     // Analysis scope: "file", "package", "project"
		Path            string `json:"path,omitempty"`            // Specific path to analyze
		IncludeExternal bool   `json:"include_external,omitempty"` // Include external dependencies
		GroupBy         string `json:"group_by,omitempty"`        // "file", "package", "kind"
		ShowUnused      bool   `json:"show_unused,omitempty"`     // Highlight unused symbols
		Language        string `json:"language,omitempty"`        // Language filter
	}

	argsBytes, _ := json.Marshal(req.Arguments)
	if err := json.Unmarshal(argsBytes, &args); err != nil {
		return mcp.CallToolResult{}, fmt.Errorf("invalid arguments: %w", err)
	}

	if args.Scope == "" {
		args.Scope = "project"
	}
	if args.GroupBy == "" {
		args.GroupBy = "package"
	}

	// Analyze dependencies
	analysis, err := semantic.symbolManager.AnalyzeDependencies(args.Scope, args.Path, args.IncludeExternal, args.GroupBy, args.ShowUnused, args.Language)
	if err != nil {
		return mcp.CallToolResult{}, fmt.Errorf("failed to analyze dependencies: %w", err)
	}

	// Format response
	responseJSON, _ := json.MarshalIndent(analysis, "", "  ")

	return mcp.CallToolResult{
		Content: []mcp.Content{
			mcp.TextContent{
				Type: "text",
				Text: fmt.Sprintf("Dependency analysis for scope '%s' (grouped by %s):\n\n%s", 
					args.Scope, args.GroupBy, string(responseJSON)),
			},
		},
	}, nil
}

// Shutdown gracefully shuts down the semantic server
func (semantic *SemanticOperations) Shutdown() error {
	semantic.mu.Lock()
	defer semantic.mu.Unlock()

	if semantic.lspManager != nil {
		if err := semantic.lspManager.Shutdown(); err != nil {
			return fmt.Errorf("failed to shutdown LSP manager: %w", err)
		}
	}

	if semantic.projectManager != nil {
		if err := semantic.projectManager.Shutdown(); err != nil {
			return fmt.Errorf("failed to shutdown project manager: %w", err)
		}
	}

	return nil
}