iflow-mcp_kandrwmrtn-cplusplus_mcp 0.1.0__py3-none-any.whl

mcp_server/file_scanner.py

@@ -0,0 +1,92 @@
+"""File discovery and filtering for C++ projects."""
+
+import os
+import sys
+from pathlib import Path
+from typing import List, Set
+
+
+class FileScanner:
+    """Handles file discovery and filtering for C++ projects."""
+    
+    # C++ file extensions
+    CPP_EXTENSIONS = {'.cpp', '.cc', '.cxx', '.c++', '.h', '.hpp', '.hxx', '.h++'}
+    
+    # Directories to exclude (set by configuration)
+    EXCLUDE_DIRS = set()
+    
+    # Directories that contain dependencies (set by configuration)
+    DEPENDENCY_DIRS = set()
+    
+    def __init__(self, project_root: Path, include_dependencies: bool = False):
+        self.project_root = project_root
+        self.include_dependencies = include_dependencies
+    
+    def should_skip_directory(self, dir_path: str) -> bool:
+        """Check if a directory should be skipped"""
+        # Only skip if this directory is directly under the project root
+        try:
+            rel_path = Path(dir_path).relative_to(self.project_root)
+            # If the relative path has no parent, it's a top-level directory
+            if len(rel_path.parts) == 1:
+                return rel_path.parts[0] in self.EXCLUDE_DIRS
+        except ValueError:
+            # Directory is outside project root
+            pass
+        return False
+    
+    def should_skip_file(self, file_path: str) -> bool:
+        """Check if a file should be skipped during indexing"""
+        # Skip files outside project root (shouldn't happen, but safety check)
+        try:
+            rel_path = Path(file_path).relative_to(self.project_root)
+        except ValueError:
+            # File is outside project root
+            if not self.include_dependencies:
+                return True
+            else:
+                return False
+        
+        # Check if file is in a top-level excluded directory
+        if len(rel_path.parts) > 0 and rel_path.parts[0] in self.EXCLUDE_DIRS:
+            return True
+        
+        return False
+    
+    def find_cpp_files(self) -> List[str]:
+        """Find all C++ files in the project"""
+        files = []
+        
+        try:
+            for root, dirs, filenames in os.walk(self.project_root):
+                # Filter directories in-place to prevent walking into them
+                dirs[:] = [d for d in dirs if not self.should_skip_directory(os.path.join(root, d))]
+                
+                for filename in filenames:
+                    if any(filename.endswith(ext) for ext in self.CPP_EXTENSIONS):
+                        file_path = os.path.join(root, filename)
+                        if not self.should_skip_file(file_path):
+                            files.append(file_path)
+        except Exception as e:
+            print(f"Error scanning directory: {e}", file=sys.stderr)
+        
+        return files
+    
+    def is_project_file(self, file_path: str) -> bool:
+        """Check if a file is part of the project (not a dependency)"""
+        if not file_path:
+            return False
+        
+        # Check if file is under project root
+        try:
+            rel_path = Path(file_path).relative_to(self.project_root)
+            
+            # Check if file is in a dependency directory (at any level)
+            for part in rel_path.parts:
+                if part in self.DEPENDENCY_DIRS:
+                    return False
+            
+            return True
+        except ValueError:
+            # File is outside project root - it's a dependency
+            return False

mcp_server/search_engine.py

@@ -0,0 +1,131 @@
+"""Search functionality for C++ symbols."""
+
+import re
+from typing import Dict, List, Optional, Any
+from collections import defaultdict
+from .symbol_info import SymbolInfo
+
+
+class SearchEngine:
+    """Handles searching for C++ symbols."""
+    
+    def __init__(self, class_index: Dict[str, List[SymbolInfo]], 
+                 function_index: Dict[str, List[SymbolInfo]],
+                 file_index: Dict[str, List[SymbolInfo]],
+                 usr_index: Dict[str, SymbolInfo]):
+        self.class_index = class_index
+        self.function_index = function_index
+        self.file_index = file_index
+        self.usr_index = usr_index
+    
+    def search_classes(self, pattern: str, project_only: bool = True) -> List[Dict[str, Any]]:
+        """Search for classes matching a pattern"""
+        results = []
+        regex = re.compile(pattern, re.IGNORECASE)
+        
+        for name, infos in self.class_index.items():
+            if regex.search(name):
+                for info in infos:
+                    if not project_only or info.is_project:
+                        results.append({
+                            "name": info.name,
+                            "kind": info.kind,
+                            "file": info.file,
+                            "line": info.line,
+                            "is_project": info.is_project,
+                            "base_classes": info.base_classes
+                        })
+        
+        return results
+    
+    def search_functions(self, pattern: str, project_only: bool = True, 
+                        class_name: Optional[str] = None) -> List[Dict[str, Any]]:
+        """Search for functions matching a pattern"""
+        results = []
+        regex = re.compile(pattern, re.IGNORECASE)
+        
+        for name, infos in self.function_index.items():
+            if regex.search(name):
+                for info in infos:
+                    if not project_only or info.is_project:
+                        # Filter by class name if specified
+                        if class_name and info.parent_class != class_name:
+                            continue
+                        
+                        results.append({
+                            "name": info.name,
+                            "kind": info.kind,
+                            "file": info.file,
+                            "line": info.line,
+                            "signature": info.signature,
+                            "is_project": info.is_project,
+                            "parent_class": info.parent_class
+                        })
+        
+        return results
+    
+    def search_symbols(self, pattern: str, project_only: bool = True,
+                      symbol_types: Optional[List[str]] = None) -> Dict[str, List[Dict[str, Any]]]:
+        """Search for any symbols matching a pattern"""
+        results = {"classes": [], "functions": []}
+        
+        # Filter symbol types
+        search_classes = not symbol_types or any(t in ["class", "struct"] for t in symbol_types)
+        search_functions = not symbol_types or any(t in ["function", "method"] for t in symbol_types)
+        
+        if search_classes:
+            results["classes"] = self.search_classes(pattern, project_only)
+        
+        if search_functions:
+            results["functions"] = self.search_functions(pattern, project_only)
+        
+        return results
+    
+    def get_symbols_in_file(self, file_path: str) -> List[SymbolInfo]:
+        """Get all symbols in a specific file"""
+        return self.file_index.get(file_path, [])
+    
+    def get_class_info(self, class_name: str) -> Optional[Dict[str, Any]]:
+        """Get detailed information about a class"""
+        infos = self.class_index.get(class_name, [])
+        if not infos:
+            return None
+        
+        # Return the first match (could be enhanced to handle multiple matches)
+        info = infos[0]
+        
+        # Find all methods of this class
+        methods = []
+        for name, func_infos in self.function_index.items():
+            for func_info in func_infos:
+                if func_info.parent_class == class_name:
+                    methods.append({
+                        "name": func_info.name,
+                        "signature": func_info.signature,
+                        "access": func_info.access,
+                        "line": func_info.line
+                    })
+        
+        return {
+            "name": info.name,
+            "kind": info.kind,
+            "file": info.file,
+            "line": info.line,
+            "base_classes": info.base_classes,
+            "methods": sorted(methods, key=lambda x: x["line"]),
+            "is_project": info.is_project
+        }
+    
+    def get_function_signature(self, function_name: str, 
+                             class_name: Optional[str] = None) -> List[str]:
+        """Get function signatures matching the name"""
+        signatures = []
+        
+        for info in self.function_index.get(function_name, []):
+            if class_name is None or info.parent_class == class_name:
+                if info.parent_class:
+                    signatures.append(f"{info.parent_class}::{info.name}{info.signature}")
+                else:
+                    signatures.append(f"{info.name}{info.signature}")
+        
+        return signatures

mcp_server/symbol_info.py

@@ -0,0 +1,42 @@
+"""Symbol information data structure for C++ analysis."""
+
+from dataclasses import dataclass, field
+from typing import List
+
+
+@dataclass
+class SymbolInfo:
+    """Information about a C++ symbol (class, function, etc.)"""
+    name: str
+    kind: str  # "class", "function", "method", etc.
+    file: str
+    line: int
+    column: int
+    signature: str = ""
+    is_project: bool = True
+    namespace: str = ""
+    access: str = "public"  # public, private, protected
+    parent_class: str = ""  # For methods, the containing class
+    base_classes: List[str] = field(default_factory=list)  # For classes
+    usr: str = ""  # Unified Symbol Resolution - unique identifier
+    calls: List[str] = field(default_factory=list)  # USRs of functions this function calls
+    called_by: List[str] = field(default_factory=list)  # USRs of functions that call this
+    
+    def to_dict(self):
+        """Convert to dictionary for JSON serialization"""
+        return {
+            "name": self.name,
+            "kind": self.kind,
+            "file": self.file,
+            "line": self.line,
+            "column": self.column,
+            "signature": self.signature,
+            "is_project": self.is_project,
+            "namespace": self.namespace,
+            "access": self.access,
+            "parent_class": self.parent_class,
+            "base_classes": self.base_classes,
+            "usr": self.usr,
+            "calls": self.calls,
+            "called_by": self.called_by
+        }