icdev 0.0.3__py3-none-any.whl

tools/forge_studio/eject/eject_engine.py

@@ -0,0 +1,230 @@
+# CUI // SP-CTI
+"""Eject engine — exports a generated app to a standalone React + Supabase project (D-FS-7).
+
+Orchestrates the full eject pipeline:
+1. Load ForgeApp from DB (or accept app dict directly)
+2. Generate Next.js project skeleton
+3. Render all pages via json_render_engine
+4. Generate Supabase schema + migrations
+5. Generate auth files
+6. Generate Docker Compose for self-hosting
+7. Write all files to output directory
+8. Audit trail entry
+
+The ejected project has ZERO runtime dependency on ICDEV.
+
+CLI: python tools/forge_studio/eject/eject_engine.py --eject --app-id "..." --output-dir "/path" --json
+"""
+from __future__ import annotations
+
+import json
+import logging
+import os
+import sys
+import time
+from pathlib import Path
+from typing import Any, Dict, List, Optional
+
+from tools.forge_studio.models import ForgeApp, ForgeEjectResult, ForgeSchema
+from tools.forge_studio.renderer.json_render_engine import render_app
+from tools.forge_studio.renderer.layout_engine import (
+    compose_app_layout, compose_globals_css, generate_navigation_config,
+)
+from tools.forge_studio.supabase.auth_generator import generate_auth_files
+from tools.forge_studio.supabase.migration_generator import (
+    generate_migration_files, generate_supabase_config,
+)
+from tools.forge_studio.eject.nextjs_scaffolder import scaffold_project
+from tools.forge_studio.eject.docker_compose_generator import (
+    generate_docker_compose, generate_dockerfile, generate_env_file,
+)
+from tools.forge_studio.audit import log_forge_event
+
+logger = logging.getLogger("forge_studio.eject")
+
+
+def eject_app(
+    app_id: Optional[str] = None,
+    app_dict: Optional[Dict[str, Any]] = None,
+    output_dir: str = "",
+    project_id: str = "",
+) -> Dict[str, Any]:
+    """Eject a Forge Studio app to a standalone project.
+
+    Provide either app_id (loads from DB) or app_dict (direct).
+
+    Returns: {status, output_dir, files_created, duration_ms}
+    """
+    start = time.time()
+
+    # Load app
+    if app_dict:
+        app_data = app_dict
+    elif app_id:
+        from tools.forge_studio.generator.app_generator import get_app
+        app_data = get_app(app_id)
+        if not app_data:
+            return {"status": "error", "error": f"App not found: {app_id}"}
+    else:
+        return {"status": "error", "error": "Provide app_id or app_dict"}
+
+    app_name = app_data.get("name", "Forge App")
+    safe_name = app_name.lower().replace(" ", "-")
+
+    # Default output dir
+    if not output_dir:
+        output_dir = str(Path.cwd() / ".tmp" / "eject" / safe_name)
+
+    out = Path(output_dir)
+    out.mkdir(parents=True, exist_ok=True)
+
+    files_created: List[str] = []
+
+    # Step 1: Project skeleton
+    skeleton = scaffold_project(app_name)
+    for filepath, content in skeleton.items():
+        _write_file(out, filepath, content, files_created)
+
+    # Step 2: Render pages
+    pages = app_data.get("pages", [])
+    if isinstance(pages, str):
+        pages = json.loads(pages)
+
+    page_files = render_app({"name": app_name, "pages": pages})
+    for filepath, content in page_files.items():
+        _write_file(out, filepath, content, files_created)
+
+    # Step 3: Root layout + globals.css
+    layout_content = compose_app_layout({"name": app_name, "pages": pages})
+    _write_file(out, "app/layout.tsx", layout_content, files_created)
+    _write_file(out, "app/globals.css", compose_globals_css(), files_created)
+
+    # Step 4: Auth files
+    protected_routes = [
+        p.get("route", "/") for p in pages if p.get("is_protected", True)
+    ]
+    auth_files = generate_auth_files(protected_routes)
+    for filepath, content in auth_files.items():
+        _write_file(out, filepath, content, files_created)
+
+    # Step 5: Supabase schema + migrations
+    schema_data = app_data.get("schema")
+    if isinstance(schema_data, str):
+        schema_data = json.loads(schema_data)
+    if schema_data:
+        schema = ForgeSchema.from_dict(schema_data)
+        migration_files = generate_migration_files(schema)
+        for filepath, content in migration_files.items():
+            _write_file(out, filepath, content, files_created)
+
+    _write_file(out, "supabase/config.toml", generate_supabase_config(safe_name), files_created)
+
+    # Step 6: Docker Compose + Dockerfile
+    _write_file(out, "docker-compose.yml", generate_docker_compose(app_name), files_created)
+    _write_file(out, "Dockerfile", generate_dockerfile(), files_created)
+    _write_file(out, ".env.template", generate_env_file(), files_created)
+
+    # Step 7: Audit trail
+    duration_ms = int((time.time() - start) * 1000)
+    log_forge_event(
+        "forge_studio_ejected",
+        {
+            "app_id": app_id or app_data.get("id", "direct"),
+            "app_name": app_name,
+            "output_dir": str(out),
+            "files_created": len(files_created),
+            "duration_ms": duration_ms,
+        },
+        project_id=project_id,
+    )
+
+    return {
+        "status": "success",
+        "app_name": app_name,
+        "output_dir": str(out),
+        "files_created": files_created,
+        "file_count": len(files_created),
+        "duration_ms": duration_ms,
+    }
+
+
+def eject_from_description(
+    description: str,
+    output_dir: str = "",
+    project_id: str = "",
+    use_llm: bool = True,
+) -> Dict[str, Any]:
+    """One-shot: generate app from description and eject immediately.
+
+    Combines generate_app + eject_app in a single call.
+    """
+    from tools.forge_studio.generator.app_generator import generate_app
+
+    gen_result = generate_app(
+        description=description,
+        project_id=project_id,
+        use_llm=use_llm,
+        store=True,
+    )
+
+    if gen_result.get("status") == "error":
+        return gen_result
+
+    return eject_app(
+        app_dict=gen_result["app"],
+        output_dir=output_dir,
+        project_id=project_id,
+    )
+
+
+# ---------------------------------------------------------------------------
+# Helpers
+# ---------------------------------------------------------------------------
+
+def _write_file(base: Path, filepath: str, content: str, tracker: List[str]):
+    """Write a file and track it."""
+    full_path = base / filepath
+    full_path.parent.mkdir(parents=True, exist_ok=True)
+    full_path.write_text(content, encoding="utf-8")
+    tracker.append(filepath)
+    logger.debug("Wrote: %s", filepath)
+
+
+# ---------------------------------------------------------------------------
+# CLI
+# ---------------------------------------------------------------------------
+
+def main():
+    import argparse
+    parser = argparse.ArgumentParser(description="Forge Studio Eject Engine")
+    parser.add_argument("--eject", action="store_true", help="Eject app to standalone project")
+    parser.add_argument("--app-id", type=str, help="App ID to eject")
+    parser.add_argument("--description", type=str, help="Generate + eject from description")
+    parser.add_argument("--output-dir", type=str, default="", help="Output directory")
+    parser.add_argument("--project-id", type=str, default="", help="Project ID")
+    parser.add_argument("--no-llm", action="store_true", help="Use template (no LLM)")
+    parser.add_argument("--json", action="store_true", help="JSON output")
+    args = parser.parse_args()
+
+    if args.description:
+        result = eject_from_description(
+            description=args.description,
+            output_dir=args.output_dir,
+            project_id=args.project_id,
+            use_llm=not args.no_llm,
+        )
+    elif args.eject and args.app_id:
+        result = eject_app(
+            app_id=args.app_id,
+            output_dir=args.output_dir,
+            project_id=args.project_id,
+        )
+    else:
+        parser.print_help()
+        sys.exit(0)
+
+    print(json.dumps(result, indent=2, default=str))
+
+
+if __name__ == "__main__":
+    main()

tools/forge_studio/eject/expo_scaffolder.py

@@ -0,0 +1,303 @@
+# CUI // SP-CTI
+"""Expo / React Native project scaffolder for Forge Studio mobile generation.
+
+Generates a standalone Expo project from a Forge Studio app spec:
+- app.json (Expo config)
+- package.json (Expo + React Native Paper + Supabase + React Navigation)
+- tsconfig.json
+- babel.config.js
+- App.tsx (navigation + screens)
+- Screen files (one per page)
+- Supabase client (AsyncStorage-based auth persistence)
+
+Architecture decision:
+- D-FS-P5-4: Parallel render path (not transpiler from Next.js)
+- Pure string generation, no LLM
+
+CLI: python tools/forge_studio/eject/expo_scaffolder.py --app-id "..." --json
+"""
+from __future__ import annotations
+
+import json
+import logging
+from pathlib import Path
+from typing import Any, Dict, List
+
+from tools.forge_studio.renderer.rn_component_map import (
+    get_required_imports,
+    get_rn_mapping,
+    translate_props,
+)
+
+logger = logging.getLogger("forge_studio.eject.expo")
+
+
+def scaffold_expo_project(
+    app_name: str = "forge-app",
+    app_spec: Dict[str, Any] = None,
+    output_dir: str = "",
+) -> Dict[str, Any]:
+    """Generate a complete Expo project from a Forge Studio app spec."""
+    spec = app_spec or {}
+    safe_name = app_name.lower().replace(" ", "-").replace("_", "-")[:40]
+    pages = spec.get("pages", [{"name": "Home", "components": []}])
+
+    files: Dict[str, str] = {}
+
+    # app.json
+    files["app.json"] = json.dumps({
+        "expo": {
+            "name": app_name,
+            "slug": safe_name,
+            "version": "1.0.0",
+            "orientation": "portrait",
+            "scheme": safe_name,
+            "platforms": ["ios", "android"],
+            "plugins": ["expo-router"],
+            "experiments": {"typedRoutes": True},
+        }
+    }, indent=2)
+
+    # package.json
+    files["package.json"] = json.dumps({
+        "name": safe_name,
+        "version": "1.0.0",
+        "private": True,
+        "main": "expo-router/entry",
+        "scripts": {
+            "start": "expo start",
+            "android": "expo start --android",
+            "ios": "expo start --ios",
+            "web": "expo start --web",
+        },
+        "dependencies": {
+            "expo": "~52.0.0",
+            "expo-router": "~4.0.0",
+            "react": "18.3.1",
+            "react-native": "0.76.3",
+            "react-native-paper": "^5.12.0",
+            "react-native-safe-area-context": "^4.10.0",
+            "react-native-screens": "^4.0.0",
+            "@react-navigation/native": "^7.0.0",
+            "@react-navigation/bottom-tabs": "^7.0.0",
+            "@supabase/supabase-js": "^2.45.0",
+            "@react-native-async-storage/async-storage": "^2.0.0",
+            "react-native-chart-kit": "^6.12.0",
+            "react-native-svg": "^15.8.0",
+        },
+        "devDependencies": {
+            "@types/react": "~18.3.0",
+            "typescript": "^5.3.0",
+        },
+    }, indent=2)
+
+    # tsconfig.json
+    files["tsconfig.json"] = json.dumps({
+        "extends": "expo/tsconfig.base",
+        "compilerOptions": {
+            "strict": True,
+            "paths": {"@/*": ["./*"]},
+        },
+    }, indent=2)
+
+    # babel.config.js
+    files["babel.config.js"] = """module.exports = function (api) {
+  api.cache(true);
+  return {
+    presets: ['babel-preset-expo'],
+  };
+};
+"""
+
+    # Supabase client
+    files["lib/supabase.ts"] = f"""// CUI // SP-CTI
+import {{ createClient }} from '@supabase/supabase-js';
+import AsyncStorage from '@react-native-async-storage/async-storage';
+
+const SUPABASE_URL = process.env.EXPO_PUBLIC_SUPABASE_URL || 'http://localhost:54321';
+const SUPABASE_ANON_KEY = process.env.EXPO_PUBLIC_SUPABASE_ANON_KEY || 'your-anon-key';
+
+export const supabase = createClient(SUPABASE_URL, SUPABASE_ANON_KEY, {{
+  auth: {{
+    storage: AsyncStorage,
+    autoRefreshToken: true,
+    persistSession: true,
+    detectSessionInUrl: false,
+  }},
+}});
+"""
+
+    # App layout (expo-router)
+    tab_screens = ""
+    for i, page in enumerate(pages):
+        pname = page.get("name", f"Page{i+1}")
+        slug = pname.lower().replace(" ", "-")
+        tab_screens += f'        <Tabs.Screen name="{slug}" options={{{{ title: "{pname}" }}}} />\n'
+
+    files["app/_layout.tsx"] = f"""// CUI // SP-CTI
+import {{ Tabs }} from 'expo-router';
+import {{ PaperProvider }} from 'react-native-paper';
+
+export default function Layout() {{
+  return (
+    <PaperProvider>
+      <Tabs>
+{tab_screens}      </Tabs>
+    </PaperProvider>
+  );
+}}
+"""
+
+    # Generate screen files
+    for i, page in enumerate(pages):
+        pname = page.get("name", f"Page{i+1}")
+        slug = pname.lower().replace(" ", "-")
+        components = page.get("components", [])
+        screen_code = _generate_screen(pname, components)
+        files[f"app/{slug}.tsx"] = screen_code
+
+    # .env template
+    files[".env.template"] = """# CUI // SP-CTI
+EXPO_PUBLIC_SUPABASE_URL=http://localhost:54321
+EXPO_PUBLIC_SUPABASE_ANON_KEY=your-anon-key
+"""
+
+    # Write files if output_dir specified
+    files_created: List[str] = []
+    if output_dir:
+        out = Path(output_dir)
+        for filepath, content in files.items():
+            full = out / filepath
+            full.parent.mkdir(parents=True, exist_ok=True)
+            full.write_text(content, encoding="utf-8")
+            files_created.append(filepath)
+
+    return {
+        "status": "success",
+        "target": "mobile",
+        "framework": "expo",
+        "files": files if not output_dir else None,
+        "files_created": files_created,
+        "file_count": len(files),
+        "pages": [p.get("name", "Page") for p in pages],
+    }
+
+
+def _generate_screen(page_name: str, components: List[Dict[str, Any]]) -> str:
+    """Generate a React Native screen file from components."""
+    # Collect required imports
+    comp_types = [c.get("type", "View") for c in components]
+    import_map = get_required_imports(comp_types)
+
+    # Build import lines
+    import_lines = ["import React from 'react';"]
+    rn_imports = {"View", "ScrollView", "StyleSheet"}
+    paper_imports = set()
+
+    for pkg, comps in import_map.items():
+        if pkg == "react-native":
+            rn_imports.update(comps)
+        elif pkg == "react-native-paper":
+            paper_imports.update(comps)
+
+    import_lines.append(f"import {{ {', '.join(sorted(rn_imports))} }} from 'react-native';")
+    if paper_imports:
+        import_lines.append(f"import {{ {', '.join(sorted(paper_imports))} }} from 'react-native-paper';")
+
+    # Build component JSX
+    jsx_lines = []
+    for comp in components:
+        ctype = comp.get("type", "View")
+        mapping = get_rn_mapping(ctype)
+        rn_comp = mapping["rn_component"].split("/")[-1]
+        props = comp.get("props", {})
+        rn_props = translate_props(ctype, props)
+
+        # Simple rendering
+        label = rn_props.pop("label", rn_props.pop("title", comp.get("props", {}).get("label", "")))
+        children = rn_props.pop("children", label or ctype)
+
+        props_str = " ".join(f'{k}={{{json.dumps(v)}}}' for k, v in rn_props.items() if v is not None)
+        if props_str:
+            props_str = " " + props_str
+
+        if ctype in ("Button", "Text", "Badge"):
+            jsx_lines.append(f'        <{rn_comp}{props_str}>{children}</{rn_comp}>')
+        elif ctype == "Separator":
+            jsx_lines.append(f'        <{rn_comp} />')
+        else:
+            jsx_lines.append(f'        <{rn_comp}{props_str}>')
+            if children and isinstance(children, str):
+                jsx_lines.append(f'          <Text>{children}</Text>')
+            jsx_lines.append(f'        </{rn_comp}>')
+
+    body = "\n".join(jsx_lines) if jsx_lines else '        <Text>Empty page</Text>'
+
+    return f"""// CUI // SP-CTI
+{chr(10).join(import_lines)}
+
+export default function {page_name.replace(' ', '')}Screen() {{
+  return (
+    <ScrollView style={{styles.container}}>
+      <View style={{styles.content}}>
+        <Text variant="headlineMedium" style={{styles.title}}>{page_name}</Text>
+{body}
+      </View>
+    </ScrollView>
+  );
+}}
+
+const styles = StyleSheet.create({{
+  container: {{ flex: 1, backgroundColor: '#f5f5f5' }},
+  content: {{ padding: 16, gap: 12 }},
+  title: {{ marginBottom: 16, fontWeight: 'bold' }},
+}});
+"""
+
+
+# ---------------------------------------------------------------------------
+# CLI
+# ---------------------------------------------------------------------------
+
+def main():
+    import argparse
+    import sys
+
+    parser = argparse.ArgumentParser(description="Forge Studio Expo Scaffolder")
+    parser.add_argument("--scaffold", action="store_true", help="Scaffold Expo project")
+    parser.add_argument("--app-id", type=str, default="", help="App ID")
+    parser.add_argument("--app-name", type=str, default="forge-app", help="App name")
+    parser.add_argument("--output-dir", type=str, default="", help="Output directory")
+    parser.add_argument("--json", action="store_true", help="JSON output")
+    args = parser.parse_args()
+
+    if args.scaffold:
+        # Load app spec from DB if app_id provided
+        spec = {}
+        if args.app_id:
+            try:
+                from tools.db.storage import get_connection
+                with get_connection() as conn:
+                    row = conn.execute(
+                        "SELECT spec_json FROM forge_studio_apps WHERE id = ?",
+                        (args.app_id,),
+                    ).fetchone()
+                if row and row[0]:
+                    spec = json.loads(row[0])
+            except Exception:
+                pass
+
+        result = scaffold_expo_project(
+            app_name=args.app_name,
+            app_spec=spec,
+            output_dir=args.output_dir,
+        )
+    else:
+        parser.print_help()
+        sys.exit(0)
+
+    print(json.dumps(result, indent=2, default=str))
+
+
+if __name__ == "__main__":
+    main()