yycode 0.3.2__py3-none-any.whl

agent/runtime/tool_output.py

@@ -0,0 +1,261 @@
+"""Model-facing compaction for verbose tool outputs."""
+
+from __future__ import annotations
+
+import re
+from dataclasses import dataclass
+
+from agent.runtime.tool_events import file_paths_for_tool_call
+
+
+MAX_MODEL_TOOL_OUTPUT_CHARS = 4_000
+MAX_MODEL_READ_OUTPUT_CHARS = 12_000
+MAX_MODEL_DIFF_LINES = 80
+MAX_MODEL_COMMAND_OUTPUT_CHARS = 3_000
+
+
+@dataclass(frozen=True)
+class ToolOutputView:
+    """Separate output shown to users from output persisted into model messages."""
+
+    display: str
+    model: str
+    context_policy: str = "full"
+
+
+def build_tool_output_view(tool_name: str, raw_output: str, tc) -> ToolOutputView:
+    """Return display and model-facing representations for one tool result."""
+    display = raw_output or ""
+    if tool_name == "git_diff":
+        return ToolOutputView(
+            display=display,
+            model=_compact_diff_output(display, "git_diff"),
+            context_policy="compact",
+        )
+    if tool_name in {"apply_patch", "write_file"}:
+        return ToolOutputView(
+            display=display,
+            model=_compact_write_output(tool_name, display, tc),
+            context_policy="compact",
+        )
+    if tool_name in {"bash", "verify"}:
+        return _command_output_view(tool_name, display)
+    if tool_name in {"read_file", "read_many_files", "grep", "git_show"}:
+        return _read_output_view(tool_name, display, tc)
+    if len(display) > MAX_MODEL_TOOL_OUTPUT_CHARS:
+        return ToolOutputView(
+            display=display,
+            model=_truncate_with_notice(display, MAX_MODEL_TOOL_OUTPUT_CHARS),
+            context_policy="compact",
+        )
+    return ToolOutputView(display=display, model=display)
+
+
+def compact_preflight_output(output: str) -> str:
+    """Return a compact preflight block for model context."""
+    changed_files = _changed_files_from_workspace_state(output)
+    diff_files = _changed_files_from_diff(output)
+    files = _unique([*changed_files, *diff_files])
+    lines = [
+        "Code workflow guard blocked this write because workspace preflight had not been reviewed yet.",
+        "",
+        "Preflight summary:",
+        f"- changed_files: {len(files)}" if files else "- changed_files: unknown",
+    ]
+    lines.extend(f"  - {path}" for path in files[:20])
+    if len(files) > 20:
+        lines.append(f"  ... {len(files) - 20} more file(s)")
+    lines.extend(
+        [
+            "",
+            "Review workspace_state/git_diff results, then retry the write with the smallest safe patch.",
+            "Verbose preflight output was omitted from model context to avoid carrying large diffs forward.",
+        ]
+    )
+    return "\n".join(lines)
+
+
+def _command_output_view(tool_name: str, output: str) -> ToolOutputView:
+    if _is_success_empty_command_output(output):
+        return ToolOutputView(
+            display=output,
+            model=(
+                "[Tool output omitted from model context; command completed successfully "
+                "with empty stdout/stderr. Full result was shown in the UI.]"
+            ),
+            context_policy="marker",
+        )
+    if len(output) > MAX_MODEL_COMMAND_OUTPUT_CHARS:
+        return ToolOutputView(
+            display=output,
+            model=_compact_command_output(tool_name, output),
+            context_policy="compact",
+        )
+    return ToolOutputView(display=output, model=output)
+
+
+def _read_output_view(tool_name: str, output: str, tc) -> ToolOutputView:
+    if len(output) <= MAX_MODEL_READ_OUTPUT_CHARS:
+        return ToolOutputView(display=output, model=output)
+    paths = file_paths_for_tool_call(tc)
+    path_text = ", ".join(paths[:10]) if paths else "(unknown)"
+    head = output[:5_000].rstrip()
+    tail = output[-2_000:].lstrip()
+    omitted = max(len(output) - len(head) - len(tail), 0)
+    model = (
+        f"{tool_name} output was compacted for model context.\n"
+        f"paths: {path_text}\n"
+        f"original_chars: {len(output)}\n"
+        f"omitted_chars: {omitted}\n"
+        "Use a narrower read_file line range or grep query if more detail is needed.\n\n"
+        f"head:\n{head}\n\n"
+        f"tail:\n{tail}"
+    )
+    return ToolOutputView(display=output, model=model, context_policy="compact")
+
+
+def _compact_write_output(tool_name: str, output: str, tc) -> str:
+    if output.startswith(("Error:", "approval_required:", "Code workflow guard blocked")):
+        return _truncate_with_notice(output, MAX_MODEL_TOOL_OUTPUT_CHARS)
+    paths = file_paths_for_tool_call(tc)
+    diff = _extract_diff(output)
+    stat = _extract_diff_stat(output)
+    lines = [f"{tool_name} completed."]
+    if paths:
+        lines.append("files:")
+        lines.extend(f"- {path}" for path in paths[:20])
+        if len(paths) > 20:
+            lines.append(f"- ... {len(paths) - 20} more file(s)")
+    if stat:
+        lines.extend(["", "diff_stat:", stat])
+    if diff:
+        lines.extend(["", _compact_diff_output(diff, "diff preview")])
+    else:
+        lines.extend(["", _truncate_with_notice(output, MAX_MODEL_TOOL_OUTPUT_CHARS)])
+    return "\n".join(lines)
+
+
+def _compact_diff_output(diff: str, label: str) -> str:
+    if not diff.strip() or diff.strip() == "No diff.":
+        return "No diff."
+    files = _changed_files_from_diff(diff)
+    added = removed = 0
+    kept_lines: list[str] = []
+    for line in diff.splitlines():
+        if line.startswith("+") and not line.startswith("+++"):
+            added += 1
+        elif line.startswith("-") and not line.startswith("---"):
+            removed += 1
+        if len(kept_lines) < MAX_MODEL_DIFF_LINES:
+            kept_lines.append(line)
+    lines = [
+        f"{label} summary:",
+        f"- files_changed: {len(files)}",
+        f"- added_lines: {added}",
+        f"- removed_lines: {removed}",
+    ]
+    if files:
+        lines.append("- files:")
+        lines.extend(f"  - {path}" for path in files[:20])
+        if len(files) > 20:
+            lines.append(f"  ... {len(files) - 20} more file(s)")
+    lines.extend(["", f"first_{MAX_MODEL_DIFF_LINES}_diff_lines:", *kept_lines])
+    if len(diff.splitlines()) > MAX_MODEL_DIFF_LINES:
+        lines.append(
+            "... diff truncated for model context; full output was streamed to the UI "
+            "or can be requested again with git_diff."
+        )
+    return "\n".join(lines)
+
+
+def _compact_command_output(tool_name: str, output: str) -> str:
+    if len(output) <= MAX_MODEL_COMMAND_OUTPUT_CHARS:
+        return output
+    head = output[:1200].rstrip()
+    tail = output[-1200:].lstrip()
+    omitted = len(output) - len(head) - len(tail)
+    return (
+        f"{tool_name} output was truncated for model context.\n"
+        f"original_chars: {len(output)}\n"
+        f"omitted_chars: {max(omitted, 0)}\n\n"
+        f"head:\n{head}\n\n"
+        f"tail:\n{tail}"
+    )
+
+
+def _is_success_empty_command_output(output: str) -> bool:
+    normalized = output.replace("\r\n", "\n")
+    return (
+        "status: success" in normalized
+        and "exit_code: 0" in normalized
+        and "stdout:\n(empty)" in normalized
+        and "stderr:\n(empty)" in normalized
+    )
+
+
+def _truncate_with_notice(text: str, limit: int) -> str:
+    if len(text) <= limit:
+        return text
+    return (
+        text[:limit].rstrip()
+        + f"\n... output truncated for model context from {len(text)} to {limit} chars"
+    )
+
+
+def _extract_diff(output: str) -> str:
+    marker = "\ndiff:\n"
+    if marker in output:
+        return output.split(marker, 1)[1]
+    if output.startswith("diff:\n"):
+        return output[len("diff:\n") :]
+    if output.startswith("diff --git ") or output.startswith("--- "):
+        return output
+    return ""
+
+
+def _extract_diff_stat(output: str) -> str:
+    marker = "\ndiff_stat:\n"
+    if marker not in output:
+        return ""
+    tail = output.split(marker, 1)[1]
+    if "\ndiff:\n" in tail:
+        tail = tail.split("\ndiff:\n", 1)[0]
+    return tail.strip()
+
+
+def _changed_files_from_diff(diff: str) -> list[str]:
+    paths: list[str] = []
+    for line in diff.splitlines():
+        path = None
+        if line.startswith("diff --git "):
+            match = re.match(r"diff --git a/(.+?) b/(.+)$", line)
+            if match:
+                path = match.group(2)
+        elif line.startswith("+++ "):
+            raw = line[4:].split("\t", 1)[0].strip()
+            if raw != "/dev/null":
+                path = raw[2:] if raw.startswith("b/") else raw
+        if path and path not in paths:
+            paths.append(path)
+    return paths
+
+
+def _changed_files_from_workspace_state(output: str) -> list[str]:
+    paths: list[str] = []
+    for line in output.splitlines():
+        stripped = line.strip()
+        if not stripped or stripped.startswith(("branch:", "changed_files:", "status:")):
+            continue
+        if stripped[:2] in {"M ", "A ", "D ", "??"}:
+            path = stripped[2:].strip()
+            if path:
+                paths.append(path)
+    return paths
+
+
+def _unique(items: list[str]) -> list[str]:
+    values: list[str] = []
+    for item in items:
+        if item and item not in values:
+            values.append(item)
+    return values

agent/runtime/tool_registry.py

@@ -0,0 +1,91 @@
+"""Runtime tool registry and handler binding."""
+
+from functools import wraps
+from typing import Callable, Optional
+
+from agent.runtime.context import AgentRuntimeContext
+from agent.runtime.workspace_tools import WORKSPACE_BOUND_TOOLS
+from agent.skills import SkillRegistry
+from agent.subagent import SubagentRunner
+
+
+CONCURRENT_SUBAGENT_ROLES = {"explorer", "architect", "tester", "security"}
+DEFAULT_TOOL_TIMEOUT_SECONDS = 3600
+DEFAULT_TOOL_EXECUTION = {
+    "side_effects": "unknown",
+    "concurrency": "serial",
+    "timeout_seconds": DEFAULT_TOOL_TIMEOUT_SECONDS,
+}
+
+class RuntimeToolRegistry:
+    """Resolve runtime-bound tool handlers and execution metadata."""
+
+    def __init__(self, runtime: AgentRuntimeContext):
+        self.runtime = runtime
+        self.todo_handler = runtime.todo_manager.create_todo_handler()
+        self.skill_registry = SkillRegistry(runtime.workdir, runtime.skill_dirs)
+        self.tool_execution = {
+            tool["name"]: tool.get("execution", {})
+            for tool in runtime.tools
+        }
+
+    def resolve(self, tool_name: str) -> Optional[Callable]:
+        """Return the handler for a tool name."""
+        if tool_name == "todo":
+            return self.todo_handler
+        if tool_name == "list_skills":
+            return self.skill_registry.format_skill_list
+        if tool_name == "load_skill":
+            return lambda names: self.skill_registry.format_loaded_skills(names)
+        if tool_name == "subagent":
+            return self.create_subagent_runner().run
+        handler = self.runtime.tool_handlers.get(tool_name)
+        if handler is not None and tool_name in WORKSPACE_BOUND_TOOLS:
+            return self._bind_workdir(handler)
+        return handler
+
+    def _bind_workdir(self, handler: Callable) -> Callable:
+        """Inject runtime workdir into workspace-bound tools without exposing it to models."""
+
+        @wraps(handler)
+        def wrapped(*args, **kwargs):
+            kwargs.setdefault("workdir", self.runtime.workdir)
+            return handler(*args, **kwargs)
+
+        return wrapped
+
+    def create_subagent_runner(self) -> SubagentRunner:
+        """Create a subagent runner bound to the current runtime."""
+        return SubagentRunner(
+            provider=self.runtime.provider,
+            workdir=self.runtime.workdir,
+            parent_system_prompt=self.runtime.system_prompt,
+            tool_handlers=self.runtime.tool_handlers,
+            tools=self.runtime.tools,
+            parent_session_id=self.runtime.session_id,
+            skill_dirs=self.runtime.skill_dirs,
+            app_root=self.runtime.app_root,
+            stream_callback=self.runtime.stream_callback,
+            approval_callback=self.runtime.approval_callback,
+        )
+
+    def execution_for(self, tool_name: str) -> dict:
+        """Return execution policy for a tool."""
+        return {**DEFAULT_TOOL_EXECUTION, **self.tool_execution.get(tool_name, {})}
+
+    def timeout_for(self, tool_name: str) -> int:
+        """Return timeout seconds for a tool."""
+        return int(self.execution_for(tool_name)["timeout_seconds"])
+
+    def is_workspace_write(self, tool_name: str) -> bool:
+        """Return whether a tool mutates the workspace."""
+        return self.execution_for(tool_name)["side_effects"] == "workspace_write"
+
+    def can_run_concurrently(self, tool_call) -> bool:
+        """Return whether a tool call may run in a concurrent batch."""
+        if tool_call.name == "subagent":
+            return tool_call.args.get("role") in CONCURRENT_SUBAGENT_ROLES
+        execution = self.execution_for(tool_call.name)
+        if execution["side_effects"] in {"workspace_write", "session_state"}:
+            return False
+        return execution["concurrency"] == "safe"

agent/runtime/tool_scheduler.py

@@ -0,0 +1,35 @@
+"""Tool call scheduling helpers."""
+
+import asyncio
+from typing import Awaitable, Callable
+
+
+async def execute_tool_calls(
+    tool_calls,
+    execute_tool_call: Callable[[object], Awaitable[object]],
+    can_run_concurrently: Callable[[object], bool],
+) -> list[object]:
+    """Execute tool calls while preserving original result order."""
+    results = [None] * len(tool_calls)
+    concurrent_batch = []
+
+    async def flush_concurrent_batch():
+        if not concurrent_batch:
+            return
+        batch = list(concurrent_batch)
+        concurrent_batch.clear()
+        outputs = await asyncio.gather(
+            *(execute_tool_call(tc) for _, tc in batch),
+        )
+        for (index, _), output in zip(batch, outputs):
+            results[index] = output
+
+    for index, tc in enumerate(tool_calls):
+        if can_run_concurrently(tc):
+            concurrent_batch.append((index, tc))
+            continue
+        await flush_concurrent_batch()
+        results[index] = await execute_tool_call(tc)
+
+    await flush_concurrent_batch()
+    return results

agent/runtime/workflow_guard.py

@@ -0,0 +1,217 @@
+"""Workspace workflow guardrails."""
+
+from langchain_core.messages import HumanMessage
+
+from agent.runtime.context import AgentRuntimeContext, WorkflowState
+from agent.runtime.tool_events import file_paths_for_tool_call, tool_output_indicates_successful_write
+from agent.runtime.tool_registry import RuntimeToolRegistry
+
+
+CODE_EXTENSIONS = {
+    ".c",
+    ".cc",
+    ".cpp",
+    ".cs",
+    ".css",
+    ".cxx",
+    ".go",
+    ".h",
+    ".hpp",
+    ".html",
+    ".java",
+    ".js",
+    ".jsx",
+    ".kt",
+    ".kts",
+    ".m",
+    ".mm",
+    ".php",
+    ".py",
+    ".rb",
+    ".rs",
+    ".scala",
+    ".scss",
+    ".sh",
+    ".swift",
+    ".ts",
+    ".tsx",
+    ".vue",
+}
+
+VERIFY_CONFIG_EXTENSIONS = {
+    ".gradle",
+    ".kts",
+    ".lock",
+    ".toml",
+    ".xml",
+}
+
+VERIFY_CONFIG_FILENAMES = {
+    ".eslintrc",
+    ".eslintrc.cjs",
+    ".eslintrc.js",
+    ".eslintrc.json",
+    ".prettierrc",
+    ".ruff.toml",
+    "Cargo.lock",
+    "Cargo.toml",
+    "build.gradle",
+    "build.gradle.kts",
+    "go.mod",
+    "go.sum",
+    "mypy.ini",
+    "package-lock.json",
+    "package.json",
+    "pnpm-lock.yaml",
+    "pom.xml",
+    "pyproject.toml",
+    "pytest.ini",
+    "requirements-dev.txt",
+    "requirements.txt",
+    "setup.cfg",
+    "setup.py",
+    "tox.ini",
+    "tsconfig.json",
+    "yarn.lock",
+}
+
+VERIFY_CONFIG_SUFFIXES = {
+    ".csproj",
+    ".fsproj",
+    ".props",
+    ".sln",
+    ".targets",
+    ".vbproj",
+}
+
+
+class WorkflowGuard:
+    """Enforce workspace safety and verification workflow rules."""
+
+    def __init__(self, runtime: AgentRuntimeContext, registry: RuntimeToolRegistry):
+        self.runtime = runtime
+        self.registry = registry
+        self.state: WorkflowState = runtime.workflow_state
+
+    def has_preflight(self) -> bool:
+        """Return whether workspace state and diff have been checked."""
+        return self.state.workspace_state_checked and self.state.git_diff_checked
+
+    def path_exists(self, path: str) -> bool:
+        """Return whether a workspace-relative path exists."""
+        if not path:
+            return False
+        return (self.runtime.workdir / path).resolve().exists()
+
+    def should_require_apply_patch(self, tc) -> bool:
+        """Return whether a tool call should be redirected to apply_patch."""
+        if tc.name == "edit_file":
+            return True
+        if tc.name == "write_file":
+            return self.path_exists(tc.args.get("path", ""))
+        return False
+
+    def apply_patch_required_message(self, tc) -> str:
+        """Return a message explaining why apply_patch is required."""
+        path = tc.args.get("path", "")
+        if tc.name == "write_file":
+            return (
+                f"Code workflow guard blocked write_file for existing file: {path}\n\n"
+                "Use apply_patch with path + old_text + new_text, or a unified diff, "
+                "for existing file edits. "
+                "write_file is only allowed for brand-new files or generated artifacts."
+            )
+        return (
+            f"Code workflow guard blocked edit_file for: {path}\n\n"
+            "Use apply_patch with path + old_text + new_text, or a unified diff, "
+            "for code edits so the change is reviewable "
+            "and the diff can be shown to the user."
+        )
+
+    async def run_preflight(self) -> str:
+        """Collect workspace state and diff before allowing a write tool."""
+        workspace_output = await self.runtime.run_tool(
+            self.registry.resolve("workspace_state"),
+            "workspace_state",
+            max_retries=0,
+            timeout_seconds=self.registry.timeout_for("workspace_state"),
+        )
+        diff_output = await self.runtime.run_tool(
+            self.registry.resolve("git_diff"),
+            "git_diff",
+            max_retries=0,
+            timeout_seconds=self.registry.timeout_for("git_diff"),
+        )
+        self.state.workspace_state_checked = True
+        self.state.git_diff_checked = True
+        return (
+            "Code workflow guard blocked this write because workspace preflight "
+            "had not been reviewed yet.\n\n"
+            "workspace_state:\n"
+            f"{workspace_output}\n\n"
+            "git_diff:\n"
+            f"{diff_output}\n\n"
+            "Review the existing changes, then retry the write with the smallest safe patch."
+        )
+
+    def update_after_tool(self, tool_call, output: str) -> bool:
+        """Update workflow state after a tool and return whether a diff event is needed."""
+        tool_name = tool_call.name
+        if tool_name == "workspace_state":
+            self.state.workspace_state_checked = True
+        if tool_name == "git_diff":
+            self.state.git_diff_checked = True
+        if tool_name == "verify":
+            self.state.needs_verify = False
+        if self.registry.is_workspace_write(tool_name) and tool_output_indicates_successful_write(output):
+            self.state.needs_verify = paths_need_code_verification(file_paths_for_tool_call(tool_call))
+            return True
+        return False
+
+    def after_batch_messages(self, tool_calls_data: list) -> list[HumanMessage]:
+        """Return extra HumanMessages to append after a tools batch."""
+        additional_messages = []
+        todo_manager = self.runtime.todo_manager
+        if todo_manager.needs_reminder():
+            additional_messages.append(
+                HumanMessage(
+                    content=todo_manager.consume_reminder_message(),
+                    additional_kwargs={
+                        "context_ephemeral": True,
+                        "ephemeral_kind": "task_reminder",
+                    },
+                )
+            )
+        if self.state.needs_verify and not any(tc.name == "verify" for tc in tool_calls_data):
+            additional_messages.append(
+                HumanMessage(
+                    content=(
+                        "Code changes were made. Run verify with the narrowest useful "
+                        "target before providing the final answer."
+                    ),
+                    additional_kwargs={
+                        "context_ephemeral": True,
+                        "ephemeral_kind": "verify_reminder",
+                    },
+                )
+            )
+        return additional_messages
+
+
+def paths_need_code_verification(paths: list[str]) -> bool:
+    """Return whether changed paths should trigger code verification."""
+    if not paths:
+        return True
+    return any(path_needs_code_verification(path) for path in paths)
+
+
+def path_needs_code_verification(path: str) -> bool:
+    """Return whether a single path is code or known build/test configuration."""
+    normalized = path.replace("\\", "/").rstrip("/")
+    name = normalized.rsplit("/", 1)[-1]
+    if name in VERIFY_CONFIG_FILENAMES:
+        return True
+    if any(name.endswith(suffix) for suffix in VERIFY_CONFIG_SUFFIXES):
+        return True
+    extension = "." + name.rsplit(".", 1)[-1].lower() if "." in name else ""
+    return extension in CODE_EXTENSIONS or extension in VERIFY_CONFIG_EXTENSIONS

agent/runtime/workspace.py

@@ -0,0 +1,5 @@
+"""Runtime import compatibility for workspace helpers."""
+
+from tools.workspace import Workspace, resolve_workspace
+
+__all__ = ["Workspace", "resolve_workspace"]

agent/runtime/workspace_tools.py

@@ -0,0 +1,22 @@
+"""Workspace-bound tool names used by runtime and subagents."""
+
+WORKSPACE_BOUND_TOOLS = {
+    "read_file",
+    "read_many_files",
+    "write_file",
+    "edit_file",
+    "apply_patch",
+    "grep",
+    "list_files",
+    "lsp_definition",
+    "lsp_diagnostics",
+    "lsp_document_symbols",
+    "lsp_hover",
+    "lsp_references",
+    "lsp_workspace_symbols",
+    "git_show",
+    "git_diff",
+    "workspace_state",
+    "verify",
+    "bash",
+}