create-aphex 0.3.6 → 0.4.0-next.20261109083516

package/README.md

@@ -1,8 +1,40 @@
 # create-aphex
 
-Scaffold a new Aphex CMS project from an official standalone template.
+Create a new Aphex CMS project, or add Aphex to the SvelteKit app you already have.
 
-## Usage
+## Add Aphex to an existing app
+
+Run it inside your SvelteKit 2 app, with no project name:
+
+```bash
+pnpm create aphex
+```
+
+It asks which database, upload storage and email to use, shows every file it will create or change, and asks before writing anything. It creates the config, the admin route and a sample schema, adds `aphex()` (and Tailwind, if you don't have it) to `vite.config.ts`, puts Aphex first in your `handle`, adds Aphex's `locals` to `app.d.ts`, fills in `.env` with a generated secret, and installs the packages. It never overwrites a file you already have. When a file has a shape it can't edit safely, it prints the lines to add by hand.
+
+```bash
+pnpm create aphex --dry-run                          # show the changes, make none
+pnpm create aphex --db postgres --storage s3 --yes   # no questions
+```
+
+| Flag           | Values                                                            | Default  |
+| -------------- | ----------------------------------------------------------------- | -------- |
+| `--db`         | `sqlite`, `postgres`                                              | `sqlite` |
+| `--storage`    | `local`, `s3`                                                     | `local`  |
+| `--email`      | `none`, `resend`                                                  | `none`   |
+| `-y`, `--yes`  | Use the defaults for anything not given, and don't ask to confirm |          |
+| `--dry-run`    | Show the changes without making them                              |          |
+| `--no-install` | Write the files but don't install packages                        |          |
+
+With Postgres it also runs `drizzle-kit generate`, so commit the `drizzle` folder it creates. It stops without changing anything on SvelteKit 3, Tailwind 3, an app without TypeScript, or an app that already has `src/routes/admin`.
+
+## Upgrade an older Aphex app
+
+Run the same command in an app that already uses Aphex, and it upgrades the app to the embedded admin (`@aphexcms/cms-core` 12) instead: it deletes the admin, account, `/api` and `/media` route files that core now serves, adds the admin route and `aphex.client.ts`, fixes the config, and moves the `@aphexcms/*` packages to the latest version. `--yes`, `--dry-run` and `--no-install` work the same way.
+
+It deletes a file only if it's exactly a version an Aphex template shipped, and keeps a route folder whole if you changed any file in it. It recognises versions by their git blob ids, listed in `src/upgrade/known-files.ts`. When a template changes one of those files, regenerate the list with `pnpm -F create-aphex known-files`, which reads the monorepo's git history. See [Upgrading to the embedded admin](https://docs.getaphex.com/upgrading-to-embedded-admin).
+
+## Create a new app
 
 ```bash
 pnpm create aphex my-app

package/dist/index.js

@@ -4,8 +4,11 @@ import { existsSync, readFileSync, writeFileSync } from 'fs';
 import { join, resolve } from 'path';
 import pc from 'picocolors';
 import { downloadTemplate } from 'giget';
-import { parseArgs, templates } from './options.js';
+import { parseArgs, releaseTag, templates } from './options.js';
 import { withGeneratedAuthSecret } from './env.js';
+import { isSvelteKitApp, readPackageJson } from './init/detect.js';
+import { runInit } from './init/run.js';
+import { runUpgrade } from './upgrade/run.js';
 /** Shown as the prompt's placeholder and used when the answer is left empty. */
 const DEFAULT_PROJECT_NAME = 'my-aphex-project';
 async function main() {
@@ -14,6 +17,29 @@ async function main() {
         printHelp();
         return;
     }
+    // Run inside a SvelteKit app with no project name, and this adds Aphex to that app
+    // instead of creating a new one beside it.
+    // An app that already has Aphex is upgraded to the embedded admin instead.
+    if (!cliOptions.projectName && !cliOptions.template && isSvelteKitApp(process.cwd())) {
+        const pkg = readPackageJson(process.cwd());
+        const hasAphex = Boolean(pkg?.dependencies?.['@aphexcms/cms-core'] ?? pkg?.devDependencies?.['@aphexcms/cms-core']);
+        if (!hasAphex) {
+            await runInit(process.cwd(), cliOptions);
+            return;
+        }
+        if (cliOptions.database || cliOptions.storage || cliOptions.email) {
+            throw new Error('This app already uses Aphex, so this upgrades it. --db, --storage and --email are only for adding Aphex.');
+        }
+        await runUpgrade(process.cwd(), cliOptions);
+        return;
+    }
+    if (cliOptions.database || cliOptions.storage || cliOptions.email || cliOptions.dryRun) {
+        throw new Error('--db, --storage, --email and --dry-run are for adding Aphex to an existing app. Run them inside a SvelteKit app, without a project name.');
+    }
+    // Templates are tagged per stable release only, so a snapshot has none to fetch.
+    if (releaseTag !== 'latest' && !process.env.APHEX_TEMPLATE) {
+        throw new Error(`create-aphex@${releaseTag} adds Aphex to an existing app or upgrades one, but can't start a new project. For that, run \`pnpm create aphex@latest\`.`);
+    }
     console.clear();
     p.intro(pc.bgCyan(pc.black(' create-aphex ')));
     const options = {
@@ -139,15 +165,29 @@ function printHelp() {
     console.log(`create-aphex
 
 Usage:
-  create-aphex [project-name] [options]
+  create-aphex [project-name] [options]   Create a new app
+  create-aphex [options]                  Inside a SvelteKit app: add Aphex to it,
+                                          or upgrade an app that has it
 
-Options:
+New app:
   -t, --template <name>  Template to use: base or website
-  -h, --help             Show this help message
+
+Existing app:
+  --db <sqlite|postgres>     Database (default sqlite)
+  --storage <local|s3>       Where uploads go (default local)
+  --email <none|resend>      Email adapter (default none)
+  -y, --yes                  Use the defaults for anything not given, and don't ask
+  --dry-run                  Show the changes without making them
+  --no-install               Write the files but don't install packages
+  (--yes, --dry-run and --no-install also work when upgrading)
+
+  -h, --help                 Show this help message
 
 Examples:
   pnpm create aphex my-site
-  pnpm create aphex my-site --template website`);
+  pnpm create aphex my-site --template website
+  pnpm create aphex                       (inside your SvelteKit app)
+  pnpm create aphex --db postgres --storage s3 --dry-run`);
 }
 main().catch((error) => {
     console.error('Error:', error);

package/dist/init/detect.js

@@ -0,0 +1,114 @@
+import { existsSync, readFileSync } from 'node:fs';
+import { join } from 'node:path';
+function readJson(path) {
+    try {
+        return JSON.parse(readFileSync(path, 'utf8'));
+    }
+    catch {
+        return undefined;
+    }
+}
+export function readPackageJson(cwd) {
+    return readJson(join(cwd, 'package.json'));
+}
+/** True when the folder is a SvelteKit app, which is what switches create-aphex into init. */
+export function isSvelteKitApp(cwd) {
+    const pkg = readPackageJson(cwd);
+    return Boolean(pkg?.dependencies?.['@sveltejs/kit'] ?? pkg?.devDependencies?.['@sveltejs/kit']);
+}
+/** The installed version, else the first version in the declared range. */
+function versionOf(cwd, pkg, name) {
+    const installed = readJson(join(cwd, 'node_modules', name, 'package.json'));
+    if (installed && 'version' in installed && typeof installed.version === 'string') {
+        return installed.version;
+    }
+    const range = pkg.dependencies?.[name] ?? pkg.devDependencies?.[name];
+    return range?.match(/\d+(\.\d+){0,2}/)?.[0];
+}
+function major(version) {
+    if (!version)
+        return undefined;
+    const value = Number.parseInt(version, 10);
+    return Number.isNaN(value) ? undefined : value;
+}
+export function detectPackageManager(cwd, userAgent = process.env.npm_config_user_agent) {
+    if (existsSync(join(cwd, 'pnpm-lock.yaml')))
+        return 'pnpm';
+    if (existsSync(join(cwd, 'bun.lock')) || existsSync(join(cwd, 'bun.lockb')))
+        return 'bun';
+    if (existsSync(join(cwd, 'yarn.lock')))
+        return 'yarn';
+    if (existsSync(join(cwd, 'package-lock.json')))
+        return 'npm';
+    const fromAgent = userAgent?.split('/')[0];
+    if (fromAgent === 'pnpm' || fromAgent === 'yarn' || fromAgent === 'bun')
+        return fromAgent;
+    return 'npm';
+}
+function firstExisting(cwd, candidates) {
+    return candidates.find((file) => existsSync(join(cwd, file)));
+}
+export function detectApp(cwd) {
+    const pkg = readPackageJson(cwd) ?? {};
+    const installed = new Set([
+        ...Object.keys(pkg.dependencies ?? {}),
+        ...Object.keys(pkg.devDependencies ?? {})
+    ]);
+    const kitVersion = versionOf(cwd, pkg, '@sveltejs/kit');
+    const viteConfig = firstExisting(cwd, [
+        'vite.config.ts',
+        'vite.config.js',
+        'vite.config.mts',
+        'vite.config.mjs'
+    ]);
+    const viteSource = viteConfig ? readFileSync(join(cwd, viteConfig), 'utf8') : '';
+    return {
+        cwd,
+        name: pkg.name ?? 'my-app',
+        packageManager: detectPackageManager(cwd),
+        installed,
+        kitMajor: major(kitVersion),
+        kitVersion,
+        svelteMajor: major(versionOf(cwd, pkg, 'svelte')),
+        tailwindMajor: installed.has('tailwindcss')
+            ? major(versionOf(cwd, pkg, 'tailwindcss'))
+            : undefined,
+        hasTailwindVitePlugin: installed.has('@tailwindcss/vite') || viteSource.includes('@tailwindcss/vite'),
+        typescript: existsSync(join(cwd, 'tsconfig.json')),
+        viteConfig,
+        hooksFile: firstExisting(cwd, ['src/hooks.server.ts', 'src/hooks.server.js']),
+        appDts: existsSync(join(cwd, 'src/app.d.ts'))
+    };
+}
+/**
+ * Reasons `init` can't go ahead. Each one is something the person has to change first,
+ * so they are checked before any question is asked.
+ */
+export function findBlockers(app) {
+    const blockers = [];
+    if (app.kitMajor === undefined) {
+        blockers.push('Couldn’t find the @sveltejs/kit version. Run your install first.');
+    }
+    else if (app.kitMajor >= 3) {
+        blockers.push(`This app uses SvelteKit ${app.kitVersion}. Aphex supports SvelteKit 2 for now, and Kit 3 support is planned.`);
+    }
+    else if (app.kitMajor < 2) {
+        blockers.push(`This app uses SvelteKit ${app.kitVersion}. Aphex needs SvelteKit 2.49 or newer.`);
+    }
+    if (app.svelteMajor !== undefined && app.svelteMajor < 5) {
+        blockers.push('Aphex needs Svelte 5. Upgrade svelte first.');
+    }
+    if (app.tailwindMajor !== undefined && app.tailwindMajor < 4) {
+        blockers.push(`This app uses Tailwind ${app.tailwindMajor}. The admin is styled with Tailwind 4, so upgrade Tailwind first.`);
+    }
+    if (!app.typescript) {
+        blockers.push('Aphex’s setup files are TypeScript, and this app has no tsconfig.json.');
+    }
+    if (!app.viteConfig) {
+        blockers.push('Couldn’t find vite.config.ts.');
+    }
+    if (existsSync(join(app.cwd, 'src/routes/admin'))) {
+        blockers.push('src/routes/admin already exists, and that’s where the admin goes. Move it, then run this again.');
+    }
+    return blockers;
+}

package/dist/init/patch.js

@@ -0,0 +1,252 @@
+// Edits to files the app already owns. Each returns the new source, `unchanged` when
+// Aphex is already there, or `manual` with the lines to add when the file has a shape
+// these edits don't recognise. Guessing at someone else's file is worse than asking.
+import { generateCode, parseModule } from 'magicast';
+import { addVitePlugin } from 'magicast/helpers';
+export function patchViteConfig(source, addTailwind) {
+    const needsAphex = !source.includes('@aphexcms/cms-core/vite');
+    const needsTailwind = addTailwind && !source.includes('@tailwindcss/vite');
+    if (!needsAphex && !needsTailwind)
+        return { kind: 'unchanged' };
+    const manual = {
+        kind: 'manual',
+        instructions: [
+            ...(needsTailwind ? ["import tailwindcss from '@tailwindcss/vite';"] : []),
+            ...(needsAphex ? ["import { aphex } from '@aphexcms/cms-core/vite';"] : []),
+            '',
+            `Then add ${[needsTailwind && 'tailwindcss()', needsAphex && 'aphex()'].filter(Boolean).join(' and ')} to plugins.`
+        ].join('\n')
+    };
+    // Only aphex() missing: add it as text, so the rest of the file isn't reprinted.
+    if (needsAphex && !needsTailwind) {
+        const inserted = appendToPlugins(source, 'aphex()');
+        if (inserted) {
+            return {
+                kind: 'patched',
+                code: `import { aphex } from '@aphexcms/cms-core/vite';\n${inserted}`
+            };
+        }
+    }
+    // recast, under magicast, re-indents the lines it reprints at four tabs per level in a
+    // tab-indented file. It handles spaces correctly, so tabs become two spaces for the edit
+    // and go back afterwards.
+    const usesTabs = /^\t/m.test(source);
+    const toSpaces = (code) => code.replace(/^\t+/gm, (tabs) => '  '.repeat(tabs.length));
+    const toTabs = (code) => code.replace(/^(?: {2})+/gm, (spaces) => '\t'.repeat(spaces.length / 2));
+    try {
+        const module = parseModule(usesTabs ? toSpaces(source) : source);
+        if (needsTailwind) {
+            addVitePlugin(module, { from: '@tailwindcss/vite', constructor: 'tailwindcss' });
+        }
+        if (needsAphex) {
+            addVitePlugin(module, {
+                from: '@aphexcms/cms-core/vite',
+                imported: 'aphex',
+                constructor: 'aphex'
+            });
+        }
+        const generated = generateCode(module, { format: { tabWidth: 2, useTabs: false } }).code;
+        const code = usesTabs ? toTabs(generated) : generated;
+        // magicast can't see into every shape (a config built by a function, say), and
+        // says so by changing nothing.
+        if (needsAphex && !code.includes('aphex()'))
+            return manual;
+        return { kind: 'patched', code: code.endsWith('\n') ? code : `${code}\n` };
+    }
+    catch {
+        return manual;
+    }
+}
+/**
+ * Adds `entry` as the last element of the first `plugins: [...]` array, keeping the
+ * file's own formatting. Undefined when the array can't be found with confidence.
+ */
+export function appendToPlugins(source, entry) {
+    const start = source.match(/\bplugins\s*:\s*\[/);
+    if (!start || start.index === undefined)
+        return undefined;
+    const open = start.index + start[0].length - 1;
+    let depth = 0;
+    let quote;
+    for (let i = open; i < source.length; i++) {
+        const char = source[i];
+        if (quote) {
+            if (char === '\\')
+                i++;
+            else if (char === quote)
+                quote = undefined;
+            continue;
+        }
+        if (char === '"' || char === "'" || char === '`')
+            quote = char;
+        else if (char === '/' && source[i + 1] === '/')
+            i = source.indexOf('\n', i) === -1 ? source.length : source.indexOf('\n', i);
+        else if (char === '/' && source[i + 1] === '*')
+            i = source.indexOf('*/', i) + 1;
+        else if (char === '[' || char === '{' || char === '(')
+            depth++;
+        else if (char === ']' || char === '}' || char === ')') {
+            depth--;
+            if (depth === 0) {
+                if (char !== ']')
+                    return undefined;
+                const inner = source.slice(open + 1, i);
+                const trimmed = inner.replace(/\s+$/, '');
+                if (trimmed.trim() === '')
+                    return `${source.slice(0, open + 1)}${entry}${source.slice(i)}`;
+                // Multi-line arrays get the entry on its own line, at the last element's indent.
+                const multiline = /\n([ \t]*)\S[^\n]*$/.exec(trimmed);
+                const comma = trimmed.endsWith(',') ? '' : ',';
+                const addition = multiline ? `${comma}\n${multiline[1]}${entry}` : `${comma} ${entry}`;
+                return `${source.slice(0, open + 1)}${trimmed}${addition}${inner.slice(trimmed.length)}${source.slice(i)}`;
+            }
+        }
+    }
+    return undefined;
+}
+const HOOK_IMPORTS = [
+    "import { createCMSHook } from '@aphexcms/cms-core/server';",
+    "import cmsConfig from '../aphex.config';"
+];
+/** A name for the app's own handle that the file doesn't already use. */
+function freeName(source) {
+    for (const name of ['appHandle', 'existingHandle', 'userHandle']) {
+        if (!new RegExp(`\\b${name}\\b`).test(source))
+            return name;
+    }
+    return 'appHandle_';
+}
+/**
+ * Puts Aphex first in `handle`. The app's handle is renamed and kept, then
+ * `sequence(createCMSHook(cmsConfig), <it>)` takes its place, which is what the guide
+ * tells people to write by hand.
+ */
+export function patchHooks(source) {
+    if (source.includes('createCMSHook'))
+        return { kind: 'unchanged' };
+    const instructions = [
+        ...HOOK_IMPORTS,
+        "import { sequence } from '@sveltejs/kit/hooks';",
+        '',
+        'export const handle = sequence(createCMSHook(cmsConfig), yourHandle);',
+        '',
+        'Aphex has to come first, so that your hook can use locals.aphexCMS.'
+    ].join('\n');
+    // `export { handle }` or a re-export: the definition is somewhere this can't follow.
+    if (/export\s*\{[^}]*\bhandle\b[^}]*\}/.test(source) || /export\s+let\s+handle\b/.test(source)) {
+        return { kind: 'manual', instructions };
+    }
+    const name = freeName(source);
+    let body;
+    if (/^export\s+const\s+handle\b/m.test(source)) {
+        body = source.replace(/^export\s+const\s+handle\b/m, `const ${name}`);
+    }
+    else if (/^export\s+(async\s+)?function\s+handle\s*\(/m.test(source)) {
+        body = source.replace(/^export\s+(async\s+)?function\s+handle\s*\(/m, (_match, isAsync) => {
+            return `${isAsync ?? ''}function ${name}(`;
+        });
+    }
+    else if (/\bhandle\b/.test(source.replace(/\/\/.*$|\/\*[\s\S]*?\*\//gm, ''))) {
+        // Mentions `handle` some way not covered above.
+        return { kind: 'manual', instructions };
+    }
+    else {
+        // No handle yet: other hooks (handleError, init) stay as they are.
+        return {
+            kind: 'patched',
+            code: `${HOOK_IMPORTS.join('\n')}\n${source.trimEnd()}\n\nexport const handle = createCMSHook(cmsConfig);\n`
+        };
+    }
+    const hasSequence = /import\s*\{[^}]*\bsequence\b[^}]*\}\s*from\s*['"]@sveltejs\/kit\/hooks['"]/.test(source);
+    const imports = [
+        ...HOOK_IMPORTS,
+        ...(hasSequence ? [] : ["import { sequence } from '@sveltejs/kit/hooks';"])
+    ];
+    return {
+        kind: 'patched',
+        code: `${imports.join('\n')}\n${body.trimEnd()}\n\nexport const handle = sequence(createCMSHook(cmsConfig), ${name});\n`
+    };
+}
+const LOCALS_FIELDS = [
+    { key: 'aphexCMS', line: 'aphexCMS: CMSInstances;', type: 'CMSInstances' },
+    { key: 'aphexAuth', line: 'aphexAuth?: Auth;', type: 'Auth' }
+];
+const AUGMENT_IMPORT = "import '@aphexcms/cms-core/app-augment';";
+/** Adds whichever of Aphex's `locals`, and the imports they need, `App.Locals` lacks. */
+export function patchAppDts(source) {
+    const fields = LOCALS_FIELDS.filter(({ key }) => !new RegExp(`\\b${key}\\??\\s*:`).test(source));
+    const types = fields
+        .map(({ type }) => type)
+        .filter((type) => !new RegExp(`import\\s+type\\s*\\{[^}]*\\b${type}\\b`).test(source));
+    const needsAugment = !source.includes('@aphexcms/cms-core/app-augment');
+    if (fields.length === 0 && !needsAugment)
+        return { kind: 'unchanged' };
+    const imports = [
+        ...(types.length > 0
+            ? [`import type { ${types.join(', ')} } from '@aphexcms/cms-core/server';`]
+            : []),
+        ...(needsAugment ? [AUGMENT_IMPORT] : [])
+    ];
+    const instructions = [
+        ...imports,
+        ...(fields.length > 0
+            ? [
+                '',
+                'Inside declare global { namespace App { interface Locals { … } } }:',
+                ...fields.map(({ line }) => `\t${line}`)
+            ]
+            : [])
+    ].join('\n');
+    // Adding an import turns a script into a module, and in a module `namespace App`
+    // only augments the global one from inside `declare global`.
+    if (!/declare\s+global\s*\{/.test(source))
+        return { kind: 'manual', instructions };
+    let body = source;
+    if (fields.length > 0) {
+        const locals = source.match(/^([ \t]*)interface\s+Locals\s*\{[ \t]*(\}?)/m);
+        const commented = source.match(/^([ \t]*)\/\/\s*interface\s+Locals\s*\{\s*\}[ \t]*$/m);
+        const namespace = source.match(/^([ \t]*)namespace\s+App\s*\{[ \t]*$/m);
+        const lines = (indent) => fields.map(({ line }) => `${indent}${line}`).join('\n');
+        if (locals) {
+            // `interface Locals {}` on one line gets opened up.
+            const replacement = locals[2]
+                ? `${locals[1]}interface Locals {\n${lines(`${locals[1]}\t`)}\n${locals[1]}}`
+                : `${locals[1]}interface Locals {\n${lines(`${locals[1]}\t`)}`;
+            body = source.replace(locals[0], replacement);
+        }
+        else if (commented) {
+            const indent = commented[1];
+            body = source.replace(commented[0], `${indent}interface Locals {\n${lines(`${indent}\t`)}\n${indent}}`);
+        }
+        else if (namespace) {
+            const indent = `${namespace[1]}\t`;
+            body = source.replace(namespace[0], `${namespace[0]}\n${indent}interface Locals {\n${lines(`${indent}\t`)}\n${indent}}`);
+        }
+        else {
+            return { kind: 'manual', instructions };
+        }
+    }
+    return { kind: 'patched', code: imports.length > 0 ? `${imports.join('\n')}\n${body}` : body };
+}
+/** Appends missing lines, leaving everything already there alone. */
+export function appendMissingLines(source, lines, heading) {
+    const existing = new Set(source.split(/\r?\n/).map((line) => line.trim()));
+    const missing = lines.filter((line) => !existing.has(line));
+    if (missing.length === 0)
+        return { kind: 'unchanged' };
+    const separator = source === '' || source.endsWith('\n\n') ? '' : source.endsWith('\n') ? '\n' : '\n\n';
+    return { kind: 'patched', code: `${source}${separator}# ${heading}\n${missing.join('\n')}\n` };
+}
+/** Adds the `.env` keys the app doesn't set yet, never changing a value that's there. */
+export function patchEnv(source, entries) {
+    const keys = new Set(source
+        .split(/\r?\n/)
+        .map((line) => line.match(/^\s*(?:export\s+)?([A-Za-z_][A-Za-z0-9_]*)\s*=/)?.[1])
+        .filter((key) => Boolean(key)));
+    const missing = entries
+        .filter(([key]) => !keys.has(key))
+        .map(([key, value]) => `${key}=${value}`);
+    if (missing.length === 0)
+        return { kind: 'unchanged' };
+    return appendMissingLines(source, missing, 'Aphex');
+}

package/dist/init/plan.js

@@ -0,0 +1,102 @@
+import { existsSync, readFileSync } from 'node:fs';
+import { join } from 'node:path';
+import { appendMissingLines, patchAppDts, patchEnv, patchHooks, patchViteConfig } from './patch.js';
+import { adminPageServer, adminPageSvelte, aphexClient, aphexConfig, appDts, drizzleConfig, envEntries, hooksServer, packagesFor, schemaTypesIndex, titleFromName } from './templates.js';
+function read(app, path) {
+    const full = join(app.cwd, path);
+    return existsSync(full) ? readFileSync(full, 'utf8') : undefined;
+}
+/** A file only init writes: created when missing, otherwise left as the person has it. */
+function createOnly(app, path, content, reason = 'already exists') {
+    return read(app, path) === undefined
+        ? { path, action: 'create', content }
+        : { path, action: 'keep', reason };
+}
+/** A file the app may already have: patched in place, or created from scratch. */
+function patchOrCreate(app, path, create, patch) {
+    const source = read(app, path);
+    if (source === undefined)
+        return { path, action: 'create', content: create };
+    const result = patch(source);
+    if (result.kind === 'patched')
+        return { path, action: 'update', content: result.code };
+    if (result.kind === 'manual')
+        return { path, action: 'manual', instructions: result.instructions };
+    return { path, action: 'keep', reason: 'already set up for Aphex' };
+}
+function fromPatch(path, result) {
+    if (result.kind === 'patched')
+        return { path, action: 'update', content: result.code };
+    if (result.kind === 'manual')
+        return { path, action: 'manual', instructions: result.instructions };
+    return { path, action: 'keep', reason: 'already set up for Aphex' };
+}
+/**
+ * Everything init would do, worked out before anything is written, so `--dry-run`
+ * and the confirmation prompt show exactly what happens.
+ */
+export function buildPlan(app, choices, secret) {
+    const needsTailwind = !app.hasTailwindVitePlugin;
+    const changes = [
+        createOnly(app, 'aphex.config.ts', aphexConfig(choices, titleFromName(app.name))),
+        createOnly(app, 'src/lib/schemaTypes/index.ts', schemaTypesIndex),
+        createOnly(app, 'src/lib/aphex.client.ts', aphexClient),
+        {
+            path: 'src/routes/admin/[...path]/+page.server.ts',
+            action: 'create',
+            content: adminPageServer
+        },
+        { path: 'src/routes/admin/[...path]/+page.svelte', action: 'create', content: adminPageSvelte }
+    ];
+    if (app.viteConfig) {
+        changes.push(fromPatch(app.viteConfig, patchViteConfig(read(app, app.viteConfig) ?? '', needsTailwind)));
+    }
+    changes.push(app.hooksFile
+        ? fromPatch(app.hooksFile, patchHooks(read(app, app.hooksFile) ?? ''))
+        : { path: 'src/hooks.server.ts', action: 'create', content: hooksServer });
+    changes.push(patchOrCreate(app, 'src/app.d.ts', appDts, patchAppDts));
+    if (choices.database === 'postgres') {
+        const existing = read(app, 'drizzle.config.ts');
+        changes.push(existing === undefined
+            ? { path: 'drizzle.config.ts', action: 'create', content: drizzleConfig }
+            : existing.includes('@aphexcms/postgresql-adapter')
+                ? { path: 'drizzle.config.ts', action: 'keep', reason: 'already lists the Aphex tables' }
+                : {
+                    path: 'drizzle.config.ts',
+                    action: 'manual',
+                    instructions: [
+                        'Add the Aphex tables to schema:',
+                        "\t'./node_modules/@aphexcms/postgresql-adapter/dist/schema.js',",
+                        "\t'./node_modules/@aphexcms/auth/dist/schema/pg.js'"
+                    ].join('\n')
+                });
+    }
+    const entries = envEntries(choices, app.name, secret);
+    changes.push(fromPatchOrNew('.env', read(app, '.env'), (source) => patchEnv(source, entries)));
+    const example = read(app, '.env.example');
+    if (example !== undefined) {
+        // The example gets the keys but never the secret.
+        changes.push(fromPatch('.env.example', patchEnv(example, entries.map(([key, value]) => [key, key === 'AUTH_SECRET' ? '' : value]))));
+    }
+    const ignored = [
+        ...(choices.database === 'sqlite' ? ['.aphex'] : []),
+        ...(choices.storage === 'local' ? ['/storage'] : [])
+    ];
+    if (ignored.length > 0) {
+        changes.push(fromPatchOrNew('.gitignore', read(app, '.gitignore'), (source) => appendMissingLines(source, ignored, 'Aphex')));
+    }
+    const packages = packagesFor(choices, needsTailwind);
+    const bare = (spec) => spec.replace(/(.)@[^/]*$/, '$1');
+    return {
+        changes,
+        dependencies: packages.dependencies.filter((spec) => !app.installed.has(bare(spec))),
+        devDependencies: packages.devDependencies.filter((spec) => !app.installed.has(bare(spec)))
+    };
+}
+function fromPatchOrNew(path, source, patch) {
+    const result = patch(source ?? '');
+    if (result.kind === 'patched') {
+        return { path, action: source === undefined ? 'create' : 'update', content: result.code };
+    }
+    return fromPatch(path, result);
+}