uni-diff-patch 0.0.1__py3-none-any.whl

uni_diff_patch/__init__.py

@@ -0,0 +1,46 @@
+"""uni-diff-patch: MCP server and CLI for generating valid unified diff patches."""
+
+from uni_diff_patch.core.diff_engine import (
+    DiffGenerationError,
+    GenerateResult,
+    generate_patch,
+)
+from uni_diff_patch.core.search_replace import (
+    AmbiguousMatchError,
+    NoMatchError,
+    Replacement,
+    SearchReplaceError,
+)
+from uni_diff_patch.core.validator import ValidationResult, validate_patch
+from uni_diff_patch.models import (
+    ChmodChange,
+    CreateFileChange,
+    DeleteFileChange,
+    FileChange,
+    FileContentChange,
+    RenameFileChange,
+    ReplacementModel,
+    SearchReplaceChange,
+    TextPairChange,
+)
+
+__all__ = [
+    "ChmodChange",
+    "CreateFileChange",
+    "DeleteFileChange",
+    "DiffGenerationError",
+    "FileChange",
+    "FileContentChange",
+    "GenerateResult",
+    "RenameFileChange",
+    "ReplacementModel",
+    "SearchReplaceChange",
+    "TextPairChange",
+    "generate_patch",
+    "validate_patch",
+    "ValidationResult",
+    "Replacement",
+    "SearchReplaceError",
+    "NoMatchError",
+    "AmbiguousMatchError",
+]

uni_diff_patch/cli.py

@@ -0,0 +1,178 @@
+"""CLI entry point for uni-diff-patch."""
+
+from __future__ import annotations
+
+import json
+import sys
+
+import click
+
+from uni_diff_patch.core.diff_engine import (
+    DiffGenerationError,
+    generate_patch,
+)
+from uni_diff_patch.core.search_replace import SearchReplaceError
+from uni_diff_patch.core.validator import validate_patch
+from uni_diff_patch.server import _parse_changes
+
+
+@click.group()
+@click.version_option(package_name="uni-diff-patch")
+def main() -> None:
+    """uni-diff-patch: Generate valid unified diff patches deterministically."""
+
+
+@main.command()
+@click.option(
+    "--spec",
+    "spec_source",
+    required=True,
+    help="JSON spec file path, or '-' for stdin.",
+)
+@click.option(
+    "-o",
+    "--output",
+    "output_override",
+    default=None,
+    help="Override output file path (takes precedence over spec's output_path).",
+)
+@click.option(
+    "--work-dir",
+    default=None,
+    help="Base directory for relativizing absolute paths in diff headers.",
+)
+@click.option(
+    "--overwrite",
+    is_flag=True,
+    help="Overwrite existing output file.",
+)
+def generate(
+    spec_source: str,
+    output_override: str | None,
+    work_dir: str | None,
+    overwrite: bool,
+) -> None:
+    """Generate a unified diff patch from a JSON spec.
+
+    The spec JSON must contain a "changes" array. Each change has:
+    file_path, mode, and mode-specific fields.
+
+    Modes: file_content, search_replace, create_file, delete_file,
+    text_pair, rename_file, chmod.
+    """
+    # 读取 spec
+    try:
+        if spec_source == "-":
+            spec_data = json.load(sys.stdin)
+        else:
+            with open(spec_source, encoding="utf-8") as f:
+                spec_data = json.load(f)
+    except (json.JSONDecodeError, FileNotFoundError, OSError) as e:
+        raise click.ClickException(f"Failed to read spec: {e}")
+
+    if not isinstance(spec_data, dict):
+        raise click.ClickException("Spec must be a JSON object")
+
+    raw_changes = spec_data.get("changes")
+    if not isinstance(raw_changes, list) or not raw_changes:
+        raise click.ClickException("Spec must contain a non-empty 'changes' array")
+
+    try:
+        file_changes = _parse_changes(raw_changes)
+    except ValueError as e:
+        raise click.ClickException(str(e))
+
+    # output 优先级：CLI flag > spec 中的 output_path
+    final_output = output_override or spec_data.get("output_path")
+
+    try:
+        result = generate_patch(
+            file_changes,
+            output_path=final_output,
+            work_dir=work_dir,
+            overwrite=overwrite,
+        )
+    except (DiffGenerationError, SearchReplaceError) as e:
+        raise click.ClickException(str(e))
+
+    if not result.patch:
+        click.echo("No changes detected.", err=True)
+        sys.exit(0)
+
+    if result.skipped_files:
+        click.echo(
+            f"Skipped (no changes): {', '.join(result.skipped_files)}",
+            err=True,
+        )
+
+    if not result.self_valid:
+        click.echo("WARNING: generated patch failed self-validation", err=True)
+
+    if final_output:
+        click.echo(
+            f"Patch written to {final_output} "
+            f"({result.files_changed} file(s) changed)",
+            err=True,
+        )
+    else:
+        click.echo(result.patch, nl=False)
+
+
+@main.command()
+@click.argument("patch_source", default="-")
+@click.option(
+    "--git-check", is_flag=True, help="Also run git apply --check."
+)
+@click.option(
+    "--work-dir",
+    default=None,
+    help="Working directory for git apply --check.",
+)
+def validate(patch_source: str, git_check: bool, work_dir: str | None) -> None:
+    """Validate a unified diff patch file.
+
+    Pass a file path or '-' (default) to read from stdin.
+    """
+    patch_content: str | None = None
+    patch_path: str | None = None
+
+    if patch_source == "-":
+        raw = sys.stdin.read()
+        if not raw.strip():
+            raise click.ClickException("No patch content provided on stdin")
+        patch_content = raw
+    else:
+        patch_path = patch_source
+
+    result = validate_patch(
+        patch_content=patch_content,
+        patch_path=patch_path,
+        git_check=git_check,
+        work_dir=work_dir,
+    )
+
+    if result.valid:
+        click.echo(f"VALID — {len(result.files)} file(s), {result.total_hunks} hunk(s)")
+        for f in result.files:
+            status = " [new]" if f.is_creation else ""
+            click.echo(f"  {f.file_path}: {f.hunk_count} hunk(s){status}")
+    else:
+        click.echo("INVALID", err=True)
+        if result.parse_error:
+            click.echo(f"  Parse error: {result.parse_error}", err=True)
+        if result.git_apply_error:
+            click.echo(f"  git apply: {result.git_apply_error}", err=True)
+        sys.exit(1)
+
+    if result.git_apply_ok is True:
+        click.echo("git apply --check: OK")
+    elif result.git_apply_ok is False:
+        click.echo(f"git apply --check: FAILED — {result.git_apply_error}", err=True)
+
+
+@main.command()
+def serve() -> None:
+    """Start the MCP server (stdio transport)."""
+    from uni_diff_patch.server import run_server
+
+    run_server()

uni_diff_patch/core/diff_engine.py

@@ -0,0 +1,402 @@
+"""Core diff generation engine backed by mpatch.
+
+Uses mpatch (Rust) for normal diffs and falls back to difflib (stdlib)
+when files lack trailing newlines, since difflib correctly preserves
+line endings and allows proper '\\No newline at end of file' markers.
+"""
+
+from __future__ import annotations
+
+import difflib
+from collections.abc import Sequence
+from dataclasses import dataclass, field
+from pathlib import Path
+
+import mpatch
+
+from uni_diff_patch.core.search_replace import Replacement, apply_replacements
+from uni_diff_patch.core.validator import validate_patch
+from uni_diff_patch.models import (
+    ChmodChange,
+    CreateFileChange,
+    DeleteFileChange,
+    FileChange,
+    FileContentChange,
+    RenameFileChange,
+    SearchReplaceChange,
+    TextPairChange,
+)
+
+_NO_NEWLINE_MARKER = "\"
+
+
+class DiffGenerationError(Exception):
+    """Raised when diff generation fails."""
+
+
+@dataclass
+class GenerateResult:
+    """Result of a diff generation operation.
+
+    Args:
+        patch: The generated unified diff string.
+        files_changed: Number of files with actual changes.
+        self_valid: Whether the generated patch passed self-validation.
+        skipped_files: Files skipped because old == new (no changes).
+    """
+
+    patch: str
+    files_changed: int = 0
+    self_valid: bool = True
+    skipped_files: list[str] = field(default_factory=list)
+
+
+# 二进制探测只读前 8KB，全文件读取有大小限制
+_BINARY_PROBE_SIZE = 8192
+_MAX_FILE_SIZE = 50 * 1024 * 1024  # 50MB
+
+
+def _read_file(file_path: str, encoding: str = "utf-8") -> str:
+    """Read a file from disk with binary detection.
+
+    Args:
+        file_path: Path to the file.
+        encoding: Text encoding.
+
+    Returns:
+        File content as string.
+
+    Raises:
+        DiffGenerationError: If the file is binary, not found, or unreadable.
+    """
+    path = Path(file_path)
+    if not path.is_file():
+        raise DiffGenerationError(f"File not found: {file_path}")
+    if path.is_symlink():
+        raise DiffGenerationError(f"Symlinks not supported: {file_path}")
+
+    size = path.stat().st_size
+    if size > _MAX_FILE_SIZE:
+        raise DiffGenerationError(
+            f"File too large ({size} bytes, max {_MAX_FILE_SIZE}): {file_path}"
+        )
+
+    with open(path, "rb") as f:
+        probe = f.read(_BINARY_PROBE_SIZE)
+    if b"\x00" in probe:
+        raise DiffGenerationError(f"Binary file detected: {file_path}")
+
+    try:
+        return path.read_text(encoding=encoding)
+    except (UnicodeDecodeError, LookupError) as e:
+        raise DiffGenerationError(
+            f"Cannot decode {file_path} with encoding {encoding}: {e}"
+        ) from e
+
+
+def _make_patch_path(file_path: str, work_dir: str | None) -> str:
+    """Normalize a file path for diff headers, ensuring git apply compatibility.
+
+    Relative paths are preserved as-is. Absolute paths are relativized
+    against work_dir to avoid the 'a//abs/path' double-slash issue.
+    """
+    path = Path(file_path)
+    if not path.is_absolute():
+        return file_path
+
+    resolved = path.resolve()
+    if work_dir:
+        base = Path(work_dir).resolve()
+        try:
+            return str(resolved.relative_to(base))
+        except ValueError:
+            raise DiffGenerationError(
+                f"Absolute path {file_path} is outside work_dir {work_dir}. "
+                f"Use a path within work_dir or switch to text_pair mode."
+            )
+
+    return str(resolved).lstrip("/")
+
+
+def _create_unified_diff(
+    patch_path: str, old: str, new: str, context_lines: int
+) -> str:
+    """Generate a unified diff, choosing the best engine.
+
+    Uses mpatch (Rust, fast) for normal files. Falls back to difflib
+    when either side lacks a trailing newline (correct marker handling).
+    """
+    old_has_newline = (not old) or old.endswith("\n")
+    new_has_newline = (not new) or new.endswith("\n")
+
+    if old_has_newline and new_has_newline:
+        return mpatch.create_unified_diff(
+            patch_path, old, new, context_len=context_lines
+        )
+
+    # difflib 降级：正确处理 "" 标记
+    old_lines = old.splitlines(keepends=True)
+    new_lines = new.splitlines(keepends=True)
+
+    raw = difflib.unified_diff(
+        old_lines, new_lines,
+        fromfile=f"a/{patch_path}", tofile=f"b/{patch_path}",
+        n=context_lines,
+    )
+
+    result: list[str] = []
+    for line in raw:
+        result.append(line)
+        if line and not line.endswith("\n") and line[0] in (" ", "-", "+"):
+            result.append(f"\n{_NO_NEWLINE_MARKER}\n")
+
+    return "".join(result)
+
+
+# --- git 扩展 diff header 构建 ---
+
+
+def _build_rename_diff(
+    old_path: str, new_path: str, old: str, new: str, context_lines: int
+) -> str:
+    """Build a git-compatible rename diff with extended headers.
+
+    Format:
+        diff --git a/old b/new
+        rename from old
+        rename to new
+        --- a/old
+        +++ b/new
+        @@ ... @@
+        ...
+    """
+    header = (
+        f"diff --git a/{old_path} b/{new_path}\n"
+        f"rename from {old_path}\n"
+        f"rename to {new_path}\n"
+    )
+
+    if old == new:
+        # 纯重命名，无内容变更
+        return header
+
+    # 有内容变更，生成 body
+    body = _create_unified_diff(old_path, old, new, context_lines)
+    # 替换 body 中的路径：--- a/old_path 保持, +++ b/new_path
+    body = body.replace(f"+++ b/{old_path}", f"+++ b/{new_path}", 1)
+    return header + body
+
+
+def _build_chmod_diff(
+    patch_path: str, old_mode: str, new_mode: str,
+    old: str | None, new: str | None, context_lines: int
+) -> str:
+    """Build a git-compatible mode change diff with extended headers.
+
+    Format:
+        diff --git a/path b/path
+        old mode <old>
+        new mode <new>
+        --- a/path       (only if content changed)
+        +++ b/path
+        @@ ... @@
+        ...
+    """
+    header = (
+        f"diff --git a/{patch_path} b/{patch_path}\n"
+        f"old mode {old_mode}\n"
+        f"new mode {new_mode}\n"
+    )
+
+    if old is None or new is None or old == new:
+        # 纯权限变更
+        return header
+
+    # 有内容变更
+    body = _create_unified_diff(patch_path, old, new, context_lines)
+    return header + body
+
+
+# --- 主入口 ---
+
+
+def _to_replacements(change: SearchReplaceChange) -> list[Replacement]:
+    """Convert Pydantic ReplacementModel list to internal Replacement list."""
+    return [
+        Replacement(search=r.search, replace=r.replace, line_hint=r.line_hint)
+        for r in change.replacements
+    ]
+
+
+def _generate_single_diff(
+    change: FileChange, work_dir: str | None
+) -> str | None:
+    """Generate a unified diff for a single file change.
+
+    Returns:
+        The diff string, or None if there are no changes.
+
+    Raises:
+        DiffGenerationError: On invalid input or file access errors.
+    """
+    match change:
+        case FileContentChange():
+            old = _read_file(change.file_path, change.encoding)
+            new = change.new_content
+            if old == new:
+                return None
+            patch_path = _make_patch_path(change.file_path, work_dir)
+            return _create_unified_diff(patch_path, old, new, change.context_lines)
+
+        case SearchReplaceChange():
+            old = _read_file(change.file_path, change.encoding)
+            new = apply_replacements(old, _to_replacements(change), change.file_path)
+            if old == new:
+                return None
+            patch_path = _make_patch_path(change.file_path, work_dir)
+            return _create_unified_diff(patch_path, old, new, change.context_lines)
+
+        case CreateFileChange():
+            if Path(change.file_path).exists():
+                raise DiffGenerationError(
+                    f"File already exists (use file_content mode to modify): "
+                    f"{change.file_path}"
+                )
+            patch_path = _make_patch_path(change.file_path, work_dir)
+            return _create_unified_diff(patch_path, "", change.new_content, 3)
+
+        case DeleteFileChange():
+            old = _read_file(change.file_path, change.encoding)
+            patch_path = _make_patch_path(change.file_path, work_dir)
+            return _create_unified_diff(patch_path, old, "", 3)
+
+        case TextPairChange():
+            if change.old_text == change.new_text:
+                return None
+            patch_path = _make_patch_path(change.file_path, work_dir)
+            return _create_unified_diff(
+                patch_path, change.old_text, change.new_text, change.context_lines
+            )
+
+        case RenameFileChange():
+            old = _read_file(change.file_path, change.encoding)
+            # 检查目标文件是否已存在
+            if Path(change.new_path).exists():
+                raise DiffGenerationError(
+                    f"Rename target already exists: {change.new_path}"
+                )
+            new = change.new_content if change.new_content is not None else old
+            old_patch = _make_patch_path(change.file_path, work_dir)
+            new_patch = _make_patch_path(change.new_path, work_dir)
+            return _build_rename_diff(old_patch, new_patch, old, new, change.context_lines)
+
+        case ChmodChange():
+            # 始终验证文件存在（即使纯 chmod 不读内容）
+            if not Path(change.file_path).is_file():
+                raise DiffGenerationError(f"File not found: {change.file_path}")
+            old_patch = _make_patch_path(change.file_path, work_dir)
+            old_content: str | None = None
+            new_content: str | None = None
+            if change.new_content is not None:
+                old_content = _read_file(change.file_path, change.encoding)
+                new_content = change.new_content
+            return _build_chmod_diff(
+                old_patch, change.old_mode, change.new_mode,
+                old_content, new_content, change.context_lines,
+            )
+
+        case _:
+            raise DiffGenerationError(f"Unknown change type: {type(change)}")
+
+
+def generate_patch(
+    changes: Sequence[FileChange],
+    output_path: str | None = None,
+    work_dir: str | None = None,
+    self_validate: bool = True,
+    overwrite: bool = False,
+) -> GenerateResult:
+    """Generate a unified diff patch from one or more file changes.
+
+    Args:
+        changes: List of file changes (Pydantic models) to include in the patch.
+        output_path: If provided, write the patch to this file path.
+        work_dir: Base directory for relativizing absolute paths in diff headers.
+            Defaults to current working directory.
+        self_validate: If True, validate the generated patch with mpatch.parse_auto.
+        overwrite: If True, overwrite existing output files. Default False.
+
+    Returns:
+        GenerateResult with the patch string and metadata.
+
+    Raises:
+        DiffGenerationError: On input errors or generation failures.
+    """
+    if not changes:
+        raise DiffGenerationError("No changes provided")
+
+    # 检查重复文件目标（含 rename 的 new_path）
+    seen_paths: set[str] = set()
+    for change in changes:
+        normalized = str(Path(change.file_path).resolve())
+        if normalized in seen_paths:
+            raise DiffGenerationError(
+                f"Duplicate file target: {change.file_path}. "
+                f"Combine changes into a single FileChange per file."
+            )
+        seen_paths.add(normalized)
+        # rename 的目标路径也需要检查冲突
+        if isinstance(change, RenameFileChange):
+            new_normalized = str(Path(change.new_path).resolve())
+            if new_normalized in seen_paths:
+                raise DiffGenerationError(
+                    f"Duplicate file target: {change.new_path} (rename destination). "
+                )
+            seen_paths.add(new_normalized)
+
+    effective_work_dir = work_dir or str(Path.cwd())
+
+    diffs: list[str] = []
+    skipped: list[str] = []
+
+    for change in changes:
+        diff = _generate_single_diff(change, effective_work_dir)
+        if diff is None:
+            skipped.append(change.file_path)
+        else:
+            diffs.append(diff)
+
+    if not diffs:
+        return GenerateResult(
+            patch="", files_changed=0, self_valid=True, skipped_files=skipped,
+        )
+
+    combined = "\n".join(diffs)
+    if not combined.endswith("\n"):
+        combined += "\n"
+
+    is_valid = True
+    if self_validate:
+        # 检查是否所有 diff 都是 header-only（纯 rename/chmod 无 hunk body）
+        # mpatch.parse_auto 无法解析这类 diff，跳过验证
+        has_hunk_body = any("@@" in d for d in diffs)
+        if has_hunk_body:
+            validation = validate_patch(patch_content=combined)
+            is_valid = validation.valid
+
+    result = GenerateResult(
+        patch=combined, files_changed=len(diffs),
+        self_valid=is_valid, skipped_files=skipped,
+    )
+
+    if output_path is not None:
+        out = Path(output_path)
+        if out.exists() and not overwrite:
+            raise DiffGenerationError(
+                f"Output file already exists: {output_path}. "
+                f"Use overwrite=True to replace."
+            )
+        out.parent.mkdir(parents=True, exist_ok=True)
+        out.write_text(combined, encoding="utf-8")
+
+    return result