fix: Handle MCP server working directory issue using roots

- Add roots support to access Claude Code's working directory
- Update analyze_file_changes in all modules to use correct cwd
- Add documentation about working directory considerations
- Include helpful comments in starter code about roots usage

Author: zealoushacker

projects/unit3/build-mcp-server/solution/server.py

@@ -23,29 +23,73 @@
 async def analyze_file_changes(
     base_branch: str = "main",
     include_diff: bool = True,
-    max_diff_lines: int = 500
+    max_diff_lines: int = 500,
+    working_directory: Optional[str] = None
 ) -> str:
     """Get the full diff and list of changed files in the current git repository.
     
     Args:
         base_branch: Base branch to compare against (default: main)
         include_diff: Include the full diff content (default: true)
         max_diff_lines: Maximum number of diff lines to include (default: 500)
+        working_directory: Directory to run git commands in (default: current directory)
     """
     try:
+        # Try to get working directory from roots first
+        if working_directory is None:
+            try:
+                context = mcp.get_context()
+                roots_result = await context.session.list_roots()
+                # Get the first root - Claude Code sets this to the CWD
+                root = roots_result.roots[0]
+                # FileUrl object has a .path property that gives us the path directly
+                working_directory = root.uri.path
+            except Exception as e:
+                # If we can't get roots, fall back to current directory
+                pass
+        
+        # Use provided working directory or current directory
+        cwd = working_directory if working_directory else os.getcwd()
+        
+        # Debug output
+        debug_info = {
+            "provided_working_directory": working_directory,
+            "actual_cwd": cwd,
+            "server_process_cwd": os.getcwd(),
+            "server_file_location": str(Path(__file__).parent),
+            "roots_check": None
+        }
+        
+        # Add roots debug info
+        try:
+            context = mcp.get_context()
+            roots_result = await context.session.list_roots()
+            debug_info["roots_check"] = {
+                "found": True,
+                "count": len(roots_result.roots),
+                "roots": [str(root.uri) for root in roots_result.roots]
+            }
+        except Exception as e:
+            debug_info["roots_check"] = {
+                "found": False,
+                "error": str(e)
+            }
+        
         # Get list of changed files
         files_result = subprocess.run(
             ["git", "diff", "--name-status", f"{base_branch}...HEAD"],
             capture_output=True,
             text=True,
-            check=True
+            check=True,
+            cwd=cwd
         )
 
         # Get diff statistics
         stat_result = subprocess.run(
             ["git", "diff", "--stat", f"{base_branch}...HEAD"],
             capture_output=True,
-            text=True
+            text=True,
+            cwd=cwd
         )
 
         # Get the actual diff if requested
@@ -55,7 +99,8 @@ async def analyze_file_changes(
             diff_result = subprocess.run(
                 ["git", "diff", f"{base_branch}...HEAD"],
                 capture_output=True,
-                text=True
+                text=True,
+                cwd=cwd
             )
             diff_lines = diff_result.stdout.split('\n')
 
@@ -72,7 +117,8 @@ async def analyze_file_changes(
         commits_result = subprocess.run(
             ["git", "log", "--oneline", f"{base_branch}..HEAD"],
             capture_output=True,
-            text=True
+            text=True,
+            cwd=cwd
         )
 
         analysis = {
@@ -82,7 +128,8 @@ async def analyze_file_changes(
             "commits": commits_result.stdout,
             "diff": diff_content if include_diff else "Diff not included (set include_diff=true to see full diff)",
             "truncated": truncated,
-            "total_diff_lines": len(diff_lines) if include_diff else 0
+            "total_diff_lines": len(diff_lines) if include_diff else 0,
+            "_debug": debug_info
         }
 
         return json.dumps(analysis, indent=2)

projects/unit3/build-mcp-server/starter/server.py

@@ -47,6 +47,14 @@ async def analyze_file_changes(base_branch: str = "main", include_diff: bool = T
     # - Adding a max_diff_lines parameter (e.g., 500 lines)
     # - Truncating large outputs with a message
     # - Returning summary statistics alongside limited diffs
+    
+    # NOTE: Git commands run in the server's directory by default!
+    # To run in Claude's working directory, use MCP roots:
+    # context = mcp.get_context()
+    # roots_result = await context.session.list_roots()
+    # working_dir = roots_result.roots[0].uri.path
+    # subprocess.run(["git", "diff"], cwd=working_dir)
+    
     return json.dumps({"error": "Not implemented yet", "hint": "Use subprocess to run git commands"})
 
 

projects/unit3/github-actions-integration/solution/server.py

@@ -28,29 +28,48 @@
 async def analyze_file_changes(
     base_branch: str = "main",
     include_diff: bool = True,
-    max_diff_lines: int = 500
+    max_diff_lines: int = 500,
+    working_directory: Optional[str] = None
 ) -> str:
     """Get the full diff and list of changed files in the current git repository.
     
     Args:
         base_branch: Base branch to compare against (default: main)
         include_diff: Include the full diff content (default: true)
         max_diff_lines: Maximum number of diff lines to include (default: 500)
+        working_directory: Directory to run git commands in (default: current directory)
     """
     try:
+        # Try to get working directory from roots first
+        if working_directory is None:
+            try:
+                context = mcp.get_context()
+                roots_result = await context.session.list_roots()
+                # Get the first root - Claude Code sets this to the CWD
+                root = roots_result.roots[0]
+                # FileUrl object has a .path property that gives us the path directly
+                working_directory = root.uri.path
+            except Exception as e:
+                # If we can't get roots, fall back to current directory
+                pass
+        
+        # Use provided working directory or current directory
+        cwd = working_directory if working_directory else os.getcwd()
         # Get list of changed files
         files_result = subprocess.run(
             ["git", "diff", "--name-status", f"{base_branch}...HEAD"],
             capture_output=True,
             text=True,
-            check=True
+            check=True,
+            cwd=cwd
         )
 
         # Get diff statistics
         stat_result = subprocess.run(
             ["git", "diff", "--stat", f"{base_branch}...HEAD"],
             capture_output=True,
-            text=True
+            text=True,
+            cwd=cwd
         )
 
         # Get the actual diff if requested
@@ -60,7 +79,8 @@ async def analyze_file_changes(
             diff_result = subprocess.run(
                 ["git", "diff", f"{base_branch}...HEAD"],
                 capture_output=True,
-                text=True
+                text=True,
+                cwd=cwd
             )
             diff_lines = diff_result.stdout.split('\n')
 
@@ -77,7 +97,8 @@ async def analyze_file_changes(
         commits_result = subprocess.run(
             ["git", "log", "--oneline", f"{base_branch}..HEAD"],
             capture_output=True,
-            text=True
+            text=True,
+            cwd=cwd
         )
 
         analysis = {

projects/unit3/slack-notification/solution/server.py

@@ -29,29 +29,48 @@
 async def analyze_file_changes(
     base_branch: str = "main",
     include_diff: bool = True,
-    max_diff_lines: int = 500
+    max_diff_lines: int = 500,
+    working_directory: Optional[str] = None
 ) -> str:
     """Get the full diff and list of changed files in the current git repository.
     
     Args:
         base_branch: Base branch to compare against (default: main)
         include_diff: Include the full diff content (default: true)
         max_diff_lines: Maximum number of diff lines to include (default: 500)
+        working_directory: Directory to run git commands in (default: current directory)
     """
     try:
+        # Try to get working directory from roots first
+        if working_directory is None:
+            try:
+                context = mcp.get_context()
+                roots_result = await context.session.list_roots()
+                # Get the first root - Claude Code sets this to the CWD
+                root = roots_result.roots[0]
+                # FileUrl object has a .path property that gives us the path directly
+                working_directory = root.uri.path
+            except Exception as e:
+                # If we can't get roots, fall back to current directory
+                pass
+        
+        # Use provided working directory or current directory
+        cwd = working_directory if working_directory else os.getcwd()
         # Get list of changed files
         files_result = subprocess.run(
             ["git", "diff", "--name-status", f"{base_branch}...HEAD"],
             capture_output=True,
             text=True,
-            check=True
+            check=True,
+            cwd=cwd
         )
 
         # Get diff statistics
         stat_result = subprocess.run(
             ["git", "diff", "--stat", f"{base_branch}...HEAD"],
             capture_output=True,
-            text=True
+            text=True,
+            cwd=cwd
         )
 
         # Get the actual diff if requested
@@ -61,7 +80,8 @@ async def analyze_file_changes(
             diff_result = subprocess.run(
                 ["git", "diff", f"{base_branch}...HEAD"],
                 capture_output=True,
-                text=True
+                text=True,
+                cwd=cwd
             )
             diff_lines = diff_result.stdout.split('\n')
 
@@ -78,7 +98,8 @@ async def analyze_file_changes(
         commits_result = subprocess.run(
             ["git", "log", "--oneline", f"{base_branch}..HEAD"],
             capture_output=True,
-            text=True
+            text=True,
+            cwd=cwd
         )
 
         analysis = {

units/en/unit3/build-mcp-server.mdx

@@ -88,6 +88,7 @@ This is your first hands-on MCP development experience! Open `server.py` and imp
    - ⚠️ **Important**: You'll likely hit a token limit error (25,000 tokens max per response)
    - This is a real-world constraint that teaches proper output management
    - See the "Handling Large Outputs" section below for the solution
+   - ⚠️ **Note**: Git commands will run in the MCP server's directory by default. See "Working Directory Considerations" below for details
 2. **Implement `get_pr_templates`** to manage and return PR templates  
 3. **Implement `suggest_template`** to map change types to templates
 
@@ -254,6 +255,35 @@ async def analyze_file_changes(base_branch: str = "main",
 4. **Use progressive disclosure**: Start with high-level info, allow drilling down
 5. **Set sensible defaults**: Default to reasonable limits that work for most cases
 
+## Working Directory Considerations
+
+By default, MCP servers run commands in their installation directory, not in Claude's current working directory. This means your git commands might analyze the wrong repository! 
+
+To solve this, MCP provides [roots](https://modelcontextprotocol.io/docs/concepts/roots) - a way for clients to inform servers about relevant directories. Claude Code automatically provides its working directory as a root.
+
+Here's how to access it in your tool:
+
+```python
+@mcp.tool()
+async def analyze_file_changes(...):
+    # Get Claude's working directory from roots
+    context = mcp.get_context()
+    roots_result = await context.session.list_roots()
+    
+    # Extract the path from the FileUrl object
+    working_dir = roots_result.roots[0].uri.path
+    
+    # Use it for all git commands
+    result = subprocess.run(
+        ["git", "diff", "--name-status"],
+        capture_output=True,
+        text=True,
+        cwd=working_dir  # Run in Claude's directory!
+    )
+```
+
+This ensures your tools operate on the repository Claude is actually working with, not the MCP server's installation location.
+
 ## Troubleshooting
 
 - **Import errors**: Ensure you've run `uv sync`
@@ -262,6 +292,17 @@ async def analyze_file_changes(base_branch: str = "main",
 - **JSON errors**: All tools must return valid JSON strings
 - **Token limit exceeded**: This is expected with large diffs! Implement output limiting as shown above
 - **"Response too large" errors**: Add `max_diff_lines` parameter or set `include_diff=false`
+- **Git commands run in wrong directory**: MCP servers run in their installation directory by default, not Claude's working directory. To fix this, use [MCP roots](https://modelcontextprotocol.io/docs/concepts/roots) to access Claude's current directory:
+  ```python
+  # Get Claude's working directory from roots
+  context = mcp.get_context()
+  roots_result = await context.session.list_roots()
+  working_dir = roots_result.roots[0].uri.path  # FileUrl object has .path property
+  
+  # Use it in subprocess calls
+  subprocess.run(["git", "diff"], cwd=working_dir)
+  ```
+  Claude Code automatically provides its working directory as a root, allowing your MCP server to operate in the correct location.
 
 ## Next Steps