forestui 0.9.0__py3-none-any.whl

forestui/components/worktree_detail.py

@@ -0,0 +1,326 @@
+"""Worktree detail view component."""
+
+from datetime import datetime
+from uuid import UUID
+
+import humanize
+from textual.app import ComposeResult
+from textual.containers import Horizontal, Vertical
+from textual.message import Message
+from textual.widget import Widget
+from textual.widgets import Button, Input, Label, Rule
+
+from forestui.components.messages import (
+    ConfigureClaudeCommand,
+    ContinueClaudeSession,
+    ContinueClaudeYoloSession,
+    OpenInEditor,
+    OpenInFileManager,
+    OpenInTerminal,
+    StartClaudeSession,
+    StartClaudeYoloSession,
+)
+from forestui.models import ClaudeSession, Repository, Worktree
+
+
+class WorktreeDetail(Widget):
+    """Detail view for a selected worktree."""
+
+    class ArchiveWorktreeRequested(Message):
+        """Request to archive the worktree."""
+
+        def __init__(self, worktree_id: UUID) -> None:
+            self.worktree_id = worktree_id
+            super().__init__()
+
+    class UnarchiveWorktreeRequested(Message):
+        """Request to unarchive the worktree."""
+
+        def __init__(self, worktree_id: UUID) -> None:
+            self.worktree_id = worktree_id
+            super().__init__()
+
+    class DeleteWorktreeRequested(Message):
+        """Request to delete the worktree."""
+
+        def __init__(self, repo_id: UUID, worktree_id: UUID) -> None:
+            self.repo_id = repo_id
+            self.worktree_id = worktree_id
+            super().__init__()
+
+    class RenameWorktreeRequested(Message):
+        """Request to rename the worktree."""
+
+        def __init__(self, worktree_id: UUID, new_name: str) -> None:
+            self.worktree_id = worktree_id
+            self.new_name = new_name
+            super().__init__()
+
+    class RenameBranchRequested(Message):
+        """Request to rename the branch."""
+
+        def __init__(self, worktree_id: UUID, new_branch: str) -> None:
+            self.worktree_id = worktree_id
+            self.new_branch = new_branch
+            super().__init__()
+
+    class SyncRequested(Message):
+        """Request to sync (fetch/pull) the worktree."""
+
+        def __init__(self, worktree_id: UUID, path: str) -> None:
+            self.worktree_id = worktree_id
+            self.path = path
+            super().__init__()
+
+    def __init__(
+        self,
+        repository: Repository,
+        worktree: Worktree,
+        commit_hash: str = "",
+        commit_time: datetime | None = None,
+        has_remote: bool = True,
+    ) -> None:
+        super().__init__()
+        self._repository = repository
+        self._worktree = worktree
+        self._commit_hash = commit_hash
+        self._commit_time = commit_time
+        self._has_remote = has_remote
+        self._sessions: list[ClaudeSession] = []
+
+    def compose(self) -> ComposeResult:
+        """Compose the worktree detail view."""
+        with Vertical(classes="detail-content"):
+            # Header - Worktree
+            with Vertical(classes="detail-header"):
+                yield Label("WORKTREE", classes="section-header")
+                yield Label(
+                    f"Repository: {self._repository.name}",
+                    classes="detail-title",
+                )
+                yield Label(
+                    f"Worktree:   {self._worktree.name}",
+                    classes="label-primary",
+                )
+                yield Label(
+                    f"Branch:     {self._worktree.branch}",
+                    classes="label-accent",
+                )
+                # Commit info
+                if self._commit_hash:
+                    relative_time = (
+                        humanize.naturaltime(self._commit_time)
+                        if self._commit_time
+                        else ""
+                    )
+                    commit_text = f"Commit:     {self._commit_hash}"
+                    if relative_time:
+                        commit_text += f" ({relative_time})"
+                    yield Label(commit_text, classes="label-muted")
+                # Sync button
+                with Horizontal(classes="action-row"):
+                    if self._has_remote:
+                        yield Button("⟳ Git Pull", id="btn-sync", variant="default")
+                    else:
+                        yield Button(
+                            "⟳ Git Pull (No remote)",
+                            id="btn-sync",
+                            variant="default",
+                            disabled=True,
+                        )
+
+            yield Rule()
+
+            # Location section
+            yield Label("LOCATION", classes="section-header")
+            yield Label(
+                self._worktree.path,
+                classes="path-display label-secondary",
+            )
+
+            yield Rule()
+
+            # Actions section
+            yield Label("OPEN IN", classes="section-header")
+            with Horizontal(classes="action-row"):
+                yield Button(" Editor", id="btn-editor", variant="default")
+                yield Button(" Terminal", id="btn-terminal", variant="default")
+                yield Button(" Files", id="btn-files", variant="default")
+
+            yield Rule()
+
+            # Claude section
+            yield Label("CLAUDE", classes="section-header")
+            with Horizontal(classes="action-row"):
+                yield Button("New Session", id="btn-claude-new", variant="primary")
+                yield Button(
+                    "New Session: YOLO",
+                    id="btn-claude-yolo",
+                    variant="error",
+                    classes="-destructive",
+                )
+
+            # Sessions list (loaded async)
+            yield Label("RECENT SESSIONS", classes="section-header")
+            with Vertical(id="sessions-container"):
+                yield Label("Loading...", classes="label-muted")
+
+            yield Rule()
+
+            # Rename section
+            yield Label("RENAME", classes="section-header")
+            with Horizontal(classes="action-row"):
+                yield Input(
+                    value=self._worktree.name,
+                    placeholder="Worktree name",
+                    id="input-worktree-name",
+                )
+            with Horizontal(classes="action-row"):
+                yield Input(
+                    value=self._worktree.branch,
+                    placeholder="Branch name",
+                    id="input-branch-name",
+                )
+
+            yield Rule()
+
+            # Manage section
+            yield Label("MANAGE", classes="section-header")
+            with Horizontal(classes="action-row"):
+                yield Button(
+                    " Custom Claude Command",
+                    id="btn-configure-claude",
+                    variant="default",
+                )
+                if self._worktree.is_archived:
+                    yield Button(
+                        " Unarchive",
+                        id="btn-unarchive",
+                        variant="default",
+                    )
+                else:
+                    yield Button(
+                        " Archive",
+                        id="btn-archive",
+                        variant="default",
+                    )
+                yield Button(
+                    " Delete",
+                    id="btn-delete",
+                    variant="error",
+                    classes="-destructive",
+                )
+
+    def on_button_pressed(self, event: Button.Pressed) -> None:
+        """Handle button presses."""
+        path = self._worktree.path
+        btn_id = event.button.id or ""
+
+        match btn_id:
+            case "btn-editor":
+                self.post_message(OpenInEditor(path))
+            case "btn-terminal":
+                self.post_message(OpenInTerminal(path))
+            case "btn-files":
+                self.post_message(OpenInFileManager(path))
+            case "btn-claude-new":
+                self.post_message(StartClaudeSession(path))
+            case "btn-claude-yolo":
+                self.post_message(StartClaudeYoloSession(path))
+            case "btn-configure-claude":
+                self.post_message(
+                    ConfigureClaudeCommand(self._repository.id, self._worktree.id)
+                )
+            case "btn-archive":
+                self.post_message(self.ArchiveWorktreeRequested(self._worktree.id))
+            case "btn-unarchive":
+                self.post_message(self.UnarchiveWorktreeRequested(self._worktree.id))
+            case "btn-delete":
+                self.post_message(
+                    self.DeleteWorktreeRequested(self._repository.id, self._worktree.id)
+                )
+            case "btn-sync":
+                self.post_message(self.SyncRequested(self._worktree.id, path))
+            case _ if btn_id.startswith("btn-resume-"):
+                session_id = btn_id.replace("btn-resume-", "")
+                self.post_message(ContinueClaudeSession(session_id, path))
+            case _ if btn_id.startswith("btn-yolo-"):
+                session_id = btn_id.replace("btn-yolo-", "")
+                self.post_message(ContinueClaudeYoloSession(session_id, path))
+
+    def on_input_submitted(self, event: Input.Submitted) -> None:
+        """Handle input submission."""
+        match event.input.id:
+            case "input-worktree-name":
+                if event.value and event.value != self._worktree.name:
+                    self.post_message(
+                        self.RenameWorktreeRequested(self._worktree.id, event.value)
+                    )
+            case "input-branch-name":
+                if event.value and event.value != self._worktree.branch:
+                    self.post_message(
+                        self.RenameBranchRequested(self._worktree.id, event.value)
+                    )
+
+    def update_sessions(self, sessions: list[ClaudeSession]) -> None:
+        """Update the sessions section with fetched sessions."""
+        self._sessions = sessions
+
+        try:
+            container = self.query_one("#sessions-container", Vertical)
+            container.remove_children()
+
+            if sessions:
+                for session in sessions[:5]:
+                    title_display = session.title[:60] + (
+                        "..." if len(session.title) > 60 else ""
+                    )
+
+                    # Build session info widgets
+                    info_children: list[Label] = [
+                        Label(title_display, classes="session-title")
+                    ]
+
+                    if session.last_message and session.last_message != session.title:
+                        last_display = session.last_message[:40] + (
+                            "..." if len(session.last_message) > 40 else ""
+                        )
+                        info_children.append(
+                            Label(
+                                f"> {last_display}",
+                                classes="session-last label-secondary",
+                            )
+                        )
+
+                    meta = f"{session.relative_time} • {session.message_count} msgs"
+                    info_children.append(
+                        Label(meta, classes="session-meta label-muted")
+                    )
+
+                    row = Vertical(
+                        Horizontal(
+                            Vertical(*info_children, classes="session-info"),
+                            Horizontal(
+                                Button(
+                                    "Resume",
+                                    id=f"btn-resume-{session.id}",
+                                    variant="default",
+                                    classes="session-btn",
+                                ),
+                                Button(
+                                    "YOLO",
+                                    id=f"btn-yolo-{session.id}",
+                                    variant="error",
+                                    classes="session-btn -destructive",
+                                ),
+                                classes="session-buttons",
+                            ),
+                            classes="session-header-row",
+                        ),
+                        classes="session-item",
+                    )
+                    container.mount(row)
+            else:
+                container.mount(Label("No sessions found", classes="label-muted"))
+        except Exception:
+            pass  # Widget may have been removed

forestui/models.py

@@ -0,0 +1,221 @@
+"""Data models for forestui."""
+
+import re
+from dataclasses import dataclass
+from datetime import UTC, datetime
+from pathlib import Path
+from typing import Self
+from uuid import UUID, uuid4
+
+import humanize
+from pydantic import BaseModel, Field, field_validator
+
+# Constants for validation
+MAX_CLAUDE_COMMAND_LENGTH = 200
+
+
+def validate_claude_command(command: str) -> str | None:
+    """Validate a custom Claude command.
+
+    Args:
+        command: The command string to validate (can be empty).
+
+    Returns:
+        Error message if invalid, None if valid.
+    """
+    if not command:
+        return None  # Empty is valid (clears/uses default)
+
+    if len(command) > MAX_CLAUDE_COMMAND_LENGTH:
+        return f"Command too long (max {MAX_CLAUDE_COMMAND_LENGTH} characters)"
+
+    if any(c in command for c in "\n\r\t\0"):
+        return "Command cannot contain newlines or control characters"
+
+    return None
+
+
+def _validate_command_field(v: str | None) -> str | None:
+    """Pydantic field validator for custom_claude_command."""
+    if v is None:
+        return None
+    error = validate_claude_command(v)
+    if error:
+        raise ValueError(error)
+    return v
+
+
+@dataclass
+class ClaudeCommandResult:
+    """Result from ClaudeCommandModal.
+
+    Attributes:
+        command: The command string, or None to clear the setting.
+        cancelled: True if user cancelled the modal.
+    """
+
+    command: str | None
+    cancelled: bool = False
+
+
+class Worktree(BaseModel):
+    """Represents a Git worktree."""
+
+    id: UUID = Field(default_factory=uuid4)
+    name: str
+    branch: str
+    path: str
+    is_archived: bool = False
+    sort_order: int | None = None
+    last_modified: datetime = Field(default_factory=lambda: datetime.now(UTC))
+    custom_claude_command: str | None = None
+
+    @field_validator("custom_claude_command")
+    @classmethod
+    def validate_command(cls, v: str | None) -> str | None:
+        """Validate custom_claude_command field."""
+        return _validate_command_field(v)
+
+    def get_path(self) -> Path:
+        """Get the worktree path as a Path object."""
+        return Path(self.path).expanduser()
+
+
+class Repository(BaseModel):
+    """Represents a Git repository with its worktrees."""
+
+    id: UUID = Field(default_factory=uuid4)
+    name: str
+    source_path: str
+    worktrees: list[Worktree] = Field(default_factory=list)
+    custom_claude_command: str | None = None
+
+    @field_validator("custom_claude_command")
+    @classmethod
+    def validate_command(cls, v: str | None) -> str | None:
+        """Validate custom_claude_command field."""
+        return _validate_command_field(v)
+
+    def get_source_path(self) -> Path:
+        """Get the source path as a Path object."""
+        return Path(self.source_path).expanduser()
+
+    def active_worktrees(self) -> list[Worktree]:
+        """Get active (non-archived) worktrees sorted by order/recency."""
+        active = [w for w in self.worktrees if not w.is_archived]
+        return sorted(
+            active,
+            key=lambda w: (
+                w.sort_order if w.sort_order is not None else float("inf"),
+                -w.last_modified.timestamp(),
+            ),
+        )
+
+    def archived_worktrees(self) -> list[Worktree]:
+        """Get archived worktrees sorted by recency."""
+        archived = [w for w in self.worktrees if w.is_archived]
+        return sorted(archived, key=lambda w: -w.last_modified.timestamp())
+
+    def find_worktree(self, worktree_id: UUID) -> Worktree | None:
+        """Find a worktree by ID."""
+        for w in self.worktrees:
+            if w.id == worktree_id:
+                return w
+        return None
+
+
+class ClaudeSession(BaseModel):
+    """Represents a Claude Code session."""
+
+    id: str
+    title: str
+    last_message: str = ""
+    last_timestamp: datetime
+    message_count: int
+    git_branches: list[str] = Field(default_factory=list)
+
+    @property
+    def relative_time(self) -> str:
+        """Get a human-readable relative time string."""
+        return humanize.naturaltime(self.last_timestamp)
+
+    @property
+    def primary_branch(self) -> str | None:
+        """Get the first git branch if available."""
+        return self.git_branches[0] if self.git_branches else None
+
+
+class Settings(BaseModel):
+    """Application settings."""
+
+    default_editor: str = "vim"
+    default_terminal: str = ""
+    branch_prefix: str = "feat/"
+    theme: str = "system"
+    custom_claude_command: str | None = None
+
+    @field_validator("custom_claude_command")
+    @classmethod
+    def validate_command(cls, v: str | None) -> str | None:
+        """Validate custom_claude_command field."""
+        return _validate_command_field(v)
+
+    @classmethod
+    def default(cls) -> Self:
+        """Create default settings."""
+        return cls()
+
+
+class Selection(BaseModel):
+    """Represents the current selection state."""
+
+    repository_id: UUID | None = None
+    worktree_id: UUID | None = None
+
+    @property
+    def is_repository(self) -> bool:
+        """Check if a repository is selected (not a worktree)."""
+        return self.repository_id is not None and self.worktree_id is None
+
+    @property
+    def is_worktree(self) -> bool:
+        """Check if a worktree is selected."""
+        return self.worktree_id is not None
+
+
+class GitHubLabel(BaseModel):
+    """GitHub issue label."""
+
+    name: str
+    color: str = ""
+
+
+class GitHubUser(BaseModel):
+    """GitHub user."""
+
+    login: str
+
+
+class GitHubIssue(BaseModel):
+    """GitHub issue."""
+
+    number: int
+    title: str
+    state: str
+    url: str
+    created_at: datetime
+    updated_at: datetime
+    author: GitHubUser
+    assignees: list[GitHubUser] = Field(default_factory=list)
+    labels: list[GitHubLabel] = Field(default_factory=list)
+
+    @property
+    def branch_name(self) -> str:
+        """Generate branch-safe name from issue. e.g., '42-fix-login-bug'."""
+        slug = re.sub(r"[^a-z0-9]+", "-", self.title.lower())[:40].strip("-")
+        return f"{self.number}-{slug}"
+
+    @property
+    def relative_time(self) -> str:
+        """Human-readable relative time since update."""
+        return humanize.naturaltime(self.updated_at)

forestui/services/__init__.py

@@ -0,0 +1,16 @@
+"""Services for forestui."""
+
+from forestui.services.claude_session import ClaudeSessionService
+from forestui.services.git import GitService
+from forestui.services.github import GitHubService, get_github_service
+from forestui.services.settings import SettingsService
+from forestui.services.tmux import TmuxService
+
+__all__ = [
+    "ClaudeSessionService",
+    "GitHubService",
+    "GitService",
+    "SettingsService",
+    "TmuxService",
+    "get_github_service",
+]