@stjoseph/prumo 0.5.1 → 0.6.1

package/dist/cli.js

@@ -1,6 +1,8 @@
 #!/usr/bin/env node
 import { parseArgs } from 'node:util';
 import * as prompt from '@clack/prompts';
+import { addApp } from "./add.js";
+import { TYPES } from "./apps.js";
 import { terminalAsker } from "./asker.js";
 import { assetsFor, requireAssets } from "./assets.js";
 import { cleanText, planClean } from "./clean.js";
@@ -29,6 +31,7 @@ async function runNew(args, json) {
         allowPositionals: true,
         options: {
             types: { type: 'string' },
+            app: { type: 'string', multiple: true },
             alone: { type: 'boolean', default: false },
             monorepo: { type: 'boolean', default: false },
             'multi-tenant': { type: 'boolean', default: false },
@@ -61,6 +64,7 @@ async function runNew(args, json) {
     const answers = await resolveAnswers({
         name,
         types: values.types,
+        apps: values.app,
         alone: values.alone,
         monorepo: values.monorepo,
         multiTenant: values['multi-tenant'],
@@ -72,8 +76,8 @@ async function runNew(args, json) {
         social: values.social,
         noSocial: values['no-social'],
     }, interactive ? terminalAsker((input) => projectProblem(input, cwd)) : undefined, cwd);
-    if (!json && answers.types.length > 1) {
-        prompt.log.info(`${answers.types.length} types make a workspace: apps/ and packages/ under one root.`);
+    if (!json && answers.architecture === 'monorepo' && answers.apps.length > 1) {
+        prompt.log.info(`${answers.apps.length} apps make a workspace: apps/ and packages/ under one root.`);
     }
     const { target, warnings, ...chosen } = answers;
     // Without --json a person is reading; with it, the warnings travel in the result instead.
@@ -95,6 +99,7 @@ async function runNew(args, json) {
             target,
             cwd,
             types: chosen.types,
+            apps: chosen.apps,
             architecture: chosen.architecture,
             installed: install,
         });
@@ -102,6 +107,47 @@ async function runNew(args, json) {
     }
     return { data: { ...chosen, target, installed: install, warnings }, text: '' };
 }
+async function runAdd(args, json) {
+    const { values, positionals } = parseArgs({
+        args,
+        allowPositionals: true,
+        options: {
+            'skip-install': { type: 'boolean', default: false },
+            json: { type: 'boolean', default: false },
+        },
+    });
+    const [type, name, ...extra] = positionals;
+    if (type === undefined || extra.length > 0) {
+        throw new CliError('usage', 'Usage: prumo add <type> [name], as in `prumo add web backoffice`.');
+    }
+    if (!TYPES.includes(type)) {
+        throw new CliError('invalid_app', `Unknown type: ${type}. Choose from ${TYPES.join(', ')}.`);
+    }
+    const install = !values['skip-install'];
+    const tools = toolChecks(systemProbe, install ? ['pnpm'] : []);
+    if (tools.some((check) => check.status !== 'ok')) {
+        throw new CliError('not_ready', 'This machine is missing something Prumo needs.', {
+            ready: false,
+            checks: tools,
+        });
+    }
+    const added = await addApp({
+        ...requireAssets(assetsFor(import.meta.dirname)),
+        cwd: process.cwd(),
+        type: type,
+        name,
+        install,
+        childOutput: json ? 'stderr' : 'inherit',
+    });
+    const steps = [
+        ...(install ? [] : ['pnpm install']),
+        `pnpm ${added.app.name}  # on port ${added.port}`,
+    ];
+    return {
+        data: added,
+        text: `Added ${added.app.name}, a ${added.app.type}, in apps/${added.app.name}.\nNext:\n${steps.map((step) => `  ${step}\n`).join('')}`,
+    };
+}
 async function runClean(args, json) {
     const { values } = parseArgs({
         args,
@@ -198,6 +244,9 @@ async function main(argv) {
         else if (name === 'new') {
             result = await runNew(args, json);
         }
+        else if (name === 'add') {
+            result = await runAdd(args, json);
+        }
         else {
             throw new CliError('unknown_command', `Unknown command "${name}". Run \`prumo help\`.`);
         }

package/dist/commands.js

@@ -9,6 +9,10 @@ export const COMMANDS = [
         summary: 'Generate a project and the .prumo/ context it follows; `.` generates into this empty directory',
         options: [
             { flag: '--types <list>', description: 'Comma-separated: api, web, mobile, site' },
+            {
+                flag: '--app <name>=<type>',
+                description: 'Advanced, repeatable: an app with a name of its own, as backoffice=web; only web and site may repeat',
+            },
             {
                 flag: '--alone',
                 description: 'One project of one type; without a terminal, one type needs this or --monorepo',
@@ -32,6 +36,12 @@ export const COMMANDS = [
             JSON_OPTION,
         ],
     },
+    {
+        name: 'add',
+        usage: 'prumo add <type> [name] [options]',
+        summary: 'Add an app to this workspace, named after its type unless a name is given; only the Prumo version that generated the project adds to it',
+        options: [{ flag: '--skip-install', description: 'Do not run pnpm install' }, JSON_OPTION],
+    },
     {
         name: 'db',
         usage: 'prumo db [options]',

package/dist/compose.js

@@ -1,9 +1,10 @@
 import { existsSync } from 'node:fs';
 import { cp, mkdir, readdir, readFile, rename, rm, writeFile } from 'node:fs/promises';
 import { join, relative, sep } from 'node:path';
+import { appsOfType, PORTS, portOf } from "./apps.js";
 import { applyFeatures, cutFeatures, NONE } from "./features.js";
 import { prependProperty, readJsonc, removeWhatBaseDeclares, setJsonc } from "./jsonc.js";
-const CLIENTS = ['web', 'mobile'];
+export const CLIENTS = ['web', 'mobile'];
 // One exception to one-version-per-dependency: stable NativeWind needs Tailwind 3.
 const NAMED_CATALOGS = [{ name: 'tailwind3', dependency: 'tailwindcss', major: '3' }];
 const NOT_COPIED = new Set([
@@ -18,6 +19,10 @@ const NOT_COPIED = new Set([
 const NOT_COPIED_SUFFIXES = ['.tsbuildinfo'];
 // The name inside the package, and the name it is restored to. npm deletes a dotted .gitignore from a tarball.
 const PACKAGED_AS = { gitignore: '.gitignore' };
+// The root's `dev` sets the API's database up first, in whichever directory the API was given.
+export function rootDevPrefix(api) {
+    return `node apps/${api}/scripts/database.mjs --check && `;
+}
 const CONTRACT_IMPORT = "'@/api-contract'";
 const CONTRACT_PACKAGE = '@app/api-contract';
 function dependencySections(pkg) {
@@ -46,9 +51,11 @@ export async function copyTemplate(source, destination) {
         }
     }
 }
-async function copyApp(templates, target, type) {
-    const destination = join(target, 'apps', type);
-    await copyTemplate(join(templates, type), destination);
+export async function copyApp(templates, target, app) {
+    const destination = join(target, 'apps', app.name);
+    await copyTemplate(join(templates, app.type), destination);
+    // The package is the app's name, which the root's `pnpm --filter <name>` finds it by.
+    await rewriteText(join(destination, 'package.json'), (text) => setJsonc(text, ['name'], app.name));
     // The workspace root carries both, for every app below it.
     for (const rootOnly of ['.githooks', '.gitattributes']) {
         await rm(join(destination, rootOnly), { recursive: true, force: true });
@@ -62,8 +69,8 @@ async function contractFiles(directory) {
     }
     return files;
 }
-async function extractContract(target, clients) {
-    const [first, ...others] = clients.map((client) => join(target, 'apps', client));
+export async function extractContract(target, clients) {
+    const [first, ...others] = clients.map((client) => join(target, 'apps', client.name));
     if (first === undefined) {
         return;
     }
@@ -79,15 +86,62 @@ async function extractContract(target, clients) {
     }
     await rename(join(first, 'src', 'api-contract'), join(target, 'packages', 'api-contract', 'src'));
     for (const client of [first, ...others]) {
-        for (const directory of ['src', 'test']) {
-            for (const file of await sourceFiles(join(client, directory)).catch(() => [])) {
-                await rewriteText(file, (text) => text.replaceAll(CONTRACT_IMPORT, `'${CONTRACT_PACKAGE}'`));
-            }
+        await importContract(client);
+    }
+}
+// A client of the workspace imports the contract from its package rather than from a copy of its own.
+async function importContract(client) {
+    for (const directory of ['src', 'test']) {
+        for (const file of await sourceFiles(join(client, directory)).catch(() => [])) {
+            await rewriteText(file, (text) => text.replaceAll(CONTRACT_IMPORT, `'${CONTRACT_PACKAGE}'`));
+        }
+    }
+    await rewriteText(join(client, 'package.json'), (text) => setJsonc(text, ['dependencies', CONTRACT_PACKAGE], 'workspace:*'));
+}
+// A client added to a workspace that already shares a contract takes the team's, which may have grown since, and
+// drops the template's copy.
+export async function joinContract(client) {
+    await rm(join(client, 'src', 'api-contract'), { recursive: true });
+    await importContract(client);
+}
+function setEnvLine(text, key, value, file) {
+    const line = new RegExp(`^${key}=.*$`, 'm');
+    if (!line.test(text)) {
+        throw new Error(`${file} no longer carries a ${key} line`);
+    }
+    return text.replace(line, `${key}=${value}`);
+}
+// A second web or site takes the next port of its type, written where the template wrote the first, and the API
+// trusts every web app, the first one first.
+async function placePorts(target, apps) {
+    for (const app of apps) {
+        const { key, from } = PORTS[app.type];
+        const port = portOf(apps, app);
+        const directory = join(target, 'apps', app.name);
+        if (port === from) {
+            continue;
+        }
+        const example = join(directory, '.env.example');
+        await rewriteText(example, (text) => setEnvLine(text, key, String(port), example));
+        if (app.type === 'site') {
+            await rewriteText(join(directory, 'package.json'), (text) => {
+                const start = readJsonc(text).scripts?.start ?? '';
+                if (!start.includes(`--port ${from}`)) {
+                    throw new Error(`${join(directory, 'package.json')} no longer starts on --port ${from}`);
+                }
+                return setJsonc(text, ['scripts', 'start'], start.replace(`--port ${from}`, `--port ${port}`));
+            });
         }
-        await rewriteText(join(client, 'package.json'), (text) => setJsonc(text, ['dependencies', CONTRACT_PACKAGE], 'workspace:*'));
+    }
+    const [api] = appsOfType(apps, 'api');
+    const webs = appsOfType(apps, 'web');
+    if (api !== undefined && webs.length > 1) {
+        const example = join(target, 'apps', api.name, '.env.example');
+        const origins = webs.map((web) => `http://localhost:${portOf(apps, web)}`).join(',');
+        await rewriteText(example, (text) => setEnvLine(text, 'WEB_ORIGIN', origins, example));
     }
 }
-function namedCatalogFor(dependency, version) {
+export function namedCatalogFor(dependency, version) {
     return NAMED_CATALOGS.find((entry) => entry.dependency === dependency && version.split('.')[0] === entry.major)?.name;
 }
 export function collectCatalog(packages) {
@@ -113,7 +167,7 @@ export function collectCatalog(packages) {
     }
     return catalogs;
 }
-async function adaptAppConfig(target, app) {
+export async function adaptAppConfig(target, app) {
     const packagePath = join(app, 'package.json');
     let pkg = await readFile(packagePath, 'utf8');
     const parsed = readJsonc(pkg);
@@ -143,7 +197,7 @@ async function adaptAppConfig(target, app) {
     const biome = removeWhatBaseDeclares(await readFile(biomePath, 'utf8'), rootBiome);
     await writeFile(biomePath, prependProperty(biome, 'extends', '//'));
 }
-async function takeBuildApprovals(app) {
+export async function takeBuildApprovals(app) {
     const path = join(app, 'pnpm-workspace.yaml');
     const text = await readFile(path, 'utf8').catch(() => undefined);
     if (text === undefined) {
@@ -185,20 +239,24 @@ async function assertCatalogCovers(target, catalog) {
         }
     }
 }
-export async function composeWorkspace({ templates, target, types, features = NONE, }) {
+export async function composeWorkspace({ templates, target, apps, features = NONE, }) {
     await mkdir(target, { recursive: true });
     await copyTemplate(join(templates, 'workspace'), target);
     // The root README tells a first run what the features change, so it is cut like any app's.
+    // It also points into the API's directory, which may have been given a name of its own.
     const readme = join(target, 'README.md');
-    await writeFile(readme, cutFeatures(await readFile(readme, 'utf8'), features, readme));
-    const apps = [];
-    for (const type of types) {
-        const app = await copyApp(templates, target, type);
+    const [api] = appsOfType(apps, 'api');
+    const cut = cutFeatures(await readFile(readme, 'utf8'), features, readme);
+    await writeFile(readme, cut.replaceAll('apps/api/', `apps/${api?.name ?? 'api'}/`));
+    const directories = [];
+    for (const app of apps) {
+        const directory = await copyApp(templates, target, app);
         // Before the catalog is collected, so a dependency that leaves never reaches it.
-        await applyFeatures(app, type, features);
-        apps.push(app);
+        await applyFeatures(directory, app.type, features);
+        directories.push(directory);
     }
-    const clients = CLIENTS.filter((client) => types.includes(client));
+    await placePorts(target, apps);
+    const clients = apps.filter((app) => CLIENTS.includes(app.type));
     if (clients.length > 0) {
         await extractContract(target, clients);
     }
@@ -210,18 +268,18 @@ export async function composeWorkspace({ templates, target, types, features = NO
     // parallel run would bury, so the root asks first and each app's own check then finds nothing to do.
     // `pnpm -r --parallel` starts each app in its own process group, so Ctrl+C reaches pnpm and leaves the apps
     // running. The ports script wraps the run, remembers what it started, and stops all of it on the way out.
-    const database = types.includes('api') ? 'node apps/api/scripts/database.mjs --check && ' : '';
+    const database = api === undefined ? '' : rootDevPrefix(api.name);
     const dev = `${database}node scripts/ports.mjs --all -- pnpm -r --parallel dev`;
-    await rewriteText(join(target, 'package.json'), (text) => types.reduce((pkg, type) => setJsonc(pkg, ['scripts', type], `pnpm --filter ${type} dev`), setJsonc(text, ['scripts', 'dev'], dev)));
-    const manifests = await Promise.all(apps.map(async (app) => readJsonc(await readFile(join(app, 'package.json'), 'utf8'))));
+    await rewriteText(join(target, 'package.json'), (text) => apps.reduce((pkg, app) => setJsonc(pkg, ['scripts', app.name], `pnpm --filter ${app.name} dev`), setJsonc(text, ['scripts', 'dev'], dev)));
+    const manifests = await Promise.all(directories.map(async (app) => readJsonc(await readFile(join(app, 'package.json'), 'utf8'))));
     const catalogs = collectCatalog(manifests);
     if (clients.length > 0) {
         await assertCatalogCovers(target, catalogs.default);
     }
     const approvals = [];
-    for (const app of apps) {
-        await adaptAppConfig(target, app);
-        for (const line of await takeBuildApprovals(app)) {
+    for (const directory of directories) {
+        await adaptAppConfig(target, directory);
+        for (const line of await takeBuildApprovals(directory)) {
             if (!approvals.includes(line)) {
                 approvals.push(line);
             }

package/dist/context.js

@@ -1,5 +1,7 @@
+import { existsSync } from 'node:fs';
 import { cp, mkdir, readdir, readFile, writeFile } from 'node:fs/promises';
 import { join } from 'node:path';
+import { appsOf } from "./apps.js";
 import { cliVersion } from "./version.js";
 const CLIENTS = ['web', 'mobile', 'site'];
 export function areasFor(answers) {
@@ -20,21 +22,23 @@ async function titleOf(path) {
     const firstLine = (await readFile(path, 'utf8')).split('\n', 1)[0] ?? '';
     return firstLine.replace(/^#\s*/, '');
 }
-export async function writeContext(knowledge, root, answers) {
-    const prumo = join(root, '.prumo');
+// The index lists every file of every area the project holds. It is the tool's file, so it is always rewritten.
+async function writeIndex(prumo, areas) {
     const lines = [];
-    await mkdir(prumo, { recursive: true });
-    for (const area of areasFor(answers)) {
-        await cp(join(knowledge, area), join(prumo, area), { recursive: true });
+    for (const area of areas) {
         for (const file of (await readdir(join(prumo, area))).filter((f) => f.endsWith('.md')).sort()) {
             lines.push(`- [${area}/${file}](${area}/${file}): ${await titleOf(join(prumo, area, file))}`);
         }
     }
     await writeFile(join(prumo, 'INDEX.md'), `# Conventions\n\n${lines.join('\n')}\n`);
+}
+async function writeConfig(prumo, answers) {
     // The version that wrote the project, so a tool reading it can tell a project made by an older Prumo.
     const config = {
         prumo: cliVersion(),
         types: answers.types,
+        // Only a workspace has apps/ to name a directory in.
+        ...(answers.architecture === 'monorepo' ? { apps: appsOf(answers) } : {}),
         architecture: answers.architecture,
         multiTenant: answers.multiTenant,
         mcp: answers.mcp,
@@ -42,6 +46,29 @@ export async function writeContext(knowledge, root, answers) {
         social: answers.social,
     };
     await writeFile(join(prumo, 'config.json'), `${JSON.stringify(config, null, 2)}\n`);
+}
+export async function writeContext(knowledge, root, answers) {
+    const prumo = join(root, '.prumo');
+    const areas = areasFor(answers);
+    await mkdir(prumo, { recursive: true });
+    for (const area of areas) {
+        await cp(join(knowledge, area), join(prumo, area), { recursive: true });
+    }
+    await writeIndex(prumo, areas);
+    await writeConfig(prumo, answers);
     await writeFile(join(root, 'AGENTS.md'), `# ${answers.name}\n\nThis project's conventions live in \`.prumo/\`. Read [\`.prumo/INDEX.md\`](.prumo/INDEX.md) before changing how something is done.\n`);
     await writeFile(join(root, 'CLAUDE.md'), '@AGENTS.md\n');
 }
+// A project that grew: the areas it now calls for and did not have arrive, and an area it had stays as the team left
+// it. The index and the config follow; AGENTS.md is the team's, and is not touched. Returns the areas that arrived.
+export async function growContext(knowledge, root, answers) {
+    const prumo = join(root, '.prumo');
+    const areas = areasFor(answers);
+    const arrived = areas.filter((area) => !existsSync(join(prumo, area)));
+    for (const area of arrived) {
+        await cp(join(knowledge, area), join(prumo, area), { recursive: true });
+    }
+    await writeIndex(prumo, areas);
+    await writeConfig(prumo, answers);
+    return arrived;
+}

package/dist/database.js

@@ -1,6 +1,7 @@
 import { spawnSync } from 'node:child_process';
 import { existsSync, readFileSync } from 'node:fs';
 import { dirname, join, resolve } from 'node:path';
+import { appDirectory, appsOf, appsOfType } from "./apps.js";
 import { CliError } from "./output.js";
 const SCRIPT = join('scripts', 'database.mjs');
 export function findProjectRoot(from) {
@@ -19,10 +20,8 @@ export function readConfig(root) {
 // Where the API sits, or undefined when the project has none.
 export function apiPath(root) {
     const config = readConfig(root);
-    if (!config.types.includes('api')) {
-        return undefined;
-    }
-    return config.architecture === 'alone' ? root : join(root, 'apps', 'api');
+    const [api] = appsOfType(appsOf(config), 'api');
+    return api === undefined ? undefined : appDirectory(root, config.architecture, api);
 }
 export function apiDirectory(root) {
     const api = apiPath(root);

package/dist/generate.js

@@ -2,6 +2,7 @@ import { randomBytes } from 'node:crypto';
 import { existsSync } from 'node:fs';
 import { readdir, readFile, rm, writeFile } from 'node:fs/promises';
 import { join } from 'node:path';
+import { appDirectory, appsOf, appsOfType } from "./apps.js";
 import { runCommand } from "./command.js";
 import { composeWorkspace, copyTemplate } from "./compose.js";
 import { writeContext } from "./context.js";
@@ -16,7 +17,7 @@ async function nameProject(root, name) {
     await rewrite(join(root, 'package.json'), (text) => setJsonc(text, ['name'], name));
     await rewrite(join(root, 'README.md'), (text) => text.replace(/^# .*$/m, `# ${name}`));
 }
-async function nameMobileApp(app, name) {
+export async function nameMobileApp(app, name) {
     await rewrite(join(app, 'app.json'), (text) => {
         let result = setJsonc(text, ['expo', 'name'], name);
         result = setJsonc(result, ['expo', 'slug'], name);
@@ -27,7 +28,7 @@ const SECRET_LINE = /^JWT_SECRET=.*$/m;
 const SCHEME_LINES = /^# The mobile app's scheme.*\nMOBILE_APP_SCHEME=.*\n/m;
 // Social sign-in sends a mobile app back by its scheme, the one app.json was given. Without a mobile app the setting
 // names nothing, so it goes. Without social sign-in its marker already took it.
-async function settleMobileScheme(api, scheme) {
+export async function settleMobileScheme(api, scheme) {
     for (const file of ['.env.example', '.env']) {
         const path = join(api, file);
         if (existsSync(path)) {
@@ -39,7 +40,7 @@ async function settleMobileScheme(api, scheme) {
 }
 // `.env` stays out of git, so the example is the committed truth and a fresh project gets a copy it can start with.
 // Only the secret differs: a sample value is public, so every generated API draws its own.
-async function writeLocalEnv(app, type) {
+export async function writeLocalEnv(app, type) {
     const example = join(app, '.env.example');
     if (!existsSync(example)) {
         return;
@@ -55,7 +56,7 @@ async function writeLocalEnv(app, type) {
 }
 // Compose names the container and volume after the project; without this, every workspace's apps/api is `api`
 // and a second project's database replaces the first's.
-async function nameCompose(api, name) {
+export async function nameCompose(api, name) {
     await rewrite(join(api, 'docker-compose.yml'), (text) => {
         if (!/^name: .*$/m.test(text)) {
             throw new Error(`${join(api, 'docker-compose.yml')} no longer carries a top-level name`);
@@ -69,12 +70,18 @@ let interrupted = false;
 function interrupt() {
     interrupted = true;
 }
+// From here until the returned function is called, Ctrl+C stops the next step instead of Prumo itself.
+export function watchInterrupt() {
+    interrupted = false;
+    process.on('SIGINT', interrupt);
+    return () => process.off('SIGINT', interrupt);
+}
 function stopIfInterrupted() {
     if (interrupted) {
         throw new CliError('interrupted', 'Interrupted. Nothing was kept.');
     }
 }
-function run(command, args, cwd, output) {
+export function run(command, args, cwd, output) {
     stopIfInterrupted();
     // Under --json stdout belongs to the result document, so a child's output goes to stderr instead.
     const result = runCommand(command, args, {
@@ -109,8 +116,7 @@ export async function generate({ templates, knowledge, target, answers, install,
         throw new CliError('target_not_empty', occupied);
     }
     const created = !existsSync(target);
-    interrupted = false;
-    process.on('SIGINT', interrupt);
+    const unwatch = watchInterrupt();
     try {
         await write({ templates, knowledge, target, answers, install, childOutput });
     }
@@ -119,11 +125,12 @@ export async function generate({ templates, knowledge, target, answers, install,
         throw error;
     }
     finally {
-        process.off('SIGINT', interrupt);
+        unwatch();
     }
 }
 async function write({ templates, knowledge, target, answers, install, childOutput, }) {
     const [only] = answers.types;
+    const apps = appsOf(answers);
     if (answers.architecture === 'alone' && only !== undefined) {
         await copyTemplate(join(templates, only), target);
         await applyFeatures(target, only, enabledFor(answers));
@@ -137,22 +144,18 @@ async function write({ templates, knowledge, target, answers, install, childOutp
         }
     }
     else {
-        await composeWorkspace({
-            templates,
-            target,
-            types: answers.types,
-            features: enabledFor(answers),
-        });
+        const at = (app) => join(target, 'apps', app.name);
+        await composeWorkspace({ templates, target, apps, features: enabledFor(answers) });
         await nameProject(target, answers.name);
-        for (const type of answers.types) {
-            await writeLocalEnv(join(target, 'apps', type), type);
+        for (const app of apps) {
+            await writeLocalEnv(at(app), app.type);
         }
-        if (answers.types.includes('api')) {
-            await nameCompose(join(target, 'apps', 'api'), answers.name);
-            await settleMobileScheme(join(target, 'apps', 'api'), answers.types.includes('mobile') ? schemeFor(answers.name) : null);
+        for (const api of appsOfType(apps, 'api')) {
+            await nameCompose(at(api), answers.name);
+            await settleMobileScheme(at(api), answers.types.includes('mobile') ? schemeFor(answers.name) : null);
         }
-        if (answers.types.includes('mobile')) {
-            await nameMobileApp(join(target, 'apps', 'mobile'), answers.name);
+        for (const mobile of appsOfType(apps, 'mobile')) {
+            await nameMobileApp(at(mobile), answers.name);
         }
     }
     await writeContext(knowledge, target, answers);
@@ -162,9 +165,8 @@ async function write({ templates, knowledge, target, answers, install, childOutp
         // Rewriting the contract import changes import grouping and line length; only the formatter can settle both.
         run('pnpm', ['exec', 'biome', 'check', '--write'], target, childOutput);
         // The route tree is generated from the route files, and cutting MCP removed one.
-        if (answers.types.includes('web')) {
-            const web = answers.architecture === 'alone' ? target : join(target, 'apps', 'web');
-            run('pnpm', ['exec', 'tsr', 'generate'], web, childOutput);
+        for (const web of appsOfType(apps, 'web')) {
+            run('pnpm', ['exec', 'tsr', 'generate'], appDirectory(target, answers.architecture, web), childOutput);
         }
     }
 }

package/dist/names.js

@@ -4,7 +4,8 @@ import { EXTENDED_BY_PNPM } from "./pnpm-extended.js";
 const PROJECT_NAME = /^[a-z][a-z0-9-]*$/;
 // npm refuses a longer package name.
 const MAX_LENGTH = 214;
-// In a workspace each app's package is named after its type, and `pnpm --filter <type>` would match the root too.
+// In a workspace an app's package is named after its type by default, and `pnpm --filter <type>` would match the
+// root too. A name given on purpose is checked against the project's in apps.ts.
 const RESERVED = ['api', 'web', 'mobile', 'site'];
 export function validateProjectName(name) {
     if (!PROJECT_NAME.test(name)) {

package/dist/next-steps.js

@@ -1,8 +1,9 @@
 import { relative } from 'node:path';
+import { appsOfType, defaultApps } from "./apps.js";
 // What to type after `prumo new`, built from the scripts the templates ship rather than written per case. Every app
 // and every workspace root answers to `pnpm dev`; an API's `dev` first offers to create the database, and a mobile
 // app opens only in a development build, which its `ios` and `android` scripts make.
-export function nextSteps({ target, cwd, types, architecture, installed, }) {
+export function nextSteps({ target, cwd, types, apps = defaultApps(types), architecture, installed, }) {
     const steps = [];
     const directory = relative(cwd, target);
     if (directory !== '') {
@@ -11,8 +12,8 @@ export function nextSteps({ target, cwd, types, architecture, installed, }) {
     if (!installed) {
         steps.push(['pnpm install']);
     }
-    if (types.includes('mobile')) {
-        const run = architecture === 'alone' ? 'pnpm' : 'pnpm --filter mobile';
+    for (const mobile of appsOfType(apps, 'mobile')) {
+        const run = architecture === 'alone' ? 'pnpm' : `pnpm --filter ${mobile.name}`;
         steps.push([`${run} ios`, 'or android: the development build the mobile app opens in']);
     }
     steps.push([

package/dist/questions.js

@@ -1,7 +1,7 @@
+import { defaultApps, parseApp, TYPES, typesOf, validateApps } from "./apps.js";
 import { SOCIAL_PROVIDERS } from "./features.js";
 import { projectAt, targetProblem, validateProjectName } from "./names.js";
 import { CliError } from "./output.js";
-const TYPES = ['api', 'web', 'mobile', 'site'];
 const TENANT_AWARE = ['api', 'web', 'mobile'];
 function missing(flag) {
     throw new CliError('needs_input', `Missing ${flag}. Outside an interactive terminal every answer must come from a flag.`);
@@ -59,18 +59,27 @@ export async function resolveAnswers(flags, asker, cwd = process.cwd()) {
     if (occupied !== undefined) {
         throw new CliError('target_not_empty', occupied);
     }
+    const named = (flags.apps ?? []).map(parseApp);
     let types;
     if (flags.types !== undefined) {
         types = parseTypes(flags.types);
     }
+    else if (named.length > 0) {
+        types = [];
+    }
     else if (asker !== undefined) {
         types = await asker.types();
     }
     else {
         missing('--types');
     }
+    // The types answered take their own names; an app named on purpose comes after them.
+    let apps = [...defaultApps(types), ...named];
     let architecture;
-    if (types.length > 1) {
+    if (named.length > 0 && flags.alone) {
+        throw new CliError('invalid_input', '--app names an app inside a workspace; drop --alone.');
+    }
+    if (apps.length > 1 || named.length > 0) {
         if (flags.alone) {
             throw new CliError('invalid_input', '--alone holds a single type; several types make a workspace.');
         }
@@ -85,6 +94,16 @@ export async function resolveAnswers(flags, asker, cwd = process.cwd()) {
     else {
         missing('--alone or --monorepo');
     }
+    // Renaming an app, or adding another web or site, is for those who ask: offered once, after the types were asked
+    // rather than passed, and answered no by default. With flags, --app says it.
+    if (architecture === 'monorepo' &&
+        flags.types === undefined &&
+        named.length === 0 &&
+        asker !== undefined) {
+        apps = await asker.apps(apps, name);
+    }
+    validateApps(apps, name);
+    types = typesOf(apps);
     let multiTenant = false;
     if (!types.some((type) => TENANT_AWARE.includes(type))) {
         if (flags.multiTenant) {
@@ -162,5 +181,5 @@ export async function resolveAnswers(flags, asker, cwd = process.cwd()) {
         warnings.push('Without --email no password account is ever confirmed, so the first sign-in with a provider for an existing ' +
             "account's email removes its password: the owner keeps the account through the provider. --email avoids it.");
     }
-    return { name, types, architecture, multiTenant, mcp, email, social, target, warnings };
+    return { name, types, apps, architecture, multiTenant, mcp, email, social, target, warnings };
 }