feat: Add FileEditTool, GrepTool, GlobTool (Tier 1 RTMP tools)

- FileEditTool: insert, delete, replace operations with regex and backups
- GrepTool: regex search with context lines and file filtering
- GlobTool: pattern matching (**/*.py style) with exclusions

src/tools/file_edit.py

@@ -0,0 +1,255 @@
+"""FileEditTool - Intelligent file editing for Stack 2.9"""
+
+import json
+import os
+import re
+import shutil
+from datetime import datetime
+from pathlib import Path
+from typing import Any, Dict, List, Optional, Tuple
+
+from .base import BaseTool, ToolResult
+from .registry import tool_registry
+
+# Protected paths that should not be edited
+PROTECTED_PATHS = {
+    '/etc', '/usr', '/bin', '/sbin', '/lib', '/System',
+    'C:\\Windows', 'C:\\Program Files', 'C:\\Program Files (x86)',
+    '/System', '/Library', '/Applications'
+}
+
+BACKUP_DIR = Path.home() / ".stack-2.9" / "backups"
+
+
+def _is_protected_path(path: str) -> bool:
+    """Check if path is protected."""
+    abs_path = str(Path(path).resolve())
+    for protected in PROTECTED_PATHS:
+        if abs_path.startswith(protected):
+            return True
+    return False
+
+
+def _create_backup(content: str, file_path: str) -> str:
+    """Create backup of file content."""
+    BACKUP_DIR.mkdir(parents=True, exist_ok=True)
+    timestamp = datetime.now().strftime("%Y%m%d_%H%M%S")
+    backup_name = f"{Path(file_path).name}.{timestamp}.bak"
+    backup_path = BACKUP_DIR / backup_name
+    backup_path.write_text(content)
+    return str(backup_path)
+
+
+class FileEditInsertTool(BaseTool):
+    """Insert content at specific line or after a pattern."""
+
+    name = "file_edit_insert"
+    description = "Insert content at a specific line number or after a pattern"
+
+    input_schema = {
+        "type": "object",
+        "properties": {
+            "path": {"type": "string", "description": "File path to edit"},
+            "content": {"type": "string", "description": "Content to insert"},
+            "line": {"type": "number", "description": "Line number to insert at (1-indexed)"},
+            "after_pattern": {"type": "string", "description": "Or insert after this regex pattern"},
+            "create_backup": {"type": "boolean", "default": True}
+        },
+        "required": ["path", "content"]
+    }
+
+    async def execute(self, path: str, content: str, line: Optional[int] = None, after_pattern: Optional[str] = None, create_backup: bool = True) -> ToolResult:
+        """Insert content into file."""
+        if _is_protected_path(path):
+            return ToolResult(success=False, error="Cannot edit protected path")
+
+        if not Path(path).exists():
+            return ToolResult(success=False, error=f"File not found: {path}")
+
+        original_content = Path(path).read_text()
+        lines = original_content.split('\n')
+
+        if after_pattern:
+            pattern = re.compile(after_pattern)
+            for i, l in enumerate(lines):
+                if pattern.search(l):
+                    lines.insert(i + 1, content)
+                    break
+            else:
+                return ToolResult(success=False, error=f"Pattern not found: {after_pattern}")
+        elif line:
+            if line < 1 or line > len(lines) + 1:
+                return ToolResult(success=False, error=f"Line {line} out of range (1-{len(lines) + 1})")
+            lines.insert(line - 1, content)
+        else:
+            return ToolResult(success=False, error="Must specify line or after_pattern")
+
+        if create_backup:
+            backup_path = _create_backup(original_content, path)
+
+        new_content = '\n'.join(lines)
+        Path(path).write_text(new_content)
+
+        return ToolResult(success=True, data={
+            "path": path,
+            "operation": "insert",
+            "line": line or "after_pattern",
+            "backup": backup_path if create_backup else None
+        })
+
+
+class FileEditDeleteTool(BaseTool):
+    """Delete lines from a file."""
+
+    name = "file_edit_delete"
+    description = "Delete lines from a file"
+
+    input_schema = {
+        "type": "object",
+        "properties": {
+            "path": {"type": "string", "description": "File path"},
+            "line_start": {"type": "number", "description": "Start line (1-indexed)"},
+            "line_end": {"type": "number", "description": "End line (1-indexed, inclusive)"},
+            "pattern": {"type": "string", "description": "Or delete lines matching this regex"},
+            "create_backup": {"type": "boolean", "default": True}
+        },
+        "required": ["path"]
+    }
+
+    async def execute(self, path: str, line_start: Optional[int] = None, line_end: Optional[int] = None, pattern: Optional[str] = None, create_backup: bool = True) -> ToolResult:
+        """Delete lines from file."""
+        if _is_protected_path(path):
+            return ToolResult(success=False, error="Cannot edit protected path")
+
+        if not Path(path).exists():
+            return ToolResult(success=False, error=f"File not found: {path}")
+
+        original_content = Path(path).read_text()
+        lines = original_content.split('\n')
+
+        if pattern:
+            regex = re.compile(pattern)
+            deleted = [i for i, l in enumerate(lines) if regex.search(l)]
+            lines = [l for i, l in enumerate(lines) if i not in deleted]
+            deleted_count = len(deleted)
+        else:
+            if line_start is None or line_end is None:
+                return ToolResult(success=False, error="Must specify line_start/line_end or pattern")
+
+            if line_start < 1 or line_end > len(lines) or line_start > line_end:
+                return ToolResult(success=False, error=f"Invalid line range ({line_start}-{line_end})")
+
+            deleted_count = line_end - line_start + 1
+            lines = lines[:line_start - 1] + lines[line_end:]
+
+        if create_backup:
+            backup_path = _create_backup(original_content, path)
+
+        new_content = '\n'.join(lines)
+        Path(path).write_text(new_content)
+
+        return ToolResult(success=True, data={
+            "path": path,
+            "operation": "delete",
+            "lines_deleted": deleted_count,
+            "backup": backup_path if create_backup else None
+        })
+
+
+class FileEditReplaceTool(BaseTool):
+    """Replace content using regex."""
+
+    name = "file_edit_replace"
+    description = "Replace content using regex pattern"
+
+    input_schema = {
+        "type": "object",
+        "properties": {
+            "path": {"type": "string", "description": "File path"},
+            "pattern": {"type": "string", "description": "Regex pattern to find"},
+            "replacement": {"type": "string", "description": "Replacement text"},
+            "replace_all": {"type": "boolean", "default": False, "description": "Replace all occurrences"},
+            "case_sensitive": {"type": "boolean", "default": True},
+            "create_backup": {"type": "boolean", "default": True}
+        },
+        "required": ["path", "pattern", "replacement"]
+    }
+
+    async def execute(self, path: str, pattern: str, replacement: str, replace_all: bool = False, case_sensitive: bool = True, create_backup: bool = True) -> ToolResult:
+        """Replace content in file."""
+        if _is_protected_path(path):
+            return ToolResult(success=False, error="Cannot edit protected path")
+
+        if not Path(path).exists():
+            return ToolResult(success=False, error=f"File not found: {path}")
+
+        original_content = Path(path).read_text()
+
+        flags = 0 if case_sensitive else re.IGNORECASE
+        regex = re.compile(pattern, flags)
+
+        if replace_all:
+            new_content, count = regex.subn(replacement, original_content)
+        else:
+            match = regex.search(original_content)
+            if not match:
+                return ToolResult(success=False, error=f"Pattern not found: {pattern}")
+            new_content = original_content[:match.start()] + replacement + original_content[match.end():]
+            count = 1
+
+        if create_backup:
+            backup_path = _create_backup(original_content, path)
+
+        Path(path).write_text(new_content)
+
+        return ToolResult(success=True, data={
+            "path": path,
+            "operation": "replace",
+            "replacements": count,
+            "backup": backup_path if create_backup else None
+        })
+
+
+class FileEditTool(BaseTool):
+    """Main file editing tool with multiple operations."""
+
+    name = "file_edit"
+    description = "Edit files with insert, delete, replace operations"
+
+    input_schema = {
+        "type": "object",
+        "properties": {
+            "path": {"type": "string", "description": "File path"},
+            "operation": {
+                "type": "string",
+                "enum": ["insert", "delete", "replace"],
+                "description": "Operation type"
+            },
+            "content": {"type": "string", "description": "Content for insert/replace"},
+            "line_start": {"type": "number", "description": "Start line for delete"},
+            "line_end": {"type": "number", "description": "End line for delete"},
+            "pattern": {"type": "string", "description": "Regex pattern"},
+            "replacement": {"type": "string", "description": "Replacement text"},
+            "replace_all": {"type": "boolean", "default": False},
+            "create_backup": {"type": "boolean", "default": True}
+        },
+        "required": ["path", "operation"]
+    }
+
+    async def execute(self, path: str, operation: str, content: Optional[str] = None, line_start: Optional[int] = None, line_end: Optional[int] = None, pattern: Optional[str] = None, replacement: Optional[str] = None, replace_all: bool = False, create_backup: bool = True) -> ToolResult:
+        """Execute file edit operation."""
+        if operation == "insert" and content:
+            return await FileEditInsertTool().execute(path, content, line=line_start, after_pattern=pattern, create_backup=create_backup)
+        elif operation == "delete":
+            return await FileEditDeleteTool().execute(path, line_start=line_start, line_end=line_end, pattern=pattern, create_backup=create_backup)
+        elif operation == "replace" and pattern and replacement:
+            return await FileEditReplaceTool().execute(path, pattern, replacement, replace_all=replace_all, create_backup=create_backup)
+        else:
+            return ToolResult(success=False, error=f"Invalid operation or missing parameters: {operation}")
+
+
+# Register tools
+tool_registry.register(FileEditInsertTool())
+tool_registry.register(FileEditDeleteTool())
+tool_registry.register(FileEditReplaceTool())
+tool_registry.register(FileEditTool())

src/tools/glob_tool.py

@@ -0,0 +1,223 @@
+"""GlobTool - File pattern matching for Stack 2.9"""
+
+import fnmatch
+import os
+from pathlib import Path
+from typing import Any, Dict, List, Optional
+
+from .base import BaseTool, ToolResult
+from .registry import tool_registry
+
+# Default exclusions
+DEFAULT_EXCLUDES = {
+    '.git', '.svn', '.hg', '__pycache__', 'node_modules', '.venv', 'venv',
+    'env', '.idea', '.vscode', '.DS_Store', '*.pyc', '*.pyo', '*.so',
+    '*.dylib', '.cache', '.pytest_cache', '.mypy_cache', 'dist', 'build',
+    '*.egg-info', '.tox', '.nox'
+}
+
+
+def _should_exclude(path: Path, exclude_patterns: List[str]) -> bool:
+    """Check if path should be excluded."""
+    name = path.name
+
+    # Check default exclusions
+    if name in DEFAULT_EXCLUDES:
+        return True
+
+    # Check custom patterns
+    for pattern in exclude_patterns:
+        if fnmatch.fnmatch(name, pattern) or fnmatch.fnmatch(str(path), pattern):
+            return True
+
+    return False
+
+
+def _glob_pattern_to_regex(pattern: str) -> str:
+    """Convert glob pattern to regex."""
+    # Handle ** for recursive matching
+    regex_parts = []
+    i = 0
+    while i < len(pattern):
+        c = pattern[i]
+        if c == '*':
+            if i + 1 < len(pattern) and pattern[i + 1] == '*':
+                # ** matches everything including /
+                regex_parts.append('.*')
+                i += 2
+            else:
+                # * matches everything except /
+                regex_parts.append('[^/]*')
+                i += 1
+        elif c == '?':
+            regex_parts.append('.')
+            i += 1
+        elif c == '[':
+            # Character class
+            j = i + 1
+            if j < len(pattern) and pattern[j] == '!':
+                regex_parts.append('[^')
+                j += 1
+            else:
+                regex_parts.append('[')
+            while j < len(pattern) and pattern[j] != ']':
+                regex_parts.append(re.escape(pattern[j]))
+                j += 1
+            regex_parts.append(']')
+            i = j + 1
+        else:
+            regex_parts.append(re.escape(c))
+            i += 1
+
+    return ''.join(regex_parts)
+
+
+def _match_glob(path: Path, pattern: str) -> bool:
+    """Check if path matches glob pattern."""
+    import re
+
+    # Normalize pattern - handle **/*.py style patterns
+    if pattern.startswith('**/'):
+        # Recursive pattern
+        regex_pattern = _glob_pattern_to_regex(pattern)
+        regex = re.compile(regex_pattern)
+        return bool(regex.match(str(path))) or bool(regex.match(path.name))
+    elif '**' in pattern:
+        regex_pattern = _glob_pattern_to_regex(pattern)
+        regex = re.compile(regex_pattern)
+        return bool(regex.match(str(path)))
+    else:
+        # Simple pattern
+        return fnmatch.fnmatch(path.name, pattern) or fnmatch.fnmatch(str(path), pattern)
+
+
+class GlobTool(BaseTool):
+    """Find files matching glob patterns."""
+
+    name = "glob"
+    description = "Find files matching glob patterns"
+
+    input_schema = {
+        "type": "object",
+        "properties": {
+            "pattern": {"type": "string", "description": "Glob pattern (e.g., **/*.py, *.js)"},
+            "base_path": {"type": "string", "description": "Base directory to search"},
+            "exclude": {"type": "array", "items": {"type": "string"}, "description": "Patterns to exclude"},
+            "max_results": {"type": "number", "default": 1000, "description": "Maximum results"},
+            "files_only": {"type": "boolean", "default": True, "description": "Only return files"}
+        },
+        "required": ["pattern"]
+    }
+
+    async def execute(self, pattern: str, base_path: Optional[str] = None, exclude: Optional[List[str]] = None, max_results: int = 1000, files_only: bool = True) -> ToolResult:
+        """Find files matching pattern."""
+        if base_path:
+            search_path = Path(base_path)
+        else:
+            search_path = Path.cwd()
+
+        if not search_path.exists():
+            return ToolResult(success=False, error=f"Path not found: {search_path}")
+
+        exclude_patterns = exclude or []
+        matches = []
+        visited_dirs = set()
+
+        def search_dir(dir_path: Path, depth: int = 0):
+            """Recursively search directory."""
+            if str(dir_path) in visited_dirs:
+                return
+            visited_dirs.add(str(dir_path))
+
+            try:
+                for item in dir_path.iterdir():
+                    if _should_exclude(item, exclude_patterns):
+                        continue
+
+                    if item.is_file():
+                        if _match_glob(item, pattern):
+                            matches.append(str(item))
+                            if len(matches) >= max_results:
+                                return True
+                    elif item.is_dir():
+                        # Handle ** pattern
+                        if '**' in pattern:
+                            search_dir(item, depth + 1)
+                        elif depth < 20:  # Limit depth for non-** patterns
+                            search_dir(item, depth + 1)
+            except PermissionError:
+                pass
+
+            return False
+
+        search_dir(search_path)
+
+        return ToolResult(success=True, data={
+            "pattern": pattern,
+            "base_path": str(search_path),
+            "matches": matches,
+            "count": len(matches),
+            "truncated": len(matches) >= max_results
+        })
+
+
+class GlobListTool(BaseTool):
+    """List all files in directory with optional filtering."""
+
+    name = "glob_list"
+    description = "List files in directory with optional pattern filter"
+
+    input_schema = {
+        "type": "object",
+        "properties": {
+            "path": {"type": "string", "description": "Directory path"},
+            "pattern": {"type": "string", "description": "Optional pattern filter"},
+            "recursive": {"type": "boolean", "default": False, "description": "Recursive listing"},
+            "max_results": {"type": "number", "default": 500}
+        },
+        "required": ["path"]
+    }
+
+    async def execute(self, path: str, pattern: Optional[str] = None, recursive: bool = False, max_results: int = 500) -> ToolResult:
+        """List directory contents."""
+        dir_path = Path(path)
+        if not dir_path.exists():
+            return ToolResult(success=False, error=f"Path not found: {path}")
+
+        matches = []
+
+        def search_dir(d: Path, depth: int = 0):
+            if len(matches) >= max_results:
+                return
+
+            try:
+                for item in d.iterdir():
+                    if item.name.startswith('.'):
+                        continue
+
+                    if pattern:
+                        if _match_glob(item, pattern):
+                            matches.append(str(item))
+                    else:
+                        matches.append(str(item))
+
+                    if item.is_dir() and recursive and depth < 10:
+                        search_dir(item, depth + 1)
+
+                    if len(matches) >= max_results:
+                        return
+            except PermissionError:
+                pass
+
+        search_dir(dir_path)
+
+        return ToolResult(success=True, data={
+            "path": str(dir_path),
+            "files": matches,
+            "count": len(matches)
+        })
+
+
+# Register tools
+tool_registry.register(GlobTool())
+tool_registry.register(GlobListTool())

src/tools/grep_tool.py

@@ -0,0 +1,163 @@
+"""GrepTool - Enhanced code search for Stack 2.9"""
+
+import os
+import re
+from pathlib import Path
+from typing import Any, Dict, List, Optional
+
+from .base import BaseTool, ToolResult
+from .registry import tool_registry
+
+
+class GrepTool(BaseTool):
+    """Search files using regex patterns."""
+
+    name = "grep"
+    description = "Search for regex patterns in files"
+
+    input_schema = {
+        "type": "object",
+        "properties": {
+            "pattern": {"type": "string", "description": "Regex pattern to search"},
+            "path": {"type": "string", "description": "Directory or file path to search"},
+            "recursive": {"type": "boolean", "default": True, "description": "Search recursively"},
+            "case_sensitive": {"type": "boolean", "default": True},
+            "context_lines": {"type": "number", "default": 0, "description": "Lines of context before/after"},
+            "file_pattern": {"type": "string", "description": "Filter by file pattern (e.g., *.py, *.js)"},
+            "max_results": {"type": "number", "default": 1000, "description": "Maximum matches to return"}
+        },
+        "required": ["pattern", "path"]
+    }
+
+    async def execute(self, pattern: str, path: str, recursive: bool = True, case_sensitive: bool = True, context_lines: int = 0, file_pattern: Optional[str] = None, max_results: int = 1000) -> ToolResult:
+        """Search for pattern in files."""
+        search_path = Path(path)
+        if not search_path.exists():
+            return ToolResult(success=False, error=f"Path not found: {path}")
+
+        try:
+            regex = re.compile(pattern, 0 if case_sensitive else re.IGNORECASE)
+        except re.error as e:
+            return ToolResult(success=False, error=f"Invalid regex: {e}")
+
+        matches = []
+        visited_dirs = set()
+
+        def matches_pattern(text: str) -> List[str]:
+            """Find all matches in text with line numbers."""
+            results = []
+            for i, line in enumerate(text.split('\n'), 1):
+                if regex.search(line):
+                    results.append((i, line.rstrip()))
+            return results
+
+        def search_file(file_path: Path):
+            """Search a single file."""
+            if file_pattern:
+                if not any(file_path.match(p) for p in file_pattern.split(',')):
+                    return
+
+            try:
+                content = file_path.read_text(errors='ignore')
+            except Exception:
+                return
+
+            for line_num, line_text in matches_pattern(content):
+                match_entry = {
+                    "file": str(file_path),
+                    "line": line_num,
+                    "text": line_text
+                }
+
+                if context_lines > 0:
+                    lines = content.split('\n')
+                    start = max(0, line_num - context_lines - 1)
+                    end = min(len(lines), line_num + context_lines)
+                    match_entry["context"] = {
+                        "before": lines[start:line_num - 1],
+                        "after": lines[line_num:end]
+                    }
+
+                matches.append(match_entry)
+
+                if len(matches) >= max_results:
+                    return True  # Stop searching
+            return False
+
+        def walk_dir(dir_path: Path):
+            """Walk directory tree."""
+            if str(dir_path) in visited_dirs:
+                return
+            visited_dirs.add(str(dir_path))
+
+            try:
+                for item in dir_path.iterdir():
+                    # Skip hidden and common ignore directories
+                    if item.name.startswith('.') or item.name in ('__pycache__', 'node_modules', '.git', 'venv', 'env'):
+                        continue
+
+                    if item.is_file():
+                        if search_file(item):
+                            return True
+                    elif item.is_dir() and recursive:
+                        if walk_dir(item):
+                            return True
+            except PermissionError:
+                pass
+            return False
+
+        walk_dir(search_path)
+
+        return ToolResult(success=True, data={
+            "pattern": pattern,
+            "path": str(path),
+            "matches": matches,
+            "count": len(matches),
+            "truncated": len(matches) >= max_results
+        })
+
+
+class GrepCountTool(BaseTool):
+    """Count occurrences of pattern in files."""
+
+    name = "grep_count"
+    description = "Count occurrences of pattern in files"
+
+    input_schema = {
+        "type": "object",
+        "properties": {
+            "pattern": {"type": "string", "description": "Regex pattern"},
+            "path": {"type": "string", "description": "Directory or file path"},
+            "recursive": {"type": "boolean", "default": True},
+            "case_sensitive": {"type": "boolean", "default": True},
+            "file_pattern": {"type": "string", "description": "Filter by file pattern"}
+        },
+        "required": ["pattern", "path"]
+    }
+
+    async def execute(self, pattern: str, path: str, recursive: bool = True, case_sensitive: bool = True, file_pattern: Optional[str] = None) -> ToolResult:
+        """Count pattern matches."""
+        grep_result = await GrepTool().execute(
+            pattern=pattern,
+            path=path,
+            recursive=recursive,
+            case_sensitive=case_sensitive,
+            file_pattern=file_pattern,
+            max_results=100000
+        )
+
+        counts = {}
+        for match in grep_result.data.get("matches", []):
+            file_path = match["file"]
+            counts[file_path] = counts.get(file_path, 0) + 1
+
+        return ToolResult(success=True, data={
+            "pattern": pattern,
+            "total_matches": len(matches) if (matches := grep_result.data.get("matches", [])) else 0,
+            "by_file": counts
+        })
+
+
+# Register tools
+tool_registry.register(GrepTool())
+tool_registry.register(GrepCountTool())