Update app.py

app.py

@@ -1,512 +1,159 @@
 import streamlit as st
 import os
-from transformers import pipeline, AutoTokenizer, AutoModelForCausalLM
-from langchain_community.llms import HuggingFacePipeline
-from langchain.agents import AgentType, initialize_agent, load_tools
-from langchain.memory import ConversationBufferMemory
-from crewai import Agent, Task, Crew, Process
-import warnings
-import json
 from datetime import datetime
 import logging
 import uuid
 import pytz
-import numexpr
+from typing import List, Dict
 
 # Configure logging
-logging.basicConfig(
-    level=logging.INFO,
-    format='%(asctime)s - %(name)s - %(levelname)s - %(message)s'
-)
+logging.basicConfig(level=logging.INFO)
 logger = logging.getLogger(__name__)
 
-# Suppress warnings
-warnings.filterwarnings('ignore')
-
-# Global variables for current user and time
+# Global variables
+CURRENT_UTC_TIME = datetime.strptime("2025-02-04 19:14:50", "%Y-%m-%d %H:%M:%S")
 CURRENT_USER = "ChadSaglam"
-CURRENT_UTC_TIME = datetime.strptime("2025-02-04 18:53:13", "%Y-%m-%d %H:%M:%S")
-
-# Cache the model loading
-@st.cache_resource
-def load_model():
-    try:
-        model_name = "EleutherAI/gpt-neo-125M"
-        tokenizer = AutoTokenizer.from_pretrained(model_name)
-        model = AutoModelForCausalLM.from_pretrained(model_name)
-        return tokenizer, model
-    except Exception as e:
-        st.error(f"Error loading model: {str(e)}")
-        return None, None
 
-# Initialize the LLM and tools at the module level
-def initialize_llm():
-    tokenizer, model = load_model()
-    if tokenizer is None or model is None:
-        st.error("Failed to initialize model")
-        return None
-    
-    llm_pipeline = pipeline(
-        "text-generation",
-        model=model,
-        tokenizer=tokenizer,
-        max_new_tokens=200,
-        temperature=0.7,
-        top_p=0.95,
-        repetition_penalty=1.15,
-        device="cpu"
-    )
-    
-    return HuggingFacePipeline(pipeline=llm_pipeline)
+class MeetingParticipant:
+    def __init__(self, role: str, department: str):
+        self.role = role
+        self.department = department
+        self.comments: List[str] = []
 
-def initialize_tools(llm):
-    try:
-        return load_tools(["llm-math"], llm=llm)
-    except ImportError as e:
-        st.error(f"Error loading tools: {str(e)}")
-        return []
-
-class ProjectCrew:
-    def __init__(self, project_name, project_type):
+class Meeting:
+    def __init__(self, meeting_type: str, project_name: str, project_type: str):
+        self.meeting_type = meeting_type
         self.project_name = project_name
         self.project_type = project_type
-        self.meeting_notes = []
-        self.tasks = {}
-        self.priorities = {}
-        self.created_by = CURRENT_USER
-        self.created_at = CURRENT_UTC_TIME
-        self.llm = llm_global
-        
-        # Initialize crew with dynamic name
-        self.crew = self._create_crew()
-    
-    def _create_crew(self):
-        crew_name = f"{self.project_type.lower()}_crew_{self.created_at.strftime('%Y%m%d')}"
-        return Crew(
-            agents=self._create_all_agents(),
-            tasks=self._initialize_tasks(),
-            manager_llm=self.llm,
-            process=Process.hierarchical,
-            verbose=True
-        )
-    
-    def _create_all_agents(self):
-        """Combine all teams into a single list of agents"""
-        return (
-            self._create_executive_team() +
-            self._create_product_team() +
-            self._create_engineering_team() +
-            self._create_qa_team()
-        )
-    
-    def _create_agent(self, role, goal, backstory):
-        return Agent(
-            role=role,
-            goal=goal,
-            backstory=backstory,
-            tools=tools,
-            verbose=True,
-            allow_delegation=True,
-            llm=self.llm
-        )
-    
-    def _create_executive_team(self):
-        return [
-            self._create_agent(
-                role="CEO",
-                goal="Define and execute company strategy",
-                backstory="Experienced leader with focus on growth"
-            ),
-            self._create_agent(
-                role="CTO",
-                goal="Technical strategy and architecture",
-                backstory="Technical leader with extensive experience"
-            ),
-            self._create_agent(
-                role="CPO",
-                goal="Product strategy and vision",
-                backstory="Product leader focused on user needs"
-            )
-        ]
-
-    def _create_product_team(self):
-        return [
-            self._create_agent(
-                role="Product Manager",
-                goal="Define and prioritize product features",
-                backstory="Experienced in product development and user needs"
-            ),
-            self._create_agent(
-                role="UX Designer",
-                goal="Create user-centered designs",
-                backstory="Expert in user experience and interface design"
-            )
-        ]
-
-    def _create_engineering_team(self):
-        return [
-            self._create_agent(
-                role="Engineering Manager",
-                goal="Lead technical implementation",
-                backstory="Technical leader with team management experience"
-            ),
-            self._create_agent(
-                role="Senior Engineer",
-                goal="Implement complex features",
-                backstory="Experienced in software architecture"
-            ),
-            self._create_agent(
-                role="Frontend Engineer",
-                goal="Implement user interfaces",
-                backstory="Expert in frontend technologies"
-            ),
-            self._create_agent(
-                role="Backend Engineer",
-                goal="Implement server-side features",
-                backstory="Expert in backend technologies"
-            )
-        ]
-
-    def _create_qa_team(self):
-        return [
-            self._create_agent(
-                role="QA Lead",
-                goal="Ensure product quality",
-                backstory="Expert in quality assurance"
-            ),
-            self._create_agent(
-                role="QA Engineer",
-                goal="Test and validate features",
-                backstory="Experienced in software testing"
-            )
-        ]
-
-    def _initialize_tasks(self):
-        return []  # Initialize with empty task list
-
-class TaskManagementSystem:
-    def __init__(self):
-        self.priorities = {
-            "P0": "Critical - Must be done immediately",
-            "P1": "High - Must be done this sprint",
-            "P2": "Medium - Should be done this sprint",
-            "P3": "Low - Nice to have"
-        }
+        self.date = CURRENT_UTC_TIME
+        self.participants = self._initialize_participants()
+        self.discussion_points: List[str] = []
+        self.action_items: List[Dict] = []
         
-        self.task_types = {
-            "FEATURE": "New feature development",
-            "BUG": "Bug fix",
-            "TECH_DEBT": "Technical debt",
-            "IMPROVEMENT": "Improvement to existing feature"
-        }
-        
-        self.departments = {
-            "ENGINEERING": ["Backend", "Frontend", "DevOps"],
-            "PRODUCT": ["Design", "Product Management"],
-            "QA": ["Testing", "Automation"],
-            "MANAGEMENT": ["Executive", "Team Lead"]
-        }
-
-    def create_sprint_tasks(self, meeting_output):
-        sprint_tasks = []
-        
-        for item in meeting_output["action_items"]:
-            task = {
-                "id": str(uuid.uuid4()),
-                "title": item["title"],
-                "description": item["description"],
-                "assignee": {
-                    "name": item["assignee"],
-                    "department": self._get_department(item.get("assignee_role", "Unknown")),
-                    "role": item.get("assignee_role", "Unknown")
-                },
-                "priority": item["priority"],
-                "type": item["task_type"],
-                "estimated_hours": item["estimated_hours"],
-                "due_date": item["due_date"],
-                "dependencies": item.get("dependencies", []),
-                "subtasks": self._create_subtasks(item),
-                "acceptance_criteria": item["acceptance_criteria"],
-                "resources_needed": item.get("resources_needed", []),
-                "status": "TO_DO",
-                "progress": 0,
-                "reviews_required": self._get_required_reviews(item),
-                "created_by": CURRENT_USER,
-                "created_at": CURRENT_UTC_TIME,
-                "updated_at": CURRENT_UTC_TIME,
-                "tags": item.get("tags", []),
-                "related_documents": item.get("related_documents", [])
-            }
-            
-            sprint_tasks.append(task)
-            
-        return sprint_tasks
-
-    def _get_department(self, role):
-        for dept, roles in self.departments.items():
-            if any(r in role for r in roles):
-                return dept
-        return "UNKNOWN"
-
-    def _create_subtasks(self, task_item):
-        subtasks = []
-        if "subtasks" in task_item:
-            for subtask in task_item["subtasks"]:
-                subtask_obj = {
-                    "id": str(uuid.uuid4()),
-                    "title": subtask["title"],
-                    "description": subtask["description"],
-                    "assignee": subtask["assignee"],
-                    "status": "TO_DO",
-                    "estimated_hours": subtask["estimated_hours"],
-                    "dependencies": subtask.get("dependencies", []),
-                    "created_by": CURRENT_USER,
-                    "created_at": CURRENT_UTC_TIME
-                }
-                subtasks.append(subtask_obj)
-        return subtasks
-
-    def _get_required_reviews(self, task_item):
-        reviews = {
-            "code_review": {
-                "required": True if task_item["type"] in ["FEATURE", "BUG", "TECH_DEBT"] else False,
-                "reviewers": []
-            },
-            "design_review": {
-                "required": True if task_item["type"] == "FEATURE" else False,
-                "reviewers": []
-            },
-            "qa_review": {
-                "required": True,
-                "reviewers": []
-            }
-        }
-        return reviews
-
-    def generate_sprint_report(self, tasks):
+    def _initialize_participants(self) -> Dict[str, MeetingParticipant]:
         return {
-            "sprint_summary": {
-                "total_tasks": len(tasks),
-                "completed_tasks": len([t for t in tasks if t["status"] == "DONE"]),
-                "in_progress": len([t for t in tasks if t["status"] == "IN_PROGRESS"]),
-                "blocked": len([t for t in tasks if t["status"] == "BLOCKED"]),
-                "total_hours": sum(t["estimated_hours"] for t in tasks)
-            },
-            "priority_breakdown": self._get_priority_breakdown(tasks),
-            "department_breakdown": self._get_department_breakdown(tasks),
-            "risk_assessment": self._assess_risks(tasks),
-            "recommendations": self._generate_recommendations(tasks)
+            "CEO": MeetingParticipant("CEO", "Executive"),
+            "CTO": MeetingParticipant("CTO", "Executive"),
+            "CPO": MeetingParticipant("CPO", "Executive"),
+            "Engineering Manager": MeetingParticipant("Engineering Manager", "Engineering"),
+            "Product Manager": MeetingParticipant("Product Manager", "Product")
         }
 
-    def _get_priority_breakdown(self, tasks):
-        breakdown = {"P0": 0, "P1": 0, "P2": 0, "P3": 0}
-        for task in tasks:
-            breakdown[task["priority"]] += 1
-        return breakdown
-
-    def _get_department_breakdown(self, tasks):
-        breakdown = {dept: 0 for dept in self.departments.keys()}
-        for task in tasks:
-            dept = task["assignee"]["department"]
-            breakdown[dept] = breakdown.get(dept, 0) + 1
-        return breakdown
-
-    def _assess_risks(self, tasks):
-        risks = []
+def simulate_sprint_planning():
+    discussion = [
+        ("CEO", "Our goal this quarter is to increase user engagement by 25%."),
+        ("CPO", "We should focus on improving the user interface and adding personalization features."),
+        ("CTO", "We'll need to optimize our backend services to handle increased traffic."),
+        ("Engineering Manager", "We can split the work into frontend improvements and backend optimization."),
+        ("Product Manager", "Let's prioritize the shopping cart experience and recommendation engine.")
+    ]
+    
+    tasks = [
+        {
+            "id": str(uuid.uuid4()),
+            "title": "Implement Personalized Product Recommendations",
+            "owner": "Engineering Team",
+            "priority": "P1",
+            "description": "Develop AI-powered recommendation engine for product suggestions",
+            "subtasks": [
+                "Design recommendation algorithm",
+                "Implement data collection pipeline",
+                "Create API endpoints",
+                "Add frontend components"
+            ],
+            "estimated_hours": 80,
+            "dependencies": [],
+            "status": "TO_DO"
+        },
+        {
+            "id": str(uuid.uuid4()),
+            "title": "Optimize Shopping Cart Experience",
+            "owner": "Product Team",
+            "priority": "P0",
+            "description": "Improve cart UI/UX and add one-click checkout",
+            "subtasks": [
+                "Redesign cart interface",
+                "Implement quick checkout flow",
+                "Add saved payment methods",
+                "Optimize mobile experience"
+            ],
+            "estimated_hours": 60,
+            "dependencies": [],
+            "status": "TO_DO"
+        }
+    ]
+    
+    return discussion, tasks
+
+def simulate_daily_standup():
+    discussion = [
+        ("Engineering Manager", "Yesterday we completed the basic recommendation engine setup."),
+        ("Product Manager", "The new cart design mockups are ready for review."),
+        ("CTO", "Any blocking issues we need to address?"),
+        ("Engineering Manager", "We need more test data for the recommendation engine."),
+        ("Product Manager", "Waiting for feedback on the checkout flow from the UX team.")
+    ]
+    return discussion
+
+def simulate_retrospective():
+    discussion = [
+        ("CPO", "What went well in this sprint?"),
+        ("Engineering Manager", "Team completed all high-priority tasks on time."),
+        ("Product Manager", "User feedback on new features has been positive."),
+        ("CTO", "What could we improve?"),
+        ("Engineering Manager", "We need better test coverage for new features.")
+    ]
+    return discussion
+
+def display_meeting(meeting_type: str):
+    st.header(f"{meeting_type} - E-commerce Platform (Website)")
+    st.subheader("Meeting Details")
+    st.write(f"Date: {CURRENT_UTC_TIME.strftime('%Y-%m-%d %H:%M:%S UTC')}")
+    st.write(f"Project: E-commerce Platform")
+    st.write(f"Type: Website")
+    
+    if meeting_type == "Sprint Planning":
+        discussion, tasks = simulate_sprint_planning()
+        
+        st.subheader("Discussion")
+        for role, comment in discussion:
+            st.write(f"**{role}**: {comment}")
+        
+        st.subheader("Sprint Tasks")
         for task in tasks:
-            if task["priority"] in ["P0", "P1"] and task["status"] != "DONE":
-                risks.append({
-                    "task_id": task["id"],
-                    "title": task["title"],
-                    "risk_level": "HIGH" if task["priority"] == "P0" else "MEDIUM",
-                    "reason": "High priority task not completed"
-                })
-        return risks
-
-    def _generate_recommendations(self, tasks):
-        recommendations = []
-        priority_breakdown = self._get_priority_breakdown(tasks)
-        
-        if priority_breakdown["P0"] > 3:
-            recommendations.append("Too many critical tasks. Consider re-evaluating priorities.")
-        
-        blocked_tasks = [t for t in tasks if t["status"] == "BLOCKED"]
-        if blocked_tasks:
-            recommendations.append(f"Address {len(blocked_tasks)} blocked tasks to improve sprint velocity.")
-        
-        return recommendations
-
-def create_meeting_ui(project):
-    st.subheader("Meeting Notes")
-    attendees = st.multiselect("Attendees", ["CEO", "CTO", "CPO", "Engineering Team", "Product Team"])
-    agenda = st.text_area("Agenda")
-    decisions = st.text_area("Decisions")
-    
-    st.subheader("Action Items")
-    action_items = []
-    
-    num_items = st.number_input("Number of Action Items", min_value=1, value=1)
-    
-    for i in range(int(num_items)):
-        with st.expander(f"Action Item {i+1}"):
-            action_item = create_action_item_ui(i)
-            action_items.append(action_item)
-    
-    if st.button("Generate Tasks"):
-        task_system = TaskManagementSystem()
-        tasks = task_system.create_sprint_tasks({"action_items": action_items})
-        st.session_state.tasks = tasks
-        st.success(f"Generated {len(tasks)} tasks successfully!")
-
-def create_action_item_ui(index):
-    return {
-        "title": st.text_input(f"Title #{index+1}"),
-        "description": st.text_area(f"Description #{index+1}"),
-        "assignee": st.selectbox(f"Assignee #{index+1}", ["CEO", "CTO", "CPO", "Engineer 1", "Engineer 2"]),
-        "priority": st.selectbox(f"Priority #{index+1}", ["P0", "P1", "P2", "P3"]),
-        "due_date": st.date_input(f"Due Date #{index+1}"),
-        "task_type": st.selectbox(f"Task Type #{index+1}", ["FEATURE", "BUG", "TECH_DEBT", "IMPROVEMENT"]),
-        "estimated_hours": st.number_input(f"Estimated Hours #{index+1}", min_value=1),
-        "acceptance_criteria": st.text_area(f"Acceptance Criteria #{index+1}"),
-        "dependencies": st.multiselect(f"Dependencies #{index+1}", ["Task A", "Task B", "Task C"]),
-    }
-
-def display_tasks_ui(project):
-    if "tasks" in st.session_state:
-        for task in st.session_state.tasks:
             with st.expander(f"Task: {task['title']}"):
-                st.write(f"**Assignee:** {task['assignee']['name']}")
+                st.write(f"**Owner:** {task['owner']}")
                 st.write(f"**Priority:** {task['priority']}")
-                st.write(f"**Due Date:** {task['due_date']}")
                 st.write(f"**Description:** {task['description']}")
+                st.write(f"**Estimated Hours:** {task['estimated_hours']}")
+                st.write("**Subtasks:**")
+                for subtask in task['subtasks']:
+                    st.write(f"- {subtask}")
                 
-                if task['subtasks']:
-                    st.subheader("Subtasks")
-                    for subtask in task['subtasks']:
-                        st.write(f"- {subtask['title']}")
-
-def display_reports_ui(project):
-    if "tasks" in st.session_state:
-        task_system = TaskManagementSystem()
-        report = task_system.generate_sprint_report(st.session_state.tasks)
-        
-        st.subheader("Sprint Summary")
-        col1, col2, col3, col4 = st.columns(4)
-        
-        with col1:
-            st.metric("Total Tasks", report["sprint_summary"]["total_tasks"])
-        with col2:
-            st.metric("Completed", report["sprint_summary"]["completed_tasks"])
-        with col3:
-            st.metric("In Progress", report["sprint_summary"]["in_progress"])
-        with col4:
-            st.metric("Blocked", report["sprint_summary"]["blocked"])
-        
-        st.subheader("Priority Breakdown")
-        st.bar_chart(report["priority_breakdown"])
-        
-        st.subheader("Department Distribution")
-        st.bar_chart(report["department_breakdown"])
-        
-        st.subheader("Risk Assessment")
-        risks = report["risk_assessment"]
-        if risks:
-            for risk in risks:
-                with st.expander(f"Risk: {risk['title']}"):
-                    st.write(f"**Risk Level:** {risk['risk_level']}")
-                    st.write(f"**Reason:** {risk['reason']}")
-        else:
-            st.success("No high-risk items identified")
-        
-        # Recommendations
-        st.subheader("Recommendations")
-        for rec in report["recommendations"]:
-            st.info(rec)
-        
-        # Export Options
-        st.subheader("Export Report")
-        report_json = json.dumps(report, indent=2, default=str)
-        st.download_button(
-            label="Download Report (JSON)",
-            data=report_json,
-            file_name=f"sprint_report_{CURRENT_UTC_TIME.strftime('%Y%m%d_%H%M%S')}.json",
-            mime="application/json"
-        )
+    elif meeting_type == "Daily Standup":
+        discussion = simulate_daily_standup()
+        st.subheader("Updates")
+        for role, update in discussion:
+            st.write(f"**{role}**: {update}")
+            
+    elif meeting_type == "Retrospective":
+        discussion = simulate_retrospective()
+        st.subheader("Discussion Points")
+        for role, point in discussion:
+            st.write(f"**{role}**: {point}")
 
 def main():
-    st.set_page_config(page_title="AI Project Management", layout="wide")
+    st.set_page_config(page_title="E-commerce Platform Meetings", layout="wide")
     
-    # Display current user and time
     st.sidebar.info(f"Current User: {CURRENT_USER}")
     st.sidebar.info(f"Current Time (UTC): {CURRENT_UTC_TIME.strftime('%Y-%m-%d %H:%M:%S')}")
     
-    # Initialize LLM
-    llm = initialize_llm()
-    if llm is None:
-        st.error("Failed to initialize the application")
-        return
-    
-    # Initialize tools
-    global tools
-    tools = initialize_tools(llm)
-    if not tools:
-        st.warning("Some tools failed to initialize. Limited functionality available.")
-    
-    # Set global LLM
-    global llm_global
-    llm_global = llm
-    
-    # Project Setup
-    with st.sidebar:
-        project_name = st.text_input("Project Name", "E-commerce Platform")
-        project_type = st.selectbox("Project Type", ["E-commerce", "SaaS", "Mobile App", "Enterprise"])
+    meeting_type = st.selectbox(
+        "Select Meeting Type",
+        ["Sprint Planning", "Daily Standup", "Retrospective"]
+    )
     
-    try:
-        # Initialize Project Crew
-        project = ProjectCrew(project_name, project_type)
-        
-        # Main content tabs
-        tab1, tab2, tab3 = st.tabs(["Meeting Management", "Task Management", "Reports"])
-        
-        with tab1:
-            st.header("Meeting Management")
-            meeting_type = st.selectbox("Meeting Type", ["Sprint Planning", "Daily Standup", "Retrospective"])
-            
-            if st.button("Start Meeting"):
-                create_meeting_ui(project)
-        
-        with tab2:
-            st.header("Task Management")
-            display_tasks_ui(project)
-        
-        with tab3:
-            st.header("Reports")
-            display_reports_ui(project)
-            
-    except Exception as e:
-        st.error(f"An error occurred: {str(e)}")
-        logger.exception("Error in main application flow")
+    display_meeting(meeting_type)
 
 if __name__ == "__main__":
-    try:
-        # Set timezone and current time
-        CURRENT_UTC_TIME = datetime.strptime("2025-02-04 19:05:18", "%Y-%m-%d %H:%M:%S")
-        CURRENT_USER = "ChadSaglam"
-        
-        # Initialize session state if not exists
-        if 'tasks' not in st.session_state:
-            st.session_state.tasks = []
-        
-        if 'project' not in st.session_state:
-            st.session_state.project = None
-        
-        # Initialize global variables
-        global llm
-        global tools
-        global llm_global
-        
-        main()
-        
-    except Exception as e:
-        st.error("Application failed to start")
-        logger.exception("Fatal error in application startup")
+    main()