toolplane-python-client 0.1.0__py3-none-any.whl

toolplane/toolkits/standalone_tools/create_directory.py

@@ -0,0 +1,94 @@
+#!/usr/bin/env python3
+"""
+Description: Create a new directory structure with enhanced features.
+
+This tool creates directories recursively (like mkdir -p) and provides
+additional features like permission handling and validation.
+
+Parameters:
+  dirPath (string, required): The absolute path to the directory to create.
+  mode (integer, optional): The permission mode for the directory (default: 0o755).
+  parents (boolean, optional): Create parent directories if they don't exist (default: True).
+  exist_ok (boolean, optional): Don't raise an error if the directory already exists (default: True).
+"""
+
+import argparse
+import os
+import sys
+from pathlib import Path
+
+
+def create_directory(
+    dir_path: str, mode: int = 0o755, parents: bool = True, exist_ok: bool = True
+) -> bool:
+    """
+    Create a directory with the specified parameters.
+
+    Args:
+        dir_path: The absolute path to the directory to create
+        mode: Permission mode for the directory
+        parents: Create parent directories if they don't exist
+        exist_ok: Don't raise error if directory already exists
+
+    Returns:
+        bool: True if directory was created or already exists, False otherwise
+    """
+    try:
+        path = Path(dir_path)
+        path.mkdir(mode=mode, parents=parents, exist_ok=exist_ok)
+
+        if path.exists():
+            print(f"Directory created successfully: {dir_path}")
+            return True
+        else:
+            print(f"Failed to create directory: {dir_path}")
+            return False
+
+    except PermissionError:
+        print(f"Permission denied: Cannot create directory {dir_path}")
+        return False
+    except FileExistsError:
+        print(f"Directory already exists: {dir_path}")
+        return exist_ok
+    except Exception as e:
+        print(f"Error creating directory {dir_path}: {e}")
+        return False
+
+
+def main():
+    parser = argparse.ArgumentParser(
+        description="Create a new directory structure with enhanced features."
+    )
+    parser.add_argument(
+        "dirPath", type=str, help="The absolute path to the directory to create."
+    )
+    parser.add_argument(
+        "--mode",
+        type=lambda x: int(x, 8),  # Parse as octal
+        default=0o755,
+        help="Permission mode for the directory (octal, default: 755)",
+    )
+    parser.add_argument(
+        "--parents",
+        action="store_true",
+        default=True,
+        help="Create parent directories if they don't exist (default: True)",
+    )
+    parser.add_argument(
+        "--exist_ok",
+        action="store_true",
+        default=True,
+        help="Don't raise error if directory already exists (default: True)",
+    )
+
+    args = parser.parse_args()
+
+    success = create_directory(
+        args.dirPath, mode=args.mode, parents=args.parents, exist_ok=args.exist_ok
+    )
+
+    sys.exit(0 if success else 1)
+
+
+if __name__ == "__main__":
+    main()

toolplane/toolkits/standalone_tools/create_file.py

@@ -0,0 +1,124 @@
+#!/usr/bin/env python3
+"""
+Description: Create a new file with specified content and enhanced features.
+
+This tool creates a new file with the given content and automatically creates
+parent directories if they don't exist. It includes validation and error handling.
+
+Parameters:
+  filePath (string, required): The absolute path to the file to create.
+  content (string, required): The content to write to the file.
+  encoding (string, optional): The encoding to use for the file (default: utf-8).
+  mode (string, optional): The file creation mode (default: 'w').
+  auto_create_dirs (boolean, optional): Create parent directories if they don't exist (default: True).
+  overwrite (boolean, optional): Overwrite the file if it already exists (default: False).
+"""
+
+import argparse
+import os
+import sys
+from pathlib import Path
+
+
+def create_file(
+    file_path: str,
+    content: str,
+    encoding: str = "utf-8",
+    mode: str = "w",
+    auto_create_dirs: bool = True,
+    overwrite: bool = False,
+) -> bool:
+    """
+    Create a new file with the specified content.
+
+    Args:
+        file_path: The absolute path to the file to create
+        content: The content to write to the file
+        encoding: The encoding to use for the file
+        mode: The file creation mode
+        auto_create_dirs: Create parent directories if they don't exist
+        overwrite: Overwrite the file if it already exists
+
+    Returns:
+        bool: True if file was created successfully, False otherwise
+    """
+    try:
+        path = Path(file_path)
+
+        # Check if file already exists
+        if path.exists() and not overwrite:
+            print(f"File already exists: {file_path}")
+            print("Use --overwrite flag to overwrite existing files.")
+            return False
+
+        # Create parent directories if needed
+        if auto_create_dirs and not path.parent.exists():
+            path.parent.mkdir(parents=True, exist_ok=True)
+            print(f"Created parent directories for: {file_path}")
+
+        # Write the file
+        with open(path, mode, encoding=encoding) as f:
+            f.write(content)
+
+        print(f"File created successfully: {file_path}")
+        print(f"Content length: {len(content)} characters")
+        return True
+
+    except PermissionError:
+        print(f"Permission denied: Cannot create file {file_path}")
+        return False
+    except FileNotFoundError:
+        print(f"Directory does not exist: {path.parent}")
+        print("Use --auto_create_dirs flag to create parent directories.")
+        return False
+    except Exception as e:
+        print(f"Error creating file {file_path}: {e}")
+        return False
+
+
+def main():
+    parser = argparse.ArgumentParser(
+        description="Create a new file with specified content and enhanced features."
+    )
+    parser.add_argument(
+        "filePath", type=str, help="The absolute path to the file to create."
+    )
+    parser.add_argument("content", type=str, help="The content to write to the file.")
+    parser.add_argument(
+        "--encoding",
+        type=str,
+        default="utf-8",
+        help="The encoding to use for the file (default: utf-8)",
+    )
+    parser.add_argument(
+        "--mode", type=str, default="w", help="The file creation mode (default: 'w')"
+    )
+    parser.add_argument(
+        "--auto_create_dirs",
+        action="store_true",
+        default=True,
+        help="Create parent directories if they don't exist (default: True)",
+    )
+    parser.add_argument(
+        "--overwrite",
+        action="store_true",
+        default=False,
+        help="Overwrite the file if it already exists (default: False)",
+    )
+
+    args = parser.parse_args()
+
+    success = create_file(
+        args.filePath,
+        args.content,
+        encoding=args.encoding,
+        mode=args.mode,
+        auto_create_dirs=args.auto_create_dirs,
+        overwrite=args.overwrite,
+    )
+
+    sys.exit(0 if success else 1)
+
+
+if __name__ == "__main__":
+    main()

toolplane/toolkits/standalone_tools/file_search.py

@@ -0,0 +1,229 @@
+#!/usr/bin/env python3
+"""
+Description: Search for files in the workspace using glob patterns with advanced features.
+
+This tool searches for files using glob patterns and provides additional
+filtering and sorting options. It returns file paths matching the pattern.
+
+Parameters:
+  query (string, required): Glob pattern to search for files.
+  max_results (integer, optional): Maximum number of results to return.
+  include_hidden (boolean, optional): Include hidden files in results (default: False).
+  sort_by (string, optional): Sort results by 'name', 'size', 'modified' (default: 'name').
+  reverse_sort (boolean, optional): Reverse the sort order (default: False).
+  show_details (boolean, optional): Show file details like size and modification time (default: False).
+"""
+
+import argparse
+import glob
+import os
+import sys
+import time
+from pathlib import Path
+from typing import Any, Dict, List
+
+
+def file_search(
+    query: str,
+    max_results: int = None,
+    include_hidden: bool = False,
+    sort_by: str = "name",
+    reverse_sort: bool = False,
+    show_details: bool = False,
+    base_path: str = None,
+) -> List[Dict[str, Any]]:
+    """
+    Search for files using glob patterns with advanced features.
+
+    Args:
+        query: Glob pattern to search for files
+        max_results: Maximum number of results to return
+        include_hidden: Include hidden files in results
+        sort_by: Sort results by 'name', 'size', 'modified'
+        reverse_sort: Reverse the sort order
+        show_details: Show file details like size and modification time
+        base_path: Base directory to search from (default: current directory)
+
+    Returns:
+        List of dictionaries containing file information
+    """
+    if base_path is None:
+        base_path = os.getcwd()
+
+    # Change to base directory for glob search
+    original_cwd = os.getcwd()
+    os.chdir(base_path)
+
+    try:
+        # Use glob to find matching files
+        matches = glob.glob(query, recursive=True)
+
+        results = []
+        for match in matches:
+            try:
+                path = Path(match)
+                absolute_path = path.resolve()
+
+                # Skip hidden files if not requested
+                if not include_hidden and any(
+                    part.startswith(".") for part in path.parts
+                ):
+                    continue
+
+                # Get file stats
+                stat = absolute_path.stat()
+
+                result = {
+                    "path": str(absolute_path),
+                    "relative_path": str(path),
+                    "name": path.name,
+                    "is_file": absolute_path.is_file(),
+                    "is_dir": absolute_path.is_dir(),
+                    "size": stat.st_size if absolute_path.is_file() else 0,
+                    "modified": stat.st_mtime,
+                    "modified_readable": time.strftime(
+                        "%Y-%m-%d %H:%M:%S", time.localtime(stat.st_mtime)
+                    ),
+                }
+
+                results.append(result)
+
+            except (OSError, PermissionError) as e:
+                # Skip files that can't be accessed
+                continue
+
+        # Sort results
+        if sort_by == "name":
+            results.sort(key=lambda x: x["name"].lower(), reverse=reverse_sort)
+        elif sort_by == "size":
+            results.sort(key=lambda x: x["size"], reverse=reverse_sort)
+        elif sort_by == "modified":
+            results.sort(key=lambda x: x["modified"], reverse=reverse_sort)
+
+        # Limit results if specified
+        if max_results and len(results) > max_results:
+            results = results[:max_results]
+
+        return results
+
+    finally:
+        # Restore original working directory
+        os.chdir(original_cwd)
+
+
+def format_size(size_bytes: int) -> str:
+    """Format file size in human-readable format."""
+    if size_bytes == 0:
+        return "0 B"
+
+    units = ["B", "KB", "MB", "GB", "TB"]
+    i = 0
+    while size_bytes >= 1024 and i < len(units) - 1:
+        size_bytes /= 1024
+        i += 1
+
+    return f"{size_bytes:.1f} {units[i]}"
+
+
+def main():
+    parser = argparse.ArgumentParser(
+        description="Search for files in the workspace using glob patterns with advanced features."
+    )
+    parser.add_argument(
+        "query",
+        type=str,
+        help="Glob pattern to search for files (e.g., '*.py', '**/*.txt', 'src/**/*.js')",
+    )
+    parser.add_argument(
+        "--max_results", type=int, help="Maximum number of results to return"
+    )
+    parser.add_argument(
+        "--include_hidden",
+        action="store_true",
+        default=False,
+        help="Include hidden files in results (default: False)",
+    )
+    parser.add_argument(
+        "--sort_by",
+        choices=["name", "size", "modified"],
+        default="name",
+        help="Sort results by 'name', 'size', or 'modified' (default: name)",
+    )
+    parser.add_argument(
+        "--reverse_sort",
+        action="store_true",
+        default=False,
+        help="Reverse the sort order (default: False)",
+    )
+    parser.add_argument(
+        "--show_details",
+        action="store_true",
+        default=False,
+        help="Show file details like size and modification time (default: False)",
+    )
+    parser.add_argument(
+        "--base_path",
+        type=str,
+        help="Base directory to search from (default: current directory)",
+    )
+    parser.add_argument(
+        "--output_format",
+        choices=["list", "table", "json"],
+        default="list",
+        help="Output format (default: list)",
+    )
+
+    args = parser.parse_args()
+
+    results = file_search(
+        args.query,
+        max_results=args.max_results,
+        include_hidden=args.include_hidden,
+        sort_by=args.sort_by,
+        reverse_sort=args.reverse_sort,
+        show_details=args.show_details,
+        base_path=args.base_path,
+    )
+
+    if not results:
+        print(f"No files found matching pattern: {args.query}")
+        sys.exit(0)
+
+    if args.output_format == "json":
+        import json
+
+        print(json.dumps(results, indent=2))
+
+    elif args.output_format == "table" or args.show_details:
+        print(f"Found {len(results)} files matching pattern: {args.query}")
+        print("-" * 80)
+
+        if args.show_details:
+            print(f"{'Name':<40} {'Size':<12} {'Modified':<20} {'Type':<8}")
+            print("-" * 80)
+
+            for result in results:
+                file_type = "DIR" if result["is_dir"] else "FILE"
+                size_str = format_size(result["size"]) if result["is_file"] else "-"
+
+                print(
+                    f"{result['name']:<40} {size_str:<12} {result['modified_readable']:<20} {file_type:<8}"
+                )
+        else:
+            for result in results:
+                print(result["path"])
+
+    else:  # list format
+        print(f"Found {len(results)} files matching pattern: {args.query}")
+        for result in results:
+            print(result["path"])
+
+    # Show truncation warning if results were limited
+    if args.max_results and len(results) == args.max_results:
+        print(
+            f"\nResults truncated to {args.max_results} items. Use --max_results to see more."
+        )
+
+
+if __name__ == "__main__":
+    main()