fixup! 3e59ac4

Author: mtth

docs/git-draft.adoc

@@ -89,7 +89,7 @@ Otherwise if no template is specified and stdin is a TTY, `$EDITOR` will be open
 --quit::
 Go back to the draft's origin branch, keeping the working directory's current state.
 This will delete the draft branch and its upstream.
-Generated commits and the draft branch's final state remain available via `ref/drafts`.
+Generated commits and the draft branch's final state remain available via `refs/drafts`.
 
 -T::
 --templates::

src/git_draft/bots/openai.py

@@ -173,11 +173,11 @@ def params(self) -> Sequence[openai.types.chat.ChatCompletionToolParam]:
 
 
 class _ToolHandler[V]:
-    def __init__(self, tree: Worktree) -> None:
+    def __init__(self, tree: Worktree, feedback: UserFeedback) -> None:
         self._tree = tree
-        self.question: str | None = None
+        self._feedback = feedback
 
-    def _on_ask_user(self) -> V:
+    def _on_ask_user(self, response: str) -> V:
         raise NotImplementedError()
 
     def _on_read_file(self, path: PurePosixPath, contents: str | None) -> V:
@@ -202,9 +202,9 @@ def handle_function(self, function: Any) -> V:
         _logger.info("Requested function: %s", function)
         match function.name:
             case "ask_user":
-                assert not self.question
-                self.question = inputs["question"]
-                return self._on_ask_user()
+                question = inputs["question"]
+                response = self._feedback.ask(question)
+                return self._on_ask_user(response)
             case "read_file":
                 path = PurePosixPath(inputs["path"])
                 return self._on_read_file(path, self._tree.read_file(path))
@@ -235,10 +235,10 @@ def __init__(self, client: openai.OpenAI, model: str) -> None:
         self._model = model
 
     async def act(
-        self, goal: Goal, tree: Worktree, _feedback: UserFeedback
+        self, goal: Goal, tree: Worktree, feedback: UserFeedback
     ) -> Action:
         tools = _ToolsFactory(strict=False).params()
-        tool_handler = _CompletionsToolHandler(tree)
+        tool_handler = _CompletionsToolHandler(tree, feedback)
 
         messages: list[openai.types.chat.ChatCompletionMessageParam] = [
             {"role": "system", "content": reindent(_INSTRUCTIONS)},
@@ -266,15 +266,12 @@ async def act(
             if done:
                 break
 
-        return Action(
-            request_count=request_count,
-            question=tool_handler.question,
-        )
+        return Action(request_count=request_count)
 
 
 class _CompletionsToolHandler(_ToolHandler[str | None]):
-    def _on_ask_user(self) -> None:
-        return None
+    def _on_ask_user(self, response: str) -> str:
+        return response
 
     def _on_read_file(self, path: PurePosixPath, contents: str | None) -> str:
         if contents is None:
@@ -321,7 +318,7 @@ def _load_assistant_id(self) -> str:
         return assistant_id
 
     async def act(
-        self, goal: Goal, tree: Worktree, _feedback: UserFeedback
+        self, goal: Goal, tree: Worktree, feedback: UserFeedback
     ) -> Action:
         assistant_id = self._load_assistant_id()
 
@@ -338,24 +335,29 @@ async def act(
         with self._client.beta.threads.runs.stream(
             thread_id=thread.id,
             assistant_id=assistant_id,
-            event_handler=_EventHandler(self._client, tree, action),
+            event_handler=_EventHandler(self._client, tree, feedback, action),
         ) as stream:
             stream.until_done()
         return action
 
 
 class _EventHandler(openai.AssistantEventHandler):
     def __init__(
-        self, client: openai.Client, tree: Worktree, action: Action
+        self, client: openai.Client, tree: Worktree,
+        feedback: UserFeedback,
+        action: Action,
     ) -> None:
         super().__init__()
         self._client = client
         self._tree = tree
+        self._feedback = feedback
         self._action = action
         self._action.increment_request_count()
 
     def _clone(self) -> Self:
-        return self.__class__(self._client, self._tree, self._action)
+        return self.__class__(
+            self._client, self._tree, self._feedback, self._action
+        )
 
     @override
     def on_event(self, event: openai.types.beta.AssistantStreamEvent) -> None:
@@ -381,11 +383,8 @@ 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._tree, tool.id)
+            handler = _ThreadToolHandler(self._tree, self._feedback, tool.id)
             tool_outputs.append(handler.handle_function(tool.function))
-            if handler.question:
-                assert not self._action.question
-                self._action.question = handler.question
 
         run = self.current_run
         assert run, "No ongoing run"
@@ -404,15 +403,17 @@ class _ToolOutput(TypedDict):
 
 
 class _ThreadToolHandler(_ToolHandler[_ToolOutput]):
-    def __init__(self, tree: Worktree, call_id: str) -> None:
-        super().__init__(tree)
+    def __init__(
+        self, tree: Worktree, feedback: UserFeedback, call_id: str
+    ) -> None:
+        super().__init__(tree, feedback)
         self._call_id = call_id
 
     def _wrap(self, output: str) -> _ToolOutput:
         return _ToolOutput(tool_call_id=self._call_id, output=output)
 
-    def _on_ask_user(self) -> _ToolOutput:
-        return self._wrap("OK")
+    def _on_ask_user(self, response: str) -> _ToolOutput:
+        return self._wrap(response)
 
     def _on_read_file(
         self, _path: PurePosixPath, contents: str | None

src/git_draft/common.py

@@ -140,8 +140,12 @@ def from_cursor(cls, cursor: sqlite3.Cursor) -> Self:
 
 
 def _tagged(text: str, /, **kwargs) -> str:
-    tags = [f"{key}={val}" for key, val in kwargs.items() if val is not None]
-    return f"{text} [{', '.join(tags)}]" if tags else text
+    if kwargs:
+        tags = [
+            f"{key}={val}" for key, val in kwargs.items() if val is not None
+        ]
+        text = f"{text} [{', '.join(tags)}]" if tags else text
+    return reindent(text)
 
 
 class Progress:

src/git_draft/drafter.py

@@ -32,7 +32,7 @@ class Draft:
     folio: Folio
     seqno: int
     is_noop: bool
-    has_question: bool
+    has_pending_question: bool
     walltime: timedelta
     token_count: int | None
 
@@ -154,8 +154,6 @@ async def generate_draft(
                 tree.with_hooks(operation_recorder),
                 feedback,
             )
-            if change.action.question:
-                self._progress.report("Requested feedback.")
             spinner.update(
                 "Completed bot run.",
                 runtime=round(change.walltime.total_seconds(), 1),
@@ -167,7 +165,7 @@ async def generate_draft(
             folio=folio,
             seqno=seqno,
             is_noop=change.is_noop,
-            has_question=change.action.question is not None,
+            has_pending_question=change.action.question is not None,
             walltime=change.walltime,
             token_count=change.action.token_count,
         )
@@ -197,7 +195,7 @@ async def generate_draft(
                         "walltime_seconds": change.walltime.total_seconds(),
                         "request_count": change.action.request_count,
                         "token_count": change.action.token_count,
-                        "question": change.action.question,
+                        "pending_question": change.action.question,
                     },
                 )
                 cursor.executemany(

src/git_draft/queries/add-action.sql

@@ -4,11 +4,11 @@ insert into actions (
     walltime_seconds,
     request_count,
     token_count,
-    question)
+    pending_question)
   values (
     :prompt_id,
     :bot_class,
     :walltime_seconds,
     :request_count,
     :token_count,
-    :question);
+    :pending_question);

src/git_draft/queries/create-tables.sql

@@ -26,10 +26,21 @@ create table if not exists actions (
   walltime_seconds real not null,
   request_count int,
   token_count int,
-  question text,
+  pending_question text,
   foreign key (prompt_id) references prompts (id) on delete cascade
 ) without rowid;
 
+create table if not exists notifications (
+  id integer primary key,
+  prompt_id integer not null,
+  created_at timestamp default current_timestamp,
+  status text,
+  question text,
+  answer text,
+  foreign key (prompt_id) references actions (prompt_id) on delete cascade,
+  check ((status is null != question is null) and (answer is null or question is not null))
+);
+
 create table if not exists operations (
   id integer primary key,
   prompt_id integer not null,

src/git_draft/queries/get-latest-folio-prompt.sql

@@ -1,4 +1,4 @@
-select p.contents, a.question
+select p.contents, a.pending_question
   from prompts as p
   join folios as f on p.folio_id = f.id
   left join actions as a on p.id = a.prompt_id

src/git_draft/store.py

@@ -19,7 +19,7 @@
 class Store:
     """Lightweight sqlite wrapper"""
 
-    _name = "v4.sqlite3"
+    _name = "v5.sqlite3"
 
     def __init__(self, conn: sqlite3.Connection) -> None:
         self._connection = conn