tasktree-manager 2.3.0__tar.gz → 2.5.0__tar.gz

{tasktree_manager-2.3.0 → tasktree_manager-2.5.0}/CHANGELOG.md

@@ -15,6 +15,18 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 - Git hooks support
 - Custom task metadata
 
+## [2.5.0] - 2026-06-10
+
+### Added
+- Searchable app actions in the command palette (#7)
+
+
+## [2.4.0] - 2026-06-10
+
+### Added
+- Context-sensitive footer showing the focused panel's keys (#6)
+
+
 ## [2.3.0] - 2026-06-10
 
 ### Added

{tasktree_manager-2.3.0 → tasktree_manager-2.5.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: tasktree-manager
-Version: 2.3.0
+Version: 2.5.0
 Summary: TUI application for managing worktree-based tasks
 License-File: LICENSE
 Requires-Python: >=3.10

{tasktree_manager-2.3.0 → tasktree_manager-2.5.0}/docs/user-guide.md

@@ -246,6 +246,12 @@ Shows detailed git status for the selected worktree:
 
 All keybindings can be customized in [`config.toml`](configuration.md).
 
+The footer is context-sensitive, lazygit-style: it shows the actions for the
+focused panel (task actions in the Task List, worktree/git actions in the
+Worktree List) plus the always-available `r` Refresh, `?` Help, and `q` Quit.
+Every key works regardless of which panel has focus — the footer only changes
+what is displayed. Press `?` for the full reference at any time.
+
 ### Navigation
 
 | Key        | Action                      | Description                                      |
@@ -358,7 +364,7 @@ Useful when you're spinning up several similar tasks that share the same set of
 
 | Key     | Action                  | Description                                  |
 |---------|-------------------------|----------------------------------------------|
-| `Ctrl+P`| Open Command Palette    | Switch themes and run commands               |
+| `Ctrl+P`| Open Command Palette    | Search and run any action (hotkeys shown), switch themes |
 | `o`     | Open folder             | Open current folder in new terminal tab      |
 | `m`     | Toggle messages         | Show/hide the activity messages panel        |
 | `?`     | Show help               | Display help modal with keybindings          |

{tasktree_manager-2.3.0 → tasktree_manager-2.5.0}/pyproject.toml

@@ -70,7 +70,7 @@ version-file = "tasktree_manager/_version.py"
 # Semantic Release Configuration
 [tool.semantic_release]
 version_toml = ["pyproject.toml:tool.semantic_release.version"]
-version = "2.3.0"
+version = "2.5.0"
 tag_format = "v{version}"
 branch = "main"
 commit_message = "chore(release): {version} [skip ci]"

{tasktree_manager-2.3.0 → tasktree_manager-2.5.0}/tasktree_manager/_version.py

@@ -18,7 +18,7 @@ version_tuple: tuple[int | str, ...]
 commit_id: str | None
 __commit_id__: str | None
 
-__version__ = version = '2.3.0'
-__version_tuple__ = version_tuple = (2, 3, 0)
+__version__ = version = '2.5.0'
+__version_tuple__ = version_tuple = (2, 5, 0)
 
 __commit_id__ = commit_id = None

{tasktree_manager-2.3.0 → tasktree_manager-2.5.0}/tasktree_manager/app.py

@@ -10,6 +10,7 @@ from textual.binding import Binding
 from textual.containers import Horizontal, Vertical
 from textual.widgets import Footer, Header, Static
 
+from .commands import TaskTreeCommands
 from .services.claude_hooks import ensure_claude_hooks, has_claude_session
 from .services.config import Config
 from .services.git_ops import GitOps
@@ -35,6 +36,10 @@ class TaskTreeApp(App):
 
     TITLE = "tasktree-manager"
 
+    # System commands plus all keybound tasktree actions (searchable by
+    # name, displayed with their configured hotkey)
+    COMMANDS = App.COMMANDS | {TaskTreeCommands}
+
     CSS = """
     /* Main layout */
     Screen {
@@ -210,19 +215,21 @@ class TaskTreeApp(App):
     }
     """
 
-    # Default bindings - will be overridden in __init__ with config values
-    # Footer order: n, a, d, g, o, c, p, r, m, q, ?
-    # Uppercase shown only when shift is pressed: C, P, S
+    # Default bindings - will be overridden in __init__ with config values.
+    # The footer is context-sensitive: app-level bindings keep every key
+    # working globally but stay hidden, except the always-visible globals
+    # (refresh/help/quit). The focused panel contributes its own visible
+    # bindings (see compose), lazygit-style.
     BINDINGS = [
-        Binding("n", "new_task", "New Task"),
-        Binding("y", "clone_task", "Clone Task"),
-        Binding("a", "add_repo", "Add Repo"),
-        Binding("d", "delete_task", "Delete Task"),
-        Binding("g", "open_lazygit", "Lazygit"),
-        Binding("e", "open_editor", "Editor"),
-        Binding("o", "open_folder", "Open"),
-        Binding("c", "open_claude_resume", "Claude"),
-        Binding("p", "push_all", "Push All"),
+        Binding("n", "new_task", "New", show=False),
+        Binding("y", "clone_task", "Clone", show=False),
+        Binding("a", "add_repo", "Add Repo", show=False),
+        Binding("d", "delete_task", "Delete", show=False),
+        Binding("g", "open_lazygit", "Lazygit", show=False),
+        Binding("e", "open_editor", "Editor", show=False),
+        Binding("o", "open_folder", "Open", show=False),
+        Binding("c", "open_claude_resume", "Claude", show=False),
+        Binding("p", "push_all", "Push", show=False),
         Binding("r", "refresh", "Refresh"),
         Binding("m", "toggle_messages", "Messages"),
         Binding("q", "quit", "Quit"),
@@ -231,7 +238,7 @@ class TaskTreeApp(App):
         Binding("C", "open_claude_gui_code", "Claude GUI", show=False),
         Binding("P", "pull_all", "Pull All", show=False),
         Binding("S", "toggle_grouping", "Group", show=False),
-        Binding("D", "delete_worktree", "Del Worktree", show=False),
+        Binding("D", "delete_worktree", "Del WT", show=False),
         Binding("tab", "focus_next", "Next Panel", show=False),
         Binding("shift+tab", "focus_previous", "Prev Panel", show=False),
         Binding("j", "cursor_down", "Down", show=False),
@@ -264,24 +271,26 @@ class TaskTreeApp(App):
         self._last_tasks_fingerprint: tuple | None = None
 
     def _build_bindings_from_config(self) -> list[Binding]:
-        """Build keybindings list from config.
+        """Build app-level keybindings from config.
+
+        Every key works globally regardless of focus, but only the global
+        actions (refresh/help/quit) are shown in the footer; the focused
+        panel contributes its own visible bindings (see compose).
 
         Returns:
             List of Binding objects with keys from config
         """
         kb = self.config.keybindings
-        # Footer order: n, a, d, g, o, c, p, r, m, q, ?
-        # Uppercase shown only when shift is pressed: C, P, S
         return [
-            Binding(kb.get("new_task", "n"), "new_task", "New Task"),
-            Binding(kb.get("clone_task", "y"), "clone_task", "Clone Task"),
-            Binding(kb.get("add_repo", "a"), "add_repo", "Add Repo"),
-            Binding(kb.get("delete_task", "d"), "delete_task", "Delete Task"),
-            Binding(kb.get("open_lazygit", "g"), "open_lazygit", "Lazygit"),
-            Binding(kb.get("open_editor", "e"), "open_editor", "Editor"),
-            Binding(kb.get("open_folder", "o"), "open_folder", "Open"),
-            Binding(kb.get("open_claude_resume", "c"), "open_claude_resume", "Claude"),
-            Binding(kb.get("push_all", "p"), "push_all", "Push All"),
+            Binding(kb.get("new_task", "n"), "new_task", "New", show=False),
+            Binding(kb.get("clone_task", "y"), "clone_task", "Clone", show=False),
+            Binding(kb.get("add_repo", "a"), "add_repo", "Add Repo", show=False),
+            Binding(kb.get("delete_task", "d"), "delete_task", "Delete", show=False),
+            Binding(kb.get("open_lazygit", "g"), "open_lazygit", "Lazygit", show=False),
+            Binding(kb.get("open_editor", "e"), "open_editor", "Editor", show=False),
+            Binding(kb.get("open_folder", "o"), "open_folder", "Open", show=False),
+            Binding(kb.get("open_claude_resume", "c"), "open_claude_resume", "Claude", show=False),
+            Binding(kb.get("push_all", "p"), "push_all", "Push", show=False),
             Binding(kb.get("refresh", "r"), "refresh", "Refresh"),
             Binding(kb.get("toggle_messages", "m"), "toggle_messages", "Messages"),
             Binding(kb.get("quit", "q"), "quit", "Quit"),
@@ -295,7 +304,7 @@ class TaskTreeApp(App):
             ),
             Binding(kb.get("pull_all", "P"), "pull_all", "Pull All", show=False),
             Binding(kb.get("toggle_grouping", "S"), "toggle_grouping", "Group", show=False),
-            Binding(kb.get("delete_worktree", "D"), "delete_worktree", "Del Worktree", show=False),
+            Binding(kb.get("delete_worktree", "D"), "delete_worktree", "Del WT", show=False),
             Binding(kb.get("focus_next", "tab"), "focus_next", "Next Panel", show=False),
             Binding(
                 kb.get("focus_previous", "shift+tab"), "focus_previous", "Prev Panel", show=False
@@ -312,16 +321,37 @@ class TaskTreeApp(App):
 
     def compose(self) -> ComposeResult:
         """Compose the app layout."""
+        kb = self.config.keybindings
+        # Footer bindings shown only while the respective panel has focus.
+        # The keys themselves also exist app-level (hidden) so they work
+        # regardless of focus; these entries only add footer visibility.
+        task_panel_bindings = [
+            (kb.get("new_task", "n"), "new_task", "New"),
+            (kb.get("clone_task", "y"), "clone_task", "Clone"),
+            (kb.get("add_repo", "a"), "add_repo", "Add Repo"),
+            (kb.get("delete_task", "d"), "delete_task", "Delete"),
+            (kb.get("open_claude_resume", "c"), "open_claude_resume", "Claude"),
+            (kb.get("cycle_sort", "s"), "cycle_sort", "Sort"),
+        ]
+        worktree_panel_bindings = [
+            (kb.get("open_lazygit", "g"), "open_lazygit", "Lazygit"),
+            (kb.get("open_editor", "e"), "open_editor", "Editor"),
+            (kb.get("open_folder", "o"), "open_folder", "Open"),
+            (kb.get("open_shell", "enter"), "open_shell", "Shell"),
+            (kb.get("push_all", "p"), "push_all", "Push"),
+            (kb.get("delete_worktree", "D"), "delete_worktree", "Del WT"),
+        ]
+
         yield Header()
         with Horizontal(id="main-container"):
             # Left column: Tasks (top) and Worktrees (bottom)
             with Vertical(id="left-column"):
                 with Vertical(id="task-panel"):
                     yield Static("Tasks", classes="panel-title", id="task-panel-title")
-                    yield TaskList(id="task-list")
+                    yield TaskList(id="task-list", context_bindings=task_panel_bindings)
                 with Vertical(id="worktree-panel"):
                     yield Static("Worktrees", classes="panel-title", id="worktree-panel-title")
-                    yield WorktreeList(id="worktree-list")
+                    yield WorktreeList(id="worktree-list", context_bindings=worktree_panel_bindings)
             # Right column: Info/Status panel
             with Vertical(id="right-column"):
                 with Vertical(id="status-panel"):

tasktree_manager-2.5.0/tasktree_manager/commands.py

@@ -0,0 +1,69 @@
+"""Command palette provider for tasktree-manager actions."""
+
+from functools import partial
+
+from textual.command import DiscoveryHit, Hit, Hits, Provider
+
+# (action, title, help) for every keybound app action. The key for each
+# action is looked up from the app's config at search time so customized
+# keybindings display correctly.
+APP_COMMANDS: list[tuple[str, str, str]] = [
+    ("new_task", "New Task", "Create a new task with worktrees"),
+    ("clone_task", "Clone Task", "Create a new task with the same repos as the current one"),
+    ("add_repo", "Add Repo", "Add repositories to the current task"),
+    ("delete_task", "Delete Task", "Delete the current task (with safety checks)"),
+    ("delete_worktree", "Delete Worktree", "Delete the selected worktree from the task"),
+    ("open_lazygit", "Open Lazygit", "Open lazygit in the selected worktree"),
+    ("open_editor", "Open Editor", "Open your editor in the focused task/worktree folder"),
+    ("open_folder", "Open Folder", "Open the focused folder in a new terminal tab"),
+    ("open_shell", "Open Shell", "Open a shell in the selected worktree"),
+    ("open_claude_resume", "Open Claude", "Open Claude Code for the task (resume if possible)"),
+    (
+        "open_claude_gui_code",
+        "Open Claude Desktop",
+        "Open the Claude desktop app on the Code page",
+    ),
+    ("push_all", "Push All", "Push all worktrees in the current task"),
+    ("pull_all", "Pull All", "Pull all worktrees in the current task"),
+    ("refresh", "Refresh", "Refresh git status for all tasks"),
+    ("toggle_messages", "Toggle Messages", "Show or hide the activity messages panel"),
+    ("toggle_grouping", "Toggle Grouping", "Group worktrees by dirty/clean status"),
+    ("cycle_sort", "Cycle Sort", "Cycle through task sort modes"),
+    ("help", "Help", "Show the keybinding reference"),
+    ("quit", "Quit", "Exit tasktree-manager"),
+]
+
+
+class TaskTreeCommands(Provider):
+    """Expose all keybound tasktree actions in the command palette."""
+
+    def _entries(self):
+        """Yield (display title with hotkey, action, help) tuples."""
+        config = getattr(self.app, "config", None)
+        keybindings = config.keybindings if config else {}
+        for action, title, help_text in APP_COMMANDS:
+            key = keybindings.get(action, "")
+            display = f"{title} ({key})" if key else title
+            yield display, action, help_text
+
+    async def discover(self) -> Hits:
+        """List all commands when the palette opens with an empty query."""
+        for display, action, help_text in self._entries():
+            yield DiscoveryHit(
+                display,
+                partial(self.app.run_action, action),
+                help=help_text,
+            )
+
+    async def search(self, query: str) -> Hits:
+        """Fuzzy-match commands against the query."""
+        matcher = self.matcher(query)
+        for display, action, help_text in self._entries():
+            score = matcher.match(display)
+            if score > 0:
+                yield Hit(
+                    score,
+                    matcher.highlight(display),
+                    partial(self.app.run_action, action),
+                    help=help_text,
+                )

{tasktree_manager-2.3.0 → tasktree_manager-2.5.0}/tasktree_manager/widgets/task_list.py

@@ -45,12 +45,26 @@ class TaskList(OptionList):
             self.label = label
             super().__init__()
 
-    def __init__(self, *args, **kwargs):
+    def __init__(
+        self,
+        *args,
+        context_bindings: list[tuple[str, str, str]] | None = None,
+        **kwargs,
+    ):
         super().__init__(*args, **kwargs)
         self.tasks: list[Task] = []
         self._sort_mode: SortMode = SortMode.NAME_ASC
         # Last known Claude session statuses, kept so indicators survive reloads
         self._claude_statuses: dict[str, str] = {}
+        # Footer-visible (key, app action, description) bindings shown while
+        # this panel has focus; the keys also exist app-level (hidden) so
+        # they keep working regardless of focus
+        for key, action, description in context_bindings or []:
+            # Drop any inherited binding on the same key - dispatch and the
+            # footer both use the first binding found, so an OptionList
+            # default (e.g. "enter") would otherwise shadow the app action
+            self._bindings.key_to_bindings.pop(key, None)
+            self._bindings.bind(key, f"app.{action}", description, show=True)
 
     @property
     def index(self) -> int | None:

{tasktree_manager-2.3.0 → tasktree_manager-2.5.0}/tasktree_manager/widgets/worktree_list.py

@@ -31,12 +31,25 @@ class WorktreeList(OptionList):
             self.enabled = enabled
             super().__init__()
 
-    def __init__(self, *args, **kwargs):
+    def __init__(
+        self,
+        *args,
+        context_bindings: list[tuple[str, str, str]] | None = None,
+        **kwargs,
+    ):
         super().__init__(*args, **kwargs)
         self.worktrees: list[Worktree] = []
         self._grouping_enabled: bool = False
         # Maps option index to worktree index (for handling headers)
         self._option_to_worktree: dict[int, int] = {}
+        # Footer-visible (key, app action, description) bindings shown while
+        # this panel has focus; the keys also exist app-level (hidden) so
+        # they keep working regardless of focus. Replacing "enter" here also
+        # fixes shell opening: OptionList's own select binding used to
+        # swallow the key before the app's open_shell binding could see it.
+        for key, action, description in context_bindings or []:
+            self._bindings.key_to_bindings.pop(key, None)
+            self._bindings.bind(key, f"app.{action}", description, show=True)
 
     @property
     def index(self) -> int | None:

{tasktree_manager-2.3.0 → tasktree_manager-2.5.0}/tests/test_app.py

@@ -570,3 +570,97 @@ class TestAppConfiguration:
         from tasktree_manager.services.git_ops import GitOps
 
         assert GitOps.network_timeout == app.config.git_timeout
+
+
+class TestContextSensitiveFooter:
+    """Tests for the context-sensitive footer bindings."""
+
+    @staticmethod
+    def _shown_actions(app) -> set[str]:
+        """Actions currently visible in the footer."""
+        return {
+            active.binding.action
+            for active in app.screen.active_bindings.values()
+            if active.binding.show
+        }
+
+    async def test_task_panel_footer_shows_task_actions(self, app, sample_repo, task_manager):
+        """Task list focused: task actions plus globals are visible."""
+        repo_path, branch = sample_repo
+        task_manager.create_task("FOOTER-TASKS", ["sample-repo"], branch)
+
+        async with app.run_test() as pilot:
+            await pilot.pause()
+
+            assert app.focused.id == "task-list"
+            shown = self._shown_actions(app)
+            assert "app.new_task" in shown
+            assert "app.clone_task" in shown
+            assert "app.delete_task" in shown
+            # Worktree-context actions are hidden in this context
+            assert "app.open_lazygit" not in shown
+            assert "app.open_shell" not in shown
+            # Globals always visible
+            assert "refresh" in shown
+            assert "toggle_messages" in shown
+            assert "help" in shown
+            assert "quit" in shown
+
+    async def test_worktree_panel_footer_shows_worktree_actions(
+        self, app, sample_repo, task_manager
+    ):
+        """Worktree list focused: worktree actions plus globals are visible."""
+        repo_path, branch = sample_repo
+        task_manager.create_task("FOOTER-WT", ["sample-repo"], branch)
+
+        async with app.run_test() as pilot:
+            await pilot.pause()
+            await pilot.press("tab")
+            await pilot.pause()
+
+            assert app.focused.id == "worktree-list"
+            shown = self._shown_actions(app)
+            assert "app.open_lazygit" in shown
+            assert "app.open_shell" in shown
+            assert "app.push_all" in shown
+            # Task-context actions are hidden in this context
+            assert "app.new_task" not in shown
+            # Globals always visible
+            assert "refresh" in shown
+            assert "quit" in shown
+
+    async def test_keys_work_outside_their_panel(self, app, sample_repos, task_manager):
+        """A task-context key still works while the worktree list is focused."""
+        _, branch = sample_repos
+        task_manager.create_task("FOOTER-KEYS", ["repo-alpha"], branch)
+
+        async with app.run_test() as pilot:
+            await pilot.pause()
+            await pilot.press("tab")  # focus worktree list
+            await pilot.pause()
+
+            # 'n' is a task-panel binding but must still open the modal
+            await pilot.press("n")
+            await pilot.pause()
+
+            create_modals = [s for s in app.screen_stack if isinstance(s, CreateTaskModal)]
+            assert len(create_modals) == 1
+
+    async def test_enter_opens_shell_from_worktree_list(
+        self, app, sample_repo, task_manager, monkeypatch
+    ):
+        """Enter on the worktree list triggers open_shell (was swallowed by select)."""
+        repo_path, branch = sample_repo
+        task_manager.create_task("FOOTER-ENTER", ["sample-repo"], branch)
+
+        called = []
+        monkeypatch.setattr(app, "action_open_shell", lambda: called.append(True))
+
+        async with app.run_test() as pilot:
+            await pilot.pause()
+            await pilot.press("tab")
+            await pilot.pause()
+            await pilot.press("enter")
+            await pilot.pause()
+
+        assert called

tasktree_manager-2.5.0/tests/test_commands.py

@@ -0,0 +1,55 @@
+"""Tests for the command palette provider."""
+
+from tasktree_manager.app import TaskTreeApp
+from tasktree_manager.commands import APP_COMMANDS, TaskTreeCommands
+
+
+class TestTaskTreeCommands:
+    """Tests for the TaskTreeCommands palette provider."""
+
+    async def test_app_registers_provider(self, app):
+        """The app exposes the provider alongside the system commands."""
+        assert TaskTreeCommands in TaskTreeApp.COMMANDS
+
+    async def test_discover_lists_all_commands(self, app):
+        """Opening the palette with an empty query lists every action."""
+        async with app.run_test() as pilot:
+            await pilot.pause()
+
+            provider = TaskTreeCommands(app.screen)
+            hits = [hit async for hit in provider.discover()]
+
+            assert len(hits) == len(APP_COMMANDS)
+
+    async def test_search_finds_action_with_hotkey(self, app):
+        """Searching shows the matching command with its hotkey."""
+        async with app.run_test() as pilot:
+            await pilot.pause()
+
+            provider = TaskTreeCommands(app.screen)
+            hits = [hit async for hit in provider.search("lazygit")]
+
+            assert hits
+            assert any("(g)" in str(hit.match_display) for hit in hits)
+
+    async def test_search_shows_customized_key(self, app):
+        """A remapped keybinding shows the configured key, not the default."""
+        app.config.keybindings["push_all"] = "x"
+
+        async with app.run_test() as pilot:
+            await pilot.pause()
+
+            provider = TaskTreeCommands(app.screen)
+            hits = [hit async for hit in provider.search("push all")]
+
+            assert any("(x)" in str(hit.match_display) for hit in hits)
+
+    async def test_search_no_match_returns_nothing(self, app):
+        """A nonsense query yields no hits."""
+        async with app.run_test() as pilot:
+            await pilot.pause()
+
+            provider = TaskTreeCommands(app.screen)
+            hits = [hit async for hit in provider.search("zzz-no-such-command")]
+
+            assert hits == []