claude-launcher 0.1.0__py3-none-any.whl

claude_launcher/core/storage.py

@@ -0,0 +1,247 @@
+"""SQLite storage for claude-launcher."""
+
+import shutil
+import sqlite3
+import time
+from datetime import datetime
+from pathlib import Path
+from typing import List, Optional
+
+from claude_launcher.core.models import Project
+
+
+class Storage:
+    """Manages SQLite database for manual paths and history."""
+
+    def __init__(self, db_path: Path):
+        """Initialize storage.
+
+        Args:
+            db_path: Path to SQLite database file
+        """
+        self.db_path = db_path
+        self._ensure_database()
+
+    def _ensure_database(self) -> None:
+        """Ensure database exists and has correct schema."""
+        try:
+            # Try to connect and validate
+            conn = sqlite3.connect(self.db_path)
+            cursor = conn.cursor()
+
+            # Check if tables exist
+            cursor.execute("SELECT name FROM sqlite_master WHERE type='table'")
+            tables = {row[0] for row in cursor.fetchall()}
+
+            if "manual_projects" not in tables or "last_opened" not in tables:
+                # Create schema
+                self._create_schema(conn)
+            else:
+                # Validate we can query
+                cursor.execute("SELECT 1 FROM manual_projects LIMIT 1")
+
+            conn.close()
+
+        except sqlite3.DatabaseError as e:
+            print(f"Database corruption detected: {e}")
+            self._recover_database()
+
+    def _create_schema(self, conn: sqlite3.Connection) -> None:
+        """Create database schema.
+
+        Args:
+            conn: SQLite connection
+        """
+        cursor = conn.cursor()
+
+        # Manual projects table
+        cursor.execute(
+            """
+            CREATE TABLE IF NOT EXISTS manual_projects (
+                path TEXT PRIMARY KEY,
+                added_at TEXT NOT NULL
+            )
+        """
+        )
+
+        # Last opened project table (single row)
+        cursor.execute(
+            """
+            CREATE TABLE IF NOT EXISTS last_opened (
+                path TEXT PRIMARY KEY
+            )
+        """
+        )
+
+        # Access history (optional, for future analytics)
+        cursor.execute(
+            """
+            CREATE TABLE IF NOT EXISTS access_history (
+                id INTEGER PRIMARY KEY AUTOINCREMENT,
+                path TEXT NOT NULL,
+                accessed_at TEXT NOT NULL
+            )
+        """
+        )
+
+        cursor.execute(
+            """
+            CREATE INDEX IF NOT EXISTS idx_access_history_path
+            ON access_history(path)
+        """
+        )
+
+        cursor.execute(
+            """
+            CREATE INDEX IF NOT EXISTS idx_access_history_time
+            ON access_history(accessed_at)
+        """
+        )
+
+        conn.commit()
+
+    def _recover_database(self) -> None:
+        """Recover from corrupted database by backing up and recreating."""
+        if self.db_path.exists():
+            # Backup corrupted database
+            backup_path = self.db_path.with_suffix(f".db.backup.{int(time.time())}")
+            shutil.move(str(self.db_path), str(backup_path))
+            print(f"Corrupted database backed up to: {backup_path}")
+
+        # Create fresh database
+        self.db_path.parent.mkdir(parents=True, exist_ok=True)
+        conn = sqlite3.connect(self.db_path)
+        self._create_schema(conn)
+        conn.close()
+        print(f"Fresh database created at: {self.db_path}")
+
+    def add_manual_path(self, path: Path) -> None:
+        """Add a manual project path.
+
+        Args:
+            path: Path to add
+        """
+        conn = sqlite3.connect(self.db_path)
+        cursor = conn.cursor()
+
+        cursor.execute(
+            "INSERT OR REPLACE INTO manual_projects (path, added_at) VALUES (?, ?)",
+            (str(path), datetime.now().isoformat()),
+        )
+
+        conn.commit()
+        conn.close()
+
+    def remove_manual_path(self, path: str) -> None:
+        """Remove a manual project path.
+
+        Args:
+            path: Path string to remove
+        """
+        conn = sqlite3.connect(self.db_path)
+        cursor = conn.cursor()
+
+        cursor.execute("DELETE FROM manual_projects WHERE path = ?", (path,))
+
+        conn.commit()
+        conn.close()
+
+    def get_manual_paths(self) -> List[str]:
+        """Get all manual project paths.
+
+        Returns:
+            List of path strings
+        """
+        conn = sqlite3.connect(self.db_path)
+        cursor = conn.cursor()
+
+        cursor.execute("SELECT path FROM manual_projects ORDER BY path")
+        paths = [row[0] for row in cursor.fetchall()]
+
+        conn.close()
+        return paths
+
+    def get_manual_projects(self) -> List[Project]:
+        """Get manual projects, auto-removing non-existent paths.
+
+        Returns:
+            List of valid Project instances
+        """
+        paths = self.get_manual_paths()
+        valid_projects = []
+        invalid_paths = []
+
+        for path_str in paths:
+            # Don't resolve symlinks - keep the original path
+            # This ensures projects show up in the tree under their symlink location
+            path = Path(path_str).expanduser()
+
+            if path.exists() and path.is_dir():
+                project = Project.from_path(path, is_manual=True)
+                valid_projects.append(project)
+            else:
+                invalid_paths.append(path_str)
+                print(f"Removing non-existent manual path: {path_str}")
+
+        # Clean up invalid paths
+        for path_str in invalid_paths:
+            self.remove_manual_path(path_str)
+
+        return valid_projects
+
+    def set_last_opened(self, path: Path) -> None:
+        """Set the last opened project.
+
+        Args:
+            path: Path to the project
+        """
+        conn = sqlite3.connect(self.db_path)
+        cursor = conn.cursor()
+
+        # Clear existing and set new (single row table)
+        cursor.execute("DELETE FROM last_opened")
+        cursor.execute("INSERT INTO last_opened (path) VALUES (?)", (str(path),))
+
+        # Also record in access history
+        cursor.execute(
+            "INSERT INTO access_history (path, accessed_at) VALUES (?, ?)",
+            (str(path), datetime.now().isoformat()),
+        )
+
+        conn.commit()
+        conn.close()
+
+    def get_last_opened(self) -> Optional[str]:
+        """Get the last opened project path.
+
+        Returns:
+            Path string or None if no history
+        """
+        conn = sqlite3.connect(self.db_path)
+        cursor = conn.cursor()
+
+        cursor.execute("SELECT path FROM last_opened LIMIT 1")
+        row = cursor.fetchone()
+
+        conn.close()
+        result: Optional[str] = row[0] if row else None
+        return result
+
+    def get_default_selection_index(self, projects: List[Project]) -> int:
+        """Get the index of the last opened project in the list.
+
+        Args:
+            projects: Sorted list of projects
+
+        Returns:
+            Index of last opened project, or 0 if not found
+        """
+        last_opened = self.get_last_opened()
+        if not last_opened:
+            return 0
+
+        for i, project in enumerate(projects):
+            if str(project.path) == last_opened:
+                return i
+
+        return 0

claude_launcher/ui/__init__.py

@@ -0,0 +1 @@
+"""User interface components for claude-launcher."""

claude_launcher/ui/_preview_helper.py

@@ -0,0 +1,72 @@
+#!/usr/bin/env python3
+"""Preview helper script for fzf."""
+
+import sys
+from pathlib import Path
+
+from claude_launcher.ui.preview import generate_preview
+
+
+def main() -> None:
+    """Generate preview from fzf selection line."""
+    if len(sys.argv) < 2:
+        print("No selection provided")
+        return
+
+    line = sys.argv[1]
+
+    # Extract path from formatted line
+    # Format is: "absolute_path\t\ttree_display" or special markers
+    # Special marker: __SPACE__ (spacing line)
+    parts = line.split("\t\t", 1)
+
+    if len(parts) == 2 and parts[0] != "__SPACE__":
+        # Normal line - first field is absolute path (project or directory)
+        path_str = parts[0]
+    else:
+        # Spacing line or malformed - show nothing
+        return
+
+    try:
+        path = Path(path_str).expanduser().resolve()
+
+        # Show full path at top with divider
+        print(f"{path}")
+        print("━" * 80)
+        print()
+
+        # Check if it's a directory (folder header) or project
+        if path.is_dir() and not (path / ".git").exists():
+            # Directory header - show directory contents
+            print("Contents:")
+            print("─" * 40)
+            try:
+                # Separate directories and files
+                dirs = []
+                files = []
+                for item in path.iterdir():
+                    if item.is_dir():
+                        dirs.append(f"📁 {item.name}/")
+                    else:
+                        files.append(f"📄 {item.name}")
+
+                # Sort each group and combine (folders first)
+                items = sorted(dirs) + sorted(files)
+
+                # Show all items (no limit)
+                if items:
+                    print("\n".join(items))
+                else:
+                    print("(empty directory)")
+            except PermissionError:
+                print("(permission denied)")
+        else:
+            # Project directory - show full preview
+            preview = generate_preview(path, show_git_status=True)
+            print(preview.format())
+    except Exception as e:
+        print(f"Error generating preview: {e}")
+
+
+if __name__ == "__main__":
+    main()

claude_launcher/ui/browser.py

@@ -0,0 +1,196 @@
+"""Directory browser 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 browse_directory(start_path: Optional[Path] = None) -> Optional[Path]:
+    """Interactive directory browser for selecting a path.
+
+    Args:
+        start_path: Starting directory (default: ~/projects or ~)
+
+    Returns:
+        Selected directory Path or None if cancelled
+    """
+    # Start at ~/projects if it exists, otherwise ~
+    if start_path is None:
+        projects_dir = Path.home() / "projects"
+        start_path = projects_dir if projects_dir.exists() else Path.home()
+
+    current_path = start_path.resolve()
+
+    while True:
+        # Get directory contents
+        try:
+            items = []
+
+            # Add special navigation options
+            items.append(".")
+            items.append("..")
+
+            # Add subdirectories
+            dirs = []
+            for item in sorted(current_path.iterdir()):
+                if item.is_dir():
+                    # Show symlink indicator
+                    if item.is_symlink():
+                        dirs.append(item.name + "@")
+                    else:
+                        dirs.append(item.name)
+
+            items.extend(dirs)
+
+        except PermissionError:
+            print(f"Permission denied: {current_path}")
+            return None
+
+        # Build header
+        header = f"""╭─────────────────────────────────────────╮
+│         Directory Browser               │
+╰─────────────────────────────────────────╯
+Current: {current_path}
+
+. = Select this directory
+.. = Go up one level
+@ suffix = symlink"""
+
+        # Build preview command
+        preview_cmd = f"""
+if [[ {{}} == '.' ]]; then
+    echo 'Select: {current_path}'
+elif [[ {{}} == '..' ]]; then
+    echo 'Go to: {current_path.parent}'
+else
+    target='{current_path}/{{}}'
+    target=${{target%@}}
+    if [[ -L "$target" ]]; then
+        echo "Symlink to: $(readlink -f "$target")"
+        echo ''
+    fi
+    ls -la "$target" 2>/dev/null | head -20
+fi
+"""
+
+        # Run fzf
+        try:
+            process = subprocess.Popen(  # nosec B603, B607
+                [
+                    "fzf",
+                    "--height=80%",
+                    "--layout=reverse",
+                    "--border=rounded",
+                    f"--header={header}",
+                    "--header-first",
+                    "--prompt=> ",
+                    f"--preview={preview_cmd}",
+                    "--preview-window=right:60%:wrap",
+                ],
+                stdin=subprocess.PIPE,
+                stdout=subprocess.PIPE,
+                text=True,
+            )
+
+            stdout, _ = process.communicate(input="\n".join(items))
+
+            if process.returncode != 0:
+                return None
+
+            selected = stdout.strip()
+            if not selected:
+                return None
+
+        except FileNotFoundError:
+            print("Error: fzf not found")
+            return None
+
+        # Handle selection
+        if selected == ".":
+            # Select current directory
+            return current_path
+        elif selected == "..":
+            # Navigate up
+            current_path = current_path.parent
+        else:
+            # Navigate into subdirectory (strip @ if symlink)
+            dir_name = selected.rstrip("@")
+            current_path = current_path / dir_name
+
+
+def remove_manual_path(storage: "Storage") -> bool:
+    """Interactive removal of manual paths.
+
+    Args:
+        storage: Storage instance
+
+    Returns:
+        True if a path was removed, False otherwise
+    """
+
+    manual_paths = storage.get_manual_paths()
+
+    if not manual_paths:
+        print("No manual paths to remove.")
+        return False
+
+    # Build header
+    count = len(manual_paths)
+    header = f"""╭─────────────────────────────────────────╮
+│   Remove Manual Path ({count} total)        │
+╰─────────────────────────────────────────╯
+Select path to remove (Esc to cancel)"""
+
+    # Build preview command
+    preview_cmd = """
+echo 'Will remove:'
+echo ''
+echo '  {}'
+echo ''
+if [[ -d '{}' ]]; then
+    echo 'Directory exists'
+else
+    echo 'Directory does not exist'
+fi
+"""
+
+    # Run fzf
+    try:
+        process = subprocess.Popen(  # nosec B603, B607
+            [
+                "fzf",
+                "--height=50%",
+                "--layout=reverse",
+                "--border=rounded",
+                f"--header={header}",
+                "--header-first",
+                "--prompt=Remove > ",
+                f"--preview={preview_cmd}",
+                "--preview-window=right:60%:wrap",
+            ],
+            stdin=subprocess.PIPE,
+            stdout=subprocess.PIPE,
+            text=True,
+        )
+
+        stdout, _ = process.communicate(input="\n".join(manual_paths))
+
+        if process.returncode != 0:
+            print("Cancelled.")
+            return False
+
+        selected = stdout.strip()
+        if not selected:
+            print("Cancelled.")
+            return False
+
+    except FileNotFoundError:
+        print("Error: fzf not found")
+        return False
+
+    # Remove the path
+    storage.remove_manual_path(selected)
+    return True