add generate code agent

.gitignore

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

app.py

@@ -2,22 +2,18 @@ import gradio as gr
 from langchain.chains import LLMChain
 from langchain.chat_models import ChatOpenAI
 from langchain.document_loaders import TextLoader
+from chains import HumanFeedBackChain
 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
 
-llm = ChatOpenAI(temperature=0.1)
+# llm = ChatOpenAI(temperature=0.1)
 
-memory = HumenFeedbackBufferMemory(
-    input_key="input", human_prefix="Answer", ai_prefix="AI")
-
-llmchain = LLMChain(
-    llm=llm,
-    prompt=FEEDBACK_PROMPT,
-    memory=memory,
-    verbose=True
-)
+baMemory = HumenFeedbackBufferMemory(
+            input_key="input", human_prefix="Answer", ai_prefix="AI")
+baChain = HumanFeedBackChain(verbose=True, memory=baMemory)
 
 """读取document/business_context.py文件内容作为context"""
 context_path = "./documents/bussiness_context/business_context.md"
@@ -33,18 +29,18 @@ def sendMessage(chatbot, input):
 
 def clearMemory(chatbot):
     chatbot.clear()
-    memory.clear()
+    if baMemory != None:
+        baMemory.clear()
     return chatbot, ""
 
 
 def feedBack(context, story, chatbot=[], input=""):
     if len(input) > 0:
-        context += (f"\n- {input}")
+        context += (f"\n\n {input}")
         with open(context_path, 'w') as f:
             f.write(context)
-
-    response = llmchain.run(
-        input=(input if len(input) == 0 else ("Answer: " + input)), context=context, story=story, stop="\nAnswer:")
+    response = baChain.run(
+        input=(input if len(input) == 0 else input), context=context, story=story, stop="\nAnswer:")
     chatbot[-1][1] = response
     return chatbot, "", context
 
@@ -53,7 +49,7 @@ customerEmbedding = CustomEmbedding()
 
 faqChain = customerEmbedding.getFAQChain()
 
-
+code_agent_executor = code_agent_executor()
 def faqFromLocal(input, chatbot=[]):
     response = faqChain.run(input)
     chatbot.append((input, response))
@@ -65,6 +61,16 @@ def generateEmbeddings():
     customerEmbedding.calculateNotionEmbedding()
 
 
+def generateCode(input: str, chatbot=[]):
+    if len(input) <=0:
+        chatbot[-1][1] = None
+        return chatbot, ""
+    response = code_agent_executor.run(
+        input=(input if len(input) == 0 else input))
+    chatbot[-1][1] = response
+    return chatbot, ""
+
+
 with gr.Blocks() as demo:
     with gr.Row():
         with gr.Column():
@@ -74,7 +80,10 @@ with gr.Blocks() as demo:
                 txt = gr.Textbox(show_label=False, placeholder="Enter text and press enter").style(
                     container=False)
             with gr.Row():
-                faq = gr.Textbox(show_label=False, placeholder="A&Q from local context").style(
+                code = gr.Textbox(show_label=True, label="Code Generate", placeholder="Enter text and press enter").style(
+                    container=False)
+            with gr.Row():
+                faq = gr.Textbox(show_label=False, placeholder="Q&A from local context").style(
                     container=False)
         with gr.Column():
             with gr.Row():
@@ -96,6 +105,10 @@ with gr.Blocks() as demo:
         feedBack, [context, story, chatbot], [chatbot, txt])
     txt.submit(sendMessage, [chatbot, txt], [chatbot]).then(
         feedBack, [context, story, chatbot, txt], [chatbot, txt, context])
+    
+    code.submit(sendMessage, [chatbot, code], [chatbot]).then(
+        generateCode, [code, chatbot], [chatbot, code])
+    
     faq.submit(faqFromLocal, [faq, chatbot], [chatbot, faq])
     generateEmbedding.click(generateEmbeddings)
 

chains.py

@@ -0,0 +1,42 @@
+from typing import Any, Optional
+from langchain.chains import LLMChain
+from langchain.base_language import BaseLanguageModel
+from langchain.schema import LLMResult, PromptValue
+from langchain.prompts import PromptTemplate
+from langchain.memory.chat_memory import BaseMemory
+from langchain.chat_models import ChatOpenAI
+
+from promopts import FEEDBACK_PROMPT
+
+
+class HumanFeedBackChain(LLMChain):
+    """Chain to run queries against LLMs."""
+
+    memory: Optional[BaseMemory] = None
+
+    def __init__(self, verbose=True, llm: BaseLanguageModel = ChatOpenAI(temperature=0.7),  memory: Optional[BaseMemory] = None, prompt: PromptTemplate = FEEDBACK_PROMPT):
+        super().__init__(llm=llm, prompt=prompt, memory=memory, verbose=verbose)
+
+    def run(self, *args: Any, **kwargs: Any) -> str:
+        """Run the chain as text in, text out or multiple variables, text out."""
+        if len(self.output_keys) != 1:
+            raise ValueError(
+                f"`run` not supported when there is not exactly "
+                f"one output key. Got {self.output_keys}."
+            )
+
+        if args and not kwargs:
+            if len(args) != 1:
+                raise ValueError(
+                    "`run` supports only one positional argument.")
+            return self("Answer:" + args[0])[self.output_keys[0]]
+
+        if kwargs and not args:
+            return self(kwargs)[self.output_keys[0]]
+
+        raise ValueError(
+            f"`run` supported with either positional arguments or keyword arguments"
+            f" but not both. Got args: {args} and kwargs: {kwargs}."
+        )
+
+

code_generate.py

@@ -0,0 +1,259 @@
+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.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
+
+
+
+class CustomPromptTemplate(StringPromptTemplate):
+    # The template to use
+    template: str
+    # The list of tools available
+    tools: List[Tool]
+
+    def format(self, **kwargs) -> str:
+        # Get the intermediate steps (AgentAction, Observation tuples)
+        # Format them in a particular way
+        intermediate_steps = kwargs.pop("intermediate_steps")
+        thoughts = ""
+        for action, observation in intermediate_steps:
+            thoughts += action.log
+            thoughts += f"\nObservation: {observation}\nThought: "
+        # Set the agent_scratchpad variable to that value
+        kwargs["agent_scratchpad"] = thoughts
+        # Create a tools variable from the list of tools provided
+        kwargs["tools"] = "\n".join(
+            [f"{tool.name}: {tool.description}" for tool in self.tools])
+        # Create a list of tool names for the tools provided
+        kwargs["tool_names"] = ", ".join([tool.name for tool in self.tools])
+        return self.template.format(**kwargs)
+
+
+class CustomOutputParser(AgentOutputParser):
+
+    def parse(self, llm_output: str) -> Union[AgentAction, AgentFinish]:
+        # Check if agent should finish
+        if "Final Answer:" in llm_output:
+            return AgentFinish(
+                # Return values is generally always a dictionary with a single `output` key
+                # It is not recommended to try anything else at the moment :)
+                return_values={"output": llm_output.split(
+                    "Final Answer:")[-1].strip()},
+                log=llm_output,
+            )
+        # Parse out the action and action input
+        regex = r"Action\s*\d*\s*:(.*?)\nAction\s*\d*\s*Input\s*\d*\s*:[\s]*(.*)"
+        match = re.search(regex, llm_output, re.DOTALL)
+        if not match:
+            raise ValueError(f"Could not parse LLM output: `{llm_output}`")
+        action = match.group(1).strip()
+        action_input = match.group(2)
+        # Return the action and action input
+        return AgentAction(tool=action, tool_input=action_input.strip(" ").strip('"'), log=llm_output)
+    
+# chatllm=ChatOpenAI(temperature=0)
+# code_genenrate_memory = ConversationBufferMemory(memory_key="chat_history", return_messages=True)
+# code_generate_agent = initialize_agent(tools, chatllm, agent=AgentType.ZERO_SHOT_REACT_DESCRIPTION, memory=memory, verbose=True)
+
+
+
+# agent = initialize_agent(
+#     tools=tools, llm=llm_chain, template=AGENT_PROMPT, stop=["\nObservation:"], agent=AgentType.ZERO_SHOT_REACT_DESCRIPTION, verbose=True)
+
+
+def code_agent_executor() -> AgentExecutor:
+    
+
+    tools = [domainLayerCodeGenerator, persistentLayerCodeGenerator, apiLayerCodeGenerator]
+
+    output_parser = CustomOutputParser()
+
+
+    AGENT_PROMPT = CustomPromptTemplate(
+        template=code_generate_agent_template,
+        tools=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"]
+    )
+
+    code_llm_chain = LLMChain(llm=ChatOpenAI(temperature=0.7), prompt=AGENT_PROMPT)
+
+    tool_names = [tool.name for tool in tools]
+    code_agent = LLMSingleActionAgent(
+        llm_chain=code_llm_chain,
+        output_parser=output_parser,
+        stop=["\nObservation:"],
+        allowed_tools=tool_names,
+    )
+
+    code_agent_executor = AgentExecutor.from_agent_and_tools(
+        agent=code_agent, tools=tools, verbose=True)
+    return code_agent_executor
+
+# if __name__ == "__main__":
+# response = domainLayerChain.run("""FeatureConfig用于配置某个Feature中控制前端展示效果的配置项
+# FeatureConfig主要属性包括：featureKey(feature标识)、data（配置数据）、saData（埋点数据）、status（状态）、标题、描述、创建时间、更新时间
+# FeatureConfig中status为枚举值，取值范围为（DRAFT、PUBLISHED、DISABLED）
+# FeatureConfig新增后status为DRAFT、执行发布操作后变为PUBLISHED、执行撤销操作后变为DISABLED
+# 状态为DRAFT的FeatureConfig可以执行编辑、发布、撤销操作
+# 发布后FeatureConfig变为PUBLISHED状态，可以执行撤销操作
+# 撤销后FeatureConfig变为DISABLED状态，不可以执行编辑、发布、撤销操作
+# """)
+
+# print(response)
+
+
+# response = persistentChain.run("""
+# Entity:
+# ```
+# public class FeatureConfig {
+#     private FeatureConfigId id;
+#     private FeatureConfigDescription description;
+
+#     public enum FeatureConfigStatus {
+#         DRAFT, PUBLISHED, DISABLED;
+#     }
+
+#     public record FeatureConfigId(String id) {}
+#     public record FeatureKey(String key) {}
+#     public record FeatureConfigData(String data) {}
+#     public record FeatureConfigSaData(String saData) {}
+
+#     @Builder
+#     public record FeatureConfigDescription(FeatureKey featureKey, FeatureConfigData data, FeatureConfigSaData saData, String title, String description, 
+#         FeatureConfigStatus status, LocalDateTime createTime, LocalDateTime updateTime) {}
+
+#     public void update(FeatureConfigDescription description) {
+#         this.title = description.title();
+#         this.description = description.description();
+#         this.updateTime = LocalDateTime.now();
+#     }
+
+#     public void publish() {
+#         this.status = FeatureConfigStatus.PUBLISHED;
+#         this.updateTime = LocalDateTime.now();
+#     }
+
+#     public void disable() {
+#         this.status = FeatureConfigStatus.DISABLED;
+#         this.updateTime = LocalDateTime.now();
+#     }
+# }
+# ```
+
+# Association:
+# ```
+# public interface FeatureConfigs {
+#     Flux<FeatureConfig> findAllByFeatureKey(String featureKey);
+#     Mono<FeatureConfig> findById(FeatureConfigId id);
+#     Mono<FeatureConfig> save(FeatureConfig featureConfig);
+# }
+# ```
+# """)
+
+# print(response)
+
+
+# response = apiChain.run("""
+# Entity:
+# ```
+# public class FeatureConfig {
+#     private FeatureConfigId id;
+#     private FeatureConfigDescription description;
+
+#     public enum FeatureConfigStatus {
+#         DRAFT, PUBLISHED, DISABLED;
+#     }
+
+#     public record FeatureConfigId(String id) {}
+#     public record FeatureKey(String key) {}
+#     public record FeatureConfigData(String data) {}
+#     public record FeatureConfigSaData(String saData) {}
+
+#     @Builder
+#     public record FeatureConfigDescription(FeatureKey featureKey, FeatureConfigData data, FeatureConfigSaData saData, String title, String description, 
+#         FeatureConfigStatus status, LocalDateTime createTime, LocalDateTime updateTime) {}
+
+#     public void update(FeatureConfigDescription description) {
+#         this.title = description.title();
+#         this.description = description.description();
+#         this.updateTime = LocalDateTime.now();
+#     }
+
+#     public void publish() {
+#         this.status = FeatureConfigStatus.PUBLISHED;
+#         this.updateTime = LocalDateTime.now();
+#     }
+
+#     public void disable() {
+#         this.status = FeatureConfigStatus.DISABLED;
+#         this.updateTime = LocalDateTime.now();
+#     }
+# }
+# ```
+
+# Association:
+# ```
+# public interface FeatureConfigs {
+#     Flux<FeatureConfig> findAllByFeatureKey(String featureKey);
+#     Mono<FeatureConfig> findById(FeatureConfigId id);
+#     Mono<FeatureConfig> save(FeatureConfig featureConfig);
+#     Mono<Void> update(FeatureConfigId id, FeatureConfigDescription description);
+#     Mono<Void> publish(FeatureConfigId id);
+#     Mono<Void> disable(FeatureConfigId id);
+# }
+# ```
+# """)
+
+# print(response)
+
+# if __name__ == "code_generate":
+#     response = code_agent_executor.run("""
+#     根据如下需求generate domain layer code: 
+#     ---
+#     FeatureConfig用于配置某个Feature中控制前端展示效果的配置项
+#     FeatureConfig主要属性包括：featureKey(feature标识)、data（配置数据）、saData（埋点数据）、status（状态）、标题、描述、创建时间、更新时间
+#     FeatureConfig中status为枚举值，取值范围为（DRAFT、PUBLISHED、DISABLED）
+#     FeatureConfig新增后status为DRAFT、执行发布操作后变为PUBLISHED、执行撤销操作后变为DISABLED
+#     状态为DRAFT的FeatureConfig可以执行编辑、发布、撤销操作
+#     发布后FeatureConfig变为PUBLISHED状态，可以执行撤销操作
+#     撤销后FeatureConfig变为DISABLED状态，不可以执行编辑、发布、���销操作
+#     ---
+#     """)
+#     print(response)

documents/bussiness_context/NOTION_DB/Engineering Wiki 2402f5396a3244fdb3f1d135bdb0f3d6/Engineering Interviews 4be8039581d04456b0151f2cc4b22130/Questions ede8818b3a0e447f80145905690eb3f6.csv

@@ -0,0 +1,4 @@
+Question Name,Difficulty,Skills
+To Do List Design,Medium,"Architecture, Backend, Front end"
+FizzBuzz,Easy,"Algorithms, Front end"
+Alphabet Ordering,Hard,"Algorithms, Data Structures"

documents/bussiness_context/NOTION_DB/Engineering Wiki 2402f5396a3244fdb3f1d135bdb0f3d6/Getting Started 6bc871dcdd4a4554b5b22c0c40740841/Example sub-page 48f64d6186ec4428b2e4180475245a9c.md

@@ -0,0 +1,5 @@
+# Example sub-page
+
+Last edited time: March 31, 2023 1:49 PM
+Owner: Anonymous
+Tags: Testing

documents/bussiness_context/business_context.md

@@ -1,13 +1,22 @@
-ABstract是一个AB测试平台，整合了配置管理和实验管理，为企业提供数据驱动的决策能力。例如，一个用户想要创建一个实验来测试两个不同版本的网页，以了解哪个版本能带来更多的服务注册。他们将创建一个实验，包含两个分组（bucket），每个分组对应一个网页版本，并将不同的用户分配到每个分组以比较结果。
+AB测试系统中一个重要功能是用于控制某个feature的配置下发管理，配置管理中有两个主要业务概念FeatureFlag 和 FeatureConfig
+FeatureFlag用于标识某个具体Feature
+FeatureFlag主要属性包括: featureKey(feature标识)、名称、描述、enabled、创建时间、最后更新时间、template（作为FeatureConfig的模版用于生成后续FeatureConfig的配置界面组件，属性包括key、名称、描述、dataType、items）
+template中dataType为枚举值，取值范围为（STRING、NUMBER、BOOLEAN、OBJECT、ARRAY）
 
-每个实验可以包含1个或多个分组，每个分组都有一个不同的配置。实验信息包括：实验名称、实验描述、开始和结束时间、抽样百分比、识别实验的关键字、每个分组的名称及其关联的配置和分配给每个分组的流量百分比，以及将用户分配到分组的目标规则。
+FeatureConfig用于配置某个Feature中控制前端展示效果的配置项
+FeatureConfig主要属性包括：featureKey(feature标识)、data（配置数据）、saData（埋点数据）、status（状态）、标题、描述、创建时间、更新时间
+FeatureConfig中status为枚举值，取值范围为（DRAFT、PUBLISHED、DISABLED）
+FeatureConfig新增后status为DRAFT、执行发布操作后变为PUBLISHED、执行撤销操作后变为DISABLED
+一个FeatureFlag中可以包含多个FeatureConfig, FeatureFlag和FeatureConfig通过featureKey字段进行关联
 
-实验和分组可以一起配置。实验中的配置用于为用户提供不同的交互体验。一个实验最多可以创建10个分组。分组配置将作为分组的一个配置项与分组关联。
+ FeatureConfig对应feature控制的不同版本配置内容，添加FeatureConfig目的是控制featureConfig消费方的某个行为
 
-实验分为灰度发布、AB对比和多分组实验三种类型。一个实验应该包含：实验名称、实验描述、开始和结束时间、抽样百分比、识别实验的关键字、每个分组的名称及其关联的配置和分配给每个分组的流量百分比，以及将用户分配到分组的目标规则。
+ 添加FeatureConfig应该包含featureKey(feature标识)、data（配置数据）、saData（埋点数据）、status（状态）、标题、描述信息
 
-实验的目的是将用户随机分配到不同的分组，不同分组中的用户获得不同的软件交互体验。通过收集不同分组中用户的行为数据，对比不同设计的效果。一个实验至少包含1个，最多10个分组。
+ 新创建的FeatureConfig状态为DRAFT
 
-用户在同一个编辑界面编辑实验和分组信息，点击保存按钮时一起提交。创建实验时应该包含：实验名称、分流比例、开始时间、截止时间、分组（名称、关键字、分流比例）。实验类型分为灰度发布、AB对比和多分组实验三种。
-- 实验的目标是通过将用户随机分组，收集不同组用户的行为数据，对比分析不同设计的效果，找出最有设计
-- 实验有三种： 1.灰度发布（一个实验只有一个分组，通过实验采样比例控制新特性的发布比例）2. A/B对比（一个实验有两个分组，在用户总量中采样部分用户进行实验，对比新旧两组的数据）3. 多分组实验（一个实验有多个分组，在用户总量中采样部分用户进行实验，对比不同设计的效果））
+ 添加FeatureConfig应该包含：featureKey(feature标识)、data（配置数据）、saData（埋点数据）、status（状态）、标题、描述信息
+
+新创建的FeatureConfig状态为DRAFT
+
+ 一个FeatureFlag中可以包含多个FeatureConfig

documents/bussiness_context/business_context.md.bak

@@ -0,0 +1,21 @@
+ABstract是一个AB测试平台，整合了配置管理和实验管理，为企业提供数据驱动的决策能力。例如，一个用户想要创建一个实验来测试两个不同版本的网页，以了解哪个版本能带来更多的服务注册。他们将创建一个实验，包含两个分组（bucket），每个分组对应一个网页版本，并将不同的用户分配到每个分组以比较结果。
+
+每个实验可以包含1个或多个分组，每个分组都有一个不同的配置。实验信息包括：实验名称、实验描述、开始和结束时间、抽样百分比、识别实验的关键字、每个分组的名称及其关联的配置和分配给每个分组的流量百分比，以及将用户分配到分组的目标规则。
+
+实验和分组可以一起配置。实验中的配置用于为用户提供不同的交互体验。一个实验最多可以创建10个分组。分组配置将作为分组的一个配置项与分组关联。
+
+实验分为灰度发布、AB对比和多分组实验三种类型。一个实验应该包含：实验名称、实验描述、开始和结束时间、抽样百分比、识别实验的关键字、每个分组的名称及其关联的配置和分配给每个分组的流量百分比，以及将用户分配到分组的目标规则。
+
+实验的目的是将用户随机分配到不同的分组，不同分组中的用户获得不同的软件交互体验。通过收集不同分组中用户的行为数据，对比不同设计的效果。一个实验至少包含1个，最多10个分组。
+
+用户在同一个编辑界面编辑实验和分组信息，点击保存按钮时一起提交。创建实验时应该包含：实验名称、分流比例、开始时间、截止时间、分组（名称、关键字、分流比例）。实验类型分为灰度发布、AB对比和多分组实验三种。
+- 实验的目标是通过将用户随机分组，收集不同组用户的行为数据，对比分析不同设计的效果，找出最有设计
+- 实验有三种： 1.灰度发布（一个实验只有一个分组，通过实验采样比例控制新特性的发布比例）2. A/B对比（一个实验有两个分组，在用户总量中采样部分用户进行实验，对比新旧两组的数据）3. 多分组实验（一个实验有多个分组，在用户总量中采样部分用户进行实验，对比不同设计的效果））
+- 向实验列表增加一个实验记录
+- 实验名称、实验描述、开始和结束时间、抽样百分比、识别实验的关键字、每个分组的名称及其关联的配置和分配给每个分组的流量百分比，以及将用户分配到分组的目标规则。
+
+ 例如，一个用户想要创建一个实验来测试两个不同版本的网页，以了解哪个版本能带来更多的服务注册。他们将创建一个实验，包含两个分组（bucket），每个分组对应一个网页版本，并将不同的用户分配到每个分组以比较结果。
+
+ 例如，一个用户想要创建一个实验来测试两个不同版本的网页，以了解哪个版本能带来更多的服务注册。他们将创建一个实验，包含两个分组（bucket），每个分组对应一个网页版本，并将不同的用户分配到每个分组以比较结果。
+
+ 实验信息包括：实验名称、实验描述、开始和结束时间、抽样百分比、识别实验的关键字、每个分组的名称及其关联的配置和分配给每个分组的流量百分比，以及将用户分配到分组的目标规则。

memories.py

@@ -11,20 +11,20 @@ def get_buffer_string(
     for m in messages:
         if isinstance(m, HumanMessage):
             print("HumanMessage: " + m.content)
-            role = human_prefix + ":"
+            role = human_prefix + ": "
         elif isinstance(m, AIMessage):
             print("AIMessage" + m.content)
             role = ""
         elif isinstance(m, SystemMessage):
             print("SystemMessage")
-            role = "System:"
+            role = "System: "
         elif isinstance(m, ChatMessage):
             print("ChatMessage")
-            role = m.role + ":"
+            role = m.role + ": "
         else:
             raise ValueError(f"Got unsupported message type: {m}")
 
-        string_messages.append(f"{m.content}")
+        string_messages.append(f"{role + m.content}")
 
     return "\n".join(string_messages)
 

promopts.py

@@ -21,8 +21,325 @@ Scenarios: List all possible scenarios with concrete example in Given/When/Then
 
 
 {history}
-{input}"""
+Answer:{input}"""
 
 FEEDBACK_PROMPT = PromptTemplate(
     input_variables=["context", "story", "history", "input"], template=FEEDBACK,
 )
+
+
+agent_template = """You are a business analyst who is familiar with specification by example. Your main task is to explain the user story as scenarios. 
+You have access to the following tools:
+
+{tools}
+
+Use the following format:
+
+Story: the story that you need to explain
+Thought: you should always think about what is still uncertain about the user story to Explain the user story. Ignore technical concerns.
+Action: the action to take, should be one of [{tool_names}]
+Action Input: the input to the action
+Observation: the result of the action
+... (this Thought/Action/Action Input/Observation can repeat 10 times)
+Thought: I now know the final answer
+Final Answer: List all possible scenarios with concrete example in Given/When/Then style
+
+Begin! 
+
+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
+
+the code just include Enity Association and tests for Entity that you write to fulfill the request, follow TechStack Architecture TestStrategy to fulfill request, you should cover more test case as posible 
+
+
+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
+
+the code just include DbEnity、Repository、Association Implement and tests code that you write to fulfill the request, follow TechStack Architecture TestStrategy to fulfill request, you should cover more test case as posible 
+
+
+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
+
+the code just include Controller、DTO and tests code that you write to fulfill the request, follow TechStack Architecture TestStrategy to fulfill request, you should cover as more test case as posible
+
+request: {input}"""
+
+API_LAYER_PROMPT = PromptTemplate(input_variables=["input"], template=API_LAYER,)
+
+
+code_generate_agent_template = """You are a tool picker. 
+You should pick a tool of following tools to ansser the question.:
+
+{tools}
+
+Use the following format:
+
+Request: the request 
+Thought: which tool should used to fufill this request and  pass the original content of Request to it.
+Action: the action to take, should be one of [{tool_names}]
+Action Input: the original content of Request 
+Observation: the result of the action
+... (this Thought/Action/Action Input/Observation can repeat 1 times)
+Final Answer: the result of the action
+
+Begin! 
+
+Request: {input}
+{agent_scratchpad}"""