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

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: prompt-copilot-cli
-Version: 0.2.2
+Version: 0.2.6
 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.2 → prompt_copilot_cli-0.2.6}/main.py

@@ -94,10 +94,9 @@ def build_bottom_toolbar_text() -> str:
     return f"{token_summary} | {base}"
 
 
-ZH_SYSTEM_PROMPT = """
-你是一个基于 CLI 的编程 Agent，你的名字是 Jason Li，专注于使用文件、命令、Python 脚本等工具完成开发任务。
 
-工作原则：
+
+DEFAULT_SYSTEM_WORKING_PRINCIPLES_ZH = """工作原则：
 1、先检查工作目录并理解需求。
 2、优先使用网络搜索类工具搜索网络实时信息，例如：天气、新闻、资讯等等。
 3、所有代码文件生成、编辑、删除等操作均在工作目录中执行。如果用户没有指定具体目录，默认工作目录为工程的根目录。
@@ -108,16 +107,13 @@ ZH_SYSTEM_PROMPT = """
 8、如果用户想“读取/识别其他二进制文件”，你必须明确告知：我无法直接读取或理解通用二进制文件内容。
 9、如果用户想“查看图片内容”，应优先调用图片读取工具将图片转成 base64 或视觉消息格式，再将其发送给支持多模态的模型。
 10、对于图片类任务，优先使用图片工具而不是尝试直接读取二进制原始内容。
-11、当用户输入一条任务指令时，如果是详细的任务清单，你就理解用户要求逐步完成工作，同时每个步骤执行完毕要反馈状态和进度。
-12、在执行命令前，先判断该命令是短时命令还是持久命令：短时命令如 ls、pytest、python -m compileall 等应同步执行并等待结果；持久命令如 npm run dev、python app.py、uvicorn、flask run、serve、http.server 等会持续运行，应该优先以后台方式启动，并在必要时用健康检查确认服务已就绪。
+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。"""
 
-"""
-
-EN_SYSTEM_PROMPT = """
-You are a CLI-based coding agent named Jason Li, focused on completing development tasks by using files, commands, Python scripts, and other tools.
-
-Working principles:
+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.
@@ -128,37 +124,71 @@ Working principles:
 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 gives a task instruction, first understand the full intent from the context and the conversation history, then generate a clear execution checklist. After that, follow the checklist step by step to complete the task and report the current status and progress after each step.
-12. Before executing a command, first determine whether it is a short-lived command or a persistent one: short-lived commands such as ls, pytest, and python -m compileall should be executed synchronously and awaited; persistent commands such as npm run dev, python app.py, uvicorn, flask run, serve, and http.server will keep running, so they should be started in the background and, when needed, checked for readiness with a health check.
-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.
+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 字符以内。"""
+
+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}
+
+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 = (
-    "你是一个基于 CLI 的编程 Agent，你的名字是 Jason Li，专注于使用文件、命令、Python 脚本等工具完成开发任务。\n\n"
-    "在生成任务执行计划时，请遵循以下工作原则：\n"
-    "1、先检查工作目录并理解需求。\n"
-    "2、优先使用网络搜索类工具搜索网络实时信息，例如：天气、新闻、资讯等等。\n"
-    "3、所有代码文件生成、编辑、删除等操作均在工作目录中执行。如果用户没有指定具体目录，默认工作目录为工程的根目录。\n"
-    "4、如果需要，输出简洁的说明与下一步建议。\n"
-    "5、若涉及删除系统文件或执行危险命令，必须先向用户确认后方可执行。\n"
-    "6、当用户输入指令：/task-start 的时候，直接回复：请输入你的第一条初始提示。\n"
-    "7、遇到信息盲区时，严禁主观臆测，请优先使用搜索工具补齐信息缺口，确保回答精准有据。\n"
-    "8、如果用户想“读取/识别其他二进制文件”，你必须明确告知：我无法直接读取或理解通用二进制文件内容。\n"
-    "9、如果用户想“查看图片内容”，应优先调用图片读取工具将图片转成 base64 或视觉消息格式，再将其发送给支持多模态的模型。\n"
-    "10、对于图片类任务，优先使用图片工具而不是尝试直接读取二进制原始内容。\n"
-    "11、基于上下文和历史对话，先梳理用户的完整意图，再生成一份清晰、可执行的步骤清单；随后按步骤逐步完成任务，并在每个步骤完成后反馈执行状态和进度。\n"
-    "12、在任何需要执行命令的步骤中，先判断该命令属于短时命令还是持久命令，并在任务清单中明确写出你的判断说明：短时命令如 ls、pytest、python -m compileall 等应同步执行并等待结果；持久命令如 npm run dev、python app.py、uvicorn、flask run、serve、http.server 等应优先以后台方式启动，并在必要时用健康检查确认服务已就绪。\n\n"
-    "13、无法调用官方联网检索工具而通过脚本抓取网络内容时需区分数据类型处理，抓取普通网页文本需剔除 HTML 标签、样式代码、广告碎片、无效注释、多余空行等冗余内容，仅留存有效正文且文本超出 8000 字符则截断，文本输出上限为 8000 字符，抓取程序源代码则无需过滤，完整保留原始代码、自带注释、缩进换行与原有格式，代码输出无字符数量限制。\n\n"
-    "请严格按照以下格式输出结果：\n\n"
-    "用户原始指令：......\n\n"
-    "结合上下文得到用户的完整意图：.....\n\n"
-    "接下来按照这个步骤逐步执行完成任务：\n\n"
-    "1、第一步：......\n"
-    "2、第二步：......\n"
-    "......"
-)
+"""
+
+
+PLANNING_PROMPT = f"""
+你是一个基于 CLI 的编程 Agent，你的名字是 Jason Li，能够通过使用文件、命令、Python 脚本等工具完成开发任务，当前你只能够生成任务执行计划。
+
+注意：你的输出只能是“任务执行计划”的文本说明。绝对不能真实执行任何命令、脚本、文件修改或调用任何工具方法。你是在“规划”而非“动手”。
+
+在生成任务执行计划时，请遵循以下{DEFAULT_SYSTEM_WORKING_PRINCIPLES_ZH}
+
+
+请严格按照以下格式输出结果：
+
+用户原始指令：......
+
+结合上下文得到用户的完整意图：.....
+
+接下来按照这个步骤逐步执行完成任务：
+1、第一步：......
+2、第二步：......
+......
+
+"""
 
 
 TRANSLATIONS = {
@@ -166,6 +196,10 @@ TRANSLATIONS = {
         "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"},
@@ -273,7 +307,6 @@ TRANSLATIONS = {
     "context_size_label": {"zh": "提交上下文大小", "en": "Submitted context size"},
     "response_length_label": {"zh": "回复内容长度", "en": "Response content length"},
     "recent_conversations_header": {"zh": "# 最近对话记录", "en": "# Recent conversations"},
-    "task_end_system_prompt": {"zh": "你是提示词优化专家（精通将对话记录转化为清晰、可执行的任务提示）。\n输入：首先是用户在输入 /task-start 后会给出第一条初始提示，随后是从该标记以来的对话记录（包括模型回复、工具调用与结果）。\n任务：阅读这些记录，理解用户起始提示与后续的澄清或更改，并结合这些信息生成一个改进后的、清晰且可直接用于执行的最终提示词。\n输出要求：只输出最终改进后的提示词文本，不要添加任何解释、元信息或注释。长度控制在 18000 字符以内。", "en": "You are a prompt-optimization expert skilled at turning conversation history into a clear and actionable task prompt.\nInput: first the user provides an initial prompt after /task-start, then the conversation history from that point onward including model replies, tool calls, and results.\nTask: read these records, understand the initial prompt and any follow-up clarifications or changes, and generate an improved final prompt that is clear, executable, and ready to use.\nOutput requirements: return only the final improved prompt text, with no explanation, metadata, or comments. Keep it within 18000 characters."},
     "task_end_user_message": {"zh": "对话记录（从 /task-start 开始，按时间从旧到新）：\n\n{compiled_text}", "en": "Conversation history (starting from /task-start, from oldest to newest):\n\n{compiled_text}"},
     "task_end_generation_failed_log": {"zh": "调用模型生成最终提示失败", "en": "Failed to generate the final prompt with the model"},
     "final_prompt_header": {"zh": "# 最终提示词", "en": "# Final prompt"},
@@ -289,7 +322,7 @@ def t(key: str, **kwargs: Any) -> str:
 
 
 UI_SYSTEM_LANGUAGE = "en"
-APPLICATION_VERSION = "0.2.2"
+APPLICATION_VERSION = "0.2.6"
 DEFAULT_SYSTEM_PROMPT = t("system_prompt")
 WORKSPACE_DIR = ROOT / "workspace"
 LOG_DIR = ROOT / "logs"
@@ -475,38 +508,31 @@ TOOL_DEFINITIONS = [
             },
         },
     },
-    {
-        "type": "function",
-        "function": {
-            "name": "execute_command",
-            "description": t("execute_command_desc"),
-            "parameters": {
-                "type": "object",
-                "properties": {
-                    "command": {"type": "string", "description": t("command_desc")},
-                    "cwd": {"type": "string", "description": t("cwd_desc")},
-                    "timeout_seconds": {"type": "integer", "description": "Maximum runtime in seconds before the background process is terminated automatically."},
-                    "output_log_path": {"type": "string", "description": "Optional path to a log file where stdout/stderr will be written."},
-                },
-                "required": ["command", "cwd"],
-            },
-        },
-    },
     {
         "type": "function",
         "function": {
             "name": "execute_python_script",
-            "description": t("execute_python_script_desc"),
+            "description": "Execute a Python script or a block of Python code. Use the 'timeout_seconds' parameter to control the maximum execution time and prevent the process from hanging indefinitely.",
             "parameters": {
                 "type": "object",
                 "properties": {
-                    "script": {"type": "string", "description": t("script_desc")},
-                    "cwd": {"type": "string", "description": t("script_cwd_desc")},
+                    "script": {
+                        "type": "string",
+                        "description": "The Python script content to execute."
+                    },
+                    "cwd": {
+                        "type": "string",
+                        "description": "The working directory for the script execution."
+                    },
+                    "timeout_seconds": {
+                        "type": "integer",
+                        "description": "Maximum execution time in seconds before the process is terminated. Defaults to 120. Set a shorter timeout for quick commands to avoid waiting."
+                    }
                 },
-                "required": ["script", "cwd"],
-            },
-        },
-    },
+                "required": ["script", "cwd"]
+            }
+        }
+    }
 ]
 ACTIVE_MCP_TOOL_DEFINITIONS: list[dict[str, Any]] = []
 ACTIVE_MCP_TOOL_CONFIG: dict[str, Any] = {}
@@ -1211,51 +1237,193 @@ def wait_for_health_check(url: str, timeout_seconds: int = 20) -> bool:
 
 def run_subprocess_command(command: Any, cwd: str, shell: bool = False, timeout: int | None = None) -> tuple[int, str, str]:
     safe_cwd = resolve_execution_cwd(cwd, Path.cwd())
+    
+    # 跨平台进程隔离配置
+    popen_kwargs = {
+        "cwd": safe_cwd,
+        "stdout": subprocess.PIPE,
+        "stderr": subprocess.PIPE,
+        "stdin": subprocess.DEVNULL,  # 根治等待输入导致的卡死！
+        "text": True,
+        "encoding": "utf-8",
+        "errors": "replace",
+    }
+    if platform.system() == "Windows":
+        popen_kwargs["creationflags"] = subprocess.CREATE_NEW_PROCESS_GROUP
+    else:
+        popen_kwargs["start_new_session"] = True # 创建新进程组，便于后续杀整棵树
+
     try:
-        proc = subprocess.Popen(
-            command,
-            cwd=safe_cwd,
-            shell=shell,
-            stdout=subprocess.PIPE,
-            stderr=subprocess.PIPE,
-            text=True,
-            encoding="utf-8",
-            errors="replace",
-        )
+        proc = subprocess.Popen(command, shell=shell, **popen_kwargs)
     except (FileNotFoundError, NotADirectoryError, OSError) as exc:
         logger.warning(t("tool_subprocess_failed"), cwd, safe_cwd, exc)
-        proc = subprocess.Popen(
-            command,
-            cwd=str(Path.cwd()),
-            shell=shell,
-            stdout=subprocess.PIPE,
-            stderr=subprocess.PIPE,
-            text=True,
-            encoding="utf-8",
-            errors="replace",
-        )
+        proc = subprocess.Popen(command, cwd=str(Path.cwd()), shell=shell, **popen_kwargs)
 
     try:
         stdout, stderr = proc.communicate(timeout=timeout)
     except subprocess.TimeoutExpired:
-        proc.terminate()
+        # 超时后杀掉整个进程树，防止孤儿进程
         try:
-            proc.wait(timeout=5)
-        except subprocess.TimeoutExpired:
-            proc.kill()
-            proc.wait(timeout=5)
+            if platform.system() == "Windows":
+                subprocess.run(["taskkill", "/F", "/T", "/PID", str(proc.pid)], capture_output=True, timeout=5)
+            else:
+                os.killpg(os.getpgid(proc.pid), signal.SIGTERM)
+                proc.wait(timeout=3)
+                if proc.poll() is None:
+                    os.killpg(os.getpgid(proc.pid), signal.SIGKILL)
+        except Exception:
+            pass
+        finally:
+            try: proc.kill()
+            except: pass
         return -1, "", f"Command timed out after {timeout} seconds"
     except KeyboardInterrupt:
-        proc.terminate()
+        # 处理用户 Ctrl+C 中断
         try:
-            proc.wait(timeout=5)
-        except subprocess.TimeoutExpired:
-            proc.kill()
-            proc.wait(timeout=5)
+            if platform.system() == "Windows":
+                subprocess.run(["taskkill", "/F", "/T", "/PID", str(proc.pid)], capture_output=True, timeout=5)
+            else:
+                os.killpg(os.getpgid(proc.pid), signal.SIGTERM)
+        except Exception:
+            pass
         raise
+
     return proc.returncode, stdout or "", stderr or ""
 
 
+
+import os
+import signal
+import subprocess
+import uuid
+import time
+import platform
+from pathlib import Path
+
+def handle_execute_command(args):
+    command = args.get("command")
+    if not command:
+        return {"status": "error", "content": "Missing 'command' argument."}
+    
+    cwd = resolve_execution_cwd(args.get("cwd"), Path.cwd())
+    
+    # 解析命令类型参数
+    is_background = args.get("background", False)
+    
+    # ================= 路径 A: 常驻服务 (保留你原有的优秀逻辑) =================
+    if is_background:
+        output_log_path = args.get("output_log_path") or args.get("log_path")
+        if not output_log_path:
+            output_log_path = ROOT / "logs" / "background" / f"cmd_{datetime.now().strftime('%Y%m%d_%H%M%S')}_{os.getpid()}.log"
+            
+        result = start_background_process(command, cwd, timeout_seconds=None, output_log_path=output_log_path)
+        
+        if result.get("status") == "ok":
+            health_check_url = args.get("health_check_url")
+            if health_check_url:
+                try:
+                    ready = wait_for_health_check(str(health_check_url), timeout_seconds=int(args.get("health_check_timeout", 20)))
+                    result["health_check_ready"] = ready
+                    result["content"] = f"Started background process (pid={result['pid']})" + (" and health check succeeded." if ready else " but health check did not succeed yet.")
+                except Exception:
+                    result["health_check_ready"] = False
+                    result["content"] = f"Started background process (pid={result['pid']})"
+            
+            time.sleep(0.5) # 防止竞态
+            result["output_tail"] = _read_text_file_tail(output_log_path, max_chars=4000)
+            return result
+        return result
+        
+    # ================= 路径 B: 一次性命令 (新增 Sentinel 同步等待逻辑) =================
+    else:
+        timeout_seconds = int(args.get("timeout_seconds") or args.get("timeout") or 120)
+        
+        # 生成唯一哨兵并组装命令 (跨平台适配错误码输出)
+        sentinel = f"@@CMD_DONE_{uuid.uuid4().hex}@@"
+        if platform.system() == "Windows":
+            full_cmd = f"{command}\necho {sentinel} %errorlevel%\n"
+        else:
+            full_cmd = f"{command}\necho {sentinel} $?\n"
+        
+        # 构建启动参数 (跨平台适配进程组)
+        popen_kwargs = {
+            "shell": True,
+            "cwd": str(cwd),
+            "stdout": subprocess.PIPE,
+            "stderr": subprocess.STDOUT,
+            "text": True,
+            "bufsize": 1,
+        }
+        
+        if platform.system() == "Windows":
+            popen_kwargs["creationflags"] = subprocess.CREATE_NEW_PROCESS_GROUP
+        else:
+            popen_kwargs["start_new_session"] = True
+            
+        process = subprocess.Popen(full_cmd, **popen_kwargs)
+        
+        output_lines = []
+        timed_out = False
+        start_time = time.time()
+        
+        try:
+            while True:
+                line = process.stdout.readline()
+                if not line:
+                    if time.time() - start_time > timeout_seconds:
+                        timed_out = True
+                        break
+                    continue
+                
+                if sentinel in line:
+                    # 提取退出码
+                    try:
+                        exit_code = int(line.split(sentinel)[-1].strip().rstrip())
+                    except:
+                        exit_code = -1
+                    break
+                else:
+                    output_lines.append(line)
+                    if len(output_lines) > 5000:
+                        output_lines.pop(0)
+                        
+                if time.time() - start_time > timeout_seconds:
+                    timed_out = True
+                    break
+        finally:
+            # 超时或完成后，杀掉整个进程树 (跨平台适配)
+            if process.poll() is None:
+                try:
+                    if platform.system() == "Windows":
+                        # Windows: taskkill 强杀整个进程树
+                        subprocess.run(["taskkill", "/F", "/T", "/PID", str(process.pid)], 
+                                      capture_output=True, timeout=5)
+                    else:
+                        # Unix: 杀整个进程组
+                        os.killpg(os.getpgid(process.pid), signal.SIGTERM)
+                        time.sleep(1)
+                        if process.poll() is None:
+                            os.killpg(os.getpgid(process.pid), signal.SIGKILL)
+                except Exception:
+                    pass
+        
+        content = "".join(output_lines)[-4000:]
+        
+        if timed_out:
+            return {
+                "status": "timeout",
+                "exit_code": None,
+                "content": f"{content}\n[ERROR] Command timed out after {timeout_seconds} seconds and was forcefully terminated.\n[Hint] If this is a dev server, please use background=true."
+            }
+        else:
+            return {
+                "status": "success" if exit_code == 0 else "error",
+                "exit_code": exit_code,
+                "content": content
+            }
+
+
+
 def execute_tool_call(tool_call: Any) -> dict[str, Any]:
     name = getattr(tool_call.function, "name", "")
     args = safe_parse_tool_args(getattr(tool_call.function, "arguments", {}))
@@ -1454,46 +1622,6 @@ def execute_tool_call(tool_call: Any) -> dict[str, Any]:
         logger.info("list_dir result: %s", result)
         return result
 
-    if name == "execute_command":
-        command = args.get("command")
-        if not command:
-            result = {"status": "error", "content": t("tool_missing_arg", name="execute_command", arg="command")}
-            logger.error("execute_command missing command argument, raw args: %s", args)
-            return result
-        cwd = resolve_execution_cwd(args.get("cwd"), Path.cwd())
-
-        timeout_seconds = None
-        timeout_value = args.get("timeout_seconds") or args.get("timeout")
-        if timeout_value is not None:
-            try:
-                timeout_seconds = int(timeout_value)
-            except (TypeError, ValueError):
-                timeout_seconds = None
-
-        output_log_path = args.get("output_log_path") or args.get("log_path")
-        if not output_log_path:
-            output_log_path = ROOT / "logs" / "background" / f"cmd_{datetime.now().strftime('%Y%m%d_%H%M%S')}_{os.getpid()}.log"
-        result = start_background_process(command, cwd, timeout_seconds=timeout_seconds, output_log_path=output_log_path)
-        if result.get("status") == "ok":
-            health_check_url = args.get("health_check_url")
-            if health_check_url:
-                try:
-                    ready = wait_for_health_check(str(health_check_url), timeout_seconds=int(args.get("health_check_timeout", 20)))
-                    result["health_check_ready"] = ready
-                    result["content"] = (
-                        f"Started background process (pid={result['pid']})"
-                        + (" and confirmed health check succeeded." if ready else " but health check did not succeed yet.")
-                    )
-                except Exception:
-                    result["health_check_ready"] = False
-                    result["content"] = f"Started background process (pid={result['pid']})"
-            result["output_tail"] = _read_text_file_tail(output_log_path, max_chars=4000)
-            logger.info("execute_command background result: %s", result)
-            return result
-
-        logger.info("execute_command result: %s", result)
-        return result
-
     if name == "execute_python_script":
         script = args.get("script")
         if not script:
@@ -1504,7 +1632,17 @@ def execute_tool_call(tool_call: Any) -> dict[str, Any]:
         script_path = Path(cwd) / "__cli_temp_script__.py"
         script_path.parent.mkdir(parents=True, exist_ok=True)
         script_path.write_text(script, encoding="utf-8")
-        returncode, stdout, stderr = run_subprocess_command([sys.executable, str(script_path)], cwd, timeout=TOOL_SUBPROCESS_TIMEOUT)
+        
+        # 获取自定义超时，默认 120 秒，最大不超过 360 秒
+        timeout_seconds = int(args.get("timeout_seconds") or 120)
+        timeout_seconds = min(max(timeout_seconds, 10), TOOL_SUBPROCESS_TIMEOUT)
+        
+        returncode, stdout, stderr = run_subprocess_command(
+            [sys.executable, str(script_path)], 
+            cwd, 
+            shell=False, 
+            timeout=timeout_seconds
+        )
         response = {
             "status": "ok" if returncode == 0 else "error",
             "content": stdout + stderr,
@@ -1513,6 +1651,7 @@ def execute_tool_call(tool_call: Any) -> dict[str, Any]:
         logger.info("execute_python_script result: %s", response)
         return response
 
+
     if name in {item["function"]["name"] for item in ACTIVE_MCP_TOOL_DEFINITIONS}:
         logger.info("Executing MCP tool: %s, args: %s", name, args)
         return run_mcp_tool(name, args)
@@ -1776,8 +1915,10 @@ 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_messages = [
-        {"role": "system", "content": PLANNING_PROMPT},
+        {"role": "system", "content": planning_prompt},
         {"role": "user", "content": user_text},
     ]
     if history:
@@ -1960,9 +2101,7 @@ 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 = t("task_end_system_prompt")
 
     user_msg = (
         t("task_end_user_message", compiled_text=compiled_text)

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: prompt-copilot-cli
-Version: 0.2.2
+Version: 0.2.6
 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.2 → prompt_copilot_cli-0.2.6}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "prompt-copilot-cli"
-version = "0.2.2"
+version = "0.2.6"
 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.2 → prompt_copilot_cli-0.2.6}/tests/test_cli_args.py

@@ -1,6 +1,7 @@
 import contextlib
 import io
 import sys
+import tempfile
 import types
 import unittest
 from pathlib import Path
@@ -102,6 +103,42 @@ class CLITests(unittest.TestCase):
         self.assertEqual(captured["messages"][0]["role"], "system")
         self.assertEqual(captured["messages"][-1]["content"], "帮我修复这个 bug")
 
+    def test_task_end_command_uses_aligned_working_principles(self) -> None:
+        captured: dict[str, object] = {}
+
+        def fake_chat_once(client, model, messages, temperature, debug_enabled=False):
+            captured["messages"] = messages
+            return types.SimpleNamespace(content="final prompt")
+
+        original_chat_once = main.chat_once
+        original_lang = main.UI_SYSTEM_LANGUAGE
+        main.UI_SYSTEM_LANGUAGE = "zh"
+        main.chat_once = fake_chat_once
+        try:
+            with tempfile.TemporaryDirectory() as temp_dir:
+                md_path = Path(temp_dir) / "recent_conversations.md"
+                md_path.write_text(
+                    "# Recent conversations\n\n## Round 1\n\n**User:** /task-start\n\nhello\n\n**Assistant:** hi",
+                    encoding="utf-8",
+                )
+                main.handle_task_end_command(
+                    md_path=md_path,
+                    client=object(),
+                    model="gpt-4o-mini",
+                    system_prompt="ignored",
+                    workdir=Path(temp_dir),
+                    debug_enabled=False,
+                )
+        finally:
+            main.UI_SYSTEM_LANGUAGE = original_lang
+            main.chat_once = original_chat_once
+
+        self.assertIn("messages", captured)
+        system_prompt = captured["messages"][0]["content"]
+        self.assertIn("先检查工作目录并理解需求", system_prompt)
+        self.assertIn("生成最终提示词时，请严格遵循以下约束", system_prompt)
+        self.assertIn("\n\n", system_prompt)
+
     def test_version_flag_prints_application_version_and_exits(self) -> None:
         parser = main.build_cli_parser()
         output = io.StringIO()