feat: add list drafts and templates commands (#47)

Author: mtth

poetry.lock

@@ -8,8 +8,9 @@ dynamic = ["version"]
 requires-python = ">=3.12"
 dependencies = [
   "gitpython (>=3.1.44,<4)",
-  "jinja2 (>=3.1.5,<4.0.0)",
-  "xdg-base-dirs (>=6.0.2,<7.0.0)",
+  "jinja2 (>=3.1.5,<4)",
+  "prettytable (>=3.15.1,<4)",
+  "xdg-base-dirs (>=6.0.2,<7)",
 ]
 
 [project.optional-dependencies]

pyproject.toml

@@ -13,7 +13,7 @@
 from .common import PROGRAM, Config, UnreachableError, ensure_state_home
 from .drafter import Drafter
 from .editor import open_editor
-from .prompt import TemplatedPrompt
+from .prompt import TemplatedPrompt, template_source, templates_table
 from .store import Store
 from .toolbox import ToolVisitor
 
@@ -40,12 +40,12 @@ def new_parser() -> optparse.OptionParser:
         dest="root",
     )
 
-    def add_command(name: str, **kwargs) -> None:
+    def add_command(name: str, short: str | None = None, **kwargs) -> None:
         def callback(_option, _opt, _value, parser) -> None:
             parser.values.command = name
 
         parser.add_option(
-            f"-{name[0].upper()}",
+            f"-{short or name[0].upper()}",
             f"--{name}",
             action="callback",
             callback=callback,
@@ -54,7 +54,9 @@ def callback(_option, _opt, _value, parser) -> None:
 
     add_command("finalize", help="apply current draft to original branch")
     add_command("generate", help="start a new draft from a prompt")
+    add_command("history", help="show history drafts or prompts")
     add_command("revert", help="discard the current draft")
+    add_command("templates", help="show template information")
 
     parser.add_option(
         "-b",
@@ -74,6 +76,13 @@ def callback(_option, _opt, _value, parser) -> None:
         help="delete draft after finalizing or discarding",
         action="store_true",
     )
+    # TODO: Add edit option. Works both for prompts and templates.
+    parser.add_option(
+        "-j",
+        "--json",
+        help="use JSON for table output",
+        action="store_true",
+    )
     parser.add_option(
         "-r",
         "--reset",
@@ -151,6 +160,7 @@ def main() -> None:
         name = drafter.generate_draft(
             prompt,
             bot,
+            bot_name=opts.bot,
             tool_visitors=[ToolPrinter()],
             reset=opts.reset,
         )
@@ -161,6 +171,16 @@ def main() -> None:
     elif command == "revert":
         name = drafter.revert_draft(delete=opts.delete)
         print(f"Reverted {name}.")
+    elif command == "history":
+        table = drafter.history_table(args[0] if args else None)
+        if table:
+            print(table.to_json() if opts.json else table)
+    elif command == "templates":
+        if args:
+            print(template_source(args[0]))
+        else:
+            table = templates_table()
+            print(table.to_json() if opts.json else table)
     else:
         raise UnreachableError()
 

src/git_draft/__main__.py

@@ -3,7 +3,7 @@
 import dataclasses
 from pathlib import Path
 
-from ..common import ensure_state_home
+from ..common import ensure_state_home, qualified_class_name
 from ..toolbox import Toolbox
 
 
@@ -21,9 +21,7 @@ class Action:
 class Bot:
     @classmethod
     def state_folder_path(cls, ensure_exists=False) -> Path:
-        name = cls.__qualname__
-        if cls.__module__:
-            name = f"{cls.__module__}.{name}"
+        name = qualified_class_name(cls)
         path = ensure_state_home() / "bots" / name
         if ensure_exists:
             path.mkdir(parents=True, exist_ok=True)

src/git_draft/bots/common.py

@@ -7,11 +7,13 @@
 import logging
 from pathlib import Path
 import random
+import sqlite3
 import string
 import textwrap
 import tomllib
-from typing import Any, Mapping, Self, Sequence
+from typing import Any, Mapping, Self, Sequence, Type
 
+import prettytable
 import xdg_base_dirs
 
 
@@ -90,3 +92,37 @@ def reindent(s: str, width=0) -> str:
     return "\n\n".join(
         textwrap.fill(p, width=width) if width else p for p in paragraphs
     )
+
+
+def qualified_class_name(cls: Type) -> str:
+    name = cls.__qualname__
+    return f"{cls.__module__}.{name}" if cls.__module__ else name
+
+
+class Table:
+    """Pretty-printable table"""
+
+    _kwargs = dict(border=False)  # Shared options
+
+    def __init__(self, data: prettytable.PrettyTable) -> None:
+        self.data = data
+        self.data.align = "l"
+
+    def __bool__(self) -> bool:
+        return len(self.data.rows) > 0
+
+    def __str__(self) -> str:
+        return str(self.data) if self else ""
+
+    def to_json(self) -> str:
+        return self.data.get_json_string(header=False)
+
+    @classmethod
+    def empty(cls) -> Self:
+        return cls(prettytable.PrettyTable([], **cls._kwargs))
+
+    @classmethod
+    def from_cursor(cls, cursor: sqlite3.Cursor) -> Self:
+        table = prettytable.from_db_cursor(cursor, **cls._kwargs)
+        assert table
+        return cls(table)

src/git_draft/common.py

@@ -15,7 +15,7 @@
 import git
 
 from .bots import Bot, Goal
-from .common import JSONObject, random_id
+from .common import JSONObject, Table, qualified_class_name, random_id
 from .prompt import PromptRenderer, TemplatedPrompt
 from .store import Store, sql
 from .toolbox import StagingToolbox, ToolVisitor
@@ -28,7 +28,7 @@
 class _Branch:
     """Draft branch"""
 
-    _name_pattern = re.compile(r"draft/(.+)")
+    _pattern = re.compile(r"draft/(.+)")
 
     suffix: str
 
@@ -40,11 +40,13 @@ def __str__(self) -> str:
         return self.name
 
     @classmethod
-    def active(cls, repo: git.Repo) -> _Branch | None:
+    def active(cls, repo: git.Repo, name: str | None = None) -> _Branch | None:
         match: Match | None = None
-        if not repo.head.is_detached:
-            match = cls._name_pattern.fullmatch(repo.active_branch.name)
+        if name or not repo.head.is_detached:
+            match = cls._pattern.fullmatch(name or repo.active_branch.name)
         if not match:
+            if name:
+                raise ValueError(f"Not a valid draft branch name: {name!r}")
             return None
         return _Branch(match[1])
 
@@ -64,12 +66,16 @@ def __init__(self, store: Store, repo: git.Repo) -> None:
 
     @classmethod
     def create(cls, store: Store, path: str | None = None) -> Drafter:
-        return cls(store, git.Repo(path, search_parent_directories=True))
+        try:
+            return cls(store, git.Repo(path, search_parent_directories=True))
+        except git.NoSuchPathError:
+            raise ValueError(f"No git repository at {path}")
 
     def generate_draft(
         self,
         prompt: str | TemplatedPrompt,
         bot: Bot,
+        bot_name: str | None = None,
         tool_visitors: Sequence[ToolVisitor] | None = None,
         reset: bool = False,
         sync: bool = False,
@@ -94,16 +100,19 @@ def generate_draft(
         tool_visitors = [operation_recorder] + list(tool_visitors or [])
         toolbox = StagingToolbox(self._repo, tool_visitors)
         if isinstance(prompt, TemplatedPrompt):
+            template: str | None = prompt.template
             renderer = PromptRenderer.for_toolbox(toolbox)
             prompt_contents = renderer.render(prompt)
         else:
+            template = None
             prompt_contents = prompt
 
         with self._store.cursor() as cursor:
             [(prompt_id,)] = cursor.execute(
                 sql("add-prompt"),
                 {
                     "branch_suffix": branch.suffix,
+                    "template": template,
                     "contents": prompt_contents,
                 },
             )
@@ -131,6 +140,8 @@ def generate_draft(
                 {
                     "commit_sha": commit.hexsha,
                     "prompt_id": prompt_id,
+                    "bot_name": bot_name,
+                    "bot_class": qualified_class_name(bot.__class__),
                     "walltime": walltime,
                 },
             )
@@ -161,6 +172,26 @@ def revert_draft(self, delete=False) -> str:
         _logger.info("Reverted %s.", name)
         return name
 
+    def history_table(self, branch_name: str | None = None) -> Table:
+        path = self._repo.working_dir
+        branch = _Branch.active(self._repo, branch_name)
+        if branch:
+            with self._store.cursor() as cursor:
+                results = cursor.execute(
+                    sql("list-prompts"),
+                    {
+                        "repo_path": path,
+                        "branch_suffix": branch.suffix,
+                    },
+                )
+                return Table.from_cursor(results)
+        else:
+            with self._store.cursor() as cursor:
+                results = cursor.execute(
+                    sql("list-drafts"), {"repo_path": path}
+                )
+                return Table.from_cursor(results)
+
     def _create_branch(self, sync: bool) -> _Branch:
         if self._repo.head.is_detached:
             raise RuntimeError("No currently active branch")