genxai-framework 0.1.0__py3-none-any.whl

genxai/tools/builtin/database/vector_search.py

@@ -0,0 +1,163 @@
+"""Vector search tool for semantic similarity search."""
+
+from typing import Any, Dict, List, Optional
+import logging
+
+from genxai.tools.base import Tool, ToolMetadata, ToolParameter, ToolCategory
+
+logger = logging.getLogger(__name__)
+
+
+class VectorSearchTool(Tool):
+    """Perform semantic similarity search in vector databases."""
+
+    def __init__(self) -> None:
+        """Initialize vector search tool."""
+        metadata = ToolMetadata(
+            name="vector_search",
+            description="Search vector databases for semantic similarity (supports in-memory vectors)",
+            category=ToolCategory.DATABASE,
+            tags=["vector", "semantic", "search", "similarity", "embeddings"],
+            version="1.0.0",
+        )
+
+        parameters = [
+            ToolParameter(
+                name="query",
+                type="string",
+                description="Search query text",
+                required=True,
+            ),
+            ToolParameter(
+                name="vectors",
+                type="object",
+                description="Dictionary of id:vector pairs to search (for in-memory search)",
+                required=True,
+            ),
+            ToolParameter(
+                name="top_k",
+                type="number",
+                description="Number of top results to return",
+                required=False,
+                default=5,
+                min_value=1,
+                max_value=100,
+            ),
+            ToolParameter(
+                name="threshold",
+                type="number",
+                description="Minimum similarity threshold (0-1)",
+                required=False,
+                default=0.0,
+                min_value=0.0,
+                max_value=1.0,
+            ),
+        ]
+
+        super().__init__(metadata, parameters)
+
+    async def _execute(
+        self,
+        query: str,
+        vectors: Dict[str, List[float]],
+        top_k: int = 5,
+        threshold: float = 0.0,
+    ) -> Dict[str, Any]:
+        """Execute vector search.
+
+        Args:
+            query: Search query
+            vectors: Dictionary of vectors to search
+            top_k: Number of results
+            threshold: Similarity threshold
+
+        Returns:
+            Dictionary containing search results
+        """
+        result: Dict[str, Any] = {
+            "query": query,
+            "success": False,
+        }
+
+        try:
+            # Simple in-memory vector search using cosine similarity
+            # In production, this would connect to Pinecone, Weaviate, etc.
+            
+            # For demo purposes, we'll use a simple similarity calculation
+            # Assuming query is already a vector or we have a simple embedding
+            
+            # Convert query to simple vector (character-based for demo)
+            query_vector = self._text_to_simple_vector(query)
+            
+            # Calculate similarities
+            similarities = []
+            for doc_id, doc_vector in vectors.items():
+                similarity = self._cosine_similarity(query_vector, doc_vector)
+                if similarity >= threshold:
+                    similarities.append({
+                        "id": doc_id,
+                        "similarity": similarity,
+                    })
+            
+            # Sort by similarity
+            similarities.sort(key=lambda x: x["similarity"], reverse=True)
+            
+            # Return top k
+            top_results = similarities[:top_k]
+            
+            result.update({
+                "results": top_results,
+                "count": len(top_results),
+                "total_searched": len(vectors),
+                "success": True,
+            })
+
+        except Exception as e:
+            result["error"] = str(e)
+
+        logger.info(f"Vector search completed: success={result['success']}")
+        return result
+
+    def _text_to_simple_vector(self, text: str, dim: int = 128) -> List[float]:
+        """Convert text to simple vector (demo implementation).
+
+        Args:
+            text: Input text
+            dim: Vector dimension
+
+        Returns:
+            Vector representation
+        """
+        # Simple character-based vectorization for demo
+        vector = [0.0] * dim
+        for i, char in enumerate(text[:dim]):
+            vector[i] = ord(char) / 255.0
+        return vector
+
+    def _cosine_similarity(self, vec1: List[float], vec2: List[float]) -> float:
+        """Calculate cosine similarity between two vectors.
+
+        Args:
+            vec1: First vector
+            vec2: Second vector
+
+        Returns:
+            Similarity score (0-1)
+        """
+        # Ensure same length
+        min_len = min(len(vec1), len(vec2))
+        vec1 = vec1[:min_len]
+        vec2 = vec2[:min_len]
+        
+        # Calculate dot product
+        dot_product = sum(a * b for a, b in zip(vec1, vec2))
+        
+        # Calculate magnitudes
+        mag1 = sum(a * a for a in vec1) ** 0.5
+        mag2 = sum(b * b for b in vec2) ** 0.5
+        
+        # Avoid division by zero
+        if mag1 == 0 or mag2 == 0:
+            return 0.0
+        
+        return dot_product / (mag1 * mag2)

genxai/tools/builtin/file/__init__.py

@@ -0,0 +1,17 @@
+"""File tools for GenXAI."""
+
+from genxai.tools.builtin.file.file_reader import FileReaderTool
+from genxai.tools.builtin.file.file_writer import FileWriterTool
+from genxai.tools.builtin.file.pdf_parser import PDFParserTool
+from genxai.tools.builtin.file.image_processor import ImageProcessorTool
+from genxai.tools.builtin.file.file_compressor import FileCompressorTool
+from genxai.tools.builtin.file.directory_scanner import DirectoryScannerTool
+
+__all__ = [
+    "FileReaderTool",
+    "FileWriterTool",
+    "PDFParserTool",
+    "ImageProcessorTool",
+    "FileCompressorTool",
+    "DirectoryScannerTool",
+]

genxai/tools/builtin/file/directory_scanner.py

@@ -0,0 +1,214 @@
+"""Directory scanner tool for scanning and analyzing directory structures."""
+
+from typing import Any, Dict, List
+import logging
+import os
+from pathlib import Path
+
+from genxai.tools.base import Tool, ToolMetadata, ToolParameter, ToolCategory
+
+logger = logging.getLogger(__name__)
+
+
+class DirectoryScannerTool(Tool):
+    """Scan directories and analyze file structures."""
+
+    def __init__(self) -> None:
+        """Initialize directory scanner tool."""
+        metadata = ToolMetadata(
+            name="directory_scanner",
+            description="Scan directories, list files, and analyze directory structures",
+            category=ToolCategory.FILE,
+            tags=["directory", "scan", "files", "structure", "analysis"],
+            version="1.0.0",
+        )
+
+        parameters = [
+            ToolParameter(
+                name="path",
+                type="string",
+                description="Path to directory to scan",
+                required=True,
+            ),
+            ToolParameter(
+                name="recursive",
+                type="boolean",
+                description="Whether to scan recursively",
+                required=False,
+                default=True,
+            ),
+            ToolParameter(
+                name="include_hidden",
+                type="boolean",
+                description="Whether to include hidden files",
+                required=False,
+                default=False,
+            ),
+            ToolParameter(
+                name="file_pattern",
+                type="string",
+                description="File pattern to match (e.g., '*.py', '*.txt')",
+                required=False,
+                pattern=r"^\*?\.\w+$",
+            ),
+            ToolParameter(
+                name="max_depth",
+                type="number",
+                description="Maximum depth for recursive scan",
+                required=False,
+                default=10,
+                min_value=1,
+                max_value=50,
+            ),
+        ]
+
+        super().__init__(metadata, parameters)
+
+    async def _execute(
+        self,
+        path: str,
+        recursive: bool = True,
+        include_hidden: bool = False,
+        file_pattern: str = None,
+        max_depth: int = 10,
+    ) -> Dict[str, Any]:
+        """Execute directory scanning.
+
+        Args:
+            directory_path: Directory to scan
+            recursive: Recursive scan flag
+            include_hidden: Include hidden files flag
+            file_pattern: File pattern to match
+            max_depth: Maximum depth
+
+        Returns:
+            Dictionary containing scan results
+        """
+        result: Dict[str, Any] = {
+            "path": path,
+            "success": False,
+        }
+
+        try:
+            if not os.path.exists(path):
+                raise FileNotFoundError(f"Directory not found: {path}")
+
+            if not os.path.isdir(path):
+                raise ValueError(f"Path is not a directory: {path}")
+
+            # Scan directory
+            files = []
+            directories = []
+            total_size = 0
+
+            if recursive:
+                for root, dirs, filenames in os.walk(path):
+                    # Calculate depth
+                    depth = root[len(path):].count(os.sep)
+                    if depth >= max_depth:
+                        dirs.clear()  # Don't recurse deeper
+                        continue
+
+                    # Filter hidden directories
+                    if not include_hidden:
+                        dirs[:] = [d for d in dirs if not d.startswith('.')]
+
+                    # Process directories
+                    for dirname in dirs:
+                        dir_path = os.path.join(root, dirname)
+                        directories.append({
+                            "name": dirname,
+                            "path": dir_path,
+                            "relative_path": os.path.relpath(dir_path, path),
+                            "depth": depth + 1,
+                        })
+
+                    # Process files
+                    for filename in filenames:
+                        # Filter hidden files
+                        if not include_hidden and filename.startswith('.'):
+                            continue
+
+                        # Filter by pattern
+                        if file_pattern:
+                            if not Path(filename).match(file_pattern):
+                                continue
+
+                        file_path = os.path.join(root, filename)
+                        file_stat = os.stat(file_path)
+                        file_size = file_stat.st_size
+                        total_size += file_size
+
+                        files.append({
+                            "name": filename,
+                            "path": file_path,
+                            "relative_path": os.path.relpath(file_path, path),
+                            "size": file_size,
+                            "extension": Path(filename).suffix,
+                            "modified_time": file_stat.st_mtime,
+                            "depth": depth,
+                        })
+            else:
+                # Non-recursive scan
+                for item in os.listdir(path):
+                    # Filter hidden items
+                    if not include_hidden and item.startswith('.'):
+                        continue
+
+                    item_path = os.path.join(path, item)
+
+                    if os.path.isdir(item_path):
+                        directories.append({
+                            "name": item,
+                            "path": item_path,
+                            "relative_path": item,
+                            "depth": 0,
+                        })
+                    else:
+                        # Filter by pattern
+                        if file_pattern and not Path(item).match(file_pattern):
+                            continue
+
+                        file_stat = os.stat(item_path)
+                        file_size = file_stat.st_size
+                        total_size += file_size
+
+                        files.append({
+                            "name": item,
+                            "path": item_path,
+                            "relative_path": item,
+                            "size": file_size,
+                            "extension": Path(item).suffix,
+                            "modified_time": file_stat.st_mtime,
+                            "depth": 0,
+                        })
+
+            # Calculate statistics
+            file_types = {}
+            for file in files:
+                ext = file["extension"] or "no_extension"
+                if ext not in file_types:
+                    file_types[ext] = {"count": 0, "total_size": 0}
+                file_types[ext]["count"] += 1
+                file_types[ext]["total_size"] += file["size"]
+
+            result.update({
+                "files": files,
+                "directories": directories,
+                "file_count": len(files),
+                "directory_count": len(directories),
+                "total_size": total_size,
+                "total_size_mb": round(total_size / (1024 * 1024), 2),
+                "file_types": file_types,
+                "success": True,
+            })
+
+        except FileNotFoundError as e:
+            result["error"] = str(e)
+        except PermissionError:
+            result["error"] = f"Permission denied: {path}"
+        except Exception as e:
+            result["error"] = str(e)
+
+        logger.info(f"Directory scan completed: success={result['success']}")
+        return result

genxai/tools/builtin/file/file_compressor.py

@@ -0,0 +1,237 @@
+"""File compressor tool for compressing and decompressing files."""
+
+from typing import Any, Dict, List, Optional
+import logging
+import os
+import zipfile
+import tarfile
+import gzip
+import shutil
+
+from genxai.tools.base import Tool, ToolMetadata, ToolParameter, ToolCategory
+
+logger = logging.getLogger(__name__)
+
+
+class FileCompressorTool(Tool):
+    """Compress and decompress files using various formats (ZIP, TAR, GZIP)."""
+
+    def __init__(self) -> None:
+        """Initialize file compressor tool."""
+        metadata = ToolMetadata(
+            name="file_compressor",
+            description="Compress and decompress files and directories using ZIP, TAR, or GZIP",
+            category=ToolCategory.FILE,
+            tags=["compression", "zip", "tar", "gzip", "archive"],
+            version="1.0.0",
+        )
+
+        parameters = [
+            ToolParameter(
+                name="operation",
+                type="string",
+                description="Operation to perform",
+                required=True,
+                enum=["compress", "decompress", "list"],
+            ),
+            ToolParameter(
+                name="source_path",
+                type="string",
+                description="Source file or directory path",
+                required=True,
+            ),
+            ToolParameter(
+                name="output_path",
+                type="string",
+                description="Output archive path (for compress) or extraction directory (for decompress)",
+                required=False,
+            ),
+            ToolParameter(
+                name="format",
+                type="string",
+                description="Compression format",
+                required=False,
+                default="zip",
+                enum=["zip", "tar", "tar.gz", "gzip"],
+            ),
+        ]
+
+        super().__init__(metadata, parameters)
+
+    async def _execute(
+        self,
+        operation: str,
+        source_path: str,
+        output_path: Optional[str] = None,
+        format: str = "zip",
+    ) -> Dict[str, Any]:
+        """Execute file compression/decompression.
+
+        Args:
+            operation: Operation to perform
+            source_path: Source path
+            output_path: Output path
+            format: Compression format
+
+        Returns:
+            Dictionary containing operation results
+        """
+        result: Dict[str, Any] = {
+            "operation": operation,
+            "format": format,
+            "success": False,
+        }
+
+        try:
+            if operation == "compress":
+                if not output_path:
+                    raise ValueError("output_path required for compress operation")
+
+                if format == "zip":
+                    result.update(self._compress_zip(source_path, output_path))
+                elif format in ["tar", "tar.gz"]:
+                    result.update(self._compress_tar(source_path, output_path, format))
+                elif format == "gzip":
+                    result.update(self._compress_gzip(source_path, output_path))
+
+            elif operation == "decompress":
+                if not output_path:
+                    raise ValueError("output_path required for decompress operation")
+
+                if format == "zip":
+                    result.update(self._decompress_zip(source_path, output_path))
+                elif format in ["tar", "tar.gz"]:
+                    result.update(self._decompress_tar(source_path, output_path))
+                elif format == "gzip":
+                    result.update(self._decompress_gzip(source_path, output_path))
+
+            elif operation == "list":
+                if format == "zip":
+                    result.update(self._list_zip(source_path))
+                elif format in ["tar", "tar.gz"]:
+                    result.update(self._list_tar(source_path))
+
+            result["success"] = True
+
+        except FileNotFoundError:
+            result["error"] = f"File not found: {source_path}"
+        except Exception as e:
+            result["error"] = str(e)
+
+        logger.info(f"File {operation} ({format}) completed: success={result['success']}")
+        return result
+
+    def _compress_zip(self, source_path: str, output_path: str) -> Dict[str, Any]:
+        """Compress to ZIP format."""
+        with zipfile.ZipFile(output_path, "w", zipfile.ZIP_DEFLATED) as zipf:
+            if os.path.isfile(source_path):
+                zipf.write(source_path, os.path.basename(source_path))
+                file_count = 1
+            else:
+                file_count = 0
+                for root, dirs, files in os.walk(source_path):
+                    for file in files:
+                        file_path = os.path.join(root, file)
+                        arcname = os.path.relpath(file_path, source_path)
+                        zipf.write(file_path, arcname)
+                        file_count += 1
+
+        return {
+            "output_path": output_path,
+            "file_count": file_count,
+            "compressed_size": os.path.getsize(output_path),
+        }
+
+    def _compress_tar(self, source_path: str, output_path: str, format: str) -> Dict[str, Any]:
+        """Compress to TAR format."""
+        mode = "w:gz" if format == "tar.gz" else "w"
+        
+        with tarfile.open(output_path, mode) as tar:
+            tar.add(source_path, arcname=os.path.basename(source_path))
+
+        return {
+            "output_path": output_path,
+            "compressed_size": os.path.getsize(output_path),
+        }
+
+    def _compress_gzip(self, source_path: str, output_path: str) -> Dict[str, Any]:
+        """Compress to GZIP format."""
+        with open(source_path, "rb") as f_in:
+            with gzip.open(output_path, "wb") as f_out:
+                shutil.copyfileobj(f_in, f_out)
+
+        return {
+            "output_path": output_path,
+            "original_size": os.path.getsize(source_path),
+            "compressed_size": os.path.getsize(output_path),
+            "compression_ratio": round(
+                os.path.getsize(output_path) / os.path.getsize(source_path), 2
+            ),
+        }
+
+    def _decompress_zip(self, source_path: str, output_path: str) -> Dict[str, Any]:
+        """Decompress ZIP format."""
+        with zipfile.ZipFile(source_path, "r") as zipf:
+            zipf.extractall(output_path)
+            file_count = len(zipf.namelist())
+
+        return {
+            "output_path": output_path,
+            "file_count": file_count,
+        }
+
+    def _decompress_tar(self, source_path: str, output_path: str) -> Dict[str, Any]:
+        """Decompress TAR format."""
+        with tarfile.open(source_path, "r:*") as tar:
+            tar.extractall(output_path)
+            file_count = len(tar.getmembers())
+
+        return {
+            "output_path": output_path,
+            "file_count": file_count,
+        }
+
+    def _decompress_gzip(self, source_path: str, output_path: str) -> Dict[str, Any]:
+        """Decompress GZIP format."""
+        with gzip.open(source_path, "rb") as f_in:
+            with open(output_path, "wb") as f_out:
+                shutil.copyfileobj(f_in, f_out)
+
+        return {
+            "output_path": output_path,
+            "decompressed_size": os.path.getsize(output_path),
+        }
+
+    def _list_zip(self, source_path: str) -> Dict[str, Any]:
+        """List contents of ZIP archive."""
+        with zipfile.ZipFile(source_path, "r") as zipf:
+            files = [
+                {
+                    "name": info.filename,
+                    "size": info.file_size,
+                    "compressed_size": info.compress_size,
+                }
+                for info in zipf.filelist
+            ]
+
+        return {
+            "file_count": len(files),
+            "files": files,
+        }
+
+    def _list_tar(self, source_path: str) -> Dict[str, Any]:
+        """List contents of TAR archive."""
+        with tarfile.open(source_path, "r:*") as tar:
+            files = [
+                {
+                    "name": member.name,
+                    "size": member.size,
+                    "type": "directory" if member.isdir() else "file",
+                }
+                for member in tar.getmembers()
+            ]
+
+        return {
+            "file_count": len(files),
+            "files": files,
+        }