claude-launcher 0.1.0__py3-none-any.whl

claude_launcher/ui/preview.py

@@ -0,0 +1,265 @@
+"""Preview generation for claude-launcher."""
+
+import subprocess  # nosec B404
+from pathlib import Path
+from typing import Dict, List, Optional, Tuple
+
+from claude_launcher.core.models import PreviewContent, Project
+
+
+def generate_preview(
+    project_path: Path, show_git_status: bool = True
+) -> PreviewContent:
+    """Generate preview content for a project.
+
+    Args:
+        project_path: Path to the project
+        show_git_status: Whether to include git status
+
+    Returns:
+        PreviewContent instance with available information
+    """
+    preview = PreviewContent()
+
+    # Try to read CLAUDE.md
+    claude_md_path = project_path / "CLAUDE.md"
+    if claude_md_path.exists():
+        try:
+            with open(claude_md_path, "r", encoding="utf-8") as f:
+                lines = f.readlines()[:20]  # First 20 lines
+                preview.claude_md = "".join(lines).rstrip()
+        except Exception as e:
+            preview.error = f"Error reading CLAUDE.md: {e}"
+
+    # Try to get git status
+    if show_git_status and (project_path / ".git").exists():
+        try:
+            result = subprocess.run(  # nosec B603, B607
+                ["git", "status", "-s"],
+                cwd=project_path,
+                capture_output=True,
+                text=True,
+                timeout=2,
+            )
+            if result.returncode == 0:
+                status = result.stdout.strip()
+                if status:
+                    preview.git_status = status
+                else:
+                    preview.git_status = "Clean working tree"
+        except (subprocess.TimeoutExpired, FileNotFoundError, Exception):
+            # Git not available or error - graceful degradation
+            pass
+
+    # Directory listing as fallback
+    try:
+        # Separate directories and files
+        dirs = []
+        files = []
+        for item in project_path.iterdir():
+            if item.is_dir():
+                dirs.append(f"📁 {item.name}/")
+            else:
+                files.append(f"📄 {item.name}")
+
+        # Sort each group and combine (folders first, then files)
+        items = sorted(dirs) + sorted(files)
+
+        # Show all items (no limit)
+        if items:
+            preview.directory_listing = "\n".join(items)
+    except Exception as e:
+        if not preview.error:
+            preview.error = f"Error reading directory: {e}"
+
+    return preview
+
+
+def format_project_line(
+    project_path: Path,
+    parent_path: Optional[Path] = None,
+    is_git: bool = False,
+    is_manual: bool = False,
+) -> str:
+    """Format a project for display in the list.
+
+    Args:
+        project_path: Path to the project
+        parent_path: Parent directory path (for relative display)
+        is_git: Whether this is a git repository
+        is_manual: Whether this was manually added
+
+    Returns:
+        Formatted string for display
+    """
+    markers = []
+    if is_git:
+        markers.append("git")
+    if is_manual:
+        markers.append("manual")
+
+    marker_str = f"[{','.join(markers)}]" if markers else ""
+
+    # Show relative to parent if available
+    if parent_path:
+        try:
+            rel_path = project_path.relative_to(parent_path)
+            display_path = f"{parent_path.name}/{rel_path}"
+        except ValueError:
+            display_path = str(project_path)
+    else:
+        display_path = str(project_path)
+
+    if marker_str:
+        return f"{display_path} {marker_str}"
+    return display_path
+
+
+def build_tree_view(
+    projects: List[Project], base_path: Optional[Path] = None
+) -> Tuple[List[str], Dict[str, Project]]:
+    """Build a hierarchical tree view showing full folder structure.
+
+    Format: Each line contains "absolute_path\t\ttree_display"
+    fzf will be configured to only show tree_display but pass the whole line.
+
+    Args:
+        projects: List of projects to display
+        base_path: Base path to use for relative display (optional)
+
+    Returns:
+        Tuple of (formatted_lines, line_to_project_mapping)
+    """
+    if not projects:
+        return [], {}
+
+    # Use provided base_path or calculate from projects
+    if base_path:
+        base = base_path
+    else:
+        # Find common base path
+        if len(projects) == 1:
+            base = projects[0].path.parent
+        else:
+            # Find common ancestor
+            all_parts = [p.path.parts for p in projects]
+            common_parts = []
+            for parts in zip(*all_parts):
+                if len(set(parts)) == 1:
+                    common_parts.append(parts[0])
+                else:
+                    break
+
+            # If we only have root as common, use the parent of the first project as base
+            # This avoids showing the entire filesystem
+            if not common_parts or (len(common_parts) == 1 and common_parts[0] == "/"):
+                # No meaningful common path - use first project's parent
+                base = projects[0].path.parent
+            else:
+                base = Path(*common_parts)
+
+    # Build full directory tree structure
+    # Track all directories and their children (both dirs and projects)
+    dir_children: Dict[Path, List[Path]] = {}  # dir -> child dirs
+    dir_projects: Dict[Path, List[Project]] = {}  # dir -> projects in that dir
+
+    # Collect all directories in the hierarchy
+    all_dirs = set()
+    for project in projects:
+        # Add project to its parent directory
+        parent = project.path.parent
+        if parent not in dir_projects:
+            dir_projects[parent] = []
+        dir_projects[parent].append(project)
+
+        # Add all ancestor directories
+        current = project.path.parent
+        while current != base and current != current.parent:
+            all_dirs.add(current)
+            parent_dir = current.parent
+            if parent_dir != current and parent_dir != base.parent:
+                if parent_dir not in dir_children:
+                    dir_children[parent_dir] = []
+                if current not in dir_children[parent_dir]:
+                    dir_children[parent_dir].append(current)
+            current = parent_dir
+
+    # Sort children for consistent display
+    for parent in dir_children:
+        dir_children[parent].sort()
+
+    formatted_lines = []
+    line_to_project = {}
+
+    def add_directory(
+        dir_path: Path, prefix: str = "", is_last: bool = True, depth: int = 0
+    ) -> None:
+        """Recursively add directory tree."""
+        # Show directory header if not the base
+        if dir_path != base:
+            connector = "└── " if is_last else "├── "
+            # Get relative path from base for folder display
+            try:
+                rel_dir = dir_path.relative_to(base)
+                dir_name = str(rel_dir)
+            except ValueError:
+                # Can't make relative - show full path
+                dir_name = str(dir_path)
+
+            dir_display = f"\033[2m{prefix}{connector}📁 {dir_name}/\033[0m"
+            formatted_lines.append(f"{dir_path}\t\t{dir_display}")
+
+            # Update prefix for children
+            if is_last:
+                child_prefix = prefix + "    "
+            else:
+                child_prefix = prefix + "│   "
+        else:
+            # Base directory - only show if it's meaningful (not root)
+            if base != Path("/"):
+                dir_display = f"\033[2m📁 {base}/\033[0m"
+                formatted_lines.append(f"{base}\t\t{dir_display}")
+            child_prefix = ""
+
+        # Get subdirectories and projects
+        subdirs = dir_children.get(dir_path, [])
+        projects_here = dir_projects.get(dir_path, [])
+
+        # Sort projects
+        projects_here = sorted(projects_here, key=lambda p: p.path.name)
+
+        # Calculate total items (subdirs + projects)
+        total_items = len(subdirs) + len(projects_here)
+        item_idx = 0
+
+        # Add subdirectories first
+        for subdir in subdirs:
+            item_idx += 1
+            is_last_item = item_idx == total_items
+            add_directory(subdir, child_prefix, is_last_item, depth + 1)
+
+        # Add projects
+        for project in projects_here:
+            item_idx += 1
+            is_last_item = item_idx == total_items
+
+            connector = "└── " if is_last_item else "├── "
+
+            # Format markers
+            markers = []
+            if project.is_git_repo:
+                markers.append("git")
+            if project.is_manual:
+                markers.append("manual")
+            marker_str = f" [{','.join(markers)}]" if markers else ""
+
+            # Just show project name, not full path
+            tree_display = f"{child_prefix}{connector}{project.path.name}{marker_str}"
+            full_line = f"{project.path}\t\t{tree_display}"
+            formatted_lines.append(full_line)
+            line_to_project[full_line] = project
+
+    # Start with base directory
+    add_directory(base, "", True, 0)
+
+    return formatted_lines, line_to_project

claude_launcher/ui/selector.py

@@ -0,0 +1,272 @@
+"""Project selector UI for claude-launcher."""
+
+import os
+import subprocess  # nosec B404
+import sys
+from pathlib import Path
+from typing import List, Optional
+
+from claude_launcher.core.config import ConfigManager
+from claude_launcher.core.discovery import get_all_projects
+from claude_launcher.core.models import Project
+from claude_launcher.core.storage import Storage
+from claude_launcher.ui.preview import build_tree_view
+
+
+def clear_screen() -> None:
+    """Clear the terminal screen using ANSI escape codes."""
+    print("\033[H\033[2J", end="", flush=True)
+
+
+def select_project(
+    projects: List[Project],
+    storage: Storage,
+    show_git_status: bool = True,
+    config_manager: Optional[ConfigManager] = None,
+    scan_paths: Optional[List[Path]] = None,
+) -> Optional[Project]:
+    """Show interactive project selector with action support.
+
+    Args:
+        projects: List of projects to choose from (already sorted)
+        storage: Storage instance for last opened tracking
+        show_git_status: Whether to show git status in preview
+        config_manager: Config manager for add/remove actions (optional)
+        scan_paths: Original scan paths for rescan action (optional)
+
+    Returns:
+        Selected Project or None if cancelled
+    """
+    # Action loop - allows rescanning, adding, removing
+    current_projects = projects
+    while True:
+        if not current_projects:
+            print(
+                "No projects found. Add scan paths with --setup or add manual paths with --add"
+            )
+            return None
+
+        # Clear screen before launching fzf
+        clear_screen()
+
+        # Get default selection index
+        # Note: Not currently used - could reorder choices to put default first
+        # default_index = storage.get_default_selection_index(current_projects)
+
+        # Determine base path for display
+        # Use the actual scan path for header and tree display
+        if scan_paths:
+            if len(scan_paths) == 1:
+                base_path = scan_paths[0]
+            else:
+                # Multiple scan paths - find common base
+                common = os.path.commonpath([str(p) for p in scan_paths])
+                base_path = Path(common)
+        else:
+            base_path = Path.cwd()
+
+        # Build tree view of projects with the base path
+        # Format: "absolute_path\t\ttree_display"
+        choices, choice_to_project = build_tree_view(current_projects, base_path)
+
+        # Add action menu items at the bottom
+        choices.append("__ACTION__\t\t")
+        choices.append("__ACTION__\t\t↻ Rescan")
+        choices.append("__ACTION__\t\t+ Add path")
+        choices.append("__ACTION__\t\t- Remove path")
+
+        # Build header with project info
+        project_count = len(current_projects)
+
+        header = f"""╭─────────────────────────────────────────╮
+│      Claude Code Launcher               │
+╰─────────────────────────────────────────╯
+
+{project_count} project{"s" if project_count != 1 else ""} in {base_path}
+
+Type to filter, arrows to navigate.
+"""
+
+        # Build preview command using helper script
+        helper_script = Path(__file__).parent / "_preview_helper.py"
+        preview_cmd = f"{sys.executable} {helper_script} {{}}"
+
+        # Run fzf directly via subprocess
+        try:
+            fzf_cmd = [
+                "fzf",
+                "--prompt=❯ ",
+                "--height=100%",
+                "--layout=reverse",  # Nav at top
+                "--border=rounded",
+                "--border-label= Projects | Solent Labs™ ",
+                "--delimiter=\t\t",  # Use double-tab as delimiter
+                "--with-nth=2..",  # Show only the tree display (field 2 onwards)
+                "--preview-window=right:70%:wrap:border-left:nohidden",  # Preview 70%, list 30%
+                f"--preview={preview_cmd}",
+                f"--header={header}",
+                "--header-first",  # Display header before prompt
+                "--info=default",  # Show match count on separate line
+                "--color=header:italic",
+                "--ansi",  # Enable ANSI color codes
+                "--exact",  # Use exact substring matching instead of fuzzy
+            ]
+
+            # Pass choices via stdin
+            input_data = "\n".join(choices)
+
+            # Run fzf with stdin, but let it use the terminal for UI
+            # Do NOT capture stdout/stderr - fzf needs direct terminal access
+            process = subprocess.Popen(  # nosec B603
+                fzf_cmd,
+                stdin=subprocess.PIPE,
+                stdout=subprocess.PIPE,
+                text=True,
+            )
+
+            stdout, _ = process.communicate(input=input_data)
+            result_code = process.returncode
+
+            # Check if user cancelled (exit code 130 = Ctrl+C, 1 = no match/cancelled)
+            if result_code in (1, 130):
+                clear_screen()
+                return None
+
+            if result_code != 0:
+                clear_screen()
+                print(f"Error running fzf: exit code {result_code}")
+                return None
+
+            # Get selected line
+            selected = stdout.strip()
+            if not selected:
+                return None
+
+            # Handle action menu items
+            if selected == "__ACTION__\t\t↻ Rescan":
+                # Rescan - refresh project list
+                clear_screen()
+                if scan_paths and config_manager:
+                    config = config_manager.load()
+                    manual_projects = storage.get_manual_projects()
+                    current_projects = get_all_projects(
+                        scan_paths,
+                        config.scan.max_depth,
+                        config.scan.prune_dirs,
+                        manual_projects,
+                    )
+                    continue  # Loop back to show updated list
+                else:
+                    # Can't rescan without scan_paths
+                    continue
+
+            elif selected == "__ACTION__\t\t+ Add path":
+                # Add manual project
+                clear_screen()
+                from claude_launcher.ui.browser import browse_directory
+
+                new_path = browse_directory()
+                if new_path:
+                    storage.add_manual_path(new_path)
+                    clear_screen()
+                    print(f"✓ Added: {new_path}\n")
+                    # Refresh project list
+                    if scan_paths and config_manager:
+                        config = config_manager.load()
+                        manual_projects = storage.get_manual_projects()
+                        current_projects = get_all_projects(
+                            scan_paths,
+                            config.scan.max_depth,
+                            config.scan.prune_dirs,
+                            manual_projects,
+                        )
+                continue  # Loop back
+
+            elif selected == "__ACTION__\t\t- Remove path":
+                # Remove manual project
+                clear_screen()
+                from claude_launcher.ui.browser import remove_manual_path
+
+                removed_path = storage.get_manual_paths()  # Get current paths
+                if remove_manual_path(storage):
+                    clear_screen()
+                    # Show which path was removed by comparing before/after
+                    after_paths = set(storage.get_manual_paths())
+                    before_paths = set(removed_path)
+                    removed = before_paths - after_paths
+                    if removed:
+                        print(f"✓ Removed: {removed.pop()}\n")
+                    # Refresh project list
+                    if scan_paths and config_manager:
+                        config = config_manager.load()
+                        manual_projects = storage.get_manual_projects()
+                        current_projects = get_all_projects(
+                            scan_paths,
+                            config.scan.max_depth,
+                            config.scan.prune_dirs,
+                            manual_projects,
+                        )
+                continue  # Loop back
+
+            # Handle empty line action item (just loop back)
+            elif selected == "__ACTION__\t\t":
+                continue
+
+            # Regular project selection
+            if not selected:
+                return None
+
+            # Look up the project from the formatted line
+            project = choice_to_project.get(selected)
+            if project:
+                # Clear screen before launching Claude
+                clear_screen()
+                return project
+
+            # Fallback: try to match by index
+            try:
+                selected_index = choices.index(selected)
+                # Clear screen before launching Claude
+                clear_screen()
+                return current_projects[selected_index]
+            except ValueError:
+                clear_screen()
+                print(f"Warning: Could not find selected project: {selected}")
+                return None
+
+        except FileNotFoundError:
+            print("Error: fzf not found. Please install fzf:")
+            print("  Ubuntu/Debian: sudo apt install fzf")
+            print("  macOS: brew install fzf")
+            return None
+        except Exception as e:
+            print(f"Error in project selector: {e}")
+            import traceback
+
+            traceback.print_exc()
+            return None
+
+
+def show_project_list(projects: List[Project]) -> None:
+    """Show a simple list of all projects.
+
+    Args:
+        projects: List of projects to display
+    """
+    if not projects:
+        print("No projects found.")
+        return
+
+    print(f"\nFound {len(projects)} project(s):\n")
+
+    for project in projects:
+        markers = []
+        if project.is_git_repo:
+            markers.append("git")
+        if project.is_manual:
+            markers.append("manual")
+
+        marker_str = f" [{','.join(markers)}]" if markers else ""
+        print(f"  {project.path}{marker_str}")
+
+    print()

claude_launcher/utils/__init__.py

@@ -0,0 +1 @@
+"""Utility functions for claude-launcher."""

claude_launcher/utils/git.py

@@ -0,0 +1,148 @@
+"""Git utilities for claude-launcher."""
+
+import subprocess  # nosec B404
+from pathlib import Path
+from typing import TYPE_CHECKING, Optional
+
+if TYPE_CHECKING:
+    from claude_launcher.core.storage import Storage
+
+
+def clone_repository(
+    url: str,
+    target_base: Path,
+    subfolder: Optional[str] = None,
+) -> Path:
+    """Clone a git repository.
+
+    Args:
+        url: Git repository URL (https or ssh)
+        target_base: Base directory for cloning
+        subfolder: Optional subfolder within target_base
+
+    Returns:
+        Path to cloned repository
+
+    Raises:
+        ValueError: If URL is invalid or target exists
+        RuntimeError: If git clone fails
+    """
+    # Validate URL format
+    if not (url.startswith("https://") or url.startswith("git@")):
+        raise ValueError(
+            f"Invalid git URL: {url}\nMust start with 'https://' or 'git@'"
+        )
+
+    # Extract repository name from URL
+    repo_name = url.rstrip("/").split("/")[-1].replace(".git", "")
+
+    # Construct target path
+    if subfolder:
+        target_path = target_base / subfolder / repo_name
+    else:
+        target_path = target_base / repo_name
+
+    # Check if target already exists
+    if target_path.exists():
+        raise ValueError(f"Directory already exists: {target_path}")
+
+    # Ensure parent directory exists
+    target_path.parent.mkdir(parents=True, exist_ok=True)
+
+    # Clone repository
+    try:
+        print(f"Cloning {url}...")
+        print(f"Target: {target_path}\n")
+
+        subprocess.run(  # nosec B603, B607
+            ["git", "clone", url, str(target_path)],
+            capture_output=True,
+            text=True,
+            check=True,
+        )
+
+        print("Clone successful!")
+        return target_path
+
+    except subprocess.CalledProcessError as e:
+        error_msg = e.stderr if e.stderr else str(e)
+        raise RuntimeError(f"Git clone failed: {error_msg}")
+    except FileNotFoundError:
+        raise RuntimeError("Git command not found. Please install git.")
+
+
+def interactive_clone(storage: "Storage") -> Optional[Path]:
+    """Interactive git clone workflow.
+
+    Args:
+        storage: Storage instance for adding manual paths
+
+    Returns:
+        Path to cloned repository or None if cancelled
+    """
+
+    # Get git URL
+    print("\n=== Clone Git Repository ===\n")
+    url = input("Git repository URL (https:// or git@): ").strip()
+
+    if not url:
+        print("Cancelled.")
+        return None
+
+    # Validate URL
+    if not (url.startswith("https://") or url.startswith("git@")):
+        print("Error: Invalid URL. Must start with 'https://' or 'git@'")
+        return None
+
+    # Get target folder
+    print("\nSelect target folder:")
+    print("  1. Home directory (~)")
+    print("  2. ~/projects")
+    print("  3. ~/work")
+    print("  4. Custom path")
+
+    choice = input("\nChoice (1-4): ").strip()
+
+    if choice == "1":
+        target_base = Path.home()
+        subfolder = None
+    elif choice == "2":
+        target_base = Path.home()
+        subfolder = "projects"
+    elif choice == "3":
+        target_base = Path.home()
+        subfolder = "work"
+    elif choice == "4":
+        custom = input("Enter custom path: ").strip()
+        if not custom:
+            print("Cancelled.")
+            return None
+        target_base = Path(custom).expanduser().resolve()
+        subfolder = None
+    else:
+        print("Invalid choice.")
+        return None
+
+    # Clone
+    try:
+        cloned_path = clone_repository(url, target_base, subfolder)
+
+        # Ask if they want to add as manual path
+        print(f"\nCloned to: {cloned_path}")
+        add_manual = input("Add to manual paths? (y/n): ").strip().lower()
+
+        if add_manual == "y":
+            storage.add_manual_path(cloned_path)
+            print("Added to manual paths.")
+
+        # Ask if they want to launch Claude
+        launch = input("Launch Claude now? (y/n): ").strip().lower()
+
+        if launch == "y":
+            return cloned_path
+
+        return None
+
+    except (ValueError, RuntimeError) as e:
+        print(f"\nError: {e}")
+        return None