yycode 0.3.2__py3-none-any.whl

tools/apply_patch.py

@@ -0,0 +1,305 @@
+"""Apply reviewable patches safely inside the workspace."""
+
+from difflib import unified_diff
+import re
+import subprocess
+from pathlib import Path
+
+from .read_file import safe_path, workspace_for
+from .safety import ApprovalRequired, approval_required
+
+MAX_PATCH_CHARS = 100_000
+MAX_REPLACEMENT_LINES = 80
+
+
+def _strip_fence(patch: str) -> str:
+    text = patch
+    if text.lstrip().startswith("```"):
+        lines = text.strip().splitlines()
+        if lines and lines[-1].strip() == "```":
+            return "\n".join(lines[1:-1]) + "\n"
+    return text
+
+
+def _changed_paths(patch: str) -> set[str]:
+    paths = set()
+    for line in patch.splitlines():
+        if line.startswith("deleted file mode") or line.startswith("+++ /dev/null"):
+            raise ApprovalRequired(
+                approval_required(
+                    action="delete_file",
+                    reason="apply_patch does not delete files without explicit approval.",
+                    risk="File deletion can remove user work or project assets.",
+                )
+            )
+        if line.startswith(("--- ", "+++ ")):
+            raw = line[4:].split("\t", 1)[0].strip()
+            if raw == "/dev/null":
+                continue
+            if raw.startswith(("a/", "b/")):
+                raw = raw[2:]
+            paths.add(raw)
+        elif line.startswith("diff --git "):
+            match = re.match(r"diff --git a/(.+?) b/(.+)$", line)
+            if match:
+                paths.update(match.groups())
+    return paths
+
+
+def _validate_paths(paths: set[str], workdir: Path | str | None = None) -> None:
+    if not paths:
+        raise ValueError("no changed paths found in patch")
+    for path in paths:
+        if Path(path).is_absolute() or ".." in Path(path).parts:
+            raise ValueError(f"path escapes workspace: {path}")
+        safe_path(path, workdir)
+
+
+def _read_snapshot(path: str, workdir: Path | str | None = None) -> str:
+    fp = safe_path(path, workdir)
+    if not fp.exists():
+        return ""
+    try:
+        return fp.read_text()
+    except UnicodeDecodeError:
+        return "<binary or non-utf8 file>"
+
+
+def _format_operation_diff(
+    action: str,
+    before_by_path: dict[str, str],
+    workdir: Path | str | None = None,
+) -> str:
+    sections = _diff_sections(
+        {
+            path: (before, _read_snapshot(path, workdir))
+            for path, before in before_by_path.items()
+        }
+    )
+    if not sections:
+        return f"{action}\n\ndiff: No diff."
+    return f"{action}\n\ndiff:\n" + "\n".join(sections)
+
+
+def _diff_sections(before_after_by_path: dict[str, tuple[str, str]]) -> list[str]:
+    sections = []
+    for path, (before, after) in before_after_by_path.items():
+        if before == after:
+            continue
+        before_lines = before.splitlines()
+        after_lines = after.splitlines()
+        diff = "\n".join(
+            unified_diff(
+                before_lines,
+                after_lines,
+                fromfile=f"a/{path}",
+                tofile=f"b/{path}",
+                lineterm="",
+            )
+        )
+        if diff:
+            sections.append(diff)
+    return sections
+
+
+def _format_preview_diff(before_after_by_path: dict[str, tuple[str, str]]) -> str:
+    sections = _diff_sections(before_after_by_path)
+    return "\n".join(sections)
+
+
+def _preview_replacement(
+    path: str,
+    old_text: str,
+    new_text: str,
+    workdir: Path | str | None = None,
+) -> str:
+    try:
+        fp = safe_path(path, workdir)
+        content = fp.read_text()
+    except Exception as exc:
+        return f"Error: {exc}"
+    if old_text not in content:
+        return f"Error: old_text not found in {path}"
+    after = content.replace(old_text, new_text, 1)
+    return _format_preview_diff({path: (content, after)})
+
+
+def preview_apply_patch_diff(
+    patch: str = "",
+    path: str = "",
+    old_text: str = "",
+    new_text: str = "",
+    workdir: Path | str | None = None,
+) -> str:
+    """Return the diff that apply_patch would apply without modifying files."""
+    if path or old_text or new_text:
+        if not path or not old_text:
+            return ""
+        return _preview_replacement(path, old_text, new_text, workdir)
+
+    patch_text = _strip_fence(patch)
+    if not patch_text.strip() or patch_text.lstrip().startswith("*** Begin Patch"):
+        return ""
+    if len(patch_text) > MAX_PATCH_CHARS:
+        return ""
+    try:
+        changed_paths = _changed_paths(patch_text)
+        _validate_paths(changed_paths, workdir)
+    except Exception:
+        return ""
+    return patch_text.strip()
+
+
+def _looks_like_whole_file(content: str, old_text: str) -> bool:
+    return old_text == content and len(content.splitlines()) > MAX_REPLACEMENT_LINES
+
+
+def _replacement_is_too_large(old_text: str, new_text: str) -> bool:
+    return (
+        len(old_text.splitlines()) > MAX_REPLACEMENT_LINES
+        or len(new_text.splitlines()) > MAX_REPLACEMENT_LINES
+    )
+
+
+def _apply_replacement(
+    path: str,
+    old_text: str,
+    new_text: str,
+    workdir: Path | str | None = None,
+) -> str:
+    fp = safe_path(path, workdir)
+    content = fp.read_text()
+    if old_text not in content:
+        return f"Error: old_text not found in {path}"
+    if _looks_like_whole_file(content, old_text):
+        return (
+            "Error: Refusing whole-file replacement in apply_patch exact replacement mode. "
+            "Use old_text/new_text for only the smallest changed block, or provide a focused unified diff."
+        )
+    if _replacement_is_too_large(old_text, new_text):
+        return (
+            f"Error: Replacement block is too large for exact replacement mode "
+            f"({MAX_REPLACEMENT_LINES} line limit). Use a focused unified diff with context instead."
+        )
+    before_by_path = {path: content}
+    fp.write_text(content.replace(old_text, new_text, 1))
+    return _format_operation_diff(f"Applied replacement patch to {path}.", before_by_path, workdir)
+
+
+def _edit_approval_required(paths: list[str]) -> str:
+    path_text = ", ".join(paths) if paths else ""
+    return approval_required(
+        action="edit_file",
+        path=path_text,
+        reason="apply_patch edits workspace files and requires user approval before writing.",
+        risk="File edits can overwrite user work or introduce unintended code changes.",
+    )
+
+
+def apply_patch(
+    patch: str = "",
+    path: str = "",
+    old_text: str = "",
+    new_text: str = "",
+    approved: bool = False,
+    workdir: Path | str | None = None,
+) -> str:
+    """Apply a unified diff or exact replacement patch after path validation."""
+    try:
+        workspace = workspace_for(workdir)
+        if path or old_text or new_text:
+            if not path or not old_text:
+                return "Error: path and old_text are required for replacement patches"
+            if not approved:
+                return _edit_approval_required([path])
+            return _apply_replacement(path, old_text, new_text, workspace.root)
+
+        patch_text = _strip_fence(patch)
+        if not patch_text.strip():
+            return "Error: Patch is empty"
+        if patch_text.lstrip().startswith("*** Begin Patch"):
+            return "Error: apply_patch expects a unified diff patch, not Begin Patch format"
+        if len(patch_text) > MAX_PATCH_CHARS:
+            return f"Error: Patch exceeds {MAX_PATCH_CHARS} characters"
+
+        changed_paths = _changed_paths(patch_text)
+        _validate_paths(changed_paths, workspace.root)
+        if not approved:
+            return _edit_approval_required(sorted(changed_paths))
+        before_by_path = {path: _read_snapshot(path, workspace.root) for path in sorted(changed_paths)}
+
+        check = subprocess.run(
+            ["git", "apply", "--check", "--whitespace=nowarn", "-"],
+            input=patch_text,
+            cwd=workspace.root,
+            capture_output=True,
+            text=True,
+            errors="backslashreplace",
+            timeout=60,
+        )
+        if check.returncode != 0:
+            output = (check.stdout + check.stderr).strip()
+            return f"Error: {output or 'git apply --check failed'}"
+
+        result = subprocess.run(
+            ["git", "apply", "--whitespace=nowarn", "-"],
+            input=patch_text,
+            cwd=workspace.root,
+            capture_output=True,
+            text=True,
+            errors="backslashreplace",
+            timeout=60,
+        )
+        if result.returncode != 0:
+            output = (result.stdout + result.stderr).strip()
+            return f"Error: {output or 'git apply failed'}"
+
+        return _format_operation_diff("Applied patch.", before_by_path, workspace.root)
+    except subprocess.TimeoutExpired:
+        return "Error: Timeout"
+    except ApprovalRequired as exc:
+        return str(exc)
+    except Exception as exc:
+        return f"Error: {exc}"
+
+
+apply_patch_tool = {
+    "name": "apply_patch",
+    "description": (
+        "Primary tool for editing existing files. Prefer path + old_text + new_text "
+        "for exact replacements (old_text MUST contain ONLY the exact lines to be changed, "
+        "NOT the entire file and not large unchanged blocks); use patch for focused unified diffs. Requires approved=true "
+        "after explicit user approval and returns the resulting diff."
+    ),
+    "execution": {
+        "side_effects": "workspace_write",
+        "concurrency": "serial",
+        "timeout_seconds": 60,
+    },
+    "input_schema": {
+        "type": "object",
+        "properties": {
+            "patch": {
+                "type": "string",
+                "description": "Optional unified diff patch to apply inside the workspace.",
+            },
+            "path": {
+                "type": "string",
+                "description": "Workspace-relative file path for exact replacement mode.",
+            },
+            "old_text": {
+                "type": "string",
+                "description": "Small exact text block to replace once. Do not pass the whole file or large unchanged blocks.",
+            },
+            "new_text": {
+                "type": "string",
+                "description": "Replacement text for the small changed block.",
+            },
+            "approved": {
+                "type": "boolean",
+                "description": "Set true only after the user explicitly approves this file edit.",
+            },
+        },
+        "required": [],
+    },
+}

tools/bash.py

@@ -0,0 +1,76 @@
+"""Bash tool."""
+
+import subprocess
+from pathlib import Path
+
+from .safety import unsafe_command_response
+from .read_file import workspace_for
+
+MAX_OUTPUT_CHARS = 50_000
+
+
+def _format_stream(name: str, content: str) -> str:
+    """Format a subprocess stream with an explicit empty marker."""
+    text = content.strip()
+    return f"{name}:\n{text or '(empty)'}"
+
+
+def _format_bash_result(returncode: int, stdout: str, stderr: str) -> str:
+    """Return a model-readable command result."""
+    status = "success" if returncode == 0 else "failed"
+    result = (
+        f"status: {status}\n"
+        f"exit_code: {returncode}\n"
+        f"{_format_stream('stdout', stdout)}\n"
+        f"{_format_stream('stderr', stderr)}"
+    )
+    if len(result) > MAX_OUTPUT_CHARS:
+        return result[:MAX_OUTPUT_CHARS] + f"\n... output truncated to {MAX_OUTPUT_CHARS} chars"
+    return result
+
+
+def bash(command: str, approved: bool = False, workdir: Path | str | None = None) -> str:
+    """Run a shell command."""
+    unsafe_response = unsafe_command_response(command)
+    if unsafe_response and not approved:
+        return unsafe_response
+    try:
+        workspace = workspace_for(workdir)
+        r = subprocess.run(
+            command,
+            shell=True,
+            cwd=workspace.root,
+            capture_output=True,
+            text=True,
+            errors="backslashreplace",
+            timeout=120,
+        )
+        return _format_bash_result(r.returncode, r.stdout, r.stderr)
+    except subprocess.TimeoutExpired:
+        return "Error: Timeout (120s)"
+
+
+bash_tool = {
+    "name": "bash",
+    "description": (
+        "Run a shell command when built-in tools are insufficient. "
+        "Do not use this for normal code navigation when list_files, grep, read_file, "
+        "read_many_files, git_show, or git_diff can answer the question."
+    ),
+    "execution": {
+        "side_effects": "process",
+        "concurrency": "serial",
+        "timeout_seconds": 130,
+    },
+    "input_schema": {
+        "type": "object",
+        "properties": {
+            "command": {"type": "string"},
+            "approved": {
+                "type": "boolean",
+                "description": "Set true only after this command is approved by runtime approval.",
+            },
+        },
+        "required": ["command"],
+    },
+}

tools/diff_utils.py

@@ -0,0 +1,139 @@
+"""Helpers for rendering git diffs after workspace writes."""
+
+import subprocess
+from pathlib import Path
+
+from . import read_file
+
+MAX_DIFF_CHARS = 12_000
+
+
+def _workspace(workdir: Path | str | None = None):
+    return read_file.workspace_for(workdir)
+
+
+def _relative_paths(paths: list[str] | None, workdir: Path | str | None = None) -> list[str]:
+    if not paths:
+        return []
+    workspace = _workspace(workdir)
+    return [str(workspace.safe_path(path).relative_to(workspace.root)) for path in paths]
+
+
+def git_diff_stat(paths: list[str] | None = None, workdir: Path | str | None = None) -> str:
+    """Return git diff stat for optional workspace-relative paths."""
+    return _run_git_diff(["--stat"], paths, max_chars=4_000, workdir=workdir)
+
+
+def git_diff_preview(
+    paths: list[str] | None = None,
+    max_chars: int = MAX_DIFF_CHARS,
+    workdir: Path | str | None = None,
+) -> str:
+    """Return a capped git diff for optional workspace-relative paths."""
+    return _run_git_diff([], paths, max_chars=max_chars, workdir=workdir)
+
+
+def format_diff_result(
+    action: str,
+    paths: list[str] | None = None,
+    workdir: Path | str | None = None,
+) -> str:
+    """Format a write-tool result with diff stat and capped diff preview."""
+    stat = git_diff_stat(paths, workdir=workdir)
+    diff = git_diff_preview(paths, workdir=workdir)
+    if not diff and paths:
+        stat = stat or _untracked_files_stat(paths, workdir=workdir)
+        diff = _untracked_files_diff(paths, workdir=workdir)
+    parts = [action]
+    if stat:
+        parts.append(f"diff_stat:\n{stat}")
+    if diff:
+        parts.append(f"diff:\n{diff}")
+    if len(parts) == 1:
+        parts.append("diff: No diff.")
+    return "\n\n".join(parts)
+
+
+def _run_git_diff(
+    args: list[str],
+    paths: list[str] | None,
+    max_chars: int,
+    workdir: Path | str | None = None,
+) -> str:
+    workspace = _workspace(workdir)
+    command = ["git", "diff", *args, "--", *_relative_paths(paths, workdir)]
+    result = subprocess.run(
+        command,
+        cwd=workspace.root,
+        capture_output=True,
+        text=True,
+        errors="backslashreplace",
+        timeout=30,
+    )
+    output = (result.stdout + result.stderr).strip()
+    if result.returncode != 0:
+        return f"Error: {output or f'git diff exited with {result.returncode}'}"
+    if len(output) > max_chars:
+        return output[:max_chars] + f"\n... diff truncated to {max_chars} chars"
+    return output
+
+
+def _untracked_files_diff(paths: list[str], workdir: Path | str | None = None) -> str:
+    workspace = _workspace(workdir)
+    sections = []
+    for path in paths:
+        file_path = workspace.safe_path(path)
+        if not file_path.exists() or _is_tracked(path, workdir=workdir):
+            continue
+        try:
+            text = file_path.read_text()
+        except UnicodeDecodeError:
+            text = "<binary or non-utf8 file>"
+        relative_path = file_path.relative_to(workspace.root)
+        lines = text.splitlines()
+        sections.append(
+            "\n".join(
+                [
+                    f"diff --git a/{relative_path} b/{relative_path}",
+                    "new file mode 100644",
+                    "--- /dev/null",
+                    f"+++ b/{relative_path}",
+                    f"@@ -0,0 +1,{len(lines)} @@",
+                    *[f"+{line}" for line in lines],
+                ]
+            )
+        )
+    output = "\n".join(sections)
+    if len(output) > MAX_DIFF_CHARS:
+        return output[:MAX_DIFF_CHARS] + f"\n... diff truncated to {MAX_DIFF_CHARS} chars"
+    return output
+
+
+def _untracked_files_stat(paths: list[str], workdir: Path | str | None = None) -> str:
+    workspace = _workspace(workdir)
+    stats = []
+    for path in paths:
+        file_path = workspace.safe_path(path)
+        if not file_path.exists() or _is_tracked(path, workdir=workdir):
+            continue
+        try:
+            line_count = len(file_path.read_text().splitlines())
+        except UnicodeDecodeError:
+            line_count = 0
+        relative_path = file_path.relative_to(workspace.root)
+        stats.append(f" {relative_path} | {line_count} +")
+    return "\n".join(stats)
+
+
+def _is_tracked(path: str, workdir: Path | str | None = None) -> bool:
+    workspace = _workspace(workdir)
+    relative_path = str(workspace.safe_path(path).relative_to(workspace.root))
+    result = subprocess.run(
+        ["git", "ls-files", "--error-unmatch", "--", relative_path],
+        cwd=workspace.root,
+        capture_output=True,
+        text=True,
+        errors="backslashreplace",
+        timeout=30,
+    )
+    return result.returncode == 0

tools/edit_file.py

@@ -0,0 +1,40 @@
+"""Edit file tool."""
+
+from pathlib import Path
+
+
+def edit_file(
+    path: str,
+    old_text: str,
+    new_text: str,
+    workdir: Path | str | None = None,
+) -> str:
+    """Replace exact text in file."""
+    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."
+    )
+
+
+edit_file_tool = {
+    "name": "edit_file",
+    "description": (
+        "Fallback exact-text replacement for exceptional cases. Prefer apply_patch "
+        "for normal code edits so changes are reviewable as a diff."
+    ),
+    "execution": {
+        "side_effects": "workspace_write",
+        "concurrency": "serial",
+        "timeout_seconds": 60,
+    },
+    "input_schema": {
+        "type": "object",
+        "properties": {
+            "path": {"type": "string"},
+            "old_text": {"type": "string"},
+            "new_text": {"type": "string"},
+        },
+        "required": ["path", "old_text", "new_text"],
+    },
+}

tools/git_diff.py

@@ -0,0 +1,72 @@
+"""Git diff inspection tool."""
+
+import subprocess
+from pathlib import Path
+
+from .read_file import workspace_for
+
+MAX_OUTPUT_CHARS = 50_000
+
+
+def _relative_path(path: str, workdir: Path | str | None = None) -> str:
+    workspace = workspace_for(workdir)
+    return str(workspace.safe_path(path).relative_to(workspace.root))
+
+
+def git_diff(
+    paths: list[str] | None = None,
+    staged: bool = False,
+    workdir: Path | str | None = None,
+) -> str:
+    """Return git diff for workspace-relative paths."""
+    try:
+        workspace = workspace_for(workdir)
+        command = ["git", "diff"]
+        if staged:
+            command.append("--cached")
+        command.append("--")
+        if paths:
+            command.extend(_relative_path(path, workdir) for path in paths)
+
+        result = subprocess.run(
+            command,
+            cwd=workspace.root,
+            capture_output=True,
+            text=True,
+            errors="backslashreplace",
+            timeout=30,
+        )
+        output = (result.stdout + result.stderr).strip()
+        if result.returncode != 0:
+            return f"Error: {output or f'git diff exited with {result.returncode}'}"
+        return output[:MAX_OUTPUT_CHARS] if output else "No diff."
+    except subprocess.TimeoutExpired:
+        return "Error: Timeout (30s)"
+    except Exception as exc:
+        return f"Error: {exc}"
+
+
+git_diff_tool = {
+    "name": "git_diff",
+    "description": "Show the current git diff, optionally scoped to workspace-relative paths.",
+    "execution": {
+        "side_effects": "read_only",
+        "concurrency": "safe",
+        "timeout_seconds": 30,
+    },
+    "input_schema": {
+        "type": "object",
+        "properties": {
+            "paths": {
+                "type": "array",
+                "items": {"type": "string"},
+                "description": "Optional workspace-relative paths to diff.",
+            },
+            "staged": {
+                "type": "boolean",
+                "description": "When true, show staged diff with git diff --cached.",
+            },
+        },
+        "required": [],
+    },
+}

tools/git_show.py

@@ -0,0 +1,65 @@
+"""Git show inspection tool."""
+
+import subprocess
+from pathlib import Path
+
+from . import read_file
+
+MAX_OUTPUT_CHARS = 50_000
+
+
+def _relative_path(path: str, workdir: Path | str | None = None) -> str:
+    workspace = read_file.workspace_for(workdir)
+    return str(workspace.safe_path(path).relative_to(workspace.root))
+
+
+def git_show(ref: str = "HEAD", path: str = "", workdir: Path | str | None = None) -> str:
+    """Show a git object or a file at a git ref."""
+    try:
+        workspace = read_file.workspace_for(workdir)
+        command = ["git", "show", "--no-ext-diff", "--color=never"]
+        if path:
+            command.append(f"{ref}:{_relative_path(path, workdir)}")
+        else:
+            command.append(ref)
+        result = subprocess.run(
+            command,
+            cwd=workspace.root,
+            capture_output=True,
+            text=True,
+            errors="backslashreplace",
+            timeout=30,
+        )
+        output = (result.stdout + result.stderr).strip()
+        if result.returncode != 0:
+            return f"Error: {output or f'git show exited with {result.returncode}'}"
+        return output[:MAX_OUTPUT_CHARS] if output else "(no output)"
+    except subprocess.TimeoutExpired:
+        return "Error: Timeout (30s)"
+    except Exception as exc:
+        return f"Error: {exc}"
+
+
+git_show_tool = {
+    "name": "git_show",
+    "description": "Show git commit content or a workspace file at a specific ref.",
+    "execution": {
+        "side_effects": "read_only",
+        "concurrency": "safe",
+        "timeout_seconds": 30,
+    },
+    "input_schema": {
+        "type": "object",
+        "properties": {
+            "ref": {
+                "type": "string",
+                "description": "Git ref, commit, tag, or range. Defaults to HEAD.",
+            },
+            "path": {
+                "type": "string",
+                "description": "Optional workspace-relative path to show at the ref.",
+            },
+        },
+        "required": [],
+    },
+}