crabcode 0.1.6__py3-none-win_amd64.whl

crabcode_core/tools/file_write.py

@@ -0,0 +1,154 @@
+"""FileWriteTool — create or overwrite files."""
+
+from __future__ import annotations
+
+from pathlib import Path
+from typing import Any
+
+from crabcode_core.logging_utils import get_logger
+from crabcode_core.text_io import normalize_newlines, read_utf8_text, write_utf8_text
+from crabcode_core.tools.diff_utils import compute_diff, format_edit_summary
+from crabcode_core.types.tool import Tool, ToolContext, ToolResult
+from crabcode_core.io_worker import run_file_tool
+
+logger = get_logger(__name__)
+
+
+async def _get_lsp_diagnostics(
+    file_path: str | Path,
+    context: ToolContext,
+) -> str:
+    """Collect LSP diagnostics for the written file, return formatted string."""
+    lsp = context.lsp_manager
+    if lsp is None:
+        return ""
+    from crabcode_core.lsp.diagnostics import collect_and_format_diagnostics
+    return await collect_and_format_diagnostics(lsp, str(file_path))
+
+
+class FileWriteTool(Tool):
+    name = "Write"
+    description = "Write content to a file, creating it if necessary."
+    is_read_only = False
+    is_concurrency_safe = False
+    input_schema = {
+        "type": "object",
+        "properties": {
+            "file_path": {
+                "type": "string",
+                "description": "The path of the file to write.",
+            },
+            "content": {
+                "type": "string",
+                "description": "The content to write to the file.",
+            },
+        },
+        "required": ["file_path", "content"],
+    }
+
+    async def get_prompt(self, **kwargs: Any) -> str:
+        return (
+            "Write content to a file. Creates the file and parent directories "
+            "if they don't exist. WARNING: This will overwrite the existing "
+            "file if there is one.\n\n"
+            "ALWAYS prefer editing existing files with the Edit tool instead "
+            "of rewriting them. Only use Write for:\n"
+            "- Creating new files that don't exist yet\n"
+            "- Cases where the entire file content needs to be replaced\n\n"
+            "NEVER create files unless absolutely necessary for achieving "
+            "your goal. This prevents file bloat and builds on existing "
+            "work more effectively.\n"
+            "NEVER proactively create documentation or README files unless "
+            "the user explicitly requests them."
+        )
+
+    async def call(
+        self, tool_input: dict[str, Any], context: ToolContext,
+    ) -> ToolResult:
+        result = await run_file_tool(self.name, tool_input, context)
+        if not result.is_error and result.data:
+            result.result_for_model += await _get_lsp_diagnostics(result.data["file_path"], context)
+        return result
+
+    async def _call_local(
+        self,
+        tool_input: dict[str, Any],
+        context: ToolContext,
+    ) -> ToolResult:
+        file_path = tool_input.get("file_path", "")
+        content = tool_input.get("content", "")
+
+        if not file_path:
+            return ToolResult(
+                result_for_model="Error: file_path is required",
+                is_error=True,
+            )
+
+        path = Path(file_path)
+        if not path.is_absolute():
+            path = Path(context.cwd) / path
+
+        is_new = not path.exists()
+        old_content = ""
+        newline: str | None = None
+        has_bom = False
+        if not is_new:
+            try:
+                source = read_utf8_text(path)
+                old_content = source.text
+                newline = source.newline
+                has_bom = source.has_bom
+            except (OSError, UnicodeError) as exc:
+                return ToolResult(
+                    result_for_model=f"Error reading existing file; refusing to overwrite without a valid backup: {exc}",
+                    is_error=True,
+                )
+
+        if newline is not None:
+            content = normalize_newlines(content, newline)
+
+        # Track snapshot before writing
+        if context.session_id:
+            try:
+                from crabcode_core.snapshot.tracker import track_snapshot_for_file
+                track_snapshot_for_file(
+                    cwd=context.cwd,
+                    session_id=context.session_id,
+                    file_path=str(path),
+                    old_content=old_content if not is_new else None,
+                    action="create" if is_new else "modify",
+                )
+            except Exception:
+                logger.debug("Failed to track snapshot for write", exc_info=True)
+
+        try:
+            path.parent.mkdir(parents=True, exist_ok=True)
+            write_utf8_text(path, content, has_bom=has_bom)
+        except Exception as e:
+            return ToolResult(
+                result_for_model=f"Error writing file: {e}",
+                is_error=True,
+            )
+
+        if is_new:
+            line_count = content.count("\n") + (1 if content and not content.endswith("\n") else 0)
+            lsp_msg = await _get_lsp_diagnostics(path, context)
+            return ToolResult(
+                data={"file_path": str(path), "created": True, "lines": line_count},
+                result_for_model=f"Created {path} ({line_count} lines).{lsp_msg}",
+            )
+
+        diff_info = compute_diff(old_content, content, str(path))
+        model_msg, display_msg = format_edit_summary(str(path), diff_info)
+        lsp_msg = await _get_lsp_diagnostics(path, context)
+
+        return ToolResult(
+            data={
+                "file_path": str(path),
+                "created": False,
+                "line_range": diff_info["line_range"],
+                "stats": diff_info["stats"],
+            },
+            result_for_model=model_msg + lsp_msg,
+            result_for_display=display_msg,
+        )

crabcode_core/tools/glob.py

@@ -0,0 +1,123 @@
+"""GlobTool — find files by pattern."""
+
+from __future__ import annotations
+
+from pathlib import Path
+from typing import Any
+
+from crabcode_core.tools._input_helpers import first_non_empty_str
+from crabcode_core.types.tool import Tool, ToolContext, ToolResult
+from crabcode_core.io_worker import run_file_tool
+
+
+class GlobTool(Tool):
+    name = "Glob"
+    description = "Find files matching a glob pattern."
+    is_read_only = True
+    is_concurrency_safe = True
+    input_schema = {
+        "type": "object",
+        "properties": {
+            "pattern": {
+                "type": "string",
+                "minLength": 1,
+                "description": "Glob pattern to match (e.g., '**/*.py', 'src/**/*.ts').",
+            },
+            "path": {
+                "type": "string",
+                "description": "Directory to search in (default: cwd).",
+            },
+        },
+        "required": ["pattern"],
+    }
+
+    async def get_prompt(self, **kwargs: Any) -> str:
+        return (
+            "Find files matching a glob pattern. Returns matching file paths "
+            "sorted by modification time (most recent first). Works fast "
+            "with codebases of any size.\n\n"
+            "Patterns not starting with '**/' are automatically prepended "
+            "with it for recursive searching. Use this instead of find or "
+            "ls via Bash.\n\n"
+            "Examples:\n"
+            '- "*.py" (becomes "**/*.py") — find all Python files\n'
+            '- "src/**/*.ts" — find all TypeScript files under src/\n'
+            '- "**/test_*.py" — find all test files'
+        )
+
+    async def call(
+        self, tool_input: dict[str, Any], context: ToolContext,
+    ) -> ToolResult:
+        result = await run_file_tool(self.name, tool_input, context)
+        return result
+
+    async def _call_local(
+        self,
+        tool_input: dict[str, Any],
+        context: ToolContext,
+    ) -> ToolResult:
+        pattern = first_non_empty_str(
+            tool_input,
+            ("pattern", "glob_pattern", "file_pattern", "glob", "match", "include"),
+        )
+        search_path = tool_input.get("path", context.cwd)
+
+        if not pattern:
+            return ToolResult(
+                result_for_model=(
+                    "Error: pattern is required. Pass a non-empty glob string "
+                    "(e.g. \"**/*.py\"); aliases: glob_pattern, file_pattern, glob, "
+                    "match, include."
+                ),
+                is_error=True,
+            )
+
+        if not pattern.startswith("**/") and not pattern.startswith("/"):
+            pattern = f"**/{pattern}"
+
+        root = Path(search_path)
+        if not root.is_absolute():
+            root = Path(context.cwd) / root
+
+        if not root.exists():
+            return ToolResult(
+                result_for_model=f"Error: directory not found: {root}",
+                is_error=True,
+            )
+
+        try:
+            matches: list[tuple[float, str]] = []
+            for path in root.glob(pattern):
+                if path.is_file():
+                    try:
+                        mtime = path.stat().st_mtime
+                    except OSError:
+                        mtime = 0
+                    matches.append((mtime, str(path)))
+
+                if len(matches) >= 1000:
+                    break
+
+            matches.sort(key=lambda x: x[0], reverse=True)
+            file_paths = [p for _, p in matches]
+
+        except Exception as e:
+            return ToolResult(
+                result_for_model=f"Error during glob: {e}",
+                is_error=True,
+            )
+
+        if not file_paths:
+            return ToolResult(
+                result_for_model="No files matched the pattern.",
+                data={"count": 0},
+            )
+
+        result_text = "\n".join(file_paths)
+        count = len(file_paths)
+        suffix = " (showing first 1000)" if count >= 1000 else ""
+
+        return ToolResult(
+            data={"count": count, "files": file_paths},
+            result_for_model=f"Found {count} files{suffix}:\n{result_text}",
+        )

crabcode_core/tools/goal.py

@@ -0,0 +1,134 @@
+"""Model-facing tools for managing the current session goal."""
+
+from __future__ import annotations
+
+from typing import Any
+
+from crabcode_core.types.tool import Tool, ToolContext, ToolResult
+
+
+def _session(context: ToolContext) -> Any | None:
+    return context.session
+
+
+def _goal_result(goal: Any, message: str) -> ToolResult:
+    data = goal.to_dict()
+    return ToolResult(data=data, result_for_model=f"{message}\n{data}")
+
+
+class CreateGoalTool(Tool):
+    name = "create_goal"
+    description = (
+        "Create a persistent goal only when the user explicitly requested goal-backed "
+        "work. The objective must include a concrete outcome and verification criteria."
+    )
+    is_read_only = False
+    is_concurrency_safe = False
+    input_schema = {
+        "type": "object",
+        "properties": {
+            "objective": {
+                "type": "string",
+                "description": "Concrete objective, scope, and completion evidence.",
+            },
+            "token_budget": {
+                "type": "integer",
+                "minimum": 1,
+                "description": (
+                    "Optional token budget. Set it only when the user explicitly "
+                    "requested a budget."
+                ),
+            },
+        },
+        "required": ["objective"],
+    }
+
+    async def validate_input(self, tool_input: dict[str, Any]) -> str | None:
+        objective = tool_input.get("objective")
+        if not isinstance(objective, str) or not objective.strip():
+            return "objective is required"
+        budget = tool_input.get("token_budget")
+        if budget is not None and (not isinstance(budget, int) or budget <= 0):
+            return "token_budget must be a positive integer"
+        return None
+
+    async def call(
+        self, tool_input: dict[str, Any], context: ToolContext
+    ) -> ToolResult:
+        session = _session(context)
+        if session is None:
+            return ToolResult(
+                result_for_model="Goal management is unavailable outside the main session.",
+                is_error=True,
+            )
+        try:
+            goal = session.create_goal(
+                tool_input["objective"],
+                token_budget=tool_input.get("token_budget"),
+            )
+        except (RuntimeError, ValueError) as exc:
+            return ToolResult(result_for_model=str(exc), is_error=True)
+        return _goal_result(goal, "Goal created.")
+
+
+class GetGoalTool(Tool):
+    name = "get_goal"
+    description = "Get the current persistent goal and its lifecycle state."
+    is_read_only = True
+    is_concurrency_safe = True
+    input_schema = {"type": "object", "properties": {}}
+
+    async def call(
+        self, tool_input: dict[str, Any], context: ToolContext
+    ) -> ToolResult:
+        session = _session(context)
+        if session is None:
+            return ToolResult(
+                result_for_model="Goal management is unavailable outside the main session.",
+                is_error=True,
+            )
+        goal = session.get_goal()
+        if goal is None:
+            return ToolResult(data=None, result_for_model="No goal is set.")
+        return _goal_result(goal, "Current goal.")
+
+
+class UpdateGoalTool(Tool):
+    name = "update_goal"
+    description = (
+        "Mark the current goal complete after verification, or blocked when it cannot "
+        "make further progress without user input or an external state change."
+    )
+    is_read_only = False
+    is_concurrency_safe = False
+    input_schema = {
+        "type": "object",
+        "properties": {
+            "status": {
+                "type": "string",
+                "enum": ["complete", "blocked"],
+                "description": "The terminal state to apply.",
+            }
+        },
+        "required": ["status"],
+    }
+
+    async def validate_input(self, tool_input: dict[str, Any]) -> str | None:
+        if tool_input.get("status") not in {"complete", "blocked"}:
+            return "status must be 'complete' or 'blocked'"
+        return None
+
+    async def call(
+        self, tool_input: dict[str, Any], context: ToolContext
+    ) -> ToolResult:
+        session = _session(context)
+        if session is None:
+            return ToolResult(
+                result_for_model="Goal management is unavailable outside the main session.",
+                is_error=True,
+            )
+        try:
+            goal = session.update_goal(tool_input["status"])
+        except (RuntimeError, ValueError) as exc:
+            return ToolResult(result_for_model=str(exc), is_error=True)
+        return _goal_result(goal, f"Goal marked {goal.status}.")

crabcode_core/tools/grep.py

@@ -0,0 +1,247 @@
+"""GrepTool — search file contents with portable fallbacks."""
+
+from __future__ import annotations
+
+import asyncio
+import os
+import re
+import shutil
+from pathlib import Path
+from typing import Any
+
+from crabcode_core.subprocess_utils import (
+    managed_process_command,
+    resolve_executable_command,
+)
+from crabcode_core.tools._input_helpers import first_non_empty_str
+from crabcode_core.types.tool import Tool, ToolContext, ToolResult
+from crabcode_core.io_worker import run_file_tool
+
+
+_SKIP_DIRECTORIES = {
+    ".git",
+    ".hg",
+    ".svn",
+    ".venv",
+    "__pycache__",
+    "dist",
+    "node_modules",
+    "target",
+    "venv",
+}
+
+
+def _python_search(
+    pattern: str,
+    search_path: str,
+    *,
+    cwd: str,
+    glob_pattern: str | None,
+    case_insensitive: bool,
+) -> str:
+    """Pure-Python fallback for stock Windows installations."""
+    flags = re.IGNORECASE if case_insensitive else 0
+    expression = re.compile(pattern, flags)
+    target = Path(search_path)
+    if not target.is_absolute():
+        target = Path(cwd) / target
+    target = target.resolve()
+    if not target.exists():
+        raise FileNotFoundError(f"search path does not exist: {search_path}")
+
+    if target.is_file():
+        candidates = [target]
+    else:
+        candidates = []
+        for root, directories, files in os.walk(target):
+            directories[:] = [
+                name for name in directories if name not in _SKIP_DIRECTORIES
+            ]
+            root_path = Path(root)
+            for name in files:
+                candidate = root_path / name
+                if glob_pattern and not candidate.match(glob_pattern):
+                    continue
+                candidates.append(candidate)
+
+    matches: list[str] = []
+    for candidate in candidates:
+        try:
+            with open(candidate, "rb") as probe:
+                if b"\0" in probe.read(8192):
+                    continue
+            text = candidate.read_text(encoding="utf-8", errors="replace")
+        except OSError:
+            continue
+        try:
+            display = str(candidate.relative_to(Path(cwd).resolve()))
+        except ValueError:
+            display = str(candidate)
+        for line_number, line in enumerate(text.splitlines(), start=1):
+            if expression.search(line):
+                matches.append(f"{display}:{line_number}:{line}")
+                if len(matches) >= 200:
+                    return "\n".join(matches)
+    return "\n".join(matches)
+
+
+class GrepTool(Tool):
+    name = "Grep"
+    description = "Search file contents using regex patterns."
+    is_read_only = True
+    is_concurrency_safe = True
+    input_schema = {
+        "type": "object",
+        "properties": {
+            "pattern": {
+                "type": "string",
+                "minLength": 1,
+                "description": "The regex pattern to search for.",
+            },
+            "path": {
+                "type": "string",
+                "description": (
+                    "Directory or file to search in (default: cwd). "
+                    "Directories are searched recursively. "
+                    "Use the glob parameter to filter file types when searching a directory."
+                ),
+            },
+            "glob": {
+                "type": "string",
+                "description": "File glob pattern to filter (e.g., '*.py').",
+            },
+            "case_insensitive": {
+                "type": "boolean",
+                "description": "Case insensitive search.",
+            },
+        },
+        "required": ["pattern"],
+    }
+
+    async def get_prompt(self, **kwargs: Any) -> str:
+        return (
+            "Search file contents for a regex pattern using ripgrep, system grep, or a built-in fallback. "
+            "Returns matching lines with file paths and line numbers. "
+            "Use this instead of running grep or rg via Bash.\n\n"
+            "Supports full regex syntax (e.g., 'log.*Error', "
+            "'function\\s+\\w+'). Filter files with the glob parameter "
+            "(e.g., '*.py', '*.tsx').\n\n"
+            "Results are capped at 200 matches for responsiveness. "
+            "If you need more specific results, narrow your search "
+            "with a more specific pattern or glob filter."
+        )
+
+    async def call(
+        self, tool_input: dict[str, Any], context: ToolContext,
+    ) -> ToolResult:
+        result = await run_file_tool(self.name, tool_input, context)
+        return result
+
+    async def _call_local(
+        self,
+        tool_input: dict[str, Any],
+        context: ToolContext,
+    ) -> ToolResult:
+        pattern = first_non_empty_str(
+            tool_input,
+            ("pattern", "regex", "regexp", "search", "query"),
+        )
+        search_path = tool_input.get("path", context.cwd)
+        glob_pattern = tool_input.get("glob")
+        case_insensitive = tool_input.get("case_insensitive", False)
+
+        if not pattern:
+            return ToolResult(
+                result_for_model=(
+                    "Error: pattern is required. Pass a regex string; aliases: "
+                    "regex, regexp, search, query."
+                ),
+                is_error=True,
+            )
+
+        rg = shutil.which("rg")
+        use_ripgrep = bool(rg)
+        grep_bin = shutil.which("grep")
+
+        if not use_ripgrep and not grep_bin:
+            try:
+                stdout = _python_search(
+                    pattern, str(search_path), cwd=context.cwd,
+                    glob_pattern=glob_pattern,
+                    case_insensitive=bool(case_insensitive),
+                )
+            except (FileNotFoundError, re.error) as exc:
+                return ToolResult(result_for_model=f"Grep error: {exc}", is_error=True)
+            lines = stdout.splitlines() if stdout else []
+            if len(stdout) > 50_000:
+                stdout = stdout[:50_000] + "\n... (truncated)"
+            return ToolResult(
+                data={"match_count": len(lines)},
+                result_for_model=stdout or "No matches found.",
+            )
+
+        if use_ripgrep:
+            args = [rg, "--line-number", "--no-heading", "--color=never"]
+            if case_insensitive:
+                args.append("-i")
+            if glob_pattern:
+                args.extend(["--glob", glob_pattern])
+            args.extend(["--max-count", "200"])
+            args.append(pattern)
+            args.append("--")
+            args.append(search_path)
+        else:
+            # Fallback to system grep
+            assert grep_bin is not None
+            args = [grep_bin, "-rn", "--color=never", "-E"]
+            if case_insensitive:
+                args.append("-i")
+            if glob_pattern:
+                args.extend(["--include", glob_pattern])
+            args.extend(["-m", "200"])
+            args.append(pattern)
+            args.append(search_path)
+
+        proc: asyncio.subprocess.Process | None = None
+        try:
+            args = resolve_executable_command(args, cwd=context.cwd)
+            proc = await asyncio.create_subprocess_exec(
+                *managed_process_command(args),
+                stdout=asyncio.subprocess.PIPE,
+                stderr=asyncio.subprocess.PIPE,
+                cwd=context.cwd,
+            )
+            stdout_bytes, stderr_bytes = await proc.communicate()
+        except FileNotFoundError:
+            return ToolResult(
+                result_for_model="Error: neither ripgrep (rg) nor grep found on PATH.",
+                is_error=True,
+            )
+        except ValueError as exc:
+            return ToolResult(result_for_model=f"Search error: {exc}", is_error=True)
+
+        stdout = stdout_bytes.decode("utf-8", errors="replace")
+        stderr = stderr_bytes.decode("utf-8", errors="replace")
+
+        if proc.returncode == 1:
+            return ToolResult(
+                result_for_model="No matches found.",
+                data={"matches": 0},
+            )
+
+        if proc.returncode and proc.returncode > 1:
+            return ToolResult(
+                result_for_model=f"Grep error: {stderr or 'unknown error'}",
+                is_error=True,
+            )
+
+        lines = stdout.strip().split("\n") if stdout.strip() else []
+
+        max_output = 50_000
+        if len(stdout) > max_output:
+            stdout = stdout[:max_output] + "\n... (truncated)"
+
+        return ToolResult(
+            data={"match_count": len(lines)},
+            result_for_model=stdout or "No matches found.",
+        )