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

pi_coding/__init__.py

@@ -0,0 +1,215 @@
+from __future__ import annotations
+
+import os
+from typing import Any
+
+from pi_agent import Agent
+
+from pi_coding.config import (
+    ENV_AGENT_DIR,
+    VERSION,
+    get_agent_dir,
+    get_bin_dir,
+    get_sessions_dir,
+    get_settings_path,
+)
+from pi_coding.core.defaults import DEFAULT_THINKING_LEVEL
+from pi_coding.tools import (
+    all_tools,
+    bash_tool,
+    coding_tools,
+    create_all_tools,
+    create_bash_tool,
+    create_coding_tools,
+    create_edit_tool,
+    create_find_tool,
+    create_grep_tool,
+    create_ls_tool,
+    create_read_only_tools,
+    create_read_tool,
+    create_write_tool,
+    edit_tool,
+    find_tool,
+    grep_tool,
+    ls_tool,
+    read_only_tools,
+    read_tool,
+    write_tool,
+)
+from pi_coding.utils import (
+    DEFAULT_MAX_BYTES,
+    DEFAULT_MAX_LINES,
+    EditDiffError,
+    EditDiffResult,
+    FuzzyMatchResult,
+    GREP_MAX_LINE_LENGTH,
+    TruncationOptions,
+    TruncationResult,
+    compute_edit_diff,
+    detect_line_ending,
+    expand_path,
+    file_exists,
+    format_size,
+    fuzzy_find_text,
+    generate_diff_string,
+    normalize_for_fuzzy_match,
+    normalize_to_lf,
+    resolve_read_path,
+    resolve_to_cwd,
+    restore_line_endings,
+    strip_bom,
+    truncate_head,
+    truncate_line,
+    truncate_tail,
+)
+
+__all__ = [
+    "get_coding_tools",
+    "get_read_only_tools",
+    "get_all_tools",
+    "create_coding_agent",
+    "CodingAgentConfig",
+    "read_tool",
+    "write_tool",
+    "edit_tool",
+    "bash_tool",
+    "ls_tool",
+    "grep_tool",
+    "find_tool",
+    "create_read_tool",
+    "create_write_tool",
+    "create_edit_tool",
+    "create_bash_tool",
+    "create_ls_tool",
+    "create_grep_tool",
+    "create_find_tool",
+    "coding_tools",
+    "read_only_tools",
+    "all_tools",
+    "create_coding_tools",
+    "create_read_only_tools",
+    "create_all_tools",
+    "DEFAULT_MAX_BYTES",
+    "DEFAULT_MAX_LINES",
+    "GREP_MAX_LINE_LENGTH",
+    "TruncationOptions",
+    "TruncationResult",
+    "format_size",
+    "truncate_head",
+    "truncate_tail",
+    "truncate_line",
+    "expand_path",
+    "resolve_to_cwd",
+    "resolve_read_path",
+    "file_exists",
+    "detect_line_ending",
+    "normalize_to_lf",
+    "restore_line_endings",
+    "normalize_for_fuzzy_match",
+    "fuzzy_find_text",
+    "FuzzyMatchResult",
+    "strip_bom",
+    "generate_diff_string",
+    "compute_edit_diff",
+    "EditDiffResult",
+    "EditDiffError",
+    # Configuration
+    "VERSION",
+    "ENV_AGENT_DIR",
+    "get_agent_dir",
+    "get_bin_dir",
+    "get_sessions_dir",
+    "get_settings_path",
+    # Defaults
+    "DEFAULT_THINKING_LEVEL",
+]
+
+
+def get_coding_tools(cwd: str | None = None) -> list:
+    return create_coding_tools(cwd or os.getcwd())
+
+
+def get_read_only_tools(cwd: str | None = None) -> list:
+    return create_read_only_tools(cwd or os.getcwd())
+
+
+def get_all_tools(cwd: str | None = None) -> list:
+    return create_all_tools(cwd or os.getcwd())
+
+
+class CodingAgentConfig:
+    def __init__(
+        self,
+        model: Any = None,
+        system_prompt: str | None = None,
+        working_dir: str | None = None,
+        tools: list | None = None,
+    ):
+        self.model = model
+        self.system_prompt = system_prompt
+        self.working_dir = working_dir
+        self.tools = tools
+
+
+def create_coding_agent(
+    config: CodingAgentConfig | None = None,
+    **kwargs: Any,
+) -> Agent:
+    cfg = config or CodingAgentConfig()
+
+    cwd = cfg.working_dir or os.getcwd()
+
+    system_prompt = cfg.system_prompt or """You are an expert coding assistant with access to file system tools.
+
+## Core Principles
+
+1. **Read before writing**: Always read files before suggesting changes
+2. **Be precise**: Use exact string matches when editing
+3. **Show context**: Display file previews before editing
+4. **Explain changes**: Clearly describe what you're changing and why
+5. **Handle errors**: Gracefully report errors and suggest solutions
+
+## Available Tools
+
+### File Operations
+- **read**: Read file contents with line numbers, supports images
+- **write**: Create or overwrite files (creates directories)
+- **edit**: Search and replace text in files (exact match required)
+
+### Search & Navigation
+- **ls**: List directory contents with type indicators
+- **grep**: Search file contents using ripgrep
+- **find**: Find files by glob pattern using fd
+
+### Execution
+- **bash**: Execute shell commands with streaming output
+
+## Workflow
+
+When asked to make code changes:
+1. Use ls to understand structure
+2. Read relevant files
+3. Explain what you're going to do
+4. Make changes with edit or write
+5. Verify changes by reading back
+
+## Best Practices
+
+- Use relative paths when possible
+- Check if files exist before editing
+- Be conservative with replacements
+- Provide clear, concise explanations"""
+
+    tools = cfg.tools or create_coding_tools(cwd)
+
+    agent = Agent(
+        options={
+            "model": cfg.model,
+            "tools": tools,
+            **kwargs,
+        }
+    )
+
+    agent.set_system_prompt(system_prompt)
+
+    return agent

pi_coding/config.py

@@ -0,0 +1,59 @@
+"""Configuration paths for pi_coding agent."""
+
+import os
+from pathlib import Path
+
+# Version from package (can be updated)
+VERSION = "0.1.0"
+
+# App configuration
+APP_NAME = "pi"
+CONFIG_DIR_NAME = ".pi"
+
+# Environment variable for custom agent directory
+ENV_AGENT_DIR = f"{APP_NAME.upper()}_CODING_AGENT_DIR"
+
+
+def get_agent_dir() -> Path:
+    """Get the agent config directory (e.g., ~/.pi/agent/).
+    
+    Checks ENV_AGENT_DIR first, then uses default ~/.pi/agent/
+    
+    Returns:
+        Path to agent directory
+    """
+    env_dir = os.environ.get(ENV_AGENT_DIR)
+    if env_dir:
+        if env_dir == "~":
+            return Path.home()
+        if env_dir.startswith("~/"):
+            return Path.home() / env_dir[2:]
+        return Path(env_dir)
+    return Path.home() / CONFIG_DIR_NAME / "agent"
+
+
+def get_sessions_dir() -> Path:
+    """Get the sessions directory (e.g., ~/.pi/agent/sessions/).
+    
+    Returns:
+        Path to sessions directory
+    """
+    return get_agent_dir() / "sessions"
+
+
+def get_settings_path() -> Path:
+    """Get path to settings.json (e.g., ~/.pi/agent/settings.json).
+    
+    Returns:
+        Path to settings.json file
+    """
+    return get_agent_dir() / "settings.json"
+
+
+def get_bin_dir() -> Path:
+    """Get path to managed binaries directory (fd, rg).
+    
+    Returns:
+        Path to bin directory
+    """
+    return get_agent_dir() / "bin"

pi_coding/core/__init__.py

@@ -0,0 +1,5 @@
+"""Core module for pi_coding."""
+
+from pi_coding.core.defaults import DEFAULT_THINKING_LEVEL
+
+__all__ = ["DEFAULT_THINKING_LEVEL"]

pi_coding/core/defaults.py

@@ -0,0 +1,4 @@
+"""Core default constants for pi_coding module."""
+
+# Default thinking level for agent reasoning
+DEFAULT_THINKING_LEVEL = "medium"

pi_coding/tools/__init__.py

@@ -0,0 +1,70 @@
+"""Coding agent tools - read, write, edit, bash, ls, grep, find."""
+
+from __future__ import annotations
+
+from pi_coding.tools.bash import bash_tool, create_bash_tool
+from pi_coding.tools.edit import edit_tool, create_edit_tool
+from pi_coding.tools.find import find_tool, create_find_tool
+from pi_coding.tools.grep import grep_tool, create_grep_tool
+from pi_coding.tools.ls import ls_tool, create_ls_tool
+from pi_coding.tools.read import read_tool, create_read_tool
+from pi_coding.tools.write import write_tool, create_write_tool
+
+coding_tools = [read_tool, bash_tool, edit_tool, write_tool]
+read_only_tools = [read_tool, bash_tool, ls_tool, grep_tool, find_tool]
+all_tools = [read_tool, write_tool, edit_tool, bash_tool, ls_tool, grep_tool, find_tool]
+
+
+def create_coding_tools(cwd: str) -> list:
+    return [
+        create_read_tool(cwd),
+        create_bash_tool(cwd),
+        create_edit_tool(cwd),
+        create_write_tool(cwd),
+    ]
+
+
+def create_read_only_tools(cwd: str) -> list:
+    return [
+        create_read_tool(cwd),
+        create_bash_tool(cwd),
+        create_ls_tool(cwd),
+        create_grep_tool(cwd),
+        create_find_tool(cwd),
+    ]
+
+
+def create_all_tools(cwd: str) -> list:
+    return [
+        create_read_tool(cwd),
+        create_write_tool(cwd),
+        create_edit_tool(cwd),
+        create_bash_tool(cwd),
+        create_ls_tool(cwd),
+        create_grep_tool(cwd),
+        create_find_tool(cwd),
+    ]
+
+
+__all__ = [
+    "read_tool",
+    "write_tool",
+    "edit_tool",
+    "bash_tool",
+    "ls_tool",
+    "grep_tool",
+    "find_tool",
+    "create_read_tool",
+    "create_write_tool",
+    "create_edit_tool",
+    "create_bash_tool",
+    "create_ls_tool",
+    "create_grep_tool",
+    "create_find_tool",
+    "coding_tools",
+    "read_only_tools",
+    "all_tools",
+    "create_coding_tools",
+    "create_read_only_tools",
+    "create_all_tools",
+]

pi_coding/tools/bash.py

@@ -0,0 +1,213 @@
+"""Bash tool - executes shell commands with streaming output and truncation."""
+
+from __future__ import annotations
+
+import asyncio
+import os
+import tempfile
+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, DEFAULT_MAX_LINES, format_size, truncate_tail
+
+_BASH_TOOL_PARAMETERS = {
+    "type": "object",
+    "properties": {
+        "command": {
+            "type": "string",
+            "description": "Bash command to execute",
+        },
+        "timeout": {
+            "type": "number",
+            "description": "Timeout in seconds (optional, no default timeout)",
+        },
+    },
+    "required": ["command"],
+}
+
+
+async def _execute_bash(
+    tool_call_id: str,
+    params: dict[str, Any],
+    cwd: str,
+    cancel_event: asyncio.Event | None,
+    on_update: AgentToolUpdateCallback | None,
+) -> AgentToolResult:
+    command = params.get("command")
+    timeout = params.get("timeout")
+
+    if not command:
+        return AgentToolResult(
+            content=[TextContent(type="text", text="Error: 'command' parameter is required")],
+            details={"error": "missing_parameter"},
+        )
+
+    if cancel_event and cancel_event.is_set():
+        return AgentToolResult(
+            content=[TextContent(type="text", text="Operation aborted")],
+            details={"error": "aborted"},
+        )
+
+    shell = os.environ.get("SHELL", "/bin/bash")
+    temp_file: tempfile._TemporaryFileWrapper | None = None
+    temp_file_path: str | None = None
+
+    chunks: list[bytes] = []
+    chunks_bytes = 0
+    max_chunks_bytes = DEFAULT_MAX_BYTES * 2
+    total_bytes = 0
+
+    try:
+        process = await asyncio.create_subprocess_shell(
+            command,
+            cwd=cwd,
+            shell=True,
+            stdout=asyncio.subprocess.PIPE,
+            stderr=asyncio.subprocess.STDOUT,
+            executable=shell,
+        )
+
+        async def read_stream():
+            nonlocal total_bytes, chunks_bytes, temp_file, temp_file_path
+
+            if process.stdout is None:
+                return
+
+            while True:
+                try:
+                    chunk = await process.stdout.read(4096)
+                    if not chunk:
+                        break
+
+                    total_bytes += len(chunk)
+
+                    if total_bytes > DEFAULT_MAX_BYTES and temp_file is None:
+                        temp_file = tempfile.NamedTemporaryFile(
+                            mode="wb", suffix=".log", prefix="pi-bash-", delete=False
+                        )
+                        temp_file_path = temp_file.name
+                        for c in chunks:
+                            temp_file.write(c)
+
+                    if temp_file:
+                        temp_file.write(chunk)
+
+                    chunks.append(chunk)
+                    chunks_bytes += len(chunk)
+
+                    while chunks_bytes > max_chunks_bytes and len(chunks) > 1:
+                        removed = chunks.pop(0)
+                        chunks_bytes -= len(removed)
+
+                    if on_update:
+                        full_buffer = b"".join(chunks)
+                        full_text = full_buffer.decode("utf-8", errors="replace")
+                        truncation = truncate_tail(full_text)
+                        on_update(
+                            AgentToolResult(
+                                content=[TextContent(type="text", text=truncation.content or "")],
+                                details={
+                                    "truncation": truncation.__dict__ if truncation.truncated else None,
+                                    "full_output_path": temp_file_path,
+                                },
+                            )
+                        )
+
+                except asyncio.CancelledError:
+                    break
+
+        read_task = asyncio.create_task(read_stream())
+
+        try:
+            if timeout is not None and timeout > 0:
+                await asyncio.wait_for(process.wait(), timeout=timeout)
+            else:
+                await process.wait()
+        except asyncio.TimeoutError:
+            process.kill()
+            await process.wait()
+            if temp_file:
+                temp_file.close()
+            full_buffer = b"".join(chunks)
+            output = full_buffer.decode("utf-8", errors="replace")
+            return AgentToolResult(
+                content=[
+                    TextContent(
+                        type="text",
+                        text=f"{output}\n\nCommand timed out after {timeout} seconds",
+                    )
+                ],
+                details={"error": "timeout", "timeout": timeout, "command": command},
+            )
+
+        await read_task
+
+        if temp_file:
+            temp_file.close()
+
+        if cancel_event and cancel_event.is_set():
+            full_buffer = b"".join(chunks)
+            output = full_buffer.decode("utf-8", errors="replace")
+            return AgentToolResult(
+                content=[TextContent(type="text", text=f"{output}\n\nCommand aborted")],
+                details={"error": "aborted", "command": command},
+            )
+
+        full_buffer = b"".join(chunks)
+        full_output = full_buffer.decode("utf-8", errors="replace")
+        truncation = truncate_tail(full_output)
+        output_text = truncation.content or "(no output)"
+
+        details: dict[str, Any] = {}
+        if truncation.truncated:
+            details["truncation"] = truncation.__dict__
+            details["full_output_path"] = temp_file_path
+
+            start_line = truncation.total_lines - truncation.output_lines + 1
+            end_line = truncation.total_lines
+
+            if truncation.last_line_partial:
+                last_line_size = format_size(len(full_output.split("\n")[-1].encode("utf-8")))
+                output_text += f"\n\n[Showing last {format_size(truncation.output_bytes)} of line {end_line} (line is {last_line_size}). Full output: {temp_file_path}]"
+            elif truncation.truncated_by == "lines":
+                output_text += f"\n\n[Showing lines {start_line}-{end_line} of {truncation.total_lines}. Full output: {temp_file_path}]"
+            else:
+                output_text += f"\n\n[Showing lines {start_line}-{end_line} of {truncation.total_lines} ({format_size(DEFAULT_MAX_BYTES)} limit). Full output: {temp_file_path}]"
+
+        if process.returncode is not None and process.returncode != 0:
+            output_text += f"\n\nCommand exited with code {process.returncode}"
+            return AgentToolResult(
+                content=[TextContent(type="text", text=output_text)],
+                details={"error": "nonzero_exit", "exit_code": process.returncode, **details},
+            )
+
+        return AgentToolResult(
+            content=[TextContent(type="text", text=output_text)],
+            details=details if details else None,
+        )
+
+    except Exception as e:
+        if temp_file:
+            temp_file.close()
+        return AgentToolResult(
+            content=[TextContent(type="text", text=f"Error running command: {e}")],
+            details={"error": str(e), "command": command},
+        )
+
+
+def create_bash_tool(cwd: str, options: dict[str, Any] | None = None) -> AgentTool:
+    return AgentTool(
+        name="bash",
+        label="Bash",
+        description=f"Execute a bash command in the current working directory. Returns stdout and stderr. Output is truncated to last {DEFAULT_MAX_LINES} lines or {DEFAULT_MAX_BYTES // 1024}KB (whichever is hit first). If truncated, full output is saved to a temp file. Optionally provide a timeout in seconds.",
+        parameters=_BASH_TOOL_PARAMETERS,
+        execute=lambda tool_call_id, params, cancel_event, on_update: _execute_bash(
+            tool_call_id, params, cwd, cancel_event, on_update
+        ),
+    )
+
+
+bash_tool = create_bash_tool(os.getcwd())