Merge branch 'feature/anthropic-course-units' of https://github.com/zealoushacker/mcp-course into pr/50

Author: burtenshaw

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

@@ -22,61 +22,122 @@
 @mcp.tool()
 async def analyze_file_changes(
     base_branch: str = "main",
-    include_diff: bool = True
+    include_diff: bool = True,
+    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
         diff_content = ""
+        truncated = False
         if include_diff:
             diff_result = subprocess.run(
                 ["git", "diff", f"{base_branch}...HEAD"],
                 capture_output=True,
-                text=True
+                text=True,
+                cwd=cwd
             )
-            diff_content = diff_result.stdout
+            diff_lines = diff_result.stdout.split('\n')
+            
+            # Check if we need to truncate
+            if len(diff_lines) > max_diff_lines:
+                diff_content = '\n'.join(diff_lines[:max_diff_lines])
+                diff_content += f"\n\n... Output truncated. Showing {max_diff_lines} of {len(diff_lines)} lines ..."
+                diff_content += "\n... Use max_diff_lines parameter to see more ..."
+                truncated = True
+            else:
+                diff_content = diff_result.stdout
 
         # Get commit messages for context
         commits_result = subprocess.run(
             ["git", "log", "--oneline", f"{base_branch}..HEAD"],
             capture_output=True,
-            text=True
+            text=True,
+            cwd=cwd
         )
 
         analysis = {
             "base_branch": base_branch,
             "files_changed": files_result.stdout,
             "statistics": stat_result.stdout,
             "commits": commits_result.stdout,
-            "diff": diff_content if include_diff else "Diff not included (set include_diff=true to see full diff)"
+            "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,
+            "_debug": debug_info
         }
 
         return json.dumps(analysis, indent=2)
 
     except subprocess.CalledProcessError as e:
-        return f"Error analyzing changes: {e.stderr}"
+        return json.dumps({"error": f"Git error: {e.stderr}"})
     except Exception as e:
-        return f"Error: {str(e)}"
+        return json.dumps({"error": str(e)})
 
 
 @mcp.tool()

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

@@ -71,6 +71,40 @@ async def test_includes_required_fields(self):
             else:
                 # Starter code - just verify it returns something structured
                 assert isinstance(data, dict), "Should return a JSON object even if not implemented"
+    
+    @pytest.mark.asyncio
+    async def test_output_limiting(self):
+        """Test that large diffs are properly truncated."""
+        with patch('subprocess.run') as mock_run:
+            # Create a mock diff with many lines
+            large_diff = "\n".join([f"+ line {i}" for i in range(1000)])
+            
+            # Set up mock responses
+            mock_run.side_effect = [
+                MagicMock(stdout="M\tfile1.py\n", stderr=""),  # files changed
+                MagicMock(stdout="1 file changed, 1000 insertions(+)", stderr=""),  # stats
+                MagicMock(stdout=large_diff, stderr=""),  # diff
+                MagicMock(stdout="abc123 Initial commit", stderr="")  # commits
+            ]
+            
+            # Test with default limit (500 lines)
+            result = await analyze_file_changes(include_diff=True)
+            data = json.loads(result)
+            
+            # Check if it's implemented
+            if "error" not in data or "Not implemented" not in str(data.get("error", "")):
+                if "diff" in data and data["diff"] != "Diff not included (set include_diff=true to see full diff)":
+                    diff_lines = data["diff"].split('\n')
+                    # Should be truncated to around 500 lines plus truncation message
+                    assert len(diff_lines) < 600, "Large diffs should be truncated"
+                    
+                    # Check for truncation indicator
+                    if "truncated" in data:
+                        assert data["truncated"] == True, "Should indicate truncation"
+                    
+                    # Should have truncation message
+                    assert "truncated" in data["diff"].lower() or "..." in data["diff"], \
+                        "Should indicate diff was truncated"
 
 
 @pytest.mark.skipif(not IMPORTS_SUCCESSFUL, reason="Imports failed")

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

@@ -42,6 +42,19 @@ async def analyze_file_changes(base_branch: str = "main", include_diff: bool = T
         include_diff: Include the full diff content (default: true)
     """
     # TODO: Implement this tool
+    # IMPORTANT: MCP tools have a 25,000 token response limit!
+    # Large diffs can easily exceed this. Consider:
+    # - 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

@@ -22,66 +22,101 @@
 EVENTS_FILE = Path(__file__).parent / "github_events.json"
 
 
-# ===== Original Tools from Module 1 =====
+# ===== Original Tools from Module 1 (with output limiting) =====
 
 @mcp.tool()
 async def analyze_file_changes(
     base_branch: str = "main",
-    include_diff: bool = True
+    include_diff: bool = True,
+    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
         diff_content = ""
+        truncated = False
         if include_diff:
             diff_result = subprocess.run(
                 ["git", "diff", f"{base_branch}...HEAD"],
                 capture_output=True,
-                text=True
+                text=True,
+                cwd=cwd
             )
-            diff_content = diff_result.stdout
+            diff_lines = diff_result.stdout.split('\n')
+            
+            # Check if we need to truncate
+            if len(diff_lines) > max_diff_lines:
+                diff_content = '\n'.join(diff_lines[:max_diff_lines])
+                diff_content += f"\n\n... Output truncated. Showing {max_diff_lines} of {len(diff_lines)} lines ..."
+                diff_content += "\n... Use max_diff_lines parameter to see more ..."
+                truncated = True
+            else:
+                diff_content = diff_result.stdout
 
         # Get commit messages for context
         commits_result = subprocess.run(
             ["git", "log", "--oneline", f"{base_branch}..HEAD"],
             capture_output=True,
-            text=True
+            text=True,
+            cwd=cwd
         )
 
         analysis = {
             "base_branch": base_branch,
             "files_changed": files_result.stdout,
             "statistics": stat_result.stdout,
             "commits": commits_result.stdout,
-            "diff": diff_content if include_diff else "Diff not included (set include_diff=true to see full diff)"
+            "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
         }
 
         return json.dumps(analysis, indent=2)
 
     except subprocess.CalledProcessError as e:
-        return f"Error analyzing changes: {e.stderr}"
+        return json.dumps({"error": f"Git error: {e.stderr}"})
     except Exception as e:
-        return f"Error: {str(e)}"
+        return json.dumps({"error": str(e)})
 
 
 @mcp.tool()

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

@@ -23,18 +23,20 @@
 # Hint: EVENTS_FILE = Path(__file__).parent / "github_events.json"
 
 
-# ===== Module 1 Tools (Keep these as-is) =====
+# ===== Module 1 Tools (Already includes output limiting fix from Module 1) =====
 
 @mcp.tool()
 async def analyze_file_changes(
     base_branch: str = "main",
-    include_diff: bool = True
+    include_diff: bool = True,
+    max_diff_lines: int = 500
 ) -> 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)
     """
     try:
         # Get list of changed files
@@ -54,13 +56,23 @@ async def analyze_file_changes(
 
         # Get the actual diff if requested
         diff_content = ""
+        truncated = False
         if include_diff:
             diff_result = subprocess.run(
                 ["git", "diff", f"{base_branch}...HEAD"],
                 capture_output=True,
                 text=True
             )
-            diff_content = diff_result.stdout
+            diff_lines = diff_result.stdout.split('\n')
+            
+            # Check if we need to truncate (learned from Module 1)
+            if len(diff_lines) > max_diff_lines:
+                diff_content = '\n'.join(diff_lines[:max_diff_lines])
+                diff_content += f"\n\n... Output truncated. Showing {max_diff_lines} of {len(diff_lines)} lines ..."
+                diff_content += "\n... Use max_diff_lines parameter to see more ..."
+                truncated = True
+            else:
+                diff_content = diff_result.stdout
 
         # Get commit messages for context
         commits_result = subprocess.run(
@@ -74,7 +86,9 @@ async def analyze_file_changes(
             "files_changed": files_result.stdout,
             "statistics": stat_result.stdout,
             "commits": commits_result.stdout,
-            "diff": diff_content if include_diff else "Diff not included (set include_diff=true to see full diff)"
+            "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
         }
 
         return json.dumps(analysis, indent=2)