FluxScript 0.1.0__py3-none-any.whl

fluxscript/__init__.py

@@ -0,0 +1,5 @@
+"""FluxScript: Python-first multi-target application generation."""
+from .dsl import App, Page, Text, Heading, Button, Input
+from .version import __version__
+
+__all__ = ["App", "Page", "Text", "Heading", "Button", "Input", "__version__"]

fluxscript/__main__.py

@@ -0,0 +1,2 @@
+from .cli import main
+raise SystemExit(main())

fluxscript/analyzer.py

@@ -0,0 +1,72 @@
+"""Read-only source/project analyzer. It never imports or executes analyzed files."""
+from __future__ import annotations
+import ast
+import hashlib
+import json
+from pathlib import Path
+
+SKIP_DIRS = {".git", ".venv", "venv", "node_modules", "__pycache__", "build", "dist", ".tox"}
+MAX_FILES = 5000
+MAX_SOURCE_BYTES = 2_000_000
+RISKY_CALLS = {"eval", "exec", "compile", "__import__", "system", "popen", "Popen", "run", "call", "check_call", "check_output", "pickle", "loads"}
+
+
+def analyze_path(path: str | Path) -> dict:
+    root = Path(path).expanduser().resolve()
+    if not root.exists(): raise FileNotFoundError(f"Path does not exist: {root}")
+    files = [root] if root.is_file() else sorted(p for p in root.rglob("*") if p.is_file() and not any(part in SKIP_DIRS for part in p.parts))
+    if len(files) > MAX_FILES: raise ValueError(f"Analysis limit is {MAX_FILES} files; narrow the input path.")
+    report = {"tool": "FluxScript Analyzer", "version": "0.1.0", "root": str(root), "file_count": 0,
+              "total_bytes": 0, "files": [], "python_summary": {"files": 0, "functions": [], "classes": [], "imports": [], "syntax_errors": []}, "findings": []}
+    summary = report["python_summary"]
+    for file in files:
+        try: stat = file.stat()
+        except OSError as exc:
+            report["findings"].append({"severity": "warning", "file": str(file), "message": f"Cannot stat file: {type(exc).__name__}"}); continue
+        item = {"path": str(file.relative_to(root) if root.is_dir() else file.name), "extension": file.suffix.lower(), "size_bytes": stat.st_size}
+        if stat.st_size > MAX_SOURCE_BYTES:
+            item["sha256"] = None
+            item["note"] = f"Skipped content analysis: file exceeds {MAX_SOURCE_BYTES} bytes."
+            report["findings"].append({"severity": "info", "file": item["path"], "message": item["note"]})
+        else:
+            try: raw = file.read_bytes()
+            except OSError as exc:
+                report["findings"].append({"severity": "warning", "file": item["path"], "message": f"Cannot read file: {type(exc).__name__}"}); continue
+            item["sha256"] = hashlib.sha256(raw).hexdigest()
+            if file.suffix.lower() == ".py":
+                summary["files"] += 1
+                try:
+                    tree = ast.parse(raw.decode("utf-8"), filename=str(file))
+                    functions = [n.name for n in ast.walk(tree) if isinstance(n, (ast.FunctionDef, ast.AsyncFunctionDef))]
+                    classes = [n.name for n in ast.walk(tree) if isinstance(n, ast.ClassDef)]
+                    imports = []
+                    for node in ast.walk(tree):
+                        if isinstance(node, ast.Import): imports.extend(alias.name for alias in node.names)
+                        elif isinstance(node, ast.ImportFrom): imports.append(node.module or "")
+                    summary["functions"].extend(f"{item['path']}:{name}" for name in functions)
+                    summary["classes"].extend(f"{item['path']}:{name}" for name in classes)
+                    summary["imports"].extend(imports)
+                    for node in ast.walk(tree):
+                        if isinstance(node, ast.Call):
+                            name = node.func.id if isinstance(node.func, ast.Name) else node.func.attr if isinstance(node.func, ast.Attribute) else ""
+                            if name in RISKY_CALLS:
+                                report["findings"].append({"severity": "review", "file": item["path"], "line": getattr(node, "lineno", None), "message": f"Review dynamic execution/process/deserialization call: {name}"})
+                except (SyntaxError, UnicodeDecodeError) as exc:
+                    issue = {"file": item["path"], "line": getattr(exc, "lineno", None), "message": str(exc)}
+                    summary["syntax_errors"].append(issue)
+                    report["findings"].append({"severity": "error", **issue})
+        report["files"].append(item)
+        report["total_bytes"] += stat.st_size
+    report["file_count"] = len(report["files"])
+    summary["imports"] = sorted(set(summary["imports"]))
+    report["summary"] = {"errors": sum(1 for f in report["findings"] if f["severity"] == "error"),
+                         "review_items": sum(1 for f in report["findings"] if f["severity"] == "review"),
+                         "warnings": sum(1 for f in report["findings"] if f["severity"] == "warning")}
+    return report
+
+
+def write_report(report: dict, destination: str | Path) -> Path:
+    output = Path(destination).expanduser()
+    output.parent.mkdir(parents=True, exist_ok=True)
+    output.write_text(json.dumps(report, indent=2, ensure_ascii=False), encoding="utf-8")
+    return output

fluxscript/backends/__init__.py

@@ -0,0 +1,6 @@
+from .web import generate_web
+from .android import generate_android
+from .ios import generate_ios
+from .cli import generate_cli
+
+BACKENDS = {"web": generate_web, "android": generate_android, "ios": generate_ios, "cli": generate_cli}

fluxscript/backends/android.py

@@ -0,0 +1,127 @@
+"""Generate a multi-page native Android Kotlin/Gradle source starter."""
+from html import escape as xml_escape
+from pathlib import Path
+from ..models import AppSpec
+
+
+def _kotlin(value: str) -> str:
+    return value.replace("\\", "\\\\").replace('"', '\\"').replace("$", "\\$").replace("\n", "\\n").replace("\r", "\\r")
+
+
+def _page_function(page, index: int) -> str:
+    body = []
+    for element in page.elements:
+        text = _kotlin(element.text)
+        if element.kind in {"text", "heading"}:
+            size = "24f" if element.kind == "heading" else "16f"
+            body.append(f'''        content.addView(TextView(this).apply {{ text = "{text}"; textSize = {size}; setPadding(0, 12, 0, 12) }})''')
+        elif element.kind == "button":
+            action = _kotlin(element.action or "")
+            body.append(f'''        content.addView(Button(this).apply {{ text = "{text}"; setOnClickListener {{ Toast.makeText(this@MainActivity, "Action requested: {action}", Toast.LENGTH_SHORT).show() }} }})''')
+        elif element.kind == "input":
+            name = _kotlin(element.name or "field")
+            input_type = element.attributes.get("input_type", "text")
+            body.append(f'''        content.addView(EditText(this).apply {{ hint = "{text}"; tag = "{name}"; contentDescription = "{text}" }})''')
+    if not body:
+        body.append('        content.addView(TextView(this).apply { text = "No controls on this page." })')
+    return f'''    private fun renderPage{index}() {{
+        content.removeAllViews()
+{chr(10).join(body)}
+    }}'''
+
+
+def generate_android(spec: AppSpec, out: Path) -> list[Path]:
+    issues = spec.validate()
+    if issues: raise ValueError("Invalid application: " + "; ".join(issues))
+    package = "dev.fluxscript.generated"
+    app_name = _kotlin(spec.name)
+    functions = [_page_function(page, i) for i, page in enumerate(spec.pages)]
+    tabs = []
+    for index, page in enumerate(spec.pages):
+        title = _kotlin(page.title or page.path)
+        tabs.append(f'''        tabBar.addView(Button(this).apply {{ text = "{title}"; setOnClickListener {{ renderPage{index}() }} }})''')
+    activity = f'''package {package}
+
+import android.app.Activity
+import android.os.Bundle
+import android.view.ViewGroup
+import android.widget.Button
+import android.widget.EditText
+import android.widget.HorizontalScrollView
+import android.widget.LinearLayout
+import android.widget.ScrollView
+import android.widget.TextView
+import android.widget.Toast
+
+class MainActivity : Activity() {{
+    private lateinit var content: LinearLayout
+
+    override fun onCreate(savedInstanceState: Bundle?) {{
+        super.onCreate(savedInstanceState)
+        title = "{app_name}"
+        val root = LinearLayout(this).apply {{
+            orientation = LinearLayout.VERTICAL
+            setPadding(20, 20, 20, 20)
+            layoutParams = ViewGroup.LayoutParams(ViewGroup.LayoutParams.MATCH_PARENT, ViewGroup.LayoutParams.MATCH_PARENT)
+        }}
+        val tabScroll = HorizontalScrollView(this)
+        val tabBar = LinearLayout(this).apply {{ orientation = LinearLayout.HORIZONTAL }}
+        tabScroll.addView(tabBar)
+        root.addView(tabScroll)
+        val scroll = ScrollView(this)
+        content = LinearLayout(this).apply {{ orientation = LinearLayout.VERTICAL }}
+        scroll.addView(content)
+        root.addView(scroll, LinearLayout.LayoutParams(ViewGroup.LayoutParams.MATCH_PARENT, 0, 1f))
+{chr(10).join(tabs)}
+        setContentView(root)
+        renderPage0()
+    }}
+
+{chr(10).join(functions)}
+}}
+'''
+    gradle = '''plugins {
+    id("com.android.application") version "8.7.3"
+    id("org.jetbrains.kotlin.android") version "2.0.21"
+}
+
+android {
+    namespace = "dev.fluxscript.generated"
+    compileSdk = 35
+    defaultConfig {
+        applicationId = "dev.fluxscript.generated"
+        minSdk = 26
+        targetSdk = 35
+        versionCode = 1
+        versionName = "0.1.0"
+    }
+}
+'''
+    settings = '''pluginManagement { repositories { google(); mavenCentral(); gradlePluginPortal() } }
+dependencyResolutionManagement { repositoriesMode.set(RepositoriesMode.FAIL_ON_PROJECT_REPOS); repositories { google(); mavenCentral() } }
+rootProject.name = "FluxScriptGeneratedApp"
+include(":app")
+'''
+    manifest = f'''<manifest xmlns:android="http://schemas.android.com/apk/res/android">
+    <application android:label="{xml_escape(spec.name, quote=True)}" android:theme="@android:style/Theme.Material.Light.NoActionBar" android:usesCleartextTraffic="false">
+        <activity android:name="dev.fluxscript.generated.MainActivity" android:exported="true">
+            <intent-filter><action android:name="android.intent.action.MAIN"/><category android:name="android.intent.category.LAUNCHER"/></intent-filter>
+        </activity>
+    </application>
+</manifest>
+'''
+    files = {
+        "settings.gradle.kts": settings,
+        "build.gradle.kts": 'plugins { id("com.android.application") version "8.7.3" apply false; id("org.jetbrains.kotlin.android") version "2.0.21" apply false }\n',
+        "app/build.gradle.kts": gradle,
+        "app/src/main/AndroidManifest.xml": manifest,
+        "app/src/main/java/dev/fluxscript/generated/MainActivity.kt": activity,
+        "README.md": "# Android project generated by FluxScript\n\nThis source starter includes a native Kotlin activity and a tab for every declared page. Buttons emit an action-request toast; implement and test your real application behavior before release. Open in Android Studio with a compatible JDK, Android SDK and Gradle/Android Gradle Plugin. The generator does not sign or package an APK.\n",
+    }
+    result = []
+    for name, content in files.items():
+        path = out / name
+        path.parent.mkdir(parents=True, exist_ok=True)
+        path.write_text(content, encoding="utf-8")
+        result.append(path)
+    return result

fluxscript/backends/cli.py

@@ -0,0 +1,50 @@
+"""Generate a standalone argparse-based CLI from an application specification."""
+from pathlib import Path
+from ..models import AppSpec
+
+
+def generate_cli(spec: AppSpec, out: Path) -> list[Path]:
+    issues = spec.validate()
+    if issues: raise ValueError("Invalid application: " + "; ".join(issues))
+    actions = []
+    for page in spec.pages:
+        for element in page.elements:
+            if element.kind == "button" and element.action and element.action not in actions:
+                actions.append(element.action)
+    input_names = sorted({element.name for page in spec.pages for element in page.elements if element.kind == "input" and element.name})
+    command_specs = []
+    for index, action in enumerate(actions):
+        command_specs.append(f'''    command_{index} = commands.add_parser({action!r}, help={("Request action " + action)!r})
+    command_{index}.set_defaults(action_name={action!r})''')
+        for name in input_names:
+            command_specs.append(f'''    command_{index}.add_argument({("--" + name.replace("_", "-"))!r}, default="", help={("Value for " + name)!r})''')
+    if not actions:
+        command_specs.append('''    commands.add_parser("info", help="show application metadata").set_defaults(action_name="info")''')
+    value_names = ", ".join(repr(name) for name in input_names)
+    command_name = "".join(ch.lower() if ch.isalnum() else "-" for ch in spec.name).strip("-") or "fluxscript-app"
+    source = f'''#!/usr/bin/env python3
+"""Command-line interface generated by FluxScript for {spec.name!r}."""
+import argparse
+import json
+
+APP_NAME = {spec.name!r}
+INPUT_NAMES = [{value_names}]
+
+def main(argv=None):
+    parser = argparse.ArgumentParser(prog={command_name!r}, description=APP_NAME)
+    commands = parser.add_subparsers(dest="command", required=True)
+{chr(10).join(command_specs)}
+    args = parser.parse_args(argv)
+    values = {{name: getattr(args, name, "") for name in INPUT_NAMES}}
+    print(json.dumps({{"application": APP_NAME, "action": args.action_name, "values": values}}, ensure_ascii=False))
+    return 0
+
+if __name__ == "__main__":
+    raise SystemExit(main())
+'''
+    out.mkdir(parents=True, exist_ok=True)
+    cli_file = out / "app_cli.py"
+    cli_file.write_text(source, encoding="utf-8")
+    readme = out / "README.md"
+    readme.write_text(f"# {spec.name} command-line starter\n\nRun `python app_cli.py --help` to list generated action commands. Each command emits a JSON action request and supplied input values. Connect application-specific business logic before treating requests as completed operations.\n", encoding="utf-8")
+    return [cli_file, readme]

fluxscript/backends/ios.py

@@ -0,0 +1,66 @@
+"""Generate a SwiftUI source starter for every declared page."""
+from pathlib import Path
+import json
+from ..models import AppSpec
+
+def _swift(value: str) -> str:
+    # JSON string escaping is compatible with the common Swift string-literal escapes.
+    return json.dumps(str(value), ensure_ascii=False)
+
+def _identifier(name: str) -> str:
+    clean = "".join(c if c.isalnum() or c == "_" else "_" for c in name)
+    if not clean or clean[0].isdigit(): clean = "field_" + clean
+    return "input_" + clean
+
+def generate_ios(spec: AppSpec, out: Path) -> list[Path]:
+    issues = spec.validate()
+    if issues: raise ValueError("Invalid application: " + "; ".join(issues))
+    input_names = sorted({e.name for page in spec.pages for e in page.elements if e.kind == "input" and e.name})
+    state_lines = [f"    @State private var {_identifier(name)}: String = \"\"" for name in input_names]
+    state_lines.append('    @State private var statusMessage: String = ""')
+    tabs=[]
+    for page in spec.pages:
+        rows=[]
+        for e in page.elements:
+            text = _swift(e.text)
+            if e.kind == "text": rows.append(f"                    Text({text}).frame(maxWidth: .infinity, alignment: .leading)")
+            elif e.kind == "heading": rows.append(f"                    Text({text}).font(.system(size: {max(16, 34 - int(e.attributes.get('level', 1)) * 3)}, weight: .bold)).frame(maxWidth: .infinity, alignment: .leading)")
+            elif e.kind == "button": rows.append(f"                    Button({text}) {{ statusMessage = {_swift('Action requested: ' + (e.action or ''))} }}.buttonStyle(.borderedProminent)")
+            elif e.kind == "input": rows.append(f"                    TextField({text}, text: ${_identifier(e.name or 'field')}).textFieldStyle(.roundedBorder)")
+        if not rows: rows.append('                    Text("Generated by FluxScript")')
+        rows.append('                    if !statusMessage.isEmpty { Text(statusMessage).font(.footnote).foregroundStyle(.secondary) }')
+        page_title = page.title or page.path
+        tabs.append(f'''            NavigationStack {{
+                ScrollView {{
+                    VStack(alignment: .leading, spacing: 16) {{
+{chr(10).join(rows)}
+                    }}
+                    .padding()
+                }}
+                .navigationTitle({_swift(page_title)})
+            }}
+            .tabItem {{ Label({_swift(page_title)}, systemImage: "doc.text") }}''')
+    swift=f'''import SwiftUI
+
+@main
+struct GeneratedApp: App {{
+    var body: some Scene {{
+        WindowGroup {{ ContentView() }}
+    }}
+}}
+
+struct ContentView: View {{
+{chr(10).join(state_lines)}
+
+    var body: some View {{
+        TabView {{
+{chr(10).join(tabs)}
+        }}
+    }}
+}}
+'''
+    out.mkdir(parents=True, exist_ok=True)
+    source = out / "GeneratedApp.swift"; source.write_text(swift, encoding="utf-8")
+    readme = out / "README.md"
+    readme.write_text("# Generated SwiftUI source\n\nFluxScript generates a SwiftUI source starter with a tab for each declared page and editable text fields. Create an Xcode project on macOS, add `GeneratedApp.swift`, then build and test with Xcode. This generator does not create an `.xcodeproj`, compile, sign, or create an `.ipa`. Review navigation labels, action handlers, state management, accessibility and platform deployment settings before production use.\n", encoding="utf-8")
+    return [source, readme]

fluxscript/backends/web.py

@@ -0,0 +1,140 @@
+"""Generate a dependency-light, multi-page accessible web starter."""
+from html import escape
+from pathlib import Path
+import json
+from ..models import AppSpec, ElementSpec
+
+def _render_element(e: ElementSpec) -> str:
+    text = escape(e.text, quote=True)
+    if e.kind == "text": return f'<p class="copy">{text}</p>'
+    if e.kind == "heading":
+        level = int(e.attributes.get("level", 1))
+        return f'<h{level}>{text}</h{level}>'
+    if e.kind == "button": return f'<button type="button" data-action="{escape(e.action or "", quote=True)}">{text}</button>'
+    if e.kind == "input":
+        name = escape(e.name or "", quote=True); typ = escape(e.attributes.get("input_type", "text"), quote=True)
+        return f'<label>{text}<input name="{name}" type="{typ}" autocomplete="off" /></label>'
+    raise ValueError(f"Unknown element kind: {e.kind}")
+
+def _json_script(value) -> str:
+    # JSON embedded in a script must not be able to close the script element.
+    return json.dumps(value, ensure_ascii=False).replace("<", "\\u003c").replace(">", "\\u003e").replace("&", "\\u0026")
+
+def generate_web(spec: AppSpec, out: Path) -> list[Path]:
+    issues = spec.validate()
+    if issues: raise ValueError("Invalid application: " + "; ".join(issues))
+    out.mkdir(parents=True, exist_ok=True)
+    title = escape(spec.name, quote=True)
+    nav = "\n      ".join(f'<a href="#{escape(page.path, quote=True)}" data-route-link="{escape(page.path, quote=True)}">{escape(page.title or page.path)}</a>' for page in spec.pages)
+    sections=[]
+    for index, page in enumerate(spec.pages):
+        page_title = escape(page.title or spec.name, quote=True)
+        body = "\n        ".join(_render_element(e) for e in page.elements)
+        sections.append(f'<section class="page" data-route="{escape(page.path, quote=True)}" aria-label="{page_title}"{"" if index == 0 else " hidden"}>\n        <h1 class="page-title">{page_title}</h1>\n        {body}\n      </section>')
+    html = f'''<!doctype html>
+<html lang="en">
+<head>
+  <meta charset="utf-8" />
+  <meta name="viewport" content="width=device-width, initial-scale=1" />
+  <meta name="description" content="{title} — generated with FluxScript" />
+  <meta name="color-scheme" content="light dark" />
+  <title>{title}</title>
+  <link rel="stylesheet" href="styles.css" />
+</head>
+<body>
+  <header class="topbar"><a class="brand" href="#/">{title}</a><nav aria-label="Main navigation">{nav}</nav></header>
+  <main class="app-shell" data-flux-app="{title}">
+    <div class="panel">\n      {' '.join(sections)}\n      <p class="status" role="status" aria-live="polite" hidden></p>
+    </div>
+  </main>
+  <script src="app.js" defer></script>
+</body>
+</html>
+'''
+    css = '''* { box-sizing: border-box; }
+:root { font-family: Inter, ui-sans-serif, system-ui, -apple-system, BlinkMacSystemFont, "Segoe UI", sans-serif; color: #172033; background: #f3f5f9; }
+body { margin: 0; min-height: 100vh; }
+.topbar { display: flex; align-items: center; justify-content: space-between; gap: 20px; padding: 16px clamp(16px, 4vw, 48px); background: #fff; border-bottom: 1px solid #dce2ec; }
+.brand { font-weight: 750; color: inherit; text-decoration: none; }
+nav { display: flex; gap: 16px; flex-wrap: wrap; }
+nav a { color: #2457d6; text-decoration: none; padding: 6px 2px; }
+nav a[aria-current="page"] { font-weight: 700; text-decoration: underline; text-underline-offset: 5px; }
+.app-shell { min-height: calc(100vh - 64px); display: grid; place-items: start center; padding: clamp(16px, 5vw, 56px); }
+.panel { width: min(100%, 820px); padding: clamp(22px, 5vw, 48px); background: #fff; border: 1px solid #dce2ec; border-radius: 20px; box-shadow: 0 12px 36px #17203312; }
+.page-title { margin-top: 0; line-height: 1.2; }
+.copy { line-height: 1.7; color: #46536b; }
+button { border: 0; border-radius: 10px; padding: 12px 18px; background: #2457d6; color: #fff; font: inherit; font-weight: 600; cursor: pointer; }
+button:hover { background: #1744b4; }
+button:focus-visible, input:focus-visible, a:focus-visible { outline: 3px solid #86a8ff; outline-offset: 3px; }
+label { display: grid; gap: 8px; margin: 16px 0; font-weight: 550; }
+input { width: 100%; max-width: 480px; padding: 11px 12px; border: 1px solid #aab5c7; border-radius: 8px; font: inherit; }
+.status { margin-top: 24px; padding: 12px; background: #eef4ff; border-radius: 8px; color: #183b83; }
+[hidden] { display: none !important; }
+@media (max-width: 560px) { .topbar { align-items: flex-start; flex-direction: column; } nav { gap: 12px; } }
+@media (prefers-color-scheme: dark) { :root { color: #eef2fa; background: #101521; } .topbar, .panel { background: #192131; border-color: #303b50; } .copy { color: #c0cadd; } input { background: #101521; color: inherit; border-color: #58657a; } .status { background: #20345b; color: #e2eaff; } }
+'''
+    js = '''/** FluxScript runtime bridge. App-specific behavior is registered by the developer. */
+(() => {
+  const root = document.querySelector("[data-flux-app]");
+  if (!root) return;
+  const pages = [...root.querySelectorAll("[data-route]")];
+  const links = [...document.querySelectorAll("[data-route-link]")];
+  const status = root.querySelector("[role=status]");
+  const normalize = (route) => route && route.startsWith("/") ? route : "/";
+  function navigate() {
+    const route = normalize(location.hash.slice(1) || "/");
+    const selected = pages.find((page) => page.dataset.route === route) || pages[0];
+    pages.forEach((page) => { page.hidden = page !== selected; });
+    links.forEach((link) => {
+      if (link.dataset.routeLink === selected.dataset.route) link.setAttribute("aria-current", "page");
+      else link.removeAttribute("aria-current");
+    });
+  }
+  window.addEventListener("hashchange", navigate);
+  navigate();
+  root.addEventListener("click", (event) => {
+    const target = event.target;
+    const button = target instanceof Element ? target.closest("button[data-action]") : null;
+    if (!button) return;
+    const action = button.dataset.action || "";
+    const values = Object.fromEntries([...root.querySelectorAll("input[name]")].map((input) => [input.name, input.value]));
+    const accepted = root.dispatchEvent(new CustomEvent("flux:action", { bubbles: true, cancelable: true, detail: { action, values } }));
+    if (accepted && status) { status.hidden = false; status.textContent = `Action requested: ${action}. Connect a handler for application behavior.`; }
+  });
+  // Example integration: root.addEventListener("flux:action", (event) => { ... });
+})();
+'''
+    ts = '''/** Typed counterpart of app.js; check with `npm install && npm run typecheck`. */
+type FluxActionDetail = { action: string; values: Record<string, string> };
+const root = document.querySelector<HTMLElement>("[data-flux-app]");
+if (root) {
+  const pages = Array.from(root.querySelectorAll<HTMLElement>("[data-route]"));
+  const links = Array.from(document.querySelectorAll<HTMLAnchorElement>("[data-route-link]"));
+  const status = root.querySelector<HTMLElement>("[role=status]");
+  const normalize = (route: string): string => route.startsWith("/") ? route : "/";
+  const navigate = (): void => {
+    const route = normalize(location.hash.slice(1) || "/");
+    const selected = pages.find((page) => page.dataset.route === route) ?? pages[0];
+    if (!selected) return;
+    pages.forEach((page) => { page.hidden = page !== selected; });
+    links.forEach((link) => link.dataset.routeLink === selected.dataset.route ? link.setAttribute("aria-current", "page") : link.removeAttribute("aria-current"));
+  };
+  window.addEventListener("hashchange", navigate); navigate();
+  root.addEventListener("click", (event: MouseEvent) => {
+    const target = event.target;
+    const button = target instanceof Element ? target.closest<HTMLButtonElement>("button[data-action]") : null;
+    if (!button) return;
+    const values = Object.fromEntries(Array.from(root.querySelectorAll<HTMLInputElement>("input[name]")).map((input) => [input.name, input.value]));
+    root.dispatchEvent(new CustomEvent<FluxActionDetail>("flux:action", { bubbles: true, cancelable: true, detail: { action: button.dataset.action ?? "", values } }));
+    if (status) { status.hidden = false; status.textContent = `Action requested: ${button.dataset.action ?? ""}. Connect a handler for application behavior.`; }
+  });
+}
+'''
+    files = {"index.html": html, "styles.css": css, "app.js": js, "app.ts": ts,
+      "package.json": '{\n  "name": "fluxscript-generated-app",\n  "private": true,\n  "version": "0.1.0",\n  "scripts": { "typecheck": "tsc --noEmit" },\n  "devDependencies": { "typescript": "^5.0.0" }\n}\n',
+      "tsconfig.json": '{\n  "compilerOptions": { "target": "ES2020", "module": "ES2020", "strict": true, "noEmit": true, "lib": ["ES2020", "DOM"] },\n  "include": ["app.ts"]\n}\n',
+      "README.md": f"# {spec.name}\n\nGenerated by FluxScript 0.1.0. Supports all declared pages through hash navigation. Run `python -m http.server 8000` and open http://127.0.0.1:8000 to preview. For TypeScript validation, install Node.js/npm then run `npm install && npm run typecheck`. Buttons emit a cancellable `flux:action` event with `{{action, values}}; register an application handler before treating actions as business functionality. Review security, accessibility, persistence, API integration and browser support before production deployment.\n"}
+    result=[]
+    for name, content in files.items():
+        path=out/name; path.parent.mkdir(parents=True,exist_ok=True); path.write_text(content,encoding="utf-8"); result.append(path)
+    return result