auto-coder-web 0.1.0__py3-none-any.whl

auto_coder_web/file_group.py

@@ -0,0 +1,69 @@
+from fastapi import HTTPException
+from typing import List, Dict, Optional
+import os
+from .auto_coder_runner import AutoCoderRunner
+
+class FileGroupManager:
+    def __init__(self,auto_coder_runner: AutoCoderRunner):
+        self.runner = auto_coder_runner        
+        
+    async def create_group(self, name: str, description: str) -> Dict:
+        group = self.runner.add_group(name,description=description)
+        if group is None:
+            raise HTTPException(status_code=400, detail="Group already exists")
+        return {
+            "name": name,
+            "description": description,
+            "files": []  
+        }
+    
+    async def switch_groups(self, group_names: List[str]) -> Dict:
+        result = self.runner.switch_groups(group_names)
+        if result is None:
+            raise HTTPException(status_code=404, detail="Group not found")
+        return result
+    
+    async def delete_group(self, name: str) -> None:
+        result = self.runner.remove_group(name)
+        if result is None:
+            raise HTTPException(status_code=404, detail="Group not found")
+    
+    async def add_files_to_group(self, group_name: str, files: List[str]) -> Dict:
+        result = self.runner.add_files_to_group(group_name, files)
+        if result is None:
+            raise HTTPException(status_code=404, detail="Group not found")
+        return {
+            "name": group_name,
+            "files": result.get("files", [])
+        }
+    
+    async def remove_files_from_group(self, group_name: str, files: List[str]) -> Dict:
+        result = self.runner.remove_files_from_group(group_name, files)
+        if result is None:
+            raise HTTPException(status_code=404, detail="Group not found")
+        return {
+            "name": group_name, 
+            "files": result.get("files", [])
+        }
+    
+    async def get_groups(self) -> List[Dict]:
+        groups = self.runner.get_groups()
+        if not groups:
+            return []
+        return [
+            {
+                "name": group_name,
+                "files": self.runner.get_files_in_group(group_name).get("files", []),
+                "description": self.runner.get_group_description(group_name)
+            }
+            for group_name in groups.get("groups", [])
+        ]
+    
+    async def get_group(self, name: str) -> Optional[Dict]:
+        files = self.runner.get_files_in_group(name)
+        if files is None:
+            return None
+        return {
+            "name": name,
+            "files": files.get("files", [])
+        }

auto_coder_web/file_manager.py

@@ -0,0 +1,114 @@
+import os
+import json
+from typing import List, Dict, Any, Optional
+
+
+def get_directory_tree(root_path: str, path: str = None, lazy: bool = False) -> List[Dict[str, Any]]:
+    """
+    Generate a directory tree structure while ignoring common directories and files
+    that should not be included in version control or IDE specific files.
+
+    Args:
+        root_path: The root directory path to start traversing from
+        path: Optional path relative to root_path to get children for
+        lazy: If True, only return immediate children for directories
+
+    Returns:
+        A list of dictionaries representing the directory tree structure
+    """
+    # Common directories and files to ignore
+    IGNORE_PATTERNS = {
+        # Version control
+        '.git', '.svn', '.hg',
+        # Dependencies
+        'node_modules', 'venv', '.venv', 'env', '.env',
+        '__pycache__', '.pytest_cache',
+        # Build outputs
+        'dist', 'build', 'target',
+        # IDE specific
+        '.idea', '.vscode', '.vs',
+        # OS specific
+        '.DS_Store', 'Thumbs.db',
+        # Other common patterns
+        'coverage', '.coverage', 'htmlcov',
+        # Hidden directories (start with .)
+        '.*'
+    }
+
+    def should_ignore(name: str) -> bool:
+        """Check if a file or directory should be ignored"""
+        # Ignore hidden files/directories
+        if name.startswith('.'):
+            return True
+        # Ignore exact matches and pattern matches
+        return name in IGNORE_PATTERNS
+
+    def build_tree(current_path: str) -> List[Dict[str, Any]]:
+        """Recursively build the directory tree"""
+        items = []
+        try:
+            for name in sorted(os.listdir(current_path)):
+                if should_ignore(name):
+                    continue
+
+                full_path = os.path.join(current_path, name)
+                relative_path = os.path.relpath(full_path, root_path)
+
+                if os.path.isdir(full_path):
+                    if lazy:
+                        # For lazy loading, just check if directory has any visible children
+                        has_children = False
+                        for child_name in os.listdir(full_path):
+                            if not should_ignore(child_name):
+                                has_children = True
+                                break
+                        
+                        items.append({
+                            'title': name,
+                            'key': relative_path,
+                            'children': [],  # Empty children array for lazy loading
+                            'isLeaf': False,
+                            'hasChildren': has_children
+                        })
+                    else:
+                        children = build_tree(full_path)
+                        if children:  # Only add non-empty directories
+                            items.append({
+                                'title': name,
+                                'key': relative_path,
+                                'children': children,
+                                'isLeaf': False,
+                                'hasChildren': True
+                            })
+                else:
+                    items.append({
+                        'title': name,
+                        'key': relative_path,
+                        'isLeaf': True,
+                        'hasChildren': False
+                    })
+        except PermissionError:
+            # Skip directories we don't have permission to read
+            pass
+
+        return items
+
+    if path:
+        # If path is provided, get children of that specific directory
+        target_path = os.path.join(root_path, path)
+        if os.path.isdir(target_path):
+            return build_tree(target_path)
+        return []
+    
+    # If no path provided, build tree from root with lazy loading
+    return build_tree(root_path)
+
+
+def read_file_content(project_path: str, file_path: str) -> str:
+    """Read the content of a file"""
+    try:
+        full_path = os.path.join(project_path, file_path)
+        with open(full_path, 'r', encoding='utf-8') as f:
+            return f.read()
+    except (IOError, UnicodeDecodeError):
+        return None

auto_coder_web/hello.py

@@ -0,0 +1,36 @@
+def hello():
+    """
+    A simple hello function
+    
+    Returns:
+        str: A greeting message
+    """
+    return "Hello, Auto-Coder!"
+def hello():
+    """
+    A simple hello function
+    
+    Returns:
+        str: A greeting message
+    """
+    return "Hello, Auto-Coder!"
+def say_hello(name: str = "World") -> str:
+    """Returns a greeting message.
+    
+    Args:
+        name: The name to greet. Defaults to "World".
+        
+    Returns:
+        A greeting string
+    """
+    return f"Hello, {name}!"
+def say_hello(name: str = "World") -> str:
+    """Returns a greeting message.
+    
+    Args:
+        name: The name to greet. Defaults to "World".
+        
+    Returns:
+        A greeting string
+    """
+    return f"Hello, {name}!"

auto_coder_web/json_file_storage.py

@@ -0,0 +1,44 @@
+import json
+import os
+import aiofiles
+from typing import Dict, List, Optional
+
+class JsonFileStorage:
+    def __init__(self, storage_dir: Optional[str] = None):
+        self.storage_dir = storage_dir or os.path.expanduser("~/.auto-coder.web")
+        os.makedirs(self.storage_dir, exist_ok=True)
+        
+        self.file_groups_path = os.path.join(self.storage_dir, "file_groups.json")
+        self.project_path_file = os.path.join(self.storage_dir, "project_path.json")
+
+    async def save_file_groups(self, groups: Dict[str, Dict]) -> None:
+        """Save file groups to JSON file"""
+        async with aiofiles.open(self.file_groups_path, 'w') as f:
+            await f.write(json.dumps(groups, indent=2))
+
+    async def load_file_groups(self) -> Dict[str, Dict]:
+        """Load file groups from JSON file"""
+        try:
+            async with aiofiles.open(self.file_groups_path, 'r') as f:
+                content = await f.read()
+                return json.loads(content)
+        except (FileNotFoundError, json.JSONDecodeError):
+            return {}
+
+    async def save_project_path(self, path: str) -> None:
+        """Save project path to JSON file"""
+        async with aiofiles.open(self.project_path_file, 'w') as f:
+            await f.write(json.dumps({"project_path": path}, indent=2))
+
+    async def load_project_path(self) -> Optional[str]:
+        """Load project path from JSON file"""
+        try:
+            async with aiofiles.open(self.project_path_file, 'r') as f:
+                content = await f.read()
+                data = json.loads(content)
+                return data.get("project_path")
+        except (FileNotFoundError, json.JSONDecodeError):
+            return None
+
+# Global instance
+storage = JsonFileStorage()