my-pi-agent 0.1.0

package/src/my_coding_agent/tools/find.py

@@ -0,0 +1,118 @@
+from __future__ import annotations
+
+import fnmatch
+import os
+from collections.abc import Callable
+from pathlib import Path
+from typing import Any
+
+from my_agent_core.tools import Tool, tool
+
+from my_coding_agent.tools.base import (
+    DEFAULT_IGNORE_DIRS,
+    DEFAULT_MAX_BYTES,
+    StringCompatibleToolResult,
+    resolve_path,
+)
+
+DEFAULT_FIND_LIMIT = 1000
+
+
+class FindResult(StringCompatibleToolResult):
+    """Find 工具执行结果：继承 StringCompatibleToolResult。"""
+
+
+def make_find_tool(workspace: Path | str) -> Tool:
+    """创建 find 工具工厂，在 workspace 内按 glob pattern 检索文件。"""
+    workspace = Path(workspace).resolve()
+
+    @tool(
+        name="find",
+        description="Search for files by glob pattern. Returns matching file paths relative to the search directory. Output is truncated to 1000 results or 50KB (whichever is hit first).",
+        is_parallel_safe=True,
+    )
+    async def find(pattern: str = "*", path: str = ".", limit: int = DEFAULT_FIND_LIMIT) -> str:
+        try:
+            target_root = resolve_path(workspace, path)
+            if not target_root.exists():
+                return f"Error: Path not found: {path}"
+
+            effective_limit = limit if (limit is not None and limit > 0) else DEFAULT_FIND_LIMIT
+            matched_paths: list[str] = []
+            norm_pattern = pattern.replace("\\", "/")
+
+            if target_root.is_file():
+                try:
+                    rel = str(target_root.relative_to(workspace)).replace("\\", "/")
+                except ValueError:
+                    rel = str(target_root).replace("\\", "/")
+                if (
+                    fnmatch.fnmatch(rel, norm_pattern)
+                    or fnmatch.fnmatch(rel, pattern)
+                    or fnmatch.fnmatch(target_root.name, pattern)
+                ):
+                    matched_paths.append(rel)
+            else:
+                for root, dirs, files in os.walk(target_root):
+                    dirs[:] = [d for d in dirs if d not in DEFAULT_IGNORE_DIRS]
+                    dirs.sort()
+                    for f in sorted(files):
+                        full_p = Path(root) / f
+                        try:
+                            rel = str(full_p.relative_to(workspace)).replace("\\", "/")
+                        except ValueError:
+                            rel = str(full_p).replace("\\", "/")
+
+                        if (
+                            fnmatch.fnmatch(rel, norm_pattern)
+                            or fnmatch.fnmatch(rel, pattern)
+                            or fnmatch.fnmatch(f, pattern)
+                        ):
+                            matched_paths.append(rel)
+                            if len(matched_paths) >= effective_limit:
+                                matched_paths.append(f"[Truncated at limit of {effective_limit} results]")
+                                break
+                    if len(matched_paths) >= effective_limit:
+                        break
+
+            output = "\n".join(matched_paths) if matched_paths else f"No files matching '{pattern}' found."
+            encoded = output.encode("utf-8")
+            if len(encoded) > DEFAULT_MAX_BYTES:
+                encoded = encoded[:DEFAULT_MAX_BYTES]
+                last_nl = encoded.rfind(b"\n")
+                if last_nl != -1:
+                    encoded = encoded[:last_nl]
+                output = encoded.decode("utf-8", errors="ignore")
+                output += f"\n\n[Output truncated: exceeded {DEFAULT_MAX_BYTES // 1024}KB limit]"
+
+            return output
+        except Exception as e:
+            return f"Error: {e}"
+
+    orig_execute = find.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,
+    ) -> FindResult:
+        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 FindResult(
+            ok=res.ok,
+            data=res.data,
+            error=res.error,
+            meta=res.meta,
+            terminate=res.terminate,
+        )
+
+    find.execute = execute
+    return find

package/src/my_coding_agent/tools/grep.py

@@ -0,0 +1,177 @@
+from __future__ import annotations
+
+import fnmatch
+import os
+import re
+from collections.abc import Callable
+from pathlib import Path
+from typing import Any
+
+from my_agent_core.tools import Tool, tool
+
+from my_coding_agent.tools.base import (
+    DEFAULT_IGNORE_DIRS,
+    DEFAULT_MAX_BYTES,
+    StringCompatibleToolResult,
+    is_binary_file,
+    resolve_path,
+)
+
+
+class GrepResult(StringCompatibleToolResult):
+    """Grep 工具执行结果：继承 StringCompatibleToolResult。"""
+
+
+def make_grep_tool(workspace: Path | str) -> Tool:
+    """创建 grep 工具工厂，在 workspace 内检索文件（对标 Pi 官方 grep 协议与参数）。"""
+    workspace = Path(workspace).resolve()
+
+    @tool(
+        name="grep",
+        description="Search file contents for patterns (respects .gitignore). Supports regex, case sensitivity, context lines, glob filter, and line limits.",
+        is_parallel_safe=True,
+    )
+    async def grep(
+        pattern: str,
+        path: str = ".",
+        glob: str | None = None,
+        ignore_case: bool | None = None,
+        literal: bool | None = None,
+        context: int = 0,
+        limit: int | None = None,
+        regex: bool = False,
+        case_sensitive: bool = False,
+    ) -> str:
+        try:
+            target_root = resolve_path(workspace, path)
+            if not target_root.exists():
+                return f"Error: Path not found: {path}"
+
+            # 解析大小写敏感度（Pi 规范优先: ignoreCase / ignore_case）
+            actual_ignore_case = True
+            if ignore_case is not None:
+                actual_ignore_case = bool(ignore_case)
+            elif case_sensitive:
+                actual_ignore_case = False
+
+            # 解析字面量检索（Pi 规范: literal=True 优先，否则 regex=True）
+            is_literal = False
+            if literal is not None:
+                is_literal = bool(literal)
+            else:
+                is_literal = not regex
+
+            flags = re.IGNORECASE if actual_ignore_case else 0
+            try:
+                regex_pat = re.escape(pattern) if is_literal else pattern
+                compiled_regex = re.compile(regex_pat, flags)
+            except re.error as e:
+                return f"Error: Invalid regular expression: {e}"
+
+            effective_glob = glob
+            effective_limit = limit if limit is not None else 100
+            effective_context = max(0, context)
+
+            matches: list[str] = []
+            files_to_search: list[Path] = []
+
+            if target_root.is_file():
+                if not effective_glob or fnmatch.fnmatch(target_root.name, effective_glob):
+                    files_to_search = [target_root]
+            else:
+                for root, dirs, files in os.walk(target_root):
+                    dirs[:] = [d for d in dirs if d not in DEFAULT_IGNORE_DIRS]
+                    dirs.sort()
+                    for f in sorted(files):
+                        if effective_glob and not fnmatch.fnmatch(f, effective_glob):
+                            continue
+                        files_to_search.append(Path(root) / f)
+
+            for file_path in files_to_search:
+                if is_binary_file(file_path):
+                    continue
+                try:
+                    rel_str = str(file_path.relative_to(workspace)).replace("\\", "/")
+                except ValueError:
+                    rel_str = str(file_path).replace("\\", "/")
+
+                try:
+                    with open(file_path, encoding="utf-8", errors="replace") as f:
+                        file_lines = f.read().splitlines()
+
+                    matched_line_indices = [idx for idx, line in enumerate(file_lines) if compiled_regex.search(line)]
+
+                    if not matched_line_indices:
+                        continue
+
+                    # 处理上下文行合并
+                    if effective_context > 0:
+                        emitted_indices: set[int] = set()
+                        for idx in matched_line_indices:
+                            start_ctx = max(0, idx - effective_context)
+                            end_ctx = min(len(file_lines), idx + effective_context + 1)
+                            for c_idx in range(start_ctx, end_ctx):
+                                if c_idx not in emitted_indices:
+                                    emitted_indices.add(c_idx)
+                                    sep = ":" if c_idx == idx else "-"
+                                    matches.append(f"{rel_str}{sep}{c_idx + 1}: {file_lines[c_idx]}")
+                                    if len(matches) >= effective_limit:
+                                        matches.append(f"[Reached maximum limit of {effective_limit} matches]")
+                                        return "\n".join(matches)
+                    else:
+                        for idx in matched_line_indices:
+                            matches.append(f"{rel_str}:{idx + 1}: {file_lines[idx]}")
+                            if len(matches) >= effective_limit:
+                                matches.append(f"[Reached maximum limit of {effective_limit} matches]")
+                                return "\n".join(matches)
+
+                except (OSError, UnicodeDecodeError):
+                    continue
+
+            output = "\n".join(matches) if matches else f"No matches found for pattern '{pattern}'."
+            encoded = output.encode("utf-8")
+            if len(encoded) > DEFAULT_MAX_BYTES:
+                encoded = encoded[:DEFAULT_MAX_BYTES]
+                last_nl = encoded.rfind(b"\n")
+                if last_nl != -1:
+                    encoded = encoded[:last_nl]
+                output = encoded.decode("utf-8", errors="ignore")
+                output += f"\n\n[Output truncated: exceeded {DEFAULT_MAX_BYTES // 1024}KB limit]"
+
+            return output
+        except Exception as e:
+            return f"Error: {e}"
+
+    orig_execute = grep.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,
+    ) -> GrepResult:
+        call_args = dict(args) if isinstance(args, dict) else {}
+        call_args.update(kwargs)
+        if "ignoreCase" in call_args and "ignore_case" not in call_args:
+            call_args["ignore_case"] = call_args.pop("ignoreCase")
+        if "glob_filter" in call_args and "glob" not in call_args:
+            call_args["glob"] = call_args.pop("glob_filter")
+        if "max_matches" in call_args and "limit" not in call_args:
+            call_args["limit"] = call_args.pop("max_matches")
+        res = await orig_execute(
+            call_args,
+            signal=signal,
+            on_update=on_update,
+            tool_call_id=tool_call_id,
+        )
+        return GrepResult(
+            ok=res.ok,
+            data=res.data,
+            error=res.error,
+            meta=res.meta,
+            terminate=res.terminate,
+        )
+
+    grep.execute = execute
+    return grep

package/src/my_coding_agent/tools/ls.py

@@ -0,0 +1,112 @@
+from __future__ import annotations
+
+import contextlib
+import os
+from collections.abc import Callable
+from pathlib import Path
+from typing import Any
+
+from my_agent_core.tools import Tool, tool
+
+from my_coding_agent.tools.base import (
+    DEFAULT_MAX_BYTES,
+    StringCompatibleToolResult,
+    resolve_path,
+)
+
+DEFAULT_LS_LIMIT = 500
+
+
+class LsResult(StringCompatibleToolResult):
+    """Ls 工具执行结果：继承 StringCompatibleToolResult。"""
+
+
+def make_ls_tool(workspace: Path | str) -> Tool:
+    """创建工作区绑定的 ls 工具（对标 Pi 官方 ls 实现）。
+
+    - path: 目录路径（默认当前工作目录 "."）
+    - limit: 最多返回条目数（默认 500）
+    - 排序：按字母不区分大小写排序，目录带 '/' 后缀
+    - 包含点文件（dotfiles），输出截断至 500 条或 50KB
+    """
+    workspace = Path(workspace).resolve()
+
+    @tool(
+        name="ls",
+        description="List directory contents. Returns entries sorted alphabetically, with '/' suffix for directories. Includes dotfiles. Output is truncated to 500 entries or 50KB (whichever is hit first).",
+        is_parallel_safe=True,
+    )
+    async def ls(path: str = ".", limit: int = DEFAULT_LS_LIMIT) -> str:
+        try:
+            target = resolve_path(workspace, path)
+            if not target.exists():
+                return f"Error: Path not found: {path}"
+            if not target.is_dir():
+                return f"Error: Not a directory: {path}"
+
+            try:
+                raw_entries = os.listdir(target)
+            except OSError as e:
+                return f"Error: Cannot read directory: {e}"
+
+            # 字母不区分大小写排序
+            raw_entries.sort(key=lambda s: s.lower())
+
+            effective_limit = limit if (limit is not None and limit > 0) else DEFAULT_LS_LIMIT
+            results: list[str] = []
+            truncated_by_limit = False
+
+            for entry in raw_entries:
+                if len(results) >= effective_limit:
+                    truncated_by_limit = True
+                    break
+                full_path = target / entry
+                suffix = ""
+                with contextlib.suppress(OSError):
+                    if full_path.is_dir():
+                        suffix = "/"
+                results.append(f"{entry}{suffix}")
+
+            output = "\n".join(results)
+            encoded = output.encode("utf-8")
+            if len(encoded) > DEFAULT_MAX_BYTES:
+                encoded = encoded[:DEFAULT_MAX_BYTES]
+                last_nl = encoded.rfind(b"\n")
+                if last_nl != -1:
+                    encoded = encoded[:last_nl]
+                output = encoded.decode("utf-8", errors="ignore")
+                output += f"\n\n[Output truncated: output exceeded {DEFAULT_MAX_BYTES // 1024}KB limit]"
+            elif truncated_by_limit:
+                output += f"\n\n[Output truncated: reached entry limit of {effective_limit}]"
+
+            return output if output else "(Empty directory)"
+        except Exception as e:
+            return f"Error: {e}"
+
+    orig_execute = ls.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,
+    ) -> LsResult:
+        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 LsResult(
+            ok=res.ok,
+            data=res.data,
+            error=res.error,
+            meta=res.meta,
+            terminate=res.terminate,
+        )
+
+    ls.execute = execute
+    return ls

package/src/my_coding_agent/tools/read.py

@@ -0,0 +1,113 @@
+from __future__ import annotations
+
+from collections.abc import Callable
+from pathlib import Path
+from typing import Any
+
+from my_agent_core.tools import Tool, tool
+
+from my_coding_agent.tools.base import (
+    DEFAULT_MAX_BYTES,
+    DEFAULT_MAX_LINES,
+    StringCompatibleToolResult,
+    is_binary_file,
+    resolve_path,
+)
+
+
+class ReadResult(StringCompatibleToolResult):
+    """Read 工具执行结果：继承 StringCompatibleToolResult。"""
+
+
+def make_read_tool(workspace: Path) -> Tool:
+    workspace = workspace.resolve()
+
+    @tool(
+        name="read",
+        description="Read file contents with line offset/limit pagination and automatic truncation.",
+        is_parallel_safe=True,
+    )
+    async def read(path: str, offset: int = 1, limit: int | 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):
+                size = target.stat().st_size
+                return f"Error: Cannot read binary file ({size} bytes): {path}"
+
+            text = target.read_text(encoding="utf-8", errors="replace")
+            lines = text.splitlines()
+            total_lines = len(lines)
+
+            if offset < 1:
+                offset = 1
+            if offset > total_lines and total_lines > 0:
+                return f"Error: Offset {offset} is beyond end of file ('{path}' has only {total_lines} lines total)."
+
+            start_idx = offset - 1
+            effective_limit = limit if limit is not None else DEFAULT_MAX_LINES
+            end_idx = min(start_idx + effective_limit, total_lines)
+
+            # 检查 2000 行限制
+            is_line_truncated = False
+            if end_idx - start_idx > DEFAULT_MAX_LINES:
+                end_idx = start_idx + DEFAULT_MAX_LINES
+                is_line_truncated = True
+
+            selected_lines = lines[start_idx:end_idx]
+            result_text = "\n".join(selected_lines)
+
+            # 检查 50KB 字节限制
+            is_byte_truncated = False
+            encoded = result_text.encode("utf-8")
+            if len(encoded) > DEFAULT_MAX_BYTES:
+                encoded = encoded[:DEFAULT_MAX_BYTES]
+                last_nl = encoded.rfind(b"\n")
+                if last_nl != -1:
+                    encoded = encoded[:last_nl]
+                result_text = encoded.decode("utf-8", errors="ignore")
+                end_idx = start_idx + len(result_text.splitlines())
+                is_byte_truncated = True
+
+            truncated = (
+                is_line_truncated
+                or is_byte_truncated
+                or (end_idx < total_lines and limit is None)
+            )
+            if truncated:
+                result_text += f"\n\n[Showing lines {offset}-{end_idx} of {total_lines}. Use offset={end_idx + 1} to continue.]"
+
+            return result_text
+        except Exception as e:
+            return f"Error: {e}"
+
+    orig_execute = read.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,
+    ) -> ReadResult:
+        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 ReadResult(
+            ok=res.ok,
+            data=res.data,
+            error=res.error,
+            meta=res.meta,
+            terminate=res.terminate,
+        )
+
+    read.execute = execute
+    return read

package/src/my_coding_agent/tools/write.py

@@ -0,0 +1,72 @@
+from __future__ import annotations
+
+from collections.abc import Callable
+from pathlib import Path
+from typing import Any
+
+from my_agent_core.tools import Tool, tool
+
+from my_coding_agent.mutation_queue import FileMutationQueue
+from my_coding_agent.tools.base import StringCompatibleToolResult, resolve_path
+
+
+class WriteResult(StringCompatibleToolResult):
+    """Write 工具执行结果：继承 StringCompatibleToolResult。"""
+
+
+def make_write_tool(workspace: Path, mutation_queue: FileMutationQueue | None = None) -> Tool:
+    """创建工作区绑定的 write 工具。
+
+    - workspace: 工作区根目录路径
+    - mutation_queue: 单文件并发互斥锁队列，缺省时自动新建
+    """
+    workspace = Path(workspace).resolve()
+    queue = mutation_queue or FileMutationQueue()
+
+    @tool(
+        name="write",
+        description="Write complete content to a file, automatically creating parent directories.",
+        is_parallel_safe=True,
+    )
+    async def write(path: str, content: str) -> str:
+        try:
+            target = resolve_path(workspace, path)
+            if target.is_dir():
+                return f"Error: Path is a directory: {path}"
+
+            async with queue.acquire(target):
+                target.parent.mkdir(parents=True, exist_ok=True)
+                target.write_text(content, encoding="utf-8", newline="")
+                bytes_count = len(content.encode("utf-8"))
+                lines_count = len(content.splitlines())
+                return f"Successfully wrote {bytes_count} bytes ({lines_count} lines) to {path}"
+        except Exception as e:
+            return f"Error: {e}"
+
+    orig_execute = write.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,
+    ) -> WriteResult:
+        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 WriteResult(
+            ok=res.ok,
+            data=res.data,
+            error=res.error,
+            meta=res.meta,
+            terminate=res.terminate,
+        )
+
+    write.execute = execute
+    return write

package/tui/README.md

@@ -0,0 +1,27 @@
+# my-agent-tui
+
+`my-pi-agent` 的高质感交互终端表现层（基于 `@earendil-works/pi-tui` 的 Node.js / TypeScript 前端 Shell）。
+
+## 核心特性
+
+- **Pi 原厂渲染引擎**：基于 `@earendil-works/pi-tui` 的 `TuiMainScreen` 差量重绘器，保留原生终端历史与鼠标滚轮翻看；
+- **CSI 2026 同步屏障**：垂直原子刷新，彻底消灭字符撕裂与屏幕闪烁；
+- **24-bit TrueColor 卡片系统**：移植 Pi 官方 `dark.json` 柔和调色盘，消息气泡与圆角卡片；
+- **动态思考折叠块 (Thinking Block)**：流式大模型思考过程展示，`Ctrl+O` 随时展开/折叠；
+- **就地更新工具卡片**：圆角细线卡片（`╭─ ⚙️ read ... ─╮`）、点阵 Spinner 微动效、执行完成变绿与耗时提示；
+- **富文本多行编辑器与 IME 光标锚定**：支持中文输入法硬件光标精准对齐，候选框永不乱跳；
+- **模糊补全气泡**：`@` 文件模糊补全与 `/` 斜杠命令提示浮窗；
+- **stdio JSON-RPC 双向流**：与 Python 无头业务内核 `my-coding-agent` 深度集成，支持 `Esc` 瞬时打断与动态即时转向。
+
+## 启动与运行
+
+```bash
+# 从仓库根目录一键启动 (推荐)
+npm start
+
+# 或在 tui/ 目录下独立执行
+cd tui
+npm install
+npm run build
+npm start
+```