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

cicada/install.py

@@ -251,7 +251,15 @@ def detect_installation_method():
         ".local/share/uv/tools" in script_path_str
         or ".local/bin/cicada-" in script_path_str
     ):
-        # Installed via uv tool install
+        # Installed via uv tool install - check for cicada-mcp first
+        if shutil.which("cicada-mcp"):
+            return (
+                "cicada-mcp",
+                [],
+                None,
+                "uv tool install (ensure ~/.local/bin is in PATH)",
+            )
+        # Fall back to cicada-server for backwards compatibility
         return (
             "cicada-server",
             [],
@@ -259,7 +267,11 @@ def detect_installation_method():
             "uv tool install (ensure ~/.local/bin is in PATH)",
         )
 
-    # Check if cicada-server is in PATH (from uv tool install)
+    # Check if cicada-mcp is in PATH first (from uv tool install)
+    if shutil.which("cicada-mcp"):
+        return ("cicada-mcp", [], None, "uv tool install (permanent, fast)")
+
+    # Fall back to cicada-server for backwards compatibility
     if shutil.which("cicada-server"):
         return ("cicada-server", [], None, "uv tool install (permanent, fast)")
 
@@ -279,8 +291,13 @@ def check_tools_in_path():
     """Check if cicada tools are in PATH."""
     import shutil
 
-    tools = ["cicada-server", "cicada-index"]
+    # Check for cicada-mcp (new) or cicada-server (backwards compat)
+    has_mcp_server = shutil.which("cicada-mcp") or shutil.which("cicada-server")
+    tools = ["cicada-index"]
     visible_tools = [tool for tool in tools if shutil.which(tool)]
+    if has_mcp_server:
+        visible_tools.insert(0, "cicada-mcp/cicada-server")
+        tools.insert(0, "cicada-mcp/cicada-server")
 
     if len(visible_tools) == len(tools):
         return "all_visible"
@@ -351,8 +368,8 @@ def create_mcp_config(repo_path, _cicada_dir, _python_bin):
     print(f"✓ MCP configuration updated at {mcp_config_path}")
 
     # Show what was configured
-    if command == "cicada-server":
-        print("✅ Using 'cicada-server' command (fast, no paths needed)")
+    if command in ("cicada-mcp", "cicada-server"):
+        print(f"✅ Using '{command}' command (fast, no paths needed)")
     else:
         print(f"ℹ️  Using Python: {command}")
 

cicada/setup.py

@@ -102,9 +102,15 @@ def get_mcp_config_for_editor(
     # 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_server:
+    if has_cicada_mcp:
+        command = "cicada-mcp"
+        args = []
+        cwd = None
+    elif has_cicada_server:
         command = "cicada-server"
         args = []
         cwd = None
@@ -275,7 +281,8 @@ def setup(editor: EditorType, repo_path: Path | None = None) -> None:
     import shutil
     from cicada import __version__
 
-    if not shutil.which("cicada-server"):
+    # 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__}"

{cicada_mcp-0.1.4.dist-info → cicada_mcp-0.1.5.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: cicada-mcp
-Version: 0.1.4
+Version: 0.1.5
 Summary: An Elixir module search MCP server
 Author-email: wende <wende@hey.com>
 Maintainer-email: wende <wende@hey.com>
@@ -138,7 +138,7 @@ cicada claude  # or: cicada cursor, cicada vs
 
 **Available commands after installation:**
 - `cicada [claude|cursor|vs]` - One-command setup per project
-- `cicada-server` - MCP server (auto-started by editor)
+- `cicada-mcp` - MCP server (auto-started by editor)
 - `cicada-index` - Re-index code with custom options (medium/large spaCy models)
 - `cicada-index-pr` - Index pull requests for PR attribution
 - `cicada-install` - Legacy setup (creates `.cicada/` in repo)
@@ -169,6 +169,33 @@ uvx --from git+https://github.com/wende/cicada.git@latest cicada vs
 
 Once you're convinced, install permanently with `uv tool install` above!
 
+### Quick Setup for Cursor and Claude Code
+
+**For Cursor:**
+
+Click the install button at the top of this README or visit:
+[![Install MCP Server](https://cursor.com/deeplink/mcp-install-dark.svg)](https://cursor.com/en-US/install-mcp?name=cicada&config=eyJjb21tYW5kIjoidXZ4IC0tZnJvbSBnaXQraHR0cHM6Ly9naXRodWIuY29tL3dlbmRlL2NpY2FkYS5naXRAbGF0ZXN0IGNpY2FkYS1zZXJ2ZXIgLiJ9)
+
+**For Claude Code:**
+
+```bash
+# Option 1: Using claude mcp add command
+claude mcp add cicada -- uvx --from git+https://github.com/wende/cicada.git@latest cicada-mcp ./path/to/your/codebase
+
+# Option 2: Using setup script
+uvx --from git+https://github.com/wende/cicada.git@latest cicada claude
+```
+
+**Then for both editors,** run these commands in your codebase to generate keyword lookup and GitHub PR lookup databases:
+
+```bash
+# Generate keyword lookup database
+uvx --from git+https://github.com/wende/cicada.git@latest cicada-index .
+
+# Generate GitHub PR lookup database
+uvx --from git+https://github.com/wende/cicada.git@latest cicada-index-pr .
+```
+
 ---
 
 ## Quick Start
@@ -221,7 +248,7 @@ your-project/
 {
   "mcpServers": {
     "cicada": {
-      "command": "cicada-server",
+      "command": "cicada-mcp",
       "env": {
         "CICADA_REPO_PATH": "/path/to/project",
         "CICADA_CONFIG_DIR": "/home/user/.cicada/projects/<hash>"

{cicada_mcp-0.1.4.dist-info → cicada_mcp-0.1.5.dist-info}/RECORD

@@ -6,15 +6,14 @@ cicada/find_dead_code.py,sha256=xCheicrNbYhLvrPGgqVJJBbf_rAm_gXwnfONDWPnNI0,8288
 cicada/formatter.py,sha256=wwxD1nt1ub7HDeDRGc61JhpmgleNVlp0SfQG9QBgGns,36194
 cicada/git_helper.py,sha256=zhyqSfk90tCwndWYxhh-LxFmqqXB1Wki91uDkZRr7Js,24303
 cicada/indexer.py,sha256=gVj6Jwc-sZgcGZnueqpRqcn4Wu451qo6RVfGuQahaZ4,25249
-cicada/install.py,sha256=mM8hj1_45CkXUFbJd8ve8dqYyIzNY1HhNbVKbseiJ4s,23214
-cicada/keyword_extractor.py,sha256=9oEEU3cwv5prsWYn1P-nNFayArQeXgCFNzx4iaq1qhg,13425
+cicada/install.py,sha256=VU7OI031cM0S-Y7udXVRFs2hluQRI9S6tIm3XBLJL2w,23980
 cicada/keyword_search.py,sha256=pj5zSsYKX-pOeWyGI53ZRAZm91BnrEMHofGNoenoIqQ,21746
 cicada/lightweight_keyword_extractor.py,sha256=KtxcOjLPuoY6EjcWNvHvoZswcg9IoryMfG4EM3_LDMg,9172
 cicada/mcp_server.py,sha256=k_JnwQExgQ-dTAA-MfPTl8G02B9MEmVZJb8fAc_UnPY,60299
 cicada/mcp_tools.py,sha256=LHNyrpztmY0yk1Ysu3_I-ZE7KmngJJ0ukKd-1OJpenA,13805
 cicada/parser.py,sha256=uQlzYnQQicUWU-yF9LgvqDK-83xImzGlZOkjPoov8_I,4022
 cicada/pr_finder.py,sha256=FPSaGe5W4RwPi93VmyoIWcUZIaHLZdHsT7s_WCIvHBM,14214
-cicada/setup.py,sha256=n9hFlK4LmPG7ivCvnburXvD-7sWwZjCvz6sdWRD_d_0,9166
+cicada/setup.py,sha256=23TRe2dRQNG2XsTobwN4jpfQ6aOTRXp_cRp1zHqv6CI,9512
 cicada/version_check.py,sha256=c8BFl--ohKfLZYe_3tX40rKXydTR6FVGWiseGuIvcBk,3181
 cicada/extractors/__init__.py,sha256=Dnm_jjWMGPvaGmt1aZqcgpS964tak4hys5BFOjbCcg8,890
 cicada/extractors/base.py,sha256=reenF-Cngpg1LgueWsddYzGcmtHElSuNv1F5OlZRFpI,2487
@@ -40,9 +39,9 @@ cicada/utils/signature_builder.py,sha256=O76JfypSESNncQ_OppCAR7aUDz4ocBNPXEmI9uh
 cicada/utils/storage.py,sha256=wbw_Ma77v4uevDGTQP06Eu4m5V8IU6GkKUARYWXgj1A,2578
 cicada/utils/subprocess_runner.py,sha256=fibqu_YCCmQPvtTwaDkGkVyhGVSQ6oX235pBYavQW5M,5168
 cicada/utils/text_utils.py,sha256=_lt_65BcAVZa36QrTY84GR8v5m5oxvfPY3tr6PoNaxw,2923
-cicada_mcp-0.1.4.dist-info/licenses/LICENSE,sha256=ijMI5EAN1o3jl676-BOu0ELzlsBr2FqTRzmha9e1lug,1062
-cicada_mcp-0.1.4.dist-info/METADATA,sha256=pj5-4L2Bz3xn6w6r7HJTRwgPCTa-KiLNOUrTPREDLF0,18931
-cicada_mcp-0.1.4.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-cicada_mcp-0.1.4.dist-info/entry_points.txt,sha256=DFW2H5na_prQFHRcgcDOkziQCpzykOZuHO5cztoMA2Y,281
-cicada_mcp-0.1.4.dist-info/top_level.txt,sha256=xZCtaMDbCi2CKA5PExum99ZU54IJg5iognV-k44a1W0,7
-cicada_mcp-0.1.4.dist-info/RECORD,,
+cicada_mcp-0.1.5.dist-info/licenses/LICENSE,sha256=ijMI5EAN1o3jl676-BOu0ELzlsBr2FqTRzmha9e1lug,1062
+cicada_mcp-0.1.5.dist-info/METADATA,sha256=h0oThL5OxMrls5uEubs4LQOJCK9p8yx-MkFQHzaVq7o,19952
+cicada_mcp-0.1.5.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+cicada_mcp-0.1.5.dist-info/entry_points.txt,sha256=cwG5-3TwDGwFPiKiOC5gjlfvi9mBFc01EVtX2ZcXpcQ,317
+cicada_mcp-0.1.5.dist-info/top_level.txt,sha256=xZCtaMDbCi2CKA5PExum99ZU54IJg5iognV-k44a1W0,7
+cicada_mcp-0.1.5.dist-info/RECORD,,

{cicada_mcp-0.1.4.dist-info → cicada_mcp-0.1.5.dist-info}/entry_points.txt

@@ -5,4 +5,5 @@ cicada-find-dead-code = cicada.find_dead_code:main
 cicada-index = cicada.indexer:main
 cicada-index-pr = cicada.pr_indexer:main
 cicada-install = cicada.install:main
+cicada-mcp = cicada.mcp_server:main
 cicada-server = cicada.mcp_server:main

cicada/keyword_extractor.py

@@ -1,364 +0,0 @@
-"""
-Keyword Extraction using spaCy
-Advanced NLP-based keyword extraction for programming documentation
-
-DEPRECATED: This module is being replaced by lightweight_keyword_extractor.py
-which provides faster performance using lemminflect instead of spaCy.
-
-The spaCy-based extractor has been kept for backward compatibility and for
-cases where advanced NLP features are needed. For most use cases, prefer
-LightweightKeywordExtractor from cicada.lightweight_keyword_extractor.
-
-Performance comparison:
-- LightweightKeywordExtractor: ~0.1s startup time
-- KeywordExtractor (spaCy): ~2s startup time
-
-See: cicada.lightweight_keyword_extractor.LightweightKeywordExtractor
-"""
-
-from collections import Counter
-import re
-import sys
-import subprocess
-
-from cicada.utils import split_camel_snake_case
-
-# Lazy import spacy only when needed
-spacy = None
-
-
-def _ensure_spacy_imported():
-    """Import spacy only when needed."""
-    global spacy
-    if spacy is None:
-        import spacy as spacy_module
-
-        spacy = spacy_module
-
-
-class KeywordExtractor:
-    """Extract keywords from text using spaCy NLP."""
-
-    # spaCy model names for different sizes
-    SPACY_MODELS = {
-        "small": "en_core_web_sm",
-        "medium": "en_core_web_md",
-        "large": "en_core_web_lg",
-    }
-
-    def __init__(self, verbose: bool = False, model_size: str = "small"):
-        """
-        Initialize keyword extractor with lazy model loading.
-
-        Args:
-            verbose: If True, print status messages during initialization
-            model_size: Size of spaCy model to use ('small', 'medium', or 'large')
-                       Default is 'small'. Medium and large models provide better
-                       accuracy but are slower and require more memory.
-        """
-        self.verbose = verbose
-
-        # Validate model size
-        if model_size not in self.SPACY_MODELS:
-            raise ValueError(
-                f"Invalid model size '{model_size}'. "
-                f"Must be one of: {', '.join(self.SPACY_MODELS.keys())}"
-            )
-
-        self.model_size = model_size
-        self.model_name = self.SPACY_MODELS[model_size]
-        self.nlp = None  # Lazy-loaded on first use
-
-    def _ensure_model_loaded(self):
-        """
-        Ensure the spaCy model is loaded, downloading if necessary.
-        Only called when model is actually needed (lazy loading).
-        """
-        if self.nlp is not None:
-            return  # Already loaded
-
-        # Ensure spacy is imported
-        _ensure_spacy_imported()
-
-        if self.verbose:
-            print(f"Loading spaCy model ({self.model_size})...", file=sys.stderr)
-
-        try:
-            # Import the model directly as a Python package (fast failure if not installed)
-            import importlib
-
-            model_module = importlib.import_module(self.model_name)
-            self.nlp = model_module.load()
-            if self.verbose:
-                print("✓ Model loaded successfully", file=sys.stderr)
-        except (ImportError, AttributeError):
-            # Model not installed, download it
-            if self.verbose:
-                print(
-                    f"Model '{self.model_name}' not found. Downloading...",
-                    file=sys.stderr,
-                )
-
-            if not self._download_model():
-                raise RuntimeError(
-                    f"Failed to download spaCy model '{self.model_name}'. "
-                    f"Please install it manually with: python -m spacy download {self.model_name}"
-                )
-
-            # Try importing again after download
-            try:
-                import importlib
-
-                model_module = importlib.import_module(self.model_name)
-                self.nlp = model_module.load()
-                if self.verbose:
-                    print("✓ Model loaded successfully", file=sys.stderr)
-            except (ImportError, AttributeError) as e:
-                raise RuntimeError(
-                    f"Failed to load spaCy model '{self.model_name}' after download. "
-                    f"Please try installing it manually: python -m spacy download {self.model_name}"
-                ) from e
-
-    def _download_model(self) -> bool:
-        """
-        Download the spaCy model using uv pip install.
-
-        Returns:
-            True if download succeeded, False otherwise
-        """
-        # Model URLs for direct installation
-        model_urls = {
-            "en_core_web_sm": "https://github.com/explosion/spacy-models/releases/download/en_core_web_sm-3.8.0/en_core_web_sm-3.8.0-py3-none-any.whl",
-            "en_core_web_md": "https://github.com/explosion/spacy-models/releases/download/en_core_web_md-3.8.0/en_core_web_md-3.8.0-py3-none-any.whl",
-            "en_core_web_lg": "https://github.com/explosion/spacy-models/releases/download/en_core_web_lg-3.8.0/en_core_web_lg-3.8.0-py3-none-any.whl",
-        }
-
-        if self.model_name not in model_urls:
-            if self.verbose:
-                print(f"Unknown model: {self.model_name}", file=sys.stderr)
-            return False
-
-        model_url = model_urls[self.model_name]
-
-        # Use uv pip install (works in uv-managed environments)
-        try:
-            if self.verbose:
-                print(f"Running: uv pip install {model_url}", file=sys.stderr)
-
-            result = subprocess.run(
-                ["uv", "pip", "install", model_url],
-                capture_output=True,
-                text=True,
-                check=True,
-            )
-
-            if self.verbose and result.stdout:
-                print(result.stdout, file=sys.stderr)
-
-            return True
-        except FileNotFoundError:
-            if self.verbose:
-                print(
-                    "uv not found. Please install uv or manually install the model:",
-                    file=sys.stderr,
-                )
-                print(f"  uv pip install {model_url}", file=sys.stderr)
-            return False
-        except subprocess.CalledProcessError as e:
-            if self.verbose:
-                print(f"uv pip install failed: {e.stderr}", file=sys.stderr)
-            return False
-        except Exception as e:
-            if self.verbose:
-                print(f"Unexpected error during download: {e}", file=sys.stderr)
-            return False
-
-    def extract_code_identifiers(self, text):
-        """
-        Extract code-specific identifiers and their split words.
-
-        Returns a tuple of (identifiers, split_words) where:
-        - identifiers: original camelCase/PascalCase/snake_case identifiers
-        - split_words: individual words extracted from those identifiers
-        """
-        # Match camelCase, snake_case, PascalCase, and mixed patterns
-        patterns = [
-            r"\b[a-z]+[A-Z][a-zA-Z]*\b",  # camelCase (e.g., getUserData)
-            r"\b[A-Z]{2,}[a-z]+[a-zA-Z]*\b",  # Uppercase prefix + PascalCase (e.g., HTTPServer, XMLParser)
-            r"\b[A-Z][a-z]+[A-Z][a-zA-Z]*\b",  # PascalCase (e.g., UserController, PostgreSQL)
-            r"\b[a-z]+_[a-z_]+\b",  # snake_case (e.g., get_user_data)
-            r"\b[A-Z]{2,}\b",  # All UPPERCASE (e.g., HTTP, API, SQL)
-        ]
-
-        identifiers = []
-        for pattern in patterns:
-            matches = re.findall(pattern, text)
-            identifiers.extend(matches)
-
-        identifiers = list(set(identifiers))
-
-        # Split identifiers into individual words
-        split_words = []
-        for identifier in identifiers:
-            split_text = split_camel_snake_case(identifier)
-            # Extract individual words (lowercase, length > 1)
-            words = [
-                word.lower()
-                for word in split_text.split()
-                if len(word) > 1 and word.isalpha()
-            ]
-            split_words.extend(words)
-
-        return identifiers, list(set(split_words))
-
-    def extract_keywords_simple(self, text: str, top_n: int = 10) -> list[str]:
-        """
-        Extract keywords and return a simple list of keyword strings.
-
-        Args:
-            text: Input text to analyze
-            top_n: Number of top keywords to return
-
-        Returns:
-            List of keyword strings (e.g., ['authentication', 'user', 'validate'])
-        """
-        if not text or not text.strip():
-            return []
-
-        try:
-            self._ensure_model_loaded()
-            results = self.extract_keywords(text, top_n=top_n)
-            # Extract just the keyword strings from top_keywords tuples
-            return [keyword for keyword, _ in results["top_keywords"]]
-        except Exception as e:
-            if self.verbose:
-                print(f"Warning: Keyword extraction failed: {e}", file=sys.stderr)
-            return []
-
-    def extract_keywords(self, text, top_n=15):
-        """
-        Extract keywords using multiple strategies with emphasis on code identifiers.
-
-        Weighting strategy:
-        - Full code identifiers (e.g., getUserData, snake_case): 10x weight (exact match priority)
-        - Code split words (e.g., get, user, data): 3x weight (fuzzy match support)
-        - Regular words (nouns, verbs): 1x weight
-
-        Args:
-            text: Input text to analyze
-            top_n: Number of top keywords to return
-
-        Returns:
-            Dictionary with extracted keywords and analysis:
-            - top_keywords: List of (keyword, count) tuples, sorted by frequency
-            - code_identifiers: Original identifiers (weighted 10x)
-            - code_split_words: Words extracted from identifiers (weighted 3x)
-            - nouns, verbs, adjectives: Linguistic categories
-            - entities: Named entities found
-            - tf_scores: Term frequency scores
-            - stats: Text statistics
-        """
-        if not text or not text.strip():
-            return {
-                "top_keywords": [],
-                "nouns": [],
-                "verbs": [],
-                "adjectives": [],
-                "proper_nouns": [],
-                "noun_chunks": [],
-                "entities": [],
-                "code_identifiers": [],
-                "tf_scores": {},
-                "stats": {
-                    "total_tokens": 0,
-                    "total_words": 0,
-                    "unique_words": 0,
-                    "sentences": 0,
-                },
-            }
-        # Ensure model is loaded (lazy loading on first use)
-        self._ensure_model_loaded()
-
-        # Process with spaCy
-        doc = self.nlp(text)
-
-        # 1. Extract nouns (concepts)
-        nouns = [
-            token.lemma_.lower()
-            for token in doc
-            if token.pos_ == "NOUN" and not token.is_stop and len(token.text) > 2
-        ]
-
-        # 2. Extract verbs (actions)
-        verbs = [
-            token.lemma_.lower()
-            for token in doc
-            if token.pos_ == "VERB" and not token.is_stop and len(token.text) > 2
-        ]
-
-        # 3. Extract adjectives (descriptors)
-        adjectives = [
-            token.lemma_.lower()
-            for token in doc
-            if token.pos_ == "ADJ" and not token.is_stop
-        ]
-
-        # 4. Extract proper nouns (named entities, technologies)
-        proper_nouns = [token.text for token in doc if token.pos_ == "PROPN"]
-
-        # 5. Extract noun chunks (multi-word concepts)
-        noun_chunks = [
-            chunk.text.lower()
-            for chunk in doc.noun_chunks
-            if len(chunk.text.split()) > 1
-        ]
-
-        # 6. Extract named entities
-        entities = [(ent.text, ent.label_) for ent in doc.ents]
-
-        # 7. Extract code identifiers and their split words
-        code_identifiers, code_split_words = self.extract_code_identifiers(text)
-
-        # 8. Calculate keyword frequency (combining nouns, verbs, proper nouns, identifiers, and split code words)
-        # Give full code identifiers 10x weight for exact matching
-        # Give code split words 3x weight for fuzzy matching
-        code_identifiers_lower = [ident.lower() for ident in code_identifiers]
-        all_keywords = (
-            nouns
-            + verbs
-            + proper_nouns
-            + (code_identifiers_lower * 10)
-            + (code_split_words * 3)
-        )
-        keyword_freq = Counter(all_keywords)
-        top_keywords = keyword_freq.most_common(top_n)
-
-        # 9. Calculate TF scores (simple version)
-        total_words = len(
-            [token for token in doc if not token.is_stop and not token.is_punct]
-        )
-        tf_scores = {word: (freq / total_words) for word, freq in keyword_freq.items()}
-
-        # Statistics
-        stats = {
-            "total_tokens": len(doc),
-            "total_words": total_words,
-            "unique_words": len(set([t.text.lower() for t in doc if not t.is_punct])),
-            "sentences": len(list(doc.sents)),
-        }
-
-        return {
-            "top_keywords": top_keywords,
-            "nouns": list(set(nouns))[:20],
-            "verbs": list(set(verbs))[:20],
-            "adjectives": list(set(adjectives))[:15],
-            "proper_nouns": list(set(proper_nouns)),
-            "noun_chunks": list(set(noun_chunks))[:15],
-            "entities": entities,
-            "code_identifiers": code_identifiers,
-            "code_split_words": code_split_words,
-            "tf_scores": dict(
-                sorted(tf_scores.items(), key=lambda x: x[1], reverse=True)[:10]
-            ),
-            "stats": stats,
-        }