crabcode 0.1.6__py3-none-win_amd64.whl

crabcode_core/tools/ask_user.py

@@ -0,0 +1,122 @@
+"""AskUserTool — present choices to the user and wait for selection."""
+
+from __future__ import annotations
+
+import asyncio
+import uuid
+from typing import Any
+
+from crabcode_core.types.event import ChoiceRequestEvent, ChoiceResponseEvent
+from crabcode_core.types.tool import Tool, ToolContext, ToolResult
+
+
+class AskUserTool(Tool):
+    name = "AskUser"
+    description = "Present a question with options for the user to choose from."
+    is_read_only = True
+    is_concurrency_safe = False  # blocks on user input
+    input_schema = {
+        "type": "object",
+        "properties": {
+            "question": {
+                "type": "string",
+                "description": "The question or prompt to display to the user.",
+            },
+            "options": {
+                "type": "array",
+                "items": {"type": "string"},
+                "description": "List of options for the user to choose from.",
+            },
+            "multiple": {
+                "type": "boolean",
+                "description": (
+                    "If true, user can select multiple options. "
+                    "Default: false (single select)."
+                ),
+                "default": False,
+            },
+        },
+        "required": ["question", "options"],
+    }
+
+    async def get_prompt(self, **kwargs: Any) -> str:
+        return (
+            "Present a question with choices to the user when you are unsure "
+            "about the next step and want their input. This tool pauses "
+            "execution and waits for the user to select one or more options.\n\n"
+            "Use this tool when:\n"
+            "- There are multiple reasonable approaches and you need the user's preference\n"
+            "- You want to confirm the direction before making significant changes\n"
+            "- The user might have context you don't about which option is best\n\n"
+            "Do NOT use this tool when:\n"
+            "- The answer is obvious or there's a clear best approach\n"
+            "- The user already told you what to do\n"
+            "- You just need a simple yes/no confirmation (use text response instead)\n\n"
+            "The tool returns the selected option(s) as a list of strings."
+        )
+
+    async def call(
+        self,
+        tool_input: dict[str, Any],
+        context: ToolContext,
+    ) -> ToolResult:
+        question = tool_input.get("question", "")
+        options = tool_input.get("options", [])
+        multiple = tool_input.get("multiple", False)
+
+        if not options:
+            return ToolResult(
+                result_for_model="Error: at least one option is required",
+                is_error=True,
+            )
+
+        if len(options) == 1:
+            return ToolResult(
+                result_for_model=f"User selected: {options[0]}",
+                data={"selected": [options[0]]},
+            )
+
+        if not context.choice_queue or not context.tool_event_queue:
+            # No frontend connected — auto-select the first option
+            return ToolResult(
+                result_for_model=f"Auto-selected (no interactive frontend): {options[0]}",
+                data={"selected": [options[0]]},
+            )
+
+        # Generate a unique ID for this choice request
+        request_id = str(uuid.uuid4())
+
+        # Emit the choice request event through the tool_event_queue
+        request = ChoiceRequestEvent(
+            tool_use_id=request_id,
+            question=question,
+            options=options,
+            multiple=multiple,
+        )
+        await context.tool_event_queue.put(request)
+
+        # Wait for the user's response
+        while True:
+            response: ChoiceResponseEvent = await context.choice_queue.get()
+            if response.tool_use_id == request_id:
+                break
+            # Put back responses for other requests
+            await context.choice_queue.put(response)
+            await asyncio.sleep(0.05)
+
+        if response.cancelled:
+            return ToolResult(
+                result_for_model="User cancelled the selection.",
+                is_error=True,
+            )
+
+        selected = response.selected
+        if multiple:
+            result_text = f"User selected: {', '.join(selected)}"
+        else:
+            result_text = f"User selected: {selected[0] if selected else '(none)'}"
+
+        return ToolResult(
+            result_for_model=result_text,
+            data={"selected": selected},
+        )

crabcode_core/tools/bash.py

@@ -0,0 +1,154 @@
+"""BashTool — execute shell commands."""
+
+from __future__ import annotations
+
+import asyncio
+import os
+from typing import Any
+
+from crabcode_core.subprocess_utils import (
+    decode_subprocess_output,
+    managed_process_command,
+    shell_command,
+)
+from crabcode_core.types.tool import Tool, ToolContext, ToolResult
+from crabcode_core.io_worker import run_file_tool
+
+
+class BashTool(Tool):
+    name = "Bash"
+    description = "Execute a command in the active platform shell."
+    is_read_only = False
+    is_concurrency_safe = False
+    input_schema = {
+        "type": "object",
+        "properties": {
+            "command": {
+                "type": "string",
+                "description": "The platform-shell command to execute.",
+            },
+            "timeout": {
+                "type": "integer",
+                "description": "Timeout in seconds (defaults to filesystem_timeout in settings: 3600 if unset, unlimited if null).",
+            },
+        },
+        "required": ["command"],
+    }
+
+    async def get_prompt(self, **kwargs: Any) -> str:
+        windows_chaining = (
+            "- On Windows, commands run in PowerShell. Do not assume `&&` is "
+            "available because Windows PowerShell 5.1 does not support it; "
+            "use `; if ($?) { ... }` for conditional sequencing.\n"
+            "- If PowerShell blocks npm.ps1/npx.ps1 with PSSecurityException, "
+            "use npm.cmd/npx.cmd; do not change the system execution policy.\n"
+            if os.name == "nt"
+            else ""
+        )
+        return (
+            "Execute a command in the active platform shell. Use for system commands, "
+            "running scripts, git operations, and other terminal tasks. "
+            "Prefer dedicated tools (Read, apply_patch, Edit, Write, Glob, Grep) over "
+            "bash when they can accomplish the task.\n\n"
+            "Commands run in an explicit Bash-compatible shell on Unix and "
+            "PowerShell on Windows, with the user's environment. "
+            "The command is executed in the working directory of the "
+            "current session. Each call starts a new shell, so environment "
+            "variables and directory changes do not persist across calls.\n\n"
+            "Guidelines:\n"
+            "- Always quote file paths that contain spaces with double "
+            'quotes: cd "/path/with spaces" (correct) vs cd /path/with '
+            "spaces (incorrect, will fail).\n"
+            "- For long-running processes (dev servers, watchers), they "
+            "will be killed when the timeout expires. Warn the user if "
+            "a command is expected to run indefinitely.\n"
+            "- When issuing multiple independent commands, call Bash "
+            "multiple times in parallel rather than chaining with &&.\n"
+            "- If commands depend on each other and must run sequentially, "
+            "use the active platform shell's conditional chaining syntax in "
+            "a single call.\n"
+            f"{windows_chaining}"
+            "- Do NOT use interactive commands (e.g., git rebase -i, "
+            "vim, nano) — they require user input that is not supported.\n"
+            "- If a command fails, read the error output carefully before "
+            "retrying. Do not blindly retry the same command."
+        )
+
+    async def call(
+        self, tool_input: dict[str, Any], context: ToolContext,
+    ) -> ToolResult:
+        return await run_file_tool(self.name, tool_input, context)
+
+    async def _call_local(
+        self,
+        tool_input: dict[str, Any],
+        context: ToolContext,
+    ) -> ToolResult:
+        command = tool_input.get("command", "")
+
+        if not command.strip():
+            return ToolResult(
+                result_for_model="Error: empty command",
+                is_error=True,
+            )
+
+        env = {**os.environ, **context.env}
+
+        # Create snapshot before bash commands that might modify files
+        if context.session_id:
+            try:
+                from crabcode_core.snapshot.tracker import pre_bash_snapshot
+                # The entire operation is isolated, including snapshot I/O.
+                pre_bash_snapshot(
+                    context.cwd,
+                    context.session_id,
+                    enabled=context.snapshot_enabled,
+                    max_size_mb=context.snapshot_max_size_mb,
+                )
+            except Exception:
+                pass  # Best-effort; don't block bash if snapshot fails
+
+        try:
+            proc = await asyncio.create_subprocess_exec(
+                *managed_process_command(shell_command(command)),
+                stdout=asyncio.subprocess.PIPE,
+                stderr=asyncio.subprocess.PIPE,
+                cwd=context.cwd,
+                env=env,
+            )
+
+            # The parent worker supervisor owns the deadline and process group.
+            stdout_bytes, stderr_bytes = await proc.communicate()
+
+            stdout = decode_subprocess_output(stdout_bytes)
+            stderr = decode_subprocess_output(stderr_bytes)
+            exit_code = proc.returncode or 0
+
+            max_chars = 100_000
+            if len(stdout) > max_chars:
+                stdout = stdout[:max_chars] + "\n... (truncated)"
+            if len(stderr) > max_chars:
+                stderr = stderr[:max_chars] + "\n... (truncated)"
+
+            parts: list[str] = []
+            if stdout:
+                parts.append(stdout)
+            if stderr:
+                parts.append(f"stderr:\n{stderr}")
+            if exit_code != 0:
+                parts.append(f"Exit code: {exit_code}")
+
+            output = "\n".join(parts) if parts else "(no output)"
+
+            return ToolResult(
+                data={"stdout": stdout, "stderr": stderr, "exit_code": exit_code},
+                result_for_model=output,
+                result_for_display=output,
+                is_error=exit_code != 0,
+            )
+
+        except Exception as e:
+            return ToolResult(
+                result_for_model=f"Error executing command: {e}",
+                is_error=True,
+            )