refactor code generate tools

.gitignore

@@ -1,2 +1,3 @@
 __pycache__/*
+**/__pycache__/*
 .DS_Store

README.md

@@ -11,3 +11,18 @@ license: apache-2.0
 ---
 
 Check out the configuration reference at https://huggingface.co/docs/hub/spaces-config-reference
+
+## 环境依赖
+python3
+
+## 安装依赖
+
+```shell
+pip install -r requirments
+```
+
+## 运行命令
+
+```shell
+python -m app.py
+```

code_generate.py → agents/code_generate_agent.py

@@ -2,42 +2,14 @@ import re
 from typing import List, Union
 from langchain.chains import LLMChain
 from langchain.chat_models import ChatOpenAI
-from langchain.agents import tool, Tool, LLMSingleActionAgent, AgentExecutor, AgentOutputParser
+from langchain.agents import Tool, LLMSingleActionAgent, AgentExecutor, AgentOutputParser
 from langchain.schema import AgentAction, AgentFinish
 from langchain.agents import initialize_agent
-from langchain.memory import ConversationBufferMemory
 from langchain.prompts import StringPromptTemplate
 from promopts import code_generate_agent_template
-
-
-
-
-from promopts import API_LAYER_PROMPT, DOMAIN_LAYER_PROMPT, PERSISTENT_LAYER_PROMPT
-
-domainLayerChain = LLMChain(llm = ChatOpenAI(temperature=0.1), prompt=DOMAIN_LAYER_PROMPT)
-
-persistentChain = LLMChain(llm = ChatOpenAI(temperature=0.1), prompt=PERSISTENT_LAYER_PROMPT)
-
-apiChain = LLMChain(llm = ChatOpenAI(temperature=0.1), prompt=API_LAYER_PROMPT)
-
-@tool("Generate Domain Layer Code", return_direct=True)
-def domainLayerCodeGenerator(input: str) -> str:
-    '''useful for when you need to generate domain layer code'''
-    response = domainLayerChain.run(input)
-    return response
-
-@tool("Generate Persistent Layer Code", return_direct=True)
-def persistentLayerCodeGenerator(input: str) -> str:
-    '''useful for when you need to generate persistent layer code'''
-    response = persistentChain.run(input)
-    return response
-
-@tool("Generate API Layer Code", return_direct=True)
-def apiLayerCodeGenerator(input: str) -> str:
-    '''useful for when you need to generate API layer code'''
-    response = apiChain.run(input)
-    return response
-
+from agents.tools.api_layer_code_tool import apiLayerCodeGenerator
+from agents.tools.domain_layer_code_tool import domainLayerCodeGenerator
+from agents.tools.persistent_layer_code_tool import persistentLayerCodeGenerator
 
 
 class CustomPromptTemplate(StringPromptTemplate):
@@ -94,19 +66,13 @@ class CustomOutputParser(AgentOutputParser):
 
 # agent = initialize_agent(
 #     tools=tools, llm=llm_chain, template=AGENT_PROMPT, stop=["\nObservation:"], agent=AgentType.ZERO_SHOT_REACT_DESCRIPTION, verbose=True)
-tools = [domainLayerCodeGenerator, persistentLayerCodeGenerator, apiLayerCodeGenerator]
-
+code_agent_tools = [domainLayerCodeGenerator, persistentLayerCodeGenerator, apiLayerCodeGenerator]
 
 def code_agent_executor() -> AgentExecutor:
-    
-
-    
     output_parser = CustomOutputParser()
-
-
     AGENT_PROMPT = CustomPromptTemplate(
         template=code_generate_agent_template,
-        tools=tools,
+        tools=code_agent_tools,
         # This omits the `agent_scratchpad`, `tools`, and `tool_names` variables because those are generated dynamically
         # This includes the `intermediate_steps` variable because that is needed
         input_variables=["input", "intermediate_steps"]
@@ -114,7 +80,7 @@ def code_agent_executor() -> AgentExecutor:
 
     code_llm_chain = LLMChain(llm=ChatOpenAI(temperature=0.7), prompt=AGENT_PROMPT)
 
-    tool_names = [tool.name for tool in tools]
+    tool_names = [tool.name for tool in code_agent_tools]
     code_agent = LLMSingleActionAgent(
         llm_chain=code_llm_chain,
         output_parser=output_parser,
@@ -123,7 +89,7 @@ def code_agent_executor() -> AgentExecutor:
     )
 
     code_agent_executor = AgentExecutor.from_agent_and_tools(
-        agent=code_agent, tools=tools, verbose=True)
+        agent=code_agent, tools=code_agent_tools, verbose=True)
     return code_agent_executor
 
 # if __name__ == "__main__":

agents/tools/api_layer_code_tool.py

@@ -0,0 +1,95 @@
+from langchain import LLMChain, PromptTemplate
+from langchain.chat_models import ChatOpenAI
+from langchain.agents import tool
+
+
+API_LAYER = """You are a software developer. Your task is to generate the api layer tests and product code.
+
+===TechStack
+Java17、reactor、lombok、Junit5、reactor test、Mockito、 Spring WebFlux、Spring Boot Test
+===END OF TechStack
+
+===Architecture
+the api layer inclue 2 componets:
+* DTO: This component is use to define data structure that api request and response.
+* Controller: This component is use to define the interface to access api.
+    ---eaxmple code:
+        @RestController
+        @RequiredArgsConstructor
+        @RequestMapping("/features")
+        public class FeatureController {{
+            private final Features features;
+
+            @GetMapping()
+            public Flux<Feature> findAll() {{
+                return features.getAll();
+            }}
+
+            @PostMapping()
+            public Mono<Feature> add(@RequestBody Feature feature) {{
+                return features.add(feature);
+            }}
+        }}
+    ---end of eaxmple code
+===END OF Architecture
+
+===TestStrategy
+For the Controller and DTO, we can write component test to test the actual implementation of api operations, test class rely on Association interface use WebFluxTest and WebTestClient ability.
+    ---eaxmple code: 
+        @ExtendWith(SpringExtension.class)
+        @WebFluxTest(value = FeatureFlagApi.class, properties = "spring.main.lazy-initialization=true")
+        @ContextConfiguration(classes = TestConfiguration.class)
+        class FeatureControllerTest extends ControllerTestBase {{
+            @Autowired
+            WebTestClient webClient;
+
+            @MockBean
+            Features features;
+
+            @Test
+            void should_getAll_success_when_no_records() {{
+                when(features.getAll(Mockito.any())).thenReturn(Flux.empty());
+
+                webClient.get()
+                        .uri("/features")
+                        .exchange()
+                        .expectStatus()
+                        .isOk()
+                        .expectBodyList(FeatureFlagResponse.class)
+                        .hasSize(0);
+            }}
+        }}      
+    ---end of eaxmple code
+===END OF TestStrategy
+
+Use the following format:
+request: the request that you need to fulfill include Entity and Association of domain layer
+
+DTO:
+```
+the DTO code that you write to fulfill the request, follow TechStack and Architecture
+```
+
+Controller:
+```
+the Controller code that you write to fulfill the request, follow TechStack and Architecture
+```
+
+Test:
+```
+the test code that you write to fulfill the request, follow TechStack Architecture and TestStrategy
+```
+
+request: {input}"""
+
+API_LAYER_PROMPT = PromptTemplate(input_variables=["input"], template=API_LAYER,)
+
+
+apiChain = LLMChain(llm = ChatOpenAI(temperature=0.1), prompt=API_LAYER_PROMPT)
+
+
+@tool("Generate API Layer Code", return_direct=True)
+def apiLayerCodeGenerator(input: str) -> str:
+    '''useful for when you need to generate API layer code'''
+    response = apiChain.run(input)
+    return response

agents/tools/domain_layer_code_tool.py

@@ -0,0 +1,85 @@
+from langchain import LLMChain, PromptTemplate
+from langchain.chat_models import ChatOpenAI
+from langchain.agents import tool
+
+
+DOMAIN_LAYER = """You are a software developer. Your task is to generate the domain layer tests and product code.
+
+===TechStack
+Java17、reactor、lombok、Junit5、reactor test、Mockito
+===END OF TechStack
+
+===Architecture
+the domain layer inclue 2 componets:
+* Entity: This component is use to represents business concepts and encapsulates business rules.
+    ---eaxmple code: 
+        public class Feature {{
+            private FeatureId id;
+            private FeatureDescription description;
+
+            public record FeatureId(String featureKey) {{
+            
+            }}
+
+            @Builder
+            public record FeatureDescription(String name, String description, Boolean isEnable))) {{
+            
+            }}
+        }}
+    ---end of eaxmple code
+* Association: This component is use to define association between entities, which can represents the concept of a set of entity. 
+    ---eaxmple code: 
+        public interface Features {{
+            Flux<Feature> findAll();
+
+            Mono<Feature> findById(FeatureId id);
+
+            Mono<Feature> save(Feature feature);
+
+            Mono<Void> update(FeatureId id, FeatureDescription description);
+
+            Mono<Void> delete(FeatureId id);
+
+            Mono<Void> publish(FeatureId id);
+
+            Mono<Void> disable(FeatureId id);
+        }}
+    ---end of eaxmple code
+===END OF Architecture
+
+===TestStrategy
+For the Entity, we can write unit test to ensure that the business rules related to Merchandise are correctly encapsulated.
+For the Association，do not write tests because it is has no impletation.
+===END OF TestStrategy
+
+Use the following format:
+request: the request that you need to fulfill
+
+Entity:
+```
+the Entity code that you write to fulfill the request, follow TechStack and Architecture
+```
+
+Association:
+```
+the Association code that you write to fulfill the request, follow TechStack and Architecture
+```
+
+Test:
+```
+the test code that you write to fulfill the request, follow TechStack Architecture and TestStrategy
+```
+
+request: {input}"""
+
+
+DOMAIN_LAYER_PROMPT = PromptTemplate(input_variables=["input"], template=DOMAIN_LAYER,)
+
+domainLayerChain = LLMChain(llm = ChatOpenAI(temperature=0.1), prompt=DOMAIN_LAYER_PROMPT)
+
+
+@tool("Generate Domain Layer Code", return_direct=True)
+def domainLayerCodeGenerator(input: str) -> str:
+    '''useful for when you need to generate domain layer code'''
+    response = domainLayerChain.run(input)
+    return response

agents/tools/persistent_layer_code_tool.py

@@ -0,0 +1,172 @@
+from langchain import LLMChain, PromptTemplate
+from langchain.chat_models import ChatOpenAI
+from langchain.agents import tool
+
+
+PERSISTENT_LAYER = """You are a software developer. Your task is to generate the persistent layer tests and product code.
+
+===TechStack
+Java17、reactor、lombok、Junit5、reactor test、Mockito、 Spring Data Reactive Couchbase、Testcontainers、Couchbase、WebClient
+===END OF TechStack
+
+===Architecture
+the persistent layer inclue 3 componets:
+* DbEntity: This component is use to define data structure that save to DB.
+    ---eaxmple code:
+        @Document 
+        public class FeatureDb {{
+            @Version
+            private long version;
+
+            @Id
+            @GeneratedValue(strategy = GenerationStrategy.UNIQUE)
+            private String id;
+            
+            private String featureKey;
+
+            private Feature.FeatureDescription description;
+        }}
+    ---end of eaxmple code
+* Repository: This component is use to define the interface to access DB.
+    ---eaxmple code:
+        public interface FeatureDbRepository extends ReactiveCrudRepository<FeatureDb, String> {{
+            Mono<FeatureDb> findByFeatureKey(String featureKey);
+        }}
+    ---end of eaxmple code
+* Association Impletation: This component provide implementation of Association of domain layer, rely on Repository. 
+    ---eaxmple code: 
+        @Component
+        @RequiredArgsConstructor
+        public class FeaturesImpl implements Features{{
+            private final FeatureDbRepository featureDbRepository;
+
+            Flux<Feature> findAll() {{
+                return featureDbRepository.findAll().map(FeatureDb::toFeature);
+            }}
+
+            Mono<Feature> save(Feature feature) {{
+                return featureDbRepository.save(FeatureDb.fromFeature(feature)).map(FeatureDb::toFeature);
+            }}
+        }}
+    ---end of eaxmple code
+===END OF Architecture
+
+===TestStrategy
+For the DbEntity And Repository, we can write component test to test the actual implementation of database operations, test class should extends RepositoryTestBase to use Testcontainers ability.
+    ---eaxmple code: 
+        class FeatureDbRepositoryTest extends RepositoryTestBase {{
+            @Autowired
+            FeatureDbRepository repository;
+
+            @BeforeEach
+            void setUp() {{
+                repository.deleteAll().block();
+            }}
+
+            @AfterEach
+            void tearDown() {{
+                repository.deleteAll().block();
+            }}
+
+            @Test
+            void should_save_Feature_success() {{
+                var featureKey = "featureKey1";
+                repository.save(FeatureTestUtil.createFeatureDb(featureKey))
+                        .as(StepVerifier::create)
+                        .expectNextCount(1)
+                        .verifyComplete();
+            }}
+
+            @Test
+            void should_add_same_featureKey_fail() {{
+                var featureKey = "featureKey1";
+                repository.save(FeatureTestUtil.createFeatureDb(featureKey)).block();
+
+                repository.save(FeatureTestUtil.createFeatureDb(featureKey))
+                        .as(StepVerifier::create)
+                        .expectError()
+                        .verify();
+            }}
+        }}
+    ---end of eaxmple code
+For Association Impletation，we writ unit test, and stub repository method with Mockito.
+    ---eaxmple code:
+        @ExtendWith(MockitoExtension.class)
+        class FeatureImplTest {{
+            @Mock
+            FeatureDbRepository repository;
+
+            Features features;
+
+            @BeforeEach
+            void setUp() {{
+                features = new FeaturesImpl(repository);
+            }}
+
+            @Test
+            void should_add_success() {{
+                when(repository.save(any(FeatureDb.class))).thenAnswer(invocation -> {{
+                    FeatureDb featureDb = invocation.getArgument(0);
+                    return Mono.just(featureDb);
+                }});
+
+                features.add(createFeature("featureKey1"))
+                        .as(StepVerifier::create)
+                        .expectNextMatches(config -> config.getId().featureKey().equals("featureKey1")
+                                && config.getDescription().updatedAt() != null
+                                && config.getDescription().createdAt() != null
+                        )
+                        .verifyComplete();
+            }}
+
+            @Test
+            void should_add_return_error_when_repository_save_error() {{
+                Feature feature = createFeature("featureKey1");
+
+                when(repository.save(any(FeatureDb.class))).thenReturn(Mono.error(new DuplicateKeyException("save error")));
+
+                features.add(feature)
+                        .as(StepVerifier::create)
+                        .expectError()
+                        .verify();
+            }}
+        }}
+            
+
+===END OF TestStrategy
+
+Use the following format:
+request: the request that you need to fulfill include Entity and Association of domain layer
+
+DBEntity:
+```
+the DBEntity code that you write to fulfill the request, follow TechStack and Architecture
+```
+
+Repository:
+```
+the Repository code that you write to fulfill the request, follow TechStack and Architecture
+```
+
+Association Impletation:
+```
+the Association Impletation code that you write to fulfill the request, follow TechStack and Architecture
+```
+
+Test:
+```
+the test code that you write to fulfill the request, follow TechStack Architecture and TestStrategy
+```
+
+request: {input}"""
+
+PERSISTENT_LAYER_PROMPT = PromptTemplate(input_variables=["input"], template=PERSISTENT_LAYER,)
+
+persistentChain = LLMChain(llm = ChatOpenAI(temperature=0.1), prompt=PERSISTENT_LAYER_PROMPT)
+
+
+@tool("Generate Persistent Layer Code", return_direct=True)
+def persistentLayerCodeGenerator(input: str) -> str:
+    '''useful for when you need to generate persistent layer code'''
+    response = persistentChain.run(input)
+    return response

app.py

@@ -7,7 +7,7 @@ from embedding import CustomEmbedding
 from memories import HumenFeedbackBufferMemory
 from langchain.memory import ConversationBufferMemory
 from promopts import FEEDBACK, FEEDBACK_PROMPT
-from code_generate import code_agent_executor, tools
+from agents.code_generate_agent import code_agent_executor, code_agent_tools
 
 # llm = ChatOpenAI(temperature=0.7)
 
@@ -110,7 +110,8 @@ with gr.Blocks() as demo:
                             story = gr.Textbox(show_label=True, label="User Story", placeholder="Enter User Story").style(
                                 container=False)
                         with gr.Row():
-                            buisinessButton = gr.Button("Generate Scenarios")
+                            gr.Button("Generate Scenarios").click(clearMemory, [chatbot], [chatbot, txt]).then(sendMessage, [chatbot, txt], [chatbot]).then(
+                                feedBack, [context, story, chatbot], [chatbot, txt])
                         with gr.Row():
                             with gr.Column(scale=5):
                                 gr.Button("Rewrite Context").click(rewriteContext, [context, chatbot], [chatbot, context])
@@ -136,7 +137,7 @@ with gr.Blocks() as demo:
                         with gr.Row():
                             relateCode = gr.Textbox(show_label=True, label="Relate Code", placeholder="Enter Relate Code").style(
                                 container=False)
-                        for index, tool in enumerate(tools):
+                        for index, tool in enumerate(code_agent_tools):
                             with gr.Row():
                                 toolTextBox.append(gr.Textbox(show_label=False, visible=False, label=tool.name, value=tool.name).style())
                                 gr.Button(tool.name).click(
@@ -148,10 +149,7 @@ with gr.Blocks() as demo:
                     faq = gr.Textbox(show_label=False, placeholder="Enter text and press enter").style(
                         container=False)
 
-    
-    buisinessButton.click(clearMemory, [chatbot], [chatbot, txt]).then(sendMessage, [chatbot, txt], [chatbot]).then(
-        feedBack, [context, story, chatbot], [chatbot, txt])
-    
+        
     txt.submit(sendMessage, [chatbot, txt], [chatbot]).then(
         feedBack, [context, story, chatbot, txt], [chatbot, txt, context])
     

promopts.py

@@ -50,320 +50,14 @@ Story: {input}
 {agent_scratchpad}"""
 
 
-DOMAIN_LAYER = """You are a software developer. Your task is to generate the domain layer tests and product code.
 
-===TechStack
-Java17、reactor、lombok、Junit5、reactor test、Mockito
-===END OF TechStack
 
-===Architecture
-the domain layer inclue 2 componets:
-* Entity: This component is use to represents business concepts and encapsulates business rules.
-    ---eaxmple code: 
-        public class Feature {{
-            private FeatureId id;
-            private FeatureDescription description;
 
-            public record FeatureId(String featureKey) {{
-            
-            }}
 
-            @Builder
-            public record FeatureDescription(String name, String description, Boolean isEnable))) {{
-            
-            }}
-        }}
-    ---end of eaxmple code
-* Association: This component is use to define association between entities, which can represents the concept of a set of entity. 
-    ---eaxmple code: 
-        public interface Features {{
-            Flux<Feature> findAll();
 
-            Mono<Feature> findById(FeatureId id);
 
-            Mono<Feature> save(Feature feature);
 
-            Mono<Void> update(FeatureId id, FeatureDescription description);
 
-            Mono<Void> delete(FeatureId id);
-
-            Mono<Void> publish(FeatureId id);
-
-            Mono<Void> disable(FeatureId id);
-        }}
-    ---end of eaxmple code
-===END OF Architecture
-
-===TestStrategy
-For the Entity, we can write unit test to ensure that the business rules related to Merchandise are correctly encapsulated.
-For the Association，do not write tests because it is has no impletation.
-===END OF TestStrategy
-
-Use the following format:
-request: the request that you need to fulfill
-
-Entity:
-```
-the Entity code that you write to fulfill the request, follow TechStack and Architecture
-```
-
-Association:
-```
-the Association code that you write to fulfill the request, follow TechStack and Architecture
-```
-
-Test:
-```
-the test code that you write to fulfill the request, follow TechStack Architecture and TestStrategy
-```
-
-request: {input}"""
-
-
-DOMAIN_LAYER_PROMPT = PromptTemplate(input_variables=["input"], template=DOMAIN_LAYER,)
-
-
-PERSISTENT_LAYER = """You are a software developer. Your task is to generate the persistent layer tests and product code.
-
-===TechStack
-Java17、reactor、lombok、Junit5、reactor test、Mockito、 Spring Data Reactive Couchbase、Testcontainers、Couchbase、WebClient
-===END OF TechStack
-
-===Architecture
-the persistent layer inclue 3 componets:
-* DbEntity: This component is use to define data structure that save to DB.
-    ---eaxmple code:
-        @Document 
-        public class FeatureDb {{
-            @Version
-            private long version;
-
-            @Id
-            @GeneratedValue(strategy = GenerationStrategy.UNIQUE)
-            private String id;
-            
-            private String featureKey;
-
-            private Feature.FeatureDescription description;
-        }}
-    ---end of eaxmple code
-* Repository: This component is use to define the interface to access DB.
-    ---eaxmple code:
-        public interface FeatureDbRepository extends ReactiveCrudRepository<FeatureDb, String> {{
-            Mono<FeatureDb> findByFeatureKey(String featureKey);
-        }}
-    ---end of eaxmple code
-* Association Impletation: This component provide implementation of Association of domain layer, rely on Repository. 
-    ---eaxmple code: 
-        @Component
-        @RequiredArgsConstructor
-        public class FeaturesImpl implements Features{{
-            private final FeatureDbRepository featureDbRepository;
-
-            Flux<Feature> findAll() {{
-                return featureDbRepository.findAll().map(FeatureDb::toFeature);
-            }}
-
-            Mono<Feature> save(Feature feature) {{
-                return featureDbRepository.save(FeatureDb.fromFeature(feature)).map(FeatureDb::toFeature);
-            }}
-        }}
-    ---end of eaxmple code
-===END OF Architecture
-
-===TestStrategy
-For the DbEntity And Repository, we can write component test to test the actual implementation of database operations, test class should extends RepositoryTestBase to use Testcontainers ability.
-    ---eaxmple code: 
-        class FeatureDbRepositoryTest extends RepositoryTestBase {{
-            @Autowired
-            FeatureDbRepository repository;
-
-            @BeforeEach
-            void setUp() {{
-                repository.deleteAll().block();
-            }}
-
-            @AfterEach
-            void tearDown() {{
-                repository.deleteAll().block();
-            }}
-
-            @Test
-            void should_save_Feature_success() {{
-                var featureKey = "featureKey1";
-                repository.save(FeatureTestUtil.createFeatureDb(featureKey))
-                        .as(StepVerifier::create)
-                        .expectNextCount(1)
-                        .verifyComplete();
-            }}
-
-            @Test
-            void should_add_same_featureKey_fail() {{
-                var featureKey = "featureKey1";
-                repository.save(FeatureTestUtil.createFeatureDb(featureKey)).block();
-
-                repository.save(FeatureTestUtil.createFeatureDb(featureKey))
-                        .as(StepVerifier::create)
-                        .expectError()
-                        .verify();
-            }}
-        }}
-    ---end of eaxmple code
-For Association Impletation，we writ unit test, and stub repository method with Mockito.
-    ---eaxmple code:
-        @ExtendWith(MockitoExtension.class)
-        class FeatureImplTest {{
-            @Mock
-            FeatureDbRepository repository;
-
-            Features features;
-
-            @BeforeEach
-            void setUp() {{
-                features = new FeaturesImpl(repository);
-            }}
-
-            @Test
-            void should_add_success() {{
-                when(repository.save(any(FeatureDb.class))).thenAnswer(invocation -> {{
-                    FeatureDb featureDb = invocation.getArgument(0);
-                    return Mono.just(featureDb);
-                }});
-
-                features.add(createFeature("featureKey1"))
-                        .as(StepVerifier::create)
-                        .expectNextMatches(config -> config.getId().featureKey().equals("featureKey1")
-                                && config.getDescription().updatedAt() != null
-                                && config.getDescription().createdAt() != null
-                        )
-                        .verifyComplete();
-            }}
-
-            @Test
-            void should_add_return_error_when_repository_save_error() {{
-                Feature feature = createFeature("featureKey1");
-
-                when(repository.save(any(FeatureDb.class))).thenReturn(Mono.error(new DuplicateKeyException("save error")));
-
-                features.add(feature)
-                        .as(StepVerifier::create)
-                        .expectError()
-                        .verify();
-            }}
-        }}
-            
-
-===END OF TestStrategy
-
-Use the following format:
-request: the request that you need to fulfill include Entity and Association of domain layer
-
-DBEntity:
-```
-the DBEntity code that you write to fulfill the request, follow TechStack and Architecture
-```
-
-Repository:
-```
-the Repository code that you write to fulfill the request, follow TechStack and Architecture
-```
-
-Association Impletation:
-```
-the Association Impletation code that you write to fulfill the request, follow TechStack and Architecture
-```
-
-Test:
-```
-the test code that you write to fulfill the request, follow TechStack Architecture and TestStrategy
-```
-
-request: {input}"""
-
-PERSISTENT_LAYER_PROMPT = PromptTemplate(input_variables=["input"], template=PERSISTENT_LAYER,)
-
-
-
-API_LAYER = """You are a software developer. Your task is to generate the api layer tests and product code.
-
-===TechStack
-Java17、reactor、lombok、Junit5、reactor test、Mockito、 Spring WebFlux、Spring Boot Test
-===END OF TechStack
-
-===Architecture
-the api layer inclue 2 componets:
-* DTO: This component is use to define data structure that api request and response.
-* Controller: This component is use to define the interface to access api.
-    ---eaxmple code:
-        @RestController
-        @RequiredArgsConstructor
-        @RequestMapping("/features")
-        public class FeatureController {{
-            private final Features features;
-
-            @GetMapping()
-            public Flux<Feature> findAll() {{
-                return features.getAll();
-            }}
-
-            @PostMapping()
-            public Mono<Feature> add(@RequestBody Feature feature) {{
-                return features.add(feature);
-            }}
-        }}
-    ---end of eaxmple code
-===END OF Architecture
-
-===TestStrategy
-For the Controller and DTO, we can write component test to test the actual implementation of api operations, test class rely on Association interface use WebFluxTest and WebTestClient ability.
-    ---eaxmple code: 
-        @ExtendWith(SpringExtension.class)
-        @WebFluxTest(value = FeatureFlagApi.class, properties = "spring.main.lazy-initialization=true")
-        @ContextConfiguration(classes = TestConfiguration.class)
-        class FeatureControllerTest extends ControllerTestBase {{
-            @Autowired
-            WebTestClient webClient;
-
-            @MockBean
-            Features features;
-
-            @Test
-            void should_getAll_success_when_no_records() {{
-                when(features.getAll(Mockito.any())).thenReturn(Flux.empty());
-
-                webClient.get()
-                        .uri("/features")
-                        .exchange()
-                        .expectStatus()
-                        .isOk()
-                        .expectBodyList(FeatureFlagResponse.class)
-                        .hasSize(0);
-            }}
-        }}      
-    ---end of eaxmple code
-===END OF TestStrategy
-
-Use the following format:
-request: the request that you need to fulfill include Entity and Association of domain layer
-
-DTO:
-```
-the DTO code that you write to fulfill the request, follow TechStack and Architecture
-```
-
-Controller:
-```
-the Controller code that you write to fulfill the request, follow TechStack and Architecture
-```
-
-Test:
-```
-the test code that you write to fulfill the request, follow TechStack Architecture and TestStrategy
-```
-
-request: {input}"""
-
-API_LAYER_PROMPT = PromptTemplate(input_variables=["input"], template=API_LAYER,)
 
 
 code_generate_agent_template = """You are a tool picker.