crackerjack 0.37.9__py3-none-any.whl → 0.45.2__py3-none-any.whl

crackerjack/cli/semantic_handlers.py

@@ -0,0 +1,292 @@
+"""CLI handlers for semantic search operations."""
+
+from pathlib import Path
+from textwrap import dedent
+
+from acb import console
+from rich.panel import Panel
+from rich.table import Table
+
+from crackerjack.models.semantic_models import SearchQuery, SemanticConfig
+from crackerjack.services.vector_store import VectorStore
+
+# console imported from acb
+
+
+def handle_semantic_index(file_path: str) -> None:
+    """Handle indexing a file for semantic search.
+
+    Args:
+        file_path: Path to the file or directory to index
+    """
+    try:
+        console.print(f"[cyan]Indexing file for semantic search:[/cyan] {file_path}")
+
+        # Validate path
+        path_obj = Path(file_path)
+        if not path_obj.exists():
+            console.print(f"[red]Error:[/red] File does not exist: {file_path}")
+            return
+
+        # Create default configuration
+        config = SemanticConfig(
+            embedding_model="sentence-transformers/all-MiniLM-L6-v2",
+            chunk_size=512,
+            chunk_overlap=50,
+            max_search_results=10,
+            similarity_threshold=0.7,
+            embedding_dimension=384,
+        )
+
+        # Initialize vector store with persistent database
+        db_path = Path.cwd() / ".crackerjack" / "semantic_index.db"
+        db_path.parent.mkdir(exist_ok=True)
+        vector_store = VectorStore(config, db_path=db_path)
+
+        if path_obj.is_file():
+            # Index single file
+            embeddings = vector_store.index_file(path_obj)
+            console.print(
+                f"[green]✅ Successfully indexed {len(embeddings)} chunks from {path_obj.name}[/green]"
+            )
+        else:
+            # Index directory (recursively)
+            total_files = 0
+            total_chunks = 0
+
+            for file in path_obj.rglob("*.py"):  # Index Python files
+                try:
+                    embeddings = vector_store.index_file(file)
+                    total_files += 1
+                    total_chunks += len(embeddings)
+                    console.print(
+                        f"[dim]Indexed {len(embeddings)} chunks from {file.relative_to(path_obj)}[/dim]"
+                    )
+                except Exception as e:
+                    console.print(
+                        f"[yellow]Warning:[/yellow] Failed to index {file}: {e}"
+                    )
+
+            console.print(
+                f"[green]✅ Successfully indexed {total_files} files with {total_chunks} total chunks[/green]"
+            )
+
+        # Show index stats
+        stats = vector_store.get_stats()
+        console.print(
+            f"[cyan]Index now contains:[/cyan] {stats.total_files} files, {stats.total_chunks} chunks"
+        )
+
+    except Exception as e:
+        console.print(
+            f"[red]Error indexing file:[/red] {str(e).replace('[', '\\[').replace(']', '\\]')}"
+        )
+
+
+def handle_semantic_search(query: str) -> None:
+    """Handle semantic search across indexed files.
+
+    Args:
+        query: The search query text
+    """
+    try:
+        console.print(f"[cyan]Performing semantic search for:[/cyan] {query}")
+
+        # Create default configuration
+        config = SemanticConfig(
+            embedding_model="sentence-transformers/all-MiniLM-L6-v2",
+            chunk_size=512,
+            chunk_overlap=50,
+            max_search_results=10,
+            similarity_threshold=0.7,
+            embedding_dimension=384,
+        )
+
+        # Create search query
+        search_query = SearchQuery(
+            query=query,
+            max_results=10,
+            min_similarity=0.3,  # Lower threshold for CLI to show more results
+        )
+
+        # Initialize vector store with persistent database
+        db_path = Path.cwd() / ".crackerjack" / "semantic_index.db"
+        db_path.parent.mkdir(exist_ok=True)
+        vector_store = VectorStore(config, db_path=db_path)
+        results = vector_store.search(search_query)
+
+        if not results:
+            console.print(
+                "[yellow]No results found. Try a different search term or index more files.[/yellow]"
+            )
+            return
+
+        # Display results in a table
+        table = Table(title=f"Semantic Search Results for: '{query}'")
+        table.add_column("File", style="cyan", no_wrap=True)
+        table.add_column("Lines", style="magenta", justify="center")
+        table.add_column("Score", style="green", justify="center")
+        table.add_column("Content Preview", style="white")
+
+        for result in results:
+            # Truncate content for display
+            content_preview = (
+                result.content[:80] + "..."
+                if len(result.content) > 80
+                else result.content
+            )
+            content_preview = content_preview.replace("\n", " ").strip()
+
+            # Escape Rich markup in content to prevent rendering issues
+            content_preview = content_preview.replace("[", "\\[").replace("]", "\\]")
+
+            table.add_row(
+                str(result.file_path.name),
+                f"{result.start_line}-{result.end_line}",
+                f"{result.similarity_score:.3f}",
+                content_preview,
+            )
+
+        console.print(
+            Panel(table, title="Semantic Search Results", border_style="cyan")
+        )
+
+        # Show detailed content for top result
+        if results:
+            top_result = results[0]
+            # Escape Rich markup in the detailed content
+            escaped_content = (
+                top_result.content.strip().replace("[", "\\[").replace("]", "\\]")
+            )
+            console.print(
+                Panel(
+                    dedent(f"""
+                [cyan]Top Result Details:[/cyan]
+                [bold]File:[/bold] {top_result.file_path}
+                [bold]Lines:[/bold] {top_result.start_line}-{top_result.end_line}
+                [bold]Similarity Score:[/bold] {top_result.similarity_score:.4f}
+
+                [bold]Content:[/bold]
+                {escaped_content}
+                """).strip(),
+                    title="🎯 Best Match",
+                    border_style="green",
+                )
+            )
+
+    except Exception as e:
+        console.print(
+            f"[red]Error performing search:[/red] {str(e).replace('[', '\\[').replace(']', '\\]')}"
+        )
+
+
+def handle_semantic_stats() -> None:
+    """Handle displaying semantic search index statistics."""
+    try:
+        console.print("[cyan]Retrieving semantic search index statistics...[/cyan]")
+
+        # Create default configuration
+        config = SemanticConfig(
+            embedding_model="sentence-transformers/all-MiniLM-L6-v2",
+            chunk_size=512,
+            chunk_overlap=50,
+            max_search_results=10,
+            similarity_threshold=0.7,
+            embedding_dimension=384,
+        )
+
+        # Initialize vector store with persistent database
+        db_path = Path.cwd() / ".crackerjack" / "semantic_index.db"
+        db_path.parent.mkdir(exist_ok=True)
+        vector_store = VectorStore(config, db_path=db_path)
+        stats = vector_store.get_stats()
+
+        # Create stats table
+        table = Table(title="Semantic Search Index Statistics")
+        table.add_column("Metric", style="cyan", no_wrap=True)
+        table.add_column("Value", style="green")
+
+        table.add_row("Total Files", str(stats.total_files))
+        table.add_row("Total Chunks", str(stats.total_chunks))
+        table.add_row("Index Size", f"{stats.index_size_mb:.2f} MB")
+
+        # Calculate average chunks per file
+        avg_chunks = (
+            stats.total_chunks / stats.total_files if stats.total_files > 0 else 0.0
+        )
+        table.add_row("Average Chunks per File", f"{avg_chunks:.1f}")
+
+        table.add_row("Embedding Model", config.embedding_model)
+        table.add_row("Embedding Dimension", "384")  # ONNX fallback uses 384 dimensions
+
+        if stats.last_updated:
+            table.add_row(
+                "Last Updated", stats.last_updated.strftime("%Y-%m-%d %H:%M:%S")
+            )
+
+        console.print(Panel(table, border_style="cyan"))
+
+        if stats.total_files == 0:
+            console.print(
+                Panel(
+                    "[yellow]The semantic search index is empty. Use [bold]--index[/bold] to add files.[/yellow]",
+                    title="💡 Tip",
+                    border_style="yellow",
+                )
+            )
+
+    except Exception as e:
+        console.print(
+            f"[red]Error retrieving stats:[/red] {str(e).replace('[', '\\[').replace(']', '\\]')}"
+        )
+
+
+def handle_remove_from_semantic_index(file_path: str) -> None:
+    """Handle removing a file from the semantic search index.
+
+    Args:
+        file_path: Path to the file to remove
+    """
+    try:
+        console.print(
+            f"[cyan]Removing file from semantic search index:[/cyan] {file_path}"
+        )
+
+        # Validate path
+        path_obj = Path(file_path)
+
+        # Create default configuration
+        config = SemanticConfig(
+            embedding_model="sentence-transformers/all-MiniLM-L6-v2",
+            chunk_size=512,
+            chunk_overlap=50,
+            max_search_results=10,
+            similarity_threshold=0.7,
+            embedding_dimension=384,
+        )
+
+        # Initialize vector store with persistent database
+        db_path = Path.cwd() / ".crackerjack" / "semantic_index.db"
+        db_path.parent.mkdir(exist_ok=True)
+        vector_store = VectorStore(config, db_path=db_path)
+        success = vector_store.remove_file(path_obj)
+
+        if success:
+            console.print(
+                f"[green]✅ Successfully removed {path_obj.name} from index[/green]"
+            )
+        else:
+            console.print(
+                f"[yellow]Warning:[/yellow] File {path_obj.name} was not found in index"
+            )
+
+        # Show updated stats
+        stats = vector_store.get_stats()
+        console.print(
+            f"[cyan]Index now contains:[/cyan] {stats.total_files} files, {stats.total_chunks} chunks"
+        )
+
+    except Exception as e:
+        console.print(
+            f"[red]Error removing file:[/red] {str(e).replace('[', '\\[').replace(']', '\\]')}"
+        )

crackerjack/cli/version.py

@@ -0,0 +1,19 @@
+from pathlib import Path
+
+
+def get_package_version() -> str:
+    try:
+        from importlib.metadata import version
+
+        return version("crackerjack")
+    except (ImportError, ModuleNotFoundError):
+        try:
+            import tomllib
+
+            pyproject_path = Path(__file__).parent.parent.parent / "pyproject.toml"
+            with pyproject_path.open("rb") as f:
+                pyproject_data = tomllib.load(f)
+            version_value = pyproject_data["project"]["version"]
+            return str(version_value)
+        except Exception:
+            return "unknown"

crackerjack/code_cleaner.py

@@ -5,7 +5,6 @@ from pathlib import Path
 from typing import Protocol
 
 from pydantic import BaseModel, ConfigDict
-from rich.console import Console
 
 from .errors import ErrorCode, ExecutionError
 from .services.backup_service import BackupMetadata, PackageBackupService
@@ -23,10 +22,10 @@ from .services.security_logger import (
 
 class SafePatternApplicator:
     def apply_docstring_patterns(self, code: str) -> str:
-        result = code
-        result = SAFE_PATTERNS["docstring_triple_double"].apply(result)
-        result = SAFE_PATTERNS["docstring_triple_single"].apply(result)
-        return result
+        # Intentionally a no-op for docstrings here. Actual docstring removal is
+        # handled by the structured AST cleaning step (_create_docstring_step).
+        # This keeps SafePatternApplicator focused on formatting-only changes.
+        return code
 
     def apply_formatting_patterns(self, content: str) -> str:
         content = SAFE_PATTERNS["spacing_after_comma"].apply(content)
@@ -35,17 +34,23 @@ class SafePatternApplicator:
         return content
 
     def has_preserved_comment(self, line: str) -> bool:
-        if line.strip().startswith("#! /"):
+        # Preserve shebangs (still useful for executable scripts)
+        if line.strip().startswith(("#! /", "#!/")):
             return True
 
         line_lower = line.lower()
         preserved_keywords = [
-            "coding: ",
-            "encoding: ",
-            "type: ",
+            # Security & linting directives (critical)
+            "nosec",
             "noqa",
             "pragma",
+            # Type checking directives (critical)
+            "type: ",
+            # Security markers (custom)
             "regex ok",
+            # Task tracking (useful)
+            "todo",
+            # Note: "coding:" and "encoding:" removed - obsolete since Python 3.0
         ]
         return any(keyword in line_lower for keyword in preserved_keywords)
 
@@ -86,7 +91,7 @@ class CleaningStepProtocol(Protocol):
 class FileProcessor(BaseModel):
     model_config = ConfigDict(arbitrary_types_allowed=True, extra="allow")
 
-    console: Console
+    console: t.Any
     logger: t.Any = None
     base_directory: Path | None = None
     security_logger: t.Any = None
@@ -198,7 +203,7 @@ class FileProcessor(BaseModel):
 class CleaningErrorHandler(BaseModel):
     model_config = ConfigDict(arbitrary_types_allowed=True)
 
-    console: Console
+    console: t.Any
     logger: t.Any = None
 
     def model_post_init(self, _: t.Any) -> None:
@@ -256,7 +261,7 @@ class CleaningPipeline(BaseModel):
 
     file_processor: t.Any
     error_handler: t.Any
-    console: Console
+    console: t.Any
     logger: t.Any = None
 
     def model_post_init(self, _: t.Any) -> None:
@@ -374,7 +379,7 @@ class CleaningPipeline(BaseModel):
 class CodeCleaner(BaseModel):
     model_config = ConfigDict(arbitrary_types_allowed=True, extra="allow")
 
-    console: Console
+    console: t.Any
     file_processor: t.Any = None
     error_handler: t.Any = None
     pipeline: t.Any = None
@@ -442,7 +447,8 @@ class CodeCleaner(BaseModel):
         )
 
         if pkg_dir is None:
-            pkg_dir = Path.cwd()
+            # Use configured base directory when no explicit path is provided
+            pkg_dir = self.base_directory or Path.cwd()
 
         python_files = self._discover_package_files(pkg_dir)
 
@@ -500,9 +506,20 @@ class CodeCleaner(BaseModel):
 
     def _prepare_package_directory(self, pkg_dir: Path | None) -> Path:
         if pkg_dir is None:
-            pkg_dir = Path.cwd()
-
-        return SecurePathValidator.validate_file_path(pkg_dir, self.base_directory)
+            pkg_dir = self.base_directory or Path.cwd()
+        # Avoid normalizing symlinks to preserve exact input path semantics
+        # while still enforcing base-directory containment.
+        if self.base_directory and not SecurePathValidator.is_within_directory(
+            pkg_dir, self.base_directory
+        ):
+            raise ExecutionError(
+                message=(
+                    f"Path outside allowed directory: {pkg_dir} not within "
+                    f"{self.base_directory}"
+                ),
+                error_code=ErrorCode.VALIDATION_ERROR,
+            )
+        return pkg_dir
 
     def _create_backup(self, validated_pkg_dir: Path) -> BackupMetadata:
         self.console.print(
@@ -1108,12 +1125,18 @@ class CodeCleaner(BaseModel):
             return '"' in line or "'" in line or "#" in line
 
         def _process_line_for_comment_removal(self, line: str) -> str:
-            """Process line to remove comments while preserving strings."""
+            """Process line to remove comments while preserving strings and special comments."""
             result_chars = []
             string_state = {"in_string": False, "quote_char": None}
 
             for i, char in enumerate(line):
-                if self._should_break_for_comment(char, string_state):
+                should_stop, preserve_rest = self._should_stop_for_comment(
+                    char, string_state, line, i
+                )
+                if should_stop:
+                    if preserve_rest:
+                        # Preserve the rest of the line (special comment like nosec, noqa, type:)
+                        result_chars.extend(line[i:])
                     break
 
                 self._update_string_state(char, i, line, string_state)
@@ -1121,11 +1144,24 @@ class CodeCleaner(BaseModel):
 
             return "".join(result_chars).rstrip()
 
-        def _should_break_for_comment(
-            self, char: str, string_state: dict[str, t.Any]
-        ) -> bool:
-            """Check if we should break for a comment character."""
-            return not string_state["in_string"] and char == "#"
+        def _should_stop_for_comment(
+            self, char: str, string_state: dict[str, t.Any], line: str, index: int
+        ) -> tuple[bool, bool]:
+            """Check if we should stop processing at comment.
+
+            Returns:
+                (should_stop, preserve_rest): should_stop=True when comment found,
+                                              preserve_rest=True if comment should be kept
+            """
+            if string_state["in_string"] or char != "#":
+                return (False, False)
+
+            # Check if the comment portion should be preserved
+            comment_part = line[index:].strip()
+            if _safe_applicator.has_preserved_comment(comment_part):
+                return (True, True)  # Stop processing, preserve the comment
+
+            return (True, False)  # Stop processing, discard the comment
 
         def _update_string_state(
             self, char: str, index: int, line: str, string_state: dict[str, t.Any]