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

pi_coding/tools/ls.py

@@ -0,0 +1,126 @@
+"""Ls tool - lists directory contents with type indicators and truncation."""
+
+from __future__ import annotations
+
+import asyncio
+import os
+from pathlib import Path
+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 = 500
+
+_LS_TOOL_PARAMETERS = {
+    "type": "object",
+    "properties": {
+        "path": {
+            "type": "string",
+            "description": "Directory to list (default: current directory)",
+        },
+        "limit": {
+            "type": "number",
+            "description": "Maximum number of entries to return (default: 500)",
+        },
+    },
+    "required": [],
+}
+
+
+async def _execute_ls(
+    tool_call_id: str,
+    params: dict[str, Any],
+    cwd: str,
+    cancel_event: asyncio.Event | None,
+    on_update: AgentToolUpdateCallback | None,
+) -> AgentToolResult:
+    path = params.get("path", ".")
+    limit = params.get("limit", DEFAULT_LIMIT)
+
+    if cancel_event and cancel_event.is_set():
+        return AgentToolResult(
+            content=[TextContent(type="text", text="Operation aborted")],
+            details={"error": "aborted"},
+        )
+
+    dir_path = resolve_to_cwd(path, cwd)
+
+    if not os.path.exists(dir_path):
+        return AgentToolResult(
+            content=[TextContent(type="text", text=f"Error: Path not found: {dir_path}")],
+            details={"error": "path_not_found", "path": dir_path},
+        )
+
+    if not os.path.isdir(dir_path):
+        return AgentToolResult(
+            content=[TextContent(type="text", text=f"Error: Not a directory: {dir_path}")],
+            details={"error": "not_a_directory", "path": dir_path},
+        )
+
+    try:
+        entries = sorted(os.listdir(dir_path), key=lambda s: s.lower())
+    except PermissionError as e:
+        return AgentToolResult(
+            content=[TextContent(type="text", text=f"Error: Cannot read directory: {e}")],
+            details={"error": "permission_denied", "path": dir_path},
+        )
+
+    results: list[str] = []
+    entry_limit_reached = False
+
+    for entry in entries:
+        if len(results) >= limit:
+            entry_limit_reached = True
+            break
+
+        full_path = os.path.join(dir_path, entry)
+        suffix = "/" if os.path.isdir(full_path) else ""
+        results.append(entry + suffix)
+
+    if not results:
+        return AgentToolResult(
+            content=[TextContent(type="text", text="(empty directory)")],
+            details={"path": dir_path},
+        )
+
+    raw_output = "\n".join(results)
+    truncation = truncate_head(raw_output)
+
+    output = truncation.content
+    details: dict[str, Any] = {}
+    notices: list[str] = []
+
+    if entry_limit_reached:
+        notices.append(f"{limit} entries limit reached. Use limit={limit * 2} for more")
+        details["entry_limit_reached"] = limit
+
+    if truncation.truncated:
+        notices.append(f"{format_size(DEFAULT_MAX_BYTES)} limit reached")
+        details["truncation"] = truncation.__dict__
+
+    if notices:
+        output += f"\n\n[{'. '.join(notices)}]"
+
+    return AgentToolResult(
+        content=[TextContent(type="text", text=output)],
+        details=details if details else None,
+    )
+
+
+def create_ls_tool(cwd: str, options: dict[str, Any] | None = None) -> AgentTool:
+    return AgentTool(
+        name="ls",
+        label="List",
+        description=f"List directory contents. Returns entries sorted alphabetically, with '/' suffix for directories. Includes dotfiles. Output is truncated to {DEFAULT_LIMIT} entries or {DEFAULT_MAX_BYTES // 1024}KB (whichever is hit first).",
+        parameters=_LS_TOOL_PARAMETERS,
+        execute=lambda tool_call_id, params, cancel_event, on_update: _execute_ls(
+            tool_call_id, params, cwd, cancel_event, on_update
+        ),
+    )
+
+
+ls_tool = create_ls_tool(os.getcwd())

pi_coding/tools/read.py

@@ -0,0 +1,210 @@
+"""Read tool - reads file contents with line numbers and truncation."""
+
+from __future__ import annotations
+
+import asyncio
+import base64
+import os
+from pathlib import Path
+from typing import TYPE_CHECKING, Any, Callable
+
+from pi_agent import AgentTool, AgentToolResult
+from pi_agent.types import AgentToolUpdateCallback
+from pi_ai.types import ImageContent, TextContent
+
+from pi_coding.utils import (
+    DEFAULT_MAX_BYTES,
+    DEFAULT_MAX_LINES,
+    TruncationResult,
+    format_size,
+    resolve_read_path,
+    truncate_head,
+)
+
+if TYPE_CHECKING:
+    from pi_coding.utils import TruncationOptions
+
+IMAGE_EXTENSIONS = {".jpg", ".jpeg", ".png", ".gif", ".webp"}
+IMAGE_MIME_TYPES = {
+    ".jpg": "image/jpeg",
+    ".jpeg": "image/jpeg",
+    ".png": "image/png",
+    ".gif": "image/gif",
+    ".webp": "image/webp",
+}
+
+
+def _detect_image_mime_type(path: str) -> str | None:
+    ext = Path(path).suffix.lower()
+    return IMAGE_MIME_TYPES.get(ext)
+
+
+_READ_TOOL_PARAMETERS = {
+    "type": "object",
+    "properties": {
+        "path": {
+            "type": "string",
+            "description": "Path to the file to read (relative or absolute)",
+        },
+        "offset": {
+            "type": "number",
+            "description": "Line number to start reading from (1-indexed)",
+        },
+        "limit": {
+            "type": "number",
+            "description": "Maximum number of lines to read",
+        },
+    },
+    "required": ["path"],
+}
+
+
+async def _execute_read(
+    tool_call_id: str,
+    params: dict[str, Any],
+    cwd: str,
+    cancel_event: asyncio.Event | None,
+    on_update: AgentToolUpdateCallback | None,
+) -> AgentToolResult:
+    path = params.get("path")
+    offset = params.get("offset")
+    limit = params.get("limit")
+
+    if not path:
+        return AgentToolResult(
+            content=[TextContent(type="text", text="Error: 'path' parameter is required")],
+            details={"error": "missing_parameter"},
+        )
+
+    absolute_path = resolve_read_path(path, cwd)
+
+    if cancel_event and cancel_event.is_set():
+        return AgentToolResult(
+            content=[TextContent(type="text", text="Operation aborted")],
+            details={"error": "aborted"},
+        )
+
+    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},
+        )
+
+    if not os.path.isfile(absolute_path):
+        return AgentToolResult(
+            content=[TextContent(type="text", text=f"Error: Not a file: {path}")],
+            details={"error": "not_a_file", "path": absolute_path},
+        )
+
+    mime_type = _detect_image_mime_type(absolute_path)
+
+    if mime_type:
+        try:
+            with open(absolute_path, "rb") as f:
+                data = base64.standard_b64encode(f.read()).decode("utf-8")
+            return AgentToolResult(
+                content=[
+                    TextContent(type="text", text=f"Read image file [{mime_type}]"),
+                    ImageContent(type="image", data=data, mimeType=mime_type),
+                ],
+                details={"path": absolute_path, "mime_type": mime_type},
+            )
+        except Exception as e:
+            return AgentToolResult(
+                content=[TextContent(type="text", text=f"Error reading image: {e}")],
+                details={"error": str(e), "path": absolute_path},
+            )
+
+    try:
+        with open(absolute_path, encoding="utf-8") as f:
+            content = f.read()
+
+        if cancel_event and cancel_event.is_set():
+            return AgentToolResult(
+                content=[TextContent(type="text", text="Operation aborted")],
+                details={"error": "aborted"},
+            )
+
+        all_lines = content.split("\n")
+        total_file_lines = len(all_lines)
+
+        start_line = max(0, (offset or 1) - 1)
+        start_line_display = start_line + 1
+
+        if start_line >= total_file_lines:
+            return AgentToolResult(
+                content=[
+                    TextContent(
+                        type="text",
+                        text=f"Error: Offset {offset} is beyond end of file ({total_file_lines} lines total)",
+                    )
+                ],
+                details={"error": "offset_out_of_bounds", "total_lines": total_file_lines},
+            )
+
+        if limit is not None:
+            end_line = min(start_line + limit, total_file_lines)
+            selected_content = "\n".join(all_lines[start_line:end_line])
+            user_limited_lines = end_line - start_line
+        else:
+            selected_content = "\n".join(all_lines[start_line:])
+            user_limited_lines = None
+
+        truncation = truncate_head(selected_content)
+
+        if truncation.first_line_exceeds_limit:
+            first_line_size = format_size(len(all_lines[start_line].encode("utf-8")))
+            output_text = f"[Line {start_line_display} is {first_line_size}, exceeds {format_size(DEFAULT_MAX_BYTES)} limit. Use bash: sed -n '{start_line_display}p' {path} | head -c {DEFAULT_MAX_BYTES}]"
+            return AgentToolResult(
+                content=[TextContent(type="text", text=output_text)],
+                details={"truncation": truncation.__dict__},
+            )
+
+        if truncation.truncated:
+            end_line_display = start_line_display + truncation.output_lines - 1
+            next_offset = end_line_display + 1
+            output_text = truncation.content
+            if truncation.truncated_by == "lines":
+                output_text += f"\n\n[Showing lines {start_line_display}-{end_line_display} of {total_file_lines}. Use offset={next_offset} to continue.]"
+            else:
+                output_text += f"\n\n[Showing lines {start_line_display}-{end_line_display} of {total_file_lines} ({format_size(DEFAULT_MAX_BYTES)} limit). Use offset={next_offset} to continue.]"
+            return AgentToolResult(
+                content=[TextContent(type="text", text=output_text)],
+                details={"truncation": truncation.__dict__},
+            )
+
+        if user_limited_lines is not None and start_line + user_limited_lines < total_file_lines:
+            remaining = total_file_lines - (start_line + user_limited_lines)
+            next_offset = start_line + user_limited_lines + 1
+            output_text = truncation.content
+            output_text += f"\n\n[{remaining} more lines in file. Use offset={next_offset} to continue.]"
+            return AgentToolResult(
+                content=[TextContent(type="text", text=output_text)],
+                details={"total_lines": total_file_lines},
+            )
+
+        return AgentToolResult(
+            content=[TextContent(type="text", text=truncation.content)],
+            details={"path": absolute_path, "total_lines": total_file_lines},
+        )
+
+    except Exception as e:
+        return AgentToolResult(
+            content=[TextContent(type="text", text=f"Error reading file: {e}")],
+            details={"error": str(e), "path": absolute_path},
+        )
+
+
+def create_read_tool(cwd: str, options: dict[str, Any] | None = None) -> AgentTool:
+    return AgentTool(
+        name="read",
+        label="Read",
+        description=f"Read the contents of a file. Supports text files and images (jpg, png, gif, webp). Images are sent as attachments. For text files, output is truncated to {DEFAULT_MAX_LINES} lines or {DEFAULT_MAX_BYTES // 1024}KB (whichever is hit first). Use offset/limit for large files.",
+        parameters=_READ_TOOL_PARAMETERS,
+        execute=lambda tool_call_id, params, cancel_event, on_update: _execute_read(
+            tool_call_id, params, cwd, cancel_event, on_update
+        ),
+    )
+
+
+read_tool = create_read_tool(os.getcwd())

pi_coding/tools/write.py

@@ -0,0 +1,99 @@
+"""Write tool - writes content to files with automatic directory creation."""
+
+from __future__ import annotations
+
+import asyncio
+import os
+from pathlib import Path
+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 resolve_read_path
+
+_WRITE_TOOL_PARAMETERS = {
+    "type": "object",
+    "properties": {
+        "path": {
+            "type": "string",
+            "description": "Path to the file to write (relative or absolute)",
+        },
+        "content": {
+            "type": "string",
+            "description": "Content to write to the file",
+        },
+    },
+    "required": ["path", "content"],
+}
+
+
+async def _execute_write(
+    tool_call_id: str,
+    params: dict[str, Any],
+    cwd: str,
+    cancel_event: asyncio.Event | None,
+    on_update: AgentToolUpdateCallback | None,
+) -> AgentToolResult:
+    path = params.get("path")
+    content = params.get("content")
+
+    if not path or content is None:
+        return AgentToolResult(
+            content=[
+                TextContent(type="text", text="Error: 'path' and 'content' parameters are required")
+            ],
+            details={"error": "missing_parameters"},
+        )
+
+    absolute_path = resolve_read_path(path, cwd)
+
+    if cancel_event and cancel_event.is_set():
+        return AgentToolResult(
+            content=[TextContent(type="text", text="Operation aborted")],
+            details={"error": "aborted"},
+        )
+
+    try:
+        Path(absolute_path).parent.mkdir(parents=True, exist_ok=True)
+
+        if cancel_event and cancel_event.is_set():
+            return AgentToolResult(
+                content=[TextContent(type="text", text="Operation aborted")],
+                details={"error": "aborted"},
+            )
+
+        with open(absolute_path, "w", encoding="utf-8") as f:
+            f.write(content)
+
+        lines = content.count("\n") + 1
+        chars = len(content)
+
+        return AgentToolResult(
+            content=[
+                TextContent(type="text", text=f"Successfully wrote {lines} lines ({chars} chars) to {path}")
+            ],
+            details={"path": absolute_path, "line_count": lines, "char_count": chars},
+        )
+
+    except Exception as e:
+        return AgentToolResult(
+            content=[TextContent(type="text", text=f"Error writing file: {e}")],
+            details={"error": str(e), "path": absolute_path},
+        )
+
+
+def create_write_tool(cwd: str, options: dict[str, Any] | None = None) -> AgentTool:
+    return AgentTool(
+        name="write",
+        label="Write",
+        description="Write content to a file. Creates the file if it doesn't exist, overwrites if it does. Automatically creates parent directories.",
+        parameters=_WRITE_TOOL_PARAMETERS,
+        execute=lambda tool_call_id, params, cancel_event, on_update: _execute_write(
+            tool_call_id, params, cwd, cancel_event, on_update
+        ),
+    )
+
+
+write_tool = create_write_tool(os.getcwd())

pi_coding/utils/__init__.py

@@ -0,0 +1,91 @@
+"""Shared utility functions for pi_coding."""
+
+from pi_coding.utils.edit_diff import (
+    EditDiffError,
+    EditDiffResult,
+    FuzzyMatchResult,
+    compute_edit_diff,
+    detect_line_ending,
+    fuzzy_find_text,
+    generate_diff_string,
+    normalize_for_fuzzy_match,
+    normalize_to_lf,
+    restore_line_endings,
+    strip_bom,
+)
+from pi_coding.utils.git import (
+    GitSource,
+    get_current_branch,
+    get_repo_status,
+    parse_git_url,
+)
+from pi_coding.utils.path_utils import (
+    UNICODE_SPACES,
+    expand_path,
+    file_exists,
+    normalize_at_prefix,
+    normalize_unicode_spaces,
+    resolve_read_path,
+    resolve_to_cwd,
+    try_curly_quote_variant,
+    try_macos_screenshot_path,
+    try_nfd_variant,
+)
+from pi_coding.utils.shell import (
+    get_shell_config,
+    get_shell_env,
+    kill_process_tree,
+    sanitize_binary_output,
+)
+from pi_coding.utils.truncate import (
+    DEFAULT_MAX_BYTES,
+    DEFAULT_MAX_LINES,
+    GREP_MAX_LINE_LENGTH,
+    TruncationOptions,
+    TruncationResult,
+    format_size,
+    truncate_head,
+    truncate_line,
+    truncate_tail,
+)
+
+__all__ = [
+    "EditDiffError",
+    "EditDiffResult",
+    "FuzzyMatchResult",
+    "compute_edit_diff",
+    "detect_line_ending",
+    "fuzzy_find_text",
+    "generate_diff_string",
+    "normalize_for_fuzzy_match",
+    "normalize_to_lf",
+    "restore_line_endings",
+    "strip_bom",
+    "GitSource",
+    "get_current_branch",
+    "get_repo_status",
+    "parse_git_url",
+    "UNICODE_SPACES",
+    "expand_path",
+    "file_exists",
+    "normalize_at_prefix",
+    "normalize_unicode_spaces",
+    "resolve_read_path",
+    "resolve_to_cwd",
+    "try_curly_quote_variant",
+    "try_macos_screenshot_path",
+    "try_nfd_variant",
+    "get_shell_config",
+    "get_shell_env",
+    "kill_process_tree",
+    "sanitize_binary_output",
+    "DEFAULT_MAX_BYTES",
+    "DEFAULT_MAX_LINES",
+    "GREP_MAX_LINE_LENGTH",
+    "TruncationOptions",
+    "TruncationResult",
+    "format_size",
+    "truncate_head",
+    "truncate_line",
+    "truncate_tail",
+]