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

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

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

@@ -111,7 +111,9 @@ DEFAULT_SYSTEM_WORKING_PRINCIPLES_ZH = """工作原则：
 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。"""
+15、凡耗时不可控的超长任务（如大文件下载、模型训练、全量测试、复杂构建等），严禁在脚本内同步阻塞，必须用 subprocess.Popen 跨平台脱离终端启动并将进度心跳写入本地日志文件，打印 PID 后立即 sys.exit()，工具 timeout_seconds 设为 15 秒仅验证启动；后续须通过检查日志监控进度，若发现任务完成或长时间无心跳更新，必须主动调用系统命令（如 kill -9 PID）清理后台进程以防孤儿进程耗尽资源；仅在任务自身支持超时参数或耗时可预估时，方可在脚本内同步执行并设合理 timeout_seconds。
+16、如果需要搜索互联网信息时候优先使用中国国内搜索引擎优先，例如：bing、百度等。
+"""
 
 DEFAULT_SYSTEM_WORKING_PRINCIPLES_EN = """Working principles:
 1. First inspect the working directory and understand the requirement.
@@ -128,7 +130,9 @@ DEFAULT_SYSTEM_WORKING_PRINCIPLES_EN = """Working principles:
 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."""
+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.
+16. When searching the internet for information, prioritize domestic Chinese search engines such as Bing or Baidu.
+"""
 
 TASK_END_GUIDANCE_ZH = """你是提示词优化专家，负责将对话记录整理为更清晰、可执行的最终任务提示词。
 
@@ -215,6 +219,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."},
@@ -322,7 +328,7 @@ def t(key: str, **kwargs: Any) -> str:
 
 
 UI_SYSTEM_LANGUAGE = "en"
-APPLICATION_VERSION = "0.2.6"
+APPLICATION_VERSION = "0.2.8"
 DEFAULT_SYSTEM_PROMPT = t("system_prompt")
 WORKSPACE_DIR = ROOT / "workspace"
 LOG_DIR = ROOT / "logs"
@@ -508,6 +514,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 +1661,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 +1842,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 +2044,38 @@ 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"""
+你是一个编程行业需求分析专家，你能够通过历史上下文和用户的输入分析出用户的真实意图，能够拆分步骤，并且能够生成任务执行清单。
+
+### 请严格按照以下格式输出任务清单：
+
+用户原始指令：......
+
+结合上下文得到用户的完整意图：.....
+
+接下来按照这个步骤逐步执行完成任务：
+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
 
 
@@ -2053,6 +2204,68 @@ def run_agent(client: OpenAI, model: str, system_prompt: str, session_store: Ses
                 # 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 +2314,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

{prompt_copilot_cli-0.2.6 → prompt_copilot_cli-0.2.8/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.8
 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.8}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "prompt-copilot-cli"
-version = "0.2.6"
+version = "0.2.8"
 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.8}/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()