pycoze 0.1.307__py3-none-any.whl → 0.1.334__py3-none-any.whl

pycoze/bot/__init__.py

@@ -1,3 +1,3 @@
-from .bot import chat, get_chat_response
+from .chat import chat, get_chat_response
 
 __all__ = [chat, get_chat_response]

pycoze/bot/chat.py

@@ -0,0 +1,99 @@
+import json
+from .chat_base import handle_user_inputs
+from .lib import get_abilities, get_system_prompt
+from .message import INPUT_MESSAGE, output, CHAT_DATA, clear_chat_data
+import os
+import asyncio
+from pycoze import utils
+import tempfile
+
+
+async def check_interrupt_file(interval, interrupt_file, chat_task):
+    while True:
+        await asyncio.sleep(interval)
+        if os.path.exists(interrupt_file):
+            os.remove(interrupt_file)
+            chat_task.cancel()
+            break
+
+
+async def run_with_interrupt_check(conversation_history, user_input, cwd: str, abilities, bot_setting, has_any_tool, interrupt_file):
+    clear_chat_data()
+    try:
+        chat_task = asyncio.create_task(
+            handle_user_inputs(conversation_history, user_input, cwd, abilities, bot_setting, has_any_tool)
+        )
+        check_task = asyncio.create_task(
+            check_interrupt_file(0.5, interrupt_file, chat_task)
+        )
+        result = await chat_task
+        return result
+    except asyncio.CancelledError:
+        return CHAT_DATA["info"]
+    except Exception as e:
+        import traceback
+
+        print(traceback.format_exc())
+        return None  # 返回 None 或者处理异常后的结果
+    finally:
+        if not chat_task.done():
+            chat_task.cancel()
+        # 确保即使发生异常也会取消检查任务
+        if not check_task.done():
+            check_task.cancel()
+            try:
+                await check_task
+            except asyncio.CancelledError:
+                pass  # 忽略取消错误
+
+
+def chat(bot_setting_file: str):
+    with open(bot_setting_file, encoding="utf-8") as f:
+        bot_setting = json.load(f)
+    abilities = get_abilities(bot_setting)
+    cwd = tempfile.mkdtemp()
+    system_prompt, has_any_tool = get_system_prompt(abilities, bot_setting)
+    conversation_history = [
+        {
+            "role": "system",
+            "content": system_prompt,
+        }
+    ]
+    while True:
+        clear_chat_data()
+        input_text = input()
+        if not input_text.startswith(INPUT_MESSAGE):
+            raise ValueError("Invalid message")
+        message = json.loads(input_text[len(INPUT_MESSAGE) :])
+        user_input = message["content"]
+        params = utils.params
+        if "interruptFile" in params:
+            asyncio.run(
+                run_with_interrupt_check(
+                    conversation_history, user_input, cwd, abilities, bot_setting, has_any_tool, params["interruptFile"]
+                )
+            )
+        else:
+            asyncio.run(
+                handle_user_inputs(conversation_history, user_input, cwd, abilities, bot_setting, has_any_tool)
+            )
+
+        output("assistant", CHAT_DATA["info"])
+
+
+def get_chat_response(bot_setting_file: str, user_input: str):
+    with open(bot_setting_file, encoding="utf-8") as f:
+        bot_setting = json.load(f)
+    abilities = get_abilities(bot_setting)
+    cwd = tempfile.mkdtemp()
+    conversation_history = [
+        {
+            "role": "system",
+            "content": get_system_prompt(abilities, bot_setting),
+        }
+    ]
+    asyncio.run(
+        handle_user_inputs(conversation_history, user_input, cwd, abilities, bot_setting)
+    )
+
+    return CHAT_DATA["info"]

pycoze/bot/chat_base.py

@@ -0,0 +1,247 @@
+import json
+import os
+from .lib import get_formatted_filelist_str, read_local_file, resolve_relative_path
+from .message import info
+from pycoze.ai import chat_stream_async, extract
+from .tools import ToolExecutor
+from typing import List
+
+
+def guess_files_in_message(cwd:str, user_message: str) -> List[str]:
+
+    value = extract({"includedFiles": ['relative path format', 'relative path format', '...']}, 
+                    'Please find the files mentioned in the text. If none, return {"includedFiles": []}:\n' + user_message)
+    return [resolve_relative_path(cwd, p) for p in value["includedFiles"]]
+
+
+def user_task_prompt(conversation_history, cwd, user_input: str, programmer_mode: bool):
+    if programmer_mode:
+        potential_paths = guess_files_in_message(cwd, user_input)
+
+        exist_files = get_formatted_filelist_str(cwd, True, 200)
+        content = []
+        for file_path in potential_paths:
+            file_path = resolve_relative_path(cwd, file_path)
+            if os.path.isfile(file_path):
+                file_marker = f"[[{file_path}]]'"
+                file_content = read_local_file(file_path)
+                if not any(file_marker in msg["content"] for msg in conversation_history):
+                    content.append(f"{file_marker}\n{file_content}")
+        content_str = "Partial contents of files are as follows:" + "\n".join(content) if content else ""
+        return f"""
+<task>
+{user_input}
+</task>
+
+<environment_details>
+Current working directory: {cwd}
+
+List of files under path:
+{exist_files}
+
+{content_str}
+
+</environment_details>
+    """
+    else:
+        return f"""
+<task>
+{user_input}
+</task>
+"""
+
+
+def dumps_markdown_json(data):
+    json_str = json.dumps(data, indent=4, ensure_ascii=False)
+    return f"\n```json\n{json_str}\n```\n"
+
+
+def process_code_block(language: str, content: str):
+    """
+    处理并清理代码块内容，返回格式化后的字符串
+    """
+    if language and content:
+        # 清理代码块内容
+        cleaned_content = "\n".join(
+            line.strip() for line in content.split("\n") if line.strip()
+        )
+        return (language, cleaned_content)
+    return ""
+
+
+async def stream_openai_response(conversation_history, start_new_stream):
+    """
+    异步流式传输 OpenAI 聊天完成响应并处理结构化输出
+    """
+    stream = None
+    buffer = ""
+    in_code_block = False
+    code_block_language = ""
+    code_block_content = ""
+    text_content = ""
+
+    while True:
+        # 检查是否需要重新创建流
+        if stream is None or start_new_stream["value"]:
+            if stream is not None:
+                await stream.aclose()  # 关闭之前的流
+            stream = chat_stream_async(conversation_history)  # 获取新的异步生成器
+            start_new_stream["value"] = False  # 重置标志
+            buffer = ""
+            in_code_block = False
+            code_block_language = ""
+            code_block_content = ""
+            text_content = ""
+
+        # 使用 async for 迭代异步生成器
+        try:
+            async for chunk in stream:
+                info("assistant", chunk)
+                buffer += chunk
+
+                # 检查是否需要重新创建流
+                if start_new_stream["value"]:
+                    break  # 退出当前的 async for 循环，进入下一次 while 循环
+
+                # 处理 buffer 中的每一行
+                while "\n" in buffer:
+                    line, buffer = buffer.split("\n", 1)
+                    if not in_code_block:
+                        if line.strip().startswith("```"):
+                            if text_content:
+                                yield ("text", text_content.strip())
+                                text_content = ""
+                            in_code_block = True
+                            code_block_language = line.strip()[3:].strip()
+                        else:
+                            text_content += line + "\n"
+                    else:
+                        if line.strip().startswith("```"):
+                            in_code_block = False
+                            yield process_code_block(
+                                code_block_language, code_block_content
+                            )
+                            code_block_content = ""
+                        else:
+                            code_block_content += line + "\n"
+
+            # 如果流正常结束，退出 while 循环
+            break
+
+        except Exception as e:
+            # 捕获其他异常（如网络错误）
+            print(f"Error: {e}", style="bold red")
+            break
+
+    # 处理 buffer 中剩余的内容
+    if buffer:
+        if in_code_block:
+            buffer = buffer.split("```")[0]
+            code_block_content += buffer + "\n"
+            yield process_code_block(code_block_language, code_block_content)
+        else:
+            text_content += buffer
+            if text_content:
+                yield ("text", text_content.strip())
+
+
+async def handle_user_inputs(conversation_history, user_input, cwd, abilities, bot_setting, has_any_tool):
+    no_exit_if_incomplete = bot_setting["systemAbility"]['no_exit_if_incomplete']
+    programmer_mode = bot_setting["systemAbility"]['programmer_mode']
+
+    start_new_stream = {
+        "value": False
+    }  # 当遇到AI准备执行JSON，即需要新信息的时候，用于强制停止当前stream，减少后续无效的tokens
+
+    print("Processing user command", user_input)
+    if user_input.lower() in ["exit", "quit"]:
+        exit(0)
+    # 将用户消息添加到对话历史
+    conversation_history.append(
+        {
+            "role": "user",
+            "content": user_task_prompt(conversation_history, cwd, user_input, programmer_mode),
+        }
+    )
+    need_break = False
+
+    if no_exit_if_incomplete:
+        okay_str = 'Okay, please continue. If the tasks within <task>...task content...</task> have been completed, execute the tool "complete_all_tasks". If you have a question, use "ask_follow_up_question".'
+    else:
+        okay_str = "Okay"
+    while True:
+        async for response in stream_openai_response(
+            conversation_history, start_new_stream
+        ):
+            if len(response) == 2:
+                if response[0] == "text" and response[1].strip() != "" or (response[0] == "json" and not has_any_tool):
+                    conversation_history.append(
+                        {"role": "assistant", "content": response[1]}
+                    )
+                    conversation_history.append(
+                        {
+                            "role": "user",
+                            "content": okay_str,
+                        }
+                    )
+                    continue
+                elif response[0] == "json":
+                    info("assistant", "\n")
+                    cleaned_content = response[1]
+                    try:
+                        tool_request = json.loads(cleaned_content)
+                        tool_name = list(tool_request.keys())[0]
+                    except json.JSONDecodeError as e:
+                        conversation_history.append(
+                            {
+                                "role": "assistant",
+                                "content": f"\n```json\n{cleaned_content}\n```\n",
+                            }
+                        )
+                        conversation_history.append(
+                            {
+                                "role": "user",
+                                "content": "Invalid JSON content:" + str(e),
+                            }
+                        )
+                        continue
+
+                    ok, result = ToolExecutor.execute_tool(cwd, tool_request, abilities)
+                    if ok:
+                        info("assistant", "✅\n")
+                    else:
+                        info("assistant", "❌\n")
+                    assistant_content = (
+                        "Executing tool: "
+                        + dumps_markdown_json(tool_request)
+                        + "\n\nResult: "
+                        + result
+                    )
+                    info("assistant", "```text\n" + result + "\n```\n\n")
+                    conversation_history.append(
+                        {"role": "assistant", "content": assistant_content}
+                    )
+                    if tool_name in ["complete_all_tasks", 'ask_follow_up_question']:
+                        need_break = True
+                        break
+                    else:
+                        conversation_history.append(
+                            {
+                                "role": "user",
+                                "content": okay_str,
+                            }
+                        )
+                        start_new_stream["value"] = True
+
+        if need_break:
+            break
+        if not no_exit_if_incomplete and not start_new_stream["value"]:
+            break
+
+
+# 示例调用
+# user_input_list = [
+#     "访问https://api-docs.deepseek.com/zh-cn/guides/chat_prefix_completion，并结合它编写一段代码，并保存"
+# ]
+
+# asyncio.run(handle_user_inputs(user_input_list))

pycoze/bot/lib.py

@@ -0,0 +1,245 @@
+import os
+from collections import defaultdict
+import platform
+from jinja2 import Template
+from pathlib import Path
+from pycoze.reference.bot import ref_bot
+from pycoze.reference.tool import ref_tools
+from pycoze.reference.workflow import ref_workflow
+import inspect
+
+
+def function_to_string(func):
+    # 获取函数签名
+    signature = inspect.signature(func)
+
+    # 获取函数名
+    func_name = func.__name__
+
+    # 获取函数的文档字符串
+    docstring = func.__doc__
+
+    # 格式化函数签名
+    func_signature = f"def {func_name}{signature}:"
+
+    # 构建最终的字符串
+    result = f"#### {func_name.capitalize().replace('_', ' ')}\n"
+    result += "**Function Signature:**\n"
+    result += f"```python\n{func_signature}\n    \"\"\"{docstring}\n    \"\"\"\n    pass\n```\n\n"
+    result += "**Usage:**\n"
+    result += "```json\n"
+    result += f"{{\n  \"{func_name}\": {{\n"
+
+    # 添加参数
+    for name, param in signature.parameters.items():
+        result += f"    \"{name}\": \"{param.annotation.__name__ if param.annotation != inspect.Parameter.empty else 'value'}\"\n"
+
+    result += "  }\n"
+    result += "}\n"
+    result += "```"
+
+    return "\n\n" + result + "\n\n"
+
+def get_abilities(bot_setting):
+    abilities = []
+    for bot_id in bot_setting["bots"]:
+        bot = ref_bot(bot_id)
+        if bot:
+            abilities.append(bot)
+    for tool_id in bot_setting["tools"]:
+        abilities.extend(ref_tools(tool_id))
+    for workflow_id in bot_setting["workflows"]:
+        workflow = ref_workflow(workflow_id)
+        if workflow:
+            abilities.append(workflow)
+    return abilities
+
+
+def get_system_prompt(abilities, bot_setting):
+    md_file = os.path.join(os.path.dirname(os.path.abspath(__file__)), "prompt.md")
+    with open(md_file, encoding="utf-8") as f:
+        template = Template(f.read())
+
+    if platform.system() == "Windows":
+        cd_prompt = "When executing outside the working directory, include the CD command, such as cd /path/to/directory ; ls."
+    else:
+        cd_prompt = "When executing outside the working directory, include the CD command, such as cd /path/to/directory && ls."
+    system = platform.system()
+
+
+    abilities_str = "\n".join([function_to_string(a) for a in abilities])
+
+    context = {
+        "prompt": bot_setting["prompt"],
+        "system": system,
+        "cd_prompt": cd_prompt,
+        "abilities_str": abilities_str,
+        "programmer_mode": False,
+        "no_exit_if_incomplete": False,
+        "allow_read_file": False,
+        "allow_read_multiple_files": False,
+        "allow_execute_command": False,
+        "allow_write_or_overwrite_file": False,
+        "allow_replace_part_of_a_file": False,
+        "allow_search_files": False,
+        "allow_list_files": False,
+        "allow_access_webpage": False,
+    }
+
+    context.update(bot_setting["systemAbility"])
+    
+    has_any_tool = False
+    if len(abilities) > 0:
+        has_any_tool = True
+    for key in bot_setting["systemAbility"]:
+        if key != "programmer_mode" and bot_setting["systemAbility"][key] == True:
+            has_any_tool = True
+            break
+            
+    context["has_any_tool"] = has_any_tool
+    system_prompt = template.render(context)
+
+    return system_prompt, has_any_tool
+
+
+def resolve_relative_path(cwd:str, path_str: str) -> str:
+    """返回基于CWD的规范化绝对路径"""
+    path = Path(path_str)
+    if path.is_absolute():
+        return str(path.resolve())
+    else:
+        return str((Path(cwd) / path_str).resolve())
+
+
+def read_local_file(file_path: str) -> str:
+    """读取本地文件内容"""
+    try:
+        with open(file_path, "r", encoding="utf-8") as f:
+            return f.read()
+    except:
+        import chardet
+
+        with open(file_path, "rb") as f:
+            rawdata = f.read()
+            encoding = chardet.detect(rawdata)["encoding"]
+            return rawdata.decode(encoding)
+
+
+# 全局忽略列表
+IGNORE_LIST = [
+    "node_modules",
+    ".git",
+    ".vscode",
+    ".idea",
+    "gitServer",
+    ".DS_Store",
+    "$RECYCLE.BIN",
+    ".Trash-1000",
+    ".Spotlight-V100",
+    ".Trashes",
+    ".TemporaryItems",
+    ".fseventsd",
+    "System Volume Information",
+    "pycache",
+    "env",
+    "venv",
+    "target/dependency",
+    "build/dependencies",
+    "dist",
+    "out",
+    "bundle",
+    "vendor",
+    "tmp",
+    "temp",
+    "deps",
+    "pkg",
+    "Pods",
+]
+
+
+def should_ignore(path):
+    """检查路径是否在忽略列表中"""
+    parts = path.split(os.sep)
+    return any(part in IGNORE_LIST for part in parts)
+
+
+def get_files_and_folders(root, recursive: bool):
+    """递归获取所有文件和文件夹，并记录属性"""
+    items = []
+
+    # 使用 os.walk 遍历目录
+    for dirpath, dirnames, filenames in os.walk(root):
+        # 排除忽略列表中的路径
+        if should_ignore(dirpath):
+            continue
+
+        # 记录文件夹
+        for dirname in dirnames:
+            full_path = os.path.join(dirpath, dirname)
+            if not should_ignore(full_path):
+                relative_path = os.path.relpath(full_path, root)
+                is_empty = not os.listdir(full_path)
+                depth = relative_path.count(os.sep)
+                items.append(
+                    (relative_path, "empty_folder" if is_empty else "folder", depth)
+                )
+
+        # 记录文件
+        for filename in filenames:
+            full_path = os.path.join(dirpath, filename)
+            if not should_ignore(full_path):
+                relative_path = os.path.relpath(full_path, root)
+                depth = relative_path.count(os.sep)
+                items.append((relative_path, "file", depth))
+
+        # 如果 recursive 为 False，则只遍历当前目录，不进入子目录
+        if not recursive:
+            break
+
+    return items
+
+
+def format_filelist_str(items, limit):
+    """根据limit格式化输出"""
+    depth_groups = defaultdict(list)
+    for item in items:
+        depth_groups[item[2]].append(item)
+
+    max_depth = max(depth_groups.keys(), default=0)
+    show_list = []
+    last_depth = 0
+
+    # 浅层
+    current_items = sorted(depth_groups[0], key=lambda x: x[0])
+    overflow = len(current_items) > limit
+    for item in current_items[:limit]:
+        show_list.append(item)
+
+    for depth in range(1, max_depth + 1):
+        current_items = depth_groups[depth]
+        if len(show_list) + len(current_items) <= limit:
+            last_depth = depth
+            for item in current_items:
+                show_list.append(item)
+        else:
+            break
+
+    result_str_list = []
+    show_list.sort(key=lambda x: x[0])
+    for item in show_list:
+        if item[1] == "file":
+            result_str_list.append(f"{item[0]}")
+        elif item[1] == "folder" and item[2] == last_depth:
+            result_str_list.append(f"{item[0]}/...more...")
+        else:
+            result_str_list.append(f"{item[0]}/")
+    if overflow:
+        result_str_list.append("...more...")
+
+    return "\n".join(result_str_list)
+
+
+def get_formatted_filelist_str(root: str, recursive: bool, limit=200):
+    items = get_files_and_folders(root, recursive)
+    return format_filelist_str(items, limit=limit)
+

pycoze/bot/{agent/chat.py → message.py}

@@ -16,7 +16,6 @@ def log(content, *args, end="\n", **kwargs):
 
 
 def clear_chat_data():
-    # 注意不能写为CHAT_DATA = {"output":"", "info": ""}，这样不会清空原本的内容
     CHAT_DATA["output"] = ""
     CHAT_DATA["info"] = ""