Merge remote-tracking branch 'origin/main' into main-debugger

tests/config2.yaml

@@ -0,0 +1,27 @@
+llm:
+  base_url: "https://api.openai.com/v1"
+  api_key: "sk-xxx"
+  model: "gpt-3.5-turbo-1106"
+
+search:
+  api_type: "serpapi"
+  api_key: "xxx"
+
+s3:
+  access_key: "MOCK_S3_ACCESS_KEY"
+  secret_key: "MOCK_S3_SECRET_KEY"
+  endpoint: "http://mock:9000"
+  secure: false
+  bucket: "mock"
+
+azure_tts_subscription_key: "xxx"
+azure_tts_region: "eastus"
+
+iflytek_app_id: "xxx"
+iflytek_api_key: "xxx"
+iflytek_api_secret: "xxx"
+
+metagpt_tti_url: "http://mock.com"
+
+repair_llm_output: true
+

tests/conftest.py

@@ -18,10 +18,11 @@ import aiohttp.web
 import pytest
 
 from metagpt.const import DEFAULT_WORKSPACE_ROOT, TEST_DATA_PATH
-from metagpt.context import CONTEXT
+from metagpt.context import Context as MetagptContext
 from metagpt.llm import LLM
 from metagpt.logs import logger
 from metagpt.utils.git_repository import GitRepository
+from metagpt.utils.project_repo import ProjectRepo
 from tests.mock.mock_aiohttp import MockAioResponse
 from tests.mock.mock_curl_cffi import MockCurlCffiResponse
 from tests.mock.mock_httplib2 import MockHttplib2Response
@@ -38,14 +39,14 @@ def rsp_cache():
     rsp_cache_file_path = TEST_DATA_PATH / "rsp_cache.json"  # read repo-provided
     new_rsp_cache_file_path = TEST_DATA_PATH / "rsp_cache_new.json"  # exporting a new copy
     if os.path.exists(rsp_cache_file_path):
-        with open(rsp_cache_file_path, "r") as f1:
+        with open(rsp_cache_file_path, "r", encoding="utf-8") as f1:
             rsp_cache_json = json.load(f1)
     else:
         rsp_cache_json = {}
     yield rsp_cache_json
-    with open(rsp_cache_file_path, "w") as f2:
+    with open(rsp_cache_file_path, "w", encoding="utf-8") as f2:
         json.dump(rsp_cache_json, f2, indent=4, ensure_ascii=False)
-    with open(new_rsp_cache_file_path, "w") as f2:
+    with open(new_rsp_cache_file_path, "w", encoding="utf-8") as f2:
         json.dump(RSP_CACHE_NEW, f2, indent=4, ensure_ascii=False)
 
 
@@ -64,6 +65,7 @@ def llm_mock(rsp_cache, mocker, request):
     llm.rsp_cache = rsp_cache
     mocker.patch("metagpt.provider.base_llm.BaseLLM.aask", llm.aask)
     mocker.patch("metagpt.provider.base_llm.BaseLLM.aask_batch", llm.aask_batch)
+    mocker.patch("metagpt.provider.openai_api.OpenAILLM.aask_code", llm.aask_code)
     yield mocker
     if hasattr(request.node, "test_outcome") and request.node.test_outcome.passed:
         if llm.rsp_candidates:
@@ -71,7 +73,7 @@ def llm_mock(rsp_cache, mocker, request):
                 cand_key = list(rsp_candidate.keys())[0]
                 cand_value = list(rsp_candidate.values())[0]
                 if cand_key not in llm.rsp_cache:
-                    logger.info(f"Added '{cand_key[:100]} ... -> {cand_value[:20]} ...' to response cache")
+                    logger.info(f"Added '{cand_key[:100]} ... -> {str(cand_value)[:20]} ...' to response cache")
                     llm.rsp_cache.update(rsp_candidate)
                 RSP_CACHE_NEW.update(rsp_candidate)
 
@@ -142,19 +144,20 @@ def loguru_caplog(caplog):
     yield caplog
 
 
-# init & dispose git repo
-@pytest.fixture(scope="function", autouse=True)
-def setup_and_teardown_git_repo(request):
-    CONTEXT.git_repo = GitRepository(local_path=DEFAULT_WORKSPACE_ROOT / f"unittest/{uuid.uuid4().hex}")
-    CONTEXT.config.git_reinit = True
+@pytest.fixture(scope="function")
+def context(request):
+    ctx = MetagptContext()
+    ctx.git_repo = GitRepository(local_path=DEFAULT_WORKSPACE_ROOT / f"unittest/{uuid.uuid4().hex}")
+    ctx.repo = ProjectRepo(ctx.git_repo)
 
     # Destroy git repo at the end of the test session.
     def fin():
-        if CONTEXT.git_repo:
-            CONTEXT.git_repo.delete_repository()
+        if ctx.git_repo:
+            ctx.git_repo.delete_repository()
 
     # Register the function for destroying the environment.
     request.addfinalizer(fin)
+    return ctx
 
 
 @pytest.fixture(scope="session", autouse=True)

tests/data/environment/stanford_town/the_ville/matrix/maze_meta_info.json

@@ -0,0 +1,5 @@
+{"world_name": "the ville", 
+ "maze_width": 140,
+ "maze_height": 100,
+ "sq_tile_size": 32,
+ "special_constraint": ""}

tests/data/environment/stanford_town/the_ville/matrix/special_blocks/arena_blocks.csv

@@ -0,0 +1,63 @@
+32138, the Ville, artist's co-living space, Latoya Williams's room
+32148, the Ville, artist's co-living space, Latoya Williams's bathroom
+32158, the Ville, artist's co-living space, Rajiv Patel's room
+32168, the Ville, artist's co-living space, Rajiv Patel's bathroom
+32178, the Ville, artist's co-living space, Abigail Chen's room
+32188, the Ville, artist's co-living space, Abigail Chen's bathroom
+32198, the Ville, artist's co-living space, Francisco Lopez's room
+32139, the Ville, artist's co-living space, Francisco Lopez's bathroom
+32149, the Ville, artist's co-living space, Hailey Johnson's room
+32159, the Ville, artist's co-living space, Hailey Johnson's bathroom
+32179, the Ville, artist's co-living space, common room
+32189, the Ville, artist's co-living space, kitchen
+32199, the Ville, Arthur Burton's apartment, main room
+32140, the Ville, Arthur Burton's apartment, bathroom
+32150, the Ville, Ryan Park's apartment, main room
+32160, the Ville, Ryan Park's apartment, bathroom
+32170, the Ville, Isabella Rodriguez's apartment, main room
+32180, the Ville, Isabella Rodriguez's apartment, bathroom
+32190, the Ville, Giorgio Rossi's apartment, main room
+32200, the Ville, Giorgio Rossi's apartment, bathroom
+32141, the Ville, Carlos Gomez's apartment, main room
+32151, the Ville, Carlos Gomez's apartment, bathroom
+32161, the Ville, The Rose and Crown Pub, pub
+32171, the Ville, Hobbs Cafe, cafe
+32181, the Ville, Oak Hill College, classroom
+32191, the Ville, Oak Hill College, library
+32201, the Ville, Oak Hill College, hallway
+32142, the Ville, Johnson Park, park
+32152, the Ville, Harvey Oak Supply Store, supply store
+32162, the Ville, The Willows Market and Pharmacy, store
+32193, the Ville, Adam Smith's house, main room
+32203, the Ville, Adam Smith's house, bathroom
+32174, the Ville, Yuriko Yamamoto's house, main room
+32184, the Ville, Yuriko Yamamoto's house, bathroom
+32194, the Ville, Moore family's house, main room
+32204, the Ville, Moore family's house, bathroom
+32172, the Ville, Dorm for Oak Hill College, Klaus Mueller's room
+32182, the Ville, Dorm for Oak Hill College, Maria Lopez's room
+32192, the Ville, Dorm for Oak Hill College, Ayesha Khan's room
+32202, the Ville, Dorm for Oak Hill College, Wolfgang Schulz's room
+32143, the Ville, Dorm for Oak Hill College, man's bathroom
+32153, the Ville, Dorm for Oak Hill College, woman's bathroom
+32163, the Ville, Dorm for Oak Hill College, common room
+32173, the Ville, Dorm for Oak Hill College, kitchen
+32183, the Ville, Dorm for Oak Hill College, garden
+32205, the Ville, Tamara Taylor and Carmen Ortiz's house, Tamara Taylor's room
+32215, the Ville, Tamara Taylor and Carmen Ortiz's house, Carmen Ortiz's room
+32225, the Ville, Tamara Taylor and Carmen Ortiz's house, common room
+32235, the Ville, Tamara Taylor and Carmen Ortiz's house, kitchen
+32245, the Ville, Tamara Taylor and Carmen Ortiz's house, bathroom
+32255, the Ville, Tamara Taylor and Carmen Ortiz's house, garden
+32265, the Ville, Moreno family's house, Tom and Jane Moreno's bedroom
+32275, the Ville, Moreno family's house, empty bedroom
+32206, the Ville, Moreno family's house, common room
+32216, the Ville, Moreno family's house, kitchen
+32226, the Ville, Moreno family's house, bathroom
+32236, the Ville, Moreno family's house, garden
+32246, the Ville, Lin family's house, Mei and John Lin's bedroom
+32256, the Ville, Lin family's house, Eddy Lin's bedroom
+32266, the Ville, Lin family's house, common room
+32276, the Ville, Lin family's house, kitchen
+32207, the Ville, Lin family's house, bathroom
+32217, the Ville, Lin family's house, garden

tests/data/environment/stanford_town/the_ville/matrix/special_blocks/game_object_blocks.csv

@@ -0,0 +1,46 @@
+32227, the Ville, <all>, bed
+32237, the Ville, <all>, desk
+32247, the Ville, <all>, closet
+32257, the Ville, <all>, shelf
+32267, the Ville, <all>, easel
+32277, the Ville, <all>, bathroom sink
+32208, the Ville, <all>, shower
+32218, the Ville, <all>, toilet
+32228, the Ville, <all>, kitchen sink
+32238, the Ville, <all>, refrigerator
+32248, the Ville, <all>, toaster
+32258, the Ville, <all>, cooking area
+32268, the Ville, <all>, common room table
+32278, the Ville, <all>, common room sofa
+32209, the Ville, <all>, guitar
+32219, the Ville, <all>, microphone
+32229, the Ville, <all>, bar customer seating
+32239, the Ville, <all>, behind the bar counter
+32249, the Ville, <all>, behind the cafe counter
+32259, the Ville, <all>, cafe customer seating
+32269, the Ville, <all>, piano
+32279, the Ville, <all>, blackboard
+32210, the Ville, <all>, game console
+32220, the Ville, <all>, computer desk
+32230, the Ville, <all>, computer
+32240, the Ville, <all>, library sofa
+32250, the Ville, <all>, bookshelf
+32260, the Ville, <all>, library table
+32270, the Ville, <all>, classroom student seating
+32280, the Ville, <all>, classroom podium
+32211, the Ville, <all>, behind the pharmacy counter
+32221, the Ville, <all>, behind the grocery counter
+32231, the Ville, <all>, pharmacy store shelf
+32241, the Ville, <all>, grocery store shelf
+32251, the Ville, <all>, pharmacy store counter
+32261, the Ville, <all>, grocery store counter
+32271, the Ville, <all>, supply store product shelf
+32281, the Ville, <all>, behind the supply store counter
+32212, the Ville, <all>, supply store counter
+32222, the Ville, <all>, dorm garden
+32232, the Ville, <all>, house garden
+32242, the Ville, <all>, garden chair
+32252, the Ville, <all>, park garden
+32262, the Ville, <all>, harp
+32272, the Ville, <all>, lifting weight
+32282, the Ville, <all>, pool table

tests/data/environment/stanford_town/the_ville/matrix/special_blocks/sector_blocks.csv

@@ -0,0 +1,19 @@
+32135, the Ville, artist's co-living space
+32145, the Ville, Arthur Burton's apartment
+32155, the Ville, Ryan Park's apartment 
+32165, the Ville, Isabella Rodriguez's apartment
+32175, the Ville, Giorgio Rossi's apartment
+32185, the Ville, Carlos Gomez's apartment
+32195, the Ville, The Rose and Crown Pub
+32136, the Ville, Hobbs Cafe
+32146, the Ville, Oak Hill College
+32156, the Ville, Johnson Park
+32166, the Ville, Harvey Oak Supply Store
+32176, the Ville, The Willows Market and Pharmacy
+32186, the Ville, Adam Smith's house
+32196, the Ville, Yuriko Yamamoto's house
+32137, the Ville, Moore family's house
+32147, the Ville, Tamara Taylor and Carmen Ortiz's house
+32157, the Ville, Moreno family's house
+32167, the Ville, Lin family's house
+32177, the Ville, Dorm for Oak Hill College

tests/data/environment/stanford_town/the_ville/matrix/special_blocks/spawning_location_blocks.csv

@@ -0,0 +1,40 @@
+32285, the Ville, artist's co-living space, Latoya Williams's room, sp-A
+32295, the Ville, artist's co-living space, Rajiv Patel's room, sp-A
+32305, the Ville, artist's co-living space, Rajiv Patel's room, sp-B
+32315, the Ville, artist's co-living space, Abigail Chen's room, sp-A
+32286, the Ville, artist's co-living space, Francisco Lopez's room, sp-A
+32296, the Ville, artist's co-living space, Hailey Johnson's room, sp-A
+32306, the Ville, Arthur Burton's apartment, main room, sp-A
+32316, the Ville, Arthur Burton's apartment, main room, sp-B
+32287, the Ville, Ryan Park's apartment, main room, sp-A
+32297, the Ville, Ryan Park's apartment, main room, sp-B
+32307, the Ville, Isabella Rodriguez's apartment, main room, sp-A
+32317, the Ville, Isabella Rodriguez's apartment, main room, sp-B
+32288, the Ville, Giorgio Rossi's apartment, main room, sp-A
+32298, the Ville, Giorgio Rossi's apartment, main room, sp-B
+32308, the Ville, Carlos Gomez's apartment, main room, sp-A
+32318, the Ville, Carlos Gomez's apartment, main room, sp-B
+32289, the Ville, Adam Smith's house, main room, sp-A
+32299, the Ville, Adam Smith's house, main room, sp-B
+32309, the Ville, Yuriko Yamamoto's house, main room, sp-A
+32319, the Ville, Yuriko Yamamoto's house, main room, sp-B
+32290, the Ville, Moore family's house, main room, sp-A
+32300, the Ville, Moore family's house, main room, sp-B
+32310, the Ville, Tamara Taylor and Carmen Ortiz's house, Tamara Taylor's room, sp-A
+32320, the Ville, Tamara Taylor and Carmen Ortiz's house, Tamara Taylor's room, sp-B
+32291, the Ville, Tamara Taylor and Carmen Ortiz's house, Carmen Ortiz's room, sp-A
+32301, the Ville, Tamara Taylor and Carmen Ortiz's house, Carmen Ortiz's room, sp-B
+32311, the Ville, Moreno family's house, Tom and Jane Moreno's bedroom, sp-A
+32321, the Ville, Moreno family's house, Tom and Jane Moreno's bedroom, sp-B
+32292, the Ville, Moreno family's house, empty bedroom, sp-A
+32302, the Ville, Moreno family's house, empty bedroom, sp-B
+32312, the Ville, Lin family's house, Mei and John Lin's bedroom, sp-A
+32322, the Ville, Lin family's house, Mei and John Lin's bedroom, sp-B
+32293, the Ville, Lin family's house, Eddy Lin's bedroom, sp-A
+32303, the Ville, Lin family's house, Eddy Lin's bedroom, sp-B
+32313, the Ville, Dorm for Oak Hill College, Klaus Mueller's room, sp-A
+32323, the Ville, Dorm for Oak Hill College, Klaus Mueller's room, sp-B
+32294, the Ville, Dorm for Oak Hill College, Maria Lopez's room, sp-A
+32304, the Ville, Dorm for Oak Hill College, Ayesha Khan's room, sp-A
+32314, the Ville, Dorm for Oak Hill College, Ayesha Khan's room, sp-B
+32324, the Ville, Dorm for Oak Hill College, Wolfgang Schulz's room, sp-A

tests/data/environment/stanford_town/the_ville/matrix/special_blocks/world_blocks.csv

@@ -0,0 +1 @@
+32134, the Ville

tests/data/incremental_dev_project/mock.py

@@ -0,0 +1,466 @@
+#!/usr/bin/env python
+# -*- coding: utf-8 -*-
+"""
+@Time    : 2024/01/17
+@Author  : mannaandpoem
+@File    : mock.py
+"""
+NEW_REQUIREMENT_SAMPLE = """
+Adding graphical interface functionality to enhance the user experience in the number-guessing game. The existing number-guessing game currently relies on command-line input for numbers. The goal is to introduce a graphical interface to improve the game's usability and visual appeal
+"""
+
+PRD_SAMPLE = """
+## Language
+
+en_us
+
+## Programming Language
+
+Python
+
+## Original Requirements
+
+Make a simple number guessing game
+
+## Product Goals
+
+- Ensure a user-friendly interface for the game
+- Provide a challenging yet enjoyable game experience
+- Design the game to be easily extendable for future features
+
+## User Stories
+
+- As a player, I want to guess numbers and receive feedback on whether my guess is too high or too low
+- As a player, I want to be able to set the difficulty level by choosing the range of possible numbers
+- As a player, I want to see my previous guesses to strategize my next guess
+- As a player, I want to know how many attempts it took me to guess the number once I get it right
+
+## Competitive Analysis
+
+- Guess The Number Game A: Basic text interface, no difficulty levels
+- Number Master B: Has difficulty levels, but cluttered interface
+- Quick Guess C: Sleek design, but lacks performance tracking
+- NumGuess D: Good performance tracking, but not mobile-friendly
+- GuessIt E: Mobile-friendly, but too many ads
+- Perfect Guess F: Offers hints, but the hints are not very helpful
+- SmartGuesser G: Has a learning mode, but lacks a competitive edge
+
+## Competitive Quadrant Chart
+
+quadrantChart
+    title "User Engagement and Game Complexity"
+    x-axis "Low Complexity" --> "High Complexity"
+    y-axis "Low Engagement" --> "High Engagement"
+    quadrant-1 "Too Simple"
+    quadrant-2 "Niche Appeal"
+    quadrant-3 "Complex & Unengaging"
+    quadrant-4 "Sweet Spot"
+    "Guess The Number Game A": [0.2, 0.4]
+    "Number Master B": [0.5, 0.3]
+    "Quick Guess C": [0.6, 0.7]
+    "NumGuess D": [0.4, 0.6]
+    "GuessIt E": [0.7, 0.5]
+    "Perfect Guess F": [0.6, 0.4]
+    "SmartGuesser G": [0.8, 0.6]
+    "Our Target Product": [0.5, 0.8]
+
+## Requirement Analysis
+
+The game should be simple yet engaging, allowing players of different skill levels to enjoy it. It should provide immediate feedback and track the player's performance. The game should also be designed with a clean and intuitive interface, and it should be easy to add new features in the future.
+
+## Requirement Pool
+
+- ['P0', 'Implement the core game logic to randomly select a number and allow the user to guess it']
+- ['P0', 'Design a user interface that displays the game status and results clearly']
+- ['P1', 'Add difficulty levels by varying the range of possible numbers']
+- ['P1', 'Keep track of and display the number of attempts for each game session']
+- ['P2', "Store and show the history of the player's guesses during a game session"]
+
+## UI Design draft
+
+The UI will feature a clean and minimalist design with a number input field, submit button, and messages area to provide feedback. There will be options to select the difficulty level and a display showing the number of attempts and history of past guesses.
+
+## Anything UNCLEAR"""
+
+DESIGN_SAMPLE = """
+## Implementation approach
+
+We will create a Python-based number guessing game with a simple command-line interface. For the user interface, we will use the built-in 'input' and 'print' functions for interaction. The random library will be used for generating random numbers. We will structure the code to be modular and easily extendable, separating the game logic from the user interface.
+
+## File list
+
+- main.py
+- game.py
+- ui.py
+
+## Data structures and interfaces
+
+
+classDiagram
+    class Game {
+        -int secret_number
+        -int min_range
+        -int max_range
+        -list attempts
+        +__init__(difficulty: str)
+        +start_game()
+        +check_guess(guess: int) str
+        +get_attempts() int
+        +get_history() list
+    }
+    class UI {
+        +start()
+        +display_message(message: str)
+        +get_user_input(prompt: str) str
+        +show_attempts(attempts: int)
+        +show_history(history: list)
+        +select_difficulty() str
+    }
+    class Main {
+        +main()
+    }
+    Main --> UI
+    UI --> Game
+
+
+## Program call flow
+
+
+sequenceDiagram
+    participant M as Main
+    participant UI as UI
+    participant G as Game
+    M->>UI: start()
+    UI->>UI: select_difficulty()
+    UI-->>G: __init__(difficulty)
+    G->>G: start_game()
+    loop Game Loop
+        UI->>UI: get_user_input("Enter your guess:")
+        UI-->>G: check_guess(guess)
+        G->>UI: display_message(feedback)
+        G->>UI: show_attempts(attempts)
+        G->>UI: show_history(history)
+    end
+    G->>UI: display_message("Correct! Game over.")
+    UI->>M: main()  # Game session ends
+
+
+## Anything UNCLEAR
+
+The requirement analysis suggests the need for a clean and intuitive interface. Since we are using a command-line interface, we need to ensure that the text-based UI is as user-friendly as possible. Further clarification on whether a graphical user interface (GUI) is expected in the future would be helpful for planning the extendability of the game."""
+
+TASKS_SAMPLE = """
+## Required Python packages
+
+- random==2.2.1
+
+## Required Other language third-party packages
+
+- No third-party dependencies required
+
+## Logic Analysis
+
+- ['game.py', 'Contains Game class with methods __init__, start_game, check_guess, get_attempts, get_history and uses random library for generating secret_number']
+- ['ui.py', 'Contains UI class with methods start, display_message, get_user_input, show_attempts, show_history, select_difficulty and interacts with Game class']
+- ['main.py', 'Contains Main class with method main that initializes UI class and starts the game loop']
+
+## Task list
+
+- game.py
+- ui.py
+- main.py
+
+## Full API spec
+
+
+
+## Shared Knowledge
+
+`game.py` contains the core game logic and is used by `ui.py` to interact with the user. `main.py` serves as the entry point to start the game.
+
+## Anything UNCLEAR
+
+The requirement analysis suggests the need for a clean and intuitive interface. Since we are using a command-line interface, we need to ensure that the text-based UI is as user-friendly as possible. Further clarification on whether a graphical user interface (GUI) is expected in the future would be helpful for planning the extendability of the game."""
+
+OLD_CODE_SAMPLE = """
+--- game.py
+```## game.py
+
+import random
+
+class Game:
+    def __init__(self, difficulty: str = 'medium'):
+        self.min_range, self.max_range = self._set_difficulty(difficulty)
+        self.secret_number = random.randint(self.min_range, self.max_range)
+        self.attempts = []
+
+    def _set_difficulty(self, difficulty: str):
+        difficulties = {
+            'easy': (1, 10),
+            'medium': (1, 100),
+            'hard': (1, 1000)
+        }
+        return difficulties.get(difficulty, (1, 100))
+
+    def start_game(self):
+        self.secret_number = random.randint(self.min_range, self.max_range)
+        self.attempts = []
+
+    def check_guess(self, guess: int) -> str:
+        self.attempts.append(guess)
+        if guess < self.secret_number:
+            return "It's higher."
+        elif guess > self.secret_number:
+            return "It's lower."
+        else:
+            return "Correct! Game over."
+
+    def get_attempts(self) -> int:
+        return len(self.attempts)
+
+    def get_history(self) -> list:
+        return self.attempts```
+
+--- ui.py
+```## ui.py
+
+from game import Game
+
+class UI:
+    def start(self):
+        difficulty = self.select_difficulty()
+        game = Game(difficulty)
+        game.start_game()
+        self.display_welcome_message(game)
+
+        feedback = ""
+        while feedback != "Correct! Game over.":
+            guess = self.get_user_input("Enter your guess: ")
+            if self.is_valid_guess(guess):
+                feedback = game.check_guess(int(guess))
+                self.display_message(feedback)
+                self.show_attempts(game.get_attempts())
+                self.show_history(game.get_history())
+            else:
+                self.display_message("Please enter a valid number.")
+
+    def display_welcome_message(self, game):
+        print("Welcome to the Number Guessing Game!")
+        print(f"Guess the number between {game.min_range} and {game.max_range}.")
+
+    def is_valid_guess(self, guess):
+        return guess.isdigit()
+
+    def display_message(self, message: str):
+        print(message)
+
+    def get_user_input(self, prompt: str) -> str:
+        return input(prompt)
+
+    def show_attempts(self, attempts: int):
+        print(f"Number of attempts: {attempts}")
+
+    def show_history(self, history: list):
+        print("Guess history:")
+        for guess in history:
+            print(guess)
+
+    def select_difficulty(self) -> str:
+        while True:
+            difficulty = input("Select difficulty (easy, medium, hard): ").lower()
+            if difficulty in ['easy', 'medium', 'hard']:
+                return difficulty
+            else:
+                self.display_message("Invalid difficulty. Please choose 'easy', 'medium', or 'hard'.")```
+
+--- main.py
+```## main.py
+
+from ui import UI
+
+class Main:
+    def main(self):
+        user_interface = UI()
+        user_interface.start()
+
+if __name__ == "__main__":
+    main_instance = Main()
+    main_instance.main()```
+"""
+
+REFINED_PRD_JSON = {
+    "Language": "en_us",
+    "Programming Language": "Python",
+    "Refined Requirements": "Adding graphical interface functionality to enhance the user experience in the number-guessing game.",
+    "Project Name": "number_guessing_game",
+    "Refined Product Goals": [
+        "Ensure a user-friendly interface for the game with the new graphical interface",
+        "Provide a challenging yet enjoyable game experience with visual enhancements",
+        "Design the game to be easily extendable for future features, including graphical elements",
+    ],
+    "Refined User Stories": [
+        "As a player, I want to interact with a graphical interface to guess numbers and receive visual feedback on my guesses",
+        "As a player, I want to easily select the difficulty level through the graphical interface",
+        "As a player, I want to visually track my previous guesses and the number of attempts in the graphical interface",
+        "As a player, I want to be congratulated with a visually appealing message when I guess the number correctly",
+    ],
+    "Competitive Analysis": [
+        "Guess The Number Game A: Basic text interface, no difficulty levels",
+        "Number Master B: Has difficulty levels, but cluttered interface",
+        "Quick Guess C: Sleek design, but lacks performance tracking",
+        "NumGuess D: Good performance tracking, but not mobile-friendly",
+        "GuessIt E: Mobile-friendly, but too many ads",
+        "Perfect Guess F: Offers hints, but the hints are not very helpful",
+        "SmartGuesser G: Has a learning mode, but lacks a competitive edge",
+        "Graphical Guess H: Graphical interface, but poor user experience due to complex design",
+    ],
+    "Competitive Quadrant Chart": 'quadrantChart\n    title "User Engagement and Game Complexity with Graphical Interface"\n    x-axis "Low Complexity" --> "High Complexity"\n    y-axis "Low Engagement" --> "High Engagement"\n    quadrant-1 "Too Simple"\n    quadrant-2 "Niche Appeal"\n    quadrant-3 "Complex & Unengaging"\n    quadrant-4 "Sweet Spot"\n    "Guess The Number Game A": [0.2, 0.4]\n    "Number Master B": [0.5, 0.3]\n    "Quick Guess C": [0.6, 0.7]\n    "NumGuess D": [0.4, 0.6]\n    "GuessIt E": [0.7, 0.5]\n    "Perfect Guess F": [0.6, 0.4]\n    "SmartGuesser G": [0.8, 0.6]\n    "Graphical Guess H": [0.7, 0.3]\n    "Our Target Product": [0.5, 0.9]',
+    "Refined Requirement Analysis": [
+        "The game should maintain its simplicity while integrating a graphical interface for enhanced engagement.",
+        "Immediate visual feedback is crucial for user satisfaction in the graphical interface.",
+        "The interface must be intuitive, allowing for easy navigation and selection of game options.",
+        "The graphical design should be clean and not detract from the game's core guessing mechanic.",
+    ],
+    "Refined Requirement Pool": [
+        ["P0", "Implement a graphical user interface (GUI) to replace the command-line interaction"],
+        [
+            "P0",
+            "Design a user interface that displays the game status, results, and feedback clearly with graphical elements",
+        ],
+        ["P1", "Incorporate interactive elements for selecting difficulty levels"],
+        ["P1", "Visualize the history of the player's guesses and the number of attempts within the game session"],
+        ["P2", "Create animations for correct or incorrect guesses to enhance user feedback"],
+        ["P2", "Ensure the GUI is responsive and compatible with various screen sizes"],
+        ["P2", "Store and show the history of the player's guesses during a game session"],
+    ],
+    "UI Design draft": "The UI will feature a modern and minimalist design with a graphical number input field, a submit button with animations, and a dedicated area for visual feedback. It will include interactive elements to select the difficulty level and a visual display for the number of attempts and history of past guesses.",
+    "Anything UNCLEAR": "",
+}
+
+REFINED_DESIGN_JSON = {
+    "Refined Implementation Approach": "To accommodate the new graphical user interface (GUI) requirements, we will leverage the Tkinter library, which is included with Python and supports the creation of a user-friendly GUI. The game logic will remain in Python, with Tkinter handling the rendering of the interface. We will ensure that the GUI is responsive and provides immediate visual feedback. The main game loop will be event-driven, responding to user inputs such as button clicks and difficulty selection.",
+    "Refined File list": ["main.py", "game.py", "ui.py", "gui.py"],
+    "Refined Data structures and interfaces": "\nclassDiagram\n    class Game {\n        -int secret_number\n        -int min_range\n        -int max_range\n        -list attempts\n        +__init__(difficulty: str)\n        +start_game()\n        +check_guess(guess: int) str\n        +get_attempts() int\n        +get_history() list\n    }\n    class UI {\n        +start()\n        +display_message(message: str)\n        +get_user_input(prompt: str) str\n        +show_attempts(attempts: int)\n        +show_history(history: list)\n        +select_difficulty() str\n    }\n    class GUI {\n        +__init__()\n        +setup_window()\n        +bind_events()\n        +update_feedback(message: str)\n        +update_attempts(attempts: int)\n        +update_history(history: list)\n        +show_difficulty_selector()\n        +animate_guess_result(correct: bool)\n    }\n    class Main {\n        +main()\n    }\n    Main --> UI\n    UI --> Game\n    UI --> GUI\n    GUI --> Game\n",
+    "Refined Program call flow": '\nsequenceDiagram\n    participant M as Main\n    participant UI as UI\n    participant G as Game\n    participant GU as GUI\n    M->>UI: start()\n    UI->>GU: setup_window()\n    GU->>GU: bind_events()\n    GU->>UI: select_difficulty()\n    UI-->>G: __init__(difficulty)\n    G->>G: start_game()\n    loop Game Loop\n        GU->>GU: show_difficulty_selector()\n        GU->>UI: get_user_input("Enter your guess:")\n        UI-->>G: check_guess(guess)\n        G->>GU: update_feedback(feedback)\n        G->>GU: update_attempts(attempts)\n        G->>GU: update_history(history)\n        GU->>GU: animate_guess_result(correct)\n    end\n    G->>GU: update_feedback("Correct! Game over.")\n    GU->>M: main()  # Game session ends\n',
+    "Anything UNCLEAR": "",
+}
+
+REFINED_TASKS_JSON = {
+    "Required Python packages": ["random==2.2.1", "Tkinter==8.6"],
+    "Required Other language third-party packages": ["No third-party dependencies required"],
+    "Refined Logic Analysis": [
+        [
+            "game.py",
+            "Contains Game class with methods __init__, start_game, check_guess, get_attempts, get_history and uses random library for generating secret_number",
+        ],
+        [
+            "ui.py",
+            "Contains UI class with methods start, display_message, get_user_input, show_attempts, show_history, select_difficulty and interacts with Game class",
+        ],
+        [
+            "gui.py",
+            "Contains GUI class with methods __init__, setup_window, bind_events, update_feedback, update_attempts, update_history, show_difficulty_selector, animate_guess_result and interacts with Game class for GUI rendering",
+        ],
+        [
+            "main.py",
+            "Contains Main class with method main that initializes UI class and starts the event-driven game loop",
+        ],
+    ],
+    "Refined Task list": ["game.py", "ui.py", "gui.py", "main.py"],
+    "Full API spec": "",
+    "Refined Shared Knowledge": "`game.py` contains the core game logic and is used by `ui.py` to interact with the user. `main.py` serves as the entry point to start the game. `gui.py` is introduced to handle the graphical user interface using Tkinter, which will interact with both `game.py` and `ui.py` for a responsive and user-friendly experience.",
+    "Anything UNCLEAR": "",
+}
+
+CODE_PLAN_AND_CHANGE_SAMPLE = {
+    "Code Plan And Change": '\n1. Plan for gui.py: Develop the GUI using Tkinter to replace the command-line interface. Start by setting up the main window and event handling. Then, add widgets for displaying the game status, results, and feedback. Implement interactive elements for difficulty selection and visualize the guess history. Finally, create animations for guess feedback and ensure responsiveness across different screen sizes.\n```python\nclass GUI:\n-    pass\n+    def __init__(self):\n+        self.setup_window()\n+\n+    def setup_window(self):\n+        # Initialize the main window using Tkinter\n+        pass\n+\n+    def bind_events(self):\n+        # Bind button clicks and other events\n+        pass\n+\n+    def update_feedback(self, message: str):\n+        # Update the feedback label with the given message\n+        pass\n+\n+    def update_attempts(self, attempts: int):\n+        # Update the attempts label with the number of attempts\n+        pass\n+\n+    def update_history(self, history: list):\n+        # Update the history view with the list of past guesses\n+        pass\n+\n+    def show_difficulty_selector(self):\n+        # Show buttons or a dropdown for difficulty selection\n+        pass\n+\n+    def animate_guess_result(self, correct: bool):\n+        # Trigger an animation for correct or incorrect guesses\n+        pass\n```\n\n2. Plan for main.py: Modify the main.py to initialize the GUI and start the event-driven game loop. Ensure that the GUI is the primary interface for user interaction.\n```python\nclass Main:\n     def main(self):\n-        user_interface = UI()\n-        user_interface.start()\n+        graphical_user_interface = GUI()\n+        graphical_user_interface.setup_window()\n+        graphical_user_interface.bind_events()\n+        # Start the Tkinter main loop\n+        pass\n\n if __name__ == "__main__":\n     main_instance = Main()\n     main_instance.main()\n```\n\n3. Plan for ui.py: Refactor ui.py to work with the new GUI class. Remove command-line interactions and delegate display and input tasks to the GUI.\n```python\nclass UI:\n-    def display_message(self, message: str):\n-        print(message)\n+\n+    def display_message(self, message: str):\n+        # This method will now pass the message to the GUI to display\n+        pass\n\n-    def get_user_input(self, prompt: str) -> str:\n-        return input(prompt)\n+\n+    def get_user_input(self, prompt: str) -> str:\n+        # This method will now trigger the GUI to get user input\n+        pass\n\n-    def show_attempts(self, attempts: int):\n-        print(f"Number of attempts: {attempts}")\n+\n+    def show_attempts(self, attempts: int):\n+        # This method will now update the GUI with the number of attempts\n+        pass\n\n-    def show_history(self, history: list):\n-        print("Guess history:")\n-        for guess in history:\n-            print(guess)\n+\n+    def show_history(self, history: list):\n+        # This method will now update the GUI with the guess history\n+        pass\n```\n\n4. Plan for game.py: Ensure game.py remains mostly unchanged as it contains the core game logic. However, make minor adjustments if necessary to integrate with the new GUI.\n```python\nclass Game:\n     # No changes required for now\n```\n'
+}
+
+REFINED_CODE_INPUT_SAMPLE = """
+-----Now, game.py to be rewritten
+```## game.py
+
+import random
+
+class Game:
+    def __init__(self, difficulty: str = 'medium'):
+        self.min_range, self.max_range = self._set_difficulty(difficulty)
+        self.secret_number = random.randint(self.min_range, self.max_range)
+        self.attempts = []
+
+    def _set_difficulty(self, difficulty: str):
+        difficulties = {
+            'easy': (1, 10),
+            'medium': (1, 100),
+            'hard': (1, 1000)
+        }
+        return difficulties.get(difficulty, (1, 100))
+
+    def start_game(self):
+        self.secret_number = random.randint(self.min_range, self.max_range)
+        self.attempts = []
+
+    def check_guess(self, guess: int) -> str:
+        self.attempts.append(guess)
+        if guess < self.secret_number:
+            return "It's higher."
+        elif guess > self.secret_number:
+            return "It's lower."
+        else:
+            return "Correct! Game over."
+
+    def get_attempts(self) -> int:
+        return len(self.attempts)
+
+    def get_history(self) -> list:
+        return self.attempts```
+"""
+
+REFINED_CODE_SAMPLE = """
+## game.py
+
+import random
+
+class Game:
+    def __init__(self, difficulty: str = 'medium'):
+        # Set the difficulty level with default value 'medium'
+        self.min_range, self.max_range = self._set_difficulty(difficulty)
+        # Initialize the secret number based on the difficulty
+        self.secret_number = random.randint(self.min_range, self.max_range)
+        # Initialize the list to keep track of attempts
+        self.attempts = []
+
+    def _set_difficulty(self, difficulty: str):
+        # Define the range of numbers for each difficulty level
+        difficulties = {
+            'easy': (1, 10),
+            'medium': (1, 100),
+            'hard': (1, 1000)
+        }
+        # Return the corresponding range for the selected difficulty, default to 'medium' if not found
+        return difficulties.get(difficulty, (1, 100))
+
+    def start_game(self):
+        # Reset the secret number and attempts list for a new game
+        self.secret_number = random.randint(self.min_range, self.max_range)
+        self.attempts.clear()
+
+    def check_guess(self, guess: int) -> str:
+        # Add the guess to the attempts list
+        self.attempts.append(guess)
+        # Provide feedback based on the guess
+        if guess < self.secret_number:
+            return "It's higher."
+        elif guess > self.secret_number:
+            return "It's lower."
+        else:
+            return "Correct! Game over."
+
+    def get_attempts(self) -> int:
+        # Return the number of attempts made
+        return len(self.attempts)
+
+    def get_history(self) -> list:
+        # Return the list of attempts made
+        return self.attempts
+"""

tests/data/incremental_dev_project/readme.md

@@ -0,0 +1,3 @@
+# Code archive
+
+This folder contains a compressed package for the test_incremental_dev.py file, which is used to demonstrate the process of incremental development.

tests/metagpt/actions/ci/test_ask_review.py

@@ -0,0 +1,12 @@
+import pytest
+
+from metagpt.actions.ci.ask_review import AskReview
+
+
+@pytest.mark.asyncio
+async def test_ask_review(mocker):
+    mock_review_input = "confirm"
+    mocker.patch("builtins.input", return_value=mock_review_input)
+    rsp, confirmed = await AskReview().run()
+    assert rsp == mock_review_input
+    assert confirmed

tests/metagpt/actions/ci/test_debug_code.py

@@ -0,0 +1,51 @@
+# -*- coding: utf-8 -*-
+# @Date    : 1/11/2024 8:51 PM
+# @Author  : stellahong (stellahong@fuzhi.ai)
+# @Desc    :
+
+import pytest
+
+from metagpt.actions.ci.debug_code import DebugCode
+from metagpt.schema import Message
+
+ErrorStr = """Tested passed:
+
+Tests failed:
+assert sort_array([1, 5, 2, 3, 4]) == [1, 2, 3, 4, 5] # output: [1, 2, 4, 3, 5]
+"""
+
+CODE = """
+def sort_array(arr):
+    # Helper function to count the number of ones in the binary representation
+    def count_ones(n):
+        return bin(n).count('1')
+    
+    # Sort the array using a custom key function
+    # The key function returns a tuple (number of ones, value) for each element
+    # This ensures that if two elements have the same number of ones, they are sorted by their value
+    sorted_arr = sorted(arr, key=lambda x: (count_ones(x), x))
+    
+    return sorted_arr
+```
+"""
+
+DebugContext = '''Solve the problem in Python:
+def sort_array(arr):
+    """
+    In this Kata, you have to sort an array of non-negative integers according to
+    number of ones in their binary representation in ascending order.
+    For similar number of ones, sort based on decimal value.
+
+    It must be implemented like this:
+    >>> sort_array([1, 5, 2, 3, 4]) == [1, 2, 3, 4, 5]
+    >>> sort_array([-2, -3, -4, -5, -6]) == [-6, -5, -4, -3, -2]
+    >>> sort_array([1, 0, 2, 3, 4]) [0, 1, 2, 3, 4]
+    """
+'''
+
+
+@pytest.mark.asyncio
+async def test_debug_code():
+    debug_context = Message(content=DebugContext)
+    new_code = await DebugCode().run(context=debug_context, code=CODE, runtime_result=ErrorStr)
+    assert "def sort_array(arr)" in new_code["code"]

tests/metagpt/actions/ci/test_execute_nb_code.py

@@ -0,0 +1,116 @@
+import pytest
+
+from metagpt.actions.ci.execute_nb_code import ExecuteNbCode, truncate
+
+
+@pytest.mark.asyncio
+async def test_code_running():
+    executor = ExecuteNbCode()
+    output, is_success = await executor.run("print('hello world!')")
+    assert is_success
+
+
+@pytest.mark.asyncio
+async def test_split_code_running():
+    executor = ExecuteNbCode()
+    _ = await executor.run("x=1\ny=2")
+    _ = await executor.run("z=x+y")
+    output, is_success = await executor.run("assert z==3")
+    assert is_success
+
+
+@pytest.mark.asyncio
+async def test_execute_error():
+    executor = ExecuteNbCode()
+    output, is_success = await executor.run("z=1/0")
+    assert not is_success
+
+
+PLOT_CODE = """
+import numpy as np
+import matplotlib.pyplot as plt
+
+# 生成随机数据
+random_data = np.random.randn(1000)  # 生成1000个符合标准正态分布的随机数
+
+# 绘制直方图
+plt.hist(random_data, bins=30, density=True, alpha=0.7, color='blue', edgecolor='black')
+
+# 添加标题和标签
+plt.title('Histogram of Random Data')
+plt.xlabel('Value')
+plt.ylabel('Frequency')
+
+# 显示图形
+plt.show()
+plt.close()
+"""
+
+
+@pytest.mark.asyncio
+async def test_plotting_code():
+    executor = ExecuteNbCode()
+    output, is_success = await executor.run(PLOT_CODE)
+    assert is_success
+
+
+def test_truncate():
+    # 代码执行成功
+    output, is_success = truncate("hello world", 5, True)
+    assert "Truncated to show only first 5 characters\nhello" in output
+    assert is_success
+    # 代码执行失败
+    output, is_success = truncate("hello world", 5, False)
+    assert "Truncated to show only last 5 characters\nworld" in output
+    assert not is_success
+    # 异步
+    output, is_success = truncate("<coroutine object", 5, True)
+    assert not is_success
+    assert "await" in output
+
+
+@pytest.mark.asyncio
+async def test_run_with_timeout():
+    executor = ExecuteNbCode(timeout=1)
+    code = "import time; time.sleep(2)"
+    message, success = await executor.run(code)
+    assert not success
+    assert message.startswith("Cell execution timed out")
+
+
+@pytest.mark.asyncio
+async def test_run_code_text():
+    executor = ExecuteNbCode()
+    message, success = await executor.run(code='print("This is a code!")', language="python")
+    assert success
+    assert message == "This is a code!\n"
+    message, success = await executor.run(code="# This is a code!", language="markdown")
+    assert success
+    assert message == "# This is a code!"
+    mix_text = "# Title!\n ```python\n print('This is a code!')```"
+    message, success = await executor.run(code=mix_text, language="markdown")
+    assert success
+    assert message == mix_text
+
+
+@pytest.mark.asyncio
+async def test_terminate():
+    executor = ExecuteNbCode()
+    await executor.run(code='print("This is a code!")', language="python")
+    is_kernel_alive = await executor.nb_client.km.is_alive()
+    assert is_kernel_alive
+    await executor.terminate()
+    import time
+
+    time.sleep(2)
+    assert executor.nb_client.km is None
+
+
+@pytest.mark.asyncio
+async def test_reset():
+    executor = ExecuteNbCode()
+    await executor.run(code='print("This is a code!")', language="python")
+    is_kernel_alive = await executor.nb_client.km.is_alive()
+    assert is_kernel_alive
+    await executor.reset()
+    assert executor.nb_client.km is None

tests/metagpt/actions/ci/test_ml_action.py

@@ -0,0 +1,46 @@
+import pytest
+
+from metagpt.actions.ci.ml_action import WriteCodeWithToolsML
+from metagpt.schema import Plan, Task
+
+
+@pytest.mark.asyncio
+async def test_write_code_with_tools():
+    write_code_ml = WriteCodeWithToolsML()
+
+    task_map = {
+        "1": Task(
+            task_id="1",
+            instruction="随机生成一个pandas DataFrame数据集",
+            task_type="other",
+            dependent_task_ids=[],
+            code="""
+                import pandas as pd
+                df = pd.DataFrame({
+                    'a': [1, 2, 3, 4, 5],
+                    'b': [1.1, 2.2, 3.3, 4.4, np.nan],
+                    'c': ['aa', 'bb', 'cc', 'dd', 'ee'],
+                    'd': [1, 2, 3, 4, 5]
+                })
+                """,
+            is_finished=True,
+        ),
+        "2": Task(
+            task_id="2",
+            instruction="对数据集进行数据清洗",
+            task_type="data_preprocess",
+            dependent_task_ids=["1"],
+        ),
+    }
+    plan = Plan(
+        goal="构造数据集并进行数据清洗",
+        tasks=list(task_map.values()),
+        task_map=task_map,
+        current_task_id="2",
+    )
+    column_info = ""
+
+    _, code_with_ml = await write_code_ml.run([], plan, column_info)
+    code_with_ml = code_with_ml["code"]
+    assert len(code_with_ml) > 0
+    print(code_with_ml)

tests/metagpt/actions/ci/test_write_analysis_code.py

@@ -0,0 +1,324 @@
+import asyncio
+
+import pytest
+
+from metagpt.actions.ci.execute_nb_code import ExecuteNbCode
+from metagpt.actions.ci.write_analysis_code import (
+    WriteCodeWithoutTools,
+    WriteCodeWithTools,
+)
+from metagpt.logs import logger
+from metagpt.schema import Message, Plan, Task
+from metagpt.strategy.planner import STRUCTURAL_CONTEXT
+
+
+@pytest.mark.skip
+@pytest.mark.asyncio
+async def test_write_code_by_list_plan():
+    write_code = WriteCodeWithoutTools()
+    execute_code = ExecuteNbCode()
+    messages = []
+    plan = ["随机生成一个pandas DataFrame时间序列", "绘制这个时间序列的直方图", "回顾已完成的任务", "求均值", "总结"]
+    for task in plan:
+        print(f"\n任务: {task}\n\n")
+        messages.append(Message(task, role="assistant"))
+        code = await write_code.run(messages)
+        if task.startswith(("回顾", "总结")):
+            assert code["language"] == "markdown"
+        else:
+            assert code["language"] == "python"
+        messages.append(Message(code["code"], role="assistant"))
+        assert len(code) > 0
+        output, _ = await execute_code.run(**code)
+        print(f"\n[Output]: 任务{task}的执行结果是: \n{output}\n")
+        messages.append(output)
+
+
+@pytest.mark.asyncio
+async def test_tool_recommendation():
+    task = "clean and preprocess the data"
+    available_tools = {
+        "FillMissingValue": "Filling missing values",
+        "SplitBins": "Bin continuous data into intervals and return the bin identifier encoded as an integer value",
+    }
+    write_code = WriteCodeWithTools()
+    tools = await write_code._recommend_tool(task, available_tools)
+
+    assert len(tools) == 1
+    assert "FillMissingValue" in tools
+
+
+@pytest.mark.asyncio
+async def test_write_code_with_tools():
+    write_code = WriteCodeWithTools()
+
+    requirement = "构造数据集并进行数据清洗"
+    task_map = {
+        "1": Task(
+            task_id="1",
+            instruction="随机生成一个pandas DataFrame数据集",
+            task_type="other",
+            dependent_task_ids=[],
+            code="""
+                import pandas as pd
+                df = pd.DataFrame({
+                    'a': [1, 2, 3, 4, 5],
+                    'b': [1.1, 2.2, 3.3, 4.4, np.nan],
+                    'c': ['aa', 'bb', 'cc', 'dd', 'ee'],
+                    'd': [1, 2, 3, 4, 5]
+                })
+                """,
+            is_finished=True,
+        ),
+        "2": Task(
+            task_id="2",
+            instruction="对数据集进行数据清洗",
+            task_type="data_preprocess",
+            dependent_task_ids=["1"],
+        ),
+    }
+    plan = Plan(
+        goal="构造数据集并进行数据清洗",
+        tasks=list(task_map.values()),
+        task_map=task_map,
+        current_task_id="2",
+    )
+
+    context = STRUCTURAL_CONTEXT.format(
+        user_requirement=requirement,
+        context=plan.context,
+        tasks=list(task_map.values()),
+        current_task=plan.current_task.model_dump_json(),
+    )
+    context_msg = [Message(content=context, role="user")]
+
+    code = await write_code.run(context_msg, plan)
+    code = code["code"]
+    assert len(code) > 0
+    print(code)
+
+
+@pytest.mark.asyncio
+async def test_write_code_to_correct_error():
+    structural_context = """
+    ## User Requirement
+    read a dataset test.csv and print its head
+    ## Current Plan
+    [
+        {
+            "task_id": "1",
+            "dependent_task_ids": [],
+            "instruction": "import pandas and load the dataset from 'test.csv'.",
+            "task_type": "",
+            "code": "",
+            "result": "",
+            "is_finished": false
+        },
+        {
+            "task_id": "2",
+            "dependent_task_ids": [
+                "1"
+            ],
+            "instruction": "Print the head of the dataset to display the first few rows.",
+            "task_type": "",
+            "code": "",
+            "result": "",
+            "is_finished": false
+        }
+    ]
+    ## Current Task
+    {"task_id": "1", "dependent_task_ids": [], "instruction": "import pandas and load the dataset from 'test.csv'.", "task_type": "", "code": "", "result": "", "is_finished": false}
+    """
+    wrong_code = """import pandas as pd\ndata = pd.read_excel('test.csv')\ndata"""  # use read_excel to read a csv
+    error = """
+    Traceback (most recent call last):
+        File "<stdin>", line 2, in <module>
+        File "/Users/gary/miniconda3/envs/py39_scratch/lib/python3.9/site-packages/pandas/io/excel/_base.py", line 478, in read_excel
+            io = ExcelFile(io, storage_options=storage_options, engine=engine)
+        File "/Users/gary/miniconda3/envs/py39_scratch/lib/python3.9/site-packages/pandas/io/excel/_base.py", line 1500, in __init__
+            raise ValueError(
+        ValueError: Excel file format cannot be determined, you must specify an engine manually.
+    """
+    context = [
+        Message(content=structural_context, role="user"),
+        Message(content=wrong_code, role="assistant"),
+        Message(content=error, role="user"),
+    ]
+    new_code = await WriteCodeWithoutTools().run(context=context)
+    new_code = new_code["code"]
+    print(new_code)
+    assert "read_csv" in new_code  # should correct read_excel to read_csv
+
+
+@pytest.mark.asyncio
+async def test_write_code_reuse_code_simple():
+    structural_context = """
+    ## User Requirement
+    read a dataset test.csv and print its head
+    ## Current Plan
+    [
+        {
+            "task_id": "1",
+            "dependent_task_ids": [],
+            "instruction": "import pandas and load the dataset from 'test.csv'.",
+            "task_type": "",
+            "code": "import pandas as pd\ndata = pd.read_csv('test.csv')",
+            "result": "",
+            "is_finished": true
+        },
+        {
+            "task_id": "2",
+            "dependent_task_ids": [
+                "1"
+            ],
+            "instruction": "Print the head of the dataset to display the first few rows.",
+            "task_type": "",
+            "code": "",
+            "result": "",
+            "is_finished": false
+        }
+    ]
+    ## Current Task
+    {"task_id": "2", "dependent_task_ids": ["1"], "instruction": "Print the head of the dataset to display the first few rows.", "task_type": "", "code": "", "result": "", "is_finished": false}
+    """
+    context = [
+        Message(content=structural_context, role="user"),
+    ]
+    code = await WriteCodeWithoutTools().run(context=context)
+    code = code["code"]
+    print(code)
+    assert "pandas" not in code and "read_csv" not in code  # should reuse import and read statement from previous one
+
+
+@pytest.mark.skip
+@pytest.mark.asyncio
+async def test_write_code_reuse_code_long():
+    """test code reuse for long context"""
+
+    structural_context = """
+    ## User Requirement
+    Run data analysis on sklearn Iris dataset, include a plot
+    ## Current Plan
+    [
+        {
+            "task_id": "1",
+            "dependent_task_ids": [],
+            "instruction": "Load the Iris dataset from sklearn.",
+            "task_type": "",
+            "code": "from sklearn.datasets import load_iris\niris_data = load_iris()\niris_data['data'][0:5], iris_data['target'][0:5]",
+            "result": "(array([[5.1, 3.5, 1.4, 0.2],\n        [4.9, 3. , 1.4, 0.2],\n        [4.7, 3.2, 1.3, 0.2],\n        [4.6, 3.1, 1.5, 0.2],\n        [5. , 3.6, 1.4, 0.2]]),\n array([0, 0, 0, 0, 0]))",
+            "is_finished": true
+        },
+        {
+            "task_id": "2",
+            "dependent_task_ids": [
+                "1"
+            ],
+            "instruction": "Perform exploratory data analysis on the Iris dataset.",
+            "task_type": "",
+            "code": "",
+            "result": "",
+            "is_finished": false
+        },
+        {
+            "task_id": "3",
+            "dependent_task_ids": [
+                "2"
+            ],
+            "instruction": "Create a plot visualizing the Iris dataset features.",
+            "task_type": "",
+            "code": "",
+            "result": "",
+            "is_finished": false
+        }
+    ]
+    ## Current Task
+    {"task_id": "2", "dependent_task_ids": ["1"], "instruction": "Perform exploratory data analysis on the Iris dataset.", "task_type": "", "code": "", "result": "", "is_finished": false}
+    """
+    context = [
+        Message(content=structural_context, role="user"),
+    ]
+    trials_num = 5
+    trials = [WriteCodeWithoutTools().run(context=context, temperature=0.0) for _ in range(trials_num)]
+    trial_results = await asyncio.gather(*trials)
+    print(*trial_results, sep="\n\n***\n\n")
+    success = [
+        "load_iris" not in result["code"] and "iris_data" in result["code"] for result in trial_results
+    ]  # should reuse iris_data from previous tasks
+    success_rate = sum(success) / trials_num
+    logger.info(f"success rate: {success_rate :.2f}")
+    assert success_rate >= 0.8
+
+
+@pytest.mark.skip
+@pytest.mark.asyncio
+async def test_write_code_reuse_code_long_for_wine():
+    """test code reuse for long context"""
+
+    structural_context = """
+    ## User Requirement
+    Run data analysis on sklearn Wisconsin Breast Cancer dataset, include a plot, train a model to predict targets (20% as validation), and show validation accuracy
+    ## Current Plan
+    [
+        {
+            "task_id": "1",
+            "dependent_task_ids": [],
+            "instruction": "Load the sklearn Wine recognition dataset and perform exploratory data analysis."
+            "task_type": "",
+            "code": "from sklearn.datasets import load_wine\n# Load the Wine recognition dataset\nwine_data = load_wine()\n# Perform exploratory data analysis\nwine_data.keys()",
+            "result": "Truncated to show only the last 1000 characters\ndict_keys(['data', 'target', 'frame', 'target_names', 'DESCR', 'feature_names'])",
+            "is_finished": true
+        },
+        {
+            "task_id": "2",
+            "dependent_task_ids": ["1"],
+            "instruction": "Create a plot to visualize some aspect of the wine dataset."
+            "task_type": "",
+            "code": "",
+            "result": "",
+            "is_finished": false
+        },
+        {
+            "task_id": "3",
+            "dependent_task_ids": ["1"],
+            "instruction": "Split the dataset into training and validation sets with a 20% validation size.",
+            "task_type": "",
+            "code": "",
+            "result": "",
+            "is_finished": false
+        },
+        {
+            "task_id": "4",
+            "dependent_task_ids": ["3"],
+            "instruction": "Train a model on the training set to predict wine class.",
+            "task_type": "",
+            "code": "",
+            "result": "",
+            "is_finished": false
+        },
+        {
+            "task_id": "5",
+            "dependent_task_ids": ["4"],
+            "instruction": "Evaluate the model on the validation set and report the accuracy.",
+            "task_type": "",
+            "code": "",
+            "result": "",
+            "is_finished": false
+        }
+    ]
+    ## Current Task
+    {"task_id": "2", "dependent_task_ids": ["1"], "instruction": "Create a plot to visualize some aspect of the Wine dataset.", "task_type": "", "code": "", "result": "", "is_finished": false}
+    """
+    context = [
+        Message(content=structural_context, role="user"),
+    ]
+    trials_num = 5
+    trials = [WriteCodeWithoutTools().run(context=context, temperature=0.0) for _ in range(trials_num)]
+    trial_results = await asyncio.gather(*trials)
+    print(*trial_results, sep="\n\n***\n\n")
+    success = [
+        "load_wine" not in result["code"] and "wine_data" in result["code"] for result in trial_results
+    ]  # should reuse iris_data from previous tasks
+    success_rate = sum(success) / trials_num
+    logger.info(f"success rate: {success_rate :.2f}")
+    assert success_rate >= 0.8

tests/metagpt/actions/ci/test_write_plan.py

@@ -0,0 +1,34 @@
+import pytest
+
+from metagpt.actions.ci.write_plan import (
+    Plan,
+    Task,
+    WritePlan,
+    precheck_update_plan_from_rsp,
+)
+from metagpt.schema import Message
+
+
+def test_precheck_update_plan_from_rsp():
+    plan = Plan(goal="")
+    plan.add_tasks([Task(task_id="1")])
+    rsp = '[{"task_id": "2"}]'
+    success, _ = precheck_update_plan_from_rsp(rsp, plan)
+    assert success
+    assert len(plan.tasks) == 1 and plan.tasks[0].task_id == "1"  # precheck should not change the original one
+
+    invalid_rsp = "wrong"
+    success, _ = precheck_update_plan_from_rsp(invalid_rsp, plan)
+    assert not success
+
+
+@pytest.mark.asyncio
+@pytest.mark.parametrize("use_tools", [(False), (True)])
+async def test_write_plan(use_tools):
+    rsp = await WritePlan().run(
+        context=[Message("run analysis on sklearn iris dataset", role="user")], use_tools=use_tools
+    )
+
+    assert "task_id" in rsp
+    assert "instruction" in rsp
+    assert "json" not in rsp  # the output should be the content inside ```json ```

tests/metagpt/actions/test_action_node.py

@@ -5,10 +5,11 @@
 @Author  : alexanderwu
 @File    : test_action_node.py
 """
+from pathlib import Path
 from typing import List, Tuple
 
 import pytest
-from pydantic import ValidationError
+from pydantic import BaseModel, Field, ValidationError
 
 from metagpt.actions import Action
 from metagpt.actions.action_node import ActionNode, ReviewMode, ReviseMode
@@ -17,6 +18,7 @@ from metagpt.llm import LLM
 from metagpt.roles import Role
 from metagpt.schema import Message
 from metagpt.team import Team
+from metagpt.utils.common import encode_image
 
 
 @pytest.mark.asyncio
@@ -241,6 +243,65 @@ def test_create_model_class_with_mapping():
     assert value == ["game.py", "app.py", "static/css/styles.css", "static/js/script.js", "templates/index.html"]
 
 
+@pytest.mark.asyncio
+async def test_action_node_with_image(mocker):
+    # add a mock to update model in unittest, due to the gloabl MockLLM
+    def _cons_kwargs(self, messages: list[dict], timeout=3, **extra_kwargs) -> dict:
+        kwargs = {"messages": messages, "temperature": 0.3, "model": "gpt-4-vision-preview"}
+        return kwargs
+
+    invoice = ActionNode(
+        key="invoice", expected_type=bool, instruction="if it's a invoice file, return True else False", example="False"
+    )
+
+    invoice_path = Path(__file__).parent.joinpath("..", "..", "data", "invoices", "invoice-2.png")
+    img_base64 = encode_image(invoice_path)
+    mocker.patch("metagpt.provider.openai_api.OpenAILLM._cons_kwargs", _cons_kwargs)
+    node = await invoice.fill(context="", llm=LLM(), images=[img_base64])
+    assert node.instruct_content.invoice
+
+
+class ToolDef(BaseModel):
+    tool_name: str = Field(default="a", description="tool name", examples=[])
+    description: str = Field(default="b", description="tool description", examples=[])
+
+
+class Task(BaseModel):
+    task_id: int = Field(default=1, description="task id", examples=[1, 2, 3])
+    name: str = Field(default="Get data from ...", description="task name", examples=[])
+    dependent_task_ids: List[int] = Field(default=[], description="dependent task ids", examples=[1, 2, 3])
+    tool: ToolDef = Field(default=ToolDef(), description="tool use", examples=[])
+
+
+class Tasks(BaseModel):
+    tasks: List[Task] = Field(default=[], description="tasks", examples=[])
+
+
+def test_action_node_from_pydantic_and_print_everything():
+    node = ActionNode.from_pydantic(Task)
+    print("1. Tasks")
+    print(Task().model_dump_json(indent=4))
+    print(Tasks.model_json_schema())
+    print("2. Task")
+    print(Task.model_json_schema())
+    print("3. ActionNode")
+    print(node)
+    print("4. node.compile prompt")
+    prompt = node.compile(context="")
+    assert "tool_name" in prompt, "tool_name should be in prompt"
+    print(prompt)
+    print("5. node.get_children_mapping")
+    print(node._get_children_mapping())
+    print("6. node.create_children_class")
+    children_class = node._create_children_class()
+    print(children_class)
+    import inspect
+
+    code = inspect.getsource(Tasks)
+    print(code)
+    assert "tasks" in code, "tasks should be in code"
+
+
 if __name__ == "__main__":
     test_create_model_class()
     test_create_model_class_with_mapping()

tests/metagpt/actions/test_debug_error.py

@@ -11,9 +11,7 @@ import uuid
 import pytest
 
 from metagpt.actions.debug_error import DebugError
-from metagpt.context import CONTEXT
 from metagpt.schema import RunCodeContext, RunCodeResult
-from metagpt.utils.project_repo import ProjectRepo
 
 CODE_CONTENT = '''
 from typing import List
@@ -116,9 +114,8 @@ if __name__ == '__main__':
 
 
 @pytest.mark.asyncio
-async def test_debug_error():
-    CONTEXT.src_workspace = CONTEXT.git_repo.workdir / uuid.uuid4().hex
-    project_repo = ProjectRepo(CONTEXT.git_repo)
+async def test_debug_error(context):
+    context.src_workspace = context.git_repo.workdir / uuid.uuid4().hex
     ctx = RunCodeContext(
         code_filename="player.py",
         test_filename="test_player.py",
@@ -126,8 +123,8 @@ async def test_debug_error():
         output_filename="output.log",
     )
 
-    await project_repo.with_src_path(CONTEXT.src_workspace).srcs.save(filename=ctx.code_filename, content=CODE_CONTENT)
-    await project_repo.tests.save(filename=ctx.test_filename, content=TEST_CONTENT)
+    await context.repo.with_src_path(context.src_workspace).srcs.save(filename=ctx.code_filename, content=CODE_CONTENT)
+    await context.repo.tests.save(filename=ctx.test_filename, content=TEST_CONTENT)
     output_data = RunCodeResult(
         stdout=";",
         stderr="",
@@ -141,8 +138,8 @@ async def test_debug_error():
         "----------------------------------------------------------------------\n"
         "Ran 5 tests in 0.007s\n\nFAILED (failures=1)\n;\n",
     )
-    await project_repo.test_outputs.save(filename=ctx.output_filename, content=output_data.model_dump_json())
-    debug_error = DebugError(i_context=ctx)
+    await context.repo.test_outputs.save(filename=ctx.output_filename, content=output_data.model_dump_json())
+    debug_error = DebugError(i_context=ctx, context=context)
 
     rsp = await debug_error.run()
 

tests/metagpt/actions/test_design_api.py

@@ -9,20 +9,17 @@
 import pytest
 
 from metagpt.actions.design_api import WriteDesign
-from metagpt.context import CONTEXT
 from metagpt.logs import logger
 from metagpt.schema import Message
-from metagpt.utils.project_repo import ProjectRepo
 
 
 @pytest.mark.asyncio
-async def test_design_api():
+async def test_design_api(context):
     inputs = ["我们需要一个音乐播放器，它应该有播放、暂停、上一曲、下一曲等功能。"]  # PRD_SAMPLE
-    project_repo = ProjectRepo(CONTEXT.git_repo)
     for prd in inputs:
-        await project_repo.docs.prd.save(filename="new_prd.txt", content=prd)
+        await context.repo.docs.prd.save(filename="new_prd.txt", content=prd)
 
-        design_api = WriteDesign()
+        design_api = WriteDesign(context=context)
 
         result = await design_api.run(Message(content=prd, instruct_content=None))
         logger.info(result)

tests/metagpt/actions/test_design_api_an.py

@@ -0,0 +1,46 @@
+#!/usr/bin/env python
+# -*- coding: utf-8 -*-
+"""
+@Time    : 2024/01/03
+@Author  : mannaandpoem
+@File    : test_design_api_an.py
+"""
+import pytest
+from openai._models import BaseModel
+
+from metagpt.actions.action_node import ActionNode, dict_to_markdown
+from metagpt.actions.design_api import NEW_REQ_TEMPLATE
+from metagpt.actions.design_api_an import REFINED_DESIGN_NODE
+from metagpt.llm import LLM
+from tests.data.incremental_dev_project.mock import (
+    DESIGN_SAMPLE,
+    REFINED_DESIGN_JSON,
+    REFINED_PRD_JSON,
+)
+
+
+@pytest.fixture()
+def llm():
+    return LLM()
+
+
+def mock_refined_design_json():
+    return REFINED_DESIGN_JSON
+
+
+@pytest.mark.asyncio
+async def test_write_design_an(mocker):
+    root = ActionNode.from_children(
+        "RefinedDesignAPI", [ActionNode(key="", expected_type=str, instruction="", example="")]
+    )
+    root.instruct_content = BaseModel()
+    root.instruct_content.model_dump = mock_refined_design_json
+    mocker.patch("metagpt.actions.design_api_an.REFINED_DESIGN_NODE.fill", return_value=root)
+
+    prompt = NEW_REQ_TEMPLATE.format(old_design=DESIGN_SAMPLE, context=dict_to_markdown(REFINED_PRD_JSON))
+    node = await REFINED_DESIGN_NODE.fill(prompt, llm)
+
+    assert "Refined Implementation Approach" in node.instruct_content.model_dump()
+    assert "Refined File list" in node.instruct_content.model_dump()
+    assert "Refined Data structures and interfaces" in node.instruct_content.model_dump()
+    assert "Refined Program call flow" in node.instruct_content.model_dump()

tests/metagpt/actions/test_design_api_review.py

@@ -11,7 +11,7 @@ from metagpt.actions.design_api_review import DesignReview
 
 
 @pytest.mark.asyncio
-async def test_design_api_review():
+async def test_design_api_review(context):
     prd = "我们需要一个音乐播放器，它应该有播放、暂停、上一曲、下一曲等功能。"
     api_design = """
 数据结构:
@@ -26,7 +26,7 @@ API列表:
 """
     _ = "API设计看起来非常合理，满足了PRD中的所有需求。"
 
-    design_api_review = DesignReview()
+    design_api_review = DesignReview(context=context)
 
     result = await design_api_review.run(prd, api_design)
 

tests/metagpt/actions/test_fix_bug.py

@@ -12,6 +12,6 @@ from metagpt.actions.fix_bug import FixBug
 
 
 @pytest.mark.asyncio
-async def test_fix_bug():
-    fix_bug = FixBug()
+async def test_fix_bug(context):
+    fix_bug = FixBug(context=context)
     assert fix_bug.name == "FixBug"

tests/metagpt/actions/test_generate_questions.py

@@ -10,7 +10,7 @@ import pytest
 from metagpt.actions.generate_questions import GenerateQuestions
 from metagpt.logs import logger
 
-context = """
+msg = """
 ## topic
 如何做一个生日蛋糕
 
@@ -20,9 +20,9 @@ context = """
 
 
 @pytest.mark.asyncio
-async def test_generate_questions():
-    action = GenerateQuestions()
-    rsp = await action.run(context)
+async def test_generate_questions(context):
+    action = GenerateQuestions(context=context)
+    rsp = await action.run(msg)
     logger.info(f"{rsp.content=}")
 
     assert "Questions" in rsp.content

tests/metagpt/actions/test_invoice_ocr.py

@@ -23,9 +23,9 @@ from metagpt.const import TEST_DATA_PATH
         Path("invoices/invoice-4.zip"),
     ],
 )
-async def test_invoice_ocr(invoice_path: Path):
+async def test_invoice_ocr(invoice_path: Path, context):
     invoice_path = TEST_DATA_PATH / invoice_path
-    resp = await InvoiceOCR().run(file_path=Path(invoice_path))
+    resp = await InvoiceOCR(context=context).run(file_path=Path(invoice_path))
     assert isinstance(resp, list)
 
 

tests/metagpt/actions/test_prepare_documents.py

@@ -10,21 +10,18 @@ import pytest
 
 from metagpt.actions.prepare_documents import PrepareDocuments
 from metagpt.const import REQUIREMENT_FILENAME
-from metagpt.context import CONTEXT
+from metagpt.context import Context
 from metagpt.schema import Message
-from metagpt.utils.project_repo import ProjectRepo
 
 
 @pytest.mark.asyncio
 async def test_prepare_documents():
     msg = Message(content="New user requirements balabala...")
+    context = Context()
 
-    if CONTEXT.git_repo:
-        CONTEXT.git_repo.delete_repository()
-        CONTEXT.git_repo = None
-
-    await PrepareDocuments(context=CONTEXT).run(with_messages=[msg])
-    assert CONTEXT.git_repo
-    doc = await ProjectRepo(CONTEXT.git_repo).docs.get(filename=REQUIREMENT_FILENAME)
+    await PrepareDocuments(context=context).run(with_messages=[msg])
+    assert context.git_repo
+    assert context.repo
+    doc = await context.repo.docs.get(filename=REQUIREMENT_FILENAME)
     assert doc
     assert doc.content == msg.content

tests/metagpt/actions/test_prepare_interview.py

@@ -12,8 +12,8 @@ from metagpt.logs import logger
 
 
 @pytest.mark.asyncio
-async def test_prepare_interview():
-    action = PrepareInterview()
+async def test_prepare_interview(context):
+    action = PrepareInterview(context=context)
     rsp = await action.run("I just graduated and hope to find a job as a Python engineer")
     logger.info(f"{rsp.content=}")
 

tests/metagpt/actions/test_project_management.py

@@ -9,21 +9,18 @@
 import pytest
 
 from metagpt.actions.project_management import WriteTasks
-from metagpt.context import CONTEXT
 from metagpt.logs import logger
 from metagpt.schema import Message
-from metagpt.utils.project_repo import ProjectRepo
 from tests.metagpt.actions.mock_json import DESIGN, PRD
 
 
 @pytest.mark.asyncio
-async def test_design_api():
-    project_repo = ProjectRepo(CONTEXT.git_repo)
-    await project_repo.docs.prd.save("1.txt", content=str(PRD))
-    await project_repo.docs.system_design.save("1.txt", content=str(DESIGN))
-    logger.info(CONTEXT.git_repo)
+async def test_design_api(context):
+    await context.repo.docs.prd.save("1.txt", content=str(PRD))
+    await context.repo.docs.system_design.save("1.txt", content=str(DESIGN))
+    logger.info(context.git_repo)
 
-    action = WriteTasks()
+    action = WriteTasks(context=context)
 
     result = await action.run(Message(content="", instruct_content=None))
     logger.info(result)

tests/metagpt/actions/test_project_management_an.py

@@ -0,0 +1,45 @@
+#!/usr/bin/env python
+# -*- coding: utf-8 -*-
+"""
+@Time    : 2024/01/03
+@Author  : mannaandpoem
+@File    : test_project_management_an.py
+"""
+import pytest
+from openai._models import BaseModel
+
+from metagpt.actions.action_node import ActionNode, dict_to_markdown
+from metagpt.actions.project_management import NEW_REQ_TEMPLATE
+from metagpt.actions.project_management_an import REFINED_PM_NODE
+from metagpt.llm import LLM
+from tests.data.incremental_dev_project.mock import (
+    REFINED_DESIGN_JSON,
+    REFINED_TASKS_JSON,
+    TASKS_SAMPLE,
+)
+
+
+@pytest.fixture()
+def llm():
+    return LLM()
+
+
+def mock_refined_tasks_json():
+    return REFINED_TASKS_JSON
+
+
+@pytest.mark.asyncio
+async def test_project_management_an(mocker):
+    root = ActionNode.from_children(
+        "RefinedProjectManagement", [ActionNode(key="", expected_type=str, instruction="", example="")]
+    )
+    root.instruct_content = BaseModel()
+    root.instruct_content.model_dump = mock_refined_tasks_json
+    mocker.patch("metagpt.actions.project_management_an.REFINED_PM_NODE.fill", return_value=root)
+
+    prompt = NEW_REQ_TEMPLATE.format(old_task=TASKS_SAMPLE, context=dict_to_markdown(REFINED_DESIGN_JSON))
+    node = await REFINED_PM_NODE.fill(prompt, llm)
+
+    assert "Refined Logic Analysis" in node.instruct_content.model_dump()
+    assert "Refined Task list" in node.instruct_content.model_dump()
+    assert "Refined Shared Knowledge" in node.instruct_content.model_dump()

tests/metagpt/actions/test_rebuild_class_view.py

@@ -11,27 +11,28 @@ from pathlib import Path
 import pytest
 
 from metagpt.actions.rebuild_class_view import RebuildClassView
-from metagpt.const import GRAPH_REPO_FILE_REPO
-from metagpt.context import CONTEXT
 from metagpt.llm import LLM
 
 
+@pytest.mark.skip
 @pytest.mark.asyncio
-async def test_rebuild():
+async def test_rebuild(context):
     action = RebuildClassView(
-        name="RedBean", i_context=str(Path(__file__).parent.parent.parent.parent / "metagpt"), llm=LLM()
+        name="RedBean",
+        i_context=str(Path(__file__).parent.parent.parent.parent / "metagpt"),
+        llm=LLM(),
+        context=context,
     )
     await action.run()
-    graph_file_repo = CONTEXT.git_repo.new_file_repository(relative_path=GRAPH_REPO_FILE_REPO)
-    assert graph_file_repo.changed_files
+    assert context.repo.docs.graph_repo.changed_files
 
 
 @pytest.mark.parametrize(
     ("path", "direction", "diff", "want"),
     [
-        ("metagpt/startup.py", "=", ".", "metagpt/startup.py"),
-        ("metagpt/startup.py", "+", "MetaGPT", "MetaGPT/metagpt/startup.py"),
-        ("metagpt/startup.py", "-", "metagpt", "startup.py"),
+        ("metagpt/software_company.py", "=", ".", "metagpt/software_company.py"),
+        ("metagpt/software_company.py", "+", "MetaGPT", "MetaGPT/metagpt/software_company.py"),
+        ("metagpt/software_company.py", "-", "metagpt", "software_company.py"),
     ],
 )
 def test_align_path(path, direction, diff, want):

tests/metagpt/actions/test_rebuild_sequence_view.py

@@ -11,28 +11,29 @@ import pytest
 
 from metagpt.actions.rebuild_sequence_view import RebuildSequenceView
 from metagpt.const import GRAPH_REPO_FILE_REPO
-from metagpt.context import CONTEXT
 from metagpt.llm import LLM
 from metagpt.utils.common import aread
 from metagpt.utils.git_repository import ChangeType
-from metagpt.utils.project_repo import ProjectRepo
 
 
 @pytest.mark.asyncio
-async def test_rebuild():
+@pytest.mark.skip
+async def test_rebuild(context):
     # Mock
     data = await aread(filename=Path(__file__).parent / "../../data/graph_db/networkx.json")
-    graph_db_filename = Path(CONTEXT.git_repo.workdir.name).with_suffix(".json")
-    project_repo = ProjectRepo(CONTEXT.git_repo)
-    await project_repo.docs.graph_repo.save(filename=str(graph_db_filename), content=data)
-    CONTEXT.git_repo.add_change({f"{GRAPH_REPO_FILE_REPO}/{graph_db_filename}": ChangeType.UNTRACTED})
-    CONTEXT.git_repo.commit("commit1")
+    graph_db_filename = Path(context.repo.workdir.name).with_suffix(".json")
+    await context.repo.docs.graph_repo.save(filename=str(graph_db_filename), content=data)
+    context.git_repo.add_change({f"{GRAPH_REPO_FILE_REPO}/{graph_db_filename}": ChangeType.UNTRACTED})
+    context.git_repo.commit("commit1")
 
     action = RebuildSequenceView(
-        name="RedBean", i_context=str(Path(__file__).parent.parent.parent.parent / "metagpt"), llm=LLM()
+        name="RedBean",
+        i_context=str(Path(__file__).parent.parent.parent.parent / "metagpt"),
+        llm=LLM(),
+        context=context,
     )
     await action.run()
-    assert project_repo.docs.graph_repo.changed_files
+    assert context.repo.docs.graph_repo.changed_files
 
 
 @pytest.mark.parametrize(

tests/metagpt/actions/test_research.py

@@ -14,7 +14,7 @@ from metagpt.tools.search_engine import SearchEngine
 
 
 @pytest.mark.asyncio
-async def test_collect_links(mocker, search_engine_mocker):
+async def test_collect_links(mocker, search_engine_mocker, context):
     async def mock_llm_ask(self, prompt: str, system_msgs):
         if "Please provide up to 2 necessary keywords" in prompt:
             return '["metagpt", "llm"]'
@@ -28,15 +28,15 @@ async def test_collect_links(mocker, search_engine_mocker):
             return "[1,2]"
 
     mocker.patch("metagpt.provider.base_llm.BaseLLM.aask", mock_llm_ask)
-    resp = await research.CollectLinks(search_engine=SearchEngine(SearchEngineType.DUCK_DUCK_GO)).run(
-        "The application of MetaGPT"
-    )
+    resp = await research.CollectLinks(
+        search_engine=SearchEngine(engine=SearchEngineType.DUCK_DUCK_GO), context=context
+    ).run("The application of MetaGPT")
     for i in ["MetaGPT use cases", "The roadmap of MetaGPT", "The function of MetaGPT", "What llm MetaGPT support"]:
         assert i in resp
 
 
 @pytest.mark.asyncio
-async def test_collect_links_with_rank_func(mocker, search_engine_mocker):
+async def test_collect_links_with_rank_func(mocker, search_engine_mocker, context):
     rank_before = []
     rank_after = []
     url_per_query = 4
@@ -50,7 +50,9 @@ async def test_collect_links_with_rank_func(mocker, search_engine_mocker):
 
     mocker.patch("metagpt.provider.base_llm.BaseLLM.aask", mock_collect_links_llm_ask)
     resp = await research.CollectLinks(
-        search_engine=SearchEngine(SearchEngineType.DUCK_DUCK_GO), rank_func=rank_func
+        search_engine=SearchEngine(engine=SearchEngineType.DUCK_DUCK_GO),
+        rank_func=rank_func,
+        context=context,
     ).run("The application of MetaGPT")
     for x, y, z in zip(rank_before, rank_after, resp.values()):
         assert x[::-1] == y
@@ -58,7 +60,7 @@ async def test_collect_links_with_rank_func(mocker, search_engine_mocker):
 
 
 @pytest.mark.asyncio
-async def test_web_browse_and_summarize(mocker):
+async def test_web_browse_and_summarize(mocker, context):
     async def mock_llm_ask(*args, **kwargs):
         return "metagpt"
 
@@ -66,20 +68,20 @@ async def test_web_browse_and_summarize(mocker):
     url = "https://github.com/geekan/MetaGPT"
     url2 = "https://github.com/trending"
     query = "What's new in metagpt"
-    resp = await research.WebBrowseAndSummarize().run(url, query=query)
+    resp = await research.WebBrowseAndSummarize(context=context).run(url, query=query)
 
     assert len(resp) == 1
     assert url in resp
     assert resp[url] == "metagpt"
 
-    resp = await research.WebBrowseAndSummarize().run(url, url2, query=query)
+    resp = await research.WebBrowseAndSummarize(context=context).run(url, url2, query=query)
     assert len(resp) == 2
 
     async def mock_llm_ask(*args, **kwargs):
         return "Not relevant."
 
     mocker.patch("metagpt.provider.base_llm.BaseLLM.aask", mock_llm_ask)
-    resp = await research.WebBrowseAndSummarize().run(url, query=query)
+    resp = await research.WebBrowseAndSummarize(context=context).run(url, query=query)
 
     assert len(resp) == 1
     assert url in resp
@@ -87,7 +89,7 @@ async def test_web_browse_and_summarize(mocker):
 
 
 @pytest.mark.asyncio
-async def test_conduct_research(mocker):
+async def test_conduct_research(mocker, context):
     data = None
 
     async def mock_llm_ask(*args, **kwargs):
@@ -101,7 +103,7 @@ async def test_conduct_research(mocker):
         "outputs user stories / competitive analysis / requirements / data structures / APIs / documents, etc."
     )
 
-    resp = await research.ConductResearch().run("The application of MetaGPT", content)
+    resp = await research.ConductResearch(context=context).run("The application of MetaGPT", content)
     assert resp == data
 
 

tests/metagpt/actions/test_run_code.py

@@ -24,21 +24,21 @@ async def test_run_text():
 
 
 @pytest.mark.asyncio
-async def test_run_script():
+async def test_run_script(context):
     # Successful command
-    out, err = await RunCode().run_script(".", command=["echo", "Hello World"])
+    out, err = await RunCode(context=context).run_script(".", command=["echo", "Hello World"])
     assert out.strip() == "Hello World"
     assert err == ""
 
     # Unsuccessful command
-    out, err = await RunCode().run_script(".", command=["python", "-c", "print(1/0)"])
+    out, err = await RunCode(context=context).run_script(".", command=["python", "-c", "print(1/0)"])
     assert "ZeroDivisionError" in err
 
 
 @pytest.mark.asyncio
-async def test_run():
+async def test_run(context):
     inputs = [
-        (RunCodeContext(mode="text", code_filename="a.txt", code="print('Hello, World')"), "PASS"),
+        (RunCodeContext(mode="text", code_filename="a.txt", code="result = 'helloworld'"), "PASS"),
         (
             RunCodeContext(
                 mode="script",
@@ -61,5 +61,5 @@ async def test_run():
         ),
     ]
     for ctx, result in inputs:
-        rsp = await RunCode(i_context=ctx).run()
+        rsp = await RunCode(i_context=ctx, context=context).run()
         assert result in rsp.summary

tests/metagpt/actions/test_skill_action.py

@@ -23,9 +23,9 @@ class TestSkillAction:
                     "type": "string",
                     "description": "OpenAI API key, For more details, checkout: `https://platform.openai.com/account/api-keys`",
                 },
-                "METAGPT_TEXT_TO_IMAGE_MODEL_URL": {"type": "string", "description": "Model url."},
+                "metagpt_tti_url": {"type": "string", "description": "Model url."},
             },
-            "required": {"oneOf": ["OPENAI_API_KEY", "METAGPT_TEXT_TO_IMAGE_MODEL_URL"]},
+            "required": {"oneOf": ["OPENAI_API_KEY", "metagpt_tti_url"]},
         },
         parameters={
             "text": Parameter(type="string", description="The text used for image conversion."),
@@ -47,18 +47,18 @@ class TestSkillAction:
         assert args.get("size_type") == "512x512"
 
     @pytest.mark.asyncio
-    async def test_parser_action(self, mocker):
+    async def test_parser_action(self, mocker, context):
         # mock
         mocker.patch("metagpt.learn.text_to_image", return_value="https://mock.com/xxx")
 
-        parser_action = ArgumentsParingAction(skill=self.skill, ask="Draw an apple")
+        parser_action = ArgumentsParingAction(skill=self.skill, ask="Draw an apple", context=context)
         rsp = await parser_action.run()
         assert rsp
         assert parser_action.args
         assert parser_action.args.get("text") == "Draw an apple"
         assert parser_action.args.get("size_type") == "512x512"
 
-        action = SkillAction(skill=self.skill, args=parser_action.args)
+        action = SkillAction(skill=self.skill, args=parser_action.args, context=context)
         rsp = await action.run()
         assert rsp
         assert "image/png;base64," in rsp.content or "http" in rsp.content
@@ -81,8 +81,8 @@ class TestSkillAction:
             await SkillAction.find_and_call_function("dummy_call", {"a": 1})
 
     @pytest.mark.asyncio
-    async def test_skill_action_error(self):
-        action = SkillAction(skill=self.skill, args={})
+    async def test_skill_action_error(self, context):
+        action = SkillAction(skill=self.skill, args={}, context=context)
         rsp = await action.run()
         assert "Error" in rsp.content
 

tests/metagpt/actions/test_summarize_code.py

@@ -6,13 +6,14 @@
 @File    : test_summarize_code.py
 @Modifiled By: mashenquan, 2023-12-6. Unit test for summarize_code.py
 """
+import uuid
+from pathlib import Path
+
 import pytest
 
 from metagpt.actions.summarize_code import SummarizeCode
-from metagpt.context import CONTEXT
 from metagpt.logs import logger
 from metagpt.schema import CodeSummarizeContext
-from metagpt.utils.project_repo import ProjectRepo
 
 DESIGN_CONTENT = """
 {"Implementation approach": "To develop this snake game, we will use the Python language and choose the Pygame library. Pygame is an open-source Python module collection specifically designed for writing video games. It provides functionalities such as displaying images and playing sounds, making it suitable for creating intuitive and responsive user interfaces. We will ensure efficient game logic to prevent any delays during gameplay. The scoring system will be simple, with the snake gaining points for each food it eats. We will use Pygame's event handling system to implement pause and resume functionality, as well as high-score tracking. The difficulty will increase by speeding up the snake's movement. In the initial version, we will focus on single-player mode and consider adding multiplayer mode and customizable skins in future updates. Based on the new requirement, we will also add a moving obstacle that appears randomly. If the snake eats this obstacle, the game will end. If the snake does not eat the obstacle, it will disappear after 5 seconds. For this, we need to add mechanisms for obstacle generation, movement, and disappearance in the game logic.", "Project_name": "snake_game", "File list": ["main.py", "game.py", "snake.py", "food.py", "obstacle.py", "scoreboard.py", "constants.py", "assets/styles.css", "assets/index.html"], "Data structures and interfaces": "```mermaid\n    classDiagram\n        class Game{\n            +int score\n            +int speed\n            +bool game_over\n            +bool paused\n            +Snake snake\n            +Food food\n            +Obstacle obstacle\n            +Scoreboard scoreboard\n            +start_game() void\n            +pause_game() void\n            +resume_game() void\n            +end_game() void\n            +increase_difficulty() void\n            +update() void\n            +render() void\n            Game()\n        }\n        class Snake{\n            +list body_parts\n            +str direction\n            +bool grow\n            +move() void\n            +grow() void\n            +check_collision() bool\n            Snake()\n        }\n        class Food{\n            +tuple position\n            +spawn() void\n            Food()\n        }\n        class Obstacle{\n            +tuple position\n            +int lifetime\n            +bool active\n            +spawn() void\n            +move() void\n            +check_collision() bool\n            +disappear() void\n            Obstacle()\n        }\n        class Scoreboard{\n            +int high_score\n            +update_score(int) void\n            +reset_score() void\n            +load_high_score() void\n            +save_high_score() void\n            Scoreboard()\n        }\n        class Constants{\n        }\n        Game \"1\" -- \"1\" Snake: has\n        Game \"1\" -- \"1\" Food: has\n        Game \"1\" -- \"1\" Obstacle: has\n        Game \"1\" -- \"1\" Scoreboard: has\n    ```", "Program call flow": "```sequenceDiagram\n    participant M as Main\n    participant G as Game\n    participant S as Snake\n    participant F as Food\n    participant O as Obstacle\n    participant SB as Scoreboard\n    M->>G: start_game()\n    loop game loop\n        G->>S: move()\n        G->>S: check_collision()\n        G->>F: spawn()\n        G->>O: spawn()\n        G->>O: move()\n        G->>O: check_collision()\n        G->>O: disappear()\n        G->>SB: update_score(score)\n        G->>G: update()\n        G->>G: render()\n        alt if paused\n            M->>G: pause_game()\n            M->>G: resume_game()\n        end\n        alt if game_over\n            G->>M: end_game()\n        end\n    end\n```", "Anything UNCLEAR": "There is no need for further clarification as the requirements are already clear."}
@@ -175,21 +176,26 @@ class Snake:
 """
 
 
+@pytest.mark.skip
 @pytest.mark.asyncio
-async def test_summarize_code():
-    CONTEXT.src_workspace = CONTEXT.git_repo.workdir / "src"
-    project_repo = ProjectRepo(CONTEXT.git_repo)
-    await project_repo.docs.system_design.save(filename="1.json", content=DESIGN_CONTENT)
-    await project_repo.docs.task.save(filename="1.json", content=TASK_CONTENT)
-    await project_repo.with_src_path(CONTEXT.src_workspace).srcs.save(filename="food.py", content=FOOD_PY)
-    assert project_repo.srcs.workdir == CONTEXT.src_workspace
-    await project_repo.srcs.save(filename="game.py", content=GAME_PY)
-    await project_repo.srcs.save(filename="main.py", content=MAIN_PY)
-    await project_repo.srcs.save(filename="snake.py", content=SNAKE_PY)
+async def test_summarize_code(context):
+    git_dir = Path(__file__).parent / f"unittest/{uuid.uuid4().hex}"
+    git_dir.mkdir(parents=True, exist_ok=True)
 
-    all_files = project_repo.srcs.all_files
-    ctx = CodeSummarizeContext(design_filename="1.json", task_filename="1.json", codes_filenames=all_files)
-    action = SummarizeCode(i_context=ctx)
+    context.src_workspace = context.git_repo.workdir / "src"
+    await context.repo.docs.system_design.save(filename="1.json", content=DESIGN_CONTENT)
+    await context.repo.docs.task.save(filename="1.json", content=TASK_CONTENT)
+    await context.repo.with_src_path(context.src_workspace).srcs.save(filename="food.py", content=FOOD_PY)
+    assert context.repo.srcs.workdir == context.src_workspace
+    await context.repo.srcs.save(filename="game.py", content=GAME_PY)
+    await context.repo.srcs.save(filename="main.py", content=MAIN_PY)
+    await context.repo.srcs.save(filename="snake.py", content=SNAKE_PY)
+
+    all_files = context.repo.srcs.all_files
+    summarization_context = CodeSummarizeContext(
+        design_filename="1.json", task_filename="1.json", codes_filenames=all_files
+    )
+    action = SummarizeCode(context=context, i_context=summarization_context)
     rsp = await action.run()
     assert rsp
     logger.info(rsp)

tests/metagpt/actions/test_talk_action.py

@@ -9,13 +9,12 @@
 import pytest
 
 from metagpt.actions.talk_action import TalkAction
-from metagpt.context import CONTEXT
 from metagpt.schema import Message
 
 
 @pytest.mark.asyncio
 @pytest.mark.parametrize(
-    ("agent_description", "language", "context", "knowledge", "history_summary"),
+    ("agent_description", "language", "talk_context", "knowledge", "history_summary"),
     [
         (
             "mathematician",
@@ -33,12 +32,12 @@ from metagpt.schema import Message
         ),
     ],
 )
-async def test_prompt(agent_description, language, context, knowledge, history_summary):
+async def test_prompt(agent_description, language, talk_context, knowledge, history_summary, context):
     # Prerequisites
-    CONTEXT.kwargs.agent_description = agent_description
-    CONTEXT.kwargs.language = language
+    context.kwargs.agent_description = agent_description
+    context.kwargs.language = language
 
-    action = TalkAction(i_context=context, knowledge=knowledge, history_summary=history_summary)
+    action = TalkAction(i_context=talk_context, knowledge=knowledge, history_summary=history_summary, context=context)
     assert "{" not in action.prompt
     assert "{" not in action.prompt_gpt4
 

tests/metagpt/actions/test_write_code.py

@@ -12,25 +12,22 @@ from pathlib import Path
 import pytest
 
 from metagpt.actions.write_code import WriteCode
-from metagpt.context import CONTEXT
-from metagpt.llm import LLM
 from metagpt.logs import logger
 from metagpt.schema import CodingContext, Document
 from metagpt.utils.common import aread
-from metagpt.utils.project_repo import ProjectRepo
 from tests.metagpt.actions.mock_markdown import TASKS_2, WRITE_CODE_PROMPT_SAMPLE
 
 
 @pytest.mark.asyncio
-async def test_write_code():
+async def test_write_code(context):
     # Prerequisites
-    CONTEXT.src_workspace = CONTEXT.git_repo.workdir / "writecode"
+    context.src_workspace = context.git_repo.workdir / "writecode"
 
     coding_ctx = CodingContext(
         filename="task_filename.py", design_doc=Document(content="设计一个名为'add'的函数，该函数接受两个整数作为输入，并返回它们的和。")
     )
     doc = Document(content=coding_ctx.model_dump_json())
-    write_code = WriteCode(i_context=doc)
+    write_code = WriteCode(i_context=doc, context=context)
 
     code = await write_code.run()
     logger.info(code.model_dump_json())
@@ -41,45 +38,44 @@ async def test_write_code():
 
 
 @pytest.mark.asyncio
-async def test_write_code_directly():
+async def test_write_code_directly(context):
     prompt = WRITE_CODE_PROMPT_SAMPLE + "\n" + TASKS_2[0]
-    llm = LLM()
+    llm = context.llm_with_cost_manager_from_llm_config(context.config.llm)
     rsp = await llm.aask(prompt)
     logger.info(rsp)
 
 
 @pytest.mark.asyncio
-async def test_write_code_deps():
+async def test_write_code_deps(context):
     # Prerequisites
-    CONTEXT.src_workspace = CONTEXT.git_repo.workdir / "snake1/snake1"
+    context.src_workspace = context.git_repo.workdir / "snake1/snake1"
     demo_path = Path(__file__).parent / "../../data/demo_project"
-    project_repo = ProjectRepo(CONTEXT.git_repo)
-    await project_repo.test_outputs.save(
+    await context.repo.test_outputs.save(
         filename="test_game.py.json", content=await aread(str(demo_path / "test_game.py.json"))
     )
-    await project_repo.docs.code_summary.save(
+    await context.repo.docs.code_summary.save(
         filename="20231221155954.json",
         content=await aread(str(demo_path / "code_summaries.json")),
     )
-    await project_repo.docs.system_design.save(
+    await context.repo.docs.system_design.save(
         filename="20231221155954.json",
         content=await aread(str(demo_path / "system_design.json")),
     )
-    await project_repo.docs.task.save(
+    await context.repo.docs.task.save(
         filename="20231221155954.json", content=await aread(str(demo_path / "tasks.json"))
     )
-    await project_repo.with_src_path(CONTEXT.src_workspace).srcs.save(
+    await context.repo.with_src_path(context.src_workspace).srcs.save(
         filename="main.py", content='if __name__ == "__main__":\nmain()'
     )
     ccontext = CodingContext(
         filename="game.py",
-        design_doc=await project_repo.docs.system_design.get(filename="20231221155954.json"),
-        task_doc=await project_repo.docs.task.get(filename="20231221155954.json"),
+        design_doc=await context.repo.docs.system_design.get(filename="20231221155954.json"),
+        task_doc=await context.repo.docs.task.get(filename="20231221155954.json"),
         code_doc=Document(filename="game.py", content="", root_path="snake1"),
     )
     coding_doc = Document(root_path="snake1", filename="game.py", content=ccontext.json())
 
-    action = WriteCode(i_context=coding_doc)
+    action = WriteCode(i_context=coding_doc, context=context)
     rsp = await action.run()
     assert rsp
     assert rsp.code_doc.content

tests/metagpt/actions/test_write_code_plan_and_change_an.py

@@ -0,0 +1,71 @@
+#!/usr/bin/env python
+# -*- coding: utf-8 -*-
+"""
+@Time    : 2024/01/03
+@Author  : mannaandpoem
+@File    : test_write_code_plan_and_change_an.py
+"""
+import pytest
+from openai._models import BaseModel
+
+from metagpt.actions.action_node import ActionNode
+from metagpt.actions.write_code import WriteCode
+from metagpt.actions.write_code_plan_and_change_an import (
+    REFINED_TEMPLATE,
+    WriteCodePlanAndChange,
+)
+from metagpt.schema import CodePlanAndChangeContext
+from tests.data.incremental_dev_project.mock import (
+    CODE_PLAN_AND_CHANGE_SAMPLE,
+    DESIGN_SAMPLE,
+    NEW_REQUIREMENT_SAMPLE,
+    REFINED_CODE_INPUT_SAMPLE,
+    REFINED_CODE_SAMPLE,
+    TASKS_SAMPLE,
+)
+
+
+def mock_code_plan_and_change():
+    return CODE_PLAN_AND_CHANGE_SAMPLE
+
+
+@pytest.mark.asyncio
+async def test_write_code_plan_and_change_an(mocker):
+    root = ActionNode.from_children(
+        "WriteCodePlanAndChange", [ActionNode(key="", expected_type=str, instruction="", example="")]
+    )
+    root.instruct_content = BaseModel()
+    root.instruct_content.model_dump = mock_code_plan_and_change
+    mocker.patch("metagpt.actions.write_code_plan_and_change_an.WriteCodePlanAndChange.run", return_value=root)
+
+    requirement = "New requirement"
+    prd_filename = "prd.md"
+    design_filename = "design.md"
+    task_filename = "task.md"
+    code_plan_and_change_context = CodePlanAndChangeContext(
+        requirement=requirement,
+        prd_filename=prd_filename,
+        design_filename=design_filename,
+        task_filename=task_filename,
+    )
+    node = await WriteCodePlanAndChange(i_context=code_plan_and_change_context).run()
+
+    assert "Code Plan And Change" in node.instruct_content.model_dump()
+
+
+@pytest.mark.asyncio
+async def test_refine_code(mocker):
+    mocker.patch.object(WriteCode, "_aask", return_value=REFINED_CODE_SAMPLE)
+    prompt = REFINED_TEMPLATE.format(
+        user_requirement=NEW_REQUIREMENT_SAMPLE,
+        code_plan_and_change=CODE_PLAN_AND_CHANGE_SAMPLE,
+        design=DESIGN_SAMPLE,
+        task=TASKS_SAMPLE,
+        code=REFINED_CODE_INPUT_SAMPLE,
+        logs="",
+        feedback="",
+        filename="game.py",
+        summary_log="",
+    )
+    code = await WriteCode().write_code(prompt=prompt)
+    assert "def" in code

tests/metagpt/actions/test_write_code_review.py

@@ -12,28 +12,25 @@ from metagpt.schema import CodingContext, Document
 
 
 @pytest.mark.asyncio
-async def test_write_code_review(capfd):
+async def test_write_code_review(capfd, context):
+    context.src_workspace = context.repo.workdir / "srcs"
     code = """
 def add(a, b):
     return a + 
 """
-    context = CodingContext(
+    coding_context = CodingContext(
         filename="math.py", design_doc=Document(content="编写一个从a加b的函数，返回a+b"), code_doc=Document(content=code)
     )
 
-    context = await WriteCodeReview(i_context=context).run()
+    await WriteCodeReview(i_context=coding_context, context=context).run()
 
     # 我们不能精确地预测生成的代码评审，但我们可以检查返回的是否为字符串
-    assert isinstance(context.code_doc.content, str)
-    assert len(context.code_doc.content) > 0
+    assert isinstance(coding_context.code_doc.content, str)
+    assert len(coding_context.code_doc.content) > 0
 
     captured = capfd.readouterr()
     print(f"输出内容: {captured.out}")
 
 
-# @pytest.mark.asyncio
-# async def test_write_code_review_directly():
-#     code = SEARCH_CODE_SAMPLE
-#     write_code_review = WriteCodeReview("write_code_review")
-#     review = await write_code_review.run(code)
-#     logger.info(review)
+if __name__ == "__main__":
+    pytest.main([__file__, "-s"])

tests/metagpt/actions/test_write_docstring.py

@@ -27,8 +27,8 @@ class Person:
     ],
     ids=["google", "numpy", "sphinx"],
 )
-async def test_write_docstring(style: str, part: str):
-    ret = await WriteDocstring().run(code, style=style)
+async def test_write_docstring(style: str, part: str, context):
+    ret = await WriteDocstring(context=context).run(code, style=style)
     assert part in ret
 
 

tests/metagpt/actions/test_write_prd.py

@@ -10,21 +10,18 @@ import pytest
 
 from metagpt.actions import UserRequirement, WritePRD
 from metagpt.const import REQUIREMENT_FILENAME
-from metagpt.context import CONTEXT
 from metagpt.logs import logger
 from metagpt.roles.product_manager import ProductManager
 from metagpt.roles.role import RoleReactMode
 from metagpt.schema import Message
 from metagpt.utils.common import any_to_str
-from metagpt.utils.project_repo import ProjectRepo
 
 
 @pytest.mark.asyncio
-async def test_write_prd(new_filename):
-    product_manager = ProductManager()
+async def test_write_prd(new_filename, context):
+    product_manager = ProductManager(context=context)
     requirements = "开发一个基于大语言模型与私有知识库的搜索引擎，希望可以基于大语言模型进行搜索总结"
-    project_repo = ProjectRepo(CONTEXT.git_repo)
-    await project_repo.docs.save(filename=REQUIREMENT_FILENAME, content=requirements)
+    await context.repo.docs.save(filename=REQUIREMENT_FILENAME, content=requirements)
     product_manager.rc.react_mode = RoleReactMode.BY_ORDER
     prd = await product_manager.run(Message(content=requirements, cause_by=UserRequirement))
     assert prd.cause_by == any_to_str(WritePRD)
@@ -34,7 +31,7 @@ async def test_write_prd(new_filename):
     # Assert the prd is not None or empty
     assert prd is not None
     assert prd.content != ""
-    assert ProjectRepo(product_manager.context.git_repo).docs.prd.changed_files
+    assert product_manager.context.repo.docs.prd.changed_files
 
 
 if __name__ == "__main__":

tests/metagpt/actions/test_write_prd_an.py

@@ -0,0 +1,48 @@
+#!/usr/bin/env python
+# -*- coding: utf-8 -*-
+"""
+@Time    : 2024/01/03
+@Author  : mannaandpoem
+@File    : test_write_prd_an.py
+"""
+import pytest
+from openai._models import BaseModel
+
+from metagpt.actions.action_node import ActionNode
+from metagpt.actions.write_prd import NEW_REQ_TEMPLATE
+from metagpt.actions.write_prd_an import REFINED_PRD_NODE
+from metagpt.llm import LLM
+from tests.data.incremental_dev_project.mock import (
+    NEW_REQUIREMENT_SAMPLE,
+    PRD_SAMPLE,
+    REFINED_PRD_JSON,
+)
+
+
+@pytest.fixture()
+def llm():
+    return LLM()
+
+
+def mock_refined_prd_json():
+    return REFINED_PRD_JSON
+
+
+@pytest.mark.asyncio
+async def test_write_prd_an(mocker):
+    root = ActionNode.from_children("RefinedPRD", [ActionNode(key="", expected_type=str, instruction="", example="")])
+    root.instruct_content = BaseModel()
+    root.instruct_content.model_dump = mock_refined_prd_json
+    mocker.patch("metagpt.actions.write_prd_an.REFINED_PRD_NODE.fill", return_value=root)
+
+    prompt = NEW_REQ_TEMPLATE.format(
+        requirements=NEW_REQUIREMENT_SAMPLE,
+        old_prd=PRD_SAMPLE,
+    )
+    node = await REFINED_PRD_NODE.fill(prompt, llm)
+
+    assert "Refined Requirements" in node.instruct_content.model_dump()
+    assert "Refined Product Goals" in node.instruct_content.model_dump()
+    assert "Refined User Stories" in node.instruct_content.model_dump()
+    assert "Refined Requirement Analysis" in node.instruct_content.model_dump()
+    assert "Refined Requirement Pool" in node.instruct_content.model_dump()

tests/metagpt/actions/test_write_prd_review.py

@@ -11,7 +11,7 @@ from metagpt.actions.write_prd_review import WritePRDReview
 
 
 @pytest.mark.asyncio
-async def test_write_prd_review():
+async def test_write_prd_review(context):
     prd = """
     Introduction: This is a new feature for our product.
     Goals: The goal is to improve user engagement.
@@ -23,7 +23,7 @@ async def test_write_prd_review():
     Timeline: The feature should be ready for testing in 1.5 months.
     """
 
-    write_prd_review = WritePRDReview(name="write_prd_review")
+    write_prd_review = WritePRDReview(name="write_prd_review", context=context)
 
     prd_review = await write_prd_review.run(prd)
 

tests/metagpt/actions/test_write_review.py

@@ -9,7 +9,7 @@ import pytest
 
 from metagpt.actions.write_review import WriteReview
 
-CONTEXT = """
+TEMPLATE_CONTEXT = """
 {
     "Language": "zh_cn",
     "Programming Language": "Python",
@@ -46,8 +46,8 @@ CONTEXT = """
 
 
 @pytest.mark.asyncio
-async def test_write_review():
-    write_review = WriteReview()
-    review = await write_review.run(CONTEXT)
+async def test_write_review(context):
+    write_review = WriteReview(context=context)
+    review = await write_review.run(TEMPLATE_CONTEXT)
     assert review.instruct_content
     assert review.get("LGTM") in ["LGTM", "LBTM"]

tests/metagpt/actions/test_write_teaching_plan.py

@@ -13,11 +13,11 @@ from metagpt.actions.write_teaching_plan import WriteTeachingPlanPart
 
 @pytest.mark.asyncio
 @pytest.mark.parametrize(
-    ("topic", "context"),
+    ("topic", "content"),
     [("Title", "Lesson 1: Learn to draw an apple."), ("Teaching Content", "Lesson 1: Learn to draw an apple.")],
 )
-async def test_write_teaching_plan_part(topic, context):
-    action = WriteTeachingPlanPart(topic=topic, i_context=context)
+async def test_write_teaching_plan_part(topic, content, context):
+    action = WriteTeachingPlanPart(topic=topic, i_context=content, context=context)
     rsp = await action.run()
     assert rsp
 

tests/metagpt/actions/test_write_test.py

@@ -13,7 +13,7 @@ from metagpt.schema import Document, TestingContext
 
 
 @pytest.mark.asyncio
-async def test_write_test():
+async def test_write_test(context):
     code = """
     import random
     from typing import Tuple
@@ -25,8 +25,8 @@ async def test_write_test():
         def generate(self, max_y: int, max_x: int):
             self.position = (random.randint(1, max_y - 1), random.randint(1, max_x - 1))
     """
-    context = TestingContext(filename="food.py", code_doc=Document(filename="food.py", content=code))
-    write_test = WriteTest(i_context=context)
+    testing_context = TestingContext(filename="food.py", code_doc=Document(filename="food.py", content=code))
+    write_test = WriteTest(i_context=testing_context, context=context)
 
     context = await write_test.run()
     logger.info(context.model_dump_json())
@@ -39,12 +39,12 @@ async def test_write_test():
 
 
 @pytest.mark.asyncio
-async def test_write_code_invalid_code(mocker):
+async def test_write_code_invalid_code(mocker, context):
     # Mock the _aask method to return an invalid code string
     mocker.patch.object(WriteTest, "_aask", return_value="Invalid Code String")
 
     # Create an instance of WriteTest
-    write_test = WriteTest()
+    write_test = WriteTest(context=context)
 
     # Call the write_code method
     code = await write_test.write_code("Some prompt:")

tests/metagpt/actions/test_write_tutorial.py

@@ -14,8 +14,8 @@ from metagpt.actions.write_tutorial import WriteContent, WriteDirectory
 
 @pytest.mark.asyncio
 @pytest.mark.parametrize(("language", "topic"), [("English", "Write a tutorial about Python")])
-async def test_write_directory(language: str, topic: str):
-    ret = await WriteDirectory(language=language).run(topic=topic)
+async def test_write_directory(language: str, topic: str, context):
+    ret = await WriteDirectory(language=language, context=context).run(topic=topic)
     assert isinstance(ret, dict)
     assert "title" in ret
     assert "directory" in ret
@@ -29,8 +29,8 @@ async def test_write_directory(language: str, topic: str):
     ("language", "topic", "directory"),
     [("English", "Write a tutorial about Python", {"Introduction": ["What is Python?", "Why learn Python?"]})],
 )
-async def test_write_content(language: str, topic: str, directory: Dict):
-    ret = await WriteContent(language=language, directory=directory).run(topic=topic)
+async def test_write_content(language: str, topic: str, directory: Dict, context):
+    ret = await WriteContent(language=language, directory=directory, context=context).run(topic=topic)
     assert isinstance(ret, str)
     assert list(directory.keys())[0] in ret
     for value in list(directory.values())[0]:

tests/metagpt/environment/android_env/__init__.py

@@ -0,0 +1,3 @@
+#!/usr/bin/env python
+# -*- coding: utf-8 -*-
+# @Desc   :

tests/metagpt/environment/android_env/test_android_ext_env.py

@@ -0,0 +1,75 @@
+#!/usr/bin/env python
+# -*- coding: utf-8 -*-
+# @Desc   : the unittest of AndroidExtEnv
+
+from pathlib import Path
+
+from metagpt.environment.android_env.android_ext_env import AndroidExtEnv
+from metagpt.environment.android_env.const import ADB_EXEC_FAIL
+
+
+def mock_device_shape(self, adb_cmd: str) -> str:
+    return "shape: 720x1080"
+
+
+def mock_device_shape_invalid(self, adb_cmd: str) -> str:
+    return ADB_EXEC_FAIL
+
+
+def mock_list_devices(self, adb_cmd: str) -> str:
+    return "devices\nemulator-5554"
+
+
+def mock_get_screenshot(self, adb_cmd: str) -> str:
+    return "screenshot_xxxx-xx-xx"
+
+
+def mock_get_xml(self, adb_cmd: str) -> str:
+    return "xml_xxxx-xx-xx"
+
+
+def mock_write_read_operation(self, adb_cmd: str) -> str:
+    return "OK"
+
+
+def test_android_ext_env(mocker):
+    device_id = "emulator-5554"
+    mocker.patch(
+        "metagpt.environment.android_env.android_ext_env.AndroidExtEnv.execute_adb_with_cmd", mock_device_shape
+    )
+
+    ext_env = AndroidExtEnv(device_id=device_id, screenshot_dir="/data2/", xml_dir="/data2/")
+    assert ext_env.adb_prefix == f"adb -s {device_id} "
+    assert ext_env.adb_prefix_shell == f"adb -s {device_id} shell "
+    assert ext_env.adb_prefix_si == f"adb -s {device_id} shell input "
+
+    assert ext_env.device_shape == (720, 1080)
+
+    mocker.patch(
+        "metagpt.environment.android_env.android_ext_env.AndroidExtEnv.execute_adb_with_cmd", mock_device_shape_invalid
+    )
+    assert ext_env.device_shape == (0, 0)
+
+    mocker.patch(
+        "metagpt.environment.android_env.android_ext_env.AndroidExtEnv.execute_adb_with_cmd", mock_list_devices
+    )
+    assert ext_env.list_devices() == [device_id]
+
+    mocker.patch(
+        "metagpt.environment.android_env.android_ext_env.AndroidExtEnv.execute_adb_with_cmd", mock_get_screenshot
+    )
+    assert ext_env.get_screenshot("screenshot_xxxx-xx-xx", "/data/") == Path("/data/screenshot_xxxx-xx-xx.png")
+
+    mocker.patch("metagpt.environment.android_env.android_ext_env.AndroidExtEnv.execute_adb_with_cmd", mock_get_xml)
+    assert ext_env.get_xml("xml_xxxx-xx-xx", "/data/") == Path("/data/xml_xxxx-xx-xx.xml")
+
+    mocker.patch(
+        "metagpt.environment.android_env.android_ext_env.AndroidExtEnv.execute_adb_with_cmd", mock_write_read_operation
+    )
+    res = "OK"
+    assert ext_env.system_back() == res
+    assert ext_env.system_tap(10, 10) == res
+    assert ext_env.user_input("test_input") == res
+    assert ext_env.user_longpress(10, 10) == res
+    assert ext_env.user_swipe(10, 10) == res
+    assert ext_env.user_swipe_to((10, 10), (20, 20)) == res

tests/metagpt/environment/api/__init__.py

@@ -0,0 +1,3 @@
+#!/usr/bin/env python
+# -*- coding: utf-8 -*-
+# @Desc   :

tests/metagpt/environment/api/test_env_api.py

@@ -0,0 +1,15 @@
+#!/usr/bin/env python
+# -*- coding: utf-8 -*-
+# @Desc   :
+
+from metagpt.environment.api.env_api import EnvAPIRegistry
+
+
+def test_env_api_registry():
+    def test_func():
+        pass
+
+    env_api_registry = EnvAPIRegistry()
+    env_api_registry["test"] = test_func
+
+    env_api_registry.get("test") == test_func

tests/metagpt/environment/mincraft_env/__init__.py

@@ -0,0 +1,3 @@
+#!/usr/bin/env python
+# -*- coding: utf-8 -*-
+# @Desc   :

tests/metagpt/environment/mincraft_env/test_mincraft_ext_env.py

@@ -0,0 +1,14 @@
+#!/usr/bin/env python
+# -*- coding: utf-8 -*-
+# @Desc   : the unittest of MincraftExtEnv
+
+
+from metagpt.environment.mincraft_env.const import MC_CKPT_DIR
+from metagpt.environment.mincraft_env.mincraft_ext_env import MincraftExtEnv
+
+
+def test_mincraft_ext_env():
+    ext_env = MincraftExtEnv()
+    assert ext_env.server, f"{ext_env.server_host}:{ext_env.server_port}"
+    assert MC_CKPT_DIR.joinpath("skill/code").exists()
+    assert ext_env.warm_up.get("optional_inventory_items") == 7

tests/metagpt/environment/stanford_town_env/__init__.py

@@ -0,0 +1,3 @@
+#!/usr/bin/env python
+# -*- coding: utf-8 -*-
+# @Desc   :

tests/metagpt/environment/stanford_town_env/test_stanford_town_ext_env.py

@@ -0,0 +1,40 @@
+#!/usr/bin/env python
+# -*- coding: utf-8 -*-
+# @Desc   : the unittest of StanfordTownExtEnv
+
+from pathlib import Path
+
+from metagpt.environment.stanford_town_env.stanford_town_ext_env import (
+    StanfordTownExtEnv,
+)
+
+maze_asset_path = (
+    Path(__file__).absolute().parent.joinpath("..", "..", "..", "data", "environment", "stanford_town", "the_ville")
+)
+
+
+def test_stanford_town_ext_env():
+    ext_env = StanfordTownExtEnv(maze_asset_path=maze_asset_path)
+
+    tile_coord = ext_env.turn_coordinate_to_tile((64, 64))
+    assert tile_coord == (2, 2)
+
+    tile = (58, 9)
+    assert len(ext_env.get_collision_maze()) == 100
+    assert len(ext_env.get_address_tiles()) == 306
+    assert ext_env.access_tile(tile=tile)["world"] == "the Ville"
+    assert ext_env.get_tile_path(tile=tile, level="world") == "the Ville"
+    assert len(ext_env.get_nearby_tiles(tile=tile, vision_r=5)) == 121
+
+    event = ("double studio:double studio:bedroom 2:bed", None, None, None)
+    ext_env.add_tiles_event(tile[1], tile[0], event=event)
+    ext_env.add_event_from_tile(event, tile)
+    assert len(ext_env.tiles[tile[1]][tile[0]]["events"]) == 1
+
+    ext_env.turn_event_from_tile_idle(event, tile)
+
+    ext_env.remove_event_from_tile(event, tile)
+    assert len(ext_env.tiles[tile[1]][tile[0]]["events"]) == 0
+
+    ext_env.remove_subject_events_from_tile(subject=event[0], tile=tile)
+    assert len(ext_env.tiles[tile[1]][tile[0]]["events"]) == 0

tests/metagpt/environment/test_base_env.py

@@ -0,0 +1,54 @@
+#!/usr/bin/env python
+# -*- coding: utf-8 -*-
+# @Desc   : the unittest of ExtEnv&Env
+
+import pytest
+
+from metagpt.environment.api.env_api import EnvAPIAbstract
+from metagpt.environment.base_env import (
+    Environment,
+    env_read_api_registry,
+    env_write_api_registry,
+    mark_as_readable,
+    mark_as_writeable,
+)
+
+
+class ForTestEnv(Environment):
+    value: int = 0
+
+    @mark_as_readable
+    def read_api_no_param(self):
+        return self.value
+
+    @mark_as_readable
+    def read_api(self, a: int, b: int):
+        return a + b
+
+    @mark_as_writeable
+    def write_api(self, a: int, b: int):
+        self.value = a + b
+
+    @mark_as_writeable
+    async def async_read_api(self, a: int, b: int):
+        return a + b
+
+
+@pytest.mark.asyncio
+async def test_ext_env():
+    env = ForTestEnv()
+    assert len(env_read_api_registry) > 0
+    assert len(env_write_api_registry) > 0
+
+    apis = env.get_all_available_apis(mode="read")
+    assert len(apis) > 0
+    assert len(apis["read_api"]) == 3
+
+    _ = await env.step(EnvAPIAbstract(api_name="write_api", kwargs={"a": 5, "b": 10}))
+    assert env.value == 15
+
+    with pytest.raises(ValueError):
+        await env.observe("not_exist_api")
+
+    assert await env.observe("read_api_no_param") == 15
+    assert await env.observe(EnvAPIAbstract(api_name="read_api", kwargs={"a": 5, "b": 5})) == 10

tests/metagpt/environment/werewolf_env/__init__.py

@@ -0,0 +1,3 @@
+#!/usr/bin/env python
+# -*- coding: utf-8 -*-
+# @Desc   :

tests/metagpt/environment/werewolf_env/test_werewolf_ext_env.py

@@ -0,0 +1,64 @@
+#!/usr/bin/env python
+# -*- coding: utf-8 -*-
+# @Desc   : the unittest of WerewolfExtEnv
+
+from metagpt.environment.werewolf_env.werewolf_ext_env import RoleState, WerewolfExtEnv
+from metagpt.roles.role import Role
+
+
+class Werewolf(Role):
+    profile: str = "Werewolf"
+
+
+class Villager(Role):
+    profile: str = "Villager"
+
+
+class Witch(Role):
+    profile: str = "Witch"
+
+
+class Guard(Role):
+    profile: str = "Guard"
+
+
+def test_werewolf_ext_env():
+    players_state = {
+        "Player0": ("Werewolf", RoleState.ALIVE),
+        "Player1": ("Werewolf", RoleState.ALIVE),
+        "Player2": ("Villager", RoleState.ALIVE),
+        "Player3": ("Witch", RoleState.ALIVE),
+        "Player4": ("Guard", RoleState.ALIVE),
+    }
+    ext_env = WerewolfExtEnv(players_state=players_state, step_idx=4, special_role_players=["Player3", "Player4"])
+
+    assert len(ext_env.living_players) == 5
+    assert len(ext_env.special_role_players) == 2
+    assert len(ext_env.werewolf_players) == 2
+
+    curr_instr = ext_env.curr_step_instruction()
+    assert ext_env.step_idx == 5
+    assert "Werewolves, please open your eyes" in curr_instr["content"]
+
+    # current step_idx = 5
+    ext_env.wolf_kill_someone(wolf=Role(name="Player10"), player_name="Player4")
+    ext_env.wolf_kill_someone(wolf=Werewolf(name="Player0"), player_name="Player4")
+    ext_env.wolf_kill_someone(wolf=Werewolf(name="Player1"), player_name="Player4")
+    assert ext_env.player_hunted == "Player4"
+    assert len(ext_env.living_players) == 5  # hunted but can be saved by witch
+
+    for idx in range(13):
+        _ = ext_env.curr_step_instruction()
+
+    # current step_idx = 18
+    assert ext_env.step_idx == 18
+    ext_env.vote_kill_someone(voteer=Werewolf(name="Player0"), player_name="Player2")
+    ext_env.vote_kill_someone(voteer=Werewolf(name="Player1"), player_name="Player3")
+    ext_env.vote_kill_someone(voteer=Villager(name="Player2"), player_name="Player3")
+    ext_env.vote_kill_someone(voteer=Witch(name="Player3"), player_name="Player4")
+    ext_env.vote_kill_someone(voteer=Guard(name="Player4"), player_name="Player2")
+    assert ext_env.player_current_dead == "Player2"
+    assert len(ext_env.living_players) == 4
+
+    player_names = ["Player0", "Player2"]
+    assert ext_env.get_players_state(player_names) == dict(zip(player_names, [RoleState.ALIVE, RoleState.KILLED]))

tests/metagpt/learn/test_google_search.py

@@ -1,27 +1,21 @@
-import asyncio
-
+import pytest
 from pydantic import BaseModel
 
 from metagpt.learn.google_search import google_search
+from metagpt.tools import SearchEngineType
 
 
-async def mock_google_search():
+@pytest.mark.asyncio
+async def test_google_search(search_engine_mocker):
     class Input(BaseModel):
         input: str
 
     inputs = [{"input": "ai agent"}]
-
     for i in inputs:
         seed = Input(**i)
-        result = await google_search(seed.input)
+        result = await google_search(
+            seed.input,
+            engine=SearchEngineType.SERPER_GOOGLE,
+            api_key="mock-serper-key",
+        )
         assert result != ""
-
-
-def test_suite():
-    loop = asyncio.get_event_loop()
-    task = loop.create_task(mock_google_search())
-    loop.run_until_complete(task)
-
-
-if __name__ == "__main__":
-    test_suite()

tests/metagpt/learn/test_skill_loader.py

@@ -10,13 +10,12 @@ from pathlib import Path
 
 import pytest
 
-from metagpt.context import CONTEXT
 from metagpt.learn.skill_loader import SkillsDeclaration
 
 
 @pytest.mark.asyncio
-async def test_suite():
-    CONTEXT.kwargs.agent_skills = [
+async def test_suite(context):
+    context.kwargs.agent_skills = [
         {"id": 1, "name": "text_to_speech", "type": "builtin", "config": {}, "enabled": True},
         {"id": 2, "name": "text_to_image", "type": "builtin", "config": {}, "enabled": True},
         {"id": 3, "name": "ai_call", "type": "builtin", "config": {}, "enabled": True},
@@ -27,7 +26,7 @@ async def test_suite():
     ]
     pathname = Path(__file__).parent / "../../../docs/.well-known/skills.yaml"
     loader = await SkillsDeclaration.load(skill_yaml_file_name=pathname)
-    skills = loader.get_skill_list()
+    skills = loader.get_skill_list(context=context)
     assert skills
     assert len(skills) >= 3
     for desc, name in skills.items():

tests/metagpt/learn/test_text_to_embedding.py

@@ -11,7 +11,7 @@ from pathlib import Path
 
 import pytest
 
-from metagpt.config2 import config
+from metagpt.config2 import Config
 from metagpt.learn.text_to_embedding import text_to_embedding
 from metagpt.utils.common import aread
 
@@ -19,13 +19,14 @@ from metagpt.utils.common import aread
 @pytest.mark.asyncio
 async def test_text_to_embedding(mocker):
     # mock
+    config = Config.default()
     mock_post = mocker.patch("aiohttp.ClientSession.post")
     mock_response = mocker.AsyncMock()
     mock_response.status = 200
     data = await aread(Path(__file__).parent / "../../data/openai/embedding.json")
     mock_response.json.return_value = json.loads(data)
     mock_post.return_value.__aenter__.return_value = mock_response
-    type(config.get_openai_llm()).proxy = mocker.PropertyMock(return_value="http://mock.proxy")
+    config.get_openai_llm().proxy = mocker.PropertyMock(return_value="http://mock.proxy")
 
     # Prerequisites
     assert config.get_openai_llm().api_key

tests/metagpt/learn/test_text_to_image.py

@@ -27,7 +27,7 @@ async def test_text_to_image(mocker):
     mocker.patch.object(S3, "cache", return_value="http://mock/s3")
 
     config = Config.default()
-    assert config.METAGPT_TEXT_TO_IMAGE_MODEL_URL
+    assert config.metagpt_tti_url
 
     data = await text_to_image("Panda emoji", size_type="512x512", config=config)
     assert "base64" in data or "http" in data
@@ -52,7 +52,7 @@ async def test_openai_text_to_image(mocker):
     mocker.patch.object(S3, "cache", return_value="http://mock.s3.com/0.png")
 
     config = Config.default()
-    config.METAGPT_TEXT_TO_IMAGE_MODEL_URL = None
+    config.metagpt_tti_url = None
     assert config.get_openai_llm()
 
     data = await text_to_image("Panda emoji", size_type="512x512", config=config)

tests/metagpt/learn/test_text_to_speech.py

@@ -20,9 +20,9 @@ from metagpt.utils.s3 import S3
 async def test_azure_text_to_speech(mocker):
     # mock
     config = Config.default()
-    config.IFLYTEK_API_KEY = None
-    config.IFLYTEK_API_SECRET = None
-    config.IFLYTEK_APP_ID = None
+    config.iflytek_api_key = None
+    config.iflytek_api_secret = None
+    config.iflytek_app_id = None
     mock_result = mocker.Mock()
     mock_result.audio_data = b"mock audio data"
     mock_result.reason = ResultReason.SynthesizingAudioCompleted
@@ -32,11 +32,11 @@ async def test_azure_text_to_speech(mocker):
     mocker.patch.object(S3, "cache", return_value="http://mock.s3.com/1.wav")
 
     # Prerequisites
-    assert not config.IFLYTEK_APP_ID
-    assert not config.IFLYTEK_API_KEY
-    assert not config.IFLYTEK_API_SECRET
-    assert config.AZURE_TTS_SUBSCRIPTION_KEY and config.AZURE_TTS_SUBSCRIPTION_KEY != "YOUR_API_KEY"
-    assert config.AZURE_TTS_REGION
+    assert not config.iflytek_app_id
+    assert not config.iflytek_api_key
+    assert not config.iflytek_api_secret
+    assert config.azure_tts_subscription_key and config.azure_tts_subscription_key != "YOUR_API_KEY"
+    assert config.azure_tts_region
 
     config.copy()
     # test azure
@@ -48,8 +48,8 @@ async def test_azure_text_to_speech(mocker):
 async def test_iflytek_text_to_speech(mocker):
     # mock
     config = Config.default()
-    config.AZURE_TTS_SUBSCRIPTION_KEY = None
-    config.AZURE_TTS_REGION = None
+    config.azure_tts_subscription_key = None
+    config.azure_tts_region = None
     mocker.patch.object(IFlyTekTTS, "synthesize_speech", return_value=None)
     mock_data = mocker.AsyncMock()
     mock_data.read.return_value = b"mock iflytek"
@@ -58,11 +58,11 @@ async def test_iflytek_text_to_speech(mocker):
     mocker.patch.object(S3, "cache", return_value="http://mock.s3.com/1.mp3")
 
     # Prerequisites
-    assert config.IFLYTEK_APP_ID
-    assert config.IFLYTEK_API_KEY
-    assert config.IFLYTEK_API_SECRET
-    assert not config.AZURE_TTS_SUBSCRIPTION_KEY or config.AZURE_TTS_SUBSCRIPTION_KEY == "YOUR_API_KEY"
-    assert not config.AZURE_TTS_REGION
+    assert config.iflytek_app_id
+    assert config.iflytek_api_key
+    assert config.iflytek_api_secret
+    assert not config.azure_tts_subscription_key or config.azure_tts_subscription_key == "YOUR_API_KEY"
+    assert not config.azure_tts_region
 
     # test azure
     data = await text_to_speech("panda emoji", config=config)

tests/metagpt/provider/test_openai.py

@@ -1,9 +1,19 @@
-import pytest
+import json
 
+import pytest
+from openai.types.chat import (
+    ChatCompletion,
+    ChatCompletionMessage,
+    ChatCompletionMessageToolCall,
+)
+from openai.types.chat.chat_completion import Choice
+from openai.types.chat.chat_completion_message_tool_call import Function
+from PIL import Image
+
+from metagpt.const import TEST_DATA_PATH
 from metagpt.llm import LLM
 from metagpt.logs import logger
 from metagpt.provider import OpenAILLM
-from metagpt.schema import UserMessage
 from tests.metagpt.provider.mock_llm_config import (
     mock_llm_config,
     mock_llm_config_proxy,
@@ -11,45 +21,103 @@ from tests.metagpt.provider.mock_llm_config import (
 
 
 @pytest.mark.asyncio
-async def test_aask_code():
+async def test_text_to_speech():
     llm = LLM()
-    msg = [{"role": "user", "content": "Write a python hello world code."}]
-    rsp = await llm.aask_code(msg)  # -> {'language': 'python', 'code': "print('Hello, World!')"}
-
-    logger.info(rsp)
-    assert "language" in rsp
-    assert "code" in rsp
-    assert len(rsp["code"]) > 0
+    resp = await llm.atext_to_speech(
+        model="tts-1",
+        voice="alloy",
+        input="人生说起来长，但直到一个岁月回头看，许多事件仅是仓促的。一段一段拼凑一起，合成了人生。苦难当头时，当下不免觉得是折磨；回头看，也不够是一段短短的人生旅程。",
+    )
+    assert 200 == resp.response.status_code
 
 
 @pytest.mark.asyncio
-async def test_aask_code_str():
+async def test_speech_to_text():
     llm = LLM()
-    msg = "Write a python hello world code."
-    rsp = await llm.aask_code(msg)  # -> {'language': 'python', 'code': "print('Hello, World!')"}
-    assert "language" in rsp
-    assert "code" in rsp
-    assert len(rsp["code"]) > 0
+    audio_file = open(f"{TEST_DATA_PATH}/audio/hello.mp3", "rb")
+    resp = await llm.aspeech_to_text(file=audio_file, model="whisper-1")
+    assert "你好" == resp.text
 
 
-@pytest.mark.asyncio
-async def test_aask_code_message():
-    llm = LLM()
-    msg = UserMessage("Write a python hello world code.")
-    rsp = await llm.aask_code(msg)  # -> {'language': 'python', 'code': "print('Hello, World!')"}
-    assert "language" in rsp
-    assert "code" in rsp
-    assert len(rsp["code"]) > 0
+@pytest.fixture
+def tool_calls_rsp():
+    function_rsps = [
+        Function(arguments='{\n"language": "python",\n"code": "print(\'hello world\')"}', name="execute"),
+    ]
+    tool_calls = [
+        ChatCompletionMessageToolCall(type="function", id=f"call_{i}", function=f) for i, f in enumerate(function_rsps)
+    ]
+    messages = [ChatCompletionMessage(content=None, role="assistant", tool_calls=[t]) for t in tool_calls]
+    # 添加一个纯文本响应
+    messages.append(
+        ChatCompletionMessage(content="Completed a python code for hello world!", role="assistant", tool_calls=None)
+    )
+    # 添加 openai tool calls respond bug, code 出现在ChatCompletionMessage.content中
+    messages.extend(
+        [
+            ChatCompletionMessage(content="```python\nprint('hello world')```", role="assistant", tool_calls=None),
+        ]
+    )
+    choices = [
+        Choice(finish_reason="tool_calls", logprobs=None, index=i, message=msg) for i, msg in enumerate(messages)
+    ]
+    return [
+        ChatCompletion(id=str(i), choices=[c], created=i, model="gpt-4", object="chat.completion")
+        for i, c in enumerate(choices)
+    ]
+
+
+@pytest.fixture
+def json_decode_error():
+    function_rsp = Function(arguments='{\n"language": \'python\',\n"code": "print(\'hello world\')"}', name="execute")
+    tool_calls = [ChatCompletionMessageToolCall(type="function", id=f"call_{0}", function=function_rsp)]
+    message = ChatCompletionMessage(content=None, role="assistant", tool_calls=tool_calls)
+    choices = [Choice(finish_reason="tool_calls", logprobs=None, index=0, message=message)]
+    return ChatCompletion(id="0", choices=choices, created=0, model="gpt-4", object="chat.completion")
 
 
 class TestOpenAI:
     def test_make_client_kwargs_without_proxy(self):
         instance = OpenAILLM(mock_llm_config)
         kwargs = instance._make_client_kwargs()
-        assert kwargs == {"api_key": "mock_api_key", "base_url": "mock_base_url"}
+        assert kwargs["api_key"] == "mock_api_key"
+        assert kwargs["base_url"] == "mock_base_url"
         assert "http_client" not in kwargs
 
     def test_make_client_kwargs_with_proxy(self):
         instance = OpenAILLM(mock_llm_config_proxy)
         kwargs = instance._make_client_kwargs()
         assert "http_client" in kwargs
+
+    def test_get_choice_function_arguments_for_aask_code(self, tool_calls_rsp):
+        instance = OpenAILLM(mock_llm_config_proxy)
+        for i, rsp in enumerate(tool_calls_rsp):
+            code = instance.get_choice_function_arguments(rsp)
+            logger.info(f"\ntest get function call arguments {i}: {code}")
+            assert "code" in code
+            assert "language" in code
+            assert "hello world" in code["code"]
+            logger.info(f'code is : {code["code"]}')
+
+            if "Completed a python code for hello world!" == code["code"]:
+                code["language"] == "markdown"
+            else:
+                code["language"] == "python"
+
+    def test_aask_code_json_decode_error(self, json_decode_error):
+        instance = OpenAILLM(mock_llm_config)
+        with pytest.raises(json.decoder.JSONDecodeError) as e:
+            instance.get_choice_function_arguments(json_decode_error)
+        assert "JSONDecodeError" in str(e)
+
+
+@pytest.mark.asyncio
+async def test_gen_image():
+    llm = LLM()
+    model = "dall-e-3"
+    prompt = 'a logo with word "MetaGPT"'
+    images: list[Image] = await llm.gen_image(model=model, prompt=prompt)
+    assert images[0].size == (1024, 1024)
+
+    images: list[Image] = await llm.gen_image(model=model, prompt=prompt, resp_format="b64_json")
+    assert images[0].size == (1024, 1024)

tests/metagpt/provider/test_zhipuai_api.py

@@ -3,7 +3,6 @@
 # @Desc   : the unittest of ZhiPuAILLM
 
 import pytest
-from zhipuai.utils.sse_client import Event
 
 from metagpt.provider.zhipuai_api import ZhiPuAILLM
 from tests.metagpt.provider.mock_llm_config import mock_llm_config_zhipu
@@ -13,35 +12,16 @@ messages = [{"role": "user", "content": prompt_msg}]
 
 resp_content = "I'm chatglm-turbo"
 default_resp = {
-    "code": 200,
-    "data": {
-        "choices": [{"role": "assistant", "content": resp_content}],
-        "usage": {"prompt_tokens": 20, "completion_tokens": 20},
-    },
+    "choices": [{"finish_reason": "stop", "index": 0, "message": {"content": resp_content, "role": "assistant"}}],
+    "usage": {"completion_tokens": 22, "prompt_tokens": 19, "total_tokens": 41},
 }
 
 
-def mock_zhipuai_invoke(**kwargs) -> dict:
-    return default_resp
-
-
-async def mock_zhipuai_ainvoke(**kwargs) -> dict:
-    return default_resp
-
-
-async def mock_zhipuai_asse_invoke(**kwargs):
+async def mock_zhipuai_acreate_stream(self, **kwargs):
     class MockResponse(object):
         async def _aread(self):
             class Iterator(object):
-                events = [
-                    Event(id="xxx", event="add", data=resp_content, retry=0),
-                    Event(
-                        id="xxx",
-                        event="finish",
-                        data="",
-                        meta='{"usage": {"completion_tokens": 20,"prompt_tokens": 20}}',
-                    ),
-                ]
+                events = [{"choices": [{"index": 0, "delta": {"content": resp_content, "role": "assistant"}}]}]
 
                 async def __aiter__(self):
                     for event in self.events:
@@ -50,23 +30,26 @@ async def mock_zhipuai_asse_invoke(**kwargs):
             async for chunk in Iterator():
                 yield chunk
 
-        async def async_events(self):
+        async def stream(self):
             async for chunk in self._aread():
                 yield chunk
 
     return MockResponse()
 
 
+async def mock_zhipuai_acreate(self, **kwargs) -> dict:
+    return default_resp
+
+
 @pytest.mark.asyncio
 async def test_zhipuai_acompletion(mocker):
-    mocker.patch("metagpt.provider.zhipuai.zhipu_model_api.ZhiPuModelAPI.invoke", mock_zhipuai_invoke)
-    mocker.patch("metagpt.provider.zhipuai.zhipu_model_api.ZhiPuModelAPI.ainvoke", mock_zhipuai_ainvoke)
-    mocker.patch("metagpt.provider.zhipuai.zhipu_model_api.ZhiPuModelAPI.asse_invoke", mock_zhipuai_asse_invoke)
+    mocker.patch("metagpt.provider.zhipuai.zhipu_model_api.ZhiPuModelAPI.acreate", mock_zhipuai_acreate)
+    mocker.patch("metagpt.provider.zhipuai.zhipu_model_api.ZhiPuModelAPI.acreate_stream", mock_zhipuai_acreate_stream)
 
     zhipu_gpt = ZhiPuAILLM(mock_llm_config_zhipu)
 
     resp = await zhipu_gpt.acompletion(messages)
-    assert resp["data"]["choices"][0]["content"] == resp_content
+    assert resp["choices"][0]["message"]["content"] == resp_content
 
     resp = await zhipu_gpt.aask(prompt_msg, stream=False)
     assert resp == resp_content

tests/metagpt/provider/zhipuai/test_async_sse_client.py

@@ -11,16 +11,16 @@ from metagpt.provider.zhipuai.async_sse_client import AsyncSSEClient
 async def test_async_sse_client():
     class Iterator(object):
         async def __aiter__(self):
-            yield b"data: test_value"
+            yield b'data: {"test_key": "test_value"}'
 
     async_sse_client = AsyncSSEClient(event_source=Iterator())
-    async for event in async_sse_client.async_events():
-        assert event.data, "test_value"
+    async for chunk in async_sse_client.stream():
+        assert "test_value" in chunk.values()
 
     class InvalidIterator(object):
         async def __aiter__(self):
             yield b"invalid: test_value"
 
     async_sse_client = AsyncSSEClient(event_source=InvalidIterator())
-    async for event in async_sse_client.async_events():
-        assert not event
+    async for chunk in async_sse_client.stream():
+        assert not chunk

tests/metagpt/provider/zhipuai/test_zhipu_model_api.py

@@ -6,15 +6,13 @@ from typing import Any, Tuple
 
 import pytest
 import zhipuai
-from zhipuai.model_api.api import InvokeType
-from zhipuai.utils.http_client import headers as zhipuai_default_headers
 
 from metagpt.provider.zhipuai.zhipu_model_api import ZhiPuModelAPI
 
 api_key = "xxx.xxx"
 zhipuai.api_key = api_key
 
-default_resp = b'{"result": "test response"}'
+default_resp = b'{"choices": [{"finish_reason": "stop", "index": 0, "message": {"content": "test response", "role": "assistant"}}]}'
 
 
 async def mock_requestor_arequest(self, **kwargs) -> Tuple[Any, Any, str]:
@@ -23,22 +21,15 @@ async def mock_requestor_arequest(self, **kwargs) -> Tuple[Any, Any, str]:
 
 @pytest.mark.asyncio
 async def test_zhipu_model_api(mocker):
-    header = ZhiPuModelAPI.get_header()
-    zhipuai_default_headers.update({"Authorization": api_key})
-    assert header == zhipuai_default_headers
-
-    ZhiPuModelAPI.get_sse_header()
-    # assert len(sse_header["Authorization"]) == 191
-
-    url_prefix, url_suffix = ZhiPuModelAPI.split_zhipu_api_url(InvokeType.SYNC, kwargs={"model": "chatglm_turbo"})
+    url_prefix, url_suffix = ZhiPuModelAPI(api_key=api_key).split_zhipu_api_url()
     assert url_prefix == "https://open.bigmodel.cn/api"
-    assert url_suffix == "/paas/v3/model-api/chatglm_turbo/invoke"
+    assert url_suffix == "/paas/v4/chat/completions"
 
     mocker.patch("metagpt.provider.general_api_requestor.GeneralAPIRequestor.arequest", mock_requestor_arequest)
-    result = await ZhiPuModelAPI.arequest(
-        InvokeType.SYNC, stream=False, method="get", headers={}, kwargs={"model": "chatglm_turbo"}
+    result = await ZhiPuModelAPI(api_key=api_key).arequest(
+        stream=False, method="get", headers={}, kwargs={"model": "glm-3-turbo"}
     )
     assert result == default_resp
 
-    result = await ZhiPuModelAPI.ainvoke()
-    assert result["result"] == "test response"
+    result = await ZhiPuModelAPI(api_key=api_key).acreate()
+    assert result["choices"][0]["message"]["content"] == "test response"

tests/metagpt/roles/ci/test_code_interpreter.py

@@ -0,0 +1,23 @@
+import pytest
+
+from metagpt.logs import logger
+from metagpt.roles.ci.code_interpreter import CodeInterpreter
+
+
+@pytest.mark.asyncio
+@pytest.mark.parametrize("auto_run", [(True), (False)])
+async def test_code_interpreter(mocker, auto_run):
+    mocker.patch("metagpt.actions.ci.execute_nb_code.ExecuteNbCode.run", return_value=("a successful run", True))
+    mocker.patch("builtins.input", return_value="confirm")
+
+    requirement = "Run data analysis on sklearn Iris dataset, include a plot"
+    tools = []
+
+    ci = CodeInterpreter(auto_run=auto_run, use_tools=True, tools=tools)
+    rsp = await ci.run(requirement)
+    logger.info(rsp)
+    assert len(rsp.content) > 0
+
+    finished_tasks = ci.planner.plan.get_finished_tasks()
+    assert len(finished_tasks) > 0
+    assert len(finished_tasks[0].code) > 0  # check one task to see if code is recorded

tests/metagpt/roles/ci/test_ml_engineer.py

@@ -0,0 +1,90 @@
+import pytest
+
+from metagpt.actions.ci.execute_nb_code import ExecuteNbCode
+from metagpt.logs import logger
+from metagpt.roles.ci.ml_engineer import MLEngineer
+from metagpt.schema import Message, Plan, Task
+from metagpt.tools.tool_type import ToolType
+from tests.metagpt.actions.ci.test_debug_code import CODE, DebugContext, ErrorStr
+
+
+def test_mle_init():
+    ci = MLEngineer(goal="test", auto_run=True, use_tools=True, tools=["tool1", "tool2"])
+    assert ci.tools == []
+
+
+MockPlan = Plan(
+    goal="This is a titanic passenger survival dataset, your goal is to predict passenger survival outcome. The target column is Survived. Perform data analysis, data preprocessing, feature engineering, and modeling to predict the target. Report accuracy on the eval data. Train data path: 'tests/data/ml_datasets/titanic/split_train.csv', eval data path: 'tests/data/ml_datasets/titanic/split_eval.csv'.",
+    context="",
+    tasks=[
+        Task(
+            task_id="1",
+            dependent_task_ids=[],
+            instruction="Perform exploratory data analysis on the train dataset to understand the features and target variable.",
+            task_type="eda",
+            code="",
+            result="",
+            is_success=False,
+            is_finished=False,
+        )
+    ],
+    task_map={
+        "1": Task(
+            task_id="1",
+            dependent_task_ids=[],
+            instruction="Perform exploratory data analysis on the train dataset to understand the features and target variable.",
+            task_type="eda",
+            code="",
+            result="",
+            is_success=False,
+            is_finished=False,
+        )
+    },
+    current_task_id="1",
+)
+
+
+@pytest.mark.asyncio
+async def test_mle_write_code(mocker):
+    data_path = "tests/data/ml_datasets/titanic"
+
+    mle = MLEngineer(auto_run=True, use_tools=True)
+    mle.planner.plan = MockPlan
+
+    code, _ = await mle._write_code()
+    assert data_path in code["code"]
+
+
+@pytest.mark.asyncio
+async def test_mle_update_data_columns(mocker):
+    mle = MLEngineer(auto_run=True, use_tools=True)
+    mle.planner.plan = MockPlan
+
+    # manually update task type to test update
+    mle.planner.plan.current_task.task_type = ToolType.DATA_PREPROCESS.value
+
+    result = await mle._update_data_columns()
+    assert result is not None
+
+
+@pytest.mark.asyncio
+async def test_mle_debug_code(mocker):
+    mle = MLEngineer(auto_run=True, use_tools=True)
+    mle.working_memory.add(Message(content=ErrorStr, cause_by=ExecuteNbCode))
+    mle.latest_code = CODE
+    mle.debug_context = DebugContext
+    code, _ = await mle._write_code()
+    assert len(code) > 0
+
+
+@pytest.mark.skip
+@pytest.mark.asyncio
+async def test_ml_engineer():
+    data_path = "tests/data/ml_datasets/titanic"
+    requirement = f"This is a titanic passenger survival dataset, your goal is to predict passenger survival outcome. The target column is Survived. Perform data analysis, data preprocessing, feature engineering, and modeling to predict the target. Report accuracy on the eval data. Train data path: '{data_path}/split_train.csv', eval data path: '{data_path}/split_eval.csv'."
+    tools = ["FillMissingValue", "CatCross", "dummy_tool"]
+
+    mle = MLEngineer(auto_run=True, use_tools=True, tools=tools)
+    rsp = await mle.run(requirement)
+    logger.info(rsp)
+    assert len(rsp.content) > 0

tests/metagpt/roles/test_architect.py

@@ -13,7 +13,6 @@ import pytest
 
 from metagpt.actions import WriteDesign, WritePRD
 from metagpt.const import PRDS_FILE_REPO
-from metagpt.context import CONTEXT
 from metagpt.logs import logger
 from metagpt.roles import Architect
 from metagpt.schema import Message
@@ -22,12 +21,12 @@ from tests.metagpt.roles.mock import MockMessages
 
 
 @pytest.mark.asyncio
-async def test_architect():
+async def test_architect(context):
     # Prerequisites
     filename = uuid.uuid4().hex + ".json"
-    await awrite(CONTEXT.git_repo.workdir / PRDS_FILE_REPO / filename, data=MockMessages.prd.content)
+    await awrite(context.repo.workdir / PRDS_FILE_REPO / filename, data=MockMessages.prd.content)
 
-    role = Architect()
+    role = Architect(context=context)
     rsp = await role.run(with_message=Message(content="", cause_by=WritePRD))
     logger.info(rsp)
     assert len(rsp.content) > 0

tests/metagpt/roles/test_assistant.py

@@ -12,7 +12,6 @@ from pydantic import BaseModel
 
 from metagpt.actions.skill_action import SkillAction
 from metagpt.actions.talk_action import TalkAction
-from metagpt.context import CONTEXT
 from metagpt.memory.brain_memory import BrainMemory
 from metagpt.roles.assistant import Assistant
 from metagpt.schema import Message
@@ -20,11 +19,11 @@ from metagpt.utils.common import any_to_str
 
 
 @pytest.mark.asyncio
-async def test_run(mocker):
+async def test_run(mocker, context):
     # mock
     mocker.patch("metagpt.learn.text_to_image", return_value="http://mock.com/1.png")
 
-    CONTEXT.kwargs.language = "Chinese"
+    context.kwargs.language = "Chinese"
 
     class Input(BaseModel):
         memory: BrainMemory
@@ -80,7 +79,7 @@ async def test_run(mocker):
 
     for i in inputs:
         seed = Input(**i)
-        role = Assistant(language="Chinese")
+        role = Assistant(language="Chinese", context=context)
         role.context.kwargs.language = seed.language
         role.context.kwargs.agent_description = seed.agent_description
         role.context.kwargs.agent_skills = agent_skills
@@ -115,8 +114,8 @@ async def test_run(mocker):
     ],
 )
 @pytest.mark.asyncio
-async def test_memory(memory):
-    role = Assistant()
+async def test_memory(memory, context):
+    role = Assistant(context=context)
     role.context.kwargs.agent_skills = []
     role.load_memory(memory)
 

tests/metagpt/roles/test_engineer.py

@@ -8,44 +8,35 @@
         distribution feature for message handling.
 """
 import json
-import uuid
 from pathlib import Path
 
 import pytest
 
 from metagpt.actions import WriteCode, WriteTasks
-from metagpt.const import (
-    DEFAULT_WORKSPACE_ROOT,
-    REQUIREMENT_FILENAME,
-    SYSTEM_DESIGN_FILE_REPO,
-    TASK_FILE_REPO,
-)
-from metagpt.context import CONTEXT, Context
+from metagpt.const import REQUIREMENT_FILENAME, SYSTEM_DESIGN_FILE_REPO, TASK_FILE_REPO
 from metagpt.logs import logger
 from metagpt.roles.engineer import Engineer
 from metagpt.schema import CodingContext, Message
 from metagpt.utils.common import CodeParser, any_to_name, any_to_str, aread, awrite
-from metagpt.utils.git_repository import ChangeType, GitRepository
-from metagpt.utils.project_repo import ProjectRepo
+from metagpt.utils.git_repository import ChangeType
 from tests.metagpt.roles.mock import STRS_FOR_PARSING, TASKS, MockMessages
 
 
 @pytest.mark.asyncio
-async def test_engineer():
+async def test_engineer(context):
     # Prerequisites
     rqno = "20231221155954.json"
-    project_repo = ProjectRepo(CONTEXT.git_repo)
-    await project_repo.save(REQUIREMENT_FILENAME, content=MockMessages.req.content)
-    await project_repo.docs.prd.save(rqno, content=MockMessages.prd.content)
-    await project_repo.docs.system_design.save(rqno, content=MockMessages.system_design.content)
-    await project_repo.docs.task.save(rqno, content=MockMessages.json_tasks.content)
+    await context.repo.save(REQUIREMENT_FILENAME, content=MockMessages.req.content)
+    await context.repo.docs.prd.save(rqno, content=MockMessages.prd.content)
+    await context.repo.docs.system_design.save(rqno, content=MockMessages.system_design.content)
+    await context.repo.docs.task.save(rqno, content=MockMessages.json_tasks.content)
 
-    engineer = Engineer()
+    engineer = Engineer(context=context)
     rsp = await engineer.run(Message(content="", cause_by=WriteTasks))
 
     logger.info(rsp)
     assert rsp.cause_by == any_to_str(WriteCode)
-    assert project_repo.with_src_path(CONTEXT.src_workspace).srcs.changed_files
+    assert context.repo.with_src_path(context.src_workspace).srcs.changed_files
 
 
 def test_parse_str():
@@ -108,14 +99,12 @@ def test_parse_code():
 
 def test_todo():
     role = Engineer()
-    assert role.todo == any_to_name(WriteCode)
+    assert role.action_description == any_to_name(WriteCode)
 
 
 @pytest.mark.asyncio
-async def test_new_coding_context():
+async def test_new_coding_context(context):
     # Prerequisites
-    context = Context()
-    context.git_repo = GitRepository(local_path=DEFAULT_WORKSPACE_ROOT / f"unittest/{uuid.uuid4().hex}")
     demo_path = Path(__file__).parent / "../../data/demo_project"
     deps = json.loads(await aread(demo_path / "dependencies.json"))
     dependency = await context.git_repo.get_dependency()
@@ -123,11 +112,11 @@ async def test_new_coding_context():
         await dependency.update(k, set(v))
     data = await aread(demo_path / "system_design.json")
     rqno = "20231221155954.json"
-    await awrite(context.git_repo.workdir / SYSTEM_DESIGN_FILE_REPO / rqno, data)
+    await awrite(context.repo.workdir / SYSTEM_DESIGN_FILE_REPO / rqno, data)
     data = await aread(demo_path / "tasks.json")
-    await awrite(context.git_repo.workdir / TASK_FILE_REPO / rqno, data)
+    await awrite(context.repo.workdir / TASK_FILE_REPO / rqno, data)
 
-    context.src_workspace = Path(context.git_repo.workdir) / "game_2048"
+    context.src_workspace = Path(context.repo.workdir) / "game_2048"
 
     try:
         filename = "game.py"
@@ -149,9 +138,7 @@ async def test_new_coding_context():
 
         context.git_repo.add_change({f"{TASK_FILE_REPO}/{rqno}": ChangeType.UNTRACTED})
         context.git_repo.commit("mock env")
-        await ProjectRepo(context.git_repo).with_src_path(context.src_workspace).srcs.save(
-            filename=filename, content="content"
-        )
+        await context.repo.with_src_path(context.src_workspace).srcs.save(filename=filename, content="content")
         role = Engineer(context=context)
         assert not role.code_todos
         await role._new_code_actions()

tests/metagpt/roles/test_invoice_ocr_assistant.py

@@ -41,9 +41,11 @@ from metagpt.schema import Message
         ),
     ],
 )
-async def test_invoice_ocr_assistant(query: str, invoice_path: Path, invoice_table_path: Path, expected_result: dict):
+async def test_invoice_ocr_assistant(
+    query: str, invoice_path: Path, invoice_table_path: Path, expected_result: dict, context
+):
     invoice_path = TEST_DATA_PATH / invoice_path
-    role = InvoiceOCRAssistant()
+    role = InvoiceOCRAssistant(context=context)
     await role.run(Message(content=query, instruct_content=InvoicePath(file_path=invoice_path)))
     invoice_table_path = DATA_PATH / invoice_table_path
     df = pd.read_excel(invoice_table_path)

tests/metagpt/roles/test_product_manager.py

@@ -5,17 +5,51 @@
 @Author  : alexanderwu
 @File    : test_product_manager.py
 """
+import json
+
 import pytest
 
+from metagpt.actions import WritePRD
+from metagpt.actions.prepare_documents import PrepareDocuments
+from metagpt.const import REQUIREMENT_FILENAME
+from metagpt.context import Context
 from metagpt.logs import logger
 from metagpt.roles import ProductManager
+from metagpt.utils.common import any_to_str
 from tests.metagpt.roles.mock import MockMessages
 
 
 @pytest.mark.asyncio
 async def test_product_manager(new_filename):
-    product_manager = ProductManager()
-    rsp = await product_manager.run(MockMessages.req)
-    logger.info(rsp)
-    assert len(rsp.content) > 0
-    assert rsp.content == MockMessages.req.content
+    context = Context()
+    try:
+        assert context.git_repo is None
+        assert context.repo is None
+        product_manager = ProductManager(context=context)
+        # prepare documents
+        rsp = await product_manager.run(MockMessages.req)
+        assert context.git_repo
+        assert context.repo
+        assert rsp.cause_by == any_to_str(PrepareDocuments)
+        assert REQUIREMENT_FILENAME in context.repo.docs.changed_files
+
+        # write prd
+        rsp = await product_manager.run(rsp)
+        assert rsp.cause_by == any_to_str(WritePRD)
+        logger.info(rsp)
+        assert len(rsp.content) > 0
+        doc = list(rsp.instruct_content.docs.values())[0]
+        m = json.loads(doc.content)
+        assert m["Original Requirements"] == MockMessages.req.content
+
+        # nothing to do
+        rsp = await product_manager.run(rsp)
+        assert rsp is None
+    except Exception as e:
+        assert not e
+    finally:
+        context.git_repo.delete_repository()
+
+
+if __name__ == "__main__":
+    pytest.main([__file__, "-s"])

tests/metagpt/roles/test_project_manager.py

@@ -13,7 +13,7 @@ from tests.metagpt.roles.mock import MockMessages
 
 
 @pytest.mark.asyncio
-async def test_project_manager():
-    project_manager = ProjectManager()
+async def test_project_manager(context):
+    project_manager = ProjectManager(context=context)
     rsp = await project_manager.run(MockMessages.system_design)
     logger.info(rsp)

tests/metagpt/roles/test_qa_engineer.py

@@ -13,20 +13,19 @@ from pydantic import Field
 
 from metagpt.actions import DebugError, RunCode, WriteTest
 from metagpt.actions.summarize_code import SummarizeCode
-from metagpt.context import CONTEXT
 from metagpt.environment import Environment
 from metagpt.roles import QaEngineer
 from metagpt.schema import Message
 from metagpt.utils.common import any_to_str, aread, awrite
 
 
-async def test_qa():
+async def test_qa(context):
     # Prerequisites
     demo_path = Path(__file__).parent / "../../data/demo_project"
-    CONTEXT.src_workspace = Path(CONTEXT.git_repo.workdir) / "qa/game_2048"
+    context.src_workspace = Path(context.repo.workdir) / "qa/game_2048"
     data = await aread(filename=demo_path / "game.py", encoding="utf-8")
-    await awrite(filename=CONTEXT.src_workspace / "game.py", data=data, encoding="utf-8")
-    await awrite(filename=Path(CONTEXT.git_repo.workdir) / "requirements.txt", data="")
+    await awrite(filename=context.src_workspace / "game.py", data=data, encoding="utf-8")
+    await awrite(filename=Path(context.repo.workdir) / "requirements.txt", data="")
 
     class MockEnv(Environment):
         msgs: List[Message] = Field(default_factory=list)
@@ -37,7 +36,7 @@ async def test_qa():
 
     env = MockEnv()
 
-    role = QaEngineer()
+    role = QaEngineer(context=context)
     role.set_env(env)
     await role.run(with_message=Message(content="", cause_by=SummarizeCode))
     assert env.msgs

tests/metagpt/roles/test_researcher.py

@@ -28,20 +28,20 @@ async def mock_llm_ask(self, prompt: str, system_msgs):
 
 
 @pytest.mark.asyncio
-async def test_researcher(mocker, search_engine_mocker):
+async def test_researcher(mocker, search_engine_mocker, context):
     with TemporaryDirectory() as dirname:
         topic = "dataiku vs. datarobot"
         mocker.patch("metagpt.provider.base_llm.BaseLLM.aask", mock_llm_ask)
         researcher.RESEARCH_PATH = Path(dirname)
-        role = researcher.Researcher()
+        role = researcher.Researcher(context=context)
         for i in role.actions:
             if isinstance(i, CollectLinks):
-                i.search_engine = SearchEngine(SearchEngineType.DUCK_DUCK_GO)
+                i.search_engine = SearchEngine(engine=SearchEngineType.DUCK_DUCK_GO)
         await role.run(topic)
         assert (researcher.RESEARCH_PATH / f"{topic}.md").read_text().startswith("# Research Report")
 
 
-def test_write_report(mocker):
+def test_write_report(mocker, context):
     with TemporaryDirectory() as dirname:
         for i, topic in enumerate(
             [
@@ -53,7 +53,7 @@ def test_write_report(mocker):
         ):
             researcher.RESEARCH_PATH = Path(dirname)
             content = "# Research Report"
-            researcher.Researcher().write_report(topic, content)
+            researcher.Researcher(context=context).write_report(topic, content)
             assert (researcher.RESEARCH_PATH / f"{i+1}. metagpt.md").read_text().startswith("# Research Report")
 
 

tests/metagpt/roles/test_role.py

@@ -13,8 +13,8 @@ def test_role_desc():
     assert role.desc == "Best Seller"
 
 
-def test_role_human():
-    role = Role(is_human=True)
+def test_role_human(context):
+    role = Role(is_human=True, context=context)
     assert isinstance(role.llm, HumanProvider)
 
 

tests/metagpt/roles/test_tutorial_assistant.py

@@ -15,8 +15,8 @@ from metagpt.roles.tutorial_assistant import TutorialAssistant
 
 @pytest.mark.asyncio
 @pytest.mark.parametrize(("language", "topic"), [("Chinese", "Write a tutorial about pip")])
-async def test_tutorial_assistant(language: str, topic: str):
-    role = TutorialAssistant(language=language)
+async def test_tutorial_assistant(language: str, topic: str, context):
+    role = TutorialAssistant(language=language, context=context)
     msg = await role.run(topic)
     assert TUTORIAL_PATH.exists()
     filename = msg.content

tests/metagpt/serialize_deserialize/test_action.py

@@ -5,23 +5,22 @@
 import pytest
 
 from metagpt.actions import Action
-from metagpt.llm import LLM
 
 
 @pytest.mark.asyncio
-async def test_action_serdeser():
-    action = Action()
+async def test_action_serdeser(context):
+    action = Action(context=context)
     ser_action_dict = action.model_dump()
     assert "name" in ser_action_dict
     assert "llm" not in ser_action_dict  # not export
     assert "__module_class_name" in ser_action_dict
 
-    action = Action(name="test")
+    action = Action(name="test", context=context)
     ser_action_dict = action.model_dump()
     assert "test" in ser_action_dict["name"]
 
-    new_action = Action(**ser_action_dict)
+    new_action = Action(**ser_action_dict, context=context)
 
     assert new_action.name == "test"
-    assert isinstance(new_action.llm, type(LLM()))
+    assert isinstance(new_action.llm, type(context.llm()))
     assert len(await new_action._aask("who are you")) > 0

tests/metagpt/serialize_deserialize/test_architect.py

@@ -9,16 +9,20 @@ from metagpt.roles.architect import Architect
 
 
 @pytest.mark.asyncio
-async def test_architect_serdeser():
-    role = Architect()
+async def test_architect_serdeser(context):
+    role = Architect(context=context)
     ser_role_dict = role.model_dump(by_alias=True)
     assert "name" in ser_role_dict
     assert "states" in ser_role_dict
     assert "actions" in ser_role_dict
 
-    new_role = Architect(**ser_role_dict)
+    new_role = Architect(**ser_role_dict, context=context)
     assert new_role.name == "Bob"
     assert len(new_role.actions) == 1
     assert len(new_role.rc.watch) == 1
     assert isinstance(new_role.actions[0], Action)
     await new_role.actions[0].run(with_messages="write a cli snake game")
+
+
+if __name__ == "__main__":
+    pytest.main([__file__, "-s"])

tests/metagpt/serialize_deserialize/test_environment.py

@@ -18,20 +18,20 @@ from tests.metagpt.serialize_deserialize.test_serdeser_base import (
 )
 
 
-def test_env_serdeser():
-    env = Environment()
+def test_env_serdeser(context):
+    env = Environment(context=context)
     env.publish_message(message=Message(content="test env serialize"))
 
     ser_env_dict = env.model_dump()
     assert "roles" in ser_env_dict
     assert len(ser_env_dict["roles"]) == 0
 
-    new_env = Environment(**ser_env_dict)
+    new_env = Environment(**ser_env_dict, context=context)
     assert len(new_env.roles) == 0
     assert len(new_env.history) == 25
 
 
-def test_environment_serdeser():
+def test_environment_serdeser(context):
     out_mapping = {"field1": (list[str], ...)}
     out_data = {"field1": ["field1 value1", "field1 value2"]}
     ic_obj = ActionNode.create_model_class("prd", out_mapping)
@@ -40,7 +40,7 @@ def test_environment_serdeser():
         content="prd", instruct_content=ic_obj(**out_data), role="product manager", cause_by=any_to_str(UserRequirement)
     )
 
-    environment = Environment()
+    environment = Environment(context=context)
     role_c = RoleC()
     environment.add_role(role_c)
     environment.publish_message(message)
@@ -48,7 +48,7 @@ def test_environment_serdeser():
     ser_data = environment.model_dump()
     assert ser_data["roles"]["Role C"]["name"] == "RoleC"
 
-    new_env: Environment = Environment(**ser_data)
+    new_env: Environment = Environment(**ser_data, context=context)
     assert len(new_env.roles) == 1
 
     assert list(new_env.roles.values())[0].states == list(environment.roles.values())[0].states
@@ -57,22 +57,22 @@ def test_environment_serdeser():
     assert type(list(new_env.roles.values())[0].actions[1]) == ActionRaise
 
 
-def test_environment_serdeser_v2():
-    environment = Environment()
+def test_environment_serdeser_v2(context):
+    environment = Environment(context=context)
     pm = ProjectManager()
     environment.add_role(pm)
 
     ser_data = environment.model_dump()
 
-    new_env: Environment = Environment(**ser_data)
+    new_env: Environment = Environment(**ser_data, context=context)
     role = new_env.get_role(pm.profile)
     assert isinstance(role, ProjectManager)
     assert isinstance(role.actions[0], WriteTasks)
     assert isinstance(list(new_env.roles.values())[0].actions[0], WriteTasks)
 
 
-def test_environment_serdeser_save():
-    environment = Environment()
+def test_environment_serdeser_save(context):
+    environment = Environment(context=context)
     role_c = RoleC()
 
     stg_path = serdeser_path.joinpath("team", "environment")
@@ -82,6 +82,6 @@ def test_environment_serdeser_save():
     write_json_file(env_path, environment.model_dump())
 
     env_dict = read_json_file(env_path)
-    new_env: Environment = Environment(**env_dict)
+    new_env: Environment = Environment(**env_dict, context=context)
     assert len(new_env.roles) == 1
     assert type(list(new_env.roles.values())[0].actions[0]) == ActionOK

tests/metagpt/serialize_deserialize/test_memory.py

@@ -13,7 +13,7 @@ from metagpt.utils.common import any_to_str, read_json_file, write_json_file
 from tests.metagpt.serialize_deserialize.test_serdeser_base import serdeser_path
 
 
-def test_memory_serdeser():
+def test_memory_serdeser(context):
     msg1 = Message(role="Boss", content="write a snake game", cause_by=UserRequirement)
 
     out_mapping = {"field2": (list[str], ...)}
@@ -39,7 +39,7 @@ def test_memory_serdeser():
     assert memory.count() == 2
 
 
-def test_memory_serdeser_save():
+def test_memory_serdeser_save(context):
     msg1 = Message(role="User", content="write a 2048 game", cause_by=UserRequirement)
 
     out_mapping = {"field1": (list[str], ...)}

tests/metagpt/serialize_deserialize/test_prepare_interview.py

@@ -8,12 +8,12 @@ from metagpt.actions.prepare_interview import PrepareInterview
 
 
 @pytest.mark.asyncio
-async def test_action_serdeser():
-    action = PrepareInterview()
+async def test_action_serdeser(context):
+    action = PrepareInterview(context=context)
     serialized_data = action.model_dump()
     assert serialized_data["name"] == "PrepareInterview"
 
-    new_action = PrepareInterview(**serialized_data)
+    new_action = PrepareInterview(**serialized_data, context=context)
 
     assert new_action.name == "PrepareInterview"
     assert type(await new_action.run("python developer")) == ActionNode

tests/metagpt/serialize_deserialize/test_product_manager.py

@@ -10,10 +10,10 @@ from metagpt.schema import Message
 
 
 @pytest.mark.asyncio
-async def test_product_manager_serdeser(new_filename):
-    role = ProductManager()
+async def test_product_manager_serdeser(new_filename, context):
+    role = ProductManager(context=context)
     ser_role_dict = role.model_dump(by_alias=True)
-    new_role = ProductManager(**ser_role_dict)
+    new_role = ProductManager(**ser_role_dict, context=context)
 
     assert new_role.name == "Alice"
     assert len(new_role.actions) == 2

tests/metagpt/serialize_deserialize/test_project_manager.py

@@ -10,14 +10,14 @@ from metagpt.roles.project_manager import ProjectManager
 
 
 @pytest.mark.asyncio
-async def test_project_manager_serdeser():
-    role = ProjectManager()
+async def test_project_manager_serdeser(context):
+    role = ProjectManager(context=context)
     ser_role_dict = role.model_dump(by_alias=True)
     assert "name" in ser_role_dict
     assert "states" in ser_role_dict
     assert "actions" in ser_role_dict
 
-    new_role = ProjectManager(**ser_role_dict)
+    new_role = ProjectManager(**ser_role_dict, context=context)
     assert new_role.name == "Eve"
     assert len(new_role.actions) == 1
     assert isinstance(new_role.actions[0], Action)