tw-framework 0.2.3__py3-none-any.whl

tw_framework/compiler_stats.py

@@ -0,0 +1,51 @@
+"""
+Compiler statistics for TW Framework.
+
+Tracks pages compiled, components compiled, files reused from cache,
+files rebuilt, build duration, and cache hit rate.
+"""
+
+import logging
+import time
+from typing import Any, Dict
+
+logger = logging.getLogger(__name__)
+
+
+class CompilerStats:
+    """Collects compiler statistics during a build."""
+
+    def __init__(self):
+        self.start_time = time.time()
+        self.pages_compiled = 0
+        self.components_compiled = 0
+        self.files_reused_from_cache = 0
+        self.files_rebuilt = 0
+        self.cache_hits = 0
+        self.cache_misses = 0
+
+    @property
+    def cache_hit_rate(self) -> float:
+        total = self.cache_hits + self.cache_misses
+        if total == 0:
+            return 0.0
+        return self.cache_hits / total
+
+    @property
+    def build_duration(self) -> float:
+        return time.time() - self.start_time
+
+    def to_dict(self) -> Dict[str, Any]:
+        return {
+            "build_duration_seconds": round(self.build_duration, 2),
+            "pages_compiled": self.pages_compiled,
+            "components_compiled": self.components_compiled,
+            "files_reused_from_cache": self.files_reused_from_cache,
+            "files_rebuilt": self.files_rebuilt,
+            "cache_hits": self.cache_hits,
+            "cache_misses": self.cache_misses,
+            "cache_hit_rate": round(self.cache_hit_rate, 2),
+        }
+
+
+__all__ = ["CompilerStats"]

tw_framework/dead_code.py

@@ -0,0 +1,44 @@
+"""
+Dead code detection for TW Framework.
+
+Detects unused pages, APIs, middleware, components, and layouts.
+"""
+
+import logging
+import os
+from typing import Dict, List
+
+from . import compiler
+
+logger = logging.getLogger(__name__)
+
+
+def detect_dead_code(project_root: str) -> Dict[str, List[str]]:
+    """Return lists of dead code items."""
+    dead = {
+        "pages": [],
+        "apis": [],
+        "middleware": [],
+        "components": [],
+        "layouts": [],
+    }
+
+    # Discover all pages
+    pages = compiler.discover_pages()
+    page_paths = {p["path"] for p in pages}
+
+    # Check for orphaned page files
+    pages_dir = compiler.PAGES_DIR
+    if os.path.isdir(pages_dir):
+        for root, _, files in os.walk(pages_dir):
+            for fname in files:
+                if fname.endswith(".tw"):
+                    full_path = os.path.join(root, fname)
+                    if full_path not in page_paths:
+                        dead["pages"].append(full_path)
+
+    # TODO: Add API, middleware, component, and layout detection
+    return dead
+
+
+__all__ = ["detect_dead_code"]

tw_framework/dependency_graph.py

@@ -0,0 +1,91 @@
+"""
+Complete project dependency graph for TW Framework.
+
+Tracks pages, components, layouts, middleware, APIs, imports, and assets.
+Persisted between builds for incremental rebuilds.
+"""
+
+import json
+import logging
+import os
+from typing import Dict, List, Optional, Set
+
+from . import compiler
+
+logger = logging.getLogger(__name__)
+
+GRAPH_FILE = "dependency-graph.json"
+
+
+class DependencyGraph:
+    """Maintains a directed graph of project dependencies."""
+
+    def __init__(self, project_root: str):
+        self.project_root = project_root
+        self.graph: Dict[str, List[str]] = {}
+        self.reverse: Dict[str, List[str]] = {}
+        self._load()
+
+    def _load(self):
+        path = os.path.join(self.project_root, ".tw", GRAPH_FILE)
+        if os.path.exists(path):
+            try:
+                with open(path, "r", encoding="utf-8") as f:
+                    data = json.load(f)
+                self.graph = data.get("forward", {})
+                self.reverse = data.get("reverse", {})
+            except (json.JSONDecodeError, OSError):
+                logger.warning("Failed to load dependency graph; starting fresh")
+                self.graph = {}
+                self.reverse = {}
+
+    def save(self):
+        path = os.path.join(self.project_root, ".tw", GRAPH_FILE)
+        os.makedirs(os.path.dirname(path), exist_ok=True)
+        with open(path, "w", encoding="utf-8") as f:
+            json.dump({"forward": self.graph, "reverse": self.reverse}, f, indent=2)
+
+    def add_dependency(self, source: str, target: str):
+        if source not in self.graph:
+            self.graph[source] = []
+        if target not in self.graph[source]:
+            self.graph[source].append(target)
+        if target not in self.reverse:
+            self.reverse[target] = []
+        if source not in self.reverse[target]:
+            self.reverse[target].append(source)
+
+    def get_dependents(self, node: str) -> List[str]:
+        """Return all nodes that depend on the given node."""
+        return self.reverse.get(node, [])
+
+    def get_dependencies(self, node: str) -> List[str]:
+        """Return all nodes that the given node depends on."""
+        return self.graph.get(node, [])
+
+    def get_affected_nodes(self, changed_nodes: Set[str]) -> Set[str]:
+        """Return all nodes that need to be rebuilt when the given nodes change."""
+        affected = set(changed_nodes)
+        queue = list(changed_nodes)
+        while queue:
+            current = queue.pop(0)
+            for dependent in self.get_dependents(current):
+                if dependent not in affected:
+                    affected.add(dependent)
+                    queue.append(dependent)
+        return affected
+
+    def build_from_project(self):
+        """Build the dependency graph by scanning the project."""
+        self.graph = {}
+        self.reverse = {}
+        pages = compiler.discover_pages()
+        for page in pages:
+            page_path = page["path"]
+            deps = compiler.collect_page_dependencies(page_path)
+            for dep in deps:
+                self.add_dependency(page_path, dep)
+        self.save()
+
+
+__all__ = ["DependencyGraph"]

tw_framework/deploy.py

@@ -0,0 +1,7 @@
+from .framework import (  # noqa: F401
+    deploy_with_cloudflare,
+    deploy_with_docker,
+    deploy_with_netlify,
+    deploy_with_vercel,
+    run_deploy,
+)

tw_framework/dev.py

@@ -0,0 +1,9 @@
+from .framework import (  # noqa: F401
+    DEFAULT_DEV_HOST,
+    DEFAULT_DEV_PORT,
+    TWDevState,
+    TWFileWatcher,
+    TWProject,
+    make_dev_handler,
+    run_dev_server,
+)

tw_framework/diagnostics.py

@@ -0,0 +1,98 @@
+from __future__ import annotations
+
+from dataclasses import dataclass, field
+from typing import Iterable, List, Optional
+
+
+@dataclass
+class Diagnostic:
+    severity: str
+    code: str
+    message: str
+    file_path: str = ""
+    line: int = 0
+    col: int = 0
+    suggestion: Optional[str] = None
+    notes: List[str] = field(default_factory=list)
+    phase: Optional[str] = None
+    exception_type: Optional[str] = None
+    category: str = "compiler"
+    relative_path: str = ""
+    absolute_path: str = ""
+    source_snippet: str = ""
+    highlight: str = ""
+    reason: str = ""
+    expected: str = ""
+    found: str = ""
+    why: str = ""
+    doc_link: str = ""
+    parser_state: str = ""
+    traceback: str = ""
+
+    @classmethod
+    def from_legacy(cls, item):
+        return cls(
+            severity=getattr(item, "severity", "error"),
+            code=getattr(item, "code", "TW0000"),
+            message=getattr(item, "message", str(item)),
+            file_path=getattr(item, "file_path", "") or "",
+            line=getattr(item, "line", 0) or 0,
+            col=getattr(item, "col", 0) or 0,
+            suggestion=getattr(item, "suggestion", None),
+            notes=list(getattr(item, "notes", []) or []),
+            category=getattr(item, "category", "compiler") or "compiler",
+            relative_path=getattr(item, "relative_path", "") or "",
+            absolute_path=getattr(item, "absolute_path", "") or "",
+            source_snippet=getattr(item, "source_snippet", "") or "",
+            highlight=getattr(item, "highlight", "") or "",
+            reason=getattr(item, "reason", "") or "",
+            expected=getattr(item, "expected", "") or "",
+            found=getattr(item, "found", "") or "",
+            why=getattr(item, "why", "") or "",
+            doc_link=getattr(item, "doc_link", "") or "",
+            parser_state=getattr(item, "parser_state", "") or "",
+            traceback=getattr(item, "traceback", "") or "",
+            phase=getattr(item, "phase", None),
+            exception_type=getattr(item, "exception_type", None),
+        )
+
+    def to_dict(self):
+        return {
+            "severity": self.severity,
+            "code": self.code,
+            "message": self.message,
+            "file_path": self.file_path,
+            "line": self.line,
+            "col": self.col,
+            "suggestion": self.suggestion,
+            "notes": list(self.notes),
+            "phase": self.phase,
+            "exception_type": self.exception_type,
+        }
+
+
+def format_advanced_error(diag: Diagnostic, project_root: str = "") -> str:
+    """Format a diagnostic with all required fields."""
+    from .error_formatter import format_error
+    return format_error(diag, project_root)
+
+
+class DiagnosticBag:
+    def __init__(self):
+        self.items: List[Diagnostic] = []
+
+    def add(self, diagnostic: Diagnostic):
+        self.items.append(diagnostic)
+
+    def extend(self, diagnostics: Iterable[Diagnostic]):
+        self.items.extend(diagnostics)
+
+    @property
+    def has_errors(self) -> bool:
+        return any(item.severity == "error" for item in self.items)
+
+    def to_list(self):
+        return [item.to_dict() for item in self.items]
+
+
+__all__ = ["Diagnostic", "DiagnosticBag"]

tw_framework/dynamic_imports.py

@@ -0,0 +1,51 @@
+"""
+Dynamic imports / lazy loading support for TW Framework.
+
+Components with `lazy true` are compiled into separate chunks and loaded on demand.
+"""
+
+import hashlib
+import json
+import logging
+import os
+from typing import Dict, List, Optional
+
+from . import compiler
+
+logger = logging.getLogger(__name__)
+
+
+def extract_lazy_components(page_path: str) -> List[str]:
+    """Return a list of component names that are marked as lazy in the given page."""
+    raw = compiler.read_text_file(page_path)
+    lazy_components = []
+    # Simple regex-based detection (in production, use the AST)
+    import re
+    for match in re.finditer(r'(\w+)\s*\{[^}]*lazy\s+true[^}]*\}', raw):
+        lazy_components.append(match.group(1))
+    return lazy_components
+
+
+def generate_lazy_chunks(page_path: str, output_dir: str) -> Dict[str, str]:
+    """Generate separate chunks for lazy components and return a mapping."""
+    lazy_comps = extract_lazy_components(page_path)
+    chunk_map = {}
+    for comp_name in lazy_comps:
+        comp_path = compiler.resolve_component_path(comp_name)
+        if comp_path and os.path.exists(comp_path):
+            raw = compiler.read_text_file(comp_path)
+            # In production, compile the component to JS
+            js_content = f"// Lazy component: {comp_name}\n"
+            digest = hashlib.sha256(js_content.encode("utf-8")).hexdigest()[:12]
+            filename = f"lazy_{comp_name}.{digest}.js"
+            chunk_dir = os.path.join(output_dir, "_tw", "chunks")
+            os.makedirs(chunk_dir, exist_ok=True)
+            chunk_path = os.path.join(chunk_dir, filename)
+            if not os.path.exists(chunk_path):
+                with open(chunk_path, "w", encoding="utf-8") as f:
+                    f.write(js_content)
+            chunk_map[comp_name] = f"/_tw/chunks/{filename}"
+    return chunk_map
+
+
+__all__ = ["extract_lazy_components", "generate_lazy_chunks"]

tw_framework/error_formatter.py

@@ -0,0 +1,53 @@
+"""
+Better error formatting for TW Framework.
+
+Every error includes: error code, category, severity, file, relative path,
+absolute path, line, column, highlighted code, explanation, reason,
+expected, found, suggestions, and documentation link.
+"""
+
+import logging
+import os
+from typing import Optional
+
+from .diagnostics import Diagnostic
+
+logger = logging.getLogger(__name__)
+
+
+def format_error(diag: Diagnostic, project_root: str) -> str:
+    """Format a diagnostic into a human-readable string with all required fields."""
+    lines = []
+    code_display = diag.code if str(diag.code).upper().startswith("TW") else f"TW{diag.code}"
+    lines.append(f"{code_display} • {diag.category} Error")
+    lines.append("")
+    lines.append(f"Severity: {diag.severity.upper()}")
+    if diag.file_path:
+        rel_path = os.path.relpath(diag.file_path, project_root) if project_root else diag.file_path
+        lines.append(f"Project: {rel_path}")
+        lines.append(f"Absolute: {os.path.abspath(diag.file_path)}")
+    if diag.line:
+        lines.append(f"Line: {diag.line}")
+    if diag.col:
+        lines.append(f"Column: {diag.col}")
+    if diag.source_snippet:
+        lines.append("")
+        lines.append("Code:")
+        lines.append(diag.source_snippet)
+    if diag.reason:
+        lines.append("")
+        lines.append(f"Reason: {diag.reason}")
+    if diag.expected:
+        lines.append(f"Expected: {diag.expected}")
+    if diag.found:
+        lines.append(f"Found: {diag.found}")
+    if diag.why:
+        lines.append(f"Why: {diag.why}")
+    if diag.suggestion:
+        lines.append(f"Suggestion: {diag.suggestion}")
+    if diag.doc_link:
+        lines.append(f"Docs: {diag.doc_link}")
+    return "\n".join(lines)
+
+
+__all__ = ["format_error"]