MCP Source Tree Server

Okay, I understand. Here's how you can generate a JSON file tree from a specified directory's `src` folder, respecting `.gitignore` rules, suitable for quick project structure review in Claude. I'll provide a Python script to accomplish this. **Explanation:** 1. **`gitignore_parser` Library:** We'll use the `gitignore_parser` library to correctly interpret `.gitignore` files. This is crucial for accurately reflecting what files should be excluded. If you don't have it, you'll need to install it: `pip install gitignore_parser` 2. **`os.walk()`:** This function recursively traverses the directory tree. 3. **`.gitignore` Handling:** The script reads and parses `.gitignore` files in each directory it encounters. 4. **JSON Output:** The script constructs a JSON representation of the file tree. **Python Script:** ```python import os import json import gitignore_parser def generate_file_tree_json(root_dir, output_file="file_tree.json"): """ Generates a JSON file tree from the 'src' folder of a specified directory, respecting '.gitignore' rules. Args: root_dir (str): The root directory of the project. output_file (str): The name of the output JSON file. Defaults to "file_tree.json". """ src_dir = os.path.join(root_dir, "src") if not os.path.exists(src_dir): print(f"Error: 'src' directory not found in {root_dir}") return def build_tree(directory, ignore_checker): """Recursively builds the file tree.""" tree = {} for item in os.listdir(directory): full_path = os.path.join(directory, item) relative_path = os.path.relpath(full_path, src_dir) # Path relative to src if ignore_checker(relative_path): continue # Skip ignored files/directories if os.path.isfile(full_path): tree[item] = None # Represent files as None elif os.path.isdir(full_path): tree[item] = build_tree(full_path, ignore_checker) return tree def create_ignore_checker(root_directory): """Creates a function to check if a file/directory is ignored based on .gitignore files.""" ignore_files = [] for root, _, files in os.walk(root_directory): if '.gitignore' in files: ignore_files.append(os.path.join(root, '.gitignore')) ignore_list = [] for ignore_file in ignore_files: ignore_list.append(gitignore_parser.parse(ignore_file)) def is_ignored(path): for ignore in ignore_list: if ignore(os.path.join(src_dir, path)): # Check against the full path return True return False return is_ignored ignore_checker = create_ignore_checker(src_dir) file_tree = build_tree(src_dir, ignore_checker) with open(output_file, "w") as f: json.dump(file_tree, f, indent=4) print(f"File tree JSON saved to {output_file}") # Example Usage: if __name__ == "__main__": # Replace with the actual root directory of your project project_root = "/path/to/your/project" # <---- CHANGE THIS! generate_file_tree_json(project_root) ``` **How to Use:** 1. **Install `gitignore_parser`:** `pip install gitignore_parser` 2. **Replace Placeholder:** In the `if __name__ == "__main__":` block, replace `"/path/to/your/project"` with the actual absolute path to the root directory of your project (the directory containing the `src` folder). 3. **Run the Script:** Execute the Python script. It will create a file named `file_tree.json` in the same directory as the script. 4. **Upload to Claude:** Upload the `file_tree.json` file to Claude. **Example `file_tree.json` Output (Illustrative):** ```json { "components": { "Button.js": null, "Input.js": null }, "utils": { "api.js": null, "helpers.js": null }, "App.js": null, "index.js": null } ``` **Key Improvements and Considerations:** * **`.gitignore` Parsing:** Uses `gitignore_parser` for accurate `.gitignore` handling. This is *essential* for real-world projects. * **Error Handling:** Includes a check to ensure the `src` directory exists. * **Relative Paths:** Uses `os.path.relpath` to store paths relative to the `src` directory in the JSON, making the output more concise and readable. * **Clearer Structure:** Represents files as `null` in the JSON tree, which is a common and easily understood convention. * **Example Usage:** Provides a clear example of how to use the script. * **Comments:** Includes comments to explain the code. * **`create_ignore_checker` Function:** This function encapsulates the logic for creating the ignore checker, making the code more modular and readable. It finds all `.gitignore` files within the `src` directory and its subdirectories. * **Full Path Checking:** The `is_ignored` function now checks the full path (relative to the `src` directory) against the `.gitignore` rules, ensuring accurate matching. * **Modularity:** The code is broken down into functions for better organization and reusability. **How to Use with Claude:** 1. **Upload the JSON:** Upload the generated `file_tree.json` file to Claude. 2. **Prompt Claude:** Craft a prompt that asks Claude to analyze the file structure. For example: * "Here is a JSON representation of the file structure of a project's `src` directory. Can you identify the main components and utilities?" * "Analyze this file structure and suggest potential areas for refactoring." * "Based on this file structure, what design patterns might be in use?" * "This JSON represents the file tree of a React project. Identify the likely component structure." The more specific your prompt, the better the results you'll get from Claude. You can also ask Claude to generate diagrams or visualizations based on the JSON data.