sp2react 0.1.0__py3-none-any.whl

sp2react/scaffold/generate.py

@@ -0,0 +1,279 @@
+"""Stage 6a: deterministic code generation (seconds, no model calls).
+
+Writes the React + FastAPI app skeleton, the specs, seed data and generated tests. Agents only
+write what is screen-specific (page components, custom handlers); everything here is fixed code.
+"""
+from __future__ import annotations
+
+import json
+import re
+import shutil
+from pathlib import Path
+from typing import Iterable, Optional
+
+from ..analysis.inventory import Legacy, kebab
+from ..spec.model import Spec
+
+TEMPLATES = Path(__file__).parent / "templates"
+AGENT_OWNED = re.compile(r"^(frontend/src/screens/[^/]+/(?!index).+|frontend/src/custom/(?!index\.ts|types\.ts).+|backend/app/custom/(?!__init__).+)$")
+
+
+def ident(name: str) -> str:
+    s = re.sub(r"\W+", "_", name)
+    return ("_" + s) if s[0].isdigit() else s
+
+
+def copy_templates(out: Path) -> list[str]:
+    written = []
+    for src in TEMPLATES.rglob("*"):
+        if src.is_dir() or "__pycache__" in src.parts:
+            continue
+        rel = src.relative_to(TEMPLATES).as_posix()
+        dst = out / rel
+        dst.parent.mkdir(parents=True, exist_ok=True)
+        shutil.copyfile(src, dst)
+        written.append(rel)
+    return written
+
+
+# ----------------------------------------------------------------- seed data
+def seed_rows(legacy: Legacy, list_key: str, fields: list[dict], export_dir: Optional[Path] = None) -> list[dict]:
+    """Full migrated rows when a data export exists, otherwise the sample captured during extraction."""
+    from ..migrate import read_export, transform
+    if export_dir and (export_dir / f"{list_key}.jsonl").exists():
+        return transform(read_export(export_dir, list_key), fields)
+    return transform(legacy.items(list_key), fields)
+
+
+def users_json(legacy: Legacy) -> list[dict]:
+    f = legacy.root / "siteusers.json"
+    data = json.loads(f.read_text(encoding="utf-8")) if f.exists() else {"d": {"results": []}}
+    groups = legacy.site.get("groups", [])
+    out = []
+    for u in data.get("d", {}).get("results", []):
+        if u.get("PrincipalType", 1) != 1:
+            continue
+        login = re.sub(r"^i:0#\.\w\|", "", u.get("LoginName", ""))
+        out.append({"id": u["Id"], "login": login, "title": u.get("Title"), "email": u.get("Email"),
+                    "groups": [g["name"] for g in groups if login.lower() in [m.lower() for m in g.get("members", [])]]})
+    return out
+
+
+# ------------------------------------------------------------- generated src
+def site_ts(legacy: Legacy, specs: list[Spec]) -> str:
+    prefix = legacy.prefix
+    routes: dict[str, str] = {}
+    for s in specs:
+        for u in s.screen.legacy_urls:
+            routes[u.lower()] = s.screen.route
+        if s.screen.kind == "list-form" and s.screen.list in legacy.lists:
+            l = legacy.lists[s.screen.list]
+            routes[f"{prefix}/{l['url']}".lower()] = s.screen.route
+            routes[f"{prefix}/{l['url']}/allitems.aspx".lower()] = s.screen.route
+    links = []
+    for q in legacy.site.get("quickLaunch", []):
+        url = re.sub(r"^https?://[^/]+", "", q.get("url") or "")
+        r = routes.get(url.lower().rstrip("/"))
+        links.append({"title": q.get("title"), "href": r or (legacy.site.get("url", "").split(prefix)[0] + url), "external": not r})
+    if not links:
+        links = [{"title": s.screen.title, "href": s.screen.route, "external": False} for s in specs]
+    return ("// Generated by sp2react from the legacy site's navigation. Links to screens not yet converted point at the old site.\n"
+            f"export const site = {json.dumps({'title': legacy.site.get('title') or 'Site', 'quickLaunch': links}, indent=2)};\n")
+
+
+def app_tsx(specs: list[Spec], out: Path) -> str:
+    imports, entries, routes = [], [], []
+    for i, s in enumerate(specs):
+        var = f"spec{i}"
+        imports.append(f'import {var}Json from "./specs/{s.screen.id}.json";')
+        entries.append(f"{var}Json as unknown as Spec")
+        if s.screen.kind == "list-form":
+            routes.append(f'        <Route path="{s.screen.route}/*" element={{<ListFormScreen spec={{specs[{i}]}} />}} />')
+        else:
+            page = out / "frontend" / "src" / "screens" / s.screen.id / "Page.tsx"
+            if page.exists():
+                comp = f"Page{i}"
+                imports.append(f'import {comp} from "./screens/{s.screen.id}/Page";')
+            else:
+                comp = "GenericPage"
+            routes.append(f'        <Route path="{s.screen.route}" element={{<{comp} spec={{specs[{i}]}} />}} />')
+    home = next((s.screen.route for s in specs if s.screen.kind == "page"), specs[0].screen.route if specs else "/")
+    return "\n".join([
+        "// Generated by sp2react: one route per converted screen, plus redirects for the old SharePoint URLs.",
+        'import { Navigate, Route, Routes } from "react-router-dom";',
+        'import { GenericPage } from "./components/sp/GenericPage";',
+        'import { LegacyRedirect } from "./screens/LegacyRedirect";',
+        'import { ListFormScreen } from "./screens/ListFormScreen";',
+        'import type { Spec } from "./runtime/spec";',
+        'import { UserProvider } from "./runtime/user";',
+        *imports,
+        "",
+        f"export const specs: Spec[] = [{', '.join(entries)}];",
+        "",
+        "export default function App() {",
+        "  return (",
+        "    <UserProvider>",
+        "      <Routes>",
+        f'        <Route path="/" element={{<Navigate to="{home}" replace />}} />',
+        *routes,
+        '        <Route path="*" element={<LegacyRedirect specs={specs} />} />',
+        "      </Routes>",
+        "    </UserProvider>",
+        "  );",
+        "}",
+        "",
+    ])
+
+
+def custom_index(out: Path) -> str:
+    folder = out / "frontend" / "src" / "custom"
+    mods = sorted(p.stem for p in folder.glob("*.ts") if p.stem not in ("index", "types"))
+    lines = ["// Generated by sp2react: registry of agent-written handlers (rule kind \"custom\").",
+             'import type { Handler } from "./types";']
+    lines += [f'import * as {ident(m)} from "./{m}";' for m in mods]
+    lines.append("")
+    body = ", ".join(f'"{m}": {ident(m)} as Handler' for m in mods)
+    lines.append(f"export const HANDLERS: Record<string, Handler> = {{{body}}};")
+    return "\n".join(lines) + "\n"
+
+
+def legacy_css(legacy: Legacy, specs: list[Spec]) -> str:
+    seen, parts = set(), ["/* Site CSS carried over from the legacy SharePoint pages (order preserved). */"]
+    for s in specs:
+        for rel in s.screen.stylesheets:
+            if rel in seen:
+                continue
+            seen.add(rel)
+            txt = legacy.file_text(rel)
+            if txt:
+                parts.append(f"/* ---- {rel} ---- */\n{txt.strip()}")
+    return "\n\n".join(parts) + "\n"
+
+
+def generated_tests(specs: list[Spec], seed_counts: dict[str, int], data_source: str = "sqlite") -> str:
+    """Deterministic API tests derived from the specs (schema + rules)."""
+    db = data_source == "database"
+    lines = [
+        '"""Generated by sp2react from the screen specs. Regenerated on every convert run; add your own tests in other files."""',
+        "import os",
+        "",
+        "import pytest",
+        "from fastapi.testclient import TestClient",
+        "",
+        "from app.rules import REQUIRED_MESSAGE",
+        "",
+    ]
+    if db:
+        lines += ['pytestmark = pytest.mark.skipif(not os.environ.get("DB_URL"), reason="set DB_URL (and MAPPING_FILE) to run the API tests against your database")', ""]
+    lines += [
+        "",
+        '@pytest.fixture(scope="module")',
+        "def client():",
+        "    from app.main import create_app",
+        "    return TestClient(create_app())",
+        "",
+        "",
+        "def test_screens_are_served(client):",
+        "    ids = {s['id'] for s in client.get('/api/screens').json()}",
+        f"    assert ids >= set({sorted(s.screen.id for s in specs)!r})",
+        "",
+    ]
+    done = set()
+    for s in specs:
+        for name, l in s.lists.items():
+            if name in done:
+                continue
+            done.add(name)
+            fn = ident(name).lower()
+            lines += ["", f"def test_{fn}_items_served(client):",
+                      f"    r = client.get('/api/lists/{name}/items', params={{'$top': 5}})",
+                      "    assert r.status_code == 200, r.text"]
+            if not db:
+                lines += [f"    assert r.json()['count'] == {seed_counts.get(name, 0)}"]
+        if s.screen.kind == "list-form" and s.screen.list and "new" in s.screen.modes:
+            lst = s.lists[s.screen.list]
+            hidden_new = {r.field for r in s.rules if r.kind == "visible" and (not r.modes or "new" in r.modes)}
+            readonly = {r.field for r in s.rules if r.kind in ("readonly", "derive", "set_on_save") and (not r.modes or "new" in r.modes)}
+            defaults = {f["name"] for f in lst.fields if "default" in f} | {r.field for r in s.rules if r.kind == "default"}
+            req = [f["name"] for f in lst.fields if f.get("required") and f["name"] not in hidden_new | readonly | defaults]
+            fn = ident(s.screen.id).lower()
+            if req:
+                lines += ["", f"def test_{fn}_required_fields_enforced(client):",
+                          f"    r = client.post('/api/lists/{s.screen.list}/items', json={{'values': {{}}}})",
+                          "    assert r.status_code == 422",
+                          "    fields = {e['field'] for e in r.json()['errors'] if e['message'] == REQUIRED_MESSAGE}",
+                          f"    assert set({req!r}) <= fields"]
+    return "\n".join(lines) + "\n"
+
+
+ENV_EXAMPLE = """# Copy to .env (or set in your service configuration). Never commit real values.
+DATA_SOURCE=__SOURCE__
+# database: your existing tables
+DB_URL=mysql+pymysql://user:password@db-host:3306/sea
+MAPPING_FILE=./mapping.json
+# auth: dev (X-User header, local only) | header (identity header from your gateway)
+AUTH_MODE=dev
+IDENTITY_HEADER=X-MS-CLIENT-PRINCIPAL-NAME
+CORS_ORIGINS=http://localhost:5173
+"""
+
+
+def generate(out: Path, specs: list[Spec], legacy: Legacy, export_dir: Optional[Path] = None,
+             data_source: str = "sqlite", mapping_file: Optional[Path] = None) -> dict:
+    out.mkdir(parents=True, exist_ok=True)
+    written = copy_templates(out)
+    (out / "backend" / "specs").mkdir(parents=True, exist_ok=True)
+    (out / "frontend" / "src" / "specs").mkdir(parents=True, exist_ok=True)
+    for s in specs:
+        js = s.model_dump_json(indent=2, exclude_none=True)
+        (out / "backend" / "specs" / f"{s.screen.id}.json").write_text(js, encoding="utf-8")
+        (out / "frontend" / "src" / "specs" / f"{s.screen.id}.json").write_text(js, encoding="utf-8")
+
+    seed_dir = out / "backend" / "data" / "seed"
+    seed_dir.mkdir(parents=True, exist_ok=True)
+    counts, lists_done = {}, set()
+    for s in specs:
+        for name, l in s.lists.items():
+            if name in lists_done:
+                continue
+            lists_done.add(name)
+            rows = seed_rows(legacy, name, l.fields, export_dir)
+            counts[name] = len(rows)
+            (seed_dir / f"{name}.json").write_text(json.dumps(rows, indent=2), encoding="utf-8")
+            if export_dir and (export_dir / "attachments" / name).exists():
+                dst = out / "backend" / "data" / "attachments" / name
+                if dst.exists():
+                    shutil.rmtree(dst)
+                shutil.copytree(export_dir / "attachments" / name, dst)
+    (out / "backend" / "data" / "users.json").write_text(json.dumps(users_json(legacy), indent=2), encoding="utf-8")
+
+    src = out / "frontend" / "src"
+    (src / "site.ts").write_text(site_ts(legacy, specs), encoding="utf-8")
+    (src / "App.tsx").write_text(app_tsx(specs, out), encoding="utf-8")
+    (src / "custom" / "index.ts").write_text(custom_index(out), encoding="utf-8")
+    (src / "styles" / "legacy.css").write_text(legacy_css(legacy, specs), encoding="utf-8")
+    html = (out / "frontend" / "index.html").read_text(encoding="utf-8").replace("__SITE_TITLE__", legacy.site.get("title") or "Site")
+    (out / "frontend" / "index.html").write_text(html, encoding="utf-8")
+    (out / "backend" / "tests" / "test_generated.py").write_text(generated_tests(specs, counts, data_source), encoding="utf-8")
+    main_py = out / "backend" / "app" / "main.py"
+    main_py.write_text(main_py.read_text(encoding="utf-8").replace("__DEFAULT_SOURCE__", data_source), encoding="utf-8")
+    if data_source == "database":
+        if mapping_file and mapping_file.exists():
+            shutil.copyfile(mapping_file, out / "backend" / "mapping.json")
+        roles = out / "backend" / "data" / "roles.json"
+        if not roles.exists():   # SharePoint group names; members are filled in by your admins (or come from the users table)
+            groups = sorted({r for sp in specs for r in sp.roles} | {g["name"] for g in legacy.site.get("groups", [])})
+            roles.write_text(json.dumps({g: [] for g in groups}, indent=2), encoding="utf-8")
+    (out / "backend" / ".env.example").write_text(ENV_EXAMPLE.replace("__SOURCE__", data_source), encoding="utf-8")
+    shared = TEMPLATES.parent / "rule_vectors.json"
+    if shared.exists():
+        (out / "shared").mkdir(exist_ok=True)
+        shutil.copyfile(shared, out / "shared" / "rule_vectors.json")
+    return {"files": len(written) + 8 + 2 * len(specs), "seed": counts}
+
+
+def refresh_registries(out: Path, specs: list[Spec]) -> None:
+    """After agents add files: re-link App.tsx routes and the custom handler registry."""
+    src = out / "frontend" / "src"
+    (src / "App.tsx").write_text(app_tsx(specs, out), encoding="utf-8")
+    (src / "custom" / "index.ts").write_text(custom_index(out), encoding="utf-8")