Update app.py

app.py

@@ -1,4 +1,7 @@
-from smolagents import CodeAgent, HfApiModel, tool
+from smolagents import CodeAgent, DuckDuckGoSearchTool, HfApiModel, load_tool, tool
+import datetime
+import requests
+import pytz
 import yaml
 import math
 from tools.final_answer import FinalAnswerTool
@@ -172,52 +175,101 @@ def udp_advisor(development_phase: str, team_size: int, project_complexity: str)
     
     return response
 
-# Setup agent
+@tool
+def get_current_time_in_timezone(timezone: str) -> str:
+    """A tool that fetches the current local time in a specified timezone.
+    
+    Args:
+        timezone: A string representing a valid timezone (e.g., 'America/New_York').
+    """
+    try:
+        # Create timezone object
+        tz = pytz.timezone(timezone)
+        # Get current time in that timezone
+        local_time = datetime.datetime.now(tz).strftime("%Y-%m-%d %H:%M:%S")
+        return f"The current local time in {timezone} is: {local_time}"
+    except Exception as e:
+        return f"Error fetching time for timezone '{timezone}': {str(e)}"
+
+@tool
+def search_udp_tool_reviews(tool_name: str) -> str:
+    """Searches for information and reviews about a specific UDP tool.
+    
+    Args:
+        tool_name: The name of the tool to search for (e.g., 'Kubernetes', 'Jira')
+    """
+    try:
+        # This is a placeholder - in a real application, you would implement 
+        # actual search functionality here using DuckDuckGoSearchTool
+        
+        common_tools = {
+            "github": "GitHub is widely regarded as one of the most popular version control and collaboration platforms. " +
+                      "Recent reviews praise its improved Actions feature for CI/CD pipelines, but note that complex " +
+                      "permissions management can be challenging for larger teams.",
+            
+            "gitlab": "GitLab receives positive reviews for its all-in-one DevOps platform approach. Users appreciate " +
+                     "the integrated CI/CD capabilities and built-in security scanning. Some reviews mention that the " +
+                     "interface can be overwhelming for beginners.",
+            
+            "kubernetes": "Kubernetes continues to be the leading container orchestration platform. Reviews highlight " +
+                         "its robust ecosystem and flexibility, though many note a steep learning curve. Enterprise " +
+                         "users praise its scalability while smaller teams sometimes find it overly complex.",
+            
+            "jenkins": "Jenkins remains a popular CI/CD tool with a large plugin ecosystem. Recent reviews mention " +
+                      "that while it's highly customizable, maintaining Jenkins installations can become complex over time. " +
+                      "Many organizations are considering cloud-native alternatives.",
+            
+            "terraform": "Terraform is widely praised for its infrastructure-as-code capabilities across multiple cloud providers. " +
+                        "Recent reviews highlight improved state management features, though some users note challenges with " +
+                        "complex dependency management in large infrastructures.",
+            
+            "jira": "Jira continues to be a leading project management tool for agile teams. Reviews appreciate its " +
+                   "customization options but sometimes criticize its complexity and learning curve. Recent updates " +
+                   "to the interface have received mixed feedback.",
+            
+            "docker": "Docker remains essential for containerization. Recent reviews praise its compatibility improvements " +
+                     "and simplified developer experience. Some enterprise users mention challenges with orchestration " +
+                     "at scale, often leading them to Kubernetes.",
+            
+            "azure devops": "Azure DevOps receives positive reviews for its integrated toolchain and strong integration " +
+                           "with Microsoft products. Users appreciate its CI/CD capabilities and built-in test management. " +
+                           "Some reviews mention that non-Microsoft workloads might require additional configuration."
+        }
+        
+        # Normalize the tool name for lookup
+        normalized_tool = tool_name.lower()
+        
+        if normalized_tool in common_tools:
+            return f"### Recent Reviews for {tool_name}\n\n{common_tools[normalized_tool]}\n\n" + \
+                   "This information is based on aggregated recent reviews and industry analysis."
+        else:
+            return f"No specific review information available for '{tool_name}'. " + \
+                   "This tool may be less commonly used or recently introduced to the market. " + \
+                   "Consider searching for specific features you need rather than tool names."
+            
+    except Exception as e:
+        return f"Error searching for information about '{tool_name}': {str(e)}"
+
+# Setup required tools
 final_answer = FinalAnswerTool()
+search_tool = DuckDuckGoSearchTool()
 
+# Setup language model
 model = HfApiModel(
     max_tokens=2096,
     temperature=0.5,
     model_id='Qwen/Qwen2.5-Coder-32B-Instruct'
 )
 
-# Configure templates for the UDP advisor
-udp_prompt_templates = {
-    "react-system": """You are a UDP (Unified Development Platform) advisor who helps users choose appropriate tools for their software development projects.
-You have access to the following tools:
-
-{tools_string}
-
-You should help the user determine which UDP tools are best for their project based on:
-1. The current development phase they are in (planning, development, testing, deployment, monitoring)
-2. The size of their development team
-3. The complexity of their project (low, medium, high)
-
-Use the udp_advisor tool to analyze these factors and provide tool recommendations.
-
-To use a tool, output an action in this format:
-```py
-action = tool_name(arg1=value1, arg2=value2, ...)
-```
-
-Always use Python syntax for calling tools. After using a tool, analyze the result to determine what to do next. Use final_answer to return your final answer.
-""",
-    "react-human": "{input_string}",
-    "react-assistant": "{agent_response}",
-    "final_answer": {
-        "pre_messages": "I'll provide you with UDP tool recommendations based on your project details.",
-        "template": "Final Answer: {answer}"
-    }
-}
-
-# Load prompt templates from file or use our templates
+# Try to load prompt templates from file
 try:
     with open("prompts.yaml", 'r') as stream:
         prompt_templates = yaml.safe_load(stream)
 except:
+    # If loading fails, create default templates
     prompt_templates = {}
 
-# Add our templates
+# Add our templates directly to ensure proper structure
 prompt_templates["react-system"] = """You are a UDP (Unified Development Platform) advisor who helps users choose appropriate tools for their software development projects.
 You have access to the following tools:
 
@@ -228,7 +280,7 @@ You should help the user determine which UDP tools are best for their project ba
 2. The size of their development team
 3. The complexity of their project (low, medium, high)
 
-Use the udp_advisor tool to analyze these factors and provide tool recommendations.
+You can also provide information about specific tools, search for reviews, and check the current time in different timezones to help with global team coordination.
 
 To use a tool, output an action in this format:
 ```py
@@ -241,14 +293,15 @@ prompt_templates["react-human"] = "{input_string}"
 prompt_templates["react-assistant"] = "{agent_response}"
 prompt_templates["final_answer"] = {
     "pre_messages": "I'll provide you with UDP tool recommendations based on your project details.",
-    "template": "Final Answer: {answer}"
+    "template": "Final Answer: {answer}",
+    "post_messages": "Is there anything else you'd like to know about these UDP tools or development practices?"
 }
 
-# Create the agent
+# Create the agent with all tools
 agent = CodeAgent(
     model=model,
-    tools=[final_answer, udp_advisor],
-    max_steps=3,
+    tools=[final_answer, udp_advisor, get_current_time_in_timezone, search_udp_tool_reviews, search_tool],
+    max_steps=6,
     verbosity_level=1,
     prompt_templates=prompt_templates
 )
@@ -260,34 +313,103 @@ class UDPAdvisorUI(GradioUI):
         
         with gr.Blocks(theme=gr.themes.Soft()) as demo:
             gr.Markdown("# UDP Advisor for Software Development")
-            gr.Markdown("Get personalized UDP tool recommendations based on your project profile")
+            gr.Markdown("Get personalized UDP tool recommendations and development information")
             
             with gr.Row():
                 with gr.Column():
-                    phase_input = gr.Radio(["Planning", "Development", "Testing", "Deployment", "Monitoring"], label="Development Phase")
-                    team_input = gr.Number(label="Team Size", minimum=1)
-                    complexity_input = gr.Radio(["Low", "Medium", "High"], label="Project Complexity")
-                    submit_btn = gr.Button("Get Recommendations", variant="primary")
+                    input_type = gr.Radio(
+                        ["Tool Recommendations", "Tool Reviews", "Timezone Check", "Free-form Question"], 
+                        label="What would you like help with?",
+                        value="Tool Recommendations"
+                    )
+                    
+                    # Tool recommendation inputs
+                    with gr.Group(visible=True) as recommendation_group:
+                        phase_input = gr.Radio(
+                            ["Planning", "Development", "Testing", "Deployment", "Monitoring"], 
+                            label="Development Phase"
+                        )
+                        team_input = gr.Number(label="Team Size", minimum=1, value=5)
+                        complexity_input = gr.Radio(
+                            ["Low", "Medium", "High"], 
+                            label="Project Complexity"
+                        )
+                    
+                    # Tool review input
+                    with gr.Group(visible=False) as review_group:
+                        tool_name_input = gr.Textbox(label="Tool Name", placeholder="Enter a tool name (e.g., Kubernetes, GitLab)")
+                    
+                    # Timezone input
+                    with gr.Group(visible=False) as timezone_group:
+                        timezone_input = gr.Textbox(label="Timezone", placeholder="Enter a timezone (e.g., America/New_York, Europe/London)")
+                    
+                    # Free-form question input
+                    with gr.Group(visible=False) as freeform_group:
+                        question_input = gr.Textbox(label="Your Question", placeholder="Ask anything about development tools or practices")
+                    
+                    submit_btn = gr.Button("Submit", variant="primary")
             
             with gr.Row():
                 with gr.Column():
-                    recommendation_output = gr.Markdown(label="UDP Recommendations")
+                    output = gr.Markdown(label="Response")
             
-            def get_recommendations(phase, team_size, complexity):
-                if not phase:
-                    return "Please select a development phase."
-                if not team_size or team_size < 1:
-                    return "Please provide a valid team size (at least 1)."
-                if not complexity:
-                    return "Please select a project complexity level."
+            # Logic to show/hide input groups based on selection
+            def update_visibility(choice):
+                return {
+                    recommendation_group: choice == "Tool Recommendations",
+                    review_group: choice == "Tool Reviews",
+                    timezone_group: choice == "Timezone Check",
+                    freeform_group: choice == "Free-form Question"
+                }
+            
+            input_type.change(
+                update_visibility,
+                inputs=[input_type],
+                outputs=[recommendation_group, review_group, timezone_group, freeform_group]
+            )
+            
+            # Process input based on type
+            def process_input(input_type, phase, team_size, complexity, tool_name, timezone, question):
+                if input_type == "Tool Recommendations":
+                    if not phase:
+                        return "Please select a development phase."
+                    if not team_size or team_size < 1:
+                        return "Please provide a valid team size (at least 1)."
+                    if not complexity:
+                        return "Please select a project complexity level."
+                    
+                    query = f"I need UDP tool recommendations for a project in the {phase.lower()} phase with a team of {int(team_size)} people and {complexity.lower()} complexity."
+                
+                elif input_type == "Tool Reviews":
+                    if not tool_name or tool_name.strip() == "":
+                        return "Please enter a tool name to search for reviews."
+                    
+                    query = f"What are the reviews and opinions about {tool_name.strip()}?"
+                
+                elif input_type == "Timezone Check":
+                    if not timezone or timezone.strip() == "":
+                        return "Please enter a timezone to check."
+                    
+                    query = f"What is the current time in {timezone.strip()}?"
+                
+                else:  # Free-form question
+                    if not question or question.strip() == "":
+                        return "Please enter your question."
+                    
+                    query = question
                 
+                # Process the query using the agent
                 try:
-                    recommendations = udp_advisor(phase.lower(), int(team_size), complexity.lower())
-                    return recommendations
+                    response = agent.run(query)
+                    return response
                 except Exception as e:
-                    return f"Error generating recommendations: {str(e)}"
+                    return f"Error processing request: {str(e)}"
             
-            submit_btn.click(get_recommendations, inputs=[phase_input, team_input, complexity_input], outputs=recommendation_output)
+            submit_btn.click(
+                process_input, 
+                inputs=[input_type, phase_input, team_input, complexity_input, tool_name_input, timezone_input, question_input], 
+                outputs=output
+            )
         
         demo.launch(**kwargs)