cicada-mcp 0.1.4__py3-none-any.whl

cicada/utils/text_utils.py

@@ -0,0 +1,90 @@
+"""
+Text utilities for identifier manipulation and processing.
+
+This module provides shared utilities for working with code identifiers,
+including splitting camelCase, PascalCase, and snake_case identifiers.
+"""
+
+import re
+from typing import List
+
+
+def split_identifier(identifier: str, lowercase: bool = True) -> List[str]:
+    """
+    Split an identifier by camelCase, PascalCase, and snake_case.
+
+    Handles various identifier patterns:
+    - snake_case: get_user_data -> ['get', 'user', 'data']
+    - camelCase: getUserData -> ['get', 'user', 'data']
+    - PascalCase: UserController -> ['user', 'controller']
+    - HTTPServer: HTTP Server -> ['http', 'server']
+    - PostgreSQL: Postgre SQL -> ['postgre', 'sql']
+    - getHTTPResponseCode -> ['get', 'http', 'response', 'code']
+
+    Args:
+        identifier: The identifier string to split
+        lowercase: If True, convert all words to lowercase (default: True)
+
+    Returns:
+        List of words from the identifier
+
+    Examples:
+        >>> split_identifier("getUserData")
+        ['get', 'user', 'data']
+        >>> split_identifier("HTTPServer")
+        ['http', 'server']
+        >>> split_identifier("snake_case_name")
+        ['snake', 'case', 'name']
+    """
+    if not identifier:
+        return []
+
+    # Handle snake_case
+    text = identifier.replace("_", " ")
+
+    # Split on transitions from lowercase to uppercase (camelCase)
+    # This handles: camelCase, PascalCase, and words ending with uppercase like PostgreSQL
+    text = re.sub(r"([a-z])([A-Z])", r"\1 \2", text)
+
+    # Split on transitions from uppercase sequence to a capitalized word (HTTPServer -> HTTP Server)
+    text = re.sub(r"([A-Z]+)([A-Z][a-z])", r"\1 \2", text)
+
+    # Split consecutive uppercase letters to separate potential acronyms
+    # This helps extract individual letters from acronyms at the end (e.g., SQL -> S Q L)
+    # But only if they're part of a longer word (not standalone acronyms)
+    text = re.sub(r"(?<=[a-z])([A-Z])(?=[A-Z])", r" \1", text)
+
+    # Split and filter
+    words = text.split()
+
+    if lowercase:
+        words = [word.lower() for word in words if word]
+    else:
+        words = [word for word in words if word]
+
+    return words
+
+
+def split_camel_snake_case(text: str) -> str:
+    """
+    Split camelCase, PascalCase, and snake_case identifiers into separate words as a string.
+
+    This is a convenience wrapper around split_identifier() that returns a space-separated
+    string instead of a list.
+
+    Args:
+        text: Input text containing identifiers
+
+    Returns:
+        String with identifiers split into separate words
+
+    Examples:
+        >>> split_camel_snake_case("camelCase")
+        'camel case'
+        >>> split_camel_snake_case("PascalCase")
+        'pascal case'
+        >>> split_camel_snake_case("snake_case")
+        'snake case'
+    """
+    words = split_identifier(text, lowercase=True)
+    return " ".join(words)

cicada/version_check.py

@@ -0,0 +1,116 @@
+"""
+Version checking utility.
+
+Checks if a newer version of cicada is available on GitHub.
+"""
+
+import subprocess
+from typing import Optional
+
+
+def get_current_version() -> str:
+    """
+    Get the current version of cicada from pyproject.toml.
+
+    Returns:
+        Current version string (e.g., "0.1.0")
+    """
+    from cicada import __version__
+
+    return __version__
+
+
+def get_latest_github_tag(repo: str = "wende/cicada") -> Optional[str]:
+    """
+    Get the latest tag from GitHub repository.
+
+    Args:
+        repo: GitHub repository in format "owner/repo"
+
+    Returns:
+        Latest tag name, or None if unable to fetch
+    """
+    try:
+        result = subprocess.run(
+            [
+                "gh",
+                "api",
+                f"repos/{repo}/tags",
+                "--jq",
+                ".[0].name",
+            ],
+            capture_output=True,
+            text=True,
+            timeout=5,
+        )
+
+        if result.returncode == 0 and result.stdout.strip():
+            tag = result.stdout.strip()
+            # Remove 'v' prefix if present (e.g., "v0.1.0" -> "0.1.0")
+            if tag.startswith("v"):
+                tag = tag[1:]
+            return tag
+
+        return None
+
+    except (subprocess.TimeoutExpired, FileNotFoundError, Exception):
+        # Silently fail - this is a non-critical check
+        return None
+
+
+def compare_versions(current: str, latest: str) -> bool:
+    """
+    Compare two version strings.
+
+    Args:
+        current: Current version (e.g., "0.1.0")
+        latest: Latest version (e.g., "0.2.0")
+
+    Returns:
+        True if latest is newer than current, False otherwise
+    """
+    try:
+        # Simple comparison by splitting on dots
+        current_parts = [int(x) for x in current.split(".")]
+        latest_parts = [int(x) for x in latest.split(".")]
+
+        # Pad with zeros if needed
+        max_len = max(len(current_parts), len(latest_parts))
+        current_parts += [0] * (max_len - len(current_parts))
+        latest_parts += [0] * (max_len - len(latest_parts))
+
+        return latest_parts > current_parts
+
+    except (ValueError, AttributeError):
+        # If we can't parse versions, assume they're the same
+        return False
+
+
+def check_for_updates() -> None:
+    """
+    Check if there's a newer version available on GitHub.
+
+    Prints a yellow warning message if a newer version is found.
+    This function never raises exceptions - it fails silently if unable to check.
+    """
+    try:
+        current = get_current_version()
+        latest = get_latest_github_tag()
+
+        if latest and compare_versions(current, latest):
+            # ANSI escape code for yellow text
+            yellow = "\033[93m"
+            reset = "\033[0m"
+
+            print(
+                f"{yellow}⚠️  A newer version of cicada is available: v{latest} (current: v{current}){reset}"
+            )
+            print(f"{yellow}   To update, run:{reset}")
+            print(
+                f"{yellow}   uv tool install git+https://github.com/wende/cicada.git{reset}"
+            )
+            print()
+
+    except Exception:
+        # Silently fail - version check is non-critical
+        pass