pi-mono-coding 0.1.0__py3-none-any.whl

pi_coding/tools/edit.py

@@ -0,0 +1,176 @@
+"""Edit tool - edits files by replacing exact text matches with fuzzy matching support."""
+
+from __future__ import annotations
+
+import asyncio
+import os
+from pi_agent.types import AgentToolUpdateCallback
+from typing import Any
+
+from pi_agent import AgentTool, AgentToolResult
+from pi_ai.types import TextContent
+
+from pi_coding.utils import (
+    detect_line_ending,
+    fuzzy_find_text,
+    generate_diff_string,
+    normalize_for_fuzzy_match,
+    normalize_to_lf,
+    resolve_to_cwd,
+    restore_line_endings,
+    strip_bom,
+)
+
+_EDIT_TOOL_PARAMETERS = {
+    "type": "object",
+    "properties": {
+        "path": {
+            "type": "string",
+            "description": "Path to the file to edit (relative or absolute)",
+        },
+        "old_text": {
+            "type": "string",
+            "description": "Exact text to find and replace (must match exactly)",
+        },
+        "new_text": {
+            "type": "string",
+            "description": "New text to replace the old text with",
+        },
+    },
+    "required": ["path", "old_text", "new_text"],
+}
+
+
+async def _execute_edit(
+    tool_call_id: str,
+    params: dict[str, Any],
+    cwd: str,
+    cancel_event: asyncio.Event | None,
+    on_update: AgentToolUpdateCallback | None,
+) -> AgentToolResult:
+    path: str = params.get("path", "")
+    old_text: str = params.get("old_text", "")
+    new_text: str = params.get("new_text", "")
+
+    if not all([path, old_text, new_text]):
+        return AgentToolResult(
+            content=[
+                TextContent(
+                    type="text", text="Error: 'path', 'old_text', and 'new_text' parameters are required"
+                )
+            ],
+            details={"error": "missing_parameters"},
+        )
+
+    absolute_path = resolve_to_cwd(path, cwd)
+
+    if cancel_event and cancel_event.is_set():
+        return AgentToolResult(
+            content=[TextContent(type="text", text="Operation aborted")],
+            details={"error": "aborted"},
+        )
+
+    try:
+        if not os.path.exists(absolute_path):
+            return AgentToolResult(
+                content=[TextContent(type="text", text=f"Error: File not found: {path}")],
+                details={"error": "file_not_found", "path": absolute_path},
+            )
+
+        with open(absolute_path, encoding="utf-8") as f:
+            raw_content = f.read()
+
+        if cancel_event and cancel_event.is_set():
+            return AgentToolResult(
+                content=[TextContent(type="text", text="Operation aborted")],
+                details={"error": "aborted"},
+            )
+
+        bom, content = strip_bom(raw_content)
+        original_ending = detect_line_ending(content)
+        normalized_content = normalize_to_lf(content)
+        normalized_old_text = normalize_to_lf(old_text)
+        normalized_new_text = normalize_to_lf(new_text)
+
+        match_result = fuzzy_find_text(normalized_content, normalized_old_text)
+
+        if not match_result.found:
+            return AgentToolResult(
+                content=[
+                    TextContent(
+                        type="text",
+                        text=f"Could not find the exact text in {path}. The old text must match exactly including all whitespace and newlines.",
+                    )
+                ],
+                details={"error": "text_not_found", "path": absolute_path},
+            )
+
+        fuzzy_content = normalize_for_fuzzy_match(normalized_content)
+        fuzzy_old_text = normalize_for_fuzzy_match(normalized_old_text)
+        occurrences = fuzzy_content.count(fuzzy_old_text)
+
+        if occurrences > 1:
+            return AgentToolResult(
+                content=[
+                    TextContent(
+                        type="text",
+                        text=f"Found {occurrences} occurrences of the text in {path}. The text must be unique. Please provide more context to make it unique.",
+                    )
+                ],
+                details={"error": "multiple_occurrences", "occurrences": occurrences, "path": absolute_path},
+            )
+
+        if cancel_event and cancel_event.is_set():
+            return AgentToolResult(
+                content=[TextContent(type="text", text="Operation aborted")],
+                details={"error": "aborted"},
+            )
+
+        base_content = match_result.content_for_replacement
+        new_content = (
+            base_content[: match_result.index]
+            + normalized_new_text
+            + base_content[match_result.index + match_result.match_length :]
+        )
+
+        if base_content == new_content:
+            return AgentToolResult(
+                content=[
+                    TextContent(
+                        type="text",
+                        text=f"No changes made to {path}. The replacement produced identical content.",
+                    )
+                ],
+                details={"error": "no_changes", "path": absolute_path},
+            )
+
+        final_content = bom + restore_line_endings(new_content, original_ending)
+        with open(absolute_path, "w", encoding="utf-8") as f:
+            f.write(final_content)
+
+        diff_result = generate_diff_string(base_content, new_content)
+        return AgentToolResult(
+            content=[TextContent(type="text", text=f"Successfully replaced text in {path}.")],
+            details={"diff": diff_result["diff"], "first_changed_line": diff_result["first_changed_line"]},
+        )
+
+    except Exception as e:
+        return AgentToolResult(
+            content=[TextContent(type="text", text=f"Error editing file: {e}")],
+            details={"error": str(e), "path": absolute_path},
+        )
+
+
+def create_edit_tool(cwd: str, options: dict[str, Any] | None = None) -> AgentTool:
+    return AgentTool(
+        name="edit",
+        label="Edit",
+        description="Edit a file by replacing exact text. The old_text must match exactly (including whitespace). Use this for precise, surgical edits.",
+        parameters=_EDIT_TOOL_PARAMETERS,
+        execute=lambda tool_call_id, params, cancel_event, on_update: _execute_edit(
+            tool_call_id, params, cwd, cancel_event, on_update
+        ),
+    )
+
+
+edit_tool = create_edit_tool(os.getcwd())

pi_coding/tools/find.py

@@ -0,0 +1,182 @@
+"""Find tool - searches for files by glob pattern using fd."""
+
+from __future__ import annotations
+
+import asyncio
+import os
+import shutil
+from pi_agent.types import AgentToolUpdateCallback
+from typing import Any
+
+from pi_agent import AgentTool, AgentToolResult
+from pi_ai.types import TextContent
+
+from pi_coding.utils import DEFAULT_MAX_BYTES, format_size, resolve_to_cwd, truncate_head
+
+DEFAULT_LIMIT = 1000
+
+_FIND_TOOL_PARAMETERS = {
+    "type": "object",
+    "properties": {
+        "pattern": {
+            "type": "string",
+            "description": "Glob pattern to match files, e.g. '*.ts', '**/*.json', or 'src/**/*.spec.ts'",
+        },
+        "path": {
+            "type": "string",
+            "description": "Directory to search in (default: current directory)",
+        },
+        "limit": {
+            "type": "number",
+            "description": "Maximum number of results (default: 1000)",
+        },
+    },
+    "required": ["pattern"],
+}
+
+
+async def _execute_find(
+    tool_call_id: str,
+    params: dict[str, Any],
+    cwd: str,
+    cancel_event: asyncio.Event | None,
+    on_update: AgentToolUpdateCallback | None,
+) -> AgentToolResult:
+    pattern = params.get("pattern")
+    search_dir = params.get("path", ".")
+    limit = params.get("limit", DEFAULT_LIMIT)
+
+    if not pattern:
+        return AgentToolResult(
+            content=[TextContent(type="text", text="Error: 'pattern' parameter is required")],
+            details={"error": "missing_parameter"},
+        )
+
+    fd_path = shutil.which("fd")
+    if not fd_path:
+        return AgentToolResult(
+            content=[TextContent(type="text", text="Error: fd is not available")],
+            details={"error": "fd_not_found"},
+        )
+
+    search_path = resolve_to_cwd(search_dir, cwd)
+
+    if not os.path.exists(search_path):
+        return AgentToolResult(
+            content=[TextContent(type="text", text=f"Error: Path not found: {search_path}")],
+            details={"error": "path_not_found", "path": search_path},
+        )
+
+    if cancel_event and cancel_event.is_set():
+        return AgentToolResult(
+            content=[TextContent(type="text", text="Operation aborted")],
+            details={"error": "aborted"},
+        )
+
+    args = [
+        fd_path,
+        "--glob",
+        "--color=never",
+        "--hidden",
+        "--max-results",
+        str(limit),
+        pattern,
+        search_path,
+    ]
+
+    try:
+        process = await asyncio.create_subprocess_exec(
+            *args,
+            stdout=asyncio.subprocess.PIPE,
+            stderr=asyncio.subprocess.PIPE,
+        )
+
+        stdout, stderr = await process.communicate()
+
+        if cancel_event and cancel_event.is_set():
+            return AgentToolResult(
+                content=[TextContent(type="text", text="Operation aborted")],
+                details={"error": "aborted"},
+            )
+
+        output = stdout.decode("utf-8", errors="replace").strip()
+
+        if process.returncode is not None and process.returncode != 0 and not output:
+            error_msg = stderr.decode("utf-8", errors="replace").strip() or f"fd exited with code {process.returncode}"
+            return AgentToolResult(
+                content=[TextContent(type="text", text=f"Error: {error_msg}")],
+                details={"error": "fd_error", "exit_code": process.returncode},
+            )
+
+        if not output:
+            return AgentToolResult(
+                content=[TextContent(type="text", text="No files found matching pattern")],
+                details={"pattern": pattern, "results": 0},
+            )
+
+        lines = output.split("\n")
+        relativized: list[str] = []
+
+        for raw_line in lines:
+            line = raw_line.rstrip("\r").strip()
+            if not line:
+                continue
+
+            had_trailing_slash = line.endswith("/") or line.endswith("\\")
+            if line.startswith(search_path):
+                relative_path = line[len(search_path) + 1 :]
+            else:
+                try:
+                    relative_path = os.path.relpath(line, search_path)
+                except ValueError:
+                    relative_path = line
+
+            if had_trailing_slash and not relative_path.endswith("/"):
+                relative_path += "/"
+
+            relativized.append(relative_path)
+
+        result_limit_reached = len(relativized) >= limit
+        raw_output = "\n".join(relativized)
+        truncation = truncate_head(raw_output)
+
+        result_output = truncation.content
+        details: dict[str, Any] = {}
+        notices: list[str] = []
+
+        if result_limit_reached:
+            notices.append(f"{limit} results limit reached. Use limit={limit * 2} for more, or refine pattern")
+            details["result_limit_reached"] = limit
+
+        if truncation.truncated:
+            notices.append(f"{format_size(DEFAULT_MAX_BYTES)} limit reached")
+            details["truncation"] = truncation.__dict__
+
+        if notices:
+            result_output += f"\n\n[{'. '.join(notices)}]"
+
+        return AgentToolResult(
+            content=[TextContent(type="text", text=result_output)],
+            details=details if details else None,
+        )
+
+    except Exception as e:
+        return AgentToolResult(
+            content=[TextContent(type="text", text=f"Error running find: {e}")],
+            details={"error": str(e)},
+        )
+
+
+def create_find_tool(cwd: str, options: dict[str, Any] | None = None) -> AgentTool:
+    return AgentTool(
+        name="find",
+        label="Find",
+        description=f"Search for files by glob pattern. Returns matching file paths relative to the search directory. Respects .gitignore. Output is truncated to {DEFAULT_LIMIT} results or {DEFAULT_MAX_BYTES // 1024}KB (whichever is hit first).",
+        parameters=_FIND_TOOL_PARAMETERS,
+        execute=lambda tool_call_id, params, cancel_event, on_update: _execute_find(
+            tool_call_id, params, cwd, cancel_event, on_update
+        ),
+    )
+
+
+find_tool = create_find_tool(os.getcwd())

pi_coding/tools/grep.py

@@ -0,0 +1,280 @@
+"""Grep tool - searches file contents using ripgrep with context lines."""
+
+from __future__ import annotations
+
+import asyncio
+import json
+import os
+import shutil
+from pi_agent.types import AgentToolUpdateCallback
+from typing import Any
+
+from pi_agent import AgentTool, AgentToolResult
+from pi_ai.types import TextContent
+
+from pi_coding.utils import (
+    DEFAULT_MAX_BYTES,
+    GREP_MAX_LINE_LENGTH,
+    format_size,
+    resolve_to_cwd,
+    truncate_head,
+    truncate_line,
+)
+
+DEFAULT_LIMIT = 100
+
+_GREP_TOOL_PARAMETERS = {
+    "type": "object",
+    "properties": {
+        "pattern": {
+            "type": "string",
+            "description": "Search pattern (regex or literal string)",
+        },
+        "path": {
+            "type": "string",
+            "description": "Directory or file to search (default: current directory)",
+        },
+        "glob": {
+            "type": "string",
+            "description": "Filter files by glob pattern, e.g. '*.ts' or '**/*.spec.ts'",
+        },
+        "ignore_case": {
+            "type": "boolean",
+            "description": "Case-insensitive search (default: false)",
+        },
+        "literal": {
+            "type": "boolean",
+            "description": "Treat pattern as literal string instead of regex (default: false)",
+        },
+        "context": {
+            "type": "number",
+            "description": "Number of lines to show before and after each match (default: 0)",
+        },
+        "limit": {
+            "type": "number",
+            "description": "Maximum number of matches to return (default: 100)",
+        },
+    },
+    "required": ["pattern"],
+}
+
+
+async def _execute_grep(
+    tool_call_id: str,
+    params: dict[str, Any],
+    cwd: str,
+    cancel_event: asyncio.Event | None,
+    on_update: AgentToolUpdateCallback | None,
+) -> AgentToolResult:
+    pattern = params.get("pattern")
+    search_dir = params.get("path", ".")
+    glob_pattern = params.get("glob")
+    ignore_case = params.get("ignore_case", False)
+    literal = params.get("literal", False)
+    context = params.get("context", 0)
+    limit = params.get("limit", DEFAULT_LIMIT)
+
+    if not pattern:
+        return AgentToolResult(
+            content=[TextContent(type="text", text="Error: 'pattern' parameter is required")],
+            details={"error": "missing_parameter"},
+        )
+
+    rg_path = shutil.which("rg")
+    if not rg_path:
+        return AgentToolResult(
+            content=[TextContent(type="text", text="Error: ripgrep (rg) is not available")],
+            details={"error": "rg_not_found"},
+        )
+
+    search_path = resolve_to_cwd(search_dir, cwd)
+
+    if not os.path.exists(search_path):
+        return AgentToolResult(
+            content=[TextContent(type="text", text=f"Error: Path not found: {search_path}")],
+            details={"error": "path_not_found", "path": search_path},
+        )
+
+    is_directory = os.path.isdir(search_path)
+    context_value = max(0, context) if context else 0
+    effective_limit = max(1, limit)
+
+    def format_path(file_path: str) -> str:
+        if is_directory:
+            try:
+                relative = os.path.relpath(file_path, search_path)
+                if not relative.startswith(".."):
+                    return relative.replace("\\", "/")
+            except ValueError:
+                pass
+        return os.path.basename(file_path)
+
+    args = [rg_path, "--json", "--line-number", "--color=never", "--hidden"]
+
+    if ignore_case:
+        args.append("--ignore-case")
+
+    if literal:
+        args.append("--fixed-strings")
+
+    if glob_pattern:
+        args.extend(["--glob", glob_pattern])
+
+    args.extend([pattern, search_path])
+
+    if cancel_event and cancel_event.is_set():
+        return AgentToolResult(
+            content=[TextContent(type="text", text="Operation aborted")],
+            details={"error": "aborted"},
+        )
+
+    try:
+        process = await asyncio.create_subprocess_exec(
+            *args,
+            stdout=asyncio.subprocess.PIPE,
+            stderr=asyncio.subprocess.PIPE,
+        )
+
+        matches: list[tuple[str, int]] = []
+        output_lines: list[str] = []
+        match_count = 0
+        match_limit_reached = False
+        lines_truncated = False
+
+        file_cache: dict[str, list[str]] = {}
+
+        def get_file_lines(file_path: str) -> list[str]:
+            if file_path not in file_cache:
+                try:
+                    with open(file_path, encoding="utf-8", errors="replace") as f:
+                        content = f.read().replace("\r\n", "\n").replace("\r", "\n")
+                        file_cache[file_path] = content.split("\n")
+                except Exception:
+                    file_cache[file_path] = []
+            return file_cache[file_path]
+
+        def format_block(file_path: str, line_number: int) -> list[str]:
+            relative_path = format_path(file_path)
+            lines = get_file_lines(file_path)
+            if not lines:
+                return [f"{relative_path}:{line_number}: (unable to read file)"]
+
+            block: list[str] = []
+            start = max(1, line_number - context_value) if context_value > 0 else line_number
+            end = min(len(lines), line_number + context_value) if context_value > 0 else line_number
+
+            for current in range(start, end + 1):
+                line_text = lines[current - 1] if current <= len(lines) else ""
+                nonlocal lines_truncated
+                truncated_text, was_truncated = truncate_line(line_text, GREP_MAX_LINE_LENGTH)
+                if was_truncated:
+                    lines_truncated = True
+
+                if current == line_number:
+                    block.append(f"{relative_path}:{current}: {truncated_text}")
+                else:
+                    block.append(f"{relative_path}-{current}- {truncated_text}")
+
+            return block
+
+        if process.stdout is None:
+            return AgentToolResult(
+                content=[TextContent(type="text", text="Error: Failed to read ripgrep output")],
+                details={"error": "no_stdout"},
+            )
+
+        while True:
+            try:
+                line = await process.stdout.readline()
+                if not line:
+                    break
+
+                line_text = line.decode("utf-8", errors="replace").strip()
+                if not line_text or match_count >= effective_limit:
+                    continue
+
+                try:
+                    event = json.loads(line_text)
+                except json.JSONDecodeError:
+                    continue
+
+                if event.get("type") == "match":
+                    match_count += 1
+                    file_path = event.get("data", {}).get("path", {}).get("text", "")
+                    line_number = event.get("data", {}).get("line_number")
+
+                    if file_path and isinstance(line_number, int):
+                        matches.append((file_path, line_number))
+
+                    if match_count >= effective_limit:
+                        match_limit_reached = True
+                        process.kill()
+                        break
+
+            except asyncio.CancelledError:
+                break
+
+        await process.wait()
+
+        if cancel_event and cancel_event.is_set():
+            return AgentToolResult(
+                content=[TextContent(type="text", text="Operation aborted")],
+                details={"error": "aborted"},
+            )
+
+        if match_count == 0:
+            return AgentToolResult(
+                content=[TextContent(type="text", text="No matches found")],
+                details={"pattern": pattern, "matches": 0},
+            )
+
+        for file_path, line_number in matches:
+            output_lines.extend(format_block(file_path, line_number))
+
+        raw_output = "\n".join(output_lines)
+        truncation = truncate_head(raw_output)
+
+        output = truncation.content
+        details: dict[str, Any] = {}
+        notices: list[str] = []
+
+        if match_limit_reached:
+            notices.append(f"{effective_limit} matches limit reached. Use limit={effective_limit * 2} for more, or refine pattern")
+            details["match_limit_reached"] = effective_limit
+
+        if truncation.truncated:
+            notices.append(f"{format_size(DEFAULT_MAX_BYTES)} limit reached")
+            details["truncation"] = truncation.__dict__
+
+        if lines_truncated:
+            notices.append(f"Some lines truncated to {GREP_MAX_LINE_LENGTH} chars. Use read tool to see full lines")
+            details["lines_truncated"] = True
+
+        if notices:
+            output += f"\n\n[{'. '.join(notices)}]"
+
+        return AgentToolResult(
+            content=[TextContent(type="text", text=output)],
+            details=details if details else None,
+        )
+
+    except Exception as e:
+        return AgentToolResult(
+            content=[TextContent(type="text", text=f"Error running grep: {e}")],
+            details={"error": str(e)},
+        )
+
+
+def create_grep_tool(cwd: str, options: dict[str, Any] | None = None) -> AgentTool:
+    return AgentTool(
+        name="grep",
+        label="Grep",
+        description=f"Search file contents for a pattern. Returns matching lines with file paths and line numbers. Respects .gitignore. Output is truncated to {DEFAULT_LIMIT} matches or {DEFAULT_MAX_BYTES // 1024}KB (whichever is hit first). Long lines are truncated to {GREP_MAX_LINE_LENGTH} chars.",
+        parameters=_GREP_TOOL_PARAMETERS,
+        execute=lambda tool_call_id, params, cancel_event, on_update: _execute_grep(
+            tool_call_id, params, cwd, cancel_event, on_update
+        ),
+    )
+
+
+grep_tool = create_grep_tool(os.getcwd())