# Options Reference (/docs/cli/options)



## General Options [#general-options]

### `--yes, -y` [#--yes--y]

Use default configuration and skip interactive prompts.

```bash
create-hackhaton-space-stack --yes
```

### `--template <type>` [#--template-type]

Use a predefined project template:

* `none`: No template (default)
* `mern`: MongoDB, Express, React, Node.js stack
* `pern`: PostgreSQL, Express, React, Node.js stack
* `t3`: T3 stack configuration
* `uniwind`: UniWind React Native template

```bash
create-hackhaton-space-stack --template t3
```

### `--manual-db` [#--manual-db]

Skip automatic database setup prompts and use manual database configuration.

```bash
create-hackhaton-space-stack --manual-db
```

### `--dry-run` [#--dry-run]

Validate configuration, compatibility, and directory handling without writing files.

```bash
create-hackhaton-space-stack my-app --yes --dry-run
```

### `--package-manager <pm>` [#--package-manager-pm]

Choose package manager: `npm`, `pnpm`, or `bun`.

```bash
create-hackhaton-space-stack --package-manager bun
```

### `--install / --no-install` [#--install----no-install]

Control dependency installation after project creation.

```bash
create-hackhaton-space-stack --no-install
```

### `--open <target>` [#--open-target]

Open the generated project in an installed editor, IDE, or coding agent. Interactive runs show an
installed-tools-only picker after scaffolding. Use `none` to skip it explicitly.

```bash
create-hackhaton-space-stack my-app --yes --open zed
create-hackhaton-space-stack my-app --yes --open codex
```

Supported targets include Cursor, VS Code, VS Code Insiders, Zed, Windsurf, VSCodium, WebStorm,
IntelliJ IDEA, Sublime Text, Neovim, the Codex app (macOS only), Codex CLI, Claude Code, OpenCode,
Pi, Gemini CLI, GitHub Copilot CLI, Kiro CLI, Factory Droid, goose, Cline CLI, Continue CLI, Amp,
Aider, Qwen Code, Crush, Cursor Agent, T3 Code, and Orca.

The picker is skipped for `--yes`, CI, and non-interactive terminals. An explicit `--open` value
still works in those modes. JSON and programmatic creation never launch external applications.

### `--git / --no-git` [#--git----no-git]

Control Git repository initialization.

```bash
create-hackhaton-space-stack --no-git
```

### `--yolo` [#--yolo]

Bypass validations and compatibility checks. Not recommended for normal use.

```bash
create-hackhaton-space-stack --yolo
```

### `--verbose` [#--verbose]

Show detailed result information in JSON format after project creation.

```bash
create-hackhaton-space-stack --verbose
```

### `--render-title / --no-render-title` [#--render-title----no-render-title]

Control whether the ASCII art title is shown. Enabled by default.

```bash
# Hide the title (useful in CI)
create-hackhaton-space-stack --no-render-title
```

### `--directory-conflict <strategy>` [#--directory-conflict-strategy]

How to handle existing, non-empty target directories:

* `merge`: Keep unrelated files and replace conflicting generated files
* `overwrite`: Permanently clear the directory before scaffolding
* `increment`: Create a suffixed directory (e.g., `my-app-1`)
* `error`: Fail instead of prompting

The interactive prompt recommends the first available suffixed directory and requires an extra
confirmation before overwriting. Project targets and generated paths that pass through symbolic
links are rejected instead of being followed.

```bash
# Overwrite an existing directory without prompting
create-hackhaton-space-stack my-app --yes --directory-conflict overwrite

# Safely create a new directory name if it exists
create-hackhaton-space-stack my-app --yes --directory-conflict increment
```

### `--disable-analytics / --no-disable-analytics` [#--disable-analytics----no-disable-analytics]

Telemetry and analytics are disabled across Hackhaton-Space-Stack by default; this flag is retained for backward compatibility and performs no action.

```bash
create-hackhaton-space-stack --disable-analytics
```

For JSON-first automation, runtime schemas, and nested structured options, see [Agent Workflows](/docs/cli/agent-workflows).

## Database Options [#database-options]

### `--database <type>` [#--database-type]

Database type to use:

* `none`: No database
* `sqlite`: SQLite database
* `postgres`: PostgreSQL database
* `mysql`: MySQL database
* `mongodb`: MongoDB database

```bash
create-hackhaton-space-stack --database postgres
```

### `--orm <type>` [#--orm-type]

ORM to use with your database:

* `none`: No ORM
* `drizzle`: Drizzle ORM (TypeScript-first)
* `prisma`: Prisma ORM (feature-rich)
* `mongoose`: Mongoose ODM (for MongoDB)

```bash
create-hackhaton-space-stack --database postgres --orm drizzle
```

### `--db-setup <setup>` [#--db-setup-setup]

Database hosting/setup provider:

* `none`: Manual setup
* `turso`: Turso (SQLite)
* `d1`: Cloudflare D1 (SQLite; requires either Cloudflare Workers server deployment or `backend self` with Cloudflare web deployment)
* `neon`: Neon (PostgreSQL)
* `supabase`: Supabase (PostgreSQL)
* `prisma-postgres`: Prisma Postgres
* `planetscale`: PlanetScale (MySQL/PostgreSQL)
* `mongodb-atlas`: MongoDB Atlas
* `docker`: Local Docker containers

```bash
create-hackhaton-space-stack --database postgres --db-setup neon
```

If you need structured control over database provisioning behavior, use `dbSetupOptions` with `create-json` or the programmatic API. See [Agent Workflows](/docs/cli/agent-workflows).

## Backend Options [#backend-options]

### `--backend <framework>` [#--backend-framework]

Backend framework to use:

* `none`: No backend
* `hono`: Hono (fast, lightweight)
* `express`: Express.js (popular, mature)
* `fastify`: Fastify (fast, plugin-based)
* `elysia`: Elysia (Bun-native)
* `convex`: Convex backend
* `self`: Self-hosted/custom backend

```bash
create-hackhaton-space-stack --backend hono
```

### `--runtime <runtime>` [#--runtime-runtime]

Runtime environment:

* `none`: No specific runtime (only with `convex`, `none`, or `self` backend)
* `bun`: Bun runtime
* `node`: Node.js runtime
* `workers`: Cloudflare Workers

```bash
create-hackhaton-space-stack --backend hono --runtime bun
```

### `--api <type>` [#--api-type]

API layer type:

* `none`: No API layer
* `trpc`: tRPC (type-safe)
* `orpc`: oRPC (OpenAPI-compatible)

```bash
create-hackhaton-space-stack --api trpc
```

## Frontend Options [#frontend-options]

### `--frontend <types...>` [#--frontend-types]

Frontend frameworks (can specify multiple):

**Web Frameworks:**

* `tanstack-router`: React with TanStack Router
* `react-router`: React with React Router
* `tanstack-start`: React with TanStack Start (SSR)
* `next`: Next.js
* `nuxt`: Nuxt (Vue)
* `svelte`: SvelteKit
* `solid`: Solid (SSR)
* `astro`: Astro

**Native Frameworks:**

* `native-bare`: React Native (bare setup)
* `native-uniwind`: React Native with UniWind (NativeWind alternative)
* `native-unistyles`: React Native with Unistyles

**No Frontend:**

* `none`: Backend-only project

```bash
# Single web frontend
create-hackhaton-space-stack --frontend tanstack-router

# Web + native frontend
create-hackhaton-space-stack --frontend next native-uniwind

# Backend-only
create-hackhaton-space-stack --frontend none
```

## Authentication [#authentication]

### `--auth <provider>` [#--auth-provider]

Choose authentication provider:

* `better-auth`: better-auth authentication (default)
* `clerk`: Clerk authentication
* `none`: No authentication

```bash
create-hackhaton-space-stack --auth better-auth
create-hackhaton-space-stack --auth clerk
create-hackhaton-space-stack --auth none
```

**Note:**

* `better-auth` requires a backend framework (cannot be `none`)
* if you choose a database, you should also choose an ORM
* with `--backend convex`, `better-auth` supports `react-router`, `tanstack-router`, `tanstack-start`, `next`, and native Expo frontends
* `clerk` requires a compatible frontend
* Supported Clerk backends: `convex`, `hono`, `express`, `fastify`, `elysia`, and `self` with Next.js or TanStack Start
* Authentication is automatically set to `none` when using `--backend none`

## Payments [#payments]

### `--payments <provider>` [#--payments-provider]

Payments provider:

* `none`: No payments integration
* `polar`: Polar payments integration
* `stripe`: Stripe subscriptions
* `autumn`: Autumn billing on top of Stripe via Better Auth

```bash
create-hackhaton-space-stack --payments polar --auth better-auth
create-hackhaton-space-stack --payments stripe --auth better-auth
create-hackhaton-space-stack --payments autumn --auth better-auth
```

**Note:** Polar, Stripe, and Autumn payments require Better Auth. Stripe and Autumn are not supported with the Convex backend.

## Storage [#storage]

### `--storage <adapter>` [#--storage-adapter]

File storage adapter for uploads and object storage:

* `none`: No storage integration
* `s3`: Amazon S3
* `r2`: Cloudflare R2
* `hetzner`: Hetzner Object Storage
* `supabase`: Supabase Storage
* `neon`: Neon Storage
* `uploadthing`: UploadThing
* `convex`: Convex Storage (requires `--backend convex`)

```bash
create-hackhaton-space-stack --storage r2 --backend hono
```

**Note:** Storage requires a backend. Some adapters also require matching database setup (for example Supabase Storage with `--db-setup supabase`, or Neon Storage with `--db-setup neon`).

Generated projects include `packages/storage` with a unified [files-sdk](https://files-sdk.dev) adapter. Import with `import { files } from "@<project>/storage"`.

## Email [#email]

### `--email <provider>` [#--email-provider]

Transactional email adapter:

* `none`: No email integration
* `resend`: [Resend](https://resend.com)
* `postmark`: [Postmark](https://postmarkapp.com)
* `unosend`: [Unosend](https://unosend.com)
* `cloudflare-email`: Cloudflare Email Sending
* `ses`: AWS SES
* `sendgrid`: SendGrid
* `mailgun`: Mailgun

```bash
create-hackhaton-space-stack --email resend --backend hono
```

**Note:** Email requires a backend (`--backend` cannot be `none`).

Generated projects include `packages/email` with a unified [Email SDK](https://email-sdk.dev) adapter. Import with `import { email } from "@<project>/email"`.

## Addons [#addons]

### `--addons <types...>` [#--addons-types]

Additional features to include:

* `none`: No addons
* `pwa`: Progressive Web App support
* `tauri`: Desktop app support for static web output (not compatible with `--backend self`)
* `electrobun`: Lightweight desktop shell for static web output (not compatible with `--backend self`)
* `starlight`: Starlight documentation site
* `fumadocs`: Fumadocs documentation site
* `biome`: Biome linting and formatting
* `lefthook`: Git hooks with Lefthook
* `husky`: Git hooks with Husky
* `turborepo`: Turborepo monorepo setup
* `nx`: Nx monorepo setup
* `vite-plus`: Vite+ unified toolchain, workspace task runner, linting, formatting, and optional native Git hooks
* `ultracite`: Ultracite configuration
* `oxlint`: Oxlint + Oxfmt (linting & formatting)
* `mcp`: Install MCP servers, including Hackhaton Space Stack itself, with add-mcp
* `opentui`: OpenTUI components
* `wxt`: WXT browser extension framework
* `skills`: Install AI agent skills for coding assistants (Cursor, Claude Code, GitHub Copilot, etc.)
* `evlog`: Structured request logging for Hono, Express, Fastify, Elysia, or fullstack web backends
* `axiom`: Managed production observability through evlog and Alchemy

```bash
create-hackhaton-space-stack --addons pwa biome husky
```

## Examples [#examples]

### `--examples <types...>` [#--examples-types]

Example implementations to include:

* `none`: No examples
* `todo`: Todo app example
* `ai`: AI chat interface example

```bash
create-hackhaton-space-stack --examples todo ai
```

## Deployment [#deployment]

### `--web-deploy <setup>` [#--web-deploy-setup]

Web deployment configuration:

* `none`: No deployment setup
* `cloudflare`: Cloudflare Workers deployment (via Alchemy infrastructure as code)
* `prisma`: Prisma deployment via Alchemy (all generated web frameworks)
* `docker`: Self-hosted deployment with a Dockerfile and a root `docker-compose.yml`
* `vercel`: Vercel Services deployment with a root `vercel.json`

```bash
create-hackhaton-space-stack --web-deploy docker
```

When the app that consumes Neon, PlanetScale, or Prisma Postgres is deployed with Alchemy, the CLI asks how the database should be provisioned and defaults to Alchemy. You can instead choose the provider's automatic setup when available or configure an existing database manually. With Alchemy selected, the generated stack provisions the database, injects runtime credentials, and applies checked-in migrations. Run `alchemy login --configure` from `packages/infra`; no separate provider setup step is required. See the [Alchemy deployment guide](/docs/guides/cloudflare-alchemy) for details.

## Automation Surfaces [#automation-surfaces]

These are part of the CLI contract for agents and scripts even though they are commands or JSON fields instead of traditional flags:

* `create-json`
* `add-json`
* `schema --name <schema>` (including `hssConfigFile` for the `hss.jsonc` shape)
* `mcp`
* `addonOptions`
* `dbSetupOptions`

See [Agent Workflows](/docs/cli/agent-workflows) for examples.

### `--server-deploy <setup>` [#--server-deploy-setup]

Server deployment configuration:

* `none`: No deployment setup
* `cloudflare`: Cloudflare Workers deployment (when runtime is workers, via Alchemy infrastructure as code)
* `prisma`: Prisma deployment via Alchemy (requires the Bun or Node runtime)
* `docker`: Self-hosted deployment with a Dockerfile and a root `docker-compose.yml` (requires the bun or node runtime)
* `vercel`: Vercel Services deployment (requires the bun or node runtime)

```bash
create-hackhaton-space-stack --server-deploy docker
```

**Note:** The CLI displays this target simply as **Prisma**. The generated infrastructure uses Alchemy's Prisma provider. See the [Alchemy deployment guide](/docs/guides/cloudflare-alchemy) for details.

## History [#history]

### `history` [#history-1]

View your project creation history. Projects are tracked locally using platform-specific directories:

* **macOS**: `~/Library/Application Support/hackhaton-space-stack/history.json`
* **Linux**: `~/.local/share/hackhaton-space-stack/history.json`
* **Windows**: `%LOCALAPPDATA%\hackhaton-space-stack\Data\history.json`

```bash
# Show last 10 projects
create-hackhaton-space-stack history

# Show last 5 projects
create-hackhaton-space-stack history --limit 5

# Output as JSON
create-hackhaton-space-stack history --json

# Clear all history
create-hackhaton-space-stack history --clear
```

**Options:**

* `--limit <number>`: Number of entries to show (default: 10)
* `--clear`: Clear all project history
* `--json`: Output history as JSON

## Option Validation [#option-validation]

The CLI validates option combinations and will show errors for incompatible selections. See the [Compatibility](/docs/cli/compatibility) page for detailed rules.

## Examples [#examples-1]

### Full Configuration [#full-configuration]

```bash
create-hackhaton-space-stack \
  --database postgres \
  --orm drizzle \
  --backend hono \
  --runtime bun \
  --frontend tanstack-router \
  --api trpc \
  --auth better-auth \
  --payments none \
  --storage none \
  --email none \
  --addons pwa biome \
  --examples todo \
  --package-manager bun \
  --web-deploy cloudflare \
  --server-deploy cloudflare \
  --install
```

### Minimal Setup [#minimal-setup]

```bash
create-hackhaton-space-stack \
  --backend none \
  --frontend tanstack-router \
  --addons none \
  --examples none
```
