comate-cli 0.4.0__tar.gz → 0.4.1__tar.gz

{comate_cli-0.4.0 → comate_cli-0.4.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: comate-cli
-Version: 0.4.0
+Version: 0.4.1
 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.4.0 → comate_cli-0.4.1}/comate_cli/terminal_agent/mention_completer.py

@@ -113,6 +113,7 @@ class LocalFileMentionCompleter(Completer):
 
         self._deep_cache_time: float = 0.0
         self._deep_cached_paths: list[str] = []
+        self._directory_cached_paths: dict[str, tuple[float, list[str]]] = {}
 
     @classmethod
     def _is_ignored(cls, name: str) -> bool:
@@ -146,6 +147,18 @@ class LocalFileMentionCompleter(Completer):
             return None
 
         fragment_lower = context.fragment.lower()
+        directory_source = self._get_directory_candidates(context.fragment)
+        if directory_source is not None:
+            matched = [
+                path
+                for path in directory_source
+                if not fragment_lower or path.lower().startswith(fragment_lower)
+            ]
+            if not matched:
+                return None
+            matched.sort(key=str.lower)
+            return context, matched[: max(max_items, 1)]
+
         source = self._candidate_paths(context.fragment)
         if not source:
             return None
@@ -203,6 +216,62 @@ class LocalFileMentionCompleter(Completer):
             return self._get_top_level_paths()
         return self._get_deep_paths()
 
+    def _get_directory_candidates(self, fragment: str) -> list[str] | None:
+        directory_fragment = self._directory_fragment(fragment)
+        if directory_fragment is None:
+            return None
+        return self._get_directory_paths(directory_fragment)
+
+    def _directory_fragment(self, fragment: str) -> str | None:
+        if "/" not in fragment:
+            return None
+        if fragment.startswith(("/", "~")):
+            return None
+        directory_fragment = fragment if fragment.endswith("/") else fragment.rpartition("/")[0]
+        if directory_fragment in ("", "."):
+            return ""
+        return directory_fragment
+
+    def _get_directory_paths(self, directory_fragment: str) -> list[str]:
+        cache_key = directory_fragment or "."
+        now = time.monotonic()
+        cached = self._directory_cached_paths.get(cache_key)
+        if cached is not None:
+            cached_at, cached_paths = cached
+            if now - cached_at <= self._refresh_interval:
+                return cached_paths
+
+        directory = self._resolve_directory(directory_fragment)
+        if directory is None:
+            return []
+
+        prefix = f"{directory_fragment.rstrip('/')}/" if directory_fragment else ""
+        entries: list[str] = []
+        try:
+            for entry in sorted(directory.iterdir(), key=lambda path: path.name):
+                name = entry.name
+                if self._is_ignored(name):
+                    continue
+                entries.append(f"{prefix}{name}/" if entry.is_dir() else f"{prefix}{name}")
+                if len(entries) >= self._limit:
+                    break
+        except OSError as exc:
+            logger.debug("directory mention scan failed for %s: %s", directory_fragment, exc)
+            return cached[1] if cached is not None else []
+
+        self._directory_cached_paths[cache_key] = (now, entries)
+        return entries
+
+    def _resolve_directory(self, directory_fragment: str) -> Path | None:
+        try:
+            candidate = (self._root / directory_fragment).resolve()
+            candidate.relative_to(self._root.resolve())
+        except (OSError, ValueError):
+            return None
+        if not candidate.is_dir():
+            return None
+        return candidate
+
     def _get_top_level_paths(self) -> list[str]:
         now = time.monotonic()
         if now - self._top_cache_time <= self._refresh_interval:

{comate_cli-0.4.0 → comate_cli-0.4.1}/pyproject.toml

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

{comate_cli-0.4.0 → comate_cli-0.4.1}/tests/test_mention_completer.py

@@ -64,6 +64,40 @@ class TestLocalFileMentionCompleter(unittest.TestCase):
         texts = [completion.text for completion in completions]
         self.assertIn("main.py ", texts)
 
+    def test_directory_prefix_completion_is_not_lost_after_large_tree_scan(self) -> None:
+        for index in range(1200):
+            nested = self.root / "bulk" / f"dir{index}"
+            nested.mkdir(parents=True, exist_ok=True)
+            (nested / f"file{index}.txt").write_text("x", encoding="utf-8")
+
+        target_dir = self.root / "target" / "sub"
+        target_dir.mkdir(parents=True, exist_ok=True)
+        (target_dir / "wanted.py").write_text("pass", encoding="utf-8")
+
+        result = self.completer.suggest("@target/", max_items=8)
+
+        self.assertIsNotNone(result)
+        assert result is not None
+        _, candidates = result
+        self.assertIn("target/sub/", candidates)
+
+    def test_existing_directory_prefix_continues_to_suggest_children(self) -> None:
+        for index in range(1200):
+            nested = self.root / "bulk" / f"dir{index}"
+            nested.mkdir(parents=True, exist_ok=True)
+            (nested / f"file{index}.txt").write_text("x", encoding="utf-8")
+
+        target_dir = self.root / "target" / "sub"
+        target_dir.mkdir(parents=True, exist_ok=True)
+        (target_dir / "wanted.py").write_text("pass", encoding="utf-8")
+
+        result = self.completer.suggest("@target/s", max_items=8)
+
+        self.assertIsNotNone(result)
+        assert result is not None
+        _, candidates = result
+        self.assertIn("target/sub/", candidates)
+
 
 if __name__ == "__main__":
     unittest.main(verbosity=2)