refactor(tools): remove GlobTool

GlobTool is redundant — GrepTool already supports glob-based file
filtering via its `glob` parameter, making a standalone glob-only
tool unnecessary. Removing it simplifies the tool surface and reduces
LLM confusion between glob and grep.

nanobot/agent/tools/search.py

@@ -1,4 +1,4 @@
-"""Search tools: grep and glob."""
+"""Search tools: grep."""
 
 from __future__ import annotations
 
@@ -108,146 +108,6 @@ class _SearchTool(_FsTool):
             for filename in sorted(filenames):
                 yield current / filename
 
-    def _iter_entries(
-        self,
-        root: Path,
-        *,
-        include_files: bool,
-        include_dirs: bool,
-    ) -> Iterable[Path]:
-        if root.is_file():
-            if include_files:
-                yield root
-            return
-
-        for dirpath, dirnames, filenames in os.walk(root):
-            dirnames[:] = sorted(d for d in dirnames if d not in self._IGNORE_DIRS)
-            current = Path(dirpath)
-            if include_dirs:
-                for dirname in dirnames:
-                    yield current / dirname
-            if include_files:
-                for filename in sorted(filenames):
-                    yield current / filename
-
-
-class GlobTool(_SearchTool):
-    """Find files matching a glob pattern."""
-    _scopes = {"core", "subagent"}
-
-    @property
-    def name(self) -> str:
-        return "glob"
-
-    @property
-    def description(self) -> str:
-        return (
-            "Find files matching a glob pattern (e.g. '*.py', 'tests/**/test_*.py'). "
-            "Results are sorted by modification time (newest first). "
-            "Skips .git, node_modules, __pycache__, and other noise directories."
-        )
-
-    @property
-    def read_only(self) -> bool:
-        return True
-
-    @property
-    def parameters(self) -> dict[str, Any]:
-        return {
-            "type": "object",
-            "properties": {
-                "pattern": {
-                    "type": "string",
-                    "description": "Glob pattern to match, e.g. '*.py' or 'tests/**/test_*.py'",
-                    "minLength": 1,
-                },
-                "path": {
-                    "type": "string",
-                    "description": "Directory to search from (default '.')",
-                },
-                "max_results": {
-                    "type": "integer",
-                    "description": "Legacy alias for head_limit",
-                    "minimum": 1,
-                    "maximum": 1000,
-                },
-                "head_limit": {
-                    "type": "integer",
-                    "description": "Maximum number of matches to return (default 250)",
-                    "minimum": 0,
-                    "maximum": 1000,
-                },
-                "offset": {
-                    "type": "integer",
-                    "description": "Skip the first N matching entries before returning results",
-                    "minimum": 0,
-                    "maximum": 100000,
-                },
-                "entry_type": {
-                    "type": "string",
-                    "enum": ["files", "dirs", "both"],
-                    "description": "Whether to match files, directories, or both (default files)",
-                },
-            },
-            "required": ["pattern"],
-        }
-
-    async def execute(
-        self,
-        pattern: str,
-        path: str = ".",
-        max_results: int | None = None,
-        head_limit: int | None = None,
-        offset: int = 0,
-        entry_type: str = "files",
-        **kwargs: Any,
-    ) -> str:
-        try:
-            root = self._resolve(path or ".")
-            if not root.exists():
-                return f"Error: Path not found: {path}"
-            if not root.is_dir():
-                return f"Error: Not a directory: {path}"
-
-            if head_limit is not None:
-                limit = None if head_limit == 0 else head_limit
-            elif max_results is not None:
-                limit = max_results
-            else:
-                limit = _DEFAULT_HEAD_LIMIT
-            include_files = entry_type in {"files", "both"}
-            include_dirs = entry_type in {"dirs", "both"}
-            matches: list[tuple[str, float]] = []
-            for entry in self._iter_entries(
-                root,
-                include_files=include_files,
-                include_dirs=include_dirs,
-            ):
-                rel_path = entry.relative_to(root).as_posix()
-                if _match_glob(rel_path, entry.name, pattern):
-                    display = self._display_path(entry, root)
-                    if entry.is_dir():
-                        display += "/"
-                    try:
-                        mtime = entry.stat().st_mtime
-                    except OSError:
-                        mtime = 0.0
-                    matches.append((display, mtime))
-
-            if not matches:
-                return f"No paths matched pattern '{pattern}' in {path}"
-
-            matches.sort(key=lambda item: (-item[1], item[0]))
-            ordered = [name for name, _ in matches]
-            paged, truncated = _paginate(ordered, limit, offset)
-            result = "\n".join(paged)
-            if note := _pagination_note(limit, offset, truncated):
-                result += f"\n\n{note}"
-            return result
-        except PermissionError as e:
-            return f"Error: {e}"
-        except Exception as e:
-            return f"Error finding files: {e}"
 
 
 class GrepTool(_SearchTool):