chatmcp-cli 0.1.0__py3-none-any.whl

aider/coders/udiff_simple.py

@@ -0,0 +1,14 @@
+from .udiff_coder import UnifiedDiffCoder
+from .udiff_simple_prompts import UnifiedDiffSimplePrompts
+
+
+class UnifiedDiffSimpleCoder(UnifiedDiffCoder):
+    """
+    A coder that uses unified diff format for code modifications.
+    This variant uses a simpler prompt that doesn't mention specific
+    diff rules like using `@@ ... @@` lines or avoiding line numbers.
+    """
+
+    edit_format = "udiff-simple"
+
+    gpt_prompts = UnifiedDiffSimplePrompts()

aider/coders/udiff_simple_prompts.py

@@ -0,0 +1,25 @@
+from .udiff_prompts import UnifiedDiffPrompts
+
+
+class UnifiedDiffSimplePrompts(UnifiedDiffPrompts):
+    """
+    Prompts for the UnifiedDiffSimpleCoder.
+    Inherits from UnifiedDiffPrompts and can override specific prompts
+    if a simpler wording is desired for this edit format.
+    """
+
+    example_messages = []
+
+    system_reminder = """# File editing rules:
+
+Return edits similar to unified diffs that `diff -U0` would produce.
+
+The user's patch tool needs CORRECT patches that apply cleanly against the current contents of the file!
+Think carefully and make sure you include and mark all lines that need to be removed or changed as `-` lines.
+Make sure you mark all new or modified lines with `+`.
+Don't leave out any lines or the diff patch won't apply correctly.
+
+To make a new file, show a diff from `--- /dev/null` to `+++ path/to/new/file.ext`.
+
+{final_reminders}
+"""  # noqa

aider/coders/wholefile_coder.py

@@ -0,0 +1,144 @@
+from pathlib import Path
+
+from aider import diffs
+
+from ..dump import dump  # noqa: F401
+from .base_coder import Coder
+from .wholefile_prompts import WholeFilePrompts
+
+
+class WholeFileCoder(Coder):
+    """A coder that operates on entire files for code modifications."""
+
+    edit_format = "whole"
+    gpt_prompts = WholeFilePrompts()
+
+    def render_incremental_response(self, final):
+        try:
+            return self.get_edits(mode="diff")
+        except ValueError:
+            return self.get_multi_response_content_in_progress()
+
+    def get_edits(self, mode="update"):
+        content = self.get_multi_response_content_in_progress()
+
+        chat_files = self.get_inchat_relative_files()
+
+        output = []
+        lines = content.splitlines(keepends=True)
+
+        edits = []
+
+        saw_fname = None
+        fname = None
+        fname_source = None
+        new_lines = []
+        for i, line in enumerate(lines):
+            if line.startswith(self.fence[0]) or line.startswith(self.fence[1]):
+                if fname is not None:
+                    # ending an existing block
+                    saw_fname = None
+
+                    full_path = self.abs_root_path(fname)
+
+                    if mode == "diff":
+                        output += self.do_live_diff(full_path, new_lines, True)
+                    else:
+                        edits.append((fname, fname_source, new_lines))
+
+                    fname = None
+                    fname_source = None
+                    new_lines = []
+                    continue
+
+                # fname==None ... starting a new block
+                if i > 0:
+                    fname_source = "block"
+                    fname = lines[i - 1].strip()
+                    fname = fname.strip("*")  # handle **filename.py**
+                    fname = fname.rstrip(":")
+                    fname = fname.strip("`")
+                    fname = fname.lstrip("#")
+                    fname = fname.strip()
+
+                    # Issue #1232
+                    if len(fname) > 250:
+                        fname = ""
+
+                    # Did gpt prepend a bogus dir? It especially likes to
+                    # include the path/to prefix from the one-shot example in
+                    # the prompt.
+                    if fname and fname not in chat_files and Path(fname).name in chat_files:
+                        fname = Path(fname).name
+                if not fname:  # blank line? or ``` was on first line i==0
+                    if saw_fname:
+                        fname = saw_fname
+                        fname_source = "saw"
+                    elif len(chat_files) == 1:
+                        fname = chat_files[0]
+                        fname_source = "chat"
+                    else:
+                        # TODO: sense which file it is by diff size
+                        raise ValueError(
+                            f"No filename provided before {self.fence[0]} in file listing"
+                        )
+
+            elif fname is not None:
+                new_lines.append(line)
+            else:
+                for word in line.strip().split():
+                    word = word.rstrip(".:,;!")
+                    for chat_file in chat_files:
+                        quoted_chat_file = f"`{chat_file}`"
+                        if word == quoted_chat_file:
+                            saw_fname = chat_file
+
+                output.append(line)
+
+        if mode == "diff":
+            if fname is not None:
+                # ending an existing block
+                full_path = (Path(self.root) / fname).absolute()
+                output += self.do_live_diff(full_path, new_lines, False)
+            return "\n".join(output)
+
+        if fname:
+            edits.append((fname, fname_source, new_lines))
+
+        seen = set()
+        refined_edits = []
+        # process from most reliable filename, to least reliable
+        for source in ("block", "saw", "chat"):
+            for fname, fname_source, new_lines in edits:
+                if fname_source != source:
+                    continue
+                # if a higher priority source already edited the file, skip
+                if fname in seen:
+                    continue
+
+                seen.add(fname)
+                refined_edits.append((fname, fname_source, new_lines))
+
+        return refined_edits
+
+    def apply_edits(self, edits):
+        for path, fname_source, new_lines in edits:
+            full_path = self.abs_root_path(path)
+            new_lines = "".join(new_lines)
+            self.io.write_text(full_path, new_lines)
+
+    def do_live_diff(self, full_path, new_lines, final):
+        if Path(full_path).exists():
+            orig_lines = self.io.read_text(full_path)
+            if orig_lines is not None:
+                orig_lines = orig_lines.splitlines(keepends=True)
+
+                show_diff = diffs.diff_partial_update(
+                    orig_lines,
+                    new_lines,
+                    final=final,
+                ).splitlines()
+                return show_diff
+
+        output = ["```"] + new_lines + ["```"]
+        return output

aider/coders/wholefile_func_coder.py

@@ -0,0 +1,134 @@
+from aider import diffs
+
+from ..dump import dump  # noqa: F401
+from .base_coder import Coder
+from .wholefile_func_prompts import WholeFileFunctionPrompts
+
+
+class WholeFileFunctionCoder(Coder):
+    functions = [
+        dict(
+            name="write_file",
+            description="create or update one or more files",
+            parameters=dict(
+                type="object",
+                required=["explanation", "files"],
+                properties=dict(
+                    explanation=dict(
+                        type="string",
+                        description=(
+                            "Step by step plan for the changes to be made to the code (future"
+                            " tense, markdown format)"
+                        ),
+                    ),
+                    files=dict(
+                        type="array",
+                        items=dict(
+                            type="object",
+                            required=["path", "content"],
+                            properties=dict(
+                                path=dict(
+                                    type="string",
+                                    description="Path of file to write",
+                                ),
+                                content=dict(
+                                    type="string",
+                                    description="Content to write to the file",
+                                ),
+                            ),
+                        ),
+                    ),
+                ),
+            ),
+        ),
+    ]
+
+    def __init__(self, *args, **kwargs):
+        raise RuntimeError("Deprecated, needs to be refactored to support get_edits/apply_edits")
+
+        self.gpt_prompts = WholeFileFunctionPrompts()
+        super().__init__(*args, **kwargs)
+
+    def add_assistant_reply_to_cur_messages(self, edited):
+        if edited:
+            self.cur_messages += [
+                dict(role="assistant", content=self.gpt_prompts.redacted_edit_message)
+            ]
+        else:
+            self.cur_messages += [dict(role="assistant", content=self.partial_response_content)]
+
+    def render_incremental_response(self, final=False):
+        if self.partial_response_content:
+            return self.partial_response_content
+
+        args = self.parse_partial_args()
+
+        if not args:
+            return
+
+        explanation = args.get("explanation")
+        files = args.get("files", [])
+
+        res = ""
+        if explanation:
+            res += f"{explanation}\n\n"
+
+        for i, file_upd in enumerate(files):
+            path = file_upd.get("path")
+            if not path:
+                continue
+            content = file_upd.get("content")
+            if not content:
+                continue
+
+            this_final = (i < len(files) - 1) or final
+            res += self.live_diffs(path, content, this_final)
+
+        return res
+
+    def live_diffs(self, fname, content, final):
+        lines = content.splitlines(keepends=True)
+
+        # ending an existing block
+        full_path = self.abs_root_path(fname)
+
+        content = self.io.read_text(full_path)
+        if content is None:
+            orig_lines = []
+        else:
+            orig_lines = content.splitlines()
+
+        show_diff = diffs.diff_partial_update(
+            orig_lines,
+            lines,
+            final,
+            fname=fname,
+        ).splitlines()
+
+        return "\n".join(show_diff)
+
+    def _update_files(self):
+        name = self.partial_response_function_call.get("name")
+        if name and name != "write_file":
+            raise ValueError(f'Unknown function_call name="{name}", use name="write_file"')
+
+        args = self.parse_partial_args()
+        if not args:
+            return
+
+        files = args.get("files", [])
+
+        edited = set()
+        for file_upd in files:
+            path = file_upd.get("path")
+            if not path:
+                raise ValueError(f"Missing path parameter: {file_upd}")
+
+            content = file_upd.get("content")
+            if not content:
+                raise ValueError(f"Missing content parameter: {file_upd}")
+
+            if self.allowed_to_edit(path, content):
+                edited.add(path)
+
+        return edited

aider/coders/wholefile_func_prompts.py

@@ -0,0 +1,27 @@
+# flake8: noqa: E501
+
+from .base_prompts import CoderPrompts
+
+
+class WholeFileFunctionPrompts(CoderPrompts):
+    main_system = """Act as an expert software developer.
+Take requests for changes to the supplied code.
+If the request is ambiguous, ask questions.
+
+Once you understand the request you MUST use the `write_file` function to edit the files to make the needed changes.
+"""
+
+    system_reminder = """
+ONLY return code using the `write_file` function.
+NEVER return code outside the `write_file` function.
+"""
+
+    files_content_prefix = "Here is the current content of the files:\n"
+    files_no_full_files = "I am not sharing any files yet."
+
+    redacted_edit_message = "No changes are needed."
+
+    # TODO: should this be present for using this with gpt-4?
+    repo_content_prefix = None
+
+    # TODO: fix the chat history, except we can't keep the whole file

aider/coders/wholefile_prompts.py

@@ -0,0 +1,67 @@
+# flake8: noqa: E501
+
+from .base_prompts import CoderPrompts
+
+
+class WholeFilePrompts(CoderPrompts):
+    main_system = """Act as an expert software developer.
+Take requests for changes to the supplied code.
+If the request is ambiguous, ask questions.
+
+Always reply to the user in {language}.
+
+{final_reminders}
+Once you understand the request you MUST:
+1. Determine if any code changes are needed.
+2. Explain any needed changes.
+3. If changes are needed, output a copy of each file that needs changes.
+"""
+
+    example_messages = [
+        dict(
+            role="user",
+            content="Change the greeting to be more casual",
+        ),
+        dict(
+            role="assistant",
+            content="""Ok, I will:
+
+1. Switch the greeting text from "Hello" to "Hey".
+
+show_greeting.py
+{fence[0]}
+import sys
+
+def greeting(name):
+    print(f"Hey {{name}}")
+
+if __name__ == '__main__':
+    greeting(sys.argv[1])
+{fence[1]}
+""",
+        ),
+    ]
+
+    system_reminder = """To suggest changes to a file you MUST return the entire content of the updated file.
+You MUST use this *file listing* format:
+
+path/to/filename.js
+{fence[0]}
+// entire file content ...
+// ... goes in between
+{fence[1]}
+
+Every *file listing* MUST use this format:
+- First line: the filename with any originally provided path; no extra markup, punctuation, comments, etc. **JUST** the filename with path.
+- Second line: opening {fence[0]}
+- ... entire content of the file ...
+- Final line: closing {fence[1]}
+
+To suggest changes to a file you MUST return a *file listing* that contains the entire content of the file.
+*NEVER* skip, omit or elide content from a *file listing* using "..." or by adding comments like "... rest of code..."!
+Create a new file you MUST return a *file listing* which includes an appropriate filename, including any appropriate path.
+
+{final_reminders}
+"""
+
+    redacted_edit_message = "No changes are needed."