claude-launcher 0.1.0__py3-none-any.whl

claude_launcher/__init__.py

@@ -0,0 +1,3 @@
+"""Claude Launcher - Fast context switching for Claude Code projects."""
+
+__version__ = "0.1.0"

claude_launcher/__main__.py

@@ -0,0 +1,6 @@
+"""Entry point for python -m claude_launcher."""
+
+from claude_launcher.cli import app
+
+if __name__ == "__main__":
+    app()

claude_launcher/cli.py

@@ -0,0 +1,199 @@
+"""CLI interface for claude-launcher."""
+
+import os
+import subprocess  # nosec B404
+import sys
+from pathlib import Path
+from typing import Optional
+
+import typer
+
+from claude_launcher import __version__
+from claude_launcher.core.config import ConfigManager, get_database_path
+from claude_launcher.core.discovery import get_all_projects
+from claude_launcher.core.storage import Storage
+from claude_launcher.ui.browser import browse_directory, remove_manual_path
+from claude_launcher.ui.selector import select_project, show_project_list
+from claude_launcher.utils.git import interactive_clone
+from claude_launcher.utils.logging import setup_logging
+
+app = typer.Typer(
+    help="Fast context switching for Claude Code projects",
+    add_completion=False,
+)
+
+
+def version_callback(value: bool) -> None:
+    """Print version and exit."""
+    if value:
+        typer.echo(f"claude-launcher {__version__}")
+        raise typer.Exit()
+
+
+@app.command()
+def main(
+    path: Optional[Path] = typer.Argument(
+        None,
+        help="Directory to scan for projects (optional)",
+        exists=True,
+    ),
+    version: Optional[bool] = typer.Option(
+        None,
+        "--version",
+        "-v",
+        help="Show version and exit",
+        callback=version_callback,
+        is_eager=True,
+    ),
+    verbose: bool = typer.Option(False, "--verbose", help="Enable verbose logging"),
+    debug: bool = typer.Option(False, "--debug", help="Enable debug mode"),
+    setup: bool = typer.Option(False, "--setup", help="Run first-time setup"),
+    add: bool = typer.Option(False, "--add", help="Add a manual project path"),
+    remove: bool = typer.Option(False, "--remove", help="Remove a manual path"),
+    list_projects: bool = typer.Option(False, "--list", help="List all projects"),
+    recent: bool = typer.Option(False, "--recent", help="Jump to last opened project"),
+    clone: bool = typer.Option(False, "--clone", help="Clone a git repository"),
+) -> None:
+    """Launch Claude Code with interactive project selection.
+
+    Examples:
+        claude-launcher                    # Use configured paths
+        claude-launcher ~/projects         # Scan specific directory
+        claude-launcher /home/user/work    # Scan absolute path
+    """
+
+    # Setup logging
+    logger = setup_logging(verbose=verbose or debug)
+    logger.debug("Claude Launcher starting")
+    logger.debug(f"Version: {__version__}")
+
+    # Initialize config and storage
+    config_manager = ConfigManager()
+    storage = Storage(get_database_path())
+
+    logger.debug(f"Config path: {config_manager.config_path}")
+    logger.debug(f"Database path: {storage.db_path}")
+
+    # Handle --setup
+    if setup:
+        config = config_manager.run_first_time_setup()
+        sys.exit(0)
+
+    # Load config
+    config = config_manager.load()
+
+    # Determine scan paths: CLI argument takes precedence over config
+    if path:
+        scan_paths = [path.resolve()]
+    elif config.scan.paths:
+        scan_paths = config.scan.paths
+    else:
+        print("Error: No directory specified.")
+        print("")
+        print("Usage:")
+        print("  claude-launcher ~/projects        # Scan a specific directory")
+        print("  claude-launcher --setup           # Run setup wizard")
+        print("  claude-launcher --help            # Show all options")
+        sys.exit(1)
+
+    # Handle --add
+    if add:
+        print("Select a directory to add as a manual project path...")
+        selected_path = browse_directory()
+        if selected_path:
+            storage.add_manual_path(selected_path)
+            print(f"Added: {selected_path}")
+        sys.exit(0)
+
+    # Handle --remove
+    if remove:
+        remove_manual_path(storage)
+        sys.exit(0)
+
+    # Handle --clone
+    if clone:
+        cloned_path = interactive_clone(storage)
+        if cloned_path:
+            print(f"Launching Claude in: {cloned_path}")
+            launch_claude(cloned_path, storage)
+        sys.exit(0)
+
+    # Get all projects
+    manual_projects = storage.get_manual_projects()
+    all_projects = get_all_projects(
+        scan_paths,
+        config.scan.max_depth,
+        config.scan.prune_dirs,
+        manual_projects,
+    )
+
+    # Handle --list
+    if list_projects:
+        show_project_list(all_projects)
+        sys.exit(0)
+
+    # Handle --recent
+    if recent:
+        last_opened = storage.get_last_opened()
+        if not last_opened:
+            print("No recent project found.")
+            sys.exit(1)
+
+        project_path = Path(last_opened)
+        if not project_path.exists():
+            print(f"Last opened project not found: {project_path}")
+            sys.exit(1)
+
+        print(f"Launching Claude in: {project_path}")
+        launch_claude(project_path, storage)
+        sys.exit(0)
+
+    # Interactive selection
+    selected_project = select_project(
+        all_projects, storage, config.ui.show_git_status, config_manager, scan_paths
+    )
+
+    if selected_project is None:
+        print("Claude Launcher: No project selected")
+        sys.exit(0)
+
+    # Launch Claude
+    print(f"Launching Claude in: {selected_project.path}")
+    launch_claude(selected_project.path, storage)
+
+
+def launch_claude(project_path: Path, storage: Storage) -> None:
+    """Launch Claude Code in the specified project directory.
+
+    Args:
+        project_path: Path to the project
+        storage: Storage instance for tracking
+    """
+    # Verify directory exists
+    if not project_path.exists():
+        print(f"Error: Directory not found: {project_path}")
+        sys.exit(1)
+
+    # Record as last opened
+    storage.set_last_opened(project_path)
+
+    # Change to project directory
+    os.chdir(project_path)
+
+    # Launch Claude
+    try:
+        subprocess.run(["claude"], check=True)  # nosec B603, B607
+    except FileNotFoundError:
+        print("Error: 'claude' command not found.")
+        print("Make sure Claude Code CLI is installed.")
+        sys.exit(1)
+    except subprocess.CalledProcessError as e:
+        print(f"Error launching Claude: {e}")
+        sys.exit(1)
+    except KeyboardInterrupt:
+        print("\nInterrupted by user.")
+        sys.exit(0)
+
+
+if __name__ == "__main__":
+    app()

claude_launcher/core/__init__.py

@@ -0,0 +1 @@
+"""Core functionality for claude-launcher."""

claude_launcher/core/config.py

@@ -0,0 +1,250 @@
+"""Configuration management for claude-launcher."""
+
+import sys
+from pathlib import Path
+from typing import Any, Dict, Optional
+
+from platformdirs import user_config_path, user_data_path
+
+from claude_launcher.utils.paths import expand_path
+
+# Handle TOML parsing for different Python versions
+if sys.version_info >= (3, 11):
+    import tomllib
+else:
+    try:
+        import tomli as tomllib
+    except ImportError:
+        tomllib = None
+
+import tomli_w
+
+from claude_launcher.core.models import ConfigData, HistoryConfig, ScanConfig, UIConfig
+
+
+class ConfigManager:
+    """Manages configuration loading, saving, and validation."""
+
+    def __init__(self, config_path: Optional[Path] = None):
+        """Initialize configuration manager.
+
+        Args:
+            config_path: Optional path to config file. If None, uses platform default.
+        """
+        if config_path is None:
+            self.config_path = user_config_path("claude-launcher") / "config.toml"
+        else:
+            self.config_path = config_path
+
+        self.config_path.parent.mkdir(parents=True, exist_ok=True)
+
+    def load(self) -> ConfigData:
+        """Load configuration from file.
+
+        Returns:
+            ConfigData instance with loaded or default values
+
+        Raises:
+            RuntimeError: If tomli/tomllib is not available
+        """
+        if not self.config_path.exists():
+            return self._get_defaults()
+
+        if tomllib is None:
+            raise RuntimeError(
+                "TOML parsing not available. Install tomli: pip install tomli"
+            )
+
+        try:
+            with open(self.config_path, "rb") as f:
+                data = tomllib.load(f)
+                return self._parse_config(data)
+        except Exception as e:
+            print(f"Warning: Error loading config: {e}")
+            print("Falling back to defaults")
+            return self._get_defaults()
+
+    def save(self, config: ConfigData) -> None:
+        """Save configuration to file.
+
+        Args:
+            config: ConfigData to save
+        """
+        data = self._config_to_dict(config)
+
+        self.config_path.parent.mkdir(parents=True, exist_ok=True)
+        with open(self.config_path, "wb") as f:
+            tomli_w.dump(data, f)
+
+    def _get_defaults(self) -> ConfigData:
+        """Get default configuration.
+
+        Returns:
+            ConfigData with sensible defaults
+        """
+        return ConfigData(
+            scan=ScanConfig(
+                paths=[],
+                max_depth=5,
+            ),
+            ui=UIConfig(
+                preview_width=70,
+                show_git_status=True,
+            ),
+            history=HistoryConfig(
+                max_entries=50,
+            ),
+        )
+
+    def _parse_config(self, data: Dict[str, Any]) -> ConfigData:
+        """Parse TOML data into ConfigData.
+
+        Args:
+            data: Raw TOML dictionary
+
+        Returns:
+            Parsed ConfigData instance
+        """
+        # Parse scan config
+        scan_data = data.get("scan", {})
+        scan_paths = [self._expand_path(p) for p in scan_data.get("paths", [])]
+        scan = ScanConfig(
+            paths=scan_paths,
+            max_depth=scan_data.get("max_depth", 5),
+            prune_dirs=scan_data.get(
+                "prune_dirs",
+                [
+                    "node_modules",
+                    ".cache",
+                    "venv",
+                    "__pycache__",
+                    ".git",
+                    ".venv",
+                    "env",
+                    "ENV",
+                ],
+            ),
+        )
+
+        # Parse UI config
+        ui_data = data.get("ui", {})
+        ui = UIConfig(
+            preview_width=ui_data.get("preview_width", 70),
+            show_git_status=ui_data.get("show_git_status", True),
+        )
+
+        # Parse history config
+        history_data = data.get("history", {})
+        history = HistoryConfig(
+            max_entries=history_data.get("max_entries", 50),
+        )
+
+        return ConfigData(scan=scan, ui=ui, history=history)
+
+    def _config_to_dict(self, config: ConfigData) -> Dict[str, Any]:
+        """Convert ConfigData to dictionary for TOML serialization.
+
+        Args:
+            config: ConfigData to convert
+
+        Returns:
+            Dictionary suitable for TOML serialization
+        """
+        return {
+            "scan": {
+                "paths": [str(p) for p in config.scan.paths],
+                "max_depth": config.scan.max_depth,
+                "prune_dirs": config.scan.prune_dirs,
+            },
+            "ui": {
+                "preview_width": config.ui.preview_width,
+                "show_git_status": config.ui.show_git_status,
+            },
+            "history": {
+                "max_entries": config.history.max_entries,
+            },
+        }
+
+    def _expand_path(self, path_str: str) -> Path:
+        """Expand path with ~ and environment variables.
+
+        Args:
+            path_str: Path string to expand
+
+        Returns:
+            Expanded Path object
+        """
+        return expand_path(path_str)
+
+    def run_first_time_setup(self) -> ConfigData:
+        """Run interactive first-time setup wizard.
+
+        Returns:
+            ConfigData with user-provided values
+        """
+        try:
+            print("=== Claude Launcher First-Time Setup ===\n")
+
+            # Get scan paths
+            paths = []
+            print("Enter directories to scan for projects (one per line).")
+            print("Common examples: ~/projects, ~/work, ~/code")
+            print("Press Enter on empty line when done.\n")
+
+            while True:
+                path_input = input("Directory path: ").strip()
+                if not path_input:
+                    break
+
+                try:
+                    expanded_path = self._expand_path(path_input)
+                    if not expanded_path.exists():
+                        print(f"  Warning: {expanded_path} does not exist")
+                        confirm = input("  Add anyway? (y/n): ").strip().lower()
+                        if confirm != "y":
+                            continue
+
+                    paths.append(expanded_path)
+                    print(f"  Added: {expanded_path}")
+                except Exception as e:
+                    print(f"  Error: {e}")
+
+            if not paths:
+                print("\nNo paths added. You can add them later with --setup")
+
+            # Create config
+            config = self._get_defaults()
+            config.scan.paths = paths
+
+            # Save config
+            self.save(config)
+            print(f"\nConfiguration saved to: {self.config_path}")
+
+            return config
+
+        except KeyboardInterrupt:
+            print("\n\nSetup cancelled.")
+            import sys
+
+            sys.exit(0)
+
+
+def get_data_dir() -> Path:
+    """Get the data directory for claude-launcher.
+
+    Returns:
+        Path to data directory (for database, cache, etc.)
+    """
+    data_dir = Path(user_data_path("claude-launcher"))
+    data_dir.mkdir(parents=True, exist_ok=True)
+    return data_dir
+
+
+def get_database_path() -> Path:
+    """Get the path to the SQLite database.
+
+    Returns:
+        Path to database file
+    """
+    data_dir = get_data_dir()
+    return data_dir / "projects.db"

claude_launcher/core/discovery.py

@@ -0,0 +1,97 @@
+"""Project discovery for claude-launcher."""
+
+import os
+from pathlib import Path
+from typing import List
+
+from claude_launcher.core.models import Project
+
+
+def scan_for_git_repos(
+    scan_paths: List[Path],
+    max_depth: int,
+    prune_dirs: List[str],
+) -> List[Project]:
+    """Recursively scan directories for git repositories.
+
+    Args:
+        scan_paths: List of base directories to scan
+        max_depth: Maximum depth to traverse
+        prune_dirs: Directory names to skip during traversal
+
+    Returns:
+        List of discovered Project instances
+    """
+    projects = []
+    seen_paths = set()
+
+    for base_path in scan_paths:
+        if not base_path.exists() or not base_path.is_dir():
+            continue
+
+        base_str = str(base_path.resolve())
+
+        for root, dirs, _ in os.walk(base_path, followlinks=False):
+            # Calculate current depth
+            depth = root[len(base_str) :].count(os.sep)
+
+            if depth > max_depth:
+                dirs[:] = []  # Stop deeper traversal
+                continue
+
+            # Remove pruned directories from traversal
+            dirs[:] = [d for d in dirs if d not in prune_dirs]
+
+            # Check if this is a git repository
+            if ".git" in os.listdir(root):
+                project_path = Path(root).resolve()
+                path_str = str(project_path)
+
+                # Avoid duplicates
+                if path_str not in seen_paths:
+                    seen_paths.add(path_str)
+                    projects.append(Project.from_path(project_path, is_manual=False))
+
+    return projects
+
+
+def get_all_projects(
+    scan_paths: List[Path],
+    max_depth: int,
+    prune_dirs: List[str],
+    manual_projects: List[Project],
+) -> List[Project]:
+    """Get all projects (discovered + manual), sorted alphabetically.
+
+    Args:
+        scan_paths: Directories to scan for git repos
+        max_depth: Maximum scan depth
+        prune_dirs: Directories to skip
+        manual_projects: Manually added projects
+
+    Returns:
+        Sorted list of all unique projects
+    """
+    # Scan for git repositories
+    discovered = scan_for_git_repos(scan_paths, max_depth, prune_dirs)
+
+    # Remove duplicates (prefer manual over discovered)
+    seen_paths = set()
+    unique_projects = []
+
+    # Process manual first (they take precedence)
+    for project in sorted(manual_projects, key=lambda p: str(p.path)):
+        path_str = str(project.path)
+        if path_str not in seen_paths:
+            seen_paths.add(path_str)
+            unique_projects.append(project)
+
+    # Then add discovered projects
+    for project in discovered:
+        path_str = str(project.path)
+        if path_str not in seen_paths:
+            seen_paths.add(path_str)
+            unique_projects.append(project)
+
+    # Sort alphabetically by path
+    return sorted(unique_projects, key=lambda p: str(p.path))

claude_launcher/core/models.py

@@ -0,0 +1,129 @@
+"""Data models for claude-launcher."""
+
+from dataclasses import dataclass, field
+from pathlib import Path
+from typing import List, Optional
+
+
+@dataclass
+class Project:
+    """Represents a project that can be launched with Claude."""
+
+    path: Path
+    name: str
+    parent_path: Path
+    is_git_repo: bool
+    is_manual: bool
+
+    @classmethod
+    def from_path(cls, path: Path, is_manual: bool = False) -> "Project":
+        """Create a Project from a filesystem path.
+
+        Args:
+            path: Path to the project directory
+            is_manual: Whether this was manually added (vs auto-discovered)
+
+        Returns:
+            Project instance
+        """
+        # For manual projects, don't resolve symlinks so they appear under their symlink location
+        # For discovered projects, resolve to avoid duplicates
+        if is_manual:
+            resolved_path = path
+        else:
+            resolved_path = path.resolve()
+
+        is_git = (resolved_path / ".git").exists()
+        return cls(
+            path=resolved_path,
+            name=resolved_path.name,
+            parent_path=resolved_path.parent,
+            is_git_repo=is_git,
+            is_manual=is_manual,
+        )
+
+    def __str__(self) -> str:
+        """String representation showing path."""
+        return str(self.path)
+
+
+@dataclass
+class ScanConfig:
+    """Configuration for project scanning."""
+
+    paths: List[Path] = field(default_factory=list)
+    max_depth: int = 5
+    prune_dirs: List[str] = field(
+        default_factory=lambda: [
+            "node_modules",
+            ".cache",
+            "venv",
+            "__pycache__",
+            ".git",
+            ".venv",
+            "env",
+            "ENV",
+        ]
+    )
+
+
+@dataclass
+class UIConfig:
+    """Configuration for user interface."""
+
+    preview_width: int = 70
+    show_git_status: bool = True
+
+
+@dataclass
+class HistoryConfig:
+    """Configuration for history tracking."""
+
+    max_entries: int = 50
+
+
+@dataclass
+class ConfigData:
+    """Complete configuration for claude-launcher."""
+
+    scan: ScanConfig = field(default_factory=ScanConfig)
+    ui: UIConfig = field(default_factory=UIConfig)
+    history: HistoryConfig = field(default_factory=HistoryConfig)
+
+
+@dataclass
+class PreviewContent:
+    """Content to display in the project preview pane."""
+
+    claude_md: Optional[str] = None
+    git_status: Optional[str] = None
+    directory_listing: Optional[str] = None
+    error: Optional[str] = None
+
+    def format(self) -> str:
+        """Format preview content for display.
+
+        Returns:
+            Formatted string for fzf preview pane
+        """
+        lines = []
+
+        if self.error:
+            lines.append(f"ERROR: {self.error}")
+            return "\n".join(lines)
+
+        if self.claude_md:
+            lines.append("=== CLAUDE.md ===")
+            lines.append(self.claude_md)
+            lines.append("")
+
+        if self.git_status:
+            lines.append("=== Git Status ===")
+            lines.append(self.git_status)
+            lines.append("")
+
+        if self.directory_listing:
+            lines.append("=== Directory ===")
+            lines.append(self.directory_listing)
+
+        return "\n".join(lines) if lines else "No preview available"