nc1709 1.15.4__py3-none-any.whl

nc1709/agent/tools/search_tools.py

@@ -0,0 +1,322 @@
+"""
+Search Tools
+
+Tools for searching file contents:
+- Grep: Search for patterns in files
+"""
+
+import re
+import subprocess
+from pathlib import Path
+from typing import Optional, List
+
+from .base import Tool, ToolResult, ToolParameter, ToolPermission
+
+
+class GrepTool(Tool):
+    """Search for patterns in files"""
+
+    name = "Grep"
+    description = (
+        "Search for a pattern in files using regex. "
+        "Returns matching lines with file paths and line numbers. "
+        "Supports full regex syntax."
+    )
+    category = "search"
+    permission = ToolPermission.AUTO  # Safe to auto-execute
+
+    parameters = [
+        ToolParameter(
+            name="pattern",
+            description="Regular expression pattern to search for",
+            type="string",
+            required=True,
+        ),
+        ToolParameter(
+            name="path",
+            description="File or directory to search in (defaults to current directory)",
+            type="string",
+            required=False,
+            default=".",
+        ),
+        ToolParameter(
+            name="glob",
+            description="Glob pattern to filter files (e.g., '*.py', '*.ts')",
+            type="string",
+            required=False,
+        ),
+        ToolParameter(
+            name="case_insensitive",
+            description="Perform case-insensitive search",
+            type="boolean",
+            required=False,
+            default=False,
+        ),
+        ToolParameter(
+            name="context_lines",
+            description="Number of context lines to show before and after matches",
+            type="integer",
+            required=False,
+            default=0,
+        ),
+        ToolParameter(
+            name="max_results",
+            description="Maximum number of results to return",
+            type="integer",
+            required=False,
+            default=50,
+        ),
+    ]
+
+    def execute(
+        self,
+        pattern: str,
+        path: str = ".",
+        glob: str = None,
+        case_insensitive: bool = False,
+        context_lines: int = 0,
+        max_results: int = 50,
+    ) -> ToolResult:
+        """Search for pattern in files"""
+
+        base_path = Path(path).expanduser()
+
+        if not base_path.exists():
+            return ToolResult(
+                success=False,
+                output="",
+                error=f"Path not found: {path}",
+                target=pattern,
+            )
+
+        try:
+            # Compile regex
+            flags = re.IGNORECASE if case_insensitive else 0
+            try:
+                regex = re.compile(pattern, flags)
+            except re.error as e:
+                return ToolResult(
+                    success=False,
+                    output="",
+                    error=f"Invalid regex pattern: {e}",
+                    target=pattern,
+                )
+
+            # Find files to search
+            if base_path.is_file():
+                files = [base_path]
+            else:
+                if glob:
+                    files = list(base_path.glob(f"**/{glob}"))
+                else:
+                    # Search common code files by default
+                    files = []
+                    for ext in ["*.py", "*.js", "*.ts", "*.tsx", "*.jsx", "*.go", "*.rs",
+                               "*.java", "*.c", "*.cpp", "*.h", "*.hpp", "*.md", "*.txt",
+                               "*.json", "*.yaml", "*.yml", "*.toml", "*.sh", "*.bash"]:
+                        files.extend(base_path.glob(f"**/{ext}"))
+
+                files = [f for f in files if f.is_file()]
+
+            # Skip binary files and very large files
+            max_file_size = 1_000_000  # 1MB
+            text_files = []
+            for f in files:
+                try:
+                    if f.stat().st_size <= max_file_size:
+                        text_files.append(f)
+                except OSError:
+                    continue
+
+            # Search files
+            results = []
+            total_matches = 0
+
+            for file_path in text_files:
+                if total_matches >= max_results:
+                    break
+
+                try:
+                    with open(file_path, "r", encoding="utf-8", errors="replace") as f:
+                        lines = f.readlines()
+
+                    for i, line in enumerate(lines):
+                        if regex.search(line):
+                            total_matches += 1
+
+                            # Get context
+                            start = max(0, i - context_lines)
+                            end = min(len(lines), i + context_lines + 1)
+
+                            context = []
+                            for j in range(start, end):
+                                prefix = ">" if j == i else " "
+                                context.append(f"{prefix} {j+1:4}: {lines[j].rstrip()}")
+
+                            rel_path = file_path.relative_to(base_path) if file_path.is_relative_to(base_path) else file_path
+                            results.append({
+                                "file": str(rel_path),
+                                "line": i + 1,
+                                "content": line.rstrip(),
+                                "context": "\n".join(context) if context_lines > 0 else None,
+                            })
+
+                            if total_matches >= max_results:
+                                break
+
+                except (OSError, UnicodeDecodeError):
+                    continue
+
+            # Format output
+            if not results:
+                return ToolResult(
+                    success=True,
+                    output=f"No matches found for pattern: {pattern}",
+                    target=pattern,
+                    data={"count": 0, "matches": []},
+                )
+
+            output_lines = [f"Found {len(results)} match(es) for '{pattern}':"]
+            for r in results:
+                output_lines.append(f"\n{r['file']}:{r['line']}")
+                if r.get("context"):
+                    output_lines.append(r["context"])
+                else:
+                    output_lines.append(f"  {r['content'][:200]}")
+
+            if total_matches >= max_results:
+                output_lines.append(f"\n... (limited to {max_results} results)")
+
+            return ToolResult(
+                success=True,
+                output="\n".join(output_lines),
+                target=pattern,
+                data={"count": len(results), "matches": results},
+            )
+
+        except Exception as e:
+            return ToolResult(
+                success=False,
+                output="",
+                error=f"Error searching: {e}",
+                target=pattern,
+            )
+
+
+class RipgrepTool(Tool):
+    """Fast search using ripgrep (if available)"""
+
+    name = "Ripgrep"
+    description = (
+        "Fast file search using ripgrep (rg). "
+        "Falls back to Python grep if ripgrep is not installed."
+    )
+    category = "search"
+    permission = ToolPermission.AUTO
+
+    parameters = [
+        ToolParameter(
+            name="pattern",
+            description="Search pattern (regex)",
+            type="string",
+            required=True,
+        ),
+        ToolParameter(
+            name="path",
+            description="Path to search in",
+            type="string",
+            required=False,
+            default=".",
+        ),
+        ToolParameter(
+            name="type",
+            description="File type to search (e.g., 'py', 'js', 'ts')",
+            type="string",
+            required=False,
+        ),
+        ToolParameter(
+            name="case_insensitive",
+            description="Case-insensitive search",
+            type="boolean",
+            required=False,
+            default=False,
+        ),
+    ]
+
+    def execute(
+        self,
+        pattern: str,
+        path: str = ".",
+        type: str = None,
+        case_insensitive: bool = False,
+    ) -> ToolResult:
+        """Search using ripgrep"""
+
+        # Build command
+        cmd = ["rg", "--line-number", "--no-heading", "--color=never"]
+
+        if case_insensitive:
+            cmd.append("-i")
+
+        if type:
+            cmd.extend(["-t", type])
+
+        cmd.extend(["--max-count=100", pattern, path])
+
+        try:
+            result = subprocess.run(
+                cmd,
+                capture_output=True,
+                text=True,
+                timeout=30,
+            )
+
+            if result.returncode == 0:
+                output = result.stdout
+                lines = output.strip().split("\n") if output.strip() else []
+                return ToolResult(
+                    success=True,
+                    output=output if output else "No matches found",
+                    target=pattern,
+                    data={"count": len(lines)},
+                )
+            elif result.returncode == 1:
+                # No matches
+                return ToolResult(
+                    success=True,
+                    output="No matches found",
+                    target=pattern,
+                    data={"count": 0},
+                )
+            else:
+                return ToolResult(
+                    success=False,
+                    output="",
+                    error=result.stderr or "ripgrep error",
+                    target=pattern,
+                )
+
+        except FileNotFoundError:
+            # ripgrep not installed, fall back to grep tool
+            grep = GrepTool()
+            return grep.execute(pattern=pattern, path=path, case_insensitive=case_insensitive)
+        except subprocess.TimeoutExpired:
+            return ToolResult(
+                success=False,
+                output="",
+                error="Search timed out",
+                target=pattern,
+            )
+        except Exception as e:
+            return ToolResult(
+                success=False,
+                output="",
+                error=f"Search error: {e}",
+                target=pattern,
+            )
+
+
+def register_search_tools(registry):
+    """Register all search tools with a registry"""
+    registry.register_class(GrepTool)
+    registry.register_class(RipgrepTool)

nc1709/agent/tools/task_tool.py

@@ -0,0 +1,284 @@
+"""
+Task Tool - Sub-agent Spawning
+
+Allows spawning sub-agents for complex, multi-step tasks.
+Each sub-agent can use tools and work autonomously.
+"""
+
+from typing import Optional, Dict, Any, TYPE_CHECKING
+import threading
+import queue
+
+from .base import Tool, ToolResult, ToolParameter, ToolPermission
+
+if TYPE_CHECKING:
+    from ..core import Agent
+
+
+class TaskTool(Tool):
+    """Spawn a sub-agent for complex tasks"""
+
+    name = "Task"
+    description = (
+        "Launch a sub-agent to handle a complex, multi-step task autonomously. "
+        "The sub-agent has access to all tools and can work independently. "
+        "Use for tasks that require multiple steps or exploration."
+    )
+    category = "agent"
+    permission = ToolPermission.ASK  # Ask before spawning
+
+    parameters = [
+        ToolParameter(
+            name="prompt",
+            description="Detailed task description for the sub-agent",
+            type="string",
+            required=True,
+        ),
+        ToolParameter(
+            name="description",
+            description="Short description of the task (3-5 words)",
+            type="string",
+            required=True,
+        ),
+        ToolParameter(
+            name="agent_type",
+            description="Type of agent to spawn",
+            type="string",
+            required=False,
+            default="general",
+            enum=["general", "explore", "code", "research"],
+        ),
+    ]
+
+    def __init__(self, parent_agent: "Agent" = None):
+        super().__init__()
+        self.parent_agent = parent_agent
+        self._running_tasks: Dict[str, Dict] = {}
+        self._task_counter = 0
+
+    def set_parent_agent(self, agent: "Agent") -> None:
+        """Set the parent agent for spawning sub-agents"""
+        self.parent_agent = agent
+
+    def execute(
+        self,
+        prompt: str,
+        description: str,
+        agent_type: str = "general",
+    ) -> ToolResult:
+        """Spawn a sub-agent to handle a task"""
+
+        if not self.parent_agent:
+            return ToolResult(
+                success=False,
+                output="",
+                error="No parent agent configured for task spawning",
+                target=description,
+            )
+
+        try:
+            # Create sub-agent with same configuration
+            from ..core import Agent, AgentConfig
+
+            # Configure sub-agent based on type
+            config = AgentConfig(
+                max_iterations=20,  # Limit sub-agent iterations
+                tool_permissions=self.parent_agent.config.tool_permissions.copy(),
+            )
+
+            # Create sub-agent
+            sub_agent = Agent(
+                llm=self.parent_agent.llm,
+                config=config,
+                parent_agent=self.parent_agent,
+            )
+
+            # Add context about this being a sub-agent
+            context = f"""You are a sub-agent spawned to handle a specific task.
+Your task: {description}
+
+Detailed instructions:
+{prompt}
+
+Work autonomously to complete this task. Use available tools as needed.
+When complete, provide a clear summary of what you accomplished.
+"""
+
+            # Run sub-agent synchronously for now
+            # (could be made async for parallel tasks)
+            result = sub_agent.run(context)
+
+            return ToolResult(
+                success=True,
+                output=f"Sub-agent completed task: {description}\n\nResult:\n{result}",
+                target=description,
+                data={
+                    "agent_type": agent_type,
+                    "iterations": sub_agent.iteration_count,
+                },
+            )
+
+        except Exception as e:
+            return ToolResult(
+                success=False,
+                output="",
+                error=f"Error running sub-agent: {e}",
+                target=description,
+            )
+
+
+class TodoWriteTool(Tool):
+    """Manage a task list for tracking progress"""
+
+    name = "TodoWrite"
+    description = (
+        "Create or update a todo list to track task progress. "
+        "Use this to plan complex tasks and show progress to the user."
+    )
+    category = "agent"
+    permission = ToolPermission.AUTO  # Safe to auto-execute
+
+    parameters = [
+        ToolParameter(
+            name="todos",
+            description="List of todo items with status",
+            type="array",
+            required=True,
+        ),
+    ]
+
+    # Class-level todo storage
+    _todos: list = []
+
+    def execute(self, todos: list) -> ToolResult:
+        """Update the todo list"""
+
+        try:
+            # Validate todo format
+            validated_todos = []
+            for item in todos:
+                if isinstance(item, dict):
+                    validated_todos.append({
+                        "content": item.get("content", ""),
+                        "status": item.get("status", "pending"),
+                        "activeForm": item.get("activeForm", item.get("content", "")),
+                    })
+                elif isinstance(item, str):
+                    validated_todos.append({
+                        "content": item,
+                        "status": "pending",
+                        "activeForm": item,
+                    })
+
+            TodoWriteTool._todos = validated_todos
+
+            # Format output
+            output_lines = ["Todo list updated:"]
+            for i, todo in enumerate(validated_todos, 1):
+                status_icon = {
+                    "pending": "○",
+                    "in_progress": "●",
+                    "completed": "✓",
+                }.get(todo["status"], "○")
+                output_lines.append(f"  {status_icon} {i}. {todo['content']}")
+
+            return ToolResult(
+                success=True,
+                output="\n".join(output_lines),
+                target=f"{len(validated_todos)} items",
+                data={"todos": validated_todos},
+            )
+
+        except Exception as e:
+            return ToolResult(
+                success=False,
+                output="",
+                error=f"Error updating todos: {e}",
+                target="todos",
+            )
+
+    @classmethod
+    def get_todos(cls) -> list:
+        """Get current todo list"""
+        return cls._todos.copy()
+
+    @classmethod
+    def clear_todos(cls) -> None:
+        """Clear the todo list"""
+        cls._todos = []
+
+
+class AskUserTool(Tool):
+    """Ask the user a question"""
+
+    name = "AskUser"
+    description = (
+        "Ask the user a question to clarify requirements or get a decision. "
+        "Use when you need user input to proceed."
+    )
+    category = "agent"
+    permission = ToolPermission.AUTO  # Safe - just asks question
+
+    parameters = [
+        ToolParameter(
+            name="question",
+            description="The question to ask the user",
+            type="string",
+            required=True,
+        ),
+        ToolParameter(
+            name="options",
+            description="Optional list of choices for the user",
+            type="array",
+            required=False,
+        ),
+    ]
+
+    def __init__(self, input_callback=None):
+        super().__init__()
+        self.input_callback = input_callback or input
+
+    def execute(self, question: str, options: list = None) -> ToolResult:
+        """Ask user a question"""
+
+        try:
+            # Display question
+            print(f"\n❓ {question}")
+
+            if options:
+                for i, opt in enumerate(options, 1):
+                    print(f"  {i}. {opt}")
+                print()
+
+            # Get user input
+            response = self.input_callback("> ").strip()
+
+            # If options provided and user entered a number, map to option
+            if options and response.isdigit():
+                idx = int(response) - 1
+                if 0 <= idx < len(options):
+                    response = options[idx]
+
+            return ToolResult(
+                success=True,
+                output=f"User response: {response}",
+                target=question[:30],
+                data={"response": response},
+            )
+
+        except Exception as e:
+            return ToolResult(
+                success=False,
+                output="",
+                error=f"Error getting user input: {e}",
+                target=question[:30],
+            )
+
+
+def register_task_tools(registry, parent_agent=None):
+    """Register task management tools with a registry"""
+    task_tool = TaskTool(parent_agent)
+    registry.register(task_tool)
+    registry.register_class(TodoWriteTool)
+    registry.register_class(AskUserTool)
+    return task_tool  # Return so parent_agent can be set later