@svadmin/create 0.20.0 → 0.22.0

package/README.md

@@ -134,3 +134,22 @@ overwriting local standards:
 bunx @svadmin/create guidance .
 bunx @svadmin/create guidance . --write
 ```
+
+## Add Lite routes to an existing SPA
+
+Lite is an optional SvelteKit server-rendered route tree. It does not modify the
+existing SPA or add IE11 branches to the SPA bundle. In a project that already
+has a SvelteKit `src/routes` directory, run:
+
+```bash
+# Preview the files first; nothing is written
+bunx @svadmin/create lite init .
+
+# Generate the shared adapter and dynamic CRUD routes
+bunx @svadmin/create lite init . --write
+```
+
+The generator creates one `[resource]` route for all resources plus the shared
+`src/lib/svadmin-lite.ts` adapter. Your existing `$lib/admin` module only needs
+to export `resources` and `dataProvider`; resources are resolved dynamically at
+request time. Existing files are preserved, so rerunning the command is safe.

package/dist/index.js

@@ -5024,9 +5024,9 @@ var require_picocolors = __commonJS(function(exports, module) {
 
 // src/index.ts
 var import_prompts2 = __toESM(require_prompts3(), 1);
-var import_picocolors2 = __toESM(require_picocolors(), 1);
-import fs2 from "node:fs";
-import path2 from "node:path";
+var import_picocolors3 = __toESM(require_picocolors(), 1);
+import fs4 from "node:fs";
+import path4 from "node:path";
 import { fileURLToPath } from "node:url";
 import { createRequire as createRequire2 } from "node:module";
 import { spawnSync } from "node:child_process";
@@ -5998,6 +5998,10 @@ function parseInferArguments(args) {
       options.primaryKey = args[++i];
     } else if (arg.startsWith("--primary-key=")) {
       options.primaryKey = arg.slice(14);
+    } else if (arg === "--fields") {
+      options.fields = args[++i];
+    } else if (arg.startsWith("--fields=")) {
+      options.fields = arg.slice(9);
     } else if (arg === "--header" || arg === "-H") {
       const headerLine = args[++i] ?? "";
       const colonIndex = headerLine.indexOf(":");
@@ -6431,6 +6435,343 @@ function capitalize2(s) {
   return s.charAt(0).toUpperCase() + s.slice(1);
 }
 
+// src/generate-command.ts
+var import_picocolors2 = __toESM(require_picocolors(), 1);
+import fs2 from "node:fs";
+import path2 from "node:path";
+function parseGenerateArguments(args) {
+  return parseInferArguments(args);
+}
+async function generateCommand(args) {
+  const options = parseGenerateArguments(args);
+  if (options.resource && options.fields) {
+    const resourceName = options.resource;
+    const primaryKey = options.primaryKey ?? "id";
+    const fieldDefs = options.fields.split(",").map((f) => {
+      const [key, typeRaw] = f.split(":");
+      const type = typeRaw || "text";
+      return {
+        key: key.trim(),
+        label: key.trim().charAt(0).toUpperCase() + key.trim().slice(1),
+        type,
+        required: key.trim() === primaryKey
+      };
+    });
+    const mockSample = {};
+    for (const f of fieldDefs) {
+      mockSample[f.key] = f.type === "number" ? 1 : f.type === "boolean" ? true : `sample_${f.key}`;
+    }
+    const inferRes = inferResource(resourceName, [mockSample], { primaryKey });
+    const resources = [
+      {
+        name: resourceName,
+        label: resourceName.charAt(0).toUpperCase() + resourceName.slice(1),
+        primaryKey,
+        fields: fieldDefs
+      }
+    ];
+    const bundles = new Map([[resourceName, inferRes]]);
+    const files = planGeneratedFiles(resources, bundles, options.format);
+    let wrote = false;
+    if (options.outDir && options.write) {
+      const targetDir = path2.resolve(process.cwd(), options.outDir);
+      for (const file of files) {
+        const fullPath = path2.join(targetDir, file.relativePath);
+        fs2.mkdirSync(path2.dirname(fullPath), { recursive: true });
+        fs2.writeFileSync(fullPath, file.content, "utf-8");
+      }
+      wrote = true;
+    }
+    printInferResult({
+      resources,
+      bundles,
+      files,
+      sourceDescription: `manual schema: ${options.fields}`,
+      wrote,
+      outDir: options.outDir
+    });
+    return;
+  }
+  if (options.url || options.file) {
+    const result = await executeInfer(options);
+    printInferResult(result);
+    return;
+  }
+  console.log(`
+${import_picocolors2.default.bold("svadmin generate")} — Generate complete Resource Definitions, Schemas, and CRUD pages.
+
+${import_picocolors2.default.bold("USAGE:")}
+  svadmin generate --resource <name> --fields <field:type,...> [OPTIONS]
+  svadmin generate --file <schema.json|openapi.yaml|schema.graphql> [OPTIONS]
+  svadmin generate --url <api-url|openapi-url> [OPTIONS]
+
+${import_picocolors2.default.bold("EXAMPLES:")}
+  svadmin generate --resource posts --fields "id:number,title:text,content:textarea,published:boolean" --out-dir src/resources --write
+  svadmin generate --file openapi.json --out-dir src/resources --write
+`);
+}
+
+// src/lite-init.ts
+import fs3 from "node:fs";
+import path3 from "node:path";
+var GENERATED_FILES = {
+  "src/lib/svadmin-lite.ts": `import { dataProvider, resources } from '$lib/admin';
+import type { ResourceDefinition } from '@svadmin/core';
+
+export { dataProvider, resources };
+
+export function getResource(name: string): ResourceDefinition | undefined {
+  return resources.find((resource) => resource.name === name);
+}
+`,
+  "src/routes/lite/+layout.ts": `export const ssr = true;
+export const csr = false;
+`,
+  "src/routes/lite/+layout.server.ts": `import { resources } from '$lib/svadmin-lite';
+import type { LayoutServerLoad } from './$types';
+
+export const load = (({ url }) => {
+  const segments = url.pathname.split('/').filter(Boolean);
+  const currentResource = segments[1] ?? '';
+
+  return { resources, currentResource };
+}) satisfies LayoutServerLoad;
+`,
+  "src/routes/lite/+layout.svelte": `<script lang="ts">
+  import type { Snippet } from 'svelte';
+  import { LiteLayout } from '@svadmin/lite';
+  import '@svadmin/lite/lite.css';
+  import type { LayoutData } from './$types';
+
+  let { data, children }: { data: LayoutData; children: Snippet } = $props();
+</script>
+
+<LiteLayout
+  resources={data.resources}
+  currentResource={data.currentResource}
+  brandName="Lite Admin"
+  basePath="/lite"
+>
+  {@render children()}
+</LiteLayout>
+`,
+  "src/routes/lite/+page.server.ts": `import { error, redirect } from '@sveltejs/kit';
+import { resources } from '$lib/svadmin-lite';
+import type { PageServerLoad } from './$types';
+
+export const load = (() => {
+  const firstResource = resources[0];
+  if (!firstResource) throw error(404, 'No Lite resources configured');
+  throw redirect(302, \`/lite/\${firstResource.name}\`);
+}) satisfies PageServerLoad;
+`,
+  "src/routes/lite/[resource]/+page.server.ts": `import { error } from '@sveltejs/kit';
+import { createCrudActions, createListLoader } from '@svadmin/lite';
+import { dataProvider, getResource } from '$lib/svadmin-lite';
+import type { Actions, PageServerLoad } from './$types';
+
+export const load = ((event) => {
+  const resource = getResource(event.params.resource);
+  if (!resource) throw error(404, \`Resource "\${event.params.resource}" not found\`);
+  return createListLoader(dataProvider, resource)(event);
+}) satisfies PageServerLoad;
+
+export const actions = {
+  delete: (event) => {
+    const resource = getResource(event.params.resource);
+    if (!resource) throw error(404, \`Resource "\${event.params.resource}" not found\`);
+    return createCrudActions(dataProvider, resource).delete(event);
+  },
+  batchDelete: (event) => {
+    const resource = getResource(event.params.resource);
+    if (!resource) throw error(404, \`Resource "\${event.params.resource}" not found\`);
+    return createCrudActions(dataProvider, resource).batchDelete(event);
+  },
+} satisfies Actions;
+`,
+  "src/routes/lite/[resource]/+page.svelte": `<script lang="ts">
+  import { LiteListPage } from '@svadmin/lite';
+  import type { PageProps } from './$types';
+
+  let { data }: PageProps = $props();
+</script>
+
+<LiteListPage {...data} basePath="/lite" />
+`,
+  "src/routes/lite/[resource]/create/+page.server.ts": `import { error, redirect } from '@sveltejs/kit';
+import { createCrudActions } from '@svadmin/lite';
+import { dataProvider, getResource } from '$lib/svadmin-lite';
+import type { Actions, PageServerLoad } from './$types';
+
+export const load = (({ params }) => {
+  const resource = getResource(params.resource);
+  if (!resource) throw error(404, \`Resource "\${params.resource}" not found\`);
+  return { resource };
+}) satisfies PageServerLoad;
+
+export const actions = {
+  create: async (event) => {
+    const resource = getResource(event.params.resource);
+    if (!resource) throw error(404, \`Resource "\${event.params.resource}" not found\`);
+    const result = await createCrudActions(dataProvider, resource).create(event);
+    if (result && 'success' in result && result.success) {
+      throw redirect(303, \`/lite/\${resource.name}\`);
+    }
+    return result;
+  },
+} satisfies Actions;
+`,
+  "src/routes/lite/[resource]/create/+page.svelte": `<script lang="ts">
+  import { LiteCreatePage } from '@svadmin/lite';
+  import type { PageProps } from './$types';
+
+  let { data, form }: PageProps = $props();
+</script>
+
+<LiteCreatePage
+  resource={data.resource}
+  errors={form?.errors}
+  values={form?.values}
+  basePath="/lite"
+/>
+`,
+  "src/routes/lite/[resource]/show/[id]/+page.server.ts": `import { error } from '@sveltejs/kit';
+import { createDetailLoader } from '@svadmin/lite';
+import { dataProvider, getResource } from '$lib/svadmin-lite';
+import type { PageServerLoad } from './$types';
+
+export const load = ((event) => {
+  const resource = getResource(event.params.resource);
+  if (!resource) throw error(404, \`Resource "\${event.params.resource}" not found\`);
+  return createDetailLoader(dataProvider, resource)(event);
+}) satisfies PageServerLoad;
+`,
+  "src/routes/lite/[resource]/show/[id]/+page.svelte": `<script lang="ts">
+  import { LiteShowPage } from '@svadmin/lite';
+  import type { PageProps } from './$types';
+
+  let { data }: PageProps = $props();
+</script>
+
+<LiteShowPage resource={data.resource} record={data.record} basePath="/lite" />
+`,
+  "src/routes/lite/[resource]/edit/[id]/+page.server.ts": `import { error, redirect } from '@sveltejs/kit';
+import { createCrudActions, createDetailLoader } from '@svadmin/lite';
+import { dataProvider, getResource } from '$lib/svadmin-lite';
+import type { Actions, PageServerLoad } from './$types';
+
+export const load = ((event) => {
+  const resource = getResource(event.params.resource);
+  if (!resource) throw error(404, \`Resource "\${event.params.resource}" not found\`);
+  return createDetailLoader(dataProvider, resource)(event);
+}) satisfies PageServerLoad;
+
+export const actions = {
+  update: async (event) => {
+    const resource = getResource(event.params.resource);
+    if (!resource) throw error(404, \`Resource "\${event.params.resource}" not found\`);
+    const result = await createCrudActions(dataProvider, resource).update(event);
+    if (result && 'success' in result && result.success) {
+      throw redirect(303, \`/lite/\${resource.name}/show/\${event.params.id}\`);
+    }
+    return result;
+  },
+  delete: (event) => {
+    const resource = getResource(event.params.resource);
+    if (!resource) throw error(404, \`Resource "\${event.params.resource}" not found\`);
+    return createCrudActions(dataProvider, resource).delete(event);
+  },
+} satisfies Actions;
+`,
+  "src/routes/lite/[resource]/edit/[id]/+page.svelte": `<script lang="ts">
+  import { LiteEditPage } from '@svadmin/lite';
+  import type { PageProps } from './$types';
+
+  let { data, form }: PageProps = $props();
+</script>
+
+<LiteEditPage
+  resource={data.resource}
+  record={data.record}
+  errors={form?.errors}
+  basePath="/lite"
+/>
+`
+};
+function parseLiteInitArguments(args) {
+  let write = false;
+  const positional = [];
+  for (const argument of args) {
+    if (argument === "--write")
+      write = true;
+    else if (argument.startsWith("-"))
+      throw new Error(`Unknown option: ${argument}`);
+    else
+      positional.push(argument);
+  }
+  if (positional.length > 1) {
+    throw new Error(`Expected at most one project directory, received: ${positional.join(", ")}`);
+  }
+  return {
+    projectDirectory: path3.resolve(process.cwd(), positional[0] ?? "."),
+    write
+  };
+}
+function assertLiteProject(projectDirectory) {
+  if (!fs3.existsSync(projectDirectory)) {
+    throw new Error(`Project directory does not exist: ${projectDirectory}`);
+  }
+  if (!fs3.existsSync(path3.join(projectDirectory, "package.json"))) {
+    throw new Error(`Not a Node project: ${path3.join(projectDirectory, "package.json")} is missing`);
+  }
+  if (!fs3.existsSync(path3.join(projectDirectory, "src", "routes"))) {
+    throw new Error("Lite routes require a SvelteKit project with src/routes. Keep the existing SPA and add a SvelteKit Lite app alongside it.");
+  }
+  const adminModuleExists = ["ts", "js", "svelte"].some((extension) => fs3.existsSync(path3.join(projectDirectory, "src", "lib", `admin.${extension}`)));
+  if (!adminModuleExists) {
+    throw new Error("Lite routes require src/lib/admin.ts (or .js/.svelte) exporting resources and dataProvider.");
+  }
+}
+function planLiteInit(projectDirectory) {
+  assertLiteProject(projectDirectory);
+  const entries = Object.entries(GENERATED_FILES).map(([relativePath, content]) => {
+    const filePath = path3.join(projectDirectory, relativePath);
+    return { filePath, relativePath, content, exists: fs3.existsSync(filePath) };
+  });
+  return { projectDirectory, entries };
+}
+function writeLiteInit(plan) {
+  const written = [];
+  const preserved = [];
+  for (const entry of plan.entries) {
+    if (entry.exists || fs3.existsSync(entry.filePath)) {
+      preserved.push(entry.relativePath);
+      continue;
+    }
+    fs3.mkdirSync(path3.dirname(entry.filePath), { recursive: true });
+    fs3.writeFileSync(entry.filePath, entry.content);
+    written.push(entry.relativePath);
+  }
+  return { plan, written, preserved };
+}
+function liteInitCommand(args) {
+  const options = parseLiteInitArguments(args);
+  const plan = planLiteInit(options.projectDirectory);
+  console.log(`
+svadmin lite init — ${options.projectDirectory}`);
+  for (const entry of plan.entries) {
+    console.log(`  ${entry.exists ? "preserve" : "add"} ${entry.relativePath}`);
+  }
+  if (!options.write) {
+    console.log(`
+Dry run only; re-run with --write to add missing Lite routes.`);
+    return;
+  }
+  const result = writeLiteInit(plan);
+  console.log(`
+Written ${result.written.length} file(s); preserved ${result.preserved.length} existing file(s).`);
+}
+
 // src/project-maintenance.ts
 import {
   constants,
@@ -6440,10 +6781,10 @@ import {
   unlinkSync,
   writeFileSync
 } from "node:fs";
-function parseDependencyMap(candidate, path2) {
+function parseDependencyMap(candidate, path4) {
   if (candidate === undefined)
     return;
-  assertStringRecord(candidate, path2);
+  assertStringRecord(candidate, path4);
   return { ...candidate };
 }
 function parseMaintainedPackageJson(packageJsonCandidate) {
@@ -6719,15 +7060,15 @@ function writeProjectPackageJsonUpgrade(packagePath, scaffold, backupDate) {
 
 // src/index.ts
 var __filename2 = fileURLToPath(import.meta.url);
-var __dirname2 = path2.dirname(__filename2);
+var __dirname2 = path4.dirname(__filename2);
 function loadShippedScaffoldManifest() {
-  return loadScaffoldManifest(path2.join(__dirname2, "..", "scaffold-manifest.json"));
+  return loadScaffoldManifest(path4.join(__dirname2, "..", "scaffold-manifest.json"));
 }
 function projectDirectoryFromArguments(positional) {
   if (positional.length > 1) {
     throw new Error(`Expected at most one project directory, received: ${positional.join(", ")}`);
   }
-  return path2.resolve(process.cwd(), positional[0] ?? ".");
+  return path4.resolve(process.cwd(), positional[0] ?? ".");
 }
 function doctorProjectDirectory(args) {
   const unknownOption = args.find((argument) => argument.startsWith("-"));
@@ -6763,52 +7104,52 @@ function upgradeChangeMessage(change) {
   return `update ${change.packageName} from ${change.from ?? "missing"} to ${change.to}`;
 }
 function printDoctorIssue(issue) {
-  const marker = issue.kind === "drift" || issue.kind === "section" ? import_picocolors2.default.yellow("  ⚠") : import_picocolors2.default.red("  ✗");
+  const marker = issue.kind === "drift" || issue.kind === "section" ? import_picocolors3.default.yellow("  ⚠") : import_picocolors3.default.red("  ✗");
   console.log(`${marker} ${doctorIssueMessage(issue)}`);
-  console.log(import_picocolors2.default.dim(`    → ${issue.action}`));
+  console.log(import_picocolors3.default.dim(`    → ${issue.action}`));
 }
 function printDoctorReport(report, projectDirectory) {
   console.log();
-  console.log(import_picocolors2.default.bold(`svadmin doctor — ${projectDirectory}`));
+  console.log(import_picocolors3.default.bold(`svadmin doctor — ${projectDirectory}`));
   if (report.status === "clean") {
-    console.log(import_picocolors2.default.green("  ✔ Dependencies match the shipped svadmin scaffold."));
+    console.log(import_picocolors3.default.green("  ✔ Dependencies match the shipped svadmin scaffold."));
   } else {
     for (const issue of report.issues)
       printDoctorIssue(issue);
     console.log();
-    console.log(import_picocolors2.default.yellow(`  ${report.issues.length} actionable issue(s) found.`));
+    console.log(import_picocolors3.default.yellow(`  ${report.issues.length} actionable issue(s) found.`));
   }
   console.log();
 }
 function doctor(args) {
   const projectDirectory = doctorProjectDirectory(args);
-  const project = readMaintainedPackageJson(path2.join(projectDirectory, "package.json"));
+  const project = readMaintainedPackageJson(path4.join(projectDirectory, "package.json"));
   const report = doctorProjectPackageJson(project, loadShippedScaffoldManifest());
   printDoctorReport(report, projectDirectory);
   process.exitCode = report.exitCode;
 }
 function printUpgradeChanges(upgradeExecution) {
   for (const change of upgradeExecution.plan.changes) {
-    console.log(`  ${import_picocolors2.default.cyan("•")} ${upgradeChangeMessage(change)}`);
+    console.log(`  ${import_picocolors3.default.cyan("•")} ${upgradeChangeMessage(change)}`);
   }
   console.log();
 }
 function printUpgradeOutcome(upgradeExecution, packagePath) {
   if (upgradeExecution.wrote) {
-    console.log(import_picocolors2.default.green("  ✔ package.json updated."));
-    console.log(`  Backup: ${import_picocolors2.default.cyan(upgradeExecution.backupPath)}`);
-    console.log(`  Restore by copying the backup over: ${import_picocolors2.default.cyan(packagePath)}`);
+    console.log(import_picocolors3.default.green("  ✔ package.json updated."));
+    console.log(`  Backup: ${import_picocolors3.default.cyan(upgradeExecution.backupPath)}`);
+    console.log(`  Restore by copying the backup over: ${import_picocolors3.default.cyan(packagePath)}`);
   } else {
-    console.log(import_picocolors2.default.yellow("  Dry run only; package.json was not changed."));
+    console.log(import_picocolors3.default.yellow("  Dry run only; package.json was not changed."));
     console.log("  Re-run this command with --write to apply the plan.");
   }
   console.log();
 }
 function printUpgradeExecution(upgradeExecution, projectDirectory, packagePath) {
   console.log();
-  console.log(import_picocolors2.default.bold(`svadmin upgrade — ${projectDirectory}`));
+  console.log(import_picocolors3.default.bold(`svadmin upgrade — ${projectDirectory}`));
   if (upgradeExecution.plan.changes.length === 0) {
-    console.log(import_picocolors2.default.green("  ✔ package.json already matches the shipped scaffold."));
+    console.log(import_picocolors3.default.green("  ✔ package.json already matches the shipped scaffold."));
     console.log();
     return;
   }
@@ -6817,58 +7158,58 @@ function printUpgradeExecution(upgradeExecution, projectDirectory, packagePath)
 }
 function upgrade(args) {
   const commandArguments = parseUpgradeArguments(args);
-  const packagePath = path2.join(commandArguments.projectDirectory, "package.json");
+  const packagePath = path4.join(commandArguments.projectDirectory, "package.json");
   const scaffoldManifest = loadShippedScaffoldManifest();
   const upgradeExecution = commandArguments.write ? writeProjectPackageJsonUpgrade(packagePath, scaffoldManifest, new Date) : planProjectPackageFileUpgrade(packagePath, scaffoldManifest);
   printUpgradeExecution(upgradeExecution, commandArguments.projectDirectory, packagePath);
 }
 var GUIDANCE_FILES = ["DESIGN.md", "AGENTS.md"];
 function missingGuidanceFiles(projectDirectory) {
-  return GUIDANCE_FILES.filter((fileName) => !fs2.existsSync(path2.join(projectDirectory, fileName)));
+  return GUIDANCE_FILES.filter((fileName) => !fs4.existsSync(path4.join(projectDirectory, fileName)));
 }
 function printGuidancePlan(projectDirectory, missingFiles) {
   console.log();
-  console.log(import_picocolors2.default.bold(`svadmin guidance — ${projectDirectory}`));
+  console.log(import_picocolors3.default.bold(`svadmin guidance — ${projectDirectory}`));
   for (const fileName of missingFiles) {
-    console.log(`  ${import_picocolors2.default.cyan("•")} add ${fileName}`);
+    console.log(`  ${import_picocolors3.default.cyan("•")} add ${fileName}`);
   }
   console.log();
 }
 function installMissingGuidanceFiles(guidanceDirectory, projectDirectory, missingFiles) {
   for (const fileName of missingFiles) {
-    fs2.copyFileSync(path2.join(guidanceDirectory, fileName), path2.join(projectDirectory, fileName));
+    fs4.copyFileSync(path4.join(guidanceDirectory, fileName), path4.join(projectDirectory, fileName));
   }
 }
 function guidance(args) {
   const { projectDirectory, write } = parseUpgradeArguments(args);
-  const guidanceDirectory = path2.join(__dirname2, "..", "guidance");
-  if (!fs2.existsSync(projectDirectory))
+  const guidanceDirectory = path4.join(__dirname2, "..", "guidance");
+  if (!fs4.existsSync(projectDirectory))
     throw new Error(`Project directory does not exist: ${projectDirectory}`);
-  if (!fs2.existsSync(guidanceDirectory))
+  if (!fs4.existsSync(guidanceDirectory))
     throw new Error("Shipped svadmin guidance files are missing");
   const missingFiles = missingGuidanceFiles(projectDirectory);
   if (missingFiles.length === 0) {
-    console.log(import_picocolors2.default.green(`
+    console.log(import_picocolors3.default.green(`
   ✔ DESIGN.md and AGENTS.md already exist; nothing was changed.
 `));
     return;
   }
   printGuidancePlan(projectDirectory, missingFiles);
   if (!write) {
-    console.log(import_picocolors2.default.yellow(`  Dry run only; re-run with --write to add missing guidance files.
+    console.log(import_picocolors3.default.yellow(`  Dry run only; re-run with --write to add missing guidance files.
 `));
     return;
   }
   installMissingGuidanceFiles(guidanceDirectory, projectDirectory, missingFiles);
-  console.log(import_picocolors2.default.green(`  ✔ Added ${missingFiles.length} guidance file(s); existing files were preserved.`));
+  console.log(import_picocolors3.default.green(`  ✔ Added ${missingFiles.length} guidance file(s); existing files were preserved.`));
   console.log();
 }
 async function init() {
   console.log();
-  console.log(import_picocolors2.default.cyan("  ╔═══════════════════════════════════╗"));
-  console.log(import_picocolors2.default.cyan("  ║  ") + import_picocolors2.default.bold("create-svadmin") + import_picocolors2.default.cyan("                    ║"));
-  console.log(import_picocolors2.default.cyan("  ║  ") + import_picocolors2.default.dim("Headless Admin for Svelte 5") + import_picocolors2.default.cyan("    ║"));
-  console.log(import_picocolors2.default.cyan("  ╚═══════════════════════════════════╝"));
+  console.log(import_picocolors3.default.cyan("  ╔═══════════════════════════════════╗"));
+  console.log(import_picocolors3.default.cyan("  ║  ") + import_picocolors3.default.bold("create-svadmin") + import_picocolors3.default.cyan("                    ║"));
+  console.log(import_picocolors3.default.cyan("  ║  ") + import_picocolors3.default.dim("Headless Admin for Svelte 5") + import_picocolors3.default.cyan("    ║"));
+  console.log(import_picocolors3.default.cyan("  ╚═══════════════════════════════════╝"));
   console.log();
   const response = await import_prompts2.default([
     {
@@ -6879,7 +7220,7 @@ async function init() {
       validate: (value) => {
         if (!value.trim())
           return "Project name is required";
-        if (fs2.existsSync(value.trim()) && fs2.readdirSync(value.trim()).length > 0) {
+        if (fs4.existsSync(value.trim()) && fs4.readdirSync(value.trim()).length > 0) {
           return "Directory already exists and is not empty";
         }
         return true;
@@ -6917,61 +7258,61 @@ async function init() {
     }
   ]);
   if (!response.projectName) {
-    console.log(import_picocolors2.default.red(`
+    console.log(import_picocolors3.default.red(`
 Operation cancelled.
 `));
     return;
   }
-  const projectDir = path2.resolve(process.cwd(), response.projectName.trim());
-  if (!fs2.existsSync(projectDir)) {
-    fs2.mkdirSync(projectDir, { recursive: true });
+  const projectDir = path4.resolve(process.cwd(), response.projectName.trim());
+  if (!fs4.existsSync(projectDir)) {
+    fs4.mkdirSync(projectDir, { recursive: true });
   }
   console.log(`
-${import_picocolors2.default.bold("Scaffolding")} project in ${import_picocolors2.default.green(projectDir)}...
+${import_picocolors3.default.bold("Scaffolding")} project in ${import_picocolors3.default.green(projectDir)}...
 `);
-  const templateDir = path2.join(__dirname2, "..", "template");
-  const guidanceDir = path2.join(__dirname2, "..", "guidance");
+  const templateDir = path4.join(__dirname2, "..", "template");
+  const guidanceDir = path4.join(__dirname2, "..", "guidance");
   const scaffoldManifest = loadShippedScaffoldManifest();
   function copyDir(src, dest) {
-    fs2.mkdirSync(dest, { recursive: true });
-    const entries = fs2.readdirSync(src, { withFileTypes: true });
+    fs4.mkdirSync(dest, { recursive: true });
+    const entries = fs4.readdirSync(src, { withFileTypes: true });
     for (const entry of entries) {
-      const srcPath = path2.join(src, entry.name);
-      const destPath = path2.join(dest, entry.name === "_gitignore" ? ".gitignore" : entry.name);
+      const srcPath = path4.join(src, entry.name);
+      const destPath = path4.join(dest, entry.name === "_gitignore" ? ".gitignore" : entry.name);
       if (entry.isDirectory()) {
         copyDir(srcPath, destPath);
       } else {
-        fs2.copyFileSync(srcPath, destPath);
+        fs4.copyFileSync(srcPath, destPath);
       }
     }
   }
-  if (fs2.existsSync(templateDir)) {
+  if (fs4.existsSync(templateDir)) {
     copyDir(templateDir, projectDir);
-    console.log(import_picocolors2.default.green("  ✔") + " Template files copied");
+    console.log(import_picocolors3.default.green("  ✔") + " Template files copied");
   }
-  if (fs2.existsSync(guidanceDir)) {
+  if (fs4.existsSync(guidanceDir)) {
     copyDir(guidanceDir, projectDir);
-    console.log(import_picocolors2.default.green("  ✔") + " AI and design guidance copied");
+    console.log(import_picocolors3.default.green("  ✔") + " AI and design guidance copied");
   }
   const packageJson = createProjectPackageJson(scaffoldManifest, {
     projectName: response.projectName,
     dataProvider: response.dataProvider,
     authProvider: response.authProvider
   });
-  fs2.writeFileSync(path2.join(projectDir, "package.json"), `${JSON.stringify(packageJson, null, 2)}
+  fs4.writeFileSync(path4.join(projectDir, "package.json"), `${JSON.stringify(packageJson, null, 2)}
 `);
-  console.log(import_picocolors2.default.green("  ✔") + " package.json generated");
-  fs2.writeFileSync(path2.join(projectDir, ".gitignore"), `node_modules
+  console.log(import_picocolors3.default.green("  ✔") + " package.json generated");
+  fs4.writeFileSync(path4.join(projectDir, ".gitignore"), `node_modules
 dist
 .svelte-kit
 .env
 .env.local
 *.local
 `);
-  console.log(import_picocolors2.default.green("  ✔") + " .gitignore generated");
+  console.log(import_picocolors3.default.green("  ✔") + " .gitignore generated");
   const dpLabel = response.dataProvider === "simple-rest" ? "Simple REST" : response.dataProvider === "supabase" ? "Supabase" : response.dataProvider === "graphql" ? "GraphQL" : "Custom";
   const authLabel = response.authProvider === "mock" ? "Mock (demo)" : response.authProvider === "jwt" ? "JWT" : response.authProvider === "supabase" ? "Supabase Auth" : "None";
-  fs2.writeFileSync(path2.join(projectDir, "README.md"), `# ${response.projectName}
+  fs4.writeFileSync(path4.join(projectDir, "README.md"), `# ${response.projectName}
 
 Built with [svadmin](https://github.com/vibeunion/svadmin) — Headless Admin Framework for Svelte 5.
 
@@ -6989,30 +7330,30 @@ bun run dev
 - **Auth**: ${authLabel}
 - **State**: TanStack Query v6
 `);
-  console.log(import_picocolors2.default.green("  ✔") + " README.md generated");
+  console.log(import_picocolors3.default.green("  ✔") + " README.md generated");
   if (response.installDeps) {
     console.log(`
-${import_picocolors2.default.bold("Installing dependencies...")}
+${import_picocolors3.default.bold("Installing dependencies...")}
 `);
     const bunInstall = spawnSync("bun", ["install"], { cwd: projectDir, stdio: "inherit" });
     if (bunInstall.status !== 0) {
       const npmInstall = spawnSync("npm", ["install"], { cwd: projectDir, stdio: "inherit" });
       if (npmInstall.status !== 0) {
-        console.log(import_picocolors2.default.yellow("\n  ⚠ Auto-install failed. Run `bun install` or `npm install` manually."));
+        console.log(import_picocolors3.default.yellow("\n  ⚠ Auto-install failed. Run `bun install` or `npm install` manually."));
       }
     }
   }
   console.log();
-  console.log(import_picocolors2.default.green(import_picocolors2.default.bold("  ✔ Project ready!")));
+  console.log(import_picocolors3.default.green(import_picocolors3.default.bold("  ✔ Project ready!")));
   console.log();
   console.log("  Next steps:");
-  console.log(`    ${import_picocolors2.default.cyan(`cd ${response.projectName}`)}`);
+  console.log(`    ${import_picocolors3.default.cyan(`cd ${response.projectName}`)}`);
   if (!response.installDeps) {
-    console.log(`    ${import_picocolors2.default.cyan("bun install")}`);
+    console.log(`    ${import_picocolors3.default.cyan("bun install")}`);
   }
-  console.log(`    ${import_picocolors2.default.cyan("bun run dev")}`);
+  console.log(`    ${import_picocolors3.default.cyan("bun run dev")}`);
   console.log();
-  console.log(`  Docs: ${import_picocolors2.default.blue("https://github.com/vibeunion/svadmin")}`);
+  console.log(`  Docs: ${import_picocolors3.default.blue("https://github.com/vibeunion/svadmin")}`);
   console.log();
 }
 var EJECT_COMPONENTS = [
@@ -7044,64 +7385,64 @@ var EJECT_COMPONENTS = [
 ];
 async function eject(args) {
   console.log();
-  console.log(import_picocolors2.default.cyan("  svadmin eject") + import_picocolors2.default.dim(" — copy internal components for deep customization"));
+  console.log(import_picocolors3.default.cyan("  svadmin eject") + import_picocolors3.default.dim(" — copy internal components for deep customization"));
   console.log();
   const requested = args.filter((a) => !a.startsWith("-"));
   const toEject = requested.length > 0 ? requested.filter((name) => {
     if (!EJECT_COMPONENTS.includes(name)) {
-      console.log(import_picocolors2.default.yellow(`  ⚠ Unknown component: ${name} (skipped)`));
+      console.log(import_picocolors3.default.yellow(`  ⚠ Unknown component: ${name} (skipped)`));
       return false;
     }
     return true;
   }) : [...EJECT_COMPONENTS];
   if (toEject.length === 0) {
-    console.log(import_picocolors2.default.red("  No valid components to eject."));
+    console.log(import_picocolors3.default.red("  No valid components to eject."));
     console.log(`  Available: ${EJECT_COMPONENTS.join(", ")}`);
     return;
   }
   let uiSrcDir;
   try {
     const require2 = createRequire2(import.meta.url);
-    const uiPkg = path2.dirname(require2.resolve("@svadmin/ui/package.json"));
-    uiSrcDir = path2.join(uiPkg, "src", "components");
+    const uiPkg = path4.dirname(require2.resolve("@svadmin/ui/package.json"));
+    uiSrcDir = path4.join(uiPkg, "src", "components");
   } catch {
-    const nm = path2.join(process.cwd(), "node_modules", "@svadmin", "ui", "src", "components");
-    if (fs2.existsSync(nm)) {
+    const nm = path4.join(process.cwd(), "node_modules", "@svadmin", "ui", "src", "components");
+    if (fs4.existsSync(nm)) {
       uiSrcDir = nm;
     } else {
-      console.log(import_picocolors2.default.red("  ✗ Cannot find @svadmin/ui. Run `bun install` first."));
+      console.log(import_picocolors3.default.red("  ✗ Cannot find @svadmin/ui. Run `bun install` first."));
       return;
     }
   }
-  const destDir = path2.join(process.cwd(), "src", "components", "svadmin");
-  fs2.mkdirSync(destDir, { recursive: true });
+  const destDir = path4.join(process.cwd(), "src", "components", "svadmin");
+  fs4.mkdirSync(destDir, { recursive: true });
   let copied = 0;
   for (const name of toEject) {
-    const srcFile = path2.join(uiSrcDir, `${name}.svelte`);
-    const srcFileAlt = path2.join(uiSrcDir, "fields", `${name}.svelte`);
-    const src = fs2.existsSync(srcFile) ? srcFile : fs2.existsSync(srcFileAlt) ? srcFileAlt : null;
+    const srcFile = path4.join(uiSrcDir, `${name}.svelte`);
+    const srcFileAlt = path4.join(uiSrcDir, "fields", `${name}.svelte`);
+    const src = fs4.existsSync(srcFile) ? srcFile : fs4.existsSync(srcFileAlt) ? srcFileAlt : null;
     if (!src) {
-      console.log(import_picocolors2.default.yellow(`  ⚠ ${name}.svelte not found in @svadmin/ui (skipped)`));
+      console.log(import_picocolors3.default.yellow(`  ⚠ ${name}.svelte not found in @svadmin/ui (skipped)`));
       continue;
     }
-    let content = fs2.readFileSync(src, "utf-8");
+    let content = fs4.readFileSync(src, "utf-8");
     content = content.replace(/from\s+['"]\.\/ui\//g, "from '@svadmin/ui/components/ui/");
     content = content.replace(/from\s+['"]\.\/((?!ui\/)[^'"]+)['"]/g, "from './$1'");
-    const destFile = path2.join(destDir, `${name}.svelte`);
-    fs2.writeFileSync(destFile, content);
-    console.log(import_picocolors2.default.green("  ✔") + ` ${name}.svelte → src/components/svadmin/`);
+    const destFile = path4.join(destDir, `${name}.svelte`);
+    fs4.writeFileSync(destFile, content);
+    console.log(import_picocolors3.default.green("  ✔") + ` ${name}.svelte → src/components/svadmin/`);
     copied++;
   }
   console.log();
   if (copied > 0) {
-    console.log(import_picocolors2.default.green(import_picocolors2.default.bold(`  ✔ Ejected ${copied} component(s)`)));
+    console.log(import_picocolors3.default.green(import_picocolors3.default.bold(`  ✔ Ejected ${copied} component(s)`)));
     console.log();
     console.log("  Usage: import overrides in your AdminApp and pass via `components` prop:");
     console.log();
-    console.log(import_picocolors2.default.dim('    import CustomLayout from "./components/svadmin/Layout.svelte";'));
-    console.log(import_picocolors2.default.dim("    <AdminApp components={{ Layout: CustomLayout }} ... />"));
+    console.log(import_picocolors3.default.dim('    import CustomLayout from "./components/svadmin/Layout.svelte";'));
+    console.log(import_picocolors3.default.dim("    <AdminApp components={{ Layout: CustomLayout }} ... />"));
   } else {
-    console.log(import_picocolors2.default.yellow("  No components were ejected."));
+    console.log(import_picocolors3.default.yellow("  No components were ejected."));
   }
   console.log();
 }
@@ -7109,7 +7450,7 @@ var [, , subcommand, ...rest] = process.argv;
 var runCommand = (command) => {
   Promise.resolve().then(command).catch((error) => {
     const message = error instanceof Error ? error.message : String(error);
-    console.error(import_picocolors2.default.red(`
+    console.error(import_picocolors3.default.red(`
   ✗ ${message}
 `));
     process.exitCode = 2;
@@ -7125,6 +7466,16 @@ if (subcommand === "eject") {
   runCommand(() => guidance(rest));
 } else if (subcommand === "infer") {
   runCommand(() => inferCommand(rest));
+} else if (subcommand === "generate" || subcommand === "gen") {
+  runCommand(() => generateCommand(rest));
+} else if (subcommand === "lite") {
+  if (rest[0] !== "init") {
+    runCommand(() => {
+      throw new Error("Usage: create-svadmin lite init [project-directory] [--write]");
+    });
+  } else {
+    runCommand(() => liteInitCommand(rest.slice(1)));
+  }
 } else {
   runCommand(init);
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@svadmin/create",
-  "version": "0.20.0",
+  "version": "0.22.0",
   "description": "Scaffolding tool for svadmin projects",
   "type": "module",
   "bin": {
@@ -27,7 +27,7 @@
     "@types/node": "^26.4.0",
     "@types/prompts": "^2.4.9",
     "typescript": "^7.0.2",
-    "@svadmin/core": "^0.45.0"
+    "@svadmin/core": "^0.47.0"
   },
   "keywords": [
     "svadmin",

package/scaffold-manifest.json

@@ -10,8 +10,8 @@
     "check": "svelte-check --tsconfig ./tsconfig.json"
   },
   "dependencies": {
-    "@svadmin/core": "^0.45.0",
-    "@svadmin/ui": "^0.63.0",
+    "@svadmin/core": "^0.47.0",
+    "@svadmin/ui": "^0.65.0",
     "@tanstack/svelte-query": "^6.1.48",
     "highlight.js": "^11.12.0",
     "@lucide/svelte": "^1.35.0"
@@ -32,16 +32,16 @@
         "@refinedev/core": "^5.0.12"
       },
       "simple-rest": {
-        "@svadmin/simple-rest": "^0.9.18",
+        "@svadmin/simple-rest": "^0.9.20",
         "@refinedev/simple-rest": "^6.0.1"
       },
       "supabase": {
-        "@svadmin/supabase": "^0.13.0",
+        "@svadmin/supabase": "^0.13.2",
         "@supabase/supabase-js": "^2.112.4",
         "@refinedev/supabase": "^6.0.2"
       },
       "graphql": {
-        "@svadmin/graphql": "^0.9.18",
+        "@svadmin/graphql": "^0.9.20",
         "@refinedev/graphql": "^8.0.1",
         "graphql-request": "^7.4.0",
         "graphql": "^16.8.0"