WebForge 1.0.0__tar.gz

webforge-1.0.0/PKG-INFO

@@ -0,0 +1,142 @@
+Metadata-Version: 2.4
+Name: WebForge
+Version: 1.0.0
+Summary: 🔥 Create web applications easily — a Flask-powered micro-framework
+Home-page: https://github.com/yourname/webforge
+Author: Your Name
+Author-email: you@example.com
+License: MIT
+Project-URL: Homepage, https://github.com/yourname/webforge
+Project-URL: Repository, https://github.com/yourname/webforge
+Project-URL: Issues, https://github.com/yourname/webforge/issues
+Requires-Python: >=3.8
+Description-Content-Type: text/markdown
+Requires-Dist: flask>=3.0.0
+Requires-Dist: python-dotenv>=1.0.0
+Dynamic: author
+Dynamic: author-email
+Dynamic: home-page
+Dynamic: requires-python
+
+# 🔥 WebForge
+
+**Create web applications easily** — a minimal Flask-powered framework with clean syntax.
+
+```bash
+pip install WebForge
+webforge new mon-site
+cd mon-site
+python backend/server/forge.py
+```
+
+---
+
+## Structure d'un projet WebForge
+
+```
+mon-site/
+├── backend/
+│   ├── requirements.txt
+│   └── server/
+│       └── forge.py        ← Cœur du serveur
+└── public/
+    ├── pages/
+    │   └── index.html      ← Templates HTML
+    ├── script/
+    │   └── app.js          ← JavaScript client
+    └── service/
+        └── style.css       ← Fichiers statiques
+```
+
+---
+
+## Écrire `forge.py`
+
+```python
+from WebForge import webforge, security, env as web
+
+# Variables d'environnement
+password = web.env("PASSWORD")
+ip = "192.168.1.123"
+
+# ─── Routes ──────────────────────────────────────
+@web.app("/")
+def index():
+    web.route("style", "/public/service/style.css")
+    return web.render("index.html")
+
+@web.app("/login")
+def login():
+    return web.render("login.html")
+
+# ─── Sécurité ────────────────────────────────────
+@web.security("/")
+def secure_home():
+    if not web.password(password):      # vérif mot de passe en session
+        return web.redirect("/login")
+    if not web.ip(ip):                  # vérif IP
+        return web.abort(403)
+
+# ─── Démarrage ───────────────────────────────────
+if __name__ == "__main__":
+    web.runapp(debug=True, port=5000, host="0.0.0.0")
+```
+
+---
+
+## API complète
+
+### Routes
+
+| Fonction | Description |
+|----------|-------------|
+| `@web.app("/path")` | Définit une route |
+| `@web.security("/path")` | Middleware de sécurité pour une route |
+| `web.route("name", "/path/to/file")` | Route vers un fichier statique |
+
+### Réponses
+
+| Fonction | Description |
+|----------|-------------|
+| `web.render("page.html", **ctx)` | Rend un template HTML |
+| `web.redirect("/url")` | Redirige vers une URL |
+| `web.abort(403)` | Retourne une erreur HTTP |
+
+### Sécurité
+
+| Fonction | Description |
+|----------|-------------|
+| `web.password("secret")` | Vérifie le mot de passe en session |
+| `web.ip("192.168.1.1")` | Vérifie l'IP du client (accepte aussi une liste) |
+
+### Utilitaires
+
+| Fonction | Description |
+|----------|-------------|
+| `web.env("VAR")` | Lit une variable d'environnement |
+| `web.runapp(debug, port, host)` | Démarre le serveur |
+
+---
+
+## CLI
+
+```bash
+webforge new <nom>    # Crée un nouveau projet
+webforge run          # Lance le projet courant
+```
+
+---
+
+## Installation pour le développement
+
+```bash
+git clone https://github.com/yourname/webforge
+cd webforge
+pip install -e .
+```
+
+---
+
+## Licence
+
+MIT

webforge-1.0.0/README.md

@@ -0,0 +1,122 @@
+# 🔥 WebForge
+
+**Create web applications easily** — a minimal Flask-powered framework with clean syntax.
+
+```bash
+pip install WebForge
+webforge new mon-site
+cd mon-site
+python backend/server/forge.py
+```
+
+---
+
+## Structure d'un projet WebForge
+
+```
+mon-site/
+├── backend/
+│   ├── requirements.txt
+│   └── server/
+│       └── forge.py        ← Cœur du serveur
+└── public/
+    ├── pages/
+    │   └── index.html      ← Templates HTML
+    ├── script/
+    │   └── app.js          ← JavaScript client
+    └── service/
+        └── style.css       ← Fichiers statiques
+```
+
+---
+
+## Écrire `forge.py`
+
+```python
+from WebForge import webforge, security, env as web
+
+# Variables d'environnement
+password = web.env("PASSWORD")
+ip = "192.168.1.123"
+
+# ─── Routes ──────────────────────────────────────
+@web.app("/")
+def index():
+    web.route("style", "/public/service/style.css")
+    return web.render("index.html")
+
+@web.app("/login")
+def login():
+    return web.render("login.html")
+
+# ─── Sécurité ────────────────────────────────────
+@web.security("/")
+def secure_home():
+    if not web.password(password):      # vérif mot de passe en session
+        return web.redirect("/login")
+    if not web.ip(ip):                  # vérif IP
+        return web.abort(403)
+
+# ─── Démarrage ───────────────────────────────────
+if __name__ == "__main__":
+    web.runapp(debug=True, port=5000, host="0.0.0.0")
+```
+
+---
+
+## API complète
+
+### Routes
+
+| Fonction | Description |
+|----------|-------------|
+| `@web.app("/path")` | Définit une route |
+| `@web.security("/path")` | Middleware de sécurité pour une route |
+| `web.route("name", "/path/to/file")` | Route vers un fichier statique |
+
+### Réponses
+
+| Fonction | Description |
+|----------|-------------|
+| `web.render("page.html", **ctx)` | Rend un template HTML |
+| `web.redirect("/url")` | Redirige vers une URL |
+| `web.abort(403)` | Retourne une erreur HTTP |
+
+### Sécurité
+
+| Fonction | Description |
+|----------|-------------|
+| `web.password("secret")` | Vérifie le mot de passe en session |
+| `web.ip("192.168.1.1")` | Vérifie l'IP du client (accepte aussi une liste) |
+
+### Utilitaires
+
+| Fonction | Description |
+|----------|-------------|
+| `web.env("VAR")` | Lit une variable d'environnement |
+| `web.runapp(debug, port, host)` | Démarre le serveur |
+
+---
+
+## CLI
+
+```bash
+webforge new <nom>    # Crée un nouveau projet
+webforge run          # Lance le projet courant
+```
+
+---
+
+## Installation pour le développement
+
+```bash
+git clone https://github.com/yourname/webforge
+cd webforge
+pip install -e .
+```
+
+---
+
+## Licence
+
+MIT

webforge-1.0.0/WebForge/__init__.py

@@ -0,0 +1,93 @@
+"""
+WebForge - Create web applications easily
+
+Usage in forge.py:
+    from WebForge import webforge, security, env as web
+
+    @web.app("/")
+    def index():
+        web.route("style", "/public/service/style.css")
+        return web.render("index.html")
+
+    @web.security("/")
+    def secure_home():
+        if not web.password(pw): return web.redirect("/login")
+        if not web.ip(allowed):  return web.abort(403)
+
+    web.runapp(debug=True, port=5000)
+"""
+
+from .core import WebForgeApp
+
+# Single global app instance shared across the whole project
+_app = WebForgeApp()
+
+
+class _Namespace:
+    """
+    The WebForge namespace object.
+    Imported as `env as web` so that `web.env()`, `web.app()`, etc. all work.
+    Also callable directly: web("MY_VAR") == web.env("MY_VAR")
+    """
+
+    def __init__(self, app: WebForgeApp):
+        self._app = app
+
+    def __call__(self, key: str, default=None):
+        return self._app.env(key, default)
+
+    # ── Environment ─────────────────────────────────────
+    def env(self, key: str, default=None):
+        """Read an environment variable (like os.getenv)"""
+        return self._app.env(key, default)
+
+    # ── Routing ─────────────────────────────────────────
+    def app(self, route_path: str, methods=None):
+        """Decorator: register a route handler"""
+        return self._app.app(route_path, methods)
+
+    def route(self, name: str, path: str):
+        """Register a named static file route"""
+        return self._app.add_static_route(name, path)
+
+    # ── Responses ───────────────────────────────────────
+    def render(self, template: str, **context):
+        """Render an HTML template from public/pages/"""
+        return self._app.render(template, **context)
+
+    def redirect(self, url: str, code: int = 302):
+        """HTTP redirect"""
+        return self._app.redirect(url, code)
+
+    def abort(self, code: int, message=None):
+        """Abort with an HTTP error code"""
+        return self._app.abort(code, message)
+
+    # ── Security ────────────────────────────────────────
+    def security(self, route_path: str):
+        """Decorator: register security middleware for a route"""
+        return self._app.security(route_path)
+
+    def password(self, stored_password: str) -> bool:
+        """Check session password against stored value"""
+        return self._app.check_password(stored_password)
+
+    def ip(self, allowed_ip) -> bool:
+        """Check if request IP matches allowed value(s)"""
+        return self._app.check_ip(allowed_ip)
+
+    # ── Server ──────────────────────────────────────────
+    def runapp(self, debug: bool = False, port: int = 5000, host: str = "0.0.0.0"):
+        """Start the WebForge development server"""
+        return self._app.run(debug=debug, port=port, host=host)
+
+
+_ns = _Namespace(_app)
+
+# Public exports:
+#   from WebForge import webforge, security, env as web
+webforge = _app          # raw app instance (advanced use)
+security = _ns.security  # importable standalone decorator
+env = _ns               # becomes `web` via `env as web`
+
+__all__ = ["WebForgeApp", "webforge", "security", "env"]

webforge-1.0.0/WebForge/core.py

@@ -0,0 +1,222 @@
+"""
+WebForge Core - Main application engine
+"""
+
+import os
+import sys
+import functools
+from pathlib import Path
+from typing import Callable, Optional, List, Union
+
+try:
+    from flask import (
+        Flask, request, session, redirect as flask_redirect,
+        abort as flask_abort, render_template_string, send_file,
+        make_response
+    )
+    FLASK_AVAILABLE = True
+except ImportError:
+    FLASK_AVAILABLE = False
+
+
+class WebForgeResponse:
+    """Wrapper for WebForge responses"""
+    def __init__(self, content, status=200, mimetype="text/html"):
+        self.content = content
+        self.status = status
+        self.mimetype = mimetype
+        self._is_redirect = False
+        self._is_abort = False
+        self._redirect_url = None
+        self._abort_code = None
+
+
+class WebForgeApp:
+    """Main WebForge application class"""
+
+    def __init__(self):
+        self._routes = {}          # route -> handler function
+        self._security = {}        # route -> security function
+        self._static_routes = {}   # name -> file path
+        self._template_dir = None
+        self._flask_app = None
+        self._project_root = None
+
+    def _find_project_root(self):
+        """Auto-detect project root from calling script location"""
+        # Walk up from the forge.py location
+        frame = sys._getframe(2)
+        caller_file = frame.f_globals.get("__file__", "")
+        if caller_file:
+            # forge.py is in backend/server/, so project root is 2 levels up
+            p = Path(caller_file).resolve()
+            for _ in range(3):
+                p = p.parent
+                if (p / "public").exists():
+                    return p
+            return Path(caller_file).resolve().parent.parent.parent
+        return Path.cwd()
+
+    def _get_flask_app(self):
+        if self._flask_app is None:
+            if not FLASK_AVAILABLE:
+                raise RuntimeError(
+                    "Flask is required. Install it with: pip install flask"
+                )
+            if self._project_root is None:
+                self._project_root = Path.cwd()
+
+            template_folder = str(self._project_root / "public" / "pages")
+            static_folder = str(self._project_root / "public" / "service")
+
+            self._flask_app = Flask(
+                __name__,
+                template_folder=template_folder,
+                static_folder=static_folder,
+                static_url_path="/static"
+            )
+            self._flask_app.secret_key = os.urandom(32)
+
+            # Register all routes
+            self._register_all_routes()
+
+        return self._flask_app
+
+    def _register_all_routes(self):
+        flask_app = self._flask_app
+
+        for route_path, handler in self._routes.items():
+            security_fn = self._security.get(route_path)
+            self._register_flask_route(flask_app, route_path, handler, security_fn)
+
+        # Register named static routes
+        for name, file_path in self._static_routes.items():
+            self._register_static_file(flask_app, name, file_path)
+
+    def _register_flask_route(self, flask_app, route_path, handler, security_fn):
+        endpoint = f"webforge_{route_path.replace('/', '_').strip('_') or 'index'}"
+
+        @flask_app.route(route_path, methods=["GET", "POST", "PUT", "DELETE", "PATCH"])
+        @functools.wraps(handler)
+        def view_func():
+            # Run security checks first
+            if security_fn:
+                self._current_request_context = True
+                result = security_fn()
+                if result is not None:
+                    return self._process_response(result)
+
+            # Run route handler
+            result = handler()
+            return self._process_response(result)
+
+        view_func.__name__ = endpoint
+        # Flask already registered it via decorator above
+
+    def _register_static_file(self, flask_app, name, file_path):
+        """Register a named static file route"""
+        endpoint = f"static_{name}"
+        abs_path = self._project_root / file_path.lstrip("/")
+
+        @flask_app.route(f"/static/{name}")
+        def serve_static():
+            return send_file(str(abs_path))
+
+        serve_static.__name__ = endpoint
+
+    def _process_response(self, result):
+        """Convert WebForge response to Flask response"""
+        if result is None:
+            return ("", 200)
+
+        if isinstance(result, str):
+            return result
+
+        if isinstance(result, WebForgeResponse):
+            if result._is_redirect:
+                return flask_redirect(result._redirect_url, result.status)
+            if result._is_abort:
+                flask_abort(result._abort_code)
+            return (result.content, result.status)
+
+        # Flask response object passthrough
+        return result
+
+    # ─── Public API ─────────────────────────────────────────────────────────
+
+    def env(self, key: str, default=None):
+        """Get environment variable"""
+        return os.environ.get(key, default)
+
+    def app(self, route_path: str, methods: Optional[List[str]] = None):
+        """Decorator to register a route"""
+        def decorator(fn: Callable):
+            self._routes[route_path] = fn
+            return fn
+        return decorator
+
+    def security(self, route_path: str):
+        """Decorator to register security middleware for a route"""
+        def decorator(fn: Callable):
+            self._security[route_path] = fn
+            return fn
+        return decorator
+
+    def add_static_route(self, name: str, path: str):
+        """Register a static file route"""
+        self._static_routes[name] = path
+
+    def render(self, template: str, **context):
+        """Render an HTML template from public/pages/"""
+        from flask import render_template
+        return render_template(template, **context)
+
+    def redirect(self, url: str, code: int = 302):
+        """Redirect to URL"""
+        return flask_redirect(url, code)
+
+    def abort(self, code: int, message: Optional[str] = None):
+        """Abort with HTTP error"""
+        if message:
+            from flask import Response
+            return Response(message, status=code)
+        flask_abort(code)
+
+    def check_password(self, stored_password: str) -> bool:
+        """Check if current session has matching password"""
+        return session.get("password") == stored_password
+
+    def check_ip(self, allowed_ip: Union[str, List[str]]) -> bool:
+        """Check if request IP is in the allowed list"""
+        client_ip = request.remote_addr
+        if isinstance(allowed_ip, str):
+            return client_ip == allowed_ip
+        return client_ip in allowed_ip
+
+    def run(self, debug: bool = False, port: int = 5000, host: str = "0.0.0.0"):
+        """Start the development server"""
+        # Detect project root from the script that called run()
+        frame = sys._getframe(1)
+        caller_file = frame.f_globals.get("__file__", "")
+        if caller_file:
+            p = Path(caller_file).resolve().parent
+            # Search upward for a dir that has public/
+            for _ in range(5):
+                if (p / "public").exists():
+                    self._project_root = p
+                    break
+                p = p.parent
+            else:
+                self._project_root = Path(caller_file).resolve().parent
+
+        flask_app = self._get_flask_app()
+
+        print(f"""
+╔══════════════════════════════════════════════╗
+║           🔥 WebForge Server                  ║
+║  Running on http://{host}:{port}        ║
+║  Debug: {str(debug):<37}║
+╚══════════════════════════════════════════════╝
+        """)
+
+        flask_app.run(debug=debug, port=port, host=host)

webforge-1.0.0/WebForge.egg-info/PKG-INFO

@@ -0,0 +1,142 @@
+Metadata-Version: 2.4
+Name: WebForge
+Version: 1.0.0
+Summary: 🔥 Create web applications easily — a Flask-powered micro-framework
+Home-page: https://github.com/yourname/webforge
+Author: Your Name
+Author-email: you@example.com
+License: MIT
+Project-URL: Homepage, https://github.com/yourname/webforge
+Project-URL: Repository, https://github.com/yourname/webforge
+Project-URL: Issues, https://github.com/yourname/webforge/issues
+Requires-Python: >=3.8
+Description-Content-Type: text/markdown
+Requires-Dist: flask>=3.0.0
+Requires-Dist: python-dotenv>=1.0.0
+Dynamic: author
+Dynamic: author-email
+Dynamic: home-page
+Dynamic: requires-python
+
+# 🔥 WebForge
+
+**Create web applications easily** — a minimal Flask-powered framework with clean syntax.
+
+```bash
+pip install WebForge
+webforge new mon-site
+cd mon-site
+python backend/server/forge.py
+```
+
+---
+
+## Structure d'un projet WebForge
+
+```
+mon-site/
+├── backend/
+│   ├── requirements.txt
+│   └── server/
+│       └── forge.py        ← Cœur du serveur
+└── public/
+    ├── pages/
+    │   └── index.html      ← Templates HTML
+    ├── script/
+    │   └── app.js          ← JavaScript client
+    └── service/
+        └── style.css       ← Fichiers statiques
+```
+
+---
+
+## Écrire `forge.py`
+
+```python
+from WebForge import webforge, security, env as web
+
+# Variables d'environnement
+password = web.env("PASSWORD")
+ip = "192.168.1.123"
+
+# ─── Routes ──────────────────────────────────────
+@web.app("/")
+def index():
+    web.route("style", "/public/service/style.css")
+    return web.render("index.html")
+
+@web.app("/login")
+def login():
+    return web.render("login.html")
+
+# ─── Sécurité ────────────────────────────────────
+@web.security("/")
+def secure_home():
+    if not web.password(password):      # vérif mot de passe en session
+        return web.redirect("/login")
+    if not web.ip(ip):                  # vérif IP
+        return web.abort(403)
+
+# ─── Démarrage ───────────────────────────────────
+if __name__ == "__main__":
+    web.runapp(debug=True, port=5000, host="0.0.0.0")
+```
+
+---
+
+## API complète
+
+### Routes
+
+| Fonction | Description |
+|----------|-------------|
+| `@web.app("/path")` | Définit une route |
+| `@web.security("/path")` | Middleware de sécurité pour une route |
+| `web.route("name", "/path/to/file")` | Route vers un fichier statique |
+
+### Réponses
+
+| Fonction | Description |
+|----------|-------------|
+| `web.render("page.html", **ctx)` | Rend un template HTML |
+| `web.redirect("/url")` | Redirige vers une URL |
+| `web.abort(403)` | Retourne une erreur HTTP |
+
+### Sécurité
+
+| Fonction | Description |
+|----------|-------------|
+| `web.password("secret")` | Vérifie le mot de passe en session |
+| `web.ip("192.168.1.1")` | Vérifie l'IP du client (accepte aussi une liste) |
+
+### Utilitaires
+
+| Fonction | Description |
+|----------|-------------|
+| `web.env("VAR")` | Lit une variable d'environnement |
+| `web.runapp(debug, port, host)` | Démarre le serveur |
+
+---
+
+## CLI
+
+```bash
+webforge new <nom>    # Crée un nouveau projet
+webforge run          # Lance le projet courant
+```
+
+---
+
+## Installation pour le développement
+
+```bash
+git clone https://github.com/yourname/webforge
+cd webforge
+pip install -e .
+```
+
+---
+
+## Licence
+
+MIT

webforge-1.0.0/WebForge.egg-info/SOURCES.txt

@@ -0,0 +1,12 @@
+README.md
+pyproject.toml
+setup.py
+WebForge/__init__.py
+WebForge/core.py
+WebForge.egg-info/PKG-INFO
+WebForge.egg-info/SOURCES.txt
+WebForge.egg-info/dependency_links.txt
+WebForge.egg-info/entry_points.txt
+WebForge.egg-info/requires.txt
+WebForge.egg-info/top_level.txt
+WebForge_cli/cli.py

webforge-1.0.0/WebForge.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

webforge-1.0.0/WebForge.egg-info/entry_points.txt

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

webforge-1.0.0/WebForge.egg-info/requires.txt

@@ -0,0 +1,2 @@
+flask>=3.0.0
+python-dotenv>=1.0.0

webforge-1.0.0/WebForge.egg-info/top_level.txt

@@ -0,0 +1,2 @@
+WebForge
+WebForge_cli

webforge-1.0.0/WebForge_cli/cli.py

@@ -0,0 +1,248 @@
+#!/usr/bin/env python3
+"""
+WebForge CLI - Scaffold new projects
+Usage: webforge new <project-name>
+       webforge run
+"""
+
+import sys
+import os
+import argparse
+from pathlib import Path
+
+
+FORGE_PY_TEMPLATE = '''\
+from WebForge import webforge, security, env as web
+
+# ─── Environment ─────────────────────────────────────────────────────────────
+# password = web.env("PASSWORD")
+# ip = "192.168.1.1"
+
+# ─── Routes ──────────────────────────────────────────────────────────────────
+@web.app("/")
+def index():
+    web.route("style", "/public/service/style.css")
+    return web.render("index.html")
+
+@web.app("/login")
+def login():
+    return web.render("login.html")
+
+# ─── Security ────────────────────────────────────────────────────────────────
+# @web.security("/")
+# def secure_home():
+#     if not web.password(password):
+#         return web.redirect("/login")
+#     if not web.ip(ip):
+#         return web.abort(403)
+
+# ─── Run ─────────────────────────────────────────────────────────────────────
+if __name__ == "__main__":
+    web.runapp(debug=True, port=5000, host="0.0.0.0")
+'''
+
+INDEX_HTML_TEMPLATE = '''\
+<!DOCTYPE html>
+<html lang="en">
+<head>
+  <meta charset="UTF-8" />
+  <meta name="viewport" content="width=device-width, initial-scale=1.0" />
+  <title>WebForge App</title>
+  <link rel="stylesheet" href="/static/style" />
+</head>
+<body>
+  <main>
+    <h1>🔥 Welcome to WebForge</h1>
+    <p>Your app is running. Edit <code>public/pages/index.html</code> to get started.</p>
+    <a href="/login">Go to Login</a>
+  </main>
+  <script src="/public/script/app.js"></script>
+</body>
+</html>
+'''
+
+LOGIN_HTML_TEMPLATE = '''\
+<!DOCTYPE html>
+<html lang="en">
+<head>
+  <meta charset="UTF-8" />
+  <meta name="viewport" content="width=device-width, initial-scale=1.0" />
+  <title>Login - WebForge</title>
+  <link rel="stylesheet" href="/static/style" />
+</head>
+<body>
+  <main>
+    <h1>🔐 Login</h1>
+    <form method="POST" action="/login">
+      <input type="password" name="password" placeholder="Password" required />
+      <button type="submit">Sign In</button>
+    </form>
+  </main>
+</body>
+</html>
+'''
+
+STYLE_CSS_TEMPLATE = '''\
+/* WebForge default styles */
+*, *::before, *::after { box-sizing: border-box; margin: 0; padding: 0; }
+
+body {
+  font-family: "Segoe UI", system-ui, -apple-system, sans-serif;
+  background: #0f0f13;
+  color: #e8e8f0;
+  min-height: 100vh;
+  display: flex;
+  align-items: center;
+  justify-content: center;
+}
+
+main {
+  text-align: center;
+  padding: 3rem;
+  max-width: 600px;
+}
+
+h1 {
+  font-size: 2.5rem;
+  margin-bottom: 1rem;
+  background: linear-gradient(135deg, #ff6b35, #f7c59f);
+  -webkit-background-clip: text;
+  -webkit-text-fill-color: transparent;
+}
+
+p { color: #a0a0b8; margin-bottom: 1.5rem; }
+
+a, button {
+  display: inline-block;
+  padding: 0.75rem 2rem;
+  background: #ff6b35;
+  color: white;
+  border: none;
+  border-radius: 8px;
+  text-decoration: none;
+  cursor: pointer;
+  font-size: 1rem;
+  transition: background 0.2s;
+}
+
+a:hover, button:hover { background: #e85a25; }
+
+input {
+  display: block;
+  width: 100%;
+  padding: 0.75rem 1rem;
+  margin-bottom: 1rem;
+  background: #1a1a24;
+  border: 1px solid #333;
+  border-radius: 8px;
+  color: #e8e8f0;
+  font-size: 1rem;
+}
+
+code {
+  background: #1a1a24;
+  padding: 0.2rem 0.5rem;
+  border-radius: 4px;
+  font-family: monospace;
+  color: #ff6b35;
+}
+'''
+
+APP_JS_TEMPLATE = '''\
+// WebForge App - client-side scripts
+console.log("🔥 WebForge App loaded");
+'''
+
+REQUIREMENTS_TEMPLATE = '''\
+WebForge
+flask>=3.0.0
+python-dotenv>=1.0.0
+'''
+
+GITIGNORE_TEMPLATE = '''\
+__pycache__/
+*.py[cod]
+.env
+*.env
+venv/
+.venv/
+'''
+
+
+def scaffold(name: str):
+    base = Path(name)
+    if base.exists():
+        print(f"❌ Directory '{name}' already exists.")
+        sys.exit(1)
+
+    dirs = [
+        base / "backend" / "server",
+        base / "public" / "pages",
+        base / "public" / "script",
+        base / "public" / "service",
+    ]
+    for d in dirs:
+        d.mkdir(parents=True)
+
+    files = {
+        base / "backend" / "server" / "forge.py": FORGE_PY_TEMPLATE,
+        base / "backend" / "requirements.txt": REQUIREMENTS_TEMPLATE,
+        base / "public" / "pages" / "index.html": INDEX_HTML_TEMPLATE,
+        base / "public" / "pages" / "login.html": LOGIN_HTML_TEMPLATE,
+        base / "public" / "service" / "style.css": STYLE_CSS_TEMPLATE,
+        base / "public" / "script" / "app.js": APP_JS_TEMPLATE,
+        base / ".gitignore": GITIGNORE_TEMPLATE,
+    }
+
+    for path, content in files.items():
+        path.write_text(content, encoding="utf-8")
+
+    print(f"""
+╔══════════════════════════════════════════════╗
+║        🔥 WebForge Project Created!           ║
+╠══════════════════════════════════════════════╣
+║  Project: {name:<35}║
+╠══════════════════════════════════════════════╣
+║  Next steps:                                  ║
+║  cd {name:<39}║
+║  pip install -r backend/requirements.txt      ║
+║  python backend/server/forge.py               ║
+╚══════════════════════════════════════════════╝
+    """)
+
+
+def run_server():
+    """Run the forge.py in the current project"""
+    forge = Path("backend/server/forge.py")
+    if not forge.exists():
+        print("❌ No forge.py found. Are you in a WebForge project directory?")
+        sys.exit(1)
+    os.execv(sys.executable, [sys.executable, str(forge)])
+
+
+def main():
+    parser = argparse.ArgumentParser(
+        prog="webforge",
+        description="🔥 WebForge - Create web apps easily"
+    )
+    subparsers = parser.add_subparsers(dest="command")
+
+    # webforge new <name>
+    new_parser = subparsers.add_parser("new", help="Create a new WebForge project")
+    new_parser.add_argument("name", help="Project name")
+
+    # webforge run
+    subparsers.add_parser("run", help="Run the current WebForge project")
+
+    args = parser.parse_args()
+
+    if args.command == "new":
+        scaffold(args.name)
+    elif args.command == "run":
+        run_server()
+    else:
+        parser.print_help()
+
+
+if __name__ == "__main__":
+    main()

webforge-1.0.0/pyproject.toml

@@ -0,0 +1,26 @@
+[build-system]
+requires = ["setuptools>=68", "wheel"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "WebForge"
+version = "1.0.0"
+description = "🔥 Create web applications easily — a Flask-powered micro-framework"
+readme = "README.md"
+requires-python = ">=3.8"
+license = { text = "MIT" }
+dependencies = [
+    "flask>=3.0.0",
+    "python-dotenv>=1.0.0",
+]
+
+[project.scripts]
+webforge = "webforge_cli.cli:main"
+
+[project.urls]
+Homepage = "https://github.com/yourname/webforge"
+Repository = "https://github.com/yourname/webforge"
+Issues = "https://github.com/yourname/webforge/issues"
+
+[tool.setuptools.packages.find]
+include = ["WebForge*", "webforge_cli*"]

webforge-1.0.0/setup.cfg

@@ -0,0 +1,4 @@
+[egg_info]
+tag_build = 
+tag_date = 0
+

webforge-1.0.0/setup.py

@@ -0,0 +1,41 @@
+from setuptools import setup, find_packages
+
+with open("README.md", "r", encoding="utf-8") as f:
+    long_description = f.read()
+
+setup(
+    name="WebForge",
+    version="1.0.0",
+    author="Your Name",
+    author_email="you@example.com",
+    description="🔥 Create web applications easily — a Flask-powered micro-framework",
+    long_description=long_description,
+    long_description_content_type="text/markdown",
+    url="https://github.com/yourname/webforge",
+    packages=find_packages(),
+    include_package_data=True,
+    python_requires=">=3.8",
+    install_requires=[
+        "flask>=3.0.0",
+        "python-dotenv>=1.0.0",
+    ],
+    entry_points={
+        "console_scripts": [
+            "webforge=webforge_cli.cli:main",
+        ],
+    },
+    classifiers=[
+        "Development Status :: 4 - Beta",
+        "Intended Audience :: Developers",
+        "License :: OSI Approved :: MIT License",
+        "Programming Language :: Python :: 3",
+        "Programming Language :: Python :: 3.8",
+        "Programming Language :: Python :: 3.9",
+        "Programming Language :: Python :: 3.10",
+        "Programming Language :: Python :: 3.11",
+        "Programming Language :: Python :: 3.12",
+        "Topic :: Internet :: WWW/HTTP :: WSGI :: Application",
+        "Topic :: Software Development :: Libraries :: Application Frameworks",
+    ],
+    keywords="web framework flask simple easy webforge",
+)