amen-cli 0.1.0__py3-none-any.whl

amen/__init__.py

@@ -0,0 +1,25 @@
+"""AMEN CLI - Python Web Framework Scaffolding Tool"""
+__version__ = "0.1.0"
+__author__ = "Tanaka Chinengundu"
+
+__description__ = "A composer-inspired Python Web Framework Scaffolding Tool"
+__license__ = "Modified MIT with Attribution Requirements"
+__copyright__ = "Copyright (c) 2025 Tanaka Chinengundu"
+__email__ = "tanakah30@gmail.com"
+__url__ = "https://github.com/taqsblaze/amen-cli"
+__docs__ = "https://github.com/taqsblaze/amen-cli/#readme"
+__python_requires__ = ">=3.7"
+
+SUPPORTED_FRAMEWORKS = {
+    "flask": {"version": ">=2.0.0", "port": 5000},
+    "fastapi": {"version": ">=0.68.0", "port": 8000}
+}
+
+# Package status
+__status__ = "Development"
+__maintainer__ = "Tanaka Chinengundu"
+__credits__ = ["Tanaka Chinengundu"]
+
+# Feature flags
+ENABLE_LOGGING = True
+DEBUG_MODE = True

amen/cli.py

@@ -0,0 +1,230 @@
+import os
+import sys
+import subprocess
+import venv
+from pathlib import Path
+
+import click
+import questionary
+from rich.console import Console
+from rich.panel import Panel
+from rich.progress import Progress, SpinnerColumn, TextColumn
+
+from .frameworks import FRAMEWORKS
+from .templates import TemplateManager
+
+console = Console()
+
+VALID_FRAMEWORKS = ['flask', 'fastapi', 'bottle', 'pyramid']
+VALID_PROJECT_TYPES = ['webapp', 'api']
+
+def create_project(path, framework, project_type):
+    """
+    Create a new project with the specified framework and type.
+    
+    Args:
+        path (str): Project directory path
+        framework (str): Web framework to use
+        project_type (str): Type of project (webapp/api)
+    """
+    if framework not in VALID_FRAMEWORKS:
+        raise ValueError(f"Invalid framework. Choose from: {VALID_FRAMEWORKS}")
+    
+    if project_type not in VALID_PROJECT_TYPES:
+        raise ValueError(f"Invalid project type. Choose from: {VALID_PROJECT_TYPES}")
+
+    # Create project directory
+    os.makedirs(path, exist_ok=True)
+    
+    # Create basic structure
+    os.makedirs(os.path.join(path, "app"), exist_ok=True)
+    os.makedirs(os.path.join(path, "app", "templates"), exist_ok=True)
+    os.makedirs(os.path.join(path, "app", "static"), exist_ok=True)
+    
+    # Create empty files
+    open(os.path.join(path, "requirements.txt"), 'a').close()
+    open(os.path.join(path, "README.md"), 'a').close()
+
+class AmenCLI:
+    def __init__(self):
+        self.template_manager = TemplateManager()
+    
+    def welcome_banner(self):
+        """Display welcome banner"""
+        console.print(Panel.fit(
+            """AMEN: composer-inspired Python Web Framework Scaffolding
+        Create your web applications with ease!
+        By [bold magenta]Tanaka Chinengundu[/bold magenta]
+        [bold blue]
+            """,
+            border_style="magenta"
+        ))
+        console.print()
+    
+    def select_framework(self) -> str:
+        """Interactive framework selection"""
+        frameworks = list(FRAMEWORKS.keys())
+        
+        choice = questionary.select(
+            "🚀 Select a web framework:",
+            choices=[
+                questionary.Choice(f"{FRAMEWORKS[fw]['name']} - {FRAMEWORKS[fw]['description']}", fw)
+                for fw in frameworks
+            ]
+        ).ask()
+        
+        return choice
+    
+    def select_app_type(self) -> str:
+        """Select application type"""
+        return questionary.select(
+            "🏗️  What type of application?",
+            choices=[
+                questionary.Choice("Full Web Application (with frontend)", "webapp"),
+                questionary.Choice("API Only", "api"),
+            ]
+        ).ask()
+    
+    def get_app_name(self) -> str:
+        """Get application name"""
+        return questionary.text(
+            "📝 Enter your application name:",
+            validate=lambda x: len(x.strip()) > 0 or "Application name cannot be empty"
+        ).ask().strip()
+    
+    def create_virtual_environment(self, app_path: Path) -> bool:
+        """Create virtual environment"""
+        venv_path = app_path / "venv"
+        
+        try:
+            with Progress(
+                SpinnerColumn(),
+                TextColumn("[progress.description]{task.description}"),
+                console=console,
+            ) as progress:
+                task = progress.add_task("Creating virtual environment...", total=None)
+                venv.create(venv_path, with_pip=True)
+                progress.update(task, description="✅ Virtual environment created")
+            
+            return True
+        except Exception as e:
+            console.print(f"❌ Error creating virtual environment: {e}", style="red")
+            return False
+    
+    def install_framework(self, app_path: Path, framework: str) -> bool:
+        """Install selected framework in virtual environment"""
+        venv_path = app_path / "venv"
+        
+        # Determine pip path based on OS
+        if sys.platform == "win32":
+            pip_path = venv_path / "Scripts" / "pip"
+        else:
+            pip_path = venv_path / "bin" / "pip"
+
+        framework_info = FRAMEWORKS[framework]
+        packages = framework_info['packages']
+        
+        try:
+            with Progress(
+                SpinnerColumn(),
+                TextColumn("[progress.description]{task.description}"),
+                console=console,
+            ) as progress:
+                task = progress.add_task(f"Installing {framework_info['name']}...", total=None)
+                
+                for package in packages:
+                    subprocess.run([
+                        str(pip_path), "install", package
+                    ], check=True, capture_output=True)
+                
+                progress.update(task, description=f"✅ {framework_info['name']} installed")
+            
+            return True
+        except subprocess.CalledProcessError as e:
+            console.print(f"❌ Error installing {framework_info['name']}: {e}", style="red")
+            return False
+    
+    def create_app(self):
+        """Main app creation flow"""
+        self.welcome_banner()
+        
+        # Get user choices
+        framework = self.select_framework()
+        if not framework:
+            console.print("❌ No framework selected. Exiting.", style="red")
+            return
+            
+        app_type = self.select_app_type()
+        if not app_type:
+            console.print("❌ No application type selected. Exiting.", style="red")
+            return
+            
+        app_name = self.get_app_name()
+        if not app_name:
+            console.print("❌ No application name provided. Exiting.", style="red")
+            return
+
+        # Create application directory
+        app_path = Path.cwd() / app_name
+        
+        if app_path.exists():
+            overwrite = questionary.confirm(
+                f"Directory '{app_name}' already exists. Overwrite?"
+            ).ask()
+            
+            if not overwrite:
+                console.print("❌ Operation cancelled.", style="yellow")
+                return
+            
+            import shutil
+            shutil.rmtree(app_path)
+
+        app_path.mkdir()
+        console.print(f"📁 Created directory: {app_path}", style="green")
+
+        # Create virtual environment
+        if not self.create_virtual_environment(app_path):
+            return
+
+        # Install framework
+        if not self.install_framework(app_path, framework):
+            return
+
+        # Generate project structure
+        with Progress(
+            SpinnerColumn(),
+            TextColumn("[progress.description]{task.description}"),
+            console=console,
+        ) as progress:
+            task = progress.add_task("Generating project structure...", total=None)
+            self.template_manager.generate_structure(app_path, framework, app_type, app_name)
+            progress.update(task, description="✅ Project structure generated")
+
+        # Success message
+        console.print(Panel(
+            f"""🎉 Successfully created '{app_name}'!
+
+📁 Next Steps:
+   1. cd {app_name}
+   2. source venv/bin/activate  (Linux/Mac) or venv\\Scripts\\activate (Windows)  
+   3. python run.py
+
+Your app will be running at http://localhost:{FRAMEWORKS[framework]['default_port']}
+            """.strip(),
+            title="🎊 Project Created Successfully!",
+            border_style="green"
+        ))
+
+@click.group()
+def main():
+    """Amen - composer-inspired Python web framework scaffolding tool"""
+    pass
+
+@main.command()
+def create():
+    """Create a new web application"""
+    cli = AmenCLI()
+    cli.create_app()
+
+if __name__ == "__main__":
+    main()

amen/frameworks.py

@@ -0,0 +1,46 @@
+"""Framework configurations and metadata"""
+
+FRAMEWORKS = {
+    'flask': {
+        'name': 'Flask',
+        'description': 'Lightweight WSGI web application framework',
+        'packages': ['flask', 'flask-cors', 'python-dotenv'],
+        'default_port': 5000,
+        'entry_file': 'app.py',
+    },
+    # 'django': {
+    #     'name': 'Django',
+    #     'description': 'High-level Python web framework',
+    #     'packages': ['django', 'django-cors-headers', 'python-dotenv'],
+    #     'default_port': 8000,
+    #     'entry_file': 'manage.py',
+    # },
+    'fastapi': {
+        'name': 'FastAPI',
+        'description': 'Modern, fast web framework for building APIs',
+        'packages': ['fastapi', 'uvicorn[standard]', 'python-dotenv'],
+        'default_port': 8000,
+        'entry_file': 'main.py',
+    },
+    # 'bottle': {
+    #     'name': 'Bottle',
+    #     'description': 'Fast, simple micro web framework',
+    #     'packages': ['bottle', 'python-dotenv'],
+    #     'default_port': 8080,
+    #     'entry_file': 'app.py',
+    # },
+    # 'pyramid': {
+    #     'name': 'Pyramid',
+    #     'description': 'Flexible, open source web framework',
+    #     'packages': ['pyramid', 'waitress', 'python-dotenv'],
+    #     'default_port': 6543,
+    #     'entry_file': 'app.py',
+    # },
+    # 'django-hotsauce': {
+    #     'name': 'Django Hotsauce',
+    #     'description': 'Django-based rapid development framework',
+    #     'packages': ['django', 'django-hotsauce', 'python-dotenv'],
+    #     'default_port': 8000,
+    #     'entry_file': 'manage.py',
+    # }
+}

amen/templates/__init__.py

@@ -0,0 +1,3 @@
+from .manager import TemplateManager
+
+__all__ = ['TemplateManager']

amen/templates/manager.py

@@ -0,0 +1,617 @@
+"""Template management for different frameworks"""
+
+import os
+from pathlib import Path
+from ..frameworks import FRAMEWORKS
+
+class TemplateManager:
+    def _write_file(self, path: Path, content: str):
+        """Helper method to write files with UTF-8 encoding"""
+        # Ensure parent directory exists
+        path.parent.mkdir(parents=True, exist_ok=True)
+        path.write_text(content, encoding='utf-8')
+
+    def generate_structure(self, app_path: Path, framework: str, app_type: str, app_name: str):
+        """Generate project structure based on framework and app type"""
+        
+        # Create all necessary directories
+        (app_path / "app").mkdir(exist_ok=True)
+        (app_path / "app" / "templates").mkdir(exist_ok=True)
+        (app_path / "app" / "static").mkdir(exist_ok=True)
+        (app_path / "app" / "static" / "css").mkdir(exist_ok=True)
+        (app_path / "app" / "static" / "js").mkdir(exist_ok=True)
+        (app_path / "tests").mkdir(exist_ok=True)  # Create tests directory
+        
+        # Generate framework-specific files
+        if framework == 'flask':
+            self._generate_flask_files(app_path, app_type, app_name)
+        elif framework == 'fastapi':
+            self._generate_fastapi_files(app_path, app_type, app_name)
+        # Add other frameworks as needed
+        
+        # Generate common files
+        self._generate_common_files(app_path, framework, app_name, app_type)
+    
+    def _generate_flask_files(self, app_path: Path, app_type: str, app_name: str):
+        """Generate Flask files"""
+        app_content = f"""from flask import Flask, render_template, jsonify
+from flask_cors import CORS
+from dotenv import load_dotenv
+import os
+
+load_dotenv()
+
+app = Flask(__name__)
+CORS(app)
+
+app.config['SECRET_KEY'] = os.getenv('SECRET_KEY', 'dev-secret-key')
+
+@app.route('/')
+def index():
+    {"return render_template('index.html', title='" + app_name + "')" if app_type == 'webapp' else "return jsonify({'message': 'Welcome to " + app_name + " API!'})"}
+
+@app.route('/health')
+def health():
+    return jsonify({{'status': 'healthy', 'service': '{app_name}'}})
+
+if __name__ == '__main__':
+    app.run(host='0.0.0.0', port=int(os.getenv('PORT', 5000)), debug=True)
+"""
+        self._write_file(app_path / "app" / "app.py", app_content)
+        self._write_file(app_path / "run.py", "from app.app import app\n\nif __name__ == '__main__':\n    app.run()")
+        
+        if app_type == 'webapp':
+            self._generate_html_template(app_path, app_name)
+    
+    def _generate_fastapi_files(self, app_path: Path, app_type: str, app_name: str):
+        """Generate FastAPI files"""
+        main_content = f"""from fastapi import FastAPI, Request
+from fastapi.middleware.cors import CORSMiddleware
+{"from fastapi.templating import Jinja2Templates" if app_type == 'webapp' else ""}
+{"from fastapi.staticfiles import StaticFiles" if app_type == 'webapp' else ""}
+from dotenv import load_dotenv
+import os
+
+load_dotenv()
+
+app = FastAPI(title="{app_name}")
+
+app.add_middleware(
+    CORSMiddleware,
+    allow_origins=["*"],
+    allow_credentials=True,
+    allow_methods=["*"],
+    allow_headers=["*"],
+)
+
+{"app.mount('/static', StaticFiles(directory='app/static'), name='static')" if app_type == 'webapp' else ""}
+{"templates = Jinja2Templates(directory='app/templates')" if app_type == 'webapp' else ""}
+
+@app.get("/")
+async def root({"request: Request" if app_type == 'webapp' else ""}):
+    {"return templates.TemplateResponse('index.html', {'request': request, 'title': '" + app_name + "'})" if app_type == 'webapp' else 'return {"message": "Welcome to ' + app_name + ' API!"}'}
+
+@app.get("/health")
+async def health():
+    return {{"status": "healthy", "service": "{app_name}"}}
+
+if __name__ == "__main__":
+    import uvicorn
+    uvicorn.run(app, host="0.0.0.0", port=8000)
+"""
+        self._write_file(app_path / "app" / "main.py", main_content)
+        self._write_file(app_path / "run.py", "import uvicorn\nfrom app.main import app\n\nif __name__ == '__main__':\n    uvicorn.run(app, host='0.0.0.0', port=8000)")
+        
+        if app_type == 'webapp':
+            self._generate_html_template(app_path, app_name)
+    
+    def _generate_html_template(self, app_path: Path, app_name: str):
+        """Generate HTML template"""
+        template_content = f"""<!DOCTYPE html>
+<html lang="en">
+<head>
+    <meta charset="UTF-8">
+    <meta name="viewport" content="width=device-width, initial-scale=1.0">
+    <title>{app_name}</title>
+    <link rel="stylesheet" href="/static/css/style.css">
+</head>
+<body>
+    <div class="container">
+        <h1>Welcome to {app_name}!</h1>
+        <p>Your application is running successfully.</p>
+    </div>
+    <script src="/static/js/app.js"></script>
+</body>
+</html>"""
+        self._write_file(app_path / "app" / "templates" / "index.html", template_content)
+    
+    def _generate_common_files(self, app_path: Path, framework: str, app_name: str, app_type: str):
+        """Generate common files for all projects"""
+        
+        # requirements.txt
+        framework_info = FRAMEWORKS[framework]
+        requirements = "\n".join(framework_info['packages'])
+        self._write_file(app_path / "requirements.txt", requirements)
+        
+        # .env
+        env_content = f"""SECRET_KEY=your-secret-key-here
+DEBUG=True
+PORT={framework_info['default_port']}
+"""
+        self._write_file(app_path / ".env", env_content)
+        
+        # README.md
+        readme_content = f"""# {app_name}
+
+A web application built with {framework_info['name']}.
+
+## Quick Start
+
+1. Activate virtual environment:
+   ```bash
+   source venv/bin/activate  # Linux/Mac
+   venv\\Scripts\\activate    # Windows
+3. **Install dependencies** (if not already installed)
+   ```bash
+   pip install -r requirements.txt
+   ```
+
+4. **Set up environment variables**
+   ```bash
+   cp .env.example .env
+   # Edit .env file with your configuration
+   ```
+
+5. **Run the application**
+   ```bash
+   python run.py
+   ```
+
+Your application will be available at `http://localhost:{framework_info['default_port']}`
+
+## 📁 Project Structure
+
+```
+{app_name}/
+├── venv/                   # Virtual environment
+├── app/                    # Main application code
+│   ├── __init__.py
+│   ├── {framework_info['entry_file']}     # Main application file
+│   ├── templates/          # HTML templates (if web app)
+│   └── static/            # Static files (CSS, JS, images)
+│       ├── css/
+│       └── js/
+├── tests/                  # Test files
+├── docs/                   # Documentation
+├── requirements.txt        # Python dependencies
+├── .env                   # Environment variables (local)
+├── .env.example          # Environment variables template
+├── .gitignore            # Git ignore rules
+├── run.py                # Application runner
+└── README.md             # This file
+```
+
+## 🛠️ Development
+
+### Framework: {FRAMEWORKS[framework]['name']}
+{FRAMEWORKS[framework]['description']}
+
+### Application Type: {"Full Web Application" if app_type == 'webapp' else "API Only"}
+
+### Available Endpoints
+- `GET /` - {"Main page" if app_type == 'webapp' else "API welcome message"}
+- `GET /health` - Health check endpoint
+
+### Adding New Routes
+
+#### {FRAMEWORKS[framework]['name']} specific instructions:
+'''
+
+        # Add framework-specific route examples
+        if framework == 'flask':
+            readme_content += '''
+```python
+from flask import Flask
+
+@app.route('/new-route')
+def new_route():
+    return 'Hello from new route!'
+```
+'''
+        elif framework == 'fastapi':
+            readme_content += '''
+```python
+from fastapi import FastAPI
+
+@app.get("/new-route")
+async def new_route():
+    return {{"message": "Hello from new route!"}}
+```
+'''
+        elif framework == 'django':
+            readme_content += '''
+1. Add to `app/urls.py`:
+```python
+path('new-route/', views.new_route, name='new_route'),
+```
+
+2. Add to `app/views.py`:
+```python
+def new_route(request):
+    return JsonResponse({{'message': 'Hello from new route!'}})
+```
+'''
+        elif framework == 'bottle':
+            readme_content += '''
+```python
+@app.route('/new-route')
+def new_route():
+    return {{'message': 'Hello from new route!'}}
+```
+'''
+        elif framework == 'pyramid':
+            readme_content += '''
+1. Add route in `main()`:
+```python
+config.add_route('new_route', '/new-route')
+```
+
+2. Add view function:
+```python
+@view_config(route_name='new_route', renderer='json')
+def new_route_view(request):
+    return {{'message': 'Hello from new route!'}}
+```
+"""
+
+        readme_content += f"""
+
+## 🧪 Testing
+
+Run tests with:
+```bash
+pytest tests/
+```
+
+## 📦 Deployment
+
+### Environment Variables
+Make sure to set these in production:
+- `SECRET_KEY`: A secure secret key
+- `DEBUG`: Set to `False` in production
+- `PORT`: Port number for the application
+
+### Docker (Optional)
+Create a `Dockerfile`:
+```dockerfile
+FROM python:3.9-slim
+
+WORKDIR /app
+
+COPY requirements.txt .`
+RUN pip install -r requirements.txt
+
+COPY . .
+
+EXPOSE {framework_info['default_port']}
+
+CMD ["python", "run.py"]
+```
+
+## 🤝 Contributing
+
+1. Fork the repository
+2. Create a feature branch (`git checkout -b feature/amazing-feature`)
+3. Commit your changes (`git commit -m 'Add amazing feature'`)
+4. Push to the branch (`git push origin feature/amazing-feature`)
+5. Open a Pull Request
+
+## 📄 License
+
+This project is licensed under the MIT License.
+
+## 🙏 Acknowledgments
+
+- Built with [Amen CLI](https://github.com/your-username/amen-cli)
+- Powered by {FRAMEWORKS[framework]['name']}
+
+---
+
+Happy coding! 🎉
+"""
+        
+        self._write_file(app_path / "README.md", readme_content)
+        
+        # Generate CSS
+        css_content = """/* Reset and Base Styles */
+* {
+    margin: 0;
+    padding: 0;
+    box-sizing: border-box;
+}
+
+body {
+    font-family: -apple-system, BlinkMacSystemFont, 'Segoe UI', Roboto, Oxygen, Ubuntu, Cantarell, sans-serif;
+    line-height: 1.6;
+    color: #333;
+    background: linear-gradient(135deg, #667eea 0%, #764ba2 100%);
+    min-height: 100vh;
+}
+
+.container {
+    max-width: 1200px;
+    margin: 0 auto;
+    padding: 2rem;
+}
+
+/* Header */
+header {
+    text-align: center;
+    margin-bottom: 3rem;
+    color: white;
+}
+
+header h1 {
+    font-size: 3rem;
+    font-weight: 700;
+    margin-bottom: 0.5rem;
+    text-shadow: 2px 2px 4px rgba(0,0,0,0.3);
+}
+
+.subtitle {
+    font-size: 1.2rem;
+    opacity: 0.9;
+    font-weight: 300;
+}
+
+/* Hero Section */
+.hero {
+    background: white;
+    padding: 3rem;
+    border-radius: 15px;
+    box-shadow: 0 20px 40px rgba(0,0,0,0.1);
+    text-align: center;
+    margin-bottom: 3rem;
+}
+
+.hero h2 {
+    color: #667eea;
+    font-size: 2rem;
+    margin-bottom: 1rem;
+}
+
+.hero p {
+    font-size: 1.1rem;
+    color: #666;
+}
+
+/* Features Grid */
+.features {
+    display: grid;
+    grid-template-columns: repeat(auto-fit, minmax(300px, 1fr));
+    gap: 2rem;
+    margin-bottom: 3rem;
+}
+
+.feature {
+    background: white;
+    padding: 2rem;
+    border-radius: 10px;
+    box-shadow: 0 10px 25px rgba(0,0,0,0.1);
+    transition: transform 0.3s ease, box-shadow 0.3s ease;
+}
+
+.feature:hover {
+    transform: translateY(-5px);
+    box-shadow: 0 15px 35px rgba(0,0,0,0.15);
+}
+
+.feature h3 {
+    color: #667eea;
+    font-size: 1.3rem;
+    margin-bottom: 1rem;
+}
+
+.feature p {
+    color: #666;
+    font-size: 1rem;
+}
+
+/* Footer */
+footer {
+    text-align: center;
+    color: white;
+    opacity: 0.8;
+    padding: 2rem 0;
+}
+
+/* Responsive Design */
+@media (max-width: 768px) {
+    .container {
+        padding: 1rem;
+    }
+    
+    header h1 {
+        font-size: 2rem;
+    }
+    
+    .hero {
+        padding: 2rem;
+    }
+    
+    .hero h2 {
+        font-size: 1.5rem;
+    }
+    
+    .features {
+        grid-template-columns: 1fr;
+        gap: 1rem;
+    }
+    
+    .feature {
+        padding: 1.5rem;
+    }
+}
+
+/* Animation */
+@keyframes fadeInUp {
+    from {
+        opacity: 0;
+        transform: translateY(30px);
+    }
+    to {
+        opacity: 1;
+        transform: translateY(0);
+    }
+}
+
+.hero, .feature {
+    animation: fadeInUp 0.6s ease-out;
+}
+
+.feature:nth-child(2) {
+    animation-delay: 0.1s;
+}
+
+.feature:nth-child(3) {
+    animation-delay: 0.2s;
+}
+"""
+        
+        self._write_file(app_path / "app" / "static" / "css" / "style.css", css_content)
+        
+        # Generate JavaScript
+        js_content = """// Main application JavaScript
+document.addEventListener('DOMContentLoaded', function() {
+    console.log('Application loaded successfully!');
+    
+    // Add smooth scrolling for anchor links
+    const links = document.querySelectorAll('a[href^="#"]');
+    links.forEach(link => {
+        link.addEventListener('click', function(e) {
+            e.preventDefault();
+            const target = document.querySelector(this.getAttribute('href'));
+            if (target) {
+                target.scrollIntoView({
+                    behavior: 'smooth',
+                    block: 'start'
+                });
+            }
+        });
+    });
+    
+    // Add click animation to features
+    const features = document.querySelectorAll('.feature');
+    features.forEach(feature => {
+        feature.addEventListener('click', function() {
+            this.style.transform = 'scale(0.98)';
+            setTimeout(() => {
+                this.style.transform = '';
+            }, 150);
+        });
+    });
+    
+    // Health check function (example API call)
+    async function checkHealth() {
+        try {
+            const response = await fetch('/health');
+            const data = await response.json();
+            console.log('Health check:', data);
+        } catch (error) {
+            console.error('Health check failed:', error);
+        }
+    }
+    
+    // Uncomment to perform health check on load
+    // checkHealth();
+});
+
+// Utility functions
+const utils = {
+    // Format date
+    formatDate: (date) => {
+        return new Intl.DateTimeFormat('en-US', {
+            year: 'numeric',
+            month: 'long',
+            day: 'numeric'
+        }).format(date);
+    },
+    
+    // Debounce function
+    debounce: (func, wait) => {
+        let timeout;
+        return function executedFunction(...args) {
+            const later = () => {
+                clearTimeout(timeout);
+                func(...args);
+            };
+            clearTimeout(timeout);
+            timeout = setTimeout(later, wait);
+        };
+    },
+    
+    // Show notification (you can integrate with a toast library)
+    showNotification: (message, type = 'info') => {
+        console.log(`[${type.toUpperCase()}] ${message}`);
+        // Implement your notification system here
+    }
+};
+
+// Export for use in other scripts
+window.AppUtils = utils;
+"""
+        self._write_file(app_path / "app" / "static" / "js" / "app.js", js_content)
+        
+        # Generate test files
+        test_content = f"""import pytest
+import sys
+import os
+
+# Add the app directory to the Python path
+sys.path.insert(0, os.path.join(os.path.dirname(__file__), '..', 'app'))
+
+def test_basic_functionality():
+    '''Test basic functionality'''
+    assert True  # Replace with actual tests
+
+class Test{app_name.replace('-', '').replace('_', '').title()}:
+    '''Test class for {app_name}'''
+    
+    def test_app_creation(self):
+        '''Test application creation'''
+        # Add your app-specific tests here
+        pass
+    
+    def test_health_endpoint(self):
+        '''Test health endpoint'''
+        # Add health endpoint test
+        pass
+"""
+# Add more tests as needed
+
+        
+        self._write_file(app_path / "tests" / "__init__.py", "")
+        self._write_file(app_path / "tests" / f"test_{app_name.replace('-', '_')}.py", test_content)
+        
+        # Generate pytest configuration
+        pytest_ini = """
+[tool:pytest]
+testpaths = tests
+python_files = test_*.py
+python_functions = test_*
+python_classes = Test*
+addopts = -v --tb=short
+"""
+        
+        self._write_file(app_path / "pytest.ini", pytest_ini)
+
+        self._write_file(app_path / "pytest.ini", pytest_ini)
+
+# MANIFEST.in - for including non-Python files in the package
+MANIFEST_IN = """
+include README.md
+include LICENSE
+recursive-include amen/templates *.py *.html *.css *.js *.md
+recursive-exclude * __pycache__
+recursive-exclude * *.py[co]
+"""

amen_cli-0.1.0.dist-info/METADATA

@@ -0,0 +1,189 @@
+Metadata-Version: 2.4
+Name: amen-cli
+Version: 0.1.0
+Summary: composer-inspired Python web framework scaffolding tool
+Home-page: https://github.com/taqsblaze/amen-cli
+Author: Tanaka Chinengundu
+Author-email: tanakah30@gmail.com
+Project-URL: Bug Reports, https://github.com/taqsblaze/amen-cli/issues
+Project-URL: Source, https://github.com/taqsblaze/amen-cli
+Project-URL: Documentation, https://github.com/taqsblaze/amen-cli#readme
+Keywords: python,web-framework,cli,scaffold,amen,composer,laravel,flask,django,fastapi,bottle,pyramid
+Classifier: Development Status :: 3 - Alpha
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: OS Independent
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Topic :: Software Development :: Libraries :: Python Modules
+Requires-Python: >=3.11
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: click>=8.0.0
+Requires-Dist: rich>=12.0.0
+Requires-Dist: questionary>=1.10.0
+Requires-Dist: virtualenv>=20.0.0
+Provides-Extra: dev
+Requires-Dist: pytest>=6.0.0; extra == "dev"
+Requires-Dist: pytest-cov>=2.0.0; extra == "dev"
+Requires-Dist: black>=21.0.0; extra == "dev"
+Requires-Dist: flake8>=3.9.0; extra == "dev"
+Requires-Dist: mypy>=0.900; extra == "dev"
+Dynamic: author
+Dynamic: author-email
+Dynamic: classifier
+Dynamic: description
+Dynamic: description-content-type
+Dynamic: home-page
+Dynamic: keywords
+Dynamic: license-file
+Dynamic: project-url
+Dynamic: provides-extra
+Dynamic: requires-dist
+Dynamic: requires-python
+Dynamic: summary
+
+# 🚀 AMEN CLI   ![icon](https://raw.githubusercontent.com/TaqsBlaze/amen-cli/refs/heads/main/image/icon.png)
+A composer-inspired Python Web Framework Scaffolding Tool that helps you create web applications with ease!
+
+## ✨ Features
+
+- 🎯 Interactive project setup wizard
+- 🔧 Multiple framework support:
+  - Flask - Lightweight WSGI framework
+  - FastAPI - Modern, fast API framework
+  - Bottle - Simple micro web framework 🚧
+  - Pyramid - Flexible web framework 🚧
+- 🎨 Project templates for both web apps and APIs
+- 🔄 Automatic virtual environment setup
+- 📦 Dependency management
+- 🏗️ Structured project scaffolding
+
+## 🛠️ Installation
+
+```bash
+pip install amen-cli
+```
+
+## 📖 Usage
+
+```bash
+# Create a new project
+amen create
+
+# Follow the interactive prompts to:
+# 1. Select a framework
+# 2. Choose application type (webapp/api)
+# 3. Name your project
+```
+
+## 🌟 Project Structure
+
+When you create a project, AMEN generates:
+
+```
+your-app/
+├── venv/                   # Virtual environment
+├── app/                    # Main application code
+│   ├── templates/         # HTML templates (webapp)
+│   └── static/           # Static files
+│       ├── css/         # Stylesheets
+│       └── js/          # JavaScript files
+├── tests/                 # Test directory
+├── requirements.txt       # Python dependencies
+├── .env                  # Environment variables
+└── README.md             # Project documentation
+```
+
+## 🎯 Supported Frameworks
+
+| Framework | Description | Default Port | Status |
+|-----------|-------------|--------------|--------|
+| Flask | Lightweight WSGI web framework | 5000 | ✅ |
+| FastAPI | Modern, fast web framework | 8000 | ✅ |
+| Django | High-level Python web framework | 8000 | ❌ |
+| Bottle | Fast, simple micro framework | 8080 | 🚧 |
+| Pyramid | Flexible web framework | 6543 | 🚧 |
+
+## Work in Progress
+Currently implementing support for additional web frameworks:
+
+- **Bottle**: Integration in development
+- **Pyramid**: Initial implementation phase
+
+These frameworks will enable:
+- Route mapping and handling
+- Request/response processing
+- Middleware integration
+- Template rendering support
+
+Check back for updates or follow the project's issues for implementation progress. Contributions are welcome!
+
+> Note: For now, please use our stable implementations for Flask or FastAPI.
+## 🚗 Quick Start
+
+```bash
+# Install AMEN CLI
+pip install amen-cli
+
+# Create a new project
+amen create
+
+# Follow the interactive prompts
+
+# Navigate to your project
+cd your-project-name
+
+# Activate virtual environment
+source venv/bin/activate  # Linux/Mac
+venv\Scripts\activate     # Windows
+
+# Run your application
+python run.py
+```
+
+## 🔧 Development
+
+```bash
+# Clone the repository
+git clone https://github.com/taqsblaze/amen-cli.git
+
+# Install for development and testing
+pip install -e .
+pip install pytest pytest-cov
+
+# Run tests
+pytest
+
+# Run tests with coverage
+pytest
+```
+
+## 🤝 Contributing
+
+Contributions are welcome! Here's how:
+
+1. Fork the repository
+2. Create your feature branch: `git checkout -b feature/amazing-feature`
+3. Make your changes
+4. Push to the branch: `git push origin feature/amazing-feature`
+5. Open a Pull Request
+
+## 📝 License
+
+This project is licensed under the MIT License - see the [LICENSE](LICENSE) file for details.
+
+## 👥 Contact & Support
+
+- 🌐 [GitHub Repository](https://github.com/taqsblaze/amen-cli)
+- 🐛 [Issue Tracker](https://github.com/taqsblaze/amen-cli/issues)
+- 📧 [Send Email](mailto:tanakah30@gmail.com)
+
+## ⭐ Credits
+
+Created by [Tanaka Chinengundu](https://www.linkedin.com/in/taqsblaze)  
+Inspired by Laravel's elegant development experience
+
+---
+
+Made with ❤️ by Tanaka Chinengundu

amen_cli-0.1.0.dist-info/RECORD

@@ -0,0 +1,11 @@
+amen/__init__.py,sha256=7gWg66LLzl97AIWrsnSq0Y3OpGIWqQzkKLzwnuNr8LQ,810
+amen/cli.py,sha256=BNeXzW2gjhLFx554WK_zZZOwQfJF30zVGLbeixq3pNE,7952
+amen/frameworks.py,sha256=uarXCHkZgMwf9sfY9r2wim3rk8sNBwW7j8Cy8On3N7s,1624
+amen/templates/__init__.py,sha256=2MvacuUyKD4x1-YnByMDi_hq90rH8wkNh0sKvUhhOAw,69
+amen/templates/manager.py,sha256=PaGqpWivfet8DoV5UTMzS9A0XEwwXK9k7iD6DtOQ2kg,16958
+amen_cli-0.1.0.dist-info/licenses/LICENSE,sha256=3A9c5OOecf_0logHhGvw85x-VtpTFPti1I1GBEJTkQk,2532
+amen_cli-0.1.0.dist-info/METADATA,sha256=L8VJTDNIiXFTDpNi2y8c1SjqyECLMmq01jYDz9LaQek,5619
+amen_cli-0.1.0.dist-info/WHEEL,sha256=zaaOINJESkSfm_4HQVc5ssNzHCPXhJm0kEUakpsEHaU,91
+amen_cli-0.1.0.dist-info/entry_points.txt,sha256=US5E6fz5OI2kAwqz-zqBB7M-LeeQANqVlEvpx5a0yo4,39
+amen_cli-0.1.0.dist-info/top_level.txt,sha256=Ot0LsWWgOO3jySIhly8qjAYj2sTASmVdbvE1LtBasdg,5
+amen_cli-0.1.0.dist-info/RECORD,,

amen_cli-0.1.0.dist-info/WHEEL

@@ -0,0 +1,5 @@
+Wheel-Version: 1.0
+Generator: setuptools (80.8.0)
+Root-Is-Purelib: true
+Tag: py3-none-any
+

amen_cli-0.1.0.dist-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+amen = amen.cli:main

amen_cli-0.1.0.dist-info/licenses/LICENSE

@@ -0,0 +1,43 @@
+Modified MIT License with Attribution Requirements
+
+Copyright (c) 2024 Tanaka Chinengundu
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, subject to the following conditions:
+
+1. The above copyright notice, this permission notice, and the following attribution
+   requirements shall be included in all copies or substantial portions of the Software.
+
+2. Attribution Requirements:
+   a. All copies or substantial portions of the Software must retain clear and visible
+      attribution to the original author, Tanaka Chinengundu.
+   b. The original author's name (Tanaka Chinengundu) must not be removed, modified,
+      or obscured in any derivative works or modifications of the Software.
+   c. Any modifications or derivative works must clearly indicate that changes have
+      been made from the original Software and must not imply endorsement by the
+      original author.
+
+3. Liability and Responsibility:
+   a. The original author shall not be held responsible or liable for any damages, 
+      losses, or consequences arising from the use, misuse, or failure of the Software,
+      whether in its original or modified form.
+   b. Users and modifiers of the Software assume all risks associated with its use,
+      including but not limited to data loss, system failure, or other damages.
+   c. Any modifications made to the Software are the sole responsibility of the modifier,
+      and the original author bears no responsibility for derivative works.
+
+4. Additional Restrictions:
+   a. The Software may not be used in any way that implies endorsement by the original author.
+   b. The Software may not be used for illegal or malicious purposes.
+   c. Users must notify end users if they are using a modified version of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

amen_cli-0.1.0.dist-info/top_level.txt

@@ -0,0 +1 @@
+amen