my-pi-agent 0.1.0

package/src/my_coding_agent/settings.py

@@ -0,0 +1,126 @@
+"""Settings: 全局 (~/.my-pi-agent/settings.json) 与项目双层级联配置系统。"""
+
+from __future__ import annotations
+
+import contextlib
+import json
+from pathlib import Path
+from typing import Any, Literal
+
+from pydantic import BaseModel, ConfigDict, Field
+
+from my_coding_agent.paths import AgentPaths
+
+# 特权字段：仅允许在全局 settings.json 中配置，项目级配置一律忽略
+PRIVILEGED_GLOBAL_KEYS: set[str] = {
+    "http_proxy",
+    "httpProxy",
+    "project_trust",
+    "projectTrust",
+}
+
+
+class CompactionSettings(BaseModel):
+    """上下文压缩管线配置参数。"""
+
+    enabled: bool = True
+    reserve_tokens: int = Field(default=16384, alias="reserveTokens")
+    keep_recent_tokens: int = Field(default=20000, alias="keepRecentTokens")
+
+    model_config = ConfigDict(populate_by_name=True)
+
+
+class Settings(BaseModel):
+    """统一管理全局偏好与项目覆盖的强类型配置实体。"""
+
+    # ── 默认模型与思考深度 ──
+    default_provider: str = Field(default="openai", alias="defaultProvider")
+    default_model: str = Field(default="deepseek-flash", alias="defaultModel")
+    default_thinking_level: Literal["off", "minimal", "low", "medium", "high", "xhigh", "max"] = Field(
+        default="off", alias="defaultThinkingLevel"
+    )
+    model_thinking_levels: dict[str, str] = Field(default_factory=dict, alias="modelThinkingLevels")
+
+    # ── UI 表现层 ──
+    theme: str = "dark"
+    quiet_startup: bool = Field(default=False, alias="quietStartup")
+    editor_padding_x: int = Field(default=0, alias="editorPaddingX")
+    show_hardware_cursor: bool = Field(default=False, alias="showHardwareCursor")
+
+    # ── 网络与代理 (特权级) ──
+    http_proxy: str | None = Field(default=None, alias="httpProxy")
+
+    # ── 会话与压缩管线 ──
+    compaction: CompactionSettings = Field(default_factory=CompactionSettings)
+    auto_save_session: bool = Field(default=True, alias="autoSaveSession")
+
+    # ── 权限与安全 ──
+    default_permission_mode: Literal["review", "yolo", "strict"] = Field(
+        default="review", alias="defaultPermissionMode"
+    )
+    project_trust: Literal["ask", "always", "never"] = Field(default="ask", alias="projectTrust")
+
+    model_config = ConfigDict(populate_by_name=True)
+
+
+def _deep_merge_dict(base: dict[str, Any], overrides: dict[str, Any]) -> dict[str, Any]:
+    """递归合并字典；数组/列表整体替换。"""
+    result = dict(base)
+    for k, v in overrides.items():
+        if k in result and isinstance(result[k], dict) and isinstance(v, dict):
+            result[k] = _deep_merge_dict(result[k], v)
+        else:
+            result[k] = v
+    return result
+
+
+def load_settings(paths: AgentPaths | None = None, cwd: Path | str | None = None) -> Settings:
+    """加载并级联合并全局与项目级配置。
+
+    优先级：默认内置值 < 全局 settings.json < 项目级 settings.json（受限覆盖）
+    """
+    active_paths = paths or AgentPaths()
+    merged: dict[str, Any] = {}
+
+    # 1. 全局配置
+    if active_paths.settings_path.exists():
+        try:
+            content = active_paths.settings_path.read_text(encoding="utf-8")
+            data = json.loads(content)
+            if isinstance(data, dict):
+                merged = dict(data)
+        except Exception:
+            pass
+
+    # 2. 项目级受控覆盖
+    if cwd:
+        proj_settings = active_paths.project_settings_path(Path(cwd))
+        if proj_settings.exists():
+            try:
+                content = proj_settings.read_text(encoding="utf-8")
+                data = json.loads(content)
+                if isinstance(data, dict):
+                    # 剥离项目级越权特权字段
+                    safe_data = {k: v for k, v in data.items() if k not in PRIVILEGED_GLOBAL_KEYS}
+                    merged = _deep_merge_dict(merged, safe_data)
+            except Exception:
+                pass
+
+    try:
+        return Settings.model_validate(merged)
+    except Exception:
+        return Settings()
+
+
+def save_settings(settings: Settings, target_path: Path) -> None:
+    """以 0o600 权限与临时文件原子替换保存配置。"""
+    resolved_target = Path(target_path).resolve()
+    resolved_target.parent.mkdir(parents=True, exist_ok=True)
+    tmp_path = resolved_target.with_name(f"{resolved_target.name}.tmp")
+    tmp_path.write_text(
+        settings.model_dump_json(by_alias=True, indent=2) + "\n",
+        encoding="utf-8",
+    )
+    with contextlib.suppress(Exception):
+        tmp_path.chmod(0o600)
+    tmp_path.replace(resolved_target)

package/src/my_coding_agent/tools/__init__.py

@@ -0,0 +1,55 @@
+"""文件工具包：7 个核心工具工厂（对齐 Pi 原厂 read/write/edit/bash/grep/find/ls）+ build_coding_tools 装配入口。"""
+
+from pathlib import Path
+from typing import TYPE_CHECKING
+
+from my_agent_core.tools import Tool  # pyright: ignore[reportMissingImports]
+
+if TYPE_CHECKING:
+    from my_agent_core.background import (  # pyright: ignore[reportMissingImports]
+        BackgroundRunner,
+    )
+
+from my_coding_agent.mutation_queue import FileMutationQueue
+from my_coding_agent.tools.base import is_binary_file, resolve_path
+from my_coding_agent.tools.bash import make_bash_tool
+from my_coding_agent.tools.edit import EditBlock, make_edit_tool
+from my_coding_agent.tools.find import make_find_tool
+from my_coding_agent.tools.grep import make_grep_tool
+from my_coding_agent.tools.ls import make_ls_tool
+from my_coding_agent.tools.read import make_read_tool
+from my_coding_agent.tools.write import make_write_tool
+
+
+def build_coding_tools(
+    workspace: str | Path,
+    mutation_queue: FileMutationQueue | None = None,
+    background_runner: "BackgroundRunner | None" = None,
+) -> list[Tool]:
+    """返回 7 个核心文件工具（read/write/edit/bash/grep/find/ls），各绑定 workspace。"""
+    workspace_path = Path(workspace).resolve()
+    queue = mutation_queue or FileMutationQueue()
+    return [
+        make_read_tool(workspace_path),
+        make_write_tool(workspace_path, mutation_queue=queue),
+        make_edit_tool(workspace_path, mutation_queue=queue),
+        make_bash_tool(workspace_path, background_runner=background_runner),
+        make_grep_tool(workspace_path),
+        make_find_tool(workspace_path),
+        make_ls_tool(workspace_path),
+    ]
+
+
+__all__ = [
+    "build_coding_tools",
+    "resolve_path",
+    "is_binary_file",
+    "make_read_tool",
+    "make_write_tool",
+    "make_edit_tool",
+    "EditBlock",
+    "make_bash_tool",
+    "make_grep_tool",
+    "make_find_tool",
+    "make_ls_tool",
+]

package/src/my_coding_agent/tools/base.py

@@ -0,0 +1,58 @@
+from __future__ import annotations
+
+from dataclasses import dataclass
+from pathlib import Path
+from typing import Any
+
+from my_agent_core.tools import ToolResult  # pyright: ignore[reportMissingImports]
+
+DEFAULT_MAX_LINES = 2000
+DEFAULT_MAX_BYTES = 50 * 1024  # 50KB
+DEFAULT_IGNORE_DIRS = {
+    ".git",
+    ".venv",
+    "node_modules",
+    "__pycache__",
+    ".pytest_cache",
+    ".ruff_cache",
+}
+
+
+def resolve_path(workspace: Path, p: str | Path) -> Path:
+    raw = Path(p)
+    if raw.is_absolute():
+        return raw.resolve()
+    return (workspace / raw).resolve()
+
+
+def is_binary_file(path: Path) -> bool:
+    try:
+        with open(path, "rb") as f:
+            chunk = f.read(1024)
+            return b"\x00" in chunk
+    except Exception:
+        return False
+
+
+@dataclass
+class StringCompatibleToolResult(ToolResult):
+    """ToolResult 子类：提供字符串兼容比较、包含、转换操作。
+
+    共享基类，供 read/write/edit/bash/grep/find 工具继承，避免重复实现。
+    """
+
+    def __eq__(self, other: Any) -> bool:
+        if isinstance(other, str):
+            val = self.data if self.data is not None else self.error
+            return str(val) == other
+        return super().__eq__(other)
+
+    def __contains__(self, item: Any) -> bool:
+        content = self.data if self.data is not None else (self.error or "")
+        return str(item) in str(content)
+
+    def __str__(self) -> str:
+        return str(self.data if self.data is not None else self.error)
+
+    def __repr__(self) -> str:
+        return repr(self.data if self.data is not None else self.error)

package/src/my_coding_agent/tools/bash.py

@@ -0,0 +1,206 @@
+from __future__ import annotations
+
+import asyncio
+import contextlib
+import inspect
+import os
+import signal
+import sys
+import tempfile
+from collections.abc import Callable
+from pathlib import Path
+from typing import Any
+
+from my_agent_core.background import BackgroundRunner
+from my_agent_core.tools import Tool, tool
+
+from my_coding_agent.tools.base import (
+    DEFAULT_MAX_BYTES,
+    DEFAULT_MAX_LINES,
+    StringCompatibleToolResult,
+)
+
+BLOCKED_COMMANDS = {
+    "rm -rf /",
+    "rm -rf /*",
+    "mkfs",
+    "dd if=/dev/zero",
+    ":(){ :|:& };:",
+    "shutdown",
+    "reboot",
+    "init 0",
+}
+
+
+def _kill_process_tree(pid: int) -> None:
+    """递归杀死指定 PID 的进程树，兼容 Windows 与 POSIX。"""
+    if sys.platform == "win32":
+        import subprocess
+
+        with contextlib.suppress(Exception):
+            subprocess.run(
+                ["taskkill", "/F", "/T", "/PID", str(pid)],
+                capture_output=True,
+                check=False,
+            )
+    else:
+        try:
+            pgid = os.getpgid(pid)
+            os.killpg(pgid, signal.SIGKILL)
+        except Exception:
+            with contextlib.suppress(Exception):
+                os.kill(pid, signal.SIGKILL)
+
+
+class BashResult(StringCompatibleToolResult):
+    """Bash 工具执行结果：继承 StringCompatibleToolResult。"""
+
+
+def make_bash_tool(
+    workspace: Path | str,
+    background_runner: BackgroundRunner | None = None,
+) -> Tool:
+    """创建 bash 工具工厂，绑定 workspace 目录并支持超时终结、日志外溢与后台运行。"""
+    workspace = Path(workspace).resolve()
+
+    @tool(
+        name="bash",
+        description="Execute a bash/shell command in the workspace with timeout protection and process tree killing.",
+        is_parallel_safe=False,
+    )
+    async def bash(
+        command: str,
+        timeout: int = 120,
+        run_in_background: bool = False,
+        on_update: Callable[[Any], None] | None = None,
+    ) -> str:
+        for blocked in BLOCKED_COMMANDS:
+            if blocked in command:
+                return f"Error: Blocked dangerous command pattern '{blocked}'."
+
+        if run_in_background:
+            if background_runner is None:
+                return "Error: Background task execution not configured on this agent."
+            res = background_runner.run_process(command, cwd=workspace)
+            task_id = await res if inspect.isawaitable(res) else res
+            return f"Background task started with ID: {task_id}"
+
+        try:
+            kwargs: dict[str, Any] = {
+                "cwd": str(workspace),
+                "stdout": asyncio.subprocess.PIPE,
+                "stderr": asyncio.subprocess.STDOUT,
+                "stdin": asyncio.subprocess.DEVNULL,
+            }
+            if sys.platform != "win32":
+                kwargs["preexec_fn"] = os.setsid
+
+            proc = await asyncio.create_subprocess_shell(command, **kwargs)
+
+            output_chunks: list[str] = []
+            loop = asyncio.get_running_loop()
+            last_update_time = loop.time()
+
+            async def _read_stream() -> None:
+                nonlocal last_update_time
+                if proc.stdout is None:
+                    return
+                while True:
+                    line_bytes = await proc.stdout.readline()
+                    if not line_bytes:
+                        break
+                    text = line_bytes.decode("utf-8", errors="replace")
+                    output_chunks.append(text)
+                    now = loop.time()
+                    if on_update is not None and (now - last_update_time >= 0.1):
+                        last_update_time = now
+                        tail_preview = "".join(output_chunks[-5:]).strip()
+                        if tail_preview:
+                            on_update(tail_preview)
+
+            try:
+                await asyncio.wait_for(_read_stream(), timeout=timeout)
+                await proc.wait()
+                output = "".join(output_chunks)
+            except asyncio.TimeoutError:
+                if proc.pid:
+                    _kill_process_tree(proc.pid)
+                    with contextlib.suppress(Exception):
+                        await asyncio.wait_for(proc.wait(), timeout=2.0)
+                return f"Error: Command timed out after {timeout} seconds: {command}"
+            except (asyncio.CancelledError, GeneratorExit):
+                if proc.pid:
+                    _kill_process_tree(proc.pid)
+                    with contextlib.suppress(Exception):
+                        await asyncio.wait_for(proc.wait(), timeout=2.0)
+                raise
+
+            exit_code = proc.returncode
+
+            # 处理尾部截断与外溢至临时日志文件
+            lines = output.splitlines()
+            total_lines = len(lines)
+            encoded = output.encode("utf-8")
+            is_overflow = total_lines > DEFAULT_MAX_LINES or len(encoded) > DEFAULT_MAX_BYTES
+
+            if is_overflow:
+                with tempfile.NamedTemporaryFile(
+                    mode="w",
+                    prefix="pi-bash-",
+                    suffix=".log",
+                    delete=False,
+                    encoding="utf-8",
+                ) as f:
+                    f.write(output)
+                    temp_log_path = f.name
+
+                truncated_lines = lines[-DEFAULT_MAX_LINES:]
+                truncated_text = "\n".join(truncated_lines)
+                trunc_bytes = truncated_text.encode("utf-8")
+                if len(trunc_bytes) > DEFAULT_MAX_BYTES:
+                    tail_bytes = trunc_bytes[-DEFAULT_MAX_BYTES:]
+                    nl_pos = tail_bytes.find(b"\n")
+                    if nl_pos != -1 and nl_pos + 1 < len(tail_bytes):
+                        tail_bytes = tail_bytes[nl_pos + 1 :]
+                    truncated_text = tail_bytes.decode("utf-8", errors="ignore")
+                    truncated_lines = truncated_text.splitlines()
+
+                output = (
+                    f"[Output truncated: showing last {len(truncated_lines)} lines of {total_lines}. "
+                    f"Full output saved to: {temp_log_path}]\n\n{truncated_text}"
+                )
+
+            if exit_code != 0:
+                return f"Command failed with exit code {exit_code}:\n{output}"
+
+            return output or "(Command executed with no output)"
+        except Exception as e:
+            return f"Error: {e}"
+
+    orig_execute = bash.execute
+
+    async def execute(
+        args: dict[str, Any] | None = None,
+        signal: Any | None = None,
+        on_update: Callable[[Any], None] | None = None,
+        tool_call_id: str | None = None,
+        **kwargs: Any,
+    ) -> BashResult:
+        call_args = dict(args) if isinstance(args, dict) else {}
+        call_args.update(kwargs)
+        res = await orig_execute(
+            call_args,
+            signal=signal,
+            on_update=on_update,
+            tool_call_id=tool_call_id,
+        )
+        return BashResult(
+            ok=res.ok,
+            data=res.data,
+            error=res.error,
+            meta=res.meta,
+            terminate=res.terminate,
+        )
+
+    bash.execute = execute
+    return bash

package/src/my_coding_agent/tools/edit.py

@@ -0,0 +1,226 @@
+from __future__ import annotations
+
+import difflib
+import json
+from collections.abc import Callable
+from pathlib import Path
+from typing import Any
+
+from my_agent_core.tools import Tool, tool
+from pydantic import BaseModel, ConfigDict, Field
+
+from my_coding_agent.mutation_queue import FileMutationQueue
+from my_coding_agent.tools.base import (
+    StringCompatibleToolResult,
+    is_binary_file,
+    resolve_path,
+)
+
+
+class EditBlock(BaseModel):
+    """单个代码编辑块：精确旧文本与替换新文本。"""
+
+    model_config = ConfigDict(populate_by_name=True)
+
+    old_text: str = Field(..., alias="oldText", description="Exact original code block to replace")
+    new_text: str = Field(..., alias="newText", description="New code block to insert")
+
+
+class EditResult(StringCompatibleToolResult):
+    """Edit 工具执行结果：继承 StringCompatibleToolResult。"""
+
+
+def make_edit_tool(workspace: Path, mutation_queue: FileMutationQueue | None = None) -> Tool:
+    """创建工作区绑定的 edit 工具。
+
+    - workspace: 工作区根目录路径
+    - mutation_queue: 单文件并发互斥锁队列，缺省时自动新建
+    """
+    workspace = workspace.resolve()
+    queue = mutation_queue or FileMutationQueue()
+
+    @tool(
+        name="edit",
+        description="Surgically edit file using multi-edit atomic blocks and unified diff generation.",
+        is_parallel_safe=True,
+    )
+    async def edit(
+        path: str,
+        edits: list[dict] | list[EditBlock] | None = None,
+        old_text: str | None = None,
+        new_text: str | None = None,
+    ) -> str:
+        try:
+            target = resolve_path(workspace, path)
+            if not target.exists():
+                return f"Error: File not found: {path}"
+            if target.is_dir():
+                return f"Error: Path is a directory: {path}"
+            if is_binary_file(target):
+                return f"Error: Cannot edit binary file: {path}"
+
+            # 1. 规范化 edits 入参 (对标 Pi 官方 prepareEditArguments 容错)
+            raw_edits = edits
+            if isinstance(raw_edits, str):
+                try:
+                    parsed = json.loads(raw_edits)
+                    if isinstance(parsed, (list, dict)):
+                        raw_edits = parsed
+                except Exception:
+                    pass
+            elif isinstance(raw_edits, dict):
+                raw_edits = [raw_edits]
+
+            edit_blocks: list[EditBlock] = []
+            if raw_edits is not None and isinstance(raw_edits, list):
+                if len(raw_edits) == 0:
+                    return "Error: No edits provided."
+                for item in raw_edits:
+                    if isinstance(item, EditBlock):
+                        edit_blocks.append(item)
+                    elif isinstance(item, dict):
+                        old_val = item.get("oldText") if "oldText" in item else item.get("old_text")
+                        new_val = item.get("newText") if "newText" in item else item.get("new_text")
+                        if old_val is None or new_val is None:
+                            return (
+                                "Error: Each edit block must contain 'oldText' (or 'old_text') "
+                                "and 'newText' (or 'new_text')."
+                            )
+                        edit_blocks.append(EditBlock(old_text=str(old_val), new_text=str(new_val)))
+                    else:
+                        return f"Error: Invalid edit block type: {type(item).__name__}"
+            elif old_text is not None and new_text is not None:
+                edit_blocks.append(EditBlock(old_text=old_text, new_text=new_text))
+            else:
+                return "Error: Either 'edits' or ('old_text' and 'new_text') must be provided."
+
+            if not edit_blocks:
+                return "Error: No edits provided."
+
+            async with queue.acquire(target):
+                raw_bytes = target.read_bytes()
+
+                # 2. 探测 BOM
+                has_bom = raw_bytes.startswith(b"\xef\xbb\xbf")
+                clean_bytes = raw_bytes[3:] if has_bom else raw_bytes
+                try:
+                    content = clean_bytes.decode("utf-8")
+                except UnicodeDecodeError:
+                    return f"Error: File is not valid UTF-8: {path}"
+
+                # 3. 探测换行符并统一归一化为 LF
+                is_crlf = "\r\n" in content
+                normalized_content = content.replace("\r\n", "\n")
+
+                # 4. 预检所有 edit block（唯一匹配与非重叠校验）
+                matches: list[tuple[int, int, str, str, int]] = []
+                for i, b in enumerate(edit_blocks):
+                    old_norm = b.old_text.replace("\r\n", "\n")
+                    new_norm = b.new_text.replace("\r\n", "\n")
+                    if not old_norm:
+                        return f"Error: 'oldText' cannot be empty (edit #{i + 1})."
+
+                    count = normalized_content.count(old_norm)
+                    if count == 0:
+                        lines_count = len(normalized_content.splitlines())
+                        return (
+                            f"Error: 'oldText' not found in {path} (edit #{i + 1}). "
+                            f"The file has {lines_count} lines. Please read the file first to check exact indentation."
+                        )
+                    if count > 1:
+                        return (
+                            f"Error: 'oldText' matched {count} times in {path} (edit #{i + 1}). "
+                            f"Please provide more surrounding context lines to ensure a unique match."
+                        )
+
+                    idx = normalized_content.find(old_norm)
+                    matches.append((idx, idx + len(old_norm), old_norm, new_norm, i + 1))
+
+                # 5. 校验区间非重叠
+                matches.sort(key=lambda m: (m[0], m[1]))
+                for j in range(len(matches) - 1):
+                    if matches[j][1] > matches[j + 1][0]:
+                        e1 = matches[j][4]
+                        e2 = matches[j + 1][4]
+                        return (
+                            f"Error: Overlapping edit regions detected between "
+                            f"edit #{min(e1, e2)} and edit #{max(e1, e2)}."
+                        )
+
+                # 6. 逆序替换（Reverse replacement）
+                modified_content = normalized_content
+                for start, end, _, new_norm, _ in sorted(matches, key=lambda m: m[0], reverse=True):
+                    modified_content = modified_content[:start] + new_norm + modified_content[end:]
+
+                # 7. 生成 Unified Diff
+                orig_lines = normalized_content.splitlines(keepends=True)
+                mod_lines = modified_content.splitlines(keepends=True)
+                display_path = path.replace("\\", "/")
+                diff = "".join(
+                    difflib.unified_diff(
+                        orig_lines,
+                        mod_lines,
+                        fromfile=f"a/{display_path}",
+                        tofile=f"b/{display_path}",
+                        lineterm="\n",
+                    )
+                )
+
+                # 8. 还原换行符与 BOM
+                final_text = modified_content.replace("\n", "\r\n") if is_crlf else modified_content
+                out_bytes = final_text.encode("utf-8")
+                if has_bom:
+                    out_bytes = b"\xef\xbb\xbf" + out_bytes
+
+                target.write_bytes(out_bytes)
+
+                return f"Successfully applied {len(edit_blocks)} edit(s) to {path}.\nDiff:\n```diff\n{diff}```"
+        except Exception as e:
+            return f"Error: {e}"
+
+    orig_execute = edit.execute
+
+    async def execute(
+        args: dict[str, Any] | None = None,
+        signal: Any | None = None,
+        on_update: Callable[[Any], None] | None = None,
+        tool_call_id: str | None = None,
+        **kwargs: Any,
+    ) -> EditResult:
+        call_args = dict(args) if isinstance(args, dict) else {}
+        call_args.update(kwargs)
+
+        # 规范化 edits 入参 (对标 Pi 官方 prepareEditArguments 容错)
+        raw_edits = call_args.get("edits")
+        if isinstance(raw_edits, str):
+            try:
+                parsed = json.loads(raw_edits)
+                if isinstance(parsed, (list, dict)):
+                    raw_edits = parsed
+            except Exception:
+                pass
+        if isinstance(raw_edits, dict):
+            raw_edits = [raw_edits]
+        if raw_edits is not None:
+            call_args["edits"] = raw_edits
+
+        if "oldText" in call_args and "old_text" not in call_args:
+            call_args["old_text"] = call_args.pop("oldText")
+        if "newText" in call_args and "new_text" not in call_args:
+            call_args["new_text"] = call_args.pop("newText")
+        res = await orig_execute(
+            call_args,
+            signal=signal,
+            on_update=on_update,
+            tool_call_id=tool_call_id,
+        )
+        return EditResult(
+            ok=res.ok,
+            data=res.data,
+            error=res.error,
+            meta=res.meta,
+            terminate=res.terminate,
+        )
+
+    edit.execute = execute
+    return edit