QA Agentic Workflows Guide

import ollama
import os

class QAChatAgent:
    """Simple chat agent for QA questions"""
    
    def __init__(self, model="llama3.2:3b"):
        self.model = model
        self.context = self._load_context()
    
    def _load_context(self):
        """Load your QA knowledge base"""
        return """
        You are a helpful QA assistant. You help with:
        - Test case generation
        - Bug analysis
        - Testing best practices
        - Code review questions
        - Daily QA workflows
        """
    
    def ask(self, question):
        """Ask the agent a question"""
        prompt = f"{self.context}\n\nQuestion: {question}\n\nAnswer:"
        
        response = ollama.generate(
            model=self.model,
            prompt=prompt
        )
        
        return response['response']
    
    def chat(self):
        """Interactive chat mode"""
        print("QA Chat Agent - Type 'quit' to exit\n")
        
        while True:
            question = input("You: ")
            if question.lower() == 'quit':
                break
            
            print("\nAgent: ", end="")
            answer = self.ask(question)
            print(answer)
            print()

# Run the agent
if __name__ == "__main__":
    agent = QAChatAgent()
    agent.chat()

import ollama
import json
import os
from datetime import datetime

class EnhancedQAChatAgent:
    """Chat agent with memory and context"""
    
    def __init__(self, model="llama3.2:3b"):
        self.model = model
        self.memory_file = "agent_memory.json"
        self.memory = self._load_memory()
        self.context = self._build_context()
    
    def _load_memory(self):
        """Load conversation memory"""
        if os.path.exists(self.memory_file):
            with open(self.memory_file, 'r') as f:
                return json.load(f)
        return {"conversations": [], "learned_patterns": []}
    
    def _save_memory(self):
        """Save conversation memory"""
        with open(self.memory_file, 'w') as f:
            json.dump(self.memory, f, indent=2)
    
    def ask(self, question):
        """Ask with context from previous conversations"""
        recent_conversations = self.memory["conversations"][-3:]
        conversation_history = ""
        for conv in recent_conversations:
            conversation_history += f"Q: {conv['question']}\nA: {conv['answer']}\n\n"
        
        prompt = f"""
        {self.context}
        
        Previous conversation:
        {conversation_history}
        
        Current question: {question}
        
        Answer helpfully and concisely.
        """
        
        response = ollama.generate(model=self.model, prompt=prompt)
        answer = response['response']
        
        # Save to memory
        self.memory["conversations"].append({
            "timestamp": datetime.now().isoformat(),
            "question": question,
            "answer": answer
        })
        
        if len(self.memory["conversations"]) > 20:
            self.memory["conversations"] = self.memory["conversations"][-20:]
        
        self._save_memory()
        return answer

if __name__ == "__main__":
    agent = EnhancedQAChatAgent()
    agent.chat()

import ollama
import json

class TestGeneratorAgent:
    """Generates test cases from requirements"""
    
    def __init__(self, model="llama3.2:3b"):
        self.model = model
    
    def generate_tests(self, requirement_text):
        """Generate test cases from requirements"""
        prompt = f"""
        You are a QA test case generator. Given the following requirement, 
        generate comprehensive test cases in JSON format.
        
        Requirement:
        {requirement_text}
        
        Generate test cases with:
        - Test ID
        - Test Description
        - Test Steps
        - Expected Result
        - Priority (High/Medium/Low)
        
        Return as JSON array.
        """
        
        response = ollama.generate(
            model=self.model,
            prompt=prompt,
            format="json"
        )
        
        try:
            tests = json.loads(response['response'])
            return tests
        except:
            return [{"error": "Failed to parse response"}]
    
    def generate_from_file(self, file_path):
        """Generate tests from a requirements file"""
        with open(file_path, 'r') as f:
            requirements = f.read()
        return self.generate_tests(requirements)

# Example usage
if __name__ == "__main__":
    agent = TestGeneratorAgent()
    requirement = """
    Feature: User Login
    - User can login with email and password
    - User sees error message for invalid credentials
    - User can reset password
    """
    tests = agent.generate_tests(requirement)
    for test in tests:
        print(f"Test ID: {test.get('id', 'N/A')}")
        print(f"Description: {test.get('description', 'N/A')}")
        print(f"Priority: {test.get('priority', 'N/A')}")
        print("---")

import ollama
import subprocess

class CodeReviewAgent:
    """Reviews code changes before commit"""
    
    def __init__(self, model="llama3.2:3b"):
        self.model = model
    
    def get_diff(self):
        """Get git diff of changes"""
        result = subprocess.run(
            ["git", "diff", "--cached"],
            capture_output=True,
            text=True
        )
        return result.stdout
    
    def review(self, diff_text=None):
        """Review code changes"""
        if not diff_text:
            diff_text = self.get_diff()
        
        if not diff_text:
            return "No changes to review"
        
        prompt = f"""
        You are a QA code reviewer. Review the following code changes 
        and provide feedback on:
        1. Potential bugs
        2. Test coverage gaps
        3. Code quality issues
        4. Security concerns
        5. Best practices
        
        Code changes:
        {diff_text}
        
        Provide structured feedback.
        """
        
        response = ollama.generate(model=self.model, prompt=prompt)
        return response['response']
    
    def review_and_suggest_tests(self, diff_text=None):
        """Review code and suggest test cases"""
        review = self.review(diff_text)
        prompt = f"""
        Based on this code review:
        {review}
        
        Suggest specific test cases that should be written to test these changes.
        """
        response = ollama.generate(model=self.model, prompt=prompt)
        return {
            "review": review,
            "suggested_tests": response['response']
        }

# Usage: Run before git commit
if __name__ == "__main__":
    agent = CodeReviewAgent()
    review = agent.review()
    print(review)

import ollama
from datetime import datetime
import json

class WeeklyQAAgents:
    """Collection of agents for weekly QA work"""
    
    def __init__(self):
        self.model = "llama3.2:3b"
        self.agents = {
            "monday": self.monday_planning,
            "tuesday": self.tuesday_test_generation,
            "wednesday": self.wednesday_regression,
            "thursday": self.thursday_bug_analysis,
            "friday": self.friday_report
        }
    
    def monday_planning(self, tickets):
        """Monday: Week planning"""
        prompt = f"""
        Create a weekly QA test plan from these tickets:
        {tickets}
        
        Provide:
        1. Priority order
        2. Estimated time per item
        3. Dependencies
        4. Risk areas
        5. Suggested test approach
        """
        return self._generate(prompt)
    
    def tuesday_test_generation(self, requirements):
        """Tuesday: Generate test cases"""
        prompt = f"""
        Generate comprehensive test cases for:
        {requirements}
        
        Include:
        - Happy path tests
        - Edge cases
        - Error scenarios
        - Integration tests
        """
        return self._generate(prompt)
    
    def wednesday_regression(self, changes):
        """Wednesday: Smart regression"""
        prompt = f"""
        Analyze these code changes:
        {changes}
        
        Recommend:
        1. Which test areas are affected
        2. Specific test cases to run
        3. New tests that might be needed
        4. Areas that can be skipped
        """
        return self._generate(prompt)
    
    def thursday_bug_analysis(self, bug_report):
        """Thursday: Bug analysis"""
        prompt = f"""
        Analyze this bug report:
        {bug_report}
        
        Provide:
        1. Likely root cause
        2. Reproduction steps
        3. Suggested fix
        4. Test cases to prevent recurrence
        """
        return self._generate(prompt)
    
    def friday_report(self, week_data):
        """Friday: Weekly report"""
        prompt = f"""
        Create a weekly QA report from:
        {week_data}
        
        Include:
        1. Summary of work
        2. Metrics (tests run, bugs found)
        3. Blockers and issues
        4. Next week priorities
        """
        return self._generate(prompt)
    
    def _generate(self, prompt):
        """Generate response using Ollama"""
        response = ollama.generate(model=self.model, prompt=prompt)
        return response['response']
    
    def run_daily_agent(self):
        """Run the appropriate agent for today"""
        day = datetime.now().strftime("%A").lower()
        if day == "monday":
            return "Run Monday planning agent"
        elif day == "tuesday":
            return "Run Tuesday test generation agent"
        elif day == "wednesday":
            return "Run Wednesday regression agent"
        elif day == "thursday":
            return "Run Thursday bug analysis agent"
        elif day == "friday":
            return "Run Friday report agent"
        else:
            return "Weekend - no agents scheduled"

# Usage
if __name__ == "__main__":
    agents = WeeklyQAAgents()
    tickets = """
    - Ticket 123: Add user authentication
    - Ticket 124: Update payment processing
    - Ticket 125: Fix login bug
    """
    plan = agents.monday_planning(tickets)
    print(plan)