forestui 0.9.8__tar.gz → 1.0.0__tar.gz

{forestui-0.9.8 → forestui-1.0.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: forestui
-Version: 0.9.8
+Version: 1.0.0
 Summary: A Terminal UI for managing Git worktrees
 Author: cadu
 Keywords: git,terminal,textual,tui,worktree

{forestui-0.9.8 → forestui-1.0.0}/forestui/app.py

@@ -456,12 +456,21 @@ class ForestApp(App[None]):
             return
         try:
             branches = await self._git_service.list_branches(repo.source_path)
+            current_branch = await self._git_service.get_current_branch(
+                repo.source_path
+            )
         except GitError:
             branches = []
+            current_branch = "main"
         settings = self._settings_service.settings
         self.push_screen(
             CreateWorktreeFromIssueModal(
-                repo, issue, branches, get_forest_path(), settings.branch_prefix
+                repo,
+                issue,
+                branches,
+                get_forest_path(),
+                settings.branch_prefix,
+                current_branch,
             )
         )
 
@@ -483,11 +492,26 @@ class ForestApp(App[None]):
                 self.notify("Pulling repo...")
                 await self._git_service.pull(repo.source_path)
 
+            # Get the ref for the base branch before creating
+            base_ref: str | None = None
+            if event.base_branch:
+                base_ref = await self._git_service.get_ref(
+                    repo.source_path, event.base_branch
+                )
+
             await self._git_service.create_worktree(
-                repo.source_path, worktree_path, event.branch, event.new_branch
+                repo.source_path,
+                worktree_path,
+                event.branch,
+                event.new_branch,
+                event.base_branch,
             )
             worktree = Worktree(
-                name=event.name, branch=event.branch, path=str(worktree_path)
+                name=event.name,
+                branch=event.branch,
+                path=str(worktree_path),
+                base_branch=event.base_branch,
+                created_from_ref=base_ref,
             )
             self._state.add_worktree(event.repo_id, worktree)
             self._state.select_worktree(event.repo_id, worktree.id)
@@ -497,6 +521,31 @@ class ForestApp(App[None]):
         except GitError as e:
             self.notify(f"Failed to create worktree: {e}", severity="error")
 
+    @work
+    async def on_create_worktree_from_issue_modal_fetch_requested(
+        self, event: CreateWorktreeFromIssueModal.FetchRequested
+    ) -> None:
+        """Handle fetch request from the create worktree modal."""
+        branches: list[str] = []
+        error: str | None = None
+        try:
+            await self._git_service.fetch(event.repo_path)
+            branches = await self._git_service.list_branches(event.repo_path)
+        except GitError as e:
+            error = str(e)
+
+        # Update the modal - use screen stack to find it
+        for screen in self.screen_stack:
+            if isinstance(screen, CreateWorktreeFromIssueModal):
+                if error:
+                    screen.fetch_failed(error)
+                else:
+                    screen.update_branches(branches)
+                break
+
+        if error:
+            self.notify(f"Fetch failed: {error}", severity="error")
+
     async def on_worktree_detail_archive_worktree_requested(
         self, event: WorktreeDetail.ArchiveWorktreeRequested
     ) -> None:
@@ -610,11 +659,29 @@ class ForestApp(App[None]):
         worktree_path = forest_dir / repo.name / event.name
 
         try:
+            # Determine base branch and get ref before creating
+            if event.new_branch:
+                # New branch stems from HEAD
+                base_branch = await self._git_service.get_current_branch(
+                    repo.source_path
+                )
+                base_ref = await self._git_service.get_ref(repo.source_path, "HEAD")
+            else:
+                # Existing branch - base is the branch itself
+                base_branch = event.branch
+                base_ref = await self._git_service.get_ref(
+                    repo.source_path, event.branch
+                )
+
             await self._git_service.create_worktree(
                 repo.source_path, worktree_path, event.branch, event.new_branch
             )
             worktree = Worktree(
-                name=event.name, branch=event.branch, path=str(worktree_path)
+                name=event.name,
+                branch=event.branch,
+                path=str(worktree_path),
+                base_branch=base_branch,
+                created_from_ref=base_ref,
             )
             self._state.add_worktree(event.repo_id, worktree)
             self._state.select_worktree(event.repo_id, worktree.id)
@@ -784,13 +851,13 @@ class ForestApp(App[None]):
                 return repo.name
         return None
 
-    def _get_claude_window_name(self, path: str) -> str:
-        """Get the window name for Claude sessions: repo:branch format."""
+    def _get_tmux_window_name(self, path: str) -> str:
+        """Get the window name for Claude sessions: repo:worktree format."""
         # Check worktrees first
         for repo in self._state.repositories:
             for worktree in repo.worktrees:
                 if worktree.path == path:
-                    return f"{repo.name}:{worktree.branch}"
+                    return f"{repo.name}:{worktree.name}"
             # Check if it's the repository source path
             if repo.source_path == path:
                 return repo.name
@@ -804,7 +871,7 @@ class ForestApp(App[None]):
         if self._tmux_service.is_inside_tmux and self._tmux_service.is_tui_editor(
             editor
         ):
-            name = self._get_claude_window_name(path)
+            name = self._get_tmux_window_name(path)
             if self._tmux_service.create_editor_window(name, path, editor):
                 self.notify(f"Opened {editor} in edit:{name}")
                 return
@@ -824,7 +891,7 @@ class ForestApp(App[None]):
 
     def _open_in_terminal(self, path: str) -> None:
         """Open path in a tmux terminal window."""
-        name = self._get_claude_window_name(path)
+        name = self._get_tmux_window_name(path)
         if self._tmux_service.create_shell_window(name, path):
             self.notify(f"Opened terminal in term:{name}")
         else:
@@ -832,7 +899,7 @@ class ForestApp(App[None]):
 
     def _open_in_file_manager(self, path: str) -> None:
         """Open path in Midnight Commander (mc) in a tmux window."""
-        name = self._get_claude_window_name(path)
+        name = self._get_tmux_window_name(path)
         if self._tmux_service.create_mc_window(name, path):
             self.notify(f"Opened mc in files:{name}")
         else:
@@ -922,7 +989,7 @@ class ForestApp(App[None]):
 
     def _start_claude_session(self, path: str, yolo: bool = False) -> None:
         """Start a new Claude session in a tmux window."""
-        name = self._get_claude_window_name(path)
+        name = self._get_tmux_window_name(path)
         custom_command = self._resolve_claude_command(path)
         window_name = self._tmux_service.create_claude_window(
             name, path, yolo=yolo, custom_command=custom_command
@@ -937,7 +1004,7 @@ class ForestApp(App[None]):
         self, session_id: str, path: str, yolo: bool = False
     ) -> None:
         """Continue an existing Claude session in a tmux window."""
-        name = self._get_claude_window_name(path)
+        name = self._get_tmux_window_name(path)
         custom_command = self._resolve_claude_command(path)
         window_name = self._tmux_service.create_claude_window(
             name,

{forestui-0.9.8 → forestui-1.0.0}/forestui/components/modals.py

@@ -7,6 +7,8 @@ from textual.app import ComposeResult
 from textual.containers import Horizontal, Vertical, VerticalScroll
 from textual.message import Message
 from textual.screen import ModalScreen
+from textual.suggester import SuggestFromList
+from textual.timer import Timer
 from textual.widgets import Button, Checkbox, Input, Label, Select
 
 from forestui.models import (
@@ -203,10 +205,10 @@ class AddWorktreeModal(ModalScreen[tuple[str, str, bool] | None]):
                 id="input-branch",
             )
 
-            yield Select(
-                [(b, b) for b in self._branches],
-                id="select-branch",
-                prompt="Select a branch...",
+            yield Input(
+                placeholder="Start typing to search branches...",
+                id="input-existing-branch",
+                suggester=SuggestFromList(self._branches, case_sensitive=False),
             )
 
             yield Label("", id="label-error", classes="label-destructive")
@@ -217,11 +219,14 @@ class AddWorktreeModal(ModalScreen[tuple[str, str, bool] | None]):
 
     def on_mount(self) -> None:
         """Set up initial state."""
-        # Hide the select by default
-        self.query_one("#select-branch", Select).display = False
+        # Hide the existing branch input by default (new branch mode)
+        self.query_one("#input-existing-branch", Input).display = False
 
     def on_input_changed(self, event: Input.Changed) -> None:
         """Handle input changes."""
+        # Clear any error when user types
+        self._clear_error()
+
         if event.input.id == "input-name":
             self._name = self._sanitize_name(event.value)
             self._update_path_preview()
@@ -230,13 +235,23 @@ class AddWorktreeModal(ModalScreen[tuple[str, str, bool] | None]):
                 branch_input = self.query_one("#input-branch", Input)
                 branch_input.value = f"{self._branch_prefix}{self._name}"
                 self._branch = branch_input.value
-        elif event.input.id == "input-branch":
+        elif event.input.id in ("input-branch", "input-existing-branch"):
             self._branch = event.value
 
-    def on_select_changed(self, event: Select.Changed) -> None:
-        """Handle select changes."""
-        if event.select.id == "select-branch" and event.value:
-            self._branch = str(event.value)
+        self._update_create_button_state()
+
+    def _clear_error(self) -> None:
+        """Clear the error label."""
+        self.query_one("#label-error", Label).update("")
+
+    def _update_create_button_state(self) -> None:
+        """Enable/disable Create button based on validation."""
+        btn = self.query_one("#btn-create", Button)
+        # For existing branch mode, branch must be in the list
+        if not self._new_branch and self._branch not in self._branches:
+            btn.disabled = True
+        else:
+            btn.disabled = False
 
     def _sanitize_name(self, name: str) -> str:
         """Sanitize worktree name to valid characters."""
@@ -271,29 +286,36 @@ class AddWorktreeModal(ModalScreen[tuple[str, str, bool] | None]):
         new_btn = self.query_one("#btn-new-branch", Button)
         existing_btn = self.query_one("#btn-existing-branch", Button)
         branch_input = self.query_one("#input-branch", Input)
-        branch_select = self.query_one("#select-branch", Select)
+        existing_branch_input = self.query_one("#input-existing-branch", Input)
 
         if new_branch:
             new_btn.variant = "primary"
             existing_btn.variant = "default"
             branch_input.display = True
-            branch_select.display = False
+            existing_branch_input.display = False
         else:
             new_btn.variant = "default"
             existing_btn.variant = "primary"
             branch_input.display = False
-            branch_select.display = True
+            existing_branch_input.display = True
+
+        self._update_create_button_state()
 
     def _create_worktree(self) -> None:
         """Create the worktree if valid."""
         error_label = self.query_one("#label-error", Label)
 
         if not self._name:
-            error_label.update(" Name is required")
+            error_label.update(" Worktree name is required")
             return
 
         if not self._branch:
-            error_label.update(" Branch is required")
+            error_label.update(" Branch name is required")
+            return
+
+        # For existing branch mode, validate the branch exists
+        if not self._new_branch and self._branch not in self._branches:
+            error_label.update(f" Branch '{self._branch}' does not exist")
             return
 
         # Check if worktree path already exists
@@ -484,12 +506,21 @@ class CreateWorktreeFromIssueModal(ModalScreen[tuple[str, str, bool, bool] | Non
             branch: str,
             new_branch: bool,
             pull_first: bool,
+            base_branch: str | None = None,
         ) -> None:
             self.repo_id = repo_id
             self.name = name
             self.branch = branch
             self.new_branch = new_branch
             self.pull_first = pull_first
+            self.base_branch = base_branch
+            super().__init__()
+
+    class FetchRequested(Message):
+        """Request to fetch from remote."""
+
+        def __init__(self, repo_path: str) -> None:
+            self.repo_path = repo_path
             super().__init__()
 
     def __init__(
@@ -499,6 +530,7 @@ class CreateWorktreeFromIssueModal(ModalScreen[tuple[str, str, bool, bool] | Non
         branches: list[str],
         forest_dir: Path,
         branch_prefix: str = "feat/",
+        current_branch: str = "main",
     ) -> None:
         super().__init__()
         self._repository = repository
@@ -506,10 +538,34 @@ class CreateWorktreeFromIssueModal(ModalScreen[tuple[str, str, bool, bool] | Non
         self._branches = branches
         self._forest_dir = forest_dir
         self._branch_prefix = branch_prefix
+        self._current_branch = current_branch
         # Pre-fill from issue
         self._name: str = issue.branch_name
         self._branch: str = f"{branch_prefix}{issue.branch_name}"
         self._pull_first: bool = True
+        # Default base branch: prefer origin/<current> if available
+        self._base_branch: str = self._compute_default_base_branch()
+        self._is_fetching: bool = False
+        # Spinner animation
+        self._spinner_chars = "|/-\\"
+        self._spinner_index = 0
+        self._spinner_timer: Timer | None = None
+
+    def _compute_default_base_branch(self) -> str:
+        """Compute the default base branch, preferring remote version."""
+        # Look for origin/<current_branch> first
+        remote_branch = f"origin/{self._current_branch}"
+        if remote_branch in self._branches:
+            return remote_branch
+        # Try upstream/<current_branch>
+        upstream_branch = f"upstream/{self._current_branch}"
+        if upstream_branch in self._branches:
+            return upstream_branch
+        # Fall back to local current branch
+        if self._current_branch in self._branches:
+            return self._current_branch
+        # Last resort: first branch in list or empty
+        return self._branches[0] if self._branches else ""
 
     def compose(self) -> ComposeResult:
         """Compose the modal UI."""
@@ -533,6 +589,16 @@ class CreateWorktreeFromIssueModal(ModalScreen[tuple[str, str, bool, bool] | Non
                 value=self._branch, id="input-branch", placeholder="feat/branch-name"
             )
 
+            yield Label("Base Branch", classes="section-header")
+            with Horizontal(classes="base-branch-row"):
+                yield Input(
+                    value=self._base_branch,
+                    id="input-base-branch",
+                    placeholder="origin/main",
+                    suggester=SuggestFromList(self._branches, case_sensitive=False),
+                )
+                yield Button("Fetch", id="btn-fetch", variant="default")
+
             yield Checkbox("Pull repo before creating", value=True, id="checkbox-pull")
 
             with Horizontal(classes="modal-buttons"):
@@ -547,6 +613,18 @@ class CreateWorktreeFromIssueModal(ModalScreen[tuple[str, str, bool, bool] | Non
             self.query_one("#path-preview", Label).update(f"Path: {path_preview}")
         elif event.input.id == "input-branch":
             self._branch = event.value
+        elif event.input.id == "input-base-branch":
+            self._base_branch = event.value
+            self._update_create_button_state()
+
+    def _update_create_button_state(self) -> None:
+        """Enable/disable Create button based on base branch validation."""
+        btn = self.query_one("#btn-create", Button)
+        # Base branch must be in the list
+        if self._base_branch and self._base_branch not in self._branches:
+            btn.disabled = True
+        else:
+            btn.disabled = False
 
     def on_checkbox_changed(self, event: Checkbox.Changed) -> None:
         """Handle checkbox changes."""
@@ -557,6 +635,8 @@ class CreateWorktreeFromIssueModal(ModalScreen[tuple[str, str, bool, bool] | Non
         """Handle button presses."""
         if event.button.id == "btn-cancel":
             self.dismiss(None)
+        elif event.button.id == "btn-fetch":
+            self._start_fetch()
         elif event.button.id == "btn-create" and self._name and self._branch:
             self.post_message(
                 self.WorktreeCreated(
@@ -565,10 +645,73 @@ class CreateWorktreeFromIssueModal(ModalScreen[tuple[str, str, bool, bool] | Non
                     self._branch,
                     True,
                     self._pull_first,
+                    self._base_branch,
                 )
             )
             self.dismiss((self._name, self._branch, True, self._pull_first))
 
+    def _start_fetch(self) -> None:
+        """Start fetching from remote."""
+        if self._is_fetching:
+            return
+        self._is_fetching = True
+        self._spinner_index = 0
+        try:
+            btn = self.query_one("#btn-fetch", Button)
+            btn.label = self._spinner_chars[0]
+            btn.disabled = True
+            self._spinner_timer = self.set_interval(0.1, self._tick_spinner)
+        except Exception:
+            pass
+        self.post_message(self.FetchRequested(self._repository.source_path))
+
+    def _tick_spinner(self) -> None:
+        """Advance the spinner animation."""
+        self._spinner_index = (self._spinner_index + 1) % len(self._spinner_chars)
+        try:
+            btn = self.query_one("#btn-fetch", Button)
+            btn.label = self._spinner_chars[self._spinner_index]
+        except Exception:
+            self._stop_spinner()
+
+    def update_branches(self, branches: list[str]) -> None:
+        """Update the branch list after fetch."""
+        self._is_fetching = False
+        self._branches = branches
+        self._reset_fetch_button()
+        try:
+            input_widget = self.query_one("#input-base-branch", Input)
+            # Update the suggester with new branches
+            input_widget.suggester = SuggestFromList(branches, case_sensitive=False)
+            # If current value is empty or not in new list, set to computed default
+            if not self._base_branch or self._base_branch not in branches:
+                self._base_branch = self._compute_default_base_branch()
+                input_widget.value = self._base_branch
+            self._update_create_button_state()
+        except Exception:
+            pass
+
+    def fetch_failed(self, _error: str) -> None:
+        """Handle fetch failure - error is shown via app notification."""
+        self._is_fetching = False
+        self._reset_fetch_button()
+
+    def _stop_spinner(self) -> None:
+        """Stop the spinner animation."""
+        if self._spinner_timer is not None:
+            self._spinner_timer.stop()
+            self._spinner_timer = None
+
+    def _reset_fetch_button(self) -> None:
+        """Reset the fetch button to its default state."""
+        self._stop_spinner()
+        try:
+            btn = self.query_one("#btn-fetch", Button)
+            btn.label = "Fetch"
+            btn.disabled = False
+        except Exception:
+            pass
+
     def action_cancel(self) -> None:
         """Cancel and close the modal."""
         self.dismiss(None)

{forestui-0.9.8 → forestui-1.0.0}/forestui/components/worktree_detail.py

@@ -106,6 +106,12 @@ class WorktreeDetail(Widget):
                     f"Branch:     {self._worktree.branch}",
                     classes="label-accent",
                 )
+                # Base branch info (if available)
+                if self._worktree.base_branch:
+                    base_text = f"Based on:   {self._worktree.base_branch}"
+                    if self._worktree.created_from_ref:
+                        base_text += f" ({self._worktree.created_from_ref})"
+                    yield Label(base_text, classes="label-muted")
                 # Commit info
                 if self._commit_hash:
                     relative_time = (

{forestui-0.9.8 → forestui-1.0.0}/forestui/models.py

@@ -69,6 +69,10 @@ class Worktree(BaseModel):
     sort_order: int | None = None
     last_modified: datetime = Field(default_factory=lambda: datetime.now(UTC))
     custom_claude_command: str | None = None
+    # Branch this worktree was created from (e.g., "origin/main")
+    base_branch: str | None = None
+    # Git commit ref when the worktree was created
+    created_from_ref: str | None = None
 
     @field_validator("custom_claude_command")
     @classmethod

{forestui-0.9.8 → forestui-1.0.0}/forestui/services/git.py

@@ -73,47 +73,130 @@ class GitService:
             raise GitError(f"Failed to get current branch: {stderr}")
         return stdout or "HEAD"
 
-    async def list_branches(self, path: str | Path) -> list[str]:
-        """List all branches (local and remote) for a repository."""
+    async def list_branches(
+        self, path: str | Path, include_remote: bool = True
+    ) -> list[str]:
+        """List branches for a repository.
+
+        Args:
+            path: Repository path
+            include_remote: If True, include remote branches with their prefix (e.g., origin/main)
+        """
         path = Path(path).expanduser()
+
+        # Get list of remotes to identify remote branches
+        remotes = await self._safe_list_remotes(path) if include_remote else []
+
         code, stdout, stderr = await self._run_git(
             "branch", "-a", "--format=%(refname:short)", cwd=path
         )
         if code != 0:
             raise GitError(f"Failed to list branches: {stderr}")
+
         branches = []
+        remote_prefixes = tuple(f"{r}/" for r in remotes)
+        remote_names = set(remotes)
+
         for line in stdout.split("\n"):
             line = line.strip()
-            if line and not line.startswith("origin/HEAD"):
-                # Clean up remote branch names
-                if line.startswith("origin/"):
-                    line = line[7:]
-                if line and line not in branches:
+            if not line or line.endswith("/HEAD"):
+                continue
+            # Skip bare remote names (e.g., "origin" without a branch)
+            if line in remote_names:
+                continue
+            # Check if it's a remote branch
+            is_remote = any(line.startswith(prefix) for prefix in remote_prefixes)
+            if is_remote:
+                if include_remote:
                     branches.append(line)
+            else:
+                branches.append(line)
         return sorted(branches)
 
+    async def list_remotes(self, path: str | Path) -> list[str]:
+        """List remote names for a repository."""
+        path = Path(path).expanduser()
+        code, stdout, stderr = await self._run_git("remote", cwd=path)
+        if code != 0:
+            raise GitError(f"Failed to list remotes: {stderr}")
+        return [r.strip() for r in stdout.split("\n") if r.strip()]
+
+    async def _safe_list_remotes(self, path: str | Path) -> list[str]:
+        """List remotes, returning empty list on error."""
+        try:
+            return await self.list_remotes(path)
+        except GitError:
+            return []
+
     async def create_worktree(
         self,
         repo_path: str | Path,
         worktree_path: str | Path,
         branch: str,
         new_branch: bool = True,
+        base_branch: str | None = None,
     ) -> None:
-        """Create a new worktree."""
+        """Create a new worktree.
+
+        Args:
+            repo_path: Path to the source repository
+            worktree_path: Path where the worktree will be created
+            branch: Branch name (new or existing)
+            new_branch: If True, create a new branch; if False, use existing branch
+            base_branch: Base branch to stem from (only used when new_branch=True)
+        """
         repo_path = Path(repo_path).expanduser()
         worktree_path = Path(worktree_path).expanduser()
 
         # Ensure parent directory exists
         worktree_path.parent.mkdir(parents=True, exist_ok=True)
 
+        # Get remotes to detect remote branches
+        remotes = await self._safe_list_remotes(repo_path)
+
         if new_branch:
-            code, _stdout, stderr = await self._run_git(
-                "worktree", "add", "-b", branch, str(worktree_path), cwd=repo_path
-            )
+            # git worktree add -b <new-branch> <path> [<base-branch>]
+            args = ["worktree", "add", "-b", branch, str(worktree_path)]
+            if base_branch:
+                args.append(base_branch)
+            code, _stdout, stderr = await self._run_git(*args, cwd=repo_path)
+
+            # If base is a remote branch, git may auto-set upstream (branch.autoSetupMerge)
+            # Unset it - new branches should be pushed with `git push -u origin <branch>`
+            if code == 0 and base_branch:
+                is_remote_base = any(base_branch.startswith(f"{r}/") for r in remotes)
+                if is_remote_base:
+                    await self._run_git(
+                        "branch", "--unset-upstream", branch, cwd=worktree_path
+                    )
         else:
-            code, _stdout, stderr = await self._run_git(
-                "worktree", "add", str(worktree_path), branch, cwd=repo_path
-            )
+            # Check if this is a remote branch (e.g., origin/feature-branch)
+            # If so, create a local tracking branch to avoid detached HEAD
+            remote_prefix = None
+            for remote in remotes:
+                if branch.startswith(f"{remote}/"):
+                    remote_prefix = f"{remote}/"
+                    break
+
+            if remote_prefix:
+                # Extract local branch name from remote branch
+                local_branch = branch[len(remote_prefix) :]
+                # git worktree add --track -b <local-branch> <path> <remote-branch>
+                code, _stdout, stderr = await self._run_git(
+                    "worktree",
+                    "add",
+                    "--track",
+                    "-b",
+                    local_branch,
+                    str(worktree_path),
+                    branch,
+                    cwd=repo_path,
+                )
+            else:
+                # Local branch - checkout directly
+                code, _stdout, stderr = await self._run_git(
+                    "worktree", "add", str(worktree_path), branch, cwd=repo_path
+                )
 
         if code != 0:
             raise GitError(f"Failed to create worktree: {stderr}")
@@ -209,6 +292,16 @@ class GitService:
         branches = await self.list_branches(repo_path)
         return branch in branches
 
+    async def get_ref(self, path: str | Path, ref: str = "HEAD") -> str | None:
+        """Get the short commit hash for a ref (branch, tag, or HEAD)."""
+        path = Path(path).expanduser()
+        code, stdout, _stderr = await self._run_git(
+            "rev-parse", "--short", ref, cwd=path
+        )
+        if code != 0:
+            return None
+        return stdout.strip() or None
+
     async def get_latest_commit(self, path: str | Path) -> CommitInfo:
         """Get the latest commit info for a repository."""
         path = Path(path).expanduser()

{forestui-0.9.8 → forestui-1.0.0}/forestui/theme.py

@@ -246,8 +246,8 @@ ModalScreen {
 }
 
 .modal-container {
-    width: 60;
-    max-width: 80%;
+    width: 80;
+    max-width: 90%;
     height: auto;
     max-height: 90%;
     background: $bg-elevated;
@@ -521,6 +521,21 @@ Container {
     margin-right: 1;
 }
 
+/* Base branch row in modal */
+.base-branch-row {
+    height: 3;
+    width: 100%;
+}
+
+.base-branch-row Input {
+    width: 1fr;
+}
+
+.base-branch-row Button {
+    min-width: 10;
+    margin-left: 1;
+}
+
 /* Branch tag */
 .branch-tag {
     background: $accent-dark;

{forestui-0.9.8 → forestui-1.0.0}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "forestui"
-version = "0.9.8"
+version = "1.0.0"
 description = "A Terminal UI for managing Git worktrees"
 readme = "README.md"
 requires-python = ">=3.14"