prompt-copilot-cli 0.2.6__tar.gz → 0.2.9__tar.gz

{prompt_copilot_cli-0.2.6/prompt_copilot_cli.egg-info → prompt_copilot_cli-0.2.9}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: prompt-copilot-cli
-Version: 0.2.6
+Version: 0.2.9
 Summary: A lightweight terminal-based coding agent with file tools, command execution, multimodal image support, and MCP integration.
 Author: Jason Li
 License-Expression: MIT

{prompt_copilot_cli-0.2.6 → prompt_copilot_cli-0.2.9}/main.py

@@ -88,118 +88,59 @@ def format_cumulative_token_summary() -> str:
     )
 
 
-def build_bottom_toolbar_text() -> str:
-    base = t("toolbar_help")
-    token_summary = format_cumulative_token_summary()
-    return f"{token_summary} | {base}"
-
-
-
-
-DEFAULT_SYSTEM_WORKING_PRINCIPLES_ZH = """工作原则：
-1、先检查工作目录并理解需求。
-2、优先使用网络搜索类工具搜索网络实时信息，例如：天气、新闻、资讯等等。
-3、所有代码文件生成、编辑、删除等操作均在工作目录中执行。如果用户没有指定具体目录，默认工作目录为工程的根目录。
-4、如果需要，输出简洁的说明与下一步建议。
-5、若涉及删除系统文件或执行危险命令，必须先向用户确认后方可执行。
-6、当用户输入指令：/task-start 的时候,直接回复：请输入你的第一条初始提示。
-7、遇到信息盲区时，严禁主观臆测，请优先使用搜索工具补齐信息缺口，确保回答精准有据。
-8、如果用户想“读取/识别其他二进制文件”，你必须明确告知：我无法直接读取或理解通用二进制文件内容。
-9、如果用户想“查看图片内容”，应优先调用图片读取工具将图片转成 base64 或视觉消息格式，再将其发送给支持多模态的模型。
-10、对于图片类任务，优先使用图片工具而不是尝试直接读取二进制原始内容。
-11、当用户输入一条任务指令时，如果是详细的任务清单，你就理解用户要求逐步完成工作，同时执行每个步骤的时候明确说明当前环节与进度，实时反馈任务状态。
-12、使用 execute_python_script 时必须在脚本内自行管理进程生命周期：若是 ls、pytest、build 等短命令用 subprocess.run 显式设置 timeout，若是 npm run dev、flask run 等常驻服务用 subprocess.Popen 脱离终端启动并在脚本内轮询健康检查 URL，确认就绪后打印 PID 并立即 sys.exit() 退出以防触发 360 秒强制超时。
-13、无法调用官方联网检索工具而通过脚本抓取网络内容时需区分数据类型处理，抓取普通网页文本需剔除 HTML 标签、样式代码、广告碎片、无效注释、多余空行等冗余内容，仅留存有效正文且文本超出 8000 字符则截断，文本输出上限为 8000 字符，抓取程序源代码则无需过滤，完整保留原始代码、自带注释、缩进换行与原有格式，代码输出无字符数量限制。
-14、脱离终端启动常驻服务时务必兼顾跨平台兼容：Linux/Mac 环境设置 start_new_session=True，Windows 环境设置 creationflags=subprocess.CREATE_NEW_PROCESS_GROUP。
-15、凡耗时不可控的超长任务（如大文件下载、模型训练、全量测试、复杂构建等），严禁在脚本内同步阻塞，必须用 subprocess.Popen 跨平台脱离终端启动并将进度心跳写入本地日志文件，打印 PID 后立即 sys.exit()，工具 timeout_seconds 设为 15 秒仅验证启动；后续须通过检查日志监控进度，若发现任务完成或长时间无心跳更新，必须主动调用系统命令（如 kill -9 PID）清理后台进程以防孤儿进程耗尽资源；仅在任务自身支持超时参数或耗时可预估时，方可在脚本内同步执行并设合理 timeout_seconds。"""
-
-DEFAULT_SYSTEM_WORKING_PRINCIPLES_EN = """Working principles:
-1. First inspect the working directory and understand the requirement.
-2. Prefer using network search tools for real-time information, such as weather, news, or other current topics.
-3. All code file creation, editing, and deletion operations are performed in the working directory. If the user does not specify a directory, the project root is used by default.
-4. If needed, provide concise explanations and next-step suggestions.
-5. If the task involves deleting system files or executing dangerous commands, you must ask for confirmation first.
-6. When the user enters /task-start, respond with: Please enter your first initial prompt.
-7. When information is missing, do not speculate; prefer using search tools to fill the gap and keep the answer precise and evidence-based.
-8. If the user wants to read or recognize other binary files, you must clearly state that you cannot directly read or understand generic binary file contents.
-9. If the user wants to inspect image content, you should first use the image-reading tool to convert the image into base64 or a visual-message format and then send it to a multimodal-capable model.
-10. For image-related tasks, prefer the image tool rather than trying to read the raw binary contents directly.
-11. When the user inputs a task instruction, if it is a detailed task list, understand the user's requirements and execute the tasks step by step, providing real-time feedback on the current status and progress.
-12. When using the execute_python_script tool, manage the process lifecycle within the script: for short commands like ls, pytest, and build, use subprocess.run with an explicit timeout; for persistent commands like npm run dev and flask run, use subprocess.Popen to start them in the background and poll a health check URL to confirm they are ready before printing the PID and exiting immediately to avoid triggering the 360-second timeout.
-13. When official network retrieval tools are unavailable and network content is crawled via scripts, differentiated processing shall be performed according to data types: for regular webpage texts, remove redundant contents including HTML tags, style codes, advertising fragments, invalid comments and redundant blank lines, retain only valid main texts and truncate the content if it exceeds 8000 characters with a strict upper limit of 8000 characters for text output; for program source codes, no filtering or cleaning is required, keep the original codes, built-in comments, indentations, line breaks and original formats completely with no character limit on code output.
-14. When starting a persistent service in the background, ensure cross-platform compatibility: set start_new_session=True for Linux/Mac environments and creationflags=subprocess.CREATE_NEW_PROCESS_GROUP for Windows environments.
-15. For long-running tasks with unpredictable durations (such as large file downloads, model training, full tests, complex builds, etc.), synchronous blocking execution within the script is strictly prohibited. Instead, use subprocess.Popen to start the task in the background across platforms and write progress heartbeats to a local log file. After printing the PID, immediately call sys.exit() and set the tool's timeout_seconds to 15 seconds for startup verification only. Subsequently, monitor progress by checking the log file. If the task completes or there is no heartbeat update for an extended period, proactively call system commands (like kill -9 PID) to clean up background processes and prevent orphan processes from consuming resources. Only when the task itself supports timeout parameters or has a predictable duration can synchronous execution be performed within the script with a reasonable timeout_seconds setting."""
-
-TASK_END_GUIDANCE_ZH = """你是提示词优化专家，负责将对话记录整理为更清晰、可执行的最终任务提示词。
-
-请与默认系统提示词保持一致的工作原则与约束条件：
-{principles}
-
-生成最终提示词时，请严格遵循以下约束：
-1. 只输出最终改进后的提示词文本，不要添加任何解释、元信息或注释。
-2. 保留用户原始目标、关键上下文、澄清或变更后的要求、待执行步骤与预期产物。
-3. 语言必须清晰、可执行、步骤化，适合直接给后续执行器使用。
-4. 如果上下文中存在不确定信息，应显式写成“待确认”或“需验证”的约束项。
-5. 输出长度控制在 18000 字符以内。"""
+def clear_task_memory_file() -> None:
+    MEMORY_FILE_PATH.parent.mkdir(parents=True, exist_ok=True)
+    MEMORY_FILE_PATH.write_text("# Task Execution Memory\n\n", encoding="utf-8")
 
-TASK_END_GUIDANCE_EN = """You are a prompt-optimization expert responsible for turning conversation history into a clearer and more actionable final task prompt.
 
-Please follow the same working principles and constraints as the default system prompt:
-{principles}
+def append_task_memory_entry(text: str) -> None:
+    MEMORY_FILE_PATH.parent.mkdir(parents=True, exist_ok=True)
+    with MEMORY_FILE_PATH.open("a", encoding="utf-8") as f:
+        f.write(text)
+        if not text.endswith("\n"):
+            f.write("\n")
 
-When generating the final prompt, strictly follow these constraints:
-1. Return only the improved final prompt text. Do not add explanations, metadata, or comments.
-2. Preserve the user's original goal, key context, clarified or changed requirements, pending steps, and expected deliverables.
-3. Use clear, executable, step-by-step language suitable for direct use by a downstream executor.
-4. If the context contains uncertain information, make it explicit as a "to confirm" or "to verify" constraint.
-5. Keep the output within 18000 characters."""
 
-ZH_SYSTEM_PROMPT = f"""
-你是一个基于 CLI 的编程 Agent，你的名字是 Jason Li，专注于使用文件、命令、Python 脚本等工具完成开发任务。
-
-{DEFAULT_SYSTEM_WORKING_PRINCIPLES_ZH}
-
-"""
-
-EN_SYSTEM_PROMPT = f"""
-You are a CLI-based coding agent named Jason Li, focused on completing development tasks by using files, commands, Python scripts, and other tools.
-
-{DEFAULT_SYSTEM_WORKING_PRINCIPLES_EN}
-
-"""
-
-
-PLANNING_PROMPT = f"""
-你是一个基于 CLI 的编程 Agent，你的名字是 Jason Li，能够通过使用文件、命令、Python 脚本等工具完成开发任务，当前你只能够生成任务执行计划。
-
-注意：你的输出只能是“任务执行计划”的文本说明。绝对不能真实执行任何命令、脚本、文件修改或调用任何工具方法。你是在“规划”而非“动手”。
-
-在生成任务执行计划时，请遵循以下{DEFAULT_SYSTEM_WORKING_PRINCIPLES_ZH}
+def summarize_memory_value(value: Any, max_len: int = 240) -> str:
+    if isinstance(value, str):
+        if len(value) > max_len:
+            return value[: max_len - 20] + f"... (truncated, len={len(value)})"
+        return value
 
+    if isinstance(value, (dict, list)):
+        try:
+            serialized = json.dumps(value, ensure_ascii=False)
+        except Exception:
+            serialized = str(value)
+        if len(serialized) > max_len:
+            return serialized[: max_len - 20] + f"... (truncated, len={len(serialized)})"
+        return serialized
 
-请严格按照以下格式输出结果：
+    return str(value)
 
-用户原始指令：......
 
-结合上下文得到用户的完整意图：.....
+def summarize_tool_result(result: Any) -> str:
+    if isinstance(result, dict):
+        status = result.get("status")
+        content = result.get("content")
+        content_summary = summarize_memory_value(content, max_len=200)
+        extra_items = [
+            f"{k}={summarize_memory_value(v, max_len=80)}"
+            for k, v in result.items()
+            if k not in {"status", "content"}
+        ]
+        extra_text = f" | {", ".join(extra_items)}" if extra_items else ""
+        return f"status={status}{extra_text}\nContent: {content_summary}"
+    return summarize_memory_value(result)
 
-接下来按照这个步骤逐步执行完成任务：
-1、第一步：......
-2、第二步：......
-......
 
-"""
+def build_bottom_toolbar_text() -> str:
+    base = t("toolbar_help")
+    token_summary = format_cumulative_token_summary()
+    return f"{token_summary} | {base}"
 
 
 TRANSLATIONS = {
-    "system_prompt": {
-        "zh": ZH_SYSTEM_PROMPT,
-        "en": EN_SYSTEM_PROMPT,
-    },
-    "task_end_system_prompt": {
-        "zh": TASK_END_GUIDANCE_ZH.format(principles=DEFAULT_SYSTEM_WORKING_PRINCIPLES_ZH),
-        "en": TASK_END_GUIDANCE_EN.format(principles=DEFAULT_SYSTEM_WORKING_PRINCIPLES_EN),
-    },
     "config_field_model": {"zh": "模型名称，例如 qwen2.5-7b-instruct", "en": "Model name, for example qwen2.5-7b-instruct"},
     "config_field_base_url": {"zh": "OpenAI 兼容接口地址，例如 http://127.0.0.1:11434/v1", "en": "OpenAI-compatible base URL, for example http://127.0.0.1:11434/v1"},
     "config_field_api_key": {"zh": "API Key；若是本地模型可填写任意非空字符串", "en": "API key; for a local model you can enter any non-empty string"},
@@ -215,6 +156,8 @@ TRANSLATIONS = {
     "copy_file_desc": {"zh": "复制文件。", "en": "Copy a file."},
     "read_image_as_base64_desc": {"zh": "读取图片文件并将其编码为 base64。", "en": "Read an image file and encode it as base64."},
     "list_dir_desc": {"zh": "列出目录中的文件和子目录。", "en": "List files and subdirectories in the given directory."},
+    "search_code_desc": {"zh": "在目录中按文本模式搜索匹配内容。", "en": "Search for matching text within a directory."},
+    "edit_file_desc": {"zh": "在文件中替换指定文本。", "en": "Replace a specific string in a file."},
     "execute_command_desc": {"zh": "在指定目录下执行 shell 命令。", "en": "Execute a shell command in the specified directory."},
     "execute_python_script_desc": {"zh": "执行一个 Python 脚本或一段 Python 代码。", "en": "Execute a Python script or a block of Python code."},
     "path_desc": {"zh": "要读取的文件路径。", "en": "Path of the file to read."},
@@ -320,14 +263,37 @@ def t(key: str, **kwargs: Any) -> str:
         return text.format(**kwargs)
     return text
 
+MEMORY_FILE_PATH = ROOT / "memory.md"
+
+DEFAULT_SYSTEM_PROMPT = f"""
+你是一个基于 CLI 的编程 Agent，你的名字是 Jason Li，专注于使用文件、命令、Python 脚本等工具完成开发任务。
+
+工作原则：
+1、先检查工作目录并理解需求。
+2、优先使用网络搜索类工具搜索网络实时信息，例如：天气、新闻、资讯等等。
+3、所有代码文件生成、编辑、删除等操作均在工作目录中执行。如果用户没有指定具体目录，默认工作目录为工程的根目录。
+4、如果需要，输出简洁的说明与下一步建议。
+5、若涉及删除系统文件或执行危险命令，必须先向用户确认后方可执行。
+6、当用户输入指令：/task-start 的时候,直接回复：请输入你的第一条初始提示。
+7、遇到信息盲区时，严禁主观臆测，请优先使用搜索工具补齐信息缺口，确保回答精准有据。
+8、在任务处理中，工具调用会产生大量中间信息，而对话只保存有限几轮上下文,在生成最终结果或者是某些步骤需要回溯前面缺失的历史信息的时候可以读取记忆文件:{MEMORY_FILE_PATH}。
+9、如果用户想“读取/识别其他二进制文件”，你必须明确告知：我无法直接读取或理解通用二进制文件内容。
+10、如果用户想“查看图片内容”，应优先调用图片读取工具。
+11、当用户输入一条任务指令时，如果是详细的任务清单，你就理解用户要求逐步完成工作，同时执行每个步骤的时候明确说明当前环节与进度，实时反馈任务状态。
+12、使用 execute_python_script 时必须在脚本内自行管理进程生命周期：若是 ls、pytest、build 等短命令用 subprocess.run 显式设置 timeout，若是 npm run dev、flask run 等常驻服务用 subprocess.Popen 脱离终端启动并在脚本内轮询健康检查 URL，确认就绪后打印 PID 并立即 sys.exit() 退出以防触发 360 秒强制超时。
+13、无法调用官方联网检索工具而通过脚本抓取网络内容时需区分数据类型处理，抓取普通网页文本需剔除 HTML 标签、样式代码、广告碎片、无效注释、多余空行等冗余内容，仅留存有效正文且文本超出 8000 字符则截断，文本输出上限为 8000 字符，抓取程序源代码则无需过滤，完整保留原始代码、自带注释、缩进换行与原有格式，代码输出无字符数量限制。
+14、脱离终端启动常驻服务时务必兼顾跨平台兼容：Linux/Mac 环境设置 start_new_session=True，Windows 环境设置 creationflags=subprocess.CREATE_NEW_PROCESS_GROUP。
+15、凡耗时不可控的超长任务（如大文件下载、模型训练、全量测试、复杂构建等），严禁在脚本内同步阻塞，必须用 subprocess.Popen 跨平台脱离终端启动并将进度心跳写入本地日志文件，打印 PID 后立即 sys.exit()，工具 timeout_seconds 设为 15 秒仅验证启动；后续须通过检查日志监控进度，若发现任务完成或长时间无心跳更新，必须主动调用系统命令（如 kill -9 PID）清理后台进程以防孤儿进程耗尽资源；仅在任务自身支持超时参数或耗时可预估时，方可在脚本内同步执行并设合理 timeout_seconds。
+16、如果需要搜索互联网信息时候优先使用中国国内搜索引擎优先，例如：bing、百度等。
+
+"""
 
 UI_SYSTEM_LANGUAGE = "en"
-APPLICATION_VERSION = "0.2.6"
-DEFAULT_SYSTEM_PROMPT = t("system_prompt")
+APPLICATION_VERSION = "0.2.9"
 WORKSPACE_DIR = ROOT / "workspace"
 LOG_DIR = ROOT / "logs"
 LOG_FILE = LOG_DIR / "agent_runtime.log"
-DEFAULT_MAX_CHAT_COUNT = 7
+DEFAULT_MAX_CHAT_COUNT = 6
 CHAT_MESSAGE_MAX_COUNT = 8
 CONFIG_SAVE_FILE_PATH = ROOT / "config.json"
 RE_ACTION_DELAY = 1 # unit: seconds
@@ -508,6 +474,39 @@ TOOL_DEFINITIONS = [
             },
         },
     },
+    {
+        "type": "function",
+        "function": {
+            "name": "search_code",
+            "description": t("search_code_desc"),
+            "parameters": {
+                "type": "object",
+                "properties": {
+                    "path": {"type": "string", "description": t("list_dir_path_desc")},
+                    "pattern": {"type": "string", "description": "Text pattern to search for."},
+                    "recursive": {"type": "boolean", "description": t("list_dir_recursive_desc")},
+                    "max_results": {"type": "integer", "description": "Maximum number of matches to return."}
+                },
+                "required": ["path", "pattern"],
+            },
+        },
+    },
+    {
+        "type": "function",
+        "function": {
+            "name": "edit_file",
+            "description": t("edit_file_desc"),
+            "parameters": {
+                "type": "object",
+                "properties": {
+                    "path": {"type": "string", "description": t("write_path_desc")},
+                    "old_string": {"type": "string", "description": "The text to replace."},
+                    "new_string": {"type": "string", "description": "The replacement text."}
+                },
+                "required": ["path", "old_string", "new_string"],
+            },
+        },
+    },
     {
         "type": "function",
         "function": {
@@ -1622,6 +1621,94 @@ def execute_tool_call(tool_call: Any) -> dict[str, Any]:
         logger.info("list_dir result: %s", result)
         return result
 
+    if name == "search_code":
+        file_path = args.get("path") or args.get("file_path")
+        pattern = args.get("pattern")
+        if not file_path or not pattern:
+            result = {"status": "error", "content": t("tool_missing_arg", name="search_code", arg="path/pattern")}
+            logger.error("search_code missing arguments, raw args: %s", args)
+            return result
+
+        path = Path(file_path).expanduser()
+        if not path.is_absolute():
+            path = Path.cwd() / path
+        if not path.exists():
+            result = {"status": "ok", "content": json.dumps([], ensure_ascii=False)}
+            logger.info("search_code result: %s", result)
+            return result
+
+        recursive = bool(args.get("recursive", True))
+        max_results = args.get("max_results")
+        try:
+            max_results = int(max_results) if max_results is not None else 50
+        except (TypeError, ValueError):
+            max_results = 50
+
+        matches: list[dict[str, Any]] = []
+        if path.is_file():
+            candidates = [path]
+        elif recursive:
+            candidates = [item for item in sorted(path.rglob("*")) if item.is_file()]
+        else:
+            candidates = [item for item in sorted(path.iterdir()) if item.is_file()]
+
+        for candidate in candidates:
+            try:
+                content = candidate.read_text(encoding="utf-8")
+            except (UnicodeDecodeError, OSError):
+                continue
+            for line_number, line in enumerate(content.splitlines(), start=1):
+                if pattern in line:
+                    matches.append({
+                        "path": str(candidate.resolve()),
+                        "line": line_number,
+                        "content": line,
+                    })
+                    if len(matches) >= max_results:
+                        break
+            if len(matches) >= max_results:
+                break
+
+        result = {"status": "ok", "content": json.dumps(matches, ensure_ascii=False)}
+        logger.info("search_code result: %s", result)
+        return result
+
+    if name == "edit_file":
+        file_path = args.get("path") or args.get("file_path")
+        old_string = args.get("old_string")
+        new_string = args.get("new_string")
+        if not file_path or old_string is None or new_string is None:
+            result = {"status": "error", "content": t("tool_missing_arg", name="edit_file", arg="path/old_string/new_string")}
+            logger.error("edit_file missing arguments, raw args: %s", args)
+            return result
+
+        path = Path(file_path).expanduser()
+        if not path.is_absolute():
+            path = Path.cwd() / path
+        if not path.exists():
+            result = {"status": "error", "content": f"File does not exist: {path}"}
+            logger.info("edit_file result: %s", result)
+            return result
+
+        try:
+            original_text = path.read_text(encoding="utf-8")
+        except Exception as exc:
+            result = {"status": "error", "content": f"Failed to read file: {path}\n{exc}"}
+            logger.exception("edit_file failed: %s", path)
+            logger.info("edit_file result: %s", result)
+            return result
+
+        if old_string not in original_text:
+            result = {"status": "error", "content": f"Target text not found in file: {path}"}
+            logger.info("edit_file result: %s", result)
+            return result
+
+        updated_text = original_text.replace(old_string, new_string, 1)
+        path.write_text(updated_text, encoding="utf-8")
+        result = {"status": "ok", "content": f"Updated: {path}"}
+        logger.info("edit_file result: %s", result)
+        return result
+
     if name == "execute_python_script":
         script = args.get("script")
         if not script:
@@ -1715,10 +1802,12 @@ def show_tool_result(tool_call: Any, result: dict[str, Any]) -> None:
     )
 
 
-def chat_once(client: OpenAI, model: str, messages: list[dict[str, Any]], temperature: float, debug_enabled: bool = False) -> Any:
+def chat_once(client: OpenAI, model: str, messages: list[dict[str, Any]], temperature: float, debug_enabled: bool = False, disable_tools:bool = False) -> Any:
     ensure_not_interrupted()
     wait_for_model_call_interval()
     tool_definitions = TOOL_DEFINITIONS + ACTIVE_MCP_TOOL_DEFINITIONS
+    if disable_tools:
+        tool_definitions = []
     request_payload = {
         "model": model,
         "messages": messages,
@@ -1915,16 +2004,39 @@ def plan_user_request(client: OpenAI, model: str, history: list[dict[str, Any]],
     if is_special_command(user_text):
         return user_text
 
-    planning_prompt = PLANNING_PROMPT
+    planning_prompt = f"""
+你是一个编程行业需求分析专家，你能够通过历史上下文和用户的输入分析出用户的真实意图，能够拆分步骤，并且能够生成任务执行清单。
+在任务处理中，工具调用会产生大量中间信息，而对话只保存有限几轮上下文,在生成最终结果或者是某些步骤需要回溯前面缺失的历史信息的时候可以读取记忆文件:{MEMORY_FILE_PATH}。
+
+### 请严格按照以下格式输出任务清单：
+
+用户原始指令：......
+
+结合上下文得到用户的完整意图：.....
+
+接下来按照这个步骤逐步执行完成任务：
+1、第一步：......
+2、第二步：......
+......
+
+"""
+
+    user_prompt = f"""请结合历史上下文分析用户输入并生成任务清单。
+### 历史上下文:
+{json.dumps(history, ensure_ascii=False)}
+
+### 用户输入:
+{user_text}
+"""
 
     planning_messages = [
         {"role": "system", "content": planning_prompt},
-        {"role": "user", "content": user_text},
+        {"role": "user", "content": user_prompt},
     ]
-    if history:
-        planning_messages.insert(1, {"role": "user", "content": "以下是历史上下文：\n" + json.dumps(history, ensure_ascii=False)})
+    # if history:
+    #     planning_messages.insert(1, {"role": "user", "content": "以下是历史上下文：\n" + json.dumps(history, ensure_ascii=False)})
 
-    assistant_message = chat_once(client, model, planning_messages, temperature=0.2, debug_enabled=debug_enabled)
+    assistant_message = chat_once(client, model, planning_messages, temperature=0.2, debug_enabled=debug_enabled, disable_tools=True)
     return (assistant_message.content or "").strip() or user_text
 
 
@@ -1938,6 +2050,9 @@ def is_special_command(user_text: str) -> bool:
 
 def run_agent(client: OpenAI, model: str, system_prompt: str, session_store: SessionStore, user_text: str, debug_enabled: bool = False, recorder: ConversationRecorder | None = None) -> None:
     reset_interruption_state()
+    clear_task_memory_file()
+    append_task_memory_entry(f"## Task started\n\nUser request: {summarize_memory_value(user_text, max_len=240)}\n\n")
+
     history = session_store.load()
     planned_user_text = user_text
     if not is_special_command(user_text):
@@ -1946,6 +2061,8 @@ def run_agent(client: OpenAI, model: str, system_prompt: str, session_store: Ses
         except Exception:
             logger.exception("Planning step failed; continuing with original user input")
 
+    append_task_memory_entry("## Task checklist\n\n" + summarize_memory_value(planned_user_text, max_len=10000) + "\n\n")
+
     first_task_prompt = {"role": "user", "content": planned_user_text}
     history.append(first_task_prompt)
     session_store.save(history)
@@ -2021,6 +2138,12 @@ def run_agent(client: OpenAI, model: str, system_prompt: str, session_store: Ses
                 result = execute_tool_call(tc)
                 messages.append({"role": "tool", "tool_call_id": tc.id, "content": json.dumps(result, ensure_ascii=False)})
                 show_tool_result(tc, result)
+                append_task_memory_entry(
+                    "### Tool invocation\n\n"
+                    f"Tool: {tc.function.name}\n\n"
+                    f"Arguments: {summarize_memory_value(tc.function.arguments, max_len=1200)}\n\n"
+                    f"Result: {summarize_tool_result(result)}\n\n"
+                )
                 # end_calling_tips = f"tool={tc.function.name}\nresult={json.dumps(result, ensure_ascii=False)}"
                 # show_stage(t("tool_call_finished"), end_calling_tips[:80])
 
@@ -2050,9 +2173,77 @@ def run_agent(client: OpenAI, model: str, system_prompt: str, session_store: Ses
                 error_payload = {"status": "error", "content": traceback.format_exc()}
                 messages.append({"role": "tool", "tool_call_id": tc.id, "content": json.dumps(error_payload, ensure_ascii=False)})
                 console.print(Panel.fit(traceback.format_exc(), title=t("tool_execution_error")))
+                append_task_memory_entry(
+                    "### Tool invocation\n\n"
+                    f"Tool: {tc.function.name}\n\n"
+                    f"Arguments: {summarize_memory_value(tc.function.arguments, max_len=1200)}\n\n"
+                    f"Result: ERROR\n{summarize_tool_result(error_payload)}\n\n"
+                )
                 # if recorder:
                 #     recorder.record_error(traceback.format_exc())
 
+import json
+from typing import List, Union
+
+def get_content_from_tool_calls(tool_calls: List) -> str:
+    """
+    Extract the `content` field from a list of tool call objects
+    (as returned by OpenAI's ChatCompletionMessage.tool_calls).
+
+    Args:
+        tool_calls: List[ChatCompletionMessageFunctionToolCall] or similar.
+                   Each item should have a `function.arguments` attribute
+                   which is a JSON string containing a dict with a `content` key.
+
+    Returns:
+        The extracted `content` string if found, otherwise an empty string ("").
+    """
+    if not tool_calls:
+        return ""
+
+    for tool_call in tool_calls:
+        try:
+            # 兼容 dict 形式（比如有些 mock / 测试数据）
+            if isinstance(tool_call, dict):
+                func = tool_call.get("function")
+                if not func:
+                    continue
+                # func 可能是 dict，也可能是有 arguments 属性的对象
+                if isinstance(func, dict):
+                    arguments_str = func.get("arguments")
+                else:
+                    arguments_str = getattr(func, "arguments", None)
+            else:
+                # OpenAI SDK 对象：ChatCompletionMessageFunctionToolCall
+                func = getattr(tool_call, "function", None)
+                if func is None:
+                    continue
+                # Function.arguments 是一个 JSON 字符串
+                arguments_str = getattr(func, "arguments", None)
+
+            if not arguments_str:
+                continue
+
+            # arguments 本身就是 JSON 字符串，需要 parse
+            if isinstance(arguments_str, str):
+                arguments = json.loads(arguments_str)
+            elif isinstance(arguments_str, dict):
+                arguments = arguments_str
+            else:
+                # 其他类型直接放弃
+                continue
+
+            # 真正取 content 字段
+            if isinstance(arguments, dict) and "content" in arguments:
+                return arguments["content"]
+
+        except (json.JSONDecodeError, TypeError, AttributeError):
+            # 解析失败或结构异常，忽略这条 tool_call
+            continue
+
+    return ""
+
+
 
 def handle_task_end_command(md_path: Path, client: OpenAI, model: str, system_prompt: str, workdir: Path, debug_enabled: bool = False) -> None:
     """Process recent_conversations.md to find the most recent /task-start and use the
@@ -2101,20 +2292,34 @@ def handle_task_end_command(md_path: Path, client: OpenAI, model: str, system_pr
     compiled_text = "\n\n".join(["## Round " + r for r in selected])
 
     # Build messages for the model
-    sys_prompt = t("task_end_system_prompt")
+    sys_prompt = f"""
+你是提示词优化专家，负责将对话记录整理为更清晰、可执行的最终任务提示词。
 
-    user_msg = (
-        t("task_end_user_message", compiled_text=compiled_text)
-    )
+### 生成最终提示词时，请严格遵循以下约束：
+1. 只输出最终改进后的提示词文本，不要添加任何解释、元信息或注释。
+2. 保留用户原始目标、关键上下文、澄清或变更后的要求、待执行步骤与预期产物。
+3. 语言必须清晰、可执行、步骤化，适合直接给后续执行器使用。
+4. 如果上下文中存在不确定信息，应显式写成“待确认”或“需验证”的约束项。
+5. 输出长度控制在 18000 字符以内。
+
+"""
+
+    user_prompt = f"""分析对话记录帮我生成最终提示词,把最终提示词内容输出给我。
+### 对话记录
+{compiled_text}
+"""
 
     try:
-        assistant_message = chat_once(client, model, [{"role": "system", "content": sys_prompt}, {"role": "user", "content": user_msg}], temperature=0.2, debug_enabled=debug_enabled)
+        assistant_message = chat_once(client, model, [{"role": "system", "content": sys_prompt}, {"role": "user", "content": user_prompt}], temperature=0.2, debug_enabled=debug_enabled, disable_tools=True)
     except Exception:
         logger.exception(t("task_end_generation_failed_log"))
         console.print(Panel.fit(traceback.format_exc(), title=t("task_end_generate_failed")))
         return
-
+    prompt_call_tools = get_content_from_tool_calls(assistant_message.tool_calls)
+    # console.print(f"{prompt_call_tools}")
     final_prompt = (assistant_message.content or "").strip()
+    if not final_prompt:
+        final_prompt = prompt_call_tools
     if not final_prompt:
         console.print(Panel.fit(t("task_end_no_prompt"), title=t("task_end_result")))
         return
@@ -2190,7 +2395,6 @@ def main() -> None:
 
     # Set localization language
     UI_SYSTEM_LANGUAGE = args.lang
-    DEFAULT_SYSTEM_PROMPT = t("system_prompt")
 
     # set up workspace directory
     WORKSPACE_DIR = Path(args.workdir)

{prompt_copilot_cli-0.2.6 → prompt_copilot_cli-0.2.9/prompt_copilot_cli.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: prompt-copilot-cli
-Version: 0.2.6
+Version: 0.2.9
 Summary: A lightweight terminal-based coding agent with file tools, command execution, multimodal image support, and MCP integration.
 Author: Jason Li
 License-Expression: MIT

{prompt_copilot_cli-0.2.6 → prompt_copilot_cli-0.2.9}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "prompt-copilot-cli"
-version = "0.2.6"
+version = "0.2.9"
 description = "A lightweight terminal-based coding agent with file tools, command execution, multimodal image support, and MCP integration."
 readme = "README.md"
 license = "MIT"

{prompt_copilot_cli-0.2.6 → prompt_copilot_cli-0.2.9}/tests/test_cli_args.py

@@ -56,6 +56,16 @@ class CLITests(unittest.TestCase):
         self.assertIn("短时命令", joined)
         self.assertIn("持久命令", joined)
 
+    def test_system_prompt_includes_notebook_memory_guidance(self) -> None:
+        self.assertIn(
+            "记事本方式",
+            main.DEFAULT_SYSTEM_WORKING_PRINCIPLES_ZH,
+        )
+        self.assertIn(
+            "notebook-style",
+            main.DEFAULT_SYSTEM_WORKING_PRINCIPLES_EN,
+        )
+
     def test_special_commands_skip_planning(self) -> None:
         called = {"value": False}
 

{prompt_copilot_cli-0.2.6 → prompt_copilot_cli-0.2.9}/tests/test_file_tools.py

@@ -87,6 +87,34 @@ class FileToolTests(unittest.TestCase):
             self.assertTrue(dest.exists())
             self.assertEqual(dest.read_text(encoding="utf-8"), "hello")
 
+    def test_search_code_tool_finds_pattern_in_file(self) -> None:
+        with tempfile.TemporaryDirectory() as tmpdir:
+            root = Path(tmpdir)
+            target = root / "demo.py"
+            target.write_text("def greet():\n    return 'hello'\n", encoding="utf-8")
+
+            result = main.execute_tool_call(DummyToolCall("search_code", {"path": str(root), "pattern": "return 'hello'"}))
+
+            self.assertEqual(result["status"], "ok")
+            matches = json.loads(result["content"])
+            self.assertTrue(matches)
+            self.assertEqual(matches[0]["path"], str(target))
+
+    def test_edit_file_tool_replaces_text(self) -> None:
+        with tempfile.TemporaryDirectory() as tmpdir:
+            target = Path(tmpdir) / "demo.py"
+            target.write_text("print('before')\n", encoding="utf-8")
+
+            result = main.execute_tool_call(
+                DummyToolCall(
+                    "edit_file",
+                    {"path": str(target), "old_string": "before", "new_string": "after"},
+                )
+            )
+
+            self.assertEqual(result["status"], "ok")
+            self.assertEqual(target.read_text(encoding="utf-8"), "print('after')\n")
+
 
 if __name__ == "__main__":
     unittest.main()