create-turniza-app 1.0.0

package/package.json

@@ -0,0 +1,46 @@
+{
+    "name": "create-turniza-app",
+    "version": "1.0.0",
+    "description": "CLI scaffold for creating new Turniza monorepo apps (Flutter + Astro + Cloudflare Workers)",
+    "type": "module",
+    "bin": {
+        "create-turniza-app": "./src/index.ts"
+    },
+    "scripts": {
+        "dev": "bun run src/index.ts",
+        "typecheck": "tsc --noEmit"
+    },
+    "dependencies": {
+        "chalk": "^5.4.1",
+        "handlebars": "^4.7.8",
+        "prompts": "^2.4.2"
+    },
+    "devDependencies": {
+        "@types/bun": "^1.2.5",
+        "@types/prompts": "^2.4.9",
+        "typescript": "^5.8.3"
+    },
+    "keywords": [
+        "scaffold",
+        "cli",
+        "flutter",
+        "astro",
+        "cloudflare-workers",
+        "monorepo",
+        "turniza"
+    ],
+    "author": "Turniza",
+    "license": "MIT",
+    "repository": {
+        "type": "git",
+        "url": "git+https://github.com/Turniza/create-turniza-app.git"
+    },
+    "files": [
+        "src/**/*",
+        "templates/**/*"
+    ],
+    "engines": {
+        "node": ">=18",
+        "bun": ">=1.0"
+    }
+}

package/src/index.ts

@@ -0,0 +1,79 @@
+#!/usr/bin/env bun
+
+/**
+ * create-turniza-app – CLI scaffold for Turniza monorepo apps
+ *
+ * Usage:
+ *   bunx create-turniza-app [project-name]
+ *   npx create-turniza-app [project-name]
+ */
+
+import chalk from 'chalk';
+import { askProjectOptions, type ProjectOptions } from './prompts.js';
+import { scaffoldProject } from './scaffold.js';
+
+const BANNER = `
+${chalk.bold.cyan('╔══════════════════════════════════════════╗')}
+${chalk.bold.cyan('║')}  ${chalk.bold('🚀 create-turniza-app')}                    ${chalk.bold.cyan('║')}
+${chalk.bold.cyan('║')}  ${chalk.dim('Scaffold a new Turniza monorepo app')}      ${chalk.bold.cyan('║')}
+${chalk.bold.cyan('╚══════════════════════════════════════════╝')}
+`;
+
+async function main(): Promise<void> {
+    console.log(BANNER);
+
+    const projectNameArg = process.argv[2];
+
+    let options: ProjectOptions;
+
+    try {
+        options = await askProjectOptions(projectNameArg);
+    } catch {
+        console.log(chalk.yellow('\n👋 Cancelled.'));
+        process.exit(0);
+    }
+
+    console.log('');
+    console.log(chalk.bold('📋 Configuration:'));
+    console.log(chalk.dim('─'.repeat(40)));
+    console.log(`  ${chalk.cyan('Project:')}     ${options.projectName}`);
+    console.log(`  ${chalk.cyan('Org:')}         ${options.org}`);
+    console.log(`  ${chalk.cyan('GitHub:')}      ${options.githubOrg}/${options.projectName}`);
+    console.log(`  ${chalk.cyan('Mobile:')}      ${options.includeMobile ? '✅' : '❌'}`);
+    console.log(`  ${chalk.cyan('Web:')}         ${options.includeWeb ? '✅' : '❌'}`);
+    console.log(`  ${chalk.cyan('Git init:')}    ${options.initGit ? '✅' : '❌'}`);
+    console.log(`  ${chalk.cyan('Install:')}     ${options.installDeps ? '✅' : '❌'}`);
+    console.log('');
+
+    try {
+        await scaffoldProject(options);
+    } catch (error) {
+        console.error(chalk.red(`\n❌ Error: ${error instanceof Error ? error.message : error}`));
+        process.exit(1);
+    }
+
+    // ── Success message ──────────────────────────────────────
+    console.log('');
+    console.log(chalk.green.bold('✅ Project created successfully!'));
+    console.log('');
+    console.log(chalk.bold('Next steps:'));
+    console.log(chalk.dim('─'.repeat(40)));
+    console.log(`  ${chalk.cyan('cd')} ${options.projectName}`);
+
+    if (!options.installDeps) {
+        console.log(`  ${chalk.cyan('make setup')}`);
+    }
+
+    if (options.includeMobile) {
+        console.log(`  ${chalk.cyan('make run-ios')}        ${chalk.dim('# or make run-android')}`);
+    }
+
+    if (options.includeWeb) {
+        console.log(`  ${chalk.cyan('make run-web')}        ${chalk.dim('# localhost:4321')}`);
+    }
+
+    console.log(`  ${chalk.cyan('make ci')}             ${chalk.dim('# full pipeline')}`);
+    console.log('');
+}
+
+main();

package/src/prompts.ts

@@ -0,0 +1,140 @@
+import prompts from 'prompts';
+
+export interface ProjectOptions {
+    projectName: string;
+    projectTitle: string;
+    projectDescription: string;
+    projectNameSnake: string;
+    org: string;
+    orgDomain: string;
+    githubOrg: string;
+    emoji: string;
+    includeMobile: boolean;
+    includeWeb: boolean;
+    initGit: boolean;
+    installDeps: boolean;
+    compatibilityDate: string;
+}
+
+function toTitleCase(str: string): string {
+    return str
+        .split(/[-_]/)
+        .map((word) => word.charAt(0).toUpperCase() + word.slice(1))
+        .join(' ');
+}
+
+function toSnakeCase(str: string): string {
+    return str.replace(/-/g, '_');
+}
+
+function validateProjectName(name: string): boolean | string {
+    if (!name) return 'Project name is required';
+    if (!/^[a-z][a-z0-9-]*$/.test(name)) {
+        return 'Must be lowercase, start with a letter, and contain only letters, numbers, and hyphens';
+    }
+    if (name.length > 50) return 'Must be 50 characters or less';
+    return true;
+}
+
+export async function askProjectOptions(
+    projectNameArg?: string,
+): Promise<ProjectOptions> {
+    const onCancel = (): void => {
+        throw new Error('cancelled');
+    };
+
+    // ── Step 1: Project name ──────────────────────────────────
+    let projectName = projectNameArg;
+
+    if (!projectName) {
+        const { name } = await prompts(
+            {
+                type: 'text',
+                name: 'name',
+                message: 'Project name (kebab-case):',
+                validate: validateProjectName,
+            },
+            { onCancel },
+        );
+        projectName = name as string;
+    } else {
+        const validation = validateProjectName(projectName);
+        if (validation !== true) {
+            throw new Error(validation as string);
+        }
+    }
+
+    // ── Step 2: Rest of options ───────────────────────────────
+    const answers = await prompts(
+        [
+            {
+                type: 'text',
+                name: 'org',
+                message: 'Organization name:',
+                initial: 'Turniza',
+            },
+            {
+                type: 'text',
+                name: 'githubOrg',
+                message: 'GitHub org/user:',
+                initial: 'Turniza',
+            },
+            {
+                type: 'text',
+                name: 'emoji',
+                message: 'Project emoji:',
+                initial: '🚀',
+            },
+            {
+                type: 'text',
+                name: 'description',
+                message: 'Short project description:',
+                initial: `A monorepo for ${toTitleCase(projectName!)} – Flutter mobile + Astro web.`,
+            },
+            {
+                type: 'confirm',
+                name: 'includeMobile',
+                message: 'Include Flutter mobile app?',
+                initial: true,
+            },
+            {
+                type: 'confirm',
+                name: 'includeWeb',
+                message: 'Include Astro web app (Cloudflare Workers)?',
+                initial: true,
+            },
+            {
+                type: 'confirm',
+                name: 'initGit',
+                message: 'Initialize git repository?',
+                initial: true,
+            },
+            {
+                type: 'confirm',
+                name: 'installDeps',
+                message: 'Install dependencies now?',
+                initial: true,
+            },
+        ],
+        { onCancel },
+    );
+
+    const org = answers.org as string;
+    const today = new Date().toISOString().split('T')[0]!;
+
+    return {
+        projectName: projectName!,
+        projectTitle: toTitleCase(projectName!),
+        projectDescription: answers.description as string,
+        projectNameSnake: toSnakeCase(projectName!),
+        org,
+        orgDomain: `${org.toLowerCase()}.com`,
+        githubOrg: answers.githubOrg as string,
+        emoji: answers.emoji as string,
+        includeMobile: answers.includeMobile as boolean,
+        includeWeb: answers.includeWeb as boolean,
+        initGit: answers.initGit as boolean,
+        installDeps: answers.installDeps as boolean,
+        compatibilityDate: today,
+    };
+}

package/src/scaffold.ts

@@ -0,0 +1,131 @@
+import { resolve, join, relative, dirname } from 'path';
+import { readdir, stat, lstat, readFile, writeFile, mkdir, copyFile } from 'fs/promises';
+import Handlebars from 'handlebars';
+import chalk from 'chalk';
+import type { ProjectOptions } from './prompts.js';
+import { exec } from './utils.js';
+
+const TEMPLATES_DIR = resolve(import.meta.dirname, '../../templates');
+
+/**
+ * Main scaffold function: copies templates, processes Handlebars, and runs post-setup.
+ */
+export async function scaffoldProject(options: ProjectOptions): Promise<void> {
+    const targetDir = resolve(process.cwd(), options.projectName);
+
+    // ── Check target doesn't exist ────────────────────────────
+    try {
+        await stat(targetDir);
+        throw new Error(`Directory "${options.projectName}" already exists.`);
+    } catch (error) {
+        if ((error as NodeJS.ErrnoException).code !== 'ENOENT') {
+            throw error;
+        }
+    }
+
+    await mkdir(targetDir, { recursive: true });
+
+    const context = {
+        ...options,
+    };
+
+    // ── 1. Copy base templates ────────────────────────────────
+    console.log(chalk.cyan('📁 Creating project structure...'));
+    await processTemplateDir(join(TEMPLATES_DIR, 'base'), targetDir, context);
+
+    // ── 2. Copy mobile templates ──────────────────────────────
+    if (options.includeMobile) {
+        console.log(chalk.cyan('📱 Setting up Flutter mobile app...'));
+        const mobileTarget = join(targetDir, 'apps', 'mobile');
+        await mkdir(mobileTarget, { recursive: true });
+        await processTemplateDir(join(TEMPLATES_DIR, 'mobile'), mobileTarget, context);
+    }
+
+    // ── 3. Copy web templates ────────────────────────────────
+    if (options.includeWeb) {
+        console.log(chalk.cyan('🌐 Setting up Astro web app...'));
+        const webTarget = join(targetDir, 'apps', 'web');
+        await mkdir(webTarget, { recursive: true });
+        await processTemplateDir(join(TEMPLATES_DIR, 'web'), webTarget, context);
+    }
+
+    // ── 4. Create packages dir ────────────────────────────────
+    const packagesDir = join(targetDir, 'packages');
+    await mkdir(packagesDir, { recursive: true });
+    await writeFile(join(packagesDir, '.gitkeep'), '');
+
+    // ── 5. Git init ──────────────────────────────────────────
+    if (options.initGit) {
+        console.log(chalk.cyan('🔧 Initializing git repository...'));
+        await exec('git init', { cwd: targetDir });
+        await exec('git add -A', { cwd: targetDir });
+        await exec('git commit -m "chore: initial scaffold from create-turniza-app"', {
+            cwd: targetDir,
+        });
+    }
+
+    // ── 6. Install deps ──────────────────────────────────────
+    if (options.installDeps) {
+        if (options.includeMobile) {
+            console.log(chalk.cyan('📦 Installing Flutter dependencies...'));
+            await exec('flutter pub get', { cwd: join(targetDir, 'apps', 'mobile') });
+        }
+
+        if (options.includeWeb) {
+            console.log(chalk.cyan('📦 Installing web dependencies...'));
+            await exec('bun install', { cwd: join(targetDir, 'apps', 'web') });
+        }
+
+        console.log(chalk.cyan('🪝 Installing lefthook...'));
+        try {
+            await exec('lefthook install', { cwd: targetDir });
+        } catch {
+            console.log(chalk.yellow('  ⚠️  lefthook not found, skipping hook install'));
+        }
+    }
+}
+
+/**
+ * Recursively process a template directory:
+ * - `.hbs` files are rendered with Handlebars then written without the extension
+ * - All other files are copied as-is
+ */
+async function processTemplateDir(
+    sourceDir: string,
+    targetDir: string,
+    context: Record<string, unknown>,
+): Promise<void> {
+    const entries = await readdir(sourceDir, { withFileTypes: true });
+
+    for (const entry of entries) {
+        const sourcePath = join(sourceDir, entry.name);
+
+        // Skip symlinks – they can't be copied reliably (e.g. iOS .symlinks)
+        const entryStat = await lstat(sourcePath);
+        if (entryStat.isSymbolicLink()) {
+            continue;
+        }
+
+        const isHbs = entry.name.endsWith('.hbs');
+        const targetName = isHbs ? entry.name.slice(0, -4) : entry.name;
+        const targetPath = join(targetDir, targetName);
+
+        if (entry.isDirectory()) {
+            await mkdir(targetPath, { recursive: true });
+            await processTemplateDir(sourcePath, targetPath, context);
+        } else if (isHbs) {
+            // Process Handlebars template
+            const templateContent = await readFile(sourcePath, 'utf-8');
+            const template = Handlebars.compile(templateContent, { noEscape: true });
+            const rendered = template(context);
+            await mkdir(dirname(targetPath), { recursive: true });
+            await writeFile(targetPath, rendered);
+            console.log(chalk.dim(`  + ${relative(process.cwd(), targetPath)}`));
+        } else {
+            // Copy file as-is
+            await mkdir(dirname(targetPath), { recursive: true });
+            await copyFile(sourcePath, targetPath);
+            console.log(chalk.dim(`  + ${relative(process.cwd(), targetPath)}`));
+        }
+    }
+}

package/src/utils.ts

@@ -0,0 +1,39 @@
+import { spawn } from 'child_process';
+
+export interface ExecOptions {
+    cwd?: string;
+}
+
+/**
+ * Execute a shell command and return stdout.
+ * Throws on non-zero exit code.
+ */
+export function exec(command: string, options: ExecOptions = {}): Promise<string> {
+    return new Promise((resolve, reject) => {
+        const child = spawn('sh', ['-c', command], {
+            cwd: options.cwd,
+            stdio: ['ignore', 'pipe', 'pipe'],
+        });
+
+        let stdout = '';
+        let stderr = '';
+
+        child.stdout.on('data', (data: Buffer) => {
+            stdout += data.toString();
+        });
+
+        child.stderr.on('data', (data: Buffer) => {
+            stderr += data.toString();
+        });
+
+        child.on('close', (code) => {
+            if (code !== 0) {
+                reject(new Error(`Command "${command}" failed (exit ${code}):\n${stderr}`));
+            } else {
+                resolve(stdout.trim());
+            }
+        });
+
+        child.on('error', reject);
+    });
+}