@aex.is/zero 0.1.0

package/LICENSE

@@ -0,0 +1,15 @@
+Copyright (c) 2026 Aexis Zero
+
+All rights reserved.
+
+This software and associated documentation files (the "Software") are proprietary
+and confidential. No part of the Software may be copied, modified, distributed,
+published, sublicensed, or sold without prior written permission from the copyright
+holder.
+
+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,26 @@
+# Aexis Zero
+
+A cross-platform interactive CLI for scaffolding modern apps with a terminal UI.
+
+## Install (global)
+
+```sh
+npm install -g @aex.is/zero
+```
+
+## Usage
+
+```sh
+zero
+```
+
+## Requirements
+
+- Bun installed and available on PATH.
+
+## Development
+
+```sh
+bun install
+bun run dev
+```

package/package.json

@@ -0,0 +1,39 @@
+{
+  "name": "@aex.is/zero",
+  "version": "0.1.0",
+  "description": "Aexis Zero scaffolding CLI",
+  "license": "UNLICENSED",
+  "type": "module",
+  "bin": {
+    "zero": "src/index.ts"
+  },
+  "main": "dist/index.js",
+  "files": [
+    "dist",
+    "src",
+    "README.md",
+    "LICENSE"
+  ],
+  "publishConfig": {
+    "access": "public"
+  },
+  "scripts": {
+    "build": "tsc -p tsconfig.json",
+    "dev": "bun run src/index.ts",
+    "start": "node dist/index.js"
+  },
+  "dependencies": {
+    "execa": "^8.0.1",
+    "ink": "^4.4.1",
+    "ink-text-input": "^5.0.1",
+    "react": "^18.3.1",
+    "react-dom": "^18.3.1",
+    "which": "^4.0.0"
+  },
+  "devDependencies": {
+    "@types/node": "^20.11.30",
+    "@types/react": "^18.3.3",
+    "@types/react-dom": "^18.3.0",
+    "typescript": "^5.5.4"
+  }
+}

package/src/config/frameworks.ts

@@ -0,0 +1,95 @@
+import type { FrameworkId } from '../types.js';
+
+export interface FrameworkDefinition {
+  id: FrameworkId;
+  label: string;
+  description: string;
+  packages: string[];
+  scaffold: {
+    command: string;
+    packageName: string;
+    argSets: string[][];
+  };
+}
+
+export const frameworks: FrameworkDefinition[] = [
+  {
+    id: 'nextjs',
+    label: 'Next.js',
+    description: 'React framework with App Router and Tailwind.',
+    packages: [],
+    scaffold: {
+      command: 'bunx',
+      packageName: 'create-next-app@latest',
+      argSets: [
+        [
+          '--ts',
+          '--eslint',
+          '--tailwind',
+          '--turbo',
+          '--app',
+          '--no-src-dir',
+          '--import-alias',
+          '@/*',
+          '--use-bun',
+          '--skip-install'
+        ],
+        [
+          '--ts',
+          '--eslint',
+          '--tailwind',
+          '--turbo',
+          '--app',
+          '--no-src-dir',
+          '--import-alias',
+          '@/*',
+          '--use-bun'
+        ],
+        [
+          '--ts',
+          '--eslint',
+          '--tailwind',
+          '--turbo',
+          '--app',
+          '--no-src-dir',
+          '--import-alias',
+          '@/*'
+        ],
+        [
+          '--ts',
+          '--eslint',
+          '--tailwind',
+          '--app',
+          '--no-src-dir',
+          '--import-alias',
+          '@/*'
+        ]
+      ]
+    }
+  },
+  {
+    id: 'expo',
+    label: 'Expo (React Native)',
+    description: 'Expo app with Router and EAS configuration.',
+    packages: ['expo-router'],
+    scaffold: {
+      command: 'bunx',
+      packageName: 'create-expo-app',
+      argSets: [
+        ['--template', 'expo-router', '--yes', '--no-install'],
+        ['--template', 'expo-router', '--yes'],
+        ['--yes', '--no-install'],
+        ['--yes'],
+        []
+      ]
+    }
+  }
+];
+
+export function getFrameworkDefinition(id: FrameworkId): FrameworkDefinition {
+  const framework = frameworks.find((item) => item.id === id);
+  if (!framework) {
+    throw new Error(`Unknown framework: ${id}`);
+  }
+  return framework;
+}

package/src/config/modules.ts

@@ -0,0 +1,82 @@
+import type { FrameworkId, ModuleId } from '../types.js';
+
+export interface ModuleDefinition {
+  id: ModuleId;
+  label: string;
+  description: string;
+  envVars: string[];
+  packages: Record<FrameworkId, string[]>;
+}
+
+export const modules: ModuleDefinition[] = [
+  {
+    id: 'neon',
+    label: 'Database (Neon)',
+    description: 'Serverless Postgres with Neon.',
+    envVars: ['DATABASE_URL'],
+    packages: {
+      nextjs: ['@neondatabase/serverless'],
+      expo: ['@neondatabase/serverless']
+    }
+  },
+  {
+    id: 'clerk',
+    label: 'Auth (Clerk)',
+    description: 'Authentication with Clerk.',
+    envVars: ['CLERK_PUBLISHABLE_KEY', 'CLERK_SECRET_KEY'],
+    packages: {
+      nextjs: ['@clerk/nextjs'],
+      expo: ['@clerk/clerk-expo']
+    }
+  },
+  {
+    id: 'payload',
+    label: 'CMS (Payload)',
+    description: 'Headless CMS using Payload.',
+    envVars: ['PAYLOAD_SECRET', 'DATABASE_URL'],
+    packages: {
+      nextjs: ['payload'],
+      expo: ['payload']
+    }
+  },
+  {
+    id: 'stripe',
+    label: 'Payments (Stripe)',
+    description: 'Payments via Stripe SDK.',
+    envVars: ['STRIPE_SECRET_KEY', 'STRIPE_WEBHOOK_SECRET'],
+    packages: {
+      nextjs: ['stripe'],
+      expo: ['stripe']
+    }
+  }
+];
+
+export function getModuleDefinition(id: ModuleId): ModuleDefinition {
+  const module = modules.find((item) => item.id === id);
+  if (!module) {
+    throw new Error(`Unknown module: ${id}`);
+  }
+  return module;
+}
+
+export function getModulePackages(moduleIds: ModuleId[], framework: FrameworkId): string[] {
+  const packages = new Set<string>();
+  for (const id of moduleIds) {
+    const module = getModuleDefinition(id);
+    for (const pkg of module.packages[framework]) {
+      packages.add(pkg);
+    }
+  }
+  return Array.from(packages).sort();
+}
+
+export function getModuleEnvVars(moduleIds: ModuleId[]): string[] {
+  const envVars = new Set<string>();
+  for (const id of moduleIds) {
+    const module = getModuleDefinition(id);
+    for (const envVar of module.envVars) {
+      envVars.add(envVar);
+    }
+  }
+  return Array.from(envVars).sort();
+}

package/src/engine/env.ts

@@ -0,0 +1,12 @@
+import path from 'path';
+import { promises as fs } from 'fs';
+import type { ModuleId } from '../types.js';
+import { getModuleEnvVars } from '../config/modules.js';
+
+export async function writeEnvExample(moduleIds: ModuleId[], targetDir: string): Promise<void> {
+  const envVars = getModuleEnvVars(moduleIds);
+  const lines = envVars.map((key) => `${key}=`);
+  const content = lines.length > 0 ? `${lines.join('\n')}\n` : '';
+  const envPath = path.join(targetDir, '.env.example');
+  await fs.writeFile(envPath, content, 'utf8');
+}

package/src/engine/installers.ts

@@ -0,0 +1,44 @@
+import { execa } from 'execa';
+import type { FrameworkId, ModuleId } from '../types.js';
+import { getModulePackages } from '../config/modules.js';
+
+const baseEnv = {
+  ...process.env,
+  CI: '1'
+};
+
+export async function installBaseDependencies(targetDir: string, extraPackages: string[] = []): Promise<void> {
+  if (extraPackages.length > 0) {
+    const packages = Array.from(new Set(extraPackages)).sort();
+    await execa('bun', ['add', ...packages], {
+      cwd: targetDir,
+      stdio: 'inherit',
+      env: baseEnv,
+      shell: false
+    });
+    return;
+  }
+  await execa('bun', ['install'], {
+    cwd: targetDir,
+    stdio: 'inherit',
+    env: baseEnv,
+    shell: false
+  });
+}
+
+export async function installModulePackages(
+  framework: FrameworkId,
+  moduleIds: ModuleId[],
+  targetDir: string
+): Promise<void> {
+  const packages = getModulePackages(moduleIds, framework);
+  if (packages.length === 0) {
+    return;
+  }
+  await execa('bun', ['add', ...packages], {
+    cwd: targetDir,
+    stdio: 'inherit',
+    env: baseEnv,
+    shell: false
+  });
+}

package/src/engine/scaffold.ts

@@ -0,0 +1,218 @@
+import path from 'path';
+import { promises as fs } from 'fs';
+import { execa } from 'execa';
+import type { ProjectConfig } from '../types.js';
+import { getFrameworkDefinition } from '../config/frameworks.js';
+import { installBaseDependencies, installModulePackages } from './installers.js';
+import { writeEnvExample } from './env.js';
+import {
+  nextLayoutTemplate,
+  nextPageTemplate,
+  expoLayoutTemplate,
+  expoIndexTemplate
+} from './templates.js';
+
+const baseEnv = {
+  ...process.env,
+  CI: '1'
+};
+
+export async function scaffoldProject(config: ProjectConfig): Promise<void> {
+  const targetDir = path.resolve(process.cwd(), config.appName);
+  await ensureEmptyTargetDir(targetDir);
+
+  const framework = getFrameworkDefinition(config.framework);
+
+  console.log(`Scaffolding ${framework.label}...`);
+  await runScaffoldCommand(framework.scaffold.command, framework.scaffold.packageName, config.appName, framework.scaffold.argSets);
+
+  console.log('Applying framework templates...');
+  if (config.framework === 'nextjs') {
+    await applyNextTemplates(targetDir);
+  } else {
+    await applyExpoTemplates(targetDir);
+  }
+
+  console.log('Installing base dependencies with Bun...');
+  await installBaseDependencies(targetDir, framework.packages);
+
+  console.log('Installing module packages...');
+  await installModulePackages(config.framework, config.modules, targetDir);
+
+  console.log('Generating .env.example...');
+  await writeEnvExample(config.modules, targetDir);
+
+  console.log('Scaffold complete.');
+  const cdTarget = config.appName.includes(' ') ? `"${config.appName}"` : config.appName;
+  console.log(`\nNext steps:\n  1) cd ${cdTarget}\n  2) bun run dev`);
+}
+
+async function ensureEmptyTargetDir(targetDir: string): Promise<void> {
+  try {
+    const stat = await fs.stat(targetDir);
+    if (!stat.isDirectory()) {
+      throw new Error('Target path exists and is not a directory.');
+    }
+    const entries = await fs.readdir(targetDir);
+    if (entries.length > 0) {
+      throw new Error('Target directory is not empty.');
+    }
+  } catch (error) {
+    if (isErrnoException(error) && error.code === 'ENOENT') {
+      return;
+    }
+    throw error;
+  }
+}
+
+async function runScaffoldCommand(
+  command: string,
+  packageName: string,
+  appName: string,
+  argSets: string[][]
+): Promise<void> {
+  const errors: string[] = [];
+  for (const args of argSets) {
+    try {
+      await execa(command, [packageName, appName, ...args], {
+        stdio: 'inherit',
+        env: baseEnv,
+        shell: false
+      });
+      return;
+    } catch (error) {
+      errors.push(formatError(error));
+    }
+  }
+  const message = errors.length > 0
+    ? `Scaffold failed after ${errors.length} attempts:\n${errors.join('\n')}`
+    : 'Scaffold failed for unknown reasons.';
+  throw new Error(message);
+}
+
+async function applyNextTemplates(targetDir: string): Promise<void> {
+  const rootAppDir = path.join(targetDir, 'app');
+  const srcAppDir = path.join(targetDir, 'src', 'app');
+  const appDir = (await pathExists(srcAppDir)) ? srcAppDir : rootAppDir;
+  await fs.mkdir(appDir, { recursive: true });
+  await fs.writeFile(path.join(appDir, 'layout.tsx'), nextLayoutTemplate, 'utf8');
+  await fs.writeFile(path.join(appDir, 'page.tsx'), nextPageTemplate, 'utf8');
+  await ensureNextTurbo(targetDir);
+}
+
+async function applyExpoTemplates(targetDir: string): Promise<void> {
+  const appDir = path.join(targetDir, 'app');
+  await fs.mkdir(appDir, { recursive: true });
+  await fs.writeFile(path.join(appDir, '_layout.tsx'), expoLayoutTemplate, 'utf8');
+  await fs.writeFile(path.join(appDir, 'index.tsx'), expoIndexTemplate, 'utf8');
+  await ensureExpoConfig(targetDir);
+}
+
+async function ensureExpoConfig(targetDir: string): Promise<void> {
+  const appJsonPath = path.join(targetDir, 'app.json');
+  const appJson = await readJson<Record<string, any>>(appJsonPath, { expo: {} });
+  if (!appJson.expo || typeof appJson.expo !== 'object') {
+    appJson.expo = {};
+  }
+
+  if (!Array.isArray(appJson.expo.platforms)) {
+    appJson.expo.platforms = ['ios', 'android', 'macos', 'windows'];
+  } else {
+    const current = appJson.expo.platforms.filter((value: unknown) => typeof value === 'string');
+    appJson.expo.platforms = mergeUnique(current, ['ios', 'android', 'macos', 'windows']);
+  }
+
+  if (!Array.isArray(appJson.expo.plugins)) {
+    appJson.expo.plugins = ['expo-router'];
+  } else {
+    const current = appJson.expo.plugins.filter((value: unknown) => typeof value === 'string');
+    appJson.expo.plugins = mergeUnique(current, ['expo-router']);
+  }
+
+  await writeJson(appJsonPath, appJson);
+
+  const packageJsonPath = path.join(targetDir, 'package.json');
+  const packageJson = await readJson<Record<string, any>>(packageJsonPath, {});
+  packageJson.main = 'expo-router/entry';
+  await writeJson(packageJsonPath, packageJson);
+
+  const easPath = path.join(targetDir, 'eas.json');
+  const easConfig = {
+    cli: {
+      version: '>= 8.0.0'
+    },
+    build: {
+      development: {
+        developmentClient: true,
+        distribution: 'internal'
+      },
+      preview: {
+        distribution: 'internal'
+      },
+      production: {}
+    },
+    submit: {}
+  };
+  await writeJson(easPath, easConfig);
+}
+
+function mergeUnique(values: string[], additions: string[]): string[] {
+  const set = new Set(values);
+  for (const value of additions) {
+    set.add(value);
+  }
+  return Array.from(set);
+}
+
+async function readJson<T>(filePath: string, fallback: T): Promise<T> {
+  try {
+    const data = await fs.readFile(filePath, 'utf8');
+    return JSON.parse(data) as T;
+  } catch (error) {
+    if (isErrnoException(error) && error.code === 'ENOENT') {
+      return fallback;
+    }
+    throw error;
+  }
+}
+
+async function writeJson(filePath: string, value: unknown): Promise<void> {
+  const data = JSON.stringify(value, null, 2);
+  await fs.writeFile(filePath, `${data}\n`, 'utf8');
+}
+
+function formatError(error: unknown): string {
+  if (error instanceof Error) {
+    return error.message;
+  }
+  return String(error);
+}
+
+function isErrnoException(error: unknown): error is NodeJS.ErrnoException {
+  return error instanceof Error && 'code' in error;
+}
+
+async function pathExists(targetPath: string): Promise<boolean> {
+  try {
+    await fs.stat(targetPath);
+    return true;
+  } catch (error) {
+    if (isErrnoException(error) && error.code === 'ENOENT') {
+      return false;
+    }
+    throw error;
+  }
+}
+
+async function ensureNextTurbo(targetDir: string): Promise<void> {
+  const packageJsonPath = path.join(targetDir, 'package.json');
+  const packageJson = await readJson<Record<string, any>>(packageJsonPath, {});
+  if (!packageJson.scripts || typeof packageJson.scripts !== 'object') {
+    packageJson.scripts = {};
+  }
+  const currentDev = typeof packageJson.scripts.dev === 'string' ? packageJson.scripts.dev : 'next dev';
+  if (!currentDev.includes('--turbo')) {
+    packageJson.scripts.dev = `${currentDev} --turbo`;
+  }
+  await writeJson(packageJsonPath, packageJson);
+}

package/src/engine/templates.ts

@@ -0,0 +1,42 @@
+export const nextLayoutTemplate = `import type { ReactNode } from 'react';
+
+export const metadata = {
+  title: 'Aexis Zero App',
+  description: 'Scaffolded by Aexis Zero.'
+};
+
+export default function RootLayout({
+  children
+}: {
+  children: ReactNode;
+}) {
+  return (
+    <html lang="en">
+      <body>{children}</body>
+    </html>
+  );
+}
+`;
+
+export const nextPageTemplate = `export default function Home() {
+  return <main />;
+}
+`;
+
+export const expoLayoutTemplate = `import { Stack } from 'expo-router';
+
+export default function RootLayout() {
+  return <Stack screenOptions={{ headerShown: false }} />;
+}
+`;
+
+export const expoIndexTemplate = `import { Text, View } from 'react-native';
+
+export default function Home() {
+  return (
+    <View style={{ flex: 1, alignItems: 'center', justifyContent: 'center' }}>
+      <Text>Aexis Zero</Text>
+    </View>
+  );
+}
+`;

package/src/env/detect.ts

@@ -0,0 +1,40 @@
+import which from 'which';
+import type { Platform, ShellFlavor } from '../types.js';
+
+export function detectPlatform(): Platform {
+  switch (process.platform) {
+    case 'darwin':
+      return 'macos';
+    case 'win32':
+      return 'windows';
+    case 'linux':
+      return 'linux';
+    default:
+      return 'linux';
+  }
+}
+
+export function detectShell(platform: Platform = detectPlatform()): ShellFlavor {
+  return platform === 'windows' ? 'powershell' : 'posix';
+}
+
+export async function isBunAvailable(): Promise<boolean> {
+  try {
+    await which('bun');
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+export async function assertBunAvailable(): Promise<void> {
+  const available = await isBunAvailable();
+  if (!available) {
+    const platform = detectPlatform();
+    const shell = detectShell(platform);
+    const hint = platform === 'windows'
+      ? 'Install Bun for Windows and reopen PowerShell.'
+      : 'Install Bun and ensure it is on your PATH.';
+    throw new Error(`Bun is required but was not found in PATH. (${platform}/${shell}) ${hint}`);
+  }
+}

package/src/index.ts

@@ -0,0 +1,48 @@
+#!/usr/bin/env bun
+import React from 'react';
+import { render } from 'ink';
+import { App } from './ui/App.js';
+import { assertBunAvailable } from './env/detect.js';
+import { scaffoldProject } from './engine/scaffold.js';
+import type { ProjectConfig } from './types.js';
+
+async function main(): Promise<void> {
+  try {
+    await assertBunAvailable();
+  } catch (error) {
+    const message = error instanceof Error ? error.message : String(error);
+    console.error(message);
+    process.exitCode = 1;
+    return;
+  }
+
+  let config: ProjectConfig | null = null;
+  const { waitUntilExit } = render(
+    <App
+      onComplete={(result) => {
+        config = result;
+      }}
+    />
+  );
+
+  await waitUntilExit();
+
+  if (!config) {
+    console.log('Cancelled.');
+    return;
+  }
+
+  try {
+    await scaffoldProject(config);
+  } catch (error) {
+    const message = error instanceof Error ? error.message : String(error);
+    console.error(`Error: ${message}`);
+    process.exitCode = 1;
+  }
+}
+
+main().catch((error) => {
+  const message = error instanceof Error ? error.message : String(error);
+  console.error(`Error: ${message}`);
+  process.exitCode = 1;
+});

package/src/types.ts

@@ -0,0 +1,12 @@
+export type Platform = 'macos' | 'linux' | 'windows';
+export type ShellFlavor = 'posix' | 'powershell';
+
+export type FrameworkId = 'nextjs' | 'expo';
+export type ModuleId = 'neon' | 'clerk' | 'payload' | 'stripe';
+
+export interface ProjectConfig {
+  appName: string;
+  domain: string;
+  framework: FrameworkId;
+  modules: ModuleId[];
+}

package/src/ui/App.tsx

@@ -0,0 +1,139 @@
+import React, { useCallback, useRef, useState } from 'react';
+import { Box, Text, useApp } from 'ink';
+import type { FrameworkId, ModuleId, ProjectConfig } from '../types.js';
+import { Intro } from './screens/Intro.js';
+import { NamePrompt } from './screens/NamePrompt.js';
+import { DomainPrompt } from './screens/DomainPrompt.js';
+import { FrameworkSelect } from './screens/FrameworkSelect.js';
+import { ModuleSelect } from './screens/ModuleSelect.js';
+import { Confirm, ConfirmAction } from './screens/Confirm.js';
+
+export type Step = 'intro' | 'name' | 'domain' | 'framework' | 'modules' | 'confirm';
+
+interface AppProps {
+  onComplete: (config: ProjectConfig | null) => void;
+}
+
+export function App({ onComplete }: AppProps) {
+  const { exit } = useApp();
+  const [step, setStep] = useState<Step>('intro');
+  const [resumeStep, setResumeStep] = useState<Step | null>(null);
+  const [name, setName] = useState('');
+  const [domain, setDomain] = useState('');
+  const [framework, setFramework] = useState<FrameworkId>('nextjs');
+  const [modules, setModules] = useState<ModuleId[]>([]);
+  const completedRef = useRef(false);
+
+  const finish = useCallback(
+    (config: ProjectConfig | null) => {
+      if (completedRef.current) {
+        return;
+      }
+      completedRef.current = true;
+      onComplete(config);
+      exit();
+    },
+    [exit, onComplete]
+  );
+
+  const goNext = useCallback(
+    (next: Step) => {
+      if (resumeStep) {
+        setStep(resumeStep);
+        setResumeStep(null);
+        return;
+      }
+      setStep(next);
+    },
+    [resumeStep]
+  );
+
+  const handleConfirmAction = useCallback(
+    (action: ConfirmAction) => {
+      switch (action) {
+        case 'continue':
+          finish({
+            appName: name,
+            domain,
+            framework,
+            modules
+          });
+          return;
+        case 'cancel':
+          finish(null);
+          return;
+        case 'edit-name':
+          setResumeStep('confirm');
+          setStep('name');
+          return;
+        case 'edit-domain':
+          setResumeStep('confirm');
+          setStep('domain');
+          return;
+        case 'edit-framework':
+          setResumeStep('confirm');
+          setStep('framework');
+          return;
+        case 'edit-modules':
+          setResumeStep('confirm');
+          setStep('modules');
+          return;
+        default:
+          return;
+      }
+    },
+    [domain, finish, framework, modules, name]
+  );
+
+  return (
+    <Box flexDirection="column">
+      {step === 'intro' ? null : (
+        <Text color="cyan">Aexis Zero</Text>
+      )}
+      {step === 'intro' ? (
+        <Intro onContinue={() => setStep('name')} />
+      ) : null}
+      {step === 'name' ? (
+        <NamePrompt
+          initialValue={name}
+          onSubmit={(value) => {
+            setName(value);
+            goNext('domain');
+          }}
+        />
+      ) : null}
+      {step === 'domain' ? (
+        <DomainPrompt
+          initialValue={domain}
+          onSubmit={(value) => {
+            setDomain(value);
+            goNext('framework');
+          }}
+        />
+      ) : null}
+      {step === 'framework' ? (
+        <FrameworkSelect
+          value={framework}
+          onChange={setFramework}
+          onConfirm={() => goNext('modules')}
+        />
+      ) : null}
+      {step === 'modules' ? (
+        <ModuleSelect
+          value={modules}
+          onChange={setModules}
+          onConfirm={() => goNext('confirm')}
+        />
+      ) : null}
+      {step === 'confirm' ? (
+        <Confirm
+          name={name}
+          domain={domain}
+          framework={framework}
+          modules={modules}
+          onAction={handleConfirmAction}
+        />
+      ) : null}
+    </Box>
+  );
+}

package/src/ui/components/SelectList.tsx

@@ -0,0 +1,114 @@
+import React, { useCallback, useMemo, useState } from 'react';
+import { Box, Text, useInput } from 'ink';
+
+export interface SelectItem {
+  id: string;
+  label: string;
+  description?: string;
+}
+
+interface SelectListProps {
+  items: SelectItem[];
+  selectedIds: string[];
+  onChange: (next: string[]) => void;
+  onSubmit: () => void;
+  multi?: boolean;
+  hint?: string;
+}
+
+export function SelectList({
+  items,
+  selectedIds,
+  onChange,
+  onSubmit,
+  multi = false,
+  hint
+}: SelectListProps) {
+  const [index, setIndex] = useState(0);
+
+  const selectedSet = useMemo(() => new Set(selectedIds), [selectedIds]);
+
+  const move = useCallback(
+    (delta: number) => {
+      setIndex((current) => {
+        const next = current + delta;
+        if (next < 0) {
+          return items.length - 1;
+        }
+        if (next >= items.length) {
+          return 0;
+        }
+        return next;
+      });
+    },
+    [items.length]
+  );
+
+  const toggle = useCallback(
+    (itemId: string) => {
+      if (multi) {
+        const next = new Set(selectedSet);
+        if (next.has(itemId)) {
+          next.delete(itemId);
+        } else {
+          next.add(itemId);
+        }
+        onChange(Array.from(next));
+      } else {
+        onChange([itemId]);
+      }
+    },
+    [multi, onChange, selectedSet]
+  );
+
+  useInput((input, key) => {
+    if (key.upArrow) {
+      move(-1);
+      return;
+    }
+    if (key.downArrow) {
+      move(1);
+      return;
+    }
+    if (input === ' ') {
+      const item = items[index];
+      if (item) {
+        toggle(item.id);
+      }
+      return;
+    }
+    if (key.return) {
+      onSubmit();
+    }
+  });
+
+  return (
+    <Box flexDirection="column">
+      <Box flexDirection="column">
+        {items.map((item, idx) => {
+          const isSelected = selectedSet.has(item.id);
+          const isActive = idx === index;
+          const prefix = isActive ? '>' : ' ';
+          const marker = multi
+            ? isSelected
+              ? '[x]'
+              : '[ ]'
+            : isSelected
+              ? '(x)'
+              : '( )';
+          return (
+            <Box key={item.id} flexDirection="column">
+              <Text color={isActive ? 'cyan' : undefined}>
+                {prefix} {marker} {item.label}
+              </Text>
+              {item.description ? (
+                <Text color="gray">  {item.description}</Text>
+              ) : null}
+            </Box>
+          );
+        })}
+      </Box>
+      {hint ? <Text color="gray">{hint}</Text> : null}
+    </Box>
+  );
+}

package/src/ui/screens/Confirm.tsx

@@ -0,0 +1,62 @@
+import React, { useState } from 'react';
+import { Box, Text } from 'ink';
+import { SelectList, SelectItem } from '../components/SelectList.js';
+import { frameworks } from '../../config/frameworks.js';
+import { modules } from '../../config/modules.js';
+import type { FrameworkId, ModuleId } from '../../types.js';
+
+export type ConfirmAction =
+  | 'continue'
+  | 'edit-name'
+  | 'edit-domain'
+  | 'edit-framework'
+  | 'edit-modules'
+  | 'cancel';
+
+interface ConfirmProps {
+  name: string;
+  domain: string;
+  framework: FrameworkId;
+  modules: ModuleId[];
+  onAction: (action: ConfirmAction) => void;
+}
+
+const actionItems: SelectItem[] = [
+  { id: 'continue', label: 'Continue' },
+  { id: 'edit-name', label: 'Edit name' },
+  { id: 'edit-domain', label: 'Edit domain' },
+  { id: 'edit-framework', label: 'Edit framework' },
+  { id: 'edit-modules', label: 'Edit modules' },
+  { id: 'cancel', label: 'Cancel' }
+];
+
+export function Confirm({ name, domain, framework, modules: selectedModules, onAction }: ConfirmProps) {
+  const [selection, setSelection] = useState<ConfirmAction>('continue');
+
+  const frameworkLabel = frameworks.find((item) => item.id === framework)?.label ?? framework;
+  const moduleLabels = selectedModules
+    .map((id) => modules.find((item) => item.id === id)?.label ?? id)
+    .join(', ');
+
+  return (
+    <Box flexDirection="column">
+      <Text color="cyan">Confirm</Text>
+      <Box flexDirection="column" marginTop={1}>
+        <Text>App name: {name}</Text>
+        <Text>Domain: {domain || 'None'}</Text>
+        <Text>Framework: {frameworkLabel}</Text>
+        <Text>Modules: {moduleLabels || 'None'}</Text>
+      </Box>
+      <Box marginTop={1}>
+        <SelectList
+          items={actionItems}
+          selectedIds={[selection]}
+          onChange={(next) => setSelection(next[0] as ConfirmAction)}
+          onSubmit={() => onAction(selection)}
+          multi={false}
+          hint="Select an action and press Enter."
+        />
+      </Box>
+    </Box>
+  );
+}

package/src/ui/screens/DomainPrompt.tsx

@@ -0,0 +1,29 @@
+import React, { useState } from 'react';
+import { Box, Text } from 'ink';
+import TextInput from 'ink-text-input';
+
+interface DomainPromptProps {
+  initialValue: string;
+  onSubmit: (value: string) => void;
+}
+
+export function DomainPrompt({ initialValue, onSubmit }: DomainPromptProps) {
+  const [value, setValue] = useState(initialValue);
+
+  const handleSubmit = () => {
+    onSubmit(value.trim());
+  };
+
+  return (
+    <Box flexDirection="column">
+      <Text color="cyan">Domain (optional)</Text>
+      <Text color="gray">Press Enter to continue or leave blank.</Text>
+      <TextInput
+        value={value}
+        onChange={setValue}
+        onSubmit={handleSubmit}
+        placeholder="example.com"
+      />
+    </Box>
+  );
+}

package/src/ui/screens/FrameworkSelect.tsx

@@ -0,0 +1,34 @@
+import React from 'react';
+import { Box, Text } from 'ink';
+import { SelectList, SelectItem } from '../components/SelectList.js';
+import { frameworks } from '../../config/frameworks.js';
+import type { FrameworkId } from '../../types.js';
+
+interface FrameworkSelectProps {
+  value: FrameworkId;
+  onChange: (value: FrameworkId) => void;
+  onConfirm: () => void;
+}
+
+export function FrameworkSelect({ value, onChange, onConfirm }: FrameworkSelectProps) {
+  const items: SelectItem[] = frameworks.map((framework) => ({
+    id: framework.id,
+    label: framework.label,
+    description: framework.description
+  }));
+
+  return (
+    <Box flexDirection="column">
+      <Text color="cyan">Framework</Text>
+      <Text color="gray">Use arrows to move, space to select, Enter to confirm.</Text>
+      <SelectList
+        items={items}
+        selectedIds={[value]}
+        onChange={(next) => onChange(next[0] as FrameworkId)}
+        onSubmit={onConfirm}
+        multi={false}
+        hint="( ) radio select"
+      />
+    </Box>
+  );
+}

package/src/ui/screens/Intro.tsx

@@ -0,0 +1,31 @@
+import React from 'react';
+import { Box, Text, useInput } from 'ink';
+
+interface IntroProps {
+  onContinue: () => void;
+}
+
+const introArt = [
+  '   _____',
+  '  / ___ \\ ',
+  ' / / _ \\ \\ ',
+  ' | |/ /| |',
+  ' \\ \\_/ / /',
+  '  \\___/_/'
+].join('\n');
+
+export function Intro({ onContinue }: IntroProps) {
+  useInput((input, key) => {
+    if (key.return || input === ' ') {
+      onContinue();
+    }
+  });
+
+  return (
+    <Box flexDirection="column">
+      <Text>{introArt}</Text>
+      <Text color="cyan">Aexis Zero</Text>
+      <Text color="gray">Press Enter to begin.</Text>
+    </Box>
+  );
+}

package/src/ui/screens/ModuleSelect.tsx

@@ -0,0 +1,34 @@
+import React from 'react';
+import { Box, Text } from 'ink';
+import { SelectList, SelectItem } from '../components/SelectList.js';
+import { modules } from '../../config/modules.js';
+import type { ModuleId } from '../../types.js';
+
+interface ModuleSelectProps {
+  value: ModuleId[];
+  onChange: (value: ModuleId[]) => void;
+  onConfirm: () => void;
+}
+
+export function ModuleSelect({ value, onChange, onConfirm }: ModuleSelectProps) {
+  const items: SelectItem[] = modules.map((module) => ({
+    id: module.id,
+    label: module.label,
+    description: module.description
+  }));
+
+  return (
+    <Box flexDirection="column">
+      <Text color="cyan">Modules</Text>
+      <Text color="gray">Use arrows to move, space to toggle, Enter to confirm.</Text>
+      <SelectList
+        items={items}
+        selectedIds={value}
+        onChange={(next) => onChange(next as ModuleId[])}
+        onSubmit={onConfirm}
+        multi
+        hint="[ ] multi-select"
+      />
+    </Box>
+  );
+}

package/src/ui/screens/NamePrompt.tsx

@@ -0,0 +1,37 @@
+import React, { useState } from 'react';
+import { Box, Text } from 'ink';
+import TextInput from 'ink-text-input';
+
+interface NamePromptProps {
+  initialValue: string;
+  onSubmit: (value: string) => void;
+}
+
+export function NamePrompt({ initialValue, onSubmit }: NamePromptProps) {
+  const [value, setValue] = useState(initialValue);
+  const [error, setError] = useState('');
+
+  const handleSubmit = () => {
+    const trimmed = value.trim();
+    if (!trimmed) {
+      setError('App name is required.');
+      return;
+    }
+    setError('');
+    onSubmit(trimmed);
+  };
+
+  return (
+    <Box flexDirection="column">
+      <Text color="cyan">App name</Text>
+      <Text color="gray">Required. Press Enter to continue.</Text>
+      <TextInput
+        value={value}
+        onChange={setValue}
+        onSubmit={handleSubmit}
+        placeholder="my-app"
+      />
+      {error ? <Text color="red">{error}</Text> : null}
+    </Box>
+  );
+}