cicada-mcp 0.2.0__py3-none-any.whl → 0.3.0__py3-none-any.whl

cicada/interactive_setup.py

@@ -2,7 +2,6 @@
 
 import sys
 from pathlib import Path
-from typing import cast
 
 try:
     from simple_term_menu import TerminalMenu
@@ -12,218 +11,271 @@ except ImportError:
     TerminalMenu = None  # type: ignore
     has_terminal_menu = False
 
-from cicada.ascii_art import generate_gradient_ascii_art
-from cicada.colors import BOLD, GREEN, GREY, PRIMARY, RESET, SELECTED
-from cicada.setup import EditorType
+from cicada.format import BOLD, GREY, PRIMARY, RESET, SELECTED, generate_gradient_ascii_art
+from cicada.interactive_setup_helpers import (
+    CLAUDE_MD_ITEMS,
+    EDITOR_ITEMS,
+    EDITOR_MAP_TEXT,
+    PR_ITEMS,
+    TIER_ITEMS,
+    TIER_MAP,
+    TIER_MAP_TEXT,
+    NotElixirProjectError,
+    add_to_claude_md,
+    check_elixir_project,
+    display_claude_md_selection,
+    display_editor_selection,
+    display_pr_indexing_selection,
+    display_tier_selection,
+    get_existing_config,
+    run_pr_indexing,
+    run_setup,
+)
+
+MENU_STYLE = {
+    "title": "",
+    "menu_cursor": "» ",
+    "menu_cursor_style": ("fg_yellow", "bold"),
+    "menu_highlight_style": ("fg_yellow", "bold"),
+    "cycle_cursor": True,
+    "clear_screen": False,
+}
+
+
+class MenuUnavailableError(Exception):
+    """Raised when TerminalMenu cannot be used for interactive prompts."""
+
+
+def _print_first_time_intro(show_header: bool) -> None:
+    """Render the ASCII art banner and intro text."""
+    if show_header:
+        print(generate_gradient_ascii_art())
+        print(f"{PRIMARY}{'=' * 70}{RESET}")
+        print(f"{SELECTED}🦗 Welcome to CICADA - Elixir Code Intelligence{RESET}")
+        print(f"{PRIMARY}{'=' * 70}{RESET}")
+    print()
+    print(f"This is your first time running CICADA in this project.{RESET}")
+    print(f"Let's configure keyword extraction for code intelligence.{RESET}")
+    print()
+
+
+def _prompt_menu_selection(items: list[str], cancel_message: str) -> int:
+    """Display a menu and return the selected index."""
+    if TerminalMenu is None:
+        raise MenuUnavailableError
 
+    try:
+        menu = TerminalMenu(items, **MENU_STYLE)  # type: ignore[arg-type]
+    except Exception:
+        raise MenuUnavailableError from None
 
-def _text_based_setup() -> tuple[str, str]:
+    try:
+        selection = menu.show()
+    except (KeyboardInterrupt, EOFError):
+        print()
+        print(cancel_message)
+        sys.exit(1)
+    except Exception:
+        raise MenuUnavailableError from None
+
+    if selection is None:
+        print()
+        print(cancel_message)
+        sys.exit(1)
+
+    if isinstance(selection, tuple):
+        selection = selection[0]
+
+    return int(selection)
+
+
+def _handle_menu_unavailable() -> tuple[str, str, bool, bool]:
+    """Fallback to text-based setup when TerminalMenu cannot be used."""
+    print(
+        f"\n{GREY}Note: Terminal menu not supported, using text-based input{RESET}\n",
+        file=sys.stderr,
+    )
+    return _text_based_setup()
+
+
+def _text_based_setup() -> tuple[str, str, bool, bool]:
     """
     Fallback text-based setup for terminals that don't support simple-term-menu.
 
     Returns:
-        tuple[str, str]: The selected extraction method and model tier
+        tuple[str, str, bool, bool]: The selected extraction method, expansion method,
+                                     whether to index PRs, and whether to add to CLAUDE.md
     """
-    print(f"{PRIMARY}{'=' * 70}{RESET}")
-    print(f"{SELECTED}🦗 Welcome to CICADA - Elixir Code Intelligence{RESET}")
-    print(f"{PRIMARY}{'=' * 70}{RESET}")
-    print()
-    print(f"This is your first time running CICADA in this project.{RESET}")
-    print(f"Let's configure keyword extraction for code intelligence.{RESET}")
-    print()
-    print(f"{BOLD}Step 1/2: Choose extraction method{RESET}")
+    _print_first_time_intro(show_header=True)
+    print(f"{BOLD}Step 1/3: Choose intelligence tier{RESET}")
     print()
-    print("1. Lemminflect - Grammar-based keyword extraction (fast, proven)")
-    print("2. KeyBERT - Semantic keyword extraction (AI embeddings)")
+    print("1. Fast - Term frequency + inflections (no downloads)")
+    print("2. Balanced - KeyBERT + GloVe semantic expansion (261MB)")
+    print("3. Maximum - KeyBERT + FastText expansion (1091MB)")
     print()
 
     while True:
         try:
-            method_choice = input("Enter your choice (1 or 2) [default: 1]: ").strip()
-            if not method_choice:
-                method_choice = "1"
-            if method_choice in ("1", "2"):
-                method = "lemminflect" if method_choice == "1" else "bert"
+            tier_choice = input("Enter your choice (1, 2, or 3) [default: 1]: ").strip()
+            if not tier_choice:
+                tier_choice = "1"
+            if tier_choice in TIER_MAP_TEXT:
+                method, expansion_method = TIER_MAP_TEXT[tier_choice]
                 break
-            print("Invalid choice. Please enter 1 or 2.")
+            print("Invalid choice. Please enter 1, 2, or 3.")
         except (KeyboardInterrupt, EOFError):
             print()
             print("Setup cancelled. Exiting...")
             sys.exit(1)
 
-    # For lemminflect, no tier selection - it's always the same
-    print()
-    if method == "lemminflect":
-        print(f"{BOLD}  What is Lemminflect?{RESET}")
-        print(f"   Lemminflect finds keywords using grammar rules + word importance{RESET}")
-        print()
-        print(f"{GREEN}✓{RESET} Selected: LEMMINFLECT")
-        print()
-        return ("lemminflect", "regular")
+    display_tier_selection(int(tier_choice) - 1)
 
-    # For KeyBERT, ask for tier
-    print(f"{SELECTED}  What is KeyBERT?{RESET}")
-    print(f"{PRIMARY}   KeyBERT uses AI embeddings to find semantically similar keywords{RESET}")
+    # Step 2: Ask about PR indexing
+    print(f"{BOLD}Step 2/3: Index pull requests?{RESET}")
+    print(f"{PRIMARY}   PR indexing enables fast offline lookup of GitHub PRs{RESET}")
+    print(f"{PRIMARY}   Useful for: finding which PR introduced code, viewing PR context{RESET}")
     print()
-    print("1. Fast (80MB, ~1s) - Recommended for bigger projects")
-    print("2. Regular (133MB, ~1.4s) - Better semantic understanding [recommended]")
-    print("3. Max (420MB, ~6.5s) - Highest quality embeddings")
-
-    print()
-    print(f"{BOLD}Step 2/2: Choose model tier{RESET}")
+    print("1. Yes - Index PRs now (requires GitHub access)")
+    print("2. No - Skip PR indexing (can run later with 'cicada-pr-indexer')")
     print()
 
     while True:
         try:
-            tier_choice = input("Enter your choice (1, 2, or 3) [default: 2]: ").strip()
-            if not tier_choice:
-                tier_choice = "2"
-            if tier_choice in ("1", "2", "3"):
-                tier_map = {"1": "fast", "2": "regular", "3": "max"}
-                tier = tier_map[tier_choice]
+            pr_choice = input("Enter your choice (1 or 2) [default: 2]: ").strip()
+            if not pr_choice:
+                pr_choice = "2"
+            if pr_choice in ("1", "2"):
+                index_prs = pr_choice == "1"
                 break
-            print("Invalid choice. Please enter 1, 2, or 3.")
+            print("Invalid choice. Please enter 1 or 2.")
         except (KeyboardInterrupt, EOFError):
             print()
             print(f"{SELECTED}Setup cancelled. Exiting...{RESET}")
             sys.exit(1)
 
+    display_pr_indexing_selection(index_prs)
+
+    # Step 3: Ask about adding to CLAUDE.md
+    print(f"{BOLD}Step 3/3: Augment CLAUDE.md for AI assistants?{RESET}")
+    print(f"{PRIMARY}   Add documentation to CLAUDE.md to help AI assistants{RESET}")
+    print(f"{PRIMARY}   understand when and how to use Cicada tools effectively{RESET}")
     print()
-    print(f"{GREEN}✓{RESET} Selected: KeyBERT - {tier.capitalize()} model")
+    print("1. Yes - Add Cicada usage guide to CLAUDE.md (recommended)")
+    print("2. No - Skip CLAUDE.md setup")
     print()
 
-    return ("bert", tier)
+    while True:
+        try:
+            claude_md_choice = input("Enter your choice (1 or 2) [default: 1]: ").strip()
+            if not claude_md_choice:
+                claude_md_choice = "1"
+            if claude_md_choice in ("1", "2"):
+                add_to_claude_md_flag = claude_md_choice == "1"
+                break
+            print("Invalid choice. Please enter 1 or 2.")
+        except (KeyboardInterrupt, EOFError):
+            print()
+            print(f"{SELECTED}Setup cancelled. Exiting...{RESET}")
+            sys.exit(1)
+
+    display_claude_md_selection(add_to_claude_md_flag)
+
+    return (method, expansion_method, index_prs, add_to_claude_md_flag)
 
 
-def show_first_time_setup() -> tuple[str, str]:
+def show_first_time_setup(show_welcome: bool = True) -> tuple[str, str, bool, bool]:
     """
     Display an interactive first-time setup menu for cicada.
 
     Falls back to text-based input if the terminal doesn't support simple-term-menu.
 
+    Args:
+        show_welcome: Whether to display the ASCII art banner and intro text.
+
     Returns:
-        tuple[str, str]: The selected extraction method and model tier
-                        e.g., ('lemminflect', 'regular') or ('bert', 'fast')
+        tuple[str, str, bool, bool]: The selected extraction method, expansion method,
+                                     whether to index PRs, and whether to add to CLAUDE.md
+                                     e.g., ('regular', 'lemmi', False, True) or ('bert', 'glove', True, True)
     """
     # Check if terminal menu is available and supported
     if not has_terminal_menu:
         return _text_based_setup()
 
-    # Display ASCII art
-    print(generate_gradient_ascii_art())
+    _print_first_time_intro(show_header=show_welcome)
+    print(f"{BOLD}Step 1/3: Choose intelligence tier{RESET}")
 
-    # Step 1: Choose extraction method
-    print(f"{PRIMARY}{'=' * 70}{RESET}")
-    print(f"{SELECTED}🦗 Welcome to CICADA - Elixir Code Intelligence{RESET}")
-    print(f"{PRIMARY}{'=' * 70}{RESET}")
-    print()
-    print(f"This is your first time running CICADA in this project.{RESET}")
-    print(f"Let's configure keyword extraction for code intelligence.{RESET}")
-    print()
-    print(f"{BOLD}Step 1/2: Choose extraction method{RESET}")
+    def _select_with_menu(items: list[str], cancel_message: str) -> int | None:
+        try:
+            return _prompt_menu_selection(items, cancel_message)
+        except MenuUnavailableError:
+            return None
 
-    method_items = [
-        "Lemminflect - Grammar-based keyword extraction (fast, proven)",
-        "KeyBERT - Semantic keyword extraction (AI embeddings)",
-    ]
+    tier_index = _select_with_menu(TIER_ITEMS, "Setup cancelled. Exiting...")
+    if tier_index is None:
+        return _handle_menu_unavailable()
 
-    try:
-        if TerminalMenu is None:
-            return _text_based_setup()
-        method_menu = TerminalMenu(
-            method_items,
-            title="",
-            menu_cursor="» ",
-            menu_cursor_style=("fg_yellow", "bold"),
-            menu_highlight_style=("fg_yellow", "bold"),
-            cycle_cursor=True,
-            clear_screen=False,
-        )
-        method_index = method_menu.show()
-    except (KeyboardInterrupt, EOFError):
-        print()
-        print("Setup cancelled. Exiting...")
-        sys.exit(1)
-    except Exception:
-        # Terminal doesn't support the menu - fall back to text-based
-        print(
-            f"\n{GREY}Note: Terminal menu not supported, using text-based input{RESET}\n",
-            file=sys.stderr,
-        )
-        return _text_based_setup()
+    method, expansion_method = TIER_MAP[tier_index]
+    display_tier_selection(tier_index)
 
-    if method_index is None:
-        print()
-        print("Setup cancelled. Exiting...")
-        sys.exit(1)
+    # Step 2: Ask about PR indexing
+    print(f"{BOLD}Step 2/3: Index pull requests?{RESET}")
+    print(f"{PRIMARY}   PR indexing enables fast offline lookup of GitHub PRs{RESET}")
+    print(f"{PRIMARY}   Useful for: finding which PR introduced code, viewing PR context{RESET}")
+    print()
 
-    method = "lemminflect" if method_index == 0 else "bert"
+    pr_index = _select_with_menu(
+        PR_ITEMS,
+        f"{SELECTED}Setup cancelled. Exiting...{RESET}",
+    )
+    if pr_index is None:
+        return _handle_menu_unavailable()
 
-    # For lemminflect, no tier selection - it's always the same
-    print()
-    if method == "lemminflect":
-        print(f"{BOLD}  What is Lemminflect?{RESET}")
-        print(f"   Lemminflect finds keywords using grammar rules + word importance{RESET}")
-        print(f'   Example: "We use Kubernetes for container orchestration"{RESET}')
-        print(f'   Output: "Kubernetes", "container", "orchestration"{RESET}')
-        print()
-        print(f"{GREEN}✓{RESET} Selected: LEMMINFLECT")
-        print()
-        return ("lemminflect", "regular")
+    index_prs = pr_index == 1
+    display_pr_indexing_selection(index_prs)
 
-    # For KeyBERT, ask for tier
-    print(f"{SELECTED}  What is KeyBERT?{RESET}")
-    print(f"{PRIMARY}   KeyBERT uses AI embeddings to find semantically similar keywords{RESET}")
-    print(f'{PRIMARY}   Example: "We use Kubernetes for container orchestration"{RESET}')
-    print(f'{PRIMARY}   Output: "Kubernetes", "deployment", "microservices", "DevOps"{RESET}')
+    # Step 3: Ask about adding to CLAUDE.md
+    print(f"{BOLD}Step 3/3: Augment CLAUDE.md for AI assistants?{RESET}")
+    print(f"{PRIMARY}   Add documentation to CLAUDE.md to help AI assistants{RESET}")
+    print(f"{PRIMARY}   understand when and how to use Cicada tools effectively{RESET}")
     print()
-    tier_items = [
-        "Fast (80MB, ~1s) - Recommended for bigger projects",
-        "Regular [recommended] (133MB, ~1.4s) - Better semantic understanding",
-        "Max (420MB, ~6.5s) - Highest quality embeddings",
-    ]
-    print(f"{SELECTED}Step 2/2: Choose model tier\n")
 
-    try:
-        if TerminalMenu is None:
-            return _text_based_setup()
-        tier_menu = TerminalMenu(
-            tier_items,
-            title="",
-            menu_cursor="» ",
-            menu_cursor_style=("fg_yellow", "bold"),
-            menu_highlight_style=("fg_yellow", "bold"),
-            cycle_cursor=True,
-            clear_screen=False,
-        )
-        tier_index = tier_menu.show()
-    except (KeyboardInterrupt, EOFError):
-        print()
-        print(f"{SELECTED}Setup cancelled. Exiting...{RESET}")
-        sys.exit(1)
-    except Exception:
-        # Terminal doesn't support the menu - fall back to text-based
-        print(
-            f"\n{GREY}Note: Terminal menu not supported, using text-based input{RESET}\n",
-            file=sys.stderr,
-        )
-        # Recreate the selection for model tier based on already selected method
-        return _text_based_setup()
+    claude_md_index = _select_with_menu(
+        CLAUDE_MD_ITEMS,
+        f"{SELECTED}Setup cancelled. Exiting...{RESET}",
+    )
+    if claude_md_index is None:
+        return _handle_menu_unavailable()
 
-    if tier_index is None:
-        print()
-        print(f"{SELECTED}Setup cancelled. Exiting...{RESET}")
-        sys.exit(1)
+    add_to_claude_md_flag = claude_md_index == 0  # "Yes" is at index 0
+    display_claude_md_selection(add_to_claude_md_flag)
 
-    tier_map = {0: "fast", 1: "regular", 2: "max"}
-    # Ensure tier_index is treated as int (TerminalMenu.show() returns int | tuple | None)
-    tier = tier_map[int(tier_index) if isinstance(tier_index, int) else tier_index[0]]
+    return (method, expansion_method, index_prs, add_to_claude_md_flag)
 
-    print()
-    print(f"{GREEN}✓{RESET} Selected: KeyBERT - {tier.capitalize()} model")
+
+def _text_based_editor_selection() -> str:
+    """
+    Fallback text-based editor selection for terminals that don't support simple-term-menu.
+
+    Returns:
+        str: The selected editor ('claude', 'cursor', or 'vs')
+    """
+    print("1. Claude Code - AI-powered code editor")
+    print("2. Cursor - AI-first code editor")
+    print("3. VS Code - Visual Studio Code")
     print()
 
-    return ("bert", tier)
+    while True:
+        try:
+            choice = input("Enter your choice (1, 2, or 3) [default: 1]: ").strip()
+            if not choice:
+                choice = "1"
+            if choice in EDITOR_MAP_TEXT:
+                return EDITOR_MAP_TEXT[choice]
+            print("Invalid choice. Please enter 1, 2, or 3.")
+        except (KeyboardInterrupt, EOFError):
+            print()
+            print("Setup cancelled. Exiting...")
+            sys.exit(1)
 
 
 def show_full_interactive_setup(repo_path: str | Path | None = None) -> None:
@@ -235,13 +287,27 @@ def show_full_interactive_setup(repo_path: str | Path | None = None) -> None:
     Args:
         repo_path: Path to the Elixir repository. Defaults to current directory.
     """
-    from cicada.setup import setup
+
+    # Helper to run setup with error handling
+    def _run_setup_with_error_handling(
+        editor: str,
+        repo_path: Path,
+        extraction_method: str,
+        expansion_method: str,
+        index_exists: bool = False,
+    ) -> None:
+        try:
+            run_setup(editor, repo_path, extraction_method, expansion_method, index_exists)
+        except Exception as e:
+            print(f"\n{PRIMARY}Error: Setup failed: {e}{RESET}")
+            sys.exit(1)
 
     # Check if we're in an Elixir project
     repo_path = Path.cwd() if repo_path is None else Path(repo_path).resolve()
-    if not (repo_path / "mix.exs").exists():
-        print(f"{PRIMARY}Error: {repo_path} does not appear to be an Elixir project{RESET}")
-        print(f"{GREY}(mix.exs not found){RESET}")
+    try:
+        check_elixir_project(repo_path)
+    except NotElixirProjectError as e:
+        print(f"{PRIMARY}Error: {e}{RESET}")
         print()
         print("Please run cicada from the root of an Elixir project.")
         sys.exit(1)
@@ -256,22 +322,15 @@ def show_full_interactive_setup(repo_path: str | Path | None = None) -> None:
     print()
     print(f"Let's set up Cicada for your editor and project.{RESET}")
     print()
-    print(f"{BOLD}Step 1/3: Choose your editor{RESET}")
-
-    editor_items = [
-        "Claude Code - AI-powered code editor",
-        "Cursor - AI-first code editor",
-        "VS Code - Visual Studio Code",
-    ]
+    print(f"{BOLD}Step 1/4: Choose your editor{RESET}")
 
     if has_terminal_menu:
         try:
             if TerminalMenu is None:
-                # Fallback to text-based
                 editor = _text_based_editor_selection()
             else:
                 editor_menu = TerminalMenu(
-                    editor_items,
+                    EDITOR_ITEMS,
                     title="",
                     menu_cursor="» ",
                     menu_cursor_style=("fg_yellow", "bold"),
@@ -286,7 +345,7 @@ def show_full_interactive_setup(repo_path: str | Path | None = None) -> None:
                     print("Setup cancelled. Exiting...")
                     sys.exit(1)
 
-                editor_map = {0: "claude", 1: "cursor", 2: "vs"}
+                editor_map = {0: "claude", 1: "cursor", 2: "vs", 3: "gemini", 4: "codex"}
                 editor = editor_map[
                     int(editor_index) if isinstance(editor_index, int) else editor_index[0]
                 ]
@@ -295,7 +354,6 @@ def show_full_interactive_setup(repo_path: str | Path | None = None) -> None:
             print("Setup cancelled. Exiting...")
             sys.exit(1)
         except Exception:
-            # Terminal doesn't support the menu - fall back to text-based
             print(
                 f"\n{GREY}Note: Terminal menu not supported, using text-based input{RESET}\n",
                 file=sys.stderr,
@@ -304,163 +362,31 @@ def show_full_interactive_setup(repo_path: str | Path | None = None) -> None:
     else:
         editor = _text_based_editor_selection()
 
-    print()
-    print(f"{GREEN}✓{RESET} Selected: {editor.upper()}")
-    print()
-
-    # Check if index already exists before showing model selection
-    from cicada.utils.storage import get_config_path, get_index_path
-
-    config_path = get_config_path(repo_path)
-    index_path = get_index_path(repo_path)
-
-    if config_path.exists() and index_path.exists():
-        # Index exists - use existing settings, don't show model selection
-        import yaml
-
-        try:
-            with open(config_path) as f:
-                existing_config = yaml.safe_load(f)
-                method = existing_config.get("keyword_extraction", {}).get("method", "lemminflect")
-                tier = existing_config.get("keyword_extraction", {}).get("tier", "regular")
-
-            # Run setup with existing settings
-            try:
-                setup(
-                    cast(EditorType, editor),
-                    repo_path,
-                    keyword_method=method,
-                    keyword_tier=tier,
-                    index_exists=True,
-                )
-            except Exception as e:
-                print(f"\n{PRIMARY}Error: Setup failed: {e}{RESET}")
-                sys.exit(1)
-
-            return  # Exit early - don't show model selection
-        except Exception:
-            # If we can't read config, proceed with model selection
-            pass
-
-    # Step 2: Choose keyword extraction method
-    print(f"{BOLD}Step 2/3: Choose extraction method{RESET}")
+    display_editor_selection(editor)
 
-    method_items = [
-        "Lemminflect - Grammar-based keyword extraction (fast, proven)",
-        "KeyBERT - Semantic keyword extraction (AI embeddings)",
-    ]
-
-    if has_terminal_menu:
-        try:
-            if TerminalMenu is None:
-                method, tier = show_first_time_setup()
-                return
-            method_menu = TerminalMenu(
-                method_items,
-                title="",
-                menu_cursor="» ",
-                menu_cursor_style=("fg_yellow", "bold"),
-                menu_highlight_style=("fg_yellow", "bold"),
-                cycle_cursor=True,
-                clear_screen=False,
-            )
-            method_index = method_menu.show()
-
-            if method_index is None:
-                print()
-                print("Setup cancelled. Exiting...")
-                sys.exit(1)
-
-            method = "lemminflect" if method_index == 0 else "bert"
-        except (KeyboardInterrupt, EOFError):
-            print()
-            print("Setup cancelled. Exiting...")
-            sys.exit(1)
-        except Exception:
-            print(
-                f"\n{GREY}Note: Terminal menu not supported, using text-based input{RESET}\n",
-                file=sys.stderr,
-            )
-            method, tier = show_first_time_setup()
-            return
-    else:
-        method, tier = show_first_time_setup()
-        return
-
-    # For lemminflect, no tier selection needed - always uses default
-    if method == "lemminflect":
-        print()
-        print(f"{BOLD}  What is Lemminflect?{RESET}")
-        print(f"   Lemminflect finds keywords using grammar rules + word importance{RESET}")
-        print()
-        print(f"{GREEN}✓{RESET} Selected: LEMMINFLECT")
-        print()
-        tier = "regular"  # Default tier (not used for lemminflect, but needed for API)
-    else:
-        # Step 3: Choose model tier (only for BERT)
-        print()
-        print(f"{SELECTED}  What is KeyBERT?{RESET}")
-        print(
-            f"{PRIMARY}   KeyBERT uses AI embeddings to find semantically similar keywords{RESET}"
+    # Check if index already exists
+    existing_config = get_existing_config(repo_path)
+    if existing_config is not None:
+        extraction_method, expansion_method = existing_config
+        _run_setup_with_error_handling(
+            editor, repo_path, extraction_method, expansion_method, index_exists=True
         )
+        return
 
-        tier_items = [
-            "Fast (80MB, ~1s) - Recommended for bigger projects",
-            "Regular [recommended] (133MB, ~1.4s) - Better semantic understanding",
-            "Max (420MB, ~6.5s) - Highest quality embeddings",
-        ]
-
-        print()
-        print(f"{BOLD}Step 3/3: Choose model tier{RESET}")
-        print()
-
-        try:
-            if TerminalMenu is None:
-                method, tier = show_first_time_setup()
-                return
-            tier_menu = TerminalMenu(
-                tier_items,
-                title="",
-                menu_cursor="» ",
-                menu_cursor_style=("fg_yellow", "bold"),
-                menu_highlight_style=("fg_yellow", "bold"),
-                cycle_cursor=True,
-                clear_screen=False,
-            )
-            tier_index = tier_menu.show()
-        except (KeyboardInterrupt, EOFError):
-            print()
-            print(f"{SELECTED}Setup cancelled. Exiting...{RESET}")
-            sys.exit(1)
-        except Exception:
-            print(
-                f"\n{GREY}Note: Terminal menu not supported, using text-based input{RESET}\n",
-                file=sys.stderr,
-            )
-            method, tier = show_first_time_setup()
-            return
-
-        if tier_index is None:
-            print()
-            print(f"{SELECTED}Setup cancelled. Exiting...{RESET}")
-            sys.exit(1)
-
-        tier_map = {0: "fast", 1: "regular", 2: "max"}
-        tier = tier_map[int(tier_index) if isinstance(tier_index, int) else tier_index[0]]
-
-        print()
-        print(f"{GREEN}✓{RESET} Selected: KeyBERT - {tier.capitalize()} model")
-        print()
+    extraction_method, expansion_method, index_prs, add_to_claude_md_flag = show_first_time_setup(
+        show_welcome=False
+    )
 
-    # Run setup
     print(f"{BOLD}Running setup...{RESET}")
     print()
 
-    try:
-        setup(cast(EditorType, editor), repo_path, keyword_method=method, keyword_tier=tier)
-    except Exception as e:
-        print(f"\n{PRIMARY}Error: Setup failed: {e}{RESET}")
-        sys.exit(1)
+    _run_setup_with_error_handling(editor, repo_path, extraction_method, expansion_method)
+
+    if index_prs:
+        run_pr_indexing(repo_path)
+
+    if add_to_claude_md_flag:
+        add_to_claude_md(repo_path)
 
 
 def _text_based_editor_selection() -> str:
@@ -468,22 +394,24 @@ def _text_based_editor_selection() -> str:
     Fallback text-based editor selection for terminals that don't support simple-term-menu.
 
     Returns:
-        str: The selected editor ('claude', 'cursor', or 'vs')
+        str: The selected editor ('claude', 'cursor', 'vs', 'gemini', or 'codex')
     """
     print("1. Claude Code - AI-powered code editor")
     print("2. Cursor - AI-first code editor")
     print("3. VS Code - Visual Studio Code")
+    print("4. Gemini CLI - Google Gemini command line interface")
+    print("5. Codex - AI code editor")
     print()
 
     while True:
         try:
-            choice = input("Enter your choice (1, 2, or 3) [default: 1]: ").strip()
+            choice = input("Enter your choice (1-5) [default: 1]: ").strip()
             if not choice:
                 choice = "1"
-            if choice in ("1", "2", "3"):
-                editor_map = {"1": "claude", "2": "cursor", "3": "vs"}
+            if choice in ("1", "2", "3", "4", "5"):
+                editor_map = {"1": "claude", "2": "cursor", "3": "vs", "4": "gemini", "5": "codex"}
                 return editor_map[choice]
-            print("Invalid choice. Please enter 1, 2, or 3.")
+            print("Invalid choice. Please enter 1-5.")
         except (KeyboardInterrupt, EOFError):
             print()
             print("Setup cancelled. Exiting...")