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

cicada/pr_indexer/pr_index_builder.py

@@ -6,9 +6,10 @@ separating index construction logic from API and mapping concerns.
 """
 
 from datetime import datetime
-from typing import Dict, List, Any, Optional
+from typing import Any
 
-from cicada.utils import load_index as load_index_util, save_index as save_index_util
+from cicada.utils import load_index as load_index_util
+from cicada.utils import save_index as save_index_util
 
 
 class PRIndexBuilder:
@@ -31,8 +32,8 @@ class PRIndexBuilder:
         self.repo_name = repo_name
 
     def build_index(
-        self, prs: List[Dict[str, Any]], preserve_last_pr: Optional[int] = None
-    ) -> Dict[str, Any]:
+        self, prs: list[dict[str, Any]], preserve_last_pr: int | None = None
+    ) -> dict[str, Any]:
         """
         Build the index structure from PR data.
 
@@ -56,7 +57,7 @@ class PRIndexBuilder:
         total_comments = sum(len(pr.get("comments", [])) for pr in prs)
 
         # Build index structure
-        metadata: Dict[str, Any] = {
+        metadata: dict[str, Any] = {
             "repo_owner": self.repo_owner,
             "repo_name": self.repo_name,
             "last_indexed_at": datetime.now().isoformat(),
@@ -65,7 +66,7 @@ class PRIndexBuilder:
             "total_comments": total_comments,
             "total_files": len(file_to_prs),
         }
-        index: Dict[str, Any] = {
+        index: dict[str, Any] = {
             "metadata": metadata,
             "prs": {str(pr["number"]): pr for pr in prs},
             "commit_to_pr": commit_to_pr,
@@ -86,7 +87,7 @@ class PRIndexBuilder:
         )
         return index
 
-    def _build_commit_mapping(self, prs: List[Dict[str, Any]]) -> Dict[str, int]:
+    def _build_commit_mapping(self, prs: list[dict[str, Any]]) -> dict[str, int]:
         """
         Build commit SHA -> PR number mapping.
 
@@ -103,7 +104,7 @@ class PRIndexBuilder:
                 commit_to_pr[commit] = pr_number
         return commit_to_pr
 
-    def _build_file_mapping(self, prs: List[Dict[str, Any]]) -> Dict[str, List[int]]:
+    def _build_file_mapping(self, prs: list[dict[str, Any]]) -> dict[str, list[int]]:
         """
         Build file path -> PR numbers mapping.
 
@@ -128,8 +129,8 @@ class PRIndexBuilder:
         return file_to_prs
 
     def merge_indexes(
-        self, existing_index: Dict[str, Any], new_prs: List[Dict[str, Any]]
-    ) -> Dict[str, Any]:
+        self, existing_index: dict[str, Any], new_prs: list[dict[str, Any]]
+    ) -> dict[str, Any]:
         """
         Merge new PRs into existing index.
 
@@ -155,29 +156,25 @@ class PRIndexBuilder:
         existing_index["file_to_prs"] = file_to_prs
 
         # Count total comments
-        total_comments = sum(
-            len(pr.get("comments", [])) for pr in existing_index["prs"].values()
-        )
+        total_comments = sum(len(pr.get("comments", [])) for pr in existing_index["prs"].values())
 
         # Update metadata
         existing_index["metadata"]["last_indexed_at"] = datetime.now().isoformat()
         existing_index["metadata"]["total_prs"] = len(existing_index["prs"])
-        existing_index["metadata"]["total_commits_mapped"] = len(
-            existing_index["commit_to_pr"]
-        )
+        existing_index["metadata"]["total_commits_mapped"] = len(existing_index["commit_to_pr"])
         existing_index["metadata"]["total_comments"] = total_comments
         existing_index["metadata"]["total_files"] = len(file_to_prs)
 
         # Update last_pr_number to the highest PR we have in the index
         if existing_index["prs"]:
-            all_pr_numbers = [int(num) for num in existing_index["prs"].keys()]
+            all_pr_numbers = [int(num) for num in existing_index["prs"]]
             existing_index["metadata"]["last_pr_number"] = max(all_pr_numbers)
 
         return existing_index
 
     def merge_partial_clean(
-        self, existing_index: Dict[str, Any], partial_index: Dict[str, Any]
-    ) -> Dict[str, Any]:
+        self, existing_index: dict[str, Any], partial_index: dict[str, Any]
+    ) -> dict[str, Any]:
         """
         Merge a partial clean build with an existing index.
 
@@ -202,17 +199,13 @@ class PRIndexBuilder:
             merged["prs"][pr_num_str] = pr_data
 
         # Rebuild commit -> PR mapping from scratch
-        merged["commit_to_pr"] = self._build_commit_mapping(
-            list(merged["prs"].values())
-        )
+        merged["commit_to_pr"] = self._build_commit_mapping(list(merged["prs"].values()))
 
         # Rebuild file -> PRs mapping from scratch
         merged["file_to_prs"] = self._build_file_mapping(list(merged["prs"].values()))
 
         # Count total comments
-        total_comments = sum(
-            len(pr.get("comments", [])) for pr in merged["prs"].values()
-        )
+        total_comments = sum(len(pr.get("comments", [])) for pr in merged["prs"].values())
 
         # Update metadata (use partial_index's last_pr_number which was preserved)
         merged["metadata"]["last_indexed_at"] = datetime.now().isoformat()
@@ -220,17 +213,12 @@ class PRIndexBuilder:
         merged["metadata"]["total_commits_mapped"] = len(merged["commit_to_pr"])
         merged["metadata"]["total_comments"] = total_comments
         merged["metadata"]["total_files"] = len(merged["file_to_prs"])
-        merged["metadata"]["last_pr_number"] = partial_index["metadata"].get(
-            "last_pr_number", 0
-        )
+        merged["metadata"]["last_pr_number"] = partial_index["metadata"].get("last_pr_number", 0)
 
-        print(
-            f"Merged: {len(merged['prs'])} total PRs "
-            f"({len(partial_index['prs'])} new/updated)"
-        )
+        print(f"Merged: {len(merged['prs'])} total PRs ({len(partial_index['prs'])} new/updated)")
         return merged
 
-    def load_existing_index(self, index_path: str) -> Optional[Dict[str, Any]]:
+    def load_existing_index(self, index_path: str) -> dict[str, Any] | None:
         """
         Load existing index file if it exists.
 
@@ -242,7 +230,7 @@ class PRIndexBuilder:
         """
         return load_index_util(index_path, verbose=True, raise_on_error=False)
 
-    def save_index(self, index: Dict[str, Any], output_path: str) -> None:
+    def save_index(self, index: dict[str, Any], output_path: str) -> None:
         """
         Save index to file.
 

cicada/setup.py

@@ -2,28 +2,26 @@
 """
 Cicada Simplified Setup Script.
 
-One-command setup: uvx cicada [claude|cursor|vs]
+One-command setup: uvx --from cicada-mcp cicada [claude|cursor|vs]
 - Indexes the repository with keyword extraction
 - Stores all files in temp directory (~/.cicada/projects/<hash>/)
 - Creates only MCP config file in user's repo
+- Generates MCP config that uses 'uvx cicada-mcp' (works with or without permanent install)
 """
 
 import argparse
 import json
 import sys
 from pathlib import Path
-from typing import Literal
+from typing import Any, Literal, cast
 
 from cicada.indexer import ElixirIndexer
 from cicada.utils import (
     create_storage_dir,
-    get_index_path,
     get_config_path,
-    get_hashes_path,
-    get_storage_dir,
+    get_index_path,
 )
 
-
 EditorType = Literal["claude", "cursor", "vs"]
 
 
@@ -41,21 +39,19 @@ def _load_existing_config(config_path: Path) -> dict:
         return {}
 
     try:
-        with open(config_path, "r") as f:
+        with open(config_path) as f:
             return json.load(f)
     except json.JSONDecodeError as e:
-        print(
-            f"Warning: Existing config at {config_path} is malformed, creating new one: {e}"
-        )
+        print(f"Warning: Existing config at {config_path} is malformed, creating new one: {e}")
         return {}
-    except IOError as e:
+    except OSError as e:
         print(f"Warning: Could not read config file {config_path}: {e}")
         return {}
 
 
 def _build_server_config(
     command: str, args: list, cwd: str | None, repo_path: Path, storage_dir: Path
-) -> dict:
+) -> dict[str, Any]:
     """
     Build the MCP server configuration.
 
@@ -69,7 +65,7 @@ def _build_server_config(
     Returns:
         Server configuration dict
     """
-    server_config = {"command": command}
+    server_config: dict[str, Any] = {"command": command}
 
     if args:
         server_config["args"] = args
@@ -99,26 +95,11 @@ def get_mcp_config_for_editor(
     Returns:
         Tuple of (config_file_path, config_content)
     """
-    # Detect installation method
-    import shutil
-
-    # Check for cicada-mcp first (new name), fall back to cicada-server (backwards compat)
-    has_cicada_mcp = shutil.which("cicada-mcp") is not None
-    has_cicada_server = shutil.which("cicada-server") is not None
-
-    if has_cicada_mcp:
-        command = "cicada-mcp"
-        args = []
-        cwd = None
-    elif has_cicada_server:
-        command = "cicada-server"
-        args = []
-        cwd = None
-    else:
-        python_bin = sys.executable
-        command = str(python_bin)
-        args = ["-m", "cicada.mcp_server"]
-        cwd = None
+    # Always use uvx for maximum compatibility
+    # Works whether cicada-mcp is permanently installed or not
+    command = "uvx"
+    args = ["cicada-mcp"]
+    cwd = None
 
     # Editor-specific specifications
     editor_specs = {
@@ -143,7 +124,7 @@ def get_mcp_config_for_editor(
         raise ValueError(f"Unsupported editor: {editor}")
 
     spec = editor_specs[editor]
-    config_path = spec["config_path"]
+    config_path = cast(Path, spec["config_path"])
 
     # Create parent directory if needed
     if spec["needs_dir"]:
@@ -163,134 +144,262 @@ def get_mcp_config_for_editor(
     return config_path, config
 
 
-def create_config_yaml(repo_path: Path, storage_dir: Path) -> None:
+def create_config_yaml(
+    repo_path: Path,
+    storage_dir: Path,
+    keyword_method: str | None = None,
+    keyword_tier: str | None = None,
+    verbose: bool = True,
+) -> None:
     """
     Create config.yaml in storage directory.
 
     Args:
         repo_path: Path to the repository
         storage_dir: Path to the storage directory
+        keyword_method: Keyword extraction method ('lemminflect' or 'bert'), None for default
+        keyword_tier: Model tier ('fast', 'regular', 'max'), None for default
+        verbose: If True, print success message. If False, silently create config.
     """
     config_path = get_config_path(repo_path)
     index_path = get_index_path(repo_path)
 
+    # Default to lemminflect if not specified
+    if keyword_method is None:
+        keyword_method = "lemminflect"
+    if keyword_tier is None:
+        keyword_tier = "regular"
+
     config_content = f"""repository:
   path: {repo_path}
 
 storage:
   index_path: {index_path}
+
+keyword_extraction:
+  method: {keyword_method}
+  tier: {keyword_tier}
 """
 
     with open(config_path, "w") as f:
         f.write(config_content)
 
-    print(f"✓ Config file created at {config_path}")
+    if verbose:
+        print(f"✓ Config file created at {config_path}")
 
 
-def index_repository(repo_path: Path) -> None:
+def index_repository(repo_path: Path, force_full: bool = False, verbose: bool = True) -> None:
     """
     Index the repository with keyword extraction enabled.
 
     Args:
         repo_path: Path to the repository
+        force_full: If True, force full reindex instead of incremental
+        verbose: Whether to print progress messages (default: True)
 
     Raises:
         Exception: If indexing fails
     """
     try:
         index_path = get_index_path(repo_path)
-        indexer = ElixirIndexer(verbose=True)
+        indexer = ElixirIndexer(verbose=verbose)
 
-        # Index with keyword extraction enabled by default
-        # Note: Using 'small' model for compatibility with uvx
-        # For better accuracy, install permanently and use cicada-index with --spacy-model medium/large
-        indexer.index_repository(
+        # Use incremental indexing by default (unless force_full is True)
+        indexer.incremental_index_repository(
             repo_path=str(repo_path),
             output_path=str(index_path),
             extract_keywords=True,
-            spacy_model="small",
+            force_full=force_full,
         )
-
-        print(f"✓ Repository indexed at {index_path}")
+        # Don't print duplicate message - indexer already reports completion
     except Exception as e:
-        print(f"Error: Failed to index repository: {e}")
-        print("Please check that the repository contains valid Elixir files.")
+        if verbose:
+            print(f"Error: Failed to index repository: {e}")
+            print("Please check that the repository contains valid Elixir files.")
         raise
 
 
-def setup(editor: EditorType, repo_path: Path | None = None) -> None:
+def setup_multiple_editors(
+    editors: list[EditorType],
+    repo_path: Path,
+    storage_dir: Path,
+    verbose: bool = False,
+) -> None:
+    """
+    Create MCP configs for multiple editors at once (for server mode).
+
+    Args:
+        editors: List of editor types to configure
+        repo_path: Path to the repository
+        storage_dir: Path to the storage directory
+        verbose: If True, print progress messages
+    """
+    for editor in editors:
+        try:
+            config_path, config_content = get_mcp_config_for_editor(editor, repo_path, storage_dir)
+
+            # Write config file
+            with open(config_path, "w") as f:
+                json.dump(config_content, f, indent=2)
+
+            if verbose:
+                print(f"✓ Created {editor.upper()} config at {config_path}")
+        except Exception as e:
+            if verbose:
+                print(f"⚠ Error creating {editor.upper()} config: {e}")
+
+
+def setup(
+    editor: EditorType,
+    repo_path: Path | None = None,
+    keyword_method: str | None = None,
+    keyword_tier: str | None = None,
+    index_exists: bool = False,
+) -> None:
     """
     Run the complete setup for the specified editor.
 
     Args:
         editor: Editor type (claude, cursor, vs)
         repo_path: Path to the repository (defaults to current directory)
+        keyword_method: Keyword extraction method ('lemminflect' or 'bert'), None for default
+        keyword_tier: Model tier ('fast', 'regular', 'max'), None for default
+        index_exists: If True, skip banner and show condensed output (index already exists)
     """
     # Determine repository path
     if repo_path is None:
         repo_path = Path.cwd()
     repo_path = repo_path.resolve()
 
-    print("=" * 60)
-    print(f"Cicada Setup for {editor.upper()}")
-    print("=" * 60)
-    print()
-
     # Create storage directory
-    print(f"Repository: {repo_path}")
     storage_dir = create_storage_dir(repo_path)
-    print(f"Storage: {storage_dir}")
-    print()
 
-    # Index repository
-    index_repository(repo_path)
-    print()
+    # Show condensed output if index already exists
+    if index_exists:
+        # Determine method and tier for display
+        display_method = keyword_method if keyword_method else "lemminflect"
+        display_tier = keyword_tier if keyword_tier else "regular"
+        print(f"✓ Found existing index ({display_method.upper()} {display_tier})")
+        # Skip indexing when index_exists is True - we're just reusing it
+        should_index = False
+        force_full = False
+        # Ensure config.yaml is up to date with current settings
+        create_config_yaml(repo_path, storage_dir, keyword_method, keyword_tier, verbose=False)
+    else:
+        # Show full banner for new setup
+        print("=" * 60)
+        print(f"Cicada Setup for {editor.upper()}")
+        print("=" * 60)
+        print()
+        print(f"Repository: {repo_path}")
+        print(f"Storage: {storage_dir}")
+        print()
 
-    # Create config.yaml
-    create_config_yaml(repo_path, storage_dir)
-    print()
+        # Check if config already exists and determine if we need to reindex
+        config_path = get_config_path(repo_path)
+        index_path = get_index_path(repo_path)
+        should_index = True
+        force_full = False
+
+        if config_path.exists() and index_path.exists():
+            import yaml
+
+            try:
+                with open(config_path) as f:
+                    existing_config = yaml.safe_load(f)
+                    existing_method = existing_config.get("keyword_extraction", {}).get(
+                        "method", "lemminflect"
+                    )
+                    existing_tier = existing_config.get("keyword_extraction", {}).get(
+                        "tier", "regular"
+                    )
+
+                    # Determine new method and tier (default to lemminflect/regular if not specified)
+                    new_method = keyword_method if keyword_method else "lemminflect"
+                    new_tier = keyword_tier if keyword_tier else "regular"
+
+                    # Check if settings changed
+                    settings_changed = (existing_method != new_method) or (
+                        existing_tier != new_tier
+                    )
+
+                    if settings_changed:
+                        print("=" * 60)
+                        print("⚠️  WARNING: Index Already Exists")
+                        print("=" * 60)
+                        print()
+                        print(
+                            f"This repository already has an index with {existing_method.upper()} ({existing_tier}) keyword extraction."
+                        )
+                        print(f"You are now switching to {new_method.upper()} ({new_tier}).")
+                        print()
+                        print(
+                            "This will require reindexing the ENTIRE codebase, which may take several minutes."
+                        )
+                        print()
+
+                        # Ask for confirmation
+                        response = input("Do you want to continue? [y/N]: ").strip().lower()
+                        if response not in ("y", "yes"):
+                            print("\nSetup cancelled.")
+                            sys.exit(0)
+                        print()
+                        force_full = True  # Force full reindex when settings change
+                    else:
+                        # Settings unchanged - just use existing index
+                        print(f"✓ Using existing index ({existing_method}, {existing_tier})")
+                        print()
+                        should_index = False
+            except Exception:
+                # If we can't read the config, just proceed with indexing
+                pass
+
+        # Create/update config.yaml BEFORE indexing (indexer reads this to determine keyword method)
+        create_config_yaml(repo_path, storage_dir, keyword_method, keyword_tier, verbose=False)
+
+        # Index repository if needed
+        if should_index:
+            index_repository(repo_path, force_full=force_full)
+            print()
 
     # Create MCP config for the editor
-    config_path, config_content = get_mcp_config_for_editor(
-        editor, repo_path, storage_dir
-    )
+    config_path, config_content = get_mcp_config_for_editor(editor, repo_path, storage_dir)
+
+    # Check if MCP config already exists
+    mcp_config_existed = config_path.exists()
 
     # Write config file
     with open(config_path, "w") as f:
         json.dump(config_content, f, indent=2)
 
-    print(f"✓ MCP configuration created at {config_path}")
-    print()
-
-    print("=" * 60)
-    print("✓ Setup Complete!")
-    print("=" * 60)
-    print()
-    print("Next steps:")
-    print(f"1. Restart {editor.upper()}")
-    print("2. Cicada MCP server will be available automatically")
-    print()
-    print("Storage location:")
-    print(f"  {storage_dir}")
-    print()
-    print("All index files are stored outside your repository.")
-    print(f"Only {config_path.name} was added to your repo.")
-    print()
+    if index_exists:
+        # Show condensed success message
+        mcp_verb = "updated" if mcp_config_existed else "created"
+        print(f"✓ MCP configuration {mcp_verb} at {config_path}")
+        print()
+        print(f"Storage: {storage_dir}")
+        print()
+        print(f"Restart {editor.upper()}.")
+        print("To reindex from scratch: cicada clean -f")
+        print()
+    else:
+        # Show simplified success message for first-time setup
+        print(f"Project config created at: {config_path}")
+        print()
+        print(f"Restart {editor.upper()}.")
+        print()
 
     # Check if running via uvx and suggest permanent installation
     import shutil
-    from cicada import __version__
 
     # Check for either cicada-mcp or cicada-server (backwards compat)
     if not (shutil.which("cicada-mcp") or shutil.which("cicada-server")):
         print("💡 Tip: For best experience, install Cicada permanently:")
-        print(
-            f"   uv tool install git+https://github.com/wende/cicada.git@v{__version__}"
-        )
+        print("   uv tool install cicada-mcp")
         print()
         print("   Benefits:")
-        print("   • Faster MCP server startup")
-        print("   • Access to cicada-index with medium/large spaCy models")
+        print("   • Faster MCP server startup (no uvx overhead)")
+        print("   • Access to cicada-index with enhanced keyword extraction (BERT/lemminflect)")
         print("   • PR indexing with cicada-index-pr")
         print()
 
@@ -299,7 +408,7 @@ def main():
     """Main entry point for the simplified setup script."""
     parser = argparse.ArgumentParser(
         description="Cicada One-Command Setup",
-        epilog="Example: uvx cicada claude",
+        epilog="Example: uvx --from cicada-mcp cicada claude",
     )
     parser.add_argument(
         "editor",

cicada/utils/__init__.py

@@ -5,27 +5,27 @@ This package contains shared utilities used across the codebase to reduce
 code duplication and improve maintainability.
 """
 
-from .subprocess_runner import SubprocessRunner, run_git_command, run_gh_command
-from .path_utils import normalize_file_path, resolve_to_repo_root
+from .call_site_formatter import CallSiteFormatter
+from .function_grouper import FunctionGrouper
 from .index_utils import (
     load_index,
-    save_index,
     merge_indexes_incremental,
+    save_index,
     validate_index_structure,
 )
-from .function_grouper import FunctionGrouper
-from .call_site_formatter import CallSiteFormatter
+from .path_utils import normalize_file_path, resolve_to_repo_root
 from .signature_builder import SignatureBuilder
-from .text_utils import split_identifier, split_camel_snake_case
 from .storage import (
-    get_repo_hash,
-    get_storage_dir,
     create_storage_dir,
-    get_index_path,
     get_config_path,
     get_hashes_path,
+    get_index_path,
     get_pr_index_path,
+    get_repo_hash,
+    get_storage_dir,
 )
+from .subprocess_runner import SubprocessRunner, run_gh_command, run_git_command
+from .text_utils import split_camel_snake_case, split_identifier
 
 __all__ = [
     "SubprocessRunner",

cicada/utils/call_site_formatter.py

@@ -5,7 +5,7 @@ This module provides utilities for grouping and formatting call sites,
 eliminating duplication in the formatter module.
 """
 
-from typing import Dict, List, Any, Tuple
+from typing import Any
 
 
 class CallSiteFormatter:
@@ -17,7 +17,7 @@ class CallSiteFormatter:
     """
 
     @staticmethod
-    def group_by_caller(call_sites: List[Dict[str, Any]]) -> List[Dict[str, Any]]:
+    def group_by_caller(call_sites: list[dict[str, Any]]) -> list[dict[str, Any]]:
         """
         Group call sites by their caller (calling_module + calling_function).
 
@@ -56,7 +56,7 @@ class CallSiteFormatter:
             #     'lines': [10, 20]
             # }]
         """
-        grouped: Dict[Tuple, Dict[str, Any]] = {}
+        grouped: dict[tuple, dict[str, Any]] = {}
 
         for site in call_sites:
             # Create a key based on caller identity
@@ -81,9 +81,7 @@ class CallSiteFormatter:
 
             grouped[key]["lines"].append(site["line"])
             if "code_line" in site:
-                grouped[key]["code_lines"].append(
-                    {"line": site["line"], "code": site["code_line"]}
-                )
+                grouped[key]["code_lines"].append({"line": site["line"], "code": site["code_line"]})
 
         # Convert back to list and sort lines
         result = []