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

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

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

@@ -110,10 +110,55 @@ ZH_SYSTEM_PROMPT = """
 10、对于图片类任务，优先使用图片工具而不是尝试直接读取二进制原始内容。
 11、当用户输入一条任务指令时，如果是详细的任务清单，你就理解用户要求逐步完成工作，同时每个步骤执行完毕要反馈状态和进度。
 12、在执行命令前，先判断该命令是短时命令还是持久命令：短时命令如 ls、pytest、python -m compileall 等应同步执行并等待结果；持久命令如 npm run dev、python app.py、uvicorn、flask run、serve、http.server 等会持续运行，应该优先以后台方式启动，并在必要时用健康检查确认服务已就绪。
+13、无法调用官方联网检索工具而通过脚本抓取网络内容时需区分数据类型处理，抓取普通网页文本需剔除 HTML 标签、样式代码、广告碎片、无效注释、多余空行等冗余内容，仅留存有效正文且文本超出 8000 字符则截断，文本输出上限为 8000 字符，抓取程序源代码则无需过滤，完整保留原始代码、自带注释、缩进换行与原有格式，代码输出无字符数量限制。
 
 """
-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.\n\nWorking principles:\n1. First inspect the working directory and understand the requirement.\n2. Prefer using network search tools for real-time information, such as weather, news, or other current topics.\n3. 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.\n4. If needed, provide concise explanations and next-step suggestions.\n5. If the task involves deleting system files or executing dangerous commands, you must ask for confirmation first.\n6. When the user enters /task-start, respond with: Please enter your first initial prompt.\n7. When information is missing, do not speculate; prefer using search tools to fill the gap and keep the answer precise and evidence-based.\n8. 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.\n9. 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.\n10. For image-related tasks, prefer the image tool rather than trying to read the raw binary contents directly.\n11. 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."""
+
+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:
+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 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.
+
+"""
+
+
+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"
+    "......"
+)
 
 
 TRANSLATIONS = {
@@ -228,7 +273,7 @@ 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输出要求：只输出最终改进后的提示词文本，不要添加任何解释、元信息或注释。长度控制在 2000 字符以内。", "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 2000 characters."},
+    "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"},
@@ -244,7 +289,7 @@ def t(key: str, **kwargs: Any) -> str:
 
 
 UI_SYSTEM_LANGUAGE = "en"
-APPLICATION_VERSION = "0.1.9"
+APPLICATION_VERSION = "0.2.2"
 DEFAULT_SYSTEM_PROMPT = t("system_prompt")
 WORKSPACE_DIR = ROOT / "workspace"
 LOG_DIR = ROOT / "logs"
@@ -252,8 +297,9 @@ LOG_FILE = LOG_DIR / "agent_runtime.log"
 DEFAULT_MAX_CHAT_COUNT = 7
 CHAT_MESSAGE_MAX_COUNT = 8
 CONFIG_SAVE_FILE_PATH = ROOT / "config.json"
-RE_ACTION_DELAY = 6 # unit: seconds
+RE_ACTION_DELAY = 1 # unit: seconds
 TOOL_SUBPROCESS_TIMEOUT = 6 * 60  # 1 hour in seconds
+MODEL_REQUEST_TIMEOUT_SECONDS = 600  # generous timeout for slower model generations
 TASK_DESCRIPTION_TARGET = "[This is the task list after understanding the user's needs]"
 DEFAULT_MODEL_CONFIG: dict[str, Any] = {
     "model": "",
@@ -733,6 +779,7 @@ def build_client(model_cfg: dict[str, Any]) -> OpenAI:
     kwargs: dict[str, Any] = {"api_key": api_key}
     if base_url:
         kwargs["base_url"] = base_url
+    kwargs["timeout"] = MODEL_REQUEST_TIMEOUT_SECONDS
     return OpenAI(**kwargs)
 
 
@@ -754,6 +801,23 @@ def normalize_mcp_tool_definition(tool_obj: Any) -> dict[str, Any]:
     }
 
 
+def get_tool_description(tool_call: Any) -> str:
+    description = getattr(getattr(tool_call, "function", None), "description", None)
+    if isinstance(description, str) and description.strip():
+        return description.strip()
+
+    tool_name = getattr(getattr(tool_call, "function", None), "name", None)
+    if not isinstance(tool_name, str) or not tool_name:
+        return ""
+
+    for definition in TOOL_DEFINITIONS + ACTIVE_MCP_TOOL_DEFINITIONS:
+        function = definition.get("function") or {}
+        if function.get("name") == tool_name:
+            return str(function.get("description", "")).strip()
+
+    return ""
+
+
 async def _run_mcp_session(server_config: dict[str, Any], handler: Any) -> Any:
     transport = str(server_config.get("transport") or server_config.get("type") or "stdio").lower()
     if transport in {"http", "streamable_http", "streamable-http"}:
@@ -987,6 +1051,19 @@ def looks_like_background_service_command(command: Any) -> bool:
     return False
 
 
+def _read_text_file_tail(path: str | os.PathLike[str], max_chars: int = 4000) -> str:
+    try:
+        p = Path(path)
+        if not p.exists():
+            return ""
+        text = p.read_text(encoding="utf-8", errors="replace")
+        if len(text) > max_chars:
+            return text[-max_chars:]
+        return text
+    except Exception:
+        return ""
+
+
 def stream_background_process_output(process: subprocess.Popen[Any], log_path: str | os.PathLike[str]) -> None:
     log_file = Path(log_path)
 
@@ -1030,14 +1107,14 @@ def start_background_process(command: Any, cwd: str, timeout_seconds: int | None
     log_path = Path(output_log_path).expanduser() if output_log_path else ROOT / "logs" / "background" / f"cmd_{datetime.now().strftime('%Y%m%d_%H%M%S')}_{os.getpid()}.log"
     log_path.parent.mkdir(parents=True, exist_ok=True)
 
-    log_handle = log_path.open("a", encoding="utf-8")
     startup_kwargs: dict[str, Any] = {
         "cwd": safe_cwd,
-        "stdout": log_handle,
+        "stdout": subprocess.PIPE,
         "stderr": subprocess.STDOUT,
         "text": True,
         "encoding": "utf-8",
         "errors": "replace",
+        "bufsize": 1,
     }
 
     if os.name == "nt":
@@ -1050,17 +1127,22 @@ def start_background_process(command: Any, cwd: str, timeout_seconds: int | None
             process = subprocess.Popen(str(command), shell=True, start_new_session=True, **startup_kwargs)
     except (FileNotFoundError, NotADirectoryError, OSError) as exc:
         logger.warning(t("tool_subprocess_failed"), cwd, safe_cwd, exc)
+        return {"status": "error", "content": str(exc)}
+
+    def _drain_output() -> None:
         try:
-            log_handle.close()
+            with log_path.open("a", encoding="utf-8") as handle:
+                while True:
+                    chunk = process.stdout.readline() if process.stdout is not None else ""
+                    if chunk == "":
+                        break
+                    handle.write(chunk)
+                    handle.flush()
         except Exception:
             pass
-        return {"status": "error", "content": str(exc)}
 
-    try:
-        log_handle.flush()
-        log_handle.close()
-    except Exception:
-        pass
+    output_thread = threading.Thread(target=_drain_output, daemon=True)
+    output_thread.start()
 
     if timeout_seconds is not None and timeout_seconds > 0:
         def _watch_timeout() -> None:
@@ -1075,6 +1157,7 @@ def start_background_process(command: Any, cwd: str, timeout_seconds: int | None
                         process.wait(timeout=5)
                     with log_path.open("a", encoding="utf-8") as handle:
                         handle.write(f"\n[timeout] process terminated after {timeout_seconds}s\n")
+                        handle.flush()
             except Exception:
                 pass
 
@@ -1089,7 +1172,28 @@ def start_background_process(command: Any, cwd: str, timeout_seconds: int | None
         "pid": process.pid,
         "cwd": safe_cwd,
         "log_path": str(log_path),
+        "state": "running",
+    }
+
+
+def get_background_process_status(process_id: int, log_path: str | os.PathLike[str] | None = None, timeout_seconds: int | None = None) -> dict[str, Any]:
+    try:
+        process = subprocess.Popen(["ps", "-p", str(process_id), "-o", "pid="], stdout=subprocess.PIPE, stderr=subprocess.PIPE, text=True)
+        stdout, _ = process.communicate(timeout=5)
+        running = bool(stdout and str(stdout).strip())
+    except Exception:
+        running = False
+
+    output_text = _read_text_file_tail(log_path) if log_path else ""
+    payload = {
+        "status": "running" if running else "completed",
+        "pid": process_id,
+        "log_path": str(log_path) if log_path else None,
+        "output_tail": output_text,
     }
+    if timeout_seconds is not None and timeout_seconds > 0 and not running:
+        payload["timeout_seconds"] = timeout_seconds
+    return payload
 
 
 def wait_for_health_check(url: str, timeout_seconds: int = 20) -> bool:
@@ -1383,6 +1487,7 @@ def execute_tool_call(tool_call: Any) -> dict[str, Any]:
                 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
 
@@ -1461,7 +1566,14 @@ def show_stage(title: str, content: str) -> None:
 
 def show_tool_result(tool_call: Any, result: dict[str, Any]) -> None:
     display_result = sanitize_tool_result_for_display(result)
-    console.print(Panel.fit(f"[bold cyan]{tool_call.function.name}[/bold cyan]\n{json.dumps(display_result, ensure_ascii=False, indent=2)}", title=t("tool_result_title")))
+    description = get_tool_description(tool_call)
+    description_text = f"{description}\n\n" if description else ""
+    console.print(
+        Panel.fit(
+            f"[bold cyan]{tool_call.function.name}[/bold cyan]\n{description_text}{json.dumps(display_result, ensure_ascii=False, indent=2)}",
+            title=t("tool_result_title"),
+        )
+    )
 
 
 def chat_once(client: OpenAI, model: str, messages: list[dict[str, Any]], temperature: float, debug_enabled: bool = False) -> Any:
@@ -1475,6 +1587,9 @@ def chat_once(client: OpenAI, model: str, messages: list[dict[str, Any]], temper
         "tools": tool_definitions,
         "tool_choice": "auto",
     }
+    request_timeout = getattr(client, "timeout", None)
+    if request_timeout is None:
+        request_timeout = MODEL_REQUEST_TIMEOUT_SECONDS
 
     context_payload = json.dumps(request_payload, ensure_ascii=False)
     context_size_chars = len(context_payload)
@@ -1484,7 +1599,7 @@ def chat_once(client: OpenAI, model: str, messages: list[dict[str, Any]], temper
         show_stage(t("model_request_params"), json.dumps(request_payload, ensure_ascii=False, indent=2))
 
     try:
-        response = client.chat.completions.create(**request_payload)
+        response = client.chat.completions.create(**request_payload, timeout=request_timeout)
         assistant_message = response.choices[0].message
         usage = getattr(response, "usage", None)
         if usage is not None:
@@ -1610,6 +1725,7 @@ def to_tool_call_objects(tool_calls: list[Any]) -> list[Any]:
                 function=SimpleNamespace(
                     name=getattr(function, "name", ""),
                     arguments=getattr(function, "arguments", {}),
+                    description=getattr(function, "description", ""),
                 ),
             )
         )
@@ -1660,31 +1776,8 @@ def plan_user_request(client: OpenAI, model: str, history: list[dict[str, Any]],
     if is_special_command(user_text):
         return user_text
 
-    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"
-        "请严格按照以下格式输出结果：\n\n"
-        "用户原始指令：......\n\n"
-        "结合上下文得到用户的完整意图：.....\n\n"
-        "接下来按照这个步骤逐步执行完成任务：\n\n"
-        "1、第一步：......\n"
-        "2、第二步：......\n"
-        "......"
-    )
     planning_messages = [
-        {"role": "system", "content": planning_prompt},
+        {"role": "system", "content": PLANNING_PROMPT},
         {"role": "user", "content": user_text},
     ]
     if history:
@@ -1779,15 +1872,16 @@ def run_agent(client: OpenAI, model: str, system_prompt: str, session_store: Ses
 
         for tc in tool_calls:
             try:
-                start_calling_tips = f"tool={tc.function.name}\narguments={tc.function.arguments}"
+                tool_desc = get_tool_description(tc)
+                start_calling_tips = f"tool={tc.function.name}\ndescription={tool_desc}\narguments={tc.function.arguments}"
                 show_stage(t("starting_tool_call"), start_calling_tips[:80])
                 # if recorder:
                 #     recorder.record_tool_start(tc.function.name, tc.function.arguments)
                 result = execute_tool_call(tc)
-                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])
-                # show_tool_result(tc, result)
                 messages.append({"role": "tool", "tool_call_id": tc.id, "content": json.dumps(result, ensure_ascii=False)})
+                show_tool_result(tc, result)
+                # 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])
 
                 if tc.function.name == "read_image_as_base64":
                     try:

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

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

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

@@ -19,6 +19,19 @@ class CommandTimeoutTests(unittest.TestCase):
         self.assertEqual(stdout, "")
         self.assertIn("timed out", stderr.lower())
 
+    def test_start_background_process_returns_running_state(self) -> None:
+        result = main.start_background_process(
+            [sys.executable, "-c", "import time; time.sleep(0.2)"],
+            cwd=".",
+            timeout_seconds=3,
+            output_log_path=str(Path("logs") / "test_background.log"),
+        )
+
+        self.assertEqual(result.get("status"), "ok")
+        self.assertEqual(result.get("state"), "running")
+        self.assertIsNotNone(result.get("pid"))
+        self.assertIn("log_path", result)
+
 
 if __name__ == "__main__":
     unittest.main()