mseep-patche 1.0.1__py3-none-any.whl

Patche/__init__.py

@@ -0,0 +1 @@
+from .app import __version__, app

Patche/__main__.py

@@ -0,0 +1,3 @@
+from .app import app
+
+app()

Patche/__version__.py

@@ -0,0 +1,9 @@
+import sys
+
+if sys.version_info >= (3, 10):
+    import importlib.metadata as importlib_metadata
+else:
+    import importlib_metadata
+
+
+__version__ = importlib_metadata.version("Patche")

Patche/app.py

@@ -0,0 +1,32 @@
+import logging
+
+import typer
+from rich.console import Console
+from rich.logging import RichHandler
+
+logging.basicConfig(level=logging.INFO, handlers=[RichHandler()], format="%(message)s")
+logger = logging.getLogger()
+
+from Patche.__version__ import __version__
+from Patche.utils.common import post_executed
+
+app = typer.Typer(result_callback=post_executed, no_args_is_help=True)
+
+
+@app.callback(invoke_without_command=True)
+def callback(verbose: bool = False, version: bool = False):
+    """
+    Entry for public options
+    """
+    if verbose:
+        logger.setLevel(logging.DEBUG)
+
+    if version:
+        console = Console()
+        console.print(f"patche version {__version__}")
+        raise typer.Exit()
+
+
+from Patche.commands.apply import apply
+from Patche.commands.help import show_settings
+from Patche.commands.show import show

Patche/commands/apply.py

@@ -0,0 +1,107 @@
+import os
+from typing import Annotated
+
+import typer
+
+from Patche.app import app, logger
+from Patche.model import File
+from Patche.utils.parse import parse_patch
+from Patche.utils.resolve import apply_change
+
+
+@app.command()
+def apply(
+    patch_path: Annotated[str, typer.Argument(help="Path to the patch file")],
+    reverse: Annotated[
+        bool,
+        typer.Option(
+            "-R",
+            "--reverse",
+            help="Assume patches were created with old and new files swapped.",
+        ),
+    ] = False,
+    fuzz: Annotated[
+        int,
+        typer.Option(
+            "-F", "--fuzz", help="Set the fuzz factor to LINES for inexact matching."
+        ),
+    ] = 0,
+):
+    """
+    Apply a patch to a file.
+    """
+
+    if not os.path.exists(patch_path):
+        logger.error(f"Warning: {patch_path} not found!")
+        raise typer.Exit(code=1)
+
+    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:
+                    logger.error("Failed to create new file: invalid diff!")
+                    raise typer.Exit(code=1)
+
+            elif new_filename == "/dev/null":
+                # 移除 old_filename
+                if os.path.exists(old_filename):
+                    os.remove(old_filename)
+                else:
+                    logger.error(f"{old_filename} not found!")
+                    raise typer.Exit(code=1)
+            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=fuzz
+                    )
+                    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:
+                    logger.error(f"{old_filename} not found!")
+                    raise typer.Exit(code=1)
+
+                # 写入文件
+                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")
+
+    raise typer.Exit(code=1 if has_failed else 0)

Patche/commands/help.py

@@ -0,0 +1,12 @@
+from rich import print
+
+from Patche.app import app
+from Patche.config import settings
+
+
+@app.command("settings")
+def show_settings():
+    """
+    Show current settings
+    """
+    print(settings.model_dump_json())

Patche/commands/show.py

@@ -0,0 +1,41 @@
+import os
+from typing import Annotated
+
+import typer
+from rich.console import Console
+from rich.table import Table
+
+from Patche.app import app, logger
+from Patche.utils.parse import parse_patch
+
+
+@app.command()
+def show(filename: Annotated[str, typer.Argument(help="Path to the patch file")]):
+    """
+    Show details of a patch file.
+    """
+    if not os.path.exists(filename):
+        logger.error(f"Warning: {filename} not found!")
+        return
+
+    content = ""
+    with open(filename, mode="r", encoding="utf-8") as (f):
+        content = f.read()
+
+    patch = parse_patch(content)
+
+    table = Table(box=None)
+    table.add_column("Field", justify="left", style="cyan")
+    table.add_column("Value", justify="left", style="magenta")
+
+    table.add_row("Patch", filename)
+    table.add_row("Sha", patch.sha)
+    table.add_row("Author", patch.author)
+    table.add_row("Date", (patch.date))
+    table.add_row("Subject", patch.subject)
+
+    for diff in patch.diff:
+        table.add_row("Diff", f"{diff.header.old_path} -> {diff.header.new_path}")
+
+    console = Console()
+    console.print(table)

Patche/config.py

@@ -0,0 +1,24 @@
+import importlib.resources as pkg_resources
+import os
+from functools import lru_cache
+
+from pydantic_settings import BaseSettings
+
+
+@lru_cache()
+def get_settings():
+    _settings = Settings()
+    if not os.path.exists(_settings.Config.env_file):
+        open(_settings.Config.env_file, "w").close()
+
+    return _settings
+
+
+class Settings(BaseSettings):
+    max_diff_lines: int = 3
+
+    class Config:
+        env_file = os.path.join(os.environ.get("HOME"), ".Patche.env")
+
+
+settings = get_settings()

Patche/mcp/__init__.py

@@ -0,0 +1,42 @@
+import asyncio
+import logging
+
+import typer
+from typer import Typer
+
+from Patche.app import logger
+from Patche.mcp.server import serve
+
+app = Typer()
+
+
+@app.command()
+# @app.option(
+#     "--repository",
+#     help="Repository to apply the patch",
+#     default=None,
+# )
+# @app.option(
+#     "--debug",
+#     help="Enable debug mode",
+#     default=False,
+# )
+def main(
+    repository: str = typer.Option(
+        None, "--repository", "-r", help="Repository to apply the patch"
+    ),
+    debug: bool = typer.Option(False, "--debug", "-d", help="Enable debug mode"),
+):
+    """
+    Main entry point for the Patche MCP server.
+    """
+
+    logger.info("Starting Patche MCP server...")
+    if debug:
+        logger.setLevel(logging.DEBUG)
+
+    asyncio.run(serve(repository))
+
+
+if __name__ == "__main__":
+    main()

Patche/mcp/__main__.py

@@ -0,0 +1,3 @@
+from Patche.mcp import main
+
+main()

Patche/mcp/model.py

@@ -0,0 +1,29 @@
+from enum import Enum
+
+from pydantic import BaseModel
+
+
+# 定义 Patche 相关的数据模型
+class PatcheConfig(BaseModel):
+    pass
+
+
+class PatcheList(BaseModel):
+    patche_dir: str
+
+
+class PatcheShow(BaseModel):
+    patch_path: str
+
+
+class PatcheApply(BaseModel):
+    patch_path: str
+    target_dir: str
+    reverse: bool = False
+
+
+class PatcheTools(str, Enum):
+    CONFIG = "patche_config"
+    LIST = "patche_list"
+    SHOW = "patche_show"
+    APPLY = "patche_apply"

Patche/mcp/prompts.py

@@ -0,0 +1,313 @@
+from mcp.types import Prompt
+
+from Patche.mcp.model import (
+    PatcheApply,
+    PatcheConfig,
+    PatcheList,
+    PatcheShow,
+    PatcheTools,
+)
+
+base_info_prompt = """
+<system>
+
+You are a tool that helps the user to manage patches in a directory.
+
+There are several tools available to you, you can use them to perform different actions.
+
+When using a tool, you should call it with given arguments, and do not add any other information.
+
+</system>
+"""
+
+show_config_prompt = f"""
+<user>
+
+Please show the configuration of the tool.
+
+Parameters:
+- config_path: string, path to the configuration file (optional)
+- patche_dir: string, directory containing patches (required)
+
+</user>
+
+Please use the following format to show the configuration:
+
+<input>
+{PatcheConfig.model_json_schema()}
+</input>
+"""
+
+list_prompt = f"""
+<user>
+
+Please list all the patches in the directory.
+
+Parameters:
+- patche_dir: string, directory path containing patches (required)
+
+</user>
+
+Please use the following format to show the patches:
+
+<input>
+{PatcheList.model_json_schema()}
+</input>
+"""
+
+show_prompt = f"""
+<user>
+
+Please show infomation of the patch.
+
+Parameters:
+- patch_path: string, path to the patch file to display (required)
+
+</user>
+
+Please use the following format to show the patch:
+
+<input>
+{PatcheShow.model_json_schema()}
+</input>
+"""
+
+apply_prompt = f"""
+<user>
+
+Please apply a patch to a target directory.
+
+Parameters:
+- patch_path: string, path to the patch file (required)
+- target_dir: string, directory to apply the patch to (required)
+- reverse: boolean, whether to reverse apply the patch (optional)
+
+</user>
+
+Please use the following format to apply the patch:
+
+<input>
+{PatcheApply.model_json_schema()}
+</input>
+
+The patch will be applied to the target directory. You can also set `reverse` to `true` to reverse the patch application.
+"""
+
+reverse_apply_prompt = f"""
+<user>
+
+Please reverse apply a patch to a target directory.
+
+Parameters:
+- patch_path: string, path to the patch file (required)
+- target_dir: string, directory to reverse apply the patch to (required)
+- reverse: boolean, default true for reverse application
+
+</user>
+
+Please use the following format to reverse apply the patch:
+
+<input>
+{{
+  "patch_path": "Path to the patch file",
+  "target_dir": "Path to the target directory",
+  "reverse": true
+}}
+</input>
+
+This will undo the changes made by the patch.
+"""
+
+help_prompt = """
+<user>
+
+Please show me how to use patche and what commands are available.
+
+</user>
+
+I can help you manage patches with Patche. Here are the available commands:
+
+1. **Show Configuration**: View the current Patche configuration
+   - Use `patche_config` tool
+
+2. **List Patches**: See all available patches in a directory
+   - Use `patche_list` tool with the directory path
+
+3. **Show Patch Details**: View metadata and content of a specific patch
+   - Use `patche_show` tool with the patch file path
+
+4. **Apply Patch**: Apply a patch to a target directory
+   - Use `patche_apply` tool with patch path and target directory
+   - Add `"reverse": true` to undo a patch
+
+Would you like me to help you with any of these operations?
+"""
+
+patch_creation_guidance_prompt = """
+<user>
+
+How can I create a new patch?
+
+</user>
+
+To create a new patch with Patche, you need to:
+
+1. Make changes to your files that you want to include in the patch
+2. Create a backup of the original files (e.g., by copying them with a `.orig` extension)
+3. Use a command like `diff -u original_file modified_file > my_patch.patch` to generate the patch
+
+If you're using the Patche CLI directly, you can use:
+```
+patche create --name "my-patch-name" --description "What this patch does" --files file1.py file2.py
+```
+
+The patch will be saved in your configured patches directory and can then be applied to other projects.
+
+Would you like me to help you apply an existing patch instead?
+"""
+
+patche_workflow_prompt = """
+<user>
+
+Please explain the typical workflow for using Patche.
+
+</user>
+
+# Typical Patche Workflow
+
+The standard workflow for using Patche involves:
+
+1. **Create or obtain patches**
+   - Create patches from modified files
+   - Download or receive patches from others
+
+2. **Manage your patch collection**
+   - List available patches with `patche_list`
+   - Examine patch details with `patche_show`
+
+3. **Apply patches to projects**
+   - Apply a patch with `patche_apply`
+   - Specify target directory and patch path
+
+4. **Revert changes if needed**
+   - Use `patche_apply` with `reverse: true` to undo a patch
+
+This workflow allows you to maintain a collection of modifications that can be applied to multiple projects or versions of code.
+
+Would you like specific help with any of these steps?
+"""
+
+patche_examples_prompt = """
+<user>
+
+Can you show me some examples of using Patche commands?
+
+</user>
+
+# Patche Command Examples
+
+Here are some practical examples of using Patche commands:
+
+**Listing patches in a directory:**
+```json
+{
+  "patche_dir": "/path/to/patches"
+}
+```
+
+**Viewing a specific patch's details:**
+```json
+{
+  "patch_path": "/path/to/patches/feature-fix.patch"
+}
+```
+
+**Applying a patch:**
+```json
+{
+  "patch_path": "/path/to/patches/feature-fix.patch",
+  "target_dir": "/path/to/project"
+}
+```
+
+**Reversing a previously applied patch:**
+```json
+{
+  "patch_path": "/path/to/patches/feature-fix.patch",
+  "target_dir": "/path/to/project",
+  "reverse": true
+}
+```
+
+Would you like me to help you execute any of these commands?
+"""
+
+# List of all prompts
+prompts: list[Prompt] = [
+    Prompt(
+        name="base_info",
+        description="Basic information about the Patche tool",
+        description_zh="Basic info of the Patche toolchain",
+        content=base_info_prompt,
+    ),
+    Prompt(
+        name="show_config",
+        description="Show the configuration of Patche",
+        content=show_config_prompt,
+        arguments=[
+            {"name": "config_path", "type": "string", "required": False},
+            {"name": "patche_dir", "type": "string", "required": True},
+        ],
+    ),
+    Prompt(
+        name="list_patches",
+        description="List all patches in a directory",
+        content=list_prompt,
+        arguments=[{"name": "patche_dir", "type": "string", "required": True}],
+    ),
+    Prompt(
+        name="show_patch",
+        description="Show detailed information about a patch",
+        content=show_prompt,
+        arguments=[{"name": "patch_path", "type": "string", "required": True}],
+    ),
+    Prompt(
+        name="apply_patch",
+        description="Apply a patch to a target directory",
+        content=apply_prompt,
+        arguments=[
+            {"name": "patch_path", "type": "string", "required": True},
+            {"name": "target_dir", "type": "string", "required": True},
+            {"name": "reverse", "type": "boolean", "required": False},
+        ],
+    ),
+    Prompt(
+        name="reverse_apply",
+        description="Reverse apply a patch to a target directory",
+        content=reverse_apply_prompt,
+        arguments=[
+            {"name": "patch_path", "type": "string", "required": True},
+            {"name": "target_dir", "type": "string", "required": True},
+        ],
+    ),
+    Prompt(
+        name="help",
+        description="Show help information about Patche commands",
+        content=help_prompt,
+    ),
+    Prompt(
+        name="patch_creation",
+        description="Guide for creating new patches",
+        content=patch_creation_guidance_prompt,
+    ),
+    Prompt(
+        name="workflow",
+        description="Explain the typical Patche workflow",
+        content=patche_workflow_prompt,
+    ),
+    Prompt(
+        name="examples",
+        description="Show examples of using Patche commands",
+        content=patche_examples_prompt,
+    ),
+]