tw-framework 0.2.3__tar.gz → 0.2.4__tar.gz

tw_framework-0.2.4/PKG-INFO

@@ -0,0 +1,101 @@
+Metadata-Version: 2.4
+Name: tw-framework
+Version: 0.2.4
+Summary: TW framework CLI with create, dev, build, and deploy commands
+Author: TW Framework
+Requires-Python: >=3.9
+Description-Content-Type: text/markdown
+Provides-Extra: dev
+Requires-Dist: pytest>=7; extra == "dev"
+
+# TW Framework
+
+TW is a custom language + framework for building websites with a Next.js‑like developer experience.
+
+## Zero‑Config Deployment
+
+1. Create a GitHub repository with your TW project (containing `tw.config`, `pages/`, `components/`, `public/`).
+2. Connect the repository to Vercel or Netlify.
+3. The platform automatically detects `tw.config` and runs `tw build`.
+4. Your site goes live – no terminal commands required.
+
+## Quick Start
+
+```bash
+# Create a new project
+tw init my-site
+cd my-site
+
+# Development server
+tw dev
+
+# Production build
+tw build
+
+# Preview the build
+tw preview
+```
+
+## CLI Commands
+
+| Command | Description |
+|---------|-------------|
+| `tw init [name]` | Create a new TW project in the current directory |
+| `tw dev` | Start the development server with live reload |
+| `tw build` | Generate a production build |
+| `tw preview` | Preview the built output |
+| `tw export` | Generate a static export |
+| `tw deploy` | Build and deploy to a hosting provider |
+| `tw doctor` | Run project health checks and deployment compatibility |
+| `tw ast file.tw` | Print the AST JSON for a TW source file |
+| `tw ir file.tw` | Print the IR JSON for a TW source file |
+| `tw run file.tw` | Interpret a TW file and output HTML |
+| `tw check file.tw` | Print diagnostics for a TW file |
+| `tw tokens file.tw` | Print the token stream JSON for a TW source file |
+| `tw clean` | Clean dist and hidden cache folders |
+| `tw info` | Show a project summary |
+| `tw login` | Save deploy provider configuration |
+
+## Deployment Metadata
+
+After a build, the file `dist/tw.deploy.json` is automatically generated. It contains:
+
+```json
+{
+  "framework": "tw",
+  "version": "1.0.0",
+  "build": "tw build",
+  "output": "dist",
+  "runtime": "ssr"
+}
+```
+
+Deployment platforms can read this file to detect the framework and configure the build.
+
+## Adapters
+
+TW Framework includes built‑in adapters for Vercel and Netlify. They provide:
+
+- Framework detection (`detect()` function)
+- Automatic generation of `vercel.json` / `netlify.toml` when missing
+- Build command, output directory, install command, and SSR handling
+
+## Documentation
+
+- [Getting Started](docs/getting-started.md)
+- [Deployment to Vercel](docs/deployment/vercel.md)
+- [Deployment to Netlify](docs/deployment/netlify.md)
+
+## Testing
+
+```bash
+python3 -m unittest discover -s tests -q
+python3 run_tests.py
+```
+
+## Debug Flags
+
+- `TW_WARN_LITERAL_PARSE=1` – warn when literal parsing falls back to string
+- `TW_STRICT_EVAL=1` – re‑raise runtime expression errors instead of warning
+
+These flags are mainly useful while debugging parser/runtime edge cases or tightening CI checks around expression handling.

{tw_framework-0.2.3 → tw_framework-0.2.4}/pyproject.toml

@@ -4,8 +4,9 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "tw-framework"
-version = "0.2.3"
+version = "0.2.4"
 description = "TW framework CLI with create, dev, build, and deploy commands"
+readme = "README.md"
 requires-python = ">=3.9"
 authors = [
   { name = "TW Framework" }
@@ -22,4 +23,4 @@ dev = [
 tw = "tw_framework.cli:main"
 
 [tool.setuptools]
-packages = ["tw_framework"]
+packages = ["tw_framework", "tw_framework.adapters"]

tw_framework-0.2.4/tw_framework/adapters/__init__.py

@@ -0,0 +1,3 @@
+from .vercel import generate_vercel_output
+from .netlify import generate_netlify_output
+from .cloudflare import generate_cloudflare_output

tw_framework-0.2.4/tw_framework/adapters/cloudflare.py

@@ -0,0 +1,96 @@
+"""
+Cloudflare adapter for TWLang framework.
+Generates _routes.json and _worker.js for Cloudflare Pages.
+"""
+
+import json
+from pathlib import Path
+from typing import Dict, Any
+
+def generate_cloudflare_output(
+    dist_dir: str,
+    config: Dict[str, Any],
+    project_root: str,
+) -> None:
+    """
+    Generate Cloudflare deployment files from build output.
+
+    Args:
+        dist_dir: Path to the build output directory (e.g., 'dist').
+        config: JSON to tw.config as a dictionary.
+        project_root: Root directory of the project.
+    """
+    root = Path(project_root)
+    routes_path = root / "_routes.json"
+    worker_path = root / "_worker.js"
+
+    # Build _routes.json
+    routes = []
+    # Add redirects
+    redirects = config.get("redirects", {}).get("rule", [])
+    for rule in redirects:
+        source = rule.get("source", "")
+        destination = rule.get("destination", "")
+        status = 301 if rule.get("permanent") else 302
+        routes.append({
+            "src": source,
+            "dest": destination,
+            "status": status,
+        })
+
+    # Add rewrites
+    rewrites = config.get("rewrites", {}).get("rule", [])
+    for rule in rewrites:
+        source = rule.get("source", "")
+        destination = rule.get("destination", "")
+        routes.append({
+            "src": source,
+            "dest": destination,
+        })
+
+    # Add headers
+    headers = config.get("headers", {}).get("rule", [])
+    for rule in headers:
+        source = rule.get("source", "/**")
+        sets = rule.get("set", {})
+        headers_dict = {}
+        for h_name, h_value in sets.items():
+            headers_dict[h_name] = h_value
+        routes.append({
+            "src": source,
+            "headers": headers_dict,
+            "continue": True,
+        })
+
+    # Static assets catch-all
+    routes.append({
+        "src": "/(.*)",
+        "dest": "/$1",
+    })
+
+    with open(routes_path, "w") as f:
+        json.dump({"version": 1, "routes": routes}, f, indent=2)
+
+    # Generate _worker.js for API routes
+    dist_path = Path(dist_dir)
+    functions_src = dist_path / "functions"
+    if functions_src.exists():
+        worker_code = """
+export default {
+  async fetch(request, env, ctx) {
+    const url = new URL(request.url);
+    // Handle API routes
+    if (url.pathname.startsWith('/api/')) {
+      return new Response(JSON.stringify({ message: "API route" }), {
+        headers: { "Content-Type": "application/json" }
+      });
+    }
+    // Otherwise serve static assets from KV or R2
+    return env.ASSETS.fetch(request);
+  }
+}
+"""
+        with open(worker_path, "w") as f:
+            f.write(worker_code)
+
+    print(f"Generated Cloudflare deployment files at {root}")

tw_framework-0.2.4/tw_framework/adapters/netlify.py

@@ -0,0 +1,91 @@
+"""
+Netlify adapter for TWLang framework.
+Generates netlify.toml and functions directory.
+"""
+
+import shutil
+from pathlib import Path
+from typing import Dict, Any
+
+def detect() -> dict:
+    """Return framework metadata for Netlify detection."""
+    return {
+        "framework": "tw",
+        "version": "1.0",
+        "buildCommand": "tw build",
+        "publish": "dist",
+        "installCommand": "pip install tw-framework",
+    }
+
+
+def generate_netlify_output(
+    dist_dir: str,
+    config: Dict[str, Any],
+    project_root: str,
+) -> None:
+    """
+    Generate Netlify deployment files from build output.
+
+    Args:
+        dist_dir: Path to the build output directory (e.g., 'dist').
+        config: Parsed tw.config as a dictionary.
+        project_root: Root directory of the project.
+    """
+    root = Path(project_root)
+    netlify_toml_path = root / "netlify.toml"
+    functions_dir = root / "netlify" / "functions"
+    publish_dir = "dist"
+
+    # Build netlify.toml
+    toml_lines = ['[build]', 'command = "tw build --prod"', f'publish = "{publish_dir}"', '']
+
+    # Add redirects from tw.config
+    redirects = config.get("redirects", {}).get("rule", [])
+    if redirects:
+        toml_lines.append('[[redirects]]')
+        for rule in redirects:
+            source = rule.get("source", "")
+            destination = rule.get("destination", "")
+            status = 301 if rule.get("permanent") else 302
+            toml_lines.append(f'  from = "{source}"')
+            toml_lines.append(f'  to = "{destination}"')
+            toml_lines.append(f'  status = {status}')
+            toml_lines.append('')
+
+    # Add headers from tw.config
+    headers = config.get("headers", {}).get("rule", [])
+    if headers:
+        toml_lines.append('[[headers]]')
+        for rule in headers:
+            source = rule.get("source", "/**")
+            sets = rule.get("set", {})
+            for h_name, h_value in sets.items():
+                toml_lines.append(f'  for = "{source}"')
+                toml_lines.append('  [headers.values]')
+                toml_lines.append(f'    {h_name} = "{h_value}"')
+                toml_lines.append('')
+
+    with open(netlify_toml_path, "w") as f:
+        f.write("\n".join(toml_lines))
+
+    # Copy API functions if present
+    dist_path = Path(dist_dir)
+    functions_src = dist_path / "functions"
+    if functions_src.exists():
+        if functions_dir.exists():
+            shutil.rmtree(functions_dir)
+        shutil.copytree(functions_src, functions_dir)
+
+    # Auto‑generate netlify.toml for zero‑config detection
+    netlify_toml_path = root / "netlify.toml"
+    if not netlify_toml_path.exists():
+        toml_content = (
+            "[build]\n"
+            'command = "tw build --prod"\n'
+            'publish = "dist"\n'
+        )
+        with open(netlify_toml_path, "w") as f:
+            f.write(toml_content)
+        print(f"  ✅ Auto‑generated netlify.toml at {netlify_toml_path}")
+
+    print(f"Generated Netlify deployment files at {root}")

tw_framework-0.2.4/tw_framework/adapters/vercel.py

@@ -0,0 +1,192 @@
+"""
+Vercel adapter for TWLang framework.
+Generates .vercel/output compliant with Build Output API v3.
+"""
+
+import json
+import shutil
+from pathlib import Path
+from typing import Dict, Any
+
+def detect() -> dict:
+    """Return framework metadata for Vercel detection."""
+    return {
+        "framework": "tw",
+        "version": "1.0",
+        "buildCommand": "tw build",
+        "outputDirectory": "dist",
+        "installCommand": "pip install tw-framework",
+        "devCommand": "tw dev",
+    }
+
+
+def generate_vercel_output(
+    dist_dir: str,
+    config: Dict[str, Any],
+    project_root: str,
+) -> None:
+    """
+    Generate .vercel/output from the build output directory.
+
+    Args:
+        dist_dir: Path to the build output directory (e.g., 'dist').
+        config: Parsed tw.config as a dictionary.
+        project_root: Root directory of the project.
+    """
+    output_dir = Path(project_root) / ".vercel" / "output"
+    # Clean previous output
+    if output_dir.exists():
+        shutil.rmtree(output_dir)
+    output_dir.mkdir(parents=True, exist_ok=True)
+
+    static_dir = output_dir / "static"
+    static_dir.mkdir(exist_ok=True)
+
+    # Copy all files from dist to static (except functions/api)
+    dist_path = Path(dist_dir)
+    if not dist_path.exists():
+        raise FileNotFoundError(f"Build output directory '{dist_dir}' not found")
+
+    functions_src = dist_path / "functions"
+    functions_dst = output_dir / "functions"
+
+    for item in dist_path.rglob("*"):
+        if item.is_file():
+            rel = item.relative_to(dist_path)
+            # Skip functions directory (handled separately)
+            if rel.parts and rel.parts[0] == "functions":
+                continue
+            dest = static_dir / rel
+            dest.parent.mkdir(parents=True, exist_ok=True)
+            shutil.copy2(item, dest)
+
+    # Handle functions if present
+    if functions_src.exists():
+        if functions_dst.exists():
+            shutil.rmtree(functions_dst)
+        shutil.copytree(functions_src, functions_dst)
+
+    # Build config.json
+    vercel_config = build_vercel_config(config, dist_path)
+    config_path = output_dir / "config.json"
+    with open(config_path, "w") as f:
+        json.dump(vercel_config, f, indent=2)
+
+    # Auto‑generate vercel.json for zero‑config detection
+    vercel_json_path = Path(project_root) / "vercel.json"
+    if not vercel_json_path.exists():
+        vercel_config = {
+            "framework": "tw",
+            "buildCommand": "tw build",
+            "outputDirectory": "dist",
+            "installCommand": "pip install tw-framework",
+        }
+        with open(vercel_json_path, "w") as f:
+            json.dump(vercel_config, f, indent=2)
+        print(f"  ✅ Auto‑generated vercel.json at {vercel_json_path}")
+
+    print(f"Generated .vercel/output at {output_dir}")
+
+
+def build_vercel_config(tw_config: Dict[str, Any], dist_path: Path) -> Dict[str, Any]:
+    """
+    Build the Vercel config.json (version 3) from tw.config and build output.
+    """
+    routes = []
+    headers_list = []
+    rewrites_list = []
+    redirects_list = []
+
+    # Extract headers from tw.config
+    headers_cfg = tw_config.get("headers", {}).get("rule", [])
+    for rule in headers_cfg:
+        source = rule.get("source", "/**")
+        headers = {}
+        sets = rule.get("set", {})
+        for h_name, h_value in sets.items():
+            headers[h_name] = h_value
+        if headers:
+            headers_list.append({
+                "source": source,
+                "headers": [{"key": k, "value": v} for k, v in headers.items()]
+            })
+
+    # Extract redirects
+    redirects_cfg = tw_config.get("redirects", {}).get("rule", [])
+    for rule in redirects_cfg:
+        source = rule.get("source", "")
+        destination = rule.get("destination", "")
+        permanent = rule.get("permanent", False)
+        redirects_list.append({
+            "source": source,
+            "destination": destination,
+            "permanent": permanent,
+        })
+
+    # Extract rewrites
+    rewrites_cfg = tw_config.get("rewrites", {}).get("rule", [])
+    for rule in rewrites_cfg:
+        source = rule.get("source", "")
+        destination = rule.get("destination", "")
+        rewrites_list.append({
+            "source": source,
+            "destination": destination,
+        })
+
+    # Build routes array
+    # 1. Handle redirects first
+    for r in redirects_list:
+        routes.append({
+            "src": r["source"],
+            "status": 308 if r.get("permanent") else 307,
+            "headers": {"Location": r["destination"]},
+        })
+
+    # 2. Handle rewrites
+    for r in rewrites_list:
+        routes.append({
+            "src": r["source"],
+            "dest": r["destination"],
+        })
+
+    # 3. Apply headers
+    for h in headers_list:
+        routes.append({
+            "src": h["source"],
+            "headers": h["headers"],
+            "continue": True,
+        })
+
+    # 4. Static files and functions
+    has_functions = (dist_path / "functions").exists()
+    if has_functions:
+        routes.append({
+            "src": "/api/(.*)",
+            "dest": "/api/$1",
+        })
+
+    # 5. Static files catch-all
+    routes.append({
+        "src": "/(.*)",
+        "dest": "/$1",
+    })
+
+    config = {
+        "version": 3,
+        "routes": routes,
+    }
+
+    # Add images config if present
+    images_cfg = tw_config.get("images", {})
+    if images_cfg:
+        config["images"] = {
+            "sizes": images_cfg.get("sizes", [640, 750, 828, 1080, 1200, 1920, 2048, 3840]),
+            "domains": [],
+            "remotePatterns": images_cfg.get("remote_patterns", []),
+            "minimumCacheTTL": 60,
+            "formats": ["image/avif", "image/webp"],
+            "dangerouslyAllowSVG": False,
+            "contentSecurityPolicy": "script-src 'none'; frame-src 'none'; sandbox;",
+        }
+
+    return config