fixup! 8c6613e

Author: mtth

src/git_draft/__init__.py

@@ -2,17 +2,15 @@
 
 import logging
 
-from .bots import Action, Bot, Goal
-from .feedback import Feedback
-from .toolbox import Toolbox
+from .bots import Action, Bot, Goal, UserFeedback, WorkTree
 
 
 __all__ = [
     "Action",
     "Bot",
-    "Feedback",
     "Goal",
-    "Toolbox",
+    "UserFeedback",
+    "WorkTree",
 ]
 
 logging.getLogger(__name__).addHandler(logging.NullHandler())

src/git_draft/__main__.py

@@ -20,7 +20,6 @@
 )
 from .drafter import Drafter, DraftMergeStrategy
 from .editor import open_editor
-from .feedback import LiveFeedback
 from .git import Repo
 from .prompt import (
     PromptMetadata,
@@ -29,6 +28,7 @@
     templates_table,
 )
 from .store import Store
+from .user_feedbacks import InteractiveUserFeedback
 
 
 _logger = logging.getLogger(__name__)
@@ -170,7 +170,7 @@ async def run() -> None:  # noqa: PLR0912 PLR0915
 
     if sys.stdin.isatty():
         progress = Progress.dynamic()
-        feedback = LiveFeedback()
+        feedback = InteractiveUserFeedback()
     else:
         progress = Progress.static()
         feedback = None

src/git_draft/bots/__init__.py

@@ -1,22 +1,19 @@
-"""Bot interfaces and built-in implementations
-
-* https://aider.chat/docs/leaderboards/
-"""
+"""Bot interfaces and built-in implementations"""
 
 import importlib
 import os
 import sys
 
 from ..common import BotConfig, reindent
-from ..toolbox import Toolbox
-from .common import Action, Bot, Goal
+from .common import Action, Bot, Goal, UserFeedback, WorkTree
 
 
 __all__ = [
     "Action",
     "Bot",
     "Goal",
-    "Toolbox",
+    "UserFeedback",
+    "WorkTree",
 ]
 
 

src/git_draft/bots/common.py

@@ -2,20 +2,64 @@
 
 from __future__ import annotations
 
+from collections.abc import Sequence
+import contextlib
 import dataclasses
-from pathlib import Path
+from pathlib import Path, PurePosixPath
+from typing import Protocol
 
 from ..common import ensure_state_home, qualified_class_name
-from ..feedback import Feedback
-from ..toolbox import Toolbox
 
 
 @dataclasses.dataclass(frozen=True)
 class Goal:
     """Bot request"""
 
     prompt: str
-    # TODO: Add timeout here.
+    # TODO: Add timeout.
+
+
+class WorkTree(Protocol):
+    """File operations
+
+    Implementations may not be thread-safe. Concurrent operations should be
+    serialized by the caller.
+    """
+
+    def list_files(self) -> Sequence[PurePosixPath]:
+        """List all files"""
+
+    def read_file(self, path: PurePosixPath) -> str | None:
+        """Get a file's contents"""
+
+    def write_file(self, path: PurePosixPath, contents: str) -> None:
+        """Update a file's contents"""
+
+    def delete_file(self, path: PurePosixPath) -> None:
+        """Remove a file"""
+
+    def rename_file(
+        self, src_path: PurePosixPath, dst_path: PurePosixPath
+    ) -> None:
+        """Move a file"""
+
+    def edit_files(self) -> contextlib.AbstractContextManager[Path]:
+        """Return path to a temporary folder with editable copies of all files
+
+        Any updates are synced back to the work tree when the context exits.
+        Other operations should not be performed concurrently as they may be
+        stale or lost.
+        """
+
+
+class UserFeedback(Protocol):
+    """User interactions"""
+
+    def notify(self, update: str) -> None:
+        """Report progress to the user"""
+
+    def ask(self, question: str) -> str:
+        """Request additional information from the user"""
 
 
 @dataclasses.dataclass
@@ -29,7 +73,6 @@ class Action:
     title: str | None = None
     request_count: int | None = None
     token_count: int | None = None
-    question: str | None = None
 
     def increment_request_count(self, n: int = 1, init: bool = False) -> None:
         self._increment("request_count", n, init)
@@ -68,7 +111,7 @@ def state_folder_path(cls, ensure_exists: bool = False) -> Path:
         return path
 
     async def act(
-        self, goal: Goal, toolbox: Toolbox, feedback: Feedback
+        self, goal: Goal, tree: WorkTree, feedback: UserFeedback
     ) -> Action:
-        """Runs the bot, striving to achieve the goal with the given toolbox"""
+        """Runs the bot, striving to achieve the goal"""
         raise NotImplementedError()

src/git_draft/bots/openai.py

@@ -21,9 +21,7 @@
 import openai
 
 from ..common import JSONObject, UnreachableError, config_string, reindent
-from ..feedback import Feedback
-from ..toolbox import Toolbox
-from .common import Action, Bot, Goal
+from .common import Action, Bot, Goal, UserFeedback, WorkTree
 
 
 _logger = logging.getLogger(__name__)
@@ -175,8 +173,8 @@ def params(self) -> Sequence[openai.types.chat.ChatCompletionToolParam]:
 
 
 class _ToolHandler[V]:
-    def __init__(self, toolbox: Toolbox) -> None:
-        self._toolbox = toolbox
+    def __init__(self, tree: WorkTree) -> None:
+        self._tree = tree
         self.question: str | None = None
 
     def _on_ask_user(self) -> V:
@@ -209,23 +207,23 @@ def handle_function(self, function: Any) -> V:
                 return self._on_ask_user()
             case "read_file":
                 path = PurePosixPath(inputs["path"])
-                return self._on_read_file(path, self._toolbox.read_file(path))
+                return self._on_read_file(path, self._tree.read_file(path))
             case "write_file":
                 path = PurePosixPath(inputs["path"])
                 contents = inputs["contents"]
-                self._toolbox.write_file(path, contents)
+                self._tree.write_file(path, contents)
                 return self._on_write_file(path)
             case "delete_file":
                 path = PurePosixPath(inputs["path"])
-                self._toolbox.delete_file(path)
+                self._tree.delete_file(path)
                 return self._on_delete_file(path)
             case "rename_file":
                 src_path = PurePosixPath(inputs["src_path"])
                 dst_path = PurePosixPath(inputs["dst_path"])
-                self._toolbox.rename_file(src_path, dst_path)
+                self._tree.rename_file(src_path, dst_path)
                 return self._on_rename_file(src_path, dst_path)
             case "list_files":
-                paths = self._toolbox.list_files()
+                paths = self._tree.list_files()
                 return self._on_list_files(paths)
             case _ as name:
                 raise UnreachableError(f"Unexpected function: {name}")
@@ -237,10 +235,10 @@ def __init__(self, client: openai.OpenAI, model: str) -> None:
         self._model = model
 
     async def act(
-        self, goal: Goal, toolbox: Toolbox, _feedback: Feedback
+        self, goal: Goal, tree: WorkTree, _feedback: UserFeedback
     ) -> Action:
         tools = _ToolsFactory(strict=False).params()
-        tool_handler = _CompletionsToolHandler(toolbox)
+        tool_handler = _CompletionsToolHandler(tree)
 
         messages: list[openai.types.chat.ChatCompletionMessageParam] = [
             {"role": "system", "content": reindent(_INSTRUCTIONS)},
@@ -323,7 +321,7 @@ def _load_assistant_id(self) -> str:
         return assistant_id
 
     async def act(
-        self, goal: Goal, toolbox: Toolbox, _feedback: Feedback
+        self, goal: Goal, tree: WorkTree, _feedback: UserFeedback
     ) -> Action:
         assistant_id = self._load_assistant_id()
 
@@ -340,24 +338,24 @@ async def act(
         with self._client.beta.threads.runs.stream(
             thread_id=thread.id,
             assistant_id=assistant_id,
-            event_handler=_EventHandler(self._client, toolbox, action),
+            event_handler=_EventHandler(self._client, tree, action),
         ) as stream:
             stream.until_done()
         return action
 
 
 class _EventHandler(openai.AssistantEventHandler):
     def __init__(
-        self, client: openai.Client, toolbox: Toolbox, action: Action
+        self, client: openai.Client, tree: WorkTree, action: Action
     ) -> None:
         super().__init__()
         self._client = client
-        self._toolbox = toolbox
+        self._tree = tree
         self._action = action
         self._action.increment_request_count()
 
     def _clone(self) -> Self:
-        return self.__class__(self._client, self._toolbox, self._action)
+        return self.__class__(self._client, self._tree, self._action)
 
     @override
     def on_event(self, event: openai.types.beta.AssistantStreamEvent) -> None:
@@ -383,7 +381,7 @@ def on_run_step_done(
     def _handle_action(self, _run_id: str, data: Any) -> None:
         tool_outputs = list[Any]()
         for tool in data.required_action.submit_tool_outputs.tool_calls:
-            handler = _ThreadToolHandler(self._toolbox, tool.id)
+            handler = _ThreadToolHandler(self._tree, tool.id)
             tool_outputs.append(handler.handle_function(tool.function))
             if handler.question:
                 assert not self._action.question
@@ -406,8 +404,8 @@ class _ToolOutput(TypedDict):
 
 
 class _ThreadToolHandler(_ToolHandler[_ToolOutput]):
-    def __init__(self, toolbox: Toolbox, call_id: str) -> None:
-        super().__init__(toolbox)
+    def __init__(self, tree: WorkTree, call_id: str) -> None:
+        super().__init__(tree)
         self._call_id = call_id
 
     def _wrap(self, output: str) -> _ToolOutput: