chore: import upstream snapshot with attribution

tools/pi_coding_tool/validation.py

@@ -0,0 +1,74 @@
+"""Input validation and request resolution for the Pi coding tool.
+
+Turns the loose tool arguments (``task`` / ``workspace`` / ``model``) into a
+validated, fully-resolved :class:`ResolvedRequest`, applying config defaults
+(``PI_CODING_WORKSPACE`` / ``PI_CODING_MODEL`` / ``PI_CODING_TIMEOUT_SECONDS``).
+Each validator raises :class:`PiCodingError` with ``kind="invalid_input"`` on a
+bad value.
+"""
+
+from __future__ import annotations
+
+from dataclasses import dataclass
+from pathlib import Path
+
+from integrations.pi import pi_coding_model, pi_coding_timeout_seconds, pi_coding_workspace
+from tools.pi_coding_tool.errors import ERR_INVALID_INPUT, PiCodingError
+
+_MAX_TASK_CHARS = 4000
+
+
+@dataclass(frozen=True)
+class ResolvedRequest:
+    """A validated, fully-resolved coding request ready to execute."""
+
+    task: str
+    workspace: str
+    model: str | None
+    timeout_sec: float
+
+
+def validate_task(task: str | None) -> str:
+    cleaned = (task or "").strip()
+    if not cleaned:
+        raise PiCodingError(ERR_INVALID_INPUT, "task is required and must be non-empty.")
+    if len(cleaned) > _MAX_TASK_CHARS:
+        raise PiCodingError(
+            ERR_INVALID_INPUT,
+            f"task is too long ({len(cleaned)} chars); keep it under {_MAX_TASK_CHARS}.",
+        )
+    return cleaned
+
+
+def validate_workspace(workspace: str | None) -> str:
+    resolved = (workspace or "").strip() or pi_coding_workspace()
+    path = Path(resolved).expanduser()
+    if not path.exists():
+        raise PiCodingError(ERR_INVALID_INPUT, f"workspace does not exist: {path}")
+    if not path.is_dir():
+        raise PiCodingError(ERR_INVALID_INPUT, f"workspace is not a directory: {path}")
+    return str(path)
+
+
+def validate_model(model: str | None) -> str | None:
+    resolved = (model or "").strip() or pi_coding_model()
+    if resolved is None:
+        return None
+    # Pi accepts "provider/model" and shorthands (e.g. "sonnet:high"); only reject
+    # obviously malformed values (whitespace inside the token).
+    if any(ch.isspace() for ch in resolved):
+        raise PiCodingError(
+            ERR_INVALID_INPUT,
+            f"model must not contain whitespace; got {resolved!r}.",
+        )
+    return resolved
+
+
+def resolve_request(task: str | None, workspace: str | None, model: str | None) -> ResolvedRequest:
+    """Validate + normalize the tool arguments into a :class:`ResolvedRequest`."""
+    return ResolvedRequest(
+        task=validate_task(task),
+        workspace=validate_workspace(workspace),
+        model=validate_model(model),
+        timeout_sec=pi_coding_timeout_seconds(),
+    )