mseep-patche 1.0.1__py3-none-any.whl

Patche/mcp/server.py

@@ -0,0 +1,101 @@
+from mcp.server import Server
+from mcp.server.stdio import stdio_server
+from mcp.types import Prompt, TextContent, Tool
+
+from Patche.app import logger
+from Patche.mcp.model import (
+    PatcheApply,
+    PatcheConfig,
+    PatcheList,
+    PatcheShow,
+    PatcheTools,
+)
+from Patche.mcp.prompts import prompts
+from Patche.mcp.tools import patche_apply, patche_config, patche_list, patche_show
+
+server = None
+
+
+async def serve(repository: str | None) -> None:
+
+    if repository is None:
+        logger.error("Repository is None")
+        return
+
+    server = Server(
+        "patche-mcp",
+        version="0.0.1",
+        instructions="An MCP Server to show, list, apply or reverse patch to a file",
+    )
+
+    @server.list_tools()
+    async def list_tools() -> list[Tool]:
+        return [
+            Tool(
+                name=PatcheTools.CONFIG,
+                description="Show the config of patche",
+                inputSchema=PatcheConfig.model_json_schema(),
+            ),
+            Tool(
+                name=PatcheTools.LIST,
+                description="List all the patches in the directory",
+                inputSchema=PatcheList.model_json_schema(),
+            ),
+            Tool(
+                name=PatcheTools.SHOW,
+                description="Show the patch",
+                inputSchema=PatcheShow.model_json_schema(),
+            ),
+            Tool(
+                name=PatcheTools.APPLY,
+                description="Apply the patch",
+                inputSchema=PatcheApply.model_json_schema(),
+            ),
+        ]
+
+    @server.call_tool()
+    async def call_tool(name: str, arguments: dict) -> list[TextContent]:
+        """
+        Call the tool with the given name and arguments.
+        """
+
+        logger.info(f"Received tool call: {name} with arguments: {arguments}")
+
+        match name:
+            case PatcheTools.CONFIG:
+                config = patche_config()
+                return [TextContent(type="text", text=f"Patche config: {config}")]
+            case PatcheTools.LIST:
+                patches = patche_list(arguments["patche_dir"])
+                return [TextContent(type="text", text=f"Patche list: {patches}")]
+            case PatcheTools.SHOW:
+                patch = patche_show(arguments["patch_path"])
+                return [TextContent(type="text", text=f"Patche show: {patch}")]
+            case PatcheTools.APPLY:
+                result = patche_apply(
+                    arguments["patch_path"],
+                    arguments["target_dir"],
+                    arguments.get("reverse", False),
+                )
+                return [TextContent(type="text", text=f"Patche apply: {result}")]
+            case _:
+                raise NotImplementedError(f"Tool {name} is not implemented")
+
+    @server.list_prompts()
+    async def list_prompts() -> list[str]:
+        """
+        List all the prompts.
+        """
+        return prompts
+
+    @server.call_prompt()
+    async def call_prompt(name: str, arguments: dict) -> list[TextContent]:
+        """
+        Call the prompt with the given name and arguments.
+        """
+        logger.info(f"Received prompt call: {name} with arguments: {arguments}")
+        raise NotImplementedError(f"Prompt {name} is not implemented")
+
+    options = server.create_initialization_options()
+    async with stdio_server() as (read_stream, write_stream):
+        await server.run(read_stream, write_stream, options, raise_exceptions=True)

Patche/mcp/tools.py

@@ -0,0 +1,160 @@
+import os
+
+from Patche.app import logger
+from Patche.config import settings
+from Patche.mcp.model import PatcheApply, PatcheConfig, PatcheList, PatcheShow
+from Patche.model import File
+from Patche.utils.parse import parse_patch
+from Patche.utils.resolve import apply_change
+
+
+def patche_config() -> str:
+    """
+    Show the config of patche
+    """
+    return settings.model_dump_json()
+
+
+def patche_list(patche_dir: str) -> str:
+    """
+    List all the patches in the directory
+    """
+    pass
+
+    patches: list[str] = []
+
+    for file in os.listdir(patche_dir):
+        if file.endswith(".patch"):
+            patches.append(file)
+
+    return "\n".join(patches)
+
+
+def patche_show(patch_path: str) -> str:
+    """
+    Show the patch
+    """
+
+    if not os.path.exists(patch_path):
+        err = f"Warning: {patch_path} not found!"
+        logger.error(err)
+        return err
+
+    content = ""
+    with open(patch_path, mode="r", encoding="utf-8") as (f):
+        content = f.read()
+
+    patch = parse_patch(content)
+
+    result = []
+    result.append(f"Patch: {patch_path}")
+    result.append(f"Sha: {patch.sha}")
+    result.append(f"Author: {patch.author}")
+    result.append(f"Date: {patch.date}")
+    result.append(f"Subject: {patch.subject}")
+
+    for diff in patch.diff:
+        result.append(f"Diff: {diff.header.old_path} -> {diff.header.new_path}")
+
+    return "\n".join(result)
+
+
+def patche_apply(patch_path: str, target_dir: str, reverse: bool = False) -> str:
+    """
+    Apply the patch
+    """
+
+    # Change dir to target_dir
+    os.chdir(target_dir)
+    logger.info(f"Changing directory to {target_dir}")
+    logger.info(f"Applying patch: {patch_path}")
+
+    # Maybe we can just catch typer.Exit() and return the error message?
+    if not os.path.exists(patch_path):
+        logger.error(f"Warning: {patch_path} not found!")
+        return f"Error: patch {patch_path} not found!"
+
+    if reverse:
+        logger.info("Reversing patch...")
+
+    has_failed = False
+
+    with open(patch_path, mode="r", encoding="utf-8") as (f):
+        diffes = parse_patch(f.read()).diff
+
+        for diff in diffes:
+
+            old_filename = diff.header.old_path
+            new_filename = diff.header.new_path
+            if reverse:
+                old_filename, new_filename = new_filename, old_filename
+
+            logger.debug(f"old_filename: {old_filename} new_filename: {new_filename}")
+
+            if old_filename == "/dev/null":
+                # 根据 diffes 创建新文件
+                try:
+                    assert len(diff.hunks) == 1
+
+                    new_line_list = []
+                    for line in diff.changes:
+
+                        assert line.old is None
+                        new_line_list.append(line)
+
+                    with open(new_filename, mode="w+", encoding="utf-8") as f:
+                        for line in new_line_list:
+                            f.write(line.content + "\n")
+
+                except AssertionError:
+                    err = "Failed to create new file: invalid diff!"
+                    logger.error(err)
+                    return err
+
+            elif new_filename == "/dev/null":
+                # 移除 old_filename
+                if os.path.exists(old_filename):
+                    os.remove(old_filename)
+                else:
+                    err = f"{old_filename} not found!"
+                    logger.error(err)
+                    return err
+
+            else:
+                if os.path.exists(old_filename):
+
+                    logger.info(f"Applying patch to {old_filename}...")
+
+                    new_line_list = File(file_path=old_filename).line_list
+                    apply_result = apply_change(
+                        diff.hunks,
+                        new_line_list,
+                        reverse=reverse,
+                        fuzz=3,  # Should be a config option?
+                    )
+                    new_line_list = apply_result.new_line_list
+
+                    # 检查失败数
+                    for failed_hunk in apply_result.failed_hunk_list:
+                        has_failed = True
+                        logger.error(f"Failed hunk: {failed_hunk.index}")
+                else:
+                    err = f"{old_filename} not found!"
+                    logger.error(err)
+                    return err
+
+                # 写入文件
+                if not has_failed:
+                    with open(new_filename, mode="w+", encoding="utf-8") as f:
+                        for line in new_line_list:
+                            if line.status:
+                                f.write(line.content + "\n")
+
+    if has_failed:
+        err = "Error: Failed to apply patch! Please check the log for details."
+        logger.error(err)
+        return err
+    else:
+        info = "Patch applied successfully!"
+        logger.info(info)
+        return info

Patche/model.py

@@ -0,0 +1,75 @@
+from enum import Enum
+from typing import Optional
+
+from pydantic import BaseModel
+from whatthepatch_pydantic.model import Change
+from whatthepatch_pydantic.model import Diff as WTPDiff
+from whatthepatch_pydantic.model import Header
+
+
+class Line(BaseModel):
+    index: int
+    content: str
+    changed: bool = False  # 标识在一轮 apply 中是否进行了修改
+    status: bool = True  # 标识在一轮 apply 中是否被删除
+    flag: bool = False  # 标识是否是在初次标记中修改了的行
+
+    hunk: Optional[int] = None  # 如果 changed 为 True，则记录其所在的 hunk
+
+    def __str__(self) -> str:
+        return self.content
+
+
+class File(object):
+    def __init__(self, file_path: str) -> None:
+        self.line_list: list[Line] = []
+
+        with open(file_path, mode="r", encoding="utf-8") as f:
+            for i, line in enumerate(f):
+                self.line_list.append(Line(index=i, content=line.rstrip("\n")))
+
+    def __str__(self) -> str:
+        return "".join([str(line) for line in self.line_list])
+
+
+class Hunk(BaseModel):
+    index: int
+    context: list[Change]
+    middle: list[Change]
+    post: list[Change]
+
+    all_: list[Change]
+
+
+class Diff(WTPDiff):
+    hunks: list[Hunk]
+
+
+class Patch(BaseModel):
+    sha: str | None
+    author: str | None
+    date: str | None
+    subject: str | None
+    message: str | None
+    diff: list[Diff] | list[WTPDiff] = []  # 临时的兼容方案
+
+
+class ApplyResult(BaseModel):
+    new_line_list: list[Line] = []
+    conflict_hunk_num_list: list[int] = []
+    failed_hunk_list: list[Hunk] = []
+
+
+class CommandType(Enum):
+    APPLY = "apply"
+    AUTO = "auto"
+    GET = "get"
+    HELP = "help"
+    SHOW = "show"
+    TRACE = "trace"
+    UNKNOWN = "unknown"
+
+
+class CommandResult(BaseModel):
+    type: CommandType
+    content: dict | list | str | None = None

Patche/utils/common.py

@@ -0,0 +1,73 @@
+import subprocess
+from typing import Any
+
+from Patche.app import logger
+from Patche.model import CommandResult, CommandType
+
+
+def clean_repo():
+    output = subprocess.run(["git", "clean", "-df"], capture_output=True).stdout.decode(
+        "utf-8"
+    )
+    logger.debug(output)
+
+    output = subprocess.run(
+        ["git", "reset", "--hard"], capture_output=True
+    ).stdout.decode("utf-8")
+    logger.debug(output)
+
+
+def process_title(filename: str):
+    """
+    Process the file name to make it suitable for path
+    """
+    return "".join([letter for letter in filename if letter.isalnum()])
+
+
+def find_list_positions(main_list: list[str], sublist: list[str]) -> list[int]:
+    sublist_length = len(sublist)
+    positions = []
+
+    for i in range(len(main_list) - sublist_length + 1):
+        if main_list[i : i + sublist_length] == sublist:
+            positions.append(i)
+
+    return positions
+
+
+def isnamedtupleinstance(x):
+    _type = type(x)
+    bases = _type.__bases__
+    if len(bases) != 1 or bases[0] != tuple:
+        return False
+    fields = getattr(_type, "_fields", None)
+    if not isinstance(fields, tuple):
+        return False
+    return all(type(i) == str for i in fields)
+
+
+def unpack(obj):
+    if isinstance(obj, dict):
+        return {key: unpack(value) for key, value in obj.items()}
+    elif isinstance(obj, list):
+        return [unpack(value) for value in obj]
+    elif isnamedtupleinstance(obj):
+        return {key: unpack(value) for key, value in obj._asdict().items()}
+    elif isinstance(obj, tuple):
+        return tuple(unpack(value) for value in obj)
+    else:
+        return obj
+
+
+def post_executed(executed_command_result: CommandResult | Any, **kwargs) -> None:
+    """Executed command result callback function"""
+    if type(executed_command_result) != CommandResult:
+        return
+
+    logger.debug(f"Executed {executed_command_result.type}")
+
+    match executed_command_result.type:
+        case CommandType.AUTO:
+            clean_repo()
+        case _:
+            pass

Patche/utils/header.py

@@ -0,0 +1,34 @@
+import re
+from typing import Iterator, Optional
+
+from Patche.model import Header
+
+HEADER_OLD = re.compile(r"^--- ([^\t\n]+)(?:\t([^\n]*)|)$")
+HEADER_NEW = re.compile(r"^\+\+\+ ([^\t\n]+)(?:\t([^\n]*)|)$")
+HUNK_START = re.compile(r"^@@ -(\d+)(?:,(\d+))? \+(\d+)(?:,(\d+))? @@")
+CHANGE_LINE = re.compile(r"^([- +\\])(.*)$")
+GIT_HEADER = re.compile(r"^diff --git a/(.*) b/(.*)$")
+
+
+def parse_header(lines: Iterator[str]) -> Optional[Header]:
+    """解析 diff 头部信息"""
+
+    old_line = next(lines, "")
+    new_line = next(lines, "")
+
+    if GIT_HEADER.match(old_line):
+        old_line = next(lines, "")
+        new_line = next(lines, "")
+
+    old_match = HEADER_OLD.match(old_line)
+    new_match = HEADER_NEW.match(new_line)
+
+    if old_match and new_match:
+        return Header(
+            index_path=None,
+            old_path=old_match.group(1),
+            old_version=old_match.group(2) if old_match.group(2) else None,
+            new_path=new_match.group(1),
+            new_version=new_match.group(2) if new_match.group(2) else None,
+        )
+    return None