devorch 0.1.2__py3-none-any.whl

tools/grep.py

@@ -0,0 +1,280 @@
+"""
+Grep Tool - Search for patterns within file contents.
+Similar to ripgrep/grep, optimized for code search.
+"""
+
+import os
+import re
+from dataclasses import dataclass
+from typing import Any
+
+from pydantic import BaseModel, Field
+
+from tools.base import Tool
+
+
+@dataclass
+class GrepMatch:
+    """A single grep match result."""
+
+    file: str
+    line_number: int
+    line_content: str
+    match_start: int
+    match_end: int
+
+
+class GrepToolSchema(BaseModel):
+    pattern: str = Field(..., description="Regex pattern to search for in file contents.")
+    path: str = Field(default=".", description="File or directory to search in.")
+    include: str = Field(default="*", description="File pattern to include (e.g., '*.py', '*.js').")
+    context: int = Field(
+        default=0, description="Number of context lines before and after match (0-5)."
+    )
+    max_results: int = Field(default=50, description="Maximum number of results to return.")
+    case_sensitive: bool = Field(default=True, description="Whether search is case-sensitive.")
+    whole_word: bool = Field(default=False, description="Match whole words only.")
+
+
+class GrepTool(Tool):
+    """
+    Searches for patterns within file contents.
+    Returns matching lines with file paths and line numbers.
+    """
+
+    name = "grep"
+    description = """Search for a pattern within file contents. Returns matching lines with file paths and line numbers.
+Use this to find specific code, functions, variables, or text patterns across files.
+Examples:
+- Search for a function: pattern="def process_data"
+- Search for imports: pattern="from typing import", include="*.py"
+- Search for TODO comments: pattern="TODO|FIXME", include="*.py"
+- Case-insensitive search: pattern="error", case_sensitive=false"""
+    args_schema = GrepToolSchema
+
+    # File extensions to search by default (text files)
+    TEXT_EXTENSIONS = {
+        ".py",
+        ".js",
+        ".ts",
+        ".jsx",
+        ".tsx",
+        ".java",
+        ".c",
+        ".cpp",
+        ".h",
+        ".hpp",
+        ".go",
+        ".rs",
+        ".rb",
+        ".php",
+        ".swift",
+        ".kt",
+        ".scala",
+        ".cs",
+        ".html",
+        ".css",
+        ".scss",
+        ".less",
+        ".vue",
+        ".svelte",
+        ".json",
+        ".yaml",
+        ".yml",
+        ".toml",
+        ".xml",
+        ".md",
+        ".txt",
+        ".rst",
+        ".sh",
+        ".bash",
+        ".zsh",
+        ".fish",
+        ".ps1",
+        ".bat",
+        ".cmd",
+        ".sql",
+        ".graphql",
+        ".proto",
+        ".env",
+        ".gitignore",
+        ".dockerignore",
+        "Dockerfile",
+        "Makefile",
+        ".cfg",
+        ".ini",
+        ".conf",
+        ".config",
+    }
+
+    # Directories to skip
+    SKIP_DIRS = {
+        ".git",
+        ".svn",
+        ".hg",
+        "node_modules",
+        "__pycache__",
+        ".venv",
+        "venv",
+        "env",
+        ".env",
+        "dist",
+        "build",
+        ".next",
+        ".nuxt",
+        "target",
+        "out",
+        ".idea",
+        ".vscode",
+        ".pytest_cache",
+        ".mypy_cache",
+        "coverage",
+        "htmlcov",
+        ".tox",
+        "eggs",
+        "*.egg-info",
+    }
+
+    def _should_search_file(self, filepath: str, include_pattern: str) -> bool:
+        """Check if file should be searched based on extension and pattern."""
+        filename = os.path.basename(filepath)
+        ext = os.path.splitext(filename)[1].lower()
+
+        # Check include pattern
+        if include_pattern != "*":
+            import fnmatch
+
+            if not fnmatch.fnmatch(filename, include_pattern):
+                return False
+
+        # Check if it's a text file
+        if ext and ext not in self.TEXT_EXTENSIONS:
+            # Allow files without extension if they match pattern
+            if ext:
+                return False
+
+        return True
+
+    def _should_skip_dir(self, dirname: str) -> bool:
+        """Check if directory should be skipped."""
+        return dirname in self.SKIP_DIRS or dirname.startswith(".")
+
+    def _search_file(
+        self, filepath: str, regex: re.Pattern, context: int, max_results: int, current_results: int
+    ) -> list[dict]:
+        """Search a single file for matches."""
+        results = []
+
+        try:
+            with open(filepath, encoding="utf-8", errors="ignore") as f:
+                lines = f.readlines()
+
+            for i, line in enumerate(lines):
+                if current_results + len(results) >= max_results:
+                    break
+
+                match = regex.search(line)
+                if match:
+                    result = {
+                        "file": filepath,
+                        "line": i + 1,
+                        "content": line.rstrip("\n\r"),
+                        "match": match.group(),
+                    }
+
+                    # Add context lines if requested
+                    if context > 0:
+                        context_before = []
+                        context_after = []
+
+                        for j in range(max(0, i - context), i):
+                            context_before.append(f"{j + 1}: {lines[j].rstrip()}")
+
+                        for j in range(i + 1, min(len(lines), i + context + 1)):
+                            context_after.append(f"{j + 1}: {lines[j].rstrip()}")
+
+                        if context_before:
+                            result["context_before"] = context_before
+                        if context_after:
+                            result["context_after"] = context_after
+
+                    results.append(result)
+
+        except Exception:
+            pass  # Skip files that can't be read
+
+        return results
+
+    def run(self, arguments: dict[str, Any]) -> Any:
+        pattern = arguments.get("pattern")
+        path = arguments.get("path", ".")
+        include = arguments.get("include", "*")
+        context = min(arguments.get("context", 0), 5)  # Max 5 context lines
+        max_results = min(arguments.get("max_results", 50), 100)  # Max 100 results
+        case_sensitive = arguments.get("case_sensitive", True)
+        whole_word = arguments.get("whole_word", False)
+
+        if not pattern:
+            return "Error: Pattern not provided."
+
+        # Build regex
+        try:
+            if whole_word:
+                pattern = rf"\b{pattern}\b"
+
+            flags = 0 if case_sensitive else re.IGNORECASE
+            regex = re.compile(pattern, flags)
+        except re.error as e:
+            return f"Error: Invalid regex pattern - {e}"
+
+        results = []
+
+        # Handle single file
+        if os.path.isfile(path):
+            results = self._search_file(path, regex, context, max_results, 0)
+        # Handle directory
+        elif os.path.isdir(path):
+            for root, dirs, files in os.walk(path):
+                # Skip certain directories
+                dirs[:] = [d for d in dirs if not self._should_skip_dir(d)]
+
+                for filename in files:
+                    if len(results) >= max_results:
+                        break
+
+                    filepath = os.path.join(root, filename)
+
+                    if self._should_search_file(filepath, include):
+                        file_results = self._search_file(
+                            filepath, regex, context, max_results, len(results)
+                        )
+                        results.extend(file_results)
+
+                if len(results) >= max_results:
+                    break
+        else:
+            return f"Error: Path '{path}' not found."
+
+        if not results:
+            return f"No matches found for pattern: {pattern}"
+
+        # Format output
+        output_lines = [f"Found {len(results)} match(es):\n"]
+
+        for r in results:
+            # Format: file:line: content
+            output_lines.append(f"{r['file']}:{r['line']}: {r['content']}")
+
+            if "context_before" in r:
+                for ctx in r["context_before"]:
+                    output_lines.append(f"  {ctx}")
+                output_lines.append(f"  {r['line']}: {r['content']}  <-- match")
+            if "context_after" in r:
+                for ctx in r["context_after"]:
+                    output_lines.append(f"  {ctx}")
+                output_lines.append("")
+
+        if len(results) >= max_results:
+            output_lines.append(f"\n(Results truncated at {max_results})")
+
+        return "\n".join(output_lines)

tools/search.py

@@ -0,0 +1,150 @@
+import glob
+import os
+from typing import Any
+
+from pydantic import BaseModel, Field
+
+from tools.base import Tool
+
+
+class SearchToolSchema(BaseModel):
+    pattern: str = Field(..., description="Glob pattern (e.g., '*.py', 'test_*.js', '**/*.md').")
+    directory: str = Field(default=".", description="Directory to search in.")
+    type: str = Field(default="all", description="Filter: 'file', 'dir', or 'all'.")
+    max_results: int = Field(default=100, description="Maximum number of results.")
+    include_hidden: bool = Field(default=False, description="Include hidden files/directories.")
+
+
+class SearchTool(Tool):
+    name = "search"
+    description = """Search for files and directories matching a glob pattern.
+
+Examples:
+- Find Python files: pattern="*.py"
+- Find test files: pattern="test_*.py"
+- Find all in subdirs: pattern="**/*.js"
+- Find specific file: pattern="**/config.yaml"
+- Find directories: pattern="**/tests", type="dir"
+- Find markdown docs: pattern="**/*.md", directory="docs"
+
+Common patterns:
+- *.ext - Files with extension in current dir
+- **/*.ext - Files with extension in all subdirs
+- **/name - File/dir with exact name in all subdirs
+- prefix* - Files starting with prefix
+- *suffix - Files ending with suffix"""
+    args_schema = SearchToolSchema
+
+    # Directories to skip by default
+    SKIP_DIRS = {
+        ".git",
+        ".svn",
+        ".hg",
+        "node_modules",
+        "__pycache__",
+        ".venv",
+        "venv",
+        "env",
+        ".env",
+        "dist",
+        "build",
+        ".next",
+        ".nuxt",
+        "target",
+        "out",
+        ".idea",
+        ".vscode",
+        ".pytest_cache",
+        ".mypy_cache",
+    }
+
+    def _filter_results(
+        self, matches: list[str], type_filter: str, include_hidden: bool, max_results: int
+    ) -> list[str]:
+        """Filter and limit results."""
+        filtered = []
+
+        for match in matches:
+            # Skip hidden unless requested
+            if not include_hidden:
+                parts = match.replace("\\", "/").split("/")
+                if any(p.startswith(".") and p not in (".", "..") for p in parts):
+                    continue
+
+                # Skip common ignored directories
+                if any(skip in parts for skip in self.SKIP_DIRS):
+                    continue
+
+            # Type filter
+            if type_filter == "file" and not os.path.isfile(match):
+                continue
+            if type_filter == "dir" and not os.path.isdir(match):
+                continue
+
+            filtered.append(match)
+
+            if len(filtered) >= max_results:
+                break
+
+        return filtered
+
+    def run(self, arguments: dict[str, Any]) -> Any:
+        pattern = arguments.get("pattern")
+        directory = arguments.get("directory", ".")
+        type_filter = arguments.get("type", "all").lower()
+        max_results = min(arguments.get("max_results", 100), 500)
+        include_hidden = arguments.get("include_hidden", False)
+
+        if not pattern:
+            return "Error: Pattern not provided."
+
+        if not os.path.isdir(directory):
+            return f"Error: Directory '{directory}' not found."
+
+        try:
+            # Handle different pattern formats
+            if pattern.startswith("**/"):
+                search_path = os.path.join(directory, pattern)
+            elif "**" in pattern:
+                search_path = os.path.join(directory, pattern)
+            else:
+                # Search recursively by default
+                search_path = os.path.join(directory, "**", pattern)
+
+            matches = glob.glob(search_path, recursive=True)
+
+            # Filter results
+            filtered = self._filter_results(matches, type_filter, include_hidden, max_results)
+
+            if not filtered:
+                return f"No files found matching: {pattern}"
+
+            # Format output with file info
+            output_lines = [f"Found {len(filtered)} result(s):\n"]
+
+            for match in filtered:
+                # Normalize path
+                rel_path = os.path.relpath(match, directory) if directory != "." else match
+
+                if os.path.isdir(match):
+                    output_lines.append(f"  [DIR]  {rel_path}/")
+                else:
+                    try:
+                        size = os.path.getsize(match)
+                        if size < 1024:
+                            size_str = f"{size}B"
+                        elif size < 1024 * 1024:
+                            size_str = f"{size // 1024}KB"
+                        else:
+                            size_str = f"{size // (1024 * 1024)}MB"
+                        output_lines.append(f"  {size_str:>6}  {rel_path}")
+                    except Exception:
+                        output_lines.append(f"  {'?':>6}  {rel_path}")
+
+            if len(matches) > max_results:
+                output_lines.append(f"\n(Showing {max_results} of {len(matches)} results)")
+
+            return "\n".join(output_lines)
+
+        except Exception as e:
+            return f"Search error: {str(e)}"

tools/shell.py

@@ -0,0 +1,55 @@
+import subprocess
+from typing import Any
+
+from pydantic import BaseModel, Field
+
+from tools.base import Tool
+
+
+class ShellToolSchema(BaseModel):
+    command: str = Field(..., description="The shell command to execute.")
+
+
+class ShellTool(Tool):
+    name = "shell"
+    description = """\
+Executes a shell command and captures its output.
+
+Use this for short-lived commands that return output, such as:
+- Package management: `npm install`, `pip install`, `cargo build`
+- Version control: `git status`, `git add`, `git commit`, `git clone`
+- File operations: `mkdir`, `cp`, `mv`, `rm`
+- Inspecting output: `cat`, `echo`, `pwd`, `ls`
+
+For long-running servers or interactive scaffold tools, use `open_terminal` instead."""
+    args_schema = ShellToolSchema
+
+    def run(self, arguments: dict[str, Any]) -> Any:
+        try:
+            command = arguments.get("command")
+            if not command:
+                return "Error: No command provided."
+
+            result = subprocess.run(
+                command,
+                shell=True,
+                capture_output=True,
+                text=True,
+                check=False,
+                timeout=120,
+                encoding="utf-8",
+                errors="replace",
+            )
+
+            output = ""
+            if result.stdout:
+                output += f"STDOUT:\n{result.stdout}\n"
+            if result.stderr:
+                output += f"STDERR:\n{result.stderr}\n"
+
+            return output if output else f"Command completed with exit code {result.returncode}."
+
+        except subprocess.TimeoutExpired:
+            return "Error: Command timed out after 120 seconds."
+        except Exception as e:
+            return f"Failed to execute command: {str(e)}"

tools/task.py

@@ -0,0 +1,91 @@
+"""Task tool for AI to track work progress."""
+
+from typing import Any
+
+from pydantic import BaseModel, Field
+
+from core.tasks import get_task_manager
+from tools.base import Tool
+
+
+class TaskItem(BaseModel):
+    """A single task item."""
+
+    content: str = Field(
+        ..., description="What needs to be done (imperative form, e.g., 'Run tests')"
+    )
+    status: str = Field("pending", description="Task status: pending, in_progress, or completed")
+    activeForm: str = Field(
+        ..., description="Present continuous form shown during execution (e.g., 'Running tests')"
+    )
+
+
+class TaskToolSchema(BaseModel):
+    """Schema for the task tool."""
+
+    todos: list[TaskItem] = Field(..., description="The updated todo list with all tasks")
+
+
+class TaskTool(Tool):
+    """
+    Tool for AI to manage a task list and track progress.
+
+    Use this tool to:
+    - Create a task list when starting multi-step work
+    - Update task status as you complete items
+    - Show the user what you're working on
+
+    Guidelines:
+    - Only ONE task should be 'in_progress' at a time
+    - Mark tasks 'completed' immediately after finishing
+    - Content should be imperative (e.g., "Fix bug")
+    - ActiveForm should be present continuous (e.g., "Fixing bug")
+    """
+
+    name = "task"
+    description = """Create and manage a task list to track progress on multi-step work.
+Use this when:
+- Working on tasks with 3+ steps
+- User provides multiple items to do
+- You want to show progress to the user
+
+Task status options: pending, in_progress, completed
+Only ONE task should be in_progress at a time."""
+
+    args_schema = TaskToolSchema
+
+    def run(self, arguments: dict[str, Any]) -> str:
+        """Execute the task tool."""
+        todos = arguments.get("todos", [])
+
+        if not todos:
+            return "No tasks provided."
+
+        # Convert to list of dicts if needed
+        task_list = []
+        for item in todos:
+            if isinstance(item, dict):
+                task_list.append(item)
+            else:
+                # Pydantic model
+                task_list.append(
+                    {
+                        "content": item.content,
+                        "status": item.status,
+                        "activeForm": item.activeForm,
+                    }
+                )
+
+        # Update task manager
+        task_manager = get_task_manager()
+        task_manager.set_tasks(task_list)
+
+        # Return summary
+        completed = sum(1 for t in task_list if t.get("status") == "completed")
+        in_progress = sum(1 for t in task_list if t.get("status") == "in_progress")
+        pending = sum(1 for t in task_list if t.get("status") == "pending")
+
+        current = next((t for t in task_list if t.get("status") == "in_progress"), None)
+        current_text = f" Current: {current['activeForm']}" if current else ""
+
+        return f"Tasks updated: {completed} completed, {in_progress} in progress, {pending} pending.{current_text}"

tools/terminal.py

@@ -0,0 +1,123 @@
+import os
+import subprocess
+import sys
+from typing import Any
+
+from pydantic import BaseModel, Field
+
+from tools.base import Tool
+
+
+class OpenTerminalSchema(BaseModel):
+    command: str = Field(
+        ...,
+        description=(
+            "The command to run in a new terminal window. "
+            "Use this for long-running servers (npm run dev, vite, uvicorn, flask run, etc.), "
+            "interactive scaffold tools (npm create, npx create-*, ng new, etc.), "
+            "or anything else that would block the main session if run normally."
+        ),
+    )
+
+
+class OpenTerminalTool(Tool):
+    name = "open_terminal"
+    description = """\
+Opens a new terminal window and runs the given command inside it.
+
+Use this tool whenever you need to:
+- Start a development server or daemon (e.g. `npm run dev`, `vite`, `uvicorn app:main`, `flask run`, `next dev`)
+- Run an interactive scaffold that prompts the user (e.g. `npm create vite@latest`, `npx create-next-app`, `ng new myapp`)
+- Run any long-running process that should NOT block the current session
+
+The main DevOrch session remains fully interactive while the command runs in its own window.
+After calling this tool, continue the conversation normally — do NOT wait for the command to finish."""
+    args_schema = OpenTerminalSchema
+
+    def run(self, arguments: dict[str, Any]) -> Any:
+        command = arguments.get("command", "").strip()
+        if not command:
+            return "Error: No command provided."
+
+        working_dir = os.getcwd()
+        system = sys.platform
+
+        try:
+            if system == "win32":
+                subprocess.Popen(
+                    ["cmd", "/c", "start", "cmd", "/k", command],
+                    cwd=working_dir,
+                )
+                return (
+                    f"✓ Opened new terminal window\n\n"
+                    f"Command: {command}\n\n"
+                    f"The command is now running in a separate window. "
+                    f"You can continue the conversation here."
+                )
+
+            elif system == "darwin":
+                escaped_command = command.replace('"', '\\"')
+                escaped_dir = working_dir.replace('"', '\\"')
+                subprocess.Popen(
+                    [
+                        "osascript",
+                        "-e",
+                        f'tell app "Terminal" to do script "cd \\"{escaped_dir}\\" && {escaped_command}"',
+                    ]
+                )
+                return (
+                    f"✓ Opened new Terminal window\n\n"
+                    f"Command: {command}\n\n"
+                    f"The command is now running in a separate window. "
+                    f"You can continue the conversation here."
+                )
+
+            else:
+                # Linux: try common terminal emulators in order
+                terminals = [
+                    [
+                        "gnome-terminal",
+                        "--working-directory",
+                        working_dir,
+                        "--",
+                        "bash",
+                        "-c",
+                        f"{command}; exec bash",
+                    ],
+                    ["konsole", "--workdir", working_dir, "-e", f"bash -c '{command}; exec bash'"],
+                    ["xterm", "-e", f"bash -c 'cd \"{working_dir}\" && {command}; exec bash'"],
+                    [
+                        "x-terminal-emulator",
+                        "-e",
+                        f"bash -c 'cd \"{working_dir}\" && {command}; exec bash'",
+                    ],
+                ]
+                for term_cmd in terminals:
+                    try:
+                        subprocess.Popen(term_cmd)
+                        return (
+                            f"✓ Opened new terminal window\n\n"
+                            f"Command: {command}\n\n"
+                            f"The command is now running in a separate window. "
+                            f"You can continue the conversation here."
+                        )
+                    except FileNotFoundError:
+                        continue
+
+                # Fallback: background process
+                process = subprocess.Popen(
+                    command,
+                    shell=True,
+                    stdout=subprocess.DEVNULL,
+                    stderr=subprocess.DEVNULL,
+                    start_new_session=True,
+                    cwd=working_dir,
+                )
+                return (
+                    f"✓ Started in background (PID: {process.pid})\n\n"
+                    f"Command: {command}\n\n"
+                    f"Note: No GUI terminal emulator found — process is running in the background."
+                )
+
+        except Exception as e:
+            return f"Error opening terminal: {str(e)}\n\nRun manually: {command}"