comate-cli 0.7.0a2__tar.gz → 0.7.0a4__tar.gz

{comate_cli-0.7.0a2 → comate_cli-0.7.0a4}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: comate-cli
-Version: 0.7.0a2
+Version: 0.7.0a4
 Summary: Comate terminal CLI built on comate-agent-sdk
 Project-URL: Homepage, https://github.com/AndyLee1024/agent-sdk
 Project-URL: Repository, https://github.com/AndyLee1024/agent-sdk

{comate_cli-0.7.0a2 → comate_cli-0.7.0a4}/comate_cli/terminal_agent/mention_completer.py

@@ -3,8 +3,9 @@ from __future__ import annotations
 import os
 import re
 import subprocess
+import threading
 import time
-from collections.abc import Iterable
+from collections.abc import Callable, Iterable
 from dataclasses import dataclass
 from pathlib import Path, PurePosixPath
 
@@ -112,6 +113,9 @@ class LocalFileMentionCompleter(Completer):
 
         self._deep_cache_time: float = 0.0
         self._deep_cached_paths: list[str] = []
+        self._deep_cache_lock = threading.RLock()
+        self._deep_warmup_lock = threading.Lock()
+        self._deep_warmup_thread: threading.Thread | None = None
         self._directory_cached_paths: dict[str, tuple[float, list[str]]] = {}
 
     @classmethod
@@ -300,16 +304,68 @@ class LocalFileMentionCompleter(Completer):
         return self._top_cached_paths
 
     def _get_deep_paths(self) -> list[str]:
-        now = time.monotonic()
-        if now - self._deep_cache_time <= self._refresh_interval:
-            return self._deep_cached_paths
+        with self._deep_cache_lock:
+            now = time.monotonic()
+            if now - self._deep_cache_time <= self._refresh_interval:
+                return self._deep_cached_paths
 
-        file_paths = self._load_indexed_file_paths()
-        paths = self._build_deep_paths(file_paths)
+            file_paths = self._load_indexed_file_paths()
+            paths = self._build_deep_paths(file_paths)
 
-        self._deep_cached_paths = paths
-        self._deep_cache_time = now
-        return self._deep_cached_paths
+            self._deep_cached_paths = paths
+            self._deep_cache_time = time.monotonic()
+            return self._deep_cached_paths
+
+    def start_deep_cache_warmup(
+        self,
+        *,
+        on_complete: Callable[[], None] | None = None,
+    ) -> bool:
+        """Build the deep path cache in a daemon thread if it is stale."""
+        with self._deep_warmup_lock:
+            if (
+                self._deep_warmup_thread is not None
+                and self._deep_warmup_thread.is_alive()
+            ):
+                return False
+
+        with self._deep_cache_lock:
+            now = time.monotonic()
+            if now - self._deep_cache_time <= self._refresh_interval:
+                return False
+
+        def _warm() -> None:
+            try:
+                self._get_deep_paths()
+            except Exception:
+                logger.debug("deep mention cache warmup failed", exc_info=True)
+            finally:
+                with self._deep_warmup_lock:
+                    if self._deep_warmup_thread is threading.current_thread():
+                        self._deep_warmup_thread = None
+                if on_complete is not None:
+                    try:
+                        on_complete()
+                    except Exception:
+                        logger.debug(
+                            "deep mention cache warmup callback failed",
+                            exc_info=True,
+                        )
+
+        thread = threading.Thread(
+            target=_warm,
+            name="comate-mention-index-warmup",
+            daemon=True,
+        )
+        with self._deep_warmup_lock:
+            if (
+                self._deep_warmup_thread is not None
+                and self._deep_warmup_thread.is_alive()
+            ):
+                return False
+            self._deep_warmup_thread = thread
+        thread.start()
+        return True
 
     def _load_indexed_file_paths(self) -> list[str]:
         git_paths = self._get_paths_from_git()

{comate_cli-0.7.0a2 → comate_cli-0.7.0a4}/comate_cli/terminal_agent/tui.py

@@ -329,6 +329,11 @@ class TerminalAgentTUI(
             if self._busy:
                 return
             doc = self._input_area.buffer.document
+            mention_context = self._mention_completer.extract_context(
+                doc.text_before_cursor
+            )
+            if mention_context is not None:
+                self._start_mention_cache_warmup()
             if self._completion_context_active(
                 doc.text_before_cursor,
                 doc.text_after_cursor,
@@ -1325,6 +1330,43 @@ class TerminalAgentTUI(
 
         task.add_done_callback(_done)
 
+    def _start_mention_cache_warmup(self) -> None:
+        mention_completer = getattr(self, "_mention_completer", None)
+        start_warmup = getattr(mention_completer, "start_deep_cache_warmup", None)
+        if not callable(start_warmup):
+            return
+        start_warmup(on_complete=self._on_mention_cache_warmed)
+
+    def _on_mention_cache_warmed(self) -> None:
+        app = self._app
+        if app is None or self._closing:
+            return
+        loop = getattr(app, "loop", None)
+        if loop is None or loop.is_closed():
+            return
+        loop.call_soon_threadsafe(self._restart_active_mention_completion)
+        app.invalidate()
+
+    def _restart_active_mention_completion(self) -> None:
+        if self._closing or self._busy or self._ui_mode != UIMode.NORMAL:
+            return
+        input_area = getattr(self, "_input_area", None)
+        if input_area is None:
+            return
+        buffer = input_area.buffer
+        doc = buffer.document
+        if not self._completion_context_active(
+            doc.text_before_cursor,
+            doc.text_after_cursor,
+        ):
+            return
+        complete_state = buffer.complete_state
+        if complete_state is not None:
+            self._invalidate()
+            return
+        buffer.start_completion(select_first=False)
+        self._invalidate()
+
     def _refresh_layers(self) -> None:
         self._sync_focus_for_mode()
         self._render_dirty = True
@@ -1546,6 +1588,7 @@ class TerminalAgentTUI(
         if self._app is None:
             return
 
+        self._start_mention_cache_warmup()
         self._refresh_layers()
 
         try:

{comate_cli-0.7.0a2 → comate_cli-0.7.0a4}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "hatchling.build"
 
 [project]
 name = "comate-cli"
-version = "0.7.0a2"
+version = "0.7.0a4"
 description = "Comate terminal CLI built on comate-agent-sdk"
 readme = "README.md"
 requires-python = ">=3.11"

comate_cli-0.7.0a4/tests/test_completion_context_activation.py

@@ -0,0 +1,119 @@
+from __future__ import annotations
+
+import tempfile
+import unittest
+from pathlib import Path
+from types import SimpleNamespace
+
+from prompt_toolkit.document import Document
+
+from comate_cli.terminal_agent.mention_completer import LocalFileMentionCompleter
+from comate_cli.terminal_agent.tui import TerminalAgentTUI
+from comate_cli.terminal_agent.tui_parts import UIMode
+
+
+class TestCompletionContextActivation(unittest.TestCase):
+    def setUp(self) -> None:
+        self._tmpdir = tempfile.TemporaryDirectory()
+        self.tui = TerminalAgentTUI.__new__(TerminalAgentTUI)
+        self.tui._mention_completer = LocalFileMentionCompleter(
+            Path(self._tmpdir.name),
+            refresh_interval=0.0,
+            limit=200,
+        )
+
+    def tearDown(self) -> None:
+        self._tmpdir.cleanup()
+
+    def test_slash_completion_requires_cursor_at_end(self) -> None:
+        self.assertTrue(self.tui._completion_context_active("/model", ""))
+        self.assertFalse(self.tui._completion_context_active("/model", " trailing"))
+
+    def test_mention_completion_triggers_at_line_end(self) -> None:
+        self.assertTrue(self.tui._completion_context_active("message @file", ""))
+
+    def test_mention_completion_triggers_at_line_start(self) -> None:
+        self.assertTrue(self.tui._completion_context_active("@file", " message"))
+
+    def test_mention_completion_triggers_in_middle_with_space_boundaries(self) -> None:
+        self.assertTrue(
+            self.tui._completion_context_active("message @file", " message")
+        )
+
+    def test_mention_completion_rejects_middle_without_right_space(self) -> None:
+        self.assertFalse(
+            self.tui._completion_context_active("message @file", "message")
+        )
+
+    def test_mention_completion_rejects_middle_without_left_space(self) -> None:
+        self.assertFalse(
+            self.tui._completion_context_active("message@file", " message")
+        )
+
+    def test_mention_completion_rejects_inside_token_editing(self) -> None:
+        self.assertFalse(
+            self.tui._completion_context_active("message @fi", "le message")
+        )
+
+    def test_mention_cache_warmup_registers_completion_callback(self) -> None:
+        callbacks = []
+
+        class _FakeMentionCompleter:
+            def start_deep_cache_warmup(self, *, on_complete):
+                callbacks.append(on_complete)
+                return True
+
+        self.tui._mention_completer = _FakeMentionCompleter()
+
+        self.tui._start_mention_cache_warmup()
+
+        self.assertEqual(len(callbacks), 1)
+        self.assertTrue(callable(callbacks[0]))
+
+    def test_warmup_callback_does_not_cancel_in_flight_completion(self) -> None:
+        class _FakeBuffer:
+            def __init__(self) -> None:
+                self.document = Document("@测", cursor_position=2)
+                self.complete_state = SimpleNamespace(completions=[])
+                self.start_calls = 0
+
+            def start_completion(self, *, select_first: bool) -> None:
+                del select_first
+                self.start_calls += 1
+
+        buffer = _FakeBuffer()
+        self.tui._closing = False
+        self.tui._busy = False
+        self.tui._ui_mode = UIMode.NORMAL
+        self.tui._app = SimpleNamespace(invalidate=lambda: None)
+        self.tui._input_area = SimpleNamespace(buffer=buffer)
+
+        self.tui._restart_active_mention_completion()
+
+        self.assertEqual(buffer.start_calls, 0)
+
+    def test_warmup_callback_restarts_when_no_completion_is_active(self) -> None:
+        class _FakeBuffer:
+            def __init__(self) -> None:
+                self.document = Document("@测", cursor_position=2)
+                self.complete_state = None
+                self.start_calls = 0
+
+            def start_completion(self, *, select_first: bool) -> None:
+                del select_first
+                self.start_calls += 1
+
+        buffer = _FakeBuffer()
+        self.tui._closing = False
+        self.tui._busy = False
+        self.tui._ui_mode = UIMode.NORMAL
+        self.tui._app = SimpleNamespace(invalidate=lambda: None)
+        self.tui._input_area = SimpleNamespace(buffer=buffer)
+
+        self.tui._restart_active_mention_completion()
+
+        self.assertEqual(buffer.start_calls, 1)
+
+
+if __name__ == "__main__":
+    unittest.main(verbosity=2)

{comate_cli-0.7.0a2 → comate_cli-0.7.0a4}/tests/test_mention_completer.py

@@ -3,6 +3,7 @@ from __future__ import annotations
 import shutil
 import subprocess
 import tempfile
+import threading
 import unittest
 from pathlib import Path
 from unittest.mock import patch
@@ -430,6 +431,77 @@ class TestLocalFileMentionCompleter(unittest.TestCase):
         self.assertEqual(first, second)
         mock_run.assert_called_once()
 
+    def test_deep_cache_warmup_populates_chinese_path_cache(self) -> None:
+        completer = LocalFileMentionCompleter(
+            self.root,
+            refresh_interval=60.0,
+            limit=200,
+        )
+        completed = threading.Event()
+        with patch(
+            "comate_cli.terminal_agent.mention_completer.subprocess.run",
+            return_value=subprocess.CompletedProcess(
+                args=["git"],
+                returncode=0,
+                stdout="Wukong/测试用户.pdf\n",
+                stderr="",
+            ),
+        ) as mock_run:
+            started = completer.start_deep_cache_warmup(
+                on_complete=completed.set
+            )
+            self.assertTrue(started)
+            self.assertTrue(completed.wait(timeout=2.0))
+
+            result = completer.suggest("@测", max_items=16)
+
+        self.assertIsNotNone(result)
+        assert result is not None
+        _, candidates = result
+        self.assertIn("Wukong/测试用户.pdf", candidates)
+        mock_run.assert_called_once()
+
+    def test_deep_cache_warmup_coalesces_concurrent_requests(self) -> None:
+        completer = LocalFileMentionCompleter(
+            self.root,
+            refresh_interval=60.0,
+            limit=200,
+        )
+        entered = threading.Event()
+        release = threading.Event()
+        completed = threading.Event()
+
+        def _run_index_command(
+            *args: object,
+            **kwargs: object,
+        ) -> subprocess.CompletedProcess[str]:
+            del args, kwargs
+            entered.set()
+            self.assertTrue(release.wait(timeout=2.0))
+            return subprocess.CompletedProcess(
+                args=["git"],
+                returncode=0,
+                stdout="Wukong/测试用户.pdf\n",
+                stderr="",
+            )
+
+        with patch(
+            "comate_cli.terminal_agent.mention_completer.subprocess.run",
+            side_effect=_run_index_command,
+        ) as mock_run:
+            first_started = completer.start_deep_cache_warmup(
+                on_complete=completed.set
+            )
+            self.assertTrue(first_started)
+            self.assertTrue(entered.wait(timeout=2.0))
+
+            second_started = completer.start_deep_cache_warmup()
+            release.set()
+            self.assertTrue(completed.wait(timeout=2.0))
+
+        self.assertFalse(second_started)
+        mock_run.assert_called_once()
+
     def test_context_query_prefers_matching_directory_over_deeper_files(self) -> None:
         (self.root / "comate_agent_sdk" / "context").mkdir(parents=True, exist_ok=True)
         (self.root / "comate_agent_sdk" / "context" / "ir.py").write_text("x = 1\n", encoding="utf-8")
@@ -534,6 +606,28 @@ class TestLocalFileMentionCompleter(unittest.TestCase):
         _, candidates = result
         self.assertIn("docs/中文目录/技术文档.md", candidates)
 
+    def test_cjk_person_name_prefixes_find_deep_file_from_first_character(self) -> None:
+        """Claude Code 对齐：中文人名/文件名从第一个字符开始就应该进深度 fuzzy。
+
+        固定三字符闸门会让 `@测`、`@测试` 只查顶层，从而漏掉
+        `Wukong/测试用户.pdf`。这个测试锁住真实用户输入路径。
+        """
+        with patch(
+            "comate_cli.terminal_agent.mention_completer.subprocess.run",
+            return_value=subprocess.CompletedProcess(
+                args=["git"],
+                returncode=0,
+                stdout="Wukong/测试用户.pdf\n",
+                stderr="",
+            ),
+        ):
+            for query in ("@测", "@测试", "@测试用户"):
+                result = self.completer.suggest(query, max_items=16)
+                self.assertIsNotNone(result, f"suggest({query!r}) returned None")
+                assert result is not None
+                _, candidates = result
+                self.assertIn("Wukong/测试用户.pdf", candidates)
+
     def test_short_ascii_query_still_restricted_to_top_level(self) -> None:
         """Bug #2 反向回归：纯 ASCII 短查询仍然走顶层，避免大仓库性能退化。
         即便深度索引里有 src/io_helper.py，2 字符 ASCII 输入也不应进深度。"""

comate_cli-0.7.0a2/tests/test_completion_context_activation.py

@@ -1,56 +0,0 @@
-from __future__ import annotations
-
-import tempfile
-import unittest
-from pathlib import Path
-
-from comate_cli.terminal_agent.mention_completer import LocalFileMentionCompleter
-from comate_cli.terminal_agent.tui import TerminalAgentTUI
-
-
-class TestCompletionContextActivation(unittest.TestCase):
-    def setUp(self) -> None:
-        self._tmpdir = tempfile.TemporaryDirectory()
-        self.tui = TerminalAgentTUI.__new__(TerminalAgentTUI)
-        self.tui._mention_completer = LocalFileMentionCompleter(
-            Path(self._tmpdir.name),
-            refresh_interval=0.0,
-            limit=200,
-        )
-
-    def tearDown(self) -> None:
-        self._tmpdir.cleanup()
-
-    def test_slash_completion_requires_cursor_at_end(self) -> None:
-        self.assertTrue(self.tui._completion_context_active("/model", ""))
-        self.assertFalse(self.tui._completion_context_active("/model", " trailing"))
-
-    def test_mention_completion_triggers_at_line_end(self) -> None:
-        self.assertTrue(self.tui._completion_context_active("message @file", ""))
-
-    def test_mention_completion_triggers_at_line_start(self) -> None:
-        self.assertTrue(self.tui._completion_context_active("@file", " message"))
-
-    def test_mention_completion_triggers_in_middle_with_space_boundaries(self) -> None:
-        self.assertTrue(
-            self.tui._completion_context_active("message @file", " message")
-        )
-
-    def test_mention_completion_rejects_middle_without_right_space(self) -> None:
-        self.assertFalse(
-            self.tui._completion_context_active("message @file", "message")
-        )
-
-    def test_mention_completion_rejects_middle_without_left_space(self) -> None:
-        self.assertFalse(
-            self.tui._completion_context_active("message@file", " message")
-        )
-
-    def test_mention_completion_rejects_inside_token_editing(self) -> None:
-        self.assertFalse(
-            self.tui._completion_context_active("message @fi", "le message")
-        )
-
-
-if __name__ == "__main__":
-    unittest.main(verbosity=2)