tw-framework 0.2.3__tar.gz

tw_framework-0.2.3/PKG-INFO

@@ -0,0 +1,8 @@
+Metadata-Version: 2.4
+Name: tw-framework
+Version: 0.2.3
+Summary: TW framework CLI with create, dev, build, and deploy commands
+Author: TW Framework
+Requires-Python: >=3.9
+Provides-Extra: dev
+Requires-Dist: pytest>=7; extra == "dev"

tw_framework-0.2.3/README.md

@@ -0,0 +1,91 @@
+# 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/pyproject.toml

@@ -0,0 +1,25 @@
+[build-system]
+requires = ["setuptools>=68", "wheel"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "tw-framework"
+version = "0.2.3"
+description = "TW framework CLI with create, dev, build, and deploy commands"
+requires-python = ">=3.9"
+authors = [
+  { name = "TW Framework" }
+]
+dependencies = []
+
+[project.optional-dependencies]
+# Dev / contributor tooling (not required to use the framework)
+dev = [
+  "pytest>=7",
+]
+
+[project.scripts]
+tw = "tw_framework.cli:main"
+
+[tool.setuptools]
+packages = ["tw_framework"]

tw_framework-0.2.3/setup.cfg

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

tw_framework-0.2.3/tests/test_deployment.py

@@ -0,0 +1,106 @@
+"""Tests for deployment metadata, adapters, and zero‑config detection."""
+
+import json
+import os
+import tempfile
+import unittest
+from pathlib import Path
+
+from tw_framework import compiler
+from tw_framework.adapters import vercel, netlify
+from tw_framework.framework import generate_deploy_metadata
+
+
+class TestDeploymentMetadata(unittest.TestCase):
+    def setUp(self):
+        self.tmpdir = tempfile.mkdtemp()
+        self.output_dir = os.path.join(self.tmpdir, "dist")
+        os.makedirs(self.output_dir, exist_ok=True)
+
+    def tearDown(self):
+        import shutil
+        shutil.rmtree(self.tmpdir)
+
+    def test_generate_deploy_metadata(self):
+        config = {"name": "Test"}
+        generate_deploy_metadata(self.output_dir, config)
+        deploy_path = os.path.join(self.output_dir, "tw.deploy.json")
+        self.assertTrue(os.path.isfile(deploy_path))
+        with open(deploy_path, "r") as f:
+            data = json.load(f)
+        self.assertEqual(data["framework"], "tw")
+        self.assertEqual(data["build"], "tw build")
+        self.assertEqual(data["output"], "dist")
+        self.assertEqual(data["runtime"], "ssr")
+        self.assertIn("version", data)
+
+    def test_detect_tw_project(self):
+        # Create a fake tw.config
+        config_path = os.path.join(self.tmpdir, "tw.config")
+        with open(config_path, "w") as f:
+            f.write("name: Test\n")
+        self.assertTrue(compiler.detect_tw_project(self.tmpdir))
+        # Without tw.config
+        empty_dir = os.path.join(self.tmpdir, "empty")
+        os.makedirs(empty_dir, exist_ok=True)
+        self.assertFalse(compiler.detect_tw_project(empty_dir))
+
+    def test_vercel_adapter_detect(self):
+        meta = vercel.detect()
+        self.assertEqual(meta["framework"], "tw")
+        self.assertEqual(meta["buildCommand"], "tw build")
+        self.assertEqual(meta["outputDirectory"], "dist")
+
+    def test_netlify_adapter_detect(self):
+        meta = netlify.detect()
+        self.assertEqual(meta["framework"], "tw")
+        self.assertEqual(meta["buildCommand"], "tw build")
+        self.assertEqual(meta["publish"], "dist")
+
+    def test_vercel_auto_generate_json(self):
+        # Simulate generate_vercel_output with missing vercel.json
+        from tw_framework.adapters.vercel import generate_vercel_output
+        config = {"name": "Test"}
+        # Create a minimal dist directory
+        dist_dir = os.path.join(self.tmpdir, "dist")
+        os.makedirs(dist_dir, exist_ok=True)
+        # The function expects dist_dir to exist
+        generate_vercel_output(dist_dir, config, self.tmpdir)
+        vercel_json = os.path.join(self.tmpdir, "vercel.json")
+        self.assertTrue(os.path.isfile(vercel_json))
+        with open(vercel_json, "r") as f:
+            data = json.load(f)
+        self.assertEqual(data["framework"], "tw")
+
+    def test_netlify_auto_generate_toml(self):
+        from tw_framework.adapters.netlify import generate_netlify_output
+        config = {"name": "Test"}
+        dist_dir = os.path.join(self.tmpdir, "dist")
+        os.makedirs(dist_dir, exist_ok=True)
+        generate_netlify_output(dist_dir, config, self.tmpdir)
+        netlify_toml = os.path.join(self.tmpdir, "netlify.toml")
+        self.assertTrue(os.path.isfile(netlify_toml))
+        with open(netlify_toml, "r") as f:
+            content = f.read()
+        self.assertIn("tw build", content)
+        self.assertIn('publish = "dist"', content)
+
+    def test_streaming_render(self):
+        """Test that streaming render produces valid HTML."""
+        from tw_framework.streaming import render_program_streaming
+        from tw_framework.ir import IRProgram, IRText
+        program = IRProgram(
+            meta={"title": "Test"},
+            head={},
+            lets={},
+            state={},
+            body=[IRText("Hello World")],
+        )
+        chunks = list(render_program_streaming(program))
+        html = "".join(chunks)
+        self.assertIn("Hello World", html)
+        self.assertIn("<!DOCTYPE html>", html)
+
+
+if __name__ == "__main__":
+    unittest.main()

tw_framework-0.2.3/tw_framework/__init__.py

@@ -0,0 +1,13 @@
+"""TW Framework package."""
+
+__version__ = "0.4.0"
+
+from .server import run_production_server, SSRCache  # noqa: F401
+from .reactivity import (  # noqa: F401
+    has_reactivity,
+    parse_state_block,
+    get_reactivity_runtime_js,
+    transform_reactive_attrs,
+)
+from .compiler import compile_file_pipeline, compile_text_pipeline  # noqa: F401
+from .interpreter import Interpreter  # noqa: F401

tw_framework-0.2.3/tw_framework/advanced_diagnostics.py

@@ -0,0 +1,25 @@
+"""
+Advanced compiler diagnostics for TW Framework.
+
+Detects duplicate attributes, unused variables, circular imports,
+recursive components, invalid nesting, duplicate IDs, duplicate routes,
+and missing exports.
+"""
+
+import logging
+from typing import Dict, List
+
+from . import compiler
+from .diagnostics import Diagnostic, DiagnosticBag
+
+logger = logging.getLogger(__name__)
+
+
+def run_advanced_diagnostics(project_root: str) -> DiagnosticBag:
+    """Run all advanced diagnostics and return the results."""
+    bag = DiagnosticBag()
+    # TODO: Implement actual detection logic
+    return bag
+
+
+__all__ = ["run_advanced_diagnostics"]

tw_framework-0.2.3/tw_framework/asset_optimizer.py

@@ -0,0 +1,30 @@
+"""
+Smart asset optimization for TW Framework.
+
+Automatically compresses images, converts to WebP, lazy loads images,
+preloads critical assets, and removes duplicate CSS/JS.
+"""
+
+import logging
+import os
+from typing import Dict, List, Optional
+
+logger = logging.getLogger(__name__)
+
+
+def optimize_assets(project_root: str, output_dir: str) -> Dict[str, List[str]]:
+    """Optimize assets in the output directory."""
+    optimized = {
+        "images_compressed": [],
+        "images_converted_to_webp": [],
+        "images_lazy_loaded": [],
+        "critical_assets_preloaded": [],
+        "duplicate_css_removed": [],
+        "duplicate_js_removed": [],
+    }
+
+    # TODO: Implement actual optimization logic
+    return optimized
+
+
+__all__ = ["optimize_assets"]

tw_framework-0.2.3/tw_framework/ast_nodes.py

@@ -0,0 +1,283 @@
+from __future__ import annotations
+
+from dataclasses import asdict, dataclass, field, is_dataclass
+from typing import Any, Dict, List, Optional
+
+
+@dataclass
+class Attribute:
+    name: str
+    value: Any
+
+
+def attribute_to_dict(attribute: Any) -> Dict[str, Any]:
+    if isinstance(attribute, Attribute):
+        return {
+            "name": attribute.name,
+            "value": serialize_value(attribute.value),
+        }
+    return {
+        "name": getattr(attribute, "name", ""),
+        "value": serialize_value(getattr(attribute, "value", None)),
+    }
+
+
+def serialize_value(value: Any) -> Any:
+    if value is None or isinstance(value, (str, int, float, bool)):
+        return value
+    if isinstance(value, Attribute):
+        return attribute_to_dict(value)
+    if isinstance(value, dict):
+        return {str(key): serialize_value(item) for key, item in value.items()}
+    if isinstance(value, (list, tuple, set)):
+        return [serialize_value(item) for item in value]
+    if is_dataclass(value):
+        return serialize_value(asdict(value))
+    if hasattr(value, "to_dict") and callable(value.to_dict):
+        try:
+            return serialize_value(value.to_dict())
+        except Exception:
+            pass
+    if hasattr(value, "rules") and isinstance(getattr(value, "rules"), list):
+        return {
+            "kind": value.__class__.__name__,
+            "rules": [serialize_value(rule) for rule in getattr(value, "rules", [])],
+        }
+    if hasattr(value, "selector") and hasattr(value, "declarations"):
+        return {
+            "kind": value.__class__.__name__,
+            "selector": getattr(value, "selector", ""),
+            "declarations": [serialize_value(item) for item in getattr(value, "declarations", [])],
+            "children": [serialize_value(item) for item in getattr(value, "children", [])],
+        }
+    if hasattr(value, "__dict__"):
+        raw = {}
+        for key, item in vars(value).items():
+            if key.startswith("_"):
+                continue
+            raw[key] = serialize_value(item)
+        if raw:
+            raw.setdefault("kind", value.__class__.__name__)
+            return raw
+    return repr(value)
+
+
+@dataclass
+class HeadModel:
+    metas: List[Dict[str, Any]] = field(default_factory=list)
+    icon: Optional[str] = None
+    seo: Dict[str, Any] = field(default_factory=dict)
+
+
+@dataclass
+class PageMeta:
+    title: str = ""
+    layout: Optional[str] = None
+    layouts: List[str] = field(default_factory=list)
+    render_mode: str = "static"
+    revalidate: Optional[int] = None
+    redirect_to: Optional[str] = None
+    rewrite_to: Optional[str] = None
+    responsive: bool = False
+
+
+@dataclass
+class BaseNode:
+    kind: str
+
+
+@dataclass
+class TextNode(BaseNode):
+    value: str
+
+    def __init__(self, value: str):
+        super().__init__("text")
+        self.value = value
+
+
+@dataclass
+class LetNode(BaseNode):
+    name: str
+    value: Any
+
+    def __init__(self, name: str, value: Any):
+        super().__init__("let")
+        self.name = name
+        self.value = value
+
+
+@dataclass
+class IfNode(BaseNode):
+    condition: str
+    children: List[BaseNode] = field(default_factory=list)
+    else_children: List[BaseNode] = field(default_factory=list)
+
+    def __init__(self, condition: str, children: Optional[List[BaseNode]] = None, else_children: Optional[List[BaseNode]] = None):
+        super().__init__("if")
+        self.condition = condition
+        self.children = children or []
+        self.else_children = else_children or []
+
+
+@dataclass
+class ForNode(BaseNode):
+    var_name: str
+    iterable: str
+    children: List[BaseNode] = field(default_factory=list)
+
+    def __init__(self, var_name: str, iterable: str, children: Optional[List[BaseNode]] = None):
+        super().__init__("for")
+        self.var_name = var_name
+        self.iterable = iterable
+        self.children = children or []
+
+
+@dataclass
+class ScriptNode(BaseNode):
+    raw_js: str
+
+    def __init__(self, raw_js: str):
+        super().__init__("script")
+        self.raw_js = raw_js
+
+
+@dataclass
+class ElementNode(BaseNode):
+    tag: str
+    text: Optional[str] = None
+    attrs: List[Attribute] = field(default_factory=list)
+    styles: List[Attribute] = field(default_factory=list)
+    events: List[Attribute] = field(default_factory=list)
+    router: Dict[str, Any] = field(default_factory=dict)
+    children: List[BaseNode] = field(default_factory=list)
+
+    def __init__(
+        self,
+        tag: str,
+        text: Optional[str] = None,
+        attrs: Optional[List[Attribute]] = None,
+        styles: Optional[List[Attribute]] = None,
+        events: Optional[List[Attribute]] = None,
+        router: Optional[Dict[str, Any]] = None,
+        children: Optional[List[BaseNode]] = None,
+    ):
+        super().__init__("element")
+        self.tag = tag
+        self.text = text
+        self.attrs = attrs or []
+        self.styles = styles or []
+        self.events = events or []
+        self.router = router or {}
+        self.children = children or []
+
+
+@dataclass
+class ComponentNode(BaseNode):
+    name: str
+    props: List[Attribute] = field(default_factory=list)
+    children: List[BaseNode] = field(default_factory=list)
+
+    def __init__(self, name: str, props: Optional[List[Attribute]] = None, children: Optional[List[BaseNode]] = None):
+        super().__init__("component")
+        self.name = name
+        self.props = props or []
+        self.children = children or []
+
+
+@dataclass
+class Program:
+    meta: PageMeta = field(default_factory=PageMeta)
+    head: HeadModel = field(default_factory=HeadModel)
+    lets: Dict[str, Any] = field(default_factory=dict)
+    state: Dict[str, Any] = field(default_factory=dict)
+    body: List[BaseNode] = field(default_factory=list)
+    loaded_sheets: List[Any] = field(default_factory=list)
+    loaded_json: List[Dict[str, Any]] = field(default_factory=list)
+    source_path: str = ""
+    legacy_page: Any = None
+
+    def to_dict(self) -> Dict[str, Any]:
+        return {
+            "meta": {
+                "title": self.meta.title,
+                "layout": self.meta.layout,
+                "layouts": list(self.meta.layouts),
+                "render_mode": self.meta.render_mode,
+                "revalidate": self.meta.revalidate,
+                "redirect_to": self.meta.redirect_to,
+                "rewrite_to": self.meta.rewrite_to,
+                "responsive": self.meta.responsive,
+            },
+            "head": {
+                "metas": list(self.head.metas),
+                "icon": self.head.icon,
+                "seo": dict(self.head.seo),
+            },
+            "lets": serialize_value(self.lets),
+            "state": serialize_value(self.state),
+            "body": [node_to_dict(node) for node in self.body],
+            "loaded_sheets": serialize_value(self.loaded_sheets),
+            "loaded_json": serialize_value(self.loaded_json),
+            "source_path": self.source_path,
+        }
+
+
+def node_to_dict(node: BaseNode) -> Dict[str, Any]:
+    if isinstance(node, TextNode):
+        return {"kind": node.kind, "value": node.value}
+    if isinstance(node, LetNode):
+        return {"kind": node.kind, "name": node.name, "value": serialize_value(node.value)}
+    if isinstance(node, IfNode):
+        return {
+            "kind": node.kind,
+            "condition": node.condition,
+            "children": [node_to_dict(child) for child in node.children],
+            "else_children": [node_to_dict(child) for child in node.else_children],
+        }
+    if isinstance(node, ForNode):
+        return {
+            "kind": node.kind,
+            "var_name": node.var_name,
+            "iterable": node.iterable,
+            "children": [node_to_dict(child) for child in node.children],
+        }
+    if isinstance(node, ScriptNode):
+        return {"kind": node.kind, "raw_js": node.raw_js}
+    if isinstance(node, ElementNode):
+        return {
+            "kind": node.kind,
+            "tag": node.tag,
+            "text": node.text,
+            "attrs": [attribute_to_dict(attr) for attr in node.attrs],
+            "styles": [attribute_to_dict(attr) for attr in node.styles],
+            "events": [attribute_to_dict(attr) for attr in node.events],
+            "router": serialize_value(node.router),
+            "children": [node_to_dict(child) for child in node.children],
+        }
+    if isinstance(node, ComponentNode):
+        return {
+            "kind": node.kind,
+            "name": node.name,
+            "props": [attribute_to_dict(prop) for prop in node.props],
+            "children": [node_to_dict(child) for child in node.children],
+        }
+    return {"kind": getattr(node, "kind", "unknown"), "repr": repr(node)}
+
+
+__all__ = [
+    "Attribute",
+    "BaseNode",
+    "ComponentNode",
+    "ElementNode",
+    "ForNode",
+    "HeadModel",
+    "IfNode",
+    "LetNode",
+    "PageMeta",
+    "Program",
+    "ScriptNode",
+    "TextNode",
+    "attribute_to_dict",
+    "node_to_dict",
+    "serialize_value",
+]

tw_framework-0.2.3/tw_framework/build.py

@@ -0,0 +1,7 @@
+from .framework import (  # noqa: F401
+    BuildSummary,
+    build_hidden_site,
+    clean_project_outputs,
+    doctor_project,
+    inspect_project,
+)

tw_framework-0.2.3/tw_framework/build_performance.py

@@ -0,0 +1,26 @@
+"""
+Build performance optimization for TW Framework.
+
+Parallelizes compilation, uses multiple CPU cores, and avoids recompiling unchanged files.
+"""
+
+import logging
+import os
+from typing import List, Optional
+
+from . import compiler
+from .compiler_stats import CompilerStats
+from .incremental_cache import IncrementalCache
+
+logger = logging.getLogger(__name__)
+
+
+def optimize_build(project_root: str, output_dir: str, force: bool = False, workers: Optional[int] = None) -> CompilerStats:
+    """Run an optimized build with parallelism and caching."""
+    stats = CompilerStats()
+    cache = IncrementalCache(project_root)
+    # TODO: Implement actual parallel build logic
+    return stats
+
+
+__all__ = ["optimize_build"]