forestui 0.9.0__py3-none-any.whl

forestui/services/settings.py

@@ -0,0 +1,84 @@
+"""Settings service for managing application configuration."""
+
+from __future__ import annotations
+
+import json
+from pathlib import Path
+
+from forestui.models import Settings
+
+# Default forest directory
+DEFAULT_FOREST_PATH = Path.home() / "forest"
+
+# Runtime forest path (set at startup via CLI argument)
+_forest_path: Path | None = None
+
+
+def set_forest_path(path: Path | str | None) -> None:
+    """Set the runtime forest path."""
+    global _forest_path
+    if path is None:
+        _forest_path = DEFAULT_FOREST_PATH
+    else:
+        _forest_path = Path(path).expanduser().resolve()
+
+
+def get_forest_path() -> Path:
+    """Get the current forest path."""
+    if _forest_path is None:
+        return DEFAULT_FOREST_PATH
+    return _forest_path
+
+
+class SettingsService:
+    """Service for managing application settings."""
+
+    _instance: SettingsService | None = None
+    _settings: Settings | None = None
+    _config_path: Path = Path.home() / ".config" / "forestui" / "settings.json"
+
+    def __new__(cls) -> SettingsService:
+        if cls._instance is None:
+            cls._instance = super().__new__(cls)
+        return cls._instance
+
+    def __init__(self) -> None:
+        if self._settings is None:
+            self._settings = self._load_settings()
+
+    def _load_settings(self) -> Settings:
+        """Load settings from config file."""
+        if self._config_path.exists():
+            try:
+                with self._config_path.open(encoding="utf-8") as f:
+                    data = json.load(f)
+                    return Settings.model_validate(data)
+            except (json.JSONDecodeError, OSError):
+                pass
+        return Settings.default()
+
+    def save_settings(self, settings: Settings) -> None:
+        """Save settings to config file."""
+        self._config_path.parent.mkdir(parents=True, exist_ok=True)
+        with self._config_path.open("w", encoding="utf-8") as f:
+            json.dump(settings.model_dump(), f, indent=2)
+        self._settings = settings
+
+    @property
+    def settings(self) -> Settings:
+        """Get current settings."""
+        if self._settings is None:
+            self._settings = self._load_settings()
+        return self._settings
+
+    def update(self, **kwargs: str) -> None:
+        """Update settings with new values."""
+        current = self.settings.model_dump()
+        current.update(kwargs)
+        new_settings = Settings.model_validate(current)
+        self.save_settings(new_settings)
+
+
+def get_settings_service() -> SettingsService:
+    """Get the singleton SettingsService instance."""
+    return SettingsService()

forestui/services/tmux.py

@@ -0,0 +1,320 @@
+"""Service for tmux integration using libtmux."""
+
+from __future__ import annotations
+
+import os
+import shlex
+
+from libtmux import Server
+from libtmux.exc import LibTmuxException
+from libtmux.session import Session
+from libtmux.window import Window
+
+TUI_EDITORS = {
+    "vim",
+    "nvim",
+    "vi",
+    "emacs",
+    "nano",
+    "helix",
+    "hx",
+    "micro",
+    "kakoune",
+    "kak",
+}
+
+
+class TmuxService:
+    """Service for interacting with tmux sessions via libtmux."""
+
+    _instance: TmuxService | None = None
+    _server: Server | None = None
+    _session: Session | None = None
+
+    def __new__(cls) -> TmuxService:
+        if cls._instance is None:
+            cls._instance = super().__new__(cls)
+        return cls._instance
+
+    @property
+    def is_inside_tmux(self) -> bool:
+        """Check if we are running inside a tmux session."""
+        return bool(os.environ.get("TMUX"))
+
+    @property
+    def server(self) -> Server | None:
+        """Get the tmux server."""
+        if not self.is_inside_tmux:
+            return None
+        if self._server is None:
+            try:
+                self._server = Server()
+            except LibTmuxException:
+                return None
+        return self._server
+
+    @property
+    def session(self) -> Session | None:
+        """Get the current tmux session."""
+        if not self.is_inside_tmux or self.server is None:
+            return None
+        if self._session is None:
+            try:
+                # Get session from TMUX environment variable
+                # Format: /socket/path,pid,window_index
+                tmux_env = os.environ.get("TMUX", "")
+                if tmux_env:
+                    # Find the attached session (session_attached is a count > 0)
+                    for sess in self.server.sessions:
+                        attached = sess.session_attached
+                        if attached and int(attached) > 0:
+                            self._session = sess
+                            break
+                    # Fallback to first session if none found
+                    if self._session is None and self.server.sessions:
+                        self._session = self.server.sessions[0]
+            except (LibTmuxException, ValueError, TypeError):
+                return None
+        return self._session
+
+    @property
+    def current_window(self) -> Window | None:
+        """Get the current tmux window."""
+        if self.session is None:
+            return None
+        try:
+            return self.session.active_window
+        except LibTmuxException:
+            return None
+
+    def rename_window(self, name: str) -> bool:
+        """Rename the current tmux window."""
+        window = self.current_window
+        if window is None:
+            return False
+        try:
+            window.rename_window(name)
+            return True
+        except LibTmuxException:
+            return False
+
+    def ensure_focus_events(self) -> bool:
+        """Ensure tmux focus-events option is enabled for proper app refresh.
+
+        Returns:
+            True if focus events were enabled successfully, False otherwise.
+        """
+        if self.server is None:
+            return False
+        try:
+            self.server.cmd("set-option", "-g", "focus-events", "on")
+            return True
+        except LibTmuxException:
+            return False
+
+    def is_tui_editor(self, editor: str) -> bool:
+        """Check if an editor is a TUI editor that should run in tmux."""
+        # Get base command (handle "emacs -nw" -> "emacs")
+        base_cmd = editor.split()[0]
+        return base_cmd in TUI_EDITORS
+
+    def find_window(self, name: str) -> Window | None:
+        """Find a window by name in the current session."""
+        if self.session is None:
+            return None
+        try:
+            for window in self.session.windows:
+                if window.window_name == name:
+                    return window
+        except LibTmuxException:
+            pass
+        return None
+
+    def create_editor_window(
+        self,
+        worktree_name: str,
+        worktree_path: str,
+        editor: str,
+    ) -> bool:
+        """Create a tmux window with the editor open in the worktree.
+
+        Args:
+            worktree_name: Name of the worktree (used for window naming)
+            worktree_path: Path to the worktree directory
+            editor: Editor command to run
+
+        Returns:
+            True if window was created/selected successfully, False otherwise
+        """
+        if self.session is None:
+            return False
+
+        window_name = f"edit:{worktree_name}"
+
+        try:
+            # Check if window already exists
+            existing_window = self.find_window(window_name)
+            if existing_window is not None:
+                existing_window.select()
+                return True
+
+            # Create new window with editor as the command (closes when editor exits)
+            self.session.new_window(
+                window_name=window_name,
+                start_directory=worktree_path,
+                attach=True,
+                window_shell=f"{editor} .",
+            )
+
+            return True
+
+        except LibTmuxException:
+            return False
+
+    def create_shell_window(self, name: str, path: str) -> bool:
+        """Create a tmux window with a shell.
+
+        Args:
+            name: Name for the window
+            path: Working directory path
+
+        Returns:
+            True if window was created successfully, False otherwise
+        """
+        if self.session is None:
+            return False
+
+        base_window_name = f"term:{name}"
+
+        try:
+            # Always create a new window with unique name
+            window_name = self._find_unique_window_name(base_window_name)
+
+            self.session.new_window(
+                window_name=window_name,
+                start_directory=path,
+                attach=True,
+            )
+
+            return True
+
+        except LibTmuxException:
+            return False
+
+    def create_mc_window(self, name: str, path: str) -> bool:
+        """Create a tmux window with Midnight Commander.
+
+        Args:
+            name: Name for the window
+            path: Working directory path
+
+        Returns:
+            True if window was created successfully, False otherwise
+        """
+        if self.session is None:
+            return False
+
+        base_window_name = f"files:{name}"
+
+        try:
+            # Always create a new window with unique name
+            window_name = self._find_unique_window_name(base_window_name)
+
+            self.session.new_window(
+                window_name=window_name,
+                start_directory=path,
+                attach=True,
+                window_shell="mc",
+            )
+
+            return True
+
+        except LibTmuxException:
+            return False
+
+    def _find_unique_window_name(self, base_name: str) -> str:
+        """Find a unique window name by adding :2, :3, etc. suffix if needed.
+
+        Args:
+            base_name: The base window name (e.g., "yolo:cogram")
+
+        Returns:
+            A unique window name (e.g., "yolo:cogram" or "yolo:cogram:2")
+        """
+        if self.session is None:
+            return base_name
+
+        try:
+            existing_names = {w.window_name for w in self.session.windows}
+        except LibTmuxException:
+            return base_name
+
+        if base_name not in existing_names:
+            return base_name
+
+        # Find next available suffix
+        counter = 2
+        while f"{base_name}:{counter}" in existing_names:
+            counter += 1
+        return f"{base_name}:{counter}"
+
+    def create_claude_window(
+        self,
+        name: str,
+        path: str,
+        resume_session_id: str | None = None,
+        yolo: bool = False,
+        custom_command: str | None = None,
+    ) -> str | None:
+        """Create a tmux window with Claude Code.
+
+        Args:
+            name: Name for the window (e.g., worktree name)
+            path: Working directory path
+            resume_session_id: Optional session ID to resume
+            yolo: If True, add --dangerously-skip-permissions flag
+            custom_command: Optional custom Claude command (e.g., "claude --model opus")
+
+        Returns:
+            The window name if created/selected successfully, None otherwise
+        """
+        if self.session is None:
+            return None
+
+        base_window_name = f"claude:{name}"
+        if yolo:
+            base_window_name = f"yolo:{name}"
+
+        try:
+            # Always create a new window with unique name (add :2, :3 suffix if needed)
+            window_name = self._find_unique_window_name(base_window_name)
+
+            # Build claude command (closes when claude exits)
+            # Use custom_command if provided, otherwise default to "claude"
+            cmd = custom_command or "claude"
+            if yolo:
+                cmd += " --dangerously-skip-permissions"
+            if resume_session_id:
+                cmd += f" -r {resume_session_id}"
+
+            # Wrap in interactive shell to support aliases
+            # Use shlex.quote to prevent shell injection from custom commands
+            shell = os.environ.get("SHELL", "/bin/bash")
+            shell_cmd = f"{shell} -ic {shlex.quote(cmd)}"
+
+            self.session.new_window(
+                window_name=window_name,
+                start_directory=path,
+                attach=True,
+                window_shell=shell_cmd,
+            )
+
+            return window_name
+
+        except LibTmuxException:
+            return None
+
+
+def get_tmux_service() -> TmuxService:
+    """Get the singleton TmuxService instance."""
+    return TmuxService()

forestui/state.py

@@ -0,0 +1,248 @@
+"""Application state management for forestui."""
+
+import json
+from datetime import UTC, datetime
+from pathlib import Path
+from uuid import UUID
+
+from pydantic import BaseModel
+
+from forestui.models import Repository, Selection, Worktree
+from forestui.services.settings import get_forest_path
+
+
+class AppStateData(BaseModel):
+    """Serializable app state data."""
+
+    repositories: list[Repository] = []
+
+
+class AppState:
+    """Centralized application state with persistence."""
+
+    def __init__(self) -> None:
+        self._repositories: list[Repository] = []
+        self._selection: Selection = Selection()
+        self._show_archived: bool = False
+        self._load_state()
+
+    def _get_config_path(self) -> Path:
+        """Get the config file path."""
+        forest_dir = get_forest_path()
+        forest_dir.mkdir(parents=True, exist_ok=True)
+        return forest_dir / ".forestui-config.json"
+
+    def _load_state(self) -> None:
+        """Load state from config file."""
+        config_path = self._get_config_path()
+        if config_path.exists():
+            try:
+                with config_path.open(encoding="utf-8") as f:
+                    data = json.load(f)
+                    state_data = AppStateData.model_validate(data)
+                    self._repositories = state_data.repositories
+            except (json.JSONDecodeError, OSError):
+                pass
+
+    def _save_state(self) -> None:
+        """Save state to config file."""
+        config_path = self._get_config_path()
+        config_path.parent.mkdir(parents=True, exist_ok=True)
+        state_data = AppStateData(repositories=self._repositories)
+        with config_path.open("w", encoding="utf-8") as f:
+            json.dump(state_data.model_dump(mode="json"), f, indent=2, default=str)
+
+    @property
+    def repositories(self) -> list[Repository]:
+        """Get all repositories."""
+        return self._repositories
+
+    @property
+    def selection(self) -> Selection:
+        """Get current selection."""
+        return self._selection
+
+    @selection.setter
+    def selection(self, value: Selection) -> None:
+        """Set current selection."""
+        self._selection = value
+
+    @property
+    def show_archived(self) -> bool:
+        """Get show archived flag."""
+        return self._show_archived
+
+    @show_archived.setter
+    def show_archived(self, value: bool) -> None:
+        """Set show archived flag."""
+        self._show_archived = value
+
+    def add_repository(self, repository: Repository) -> None:
+        """Add a repository."""
+        self._repositories.append(repository)
+        self._save_state()
+
+    def remove_repository(self, repo_id: UUID) -> None:
+        """Remove a repository by ID."""
+        self._repositories = [r for r in self._repositories if r.id != repo_id]
+        if self._selection.repository_id == repo_id:
+            self._selection = Selection()
+        self._save_state()
+
+    def find_repository(self, repo_id: UUID) -> Repository | None:
+        """Find a repository by ID."""
+        for repo in self._repositories:
+            if repo.id == repo_id:
+                return repo
+        return None
+
+    def update_repository_command(self, repo_id: UUID, command: str | None) -> bool:
+        """Update a repository's custom Claude command.
+
+        Returns:
+            True if the repository was found and updated, False otherwise.
+        """
+        for repo in self._repositories:
+            if repo.id == repo_id:
+                repo.custom_claude_command = command
+                self._save_state()
+                return True
+        return False
+
+    def update_worktree_command(self, worktree_id: UUID, command: str | None) -> bool:
+        """Update a worktree's custom Claude command.
+
+        Returns:
+            True if the worktree was found and updated, False otherwise.
+        """
+        for repo in self._repositories:
+            for worktree in repo.worktrees:
+                if worktree.id == worktree_id:
+                    worktree.custom_claude_command = command
+                    self._save_state()
+                    return True
+        return False
+
+    def find_worktree(self, worktree_id: UUID) -> tuple[Repository, Worktree] | None:
+        """Find a worktree by ID and return with its parent repository."""
+        for repo in self._repositories:
+            for worktree in repo.worktrees:
+                if worktree.id == worktree_id:
+                    return repo, worktree
+        return None
+
+    def add_worktree(self, repo_id: UUID, worktree: Worktree) -> None:
+        """Add a worktree to a repository."""
+        for repo in self._repositories:
+            if repo.id == repo_id:
+                repo.worktrees.append(worktree)
+                self._save_state()
+                return
+
+    def remove_worktree(self, worktree_id: UUID) -> None:
+        """Remove a worktree by ID."""
+        for repo in self._repositories:
+            repo.worktrees = [w for w in repo.worktrees if w.id != worktree_id]
+        if self._selection.worktree_id == worktree_id:
+            self._selection = Selection(repository_id=self._selection.repository_id)
+        self._save_state()
+
+    def update_worktree(
+        self, worktree_id: UUID, **kwargs: str | bool | int | None
+    ) -> None:
+        """Update a worktree's attributes."""
+        for repo in self._repositories:
+            for i, worktree in enumerate(repo.worktrees):
+                if worktree.id == worktree_id:
+                    data = worktree.model_dump()
+                    data.update(kwargs)
+                    repo.worktrees[i] = Worktree.model_validate(data)
+                    self._save_state()
+                    return
+
+    def archive_worktree(self, worktree_id: UUID) -> None:
+        """Archive a worktree."""
+        self.update_worktree(worktree_id, is_archived=True)
+
+    def unarchive_worktree(self, worktree_id: UUID) -> None:
+        """Unarchive a worktree."""
+        self.update_worktree(worktree_id, is_archived=False)
+
+    def select_repository(self, repo_id: UUID) -> None:
+        """Select a repository."""
+        self._selection = Selection(repository_id=repo_id)
+
+    def select_worktree(self, repo_id: UUID, worktree_id: UUID) -> None:
+        """Select a worktree."""
+        self._selection = Selection(repository_id=repo_id, worktree_id=worktree_id)
+
+    def clear_selection(self) -> None:
+        """Clear the current selection."""
+        self._selection = Selection()
+
+    @property
+    def selected_repository(self) -> Repository | None:
+        """Get the currently selected repository."""
+        if self._selection.repository_id:
+            return self.find_repository(self._selection.repository_id)
+        return None
+
+    @property
+    def selected_worktree(self) -> tuple[Repository, Worktree] | None:
+        """Get the currently selected worktree with its parent repo."""
+        if self._selection.worktree_id:
+            return self.find_worktree(self._selection.worktree_id)
+        return None
+
+    def has_archived_worktrees(self) -> bool:
+        """Check if there are any archived worktrees."""
+        for repo in self._repositories:
+            if any(w.is_archived for w in repo.worktrees):
+                return True
+        return False
+
+    def all_archived_worktrees(self) -> list[tuple[Repository, Worktree]]:
+        """Get all archived worktrees with their parent repositories."""
+        result: list[tuple[Repository, Worktree]] = []
+        for repo in self._repositories:
+            for worktree in repo.archived_worktrees():
+                result.append((repo, worktree))
+        return result
+
+    def reorder_worktree(
+        self, repo_id: UUID, worktree_id: UUID, new_index: int
+    ) -> None:
+        """Reorder a worktree within its repository."""
+        repo = self.find_repository(repo_id)
+        if not repo:
+            return
+
+        # Get active worktrees in current order
+        active = repo.active_worktrees()
+        worktree = next((w for w in active if w.id == worktree_id), None)
+        if not worktree:
+            return
+
+        # Remove and reinsert at new position
+        active = [w for w in active if w.id != worktree_id]
+        active.insert(min(new_index, len(active)), worktree)
+
+        # Update sort orders
+        for i, w in enumerate(active):
+            self.update_worktree(w.id, sort_order=i)
+
+    def refresh_worktree_timestamp(self, worktree_id: UUID) -> None:
+        """Update a worktree's last modified timestamp."""
+        self.update_worktree(worktree_id, last_modified=datetime.now(UTC).isoformat())
+
+
+# Global app state instance
+_app_state: AppState | None = None
+
+
+def get_app_state() -> AppState:
+    """Get the global app state instance."""
+    global _app_state
+    if _app_state is None:
+        _app_state = AppState()
+    return _app_state