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

cicada/colors.py

@@ -0,0 +1,27 @@
+"""
+Shared ANSI color codes for Cicada CLI.
+
+This module provides consistent color definitions across all Cicada modules
+to eliminate code duplication and ensure brand consistency.
+"""
+
+# Brand colors - primary palette
+ORANGE = "\033[38;2;217;119;87m"  # #D97757 - Primary brand color (orange)
+YELLOW = "\033[38;2;229;200;144m"  # #E5C890 - Selected items/highlights
+SELECTED = YELLOW  # Alias for menu selections
+CYAN = ORANGE  # Deprecated alias - kept for backwards compatibility
+
+# Standard terminal colors
+BLUE = "\033[94m"
+GREEN = "\033[92m"
+RED = "\033[91m"
+GRAY = "\033[90m"
+GREY = GRAY  # British spelling alias
+
+# Modifiers
+BOLD = "\033[1m"
+DIM = "\033[2m"
+RESET = "\033[0m"
+
+# Composite styles (for convenience)
+PRIMARY = ORANGE  # Alias for primary brand color

cicada/command_logger.py

@@ -9,13 +9,13 @@ import json
 import tempfile
 from datetime import datetime
 from pathlib import Path
-from typing import Any, Dict, Optional
+from typing import Any
 
 
 class CommandLogger:
     """Logger for MCP tool executions."""
 
-    def __init__(self, log_dir: Optional[str] = None):
+    def __init__(self, log_dir: str | None = None):
         """Initialize the command logger.
 
         Args:
@@ -47,11 +47,11 @@ class CommandLogger:
     def log_command(
         self,
         tool_name: str,
-        arguments: Dict[str, Any],
+        arguments: dict[str, Any],
         response: Any,
         execution_time_ms: float,
-        timestamp: Optional[datetime] = None,
-        error: Optional[str] = None,
+        timestamp: datetime | None = None,
+        error: str | None = None,
     ) -> None:
         """Log a command execution.
 
@@ -102,11 +102,11 @@ class CommandLogger:
     async def log_command_async(
         self,
         tool_name: str,
-        arguments: Dict[str, Any],
+        arguments: dict[str, Any],
         response: Any,
         execution_time_ms: float,
-        timestamp: Optional[datetime] = None,
-        error: Optional[str] = None,
+        timestamp: datetime | None = None,
+        error: str | None = None,
     ) -> None:
         """Async version of log_command that runs file I/O in a thread pool.
 
@@ -166,9 +166,7 @@ class CommandLogger:
         log_files = sorted(self.log_dir.glob("*.jsonl"))
         return log_files
 
-    def read_logs(
-        self, date: Optional[str] = None, limit: Optional[int] = None
-    ) -> list[Dict[str, Any]]:
+    def read_logs(self, date: str | None = None, limit: int | None = None) -> list[dict[str, Any]]:
         """Read logs from file(s).
 
         Args:
@@ -206,7 +204,7 @@ class CommandLogger:
 
         return logs
 
-    def _read_log_file(self, file_path: Path) -> list[Dict[str, Any]]:
+    def _read_log_file(self, file_path: Path) -> list[dict[str, Any]]:
         """Read logs from a single JSONL file.
 
         Args:
@@ -217,7 +215,7 @@ class CommandLogger:
         """
         logs = []
         try:
-            with open(file_path, "r", encoding="utf-8") as f:
+            with open(file_path, encoding="utf-8") as f:
                 for line in f:
                     line = line.strip()
                     if line:
@@ -232,7 +230,7 @@ class CommandLogger:
 
         return logs
 
-    def clear_logs(self, older_than_days: Optional[int] = None) -> int:
+    def clear_logs(self, older_than_days: int | None = None) -> int:
         """Clear log files.
 
         Args:
@@ -275,10 +273,10 @@ class CommandLogger:
 
 
 # Global logger instance
-_global_logger: Optional[CommandLogger] = None
+_global_logger: CommandLogger | None = None
 
 
-def get_logger(log_dir: Optional[str] = None) -> CommandLogger:
+def get_logger(log_dir: str | None = None) -> CommandLogger:
     """Get or create the global command logger instance.
 
     Args:

cicada/dead_code_analyzer.py

@@ -6,8 +6,6 @@ Identifies potentially unused public functions using the indexed codebase data.
 Author: Cursor(Auto)
 """
 
-from typing import Dict, List, Optional
-
 
 class DeadCodeAnalyzer:
     """Analyzes Elixir code index to find potentially unused public functions."""
@@ -56,9 +54,7 @@ class DeadCodeAnalyzer:
         for module_name, module_data in self.modules.items():
             # Skip test files and .exs files entirely
             if self._is_test_file(module_data["file"]):
-                skipped_files += sum(
-                    1 for f in module_data["functions"] if f["type"] == "def"
-                )
+                skipped_files += sum(1 for f in module_data["functions"] if f["type"] == "def")
                 continue
 
             # Analyze each function in the module
@@ -77,9 +73,7 @@ class DeadCodeAnalyzer:
                 analyzed += 1
 
                 # Find usages of this function
-                usage_count = self._find_usages(
-                    module_name, function["name"], function["arity"]
-                )
+                usage_count = self._find_usages(module_name, function["name"], function["arity"])
 
                 # If function is used, skip it
                 if usage_count > 0:
@@ -149,14 +143,10 @@ class DeadCodeAnalyzer:
             # Test files
             "/test/" in file_lower
             or file_lower.startswith("test/")
-            or file_lower.endswith("_test.ex")
-            # All .exs files (scripts, config files, etc.)
-            or file_lower.endswith(".exs")
+            or file_lower.endswith(("_test.ex", ".exs"))
         )
 
-    def _find_usages(
-        self, target_module: str, target_function: str, target_arity: int
-    ) -> int:
+    def _find_usages(self, target_module: str, target_function: str, target_arity: int) -> int:
         """
         Find the number of times a function is called across the codebase.
 
@@ -203,9 +193,12 @@ class DeadCodeAnalyzer:
                         # Filter out calls that are BEFORE the function definition
                         # (@spec, @doc annotations appear 1-5 lines before the def)
                         # Only filter if call is before def and within 5 lines
-                        if function_def_line and call["line"] < function_def_line:
-                            if (function_def_line - call["line"]) <= 5:
-                                continue
+                        if (
+                            function_def_line
+                            and call["line"] < function_def_line
+                            and (function_def_line - call["line"]) <= 5
+                        ):
+                            continue
                         call_count += 1
                 else:
                     # Qualified call - resolve the module name
@@ -260,12 +253,12 @@ class DeadCodeAnalyzer:
         Returns:
             True if module appears in value_mentions of any other module
         """
-        for other_module, module_data in self.modules.items():
+        for _other_module, module_data in self.modules.items():
             if module_name in module_data.get("value_mentions", []):
                 return True
         return False
 
-    def _find_value_mentioners(self, module_name: str) -> List[dict]:
+    def _find_value_mentioners(self, module_name: str) -> list[dict]:
         """
         Find all modules that mention this module as a value.
 

cicada/extractors/__init__.py

@@ -6,18 +6,18 @@ This package contains specialized extractors for different parts of Elixir modul
 Author: Cursor(Auto)
 """
 
-from .module import extract_modules
-from .function import extract_functions
-from .spec import extract_specs, match_specs_to_functions
-from .doc import extract_docs, match_docs_to_functions
+from .call import extract_function_calls, extract_value_mentions
 from .dependency import (
     extract_aliases,
+    extract_behaviours,
     extract_imports,
     extract_requires,
     extract_uses,
-    extract_behaviours,
 )
-from .call import extract_function_calls, extract_value_mentions
+from .doc import extract_docs, match_docs_to_functions
+from .function import extract_functions
+from .module import extract_modules
+from .spec import extract_specs, match_specs_to_functions
 
 __all__ = [
     "extract_modules",

cicada/extractors/base.py

@@ -12,9 +12,9 @@ def extract_string_from_arguments(arguments_node, source_code: bytes) -> str | N
             string_content = []
             for string_child in child.children:
                 if string_child.type == "quoted_content":
-                    content = source_code[
-                        string_child.start_byte : string_child.end_byte
-                    ].decode("utf-8")
+                    content = source_code[string_child.start_byte : string_child.end_byte].decode(
+                        "utf-8"
+                    )
                     string_content.append(content)
 
             if string_content:

cicada/extractors/call.py

@@ -19,9 +19,7 @@ def _find_function_calls_recursive(node, source_code: bytes, calls: list):
         is_function_def = False
         for child in node.children:
             if child.type == "identifier":
-                func_text = source_code[child.start_byte : child.end_byte].decode(
-                    "utf-8"
-                )
+                func_text = source_code[child.start_byte : child.end_byte].decode("utf-8")
                 if func_text in ["def", "defp", "defmodule"]:
                     is_function_def = True
                     break
@@ -67,18 +65,16 @@ def _parse_function_call(call_node, source_code: bytes) -> dict | None:
             # Extract module and function from dot
             for dot_child in child.children:
                 if dot_child.type == "alias":
-                    module_name = source_code[
-                        dot_child.start_byte : dot_child.end_byte
-                    ].decode("utf-8")
+                    module_name = source_code[dot_child.start_byte : dot_child.end_byte].decode(
+                        "utf-8"
+                    )
                 elif dot_child.type == "identifier":
-                    function_name = source_code[
-                        dot_child.start_byte : dot_child.end_byte
-                    ].decode("utf-8")
+                    function_name = source_code[dot_child.start_byte : dot_child.end_byte].decode(
+                        "utf-8"
+                    )
         elif child.type == "identifier" and not has_dot:
             # Local function call
-            function_name = source_code[child.start_byte : child.end_byte].decode(
-                "utf-8"
-            )
+            function_name = source_code[child.start_byte : child.end_byte].decode("utf-8")
         elif child.type == "arguments":
             arguments_node = child
 
@@ -151,9 +147,9 @@ def _find_value_mentions_recursive(node, source_code: bytes, value_mentions: lis
                     # Check if this is alias/import/require/use/defmodule
                     for child in current.children:
                         if child.type == "identifier":
-                            func_text = source_code[
-                                child.start_byte : child.end_byte
-                            ].decode("utf-8")
+                            func_text = source_code[child.start_byte : child.end_byte].decode(
+                                "utf-8"
+                            )
                             if func_text in [
                                 "alias",
                                 "import",

cicada/extractors/dependency.py

@@ -25,9 +25,7 @@ def _find_aliases_recursive(node, source_code: bytes, aliases: dict):
                 arguments = child
 
         if target and arguments:
-            target_text = source_code[target.start_byte : target.end_byte].decode(
-                "utf-8"
-            )
+            target_text = source_code[target.start_byte : target.end_byte].decode("utf-8")
 
             if target_text == "alias":
                 # Parse the alias
@@ -42,9 +40,9 @@ def _find_aliases_recursive(node, source_code: bytes, aliases: dict):
             is_function_def = False
             for call_child in child.children:
                 if call_child.type == "identifier":
-                    target_text = source_code[
-                        call_child.start_byte : call_child.end_byte
-                    ].decode("utf-8")
+                    target_text = source_code[call_child.start_byte : call_child.end_byte].decode(
+                        "utf-8"
+                    )
                     if target_text in ["def", "defp", "defmodule"]:
                         is_function_def = True
                         break
@@ -69,9 +67,7 @@ def _parse_alias(arguments_node, source_code: bytes) -> dict | None:
     for arg_child in arguments_node.children:
         # Simple alias: alias MyApp.User
         if arg_child.type == "alias":
-            full_name = source_code[arg_child.start_byte : arg_child.end_byte].decode(
-                "utf-8"
-            )
+            full_name = source_code[arg_child.start_byte : arg_child.end_byte].decode("utf-8")
             # Get the last part as the short name
             short_name = full_name.split(".")[-1]
             result[short_name] = full_name
@@ -84,9 +80,9 @@ def _parse_alias(arguments_node, source_code: bytes) -> dict | None:
 
             for dot_child in arg_child.children:
                 if dot_child.type == "alias":
-                    module_prefix = source_code[
-                        dot_child.start_byte : dot_child.end_byte
-                    ].decode("utf-8")
+                    module_prefix = source_code[dot_child.start_byte : dot_child.end_byte].decode(
+                        "utf-8"
+                    )
                 elif dot_child.type == "tuple":
                     tuple_node = dot_child
 
@@ -154,18 +150,16 @@ def _find_imports_recursive(node, source_code: bytes, imports: list):
                 arguments = child
 
         if target and arguments:
-            target_text = source_code[target.start_byte : target.end_byte].decode(
-                "utf-8"
-            )
+            target_text = source_code[target.start_byte : target.end_byte].decode("utf-8")
 
             if target_text == "import":
                 # Parse the import - imports are simpler than aliases
                 # import MyModule or import MyModule, only: [func: 1]
                 for arg_child in arguments.children:
                     if arg_child.type == "alias":
-                        module_name = source_code[
-                            arg_child.start_byte : arg_child.end_byte
-                        ].decode("utf-8")
+                        module_name = source_code[arg_child.start_byte : arg_child.end_byte].decode(
+                            "utf-8"
+                        )
                         imports.append(module_name)
 
     # Recursively search children, but skip function bodies
@@ -174,9 +168,9 @@ def _find_imports_recursive(node, source_code: bytes, imports: list):
             is_function_def = False
             for call_child in child.children:
                 if call_child.type == "identifier":
-                    target_text = source_code[
-                        call_child.start_byte : call_child.end_byte
-                    ].decode("utf-8")
+                    target_text = source_code[call_child.start_byte : call_child.end_byte].decode(
+                        "utf-8"
+                    )
                     if target_text in ["def", "defp", "defmodule"]:
                         is_function_def = True
                         break
@@ -207,17 +201,15 @@ def _find_requires_recursive(node, source_code: bytes, requires: list):
                 arguments = child
 
         if target and arguments:
-            target_text = source_code[target.start_byte : target.end_byte].decode(
-                "utf-8"
-            )
+            target_text = source_code[target.start_byte : target.end_byte].decode("utf-8")
 
             if target_text == "require":
                 # Parse the require
                 for arg_child in arguments.children:
                     if arg_child.type == "alias":
-                        module_name = source_code[
-                            arg_child.start_byte : arg_child.end_byte
-                        ].decode("utf-8")
+                        module_name = source_code[arg_child.start_byte : arg_child.end_byte].decode(
+                            "utf-8"
+                        )
                         requires.append(module_name)
 
     # Recursively search children, but skip function bodies
@@ -226,9 +218,9 @@ def _find_requires_recursive(node, source_code: bytes, requires: list):
             is_function_def = False
             for call_child in child.children:
                 if call_child.type == "identifier":
-                    target_text = source_code[
-                        call_child.start_byte : call_child.end_byte
-                    ].decode("utf-8")
+                    target_text = source_code[call_child.start_byte : call_child.end_byte].decode(
+                        "utf-8"
+                    )
                     if target_text in ["def", "defp", "defmodule"]:
                         is_function_def = True
                         break
@@ -259,17 +251,15 @@ def _find_uses_recursive(node, source_code: bytes, uses: list):
                 arguments = child
 
         if target and arguments:
-            target_text = source_code[target.start_byte : target.end_byte].decode(
-                "utf-8"
-            )
+            target_text = source_code[target.start_byte : target.end_byte].decode("utf-8")
 
             if target_text == "use":
                 # Parse the use
                 for arg_child in arguments.children:
                     if arg_child.type == "alias":
-                        module_name = source_code[
-                            arg_child.start_byte : arg_child.end_byte
-                        ].decode("utf-8")
+                        module_name = source_code[arg_child.start_byte : arg_child.end_byte].decode(
+                            "utf-8"
+                        )
                         uses.append(module_name)
 
     # Recursively search children, but skip function bodies
@@ -278,9 +268,9 @@ def _find_uses_recursive(node, source_code: bytes, uses: list):
             is_function_def = False
             for call_child in child.children:
                 if call_child.type == "identifier":
-                    target_text = source_code[
-                        call_child.start_byte : call_child.end_byte
-                    ].decode("utf-8")
+                    target_text = source_code[call_child.start_byte : call_child.end_byte].decode(
+                        "utf-8"
+                    )
                     if target_text in ["def", "defp", "defmodule"]:
                         is_function_def = True
                         break
@@ -319,9 +309,7 @@ def _find_behaviours_recursive(node, source_code: bytes, behaviours: list):
 
             for child in behaviour_call.children:
                 if child.type == "identifier":
-                    identifier_text = source_code[
-                        child.start_byte : child.end_byte
-                    ].decode("utf-8")
+                    identifier_text = source_code[child.start_byte : child.end_byte].decode("utf-8")
                 elif child.type == "arguments":
                     arguments_node = child
 
@@ -330,15 +318,15 @@ def _find_behaviours_recursive(node, source_code: bytes, behaviours: list):
                 for arg_child in arguments_node.children:
                     if arg_child.type == "alias":
                         # @behaviour ModuleName
-                        module_name = source_code[
-                            arg_child.start_byte : arg_child.end_byte
-                        ].decode("utf-8")
+                        module_name = source_code[arg_child.start_byte : arg_child.end_byte].decode(
+                            "utf-8"
+                        )
                         behaviours.append(module_name)
                     elif arg_child.type == "atom":
                         # @behaviour :module_name
-                        atom_text = source_code[
-                            arg_child.start_byte : arg_child.end_byte
-                        ].decode("utf-8")
+                        atom_text = source_code[arg_child.start_byte : arg_child.end_byte].decode(
+                            "utf-8"
+                        )
                         # Remove leading colon and convert to module format if needed
                         behaviours.append(atom_text.lstrip(":"))
 
@@ -348,9 +336,9 @@ def _find_behaviours_recursive(node, source_code: bytes, behaviours: list):
             is_function_def = False
             for call_child in child.children:
                 if call_child.type == "identifier":
-                    target_text = source_code[
-                        call_child.start_byte : call_child.end_byte
-                    ].decode("utf-8")
+                    target_text = source_code[call_child.start_byte : call_child.end_byte].decode(
+                        "utf-8"
+                    )
                     if target_text in ["def", "defp", "defmodule"]:
                         is_function_def = True
                         break

cicada/extractors/doc.py

@@ -3,6 +3,7 @@ Documentation extraction logic.
 """
 
 import textwrap
+
 from .base import extract_string_from_arguments
 
 
@@ -30,15 +31,13 @@ def _find_docs_recursive(node, source_code: bytes, docs: dict):
             # Check if this is a doc attribute
             for call_child in operand.children:
                 if call_child.type == "identifier":
-                    attr_name = source_code[
-                        call_child.start_byte : call_child.end_byte
-                    ].decode("utf-8")
+                    attr_name = source_code[call_child.start_byte : call_child.end_byte].decode(
+                        "utf-8"
+                    )
 
                     if attr_name == "doc":
                         # Extract the doc definition
-                        doc_info = _parse_doc(
-                            operand, source_code, node.start_point[0] + 1
-                        )
+                        doc_info = _parse_doc(operand, source_code, node.start_point[0] + 1)
                         if doc_info:
                             # Store the entire doc_info dict (includes text and examples)
                             docs[doc_info["line"]] = doc_info
@@ -50,9 +49,9 @@ def _find_docs_recursive(node, source_code: bytes, docs: dict):
             is_defmodule_or_def = False
             for call_child in child.children:
                 if call_child.type == "identifier":
-                    target_text = source_code[
-                        call_child.start_byte : call_child.end_byte
-                    ].decode("utf-8")
+                    target_text = source_code[call_child.start_byte : call_child.end_byte].decode(
+                        "utf-8"
+                    )
                     if target_text in ["defmodule", "def", "defp"]:
                         is_defmodule_or_def = True
                         break

cicada/extractors/function.py

@@ -46,9 +46,7 @@ def _extract_impl_from_prev_sibling(node, source_code: bytes):
 
     for child in impl_call.children:
         if child.type == "identifier":
-            identifier_text = source_code[child.start_byte : child.end_byte].decode(
-                "utf-8"
-            )
+            identifier_text = source_code[child.start_byte : child.end_byte].decode("utf-8")
         elif child.type == "arguments":
             arguments_node = child
 
@@ -60,15 +58,11 @@ def _extract_impl_from_prev_sibling(node, source_code: bytes):
         for arg_child in arguments_node.children:
             if arg_child.type == "boolean":
                 # @impl true or @impl false
-                bool_text = source_code[
-                    arg_child.start_byte : arg_child.end_byte
-                ].decode("utf-8")
+                bool_text = source_code[arg_child.start_byte : arg_child.end_byte].decode("utf-8")
                 return bool_text == "true"
             elif arg_child.type == "alias":
                 # @impl ModuleName
-                module_name = source_code[
-                    arg_child.start_byte : arg_child.end_byte
-                ].decode("utf-8")
+                module_name = source_code[arg_child.start_byte : arg_child.end_byte].decode("utf-8")
                 return module_name
 
     # @impl without arguments defaults to true
@@ -96,15 +90,11 @@ def _find_functions_recursive(node, source_code: bytes, functions: list):
 
             # Check if this is a def or defp call
             if target and arguments:
-                target_text = source_code[target.start_byte : target.end_byte].decode(
-                    "utf-8"
-                )
+                target_text = source_code[target.start_byte : target.end_byte].decode("utf-8")
 
                 if target_text in ["def", "defp"]:
                     # Check if previous sibling is @impl
-                    impl_value = _extract_impl_from_prev_sibling(
-                        prev_sibling, source_code
-                    )
+                    impl_value = _extract_impl_from_prev_sibling(prev_sibling, source_code)
 
                     # Extract function name and arity
                     func_info = _parse_function_definition(
@@ -143,9 +133,9 @@ def _parse_function_definition(
             # Extract function name from call target
             for call_child in arg_child.children:
                 if call_child.type == "identifier":
-                    func_name = source_code[
-                        call_child.start_byte : call_child.end_byte
-                    ].decode("utf-8")
+                    func_name = source_code[call_child.start_byte : call_child.end_byte].decode(
+                        "utf-8"
+                    )
                 elif call_child.type == "arguments":
                     arg_names = _extract_argument_names(call_child, source_code)
                     arity = len(arg_names)
@@ -167,9 +157,7 @@ def _parse_function_definition(
                     break
             break
         elif arg_child.type == "identifier":
-            func_name = source_code[arg_child.start_byte : arg_child.end_byte].decode(
-                "utf-8"
-            )
+            func_name = source_code[arg_child.start_byte : arg_child.end_byte].decode("utf-8")
             arity = 0
             arg_names = []
             break
@@ -221,9 +209,9 @@ def _extract_guards(arguments_node, source_code: bytes) -> list[str]:
                 elif has_when:
                     # This is the guard expression node (comes after 'when')
                     # It's typically a binary_operator (like n < 0)
-                    guard_expr = source_code[
-                        op_child.start_byte : op_child.end_byte
-                    ].decode("utf-8")
+                    guard_expr = source_code[op_child.start_byte : op_child.end_byte].decode(
+                        "utf-8"
+                    )
                     guards.append(guard_expr)
                     break