tass 0.1.1__tar.gz → 0.1.3__tar.gz

{tass-0.1.1 → tass-0.1.3}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: tass
-Version: 0.1.1
+Version: 0.1.3
 Summary: A terminal assistant that allows you to ask an LLM to run commands.
 Project-URL: Homepage, https://github.com/cetincan0/tass
 Author: Can Cetin

{tass-0.1.1 → tass-0.1.3}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "tass"
-version = "0.1.1"
+version = "0.1.3"
 description = "A terminal assistant that allows you to ask an LLM to run commands."
 readme = "README.md"
 requires-python = ">=3.10"

tass-0.1.3/src/app.py

@@ -0,0 +1,269 @@
+import json
+import os
+import subprocess
+
+import requests
+from rich.console import Console
+from rich.markdown import Markdown
+
+from src.constants import (
+    SYSTEM_PROMPT,
+    TOOLS,
+)
+from src.utils import (
+    is_read_only_command,
+)
+
+console = Console()
+
+
+class TassApp:
+
+    def __init__(self):
+        self.messages: list[dict] = [{"role": "system", "content": SYSTEM_PROMPT}]
+        self.host = os.environ.get("TASS_HOST", "http://localhost:8080")
+        self.TOOLS_MAP = {
+            "execute": self.execute,
+            "read_file": self.read_file,
+            "edit_file": self.edit_file,
+        }
+
+    def _check_llm_host(self):
+        test_url = f"{self.host}/v1/models"
+        try:
+            response = requests.get(test_url, timeout=2)
+            console.print("Terminal Assistant [green](LLM connection ✓)[/green]")
+            if response.status_code == 200:
+                return
+        except Exception:
+            console.print("Terminal Assistant [red](LLM connection ✗)[/red]")
+
+        console.print("\n[red]Could not connect to LLM[/red]")
+        console.print(f"If your LLM isn't running on {self.host}, you can set the [bold]TASS_HOST[/] environment variable to a different URL.")
+        new_host = console.input(
+            "Enter a different URL for this session (or press Enter to keep current): "
+        ).strip()
+
+        if new_host:
+            self.host = new_host
+
+        try:
+            response = requests.get(f"{self.host}/v1/models", timeout=2)
+            if response.status_code == 200:
+                console.print(f"[green]Connection established to {self.host}[/green]")
+                return
+        except Exception:
+            console.print(f"[red]Unable to verify new host {self.host}. Continuing with it anyway.[/red]")
+
+    def summarize(self):
+        max_messages = 10
+        if len(self.messages) <= max_messages:
+            return
+
+        prompt = (
+            "The conversation is becoming long and might soon go beyond the "
+            "context limit. Please provide a concise summary of the conversation, "
+            "preserving all important details. Keep the summary short enough "
+            "to fit within a few paragraphs at the most."
+        )
+
+        response = requests.post(
+            f"{self.host}/v1/chat/completions",
+            json={
+                "messages": self.messages + [{"role": "user", "content": prompt}],
+                "chat_template_kwargs": {"reasoning_effort": "medium"},
+            },
+        )
+        data = response.json()
+        summary = data["choices"][0]["message"]["content"]
+        self.messages = [self.messages[0], {"role": "assistant", "content": f"Summary of the conversation so far:\n{summary}"}]
+
+    def call_llm(self) -> str | None:
+        response = requests.post(
+            f"{self.host}/v1/chat/completions",
+            json={
+                "messages": self.messages,
+                "tools": TOOLS,
+                "chat_template_kwargs": {
+                    "reasoning_effort": "medium",
+                }
+            },
+        )
+
+        data = response.json()
+        message = data["choices"][0]["message"]
+        if not message.get("tool_calls"):
+            return message["content"]
+
+        tool_name = message["tool_calls"][0]["function"]["name"]
+        tool_args_str = message["tool_calls"][0]["function"]["arguments"]
+        self.messages.append(
+            {
+                "role": "assistant",
+                "tool_calls": [
+                    {
+                        "index": 0,
+                        "id": "id1",
+                        "type": "function",
+                        "function": {
+                            "name": tool_name,
+                            "arguments": tool_args_str
+                        }
+                    }
+                ]
+            }
+        )
+        try:
+            tool = self.TOOLS_MAP[tool_name]
+            tool_args = json.loads(tool_args_str)
+            result = tool(**tool_args)
+            self.messages.append({"role": "tool", "content": result})
+            return None
+        except Exception as e:
+            self.messages.append({"role": "user", "content": str(e)})
+            return self.call_llm()
+
+    def read_file(self, path: str, start: int = 1) -> str:
+        console.print(f" └ Reading file [bold]{path}[/]...")
+
+        try:
+            with open(path) as f:
+                out = f.read()
+        except Exception as e:
+            console.print("   [red]read_file failed[/red]")
+            console.print(f"   [red]{str(e)}[/red]")
+            return f"read_file failed: {str(e)}"
+
+        lines = []
+        line_num = 1
+        for line in out.split("\n"):
+            if line_num < start:
+                line_num += 1
+                continue
+
+            lines.append(line)
+            line_num += 1
+
+            if len(lines) >= 1000:
+                lines.append("... (truncated)")
+                break
+
+        console.print("   [green]Command succeeded[/green]")
+        return "".join(lines)
+
+    def edit_file(self, path: str, find: str, replace: str) -> str:
+        find_with_minuses = "\n".join([f"-{line}" for line in find.split("\n")])
+        replace_with_pluses = "\n".join([f"+{line}" for line in replace.split("\n")])
+        console.print()
+        console.print(Markdown(f"```diff\nEditing {path}\n{find_with_minuses}\n{replace_with_pluses}\n```"))
+        answer = console.input("\n[bold]Run?[/] ([bold]Y[/]/n): ").strip().lower()
+        if answer not in ("yes", "y", ""):
+            reason = console.input("Why not? (optional, press Enter to skip): ").strip()
+            return f"User declined: {reason or 'no reason'}"
+
+        console.print(" └ Running...")
+        try:
+            with open(path, "r") as f:
+                original_content = f.read()
+
+            if find not in original_content:
+                console.print("   [red]edit_file failed[/red]")
+                console.print(f"   [red]edit_file failed:\n'{find}'\nnot found in file[/red]")
+                return f"edit_file failed: '{find}' not found in file"
+
+            new_content = original_content.replace(find, replace)
+
+            with open(path, "w") as f:
+                f.write(new_content)
+        except Exception as e:
+            console.print("   [red]edit_file failed[/red]")
+            console.print(f"   [red]{str(e)}[/red]")
+            return f"edit_file failed: {str(e)}"
+
+        console.print("   [green]Command succeeded[/green]")
+        return f"Successfully edited {path}"
+
+    def execute(self, command: str, explanation: str) -> str:
+        command = command.strip()
+        requires_confirmation = not is_read_only_command(command)
+        if requires_confirmation:
+            console.print()
+            console.print(Markdown(f"```shell\n{command}\n```"))
+            if explanation:
+                console.print(f"Explanation: {explanation}")
+            answer = console.input("\n[bold]Run?[/] ([bold]Y[/]/n): ").strip().lower()
+            if answer not in ("yes", "y", ""):
+                reason = console.input("Why not? (optional, press Enter to skip): ").strip()
+                return f"User declined: {reason or 'no reason'}"
+
+        if requires_confirmation:
+            console.print(" └ Running...")
+        else:
+            console.print(f" └ Running [bold]{command}[/] (Explanation: {explanation})...")
+
+        try:
+            result = subprocess.run(
+                command,
+                shell=True,
+                capture_output=True,
+                text=True,
+            )
+        except Exception as e:
+            console.print("   [red]subprocess.run failed[/red]")
+            console.print(f"   [red]{str(e)}[/red]")
+            return f"subprocess.run failed: {str(e)}"
+
+        out = result.stdout
+        err = result.stderr
+        if result.returncode == 0:
+            console.print("   [green]Command succeeded[/green]")
+        else:
+            console.print(f"   [red]Command failed[/red] (code {result.returncode})")
+            console.print(f"   [red]{err}[/red]")
+
+        if len(out.split("\n")) > 5000:
+            out_first_1000 = "\n".join(out.split("\n")[:1000])
+            out = f"{out_first_1000}... (Truncated)"
+
+        if len(err) > 5000:
+            err_first_1000 = "\n".join(err.split("\n")[:1000])
+            err = f"{err_first_1000}... (Truncated)"
+
+        return f"Command output (exit {result.returncode}):\n{out}\n{err}"
+
+    def run(self):
+        try:
+            self._check_llm_host()
+        except KeyboardInterrupt:
+            console.print("\nBye!")
+            return
+
+        while True:
+            try:
+                user_input = console.input("\n> ").strip()
+            except KeyboardInterrupt:
+                console.print("\nBye!")
+                break
+
+            if not user_input:
+                continue
+
+            if user_input.lower().strip() == "exit":
+                console.print("\nBye!")
+                break
+
+            self.messages.append({"role": "user", "content": user_input})
+
+            while True:
+                try:
+                    llm_resp = self.call_llm()
+                except Exception as e:
+                    console.print(f"Failed to call LLM: {str(e)}")
+                    break
+
+                if llm_resp is not None:
+                    console.print("")
+                    console.print(Markdown(llm_resp))
+                    self.messages.append({"role": "assistant", "content": llm_resp})
+                    self.summarize()
+                    break

{tass-0.1.1 → tass-0.1.3}/src/constants.py

@@ -1,7 +1,6 @@
 from pathlib import Path
 
-_apply_patch_path = Path(__file__).resolve().parent / "third_party" / "apply_patch.md"
-APPLY_PATCH_PROMPT = _apply_patch_path.read_text().strip()
+_cwd_path = Path.cwd().resolve()
 
 SYSTEM_PROMPT = f"""You are Terminal-Assistant, a helpful AI that executes shell commands based on natural-language requests.
 
@@ -9,7 +8,7 @@ If the user's request involves making changes to the filesystem such as creating
 
 If a user asks for an answer or explanation to something instead of requesting to run a command, answer briefly and concisely. Do not supply extra information, suggestions, tips, or anything of the sort.
 
-{APPLY_PATCH_PROMPT}"""
+Current working directory: {_cwd_path}"""
 
 TOOLS = [
     {
@@ -26,7 +25,7 @@ TOOLS = [
                     },
                     "explanation": {
                         "type": "string",
-                        "description": "A brief explanation of why you want to run this command.",
+                        "description": "A brief explanation of why you want to run this command. Keep it to a single sentence.",
                     },
                 },
                 "required": ["command", "explanation"],
@@ -37,18 +36,25 @@ TOOLS = [
     {
         "type": "function",
         "function": {
-            "name": "apply_patch",
-            "description": "Patch a file",
+            "name": "edit_file",
+            "description": "Edits a file. Replaces the instance of 'find' with 'replace'. 'find' and 'replace' are exact strings.The file must be read at least once before calling this tool.",
             "parameters": {
                 "type": "object",
                 "properties": {
-                    "patch": {
+                    "path": {
+                        "type": "string",
+                        "description": "Relative path of the file",
+                    },
+                    "find": {
                         "type": "string",
-                        "description": "Formatted patch code",
-                        "default": "*** Begin Patch\n*** End Patch\n",
+                        "description": "The string to find",
+                    },
+                    "replace": {
+                        "type": "string",
+                        "description": "The string to replace with",
                     },
                 },
-                "required": ["patch"],
+                "required": ["path", "find", "replace"],
                 "$schema": "http://json-schema.org/draft-07/schema#",
             },
         },
@@ -84,6 +90,7 @@ READ_ONLY_COMMANDS = [
     "less",
     "more",
     "echo",
+    "head",
     "tail",
     "wc",
     "grep",
@@ -91,4 +98,5 @@ READ_ONLY_COMMANDS = [
     "ack",
     "which",
     "sed",
+    "find",
 ]

{tass-0.1.1 → tass-0.1.3}/src/utils.py

@@ -10,6 +10,11 @@ def is_read_only_command(command: str) -> bool:
     if ">" in command:
         return False
 
+    # Replace everything that potentially runs another command with a pipe
+    command = command.replace("&&", "|")
+    command = command.replace("||", "|")
+    command = command.replace(";", "|")
+
     pipes = command.split("|")
     for pipe in pipes:
         if pipe.strip().split()[0] not in READ_ONLY_COMMANDS:

{tass-0.1.1 → tass-0.1.3}/uv.lock

@@ -261,7 +261,7 @@ wheels = [
 
 [[package]]
 name = "tass"
-version = "0.1.1"
+version = "0.1.3"
 source = { editable = "." }
 dependencies = [
     { name = "requests" },

tass-0.1.1/src/app.py

@@ -1,187 +0,0 @@
-import json
-import os
-import subprocess
-
-import requests
-from rich.console import Console
-from rich.markdown import Markdown
-
-from src.constants import (
-    SYSTEM_PROMPT,
-    TOOLS,
-)
-from src.third_party.apply_patch import apply_patch
-from src.utils import (
-    is_read_only_command,
-)
-
-console = Console()
-
-
-class TassApp:
-
-    def __init__(self):
-        self.messages: list[dict] = [{"role": "system", "content": SYSTEM_PROMPT}]
-        self.host = os.environ.get("TASS_HOST", "http://localhost:8080")
-        self.TOOLS_MAP = {
-            "execute": self.execute,
-            "apply_patch": self.apply_patch_tass,
-            "read_file": self.read_file,
-        }
-
-    def call_llm(self) -> str | None:
-        response = requests.post(
-            f"{self.host}/v1/chat/completions",
-            json={
-                "messages": self.messages,
-                "tools": TOOLS,
-                "chat_template_kwargs": {
-                    "reasoning_effort": "medium",
-                }
-            },
-        )
-
-        data = response.json()
-        message = data["choices"][0]["message"]
-        if message.get("tool_calls"):
-            tool_name = message["tool_calls"][0]["function"]["name"]
-            tool_args_str = message["tool_calls"][0]["function"]["arguments"]
-            self.messages.append(
-                {
-                    "role": "assistant",
-                    "tool_calls": [
-                        {
-                            "index": 0,
-                            "id": "id1",
-                            "type": "function",
-                            "function": {
-                                "name": tool_name,
-                                "arguments": tool_args_str
-                            }
-                        }
-                    ]
-                }
-            )
-            try:
-                tool = self.TOOLS_MAP[tool_name]
-                tool_args = json.loads(tool_args_str)
-                result = tool(**tool_args)
-                self.messages.append({"role": "tool", "content": result})
-            except Exception as e:
-                self.messages.append({"role": "user", "content": str(e)})
-                return self.call_llm()
-
-        return data["choices"][0]["message"]["content"]
-
-    def read_file(self, path: str, start: int = 1) -> str:
-        console.print(f" └ Reading file [bold]{path}[/]...")
-
-        lines = []
-        with open(path) as f:
-            line_num = 1
-            for line in f:
-                if line_num < start:
-                    line_num += 1
-                    continue
-
-                lines.append(line)
-                line_num += 1
-
-                if len(lines) >= 1000:
-                    break
-
-        console.print("   [green]Command succeeded[/green]")
-        return "".join(lines)
-
-    def apply_patch_tass(self, patch: str) -> str:
-        console.print()
-        console.print(Markdown(f"```diff\n{patch}\n```"))
-        answer = console.input("\n[bold]Run?[/] ([bold]Y[/]/n): ").strip().lower()
-        if answer not in ("yes", "y", ""):
-            reason = console.input("Why not? (optional, press Enter to skip): ").strip()
-            return f"User declined: {reason or 'no reason'}"
-
-        console.print(" └ Running...")
-
-        try:
-            apply_patch(patch)
-        except Exception as e:
-            console.print("   [red]apply_patch failed[/red]")
-            console.print(f"   [red]{str(e)}[/red]")
-            return f"apply_patch failed: {str(e)}"
-
-        console.print("   [green]Command succeeded[/green]")
-
-        return "Command output (exit 0): apply_patch succeeded"
-
-    def execute(self, command: str, explanation: str) -> str:
-        command = command.strip()
-        requires_confirmation = not is_read_only_command(command)
-        if requires_confirmation:
-            console.print()
-            console.print(Markdown(f"```shell\n{command}\n```"))
-            if explanation:
-                console.print(f"Explanation: {explanation}")
-            answer = console.input("\n[bold]Run?[/] ([bold]Y[/]/n): ").strip().lower()
-            if answer not in ("yes", "y", ""):
-                reason = console.input("Why not? (optional, press Enter to skip): ").strip()
-                return f"User declined: {reason or 'no reason'}"
-
-        if requires_confirmation:
-            console.print(" └ Running...")
-        else:
-            console.print(f" └ Running [bold]{command}[/] (Explanation: {explanation})...")
-
-        try:
-            result = subprocess.run(
-                command,
-                shell=True,
-                capture_output=True,
-                text=True,
-            )
-        except Exception as e:
-            console.print("   [red]subprocess.run failed[/red]")
-            console.print(f"   [red]{str(e)}[/red]")
-            return f"subprocess.run failed: {str(e)}"
-
-        out = result.stdout.strip()
-        err = result.stderr.strip()
-        if result.returncode == 0:
-            console.print("   [green]Command succeeded[/green]")
-        else:
-            console.print(f"   [red]Command failed[/red] (code {result.returncode})")
-            console.print(f"   [red]{err}[/red]")
-
-        if len(out) > 5000:
-            out = f"{out[:5000]}... (Truncated)"
-
-        if len(err) > 5000:
-            err = f"{err[:5000]}... (Truncated)"
-
-        return f"Command output (exit {result.returncode}):\n{out}\n{err}"
-
-    def run(self):
-        console.print("Terminal Assistant")
-
-        while True:
-            try:
-                user_input = console.input("\n> ").strip()
-            except KeyboardInterrupt:
-                console.print("\nBye!")
-                break
-
-            if not user_input:
-                continue
-
-            if user_input.lower().strip() == "exit":
-                console.print("\nBye!")
-                break
-
-            self.messages.append({"role": "user", "content": user_input})
-
-            while True:
-                llm_resp = self.call_llm()
-                if llm_resp is not None:
-                    console.print("")
-                    console.print(Markdown(llm_resp))
-                    break

tass-0.1.1/src/third_party/README.md

@@ -1 +0,0 @@
-These files are taken directly from https://github.com/openai/gpt-oss to assist with gpt-oss-120b's code editing capabilities. No modifications have been made.

tass-0.1.1/src/third_party/apply_patch.md

@@ -1,64 +0,0 @@
-When requested to perform coding-related tasks, you MUST adhere to the following criteria when executing the task:
-
-- Use `apply_patch` to edit files.
-- If completing the user's task requires writing or modifying files:
-  - Your code and final answer should follow these _CODING GUIDELINES_:
-    - Avoid unneeded complexity in your solution. Minimize program size.
-    - Keep changes consistent with the style of the existing codebase. Changes should be minimal and focused on the task.
-    - NEVER add copyright or license headers unless specifically requested.
-- Never implement function stubs. Provide complete working implementations.
-
-§ `apply_patch` Specification
-
-Your patch language is a stripped‑down, file‑oriented diff format designed to be easy to parse and safe to apply. You can think of it as a high‑level envelope:
-
-*** Begin Patch
-[ one or more file sections ]
-*** End Patch
-
-Within that envelope, you get a sequence of file operations.
-You MUST include a header to specify the action you are taking.
-Each operation starts with one of three headers:
-
-*** Add File: <path> - create a new file. Every following line is a + line (the initial contents).
-*** Delete File: <path> - remove an existing file. Nothing follows.
-*** Update File: <path> - patch an existing file in place (optionally with a rename).
-
-May be immediately followed by *** Move to: <new path> if you want to rename the file.
-Then one or more “hunks”, each introduced by @@ (optionally followed by a hunk header).
-Within a hunk each line starts with:
-
-- for inserted text,
-
-* for removed text, or
-  space ( ) for context.
-  At the end of a truncated hunk you can emit *** End of File.
-
-Patch := Begin { FileOp } End
-Begin := "*** Begin Patch" NEWLINE
-End := "*** End Patch" NEWLINE
-FileOp := AddFile | DeleteFile | UpdateFile
-AddFile := "*** Add File: " path NEWLINE { "+" line NEWLINE }
-DeleteFile := "*** Delete File: " path NEWLINE
-UpdateFile := "*** Update File: " path NEWLINE [ MoveTo ] { Hunk }
-MoveTo := "*** Move to: " newPath NEWLINE
-Hunk := "@@" [ header ] NEWLINE { HunkLine } [ "*** End of File" NEWLINE ]
-HunkLine := (" " | "-" | "+") text NEWLINE
-
-A full patch can combine several operations:
-
-*** Begin Patch
-*** Add File: hello.txt
-+Hello world
-*** Update File: src/app.py
-*** Move to: src/main.py
-@@ def greet():
--print("Hi")
-+print("Hello, world!")
-*** Delete File: obsolete.txt
-*** End Patch
-
-It is important to remember:
-
-- You must include a header with your intended action (Add/Delete/Update)
-- You must prefix new lines with `+` even when creating a new file

tass-0.1.1/src/third_party/apply_patch.py

@@ -1,529 +0,0 @@
-#!/usr/bin/env python3
-
-"""
-A self-contained **pure-Python 3.9+** utility for applying human-readable
-“pseudo-diff” patch files to a collection of text files.
-
-Source: https://cookbook.openai.com/examples/gpt4-1_prompting_guide
-"""
-
-from __future__ import annotations
-
-import pathlib
-from dataclasses import dataclass, field
-from enum import Enum
-from typing import (
-    Callable,
-    Dict,
-    List,
-    Optional,
-    Tuple,
-    Union,
-)
-
-
-# --------------------------------------------------------------------------- #
-#  Domain objects
-# --------------------------------------------------------------------------- #
-class ActionType(str, Enum):
-    ADD = "add"
-    DELETE = "delete"
-    UPDATE = "update"
-
-
-@dataclass
-class FileChange:
-    type: ActionType
-    old_content: Optional[str] = None
-    new_content: Optional[str] = None
-    move_path: Optional[str] = None
-
-
-@dataclass
-class Commit:
-    changes: Dict[str, FileChange] = field(default_factory=dict)
-
-
-# --------------------------------------------------------------------------- #
-#  Exceptions
-# --------------------------------------------------------------------------- #
-class DiffError(ValueError):
-    """Any problem detected while parsing or applying a patch."""
-
-
-# --------------------------------------------------------------------------- #
-#  Helper dataclasses used while parsing patches
-# --------------------------------------------------------------------------- #
-@dataclass
-class Chunk:
-    orig_index: int = -1
-    del_lines: List[str] = field(default_factory=list)
-    ins_lines: List[str] = field(default_factory=list)
-
-
-@dataclass
-class PatchAction:
-    type: ActionType
-    new_file: Optional[str] = None
-    chunks: List[Chunk] = field(default_factory=list)
-    move_path: Optional[str] = None
-
-
-@dataclass
-class Patch:
-    actions: Dict[str, PatchAction] = field(default_factory=dict)
-
-
-# --------------------------------------------------------------------------- #
-#  Patch text parser
-# --------------------------------------------------------------------------- #
-@dataclass
-class Parser:
-    current_files: Dict[str, str]
-    lines: List[str]
-    index: int = 0
-    patch: Patch = field(default_factory=Patch)
-    fuzz: int = 0
-
-    # ------------- low-level helpers -------------------------------------- #
-    def _cur_line(self) -> str:
-        if self.index >= len(self.lines):
-            raise DiffError("Unexpected end of input while parsing patch")
-        return self.lines[self.index]
-
-    @staticmethod
-    def _norm(line: str) -> str:
-        """Strip CR so comparisons work for both LF and CRLF input."""
-        return line.rstrip("\r")
-
-    # ------------- scanning convenience ----------------------------------- #
-    def is_done(self, prefixes: Optional[Tuple[str, ...]] = None) -> bool:
-        if self.index >= len(self.lines):
-            return True
-        if (
-            prefixes
-            and len(prefixes) > 0
-            and self._norm(self._cur_line()).startswith(prefixes)
-        ):
-            return True
-        return False
-
-    def startswith(self, prefix: Union[str, Tuple[str, ...]]) -> bool:
-        return self._norm(self._cur_line()).startswith(prefix)
-
-    def read_str(self, prefix: str) -> str:
-        """
-        Consume the current line if it starts with *prefix* and return the text
-        **after** the prefix.  Raises if prefix is empty.
-        """
-        if prefix == "":
-            raise ValueError("read_str() requires a non-empty prefix")
-        if self._norm(self._cur_line()).startswith(prefix):
-            text = self._cur_line()[len(prefix) :]
-            self.index += 1
-            return text
-        return ""
-
-    def read_line(self) -> str:
-        """Return the current raw line and advance."""
-        line = self._cur_line()
-        self.index += 1
-        return line
-
-    # ------------- public entry point -------------------------------------- #
-    def parse(self) -> None:
-        while not self.is_done(("*** End Patch",)):
-            # ---------- UPDATE ---------- #
-            path = self.read_str("*** Update File: ")
-            if path:
-                if path in self.patch.actions:
-                    raise DiffError(f"Duplicate update for file: {path}")
-                move_to = self.read_str("*** Move to: ")
-                if path not in self.current_files:
-                    raise DiffError(f"Update File Error - missing file: {path}")
-                text = self.current_files[path]
-                action = self._parse_update_file(text)
-                action.move_path = move_to or None
-                self.patch.actions[path] = action
-                continue
-
-            # ---------- DELETE ---------- #
-            path = self.read_str("*** Delete File: ")
-            if path:
-                if path in self.patch.actions:
-                    raise DiffError(f"Duplicate delete for file: {path}")
-                if path not in self.current_files:
-                    raise DiffError(f"Delete File Error - missing file: {path}")
-                self.patch.actions[path] = PatchAction(type=ActionType.DELETE)
-                continue
-
-            # ---------- ADD ---------- #
-            path = self.read_str("*** Add File: ")
-            if path:
-                if path in self.patch.actions:
-                    raise DiffError(f"Duplicate add for file: {path}")
-                if path in self.current_files:
-                    raise DiffError(f"Add File Error - file already exists: {path}")
-                self.patch.actions[path] = self._parse_add_file()
-                continue
-
-            raise DiffError(f"Unknown line while parsing: {self._cur_line()}")
-
-        if not self.startswith("*** End Patch"):
-            raise DiffError("Missing *** End Patch sentinel")
-        self.index += 1  # consume sentinel
-
-    # ------------- section parsers ---------------------------------------- #
-    def _parse_update_file(self, text: str) -> PatchAction:
-        action = PatchAction(type=ActionType.UPDATE)
-        lines = text.split("\n")
-        index = 0
-        while not self.is_done(
-            (
-                "*** End Patch",
-                "*** Update File:",
-                "*** Delete File:",
-                "*** Add File:",
-                "*** End of File",
-            )
-        ):
-            def_str = self.read_str("@@ ")
-            section_str = ""
-            if not def_str and self._norm(self._cur_line()) == "@@":
-                section_str = self.read_line()
-
-            if not (def_str or section_str or index == 0):
-                raise DiffError(f"Invalid line in update section:\n{self._cur_line()}")
-
-            if def_str.strip():
-                found = False
-                if def_str not in lines[:index]:
-                    for i, s in enumerate(lines[index:], index):
-                        if s == def_str:
-                            index = i + 1
-                            found = True
-                            break
-                if not found and def_str.strip() not in [
-                    s.strip() for s in lines[:index]
-                ]:
-                    for i, s in enumerate(lines[index:], index):
-                        if s.strip() == def_str.strip():
-                            index = i + 1
-                            self.fuzz += 1
-                            found = True
-                            break
-
-            next_ctx, chunks, end_idx, eof = peek_next_section(self.lines, self.index)
-            new_index, fuzz = find_context(lines, next_ctx, index, eof)
-            if new_index == -1:
-                ctx_txt = "\n".join(next_ctx)
-                raise DiffError(
-                    f"Invalid {'EOF ' if eof else ''}context at {index}:\n{ctx_txt}"
-                )
-            self.fuzz += fuzz
-            for ch in chunks:
-                ch.orig_index += new_index
-                action.chunks.append(ch)
-            index = new_index + len(next_ctx)
-            self.index = end_idx
-        return action
-
-    def _parse_add_file(self) -> PatchAction:
-        lines: List[str] = []
-        while not self.is_done(
-            ("*** End Patch", "*** Update File:", "*** Delete File:", "*** Add File:")
-        ):
-            s = self.read_line()
-            if not s.startswith("+"):
-                raise DiffError(f"Invalid Add File line (missing '+'): {s}")
-            lines.append(s[1:])  # strip leading '+'
-        return PatchAction(type=ActionType.ADD, new_file="\n".join(lines))
-
-
-# --------------------------------------------------------------------------- #
-#  Helper functions
-# --------------------------------------------------------------------------- #
-def find_context_core(
-    lines: List[str], context: List[str], start: int
-) -> Tuple[int, int]:
-    if not context:
-        return start, 0
-
-    for i in range(start, len(lines)):
-        if lines[i : i + len(context)] == context:
-            return i, 0
-    for i in range(start, len(lines)):
-        if [s.rstrip() for s in lines[i : i + len(context)]] == [
-            s.rstrip() for s in context
-        ]:
-            return i, 1
-    for i in range(start, len(lines)):
-        if [s.strip() for s in lines[i : i + len(context)]] == [
-            s.strip() for s in context
-        ]:
-            return i, 100
-    return -1, 0
-
-
-def find_context(
-    lines: List[str], context: List[str], start: int, eof: bool
-) -> Tuple[int, int]:
-    if eof:
-        new_index, fuzz = find_context_core(lines, context, len(lines) - len(context))
-        if new_index != -1:
-            return new_index, fuzz
-        new_index, fuzz = find_context_core(lines, context, start)
-        return new_index, fuzz + 10_000
-    return find_context_core(lines, context, start)
-
-
-def peek_next_section(
-    lines: List[str], index: int
-) -> Tuple[List[str], List[Chunk], int, bool]:
-    old: List[str] = []
-    del_lines: List[str] = []
-    ins_lines: List[str] = []
-    chunks: List[Chunk] = []
-    mode = "keep"
-    orig_index = index
-
-    while index < len(lines):
-        s = lines[index]
-        if s.startswith(
-            (
-                "@@",
-                "*** End Patch",
-                "*** Update File:",
-                "*** Delete File:",
-                "*** Add File:",
-                "*** End of File",
-            )
-        ):
-            break
-        if s == "***":
-            break
-        if s.startswith("***"):
-            raise DiffError(f"Invalid Line: {s}")
-        index += 1
-
-        last_mode = mode
-        if s == "":
-            s = " "
-        if s[0] == "+":
-            mode = "add"
-        elif s[0] == "-":
-            mode = "delete"
-        elif s[0] == " ":
-            mode = "keep"
-        else:
-            raise DiffError(f"Invalid Line: {s}")
-        s = s[1:]
-
-        if mode == "keep" and last_mode != mode:
-            if ins_lines or del_lines:
-                chunks.append(
-                    Chunk(
-                        orig_index=len(old) - len(del_lines),
-                        del_lines=del_lines,
-                        ins_lines=ins_lines,
-                    )
-                )
-            del_lines, ins_lines = [], []
-
-        if mode == "delete":
-            del_lines.append(s)
-            old.append(s)
-        elif mode == "add":
-            ins_lines.append(s)
-        elif mode == "keep":
-            old.append(s)
-
-    if ins_lines or del_lines:
-        chunks.append(
-            Chunk(
-                orig_index=len(old) - len(del_lines),
-                del_lines=del_lines,
-                ins_lines=ins_lines,
-            )
-        )
-
-    if index < len(lines) and lines[index] == "*** End of File":
-        index += 1
-        return old, chunks, index, True
-
-    if index == orig_index:
-        raise DiffError("Nothing in this section")
-    return old, chunks, index, False
-
-
-# --------------------------------------------------------------------------- #
-#  Patch → Commit and Commit application
-# --------------------------------------------------------------------------- #
-def _get_updated_file(text: str, action: PatchAction, path: str) -> str:
-    if action.type is not ActionType.UPDATE:
-        raise DiffError("_get_updated_file called with non-update action")
-    orig_lines = text.split("\n")
-    dest_lines: List[str] = []
-    orig_index = 0
-
-    for chunk in action.chunks:
-        if chunk.orig_index > len(orig_lines):
-            raise DiffError(
-                f"{path}: chunk.orig_index {chunk.orig_index} exceeds file length"
-            )
-        if orig_index > chunk.orig_index:
-            raise DiffError(
-                f"{path}: overlapping chunks at {orig_index} > {chunk.orig_index}"
-            )
-
-        dest_lines.extend(orig_lines[orig_index : chunk.orig_index])
-        orig_index = chunk.orig_index
-
-        dest_lines.extend(chunk.ins_lines)
-        orig_index += len(chunk.del_lines)
-
-    dest_lines.extend(orig_lines[orig_index:])
-    return "\n".join(dest_lines)
-
-
-def patch_to_commit(patch: Patch, orig: Dict[str, str]) -> Commit:
-    commit = Commit()
-    for path, action in patch.actions.items():
-        if action.type is ActionType.DELETE:
-            commit.changes[path] = FileChange(
-                type=ActionType.DELETE, old_content=orig[path]
-            )
-        elif action.type is ActionType.ADD:
-            if action.new_file is None:
-                raise DiffError("ADD action without file content")
-            commit.changes[path] = FileChange(
-                type=ActionType.ADD, new_content=action.new_file
-            )
-        elif action.type is ActionType.UPDATE:
-            new_content = _get_updated_file(orig[path], action, path)
-            commit.changes[path] = FileChange(
-                type=ActionType.UPDATE,
-                old_content=orig[path],
-                new_content=new_content,
-                move_path=action.move_path,
-            )
-    return commit
-
-
-# --------------------------------------------------------------------------- #
-#  User-facing helpers
-# --------------------------------------------------------------------------- #
-def text_to_patch(text: str, orig: Dict[str, str]) -> Tuple[Patch, int]:
-    lines = text.splitlines()  # preserves blank lines, no strip()
-    if (
-        len(lines) < 2
-        or not Parser._norm(lines[0]).startswith("*** Begin Patch")
-        or Parser._norm(lines[-1]) != "*** End Patch"
-    ):
-        raise DiffError("Invalid patch text - missing sentinels")
-
-    parser = Parser(current_files=orig, lines=lines, index=1)
-    parser.parse()
-    return parser.patch, parser.fuzz
-
-
-def identify_files_needed(text: str) -> List[str]:
-    lines = text.splitlines()
-    return [
-        line[len("*** Update File: ") :]
-        for line in lines
-        if line.startswith("*** Update File: ")
-    ] + [
-        line[len("*** Delete File: ") :]
-        for line in lines
-        if line.startswith("*** Delete File: ")
-    ]
-
-
-def identify_files_added(text: str) -> List[str]:
-    lines = text.splitlines()
-    return [
-        line[len("*** Add File: ") :]
-        for line in lines
-        if line.startswith("*** Add File: ")
-    ]
-
-
-# --------------------------------------------------------------------------- #
-#  File-system helpers
-# --------------------------------------------------------------------------- #
-def load_files(paths: List[str], open_fn: Callable[[str], str]) -> Dict[str, str]:
-    return {path: open_fn(path) for path in paths}
-
-
-def apply_commit(
-    commit: Commit,
-    write_fn: Callable[[str, str], None],
-    remove_fn: Callable[[str], None],
-) -> None:
-    for path, change in commit.changes.items():
-        if change.type is ActionType.DELETE:
-            remove_fn(path)
-        elif change.type is ActionType.ADD:
-            if change.new_content is None:
-                raise DiffError(f"ADD change for {path} has no content")
-            write_fn(path, change.new_content)
-        elif change.type is ActionType.UPDATE:
-            if change.new_content is None:
-                raise DiffError(f"UPDATE change for {path} has no new content")
-            target = change.move_path or path
-            write_fn(target, change.new_content)
-            if change.move_path:
-                remove_fn(path)
-
-
-def open_file(path: str) -> str:
-    with open(path, "rt", encoding="utf-8") as fh:
-        return fh.read()
-
-
-def write_file(path: str, content: str) -> None:
-    target = pathlib.Path(path)
-    target.parent.mkdir(parents=True, exist_ok=True)
-    with target.open("wt", encoding="utf-8") as fh:
-        fh.write(content)
-
-
-def remove_file(path: str) -> None:
-    pathlib.Path(path).unlink(missing_ok=True)
-
-
-
-def apply_patch(
-    text: str,
-    open_fn: Callable[[str], str] = open_file,
-    write_fn: Callable[[str, str], None] = write_file, 
-    remove_fn: Callable[[str], None] = remove_file,
-) -> str:
-    if not text.startswith("*** Begin Patch"):
-        raise DiffError("Patch text must start with *** Begin Patch")
-    paths = identify_files_needed(text)
-    orig = load_files(paths, open_fn)
-    patch, _fuzz = text_to_patch(text, orig)
-    commit = patch_to_commit(patch, orig)
-    apply_commit(commit, write_fn, remove_fn)
-    return "Done!"
-
-
-def main() -> None:
-    import sys
-
-    patch_text = sys.stdin.read()
-    if not patch_text:
-        print("Please pass patch text through stdin", file=sys.stderr)
-        return
-    try:
-        result = apply_patch(patch_text)
-    except DiffError as exc:
-        print(exc, file=sys.stderr)
-        return
-    print(result)
-
-
-if __name__ == "__main__":
-    main()