@svadmin/create 0.12.5 → 0.13.1

package/README.md

@@ -66,6 +66,28 @@ Ejected files are placed in `src/components/svadmin/`. Then pass them via the `c
 
 `Layout` · `Sidebar` · `Header` · `LoginPage` · `AutoTable` · `AutoForm` · `ShowPage` · `ProfilePage` · `StatsCard` · `AuditLogDrawer` · `LiveIndicator` · `CommandPalette` · `AICommandBar` · `ChatDialog` · `PasswordInput` · `BooleanField` · `FieldRenderer` · `MarkdownRenderer` · `AnomalyBadge` · `Toast` · `ConfirmDialog` · `TooltipButton` · `Breadcrumbs` · `ConfigErrorScreen` · `DevTools`
 
+## Project Maintenance
+
+Check the current project against the dependency versions shipped with the CLI. This command is read-only and does not access the network:
+
+```bash
+npx @svadmin/create doctor
+```
+
+Preview an upgrade plan without changing `package.json`:
+
+```bash
+npx @svadmin/create upgrade
+```
+
+Apply the plan explicitly. The CLI creates a timestamped `package.json.svadmin-backup-*` file before replacing `package.json`:
+
+```bash
+npx @svadmin/create upgrade --write
+```
+
+Both commands accept an optional project-directory argument. Upgrade only manages dependencies known by the shipped scaffold; custom dependencies, scripts, and other package fields are preserved.
+
 ## Development
 
 ```bash

package/dist/index.js

@@ -5027,8 +5027,495 @@ import fs from "node:fs";
 import path 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 AUTH_PROVIDER_CHOICES = ["mock", "jwt", "supabase", "none"];
+function assertJsonObject(candidate, path) {
+  if (candidate === null || typeof candidate !== "object" || Array.isArray(candidate)) {
+    throw new Error(`${path} must be an object`);
+  }
+}
+function assertNonEmptyString(candidate, path) {
+  if (typeof candidate !== "string" || candidate.length === 0) {
+    throw new Error(`${path} must be a non-empty string`);
+  }
+}
+function assertStringRecord(candidate, path) {
+  assertJsonObject(candidate, path);
+  for (const [key, entry] of Object.entries(candidate)) {
+    assertNonEmptyString(entry, `${path}.${key}`);
+  }
+}
+function assertSelectionMap(candidate, choices, path) {
+  assertJsonObject(candidate, path);
+  for (const choice of choices) {
+    const packs = candidate[choice];
+    if (!Array.isArray(packs) || packs.some((pack) => typeof pack !== "string")) {
+      throw new Error(`${path}.${choice} must be an array of dependency-pack names`);
+    }
+  }
+}
+function assertDependencyPacks(candidate) {
+  assertJsonObject(candidate, "scaffold manifest.svadmin.dependencyPacks");
+  for (const [packName, pack] of Object.entries(candidate)) {
+    assertStringRecord(pack, `scaffold manifest.svadmin.dependencyPacks.${packName}`);
+  }
+}
+function assertReferencedPacksExist(dependencyPacks, selectedPacks) {
+  for (const packName of selectedPacks) {
+    if (!(packName in dependencyPacks)) {
+      throw new Error(`scaffold manifest references unknown dependency pack: ${packName}`);
+    }
+  }
+}
+function assertScaffoldManifest(candidate) {
+  assertJsonObject(candidate, "scaffold manifest");
+  assertNonEmptyString(candidate.name, "scaffold manifest.name");
+  assertNonEmptyString(candidate.version, "scaffold manifest.version");
+  if (candidate.private !== true) {
+    throw new Error("scaffold manifest.private must be true");
+  }
+  assertNonEmptyString(candidate.type, "scaffold manifest.type");
+  assertStringRecord(candidate.scripts, "scaffold manifest.scripts");
+  assertStringRecord(candidate.dependencies, "scaffold manifest.dependencies");
+  assertStringRecord(candidate.devDependencies, "scaffold manifest.devDependencies");
+  assertJsonObject(candidate.svadmin, "scaffold manifest.svadmin");
+  assertDependencyPacks(candidate.svadmin.dependencyPacks);
+  assertSelectionMap(candidate.svadmin.dataProviders, DATA_PROVIDER_CHOICES, "scaffold manifest.svadmin.dataProviders");
+  assertSelectionMap(candidate.svadmin.authProviders, AUTH_PROVIDER_CHOICES, "scaffold manifest.svadmin.authProviders");
+  assertReferencedPacksExist(candidate.svadmin.dependencyPacks, [
+    ...Object.values(candidate.svadmin.dataProviders).flat(),
+    ...Object.values(candidate.svadmin.authProviders).flat()
+  ]);
+}
+function loadScaffoldManifest(manifestPath) {
+  const parsed = JSON.parse(readFileSync(manifestPath, "utf8"));
+  assertScaffoldManifest(parsed);
+  return parsed;
+}
+function mergeDependencyPack(dependencies, pack, packName) {
+  for (const [packageName, version] of Object.entries(pack)) {
+    const existingVersion = dependencies[packageName];
+    if (existingVersion !== undefined && existingVersion !== version) {
+      throw new Error(`Dependency ${packageName} has conflicting versions ${existingVersion} and ${version} in pack ${packName}`);
+    }
+    dependencies[packageName] = version;
+  }
+}
+function createProjectPackageJson(scaffold, options) {
+  const dependencies = { ...scaffold.dependencies };
+  const selectedPacks = new Set([
+    ...scaffold.svadmin.dataProviders[options.dataProvider],
+    ...scaffold.svadmin.authProviders[options.authProvider]
+  ]);
+  for (const packName of selectedPacks) {
+    mergeDependencyPack(dependencies, scaffold.svadmin.dependencyPacks[packName], packName);
+  }
+  return {
+    name: options.projectName.trim(),
+    version: scaffold.version,
+    private: scaffold.private,
+    type: scaffold.type,
+    scripts: { ...scaffold.scripts },
+    dependencies,
+    devDependencies: { ...scaffold.devDependencies }
+  };
+}
+
+// src/project-maintenance.ts
+import {
+  constants,
+  copyFileSync,
+  readFileSync as readFileSync2,
+  renameSync,
+  unlinkSync,
+  writeFileSync
+} from "node:fs";
+function parseDependencyMap(candidate, path) {
+  if (candidate === undefined)
+    return;
+  assertStringRecord(candidate, path);
+  return { ...candidate };
+}
+function parseMaintainedPackageJson(packageJsonCandidate) {
+  assertJsonObject(packageJsonCandidate, "package.json");
+  const packageJson = structuredClone(packageJsonCandidate);
+  const dependencies = parseDependencyMap(packageJsonCandidate.dependencies, "package.json.dependencies");
+  const devDependencies = parseDependencyMap(packageJsonCandidate.devDependencies, "package.json.devDependencies");
+  if (dependencies !== undefined)
+    packageJson.dependencies = dependencies;
+  if (devDependencies !== undefined)
+    packageJson.devDependencies = devDependencies;
+  return packageJson;
+}
+function readMaintainedPackageJson(packagePath) {
+  const parsed = JSON.parse(readFileSync2(packagePath, "utf8"));
+  return parseMaintainedPackageJson(parsed);
+}
+function allProjectDependencies(project) {
+  return { ...project.dependencies ?? {}, ...project.devDependencies ?? {} };
+}
+function selectedDependencyPacks(project, scaffold) {
+  const currentDependencies = allProjectDependencies(project);
+  const directlySelectedPacks = new Set;
+  for (const [packName, pack] of Object.entries(scaffold.svadmin.dependencyPacks)) {
+    const providerPackage = Object.keys(pack).find((packageName) => packageName.startsWith("@svadmin/"));
+    if (providerPackage !== undefined && currentDependencies[providerPackage] !== undefined) {
+      directlySelectedPacks.add(packName);
+    }
+  }
+  const selectedPacks = new Set(directlySelectedPacks);
+  const selections = [
+    ...Object.values(scaffold.svadmin.dataProviders),
+    ...Object.values(scaffold.svadmin.authProviders)
+  ];
+  for (const packs of selections) {
+    if (packs.some((packName) => directlySelectedPacks.has(packName))) {
+      for (const packName of packs)
+        selectedPacks.add(packName);
+    }
+  }
+  return selectedPacks;
+}
+function desiredDependencies(project, scaffold) {
+  const desired = new Map;
+  for (const [packageName, version] of Object.entries(scaffold.dependencies)) {
+    desired.set(packageName, { packageName, version, section: "dependencies" });
+  }
+  for (const [packageName, version] of Object.entries(scaffold.devDependencies)) {
+    desired.set(packageName, { packageName, version, section: "devDependencies" });
+  }
+  for (const packName of selectedDependencyPacks(project, scaffold)) {
+    const pack = scaffold.svadmin.dependencyPacks[packName];
+    for (const [packageName, version] of Object.entries(pack)) {
+      const existing = desired.get(packageName);
+      if (existing !== undefined && (existing.version !== version || existing.section !== "dependencies")) {
+        throw new Error(`scaffold dependency ${packageName} has conflicting canonical locations or versions`);
+      }
+      desired.set(packageName, { packageName, version, section: "dependencies" });
+    }
+  }
+  return [...desired.values()];
+}
+function compareVersions(left, right) {
+  if (left.major !== right.major)
+    return left.major - right.major;
+  if (left.minor !== right.minor)
+    return left.minor - right.minor;
+  return left.patch - right.patch;
+}
+function parseSimpleInterval(branch) {
+  const match = /^([~^]?)(\d+)\.(\d+)\.(\d+)(?:-[0-9A-Za-z.-]+)?$/.exec(branch.trim());
+  if (!match)
+    return null;
+  const operator = match[1];
+  const minimum = {
+    major: Number(match[2]),
+    minor: Number(match[3]),
+    patch: Number(match[4])
+  };
+  let maximumExclusive;
+  if (operator === "^") {
+    maximumExclusive = minimum.major > 0 ? { major: minimum.major + 1, minor: 0, patch: 0 } : minimum.minor > 0 ? { major: 0, minor: minimum.minor + 1, patch: 0 } : { major: 0, minor: 0, patch: minimum.patch + 1 };
+  } else if (operator === "~") {
+    maximumExclusive = { major: minimum.major, minor: minimum.minor + 1, patch: 0 };
+  } else {
+    maximumExclusive = { major: minimum.major, minor: minimum.minor, patch: minimum.patch + 1 };
+  }
+  return { minimum, maximumExclusive };
+}
+function parseSimpleRange(range) {
+  const intervals = range.split("||").map(parseSimpleInterval);
+  return intervals.some((interval) => interval === null) ? null : intervals.filter((interval) => interval !== null);
+}
+function intervalsOverlap(left, right) {
+  return compareVersions(left.minimum, right.maximumExclusive) < 0 && compareVersions(right.minimum, left.maximumExclusive) < 0;
+}
+function rangesClearlyIncompatible(actual, expected) {
+  const actualIntervals = parseSimpleRange(actual);
+  const expectedIntervals = parseSimpleRange(expected);
+  if (actualIntervals === null || expectedIntervals === null)
+    return false;
+  return !actualIntervals.some((actualInterval) => expectedIntervals.some((expectedInterval) => intervalsOverlap(actualInterval, expectedInterval)));
+}
+function alternateSection(section) {
+  return section === "dependencies" ? "devDependencies" : "dependencies";
+}
+function dependencyState(project, desired) {
+  const alternate = alternateSection(desired.section);
+  return {
+    canonicalVersion: project[desired.section]?.[desired.packageName],
+    alternateVersion: project[alternate]?.[desired.packageName],
+    alternateSection: alternate
+  };
+}
+function upgradeAction(instruction) {
+  return `${instruction} by running upgrade --write for this project`;
+}
+function missingDependencyIssue(desired) {
+  return {
+    kind: "missing",
+    packageName: desired.packageName,
+    expectedVersion: desired.version,
+    expectedSection: desired.section,
+    action: upgradeAction(`Add ${desired.packageName}@${desired.version} to ${desired.section}`)
+  };
+}
+function misplacedDependencyIssue(desired, state) {
+  return {
+    kind: "section",
+    packageName: desired.packageName,
+    expectedVersion: desired.version,
+    actualVersion: state.alternateVersion,
+    expectedSection: desired.section,
+    actualSection: state.alternateSection,
+    action: upgradeAction(`Move ${desired.packageName} to ${desired.section}`)
+  };
+}
+function versionDependencyIssue(desired, actualVersion) {
+  const kind = rangesClearlyIncompatible(actualVersion, desired.version) ? "incompatible" : "drift";
+  return {
+    kind,
+    packageName: desired.packageName,
+    expectedVersion: desired.version,
+    actualVersion,
+    expectedSection: desired.section,
+    action: upgradeAction(`Update ${desired.packageName} from ${actualVersion} to ${desired.version}`)
+  };
+}
+function duplicateDependencyIssue(desired, state) {
+  return {
+    kind: "section",
+    packageName: desired.packageName,
+    expectedVersion: desired.version,
+    actualVersion: state.alternateVersion,
+    expectedSection: desired.section,
+    actualSection: state.alternateSection,
+    action: upgradeAction(`Remove the duplicate ${desired.packageName} entry from ${state.alternateSection}`)
+  };
+}
+function doctorIssueForDependency(project, desired) {
+  const state = dependencyState(project, desired);
+  if (state.canonicalVersion === undefined) {
+    return state.alternateVersion === undefined ? missingDependencyIssue(desired) : misplacedDependencyIssue(desired, state);
+  }
+  if (state.canonicalVersion !== desired.version) {
+    return versionDependencyIssue(desired, state.canonicalVersion);
+  }
+  return state.alternateVersion === undefined ? null : duplicateDependencyIssue(desired, state);
+}
+function doctorProjectPackageJson(packageJsonCandidate, scaffold) {
+  const project = parseMaintainedPackageJson(packageJsonCandidate);
+  const issues = desiredDependencies(project, scaffold).map((desired) => doctorIssueForDependency(project, desired)).filter((issue) => issue !== null);
+  return issues.length === 0 ? { status: "clean", exitCode: 0, issues: [] } : { status: "issues", exitCode: 1, issues };
+}
+function upgradeChangeForDependency(desired, state) {
+  if (state.canonicalVersion === undefined && state.alternateVersion === undefined) {
+    return { action: "add", packageName: desired.packageName, to: desired.version, section: desired.section };
+  }
+  if (state.canonicalVersion === undefined) {
+    return {
+      action: "move",
+      packageName: desired.packageName,
+      from: state.alternateVersion,
+      to: desired.version,
+      section: desired.section,
+      previousSection: state.alternateSection
+    };
+  }
+  if (state.canonicalVersion === desired.version && state.alternateVersion === undefined)
+    return null;
+  return {
+    action: state.alternateVersion === undefined ? "update" : "move",
+    packageName: desired.packageName,
+    from: state.canonicalVersion,
+    to: desired.version,
+    section: desired.section,
+    previousSection: state.alternateVersion === undefined ? undefined : state.alternateSection
+  };
+}
+function applyDesiredDependency(updatedPackageJson, desired) {
+  const canonicalDependencies = updatedPackageJson[desired.section] ?? {};
+  const otherSection = alternateSection(desired.section);
+  const alternateDependencies = updatedPackageJson[otherSection] ?? {};
+  canonicalDependencies[desired.packageName] = desired.version;
+  updatedPackageJson[desired.section] = canonicalDependencies;
+  updatedPackageJson[otherSection] = Object.fromEntries(Object.entries(alternateDependencies).filter(([packageName]) => packageName !== desired.packageName));
+}
+function planProjectUpgrade(packageJsonCandidate, scaffold) {
+  const project = parseMaintainedPackageJson(packageJsonCandidate);
+  const updatedPackageJson = structuredClone(project);
+  updatedPackageJson.dependencies = { ...project.dependencies ?? {} };
+  updatedPackageJson.devDependencies = { ...project.devDependencies ?? {} };
+  const changes = [];
+  for (const desired of desiredDependencies(project, scaffold)) {
+    const change = upgradeChangeForDependency(desired, dependencyState(updatedPackageJson, desired));
+    if (change !== null)
+      changes.push(change);
+    applyDesiredDependency(updatedPackageJson, desired);
+  }
+  changes.sort((left, right) => left.section.localeCompare(right.section) || left.packageName.localeCompare(right.packageName));
+  return { changes, updatedPackageJson };
+}
+function timestampForBackup(date) {
+  return date.toISOString().replace(/[-:.]/g, "");
+}
+function createBackup(packagePath, timestamp) {
+  for (let suffix = 0;suffix < 1000; suffix++) {
+    const suffixText = suffix === 0 ? "" : `-${suffix}`;
+    const backupPath = `${packagePath}.svadmin-backup-${timestamp}${suffixText}`;
+    try {
+      copyFileSync(packagePath, backupPath, constants.COPYFILE_EXCL);
+      return backupPath;
+    } catch (error) {
+      if (error.code !== "EEXIST")
+        throw error;
+    }
+  }
+  throw new Error(`Unable to allocate a unique backup path for ${packagePath}`);
+}
+function writePackageJsonAtomically(packagePath, updatedPackageJson, timestamp) {
+  const temporaryPath = `${packagePath}.svadmin-tmp-${process.pid}-${timestamp}`;
+  try {
+    writeFileSync(temporaryPath, `${JSON.stringify(updatedPackageJson, null, 2)}
+`, {
+      encoding: "utf8",
+      flag: "wx"
+    });
+    renameSync(temporaryPath, packagePath);
+  } catch (error) {
+    try {
+      unlinkSync(temporaryPath);
+    } catch (cleanupError) {
+      if (cleanupError.code !== "ENOENT")
+        throw cleanupError;
+    }
+    throw error;
+  }
+}
+function planProjectPackageFileUpgrade(packagePath, scaffold) {
+  const project = readMaintainedPackageJson(packagePath);
+  const plan = planProjectUpgrade(project, scaffold);
+  return { wrote: false, backupPath: null, plan };
+}
+function writeProjectPackageJsonUpgrade(packagePath, scaffold, backupDate) {
+  const plannedUpgrade = planProjectPackageFileUpgrade(packagePath, scaffold);
+  if (plannedUpgrade.plan.changes.length === 0)
+    return plannedUpgrade;
+  const timestamp = timestampForBackup(backupDate);
+  const backupPath = createBackup(packagePath, timestamp);
+  writePackageJsonAtomically(packagePath, plannedUpgrade.plan.updatedPackageJson, timestamp);
+  return { wrote: true, backupPath, plan: plannedUpgrade.plan };
+}
+
+// src/index.ts
 var __filename2 = fileURLToPath(import.meta.url);
 var __dirname2 = path.dirname(__filename2);
+function loadShippedScaffoldManifest() {
+  return loadScaffoldManifest(path.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 path.resolve(process.cwd(), positional[0] ?? ".");
+}
+function doctorProjectDirectory(args) {
+  const unknownOption = args.find((argument) => argument.startsWith("-"));
+  if (unknownOption !== undefined)
+    throw new Error(`Unknown option: ${unknownOption}`);
+  return projectDirectoryFromArguments(args);
+}
+function parseUpgradeArguments(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);
+    }
+  }
+  return { projectDirectory: projectDirectoryFromArguments(positional), write };
+}
+function doctorIssueMessage(issue) {
+  const actualDescription = issue.actualVersion === undefined ? "missing" : `${issue.actualVersion}${issue.actualSection ? ` in ${issue.actualSection}` : ""}`;
+  return `${issue.packageName}: ${issue.kind}; expected ${issue.expectedVersion} in ` + `${issue.expectedSection}, found ${actualDescription}`;
+}
+function upgradeChangeMessage(change) {
+  if (change.action === "add") {
+    return `add ${change.packageName}@${change.to} to ${change.section}`;
+  }
+  if (change.action === "move") {
+    return `move ${change.packageName} to ${change.section} and set ${change.to}`;
+  }
+  return `update ${change.packageName} from ${change.from ?? "missing"} to ${change.to}`;
+}
+function printDoctorIssue(issue) {
+  const marker = issue.kind === "drift" || issue.kind === "section" ? import_picocolors.default.yellow("  ⚠") : import_picocolors.default.red("  ✗");
+  console.log(`${marker} ${doctorIssueMessage(issue)}`);
+  console.log(import_picocolors.default.dim(`    → ${issue.action}`));
+}
+function printDoctorReport(report, projectDirectory) {
+  console.log();
+  console.log(import_picocolors.default.bold(`svadmin doctor — ${projectDirectory}`));
+  if (report.status === "clean") {
+    console.log(import_picocolors.default.green("  ✔ Dependencies match the shipped svadmin scaffold."));
+  } else {
+    for (const issue of report.issues)
+      printDoctorIssue(issue);
+    console.log();
+    console.log(import_picocolors.default.yellow(`  ${report.issues.length} actionable issue(s) found.`));
+  }
+  console.log();
+}
+function doctor(args) {
+  const projectDirectory = doctorProjectDirectory(args);
+  const project = readMaintainedPackageJson(path.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_picocolors.default.cyan("•")} ${upgradeChangeMessage(change)}`);
+  }
+  console.log();
+}
+function printUpgradeOutcome(upgradeExecution, packagePath) {
+  if (upgradeExecution.wrote) {
+    console.log(import_picocolors.default.green("  ✔ package.json updated."));
+    console.log(`  Backup: ${import_picocolors.default.cyan(upgradeExecution.backupPath)}`);
+    console.log(`  Restore by copying the backup over: ${import_picocolors.default.cyan(packagePath)}`);
+  } else {
+    console.log(import_picocolors.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_picocolors.default.bold(`svadmin upgrade — ${projectDirectory}`));
+  if (upgradeExecution.plan.changes.length === 0) {
+    console.log(import_picocolors.default.green("  ✔ package.json already matches the shipped scaffold."));
+    console.log();
+    return;
+  }
+  printUpgradeChanges(upgradeExecution);
+  printUpgradeOutcome(upgradeExecution, packagePath);
+}
+function upgrade(args) {
+  const commandArguments = parseUpgradeArguments(args);
+  const packagePath = path.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);
+}
 async function init() {
   console.log();
   console.log(import_picocolors.default.cyan("  ╔═══════════════════════════════════╗"));
@@ -5096,6 +5583,7 @@ Operation cancelled.
 ${import_picocolors.default.bold("Scaffolding")} project in ${import_picocolors.default.green(projectDir)}...
 `);
   const templateDir = path.join(__dirname2, "..", "template");
+  const scaffoldManifest = loadShippedScaffoldManifest();
   function copyDir(src, dest) {
     fs.mkdirSync(dest, { recursive: true });
     const entries = fs.readdirSync(src, { withFileTypes: true });
@@ -5113,52 +5601,13 @@ ${import_picocolors.default.bold("Scaffolding")} project in ${import_picocolors.
     copyDir(templateDir, projectDir);
     console.log(import_picocolors.default.green("  ✔") + " Template files copied");
   }
-  const packageJson = {
-    name: response.projectName,
-    version: "0.1.0",
-    private: true,
-    type: "module",
-    scripts: {
-      dev: "vite",
-      build: "vite build",
-      preview: "vite preview",
-      check: "svelte-check --tsconfig ./tsconfig.json"
-    },
-    dependencies: {
-      "@svadmin/core": "^0.31.0",
-      "@svadmin/ui": "^0.38.0",
-      "@tanstack/svelte-query": "^6.1.29",
-      "highlight.js": "^11.11.1",
-      "@lucide/svelte": "^1.17.0"
-    },
-    devDependencies: {
-      "@sveltejs/vite-plugin-svelte": "^7.0.0",
-      "@tailwindcss/vite": "^4.2.2",
-      svelte: "^5.55.1",
-      "svelte-check": "^4.4.8",
-      tailwindcss: "^4.2.2",
-      "tw-animate-css": "^1.4.0",
-      typescript: "^6.0.0",
-      vite: "^8.0.3"
-    }
-  };
-  const dpMap = {
-    "simple-rest": { "@svadmin/simple-rest": "^0.9.8", "@refinedev/simple-rest": "^5.0.0" },
-    supabase: { "@svadmin/supabase": "^0.11.3", "@supabase/supabase-js": "^2.101.1" },
-    graphql: { "@svadmin/graphql": "^0.9.9", "graphql-request": "^7.4.0", graphql: "^16.8.0" }
-  };
-  if (dpMap[response.dataProvider]) {
-    Object.assign(packageJson.dependencies, dpMap[response.dataProvider]);
-  }
-  if (response.authProvider === "supabase" && response.dataProvider !== "supabase") {
-    packageJson.dependencies["@svadmin/supabase"] = "^0.11.3";
-    packageJson.dependencies["@supabase/supabase-js"] = "^2.101.1";
-  }
-  if (response.authProvider === "jwt" && response.dataProvider !== "simple-rest") {
-    packageJson.dependencies["@svadmin/simple-rest"] = "^0.9.8";
-    packageJson.dependencies["@refinedev/simple-rest"] = "^5.0.0";
-  }
-  fs.writeFileSync(path.join(projectDir, "package.json"), JSON.stringify(packageJson, null, 2));
+  const packageJson = createProjectPackageJson(scaffoldManifest, {
+    projectName: response.projectName,
+    dataProvider: response.dataProvider,
+    authProvider: response.authProvider
+  });
+  fs.writeFileSync(path.join(projectDir, "package.json"), `${JSON.stringify(packageJson, null, 2)}
+`);
   console.log(import_picocolors.default.green("  ✔") + " package.json generated");
   fs.writeFileSync(path.join(projectDir, ".gitignore"), `node_modules
 dist
@@ -5193,13 +5642,10 @@ bun run dev
     console.log(`
 ${import_picocolors.default.bold("Installing dependencies...")}
 `);
-    const { execSync } = await import("child_process");
-    try {
-      execSync("bun install", { cwd: projectDir, stdio: "inherit" });
-    } catch {
-      try {
-        execSync("npm install", { cwd: projectDir, stdio: "inherit" });
-      } catch {
+    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_picocolors.default.yellow("\n  ⚠ Auto-install failed. Run `bun install` or `npm install` manually."));
       }
     }
@@ -5308,8 +5754,21 @@ async function eject(args) {
   console.log();
 }
 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_picocolors.default.red(`
+  ✗ ${message}
+`));
+    process.exitCode = 2;
+  });
+};
 if (subcommand === "eject") {
-  eject(rest).catch(console.error);
+  runCommand(() => eject(rest));
+} else if (subcommand === "doctor") {
+  runCommand(() => doctor(rest));
+} else if (subcommand === "upgrade") {
+  runCommand(() => upgrade(rest));
 } else {
-  init().catch(console.error);
+  runCommand(init);
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@svadmin/create",
-  "version": "0.12.5",
+  "version": "0.13.1",
   "description": "Scaffolding tool for svadmin projects",
   "type": "module",
   "bin": {
@@ -8,10 +8,13 @@
   },
   "files": [
     "dist",
-    "template"
+    "template",
+    "scaffold-manifest.json"
   ],
   "scripts": {
     "build": "bun build src/index.ts --outdir dist --target node --format esm",
+    "test": "bun test src",
+    "check:compat": "bun ../../scripts/check-create-svadmin-compat.ts",
     "sync-template": "bun src/sync-template.ts",
     "prepublishOnly": "bun run build"
   },

package/scaffold-manifest.json

@@ -0,0 +1,63 @@
+{
+  "name": "svadmin-app",
+  "version": "0.1.0",
+  "private": true,
+  "type": "module",
+  "scripts": {
+    "dev": "vite",
+    "build": "vite build",
+    "preview": "vite preview",
+    "check": "svelte-check --tsconfig ./tsconfig.json"
+  },
+  "dependencies": {
+    "@svadmin/core": "^0.35.0",
+    "@svadmin/ui": "^0.41.1",
+    "@tanstack/svelte-query": "^6.1.38",
+    "highlight.js": "^11.11.1",
+    "@lucide/svelte": "^1.30.0"
+  },
+  "devDependencies": {
+    "@sveltejs/vite-plugin-svelte": "^7.3.0",
+    "@tailwindcss/vite": "^4.3.3",
+    "svelte": "^5.56.8",
+    "svelte-check": "^4.7.5",
+    "tailwindcss": "^4.3.3",
+    "tw-animate-css": "^1.4.0",
+    "typescript": "~6.0.3",
+    "vite": "^8.2.1"
+  },
+  "svadmin": {
+    "dependencyPacks": {
+      "refine-core": {
+        "@refinedev/core": "^5.0.12"
+      },
+      "simple-rest": {
+        "@svadmin/simple-rest": "^0.9.11",
+        "@refinedev/simple-rest": "^6.0.1"
+      },
+      "supabase": {
+        "@svadmin/supabase": "^0.11.8",
+        "@supabase/supabase-js": "^2.112.2",
+        "@refinedev/supabase": "^6.0.2"
+      },
+      "graphql": {
+        "@svadmin/graphql": "^0.9.11",
+        "@refinedev/graphql": "^8.0.1",
+        "graphql-request": "^7.4.0",
+        "graphql": "^16.8.0"
+      }
+    },
+    "dataProviders": {
+      "simple-rest": ["refine-core", "simple-rest"],
+      "supabase": ["refine-core", "supabase"],
+      "graphql": ["refine-core", "graphql"],
+      "none": []
+    },
+    "authProviders": {
+      "mock": [],
+      "jwt": ["refine-core", "simple-rest"],
+      "supabase": ["refine-core", "supabase"],
+      "none": []
+    }
+  }
+}