vibego 0.2.38__tar.gz → 0.2.40__tar.gz

{vibego-0.2.38 → vibego-0.2.40}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: vibego
-Version: 0.2.38
+Version: 0.2.40
 Summary: vibego CLI：用于初始化与管理 Telegram Master Bot 的工具
 Author: Hypha
 License-Expression: LicenseRef-Proprietary

{vibego-0.2.38 → vibego-0.2.40}/bot.py

@@ -69,8 +69,6 @@ from tasks.fsm import (
     TaskNoteStates,
     TaskPushStates,
 )
-from telegram_markdown import render_markdown_to_telegram
-
 # --- 简单 .env 加载 ---
 def load_env(p: str = ".env"):
     """从指定路径加载 dotenv 格式的键值对到进程环境变量。"""
@@ -128,7 +126,7 @@ TEST_PHASE_PROMPT = f"进入测试阶段{AGENTS_PHASE_SUFFIX}"
 # 报告缺陷时的专用前缀，插入在统一提示语之前
 BUG_REPORT_PREFIX = "报告一个缺陷，详见底部最新的缺陷描述。"
 
-_parse_mode_env = (os.environ.get("TELEGRAM_PARSE_MODE") or "MarkdownV2").strip()
+_parse_mode_env = (os.environ.get("TELEGRAM_PARSE_MODE") or "Markdown").strip()
 _parse_mode_key = _parse_mode_env.replace("-", "").replace("_", "").lower()
 MODEL_OUTPUT_PARSE_MODE: Optional[ParseMode]
 if _parse_mode_key in _PARSE_MODE_CANDIDATES:
@@ -136,7 +134,12 @@ if _parse_mode_key in _PARSE_MODE_CANDIDATES:
     if MODEL_OUTPUT_PARSE_MODE is None:
         worker_log.info("模型输出将按纯文本发送")
     else:
-        worker_log.info("模型输出 parse_mode：%s", MODEL_OUTPUT_PARSE_MODE.value)
+        mode_value = (
+            MODEL_OUTPUT_PARSE_MODE.value
+            if isinstance(MODEL_OUTPUT_PARSE_MODE, ParseMode)
+            else str(MODEL_OUTPUT_PARSE_MODE)
+        )
+        worker_log.info("模型输出 parse_mode：%s", mode_value)
 else:
     MODEL_OUTPUT_PARSE_MODE = ParseMode.MARKDOWN_V2
     worker_log.warning(
@@ -503,8 +506,8 @@ def _is_already_escaped(text: str) -> bool:
 
     # 对于短文本，放宽检测条件
     if len(text) < 20:
-        # 短文本只要有 2 个以上转义字符就认为已被转义
-        if len(matches) >= 2:
+        # 短文本出现任意转义字符即可认定为已转义，防止重复转义
+        if len(matches) >= 1:
             return True
     else:
         # 检查转义字符密度（降低到 3%）
@@ -576,29 +579,17 @@ def _unescape_if_already_escaped(text: str) -> str:
 def _prepare_model_payload(text: str) -> str:
     if _IS_MARKDOWN_V2:
         cleaned = _unescape_if_already_escaped(text)
-        return render_markdown_to_telegram(cleaned)
+        return _escape_markdown_v2(cleaned)
     if _IS_MARKDOWN:
         return _normalize_legacy_markdown(text)
     return text
 
 
-def _optimize_markdown_v2_payload(payload: str) -> str:
-    """占位函数：保留严格转义版本，确保 MarkdownV2 合规。"""
-
-    return payload
-
-
 def _prepare_model_payload_variants(text: str) -> tuple[str, Optional[str]]:
-    """返回首选与备用的 MarkdownV2 内容，首选尽量减少转义。"""
-
-    strict_payload = _prepare_model_payload(text)
-    if not _IS_MARKDOWN_V2:
-        return strict_payload, None
+    """返回首选与备用内容，默认为单一格式。"""
 
-    optimized_payload = _optimize_markdown_v2_payload(strict_payload)
-    if optimized_payload != strict_payload:
-        return optimized_payload, strict_payload
-    return strict_payload, None
+    payload = _prepare_model_payload(text)
+    return payload, None
 
 
 def _extract_bad_request_message(exc: TelegramBadRequest) -> str:
@@ -704,20 +695,12 @@ async def _send_with_markdown_guard(
         if raw_sender is None:
             raise
 
-        # Markdown 彻底失败时退回纯文本发送，需要先清理 MarkdownV2 转义符号
-        fallback_payload = _force_unescape_markdown(text)
-        if fallback_payload != text:
-            worker_log.debug(
-                "Markdown 降级为纯文本发送，已移除转义符号",
-                extra={"original_length": len(text), "fallback_length": len(fallback_payload)},
-            )
-
         worker_log.warning(
             "Markdown 解析仍失败，将以纯文本发送",
             extra={"length": len(text)},
         )
-        await raw_sender(fallback_payload)
-        return fallback_payload
+        await raw_sender(text)
+        return text
 
 
 async def _notify_send_failure_message(chat_id: int) -> None:
@@ -4266,6 +4249,7 @@ async def _deliver_pending_messages(
                     "chat": chat_id,
                 },
             )
+            return False
         else:
             worker_log.info(
                 "模型输出已发送且计划完成",
@@ -4592,7 +4576,13 @@ async def _interrupt_long_poll(chat_id: int) -> None:
     线程安全：使用 asyncio.Lock 保护状态访问。
     """
     if CHAT_LONG_POLL_LOCK is None:
-        # 锁未初始化（测试环境或启动早期）
+        state = CHAT_LONG_POLL_STATE.get(chat_id)
+        if state is not None:
+            state["interrupted"] = True
+            worker_log.info(
+                "标记延迟轮询为待中断",
+                extra={"chat": chat_id},
+            )
         return
 
     async with CHAT_LONG_POLL_LOCK:
@@ -4685,6 +4675,13 @@ async def _watch_and_notify(chat_id: int, session_path: Path,
                             "max_rounds": long_poll_max_rounds,
                             "interrupted": False,
                         }
+                else:
+                    CHAT_LONG_POLL_STATE[chat_id] = {
+                        "active": True,
+                        "round": 0,
+                        "max_rounds": long_poll_max_rounds,
+                        "interrupted": False,
+                    }
                 worker_log.info(
                     "首次发送成功，启动延迟轮询模式",
                     extra={
@@ -4706,6 +4703,10 @@ async def _watch_and_notify(chat_id: int, session_path: Path,
                             state = CHAT_LONG_POLL_STATE.get(chat_id)
                             if state is not None:
                                 state["round"] = 0
+                    else:
+                        state = CHAT_LONG_POLL_STATE.get(chat_id)
+                        if state is not None:
+                            state["round"] = 0
                     worker_log.info(
                         "延迟轮询中收到新消息，重置计数",
                         extra={
@@ -4721,6 +4722,10 @@ async def _watch_and_notify(chat_id: int, session_path: Path,
                             state = CHAT_LONG_POLL_STATE.get(chat_id)
                             if state is not None:
                                 state["round"] = long_poll_rounds
+                    else:
+                        state = CHAT_LONG_POLL_STATE.get(chat_id)
+                        if state is not None:
+                            state["round"] = long_poll_rounds
 
                     if long_poll_rounds >= long_poll_max_rounds:
                         worker_log.info(
@@ -4757,6 +4762,13 @@ async def _watch_and_notify(chat_id: int, session_path: Path,
                         "监听任务退出，已清理延迟轮询状态",
                         extra={"chat": chat_id},
                     )
+        else:
+            if chat_id in CHAT_LONG_POLL_STATE:
+                CHAT_LONG_POLL_STATE.pop(chat_id, None)
+                worker_log.debug(
+                    "监听任务退出，已清理延迟轮询状态",
+                    extra={"chat": chat_id},
+                )
 
 
 def _read_pointer_path(pointer: Path) -> Optional[Path]:

{vibego-0.2.38 → vibego-0.2.40}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "vibego"
-version = "0.2.38"
+version = "0.2.40"
 description = "vibego CLI：用于初始化与管理 Telegram Master Bot 的工具"
 readme = "README.md"
 requires-python = ">=3.11"
@@ -35,14 +35,14 @@ include-package-data = true
 py-modules = ["bot", "master", "logging_setup", "project_repository"]
 
 [tool.setuptools.packages.find]
-include = ["vibego_cli", "tasks", "scripts", "telegram_markdown"]
+include = ["vibego_cli", "tasks", "scripts"]
 
 [tool.setuptools.package-data]
 "vibego_cli" = ["data/*.txt"]
 "scripts" = ["*.sh", "models/*.sh"]
 
 [tool.bumpversion]
-current_version = "0.2.38"
+current_version = "0.2.40"
 parse = "(?P<major>\\d+)\\.(?P<minor>\\d+)\\.(?P<patch>\\d+)"
 serialize = ["{major}.{minor}.{patch}"]
 search = "{current_version}"

{vibego-0.2.38 → vibego-0.2.40}/tests/test_long_poll_mechanism.py

@@ -50,11 +50,13 @@ def reset_global_state():
     bot.SESSION_OFFSETS.clear()
     bot.CHAT_DELIVERED_HASHES.clear()
     bot.CHAT_DELIVERED_OFFSETS.clear()
+    bot.CHAT_LONG_POLL_LOCK = None
     yield
     bot.CHAT_LONG_POLL_STATE.clear()
     bot.SESSION_OFFSETS.clear()
     bot.CHAT_DELIVERED_HASHES.clear()
     bot.CHAT_DELIVERED_OFFSETS.clear()
+    bot.CHAT_LONG_POLL_LOCK = None
 
 
 # ============================================================================
@@ -72,7 +74,7 @@ def test_interrupt_long_poll_sets_flag():
         "interrupted": False,
     }
 
-    bot._interrupt_long_poll(chat_id)
+    asyncio.run(bot._interrupt_long_poll(chat_id))
 
     assert bot.CHAT_LONG_POLL_STATE[chat_id]["interrupted"] is True
 
@@ -84,7 +86,7 @@ def test_interrupt_long_poll_no_state():
     bot.CHAT_LONG_POLL_STATE.pop(chat_id, None)
 
     # 不应抛出异常
-    bot._interrupt_long_poll(chat_id)
+    asyncio.run(bot._interrupt_long_poll(chat_id))
 
 
 # ============================================================================
@@ -126,7 +128,7 @@ async def test_watch_and_notify_enters_long_poll_after_first_delivery(mock_sessi
     chat_id = 12345
     delivery_count = 0
 
-    async def mock_deliver(cid, path):
+    async def mock_deliver(cid, path, **kwargs):
         nonlocal delivery_count
         delivery_count += 1
         # 第一次返回 True（首次发送成功）
@@ -151,10 +153,10 @@ async def test_watch_and_notify_enters_long_poll_after_first_delivery(mock_sessi
         assert chat_id in bot.CHAT_LONG_POLL_STATE
         assert bot.CHAT_LONG_POLL_STATE[chat_id]["active"] is True
         assert bot.CHAT_LONG_POLL_STATE[chat_id]["round"] == 0
-        assert bot.CHAT_LONG_POLL_STATE[chat_id]["max_rounds"] == 10
+        assert bot.CHAT_LONG_POLL_STATE[chat_id]["max_rounds"] == 600
 
         # 中断任务（避免等待 3 分钟）
-        bot._interrupt_long_poll(chat_id)
+        await bot._interrupt_long_poll(chat_id)
         await asyncio.sleep(0.1)
 
         # 取消任务
@@ -173,7 +175,7 @@ async def test_watch_and_notify_long_poll_increments_round(mock_session_path):
     chat_id = 12345
     delivery_count = 0
 
-    async def mock_deliver(cid, path):
+    async def mock_deliver(cid, path, **kwargs):
         nonlocal delivery_count
         delivery_count += 1
         # 第一次返回 True，之后返回 False
@@ -204,7 +206,7 @@ async def test_watch_and_notify_long_poll_increments_round(mock_session_path):
         await asyncio.sleep(0.3)
 
         # 中断并清理
-        bot._interrupt_long_poll(chat_id)
+        await bot._interrupt_long_poll(chat_id)
         await asyncio.sleep(0.1)
         task.cancel()
         try:
@@ -221,7 +223,7 @@ async def test_watch_and_notify_interrupted_by_new_message(mock_session_path):
     chat_id = 12345
     delivery_count = 0
 
-    async def mock_deliver(cid, path):
+    async def mock_deliver(cid, path, **kwargs):
         nonlocal delivery_count
         delivery_count += 1
         return delivery_count == 1  # 只第一次返回 True
@@ -241,7 +243,7 @@ async def test_watch_and_notify_interrupted_by_new_message(mock_session_path):
         assert chat_id in bot.CHAT_LONG_POLL_STATE
 
         # 模拟新消息到达，中断轮询
-        bot._interrupt_long_poll(chat_id)
+        await bot._interrupt_long_poll(chat_id)
 
         # 等待任务检测到中断标志并退出
         await asyncio.sleep(0.2)
@@ -267,7 +269,7 @@ async def test_watch_and_notify_long_poll_resets_on_new_delivery(mock_session_pa
     delivery_sequence = [True, False, False, True, False]  # 第 1 和第 4 次有消息
     delivery_index = 0
 
-    async def mock_deliver(cid, path):
+    async def mock_deliver(cid, path, **kwargs):
         nonlocal delivery_index
         result = delivery_sequence[delivery_index] if delivery_index < len(delivery_sequence) else False
         delivery_index += 1
@@ -291,7 +293,7 @@ async def test_watch_and_notify_long_poll_resets_on_new_delivery(mock_session_pa
         await asyncio.sleep(0.25)
 
         # 中断并清理
-        bot._interrupt_long_poll(chat_id)
+        await bot._interrupt_long_poll(chat_id)
         await asyncio.sleep(0.1)
         task.cancel()
         try:
@@ -316,11 +318,11 @@ def test_interrupt_long_poll_idempotent():
     }
 
     # 第一次调用
-    bot._interrupt_long_poll(chat_id)
+    asyncio.run(bot._interrupt_long_poll(chat_id))
     assert bot.CHAT_LONG_POLL_STATE[chat_id]["interrupted"] is True
 
     # 第二次调用（应该仍然是 True，不报错）
-    bot._interrupt_long_poll(chat_id)
+    asyncio.run(bot._interrupt_long_poll(chat_id))
     assert bot.CHAT_LONG_POLL_STATE[chat_id]["interrupted"] is True
 
 
@@ -335,7 +337,7 @@ async def test_watch_and_notify_max_rounds_limit(mock_session_path):
     chat_id = 12345
 
     # 修改最大轮询次数为 2（便于测试）
-    async def mock_deliver(cid, path):
+    async def mock_deliver(cid, path, **kwargs):
         # 只在第一次返回 True，进入延迟轮询
         # 后续返回 False，让轮询计数递增
         if not hasattr(mock_deliver, "called"):
@@ -362,7 +364,7 @@ async def test_watch_and_notify_does_not_block_event_loop(mock_session_path):
     """
     chat_id = 12345
 
-    async def mock_deliver(cid, path):
+    async def mock_deliver(cid, path, **kwargs):
         return False
 
     with patch.object(bot, "_deliver_pending_messages", side_effect=mock_deliver):
@@ -397,3 +399,4 @@ async def test_watch_and_notify_does_not_block_event_loop(mock_session_path):
             await task
         except asyncio.CancelledError:
             pass
+import asyncio

{vibego-0.2.38 → vibego-0.2.40}/tests/test_markdown_guard.py

@@ -10,8 +10,8 @@ import bot
 
 
 @pytest.mark.asyncio()
-async def test_markdown_guard_plain_fallback_removes_escapes() -> None:
-    """确保回退纯文本时不会残留 MarkdownV2 转义反斜杠。"""
+async def test_markdown_guard_plain_fallback_preserves_original() -> None:
+    """确保纯文本回退时返回原始内容（含必要转义）。"""
 
     delivered: list[str] = []
 
@@ -39,31 +39,30 @@ async def test_markdown_guard_plain_fallback_removes_escapes() -> None:
     original = "测试 \\_Markdown\\_ 转义"
     result = await bot._send_with_markdown_guard(original, _failing_sender, raw_sender=_raw_sender)
 
-    assert delivered and delivered[0] == "测试 _Markdown_ 转义"
-    assert result == "测试 _Markdown_ 转义"
+    assert delivered and delivered[0] == original
+    assert result == original
 
 
 @pytest.mark.asyncio()
 @pytest.mark.parametrize(
-    ("original", "expected"),
+    "original",
     [
-        ("条目 A\\)", "条目 A)"),
-        ("任务编码：/TASK\\_0022", "任务编码：/TASK_0022"),
-        ("配置文件 config\\.json", "配置文件 config.json"),
-        ("版本号 3\\.11\\.4", "版本号 3.11.4"),
-        ("保留连字符 use\\-case", "保留连字符 use-case"),
-        ("强调 \\*重要\\*", "强调 *重要*"),
-        ("变量 \\_value\\_", "变量 _value_"),
-        ("选项 A\\|B", "选项 A|B"),
-        ("集合 \\{a, b\\}", "集合 {a, b}"),
-        ("说明 test\\.", "说明 test."),
+        "条目 A\\)",
+        "任务编码：/TASK\\_0022",
+        "配置文件 config\\.json",
+        "版本号 3\\.11\\.4",
+        "保留连字符 use\\-case",
+        "强调 \\*重要\\*",
+        "变量 \\_value\\_",
+        "选项 A\\|B",
+        "集合 \\{a, b\\}",
+        "说明 test\\.",
     ],
 )
 async def test_markdown_guard_plain_fallback_force_unescape(
     original: str,
-    expected: str,
 ) -> None:
-    """验证强制反转义可处理只有单个转义符的场景。"""
+    """验证纯文本回退会直接返回原始字符串。"""
 
     delivered: list[str] = []
 
@@ -88,5 +87,5 @@ async def test_markdown_guard_plain_fallback_force_unescape(
 
     result = await bot._send_with_markdown_guard(original, _failing_sender, raw_sender=_raw_sender)
 
-    assert delivered and delivered[0] == expected
-    assert result == expected
+    assert delivered and delivered[0] == original
+    assert result == original

{vibego-0.2.38 → vibego-0.2.40}/tests/test_task_description.py

@@ -1,6 +1,7 @@
 import asyncio
 import json
 import os
+import sys
 import time
 from pathlib import Path
 from types import SimpleNamespace
@@ -14,6 +15,10 @@ from aiogram.fsm.storage.base import StorageKey
 from aiogram.fsm.storage.memory import MemoryStorage
 from aiogram.types import InlineKeyboardMarkup, ReplyKeyboardMarkup
 
+ROOT = Path(__file__).resolve().parents[1]
+if str(ROOT) not in sys.path:
+    sys.path.insert(0, str(ROOT))
+
 os.environ.setdefault("BOT_TOKEN", "TEST_TOKEN")
 
 import bot
@@ -758,6 +763,7 @@ def test_bug_report_auto_push_success(monkeypatch, tmp_path: Path):
         reply_to,
         supplement: Optional[str],
         actor: Optional[str],
+        is_bug_report: bool | None = None,
     ):
         assert reply_to is message
         push_calls.append((chat_id, supplement, actor))
@@ -1095,7 +1101,7 @@ def test_task_summary_command_triggers_request(monkeypatch, tmp_path: Path):
     assert dispatch_calls, "应向模型推送摘要请求"
     prompt_text = dispatch_calls[0][1]
     assert prompt_text.startswith(
-        "进入摘要阶段...\n任务编码：/TASK\\_0200\nSUMMARY_REQUEST_ID::"
+        "进入摘要阶段...\n任务编码：/TASK_0200\nSUMMARY_REQUEST_ID::"
     )
     assert message.calls, "应向用户提示处理结果"
     reply_text, _, _, _ = message.calls[-1]

vibego-0.2.40/tests/test_telegram_markdown_renderer.py

@@ -0,0 +1,44 @@
+import sys
+import os
+from pathlib import Path
+
+sys.path.append(str(Path(__file__).resolve().parents[1]))
+
+import pytest
+
+os.environ.setdefault("BOT_TOKEN", "dummy")
+os.environ.setdefault("TELEGRAM_PARSE_MODE", "Markdown")
+
+from bot import _prepare_model_payload, _prepare_model_payload_variants  # noqa: E402
+
+
+@pytest.mark.parametrize(
+    ("source", "expected"),
+    [
+        ("**bold** text", "*bold* text"),
+        ("__italic__", "_italic_"),
+        ("`code_snippet`", "`code_snippet`"),
+        ("普通文本 (test)", "普通文本 (test)"),
+        ("raw *literal* star", "raw *literal* star"),
+        ("multiline\nline2", "multiline\nline2"),
+    ],
+)
+def test_prepare_model_payload_markdown(source: str, expected: str) -> None:
+    assert _prepare_model_payload(source) == expected
+
+
+def test_prepare_model_payload_preserves_checklist() -> None:
+    text = "- [ ] 第一项\n- [ ] 第二项"
+    assert _prepare_model_payload(text) == text
+
+
+def test_prepare_model_payload_handles_list_numbers() -> None:
+    text = "1. 选择 A\n2. 选择 B"
+    assert _prepare_model_payload(text) == text
+
+
+def test_prepare_model_payload_variants_returns_single_payload() -> None:
+    text = "纯文本内容"
+    primary, fallback = _prepare_model_payload_variants(text)
+    assert primary == "纯文本内容"
+    assert fallback is None

{vibego-0.2.38 → vibego-0.2.40}/tests/test_unescape_markdown.py

@@ -30,7 +30,7 @@ def test_is_already_escaped():
         ("hello_world", False, "普通下划线"),
         ("**粗体**", False, "未转义的粗体"),
         ("短文本", False, "太短的文本"),
-        (r"\*", False, "单个转义字符密度不够"),
+        (r"\*", True, "单个转义字符也应识别为已转义"),
     ]
 
     passed = 0
@@ -171,7 +171,7 @@ def test_edge_cases():
         ("   ", "   ", "仅空格"),
         (None, None, "None 值"),  # 需要处理 None
         ("正常文本无需处理", "正常文本无需处理", "未检测到预转义"),
-        (r"\*", r"\*", "单个转义字符（密度不够）"),
+        (r"\*", "*", "单个转义字符同样需要反转义"),
         (r"```\n\n```", r"```\n\n```", "空代码块"),
         (r"`单独的反引号", r"`单独的反引号", "不匹配的反引号"),
         (r"混合 **未转义** 和 \*\*已转义\*\*", r"混合 **未转义** 和 **已转义**", "混合转义状态"),

{vibego-0.2.38 → vibego-0.2.40}/vibego.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: vibego
-Version: 0.2.38
+Version: 0.2.40
 Summary: vibego CLI：用于初始化与管理 Telegram Master Bot 的工具
 Author: Hypha
 License-Expression: LicenseRef-Proprietary

{vibego-0.2.38 → vibego-0.2.40}/vibego.egg-info/SOURCES.txt

@@ -430,7 +430,6 @@ tasks/constants.py
 tasks/fsm.py
 tasks/models.py
 tasks/service.py
-telegram_markdown/__init__.py
 tests/test_auto_compact.py
 tests/test_chat_menu_buttons.py
 tests/test_claudecode_jsonl.py

{vibego-0.2.38 → vibego-0.2.40}/vibego.egg-info/top_level.txt

@@ -4,5 +4,4 @@ master
 project_repository
 scripts
 tasks
-telegram_markdown
 vibego_cli

{vibego-0.2.38 → vibego-0.2.40}/vibego_cli/__init__.py

@@ -7,6 +7,6 @@ from __future__ import annotations
 
 __all__ = ["main", "__version__"]
 
-__version__ = "0.2.38"
+__version__ = "0.2.40"
 
 from .main import main  # noqa: E402