cicada-mcp 0.1.4__py3-none-any.whl

cicada/__init__.py

@@ -0,0 +1,30 @@
+"""Cicada - An Elixir module search MCP server."""
+
+import sys
+from pathlib import Path
+
+# Python 3.11+ has tomllib built-in, 3.10 needs tomli
+if sys.version_info >= (3, 11):
+    import tomllib
+else:
+    try:
+        import tomli as tomllib
+    except ImportError:
+        tomllib = None
+
+
+def _get_version() -> str:
+    """Read version from pyproject.toml."""
+    if tomllib is None:
+        return "unknown"
+
+    try:
+        pyproject_path = Path(__file__).parent.parent / "pyproject.toml"
+        with open(pyproject_path, "rb") as f:
+            pyproject_data = tomllib.load(f)
+            return pyproject_data["project"]["version"]
+    except (FileNotFoundError, KeyError, Exception):
+        return "unknown"
+
+
+__version__ = _get_version()

cicada/clean.py

@@ -0,0 +1,297 @@
+#!/usr/bin/env python
+"""
+Cicada Clean Command.
+
+Removes all Cicada configuration and indexes for a repository.
+"""
+
+import argparse
+import json
+import shutil
+import sys
+from pathlib import Path
+
+from cicada.utils import get_storage_dir
+
+
+def remove_mcp_config_entry(config_path: Path, server_key: str = "cicada") -> bool:
+    """
+    Remove Cicada entry from an MCP configuration file.
+
+    Args:
+        config_path: Path to the MCP config file
+        server_key: Server key to remove (default: "cicada")
+
+    Returns:
+        True if entry was removed, False if file doesn't exist or no entry found
+    """
+    if not config_path.exists():
+        return False
+
+    try:
+        with open(config_path, "r") as f:
+            config = json.load(f)
+
+        # Determine the config key based on editor type
+        if ".mcp.json" in str(config_path) or ".cursor" in str(config_path):
+            config_key = "mcpServers"
+        elif ".vscode" in str(config_path):
+            config_key = "mcp.servers"
+        else:
+            return False
+
+        # Check if the key exists and remove cicada entry
+        if config_key in config and server_key in config[config_key]:
+            del config[config_key][server_key]
+
+            # Write back the modified config
+            with open(config_path, "w") as f:
+                json.dump(config, f, indent=2)
+
+            return True
+
+    except (json.JSONDecodeError, IOError) as e:
+        print(f"Warning: Could not process {config_path}: {e}")
+
+    return False
+
+
+def clean_repository(repo_path: Path, force: bool = False) -> None:
+    """
+    Remove all Cicada configuration and indexes for a repository.
+
+    Args:
+        repo_path: Path to the repository
+        force: Skip confirmation prompt if True
+    """
+    repo_path = repo_path.resolve()
+
+    print("=" * 60)
+    print("Cicada Clean")
+    print("=" * 60)
+    print()
+    print(f"Repository: {repo_path}")
+    print()
+
+    # Collect items to remove
+    items_to_remove = []
+
+    # 1. Storage directory (~/.cicada/projects/<repo_hash>/)
+    storage_dir = get_storage_dir(repo_path)
+    if storage_dir.exists():
+        items_to_remove.append(("Storage directory", storage_dir))
+
+    # 2. Old .cicada directory (backward compatibility)
+    old_cicada_dir = repo_path / ".cicada"
+    if old_cicada_dir.exists():
+        items_to_remove.append(("Legacy .cicada directory", old_cicada_dir))
+
+    # 3. MCP config files
+    mcp_configs = [
+        (repo_path / ".mcp.json", "Claude Code config"),
+        (repo_path / ".cursor" / "mcp.json", "Cursor config"),
+        (repo_path / ".vscode" / "settings.json", "VS Code config"),
+    ]
+
+    for config_path, desc in mcp_configs:
+        if config_path.exists():
+            # Check if cicada entry exists
+            try:
+                with open(config_path, "r") as f:
+                    config = json.load(f)
+
+                config_key = (
+                    "mcpServers" if ".vscode" not in str(config_path) else "mcp.servers"
+                )
+
+                if config_key in config and "cicada" in config[config_key]:
+                    items_to_remove.append(
+                        (desc, config_path, True)
+                    )  # True = is MCP config
+            except (json.JSONDecodeError, IOError):
+                pass
+
+    # Show what will be removed
+    if not items_to_remove:
+        print("✓ No Cicada configuration found for this repository.")
+        print()
+        return
+
+    print("The following items will be removed:")
+    print()
+    for item in items_to_remove:
+        if len(item) == 3 and item[2]:  # MCP config entry
+            print(f"  • {item[0]}: Remove 'cicada' entry from {item[1]}")
+        else:
+            print(f"  • {item[0]}: {item[1]}")
+    print()
+
+    # Confirmation prompt
+    if not force:
+        response = input("Are you sure you want to continue? [y/N]: ")
+        if response.lower() not in ["y", "yes"]:
+            print("Aborted.")
+            return
+
+    print()
+    print("Removing Cicada configuration...")
+    print()
+
+    # Remove items
+    removed_count = 0
+    for item in items_to_remove:
+        if len(item) == 3 and item[2]:  # MCP config entry
+            desc, config_path, _ = item
+            if remove_mcp_config_entry(config_path):
+                print(f"✓ Removed 'cicada' entry from {desc}")
+                removed_count += 1
+        else:
+            desc, path = item
+            try:
+                if path.is_dir():
+                    shutil.rmtree(path)
+                else:
+                    path.unlink()
+                print(f"✓ Removed {desc}")
+                removed_count += 1
+            except (OSError, PermissionError) as e:
+                print(f"✗ Failed to remove {desc}: {e}")
+
+    print()
+    print("=" * 60)
+    print(f"✓ Cleanup Complete! ({removed_count} items removed)")
+    print("=" * 60)
+    print()
+    print("Next steps:")
+    print("1. Restart your editor if it's currently running")
+    print("2. Run 'uvx cicada <editor>' to set up Cicada again")
+    print()
+
+
+def clean_all_projects(force: bool = False) -> None:
+    """
+    Remove all Cicada storage directories for all projects.
+
+    Args:
+        force: Skip confirmation prompt if True
+    """
+    from pathlib import Path
+
+    storage_base = Path.home() / ".cicada" / "projects"
+
+    if not storage_base.exists():
+        print("✓ No Cicada storage found (~/.cicada/projects/ does not exist).")
+        return
+
+    # Count project directories
+    project_dirs = [d for d in storage_base.iterdir() if d.is_dir()]
+
+    if not project_dirs:
+        print("✓ No Cicada projects found in ~/.cicada/projects/")
+        return
+
+    print("=" * 60)
+    print("Cicada Clean All Projects")
+    print("=" * 60)
+    print()
+    print(f"Found {len(project_dirs)} project(s) in: {storage_base}")
+    print()
+
+    # Show project directories
+    print("The following storage directories will be removed:")
+    print()
+    for proj_dir in sorted(project_dirs):
+        print(f"  • {proj_dir.name}/")
+    print()
+
+    # Confirmation prompt
+    if not force:
+        response = input(
+            f"Are you sure you want to remove ALL {len(project_dirs)} project(s)? [y/N]: "
+        )
+        if response.lower() not in ["y", "yes"]:
+            print("Aborted.")
+            return
+
+    print()
+    print("Removing all Cicada storage directories...")
+    print()
+
+    # Remove all project directories
+    removed_count = 0
+    for proj_dir in project_dirs:
+        try:
+            shutil.rmtree(proj_dir)
+            print(f"✓ Removed {proj_dir.name}/")
+            removed_count += 1
+        except (OSError, PermissionError) as e:
+            print(f"✗ Failed to remove {proj_dir.name}/: {e}")
+
+    print()
+    print("=" * 60)
+    print(f"✓ Cleanup Complete! ({removed_count}/{len(project_dirs)} projects removed)")
+    print("=" * 60)
+    print()
+
+
+def main():
+    """Main entry point for the clean command."""
+    parser = argparse.ArgumentParser(
+        description="Remove all Cicada configuration and indexes for a repository",
+        epilog="Examples:\n"
+        "  cicada-clean -f              # Clean current repository\n"
+        "  cicada-clean --all -f        # Remove ALL project storage\n",
+        formatter_class=argparse.RawDescriptionHelpFormatter,
+    )
+    parser.add_argument(
+        "repo",
+        nargs="?",
+        default=None,
+        help="Path to the repository (default: current directory)",
+    )
+    parser.add_argument(
+        "-f",
+        "--force",
+        action="store_true",
+        help="Skip confirmation prompt",
+    )
+    parser.add_argument(
+        "--all",
+        action="store_true",
+        help="Remove ALL Cicada storage for all projects (~/.cicada/projects/)",
+    )
+
+    args = parser.parse_args()
+
+    # Handle --all flag
+    if args.all:
+        try:
+            clean_all_projects(force=args.force)
+        except Exception as e:
+            print(f"\nError: Cleanup failed: {e}")
+            sys.exit(1)
+        return
+
+    # Determine repo path
+    repo_path = Path(args.repo) if args.repo else Path.cwd()
+
+    # Validate path exists
+    if not repo_path.exists():
+        print(f"Error: Path does not exist: {repo_path}")
+        sys.exit(1)
+
+    # Validate path is a directory
+    if not repo_path.is_dir():
+        print(f"Error: Path is not a directory: {repo_path}")
+        sys.exit(1)
+
+    # Run cleanup
+    try:
+        clean_repository(repo_path, force=args.force)
+    except Exception as e:
+        print(f"\nError: Cleanup failed: {e}")
+        sys.exit(1)
+
+
+if __name__ == "__main__":
+    main()

cicada/command_logger.py

@@ -0,0 +1,293 @@
+"""Command logging functionality for cicada-server MCP.
+
+This module provides logging capabilities for all MCP tool executions,
+storing logs in JSONL format organized by date.
+"""
+
+import asyncio
+import json
+import tempfile
+from datetime import datetime
+from pathlib import Path
+from typing import Any, Dict, Optional
+
+
+class CommandLogger:
+    """Logger for MCP tool executions."""
+
+    def __init__(self, log_dir: Optional[str] = None):
+        """Initialize the command logger.
+
+        Args:
+            log_dir: Directory to store logs. If None, uses system temp directory.
+        """
+        if log_dir is None:
+            # Use system temp directory with a cicada subdirectory
+            self.log_dir = Path(tempfile.gettempdir()) / "cicada-logs"
+        else:
+            self.log_dir = Path(log_dir)
+
+        # Create log directory if it doesn't exist
+        self.log_dir.mkdir(parents=True, exist_ok=True)
+
+    def _get_log_file_path(self, timestamp: datetime) -> Path:
+        """Get the log file path for a given timestamp.
+
+        Logs are organized by date (YYYY-MM-DD.jsonl).
+
+        Args:
+            timestamp: The timestamp for the log entry.
+
+        Returns:
+            Path to the log file.
+        """
+        date_str = timestamp.strftime("%Y-%m-%d")
+        return self.log_dir / f"{date_str}.jsonl"
+
+    def log_command(
+        self,
+        tool_name: str,
+        arguments: Dict[str, Any],
+        response: Any,
+        execution_time_ms: float,
+        timestamp: Optional[datetime] = None,
+        error: Optional[str] = None,
+    ) -> None:
+        """Log a command execution.
+
+        Args:
+            tool_name: Name of the tool that was executed.
+            arguments: Arguments passed to the tool.
+            response: Response from the tool execution.
+            execution_time_ms: Execution time in milliseconds.
+            timestamp: Timestamp of the execution. If None, uses current time.
+            error: Error message if the command failed.
+        """
+        if timestamp is None:
+            timestamp = datetime.now()
+
+        # Prepare the log entry
+        log_entry = {
+            "timestamp": timestamp.isoformat(),
+            "tool_name": tool_name,
+            "arguments": arguments,
+            "execution_time_ms": round(execution_time_ms, 3),
+        }
+
+        # Add response or error
+        if error:
+            log_entry["error"] = error
+            log_entry["success"] = False
+        else:
+            log_entry["response"] = self._serialize_response(response)
+            log_entry["success"] = True
+
+        # Get the log file path for this date
+        log_file = self._get_log_file_path(timestamp)
+
+        # Append the log entry to the file
+        try:
+            with open(log_file, "a", encoding="utf-8") as f:
+                json.dump(log_entry, f, ensure_ascii=False)
+                f.write("\n")
+        except Exception as e:
+            # If logging fails, write to stderr but don't crash the server
+            import sys
+
+            print(
+                f"Warning: Failed to write command log: {e}",
+                file=sys.stderr,
+            )
+
+    async def log_command_async(
+        self,
+        tool_name: str,
+        arguments: Dict[str, Any],
+        response: Any,
+        execution_time_ms: float,
+        timestamp: Optional[datetime] = None,
+        error: Optional[str] = None,
+    ) -> None:
+        """Async version of log_command that runs file I/O in a thread pool.
+
+        This prevents blocking the event loop when logging commands.
+
+        Args:
+            tool_name: Name of the tool that was executed.
+            arguments: Arguments passed to the tool.
+            response: Response from the tool execution.
+            execution_time_ms: Execution time in milliseconds.
+            timestamp: Timestamp of the execution. If None, uses current time.
+            error: Error message if the command failed.
+        """
+        # Run the synchronous log_command in a thread pool
+        await asyncio.to_thread(
+            self.log_command,
+            tool_name,
+            arguments,
+            response,
+            execution_time_ms,
+            timestamp,
+            error,
+        )
+
+    def _serialize_response(self, response: Any) -> Any:
+        """Serialize the response for JSON storage.
+
+        Args:
+            response: The response object to serialize.
+
+        Returns:
+            JSON-serializable representation of the response.
+        """
+        # Handle common types first
+        if isinstance(response, list):
+            return [self._serialize_response(item) for item in response]
+        elif isinstance(response, dict):
+            return {k: self._serialize_response(v) for k, v in response.items()}
+        elif hasattr(response, "text"):
+            # MCP TextContent object
+            return {"type": "text", "text": response.text}
+        elif hasattr(response, "__dict__"):
+            # Generic object - convert to string
+            try:
+                return str(response)
+            except Exception:
+                return str(response)
+        else:
+            return response
+
+    def get_log_files(self) -> list[Path]:
+        """Get all log files, sorted by date (oldest first).
+
+        Returns:
+            List of log file paths.
+        """
+        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]]:
+        """Read logs from file(s).
+
+        Args:
+            date: Date string in YYYY-MM-DD format. If None, reads all logs.
+            limit: Maximum number of log entries to return (most recent).
+
+        Returns:
+            List of log entries.
+        """
+        logs = []
+
+        if date:
+            # Validate date format to prevent path traversal
+            try:
+                datetime.strptime(date, "%Y-%m-%d")
+            except ValueError:
+                # Invalid date format - return empty list
+                return []
+
+            # Read from specific date file
+            log_file = self.log_dir / f"{date}.jsonl"
+            if log_file.exists():
+                logs.extend(self._read_log_file(log_file))
+        else:
+            # Read from all log files, sorted by date
+            for log_file in self.get_log_files():
+                logs.extend(self._read_log_file(log_file))
+
+        # Sort by timestamp (most recent last)
+        logs.sort(key=lambda x: x.get("timestamp", ""))
+
+        # Apply limit if specified (return most recent)
+        if limit:
+            logs = logs[-limit:]
+
+        return logs
+
+    def _read_log_file(self, file_path: Path) -> list[Dict[str, Any]]:
+        """Read logs from a single JSONL file.
+
+        Args:
+            file_path: Path to the log file.
+
+        Returns:
+            List of log entries from the file.
+        """
+        logs = []
+        try:
+            with open(file_path, "r", encoding="utf-8") as f:
+                for line in f:
+                    line = line.strip()
+                    if line:
+                        try:
+                            logs.append(json.loads(line))
+                        except json.JSONDecodeError:
+                            # Skip malformed lines
+                            continue
+        except Exception:
+            # If reading fails, return what we have
+            pass
+
+        return logs
+
+    def clear_logs(self, older_than_days: Optional[int] = None) -> int:
+        """Clear log files.
+
+        Args:
+            older_than_days: If specified, only delete logs older than this many days.
+                           If None, deletes all logs.
+
+        Returns:
+            Number of files deleted.
+        """
+        count = 0
+        now = datetime.now()
+
+        for log_file in self.get_log_files():
+            should_delete = False
+
+            if older_than_days is None:
+                # Delete all logs
+                should_delete = True
+            else:
+                # Check if file is old enough
+                try:
+                    # Extract date from filename (YYYY-MM-DD.jsonl)
+                    date_str = log_file.stem  # Gets filename without .jsonl
+                    file_date = datetime.strptime(date_str, "%Y-%m-%d")
+                    age_days = (now - file_date).days
+                    if age_days > older_than_days:
+                        should_delete = True
+                except Exception:
+                    # If we can't parse the date, skip it
+                    continue
+
+            if should_delete:
+                try:
+                    log_file.unlink()
+                    count += 1
+                except Exception:
+                    pass
+
+        return count
+
+
+# Global logger instance
+_global_logger: Optional[CommandLogger] = None
+
+
+def get_logger(log_dir: Optional[str] = None) -> CommandLogger:
+    """Get or create the global command logger instance.
+
+    Args:
+        log_dir: Directory to store logs. Only used on first call.
+
+    Returns:
+        CommandLogger instance.
+    """
+    global _global_logger
+    if _global_logger is None:
+        _global_logger = CommandLogger(log_dir)
+    return _global_logger