@autoview/cli 0.1.0

package/src/orchestrate/orchestrateAutoViewScaffold.ts

@@ -0,0 +1,627 @@
+import { OpenApi } from "@typia/interface";
+import {
+  AutoBeAutoViewScaffoldEvent,
+  IAutoBeCompiler,
+} from "../typings";
+import { v7 } from "uuid";
+
+import { AutoViewFrontendTemplate } from "../constants/AutoViewFrontendTemplate";
+import { IAutoViewAgentContext } from "../context/IAutoViewAgentContext";
+import { IAutoViewProductPlan } from "./structures/IAutoViewProductPlan";
+import { IAutoViewSdkMap } from "./structures/IAutoViewSdkMap";
+
+/**
+ * Phase 3 of the AutoView agent — Scaffold.
+ *
+ * Deterministic. No LLM calls. Produces the file layout of a runnable Next.js +
+ * shadcn/ui project shaped for the in-house Sandbox platform:
+ *
+ * - Copies the bundled frontend pack (`internals/template/frontend/`) verbatim —
+ *   Dockerfile, configs, shadcn/ui primitives, base app shell, health route.
+ * - Adds the AutoBE-generated SDK under `src/api/**`.
+ * - Adds an SDK adapter and a mock `IConnection` so generated pages can import a
+ *   single helper instead of touching the SDK directly.
+ * - Materializes one placeholder TSX page per screen in
+ *   {@link IAutoViewProductPlan} so the project compiles without Phase 4 having
+ *   run yet; Phase 4 (Render) overwrites these in place.
+ * - Drops the Phase 1 and Phase 2 markdown into `wiki/` so the operator can audit
+ *   the agent's intent alongside the code.
+ */
+export async function orchestrateAutoViewScaffold(
+  ctx: IAutoViewAgentContext,
+  props: {
+    document: OpenApi.IDocument;
+    sdkMap: IAutoViewSdkMap;
+    sdkMapMarkdown: string;
+    productPlan: IAutoViewProductPlan;
+    productPlanMarkdown: string;
+    step: number;
+    /**
+     * Backend hint from the orchestrator. When the source carries a real server
+     * URL (shopping fixture), scaffold a live-mode connection so the dev server
+     * renders real data. When `host` is `null` (AutoBE interface phase), fall
+     * back to simulate-only.
+     */
+    backend: { host: string | null };
+  },
+): Promise<Record<string, string>> {
+  const files: Record<string, string> = {};
+
+  // 1. Bundled frontend pack — Dockerfile, configs, shadcn/ui base, app
+  // shell, health route, CLAUDE.md / PROMPT.md / SANDBOX.md.
+  for (const [key, value] of Object.entries(AutoViewFrontendTemplate)) {
+    files[key] = value;
+  }
+
+  // 2. SDK under `src/api/**` from the AutoBE interface compiler.
+  const compiler: IAutoBeCompiler = await ctx.compiler();
+  const written: Record<string, string> = await compiler.interface.write(
+    props.document,
+    [],
+  );
+  for (const [key, value] of Object.entries(written)) {
+    if (key.startsWith("src/api/")) {
+      files[key] = value;
+    }
+  }
+
+  // 3. SDK adapter + mock connection. Generated pages import from
+  // `@/lib/api` and `@/lib/connection` instead of touching the raw SDK,
+  // so the Render phase has one stable shape to talk to.
+  files["src/lib/connection.ts"] = renderConnectionTs(props.backend);
+  files["src/lib/api.ts"] = SDK_ADAPTER_TS;
+
+  // BootstrapGate + root layout override. The gate runs `bootstrapAuth()`
+  // once on mount before any page-level SDK call fires, so individual
+  // pages do not need to know about auth. When the bootstrap is a
+  // no-op (simulate / no-backend variant) children render immediately.
+  // The template ships a layout.tsx that does not wire the gate;
+  // overriding it here keeps the gate change in one place.
+  files["src/components/BootstrapGate.tsx"] = BOOTSTRAP_GATE_TSX;
+  files["app/layout.tsx"] = ROOT_LAYOUT_TSX;
+
+  // Navigation config consumed by the AppShell sidebar — generated from the
+  // top-level resources so the chrome reflects this swagger's domain.
+  files["src/lib/nav.ts"] = renderNavTs(props.document, props.productPlan);
+
+  // 4. Placeholder TSX per planned screen. Keeps `tsc --noEmit` happy
+  // and Next.js routable even before Phase 4 has filled the pages in.
+  // Phase 4 (Render) overwrites these by path.
+  for (const screen of props.productPlan.screens) {
+    const filePath = screenPathToFile(screen.path);
+    if (filePath === null) continue;
+    files[filePath] = renderPlaceholderPage(screen);
+  }
+
+  // 5. Wiki — Phase 1 + Phase 2 evidence next to the code.
+  files["wiki/sdk-map.md"] = props.sdkMapMarkdown;
+  files["wiki/product-plan.md"] = props.productPlanMarkdown;
+
+  ctx.dispatch({
+    type: "autoViewScaffold",
+    id: v7(),
+    created_at: new Date().toISOString(),
+    step: props.step,
+    files: Object.keys(files).length,
+  } satisfies AutoBeAutoViewScaffoldEvent);
+
+  return files;
+}
+
+/* -------------------------------------------------------------------------- */
+/* path → file mapping                                                        */
+/* -------------------------------------------------------------------------- */
+
+/**
+ * Map a Next.js route path (`/catalog`, `/orders/[id]`) to the corresponding
+ * `app/.../page.tsx` location.
+ *
+ * Returns `null` for the bare `/` route — the bundled frontend pack already
+ * ships `app/page.tsx`, and Phase 4 overwrites it directly.
+ */
+function screenPathToFile(routePath: string): string | null {
+  const trimmed = routePath.replace(/^\/+/, "").replace(/\/+$/, "");
+  if (trimmed.length === 0) return "app/page.tsx";
+  return `app/${trimmed}/page.tsx`;
+}
+
+function renderPlaceholderPage(screen: IAutoViewProductPlan.IScreen): string {
+  const title = jsonString(screen.title);
+  const purpose = jsonString(screen.purpose);
+  const pattern = jsonString(screen.uiPattern);
+  const actor = jsonString(screen.actor);
+  const endpointsArrayLit = JSON.stringify(screen.endpoints);
+  return `// Placeholder generated by AutoView Phase 3 (Scaffold).
+// Phase 4 (Render) replaces this file with a real Next.js page composed of the
+// SDK endpoints listed in the product plan. Until then the page renders a
+// short summary so \`next build\` succeeds and the operator can navigate.
+
+export default function Page() {
+  const endpoints: readonly string[] = ${endpointsArrayLit};
+  return (
+    <main className="container mx-auto py-10">
+      <p className="text-xs uppercase tracking-wide text-muted-foreground">
+        AutoView placeholder · {${pattern}}
+      </p>
+      <h1 className="mt-2 text-3xl font-bold tracking-tight">{${title}}</h1>
+      <p className="mt-3 text-muted-foreground">{${purpose}}</p>
+      <p className="mt-2 text-xs text-muted-foreground">
+        Actor: <span className="font-mono">{${actor}}</span>
+      </p>
+      {endpoints.length > 0 ? (
+        <div className="mt-4 rounded-md border bg-muted/30 p-3">
+          <p className="text-xs font-medium uppercase tracking-wide text-muted-foreground">
+            Planned SDK endpoints
+          </p>
+          <ul className="mt-2 space-y-1 text-xs font-mono">
+            {endpoints.map((accessor) => (
+              <li key={accessor}>{accessor}</li>
+            ))}
+          </ul>
+        </div>
+      ) : null}
+    </main>
+  );
+}
+`;
+}
+
+function jsonString(text: string): string {
+  return JSON.stringify(text);
+}
+
+/* -------------------------------------------------------------------------- */
+/* static helpers                                                             */
+/* -------------------------------------------------------------------------- */
+
+/**
+ * Render the connection module.
+ *
+ * Two shapes:
+ *
+ * - When `backend.host` is non-null (shopping fixture or any SDK whose swagger
+ *   declares `servers[]`), default to that host + `simulate: false` so pages
+ *   render real product data on first boot. The operator can flip back to mocks
+ *   via `NEXT_PUBLIC_API_SIMULATE=true`.
+ * - When `backend.host` is null (AutoBE interface phase — no live backend exists
+ *   yet), default to `simulate: true` so the dev server boots without a real
+ *   server behind it.
+ */
+function renderConnectionTs(backend: { host: string | null }): string {
+  if (backend.host !== null) {
+    return `import type { IConnection } from "@nestia/fetcher";
+
+/**
+ * Connection used by every generated page.
+ *
+ * Routed through Next.js's same-origin rewrite so the browser does not
+ * have to deal with the upstream backend's CORS policy — the samchon
+ * shopping backend, for instance, only advertises \`GET,HEAD,POST\` in
+ * its \`Access-Control-Allow-Methods\` response, which blocks every
+ * PATCH / PUT / DELETE preflight a typical catalog page issues. The
+ * rewrite lives in \`next.config.mjs\` and forwards \`/_backend/*\` to
+ * the real upstream (\`http://127.0.0.1:37001\` by default, see
+ * \`scripts/start-shopping-backend.sh\`). Override the upstream via
+ * \`NEXT_PUBLIC_API_HOST\` if you want to point elsewhere.
+ *
+ * Set \`NEXT_PUBLIC_API_SIMULATE=true\` to swap to typia-random mocks
+ * (the SDK then never hits the network).
+ *
+ * The \`Authorization\` header starts empty — \`bootstrapAuth()\` populates
+ * it on first call with a guest customer token issued by the shopping
+ * backend. \`BootstrapGate\` in the root layout invokes the bootstrap
+ * once on mount, before any page-level SDK call fires, so individual
+ * page components do not need to think about auth.
+ */
+/* -------------------------------------------------------------------------- */
+/* connection scope                                                            */
+/* -------------------------------------------------------------------------- */
+
+/**
+ * Which actor's token the SDK is currently authenticated as. The browser
+ * pathname picks the scope on every navigation — see \`BootstrapGate\`. A
+ * \`null\` scope means the bootstrap has not run yet.
+ */
+export type AuthScope = null | "customer" | "citizen" | "administrator" | "seller";
+
+let activeScope: AuthScope = null;
+const scopePromises: Partial<Record<Exclude<AuthScope, null>, Promise<void>>> = {};
+
+/**
+ * Seed credentials for the samchon shopping backend. The bundled
+ * \`scripts/start-shopping-backend.sh\` always seeds the same single account,
+ * so these values are constants. \`SHOPPING_SYSTEM_PASSWORD\` defaults to
+ * \`samchon\` in the upstream \`.env\` (see seeders).
+ */
+const SEED_EMAIL = "robot@nestia.io";
+const SEED_PASSWORD = "samchon";
+const SEED_NICKNAME = "Robot";
+const SEED_CITIZEN_MOBILE = "01012345678";
+const SEED_CITIZEN_NAME = "Robot";
+const CHANNEL_CODE = "samchon";
+
+export const connection: IConnection = {
+  host:
+    typeof window !== "undefined"
+      ? \`\${window.location.origin}/_backend\`
+      : (process?.env?.NEXT_PUBLIC_API_HOST ?? ${JSON.stringify(backend.host)}),
+  headers: {
+    Authorization: process?.env?.NEXT_PUBLIC_API_TOKEN ?? "",
+  },
+  simulate:
+    typeof process !== "undefined" &&
+    process.env.NEXT_PUBLIC_API_SIMULATE === "true",
+};
+
+/**
+ * Choose which actor's session the current page needs based on the URL.
+ * Defaults to plain customer (read-only catalog browsing). Admin and seller
+ * surfaces sign in with the seed account; coupons / orders / wallet /
+ * checkout / account need a citizen (the customer plus mobile/name).
+ */
+function scopeForPathname(pathname: string | null | undefined): Exclude<AuthScope, null> {
+  if (typeof pathname !== "string") return "customer";
+  if (pathname.startsWith("/admin")) return "administrator";
+  if (pathname.startsWith("/seller")) return "seller";
+  if (
+    pathname.startsWith("/cart") ||
+    pathname.startsWith("/orders") ||
+    pathname.startsWith("/checkout") ||
+    pathname.startsWith("/wallet") ||
+    pathname.startsWith("/coupons") ||
+    pathname.startsWith("/account")
+  ) {
+    return "citizen";
+  }
+  return "customer";
+}
+
+async function requestJson<T>(
+  method: "POST" | "PUT",
+  path: string,
+  body: unknown,
+): Promise<T> {
+  const res = await fetch(\`/_backend\${path}\`, {
+    method,
+    headers: { "Content-Type": "application/json", ...auth() },
+    body: JSON.stringify(body),
+  });
+  if (!res.ok) {
+    const text = await res.text().catch(() => "");
+    throw new Error(\`\${method} \${path} → \${res.status}: \${text.slice(0, 200)}\`);
+  }
+  return (await res.json()) as T;
+}
+
+function auth(): Record<string, string> {
+  const a = connection.headers?.Authorization;
+  return typeof a === "string" && a.length > 0 ? { Authorization: a } : {};
+}
+
+function applyToken(payload: unknown): void {
+  const raw = payload as {
+    setHeaders?: { Authorization?: unknown } | null;
+    token?: { access?: unknown } | null;
+  } | null;
+  const fromSetHeaders =
+    typeof raw?.setHeaders?.Authorization === "string"
+      ? (raw.setHeaders.Authorization as string)
+      : null;
+  const fromTokenAccess =
+    typeof raw?.token?.access === "string"
+      ? \`Bearer \${raw.token.access as string}\`
+      : null;
+  const token = fromSetHeaders ?? fromTokenAccess;
+  if (token === null) {
+    throw new Error("Auth bootstrap returned 2xx but no token in the body.");
+  }
+  if (connection.headers !== undefined) {
+    connection.headers.Authorization = token;
+  }
+}
+
+async function ensureCustomer(): Promise<void> {
+  // The customer \`POST /authenticate\` is the only call that issues a
+  // new JWT — every subsequent activate/login attaches role grants to
+  // the same customer server-side and returns the updated customer
+  // object with NO \`setHeaders\` / \`token\` field. Reusing the bearer
+  // header from this call works for citizen / member / admin / seller
+  // requests after the corresponding activate or login has succeeded.
+  await requestJson("POST", "/shoppings/customers/authenticate", {
+    channel_code: CHANNEL_CODE,
+    external_user: null,
+    href: typeof window !== "undefined" ? window.location.href : "http://localhost:3000",
+    referrer: typeof document !== "undefined" ? document.referrer || null : null,
+  }).then(applyToken);
+}
+
+async function ensureCitizen(): Promise<void> {
+  await ensureCustomer();
+  // \`activate\` upgrades the current customer to a citizen by attaching
+  // mobile/name. Returns the updated customer (no \`setHeaders\` / no
+  // \`token\` field) so the customer JWT from \`ensureCustomer\` stays the
+  // auth header for citizen-scoped routes. Idempotent for the seeded
+  // account; backend rejects re-activation with 409/422 which we
+  // swallow as success.
+  try {
+    await requestJson("POST", "/shoppings/customers/authenticate/activate", {
+      mobile: SEED_CITIZEN_MOBILE,
+      name: SEED_CITIZEN_NAME,
+    });
+  } catch (e: unknown) {
+    if (e instanceof Error && /already|conflict|409|422/i.test(e.message)) {
+      return;
+    }
+    throw e;
+  }
+}
+
+async function ensureMemberLogin(): Promise<void> {
+  await ensureCustomer();
+  // \`login\` is registered as PUT on the samchon/shopping backend
+  // (\`@TypedRoute.Put("login")\`), not POST. The response has no
+  // \`setHeaders\` / no \`token\` field — the existing customer JWT now
+  // carries member privileges server-side, so no header rewrite is
+  // needed.
+  await requestJson("PUT", "/shoppings/customers/authenticate/login", {
+    email: SEED_EMAIL,
+    password: SEED_PASSWORD,
+  });
+}
+
+async function ensureAdministrator(): Promise<void> {
+  await ensureMemberLogin();
+  await requestJson("PUT", "/shoppings/admins/authenticate/login", {
+    email: SEED_EMAIL,
+    password: SEED_PASSWORD,
+  });
+}
+
+async function ensureSeller(): Promise<void> {
+  await ensureMemberLogin();
+  await requestJson("PUT", "/shoppings/sellers/authenticate/login", {
+    email: SEED_EMAIL,
+    password: SEED_PASSWORD,
+  });
+}
+
+/**
+ * Bootstrap (or rotate) the connection's auth token to the scope demanded
+ * by the current pathname.
+ *
+ * Memoized per scope: the first call per scope drives the fetch chain,
+ * concurrent callers reuse the same promise, and successful runs are
+ * cached so navigations within the same scope are instant. Failures clear
+ * the cache so the next attempt retries cleanly.
+ *
+ * When \`simulate: true\` is on, this is a no-op because the SDK never
+ * touches the network in mock mode.
+ */
+export function bootstrapAuth(pathname?: string): Promise<void> {
+  if (connection.simulate === true) {
+    activeScope = "customer";
+    return Promise.resolve();
+  }
+  const scope = scopeForPathname(pathname);
+  if (scope === activeScope && scopePromises[scope] !== undefined) {
+    return scopePromises[scope]!;
+  }
+  const promise = (async () => {
+    if (scope === "administrator") await ensureAdministrator();
+    else if (scope === "seller") await ensureSeller();
+    else if (scope === "citizen") await ensureCitizen();
+    else await ensureCustomer();
+  })()
+    .then(() => {
+      activeScope = scope;
+    })
+    .catch((err: unknown) => {
+      scopePromises[scope] = undefined;
+      throw err;
+    });
+  scopePromises[scope] = promise;
+  return promise;
+}
+`;
+  }
+  return `import type { IConnection } from "@nestia/fetcher";
+
+/**
+ * Mock connection used by every generated page.
+ *
+ * Defaults to \`simulate: true\` so the project boots usefully without a
+ * live backend — the SDK returns typia-generated mock responses for every
+ * endpoint. Set \`NEXT_PUBLIC_API_SIMULATE=false\` (and point
+ * \`NEXT_PUBLIC_API_HOST\` at the real server) to switch to live mode.
+ */
+export const connection: IConnection = {
+  host:
+    typeof process !== "undefined"
+      ? process.env.NEXT_PUBLIC_API_HOST ?? "http://127.0.0.1:37001"
+      : "http://127.0.0.1:37001",
+  headers: {
+    Authorization: process?.env?.NEXT_PUBLIC_API_TOKEN ?? "Bearer preview",
+  },
+  simulate:
+    typeof process === "undefined" ||
+    process.env.NEXT_PUBLIC_API_SIMULATE !== "false",
+};
+
+/**
+ * No-op auth bootstrap for the interface (no-backend) variant. Accepts
+ * (and ignores) the pathname so the root layout can call
+ * \`bootstrapAuth(pathname)\` unconditionally, no matter which AutoView
+ * source generated the project.
+ */
+export function bootstrapAuth(_pathname?: string): Promise<void> {
+  return Promise.resolve();
+}
+`;
+}
+
+const BOOTSTRAP_GATE_TSX = `"use client";
+
+import { usePathname } from "next/navigation";
+import { useEffect } from "react";
+
+import { bootstrapAuth } from "@/src/lib/connection";
+
+/**
+ * Best-effort auth bootstrap. Attempts to issue the backend's token for the
+ * current actor scope on navigation, but NEVER blocks rendering.
+ *
+ * Auth must not gate the whole app: public screens (catalogs, lists) work
+ * without a token, and protected screens surface their own 401 through their
+ * normal load/error state. An auth-required backend (shopping / ERP) or a
+ * backend that is simply down used to take the ENTIRE app down behind a
+ * "Backend not ready" wall — even the public screens. It no longer does:
+ * the bootstrap runs in the background and children render immediately.
+ */
+export default function BootstrapGate({
+  children,
+}: {
+  children: React.ReactNode;
+}) {
+  const pathname = usePathname();
+
+  useEffect(() => {
+    bootstrapAuth(pathname).catch(() => {
+      // Bootstrap failed (no seeded account, auth-required backend, or backend
+      // down). Render anyway — each page handles its own loading / error state.
+    });
+  }, [pathname]);
+
+  return <>{children}</>;
+}
+`;
+
+const ROOT_LAYOUT_TSX = `import type { Metadata } from "next";
+import { Archivo } from "next/font/google";
+import "./globals.css";
+
+import { AppShell } from "@/components/AppShell";
+import BootstrapGate from "@/src/components/BootstrapGate";
+import { APP_NAME } from "@/src/lib/nav";
+
+// Industrial grotesque carrying the whole UI. Wires the \`--font-sans\` variable
+// the theme reads; the gate override must keep it or headings fall back to the
+// browser's default serif.
+const archivo = Archivo({
+  subsets: ["latin"],
+  variable: "--font-sans",
+  display: "swap",
+});
+
+export const metadata: Metadata = {
+  title: APP_NAME,
+  description: "Generated by AutoView from the API's OpenAPI document.",
+};
+
+export default function RootLayout({
+  children,
+}: {
+  children: React.ReactNode;
+}) {
+  return (
+    <html lang="en" className={\`dark \${archivo.variable}\`} suppressHydrationWarning>
+      <body className="min-h-screen bg-background font-sans antialiased">
+        <BootstrapGate>
+          <AppShell>{children}</AppShell>
+        </BootstrapGate>
+      </body>
+    </html>
+  );
+}
+`;
+
+/**
+ * Generate `src/lib/nav.ts` — the sidebar navigation config the AppShell reads.
+ * Top-level resources (chain depth 1) become nav items, grouped into data
+ * "Resources" (list tables) and "System" (singleton reads). The app name comes
+ * from the OpenAPI document title.
+ */
+export function renderNavTs(
+  document: OpenApi.IDocument,
+  plan: IAutoViewProductPlan,
+): string {
+  const appName = (document.info?.title ?? "API").trim() || "API";
+  const navScreens = plan.screens.filter(
+    (s) =>
+      (s.depth === undefined || s.depth === 1) &&
+      !s.path.includes("[") &&
+      (s.uiPattern === "table" ||
+        s.uiPattern === "catalog" ||
+        s.uiPattern === "detail"),
+  );
+  // Singleton reads go under "System"; browsable resources go under "Resources",
+  // but on a large swagger that one section is 36 flat items. Group them by the
+  // resource name's leading token so related resources collapse into a section
+  // (shield_information_barrier* → "Shield", legal_hold_* → "Legal"). A token
+  // shared by ≥2 resources becomes its own section; lone resources stay under
+  // the generic "Resources" heading. Purely cosmetic — no screen is removed.
+  const groupKey = new Map<string, string>(); // href → leading token (singularized)
+  const tokenCount = new Map<string, number>();
+  for (const s of navScreens) {
+    if (s.uiPattern === "detail") continue;
+    const resource = s.path.replace(/^\//, "").split("/")[0] ?? "";
+    const token = singularizeToken(resource.split("_")[0] ?? resource);
+    groupKey.set(s.path, token);
+    tokenCount.set(token, (tokenCount.get(token) ?? 0) + 1);
+  }
+  const items = navScreens.map((s) => {
+    if (s.uiPattern === "detail") {
+      return { href: s.path, title: s.title, group: "System" };
+    }
+    const token = groupKey.get(s.path) ?? "";
+    const group =
+      (tokenCount.get(token) ?? 0) >= 2 ? titleCaseToken(token) : "Resources";
+    return { href: s.path, title: s.title, group };
+  });
+  // "Resources" first, named prefix groups alphabetically, "System" last.
+  const rank = (g: string): number =>
+    g === "Resources" ? 0 : g === "System" ? 2 : 1;
+  items.sort(
+    (a, b) =>
+      rank(a.group) - rank(b.group) ||
+      a.group.localeCompare(b.group) ||
+      a.title.localeCompare(b.title),
+  );
+  return [
+    `// Generated by AutoView — sidebar navigation derived from the top-level`,
+    `// resources of the OpenAPI document.`,
+    `export const APP_NAME = ${JSON.stringify(appName)};`,
+    ``,
+    `export interface NavItem {`,
+    `  href: string;`,
+    `  title: string;`,
+    `  group: string;`,
+    `}`,
+    ``,
+    `export const NAV: NavItem[] = ${JSON.stringify(items, null, 2)};`,
+    ``,
+  ].join("\n");
+}
+
+/** Crude singularization of a leading nav token (`folders` → `folder`), used
+ *  only to bucket related resources; `status`-style 2-letter stems are left
+ *  alone to avoid over-trimming. */
+function singularizeToken(token: string): string {
+  return token.length > 3 && token.endsWith("s") ? token.slice(0, -1) : token;
+}
+
+/** Title-case a single token for a nav section heading (`shield` → `Shield`). */
+function titleCaseToken(token: string): string {
+  return token.length === 0
+    ? token
+    : token.charAt(0).toUpperCase() + token.slice(1);
+}
+
+const SDK_ADAPTER_TS = `// AutoView SDK adapter. Pages import \`api\` from this module instead of
+// touching \`@/src/api/\` directly so the SDK surface can be replaced
+// without rewriting every page.
+
+import api from "@/src/api";
+
+export default api;
+export * from "@/src/api";
+`;