mcp-vector-search 0.0.3__py3-none-any.whl → 0.4.11__py3-none-any.whl

mcp_vector_search/cli/history.py

@@ -0,0 +1,292 @@
+"""Search history and favorites management."""
+
+import json
+from datetime import datetime
+from pathlib import Path
+from typing import Any
+
+from rich.console import Console
+from rich.table import Table
+
+from .output import print_error, print_info, print_success
+
+console = Console()
+
+
+class SearchHistory:
+    """Manage search history and favorites."""
+
+    def __init__(self, project_root: Path):
+        """Initialize search history manager."""
+        self.project_root = project_root
+        self.history_file = project_root / ".mcp-vector-search" / "search_history.json"
+        self.favorites_file = project_root / ".mcp-vector-search" / "favorites.json"
+
+        # Ensure directory exists
+        self.history_file.parent.mkdir(parents=True, exist_ok=True)
+
+    def add_search(
+        self,
+        query: str,
+        results_count: int,
+        filters: dict[str, Any] | None = None,
+        execution_time: float | None = None,
+    ) -> None:
+        """Add a search to history.
+
+        Args:
+            query: Search query
+            results_count: Number of results found
+            filters: Applied filters
+            execution_time: Search execution time in seconds
+        """
+        try:
+            history = self._load_history()
+
+            search_entry = {
+                "query": query,
+                "timestamp": datetime.now().isoformat(),
+                "results_count": results_count,
+                "filters": filters or {},
+                "execution_time": execution_time,
+            }
+
+            # Add to beginning of history
+            history.insert(0, search_entry)
+
+            # Keep only last 100 searches
+            history = history[:100]
+
+            self._save_history(history)
+
+        except Exception as e:
+            print_error(f"Failed to save search history: {e}")
+
+    def get_history(self, limit: int = 20) -> list[dict[str, Any]]:
+        """Get search history.
+
+        Args:
+            limit: Maximum number of entries to return
+
+        Returns:
+            List of search history entries
+        """
+        try:
+            history = self._load_history()
+            return history[:limit]
+        except Exception as e:
+            print_error(f"Failed to load search history: {e}")
+            return []
+
+    def clear_history(self) -> bool:
+        """Clear search history.
+
+        Returns:
+            True if successful
+        """
+        try:
+            self._save_history([])
+            print_success("Search history cleared")
+            return True
+        except Exception as e:
+            print_error(f"Failed to clear search history: {e}")
+            return False
+
+    def add_favorite(self, query: str, description: str | None = None) -> bool:
+        """Add a search query to favorites.
+
+        Args:
+            query: Search query to favorite
+            description: Optional description
+
+        Returns:
+            True if successful
+        """
+        try:
+            favorites = self._load_favorites()
+
+            # Check if already exists
+            for fav in favorites:
+                if fav["query"] == query:
+                    print_info(f"Query already in favorites: {query}")
+                    return True
+
+            favorite_entry = {
+                "query": query,
+                "description": description or "",
+                "created": datetime.now().isoformat(),
+                "usage_count": 0,
+            }
+
+            favorites.append(favorite_entry)
+            self._save_favorites(favorites)
+
+            print_success(f"Added to favorites: {query}")
+            return True
+
+        except Exception as e:
+            print_error(f"Failed to add favorite: {e}")
+            return False
+
+    def remove_favorite(self, query: str) -> bool:
+        """Remove a query from favorites.
+
+        Args:
+            query: Query to remove
+
+        Returns:
+            True if successful
+        """
+        try:
+            favorites = self._load_favorites()
+            original_count = len(favorites)
+
+            favorites = [fav for fav in favorites if fav["query"] != query]
+
+            if len(favorites) < original_count:
+                self._save_favorites(favorites)
+                print_success(f"Removed from favorites: {query}")
+                return True
+            else:
+                print_info(f"Query not found in favorites: {query}")
+                return False
+
+        except Exception as e:
+            print_error(f"Failed to remove favorite: {e}")
+            return False
+
+    def get_favorites(self) -> list[dict[str, Any]]:
+        """Get favorite queries.
+
+        Returns:
+            List of favorite queries
+        """
+        try:
+            return self._load_favorites()
+        except Exception as e:
+            print_error(f"Failed to load favorites: {e}")
+            return []
+
+    def increment_favorite_usage(self, query: str) -> None:
+        """Increment usage count for a favorite query.
+
+        Args:
+            query: Query that was used
+        """
+        try:
+            favorites = self._load_favorites()
+
+            for fav in favorites:
+                if fav["query"] == query:
+                    fav["usage_count"] = fav.get("usage_count", 0) + 1
+                    fav["last_used"] = datetime.now().isoformat()
+                    break
+
+            self._save_favorites(favorites)
+
+        except Exception:
+            # Don't show error for this non-critical operation
+            pass
+
+    def _load_history(self) -> list[dict[str, Any]]:
+        """Load search history from file."""
+        if not self.history_file.exists():
+            return []
+
+        try:
+            with open(self.history_file, encoding="utf-8") as f:
+                return json.load(f)
+        except Exception:
+            return []
+
+    def _save_history(self, history: list[dict[str, Any]]) -> None:
+        """Save search history to file."""
+        with open(self.history_file, "w", encoding="utf-8") as f:
+            json.dump(history, f, indent=2, ensure_ascii=False)
+
+    def _load_favorites(self) -> list[dict[str, Any]]:
+        """Load favorites from file."""
+        if not self.favorites_file.exists():
+            return []
+
+        try:
+            with open(self.favorites_file, encoding="utf-8") as f:
+                return json.load(f)
+        except Exception:
+            return []
+
+    def _save_favorites(self, favorites: list[dict[str, Any]]) -> None:
+        """Save favorites to file."""
+        with open(self.favorites_file, "w", encoding="utf-8") as f:
+            json.dump(favorites, f, indent=2, ensure_ascii=False)
+
+
+def show_search_history(project_root: Path, limit: int = 20) -> None:
+    """Display search history in a formatted table."""
+    history_manager = SearchHistory(project_root)
+    history = history_manager.get_history(limit)
+
+    if not history:
+        print_info("No search history found")
+        return
+
+    table = Table(
+        title=f"Search History (Last {len(history)} searches)", show_header=True
+    )
+    table.add_column("#", style="cyan", width=3)
+    table.add_column("Query", style="white", min_width=20)
+    table.add_column("Results", style="green", width=8)
+    table.add_column("Time", style="dim", width=16)
+    table.add_column("Filters", style="yellow", width=15)
+
+    for i, entry in enumerate(history, 1):
+        timestamp = datetime.fromisoformat(entry["timestamp"]).strftime("%m-%d %H:%M")
+        filters_str = ", ".join(f"{k}:{v}" for k, v in entry.get("filters", {}).items())
+        if not filters_str:
+            filters_str = "-"
+
+        table.add_row(
+            str(i),
+            entry["query"][:40] + "..." if len(entry["query"]) > 40 else entry["query"],
+            str(entry["results_count"]),
+            timestamp,
+            filters_str[:15] + "..." if len(filters_str) > 15 else filters_str,
+        )
+
+    console.print(table)
+
+
+def show_favorites(project_root: Path) -> None:
+    """Display favorite queries in a formatted table."""
+    history_manager = SearchHistory(project_root)
+    favorites = history_manager.get_favorites()
+
+    if not favorites:
+        print_info("No favorite queries found")
+        return
+
+    # Sort by usage count (descending)
+    favorites.sort(key=lambda x: x.get("usage_count", 0), reverse=True)
+
+    table = Table(title="Favorite Queries", show_header=True)
+    table.add_column("#", style="cyan", width=3)
+    table.add_column("Query", style="white", min_width=25)
+    table.add_column("Description", style="dim", min_width=20)
+    table.add_column("Usage", style="green", width=6)
+    table.add_column("Created", style="dim", width=10)
+
+    for i, fav in enumerate(favorites, 1):
+        created = datetime.fromisoformat(fav["created"]).strftime("%m-%d")
+        description = fav.get("description", "")[:30]
+        if len(fav.get("description", "")) > 30:
+            description += "..."
+
+        table.add_row(
+            str(i),
+            fav["query"],
+            description or "-",
+            str(fav.get("usage_count", 0)),
+            created,
+        )
+
+    console.print(table)

mcp_vector_search/cli/interactive.py

@@ -0,0 +1,342 @@
+"""Interactive search features for MCP Vector Search."""
+
+from pathlib import Path
+
+from rich.console import Console
+from rich.panel import Panel
+from rich.prompt import Prompt
+from rich.table import Table
+
+from ..core.database import ChromaVectorDatabase
+from ..core.embeddings import create_embedding_function
+from ..core.exceptions import ProjectNotFoundError
+from ..core.models import SearchResult
+from ..core.project import ProjectManager
+from ..core.search import SemanticSearchEngine
+from .output import print_error, print_info, print_search_results, print_warning
+
+console = Console()
+
+
+class InteractiveSearchSession:
+    """Interactive search session with filtering and refinement."""
+
+    def __init__(self, project_root: Path):
+        """Initialize interactive search session."""
+        self.project_root = project_root
+        self.project_manager = ProjectManager(project_root)
+        self.search_engine: SemanticSearchEngine | None = None
+        self.database: ChromaVectorDatabase | None = None
+        self.last_results: list[SearchResult] = []
+        self.search_history: list[str] = []
+
+    async def start(self) -> None:
+        """Start interactive search session."""
+        if not self.project_manager.is_initialized():
+            raise ProjectNotFoundError(
+                f"Project not initialized at {self.project_root}. Run 'mcp-vector-search init' first."
+            )
+
+        config = self.project_manager.load_config()
+
+        # Setup database and search engine
+        embedding_function, _ = create_embedding_function(config.embedding_model)
+        self.database = ChromaVectorDatabase(
+            persist_directory=config.index_path,
+            embedding_function=embedding_function,
+        )
+
+        self.search_engine = SemanticSearchEngine(
+            database=self.database,
+            project_root=self.project_root,
+            similarity_threshold=config.similarity_threshold,
+        )
+
+        await self.database.initialize()
+
+        # Show welcome message
+        self._show_welcome()
+
+        # Main interactive loop
+        try:
+            await self._interactive_loop()
+        finally:
+            await self.database.close()
+
+    def _show_welcome(self) -> None:
+        """Show welcome message and help."""
+        welcome_text = """
+[bold blue]Interactive Search Session[/bold blue]
+
+Available commands:
+• [cyan]search <query>[/cyan] - Perform semantic search
+• [cyan]filter[/cyan] - Filter current results
+• [cyan]refine[/cyan] - Refine last search
+• [cyan]history[/cyan] - Show search history
+• [cyan]stats[/cyan] - Show result statistics
+• [cyan]help[/cyan] - Show this help
+• [cyan]quit[/cyan] - Exit session
+
+Type your search query or command:
+        """
+        console.print(Panel(welcome_text.strip(), border_style="blue"))
+
+    async def _interactive_loop(self) -> None:
+        """Main interactive loop."""
+        while True:
+            try:
+                # Get user input
+                user_input = Prompt.ask("\n[bold cyan]Search[/bold cyan]").strip()
+
+                if not user_input:
+                    continue
+
+                # Handle commands
+                if user_input.lower() in ["quit", "exit", "q"]:
+                    console.print("[yellow]Goodbye![/yellow]")
+                    break
+                elif user_input.lower() == "help":
+                    self._show_welcome()
+                elif user_input.lower() == "history":
+                    self._show_history()
+                elif user_input.lower() == "stats":
+                    self._show_stats()
+                elif user_input.lower() == "filter":
+                    await self._filter_results()
+                elif user_input.lower() == "refine":
+                    await self._refine_search()
+                elif user_input.startswith("search "):
+                    query = user_input[7:].strip()
+                    await self._perform_search(query)
+                else:
+                    # Treat as search query
+                    await self._perform_search(user_input)
+
+            except KeyboardInterrupt:
+                console.print("\n[yellow]Use 'quit' to exit[/yellow]")
+            except Exception as e:
+                print_error(f"Error: {e}")
+
+    async def _perform_search(self, query: str) -> None:
+        """Perform a search and display results."""
+        if not query:
+            print_warning("Please provide a search query")
+            return
+
+        try:
+            console.print(f"\n[dim]Searching for: {query}[/dim]")
+
+            results = await self.search_engine.search(
+                query=query,
+                limit=20,  # Get more results for filtering
+                include_context=True,
+            )
+
+            self.last_results = results
+            self.search_history.append(query)
+
+            if results:
+                print_search_results(results[:10], query, show_content=False)
+
+                if len(results) > 10:
+                    console.print(
+                        f"\n[dim]Showing top 10 of {len(results)} results. Use 'filter' to refine.[/dim]"
+                    )
+
+                # Show quick actions
+                self._show_quick_actions()
+            else:
+                print_warning(f"No results found for: {query}")
+                self._suggest_alternatives(query)
+
+        except Exception as e:
+            print_error(f"Search failed: {e}")
+
+    def _show_quick_actions(self) -> None:
+        """Show quick action options."""
+        actions = [
+            "[cyan]filter[/cyan] - Filter results",
+            "[cyan]refine[/cyan] - Refine search",
+            "[cyan]stats[/cyan] - Show statistics",
+        ]
+        console.print(f"\n[dim]Quick actions: {' | '.join(actions)}[/dim]")
+
+    async def _filter_results(self) -> None:
+        """Interactive result filtering."""
+        if not self.last_results:
+            print_warning("No results to filter. Perform a search first.")
+            return
+
+        console.print(f"\n[bold]Filtering {len(self.last_results)} results[/bold]")
+
+        # Show available filter options
+        available_languages = {r.language for r in self.last_results}
+        available_files = {r.file_path.name for r in self.last_results}
+        available_functions = {
+            r.function_name for r in self.last_results if r.function_name
+        }
+        {r.class_name for r in self.last_results if r.class_name}
+
+        # Language filter
+        if len(available_languages) > 1:
+            lang_choice = Prompt.ask(
+                f"Filter by language? ({', '.join(sorted(available_languages))})",
+                default="",
+                show_default=False,
+            )
+            if lang_choice and lang_choice in available_languages:
+                self.last_results = [
+                    r for r in self.last_results if r.language == lang_choice
+                ]
+                console.print(
+                    f"[green]Filtered to {len(self.last_results)} results with language: {lang_choice}[/green]"
+                )
+
+        # File filter
+        if len(available_files) > 1 and len(self.last_results) > 1:
+            file_pattern = Prompt.ask(
+                "Filter by file name pattern (partial match)",
+                default="",
+                show_default=False,
+            )
+            if file_pattern:
+                self.last_results = [
+                    r
+                    for r in self.last_results
+                    if file_pattern.lower() in r.file_path.name.lower()
+                ]
+                console.print(
+                    f"[green]Filtered to {len(self.last_results)} results matching: {file_pattern}[/green]"
+                )
+
+        # Function filter
+        if available_functions and len(self.last_results) > 1:
+            func_pattern = Prompt.ask(
+                "Filter by function name pattern (partial match)",
+                default="",
+                show_default=False,
+            )
+            if func_pattern:
+                self.last_results = [
+                    r
+                    for r in self.last_results
+                    if r.function_name
+                    and func_pattern.lower() in r.function_name.lower()
+                ]
+                console.print(
+                    f"[green]Filtered to {len(self.last_results)} results with function matching: {func_pattern}[/green]"
+                )
+
+        # Similarity threshold filter
+        min_similarity = Prompt.ask(
+            "Minimum similarity threshold (0.0-1.0)", default="", show_default=False
+        )
+        if min_similarity:
+            try:
+                threshold = float(min_similarity)
+                if 0.0 <= threshold <= 1.0:
+                    self.last_results = [
+                        r for r in self.last_results if r.similarity_score >= threshold
+                    ]
+                    console.print(
+                        f"[green]Filtered to {len(self.last_results)} results with similarity >= {threshold}[/green]"
+                    )
+            except ValueError:
+                print_warning("Invalid similarity threshold")
+
+        # Show filtered results
+        if self.last_results:
+            print_search_results(
+                self.last_results[:10], "Filtered Results", show_content=False
+            )
+        else:
+            print_warning("No results match the filters")
+
+    async def _refine_search(self) -> None:
+        """Refine the last search with additional terms."""
+        if not self.search_history:
+            print_warning("No previous search to refine")
+            return
+
+        last_query = self.search_history[-1]
+        console.print(f"[dim]Last search: {last_query}[/dim]")
+
+        additional_terms = Prompt.ask("Add terms to refine search", default="")
+        if additional_terms:
+            refined_query = f"{last_query} {additional_terms}"
+            await self._perform_search(refined_query)
+
+    def _show_history(self) -> None:
+        """Show search history."""
+        if not self.search_history:
+            print_info("No search history")
+            return
+
+        table = Table(title="Search History", show_header=True)
+        table.add_column("#", style="cyan", width=3)
+        table.add_column("Query", style="white")
+
+        for i, query in enumerate(self.search_history[-10:], 1):
+            table.add_row(str(i), query)
+
+        console.print(table)
+
+    def _show_stats(self) -> None:
+        """Show statistics for current results."""
+        if not self.last_results:
+            print_info("No results to analyze")
+            return
+
+        # Calculate statistics
+        languages = {}
+        files = {}
+        avg_similarity = sum(r.similarity_score for r in self.last_results) / len(
+            self.last_results
+        )
+
+        for result in self.last_results:
+            languages[result.language] = languages.get(result.language, 0) + 1
+            files[result.file_path.name] = files.get(result.file_path.name, 0) + 1
+
+        # Create statistics table
+        table = Table(title="Result Statistics", show_header=False)
+        table.add_column("Metric", style="cyan")
+        table.add_column("Value", style="white")
+
+        table.add_row("Total Results", str(len(self.last_results)))
+        table.add_row("Average Similarity", f"{avg_similarity:.1%}")
+        table.add_row(
+            "Languages",
+            ", ".join(f"{lang}({count})" for lang, count in languages.items()),
+        )
+        table.add_row("Unique Files", str(len(files)))
+
+        console.print(table)
+
+    def _suggest_alternatives(self, query: str) -> None:
+        """Suggest alternative search terms."""
+        suggestions = []
+
+        # Simple suggestions based on common patterns
+        words = query.lower().split()
+        for word in words:
+            if word in ["auth", "authentication"]:
+                suggestions.extend(["login", "user", "session", "token"])
+            elif word in ["db", "database"]:
+                suggestions.extend(["query", "model", "connection", "storage"])
+            elif word in ["api"]:
+                suggestions.extend(["endpoint", "request", "response", "handler"])
+            elif word in ["test", "testing"]:
+                suggestions.extend(["mock", "assert", "spec", "unit"])
+
+        if suggestions:
+            unique_suggestions = list(set(suggestions))[:5]
+            console.print(
+                f"[dim]Try these terms: {', '.join(unique_suggestions)}[/dim]"
+            )
+
+
+async def start_interactive_search(project_root: Path) -> None:
+    """Start an interactive search session."""
+    session = InteractiveSearchSession(project_root)
+    await session.start()