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

iflow_mcp_kandrwmrtn_cplusplus_mcp-0.1.0.dist-info/METADATA

@@ -0,0 +1,222 @@
+Metadata-Version: 2.4
+Name: iflow-mcp_kandrwmrtn-cplusplus_mcp
+Version: 0.1.0
+Summary: An MCP server for analyzing C++ codebases using libclang
+License-File: LICENSE
+Requires-Python: >=3.9
+Requires-Dist: libclang>=16.0.0
+Requires-Dist: mcp>=1.0.0
+Description-Content-Type: text/markdown
+
+# C++ MCP Server
+
+An MCP (Model Context Protocol) server for analyzing C++ codebases using libclang.
+
+## Why Use This?
+
+Instead of having Claude grep through your C++ codebase trying to understand the structure, this server provides semantic understanding of your code. Claude can instantly find classes, functions, and their relationships without getting lost in thousands of files. It understands C++ syntax, inheritance hierarchies, and call graphs - giving Claude the ability to navigate your codebase like an IDE would.
+
+## Features
+
+Context-efficient C++ code analysis:
+- **search_classes** - Find classes by name pattern
+- **search_functions** - Find functions by name pattern  
+- **get_class_info** - Get detailed class information (methods, members, inheritance)
+- **get_function_signature** - Get function signatures and parameters
+- **find_in_file** - Search symbols within specific files
+- **get_class_hierarchy** - Get complete inheritance hierarchy for a class
+- **get_derived_classes** - Find all classes that inherit from a base class
+- **find_callers** - Find all functions that call a specific function
+- **find_callees** - Find all functions called by a specific function
+- **get_call_path** - Find call paths from one function to another
+
+## Prerequisites
+
+- Python 3.9 or higher
+- pip (Python package manager)
+- Git (for cloning the repository)
+- LLVM's libclang (the setup scripts will attempt to download a portable build)
+
+## Setup
+
+1. Clone the repository:
+```bash
+git clone <repository-url>
+cd CPlusPlus-MCP-Server
+```
+
+2. Run the setup script for your platform (this creates a virtual environment, installs dependencies, and fetches libclang if possible):
+   - **Windows**
+     ```bash
+     server_setup.bat
+     ```
+   - **Linux/macOS**
+     ```bash
+     ./server_setup.sh
+     ```
+
+3. Test the installation (recommended):
+```bash
+# Activate the virtual environment first
+mcp_env\Scripts\activate
+
+# Run the installation test
+python scripts\test_installation.py
+```
+
+This will verify that all components are properly installed and working. The test script lives at `scripts/test_installation.py`.
+
+## Configuring Claude Code
+
+To use this MCP server with Claude Code, you need to add it to your Claude configuration file.
+
+1. Find and open your Claude configuration file. Common locations include:
+   ```
+   C:\Users\<YourUsername>\.claude.json
+   C:\Users\<YourUsername>\AppData\Roaming\Claude\.claude.json
+   %APPDATA%\Claude\.claude.json
+   ```
+   
+   The exact location may vary depending on your Claude installation.
+   
+2. Add the C++ MCP server to the `mcpServers` section:
+   ```json
+   {
+     "mcpServers": {
+       "cpp-analyzer": {
+         "command": "python",
+         "args": [
+           "-m",
+           "mcp_server.cpp_mcp_server"
+         ],
+         "cwd": "YOUR_INSTALLATION_PATH_HERE",
+         "env": {
+           "PYTHONPATH": "YOUR_INSTALLATION_PATH_HERE"
+         }
+       }
+     }
+   }
+   ```
+
+   **IMPORTANT:** Replace `YOUR_INSTALLATION_PATH_HERE` with the actual path where you cloned this repository.
+
+3. Restart Claude Desktop for the changes to take effect.
+
+## Configuring Codex CLI
+
+To use this MCP server inside the OpenAI Codex CLI:
+
+1. Make sure the virtual environment is created (see setup above).
+2. Create a `.mcp.json` file in the project you open with Codex. The CLI reads this file to discover MCP servers.
+3. Add an entry that points to the Python module inside the virtual environment. Replace `YOUR_REPO_PATH` with the absolute path to this repository.
+
+   ```json
+   {
+     "mcpServers": {
+       "cpp-analyzer": {
+         "type": "stdio",
+         "command": "YOUR_REPO_PATH/mcp_env/bin/python",
+         "args": [
+           "-m",
+           "mcp_server.cpp_mcp_server"
+         ],
+         "env": {
+           "PYTHONPATH": "YOUR_REPO_PATH"
+         }
+       }
+     }
+   }
+   ```
+
+   On Windows change `command` to `YOUR_REPO_PATH\\mcp_env\\Scripts\\python.exe`.
+
+4. Restart the Codex CLI (or run `codex reload`) so it picks up the new server definition.
+5. Inside Codex, use the MCP palette or prompt instructions (for example, "use the cpp-analyzer tool to set the project directory to ...") to start indexing your C++ project.
+
+If you keep the `.mcp.json` file inside this repository you can also add a `"cwd": "YOUR_REPO_PATH"` entry so Codex launches the server from the correct directory.
+
+## Usage with Claude
+
+Once configured, you can use the C++ analyzer in your conversations with Claude:
+
+1. First, ask Claude to set your project directory using the MCP tool:
+   ```
+   "Use the cpp-analyzer tool to set the project directory to C:\path\to\your\cpp\project"
+   ```
+   
+   **Note:** The initial indexing might take a long time for very large projects (several minutes for codebases with thousands of files). The server will cache the results for faster subsequent queries.
+
+2. Then you can ask questions like:
+   - "Find all classes containing 'Actor'"
+   - "Show me the Component class details"
+   - "What's the signature of BeginPlay function?"
+   - "Search for physics-related functions"
+   - "Show me the inheritance hierarchy for GameObject"
+   - "Find all functions that call Update()"
+   - "What functions does Render() call?"
+
+## Architecture
+
+- Uses libclang for accurate C++ parsing
+- Caches parsed AST for improved performance
+- Supports incremental analysis and project-wide search
+- Provides detailed symbol information including:
+  - Function signatures with parameter types and names
+  - Class members, methods, and inheritance
+  - Call graph analysis for understanding code flow
+  - File locations for easy navigation
+
+## Configuration Options
+
+The server behavior can be configured via `cpp-analyzer-config.json`:
+
+```json
+{
+  "exclude_directories": [".git", ".svn", "node_modules", "build", "Build"],
+  "exclude_patterns": ["*.generated.h", "*.generated.cpp", "*_test.cpp"],
+  "dependency_directories": ["vcpkg_installed", "third_party", "external"],
+  "include_dependencies": true,
+  "max_file_size_mb": 10
+}
+```
+
+- **exclude_directories**: Directories to skip during project scanning
+- **exclude_patterns**: File patterns to exclude from analysis
+- **dependency_directories**: Directories containing third-party dependencies
+- **include_dependencies**: Whether to analyze files in dependency directories
+- **max_file_size_mb**: Maximum file size to analyze (larger files are skipped)
+
+## Troubleshooting
+
+### Common Issues
+
+1. **"libclang not found" error**
+   - Run `server_setup.bat` (Windows) or `./server_setup.sh` (Linux/macOS) to let the project download libclang automatically
+   - If automatic download fails, manually download libclang:
+     1. Go to: https://github.com/llvm/llvm-project/releases
+     2. Download the appropriate file for your system:
+        - **Windows**: `clang+llvm-*-x86_64-pc-windows-msvc.tar.xz`
+        - **macOS**: `clang+llvm-*-x86_64-apple-darwin.tar.xz`
+        - **Linux**: `clang+llvm-*-x86_64-linux-gnu-ubuntu-*.tar.xz`
+     3. Extract and copy the libclang library to the appropriate location:
+        - **Windows**: Copy `bin\libclang.dll` to `lib\windows\libclang.dll`
+        - **macOS**: Copy `lib\libclang.dylib` to `lib\macos\libclang.dylib`
+        - **Linux**: Copy `lib\libclang.so.*` to `lib\linux\libclang.so`
+
+2. **Server fails to start**
+   - Check that Python 3.9+ is installed: `python --version`
+   - Verify all dependencies are installed: `pip install -r requirements.txt`
+   - Run the installation test to identify issues:
+     ```bash
+     mcp_env\Scripts\activate
+     python -m mcp_server.test_installation
+     ```
+
+3. **Claude doesn't recognize the server**
+   - Ensure the paths in `.claude.json` are absolute paths
+   - Restart Claude Desktop after modifying the configuration
+
+4. **Claude uses grep/glob instead of the C++ analyzer**
+   - Be explicit in prompts: Say "use the cpp-analyzer to..." when asking about C++ code
+   - Add instructions to your project's `CLAUDE.md` file telling Claude to prefer the cpp-analyzer for C++ symbol searches
+   - The cpp-analyzer is much faster than grep for finding classes, functions, and understanding code structure

iflow_mcp_kandrwmrtn_cplusplus_mcp-0.1.0.dist-info/RECORD

@@ -0,0 +1,14 @@
+mcp_server/__init__.py,sha256=rb4OYhZrwqDG7frb5y0-Ath_IfmEZZH-G1W52xqurWg,20
+mcp_server/cache_manager.py,sha256=vh27N5oikrBvDcvqU0G6hrdiT-dEa8H50irJcHNtEH8,8046
+mcp_server/call_graph.py,sha256=k7lu3K5DVrc0cNU4L4K-Cbt4TawJLQXMr2D6sUgPX9E,4564
+mcp_server/cpp_analyzer.py,sha256=3uIKJhqpoToc4jWXmNCyZnjpDEcoZcbz9emDOZJ3DIM,44837
+mcp_server/cpp_analyzer_config.py,sha256=qQXqQ4O-b26X0YWZMGYqxsnmSBDbd3gbNC49R4XiFVE,4054
+mcp_server/cpp_mcp_server.py,sha256=E0Gxq4mqZDsYqHS1qcU44zG5I6kw3cQPYeh8PZ9U-ps,70383
+mcp_server/file_scanner.py,sha256=N2i1s1eV31OO4bRRFQezLtTOcghM-iL7koCKNPEzVo8,3457
+mcp_server/search_engine.py,sha256=Kk4upwhOvpp9ejqix7OR9EZRZX75mpEVBtDRZpV5Bn0,5337
+mcp_server/symbol_info.py,sha256=jcSVfs3RY9USThwrWZM4LN0DPUKfQx4clcBpZ_XE2NM,1479
+iflow_mcp_kandrwmrtn_cplusplus_mcp-0.1.0.dist-info/METADATA,sha256=KOEY3oRSMsRlp_QmqyWc6VR4accd6mKegFvzsDBGvdM,8424
+iflow_mcp_kandrwmrtn_cplusplus_mcp-0.1.0.dist-info/WHEEL,sha256=WLgqFyCfm_KASv4WHyYy0P3pM_m7J5L9k2skdKLirC8,87
+iflow_mcp_kandrwmrtn_cplusplus_mcp-0.1.0.dist-info/entry_points.txt,sha256=hBHf2A-CyZD5JOYDPDzNlixe3tSO80uO8JpbtsacsK0,70
+iflow_mcp_kandrwmrtn_cplusplus_mcp-0.1.0.dist-info/licenses/LICENSE,sha256=btWkLC_c3_pzYSBolypn-jdLF1MF5knaY-koLLP__mc,1068
+iflow_mcp_kandrwmrtn_cplusplus_mcp-0.1.0.dist-info/RECORD,,

iflow_mcp_kandrwmrtn_cplusplus_mcp-0.1.0.dist-info/WHEEL

@@ -0,0 +1,4 @@
+Wheel-Version: 1.0
+Generator: hatchling 1.28.0
+Root-Is-Purelib: true
+Tag: py3-none-any

iflow_mcp_kandrwmrtn_cplusplus_mcp-0.1.0.dist-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+cpp-mcp-server = mcp_server.cpp_mcp_server:run_main

iflow_mcp_kandrwmrtn_cplusplus_mcp-0.1.0.dist-info/licenses/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2025 Chickenrikke
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

mcp_server/__init__.py

@@ -0,0 +1 @@
+# MCP Server Package

mcp_server/cache_manager.py

@@ -0,0 +1,212 @@
+"""Cache management for C++ analyzer."""
+
+import json
+import hashlib
+import time
+import os
+import sys
+from pathlib import Path
+from typing import Dict, List, Optional, Any
+from collections import defaultdict
+from .symbol_info import SymbolInfo
+
+
+class CacheManager:
+    """Manages caching for the C++ analyzer."""
+    
+    def __init__(self, project_root: Path):
+        self.project_root = project_root
+        self.cache_dir = self._get_cache_dir()
+        self.cache_dir.mkdir(parents=True, exist_ok=True)
+        
+    def _get_cache_dir(self) -> Path:
+        """Get the cache directory for this project"""
+        # Use the MCP server directory for cache, not the project being analyzed
+        mcp_server_root = Path(__file__).parent.parent  # Go up from mcp_server/cache_manager.py to root
+        cache_base = mcp_server_root / ".mcp_cache"
+        
+        # Use a hash of the project path to create a unique cache directory
+        project_hash = hashlib.md5(str(self.project_root).encode()).hexdigest()[:8]
+        cache_dir = cache_base / f"{self.project_root.name}_{project_hash}"
+        return cache_dir
+    
+    def get_file_hash(self, file_path: str) -> str:
+        """Calculate hash of a file"""
+        try:
+            with open(file_path, 'rb') as f:
+                return hashlib.md5(f.read()).hexdigest()
+        except:
+            return ""
+    
+    def save_cache(self, class_index: Dict[str, List[SymbolInfo]], 
+                   function_index: Dict[str, List[SymbolInfo]],
+                   file_hashes: Dict[str, str],
+                   indexed_file_count: int,
+                   include_dependencies: bool = False) -> bool:
+        """Save indexes to cache file"""
+        try:
+            cache_file = self.cache_dir / "cache_info.json"
+            
+            # Convert to serializable format
+            cache_data = {
+                "version": "2.0",  # Cache version
+                "include_dependencies": include_dependencies,
+                "class_index": {},
+                "function_index": {},
+                "file_hashes": file_hashes,
+                "indexed_file_count": indexed_file_count,
+                "timestamp": time.time()
+            }
+            
+            # Convert class index
+            for name, infos in class_index.items():
+                cache_data["class_index"][name] = [info.to_dict() for info in infos]
+            
+            # Convert function index
+            for name, infos in function_index.items():
+                cache_data["function_index"][name] = [info.to_dict() for info in infos]
+            
+            # Save to file
+            cache_file.parent.mkdir(parents=True, exist_ok=True)
+            with open(cache_file, 'w') as f:
+                json.dump(cache_data, f, indent=2)
+            
+            return True
+        except Exception as e:
+            print(f"Error saving cache: {e}", file=sys.stderr)
+            return False
+    
+    def load_cache(self, include_dependencies: bool = False) -> Optional[Dict[str, Any]]:
+        """Load cache if it exists and is valid"""
+        cache_file = self.cache_dir / "cache_info.json"
+        
+        if not cache_file.exists():
+            return None
+        
+        try:
+            with open(cache_file, 'r') as f:
+                cache_data = json.load(f)
+            
+            # Check cache version
+            if cache_data.get("version") != "2.0":
+                print("Cache version mismatch, rebuilding...", file=sys.stderr)
+                return None
+            
+            # Check if dependencies setting matches
+            cached_include_deps = cache_data.get("include_dependencies", False)
+            if cached_include_deps != include_dependencies:
+                print(f"Cache dependencies setting mismatch (cached={cached_include_deps}, current={include_dependencies})", 
+                      file=sys.stderr)
+                return None
+            
+            return cache_data
+            
+        except Exception as e:
+            print(f"Error loading cache: {e}", file=sys.stderr)
+            return None
+    
+    def get_file_cache_path(self, file_path: str) -> Path:
+        """Get the cache file path for a given source file"""
+        files_dir = self.cache_dir / "files"
+        cache_filename = hashlib.md5(file_path.encode()).hexdigest() + ".json"
+        return files_dir / cache_filename
+    
+    def save_file_cache(self, file_path: str, symbols: List[SymbolInfo], 
+                       file_hash: str) -> bool:
+        """Save parsed symbols for a single file"""
+        try:
+            # Create files subdirectory
+            files_dir = self.cache_dir / "files"
+            files_dir.mkdir(exist_ok=True)
+            
+            # Use hash of file path as cache filename
+            cache_file = self.get_file_cache_path(file_path)
+            
+            # Prepare cache data
+            cache_data = {
+                "file_path": file_path,
+                "file_hash": file_hash,
+                "timestamp": time.time(),
+                "symbols": [s.to_dict() for s in symbols]
+            }
+            
+            # Save to file
+            with open(cache_file, 'w') as f:
+                json.dump(cache_data, f, indent=2)
+            
+            return True
+        except Exception as e:
+            # Silently fail for individual file caches
+            return False
+    
+    def load_file_cache(self, file_path: str, current_hash: str) -> Optional[List[SymbolInfo]]:
+        """Load cached symbols for a file if hash matches"""
+        try:
+            cache_file = self.get_file_cache_path(file_path)
+            
+            if not cache_file.exists():
+                return None
+            
+            with open(cache_file, 'r') as f:
+                cache_data = json.load(f)
+            
+            # Check if file hash matches
+            if cache_data.get("file_hash") != current_hash:
+                return None
+            
+            # Reconstruct SymbolInfo objects
+            symbols = []
+            for s in cache_data.get("symbols", []):
+                symbols.append(SymbolInfo(**s))
+            
+            return symbols
+        except:
+            return None
+    
+    def remove_file_cache(self, file_path: str) -> bool:
+        """Remove cached data for a deleted file"""
+        try:
+            cache_file = self.get_file_cache_path(file_path)
+            if cache_file.exists():
+                cache_file.unlink()
+                return True
+            return False
+        except:
+            return False
+    
+    def save_progress(self, total_files: int, indexed_files: int, 
+                     failed_files: int, cache_hits: int,
+                     last_index_time: float, class_count: int, 
+                     function_count: int, status: str = "in_progress"):
+        """Save indexing progress"""
+        try:
+            progress_file = self.cache_dir / "indexing_progress.json"
+            progress_data = {
+                "project_root": str(self.project_root),
+                "total_files": total_files,
+                "indexed_files": indexed_files,
+                "failed_files": failed_files,
+                "cache_hits": cache_hits,
+                "last_index_time": last_index_time,
+                "timestamp": time.time(),
+                "class_count": class_count,
+                "function_count": function_count,
+                "status": status
+            }
+            
+            with open(progress_file, 'w') as f:
+                json.dump(progress_data, f, indent=2)
+        except:
+            pass  # Silently fail for progress tracking
+    
+    def load_progress(self) -> Optional[Dict[str, Any]]:
+        """Load indexing progress if available"""
+        try:
+            progress_file = self.cache_dir / "indexing_progress.json"
+            if not progress_file.exists():
+                return None
+                
+            with open(progress_file, 'r') as f:
+                return json.load(f)
+        except:
+            return None

mcp_server/call_graph.py

@@ -0,0 +1,108 @@
+"""Call graph analysis for C++ code."""
+
+import re
+from typing import Dict, List, Set, Optional, Any
+from collections import defaultdict
+from .symbol_info import SymbolInfo
+
+
+class CallGraphAnalyzer:
+    """Manages call graph analysis for C++ code."""
+    
+    def __init__(self):
+        self.call_graph: Dict[str, Set[str]] = defaultdict(set)  # Function USR -> Set of called USRs
+        self.reverse_call_graph: Dict[str, Set[str]] = defaultdict(set)  # Function USR -> Set of caller USRs
+    
+    def add_call(self, caller_usr: str, callee_usr: str):
+        """Add a function call relationship"""
+        if caller_usr and callee_usr:
+            self.call_graph[caller_usr].add(callee_usr)
+            self.reverse_call_graph[callee_usr].add(caller_usr)
+    
+    def clear(self):
+        """Clear all call graph data"""
+        self.call_graph.clear()
+        self.reverse_call_graph.clear()
+    
+    def remove_symbol(self, usr: str):
+        """Remove a symbol from the call graph completely"""
+        if usr in self.call_graph:
+            # Remove all calls made by this function
+            called_functions = self.call_graph[usr].copy()
+            for called_usr in called_functions:
+                self.reverse_call_graph[called_usr].discard(usr)
+                # Clean up empty sets
+                if not self.reverse_call_graph[called_usr]:
+                    del self.reverse_call_graph[called_usr]
+            del self.call_graph[usr]
+        
+        if usr in self.reverse_call_graph:
+            # Remove all calls to this function
+            calling_functions = self.reverse_call_graph[usr].copy()
+            for caller_usr in calling_functions:
+                self.call_graph[caller_usr].discard(usr)
+                # Clean up empty sets
+                if not self.call_graph[caller_usr]:
+                    del self.call_graph[caller_usr]
+            del self.reverse_call_graph[usr]
+    
+    def rebuild_from_symbols(self, symbols: List[SymbolInfo]):
+        """Rebuild call graph from symbol list"""
+        self.clear()
+        for symbol in symbols:
+            if symbol.usr and symbol.calls:
+                for called_usr in symbol.calls:
+                    self.add_call(symbol.usr, called_usr)
+    
+    def find_callers(self, function_usr: str) -> Set[str]:
+        """Find all functions that call the specified function"""
+        return self.reverse_call_graph.get(function_usr, set())
+    
+    def find_callees(self, function_usr: str) -> Set[str]:
+        """Find all functions called by the specified function"""
+        return self.call_graph.get(function_usr, set())
+    
+    def get_call_paths(self, from_usr: str, to_usr: str, max_depth: int = 10) -> List[List[str]]:
+        """Find all call paths from one function to another"""
+        if from_usr == to_usr:
+            return [[from_usr]]
+        
+        if max_depth <= 0:
+            return []
+        
+        paths = []
+        
+        # Get direct callees
+        callees = self.find_callees(from_usr)
+        
+        for callee in callees:
+            if callee == to_usr:
+                # Direct call found
+                paths.append([from_usr, to_usr])
+            else:
+                # Recursively search for paths
+                sub_paths = self.get_call_paths(callee, to_usr, max_depth - 1)
+                for sub_path in sub_paths:
+                    paths.append([from_usr] + sub_path)
+        
+        return paths
+    
+    def get_call_statistics(self) -> Dict[str, Any]:
+        """Get statistics about the call graph"""
+        return {
+            "total_functions_with_calls": len(self.call_graph),
+            "total_functions_being_called": len(self.reverse_call_graph),
+            "total_unique_calls": sum(len(calls) for calls in self.call_graph.values()),
+            "most_called_functions": self._get_most_called_functions(10),
+            "functions_with_most_calls": self._get_functions_with_most_calls(10)
+        }
+    
+    def _get_most_called_functions(self, limit: int) -> List[tuple]:
+        """Get the most frequently called functions"""
+        call_counts = [(usr, len(callers)) for usr, callers in self.reverse_call_graph.items()]
+        return sorted(call_counts, key=lambda x: x[1], reverse=True)[:limit]
+    
+    def _get_functions_with_most_calls(self, limit: int) -> List[tuple]:
+        """Get functions that make the most calls"""
+        call_counts = [(usr, len(callees)) for usr, callees in self.call_graph.items()]
+        return sorted(call_counts, key=lambda x: x[1], reverse=True)[:limit]