forestui 0.9.0__py3-none-any.whl

forestui/services/claude_session.py

@@ -0,0 +1,179 @@
+"""Service for managing Claude Code session history."""
+
+import json
+import re
+import shutil
+from datetime import UTC, datetime
+from pathlib import Path
+
+from forestui.models import ClaudeSession
+
+
+class ClaudeSessionService:
+    """Service for reading and managing Claude Code sessions."""
+
+    _instance: ClaudeSessionService | None = None
+
+    def __new__(cls) -> ClaudeSessionService:
+        if cls._instance is None:
+            cls._instance = super().__new__(cls)
+        return cls._instance
+
+    @staticmethod
+    def _path_to_claude_folder(path: str | Path) -> str:
+        """Convert a path to Claude's folder naming convention."""
+        path_str = str(Path(path).expanduser().resolve())
+        return path_str.replace("/", "-")
+
+    @staticmethod
+    def _get_claude_projects_dir() -> Path:
+        """Get the Claude projects directory."""
+        return Path.home() / ".claude" / "projects"
+
+    def get_sessions_for_path(
+        self, path: str | Path, limit: int = 5
+    ) -> list[ClaudeSession]:
+        """Get Claude sessions for a given path."""
+        folder_name = self._path_to_claude_folder(path)
+        sessions_dir = self._get_claude_projects_dir() / folder_name
+
+        if not sessions_dir.exists():
+            return []
+
+        sessions: list[ClaudeSession] = []
+
+        for session_file in sessions_dir.glob("*.jsonl"):
+            # Skip agent files
+            if session_file.name.startswith("agent-"):
+                continue
+
+            session = self._parse_session_file(session_file)
+            if session:
+                sessions.append(session)
+
+        # Sort by timestamp (newest first) and limit
+        sessions.sort(key=lambda s: s.last_timestamp, reverse=True)
+        return sessions[:limit]
+
+    def _parse_session_file(self, file_path: Path) -> ClaudeSession | None:
+        """Parse a session JSONL file."""
+
+        session_id = file_path.stem
+        title = ""
+        last_message = ""
+        last_timestamp = datetime.min.replace(tzinfo=UTC)
+        message_count = 0
+        git_branches: list[str] = []
+
+        try:
+            with file_path.open(encoding="utf-8") as f:
+                for line in f:
+                    line = line.strip()
+                    if not line:
+                        continue
+
+                    try:
+                        data = json.loads(line)
+                    except json.JSONDecodeError:
+                        continue
+
+                    # Extract timestamp
+                    if "timestamp" in data:
+                        try:
+                            ts = datetime.fromisoformat(
+                                data["timestamp"].replace("Z", "+00:00")
+                            )
+                            # Ensure timezone-aware (assume UTC if naive)
+                            if ts.tzinfo is None:
+                                ts = ts.replace(tzinfo=UTC)
+                            if ts > last_timestamp:
+                                last_timestamp = ts
+                        except (ValueError, AttributeError):
+                            pass
+
+                    # Check for user messages
+                    if data.get("type") == "user" or data.get("role") == "user":
+                        message_count += 1
+
+                        # Extract message content
+                        content = data.get("message", {}).get(
+                            "content", ""
+                        ) or data.get("content", "")
+                        if isinstance(content, list):
+                            # Handle block format
+                            for block in content:
+                                if (
+                                    isinstance(block, dict)
+                                    and block.get("type") == "text"
+                                ):
+                                    content = block.get("text", "")
+                                    break
+                            else:
+                                content = ""
+
+                        # Use for title/last_message if valid
+                        if (
+                            isinstance(content, str)
+                            and content
+                            and not content.startswith("<")
+                        ):
+                            # Collapse 3+ newlines to 2 (preserve single blank lines)
+                            normalized = re.sub(r"\n{3,}", "\n\n", content)
+                            if not title:
+                                title = normalized[:100]
+                            # Always update last_message (will end up with the last one)
+                            last_message = normalized[:100]
+
+                    # Extract git branches
+                    if "gitBranches" in data:
+                        branches = data["gitBranches"]
+                        if isinstance(branches, list):
+                            for branch in branches:
+                                if branch and branch not in git_branches:
+                                    git_branches.append(branch)
+
+        except OSError:
+            return None
+
+        if message_count == 0:
+            return None
+
+        if last_timestamp == datetime.min.replace(tzinfo=UTC):
+            last_timestamp = datetime.fromtimestamp(file_path.stat().st_mtime, tz=UTC)
+
+        return ClaudeSession(
+            id=session_id,
+            title=title or "Untitled session",
+            last_message=last_message,
+            last_timestamp=last_timestamp,
+            message_count=message_count,
+            git_branches=git_branches,
+        )
+
+    def migrate_sessions(self, old_path: str | Path, new_path: str | Path) -> None:
+        """Migrate session history from old path to new path."""
+        old_folder = self._path_to_claude_folder(old_path)
+        new_folder = self._path_to_claude_folder(new_path)
+
+        old_dir = self._get_claude_projects_dir() / old_folder
+        new_dir = self._get_claude_projects_dir() / new_folder
+
+        if not old_dir.exists():
+            return
+
+        new_dir.mkdir(parents=True, exist_ok=True)
+
+        # Move session files
+        for session_file in old_dir.glob("*.jsonl"):
+            dest = new_dir / session_file.name
+            if not dest.exists():
+                shutil.move(str(session_file), str(dest))
+
+        # Clean up empty directory
+        if old_dir.exists() and not any(old_dir.iterdir()):
+            old_dir.rmdir()
+
+
+def get_claude_session_service() -> ClaudeSessionService:
+    """Get the singleton ClaudeSessionService instance."""
+    return ClaudeSessionService()

forestui/services/git.py

@@ -0,0 +1,254 @@
+"""Git service for executing git commands."""
+
+import asyncio
+from datetime import UTC, datetime
+from pathlib import Path
+from typing import NamedTuple
+
+
+class GitError(Exception):
+    """Git operation error."""
+
+    pass
+
+
+class WorktreeInfo(NamedTuple):
+    """Information about a git worktree."""
+
+    path: str
+    head: str
+    branch: str | None
+
+
+class CommitInfo(NamedTuple):
+    """Information about a git commit."""
+
+    hash: str
+    short_hash: str
+    timestamp: datetime
+
+
+class GitService:
+    """Service for executing git operations."""
+
+    _instance: GitService | None = None
+
+    def __new__(cls) -> GitService:
+        if cls._instance is None:
+            cls._instance = super().__new__(cls)
+        return cls._instance
+
+    @staticmethod
+    async def _run_git(
+        *args: str, cwd: str | Path | None = None
+    ) -> tuple[int, str, str]:
+        """Run a git command and return exit code, stdout, stderr."""
+        cmd = ["git", *args]
+        process = await asyncio.create_subprocess_exec(
+            *cmd,
+            stdout=asyncio.subprocess.PIPE,
+            stderr=asyncio.subprocess.PIPE,
+            cwd=str(cwd) if cwd else None,
+        )
+        stdout, stderr = await process.communicate()
+        return (
+            process.returncode or 0,
+            stdout.decode("utf-8").strip(),
+            stderr.decode("utf-8").strip(),
+        )
+
+    async def is_git_repository(self, path: str | Path) -> bool:
+        """Check if a path is a git repository."""
+        path = Path(path).expanduser()
+        if not path.exists():
+            return False
+        code, _, _ = await self._run_git("rev-parse", "--git-dir", cwd=path)
+        return code == 0
+
+    async def get_current_branch(self, path: str | Path) -> str:
+        """Get the current branch of a repository."""
+        path = Path(path).expanduser()
+        code, stdout, stderr = await self._run_git("branch", "--show-current", cwd=path)
+        if code != 0:
+            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."""
+        path = Path(path).expanduser()
+        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 = []
+        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:
+                    branches.append(line)
+        return sorted(branches)
+
+    async def create_worktree(
+        self,
+        repo_path: str | Path,
+        worktree_path: str | Path,
+        branch: str,
+        new_branch: bool = True,
+    ) -> None:
+        """Create a new worktree."""
+        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)
+
+        if new_branch:
+            code, _stdout, stderr = await self._run_git(
+                "worktree", "add", "-b", branch, str(worktree_path), cwd=repo_path
+            )
+        else:
+            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}")
+
+    async def remove_worktree(
+        self, repo_path: str | Path, worktree_path: str | Path, force: bool = False
+    ) -> None:
+        """Remove a worktree."""
+        repo_path = Path(repo_path).expanduser()
+        worktree_path = Path(worktree_path).expanduser()
+
+        args = ["worktree", "remove"]
+        if force:
+            args.append("--force")
+        args.append(str(worktree_path))
+
+        code, _stdout, stderr = await self._run_git(*args, cwd=repo_path)
+        if code != 0:
+            # Try force remove if normal remove fails
+            if not force:
+                await self.remove_worktree(repo_path, worktree_path, force=True)
+            else:
+                raise GitError(f"Failed to remove worktree: {stderr}")
+
+    async def rename_branch(
+        self, path: str | Path, old_name: str, new_name: str
+    ) -> None:
+        """Rename a branch."""
+        path = Path(path).expanduser()
+        code, _stdout, stderr = await self._run_git(
+            "branch", "-m", old_name, new_name, cwd=path
+        )
+        if code != 0:
+            raise GitError(f"Failed to rename branch: {stderr}")
+
+    async def repair_worktree(
+        self, repo_path: str | Path, worktree_path: str | Path
+    ) -> None:
+        """Repair worktree references after moving."""
+        repo_path = Path(repo_path).expanduser()
+        worktree_path = Path(worktree_path).expanduser()
+        code, _stdout, stderr = await self._run_git(
+            "worktree", "repair", str(worktree_path), cwd=repo_path
+        )
+        if code != 0:
+            raise GitError(f"Failed to repair worktree: {stderr}")
+
+    async def list_worktrees(self, repo_path: str | Path) -> list[WorktreeInfo]:
+        """List all worktrees for a repository."""
+        repo_path = Path(repo_path).expanduser()
+        code, stdout, stderr = await self._run_git(
+            "worktree", "list", "--porcelain", cwd=repo_path
+        )
+        if code != 0:
+            raise GitError(f"Failed to list worktrees: {stderr}")
+
+        worktrees: list[WorktreeInfo] = []
+        current_path: str | None = None
+        current_head: str | None = None
+        current_branch: str | None = None
+
+        for line in stdout.split("\n"):
+            line = line.strip()
+            if line.startswith("worktree "):
+                if current_path and current_head:
+                    worktrees.append(
+                        WorktreeInfo(current_path, current_head, current_branch)
+                    )
+                current_path = line[9:]
+                current_head = None
+                current_branch = None
+            elif line.startswith("HEAD "):
+                current_head = line[5:]
+            elif line.startswith("branch "):
+                # refs/heads/branch-name -> branch-name
+                current_branch = line[7:].replace("refs/heads/", "")
+            elif line == "" and current_path and current_head:
+                worktrees.append(
+                    WorktreeInfo(current_path, current_head, current_branch)
+                )
+                current_path = None
+                current_head = None
+                current_branch = None
+
+        # Don't forget the last one
+        if current_path and current_head:
+            worktrees.append(WorktreeInfo(current_path, current_head, current_branch))
+
+        return worktrees
+
+    async def branch_exists(self, repo_path: str | Path, branch: str) -> bool:
+        """Check if a branch exists."""
+        branches = await self.list_branches(repo_path)
+        return branch in branches
+
+    async def get_latest_commit(self, path: str | Path) -> CommitInfo:
+        """Get the latest commit info for a repository."""
+        path = Path(path).expanduser()
+        # Get commit hash and unix timestamp
+        code, stdout, stderr = await self._run_git(
+            "log", "-1", "--format=%H|%h|%ct", cwd=path
+        )
+        if code != 0:
+            raise GitError(f"Failed to get latest commit: {stderr}")
+        parts = stdout.split("|")
+        if len(parts) != 3:
+            raise GitError("Unexpected git log output format")
+        full_hash, short_hash, timestamp_str = parts
+        timestamp = datetime.fromtimestamp(int(timestamp_str), tz=UTC)
+        return CommitInfo(hash=full_hash, short_hash=short_hash, timestamp=timestamp)
+
+    async def fetch(self, path: str | Path) -> None:
+        """Fetch from remote."""
+        path = Path(path).expanduser()
+        code, _stdout, stderr = await self._run_git("fetch", cwd=path)
+        if code != 0:
+            raise GitError(f"Failed to fetch: {stderr}")
+
+    async def pull(self, path: str | Path) -> None:
+        """Pull from remote (fetch + merge)."""
+        path = Path(path).expanduser()
+        code, _stdout, stderr = await self._run_git("pull", cwd=path)
+        if code != 0:
+            raise GitError(f"Failed to pull: {stderr}")
+
+    async def has_remote_tracking(self, path: str | Path) -> bool:
+        """Check if the current branch has a remote tracking branch."""
+        path = Path(path).expanduser()
+        code, stdout, _stderr = await self._run_git(
+            "rev-parse", "--abbrev-ref", "--symbolic-full-name", "@{u}", cwd=path
+        )
+        # Returns 0 if tracking branch exists, non-zero otherwise
+        return code == 0 and bool(stdout.strip())
+
+
+def get_git_service() -> GitService:
+    """Get the singleton GitService instance."""
+    return GitService()

forestui/services/github.py

@@ -0,0 +1,242 @@
+"""GitHub CLI service for interacting with gh."""
+
+from __future__ import annotations
+
+import asyncio
+import json
+from datetime import UTC, datetime
+from pathlib import Path
+from typing import NamedTuple
+
+from forestui.models import GitHubIssue, GitHubLabel, GitHubUser
+
+
+class IssueCache(NamedTuple):
+    """Cached issues with timestamp."""
+
+    issues: list[GitHubIssue]
+    fetched_at: datetime
+
+
+class GitHubService:
+    """Service for interacting with GitHub via gh CLI."""
+
+    _instance: GitHubService | None = None
+    CACHE_TTL_SECONDS: int = 300  # 5 minutes
+
+    _cache: dict[str, IssueCache]
+    _auth_status: str | None
+    _username: str | None
+
+    def __new__(cls) -> GitHubService:
+        if cls._instance is None:
+            cls._instance = super().__new__(cls)
+            cls._instance._cache = {}
+            cls._instance._auth_status = None
+            cls._instance._username = None
+        return cls._instance
+
+    @staticmethod
+    async def _run_gh(
+        *args: str, cwd: str | Path | None = None
+    ) -> tuple[int, str, str]:
+        """Run a gh command and return (exit_code, stdout, stderr)."""
+        try:
+            process = await asyncio.create_subprocess_exec(
+                "gh",
+                *args,
+                stdout=asyncio.subprocess.PIPE,
+                stderr=asyncio.subprocess.PIPE,
+                cwd=str(cwd) if cwd else None,
+            )
+            stdout, stderr = await process.communicate()
+            return (
+                process.returncode or 0,
+                stdout.decode().strip(),
+                stderr.decode().strip(),
+            )
+        except FileNotFoundError:
+            return (-1, "", "gh not found")
+
+    async def get_auth_status(self) -> tuple[str, str | None]:
+        """Get GitHub CLI authentication status and username.
+
+        Returns: (status, username) where status is "authenticated", "not_authenticated", or "not_installed"
+        """
+        if self._auth_status is not None:
+            return self._auth_status, self._username
+
+        code, _stdout, _ = await self._run_gh("auth", "status")
+        if code == -1:
+            self._auth_status = "not_installed"
+            self._username = None
+        elif code == 0:
+            self._auth_status = "authenticated"
+            # Get username
+            code, stdout, _ = await self._run_gh("api", "user", "--jq", ".login")
+            self._username = stdout if code == 0 and stdout else None
+        else:
+            self._auth_status = "not_authenticated"
+            self._username = None
+        return self._auth_status, self._username
+
+    async def get_repo_info(self, path: str | Path) -> tuple[str, str] | None:
+        """Get (owner, repo) for a git repository path. Returns None if not a GitHub repo."""
+        code, stdout, _ = await self._run_gh(
+            "repo", "view", "--json", "owner,name", cwd=path
+        )
+        if code != 0 or not stdout:
+            return None
+        try:
+            data = json.loads(stdout)
+            return (data["owner"]["login"], data["name"])
+        except (json.JSONDecodeError, KeyError):
+            return None
+
+    async def list_issues(
+        self,
+        path: str | Path,
+        assigned_to_me: bool = True,
+        authored_by_me: bool = True,
+        limit: int = 10,
+        use_cache: bool = True,
+    ) -> list[GitHubIssue]:
+        """List GitHub issues for the repository at path."""
+        # Check auth first
+        auth, _ = await self.get_auth_status()
+        if auth != "authenticated":
+            return []
+
+        repo_info = await self.get_repo_info(path)
+        if not repo_info:
+            return []
+
+        cache_key = f"{repo_info[0]}/{repo_info[1]}"
+
+        # Check cache
+        if use_cache and cache_key in self._cache:
+            cached = self._cache[cache_key]
+            age = (datetime.now(UTC) - cached.fetched_at).total_seconds()
+            if age < self.CACHE_TTL_SECONDS:
+                return cached.issues
+
+        # Fetch from GitHub
+        issues = await self._fetch_issues(path, assigned_to_me, authored_by_me, limit)
+
+        # Update cache
+        self._cache[cache_key] = IssueCache(issues=issues, fetched_at=datetime.now(UTC))
+        return issues
+
+    async def _fetch_issues(
+        self,
+        path: str | Path,
+        assigned_to_me: bool,
+        authored_by_me: bool,
+        limit: int,
+    ) -> list[GitHubIssue]:
+        """Fetch issues from GitHub API."""
+        json_fields = (
+            "number,title,state,url,createdAt,updatedAt,author,assignees,labels"
+        )
+        issues: list[GitHubIssue] = []
+        seen_numbers: set[int] = set()
+
+        if assigned_to_me:
+            code, stdout, _ = await self._run_gh(
+                "issue",
+                "list",
+                "--assignee",
+                "@me",
+                "--state",
+                "open",
+                "--limit",
+                str(limit),
+                "--json",
+                json_fields,
+                cwd=path,
+            )
+            if code == 0 and stdout:
+                for item in json.loads(stdout):
+                    if item["number"] not in seen_numbers:
+                        issues.append(self._parse_issue(item))
+                        seen_numbers.add(item["number"])
+
+        if authored_by_me:
+            code, stdout, _ = await self._run_gh(
+                "issue",
+                "list",
+                "--author",
+                "@me",
+                "--state",
+                "open",
+                "--limit",
+                str(limit),
+                "--json",
+                json_fields,
+                cwd=path,
+            )
+            if code == 0 and stdout:
+                for item in json.loads(stdout):
+                    if item["number"] not in seen_numbers:
+                        issues.append(self._parse_issue(item))
+                        seen_numbers.add(item["number"])
+
+        issues.sort(key=lambda i: i.created_at, reverse=True)
+        return issues[:limit]
+
+    def _parse_issue(self, data: dict[str, object]) -> GitHubIssue:
+        """Parse JSON response into GitHubIssue model."""
+        author_data = data.get("author") or {}
+        author_login = (
+            author_data.get("login", "unknown")
+            if isinstance(author_data, dict)
+            else "unknown"
+        )
+
+        assignees_data = data.get("assignees", [])
+        assignees = []
+        if isinstance(assignees_data, list):
+            for a in assignees_data:
+                if isinstance(a, dict) and "login" in a:
+                    assignees.append(GitHubUser(login=str(a["login"])))
+
+        labels_data = data.get("labels", [])
+        labels = []
+        if isinstance(labels_data, list):
+            for lbl in labels_data:
+                if isinstance(lbl, dict) and "name" in lbl:
+                    labels.append(
+                        GitHubLabel(
+                            name=str(lbl["name"]), color=str(lbl.get("color", ""))
+                        )
+                    )
+
+        created_at_str = str(data.get("createdAt", ""))
+        updated_at_str = str(data.get("updatedAt", ""))
+
+        number_val = data.get("number", 0)
+        number = int(number_val) if isinstance(number_val, (int, str)) else 0
+
+        return GitHubIssue(
+            number=number,
+            title=str(data.get("title", "")),
+            state=str(data.get("state", "")),
+            url=str(data.get("url", "")),
+            created_at=datetime.fromisoformat(created_at_str.replace("Z", "+00:00")),
+            updated_at=datetime.fromisoformat(updated_at_str.replace("Z", "+00:00")),
+            author=GitHubUser(login=str(author_login)),
+            assignees=assignees,
+            labels=labels,
+        )
+
+    def invalidate_cache(self, repo_key: str | None = None) -> None:
+        """Invalidate cache for a specific repo or all repos."""
+        if repo_key:
+            self._cache.pop(repo_key, None)
+        else:
+            self._cache.clear()
+
+
+def get_github_service() -> GitHubService:
+    """Get the singleton GitHubService instance."""
+    return GitHubService()