mycode-coding-agent 0.1.0__py3-none-any.whl

mycode/tools/patterns.py

@@ -0,0 +1,48 @@
+from pathlib import Path
+
+from mycode.tools.ignore import (
+    DEFAULT_SAFE_ENV_TEMPLATE_FILE_NAMES,
+    DEFAULT_SENSITIVE_FILE_NAMES,
+    DEFAULT_SENSITIVE_FILE_SUFFIXES,
+)
+
+
+GLOB_META_CHARS = frozenset("*?[")
+
+
+def validate_relative_pattern(pattern: str, *, label: str) -> str | None:
+    pattern_path = Path(pattern)
+    if pattern_path.is_absolute():
+        return f"{label} must be relative: {pattern}"
+
+    if ".." in pattern_path.parts:
+        return f"{label} must not contain '..': {pattern}"
+
+    return None
+
+
+def is_explicit_path_pattern(pattern: str) -> bool:
+    return not any(char in pattern for char in GLOB_META_CHARS)
+
+
+def is_sensitive_path_pattern(pattern: str) -> bool:
+    name_pattern = Path(pattern).name.casefold()
+    if not name_pattern:
+        return False
+
+    if name_pattern in DEFAULT_SAFE_ENV_TEMPLATE_FILE_NAMES:
+        return False
+
+    if name_pattern in DEFAULT_SENSITIVE_FILE_NAMES:
+        return True
+
+    if any(
+        name_pattern.startswith(f"{sensitive_name}*")
+        for sensitive_name in DEFAULT_SENSITIVE_FILE_NAMES
+    ):
+        return True
+
+    if name_pattern.startswith(".env"):
+        return True
+
+    return any(name_pattern.endswith(f"*{suffix}") for suffix in DEFAULT_SENSITIVE_FILE_SUFFIXES)

mycode/tools/permission_metadata.py

@@ -0,0 +1,27 @@
+from mycode.permissions import PermissionDecision
+
+
+def with_permission_metadata(
+    decision: PermissionDecision,
+    metadata: dict[str, object],
+) -> PermissionDecision:
+    merged_metadata = {**decision.metadata, **metadata}
+
+    if decision.status == "allow":
+        return PermissionDecision.allow(
+            message=decision.message,
+            metadata=merged_metadata,
+        )
+
+    if decision.status == "ask":
+        return PermissionDecision.ask(
+            reason=decision.reason,
+            message=decision.message,
+            metadata=merged_metadata,
+        )
+
+    return PermissionDecision.deny(
+        reason=decision.reason,
+        message=decision.message,
+        metadata=merged_metadata,
+    )

mycode/tools/process_tree.py

@@ -0,0 +1,166 @@
+import os
+import signal
+import subprocess
+
+
+class ProcessTreeCleanup:
+    def __init__(
+        self,
+        *,
+        method: str,
+        job_handle: int | None = None,
+        process_group_id: int | None = None,
+        error: str | None = None,
+    ) -> None:
+        self.method = method
+        self.error = error
+        self._job_handle = job_handle
+        self._process_group_id = process_group_id
+        self._closed = False
+        self._success = error is None
+
+    def close(self) -> bool:
+        if self._closed:
+            return self._success
+
+        self._closed = True
+        if self._job_handle is not None:
+            self._success = _close_windows_job_handle(self._job_handle)
+            if not self._success:
+                self.error = self.error or "CloseHandle failed for process job."
+            return self._success
+
+        if self._process_group_id is not None:
+            self._success = _kill_posix_process_group(self._process_group_id)
+            if not self._success:
+                self.error = self.error or "Failed to terminate process group."
+            return self._success
+
+        return self._success
+
+
+def process_tree_popen_kwargs() -> dict[str, object]:
+    if os.name == "nt":
+        return {}
+
+    return {"start_new_session": True}
+
+
+def create_process_tree_cleanup(
+    process: subprocess.Popen[str],
+) -> ProcessTreeCleanup:
+    if os.name == "nt":
+        return _create_windows_job_cleanup(process)
+
+    return ProcessTreeCleanup(
+        method="posix_process_group",
+        process_group_id=process.pid,
+    )
+
+
+def _create_windows_job_cleanup(
+    process: subprocess.Popen[str],
+) -> ProcessTreeCleanup:
+    try:
+        import ctypes
+        from ctypes import wintypes
+
+        kernel32 = ctypes.WinDLL("kernel32", use_last_error=True)
+
+        class _IoCounters(ctypes.Structure):
+            _fields_ = [
+                ("ReadOperationCount", ctypes.c_ulonglong),
+                ("WriteOperationCount", ctypes.c_ulonglong),
+                ("OtherOperationCount", ctypes.c_ulonglong),
+                ("ReadTransferCount", ctypes.c_ulonglong),
+                ("WriteTransferCount", ctypes.c_ulonglong),
+                ("OtherTransferCount", ctypes.c_ulonglong),
+            ]
+
+        class _JobObjectBasicLimitInformation(ctypes.Structure):
+            _fields_ = [
+                ("PerProcessUserTimeLimit", ctypes.c_int64),
+                ("PerJobUserTimeLimit", ctypes.c_int64),
+                ("LimitFlags", wintypes.DWORD),
+                ("MinimumWorkingSetSize", ctypes.c_size_t),
+                ("MaximumWorkingSetSize", ctypes.c_size_t),
+                ("ActiveProcessLimit", wintypes.DWORD),
+                ("Affinity", ctypes.c_size_t),
+                ("PriorityClass", wintypes.DWORD),
+                ("SchedulingClass", wintypes.DWORD),
+            ]
+
+        class _JobObjectExtendedLimitInformation(ctypes.Structure):
+            _fields_ = [
+                ("BasicLimitInformation", _JobObjectBasicLimitInformation),
+                ("IoInfo", _IoCounters),
+                ("ProcessMemoryLimit", ctypes.c_size_t),
+                ("JobMemoryLimit", ctypes.c_size_t),
+                ("PeakProcessMemoryUsed", ctypes.c_size_t),
+                ("PeakJobMemoryUsed", ctypes.c_size_t),
+            ]
+
+        kernel32.CreateJobObjectW.argtypes = [wintypes.LPVOID, wintypes.LPCWSTR]
+        kernel32.CreateJobObjectW.restype = wintypes.HANDLE
+        kernel32.SetInformationJobObject.argtypes = [
+            wintypes.HANDLE,
+            ctypes.c_int,
+            wintypes.LPVOID,
+            wintypes.DWORD,
+        ]
+        kernel32.SetInformationJobObject.restype = wintypes.BOOL
+        kernel32.AssignProcessToJobObject.argtypes = [wintypes.HANDLE, wintypes.HANDLE]
+        kernel32.AssignProcessToJobObject.restype = wintypes.BOOL
+
+        job_handle = kernel32.CreateJobObjectW(None, None)
+        if not job_handle:
+            raise ctypes.WinError(ctypes.get_last_error())
+
+        limit_info = _JobObjectExtendedLimitInformation()
+        limit_info.BasicLimitInformation.LimitFlags = 0x00002000
+        if not kernel32.SetInformationJobObject(
+            job_handle,
+            9,
+            ctypes.byref(limit_info),
+            ctypes.sizeof(limit_info),
+        ):
+            error = ctypes.WinError(ctypes.get_last_error())
+            _close_windows_job_handle(int(job_handle))
+            raise error
+
+        process_handle = getattr(process, "_handle")
+        if not kernel32.AssignProcessToJobObject(job_handle, process_handle):
+            error = ctypes.WinError(ctypes.get_last_error())
+            _close_windows_job_handle(int(job_handle))
+            raise error
+
+        return ProcessTreeCleanup(method="windows_job", job_handle=int(job_handle))
+    except Exception as error:
+        return ProcessTreeCleanup(
+            method="windows_job",
+            error=f"{type(error).__name__}: {error}",
+        )
+
+
+def _close_windows_job_handle(job_handle: int) -> bool:
+    try:
+        import ctypes
+        from ctypes import wintypes
+
+        kernel32 = ctypes.WinDLL("kernel32", use_last_error=True)
+        kernel32.CloseHandle.argtypes = [wintypes.HANDLE]
+        kernel32.CloseHandle.restype = wintypes.BOOL
+        return bool(kernel32.CloseHandle(wintypes.HANDLE(job_handle)))
+    except Exception:
+        return False
+
+
+def _kill_posix_process_group(process_group_id: int) -> bool:
+    try:
+        os.killpg(process_group_id, signal.SIGKILL)
+    except ProcessLookupError:
+        return True
+    except OSError:
+        return False
+
+    return True

mycode/tools/read_file.py

@@ -0,0 +1,242 @@
+from pathlib import Path
+
+from pydantic import Field, field_validator
+
+from mycode.permissions import PermissionChecker, PermissionDecision, PermissionRequest
+from mycode.tools.base import PydanticTool, ToolArgs, ToolResult
+from mycode.tools.bounds import clamp_positive_int_upper_bound
+from mycode.tools.ignore import is_sensitive_path
+from mycode.tools.path_permissions import PathPermissionPolicy
+from mycode.tools.text import (
+    SUPPORTED_TEXT_ENCODINGS,
+    contains_nul_byte,
+    decode_text,
+)
+from mycode.tools.workspace import Workspace, WorkspacePathError
+
+
+SUPPORTED_ENCODINGS = SUPPORTED_TEXT_ENCODINGS
+DEFAULT_MAX_LINES = 200
+MAX_LINES_LIMIT = 1000
+
+
+class ReadFileArgs(ToolArgs):
+    path: str = Field(description="要读取的 workspace 内文件路径。")
+    start_line: int = Field(
+        default=1,
+        ge=1,
+        description="从第几行开始读取，行号从 1 开始。",
+    )
+    max_lines: int = Field(
+        default=DEFAULT_MAX_LINES,
+        ge=1,
+        le=MAX_LINES_LIMIT,
+        strict=True,
+        description="本次最多读取的行数。",
+    )
+
+    @field_validator("max_lines", mode="before")
+    @classmethod
+    def clamp_max_lines(cls, value: object) -> object:
+        return clamp_positive_int_upper_bound(
+            value,
+            upper_bound=MAX_LINES_LIMIT,
+        )
+
+
+class ReadFileTool(PydanticTool[ReadFileArgs]):
+    name = "read_file"
+    description = "Read a text file inside the workspace with line numbers."
+    args_model = ReadFileArgs
+    capability = "read"
+    risk = "low"
+    concurrency_safe = True
+
+    def __init__(self, workspace: Workspace) -> None:
+        self.workspace = workspace
+
+    def build_permission_request(self, args: ReadFileArgs) -> PermissionRequest:
+        return PermissionRequest(
+            tool_name=self.name,
+            capability=self.capability,
+            action=self.name,
+            target=args.path,
+            arguments=args.model_dump(),
+        )
+
+    def check_permission(
+        self,
+        args: ReadFileArgs,
+        permission_checker: PermissionChecker,
+    ) -> tuple[PermissionRequest, PermissionDecision]:
+        request = self.build_permission_request(args)
+        path_decision = PathPermissionPolicy(self.workspace).check_path(
+            request,
+            args.path,
+        )
+        if path_decision.status != "allow":
+            return request, path_decision
+
+        decision = permission_checker.check(
+            request,
+            self.get_permission_profile(),
+        )
+        if decision.status != "allow":
+            return request, decision
+
+        return request, PermissionDecision.allow(
+            message=decision.message,
+            metadata={**decision.metadata, **path_decision.metadata},
+        )
+
+    def run_authorized(
+        self,
+        args: ReadFileArgs,
+        decision: PermissionDecision,
+    ) -> ToolResult:
+        try:
+            resolved_path = decision.metadata.get("resolved_path")
+            if isinstance(resolved_path, str):
+                return self._read_path(args, Path(resolved_path))
+
+            return self.run_parsed(args)
+        except Exception as error:
+            return ToolResult.failure(
+                error=f"Tool execution failed: {error}",
+                metadata={"exception_type": type(error).__name__},
+            )
+
+    def _run(self, args: ReadFileArgs) -> ToolResult:
+        try:
+            path = self.workspace.resolve_path(args.path)
+        except WorkspacePathError as error:
+            return ToolResult.failure(
+                error=str(error),
+                metadata={"path": args.path},
+            )
+
+        if not path.exists():
+            return ToolResult.failure(
+                error=f"File not found: {args.path}",
+                metadata={"path": args.path},
+            )
+
+        if not path.is_file():
+            return ToolResult.failure(
+                error=f"Path is not a file: {args.path}",
+                metadata={"path": args.path},
+            )
+
+        if is_sensitive_path(path, self.workspace.root):
+            return ToolResult.failure(
+                error=f"Refusing to read sensitive file: {args.path}",
+                metadata={"path": args.path, "reason": "sensitive_file"},
+            )
+
+        return self._read_path(args, path)
+
+    def _read_path(self, args: ReadFileArgs, path: Path) -> ToolResult:
+        if not path.exists():
+            return ToolResult.failure(
+                error=f"File not found: {args.path}",
+                metadata={"path": args.path},
+            )
+
+        if not path.is_file():
+            return ToolResult.failure(
+                error=f"Path is not a file: {args.path}",
+                metadata={"path": args.path},
+            )
+
+        raw_content = path.read_bytes()
+        if contains_nul_byte(raw_content):
+            return ToolResult.failure(
+                error=f"File is not a supported text file: {args.path}",
+                metadata={"path": args.path, "reason": "nul_byte"},
+            )
+
+        decoded = decode_text(raw_content)
+        if decoded is None:
+            return ToolResult.failure(
+                error=f"File is not a supported text file: {args.path}",
+                metadata={
+                    "path": args.path,
+                    "supported_encodings": list(SUPPORTED_ENCODINGS),
+                },
+            )
+
+        text, encoding = decoded
+        lines = text.splitlines()
+        total_lines = len(lines)
+        start_index = args.start_line - 1
+        end_index = min(start_index + args.max_lines, total_lines)
+        selected_lines = lines[start_index:end_index]
+        end_line = args.start_line + len(selected_lines) - 1
+        if not selected_lines:
+            end_line = args.start_line - 1
+        has_more = end_index < total_lines
+        next_start_line = end_line + 1 if has_more else None
+        display_path = _display_path(path, self.workspace.root)
+        content = _format_read_result(
+            path=display_path,
+            selected_lines=selected_lines,
+            start_line=args.start_line,
+            end_line=end_line,
+            total_lines=total_lines,
+            has_more=has_more,
+            next_start_line=next_start_line,
+        )
+
+        return ToolResult.success(
+            content=content,
+            metadata={
+                "path": display_path,
+                "encoding": encoding,
+                "start_line": args.start_line,
+                "end_line": end_line,
+                "total_lines": total_lines,
+                "has_more": has_more,
+                "next_start_line": next_start_line,
+            },
+        )
+
+
+def _format_numbered_lines(lines: list[str], *, start_line: int) -> str:
+    return "\n".join(
+        f"{line_number} | {line}"
+        for line_number, line in enumerate(lines, start=start_line)
+    )
+
+
+def _format_read_result(
+    *,
+    path: str,
+    selected_lines: list[str],
+    start_line: int,
+    end_line: int,
+    total_lines: int,
+    has_more: bool,
+    next_start_line: int | None,
+) -> str:
+    lines_display = (
+        f"{start_line}-{end_line}"
+        if end_line >= start_line
+        else f"none (requested start: {start_line})"
+    )
+    header = [
+        f"File: {path}",
+        f"Lines: {lines_display} / {total_lines}",
+        f"Has more: {'yes' if has_more else 'no'}",
+    ]
+    if next_start_line is not None:
+        header.append(f"Next start line: {next_start_line}")
+    body = _format_numbered_lines(selected_lines, start_line=start_line)
+    header_text = "\n".join(header)
+    return header_text if not body else f"{header_text}\n\n{body}"
+
+
+def _display_path(path: Path, root: Path) -> str:
+    try:
+        return path.relative_to(root).as_posix()
+    except ValueError:
+        return path.as_posix()

mycode/tools/read_skill_resource.py

@@ -0,0 +1,93 @@
+from pydantic import Field, field_validator
+
+from mycode.skills import ActiveSkillState, SkillPathError, SkillRegistry
+from mycode.tools.base import PydanticTool, ToolArgs, ToolResult
+from mycode.tools.bounds import clamp_positive_int_upper_bound
+
+
+DEFAULT_MAX_SKILL_RESOURCE_CHARS = 4000
+MAX_SKILL_RESOURCE_CHARS = 20000
+
+
+class ReadSkillResourceArgs(ToolArgs):
+    skill: str = Field(min_length=1)
+    path: str = Field(min_length=1)
+    offset_chars: int = Field(default=0, ge=0, strict=True)
+    max_chars: int = Field(
+        default=DEFAULT_MAX_SKILL_RESOURCE_CHARS,
+        ge=1,
+        le=MAX_SKILL_RESOURCE_CHARS,
+        strict=True,
+    )
+
+    @field_validator("max_chars", mode="before")
+    @classmethod
+    def clamp_max_chars(cls, value: object) -> object:
+        return clamp_positive_int_upper_bound(
+            value, upper_bound=MAX_SKILL_RESOURCE_CHARS
+        )
+
+
+class ReadSkillResourceTool(PydanticTool[ReadSkillResourceArgs]):
+    name = "read_skill_resource"
+    description = "从已激活的 Skill 中按边界读取 UTF-8 文本资源。"
+    args_model = ReadSkillResourceArgs
+    capability = "read"
+    risk = "low"
+    concurrency_safe = True
+
+    def __init__(self, registry: SkillRegistry, state: ActiveSkillState) -> None:
+        self.registry = registry
+        self.state = state
+
+    def _run(self, args: ReadSkillResourceArgs) -> ToolResult:
+        skill = self.registry.get(args.skill)
+        metadata: dict[str, object] = {
+            "skill_name": args.skill,
+            "resource_path": args.path,
+        }
+        if skill is None or not self.state.is_active(args.skill):
+            return ToolResult.failure(
+                error=f"Skill is not active: {args.skill}", metadata=metadata
+            )
+        metadata["skill_source"] = skill.source
+        try:
+            path = self.registry.resolve_resource(skill, args.path)
+        except SkillPathError as error:
+            return ToolResult.failure(error=str(error), metadata=metadata)
+        if not path.exists():
+            return ToolResult.failure(
+                error=f"Skill resource not found: {args.path}", metadata=metadata
+            )
+        if not path.is_file():
+            return ToolResult.failure(
+                error=f"Skill resource is not a file: {args.path}", metadata=metadata
+            )
+        try:
+            raw = path.read_bytes()
+            if b"\x00" in raw:
+                raise UnicodeDecodeError("utf-8", raw, 0, 1, "NUL byte")
+            text = raw.decode("utf-8")
+        except UnicodeDecodeError:
+            return ToolResult.failure(
+                error=f"Skill resource is not valid UTF-8 text: {args.path}",
+                metadata={**metadata, "reason": "unsupported_text"},
+            )
+        except OSError as error:
+            return ToolResult.failure(
+                error=f"Cannot read Skill resource: {error}", metadata=metadata
+            )
+        content = text[args.offset_chars : args.offset_chars + args.max_chars]
+        next_offset = args.offset_chars + len(content)
+        has_more = next_offset < len(text)
+        return ToolResult.success(
+            content=content,
+            metadata={
+                **metadata,
+                "offset_chars": args.offset_chars,
+                "returned_chars": len(content),
+                "total_chars": len(text),
+                "has_more": has_more,
+                "next_offset_chars": next_offset if has_more else None,
+            },
+        )