pro-craft 0.1.16__tar.gz → 0.2.66__tar.gz

{pro_craft-0.1.16 → pro_craft-0.2.66}/PKG-INFO

@@ -1,21 +1,21 @@
 Metadata-Version: 2.4
 Name: pro-craft
-Version: 0.1.16
+Version: 0.2.66
 Summary: Add your description here
 Requires-Python: >=3.12
 Description-Content-Type: text/markdown
 Requires-Dist: aiomysql>=0.2.0
 Requires-Dist: anyio>=4.11.0
 Requires-Dist: db-help>=0.2.2
+Requires-Dist: deepagents>=0.2.4
 Requires-Dist: fastapi>=0.119.0
-Requires-Dist: llmada>=1.1.11
-Requires-Dist: pytest>=8.4.2
-Requires-Dist: pytest-asyncio>=1.2.0
-Requires-Dist: pytest-tornasync>=0.6.0.post2
+Requires-Dist: langchain-openai>=1.0.2
+Requires-Dist: mcp[cli]>=1.19.0
+Requires-Dist: plotly>=6.3.1
 Requires-Dist: pyyaml>=6.0.3
 Requires-Dist: toml>=0.10.2
-Requires-Dist: utils-tool==0.1.3
 Requires-Dist: uvicorn>=0.38.0
+Requires-Dist: woke-time-mcp==0.1.7
 
 uv run mcp dev src/prompt_writing_assistant/mcp.py
 
@@ -51,3 +51,7 @@ await ctx.elicit(message, schema) - Request additional information from user wit
 ```
 
 
+
+## 做到prompt_writing_herper 中 目标是, 无论什么, 随便扔进去, 然后取的时候直接取即可
+
+## 然后做code自动化编写的coder 写完之后写豆包语音智能体的链接, mcp协议 然后重构一些, obsidian 的SDK

{pro_craft-0.1.16 → pro_craft-0.2.66}/README.md

@@ -32,3 +32,7 @@ await ctx.elicit(message, schema) - Request additional information from user wit
 ```
 
 
+
+## 做到prompt_writing_herper 中 目标是, 无论什么, 随便扔进去, 然后取的时候直接取即可
+
+## 然后做code自动化编写的coder 写完之后写豆包语音智能体的链接, mcp协议 然后重构一些, obsidian 的SDK

{pro_craft-0.1.16 → pro_craft-0.2.66}/pyproject.toml

@@ -1,10 +1,10 @@
 [project]
 name = "pro-craft"
-version = "0.1.16"
+version = "0.2.66"
 description = "Add your description here"
 readme = "README.md"
 requires-python = ">=3.12"
-dependencies = [ "aiomysql>=0.2.0", "anyio>=4.11.0", "db-help>=0.2.2", "fastapi>=0.119.0", "llmada>=1.1.11", "pytest>=8.4.2", "pytest-asyncio>=1.2.0", "pytest-tornasync>=0.6.0.post2", "pyyaml>=6.0.3", "toml>=0.10.2", "utils-tool==0.1.3", "uvicorn>=0.38.0",]
+dependencies = [ "aiomysql>=0.2.0", "anyio>=4.11.0", "db-help>=0.2.2", "deepagents>=0.2.4", "fastapi>=0.119.0", "langchain-openai>=1.0.2", "mcp[cli]>=1.19.0", "plotly>=6.3.1", "pyyaml>=6.0.3", "toml>=0.10.2", "uvicorn>=0.38.0", "woke-time-mcp==0.1.7",]
 
 [tool.setuptools.package-data]
 pro_craft = [ "config.yaml",]

pro_craft-0.2.66/src/pro_craft/__init__.py

@@ -0,0 +1,10 @@
+from dotenv import load_dotenv, find_dotenv
+dotenv_path = find_dotenv()
+load_dotenv(".env", override=True)
+import logging
+from .log import Log
+Log_ = Log(console_level = logging.WARNING, # 显示控制台的等级 WARNING
+             log_file_name="app.log")
+logger = Log_.logger
+
+from .prompt_craft import AsyncIntel, Intel

pro_craft-0.2.66/src/pro_craft/code_helper/agent.py

@@ -0,0 +1,87 @@
+# LLM1
+
+import os
+from typing import Literal
+# from tavily import TavilyClient
+from deepagents import create_deep_agent
+from .tools import search_template_by_text, get_template_details, ask_user_for_clarification, generate_request_file, generate_code
+
+
+# System prompt to steer the agent to be an expert researcher
+research_instructions = """你是一个高级代码生成助手 Agent，你的主要职责是帮助用户通过模板快速生成代码。
+
+**你的目标是：**
+1.  **精确理解用户对代码功能和结构的自然语言描述。**
+2.  **在现有模板库中，智能地找到最符合用户需求的模板。**
+3.  **如果找不到高匹配度的模板，引导用户创建新模板。**
+4.  **基于选定的模板和用户需求，生成一个结构化、可执行的 `REQUEST_START/END` 指令文件，用于后续的代码生成。**
+5.  **在必要时与用户进行交互，澄清需求或提供建议。**
+
+**你的可用工具:**
+
+1.  **`search_template_by_text(query: str, top_k: int = 5) -> List[Dict[str, Any]]`**
+    *   **描述:** 根据自然语言查询在模板库中进行语义搜索（使用 Qdrant 向量检索），返回最相关的 `top_k` 个模板的摘要信息。
+    *   **返回字段示例:** `[{'template_id': 'uuid', 'template_name': 'str', 'description': 'str', 'match_score': 'float'}]`
+    *   **何时使用:** 当你需要根据用户需求找到合适的代码模板时。
+
+2.  **`get_template_details(template_id: str) -> Dict[str, Any]`**
+    *   **描述:** 根据 `template_id` 从数据库中获取模板的完整详细信息，包括模板代码、推断出的命名约定和使用建议。
+    *   **返回字段示例:** `{'template_id': 'uuid', 'template_name': 'str', 'template_code': 'str', 'suggested_naming_conventions': 'json', 'usage_guidance': 'str'}`
+    *   **何时使用:** 当你已经选择了一个模板，需要其详细内容来生成指令时。
+
+3.  **`generate_request_file(template_code: str, user_request_details: Dict[str, Any], naming_conventions: Dict[str, Any]) -> str`**
+    *   **描述:** 根据选定的模板代码、解析后的用户需求（结构化形式）和模板的命名约定，生成符合 `REQUEST_START/END` 格式的指令文件。
+    *   **何时使用:** 当你已经确定了模板，并且充分理解了用户需求的所有细节，准备生成最终指令时。
+
+4.  **`ask_user_for_clarification(question: str) -> str`**
+    *   **描述:** 当你对用户需求有疑问，或需要用户做选择（例如在多个匹配模板中选择一个）时，使用此工具向用户提问。
+    *   **返回:** 用户的回答。
+    *   **何时使用:** 任何需要用户输入或确认的场景。
+
+**你的工作流程:**
+
+1.  **接收用户需求：** 用户会提供一个自然语言描述。
+2.  **初步理解与模板搜索：**
+    *   首先使用 `search_template_by_text` 工具，以用户需求的概要作为 `query`，找到 `top_k` 个最相关的模板。
+    *   分析搜索结果中的 `match_score` 和 `description`，评估匹配度。
+3.  **决策点 - 模板匹配：**
+    *   **高匹配度：** 如果存在一个或少数几个模板的 `match_score` 显著高，且 `description` 与用户需求高度吻合：
+        *   使用 `get_template_details` 获取该模板的完整信息。
+        *   进入 **需求细化与指令生成** 阶段。
+    *   **中等匹配度 / 多个相似匹配：** 如果有多个模板得分接近，或没有一个模板完美匹配：
+        *   使用 `ask_user_for_clarification` 工具，向用户展示这些模板的 `template_name` 和 `description`，并询问用户希望选择哪一个，或者是否希望在此基础上进行调整。
+        *   根据用户反馈，决定是选择一个模板还是引导用户创建新模板。
+    *   **低匹配度 / 无匹配：** 如果没有找到任何合适的模板（例如，所有 `match_score` 都很低）：
+        *   使用 `ask_user_for_clarification` 工具，告知用户未能找到合适的模板，并询问用户是否希望提供多个示例代码，以便使用 LLM 0 创建一个新的模板。
+        *   如果用户同意，引导用户进入 LLM 0 的流程。
+4.  **需求细化与指令生成 (基于选定模板):**
+    *   一旦确定了模板，仔细解析用户需求的每个细节，并将其映射到选定模板中的 `BLOCK` 和 `PLACEHOLDER`。
+    *   考虑模板的 `suggested_naming_conventions`，并尝试将其整合到生成的指令中。
+    *   如果用户需求与模板的某个 `BLOCK` 或 `PLACEHOLDER` 不兼容，或用户没有提供足够的细节来填充某个区域，使用 `ask_user_for_clarification` 向用户提问。
+    *   当所有必要信息都已获取且明确无误时，使用 `generate_request_file` 工具生成最终的 `REQUEST_START/END` 指令文件。
+5.  **输出最终指令：** 将 `generate_request_file` 的输出返回给系统，以便进行下一步的代码生成。
+
+**交互约束:**
+*   除非使用 `ask_user_for_clarification` 工具，否则不要直接与用户对话。
+*   始终以使用工具作为首选行动。
+*   保持你的回复简洁、直接，聚焦于完成任务。
+
+**示例用户需求:**
+"我需要一个API来发送用户消息。路径是 `/send`，POST 方法。输入模型叫 `SendMessageRequest`，包含 `user_id` (UUID格式) 和 `message_content` (字符串，最大500字)。输出模型叫 `SendMessageResponse`，继承 `CommonResponseModel`，额外包含 `message_id`。它会调用 `message_service_manager.send_message(user_id, content)`。如果 `user_id` 无效，应该返回 400 错误。"
+"""
+
+
+from modusched.core import Adapter
+
+agent = Adapter(model_name = "gemini-2.5-flash-preview-05-20-nothinking",
+        type = "openai",
+        api_key=os.getenv("BIANXIE_API_KEY"),
+        tools=[search_template_by_text, get_template_details, ask_user_for_clarification, generate_request_file,generate_code],
+        system_prompt=research_instructions
+        )
+
+
+if __name__ == "__main__":
+    result = agent.invoke({"messages": [{"role": "user", "content": "hello"}]})
+
+    print(result["messages"][-1].content)

pro_craft-0.2.66/src/pro_craft/code_helper/codermanager.py

@@ -0,0 +1,143 @@
+
+from sqlalchemy import create_engine
+import os
+from typing import List
+QDRANT_COLLECTION_NAME = "template_collection" # 你的 Qdrant collection 名称
+from pro_craft.utils import create_session
+from qdrant_client import QdrantClient, models
+from uuid import uuid4
+from .utils.template_extract import extract_template
+from .utils.database import Base, CodeTemplate
+from .utils.vectorstore import VolcanoEmbedding
+from qdrant_client import QdrantClient
+from qdrant_client.models import Filter, FieldCondition, MatchValue, PointStruct, CollectionStatus, Distance, VectorParams
+
+class CoderTemplateManager():
+    def __init__(self,
+                 database_url = "mysql+pymysql://zxf_root:Zhf4233613%40@rm-2ze0793c6548pxs028o.mysql.rds.aliyuncs.com:3306/serverz",
+                 model_name = "",
+                 logger = None,
+                ):
+        database_url = database_url or os.getenv("database_url")
+        assert database_url
+        self.engine = create_engine(database_url, echo=False, # echo=True 仍然会打印所有执行的 SQL 语句
+                                    pool_size=10,        # 连接池中保持的连接数
+                                    max_overflow=20,     # 当pool_size不够时，允许临时创建的额外连接数
+                                    pool_recycle=3600,   # 每小时回收一次连接
+                                    pool_pre_ping=True,  # 使用前检查连接活性
+                                    pool_timeout=30      # 等待连接池中连接的最长时间（秒）
+                                    ) 
+        self.embedding_model = VolcanoEmbedding(
+            model_name = "doubao-embedding-text-240715",
+            api_key = "39ad310a-c6f7-4d66-962e-1fbfa7e6edf1"
+        )
+
+
+        Base.metadata.create_all(self.engine)
+        
+        self.connection = QdrantClient(host="127.0.0.1", port=6333)
+
+        self.connection.recreate_collection(
+            collection_name=QDRANT_COLLECTION_NAME,
+            vectors_config=models.VectorParams(size=2560, distance=models.Distance.COSINE),
+        )
+        self.logger = logger
+    
+        # if model_name in ["gemini-2.5-flash-preview-05-20-nothinking",]:
+        #     self.llm = BianXieAdapter(model_name = model_name)
+        # elif model_name in ["doubao-1-5-pro-256k-250115","doubao-1-5-pro-32k-250115"]:
+        #     self.llm = ArkAdapter(model_name = model_name)
+        # else:
+        #     raise Exception("error llm name")
+
+    def get_embedding(self,text: str) -> List[float]:
+        return self.embedding_model._get_text_embedding(text)
+    
+    def add_template(self,
+                     use_case: str,
+                     template_id: str,
+                     description: str,):   
+        template = extract_template(use_case)
+        embedding_vector = self.get_embedding(description)
+        points = [
+                models.PointStruct(
+                    id = str(uuid4()),
+                    vector=embedding_vector,
+                    payload={
+                        "template_id": template_id,
+                        "description": description,
+                        "use_case": use_case,
+                        "template": template,
+                    }
+                )
+            ]
+        self.connection.upsert(
+            collection_name=QDRANT_COLLECTION_NAME,
+            wait=True,
+            points=points
+        )
+        # 数据库
+        with create_session(self.engine) as session:
+            new_template = CodeTemplate(
+                template_id=template_id,
+                version=1,
+                description=description,
+                template_code=template,
+            )
+            session.add(new_template)
+            session.commit()
+            session.refresh(new_template)
+        return "success"
+
+
+    def delete_template(self, template_id: str) -> bool:
+        """
+        逻辑删除指定的代码模板。
+        """
+
+
+        # 3. 使用属性删除点
+        # 目标：删除所有 'color' 属性为 'red' 的点
+
+        # 定义一个过滤器
+        # 这个过滤器会匹配所有 payload 中 'color' 字段值为 'red' 的点
+        _filter = Filter(
+            must=[
+                FieldCondition(
+                    key="template_id",
+                    match=MatchValue(value=template_id)
+                )
+            ]
+        )
+        self.connection.delete(
+            collection_name=QDRANT_COLLECTION_NAME,
+            points_selector=_filter,
+            wait=True
+        )
+
+
+        with create_session(self.engine) as session:
+            template = session.query(CodeTemplate).filter_by(template_id=template_id).first()
+            if template:
+                session.delete(template)
+                session.commit()
+                return True
+        return False
+    
+        
+    def search(self, text , limit , query_filter=None):
+        query_vector = self.get_embedding(text)
+        results = self.connection.search(
+            collection_name=QDRANT_COLLECTION_NAME,
+            query_vector=query_vector,
+            limit=limit,
+            query_filter=query_filter
+        )
+        return results
+
+    def get_template_obj(self, template_id: str):
+        # 模拟从数据库获取模板详情
+        # 实际使用时，你需要根据你的数据库 setup 来实现
+        with create_session(self.engine) as session:
+            template = session.query(CodeTemplate).filter_by(template_id = template_id).first()
+        return template

pro_craft-0.2.66/src/pro_craft/code_helper/new_code/paper_program.py

@@ -0,0 +1,183 @@
+from pro_craft import Intel
+from pro_craft.log import Log
+from pro_craft.utils import extract_
+from typing import List, Dict, Any
+from modusched.core import BianXieAdapter
+import re
+import json
+
+logger = Log.logger
+
+intel = Intel(model_name="doubao-1-5-pro-256k-250115")
+
+class CoderHelper():
+    def __init__(self):
+        self.bx = BianXieAdapter()
+
+
+    @intel.intellect_remove_warp(prompt_id ="代码修改-最小化改动001")
+    def minedit_prompt(self,input:dict):
+        # 可以做pydantic 的校验
+        input = extract_(input, pattern_key = r"python")
+        return input
+
+    @intel.intellect_remove_warp(prompt_id ="高定制化自由函数修改_001")
+    def free_function_prompt(self,input:dict,kwargs):
+        # 可以做pydantic 的校验
+        result_ = extract_(input, pattern_key = r"python")
+        if not result_:
+            return None
+        
+        complet_code = result_ + "\n" + f'result = Function(**{kwargs})'
+            
+        rut = {"result": ""}
+        # 使用exec执行代码，并捕获可能的错误
+        try:
+            exec(
+                complet_code, globals(), rut
+            )  # 将globals()作为全局作用域，避免依赖外部locals()
+        except Exception as e:
+            logger.error(f"执行动态生成的代码时发生错误: {e}")
+            return None  # 返回None或抛出异常
+
+        return rut.get("result")
+    
+    def min_edit(self,code:str, edit_demand:str):
+        input_ = {"源码":code,
+                "功能需求":edit_demand
+                }
+        data = self.minedit_prompt(input = input_)
+        return data
+    
+    def free_function(self,function: str ="帮我将 日期 2025/12/03 向前回退12天", 
+                      **kwargs):
+        # params = locals()
+        prompt_user_part = f"{function}"
+        if kwargs:
+            prompt_user_part += "入参 : \n"
+            prompt_user_part += json.dumps(kwargs,ensure_ascii=False)
+
+        exec_result = self.free_function_prompt(input = prompt_user_part,kwargs = kwargs)
+
+        return exec_result
+
+        
+    def free_function_advanced(self):
+        pass
+
+class Paper():
+    def __init__(self,content):
+        self.content = content
+
+    @intel.intellect_remove_warp(prompt_id ="白板编辑-修改画板001")
+    def system_prompt(self,data):
+        return data
+        
+    def talk(self,prompt:str):
+        data = {"data":self.content+ prompt}
+        result = self.system_prompt(data = data)
+        # result = bx.product(system_prompt+ self.content+ prompt)
+        print(result,'result')
+        result_json = json.loads(extract_(result,pattern_key = r"json"))
+        print(result_json,'result_json')
+        for ops in result_json:
+            self.deal(ops.get('type'), ops.get('operations'))
+            
+    
+    def deal(self, type_, operations:str):
+        if type_ == "add":
+            self.add(operations)
+        elif type_ == "delete":
+            self.delete(operations)
+        else:
+            print('error')
+
+    def add(self, operations:str):
+        print('add running')
+        match_tips = re.search(r'<mark>(.*?)</mark>', operations, re.DOTALL)
+        positon_ = operations.replace(f"<mark>{match_tips.group(1)}</mark>","")
+        # 锁定原文
+        positon_frist = operations.replace('<mark>',"").replace('</mark>',"")
+        print(positon_frist,'positon_frist')
+        print('==========')
+        print(positon_,'positon__')
+        self.content = self.content.replace(positon_,positon_frist)
+
+    def delete(self, operations:str):   
+        # 制定替换内容
+        print('delete running')
+        match_tips = re.search(r'<mark>(.*?)</mark>', operations, re.DOTALL)
+        positon_ = operations.replace(f"<mark>{match_tips.group(1)}</mark>","")
+        # 锁定原文
+        positon_frist = operations.replace('<mark>',"").replace('</mark>',"")
+        print(positon_frist,'positon_frist')
+        assert positon_frist in self.content
+        print('==========')
+        print(positon_,'positon__')
+        
+        self.content = self.content.replace(positon_frist,positon_)
+
+
+
+mermaid_format = """
+```mermaid
+{result}
+```"""
+
+class ProgramChart():
+    '''
+    # ## 有一个原始的程序框图, -> 可以通过需求来调整程序框图 -> 结合数据库来调度程序框图
+    # 一个新的任务, => 基本需求, -> 根据需求调取之前的程序框图, -> 融合程序框图 -> 调整程序框图到完成满意,-> 由程序框图实现代码, 并拉取出待实现函数
+    # -> 用知识库中获取代码与对应的测试, 整合到待实现函数中, -> 剩余的使用封装好的包进行补充, -> 创新的补充, -> ...
+
+
+    inputs = """
+    帮我实现一个文件读取的逻辑
+    """
+    program_chart = init_program_chart_mermaid(inputs) # TODO 类图另做吧
+    # 一直循环, 直到满意
+    program_chart = finetune_program_chart(program_chart + "如果文件不存在, 就创建")
+    codes = fill_code_frame_program_chart(program_chart) #TODO 可以尝试配置对应的pytest
+
+    '''
+
+    # TODO 数据用例等, 只是保存, 真正做统计的时候可以导出选择合适的数据
+
+    @intel.intellect_remove_warp(prompt_id="程序框图-根据需求创建")
+    def init_program_chart_mermaid(self,input_data:str,
+                                   output_format:str):
+        result = extract_(input_data,r"mermaid")
+        input_ = mermaid_format.format(result = result)
+
+        with open("/Users/zhaoxuefeng/GitHub/obsidian/工作/TODO/1根据需求创建.md",'w') as f:
+            f.write(input_)
+        return input_
+
+    @intel.intellect_remove_warp(prompt_id="程序框图-白板微调")
+    def finetune_program_chart(self,input_data:str,
+                                   output_format:str):
+        print(input_data,'input_datainput_datainput_data')
+        result = extract_(input_data,r"mermaid")
+        input_ = mermaid_format.format(result = result)
+        with open("/Users/zhaoxuefeng/GitHub/obsidian/工作/TODO/1根据需求创建.md",'w') as f:
+            f.write(input_)
+        return input_
+
+    @intel.intellect_remove_warp(prompt_id="程序框图-框架实现")
+    def fill_code_frame_program_chart(self,input:dict):
+        # result = extract_(input.get("program_chart"),r"python")
+        code = input.get("program_chart")
+
+        with open("/Users/zhaoxuefeng/GitHub/obsidian/工作/TODO/3框架实现.md",'w') as f:
+            f.write(code)
+        return code
+
+    def pc_work(self,chat,fill = False):
+        self.init_program_chart_mermaid(chat)
+
+        program_chart = self.finetune_program_chart
+
+        code = self.fill_code_frame_program_chart(input = {
+            "program_chart":program_chart
+        })
+

pro_craft-0.2.66/src/pro_craft/code_helper/tools.py

@@ -0,0 +1,182 @@
+from .codermanager import CoderTemplateManager
+from typing import List, Dict, Any,Optional
+import re
+
+coder = CoderTemplateManager()
+
+# --- 工具函数实现 ---
+
+def search_template_by_text(query: str, top_k: int = 5) -> List[Dict[str, Any]]:
+    """
+    根据自然语言查询在模板库中进行语义搜索（使用 Qdrant 向量检索），返回最相关的 `top_k` 个模板的摘要信息。
+    """
+    print("search_template_by_text")
+    print(f"input & {type(query)} & query: {query} top:k {top_k} ")
+    search_result = coder.search(
+        text=query,
+        limit=top_k,
+        # query_filter=None # 可以在这里添加额外的过滤条件，例如根据语言、框架过滤
+    )
+
+    templates_summary = []
+    for hit in search_result:
+        # 在实际 Qdrant 中，hit.id 是模板的ID，hit.payload 包含其他元数据
+        # 假设你的 Qdrant payload 中存储了 template_name 和 description
+        templates_summary.append({
+            'template_id': hit.payload.get("template_id"),
+            'description': hit.payload.get('description', 'No description provided.'),
+            'match_score': hit.score
+        })
+    print(f"output & {type(templates_summary)} & {templates_summary} ")
+    return templates_summary
+
+def get_template_details(template_id: str) -> Optional[Dict[str, Any]]: # template_id 根据你的模型是 Integer
+    """
+    根据 `template_id` 从数据库中获取模板的完整详细信息，包括模板代码、推断出的命名约定和使用建议。
+    """
+    print("get_template_details")
+    print(f"input & {type(template_id)} & query: {template_id} ")
+    template = coder.get_template_obj(template_id = template_id)
+    if template:
+        return {
+            'template_id': template.template_id,
+            'description': template.description,
+            'template_code': template.template_code,
+            'version': template.version,
+        }
+    print(f"output & {type(template)} & {template} ")
+    return None
+
+
+def ask_user_for_clarification(question: str) -> str:
+    """
+    当你对用户需求有疑问，或需要用户做选择（例如在多个匹配模板中选择一个）时，使用此工具向用户提问。
+    """
+    print("ask_user_for_clarification")
+    print(f"input & {type(question)} & query: {question} ")
+    print("\n--- Agent 需要你的帮助 ---")
+    print(f"Agent: {question}")
+    user_input = input("你的回答: ")
+    print("-------------------------\n")
+    print(f"output & {type(user_input)} & query: {user_input} ")
+    return user_input
+
+
+def generate_request_file(template_code: str, user_request_details: Dict[str, Any], naming_conventions: Optional[Dict[str, Any]] = None) -> str:
+    """
+    根据选定的模板代码、解析后的用户需求（结构化形式）和模板的命名约定，生成符合 `REQUEST_START/END` 格式的指令文件。
+    `user_request_details` 应该是一个字典，键是 BLOCK/PLACEHOLDER 的名称，值是包含 '指令' 和 '约束/示例' 的字典。
+    """
+    print("generate_request_file")
+    print(f"input & {type(template_code)} & template_code: {template_code} user_request_details: {user_request_details} naming_conventions: {naming_conventions}")
+
+    request_parts = []
+
+    request_parts.append("--- REQUEST_START ---")
+    request_parts.append("template.py # 目标文件通常是这个，可以根据实际情况调整") # 假设一个通用文件名
+
+    # 添加整体目标描述
+    overall_goal = user_request_details.get("overall_goal", "完善代码模板以满足以下需求。")
+    request_parts.append(f"\n**目标：** {overall_goal}\n")
+
+    # 添加命名约定 (如果提供了)
+    if naming_conventions:
+        request_parts.append("**命名约定:**")
+        for key, value in naming_conventions.items():
+            request_parts.append(f"*   **{key}:** {value}")
+        request_parts.append("") # 空行
+
+    request_parts.append("**具体修改点：**\n")
+
+    # 遍历模板代码，找到所有的 BLOCK 和 PLACEHOLDER
+    # 然后根据 user_request_details 填充指令
+    # 这是一个简化版本，实际可能需要更复杂的解析器来处理嵌套块或动态生成的块
+    # 对于 MVP，我们可以假设 user_request_details 中包含了所有需要填充的块/占位符
+    block_pattern = r"(BLOCK_START|PLACEHOLDER):\s*(\w+)"
+    for match in re.finditer(block_pattern, template_code):
+        block_type = match.group(1)
+        block_name = match.group(2)
+
+        if block_name in user_request_details:
+            details = user_request_details[block_name]
+            instruction = details.get("指令", "")
+            constraint_example = details.get("约束/示例", "")
+
+            request_parts.append(f"*   **{block_type}: {block_name}**")
+            request_parts.append(f"    *   **指令：** {instruction}")
+            if constraint_example:
+                # 确保多行约束/示例能正确缩进
+                formatted_ce = "\n".join([f"    *   **约束/示例：** {line}" if i == 0 else f"    *   {line}" for i, line in enumerate(str(constraint_example).splitlines())])
+                request_parts.append(formatted_ce)
+            request_parts.append("") # 空行
+
+    request_parts.append("--- REQUEST_END ---")
+    print(f"output & {type(request_parts)} & request_parts: {request_parts} ")
+
+    result = "\n".join(request_parts)
+    return result
+
+
+
+from modusched.core import BianXieAdapter
+from pro_craft.utils import extract_
+
+llm2 = """
+你是一个专业的Python代码修改和生成AI。你的任务是根据用户提供的代码模板文件和详细的修改指令文件，精确地对模板进行补充、完善和修改。
+
+**你的目标是：**
+1.  **严格遵循指令文件中的所有要求，尤其是针对特定 `BLOCK` 和 `PLACEHOLDER` 的指令和约束/示例。**
+2.  **尽可能应用指令文件中提供的命名约定。**
+3.  **仅修改指令明确要求修改的部分，模板中未被指令覆盖的固定部分必须保持不变。**
+4.  **最终输出完整且可运行的Python代码。**
+
+**输入格式:**
+用户将以以下两个部分向你提供信息：
+
+--- TEMPLATE_CODE_START ---
+[原始的代码模板内容，其中包含 BLOCK_START/END 和 PLACEHOLDER/END_PLACEHOLDER 标记]
+--- TEMPLATE_CODE_END ---
+
+--- REQUEST_FILE_START ---
+[一个结构化的指令文件，格式为 REQUEST_START/END，包含目标、命名约定和具体修改点]
+--- REQUEST_FILE_END ---
+
+**你的工作流程和生成原则:**
+
+1.  **解析指令文件：**
+    *   首先解析 `REQUEST_FILE_START` 中的所有内容，理解其 `目标`、`命名约定` 和 `具体修改点`。
+    *   将 `具体修改点` 中的每个 `BLOCK` 和 `PLACEHOLDER` 指令及其 `约束/示例` 映射到模板代码中的对应位置。
+2.  **处理模板代码：**
+    *   逐行读取 `TEMPLATE_CODE_START` 中的模板代码。
+    *   当遇到 `BLOCK_START` 或 `PLACEHOLDER` 标记时：
+        *   查找指令文件中对应 `块名称` 的修改指令。
+        *   **如果存在指令：**
+            *   删除 `BLOCK_START` 和 `BLOCK_END` (或 `PLACEHOLDER` 和 `END_PLACEHOLDER`) 及其内部的原始内容（包括 `AI:` 注释）。
+            *   用指令中提供的代码**替换**该区域。
+            *   在替换的代码块的开始和结束位置，添加特殊的标记 `// AI_MODIFIED_START` 和 `// AI_MODIFIED_END` (如果只是新增内容，可以使用 `// AI_ADDED_START` 和 `// AI_ADDED_END`)。
+            *   如果指令是要求删除某些内容，请用 `// AI_DELETED_LINE: [原始行内容]` 标记被删除的行。
+        *   **如果不存在指令：**
+            *   保留该 `BLOCK` 或 `PLACEHOLDER` 及其内部的原始内容（包括 `AI:` 注释和标记本身），不做任何改动。这允许模板中的可选部分在没有明确指令时保持原样。
+    *   当遇到非标记的普通代码行时，保持其不变。
+3.  **应用命名约定：**
+    *   在生成或修改代码时，优先应用 `REQUEST_FILE_START` 中提供的 `命名约定`。
+    *   **重要：** 命名约定只应影响由你**生成或修改**的代码部分（即 `AI_ADDED` 或 `AI_MODIFIED` 区域）。你不能随意修改模板中未被明确指令触及的固定代码部分的命名。
+4.  **生成中间输出：**
+    *   首先生成包含所有 `// AI_ADDED/MODIFIED/DELETED` 标记的完整代码。这有助于后续的自动化工具进行变更追踪和人工核查。
+5.  **生成最终输出：**
+    *   在生成中间输出后，进一步处理该代码，**移除所有 `// AI_ADDED/MODIFIED/DELETED` 类型的标记**。
+    *   移除所有模板中遗留的 `BLOCK_START/END` 和 `PLACEHOLDER/END_PLACEHOLDER` 标记。
+    *   保留所有的 Docstrings 和常规的代码注释。
+
+**你的输出必须是最终的、清理后的完整 Python 代码文件内容。**
+
+"""
+
+def generate_code(request: str) -> str:
+    """
+    使用生成的代码指令, 生成代码
+    """
+    bx = BianXieAdapter()
+    result = bx.product(llm2 + request)
+    python_code = extract_(result,r"python")
+    return python_code