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

mycode/tools/run_skill_script.py

@@ -0,0 +1,206 @@
+from pathlib import Path
+import shutil
+import sys
+
+from pydantic import Field, field_validator
+
+from mycode.permissions import PermissionChecker, PermissionDecision, PermissionRequest
+from mycode.skills import ActiveSkillState, SkillPathError, SkillRegistry
+from mycode.tools.base import PydanticTool, ToolArgs, ToolResult
+from mycode.tools.command_executor import CommandExecutionArgs, execute_command
+from mycode.tools.permission_metadata import with_permission_metadata
+from mycode.tools.run_command import (
+    DEFAULT_MAX_OUTPUT_CHARS,
+    DEFAULT_TIMEOUT_SECONDS,
+    MAX_OUTPUT_CHARS,
+    MAX_TIMEOUT_SECONDS,
+)
+from mycode.tools.workspace import Workspace
+
+
+class RunSkillScriptArgs(ToolArgs):
+    skill: str = Field(min_length=1)
+    script: str = Field(min_length=1)
+    args: list[str] = Field(default_factory=list)
+    timeout_seconds: float = Field(
+        default=DEFAULT_TIMEOUT_SECONDS, gt=0, le=MAX_TIMEOUT_SECONDS
+    )
+    max_output_chars: int = Field(
+        default=DEFAULT_MAX_OUTPUT_CHARS, ge=0, le=MAX_OUTPUT_CHARS
+    )
+
+    @field_validator("args")
+    @classmethod
+    def validate_args(cls, value: list[str]) -> list[str]:
+        if any(not isinstance(part, str) or part == "" for part in value):
+            raise ValueError("Script arguments must be non-empty strings.")
+        if any("\x00" in part for part in value):
+            raise ValueError("Script arguments must not contain null bytes.")
+        return value
+
+
+class RunSkillScriptTool(PydanticTool[RunSkillScriptArgs]):
+    name = "run_skill_script"
+    description = "在当前 workspace 中运行已激活 Skill 的受支持脚本。"
+    args_model = RunSkillScriptArgs
+    capability = "command"
+    risk = "high"
+
+    def __init__(
+        self,
+        workspace: Workspace,
+        registry: SkillRegistry,
+        state: ActiveSkillState,
+    ) -> None:
+        self.workspace = workspace
+        self.registry = registry
+        self.state = state
+
+    def build_permission_request(self, args: RunSkillScriptArgs) -> PermissionRequest:
+        logical_script = _logical_script_path(args.script)
+        return PermissionRequest(
+            tool_name=self.name,
+            capability=self.capability,
+            action=self.name,
+            target=f"{args.skill}:{logical_script}",
+            arguments=args.model_dump(),
+            description=(
+                f'Skill "{args.skill}" 请求在 workspace 中执行 {logical_script}，'
+                f"参数为 {args.args!r}。"
+            ),
+        )
+
+    def check_permission(
+        self,
+        args: RunSkillScriptArgs,
+        permission_checker: PermissionChecker,
+    ) -> tuple[PermissionRequest, PermissionDecision]:
+        request = self.build_permission_request(args)
+        skill = self.registry.get(args.skill)
+        metadata = {
+            "skill_name": args.skill,
+            "script": _logical_script_path(args.script),
+            "cwd": str(self.workspace.root),
+            "arguments": list(args.args),
+        }
+        if skill is None or not self.state.is_active(args.skill):
+            return request, PermissionDecision.deny(
+                reason="unsupported_operation",
+                message=f"Skill is not active: {args.skill}",
+                metadata=metadata,
+            )
+        metadata["skill_source"] = skill.source
+        try:
+            script_path = self.registry.resolve_script(skill, args.script)
+        except SkillPathError as error:
+            return request, PermissionDecision.deny(
+                reason="outside_workspace", message=str(error), metadata=metadata
+            )
+        if not script_path.exists():
+            return request, PermissionDecision.deny(
+                reason="unsupported_operation",
+                message=f"Skill script not found: {args.script}",
+                metadata=metadata,
+            )
+        if not script_path.is_file():
+            return request, PermissionDecision.deny(
+                reason="unsupported_operation",
+                message=f"Skill script is not a file: {args.script}",
+                metadata=metadata,
+            )
+        runtime = _runtime_for_script(script_path)
+        if runtime is None:
+            return request, PermissionDecision.deny(
+                reason="unsupported_operation",
+                message=f"Unsupported Skill script type: {script_path.suffix or '<none>'}",
+                metadata=metadata,
+            )
+        executable = runtime[0]
+        if Path(executable).is_absolute():
+            runtime_available = Path(executable).is_file()
+        else:
+            runtime_available = shutil.which(executable) is not None
+        if not runtime_available:
+            return request, PermissionDecision.deny(
+                reason="unsupported_operation",
+                message=f"Required Skill script runtime is unavailable: {executable}",
+                metadata=metadata,
+            )
+        decision = permission_checker.check(request, self.get_permission_profile())
+        decision = with_permission_metadata(decision, metadata)
+        if decision.status == "ask":
+            decision = PermissionDecision.ask(
+                reason=decision.reason,
+                message=(
+                    f'Skill "{skill.name}" 请求执行 '
+                    f"{_logical_script_path(args.script)}。"
+                ),
+                metadata=decision.metadata,
+            )
+        return request, decision
+
+    def run_authorized(
+        self,
+        args: RunSkillScriptArgs,
+        decision: PermissionDecision,
+    ) -> ToolResult:
+        try:
+            skill = self.registry.require(args.skill)
+            if not self.state.is_active(skill.name):
+                raise ValueError(f"Skill is not active: {skill.name}")
+            script_path = self.registry.resolve_script(skill, args.script)
+            if not script_path.exists() or not script_path.is_file():
+                raise ValueError(f"Skill script is unavailable: {args.script}")
+            runtime = _runtime_for_script(script_path)
+            if runtime is None:
+                raise ValueError(
+                    f"Unsupported Skill script type: {script_path.suffix or '<none>'}"
+                )
+            command = [*runtime, str(script_path), *args.args]
+            return execute_command(
+                args=CommandExecutionArgs(
+                    command=command,
+                    timeout_seconds=args.timeout_seconds,
+                    max_output_chars=args.max_output_chars,
+                ),
+                cwd=self.workspace.root,
+                permission_metadata=decision.metadata,
+                permission_status=decision.status,
+            )
+        except Exception as error:
+            return ToolResult.failure(
+                error=f"Tool execution failed: {error}",
+                metadata={
+                    **decision.metadata,
+                    "permission_status": decision.status,
+                    "exception_type": type(error).__name__,
+                },
+            )
+
+    def _run(self, args: RunSkillScriptArgs) -> ToolResult:
+        return ToolResult.failure(
+            error="run_skill_script must be run through ToolRegistry.run_tool().",
+            metadata={
+                "skill_name": args.skill,
+                "script": _logical_script_path(args.script),
+                "reason": "permission_required",
+            },
+        )
+
+
+def _runtime_for_script(script: Path) -> list[str] | None:
+    suffix = script.suffix.lower()
+    if suffix == ".py":
+        return [sys.executable]
+    if suffix in {".js", ".mjs"}:
+        return ["node"]
+    if suffix == ".sh":
+        return ["bash"]
+    if suffix == ".ps1":
+        return ["pwsh", "-File"]
+    return None
+
+
+def _logical_script_path(script: str) -> str:
+    normalized = script.replace("\\", "/")
+    return normalized if normalized.startswith("scripts/") else f"scripts/{normalized}"

mycode/tools/run_validation.py

@@ -0,0 +1,107 @@
+import subprocess
+
+from pydantic import Field, field_validator
+
+from mycode.permissions import PermissionChecker, PermissionDecision, PermissionRequest
+from mycode.subagents.limits import (
+    MAX_VALIDATION_COMMAND_CHARS,
+    MAX_VALIDATION_COMMAND_PART_CHARS,
+    MAX_VALIDATION_COMMAND_PARTS,
+)
+from mycode.tools.base import ToolResult
+from mycode.tools.permission_metadata import with_permission_metadata
+from mycode.tools.run_command import RunCommandArgs, RunCommandTool
+from mycode.tools.validation_command import analyze_validation_command
+from mycode.tools.workspace import Workspace
+
+
+class RunValidationArgs(RunCommandArgs):
+    command: list[str] = Field(
+        min_length=1,
+        max_length=MAX_VALIDATION_COMMAND_PARTS,
+    )
+    cwd: str = Field(default=".", min_length=1, max_length=500)
+
+    @field_validator("command")
+    @classmethod
+    def validation_command_must_be_bounded(cls, value: list[str]) -> list[str]:
+        if any(len(part) > MAX_VALIDATION_COMMAND_PART_CHARS for part in value):
+            raise ValueError(
+                "Validation command parts must not exceed "
+                f"{MAX_VALIDATION_COMMAND_PART_CHARS} characters."
+            )
+        if sum(len(part) for part in value) > MAX_VALIDATION_COMMAND_CHARS:
+            raise ValueError(
+                "Validation command must not exceed "
+                f"{MAX_VALIDATION_COMMAND_CHARS} total characters."
+            )
+        return value
+
+
+class RunValidationTool(RunCommandTool):
+    name = "run_validation"
+    description = (
+        "Run a non-interactive validation command inside the workspace using "
+        "the same safety and permission checks as run_command."
+    )
+    args_model = RunValidationArgs
+
+    def __init__(
+        self,
+        workspace: Workspace,
+        *,
+        restrict_to_known_validators: bool = True,
+    ) -> None:
+        super().__init__(workspace)
+        self.restrict_to_known_validators = restrict_to_known_validators
+
+    def build_permission_request(self, args: RunCommandArgs) -> PermissionRequest:
+        return PermissionRequest(
+            tool_name=self.name,
+            capability=self.capability,
+            action=self.name,
+            target=subprocess.list2cmdline(args.command),
+            arguments=args.model_dump(),
+            description="Run a validation command.",
+        )
+
+    def check_permission(
+        self,
+        args: RunCommandArgs,
+        permission_checker: PermissionChecker,
+    ) -> tuple[PermissionRequest, PermissionDecision]:
+        if not self.restrict_to_known_validators:
+            return super().check_permission(args, permission_checker)
+
+        request = self.build_permission_request(args)
+        validation = analyze_validation_command(args.command)
+        validation_metadata = {
+            "validation_allowed": validation.allowed,
+            "validation_classification": validation.classification,
+            "validation_category": validation.category,
+            "validation_reason": validation.reason,
+        }
+        if not validation.allowed:
+            return request, PermissionDecision.deny(
+                reason="unsupported_operation",
+                message=validation.reason,
+                metadata={
+                    "tool_name": self.name,
+                    "command": list(args.command),
+                    "cwd": args.cwd,
+                    **validation_metadata,
+                },
+            )
+
+        request, decision = super().check_permission(args, permission_checker)
+        return request, with_permission_metadata(decision, validation_metadata)
+
+    def _run(self, args: RunCommandArgs) -> ToolResult:
+        return ToolResult.failure(
+            error="run_validation must be run through ToolRegistry.run_tool().",
+            metadata={
+                "command": args.command,
+                "cwd": args.cwd,
+                "reason": "permission_required",
+            },
+        )

mycode/tools/submit_result.py

@@ -0,0 +1,93 @@
+from collections.abc import Callable
+from typing import Generic, TypeVar
+
+from mycode.permissions import ToolRisk
+from mycode.subagents.contracts import BoundedResultArgs, SubAgentRole
+from mycode.tools.base import PydanticTool, ToolResult
+
+
+DEFAULT_MAX_SUBMITTED_RESULT_CHARS = 24000
+
+ResultArgsT = TypeVar("ResultArgsT", bound=BoundedResultArgs)
+
+
+class SubmitResultTool(PydanticTool[ResultArgsT], Generic[ResultArgsT]):
+    name = "submit_result"
+    description = "Submit the role-specific structured result and finish the SubAgent run."
+    capability = "control"
+    risk: ToolRisk = "low"
+
+    def __init__(
+        self,
+        *,
+        role: SubAgentRole,
+        result_model: type[ResultArgsT],
+        max_result_chars: int = DEFAULT_MAX_SUBMITTED_RESULT_CHARS,
+        acceptance_validator: Callable[[ResultArgsT], str | None] | None = None,
+    ) -> None:
+        if max_result_chars < 1:
+            raise ValueError("max_result_chars must be at least 1.")
+        self.role = role
+        self.args_model = result_model
+        self.max_result_chars = max_result_chars
+        self.acceptance_validator = acceptance_validator
+        self.submitted_result: ResultArgsT | None = None
+
+    def _run(self, args: ResultArgsT) -> ToolResult:
+        if self.submitted_result is not None:
+            return ToolResult.failure(
+                error="A structured SubAgent result has already been submitted.",
+                metadata={"role": self.role, "reason": "result_already_submitted"},
+            )
+
+        serialized = args.model_dump_json()
+        result_chars = len(serialized)
+        if result_chars > self.max_result_chars:
+            return ToolResult.failure(
+                error=(
+                    "Structured SubAgent result exceeds the allowed size: "
+                    f"{result_chars}/{self.max_result_chars} characters."
+                ),
+                metadata={
+                    "role": self.role,
+                    "reason": "result_too_large",
+                    "result_chars": result_chars,
+                    "max_result_chars": self.max_result_chars,
+                },
+            )
+
+        if self.acceptance_validator is not None:
+            try:
+                validation_error = self.acceptance_validator(args)
+            except Exception as error:
+                return ToolResult.failure(
+                    error="Runtime result validation failed unexpectedly.",
+                    metadata={
+                        "role": self.role,
+                        "reason": "result_runtime_validation_error",
+                        "exception_type": type(error).__name__,
+                    },
+                )
+            if validation_error is not None:
+                return ToolResult.failure(
+                    error=validation_error,
+                    metadata={
+                        "role": self.role,
+                        "reason": "result_runtime_validation_failed",
+                    },
+                )
+
+        self.submitted_result = args
+        outcome = getattr(args, "status", None)
+        if outcome is None:
+            outcome = getattr(args, "recommendation", None)
+        return ToolResult.success(
+            content="Structured SubAgent result accepted.",
+            metadata={
+                "role": self.role,
+                "outcome": outcome,
+                "result_chars": result_chars,
+                "truncated": args.truncated,
+                "omitted_count": args.omitted_count,
+            },
+        )

mycode/tools/text.py

@@ -0,0 +1,15 @@
+SUPPORTED_TEXT_ENCODINGS = ("utf-8", "gbk")
+
+
+def contains_nul_byte(raw_content: bytes) -> bool:
+    return b"\x00" in raw_content
+
+
+def decode_text(raw_content: bytes) -> tuple[str, str] | None:
+    for encoding in SUPPORTED_TEXT_ENCODINGS:
+        try:
+            return raw_content.decode(encoding), encoding
+        except UnicodeDecodeError:
+            continue
+
+    return None