@creatorem/cli 0.0.1 → 1.0.4

package/package.json

@@ -1,17 +1,38 @@
 {
   "name": "@creatorem/cli",
-  "version": "0.0.1",
+  "version": "1.0.4",
   "description": "CLI tool for Creatorem SaaS Kit",
   "author": "Creatorem",
   "license": "MIT",
   "type": "module",
   "bin": {
-    "creatorem": "./bin/cli.mjs"
+    "creatorem": "./dist/cli.js"
   },
-  "publishConfig": {
-    "access": "public"
+  "dependencies": {
+    "ink": "^6.7.0",
+    "ink-gradient": "^4.0.0",
+    "ink-spinner": "^5.0.0",
+    "ink-text-input": "^6.0.0",
+    "meow": "^14.0.0",
+    "pastel": "^4.0.0",
+    "react": "^19.2.4",
+    "fs-extra": "^11.2.0",
+    "ts-morph": "^25.0.1",
+    "execa": "^9.5.2"
+  },
+  "devDependencies": {
+    "@types/node": "^25.2.3",
+    "@types/react": "^19.2.14",
+    "tsup": "^8.5.1",
+    "tsx": "^4.21.0",
+    "typescript": "^5.9.3",
+    "@kit/tsconfig": "0.0.0"
   },
   "scripts": {
-    "build": "echo 'no build needed'"
+    "clean": "git clean -xdf .turbo node_modules",
+    "build": "tsup",
+    "dev": "tsup --watch",
+    "start": "node dist/cli.js",
+    "test": "bash ./tests/test-cli-features.sh"
   }
 }

package/src/cli.tsx

@@ -0,0 +1,141 @@
+#!/usr/bin/env node
+import React from 'react';
+import { render } from 'ink';
+import meow from 'meow';
+import readline from 'readline';
+import fs from 'fs';
+import path from 'path';
+import App from './ui/app.js';
+
+const cli = meow(
+	`
+	Usage
+	  $ creatorem <command>
+
+	Commands
+	  create              Create a new Creatorem monorepo from scratch (use outside the repo)
+	  generate-migration  Generate a migration file from schemas
+	  generate-schemas    Generate schemas from setup.json
+	  create-dashboard    Add/configure a dashboard app inside an existing monorepo
+	  create-mobile       Add/configure a mobile app inside an existing monorepo
+	  help                Show help
+
+	Options
+	  --version, -v       Print the CLI version and exit
+	  --help              Show help
+	  --edit              Edit feature removals in-place (on current monorepo)
+	  --features          Comma-separated list of features to keep
+	  --repo-scope        Also clean up kit packages and supabase schemas in the monorepo root
+
+	Examples
+	  $ creatorem create my-saas
+	  $ creatorem create                        (interactive — prompts for name)
+	  $ creatorem generate-migration
+	  $ creatorem create-mobile --edit
+	  $ creatorem generate-schemas apps/web/setup.json
+	  $ creatorem create-dashboard my-app --features ai,keybindings --repo-scope
+`,
+	{
+		importMeta: import.meta,
+		autoVersion: false, // handled manually to support both --version and -v
+		flags: {
+			version: { type: 'boolean', shortFlag: 'v', default: false },
+			edit: { type: 'boolean', default: false },
+			features: { type: 'string' },
+			repoScope: { type: 'boolean', default: false },
+		},
+	},
+);
+
+/** Walk up from `dir` looking for monorepo markers. Returns the root dir, or null. */
+function detectMonorepoRoot(startDir: string): string | null {
+	const markers = ['pnpm-workspace.yaml', 'turbo.json', 'lerna.json', 'nx.json', 'rush.json'];
+	let current = startDir;
+	while (true) {
+		for (const marker of markers) {
+			if (fs.existsSync(path.join(current, marker))) {
+				return current;
+			}
+		}
+		// Also check package.json with workspaces field
+		const pkgPath = path.join(current, 'package.json');
+		if (fs.existsSync(pkgPath)) {
+			try {
+				const pkg = JSON.parse(fs.readFileSync(pkgPath, 'utf-8'));
+				if (pkg.workspaces) return current;
+			} catch { }
+		}
+		const parent = path.dirname(current);
+		if (parent === current) break; // filesystem root
+		current = parent;
+	}
+	return null;
+}
+
+function rl_question(prompt: string): Promise<string> {
+	const rl = readline.createInterface({ input: process.stdin, output: process.stdout });
+	return new Promise((resolve) => {
+		rl.question(prompt, (answer) => {
+			rl.close();
+			resolve(answer.trim());
+		});
+	});
+}
+
+async function main() {
+	if (cli.flags.version) {
+		process.stdout.write(`creatorem v${(cli.pkg as any).version}\n`);
+		process.exit(0);
+	}
+
+	const command = cli.input[0];
+	let args = cli.input.slice(1);
+
+	// 'create' always creates a fresh monorepo (outside-repo mode).
+	// 'create-dashboard' / 'create-mobile' operate on an existing monorepo.
+	const isCreateMonorepo = command === 'create';
+	const isCreateSubCommand = command === 'create-dashboard' || command === 'create-mobile';
+	const isCreateCommand = isCreateMonorepo || isCreateSubCommand;
+
+	const hasNameArg = !!args[0];
+	const hasFeaturesFlag = cli.flags.features !== undefined;
+	const isEditMode = !!(cli.flags as any).edit;
+
+	// Ask for project name via plain readline when running interactively (no name arg, no --features)
+	if (isCreateCommand && !hasNameArg && !hasFeaturesFlag && !isEditMode) {
+		const name = await rl_question('Project name: ');
+		if (!name) {
+			process.stderr.write('Project name is required\n');
+			process.exit(1);
+		}
+		args = [name, ...args];
+	}
+
+	// Monorepo detection: offer to place the app inside apps/ when name came from arg or readline.
+	// Only applies to create-dashboard / create-mobile (not 'create', which always starts fresh).
+	// Skip the interactive prompt in non-interactive mode (i.e. when --features is already supplied).
+	if (isCreateSubCommand && args[0] && !isEditMode && !hasFeaturesFlag) {
+		const cwd = process.cwd();
+		const monoRoot = detectMonorepoRoot(cwd);
+		const appsDir = monoRoot ? path.join(monoRoot, 'apps') : null;
+
+		if (appsDir && fs.existsSync(appsDir)) {
+			const appsRelative = path.relative(cwd, appsDir);
+			const suggestedPath = path.join(appsRelative, args[0]);
+			// Only prompt if the name doesn't already point inside apps/
+			if (!args[0].startsWith(appsRelative) && !path.isAbsolute(args[0])) {
+				const answer = await rl_question(
+					`Monorepo detected — create at ${suggestedPath}? [Y/n]: `
+				);
+				if (answer === '' || answer.toLowerCase() === 'y') {
+					args = [suggestedPath, ...args.slice(1)];
+				}
+			}
+		}
+	}
+
+	render(<App command={command} args={args} flags={cli.flags} />);
+}
+
+main();
+

package/src/commands/create-dashboard.tsx

@@ -0,0 +1,455 @@
+import React, { useState, useEffect } from 'react';
+import { Box, Text, useApp } from 'ink';
+import { MultiSelect } from '../ui/multi-select.js';
+import Spinner from 'ink-spinner';
+import Gradient from 'ink-gradient';
+import TextInput from 'ink-text-input';
+import fs from 'fs-extra';
+import path from 'path';
+import os from 'os';
+import { execa } from 'execa';
+import { features } from '../dashboard-features/index.js';
+import { FeatureRemover } from '../dashboard-features/types.js';
+import { processFeature, processFeatureRepo, writeFeatureSelectionManifest } from '../dashboard-features/manager.js';
+import { generateDashboardEnvTemplate } from '../utils/env-template.js';
+
+const PRO_REPO = 'https://github.com/creatorem/creatorem-saas-kit';
+const OSS_REPO = 'https://github.com/creatorem/creatorem-saas-kit-oss';
+
+/**
+ * Returns true when `dir` is the root of a Creatorem monorepo:
+ *   - has pnpm-workspace.yaml  (pnpm workspace)
+ *   - has turbo.json            (Turborepo)
+ *   - has kit/db, kit/shared, kit/utils packages
+ */
+const isCreatoreMonorepo = (dir: string): boolean => {
+    return (
+        fs.existsSync(path.join(dir, 'pnpm-workspace.yaml')) &&
+        fs.existsSync(path.join(dir, 'turbo.json')) &&
+        fs.existsSync(path.join(dir, 'kit', 'db')) &&
+        fs.existsSync(path.join(dir, 'kit', 'shared')) &&
+        fs.existsSync(path.join(dir, 'kit', 'utils'))
+    );
+};
+
+/**
+ * Walk up from `startDir` looking for the nearest Creatorem monorepo root.
+ * Returns the root path or null if none found.
+ */
+const findCreatoreMonorepoRoot = (startDir: string): string | null => {
+    let current = startDir;
+    while (true) {
+        if (isCreatoreMonorepo(current)) return current;
+        const parent = path.dirname(current);
+        if (parent === current) return null;
+        current = parent;
+    }
+};
+
+/** Detect the package manager from lock files. */
+const detectPackageManager = (root: string): string => {
+    if (fs.existsSync(path.join(root, 'pnpm-lock.yaml'))) return 'pnpm';
+    if (fs.existsSync(path.join(root, 'yarn.lock'))) return 'yarn';
+    if (fs.existsSync(path.join(root, 'bun.lockb')) || fs.existsSync(path.join(root, 'bun.lock'))) return 'bun';
+    return 'npm';
+};
+
+const checkProAccess = async (): Promise<boolean> => {
+    try {
+        await execa('git', ['ls-remote', '--heads', PRO_REPO], { stdio: 'pipe', timeout: 10000 });
+        return true;
+    } catch {
+        return false;
+    }
+};
+
+/** Collect i18n namespace prefixes declared by a list of features. */
+const collectFeatureNamespaces = (features: Array<{ i18nNamespacePrefix?: string | string[] }>): string[] =>
+    features.flatMap(f =>
+        f.i18nNamespacePrefix
+            ? (Array.isArray(f.i18nNamespacePrefix) ? f.i18nNamespacePrefix : [f.i18nNamespacePrefix])
+            : [],
+    );
+
+/**
+ * Removes `namespacesToRemove` from the namespace array inside
+ * `applyCrossEnvFilter('cross_env_get_namespaces', [...])` in
+ * `{dashboardAppDir}/config/i18n.config.ts`.
+ */
+export const updateDashboardI18nNamespaces = async (
+    dashboardAppDir: string,
+    namespacesToRemove: string[],
+): Promise<void> => {
+    if (namespacesToRemove.length === 0) return;
+
+    const i18nConfigPath = path.join(dashboardAppDir, 'config', 'i18n.config.ts');
+    if (!fs.existsSync(i18nConfigPath)) return;
+
+    let content = await fs.readFile(i18nConfigPath, 'utf-8');
+
+    content = content.replace(
+        /applyCrossEnvFilter\('cross_env_get_namespaces',\s*\[([^\]]*)\]\)/,
+        (_match, arrayContent: string) => {
+            const kept = arrayContent
+                .split(',')
+                .map((s: string) => s.trim().replace(/['"]/g, ''))
+                .filter((s: string) => s.length > 0 && !namespacesToRemove.includes(s));
+            const arrayStr = kept.map((s: string) => `\n    '${s}'`).join(',') + (kept.length > 0 ? ',' : '');
+            return `applyCrossEnvFilter('cross_env_get_namespaces', [${arrayStr}\n])`;
+        },
+    );
+
+    await fs.writeFile(i18nConfigPath, content, 'utf-8');
+};
+
+interface CreateDashboardProps {
+    args: string[];
+    flags?: Record<string, any>;
+}
+
+export const CreateDashboard: React.FC<CreateDashboardProps> = ({ args, flags = {} }) => {
+    const { exit } = useApp();
+
+    // Check both args (for backward compatibility or direct passing) and flags (from meow)
+    const isEditMode = flags.edit || args.includes('--edit');
+
+    // In edit mode, default the name automatically so the name prompt is skipped.
+    const editDefaultName = isEditMode ? 'dashboard' : '';
+    const [projectName, setProjectName] = useState(args[0] || editDefaultName);
+
+    // Start at 'name' if no project name given, 'processing' if both name+features are pre-supplied,
+    // otherwise 'features' (name was passed as arg, just need feature selection).
+    const initialStep = (args[0] || editDefaultName)
+        ? (flags.features !== undefined ? 'processing' : 'features')
+        : 'name';
+
+    const [step, setStep] = useState<'name' | 'features' | 'processing' | 'done' | 'error'>(initialStep);
+
+    // Parse features from flag if present
+    const [selectedFeatures, setSelectedFeatures] = useState<string[]>(() => {
+        if (flags.features !== undefined) {
+            return typeof flags.features === 'string' && flags.features !== ''
+                ? flags.features.split(',').map(f => f.trim())
+                : [];
+        }
+        return [];
+    });
+    const [currentAction, setCurrentAction] = useState<string>('');
+    const [error, setError] = useState<string>('');
+    const [isOutsideRepoMode, setIsOutsideRepoMode] = useState(false);
+    const [detectedUserType, setDetectedUserType] = useState<'premium' | 'public' | null>(null);
+
+    const getFeatureTitle = (feature: FeatureRemover) => feature.cliUI.title;
+
+    const allFeatures = features.map(feature => ({
+        label: feature.cliUI.title,
+        value: feature.key,
+        title: feature.cliUI.title,
+        description: feature.cliUI.description,
+        features: feature.cliUI.features,
+    }));
+
+    const handleNameSubmit = (name: string) => {
+        if (!name) {
+            setError('Project name is required');
+            return;
+        }
+        setProjectName(name);
+        setStep('features');
+        setError('');
+    };
+
+
+
+    const handleFeaturesSubmit = async (selected: string[]) => {
+        fs.appendFileSync('debug.log', `Features selected: ${selected.join(', ')}\n`);
+        setSelectedFeatures(selected);
+        setStep('processing');
+
+        try {
+            fs.appendFileSync('debug.log', 'Starting project creation...\n');
+            await createAndModifyProject(projectName, selected);
+            fs.appendFileSync('debug.log', 'Project creation success.\n');
+            setStep('done');
+            // Give ink a moment to render the done state before exiting
+            setTimeout(() => {
+                exit();
+            }, 100);
+        } catch (err: any) {
+            fs.appendFileSync('debug.log', `Error: ${err.message}\n${err.stack}\n`);
+            setError(err.message);
+            setStep('error');
+            exit(err);
+        }
+    };
+
+    const createAndModifyProject = async (name: string, selected: string[]) => {
+        const targetDir = path.resolve(process.cwd(), name);
+        const selectedFeatureKeys = features
+            .filter(feature => selected.includes(feature.key))
+            .map(feature => feature.key);
+        const featuresToRemove = features.filter(f => !selectedFeatureKeys.includes(f.key));
+
+        // ── Detect whether we are inside a Creatorem monorepo ──────────────
+        const existingMonoRoot = isEditMode
+            ? findCreatoreMonorepoRoot(process.cwd())   // edit mode: use CWD
+            : findCreatoreMonorepoRoot(process.cwd());
+
+        if (existingMonoRoot) {
+            setDetectedUserType('premium');
+            // ── BRANCH A: inside a Creatorem monorepo ─────────────────────
+            // Find apps/dashboard in the detected monorepo.
+            const dashboardSource = path.join(existingMonoRoot, 'apps', 'dashboard');
+            if (!fs.existsSync(dashboardSource)) {
+                throw new Error(`Could not find apps/dashboard at ${dashboardSource}`);
+            }
+
+            // In edit mode, mutate apps/dashboard in place.
+            // In create mode, copy apps/dashboard into targetDir before applying removals.
+            const appTargetDir = isEditMode ? dashboardSource : targetDir;
+
+            // Copy dashboard to appTargetDir (skip when editing in place).
+            if (!isEditMode && appTargetDir !== dashboardSource) {
+                if (fs.existsSync(appTargetDir)) await fs.remove(appTargetDir);
+                setCurrentAction(`Copying dashboard to ${name}...`);
+                await fs.copy(dashboardSource, appTargetDir, {
+                    filter: (src) => !src.includes('node_modules') && !src.includes('.next') && !src.includes('.turbo'),
+                });
+            }
+
+            // Apply app-level feature removals
+            for (const feature of featuresToRemove) {
+                setCurrentAction(`Removing feature: ${getFeatureTitle(feature)}...`);
+                await processFeature(feature, appTargetDir);
+            }
+
+            // If --repo-scope is active, clean kit packages + uninstall deps
+            const repoScope = flags['repo-scope'] || flags.repoScope;
+            if (repoScope) {
+                // 1. Uninstall deps FIRST — packages must still be present to be removed
+                const pm = detectPackageManager(existingMonoRoot);
+                const depsToUninstall = [...new Set(featuresToRemove.flatMap(f => f.dependenciesToRemove ?? []))];
+                if (depsToUninstall.length > 0) {
+                    setCurrentAction(`[repo-scope] Uninstalling ${depsToUninstall.length} package(s) via ${pm}...`);
+                    const removeCmd = pm === 'npm' ? 'uninstall' : 'remove';
+                    const workspaceFlag = pm === 'pnpm' ? ['-r'] : pm === 'yarn' ? ['-W'] : pm === 'bun' ? [] : ['-w'];
+                    try {
+                        await execa(pm, [removeCmd, ...workspaceFlag, ...depsToUninstall], { cwd: existingMonoRoot, stdio: 'pipe' });
+                    } catch { /* non-fatal */ }
+                }
+
+                // 2. Delete kit directories and run repo.apply hooks
+                for (const feature of featuresToRemove) {
+                    setCurrentAction(`[repo-scope] Cleaning kit/${feature.key}...`);
+                    await processFeatureRepo(feature, existingMonoRoot);
+                }
+            }
+
+            // Generate .env.template from the (now-trimmed) envs.ts
+            setCurrentAction('Generating .env.template...');
+            await generateDashboardEnvTemplate(appTargetDir, existingMonoRoot, {
+                createEnvFile: !isEditMode,
+                fallbackMonoRoot: process.cwd(),
+            });
+
+            setCurrentAction('Saving selected features metadata...');
+            await writeFeatureSelectionManifest(appTargetDir, 'dashboard', selectedFeatureKeys);
+
+            const removedNamespacesA = collectFeatureNamespaces(featuresToRemove);
+            if (removedNamespacesA.length > 0) {
+                setCurrentAction('Updating i18n namespaces...');
+                await updateDashboardI18nNamespaces(appTargetDir, removedNamespacesA);
+            }
+
+            if (!isEditMode) {
+                const pkgPath = path.join(appTargetDir, 'package.json');
+                if (fs.existsSync(pkgPath)) {
+                    const pkg = await fs.readJson(pkgPath);
+                    pkg.name = path.basename(name);
+                    await fs.writeJson(pkgPath, pkg, { spaces: 4 });
+                }
+            }
+
+        } else {
+            // ── BRANCH B: outside a Creatorem monorepo ────────────────────
+            // --repo-scope and --edit are always implied in this mode:
+            //   • repo-scope: always clean kit packages and uninstall deps
+            //   • edit: no package.json rename (the whole monorepo IS the output)
+            //   • only apps/dashboard is kept; all other apps/* dirs are removed
+            setIsOutsideRepoMode(true);
+
+            const tmpDir = path.join(os.tmpdir(), `creatorem-saas-kit-${Date.now()}`);
+
+            try {
+                setCurrentAction('Checking repository access...');
+                const hasPro = await checkProAccess();
+                const repoUrl = hasPro ? PRO_REPO : OSS_REPO;
+                setDetectedUserType(hasPro ? 'premium' : 'public');
+                setCurrentAction(
+                    hasPro
+                        ? 'Premium user detected. Using private Creatorem repository...'
+                        : 'Public user detected. Using OSS Creatorem repository...',
+                );
+
+                setCurrentAction('Cloning Creatorem template repo (this may take a moment)...');
+                await execa('git', ['clone', '--depth', '1', repoUrl, tmpDir], { stdio: 'pipe' });
+
+                const clonedDashboard = path.join(tmpDir, 'apps', 'dashboard');
+                if (!fs.existsSync(clonedDashboard)) {
+                    throw new Error('Template repo does not contain apps/dashboard — please report this issue.');
+                }
+
+                // 1. Delete all apps/* except apps/dashboard
+                setCurrentAction('Removing non-dashboard apps...');
+                const appsDir = path.join(tmpDir, 'apps');
+                const appEntries = await fs.readdir(appsDir);
+                for (const entry of appEntries) {
+                    if (entry !== 'dashboard') {
+                        await fs.remove(path.join(appsDir, entry));
+                    }
+                }
+
+                // 2. Uninstall removed packages FIRST — must be present before deletion
+                const pm = detectPackageManager(tmpDir);
+                const depsToUninstall = [...new Set(featuresToRemove.flatMap(f => f.dependenciesToRemove ?? []))];
+                if (depsToUninstall.length > 0) {
+                    setCurrentAction(`Uninstalling ${depsToUninstall.length} package(s) via ${pm}...`);
+                    const removeCmd = pm === 'npm' ? 'uninstall' : 'remove';
+                    const workspaceFlag = pm === 'pnpm' ? ['-r'] : pm === 'yarn' ? ['-W'] : pm === 'bun' ? [] : ['-w'];
+                    try {
+                        await execa(pm, [removeCmd, ...workspaceFlag, ...depsToUninstall], { cwd: tmpDir, stdio: 'pipe' });
+                    } catch { /* non-fatal */ }
+                }
+
+                // 3. Apply app-level feature removals on the cloned dashboard
+                for (const feature of featuresToRemove) {
+                    setCurrentAction(`Removing feature: ${getFeatureTitle(feature)}...`);
+                    await processFeature(feature, clonedDashboard);
+                }
+
+                // 4. Delete kit directories (repo-scope always on)
+                for (const feature of featuresToRemove) {
+                    setCurrentAction(`[repo-scope] Cleaning kit/${feature.key}...`);
+                    await processFeatureRepo(feature, tmpDir);
+                }
+
+                // Generate .env.template from the (now-trimmed) envs.ts
+                setCurrentAction('Generating .env.template...');
+                await generateDashboardEnvTemplate(clonedDashboard, tmpDir, {
+                    createEnvFile: true,
+                    fallbackMonoRoot: process.cwd(),
+                });
+
+                setCurrentAction('Saving selected features metadata...');
+                await writeFeatureSelectionManifest(clonedDashboard, 'dashboard', selectedFeatureKeys);
+
+                const removedNamespacesB = collectFeatureNamespaces(featuresToRemove);
+                if (removedNamespacesB.length > 0) {
+                    setCurrentAction('Updating i18n namespaces...');
+                    await updateDashboardI18nNamespaces(clonedDashboard, removedNamespacesB);
+                }
+
+                // Move cloned+stripped monorepo to the user's target path
+                setCurrentAction(`Finalizing monorepo at ${name}...`);
+                if (fs.existsSync(targetDir)) await fs.remove(targetDir);
+                await fs.move(tmpDir, targetDir);
+
+            } catch (err) {
+                // Clean up temp dir on failure
+                if (fs.existsSync(tmpDir)) await fs.remove(tmpDir).catch(() => { });
+                throw err;
+            }
+        }
+
+
+        setCurrentAction('Done.');
+    };
+
+    // Auto-exec if initialized in processing state (via flags)
+    useEffect(() => {
+        if (initialStep === 'processing' && flags.features !== undefined) {
+            const run = async () => {
+                try {
+                    const featuresToSelect = typeof flags.features === 'string' && flags.features !== ''
+                        ? flags.features.split(',').map(f => f.trim())
+                        : [];
+                    fs.appendFileSync('debug.log', `Features selected (via flag): ${featuresToSelect.join(', ')}\n`);
+                    fs.appendFileSync('debug.log', 'Starting project creation...\n');
+                    await createAndModifyProject(projectName, featuresToSelect);
+                    fs.appendFileSync('debug.log', 'Project creation success.\n');
+                    setStep('done');
+                    setTimeout(() => {
+                        exit();
+                    }, 100);
+                } catch (err: any) {
+                    fs.appendFileSync('debug.log', `Error: ${err.message}\n${err.stack}\n`);
+                    setError(err.message);
+                    setStep('error');
+                    exit(err);
+                }
+            };
+            run();
+        }
+    }, []); // Run once on mount
+
+
+    if (step === 'error') {
+        return <Text color="red">Error: {error}</Text>;
+    }
+
+    if (step === 'done') {
+        return (
+            <Box flexDirection="column">
+                <Gradient name="pastel">
+                    <Text>
+                        {isOutsideRepoMode
+                            ? `Monorepo "${projectName}" created successfully!`
+                            : `Dashboard "${projectName}" created successfully!`}
+                    </Text>
+                </Gradient>
+                {detectedUserType && (
+                    <Text color="gray">
+                        {detectedUserType === 'premium'
+                            ? 'Detected user type: Premium'
+                            : 'Detected user type: Public (using OSS repository)'}
+                    </Text>
+                )}
+                <Text>Next steps:</Text>
+                <Text>  cd {projectName}</Text>
+                <Text>  pnpm install</Text>
+                <Text>  pnpm dev</Text>
+            </Box>
+        );
+    }
+
+    if (step === 'processing') {
+        return (
+            <Box>
+                <Spinner type="dots" />
+                <Text> {currentAction}</Text>
+            </Box>
+        );
+    }
+
+    if (step === 'name') {
+        return (
+            <Box flexDirection="column">
+                <Text>Enter project name:</Text>
+                <TextInput value={projectName} onChange={setProjectName} onSubmit={handleNameSubmit} />
+                {error && <Text color="red">{error}</Text>}
+            </Box>
+        );
+    }
+
+    return (
+        <Box flexDirection="column">
+            <Text>Select features to include:</Text>
+            <MultiSelect
+                items={allFeatures}
+                onSubmit={handleFeaturesSubmit}
+            />
+        </Box>
+    );
+};
+
+export default CreateDashboard;