comodor 0.10.0__tar.gz → 0.10.2__tar.gz

{comodor-0.10.0 → comodor-0.10.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: comodor
-Version: 0.10.0
+Version: 0.10.2
 Summary: Comodor — a self-improving terminal coding agent with a Rich TUI
 Project-URL: Homepage, https://comodor.ai
 Project-URL: Repository, https://github.com/ifekri/Comodor

{comodor-0.10.0 → comodor-0.10.2}/src/comodor/_version.py

@@ -18,7 +18,7 @@ version_tuple: tuple[int | str, ...]
 commit_id: str | None
 __commit_id__: str | None
 
-__version__ = version = '0.10.0'
-__version_tuple__ = version_tuple = (0, 10, 0)
+__version__ = version = '0.10.2'
+__version_tuple__ = version_tuple = (0, 10, 2)
 
 __commit_id__ = commit_id = None

{comodor-0.10.0 → comodor-0.10.2}/src/comodor/setup.py

@@ -172,6 +172,54 @@ class SetupWizard:
                 Text(f"  enter a number between 1 and {len(options)}",
                      style=self.theme.style("bad")))
 
+    def _choose_many(self, options: Sequence[tuple[str, str, str]],
+                     title: str = "", verb: str = "choose") -> list[str]:
+        """Return every chosen value. An empty list is a real answer.
+
+        The list is tried first; without a terminal to take over, the numbered
+        form asks the same question. Both accept "none", because a question
+        offering four things has to accept zero as an answer without a fifth
+        option that means nothing.
+        """
+        if self._keys:
+            picked = chooser.choose_many(
+                self.console, self.theme,
+                [chooser.Option(value, label, note) for value, label, note in options],
+                title=title, verb=verb,
+            )
+            if picked is not None:
+                return picked
+            # Escaped, or the list would not run. Either way the question is
+            # still unanswered, so the numbered form takes over.
+
+        table = Table.grid(padding=(0, 2))
+        table.add_column(justify="right", no_wrap=True)
+        table.add_column(no_wrap=True)
+        table.add_column()
+        for index, (_, label, note) in enumerate(options, start=1):
+            table.add_row(
+                Text(f"{index}.", style=self.theme.style("accent")),
+                Text(label, style=self.theme.style("value")),
+                Text(note, style=self.theme.style("dim")),
+            )
+        self.console.print(table)
+
+        while True:
+            raw = self._prompt("  numbers, separated by commas "
+                               "(enter for none): ").strip()
+            if not raw:
+                return []
+            wanted = [part for part in raw.replace(",", " ").split() if part]
+            if all(part.isdigit() and 1 <= int(part) <= len(options)
+                   for part in wanted):
+                # Deduplicated, and in the order they were offered — the same
+                # order the list hands back, so the two paths agree.
+                taken = {int(part) - 1 for part in wanted}
+                return [options[index][0] for index in sorted(taken)]
+            self.console.print(
+                Text(f"  numbers between 1 and {len(options)}, "
+                     f"or enter for none", style=self.theme.style("bad")))
+
     def _ask(self, message: str, default: str = "") -> str:
         suffix = f" [{default}]" if default else ""
         answer = self._prompt(f"  {message}{suffix}: ").strip()
@@ -326,17 +374,22 @@ class SetupWizard:
         Skills are not in the package: they live on a branch and are fetched on
         request, which keeps the install small and means adding one needs no
         release. The cost of that is that nobody would ever find them, so they
-        are offered here — with nothing selected, because a setup wizard that
+        are offered here — with nothing ticked, because a setup wizard that
         installs things you did not ask for is a setup wizard people learn to
         distrust.
 
+        As many as you like. Wanting the review skill and the test skill is the
+        ordinary case, not an unusual one, and a list that took a single answer
+        made the second of them somebody else's problem for another day.
+
         A network that is not there is not a reason to fail a first run. It
         skips, and `comodor skills browse` is still there tomorrow.
         """
         self._rule("Any skills to start with?", step, total)
         self.console.print(Text(
             "  A skill is a written procedure the agent follows when the work "
-            "calls for it.\n  You can add more later with `comodor skills`.\n",
+            "calls for it.\n  Take as many as you like — you can add more "
+            "later with `comodor skills`.\n",
             style=self.theme.style("dim")))
 
         try:
@@ -355,17 +408,15 @@ class SetupWizard:
             self._answered("skills", "none")
             return []
 
-        options = [("__none__", "None for now",
-                    "comodor skills browse, whenever you want them")]
-        options += [(entry.id, entry.id, entry.description)
-                    for entry in catalogue.skills]
+        options = [(entry.id, entry.id, entry.description)
+                   for entry in catalogue.skills]
 
-        chosen = self._choose(options, default=1, title="Skills")
-        if chosen == "__none__":
+        chosen = self._choose_many(options, title="Skills", verb="install")
+        if not chosen:
             self._answered("skills", "none")
             return []
-        self._answered("skills", chosen)
-        return [chosen]
+        self._answered("skills", ", ".join(chosen))
+        return chosen
 
     def _banner(self) -> None:
         body = Text.assemble(

{comodor-0.10.0 → comodor-0.10.2}/src/comodor/ui/chooser.py

@@ -20,6 +20,10 @@ What is here instead is one framed list at a time.
   editor's console, `curl | sh` — the numbered prompt is still there. A setup
   wizard that requires a particular kind of terminal is a setup wizard that
   cannot be scripted.
+* **Some questions take more than one answer.** In that mode each row carries
+  a box, space ticks the one under the cursor, and enter takes everything
+  ticked. The ticks are held by value rather than by row, so filtering the
+  list down and clearing the filter again leaves them where they were.
 """
 
 from __future__ import annotations
@@ -74,7 +78,8 @@ class Chooser:
     """One list, one choice."""
 
     def __init__(self, console: Console, theme: Theme, options: Sequence[Option],
-                 title: str = "", default: int = 0) -> None:
+                 title: str = "", default: int = 0, multi: bool = False,
+                 verb: str = "choose") -> None:
         self.console = console
         self.theme = theme
         self.options = list(options)
@@ -82,6 +87,14 @@ class Chooser:
         self.cursor = max(0, min(default, len(self.options) - 1))
         self.filter = ""
         self.offset = 0
+        #: Whether enter takes one row or every ticked one.
+        self.multi = multi
+        #: What enter is going to do, for the hint line. "install" rather than
+        #: "choose" when that is what happens next.
+        self.verb = verb
+        #: Ticked values, not ticked rows. Filtering changes which options are
+        #: on screen and at which index; it must not change what was asked for.
+        self.picked: set[str] = set()
 
     # -- what is currently visible ---------------------------------------- #
 
@@ -114,28 +127,37 @@ class Chooser:
         self._scroll_into_view()
         visible = items[self.offset:self.offset + window]
 
+        box_width = max(len(theme.glyphs.ticked), len(theme.glyphs.unticked))
+
         table = Table.grid(padding=(0, 1))
         table.add_column(width=2, no_wrap=True)
+        if self.multi:
+            table.add_column(width=box_width, no_wrap=True)
         table.add_column(no_wrap=True)
         table.add_column(overflow="ellipsis")
 
         if not items:
-            table.add_row("", Text("nothing matches", style=theme.style("bad")),
-                          Text(""))
+            blank = ["", Text("nothing matches", style=theme.style("bad")), Text("")]
+            table.add_row(*([blank[0], ""] + blank[1:] if self.multi else blank))
 
         for index, option in enumerate(visible, start=self.offset):
             chosen = index == self.cursor
             # The arrow, not just a colour: a highlighted row that relies on
             # background alone disappears on a terminal that renders it faintly,
             # and this is the only thing on screen saying where you are.
-            table.add_row(
-                Text(theme.glyphs.arrow if chosen else " ",
-                     style=theme.style("accent", bold=True)),
-                Text(option.label,
-                     style=theme.style("accent" if chosen else "value",
-                                       bold=chosen)),
-                Text(option.note, style=theme.style("dim")),
-            )
+            cells = [Text(theme.glyphs.arrow if chosen else " ",
+                          style=theme.style("accent", bold=True))]
+            if self.multi:
+                ticked = option.value in self.picked
+                cells.append(Text(
+                    theme.glyphs.ticked if ticked else theme.glyphs.unticked,
+                    style=theme.style("good" if ticked else "dim",
+                                      bold=ticked)))
+            cells.append(Text(
+                option.label,
+                style=theme.style("accent" if chosen else "value", bold=chosen)))
+            cells.append(Text(option.note, style=theme.style("dim")))
+            table.add_row(*cells)
 
         blocks: list[RenderableType] = []
         above = self.offset
@@ -149,6 +171,9 @@ class Chooser:
         subtitle = None
         if self.filter:
             subtitle = Text(f" filter: {self.filter} ", style=theme.style("accent"))
+        elif self.multi and self.picked:
+            subtitle = Text(f" {len(self.picked)} selected ",
+                            style=theme.style("good"))
         elif len(items) != len(self.options):
             subtitle = Text(f" {len(items)} of {len(self.options)} ",
                             style=theme.style("dim"))
@@ -168,17 +193,36 @@ class Chooser:
 
     def _hint(self) -> Text:
         theme = self.theme
+        # Through the glyph table, like everything else in the frame. Written
+        # as a literal, this line stayed in arrows on a terminal that had just
+        # had its borders downgraded for not being able to draw them.
+        updown = f"{theme.glyphs.rise}{theme.glyphs.fall}"
+        if self.multi:
+            # The count is on the hint rather than only in the corner, because
+            # this is the line that says what enter will do and "install"
+            # without a number is a question.
+            taking = (f"{self.verb} {len(self.picked)}" if self.picked
+                      else f"{self.verb} nothing")
+            keys = ((updown, "move"), ("space", "select"), ("enter", taking),
+                    ("type", "filter"), ("esc", "cancel"))
+        else:
+            keys = ((updown, "move"), ("enter", "choose"),
+                    ("type", "filter"), ("esc", "cancel"))
         hint = Text("  ", style=theme.style("dim"))
-        for key, what in (("↑↓", "move"), ("enter", "choose"),
-                          ("type", "filter"), ("esc", "cancel")):
+        for key, what in keys:
             hint.append(key, style=theme.style("accent"))
             hint.append(f" {what}   ", style=theme.style("dim"))
         return hint
 
     # -- the loop ----------------------------------------------------------- #
 
-    def run(self) -> str | None:
-        """Returns the chosen value, or None if the user backed out."""
+    def run(self) -> str | list[str] | None:
+        """The chosen value, or the chosen values, or None if backed out.
+
+        A list when `multi` is set — possibly an empty one, which is an answer
+        of "none of them" rather than a refusal to answer. None is only ever
+        escape or ctrl-c.
+        """
         from rich.live import Live
 
         items = self.matching
@@ -210,7 +254,18 @@ class Chooser:
         if event.matches("ctrl+c") or event.key == "escape":
             return _CANCEL
         if event.key == "enter":
+            if self.multi:
+                # In the order they were offered, not the order they were
+                # ticked: the list on screen is what the reader remembers.
+                return [option.value for option in self.options
+                        if option.value in self.picked]
             return items[self.cursor].value if items else _CANCEL
+        if self.multi and event.key == "char" and event.char == " " \
+                and not event.ctrl and not event.alt:
+            if items:
+                value = items[self.cursor].value
+                self.picked.symmetric_difference_update({value})
+            return None
 
         if event.key in ("up", "down", "pgup", "pgdn", "home", "end"):
             self._move(event.key, len(items))
@@ -260,10 +315,30 @@ _CANCEL = _Cancel()
 def choose(console: Console, theme: Theme, options: Sequence[Option],
            title: str = "", default: int = 0) -> str | None:
     """The whole interaction, or None if there is no terminal to run it in."""
+    picked = _run(console, theme, options, title=title, default=default)
+    return picked if isinstance(picked, str) else None
+
+
+def choose_many(console: Console, theme: Theme, options: Sequence[Option],
+                title: str = "", verb: str = "choose") -> list[str] | None:
+    """Tick as many as you like. None means the list could not run.
+
+    An empty list is a real answer — nothing ticked, enter pressed — and the
+    caller must tell it apart from None, which means fall back to asking some
+    other way.
+    """
+    picked = _run(console, theme, options, title=title, multi=True, verb=verb)
+    return picked if isinstance(picked, list) else None
+
+
+def _run(console: Console, theme: Theme, options: Sequence[Option],
+         title: str = "", default: int = 0, multi: bool = False,
+         verb: str = "choose") -> str | list[str] | None:
     if not interactive(console) or not options:
         return None
     try:
-        return Chooser(console, theme, options, title=title, default=default).run()
+        return Chooser(console, theme, options, title=title, default=default,
+                       multi=multi, verb=verb).run()
     except Exception:
         # A terminal that will not do raw mode, a reader that will not start:
         # the caller still has the numbered prompt, and a failed experiment

{comodor-0.10.0 → comodor-0.10.2}/src/comodor/ui/console.py

@@ -65,11 +65,27 @@ def force_utf8() -> bool:
 
 
 def supports_unicode() -> bool:
+    """Whether this terminal can encode what the interface actually draws.
+
+    The probe was three box-drawing characters. Those are in cp437 and cp850 -
+    still what a fresh `cmd.exe` gives a lot of people - so the answer came
+    back yes, and then fourteen glyphs those code pages do not have went to
+    the screen: the bullet, the tick, the warning triangle, and the arrow that
+    is the only thing marking which row the cursor is on.
+
+    Built from the glyph table rather than from a literal, so a glyph added
+    later widens the probe by existing rather than by somebody remembering.
+    """
     encoding = (getattr(sys.stdout, "encoding", "") or "").lower()
     if "utf" in encoding:
         return True
+
+    from .theme import Glyphs
+
+    wanted = "─┌│" + "".join(
+        value for value in vars(Glyphs()).values() if isinstance(value, str))
     try:
-        "─┌│".encode(encoding or "ascii")
+        wanted.encode(encoding or "ascii")
         return True
     except (UnicodeEncodeError, LookupError):
         return False

{comodor-0.10.0 → comodor-0.10.2}/src/comodor/ui/theme.py

@@ -227,6 +227,11 @@ class Glyphs:
     arrow: str = "›"
     check: str = "●"
     pending: str = "○"
+    #: A box you can tick, which is a different thing from the filled and
+    #: hollow dots above: those report whether a step has happened, these
+    #: report whether you have asked for something.
+    ticked: str = "☑"
+    unticked: str = "☐"
     active: str = "◐"
     blocked: str = "✗"
     spinner: tuple[str, ...] = ("⠋", "⠙", "⠹", "⠸", "⠼", "⠴", "⠦", "⠧", "⠇", "⠏")
@@ -245,6 +250,7 @@ class Glyphs:
 
 ASCII_GLYPHS = Glyphs(
     bullet="*", arrow=">", check="[x]", pending="[ ]", active="[~]", blocked="[!]",
+    ticked="[x]", unticked="[ ]",
     spinner=("|", "/", "-", "\\"), gauge_full="#", gauge_empty=".", cursor="_",
     divider="-", tool="*", memory="+", warn="!",
     rise="^", fall="v", dot="-", dash="-",

{comodor-0.10.0 → comodor-0.10.2}/src/comodor/ui/widgets/overlay.py

@@ -123,7 +123,7 @@ def render_overlay(overlay: Overlay, width: int, height: int,
         body,
         title=Text(f" {overlay.title} ", style=theme.style("title")),
         title_align="left",
-        subtitle=Text(_footer_hint(overlay), style=theme.style("dim")),
+        subtitle=Text(_footer_hint(overlay, theme), style=theme.style("dim")),
         subtitle_align="right",
         box=theme.heavy_box,
         border_style=theme.style("bad" if overlay.kind == "permission" else "border"),
@@ -134,11 +134,18 @@ def render_overlay(overlay: Overlay, width: int, height: int,
     return Align.center(panel, vertical="middle")
 
 
-def _footer_hint(overlay: Overlay) -> str:
+def _footer_hint(overlay: Overlay, theme: Theme) -> str:
+    """The theme comes in because the arrows do.
+
+    Written as literals, this line stayed in `↑↓` on a terminal that had just
+    had its borders downgraded to `+-|` for being unable to draw them.
+    """
     if overlay.kind == "permission":
         return " y / a / n "
     if overlay.kind == "select":
-        return " ↑↓ select · enter confirm · esc cancel "
+        glyphs = theme.glyphs
+        return (f" {glyphs.rise}{glyphs.fall} select {glyphs.dot} enter confirm "
+                f"{glyphs.dot} esc cancel ")
     return " esc to close "