first build attempt

crews/code_review_crew/code_review_crew.py

@@ -1,19 +1,21 @@
-from crewai import CrewBase, Agent, Task, Crew
+from crewai import Agent, Task, Crew
+from crewai.project import CrewBase, agent, task, crew
 from crewai_tools import MCPServerAdapter
 from mcp import StdioServerParameters
 import os
 from typing import Dict, Any
+from pr_reviewer.llm import get_llm
 
 
-class CodeReviewCrew(CrewBase):
+@CrewBase
+class CodeReviewCrew:
     """Code Review Crew for conducting code quality reviews."""
     
     agents_config = "config/agents.yaml"
     tasks_config = "config/tasks.yaml"
 
     def __init__(self):
-        super().__init__()
-        # Configure Semgrep MCP server connection
+        self.llm = get_llm()
         self.semgrep_server_params = StdioServerParameters(
             command="semgrep",
             args=["--metrics=off", "--json", "--stdin-display-name", "scanned_code", "--"],
@@ -24,32 +26,38 @@ class CodeReviewCrew(CrewBase):
             }
         )
 
-    @Agent
+    @agent
     def code_reviewer(self) -> Agent:
         """Senior Software Engineer agent for code review."""
         return Agent(
             config=self.agents_config["code_reviewer"],
-            tools=[],  # Tools will be added via MCP adapter in the task
+            llm=self.llm,
+            tools=[],
             verbose=True
         )
 
-    @Task
+    @task
     def code_review_task(self) -> Task:
         """Task for conducting code review."""
         return Task(
             config=self.tasks_config["code_review_task"],
         )
 
-    @Crew
+    @crew
     def crew(self) -> Crew:
         """Create the Code Review crew."""
-        # Create MCP server adapter for Semgrep
-        semgrep_adapter = MCPServerAdapter(self.semgrep_server_params)
+        tools = []
+        try:
+            semgrep_adapter = MCPServerAdapter(self.semgrep_server_params)
+            if hasattr(semgrep_adapter, 'tools'):
+                tools = semgrep_adapter.tools
+        except Exception as e:
+            print(f"MCP adapter not available: {e}")
         
         return Crew(
             agents=[self.code_reviewer()],
             tasks=[self.code_review_task()],
             process="sequential",
             verbose=True,
-            tools=semgrep_adapter.tools if hasattr(semgrep_adapter, 'tools') else [],
+            tools=tools,
         )

crews/infra_review_crew/infra_review_crew.py

@@ -1,60 +1,65 @@
-from crewai import CrewBase, Agent, Task, Crew
+from crewai import Agent, Task, Crew
+from crewai.project import CrewBase, agent, task, crew
 from crewai_tools import MCPServerAdapter
 from mcp import StdioServerParameters
 import os
 from typing import Dict, Any
+from pr_reviewer.llm import get_llm
 
 
-class InfraReviewCrew(CrewBase):
+@CrewBase
+class InfraReviewCrew:
     """Infrastructure Review Crew for conducting infrastructure reviews."""
     
     agents_config = "config/agents.yaml"
     tasks_config = "config/tasks.yaml"
 
     def __init__(self):
-        super().__init__()
-        # Configure Hadolint MCP server connection
+        self.llm = get_llm()
         self.hadolint_server_params = StdioServerParameters(
             command="python",
-            args=["/home/armistace/dev/pr_reviewer/mcp_servers/hadolint_mcp.py"],
+            args=["/app/mcp_servers/hadolint_mcp.py"],
             env=os.environ
         )
-        # Configure Checkov MCP server connection
         self.checkov_server_params = StdioServerParameters(
             command="python",
-            args=["/home/armistace/dev/pr_reviewer/mcp_servers/checkov_mcp.py"],
+            args=["/app/mcp_servers/checkov_mcp.py"],
             env=os.environ
         )
 
-    @Agent
+    @agent
     def infra_reviewer(self) -> Agent:
         """DevOps/Platform Engineer agent for infrastructure review."""
         return Agent(
             config=self.agents_config["infra_reviewer"],
-            tools=[],  # Tools will be added via MCP adapter in the task
+            llm=self.llm,
+            tools=[],
             verbose=True
         )
 
-    @Task
+    @task
     def infra_review_task(self) -> Task:
         """Task for conducting infrastructure review."""
         return Task(
             config=self.tasks_config["infra_review_task"],
         )
 
-    @Crew
+    @crew
     def crew(self) -> Crew:
         """Create the Infrastructure Review crew."""
-        # Create MCP server adapters for Hadolint and Checkov
-        hadolint_adapter = MCPServerAdapter(self.hadolint_server_params)
-        checkov_adapter = MCPServerAdapter(self.checkov_server_params)
-        
-        # Combine tools from both adapters
         all_tools = []
-        if hasattr(hadolint_adapter, 'tools'):
-            all_tools.extend(hadolint_adapter.tools)
-        if hasattr(checkov_adapter, 'tools'):
-            all_tools.extend(checkov_adapter.tools)
+        try:
+            hadolint_adapter = MCPServerAdapter(self.hadolint_server_params)
+            if hasattr(hadolint_adapter, 'tools'):
+                all_tools.extend(hadolint_adapter.tools)
+        except Exception as e:
+            print(f"Hadolint MCP adapter not available: {e}")
+        try:
+            checkov_adapter = MCPServerAdapter(self.checkov_server_params)
+            if hasattr(checkov_adapter, 'tools'):
+                all_tools.extend(checkov_adapter.tools)
+        except Exception as e:
+            print(f"Checkov MCP adapter not available: {e}")
         
         return Crew(
             agents=[self.infra_reviewer()],

crews/security_review_crew/security_review_crew.py

@@ -1,41 +1,41 @@
-from crewai import CrewBase, Agent, Task, Crew
+from crewai import Agent, Task, Crew
+from crewai.project import CrewBase, agent, task, crew
 from crewai_tools import MCPServerAdapter
 from mcp import StdioServerParameters
 import os
 from typing import Dict, Any
+from pr_reviewer.llm import get_llm
 
 
-class SecurityReviewCrew(CrewBase):
+@CrewBase
+class SecurityReviewCrew:
     """Security Review Crew for conducting security reviews."""
     
     agents_config = "config/agents.yaml"
     tasks_config = "config/tasks.yaml"
 
     def __init__(self):
-        super().__init__()
-        # Trivy uses native MCP server, so we don't need to configure a wrapper.
-        # However, we might need to set up connection parameters if required by the native server.
-        # For now, we assume the native Trivy MCP server is available at a known address or via stdio.
-        # We'll leave the MCP server configuration empty and rely on the native server being available.
-        self.trivy_server_params = None  # Placeholder for if we need to configure stdio parameters
+        self.llm = get_llm()
+        self.trivy_server_params = None
 
-    @Agent
+    @agent
     def security_reviewer(self) -> Agent:
         """Application Security Engineer agent for security review."""
         return Agent(
             config=self.agents_config["security_reviewer"],
-            tools=[],  # Tools will be added via MCP adapter in the task
+            llm=self.llm,
+            tools=[],
             verbose=True
         )
 
-    @Task
+    @task
     def security_review_task(self) -> Task:
         """Task for conducting security review."""
         return Task(
             config=self.tasks_config["security_review_task"],
         )
 
-    @Crew
+    @crew
     def crew(self) -> Crew:
         """Create the Security Review crew."""
         # If we had an MCP server to wrap, we would create an adapter here.

crews/summariser_crew/summariser_crew.py

@@ -1,37 +1,40 @@
-from crewai import CrewBase, Agent, Task, Crew
+from crewai import Agent, Task, Crew
+from crewai.project import CrewBase, agent, task, crew
 from crewai_tools import MCPServerAdapter
 from mcp import StdioServerParameters
 import os
 from typing import Dict, Any
+from pr_reviewer.llm import get_llm
 
 
-class SummariserCrew(CrewBase):
+@CrewBase
+class SummariserCrew:
     """Summariser Crew for synthesizing review results."""
     
     agents_config = "config/agents.yaml"
     tasks_config = "config/tasks.yaml"
 
     def __init__(self):
-        super().__init__()
-        # The summarizer doesn't need MCP server connections as it works with text results
+        self.llm = get_llm()
 
-    @Agent
+    @agent
     def summariser(self) -> Agent:
         """Senior Code Review Coordinator agent for summarizing reviews."""
         return Agent(
             config=self.agents_config["summariser"],
-            tools=[],  # No tools needed for summarization
+            llm=self.llm,
+            tools=[],
             verbose=True
         )
 
-    @Task
+    @task
     def summarise_task(self) -> Task:
         """Task for synthesizing review results."""
         return Task(
             config=self.tasks_config["summarise_task"],
         )
 
-    @Crew
+    @crew
     def crew(self) -> Crew:
         """Create the Summariser crew."""
         return Crew(