@stjoseph/prumo 0.0.1

package/.prumo-templates/site/rendering.md

@@ -0,0 +1,83 @@
+# Rendering and data
+
+## Rule
+
+Use the App Router. Do not use the Pages Router, and do not mix the two.
+
+Keep every route static by default. Use revalidation where content changes without a deploy. Make a route
+dynamic only when the response depends on who asked, and write one comment line saying why.
+
+Fetch data on the server: in a Server Component or in the static generation function. Pass it to client
+components as props.
+
+Do not call the API from the browser to render a page. A browser call exists only for interaction after
+load, such as submitting a form.
+
+Treat calls from the site's server as anonymous. They carry no user cookie.
+
+**Before writing Next code, read the guide for the installed version in `node_modules/next/dist/docs/`.** It wins over
+anything remembered. Keep `agentRules: false` in `next.config.ts`.
+
+## Rationale
+
+This type exists because of SEO, so a page that does not arrive rendered defeats it. Fetching through
+`useQuery` would leave the generated HTML empty and show the crawler a shell, and then there was no
+reason to separate `site` from `web` at all.
+
+**The default must be static because in the App Router a route becomes dynamic by accident.** Reading a
+cookie, a header or a search param inside a Server Component switches the whole route to per-request
+rendering, with no error and no warning: a page that was instant starts waiting on a server. With a static
+default that is a departure from a written rule and shows up in review; with a dynamic default nobody
+notices.
+
+Making everything static forever breaks the first time somebody wants to publish a paragraph without
+calling a developer, which is what revalidation is for. Making everything dynamic inverts the cost: an
+institutional page that rarely changes would pay for a server on every visit, including the crawler's, and
+crawlers visit often.
+
+The site's server has no user, so there is nobody to authenticate as. A page needing authenticated data is
+neither static nor public, and probably does not belong to this type.
+
+**The installed documentation wins because Next says its own APIs moved.** Next 16 ships its guides inside the package
+and, when `next dev` detects an AI coding agent, writes a block into `AGENTS.md` telling it to read them, creating
+`AGENTS.md` and `CLAUDE.md` where none exist, which in a workspace means inside `apps/site`, beside the root's. The
+advice is kept here, where every other rule lives, and the automatic write is turned off so no second context file
+appears on its own.
+
+## Applies to
+
+Every route under `app/`.
+
+**This area uses half of `client/data.md`.** The wire contract (base URL, `/api/v1`, hand-written types,
+the `ApiError`) applies. The TanStack Query conventions do not: there is no client-side cache to key,
+invalidate or paginate.
+
+## Examples
+
+Where a fetch happens:
+
+```
+✅  // app/posts/page.tsx: a Server Component
+    const posts = await getPosts()
+❌  'use client'
+    const { data } = useQuery(postsQuery())
+```
+
+Going dynamic:
+
+```
+✅  // dynamic: the response depends on the visitor's country header
+❌  const country = headers().get('x-country')     // no comment, whole route now dynamic
+```
+
+## Enforcement
+
+**Review only, and this is the line that matters: nothing warns when a route slips into being dynamic.**
+The clue is indirect: somebody added a cookie or header read three components down, and the page quietly
+stopped being static. The symptom is latency, not an error.
+
+Also review: that no page renders its content from a browser fetch, and that a dynamic route carries its
+reason.
+
+**Worth knowing:** most written material about Next describes the Pages Router, so an assistant without
+this document mixes `getServerSideProps` with Server Components. They do not compose.

package/.prumo-templates/site/structure.md

@@ -0,0 +1,68 @@
+# Structure
+
+## Rule
+
+Organise by feature. Put what is reused across routes in `features/<name>/`.
+
+Keep a route's content in its own `page.tsx` or `layout.tsx`, alongside its `generateMetadata` and
+`generateStaticParams`. **Do not push a page's content into a feature.**
+
+Put shared code in one of four places and nowhere else:
+
+- `components/ui/`: shadcn primitives, where its CLI installs them
+- `api-contract/`: the wire contract with the API, as `client/data.md` describes, once a page calls the API
+- `lib/`: pure functions, with no state and no React
+- a named feature: anything with behaviour
+
+Do not create a `shared/` or `common/` folder.
+
+Style with Tailwind and shadcn/ui. Express variants with `cva`. Extract a repeated class list on its third
+occurrence, as a component.
+
+Resolve `@/` to the app's own `src/`.
+
+## Rationale
+
+**Metadata is part of a page's content, not of its navigation.** A title, a description and a share image
+describe that specific text, so separating them makes it easy to change one without the other, and a page
+with the wrong title is a defect that surfaces only when somebody shares the link.
+
+That is why this area departs from `web` and `mobile`, which both keep thin route files pointing at
+features. The departure is not preference: only in the App Router does a route file carry SEO metadata,
+and that is precisely what distinguishes this type.
+
+Everything else carries over from the web area for the reasons given there. A `shared/` folder has no
+admission criterion, so it only grows; not everything shared is a component, and a formatting helper is a
+function in a file. shadcn's plumbing (`cn()`, `cva`, the theme tokens) is used from the first
+hand-written component onward, whether or not any component is installed, which is why it is here even on
+a site with four screens.
+
+## Applies to
+
+Every file under `src/` and `app/`.
+
+## Examples
+
+Where a page lives:
+
+```
+✅  app/pricing/page.tsx        → the content and generateMetadata together
+❌  app/pricing/page.tsx        → renders <PricingPage/> from features/pricing
+```
+
+Shared code:
+
+```
+✅  features/newsletter/         // reused on three routes
+    lib/format-date.ts
+❌  shared/components/cta.tsx
+```
+
+## Enforcement
+
+**Review only.** That a page's metadata sits with its content, that no `shared/` folder appeared, and that
+a third repetition was extracted.
+
+**An asymmetry worth knowing:** `web` and `mobile` keep route files thin and push screens into features.
+This area does the opposite, and only for the metadata reason above. It is deliberate rather than an
+inconsistency to tidy up.

package/.prumo-templates/web/components.md

@@ -0,0 +1,106 @@
+# Components
+
+## Rule
+
+Edit a shadcn component in place. Do not wrap it, and do not keep a parallel component around it.
+
+Extract a repeated Tailwind class list on its **third** occurrence, and extract it as a component, never
+as a string constant.
+
+Express variants with `cva`, in every component, including ones that did not come from shadcn.
+
+Do not sort classes automatically, and do not add a Prettier plugin to do it.
+
+Components are built on Base UI. **Change the rendered element with the `render` prop, never `asChild`.** Pass
+`nativeButton={false}` when a button renders something that is not a `<button>`.
+
+## Rationale
+
+shadcn copies files into the project rather than shipping a dependency, so the component is yours to edit.
+Wrapping instead would produce a parallel set (a `Button` around `ui/Button`), and then every screen has
+to know which to import; half will import the wrong one, and the wrapper stops applying exactly where it
+mattered.
+
+The third occurrence is the threshold because the second is often not a repetition: two things that look
+alike today and diverge next week. Extracting then couples them, and the next change needs a prop to tell
+them apart. A number is arbitrary, and having one stops two developers and an assistant from each using a
+different threshold. A component rather than a string constant, because a constant shares appearance
+without structure: every site still writes its own wrapper, and there is nowhere to put the extra one
+when it is needed.
+
+`cva` is already present and already how every installed component is written. Using conditionals
+alongside it would leave two variant grammars in one project, divided by where a file came from, a
+boundary made of history rather than nature. It also declares the combinations, so TypeScript knows which
+values exist and a typo does not compile, where a concatenated string lets two conflicting variants
+coexist and the last class win by accident.
+
+**`render`, because `asChild` does not exist here** and is what almost every tutorial and every assistant's
+training shows: shadcn ran on Radix for years. The compiler rejects `asChild` on these components, and that is
+where the real risk starts: an assistant meeting the error tends to satisfy it the wrong way, by dropping the
+`Button` for a styled `Link` or by wrapping it. Base UI's own documentation states the difference in one line:
+Radix uses `asChild`, Base UI uses `render`.
+
+Class order in the attribute changes nothing: Tailwind generates the CSS in its own order, so sorting is
+cosmetic. Biome's rule for it is experimental, its fix is classified unsafe and therefore does not run in
+the pre-commit hook, and it does not yet handle screen variants or plugin utilities.
+
+## Applies to
+
+Every component under `src/`.
+
+## Examples
+
+Changing a primitive:
+
+```
+✅  edit components/ui/button.tsx
+❌  components/button.tsx exporting a wrapper around ui/Button
+```
+
+Extraction:
+
+```
+✅  third time the same list appears → <Card> component
+❌  second time → const cardClasses = "flex items-center gap-2 …"
+```
+
+Rendering a link as a button:
+
+```
+✅  <Button render={<Link to="/sign-up" />} nativeButton={false}>Sign up</Button>
+❌  <Button asChild><Link to="/sign-up">Sign up</Link></Button>     // Radix's idiom
+```
+
+Variants:
+
+```
+✅  cva('inline-flex …', { variants: { size: { sm: …, lg: … } } })
+❌  className={`inline-flex ${size === 'sm' ? 'h-8' : 'h-10'} ${tone}`}
+```
+
+## Enforcement
+
+**Compiler.** `cva` makes variant names typed, so a misspelled variant does not build. `asChild` on a Base UI
+component does not build either.
+
+**Review only.** That a third repetition was extracted, and that nobody wrapped a shadcn primitive instead
+of editing it.
+
+**Two things to know rather than discover:**
+
+`cn` is imported from the npm package **`cn`**, published by shadcn, which the CLI now installs in place of
+`clsx` and `tailwind-merge`. Code importing either of those is copied from older material.
+
+Biome's recommended preset rejects two things in generated primitives that are correct there (a label that
+receives `htmlFor` through props, and `role="group"` on a field), so those two rules are off for
+`components/ui/` only, as `core/tooling.md` records. Anything else it reports in generated code is fixed in
+place.
+
+`shadcn init` can stop on an interactive prompt even with `-y`. Pass every choice as a flag
+(`shadcn init -b base -p nova --no-monorepo -y`) rather than waiting on it.
+
+Re-running the shadcn CLI for a component **overwrites** your edits: it neither versions nor merges.
+Reinstalling one is a deliberate act with the diff inspected, not part of updating dependencies.
+
+Automatic class sorting is worth revisiting when Biome's `useSortedClasses` leaves the nursery group and
+its fix becomes safe. It then runs inside the existing hook with nothing else changing.

package/.prumo-templates/web/routing.md

@@ -0,0 +1,82 @@
+# Routing
+
+## Rule
+
+Define routes as files and let TanStack Router's Vite plugin generate the route tree. **Commit the
+generated tree.**
+
+Wrap everything requiring a session in an authenticated layout route that redirects in its `beforeLoad`.
+A public route is one placed outside that layout.
+
+Validate every search param with a Zod schema in the route's `validateSearch`. Let path params take the
+types the router derives from the file name.
+
+Let TanStack Query own the cache. Use a route loader only to call `ensureQueryData`, and read the data in
+the component through the Query hook. Never pass loader data down as props.
+
+## Rationale
+
+The generated route tree is committed because application code imports it, so without it `tsc` fails on a
+clean clone, breaking CI and the editor of whoever just cloned, and making *run the dev server first* a
+prerequisite for any task. The cost is merge conflicts on a generated file, always resolved by
+regenerating. A broken clone is worse than a predictable conflict.
+
+The authenticated layout means **protection is expressed by where a file lives**. For a route to be born
+unprotected, somebody has to place it outside the layout deliberately; forgetting is not enough.
+
+**Client-side protection is not security.** The API refuses through its own guard, so a forgotten
+redirect leaks nothing; it costs a flash of broken interface while the page mounts, fires a request and
+receives 401. This is stated so nobody treats the client as the boundary and relaxes on the server.
+
+A search param is untrusted input that does not pass through the API on its way in. Left unvalidated, a
+component feeding `?limit` into a request becomes the path by which a junk value reaches the server,
+which refuses it, but only after a round trip and with an error the user cannot read.
+
+The loader prefetches rather than fetches because two caches holding the same data is how *why did the
+screen not update* becomes unanswerable. Data handed down as props sits in no cache, so invalidating
+after a mutation never reaches it.
+
+## Applies to
+
+Every file under `routes/`.
+
+## Examples
+
+Protection by placement:
+
+```
+✅  routes/_authenticated/orders.tsx     → protected
+    routes/login.tsx                      → public
+❌  routes/orders.tsx with an if (!user) inside the component
+```
+
+Search params:
+
+```
+✅  validateSearch: z.object({ limit: z.number().max(100).default(20) })
+❌  validateSearch: (s) => s as { limit: number }
+```
+
+Loading data:
+
+```
+✅  loader: ({ context }) => context.queryClient.ensureQueryData(ordersQuery())
+    // component: useSuspenseQuery(ordersQuery())
+❌  loader: () => fetchOrders()
+    // component: props.orders
+```
+
+## Enforcement
+
+**Structural.** A route inside the authenticated layout cannot skip the redirect, because the layout runs
+first.
+
+**Compiler.** `validateSearch` makes the search params' types reflect what survived validation, so a
+component cannot read a field the schema does not produce.
+
+**Review only.** That the loader prefetches rather than returning data the component consumes, and that a
+route needing a session was not placed outside the layout.
+
+**A tie worth knowing:** the query key is shared between the loader and the component. If they differ, the
+prefetch fills one cache entry and the component reads another, paying for the request twice and gaining
+nothing. Where that key lives is settled in `data.md`.

package/.prumo-templates/web/structure.md

@@ -0,0 +1,92 @@
+# Structure
+
+## Rule
+
+Organise by feature. Put a feature's components, hooks and queries together in `features/<name>/`. Keep
+`routes/` for thin route definitions that point at features.
+
+**Do not organise by type.** There is no root `components/`, `hooks/` or `pages/` holding every
+feature's files.
+
+Put shared code in one of four places and nowhere else:
+
+- `components/ui/`: shadcn primitives, where its CLI installs them
+- `api-contract/`: the wire contract with the API, as `client/data.md` describes
+- `lib/`: pure functions, with no state and no React
+- a named feature: anything with behaviour
+
+Do not create a `shared/` or `common/` folder.
+
+Keep client state in React context, one context per subject, living in the feature that owns it. Do not
+create a single application context.
+
+Resolve `@/` to the app's own `src/`.
+
+## Rationale
+
+Feature-first is the same axis the API uses for modules, so *where do I go to change orders* has one
+answer at both ends of the project. A change then touches one folder instead of five. Organising by type
+optimises for *show me every hook*, which nobody asks; organising by feature optimises for *change this
+feature*, which is every task. This rule is written negatively because `components/`, `hooks/`, `pages/`
+is the layout of nearly every React tutorial and therefore the default an assistant reaches for.
+
+`components/ui/` is not a preference: the shadcn CLI installs there, and moving it would mean editing
+every install afterwards.
+
+A `shared/` folder has no admission criterion: *is this shared?* answers yes for anything used twice, so
+it only grows. Requiring a name forces the question *what is this*, and something nobody can name is not
+ready to be promoted. Not everything shared is a component, either: formatting a date is a function in a
+file. **If it uses React, it does not belong in `lib/`.**
+
+One context per subject exists because context re-renders **every** consumer when its value changes. A
+context bundling theme, sidebar and current user makes a theme toggle re-render the whole tree: invisible
+with three components, expensive when the screen grows, and never an error.
+
+## Applies to
+
+Every file under `src/`.
+
+## Examples
+
+Where a feature's code lives:
+
+```
+✅  features/orders/order-list.tsx
+    features/orders/use-orders.ts
+    routes/orders.tsx            → renders features/orders
+
+❌  components/orders/order-list.tsx
+    hooks/use-orders.ts
+    pages/orders.tsx
+```
+
+Shared code:
+
+```
+✅  lib/format-currency.ts          // pure
+    features/notifications/         // has behaviour, has a name
+❌  shared/utils.ts
+    shared/hooks/use-notifications.ts
+```
+
+Context:
+
+```
+✅  features/theme/theme-context.tsx
+❌  app-context.tsx                 // theme + sidebar + user
+```
+
+## Enforcement
+
+**Review only.** Nothing prevents a root `components/` folder from appearing, or a `shared/` from being
+created, or two contexts from being merged into one for tidiness.
+
+**Two things worth knowing rather than discovering:**
+
+Zustand was deliberately left out because TanStack Query owns server state and what remains is usually
+context-sized. If a project accumulates real client state and contexts start multiplying or re-rendering
+too widely, Zustand is the right answer again and installing it costs nothing. Context is not claimed to
+scale indefinitely.
+
+In a monorepo, `@/` means something different in each app, so a file moved between apps can compile while
+pointing somewhere else.

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Leonardo Freitas
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,110 @@
+<p align="center">
+  <img src="https://raw.githubusercontent.com/stjosephworks/prumo/main/docs/brand/brand.png" alt="Prumo" width="300">
+</p>
+
+<p align="center">
+  <a href="https://www.npmjs.com/package/@stjoseph/prumo"><img src="https://img.shields.io/npm/v/%40stjoseph%2Fprumo?color=1e3a5f&label=npm" alt="npm"></a>
+  <a href="https://github.com/stjosephworks/prumo/blob/main/LICENSE"><img src="https://img.shields.io/npm/l/%40stjoseph%2Fprumo?color=1e3a5f" alt="MIT"></a>
+</p>
+
+Prumo is a set of choices a team has already made, packaged so that starting a new TypeScript
+project does not mean making them all over again. Which framework, how a module is laid out, where
+the database rules live, how authentication is wired, what a test is allowed to assume: each of
+those was decided once, written down with the reasoning and with what the choice costs, and then
+turned into something that actually runs.
+
+Put briefly, Prumo is the validation of a well built project without heavy architectural
+bureaucracy, done up front instead of discovered three months in. Well built here does not mean
+heavily layered. Every choice follows what the framework itself already indicates, so there are no
+ports, no adapters, and no in house architecture to learn before writing the first endpoint.
+
+A new project receives two things. The first is code that already works: installed, wired together,
+and proven by starting rather than by compiling. The second is a `.prumo/` folder holding the
+conventions that code follows. Any AI assistant working in that repository reads the folder and
+knows the rules without anyone explaining them, which is the whole point: **the conventions live in
+the project, not in someone's head.**
+
+Applications differ, so the choices are not one fixed bundle. Three answers shape what arrives:
+which artefacts the project has, whether they sit alone or in one workspace, and whether the
+application serves several tenants. The same body of decisions covers an API on its own and a
+workspace holding four applications, without either one carrying rules it has no use for.
+
+## Requirements
+
+Node 22.17 or later, pnpm, and Docker for anything with an API.
+
+## Running it
+
+```sh
+pnpm dlx @stjoseph/prumo new my-app
+```
+
+It asks what to build, writes the project into `my-app/`, runs `git init`, and installs. Nothing is
+committed, so the first commit is yours and the diff shows everything Prumo wrote.
+
+Every question also has a flag, which is how CI runs it without a terminal. Outside an interactive
+terminal a missing answer is an error rather than a default, so nothing important gets decided by
+silence:
+
+```sh
+pnpm dlx @stjoseph/prumo new my-app --types api,web --single-tenant
+```
+
+| Flag | What it answers |
+|---|---|
+| `--types api,web,mobile,site` | What the project contains. More than one type makes a workspace |
+| `--alone` or `--monorepo` | How a single type is laid out |
+| `--multi-tenant` or `--single-tenant` | Whether the application serves several tenants |
+| `--skip-install` | Stops after writing the files |
+
+## What it generates
+
+| Type | What you get |
+|---|---|
+| `api` | NestJS, MikroORM on PostgreSQL, Better Auth in a schema of its own, Swagger, Vitest with Testcontainers |
+| `web` | Vite, React, TanStack Router and Query, Tailwind, shadcn/ui, forms validated with Zod |
+| `mobile` | Expo with Expo Router, NativeWind, MMKV, and the session kept in `expo-secure-store` |
+| `site` | Next on the App Router, static by default, for pages that have to be indexed |
+
+One type produces that project on its own. Several produce a pnpm workspace: each application under
+`apps/`, the wire contract shared through `packages/api-contract` so a change on one side breaks the
+other at typecheck, and one version per dependency held in a catalog.
+
+Every template is committed here in full, and none of them is generated by calling somebody else's
+scaffolder at install time. Each one installs, passes lint and typecheck, builds, starts, and passes
+its own tests before it ships. Versions are pinned exactly, with no carets, so two projects generated
+a month apart are the same project.
+
+## What lands in the project
+
+| File | What it is |
+|---|---|
+| `.prumo/` | The conventions, in nine areas. Only the areas the answers call for are copied |
+| `.prumo/INDEX.md` | One line per document. Generated by the tool, and safe to regenerate |
+| `AGENTS.md` | The pointer into `.prumo/`, read by Codex, Cursor, Copilot, Gemini CLI and others |
+| `CLAUDE.md` | An `@AGENTS.md` import, for Claude Code |
+
+The nine areas are `core`, `api`, `database`, `client`, `web`, `mobile`, `site`, `monorepo` and
+`multi-tenancy`. Only `core` ships unconditionally, because everything in it is true of every type;
+the rest follow the answers, since advice about a platform the project does not have is worse than
+no advice at all.
+
+Once written, those documents belong to the team. Prumo does not come back and rewrite them.
+
+## Where the rest is written
+
+| Document | Holds |
+|---|---|
+| [`docs/stack.md`](https://github.com/stjosephworks/prumo/blob/main/docs/stack.md) | What is locked, what was deliberately dropped, and the version floors |
+| [`docs/structure.md`](https://github.com/stjosephworks/prumo/blob/main/docs/structure.md) | The `.prumo/` layout, and the rule deciding which areas a project receives |
+| [`docs/DECISIONS.md`](https://github.com/stjosephworks/prumo/blob/main/docs/DECISIONS.md) | Every decision, why it won, and what it costs |
+| [`docs/OPEN-QUESTIONS.md`](https://github.com/stjosephworks/prumo/blob/main/docs/OPEN-QUESTIONS.md) | What has been raised and is still unresolved |
+
+## Status
+
+Prumo is in beta. `0.0.1` is the first published version: every template runs and every generated
+project is verified in CI, and what a generated project looks like can still change before 1.0.
+What is known to be missing is listed in [`docs/OPEN-QUESTIONS.md`](https://github.com/stjosephworks/prumo/blob/main/docs/OPEN-QUESTIONS.md), and
+`prumo new` is the only command. Updating a project's `.prumo/` in place comes after 1.0.
+
+MIT licensed. See [`LICENSE`](https://github.com/stjosephworks/prumo/blob/main/LICENSE).

package/dist/asker.js

@@ -0,0 +1,28 @@
+import * as prompt from '@clack/prompts';
+const TYPES = ['api', 'web', 'mobile', 'site'];
+function answered(value) {
+    if (prompt.isCancel(value)) {
+        prompt.cancel('Nothing was generated.');
+        process.exit(1);
+    }
+    return value;
+}
+export function terminalAsker(validateName) {
+    return {
+        name: async () => answered(await prompt.text({ message: 'Project name', validate: (v) => validateName(v ?? '') })),
+        types: async () => answered(await prompt.multiselect({
+            message: 'What does the project have?',
+            options: TYPES.map((type) => ({ value: type, label: type })),
+            required: true,
+        })),
+        architecture: async () => answered(await prompt.select({
+            message: 'One project, or a workspace ready to grow?',
+            options: [
+                { value: 'alone', label: 'alone' },
+                { value: 'monorepo', label: 'monorepo' },
+            ],
+            initialValue: 'alone',
+        })),
+        multiTenant: async () => answered(await prompt.confirm({ message: 'Is it multi-tenant?', initialValue: false })),
+    };
+}

package/dist/cli.js

@@ -0,0 +1,62 @@
+#!/usr/bin/env node
+import { existsSync } from 'node:fs';
+import { join, resolve } from 'node:path';
+import { parseArgs } from 'node:util';
+import * as prompt from '@clack/prompts';
+import { terminalAsker } from "./asker.js";
+import { generate } from "./generate.js";
+import { validateProjectName } from "./names.js";
+import { resolveAnswers } from "./questions.js";
+const USAGE = `Usage: prumo new [name] [--types api,web,mobile,site] [--alone | --monorepo]
+                  [--multi-tenant | --single-tenant] [--skip-install]`;
+function firstExisting(...candidates) {
+    const found = candidates.find((candidate) => existsSync(candidate));
+    if (found === undefined) {
+        throw new Error(`Cannot find ${candidates.join(' or ')}`);
+    }
+    return found;
+}
+async function main() {
+    const { values, positionals } = parseArgs({
+        allowPositionals: true,
+        options: {
+            types: { type: 'string' },
+            alone: { type: 'boolean', default: false },
+            monorepo: { type: 'boolean', default: false },
+            'multi-tenant': { type: 'boolean', default: false },
+            'single-tenant': { type: 'boolean', default: false },
+            'skip-install': { type: 'boolean', default: false },
+            help: { type: 'boolean', default: false },
+        },
+    });
+    const [command, name] = positionals;
+    if (values.help || command !== 'new') {
+        console.log(USAGE);
+        process.exit(values.help ? 0 : 1);
+    }
+    const interactive = process.stdin.isTTY === true && process.stdout.isTTY === true;
+    const answers = await resolveAnswers({
+        name,
+        types: values.types,
+        alone: values.alone,
+        monorepo: values.monorepo,
+        multiTenant: values['multi-tenant'],
+        singleTenant: values['single-tenant'],
+    }, interactive ? terminalAsker(validateProjectName) : undefined);
+    if (answers.types.length > 1) {
+        prompt.log.info(`${answers.types.length} types make a workspace: apps/ and packages/ under one root.`);
+    }
+    const here = import.meta.dirname;
+    await generate({
+        templates: firstExisting(join(here, '../templates'), join(here, '../../templates')),
+        knowledge: firstExisting(join(here, '../.prumo-templates'), join(here, '../../.prumo-templates')),
+        target: resolve(answers.name),
+        answers,
+        install: !values['skip-install'],
+    });
+    prompt.outro(`Created ${answers.name}.`);
+}
+main().catch((error) => {
+    console.error(error instanceof Error ? error.message : error);
+    process.exit(1);
+});