wrd 0.1.2__py2.py3-none-any.whl

wrd/__version__.py

@@ -0,0 +1,7 @@
+"""Version information for WRD package."""
+
+# This version should match the version in pyproject.toml
+__version__ = "0.1.2"
+__author__ = "Tom Sapletta"
+__license__ = "Apache-2.0"
+__email__ = "info@softreck.dev"

wrd/cli.py

@@ -0,0 +1,312 @@
+"""WRD Command Line Interface."""
+
+import os
+import sys
+import yaml
+from pathlib import Path
+from typing import Dict, Any, Optional, List
+from rich.console import Console
+from rich.prompt import Prompt, Confirm, IntPrompt
+from rich.panel import Panel
+from rich.table import Table
+from rich.progress import track
+import subprocess
+import shutil
+
+console = Console()
+
+class WRDConfig:
+    """Manage WRD configuration."""
+    
+    def __init__(self):
+        self.config_dir = Path.home() / ".wrd"
+        self.config_file = self.config_dir / "config.yaml"
+        self.templates_dir = self.config_dir / "templates"
+        self.ensure_directories()
+        self.config = self.load_config()
+    
+    def ensure_directories(self):
+        """Ensure configuration directories exist."""
+        self.config_dir.mkdir(exist_ok=True)
+        self.templates_dir.mkdir(exist_ok=True)
+    
+    def load_config(self) -> Dict[str, Any]:
+        """Load configuration from YAML file."""
+        if not self.config_file.exists():
+            return {
+                "projects_dir": str(Path.home() / "projects"),
+                "editor": os.environ.get("EDITOR", "code"),
+                "default_language": "python",
+                "templates": {}
+            }
+        
+        with open(self.config_file, 'r') as f:
+            return yaml.safe_load(f) or {}
+    
+    def save_config(self):
+        """Save configuration to YAML file."""
+        with open(self.config_file, 'w') as f:
+            yaml.dump(self.config, f, default_flow_style=False)
+
+class WRDShell:
+    """Interactive WRD shell."""
+    
+    def __init__(self):
+        self.config = WRDConfig()
+        self.current_project = None
+        self.console = Console()
+    
+    def print_banner(self):
+        """Print WRD banner."""
+        banner = """
+        ██╗    ██╗██████╗ ██████╗ 
+        ██║    ██║██╔══██╗██╔══██╗
+        ██║ █╗ ██║██████╔╝██║  ██║
+        ██║███╗██║██╔══██╗██║  ██║
+        ╚███╔███╔╝██║  ██║██████╔╝
+         ╚══╝╚══╝ ╚═╝  ╚═╝╚═════╝ 
+        WRD - WRonai Development Tool
+        """
+        self.console.print(Panel.fit(banner, style="bold blue"))
+    
+    def get_menu_choice(self, title: str, options: List[Dict[str, str]], timeout: int = 10) -> str:
+        """Display a menu and get user choice."""
+        table = Table(title=title, show_header=False, show_lines=True)
+        table.add_column("Option", style="cyan")
+        table.add_column("Description")
+        
+        for i, option in enumerate(options, 1):
+            table.add_row(str(i), option['description'])
+        
+        self.console.print(table)
+        
+        try:
+            choice = IntPrompt.ask(
+                "\nEnter your choice",
+                choices=[str(i) for i in range(1, len(options) + 1)],
+                timeout=timeout
+            )
+            return options[int(choice) - 1]['command']
+        except Exception:
+            self.console.print("\n[bold red]Timeout reached. Using default option.[/]")
+            return options[0]['command']
+    
+    def init_project(self, project_path: Optional[str] = None):
+        """Initialize a new project."""
+        if project_path is None:
+            project_path = Prompt.ask("Enter project path", default=str(Path.cwd()))
+        
+        project_path = Path(project_path).absolute()
+        
+        if project_path.exists() and any(project_path.iterdir()):
+            self.console.print(f"[yellow]Directory {project_path} is not empty.[/]")
+            if not Confirm.ask("Do you want to initialize a project here anyway?"):
+                return
+        
+        # Get project details
+        project_name = project_path.name
+        language = Prompt.ask("Project language", default=self.config.config.get('default_language', 'python'))
+        description = Prompt.ask("Project description", default="")
+        
+        # Create project structure
+        project_path.mkdir(parents=True, exist_ok=True)
+        
+        # Initialize project based on language
+        if language == 'python':
+            self._init_python_project(project_path, project_name, description)
+        # Add more language support here
+        
+        self.console.print(f"[green]✓ Project {project_name} initialized successfully![/]")
+    
+    def _init_python_project(self, project_path: Path, name: str, description: str):
+        """Initialize a Python project."""
+        # Create basic Python project structure
+        (project_path / 'src' / name.replace('-', '_')).mkdir(parents=True, exist_ok=True)
+        (project_path / 'tests').mkdir(exist_ok=True)
+        
+        # Create pyproject.toml
+        pyproject = f"""[build-system]
+requires = ["setuptools>=42.0"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "{name}"
+version = "0.1.0"
+description = "{description}"
+authors = [
+    {{ name = "Your Name", email = "your.email@example.com" }}
+]
+readme = "README.md"
+requires-python = ">=3.8"
+
+[project.optional-dependencies]
+dev = [
+    "pytest>=6.0",
+    "black>=21.12b0",
+    "isort>=5.10.1",
+    "mypy>=0.910",
+    "pytest-cov>=2.0"
+]
+"""
+        (project_path / 'pyproject.toml').write_text(pyproject)
+        
+        # Create README.md
+        readme = f"""# {name}
+
+{description}
+
+## Installation
+
+```bash
+pip install -e .
+```
+
+## Development
+
+Install development dependencies:
+
+```bash
+pip install -e ".[dev]"
+```
+
+Run tests:
+
+```bash
+pytest
+```
+"""
+        (project_path / 'README.md').write_text(readme)
+        
+        # Create .gitignore
+        gitignore = """# Python
+__pycache__/
+*.py[cod]
+*$py.class
+*.so
+.Python
+build/
+develop-eggs/
+dist/
+downloads/
+eggs/
+.eggs/
+lib/
+lib64/
+parts/
+sdist/
+var/
+wheels/
+*.egg-info/
+.installed.cfg
+*.egg
+
+# Virtual Environment
+venv/
+env/
+
+# IDE
+.idea/
+.vscode/
+*.swp
+*.swo
+
+# Testing
+.coverage
+htmlcov/
+.pytest_cache/
+"""
+        (project_path / '.gitignore').write_text(gitignore)
+        
+        # Initialize git repository
+        try:
+            subprocess.run(['git', 'init'], cwd=project_path, check=True)
+            subprocess.run(['git', 'add', '.'], cwd=project_path, check=True)
+            subprocess.run(['git', 'commit', '-m', 'Initial commit'], cwd=project_path, check=True)
+        except Exception as e:
+            self.console.print(f"[yellow]Warning: Failed to initialize git repository: {e}[/]")
+    
+    def shell(self):
+        """Start interactive shell."""
+        self.print_banner()
+        
+        while True:
+            try:
+                options = [
+                    {'command': 'init', 'description': 'Initialize a new project'},
+                    {'command': 'list', 'description': 'List all projects'},
+                    {'command': 'config', 'description': 'Configure WRD'},
+                    {'command': 'exit', 'description': 'Exit WRD shell'}
+                ]
+                
+                choice = self.get_menu_choice("WRD - Main Menu", options, timeout=60)
+                
+                if choice == 'init':
+                    self.init_project()
+                elif choice == 'list':
+                    self.list_projects()
+                elif choice == 'config':
+                    self.configure()
+                elif choice == 'exit':
+                    self.console.print("[green]Goodbye![/]")
+                    break
+                    
+            except KeyboardInterrupt:
+                self.console.print("\n[red]Operation cancelled.[/]")
+            except Exception as e:
+                self.console.print(f"[red]Error: {e}[/]")
+    
+    def list_projects(self):
+        """List all projects in the projects directory."""
+        projects_dir = Path(self.config.config.get('projects_dir', Path.home() / 'projects'))
+        
+        if not projects_dir.exists():
+            self.console.print("[yellow]No projects directory found.[/]")
+            return
+        
+        table = Table(title="Projects")
+        table.add_column("Name", style="cyan")
+        table.add_column("Path")
+        table.add_column("Modified")
+        
+        for project_dir in projects_dir.iterdir():
+            if project_dir.is_dir():
+                modified = datetime.fromtimestamp(project_dir.stat().st_mtime).strftime('%Y-%m-%d %H:%M')
+                table.add_row(project_dir.name, str(project_dir), modified)
+        
+        self.console.print(table)
+    
+    def configure(self):
+        """Configure WRD settings."""
+        self.console.print("[bold]Current Configuration:[/]")
+        for key, value in self.config.config.items():
+            self.console.print(f"  [cyan]{key}:[/] {value}")
+        
+        if Confirm.ask("\nDo you want to change any settings?"):
+            setting = Prompt.ask("Enter setting name")
+            if setting in self.config.config:
+                if isinstance(self.config.config[setting], bool):
+                    new_value = Confirm.ask(f"New value for {setting}")
+                else:
+                    new_value = Prompt.ask(f"New value for {setting}")
+                self.config.config[setting] = new_value
+                self.config.save_config()
+                self.console.print("[green]✓ Configuration updated.[/]")
+            else:
+                self.console.print("[red]Invalid setting name.[/]")
+
+def main():
+    """Entry point for the WRD CLI."""
+    if len(sys.argv) > 1 and sys.argv[1] == 'shell':
+        WRDShell().shell()
+    elif len(sys.argv) > 1 and sys.argv[1] == 'init':
+        WRDShell().init_project(sys.argv[2] if len(sys.argv) > 2 else None)
+    else:
+        console = Console()
+        console.print("WRD - WRonai Development Tool")
+        console.print("\nUsage:")
+        console.print("  wrd shell     - Start interactive shell")
+        console.print("  wrd init [path] - Initialize a new project")
+        console.print("  wrd --help    - Show this help")
+
+if __name__ == "__main__":
+    main()

wrd/template_manager.py

@@ -0,0 +1,163 @@
+"""Template manager for WRD."""
+
+import os
+import shutil
+from pathlib import Path
+from typing import Dict, Any, Optional, List
+import yaml
+import jinja2
+import importlib.resources as pkg_resources
+from . import templates
+
+class TemplateManager:
+    """Manages project templates for different languages and project types."""
+    
+    def __init__(self):
+        self.templates_dir = Path(pkg_resources.files(templates))
+        self.available_templates = self._discover_templates()
+    
+    def _discover_templates(self) -> Dict[str, Dict[str, Any]]:
+        """Discover all available templates in the templates directory."""
+        templates = {}
+        
+        if not self.templates_dir.exists():
+            return {}
+        
+        for template_dir in self.templates_dir.iterdir():
+            if template_dir.is_dir() and (template_dir / 'project.yml').exists():
+                try:
+                    with open(template_dir / 'project.yml', 'r') as f:
+                        config = yaml.safe_load(f)
+                        templates[config['name']] = {
+                            'config': config,
+                            'path': template_dir
+                        }
+                except (yaml.YAMLError, KeyError) as e:
+                    print(f"Error loading template {template_dir.name}: {e}")
+        
+        return templates
+    
+    def get_template(self, name: str) -> Optional[Dict[str, Any]]:
+        """Get a template by name."""
+        return self.available_templates.get(name)
+    
+    def list_templates(self) -> List[str]:
+        """List all available template names."""
+        return list(self.available_templates.keys())
+    
+    def create_project(
+        self,
+        template_name: str,
+        project_path: Path,
+        context: Dict[str, Any],
+        overwrite: bool = False
+    ) -> bool:
+        """Create a new project from a template.
+        
+        Args:
+            template_name: Name of the template to use
+            project_path: Path where the project should be created
+            context: Dictionary with template variables
+            overwrite: Whether to overwrite existing files
+            
+        Returns:
+            bool: True if project was created successfully, False otherwise
+        """
+        template = self.get_template(template_name)
+        if not template:
+            print(f"Error: Template '{template_name}' not found")
+            return False
+        
+        project_path = project_path.absolute()
+        
+        # Create project directory if it doesn't exist
+        project_path.mkdir(parents=True, exist_ok=True)
+        
+        # Check if directory is empty or overwrite is allowed
+        if any(project_path.iterdir()) and not overwrite:
+            print(f"Error: Directory {project_path} is not empty. Use --overwrite to ignore.")
+            return False
+        
+        # Process template files
+        config = template['config']
+        template_dir = template['path']
+        
+        # Create directories
+        for dir_path in config.get('directories', []):
+            dir_path = project_path / self._render_template(dir_path, context)
+            dir_path.mkdir(parents=True, exist_ok=True)
+        
+        # Create files
+        for file_spec in config.get('files', []):
+            if isinstance(file_spec, dict):
+                file_path = file_spec['path']
+                content = file_spec.get('content')
+                template_file = file_spec.get('template')
+            else:
+                file_path = file_spec
+                content = None
+                template_file = None
+            
+            # Render the file path
+            file_path = self._render_template(file_path, context)
+            dest_path = project_path / file_path
+            
+            # Create parent directories if they don't exist
+            dest_path.parent.mkdir(parents=True, exist_ok=True)
+            
+            # Write file content
+            if content is not None:
+                # Use direct content
+                dest_path.write_text(self._render_template(content, context))
+            elif template_file is not None:
+                # Use template file
+                template_path = template_dir / template_file
+                if template_path.exists():
+                    template_content = template_path.read_text()
+                    rendered = self._render_template(template_content, context)
+                    dest_path.write_text(rendered)
+            else:
+                # Create empty file
+                dest_path.touch()
+        
+        # Run post-create commands
+        for cmd in config.get('post_create_commands', []):
+            cmd = self._render_template(cmd, context)
+            os.system(f"cd {project_path} && {cmd}")
+        
+        return True
+    
+    def _render_template(self, template_str: str, context: Dict[str, Any]) -> str:
+        """Render a template string with the given context."""
+        return jinja2.Template(template_str).render(**context)
+    
+    def get_template_variables(self, template_name: str) -> Dict[str, Any]:
+        """Get the required variables for a template."""
+        template = self.get_template(template_name)
+        if not template:
+            return {}
+        
+        # Extract variables from template files
+        variables = set()
+        
+        # Check config files
+        for file_spec in template['config'].get('files', []):
+            if isinstance(file_spec, dict):
+                content = file_spec.get('content', '')
+                template_file = file_spec.get('template')
+                
+                if template_file:
+                    template_path = template['path'] / template_file
+                    if template_path.exists():
+                        content = template_path.read_text()
+                
+                # Simple variable extraction ({{ variable }})
+                import re
+                variables.update(re.findall(r'\{\{\s*([^\s}]+)\s*\}\}', content))
+        
+        return {var: "" for var in variables}
+
+
+def get_template_manager() -> TemplateManager:
+    """Get a template manager instance."""
+    return TemplateManager()

wrd/templates/__init__.py

@@ -0,0 +1,4 @@
+"""WRD templates package."""
+
+# This file makes the templates directory a Python package
+# so we can use importlib.resources to access template files.

wrd/templates/python/README.md.j2

@@ -0,0 +1,33 @@
+# {{ project_name }}
+
+{{ description }}
+
+## Installation
+
+```bash
+pip install -e .
+```
+
+## Development
+
+Install development dependencies:
+
+```bash
+pip install -e ".[dev]"
+```
+
+## Running Tests
+
+```bash
+pytest
+```
+
+## Building the Package
+
+```bash
+python -m build
+```
+
+## License
+
+This project is licensed under the {{ license }} License - see the [LICENSE](LICENSE) file for details.

wrd/templates/python/gitignore.j2

@@ -0,0 +1,51 @@
+# Python
+__pycache__/
+*.py[cod]
+*$py.class
+*.so
+.Python
+build/
+develop-eggs/
+dist/
+downloads/
+eggs/
+.eggs/
+lib/
+lib64/
+parts/
+sdist/
+var/
+wheels/
+*.egg-info/
+.installed.cfg
+*.egg
+
+# Virtual Environment
+venv/
+env/
+
+# IDE
+.idea/
+.vscode/
+*.swp
+*.swo
+
+# Testing
+.coverage
+htmlcov/
+.pytest_cache/
+
+# Distribution
+*.whl
+*.tar.gz
+
+# Local development
+.env
+.env.local
+
+# Logs
+*.log
+
+# OS specific
+.DS_Store
+Thumbs.db

wrd/templates/python/project.yml

@@ -0,0 +1,39 @@
+# Python project template configuration
+name: python
+version: 1.0.0
+description: A Python project template for WRD
+
+# Files to create with their content templates
+files:
+  - path: pyproject.toml
+    template: pyproject.toml.j2
+  - path: README.md
+    template: README.md.j2
+  - path: .gitignore
+    template: gitignore.j2
+  - path: src/{{ package_name }}/__init__.py
+    content: |
+      """{{ project_name }} - {{ description }}"""
+      
+      __version__ = "0.1.0"
+  - path: tests/__init__.py
+    content: "# Test package"
+  - path: tests/test_basic.py
+    content: |
+      """Basic tests for {{ project_name }}."""
+      
+      def test_import():
+          """Test that the package can be imported."""
+          import {{ package_name }}
+          assert {{ package_name }} is not None
+
+# Directories to create
+directories:
+  - src/{{ package_name }}
+  - tests
+
+# Commands to run after project creation
+post_create_commands:
+  - git init
+  - git add .
+  - git commit -m "Initial commit"

wrd/templates/python/pyproject.toml.j2

@@ -0,0 +1,35 @@
+[build-system]
+requires = ["setuptools>=42.0"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "{{ package_name }}"
+version = "0.1.0"
+description = "{{ description }}"
+authors = [
+    { name = "{{ author_name }}", email = "{{ author_email }}" }
+]
+readme = "README.md"
+requires-python = ">=3.8"
+license = { text = "{{ license }}" }
+
+[project.optional-dependencies]
+dev = [
+    "pytest>=6.0",
+    "black>=21.12b0",
+    "isort>=5.10.1",
+    "mypy>=0.910",
+    "pytest-cov>=2.0"
+]
+
+[tool.black]
+line-length = 88
+target-version = ["py38"]
+
+[tool.isort]
+profile = "black"
+line_length = 88
+
+[tool.pytest.ini_options]
+testpaths = ["tests"]
+python_files = "test_*.py"