start work

src/argenta/app/autocompleter/entity.py

@@ -1,97 +1,89 @@
 __all__ = ["AutoCompleter"]
 
-import os
-import readline
-from typing import Never
+from prompt_toolkit import PromptSession, HTML
+from prompt_toolkit.completion import Completer, Completion
+from prompt_toolkit.document import Document
+from prompt_toolkit.history import History, ThreadedHistory, FileHistory, InMemoryHistory
+from prompt_toolkit.key_binding import KeyBindings
+
+
+class HistoryCompleter(Completer):
+    def __init__(self, history_container: History, static_commands: set[str]) -> None:
+        self.history_container: History = history_container
+        self.static_commands: set[str] = static_commands
+
+    def get_completions(self, document: Document, complete_event):
+        text: str = document.text_before_cursor
+        history_items: set[str] = set(self.history_container.load_history_strings())
+        all_candidates: set[str] = history_items.union(self.static_commands)
+        matches: list[str] = sorted(cmd for cmd in all_candidates if cmd.startswith(text))
+
+        if not matches:
+            return
+
+        for match in matches:
+            yield Completion(
+                match,
+                start_position=-len(text),
+                display=match
+            )
+
+    @staticmethod
+    def _find_common_prefix(matches: list[str]) -> str:
+        if not matches:
+            return ""
+        common: str = matches[0]
+        for match in matches[1:]:
+            i: int = 0
+            while i < len(common) and i < len(match) and common[i] == match[i]:
+                i += 1
+            common = common[:i]
+        return common
 
 
 class AutoCompleter:
     def __init__(
-        self, history_filename: str | None = None, autocomplete_button: str = "tab"
+            self,
+            history_filename: str | None = None,
+            autocomplete_button: str = "tab"
     ) -> None:
-        """
-        Public. Configures and implements auto-completion of input command
-        :param history_filename: the name of the file for saving the history of the autocompleter
-        :param autocomplete_button: the button for auto-completion
-        :return: None
-        """
         self.history_filename: str | None = history_filename
         self.autocomplete_button: str = autocomplete_button
-
-    def _complete(self, text: str, state: int) -> str | None:
-        """
-        Private. Auto-completion function
-        :param text: part of the command being entered
-        :param state: the current cursor position is relative to the beginning of the line
-        :return: the desired candidate as str or None
-        """
-        matches: list[str] = sorted(
-            cmd for cmd in _get_history_items() if cmd.startswith(text)
-        )
-        if len(matches) > 1:
-            common_prefix = matches[0]
-            for match in matches[1:]:
-                i = 0
-                while (
-                    i < len(common_prefix)
-                    and i < len(match)
-                    and common_prefix[i] == match[i]
-                ):
-                    i += 1
-                common_prefix = common_prefix[:i]
-            if state == 0:
-                readline.insert_text(common_prefix[len(text) :])
-                readline.redisplay()
-            return None
-        elif len(matches) == 1:
-            return matches[0] if state == 0 else None
-        else:
-            return None
+        self._session: PromptSession | None = None
 
     def initial_setup(self, all_commands: set[str]) -> None:
-        """
-        Private. Initial setup function
-        :param all_commands: Registered commands for adding them to the autocomplete history
-        :return: None
-        """
-        if self.history_filename:
-            if os.path.exists(self.history_filename):
-                readline.read_history_file(self.history_filename)
+        kb = KeyBindings()
+
+        def _(event):
+            buff = event.app.current_buffer
+
+            if buff.complete_state:
+                buff.complete_next()
             else:
-                for line in all_commands:
-                    readline.add_history(line)
+                completions = list(buff.completer.get_completions(buff.document, None))
+                if len(completions) == 1:
+                    buff.apply_completion(completions[0])
+                else:
+                    buff.start_completion(select_first=False)
 
-        if not self.history_filename:
-            for line in all_commands:
-                readline.add_history(line)
+        kb.add(self.autocomplete_button)(_)
 
-        readline.set_completer(self._complete)
-        readline.set_completer_delims(readline.get_completer_delims().replace(" ", ""))
-        readline.parse_and_bind(f"{self.autocomplete_button}: complete")
-
-    def exit_setup(self, all_commands: set[str]) -> None:
-        """
-        Private. Exit setup function
-        :return: None
-        """
         if self.history_filename:
-            readline.write_history_file(self.history_filename)
-            with open(self.history_filename, "r") as history_file:
-                raw_history = history_file.read()
-            pretty_history: list[str] = []
-            for line in set(raw_history.strip().split("\n")):
-                if line.split()[0] in all_commands:
-                    pretty_history.append(line)
-            with open(self.history_filename, "w") as history_file:
-                _ = history_file.write("\n".join(pretty_history))
+            history = FileHistory(self.history_filename)
+            history = ThreadedHistory(history)
+        else:
+            history = InMemoryHistory()
 
+        self._session = PromptSession(
+            history=history,
+            completer=HistoryCompleter(history, all_commands),
+            complete_while_typing=False,
+            key_bindings=kb,
+        )
 
-def _get_history_items() -> list[str] | list[Never]:
-    """
-    Private. Returns a list of all commands entered by the user
-    :return: all commands entered by the user as list[str] | list[Never]
-    """
-    return [
-        readline.get_history_item(i)
-        for i in range(1, readline.get_current_history_length() + 1)
-    ]
+    def prompt(self, prompt_text: str | HTML = ">>> ") -> str:
+        if self._session is None:
+            raise RuntimeError("Call initial_setup() before using prompt()")
+        return self._session.prompt(
+            HTML(f"<b><gray>{prompt_text}</gray></b>") if isinstance(prompt_text, str) else prompt_text
+        )