ebk 0.3.1__py3-none-any.whl → 0.3.2__py3-none-any.whl

ebk/repl/find.py

@@ -0,0 +1,126 @@
+"""Find command implementation for REPL shell."""
+
+from typing import List, Dict, Any, Optional
+from ebk.library_db import Library
+from ebk.db.models import Book
+
+
+class FindQuery:
+    """Book finder with metadata filters."""
+
+    def __init__(self, library: Library):
+        """Initialize find query.
+
+        Args:
+            library: Library instance
+        """
+        self.library = library
+
+    def find(self, filters: Dict[str, Any]) -> List[Book]:
+        """Find books matching filters.
+
+        Args:
+            filters: Dictionary of field:value filters
+                Supported fields:
+                - title: Book title (partial match)
+                - author: Author name (partial match)
+                - subject: Subject/tag (partial match)
+                - text: Full-text search (FTS5 across title, description, extracted text)
+                - language: Language code (exact match)
+                - year: Publication year (exact match)
+                - publisher: Publisher name (partial match)
+                - format: File format (exact match, e.g., pdf, epub)
+                - limit: Maximum results (default: 50)
+
+        Returns:
+            List of matching books
+        """
+        query = self.library.query()
+
+        # Apply filters
+        if "title" in filters:
+            query = query.filter_by_title(filters["title"])
+
+        if "author" in filters:
+            query = query.filter_by_author(filters["author"])
+
+        if "subject" in filters:
+            query = query.filter_by_subject(filters["subject"])
+
+        if "language" in filters:
+            query = query.filter_by_language(filters["language"])
+
+        if "year" in filters:
+            try:
+                year = int(filters["year"])
+                query = query.filter_by_year(year)
+            except ValueError:
+                pass  # Skip invalid year
+
+        if "publisher" in filters:
+            query = query.filter_by_publisher(filters["publisher"])
+
+        if "format" in filters:
+            query = query.filter_by_format(filters["format"])
+
+        if "text" in filters:
+            query = query.filter_by_text(filters["text"])
+
+        # Apply limit
+        limit = filters.get("limit", 50)
+        try:
+            # Convert to int if it's a string
+            if isinstance(limit, str):
+                limit = int(limit)
+            if isinstance(limit, int):
+                query = query.limit(limit)
+        except (ValueError, TypeError):
+            # Invalid limit, use default
+            query = query.limit(50)
+
+        # Execute query
+        return query.all()
+
+    def parse_filters(self, args: List[str]) -> Dict[str, Any]:
+        """Parse command-line arguments into filter dictionary.
+
+        Args:
+            args: List of filter arguments in format "field:value"
+
+        Returns:
+            Dictionary of filters
+
+        Raises:
+            ValueError: If argument format is invalid
+        """
+        filters = {}
+
+        for arg in args:
+            if ":" not in arg:
+                raise ValueError(f"Invalid filter format: {arg}. Use field:value")
+
+            field, value = arg.split(":", 1)
+            field = field.lower().strip()
+            value = value.strip()
+
+            # Validate field
+            valid_fields = {
+                "title",
+                "author",
+                "subject",
+                "text",
+                "language",
+                "year",
+                "publisher",
+                "format",
+                "limit",
+            }
+
+            if field not in valid_fields:
+                raise ValueError(
+                    f"Unknown field: {field}. Valid fields: {', '.join(sorted(valid_fields))}"
+                )
+
+            filters[field] = value
+
+        return filters

ebk/repl/grep.py

@@ -0,0 +1,174 @@
+"""grep implementation for REPL shell."""
+
+import re
+from typing import List, Tuple, Optional
+from pathlib import Path
+
+from ebk.vfs import LibraryVFS, DirectoryNode, FileNode
+
+
+class GrepMatcher:
+    """Unix-like grep functionality for VFS."""
+
+    def __init__(self, vfs: LibraryVFS):
+        """Initialize grep matcher.
+
+        Args:
+            vfs: VFS instance
+        """
+        self.vfs = vfs
+
+    def grep(
+        self,
+        pattern: str,
+        paths: List[str],
+        recursive: bool = False,
+        ignore_case: bool = False,
+        line_numbers: bool = False,
+    ) -> List[Tuple[str, int, str]]:
+        """Search for pattern in files.
+
+        Args:
+            pattern: Regex pattern to search for
+            paths: List of paths to search (files or directories)
+            recursive: Search directories recursively
+            ignore_case: Case-insensitive matching
+            line_numbers: Include line numbers in output
+
+        Returns:
+            List of (file_path, line_number, line_content) tuples
+        """
+        results = []
+
+        # Compile regex
+        flags = re.IGNORECASE if ignore_case else 0
+        try:
+            regex = re.compile(pattern, flags)
+        except re.error as e:
+            raise ValueError(f"Invalid regex pattern: {e}")
+
+        # Process each path
+        for path in paths:
+            results.extend(
+                self._search_path(path, regex, recursive, line_numbers)
+            )
+
+        return results
+
+    def _search_path(
+        self,
+        path: str,
+        regex: re.Pattern,
+        recursive: bool,
+        line_numbers: bool,
+    ) -> List[Tuple[str, int, str]]:
+        """Search a single path.
+
+        Args:
+            path: Path to search
+            regex: Compiled regex pattern
+            recursive: Search recursively
+            line_numbers: Include line numbers
+
+        Returns:
+            List of matches
+        """
+        results = []
+
+        # Resolve path
+        node = self.vfs.get_node(path)
+        if node is None:
+            return results
+
+        # If it's a file, search it
+        if isinstance(node, FileNode):
+            results.extend(self._search_file(node, regex, line_numbers))
+
+        # If it's a directory, search children
+        elif isinstance(node, DirectoryNode):
+            if recursive:
+                results.extend(
+                    self._search_directory_recursive(node, regex, line_numbers)
+                )
+            else:
+                # Just search immediate children that are files
+                for child in node.list_children():
+                    if isinstance(child, FileNode):
+                        results.extend(
+                            self._search_file(child, regex, line_numbers)
+                        )
+
+        return results
+
+    def _search_file(
+        self,
+        file_node: FileNode,
+        regex: re.Pattern,
+        line_numbers: bool,
+    ) -> List[Tuple[str, int, str]]:
+        """Search a single file.
+
+        Args:
+            file_node: File node to search
+            regex: Compiled regex pattern
+            line_numbers: Include line numbers
+
+        Returns:
+            List of matches
+        """
+        results = []
+
+        try:
+            content = file_node.read_content()
+            lines = content.split("\n")
+
+            file_path = file_node.get_path()
+
+            for i, line in enumerate(lines, start=1):
+                if regex.search(line):
+                    line_num = i if line_numbers else 0
+                    results.append((file_path, line_num, line))
+
+        except Exception:
+            # Skip files that can't be read
+            pass
+
+        return results
+
+    def _search_directory_recursive(
+        self,
+        dir_node: DirectoryNode,
+        regex: re.Pattern,
+        line_numbers: bool,
+    ) -> List[Tuple[str, int, str]]:
+        """Search directory recursively.
+
+        Args:
+            dir_node: Directory node to search
+            regex: Compiled regex pattern
+            line_numbers: Include line numbers
+
+        Returns:
+            List of matches
+        """
+        results = []
+
+        try:
+            children = dir_node.list_children()
+
+            for child in children:
+                if isinstance(child, FileNode):
+                    results.extend(self._search_file(child, regex, line_numbers))
+                elif isinstance(child, DirectoryNode):
+                    # Recurse into subdirectory
+                    results.extend(
+                        self._search_directory_recursive(
+                            child, regex, line_numbers
+                        )
+                    )
+
+        except Exception:
+            # Skip directories that can't be read
+            pass
+
+        return results