@svadmin/create 0.31.0 → 0.32.0

package/dist/index.js

@@ -5024,16 +5024,35 @@ var require_picocolors = __commonJS(function(exports, module) {
 
 // src/index.ts
 var import_prompts2 = __toESM(require_prompts3(), 1);
-var import_picocolors3 = __toESM(require_picocolors(), 1);
-import fs4 from "node:fs";
-import path4 from "node:path";
+var import_picocolors4 = __toESM(require_picocolors(), 1);
+import fs5 from "node:fs";
+import path5 from "node:path";
 import { fileURLToPath } from "node:url";
 import { createRequire as createRequire2 } from "node:module";
 import { spawnSync } from "node:child_process";
 
 // src/project-manifest.ts
 import { readFileSync } from "node:fs";
-var DATA_PROVIDER_CHOICES = ["simple-rest", "supabase", "graphql", "none"];
+var DATA_PROVIDER_CHOICES = [
+  "simple-rest",
+  "supabase",
+  "graphql",
+  "rest",
+  "airtable",
+  "appwrite",
+  "directus",
+  "drizzle",
+  "elysia",
+  "firebase",
+  "hasura",
+  "medusa",
+  "nestjs-query",
+  "nestjsx-crud",
+  "pocketbase",
+  "sanity",
+  "strapi",
+  "none"
+];
 var AUTH_PROVIDER_CHOICES = ["mock", "jwt", "supabase", "none"];
 function assertJsonObject(candidate, path) {
   if (candidate === null || typeof candidate !== "object" || Array.isArray(candidate)) {
@@ -6898,11 +6917,695 @@ Dry run only; re-run with --write to add missing Lite routes.`);
 Written ${result.written.length} file(s); preserved ${result.preserved.length} existing file(s).`);
 }
 
+// src/init-arguments.ts
+var PRESET_NAMES = ["supabase", "rest", "graphql"];
+var INIT_PRESETS = {
+  supabase: { dataProvider: "supabase", authProvider: "supabase" },
+  rest: { dataProvider: "simple-rest", authProvider: "jwt" },
+  graphql: { dataProvider: "graphql", authProvider: "mock" }
+};
+function isPresetName(value) {
+  return PRESET_NAMES.includes(value);
+}
+function isDataProviderChoice(value) {
+  return DATA_PROVIDER_CHOICES.includes(value);
+}
+function isAuthProviderChoice(value) {
+  return AUTH_PROVIDER_CHOICES.includes(value);
+}
+function takeValue(args, index, option) {
+  const value = args[index + 1];
+  if (value === undefined || value.startsWith("-")) {
+    throw new Error(`${option} requires a value`);
+  }
+  return value;
+}
+function parseInitArguments(args) {
+  let projectName;
+  let preset;
+  let dataProvider;
+  let authProvider;
+  let installDependencies;
+  for (let index = 0;index < args.length; index++) {
+    const argument = args[index];
+    if (argument === undefined)
+      continue;
+    if (argument === "--preset") {
+      const value = takeValue(args, index, "--preset");
+      if (!isPresetName(value)) {
+        throw new Error(`Unknown preset "${value}"; expected one of: ${PRESET_NAMES.join(", ")}`);
+      }
+      preset = value;
+      index++;
+    } else if (argument === "--data-provider") {
+      const value = takeValue(args, index, "--data-provider");
+      if (!isDataProviderChoice(value)) {
+        throw new Error(`Unknown data provider "${value}"; expected one of: ${DATA_PROVIDER_CHOICES.join(", ")}`);
+      }
+      dataProvider = value;
+      index++;
+    } else if (argument === "--auth-provider") {
+      const value = takeValue(args, index, "--auth-provider");
+      if (!isAuthProviderChoice(value)) {
+        throw new Error(`Unknown auth provider "${value}"; expected one of: ${AUTH_PROVIDER_CHOICES.join(", ")}`);
+      }
+      authProvider = value;
+      index++;
+    } else if (argument === "--install") {
+      installDependencies = true;
+    } else if (argument === "--no-install") {
+      installDependencies = false;
+    } else if (argument.startsWith("-")) {
+      throw new Error(`Unknown option: ${argument}`);
+    } else if (projectName === undefined) {
+      projectName = argument;
+    } else {
+      throw new Error(`Unexpected argument: ${argument}`);
+    }
+  }
+  const resolved = {};
+  if (projectName !== undefined)
+    resolved.projectName = projectName;
+  if (preset !== undefined)
+    resolved.preset = preset;
+  if (dataProvider !== undefined)
+    resolved.dataProvider = dataProvider;
+  if (authProvider !== undefined)
+    resolved.authProvider = authProvider;
+  if (installDependencies !== undefined)
+    resolved.installDependencies = installDependencies;
+  return resolved;
+}
+function resolvePresetSelections(args) {
+  const preset = args.preset === undefined ? undefined : INIT_PRESETS[args.preset];
+  const dataProvider = args.dataProvider ?? preset?.dataProvider;
+  const authProvider = args.authProvider ?? preset?.authProvider;
+  if (dataProvider === undefined || authProvider === undefined)
+    return;
+  return { dataProvider, authProvider };
+}
+
+// src/add-command.ts
+var import_picocolors3 = __toESM(require_picocolors(), 1);
+import fs4 from "node:fs";
+import path4 from "node:path";
+
+// src/scaffold-platform.ts
+import { existsSync, readFileSync as readFileSync2 } from "node:fs";
+import { join } from "node:path";
+var SCAFFOLD_CONFIG_PATH = "src/svadmin.config.ts";
+var ADMIN_AI_MANIFEST_FILENAME = "svadmin.ai.json";
+var ADMIN_SCHEMA_FILENAME = "svadmin.schema.json";
+var SCAFFOLD_OFFICIAL_PROVIDERS = [
+  { name: "simple-rest", package: "@svadmin/simple-rest", capabilities: ["data", "jwt-auth", "session"], stability: "stable" },
+  { name: "supabase", package: "@svadmin/supabase", capabilities: ["data", "auth", "live", "storage", "audit"], stability: "stable" },
+  { name: "graphql", package: "@svadmin/graphql", capabilities: ["data", "graphql"], stability: "stable" },
+  { name: "rest", package: "@svadmin/rest", capabilities: ["data", "rest", "custom-endpoints"], stability: "experimental" },
+  { name: "airtable", package: "@svadmin/airtable", capabilities: ["data"], stability: "stable" },
+  { name: "appwrite", package: "@svadmin/appwrite", capabilities: ["data", "auth", "storage", "live"], stability: "stable" },
+  { name: "directus", package: "@svadmin/directus", capabilities: ["data", "auth"], stability: "stable" },
+  { name: "drizzle", package: "@svadmin/drizzle", capabilities: ["server-data", "migrations"], stability: "stable" },
+  { name: "elysia", package: "@svadmin/elysia", capabilities: ["server-data"], stability: "stable" },
+  { name: "firebase", package: "@svadmin/firebase", capabilities: ["data", "auth", "storage", "live"], stability: "stable" },
+  { name: "hasura", package: "@svadmin/hasura", capabilities: ["data", "graphql", "live"], stability: "stable" },
+  { name: "medusa", package: "@svadmin/medusa", capabilities: ["data", "auth"], stability: "stable" },
+  { name: "nestjs-query", package: "@svadmin/nestjs-query", capabilities: ["data", "graphql"], stability: "stable" },
+  { name: "nestjsx-crud", package: "@svadmin/nestjsx-crud", capabilities: ["data"], stability: "stable" },
+  { name: "pocketbase", package: "@svadmin/pocketbase", capabilities: ["data", "auth", "storage", "live"], stability: "stable" },
+  { name: "sanity", package: "@svadmin/sanity", capabilities: ["data", "live"], stability: "stable" },
+  { name: "strapi", package: "@svadmin/strapi", capabilities: ["data", "auth"], stability: "stable" },
+  { name: "refine-adapter", package: "@svadmin/refine-adapter", capabilities: ["adapter", "refine-bridge"], stability: "stable" },
+  { name: "sso", package: "@svadmin/sso", capabilities: ["auth", "oidc", "oauth2"], stability: "stable" },
+  { name: "sveltekit", package: "@svadmin/sveltekit", capabilities: ["router", "ssr"], stability: "stable" }
+];
+var SCAFFOLD_DATA_PROVIDERS = {
+  "simple-rest": {
+    package: "@svadmin/simple-rest",
+    capabilities: ["data", "filter", "sort", "pagination"]
+  },
+  supabase: {
+    package: "@svadmin/supabase",
+    capabilities: ["data", "auth", "live", "storage"]
+  },
+  graphql: {
+    package: "@svadmin/graphql",
+    capabilities: ["data", "graphql"]
+  },
+  rest: {
+    package: "@svadmin/rest",
+    capabilities: ["data", "rest", "custom-endpoints"]
+  },
+  airtable: {
+    package: "@svadmin/airtable",
+    capabilities: ["data"]
+  },
+  appwrite: {
+    package: "@svadmin/appwrite",
+    capabilities: ["data", "auth", "storage", "live"]
+  },
+  directus: {
+    package: "@svadmin/directus",
+    capabilities: ["data", "auth"]
+  },
+  drizzle: {
+    package: "@svadmin/drizzle",
+    capabilities: ["server-data", "migrations"]
+  },
+  elysia: {
+    package: "@svadmin/elysia",
+    capabilities: ["server-data"]
+  },
+  firebase: {
+    package: "@svadmin/firebase",
+    capabilities: ["data", "auth", "storage", "live"]
+  },
+  hasura: {
+    package: "@svadmin/hasura",
+    capabilities: ["data", "graphql", "live"]
+  },
+  medusa: {
+    package: "@svadmin/medusa",
+    capabilities: ["data", "auth"]
+  },
+  "nestjs-query": {
+    package: "@svadmin/nestjs-query",
+    capabilities: ["data", "graphql"]
+  },
+  "nestjsx-crud": {
+    package: "@svadmin/nestjsx-crud",
+    capabilities: ["data"]
+  },
+  pocketbase: {
+    package: "@svadmin/pocketbase",
+    capabilities: ["data", "auth", "storage", "live"]
+  },
+  sanity: {
+    package: "@svadmin/sanity",
+    capabilities: ["data", "live"]
+  },
+  strapi: {
+    package: "@svadmin/strapi",
+    capabilities: ["data", "auth"]
+  },
+  none: {
+    package: null,
+    capabilities: ["custom"]
+  }
+};
+var SCAFFOLD_AUTH_PROVIDERS = {
+  mock: {
+    package: null,
+    capabilities: ["demo-auth"]
+  },
+  jwt: {
+    package: "@svadmin/simple-rest",
+    capabilities: ["jwt-auth", "session"]
+  },
+  supabase: {
+    package: "@svadmin/supabase",
+    capabilities: ["auth", "session"]
+  },
+  none: {
+    package: null,
+    capabilities: []
+  }
+};
+var SCAFFOLD_RESOURCES = [
+  {
+    name: "posts",
+    label: "Posts",
+    operations: ["list", "create", "edit", "show", "delete"],
+    fields: [
+      { key: "id", label: "ID", type: "number", required: true },
+      { key: "title", label: "Title", type: "text", required: false },
+      { key: "body", label: "Body", type: "textarea", required: false },
+      { key: "userId", label: "Author", type: "number", required: false }
+    ]
+  },
+  {
+    name: "users",
+    label: "Users",
+    operations: ["list", "show"],
+    fields: [
+      { key: "id", label: "ID", type: "number", required: true },
+      { key: "name", label: "Name", type: "text", required: false },
+      { key: "username", label: "Username", type: "text", required: false },
+      { key: "email", label: "Email", type: "email", required: false },
+      { key: "phone", label: "Phone", type: "phone", required: false },
+      { key: "website", label: "Website", type: "url", required: false }
+    ]
+  },
+  {
+    name: "comments",
+    label: "Comments",
+    operations: ["list", "create", "edit", "show", "delete"],
+    fields: [
+      { key: "id", label: "ID", type: "number", required: true },
+      { key: "postId", label: "Post", type: "number", required: false },
+      { key: "name", label: "Title", type: "text", required: false },
+      { key: "email", label: "Email", type: "email", required: false },
+      { key: "body", label: "Body", type: "textarea", required: false }
+    ]
+  },
+  {
+    name: "todos",
+    label: "Todos",
+    operations: ["list", "create", "edit", "show", "delete"],
+    fields: [
+      { key: "id", label: "ID", type: "number", required: true },
+      { key: "title", label: "Title", type: "text", required: false },
+      { key: "completed", label: "Done", type: "boolean", required: false },
+      { key: "userId", label: "User", type: "number", required: false }
+    ]
+  }
+];
+var SCAFFOLD_MIGRATION_NOTES = [
+  "Run `create-svadmin doctor` after changing providers or dependencies.",
+  "Apply dependency migrations with `create-svadmin migrate --write`.",
+  "Keep src/svadmin.config.ts and svadmin.ai.json in sync."
+];
+var SCAFFOLD_UI_COMPONENTS = [
+  ...[
+    "AdminApp",
+    "AutoTable",
+    "AutoForm",
+    "ShowPage",
+    "Layout",
+    "Sidebar",
+    "Header",
+    "CommandPalette",
+    "DataState",
+    "CreateButton",
+    "EditButton",
+    "DeleteButton",
+    "ShowButton",
+    "RefreshButton",
+    "ExportButton",
+    "ImportButton",
+    "FilterBuilder",
+    "ConfigErrorScreen",
+    "AppFooter",
+    "ResizableGrid",
+    "AreaChart",
+    "ScatterChart",
+    "HighlightText",
+    "Marquee",
+    "MediaPlayer",
+    "TopProgressBar",
+    "PhoneInput"
+  ].map((name) => ({ name, package: "@svadmin/ui", import: "@svadmin/ui" })),
+  { name: "CodeEditor", package: "@svadmin/ui", import: "@svadmin/ui/code-editor" },
+  { name: "CodeEditorPresets", package: "@svadmin/ui", import: "@svadmin/ui/code-editor/presets" },
+  { name: "JsonEditor", package: "@svadmin/ui", import: "@svadmin/ui/json-editor" },
+  { name: "QRCode", package: "@svadmin/ui", import: "@svadmin/ui/qr-code" }
+];
+var CUSTOM_DATA_PROVIDER_BODY = [
+  "const unsupported = (): never => {",
+  "  throw new Error('Configure a DataProvider in src/svadmin.config.ts before using the app.');",
+  "};",
+  "const dataProvider: DataProvider = {",
+  "  getApiUrl: () => '',",
+  "  getList: async () => unsupported(),",
+  "  getOne: async () => unsupported(),",
+  "  create: async () => unsupported(),",
+  "  update: async () => unsupported(),",
+  "  deleteOne: async () => unsupported(),",
+  "};"
+];
+function quote(value) {
+  return `'${value.replaceAll("\\", "\\\\").replaceAll("'", "\\'")}'`;
+}
+function buildSvadminConfigSource(options) {
+  const imports = new Set(["import { createProviderBundle, defineAdminConfig } from '@svadmin/app';"]);
+  const body = [];
+  let needsSupabaseClient = false;
+  switch (options.dataProvider) {
+    case "simple-rest":
+      imports.add("import { createSimpleRestDataProvider } from '@svadmin/simple-rest';");
+      body.push("const dataProvider = await createSimpleRestDataProvider('https://jsonplaceholder.typicode.com');");
+      break;
+    case "supabase":
+      imports.add("import { createSupabaseDataProvider } from '@svadmin/supabase';");
+      needsSupabaseClient = true;
+      body.push("const dataProvider = createSupabaseDataProvider(supabaseClient);");
+      break;
+    case "graphql":
+      imports.add("import { createGraphQLDataProvider } from '@svadmin/graphql';");
+      body.push("const dataProvider = await createGraphQLDataProvider('https://example.com/graphql');");
+      break;
+    case "none":
+      imports.add("import type { DataProvider } from '@svadmin/core';");
+      body.push(...CUSTOM_DATA_PROVIDER_BODY);
+      break;
+    default: {
+      const descriptor = SCAFFOLD_DATA_PROVIDERS[options.dataProvider];
+      const packageName = descriptor.package ?? "@svadmin/core";
+      imports.add("import type { DataProvider } from '@svadmin/core';");
+      body.push(`// TODO: configure ${packageName} in src/svadmin.config.ts.`, "async function createDataProvider(): Promise<DataProvider> {", `  throw new Error('Configure the ${options.dataProvider} data provider before running the app.');`, "}", "const dataProvider = await createDataProvider();");
+      break;
+    }
+  }
+  let authExpression = null;
+  switch (options.authProvider) {
+    case "mock":
+      imports.add("import { mockAuthProvider } from './providers/mockAuth';");
+      authExpression = "mockAuthProvider";
+      break;
+    case "jwt":
+      imports.add("import { createSimpleRestAuthProvider } from '@svadmin/simple-rest';");
+      body.push("const authProvider = createSimpleRestAuthProvider({ loginUrl: '/api/auth/login', identityUrl: '/api/auth/me' });");
+      authExpression = "authProvider";
+      break;
+    case "supabase":
+      imports.add("import { createSupabaseAuthProvider } from '@svadmin/supabase';");
+      needsSupabaseClient = true;
+      body.push("const authProvider = createSupabaseAuthProvider(supabaseClient);");
+      authExpression = "authProvider";
+      break;
+    case "none":
+      break;
+  }
+  if (needsSupabaseClient) {
+    imports.add("import { supabaseClient } from './providers/supabase';");
+    body.unshift("if (!supabaseClient) throw new Error('Supabase is not configured: set VITE_SUPABASE_URL and VITE_SUPABASE_ANON_KEY.');");
+  }
+  imports.add("import { resources } from './resources';");
+  const providerEntries = ["    dataProvider,", ...authExpression === null ? [] : [`    authProvider: ${authExpression},`]].join(`
+`);
+  return [
+    "/**",
+    " * svadmin application entrypoint — the first file AI tooling should read.",
+    " * Generated by create-svadmin; edit freely.",
+    " */",
+    [...imports].join(`
+`),
+    "",
+    body.join(`
+`),
+    "",
+    "export default defineAdminConfig({",
+    `  name: ${quote(options.projectName)},`,
+    "  providers: createProviderBundle({",
+    providerEntries,
+    "  }),",
+    "  resources,",
+    "});",
+    ""
+  ].join(`
+`);
+}
+function buildAdminAiManifest(options) {
+  return {
+    $schema: `./${ADMIN_SCHEMA_FILENAME}`,
+    version: 1,
+    project: {
+      name: options.projectName,
+      entrypoints: {
+        config: SCAFFOLD_CONFIG_PATH,
+        manifest: ADMIN_AI_MANIFEST_FILENAME
+      },
+      commands: {
+        dev: "bun run dev",
+        build: "bun run build",
+        preview: "bun run preview",
+        check: "bun run check"
+      },
+      testCommand: null,
+      forbiddenImports: ["@svadmin/ui/src", "@svadmin/core/src", "@svadmin/core/dist"]
+    },
+    providers: {
+      data: { choice: options.dataProvider, ...SCAFFOLD_DATA_PROVIDERS[options.dataProvider] },
+      auth: { choice: options.authProvider, ...SCAFFOLD_AUTH_PROVIDERS[options.authProvider] }
+    },
+    resources: SCAFFOLD_RESOURCES,
+    routes: SCAFFOLD_RESOURCES.map((resource) => ({
+      resource: resource.name,
+      path: `/${resource.name}`,
+      operations: resource.operations
+    })),
+    components: SCAFFOLD_UI_COMPONENTS,
+    providerCatalog: SCAFFOLD_OFFICIAL_PROVIDERS,
+    migration: {
+      scaffoldVersion: options.scaffoldVersion ?? "0.0.0",
+      coreVersionRange: options.coreVersionRange ?? null,
+      notes: SCAFFOLD_MIGRATION_NOTES
+    },
+    plugins: [],
+    guidance: ["AGENTS.md", "DESIGN.md"]
+  };
+}
+function buildScaffoldPlatformFiles(options) {
+  return {
+    config: {
+      path: SCAFFOLD_CONFIG_PATH,
+      content: buildSvadminConfigSource(options)
+    },
+    aiManifest: {
+      path: ADMIN_AI_MANIFEST_FILENAME,
+      content: `${JSON.stringify(buildAdminAiManifest(options), null, 2)}
+`
+    },
+    schema: {
+      path: ADMIN_SCHEMA_FILENAME,
+      content: `${JSON.stringify(buildAdminSchemaJson(), null, 2)}
+`
+    }
+  };
+}
+function buildAdminSchemaJson() {
+  const provider = {
+    type: "object",
+    required: ["choice", "package", "capabilities"],
+    properties: {
+      choice: { type: "string" },
+      package: { type: ["string", "null"] },
+      capabilities: { type: "array", items: { type: "string" } }
+    }
+  };
+  const field = {
+    type: "object",
+    required: ["key", "label", "type", "required"],
+    properties: {
+      key: { type: "string" },
+      label: { type: "string" },
+      type: { type: "string" },
+      required: { type: "boolean" }
+    }
+  };
+  const resource = {
+    type: "object",
+    required: ["name", "label", "fields", "operations"],
+    properties: {
+      name: { type: "string" },
+      label: { type: "string" },
+      fields: { type: "array", items: field },
+      operations: { type: "array", items: { type: "string" } }
+    }
+  };
+  return {
+    $schema: "https://json-schema.org/draft/2020-12/schema",
+    $id: "https://svadmin.dev/schemas/svadmin.ai.json",
+    title: "svadmin AI manifest",
+    type: "object",
+    required: ["version", "project", "providers", "resources"],
+    properties: {
+      $schema: { type: "string" },
+      version: { const: 1 },
+      project: {
+        type: "object",
+        required: ["name", "entrypoints", "commands"],
+        properties: {
+          name: { type: "string" },
+          entrypoints: {
+            type: "object",
+            required: ["config", "manifest"],
+            properties: { config: { type: "string" }, manifest: { type: "string" } }
+          },
+          commands: { type: "object", additionalProperties: { type: "string" } },
+          testCommand: { type: ["string", "null"] },
+          forbiddenImports: { type: "array", items: { type: "string" } }
+        }
+      },
+      providers: {
+        type: "object",
+        required: ["data", "auth"],
+        properties: { data: provider, auth: provider }
+      },
+      resources: { type: "array", items: resource },
+      routes: {
+        type: "array",
+        items: {
+          type: "object",
+          required: ["resource", "path", "operations"],
+          properties: {
+            resource: { type: "string" },
+            path: { type: "string" },
+            operations: { type: "array", items: { type: "string" } }
+          }
+        }
+      },
+      components: {
+        type: "array",
+        items: {
+          type: "object",
+          required: ["name", "package", "import"],
+          properties: {
+            name: { type: "string" },
+            package: { type: "string" },
+            import: { type: "string" }
+          }
+        }
+      },
+      providerCatalog: {
+        type: "array",
+        items: {
+          type: "object",
+          required: ["name", "package", "capabilities", "stability"],
+          properties: {
+            name: { type: "string" },
+            package: { type: "string" },
+            capabilities: { type: "array", items: { type: "string" } },
+            stability: { type: "string" }
+          }
+        }
+      },
+      migration: {
+        type: "object",
+        required: ["scaffoldVersion", "notes"],
+        properties: {
+          scaffoldVersion: { type: "string" },
+          coreVersionRange: { type: ["string", "null"] },
+          notes: { type: "array", items: { type: "string" } }
+        }
+      },
+      plugins: { type: "array" },
+      guidance: { type: "array", items: { type: "string" } }
+    }
+  };
+}
+function parseManifest(path) {
+  let parsed;
+  try {
+    parsed = JSON.parse(readFileSync2(path, "utf8"));
+  } catch {
+    return {
+      issue: {
+        path,
+        message: "svadmin.ai.json is not valid JSON",
+        action: "regenerate it or run `create-svadmin doctor` after fixing the file"
+      }
+    };
+  }
+  if (typeof parsed !== "object" || parsed === null || Reflect.get(parsed, "version") !== 1) {
+    return {
+      issue: {
+        path,
+        message: "svadmin.ai.json must be an object with version 1",
+        action: "regenerate the project platform files"
+      }
+    };
+  }
+  return { manifest: parsed };
+}
+function declaredDependencies(project) {
+  return new Set([
+    ...Object.keys(project.dependencies ?? {}),
+    ...Object.keys(project.devDependencies ?? {})
+  ]);
+}
+function readInstalledProviderMeta(projectDirectory, packageName) {
+  const manifestPath = join(projectDirectory, "node_modules", ...packageName.split("/"), "package.json");
+  if (!existsSync(manifestPath))
+    return null;
+  try {
+    const parsed = JSON.parse(readFileSync2(manifestPath, "utf8"));
+    const meta = typeof parsed === "object" && parsed !== null ? Reflect.get(parsed, "svadmin") : undefined;
+    return typeof meta === "object" && meta !== null ? meta : null;
+  } catch {
+    return null;
+  }
+}
+function firstVersion(range) {
+  const match = /(\d+)\.(\d+)\.(\d+)/u.exec(range);
+  if (match === null)
+    return null;
+  return [Number(match[1]), Number(match[2]), Number(match[3])];
+}
+function coreRangesCompatible(projectRange, moduleRange) {
+  const project = firstVersion(projectRange);
+  const module = firstVersion(moduleRange);
+  if (project === null || module === null)
+    return true;
+  if (project[0] !== module[0])
+    return false;
+  return project[0] !== 0 || project[1] === module[1];
+}
+function checkAdminManifest(projectDirectory, project) {
+  const configPath = join(projectDirectory, SCAFFOLD_CONFIG_PATH);
+  if (!existsSync(configPath))
+    return [];
+  const manifestPath = join(projectDirectory, ADMIN_AI_MANIFEST_FILENAME);
+  if (!existsSync(manifestPath)) {
+    return [{
+      path: manifestPath,
+      message: `${SCAFFOLD_CONFIG_PATH} exists but ${ADMIN_AI_MANIFEST_FILENAME} is missing`,
+      action: "regenerate the platform files so AI tooling has a stable entrypoint"
+    }];
+  }
+  const { manifest, issue } = parseManifest(manifestPath);
+  if (issue !== undefined)
+    return [issue];
+  if (manifest === undefined)
+    return [];
+  const issues = [];
+  if (!existsSync(join(projectDirectory, ADMIN_SCHEMA_FILENAME))) {
+    issues.push({
+      path: join(projectDirectory, ADMIN_SCHEMA_FILENAME),
+      message: `${ADMIN_AI_MANIFEST_FILENAME} is present but ${ADMIN_SCHEMA_FILENAME} is missing`,
+      action: "regenerate the platform files so editors can validate the manifest"
+    });
+  }
+  const dependencies = declaredDependencies(project);
+  const providerPackages = [
+    manifest.providers.data.package,
+    manifest.providers.auth.package
+  ].filter((name) => name !== null);
+  const declaredCore = project.dependencies?.["@svadmin/core"] ?? project.devDependencies?.["@svadmin/core"];
+  for (const packageName of new Set(providerPackages)) {
+    if (!dependencies.has(packageName)) {
+      issues.push({
+        path: manifestPath,
+        message: `svadmin.ai.json declares provider "${packageName}" but package.json does not depend on it`,
+        action: `add ${packageName} to package.json or update svadmin.ai.json`
+      });
+      continue;
+    }
+    const meta = readInstalledProviderMeta(projectDirectory, packageName);
+    if (meta === null)
+      continue;
+    if (meta.capabilities !== undefined && !Array.isArray(meta.capabilities)) {
+      issues.push({
+        path: manifestPath,
+        message: `${packageName} declares a non-array svadmin.capabilities`,
+        action: "fix the provider package metadata"
+      });
+    }
+    if (typeof meta.core === "string" && declaredCore !== undefined && !coreRangesCompatible(declaredCore, meta.core)) {
+      issues.push({
+        path: manifestPath,
+        message: `${packageName} declares @svadmin/core ${meta.core}, incompatible with the project range ${declaredCore}`,
+        action: `align @svadmin/core with ${meta.core} or upgrade ${packageName}`
+      });
+    }
+  }
+  return issues;
+}
+
 // src/project-maintenance.ts
 import {
   constants,
   copyFileSync,
-  readFileSync as readFileSync2,
+  readFileSync as readFileSync3,
   renameSync,
   unlinkSync,
   writeFileSync
@@ -6925,7 +7628,7 @@ function parseMaintainedPackageJson(packageJsonCandidate) {
   return packageJson;
 }
 function readMaintainedPackageJson(packagePath) {
-  const parsed = JSON.parse(readFileSync2(packagePath, "utf8"));
+  const parsed = JSON.parse(readFileSync3(packagePath, "utf8"));
   return parseMaintainedPackageJson(parsed);
 }
 function allProjectDependencies(project) {
@@ -7186,17 +7889,269 @@ function writeProjectPackageJsonUpgrade(packagePath, scaffold, backupDate) {
   return { wrote: true, backupPath, plan: plannedUpgrade.plan };
 }
 
+// src/add-command.ts
+var RESOURCE_NAME_PATTERN = /^[a-z][a-z0-9_]*$/;
+function parseAddArguments(args) {
+  const [kind, ...rest] = args;
+  if (kind !== "resource" && kind !== "provider" && kind !== "auth") {
+    throw new Error("Usage: create-svadmin add <resource|provider|auth> <name> [--project-dir <dir>] [--write]");
+  }
+  let projectDirectory = process.cwd();
+  let write = false;
+  const positional = [];
+  for (let index = 0;index < rest.length; index++) {
+    const argument = rest[index];
+    if (argument === "--write") {
+      write = true;
+    } else if (argument === "--project-dir") {
+      const value = rest[index + 1];
+      if (value === undefined)
+        throw new Error("--project-dir requires a value");
+      projectDirectory = path4.resolve(process.cwd(), value);
+      index++;
+    } else if (argument === undefined) {
+      continue;
+    } else if (argument.startsWith("-")) {
+      throw new Error(`Unknown option: ${argument}`);
+    } else {
+      positional.push(argument);
+    }
+  }
+  if (positional.length !== 1) {
+    throw new Error(`Expected exactly one target, received: ${positional.join(", ") || "(none)"}`);
+  }
+  return { kind, target: positional[0], projectDirectory, write };
+}
+function humanize4(name) {
+  return name.split("_").filter(Boolean).map((part) => part.charAt(0).toUpperCase() + part.slice(1)).join(" ");
+}
+function assertProject(projectDirectory) {
+  if (!fs4.existsSync(path4.join(projectDirectory, "package.json"))) {
+    throw new Error(`Not a Node project: ${path4.join(projectDirectory, "package.json")} is missing`);
+  }
+}
+function resourceFileContents(name) {
+  const label = humanize4(name);
+  return {
+    index: `export { ${name}Resource, ${name}Definition } from './${name}.resource';
+`,
+    resource: `import { Type } from '@sinclair/typebox';
+import { defineResource, type AdminResourceDefinition } from '@svadmin/core';
+
+/**
+ * ${label} runtime contract.
+ * Extend the create/update schemas before enabling writes; empty object schemas
+ * keep writes disabled until fields are declared.
+ */
+export const ${name}Resource = defineResource('${name}', {
+  record: Type.Object({
+    id: Type.String(),
+  }),
+  create: Type.Object({}),
+  update: Type.Object({}),
+});
+
+/** Menu and field metadata consumed by the resource registry. */
+export const ${name}Definition: AdminResourceDefinition = {
+  name: '${name}',
+  label: '${label}',
+  icon: 'file',
+  fields: [
+    { key: 'id', label: 'ID', type: 'text', showInForm: false },
+  ],
+  contract: ${name}Resource,
+};
+`
+  };
+}
+function planAddResource(projectDirectory, resourceName) {
+  assertProject(projectDirectory);
+  if (!RESOURCE_NAME_PATTERN.test(resourceName)) {
+    throw new Error(`Invalid resource name "${resourceName}"; use lowercase letters, digits, and underscores (for example "order_items")`);
+  }
+  const files = resourceFileContents(resourceName);
+  const base = path4.posix.join("src", "features", resourceName);
+  const contents = {
+    [`${base}/index.ts`]: files.index,
+    [`${base}/${resourceName}.resource.ts`]: files.resource
+  };
+  const entries = Object.entries(contents).map(([relativePath, content]) => ({
+    relativePath,
+    content,
+    filePath: path4.join(projectDirectory, relativePath),
+    exists: fs4.existsSync(path4.join(projectDirectory, relativePath))
+  }));
+  return {
+    projectDirectory,
+    resourceName,
+    entries,
+    registrationHint: `Register it in src/resources.ts:
+  import { ${resourceName}Definition } from './features/${resourceName}';
+  // then add ${resourceName}Definition to the resources array`
+  };
+}
+function writeAddResource(plan) {
+  const written = [];
+  const preserved = [];
+  for (const entry of plan.entries) {
+    if (entry.exists || fs4.existsSync(entry.filePath)) {
+      preserved.push(entry.relativePath);
+      continue;
+    }
+    fs4.mkdirSync(path4.dirname(entry.filePath), { recursive: true });
+    fs4.writeFileSync(entry.filePath, entry.content);
+    written.push(entry.relativePath);
+  }
+  return { written, preserved };
+}
+function providerPackages(scaffold, kind, choice) {
+  const packs = kind === "provider" ? scaffold.svadmin.dataProviders[choice] : scaffold.svadmin.authProviders[choice];
+  const packages = new Map;
+  for (const packName of packs) {
+    const pack = scaffold.svadmin.dependencyPacks[packName];
+    if (pack === undefined)
+      throw new Error(`Unknown dependency pack: ${packName}`);
+    for (const [packageName, version] of Object.entries(pack))
+      packages.set(packageName, version);
+  }
+  return [...packages].map(([packageName, version]) => ({ packageName, version }));
+}
+function readManifest(manifestPath) {
+  if (!fs4.existsSync(manifestPath))
+    return null;
+  try {
+    const parsed = JSON.parse(fs4.readFileSync(manifestPath, "utf8"));
+    if (typeof parsed !== "object" || parsed === null || Reflect.get(parsed, "version") !== 1)
+      return null;
+    return parsed;
+  } catch {
+    return null;
+  }
+}
+function planAddProvider(projectDirectory, scaffold, kind, choice) {
+  assertProject(projectDirectory);
+  const validChoices = kind === "provider" ? DATA_PROVIDER_CHOICES : AUTH_PROVIDER_CHOICES;
+  if (!validChoices.includes(choice)) {
+    throw new Error(`Unknown ${kind} "${choice}"; expected one of: ${validChoices.join(", ")}`);
+  }
+  const packageJsonPath = path4.join(projectDirectory, "package.json");
+  const project = readMaintainedPackageJson(packageJsonPath);
+  const dependencies = { ...project.dependencies ?? {} };
+  const devDependencies = { ...project.devDependencies ?? {} };
+  const addedDependencies = [];
+  for (const dependency of providerPackages(scaffold, kind, choice)) {
+    if (dependencies[dependency.packageName] === undefined && devDependencies[dependency.packageName] === undefined) {
+      dependencies[dependency.packageName] = dependency.version;
+      addedDependencies.push(dependency);
+    }
+  }
+  const updatedPackageJson = { ...project, dependencies, devDependencies };
+  const manifestPath = path4.join(projectDirectory, ADMIN_AI_MANIFEST_FILENAME);
+  const manifest = readManifest(manifestPath);
+  const descriptor = kind === "provider" ? SCAFFOLD_DATA_PROVIDERS[choice] : SCAFFOLD_AUTH_PROVIDERS[choice];
+  const updatedManifest = manifest === null ? null : kind === "provider" ? { ...manifest, providers: { ...manifest.providers, data: { choice, ...descriptor } } } : { ...manifest, providers: { ...manifest.providers, auth: { choice, ...descriptor } } };
+  return {
+    projectDirectory,
+    kind,
+    choice,
+    packageJsonPath,
+    updatedPackageJson: addedDependencies.length === 0 ? null : updatedPackageJson,
+    addedDependencies,
+    manifestPath,
+    updatedManifest: manifest === null ? null : updatedManifest
+  };
+}
+function writeAddProvider(plan) {
+  const written = [];
+  const preserved = [];
+  if (plan.updatedPackageJson !== null) {
+    fs4.writeFileSync(plan.packageJsonPath, `${JSON.stringify(plan.updatedPackageJson, null, 2)}
+`);
+    written.push("package.json");
+  } else {
+    preserved.push("package.json");
+  }
+  if (plan.updatedManifest !== null && fs4.existsSync(plan.manifestPath)) {
+    fs4.writeFileSync(plan.manifestPath, `${JSON.stringify(plan.updatedManifest, null, 2)}
+`);
+    written.push(ADMIN_AI_MANIFEST_FILENAME);
+  }
+  return { written, preserved };
+}
+function printAddResult(wrote, result, hint) {
+  if (wrote) {
+    if (result.written.length > 0) {
+      console.log(import_picocolors3.default.green(`  ✔ wrote ${result.written.join(", ")}`));
+    }
+    if (result.preserved.length > 0) {
+      console.log(import_picocolors3.default.dim(`  • preserved ${result.preserved.join(", ")}`));
+    }
+  }
+  if (hint !== undefined)
+    console.log(`
+${hint}`);
+  console.log();
+}
+function addCommand(args, scaffold) {
+  const options = parseAddArguments(args);
+  console.log(`
+svadmin add ${options.kind} ${options.target} — ${options.projectDirectory}`);
+  if (options.kind === "resource") {
+    const plan = planAddResource(options.projectDirectory, options.target);
+    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 create missing files.`);
+      printAddResult(false, { written: [], preserved: [] }, plan.registrationHint);
+      return;
+    }
+    printAddResult(true, writeAddResource(plan), plan.registrationHint);
+    return;
+  }
+  const plan = planAddProvider(options.projectDirectory, scaffold, options.kind, options.target);
+  if (plan.addedDependencies.length === 0) {
+    console.log(import_picocolors3.default.green("  ✔ dependencies already present; nothing to add."));
+  } else {
+    for (const dependency of plan.addedDependencies) {
+      console.log(`  add ${dependency.packageName}@${dependency.version}`);
+    }
+  }
+  if (plan.updatedManifest !== null) {
+    console.log(`  update ${ADMIN_AI_MANIFEST_FILENAME} -> ${options.kind}: ${options.target}`);
+  }
+  if (!options.write) {
+    console.log(`
+Dry run only; re-run with --write to update package.json and the AI manifest.`);
+    console.log(import_picocolors3.default.dim("  Update src/svadmin.config.ts to wire the new provider."));
+    console.log();
+    return;
+  }
+  printAddResult(true, writeAddProvider(plan), "Update src/svadmin.config.ts to wire the new provider.");
+}
+
 // src/index.ts
 var __filename2 = fileURLToPath(import.meta.url);
-var __dirname2 = path4.dirname(__filename2);
+var __dirname2 = path5.dirname(__filename2);
 function loadShippedScaffoldManifest() {
-  return loadScaffoldManifest(path4.join(__dirname2, "..", "scaffold-manifest.json"));
+  return loadScaffoldManifest(path5.join(__dirname2, "..", "scaffold-manifest.json"));
+}
+function shippedCliVersion() {
+  try {
+    const raw = fs5.readFileSync(path5.join(__dirname2, "..", "package.json"), "utf8");
+    const parsed = JSON.parse(raw);
+    const version = typeof parsed === "object" && parsed !== null ? Reflect.get(parsed, "version") : undefined;
+    return typeof version === "string" ? version : "0.0.0";
+  } catch {
+    return "0.0.0";
+  }
 }
 function projectDirectoryFromArguments(positional) {
   if (positional.length > 1) {
     throw new Error(`Expected at most one project directory, received: ${positional.join(", ")}`);
   }
-  return path4.resolve(process.cwd(), positional[0] ?? ".");
+  return path5.resolve(process.cwd(), positional[0] ?? ".");
 }
 function doctorProjectDirectory(args) {
   const unknownOption = args.find((argument) => argument.startsWith("-"));
@@ -7232,52 +8187,61 @@ 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_picocolors3.default.yellow("  ⚠") : import_picocolors3.default.red("  ✗");
+  const marker = issue.kind === "drift" || issue.kind === "section" ? import_picocolors4.default.yellow("  ⚠") : import_picocolors4.default.red("  ✗");
   console.log(`${marker} ${doctorIssueMessage(issue)}`);
-  console.log(import_picocolors3.default.dim(`    → ${issue.action}`));
+  console.log(import_picocolors4.default.dim(`    → ${issue.action}`));
 }
 function printDoctorReport(report, projectDirectory) {
   console.log();
-  console.log(import_picocolors3.default.bold(`svadmin doctor — ${projectDirectory}`));
+  console.log(import_picocolors4.default.bold(`svadmin doctor — ${projectDirectory}`));
   if (report.status === "clean") {
-    console.log(import_picocolors3.default.green("  ✔ Dependencies match the shipped svadmin scaffold."));
+    console.log(import_picocolors4.default.green("  ✔ Dependencies match the shipped svadmin scaffold."));
   } else {
     for (const issue of report.issues)
       printDoctorIssue(issue);
     console.log();
-    console.log(import_picocolors3.default.yellow(`  ${report.issues.length} actionable issue(s) found.`));
+    console.log(import_picocolors4.default.yellow(`  ${report.issues.length} actionable issue(s) found.`));
   }
   console.log();
 }
 function doctor(args) {
   const projectDirectory = doctorProjectDirectory(args);
-  const project = readMaintainedPackageJson(path4.join(projectDirectory, "package.json"));
+  const project = readMaintainedPackageJson(path5.join(projectDirectory, "package.json"));
   const report = doctorProjectPackageJson(project, loadShippedScaffoldManifest());
   printDoctorReport(report, projectDirectory);
-  process.exitCode = report.exitCode;
+  const manifestIssues = checkAdminManifest(projectDirectory, project);
+  if (manifestIssues.length > 0) {
+    console.log(import_picocolors4.default.bold("  Platform entrypoints:"));
+    for (const issue of manifestIssues) {
+      console.log(import_picocolors4.default.yellow(`  ⚠ ${issue.message}`));
+      console.log(import_picocolors4.default.dim(`    → ${issue.action}`));
+    }
+    console.log();
+  }
+  process.exitCode = report.exitCode === 0 && manifestIssues.length === 0 ? 0 : 1;
 }
 function printUpgradeChanges(upgradeExecution) {
   for (const change of upgradeExecution.plan.changes) {
-    console.log(`  ${import_picocolors3.default.cyan("•")} ${upgradeChangeMessage(change)}`);
+    console.log(`  ${import_picocolors4.default.cyan("•")} ${upgradeChangeMessage(change)}`);
   }
   console.log();
 }
 function printUpgradeOutcome(upgradeExecution, packagePath) {
   if (upgradeExecution.wrote) {
-    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)}`);
+    console.log(import_picocolors4.default.green("  ✔ package.json updated."));
+    console.log(`  Backup: ${import_picocolors4.default.cyan(upgradeExecution.backupPath)}`);
+    console.log(`  Restore by copying the backup over: ${import_picocolors4.default.cyan(packagePath)}`);
   } else {
-    console.log(import_picocolors3.default.yellow("  Dry run only; package.json was not changed."));
+    console.log(import_picocolors4.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_picocolors3.default.bold(`svadmin upgrade — ${projectDirectory}`));
+  console.log(import_picocolors4.default.bold(`svadmin upgrade — ${projectDirectory}`));
   if (upgradeExecution.plan.changes.length === 0) {
-    console.log(import_picocolors3.default.green("  ✔ package.json already matches the shipped scaffold."));
+    console.log(import_picocolors4.default.green("  ✔ package.json already matches the shipped scaffold."));
     console.log();
     return;
   }
@@ -7286,61 +8250,64 @@ function printUpgradeExecution(upgradeExecution, projectDirectory, packagePath)
 }
 function upgrade(args) {
   const commandArguments = parseUpgradeArguments(args);
-  const packagePath = path4.join(commandArguments.projectDirectory, "package.json");
+  const packagePath = path5.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) => !fs4.existsSync(path4.join(projectDirectory, fileName)));
+  return GUIDANCE_FILES.filter((fileName) => !fs5.existsSync(path5.join(projectDirectory, fileName)));
 }
 function printGuidancePlan(projectDirectory, missingFiles) {
   console.log();
-  console.log(import_picocolors3.default.bold(`svadmin guidance — ${projectDirectory}`));
+  console.log(import_picocolors4.default.bold(`svadmin guidance — ${projectDirectory}`));
   for (const fileName of missingFiles) {
-    console.log(`  ${import_picocolors3.default.cyan("•")} add ${fileName}`);
+    console.log(`  ${import_picocolors4.default.cyan("•")} add ${fileName}`);
   }
   console.log();
 }
 function installMissingGuidanceFiles(guidanceDirectory, projectDirectory, missingFiles) {
   for (const fileName of missingFiles) {
-    fs4.copyFileSync(path4.join(guidanceDirectory, fileName), path4.join(projectDirectory, fileName));
+    fs5.copyFileSync(path5.join(guidanceDirectory, fileName), path5.join(projectDirectory, fileName));
   }
 }
 function guidance(args) {
   const { projectDirectory, write } = parseUpgradeArguments(args);
-  const guidanceDirectory = path4.join(__dirname2, "..", "guidance");
-  if (!fs4.existsSync(projectDirectory))
+  const guidanceDirectory = path5.join(__dirname2, "..", "guidance");
+  if (!fs5.existsSync(projectDirectory))
     throw new Error(`Project directory does not exist: ${projectDirectory}`);
-  if (!fs4.existsSync(guidanceDirectory))
+  if (!fs5.existsSync(guidanceDirectory))
     throw new Error("Shipped svadmin guidance files are missing");
   const missingFiles = missingGuidanceFiles(projectDirectory);
   if (missingFiles.length === 0) {
-    console.log(import_picocolors3.default.green(`
+    console.log(import_picocolors4.default.green(`
   ✔ DESIGN.md and AGENTS.md already exist; nothing was changed.
 `));
     return;
   }
   printGuidancePlan(projectDirectory, missingFiles);
   if (!write) {
-    console.log(import_picocolors3.default.yellow(`  Dry run only; re-run with --write to add missing guidance files.
+    console.log(import_picocolors4.default.yellow(`  Dry run only; re-run with --write to add missing guidance files.
 `));
     return;
   }
   installMissingGuidanceFiles(guidanceDirectory, projectDirectory, missingFiles);
-  console.log(import_picocolors3.default.green(`  ✔ Added ${missingFiles.length} guidance file(s); existing files were preserved.`));
+  console.log(import_picocolors4.default.green(`  ✔ Added ${missingFiles.length} guidance file(s); existing files were preserved.`));
   console.log();
 }
-async function init() {
+async function init(args) {
   console.log();
-  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(import_picocolors4.default.cyan("  ╔═══════════════════════════════════╗"));
+  console.log(import_picocolors4.default.cyan("  ║  ") + import_picocolors4.default.bold("create-svadmin") + import_picocolors4.default.cyan("                    ║"));
+  console.log(import_picocolors4.default.cyan("  ║  ") + import_picocolors4.default.dim("Headless Admin for Svelte 5") + import_picocolors4.default.cyan("    ║"));
+  console.log(import_picocolors4.default.cyan("  ╚═══════════════════════════════════╝"));
   console.log();
-  const response = await import_prompts2.default([
-    {
+  const parsed = parseInitArguments(args);
+  const presetSelections = resolvePresetSelections(parsed);
+  const questions = [];
+  if (parsed.projectName === undefined) {
+    questions.push({
       type: "text",
       name: "projectName",
       message: "Project name:",
@@ -7348,99 +8315,130 @@ async function init() {
       validate: (value) => {
         if (!value.trim())
           return "Project name is required";
-        if (fs4.existsSync(value.trim()) && fs4.readdirSync(value.trim()).length > 0) {
+        if (fs5.existsSync(value.trim()) && fs5.readdirSync(value.trim()).length > 0) {
           return "Directory already exists and is not empty";
         }
         return true;
       }
-    },
-    {
-      type: "select",
-      name: "dataProvider",
-      message: "Data Provider:",
-      choices: [
-        { title: "Simple REST", value: "simple-rest", description: "Standard JSON APIs / JSON Server" },
-        { title: "Supabase", value: "supabase", description: "PostgreSQL Backend-as-a-Service" },
-        { title: "GraphQL", value: "graphql", description: "Generic GraphQL endpoints" },
-        { title: "Custom", value: "none", description: "Implement your own DataProvider" }
-      ],
-      initial: 0
-    },
-    {
-      type: "select",
-      name: "authProvider",
-      message: "Auth Provider:",
-      choices: [
-        { title: "Mock (Demo)", value: "mock", description: "Built-in mock for development" },
-        { title: "Simple REST JWT", value: "jwt", description: "JWT-based auth via REST API" },
-        { title: "Supabase Auth", value: "supabase", description: "Supabase authentication" },
-        { title: "None", value: "none", description: "No authentication" }
-      ],
-      initial: 0
-    },
-    {
+    });
+  }
+  if (presetSelections === undefined) {
+    if (parsed.dataProvider === undefined) {
+      questions.push({
+        type: "select",
+        name: "dataProvider",
+        message: "Data Provider:",
+        choices: [
+          { title: "Simple REST", value: "simple-rest", description: "Standard JSON APIs / JSON Server" },
+          { title: "Supabase", value: "supabase", description: "PostgreSQL Backend-as-a-Service" },
+          { title: "GraphQL", value: "graphql", description: "Generic GraphQL endpoints" },
+          { title: "Custom", value: "none", description: "Implement your own DataProvider" }
+        ],
+        initial: 0
+      });
+    }
+    if (parsed.authProvider === undefined) {
+      questions.push({
+        type: "select",
+        name: "authProvider",
+        message: "Auth Provider:",
+        choices: [
+          { title: "Mock (Demo)", value: "mock", description: "Built-in mock for development" },
+          { title: "Simple REST JWT", value: "jwt", description: "JWT-based auth via REST API" },
+          { title: "Supabase Auth", value: "supabase", description: "Supabase authentication" },
+          { title: "None", value: "none", description: "No authentication" }
+        ],
+        initial: 0
+      });
+    }
+  }
+  if (parsed.installDependencies === undefined) {
+    questions.push({
       type: "confirm",
       name: "installDeps",
       message: "Install dependencies now?",
       initial: true
-    }
-  ]);
-  if (!response.projectName) {
-    console.log(import_picocolors3.default.red(`
+    });
+  }
+  const answers = questions.length > 0 ? await import_prompts2.default(questions) : {};
+  const resolvedDataProvider = parsed.dataProvider ?? presetSelections?.dataProvider ?? answers.dataProvider;
+  const resolvedAuthProvider = parsed.authProvider ?? presetSelections?.authProvider ?? answers.authProvider;
+  const projectName = parsed.projectName ?? answers.projectName;
+  if (!projectName || resolvedDataProvider === undefined || resolvedAuthProvider === undefined) {
+    console.log(import_picocolors4.default.red(`
 Operation cancelled.
 `));
     return;
   }
-  const projectDir = path4.resolve(process.cwd(), response.projectName.trim());
-  if (!fs4.existsSync(projectDir)) {
-    fs4.mkdirSync(projectDir, { recursive: true });
+  const response = {
+    projectName,
+    dataProvider: resolvedDataProvider,
+    authProvider: resolvedAuthProvider,
+    installDeps: parsed.installDependencies ?? answers.installDeps ?? true
+  };
+  const projectDir = path5.resolve(process.cwd(), response.projectName.trim());
+  if (!fs5.existsSync(projectDir)) {
+    fs5.mkdirSync(projectDir, { recursive: true });
   }
   console.log(`
-${import_picocolors3.default.bold("Scaffolding")} project in ${import_picocolors3.default.green(projectDir)}...
+${import_picocolors4.default.bold("Scaffolding")} project in ${import_picocolors4.default.green(projectDir)}...
 `);
-  const templateDir = path4.join(__dirname2, "..", "template");
-  const guidanceDir = path4.join(__dirname2, "..", "guidance");
+  const templateDir = path5.join(__dirname2, "..", "template");
+  const guidanceDir = path5.join(__dirname2, "..", "guidance");
   const scaffoldManifest = loadShippedScaffoldManifest();
   function copyDir(src, dest) {
-    fs4.mkdirSync(dest, { recursive: true });
-    const entries = fs4.readdirSync(src, { withFileTypes: true });
+    fs5.mkdirSync(dest, { recursive: true });
+    const entries = fs5.readdirSync(src, { withFileTypes: true });
     for (const entry of entries) {
-      const srcPath = path4.join(src, entry.name);
-      const destPath = path4.join(dest, entry.name === "_gitignore" ? ".gitignore" : entry.name);
+      const srcPath = path5.join(src, entry.name);
+      const destPath = path5.join(dest, entry.name === "_gitignore" ? ".gitignore" : entry.name);
       if (entry.isDirectory()) {
         copyDir(srcPath, destPath);
       } else {
-        fs4.copyFileSync(srcPath, destPath);
+        fs5.copyFileSync(srcPath, destPath);
       }
     }
   }
-  if (fs4.existsSync(templateDir)) {
+  if (fs5.existsSync(templateDir)) {
     copyDir(templateDir, projectDir);
-    console.log(import_picocolors3.default.green("  ✔") + " Template files copied");
+    console.log(import_picocolors4.default.green("  ✔") + " Template files copied");
   }
-  if (fs4.existsSync(guidanceDir)) {
+  if (fs5.existsSync(guidanceDir)) {
     copyDir(guidanceDir, projectDir);
-    console.log(import_picocolors3.default.green("  ✔") + " AI and design guidance copied");
+    console.log(import_picocolors4.default.green("  ✔") + " AI and design guidance copied");
   }
+  const platformFiles = buildScaffoldPlatformFiles({
+    projectName: response.projectName.trim(),
+    dataProvider: response.dataProvider,
+    authProvider: response.authProvider,
+    scaffoldVersion: shippedCliVersion(),
+    ...scaffoldManifest.dependencies["@svadmin/core"] === undefined ? {} : { coreVersionRange: scaffoldManifest.dependencies["@svadmin/core"] }
+  });
+  for (const file of [platformFiles.config, platformFiles.aiManifest, platformFiles.schema]) {
+    const target = path5.join(projectDir, file.path);
+    fs5.mkdirSync(path5.dirname(target), { recursive: true });
+    fs5.writeFileSync(target, file.content);
+  }
+  console.log(import_picocolors4.default.green("  ✔") + " svadmin.config.ts, svadmin.ai.json and svadmin.schema.json generated");
   const packageJson = createProjectPackageJson(scaffoldManifest, {
     projectName: response.projectName,
     dataProvider: response.dataProvider,
     authProvider: response.authProvider
   });
-  fs4.writeFileSync(path4.join(projectDir, "package.json"), `${JSON.stringify(packageJson, null, 2)}
+  fs5.writeFileSync(path5.join(projectDir, "package.json"), `${JSON.stringify(packageJson, null, 2)}
 `);
-  console.log(import_picocolors3.default.green("  ✔") + " package.json generated");
-  fs4.writeFileSync(path4.join(projectDir, ".gitignore"), `node_modules
+  console.log(import_picocolors4.default.green("  ✔") + " package.json generated");
+  fs5.writeFileSync(path5.join(projectDir, ".gitignore"), `node_modules
 dist
 .svelte-kit
 .env
 .env.local
 *.local
 `);
-  console.log(import_picocolors3.default.green("  ✔") + " .gitignore generated");
+  console.log(import_picocolors4.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";
-  fs4.writeFileSync(path4.join(projectDir, "README.md"), `# ${response.projectName}
+  fs5.writeFileSync(path5.join(projectDir, "README.md"), `# ${response.projectName}
 
 Built with [svadmin](https://github.com/vibeunion/svadmin) — Headless Admin Framework for Svelte 5.
 
@@ -7458,30 +8456,30 @@ bun run dev
 - **Auth**: ${authLabel}
 - **State**: TanStack Query v6
 `);
-  console.log(import_picocolors3.default.green("  ✔") + " README.md generated");
+  console.log(import_picocolors4.default.green("  ✔") + " README.md generated");
   if (response.installDeps) {
     console.log(`
-${import_picocolors3.default.bold("Installing dependencies...")}
+${import_picocolors4.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_picocolors3.default.yellow("\n  ⚠ Auto-install failed. Run `bun install` or `npm install` manually."));
+        console.log(import_picocolors4.default.yellow("\n  ⚠ Auto-install failed. Run `bun install` or `npm install` manually."));
       }
     }
   }
   console.log();
-  console.log(import_picocolors3.default.green(import_picocolors3.default.bold("  ✔ Project ready!")));
+  console.log(import_picocolors4.default.green(import_picocolors4.default.bold("  ✔ Project ready!")));
   console.log();
   console.log("  Next steps:");
-  console.log(`    ${import_picocolors3.default.cyan(`cd ${response.projectName}`)}`);
+  console.log(`    ${import_picocolors4.default.cyan(`cd ${response.projectName}`)}`);
   if (!response.installDeps) {
-    console.log(`    ${import_picocolors3.default.cyan("bun install")}`);
+    console.log(`    ${import_picocolors4.default.cyan("bun install")}`);
   }
-  console.log(`    ${import_picocolors3.default.cyan("bun run dev")}`);
+  console.log(`    ${import_picocolors4.default.cyan("bun run dev")}`);
   console.log();
-  console.log(`  Docs: ${import_picocolors3.default.blue("https://github.com/vibeunion/svadmin")}`);
+  console.log(`  Docs: ${import_picocolors4.default.blue("https://github.com/vibeunion/svadmin")}`);
   console.log();
 }
 var EJECT_COMPONENTS = [
@@ -7510,64 +8508,64 @@ var EJECT_COMPONENTS = [
 ];
 async function eject(args) {
   console.log();
-  console.log(import_picocolors3.default.cyan("  svadmin eject") + import_picocolors3.default.dim(" — copy internal components for deep customization"));
+  console.log(import_picocolors4.default.cyan("  svadmin eject") + import_picocolors4.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_picocolors3.default.yellow(`  ⚠ Unknown component: ${name} (skipped)`));
+      console.log(import_picocolors4.default.yellow(`  ⚠ Unknown component: ${name} (skipped)`));
       return false;
     }
     return true;
   }) : [...EJECT_COMPONENTS];
   if (toEject.length === 0) {
-    console.log(import_picocolors3.default.red("  No valid components to eject."));
+    console.log(import_picocolors4.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 = path4.dirname(require2.resolve("@svadmin/ui/package.json"));
-    uiSrcDir = path4.join(uiPkg, "src", "components");
+    const uiPkg = path5.dirname(require2.resolve("@svadmin/ui/package.json"));
+    uiSrcDir = path5.join(uiPkg, "src", "components");
   } catch {
-    const nm = path4.join(process.cwd(), "node_modules", "@svadmin", "ui", "src", "components");
-    if (fs4.existsSync(nm)) {
+    const nm = path5.join(process.cwd(), "node_modules", "@svadmin", "ui", "src", "components");
+    if (fs5.existsSync(nm)) {
       uiSrcDir = nm;
     } else {
-      console.log(import_picocolors3.default.red("  ✗ Cannot find @svadmin/ui. Run `bun install` first."));
+      console.log(import_picocolors4.default.red("  ✗ Cannot find @svadmin/ui. Run `bun install` first."));
       return;
     }
   }
-  const destDir = path4.join(process.cwd(), "src", "components", "svadmin");
-  fs4.mkdirSync(destDir, { recursive: true });
+  const destDir = path5.join(process.cwd(), "src", "components", "svadmin");
+  fs5.mkdirSync(destDir, { recursive: true });
   let copied = 0;
   for (const name of toEject) {
-    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;
+    const srcFile = path5.join(uiSrcDir, `${name}.svelte`);
+    const srcFileAlt = path5.join(uiSrcDir, "fields", `${name}.svelte`);
+    const src = fs5.existsSync(srcFile) ? srcFile : fs5.existsSync(srcFileAlt) ? srcFileAlt : null;
     if (!src) {
-      console.log(import_picocolors3.default.yellow(`  ⚠ ${name}.svelte not found in @svadmin/ui (skipped)`));
+      console.log(import_picocolors4.default.yellow(`  ⚠ ${name}.svelte not found in @svadmin/ui (skipped)`));
       continue;
     }
-    let content = fs4.readFileSync(src, "utf-8");
+    let content = fs5.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 = path4.join(destDir, `${name}.svelte`);
-    fs4.writeFileSync(destFile, content);
-    console.log(import_picocolors3.default.green("  ✔") + ` ${name}.svelte → src/components/svadmin/`);
+    const destFile = path5.join(destDir, `${name}.svelte`);
+    fs5.writeFileSync(destFile, content);
+    console.log(import_picocolors4.default.green("  ✔") + ` ${name}.svelte → src/components/svadmin/`);
     copied++;
   }
   console.log();
   if (copied > 0) {
-    console.log(import_picocolors3.default.green(import_picocolors3.default.bold(`  ✔ Ejected ${copied} component(s)`)));
+    console.log(import_picocolors4.default.green(import_picocolors4.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_picocolors3.default.dim('    import CustomLayout from "./components/svadmin/Layout.svelte";'));
-    console.log(import_picocolors3.default.dim("    <AdminApp components={{ Layout: CustomLayout }} ... />"));
+    console.log(import_picocolors4.default.dim('    import CustomLayout from "./components/svadmin/Layout.svelte";'));
+    console.log(import_picocolors4.default.dim("    <AdminApp components={{ Layout: CustomLayout }} ... />"));
   } else {
-    console.log(import_picocolors3.default.yellow("  No components were ejected."));
+    console.log(import_picocolors4.default.yellow("  No components were ejected."));
   }
   console.log();
 }
@@ -7575,7 +8573,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_picocolors3.default.red(`
+    console.error(import_picocolors4.default.red(`
   ✗ ${message}
 `));
     process.exitCode = 2;
@@ -7587,10 +8585,14 @@ if (subcommand === "eject") {
   runCommand(() => doctor(rest));
 } else if (subcommand === "upgrade") {
   runCommand(() => upgrade(rest));
+} else if (subcommand === "migrate") {
+  runCommand(() => upgrade(rest));
 } else if (subcommand === "guidance") {
   runCommand(() => guidance(rest));
 } else if (subcommand === "infer") {
   runCommand(() => inferCommand(rest));
+} else if (subcommand === "add") {
+  runCommand(() => addCommand(rest, loadShippedScaffoldManifest()));
 } else if (subcommand === "generate" || subcommand === "gen") {
   runCommand(() => generateCommand(rest));
 } else if (subcommand === "lite") {
@@ -7601,6 +8603,8 @@ if (subcommand === "eject") {
   } else {
     runCommand(() => liteInitCommand(rest.slice(1)));
   }
+} else if (subcommand === "init") {
+  runCommand(() => init(rest));
 } else {
-  runCommand(init);
+  runCommand(() => init(subcommand === undefined ? rest : [subcommand, ...rest]));
 }