@aex.is/zero 0.1.2 → 0.1.4

package/dist/cli/prompts.js

@@ -0,0 +1,163 @@
+import * as p from '@clack/prompts';
+import { frameworks } from '../config/frameworks.js';
+import { modules } from '../config/modules.js';
+const introArt = [
+    '   _____',
+    '  / ___ \\\\',
+    ' / / _ \\\\ \\\\',
+    ' | |/ /| |',
+    ' \\\\ \\\\_/ / /',
+    '  \\\\___/_/'
+].join('\n');
+export async function runWizard() {
+    p.intro(`${introArt}\nAexis Zero`);
+    let directory = '.';
+    let appName = '';
+    let domain = '';
+    let framework = 'nextjs';
+    let selectedModules = [];
+    let step = 'directory';
+    while (true) {
+        if (step === 'directory') {
+            const value = await p.text({
+                message: 'Project directory',
+                placeholder: '.',
+                validate: (input) => {
+                    if (typeof input !== 'string') {
+                        return 'Enter a directory.';
+                    }
+                    return undefined;
+                }
+            });
+            if (isCancelled(value))
+                return null;
+            const normalized = String(value).trim();
+            directory = normalized.length === 0 ? '.' : normalized;
+            step = 'name';
+            continue;
+        }
+        if (step === 'name') {
+            const value = await p.text({
+                message: 'App name',
+                placeholder: 'my-app',
+                validate: (input) => {
+                    if (typeof input !== 'string' || input.trim().length === 0) {
+                        return 'App name is required.';
+                    }
+                    return undefined;
+                }
+            });
+            if (isCancelled(value))
+                return null;
+            appName = String(value).trim();
+            step = 'domain';
+            continue;
+        }
+        if (step === 'domain') {
+            const value = await p.text({
+                message: 'Domain (optional)',
+                placeholder: 'example.com'
+            });
+            if (isCancelled(value))
+                return null;
+            domain = String(value).trim();
+            step = 'framework';
+            continue;
+        }
+        if (step === 'framework') {
+            const value = await p.select({
+                message: 'Framework',
+                options: frameworks.map((item) => ({
+                    value: item.id,
+                    label: item.label,
+                    hint: item.description
+                }))
+            });
+            if (isCancelled(value))
+                return null;
+            framework = value;
+            step = 'modules';
+            continue;
+        }
+        if (step === 'modules') {
+            const value = await p.multiselect({
+                message: 'Modules',
+                options: modules.map((item) => ({
+                    value: item.id,
+                    label: item.label,
+                    hint: item.description
+                })),
+                required: false
+            });
+            if (isCancelled(value))
+                return null;
+            selectedModules = value;
+            step = 'confirm';
+            continue;
+        }
+        if (step === 'confirm') {
+            const frameworkLabel = frameworks.find((item) => item.id === framework)?.label ?? framework;
+            const moduleLabels = selectedModules
+                .map((id) => modules.find((item) => item.id === id)?.label ?? id)
+                .join(', ');
+            p.note([
+                `Directory: ${directory}`,
+                `App name: ${appName}`,
+                `Domain: ${domain || 'None'}`,
+                `Framework: ${frameworkLabel}`,
+                `Modules: ${moduleLabels || 'None'}`
+            ].join('\n'), 'Review');
+            const action = await p.select({
+                message: 'Next step',
+                options: [
+                    { value: 'continue', label: 'Continue' },
+                    { value: 'edit-directory', label: 'Edit directory' },
+                    { value: 'edit-name', label: 'Edit name' },
+                    { value: 'edit-domain', label: 'Edit domain' },
+                    { value: 'edit-framework', label: 'Edit framework' },
+                    { value: 'edit-modules', label: 'Edit modules' },
+                    { value: 'cancel', label: 'Cancel' }
+                ]
+            });
+            if (isCancelled(action))
+                return null;
+            switch (action) {
+                case 'continue':
+                    return {
+                        directory,
+                        appName,
+                        domain,
+                        framework,
+                        modules: selectedModules
+                    };
+                case 'edit-directory':
+                    step = 'directory';
+                    continue;
+                case 'edit-name':
+                    step = 'name';
+                    continue;
+                case 'edit-domain':
+                    step = 'domain';
+                    continue;
+                case 'edit-framework':
+                    step = 'framework';
+                    continue;
+                case 'edit-modules':
+                    step = 'modules';
+                    continue;
+                case 'cancel':
+                    p.cancel('Cancelled.');
+                    return null;
+                default:
+                    return null;
+            }
+        }
+    }
+}
+function isCancelled(value) {
+    if (p.isCancel(value)) {
+        p.cancel('Cancelled.');
+        return true;
+    }
+    return false;
+}

package/dist/config/frameworks.js

@@ -0,0 +1,97 @@
+export const frameworks = [
+    {
+        id: 'nextjs',
+        label: 'Next.js',
+        description: 'React framework with App Router and Tailwind.',
+        packages: [
+            'class-variance-authority',
+            'clsx',
+            'lucide-react',
+            'tailwind-merge',
+            'tailwindcss-animate',
+            '@radix-ui/react-slot'
+        ],
+        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',
+            'expo-font',
+            '@expo-google-fonts/geist-mono',
+            'tamagui',
+            '@tamagui/config',
+            '@tamagui/animations-react-native',
+            '@tamagui/metro-plugin',
+            '@tamagui/babel-plugin',
+            'react-native-svg'
+        ],
+        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) {
+    const framework = frameworks.find((item) => item.id === id);
+    if (!framework) {
+        throw new Error(`Unknown framework: ${id}`);
+    }
+    return framework;
+}

package/dist/config/modules.js

@@ -0,0 +1,120 @@
+export const modules = [
+    {
+        id: 'neon',
+        label: 'Database (Neon)',
+        description: 'Serverless Postgres with Neon.',
+        envVars: [
+            {
+                key: 'DATABASE_URL',
+                description: 'Neon connection string',
+                url: 'https://neon.com/docs/get-started/connect-neon'
+            }
+        ],
+        packages: {
+            nextjs: ['@neondatabase/serverless'],
+            expo: ['@neondatabase/serverless']
+        }
+    },
+    {
+        id: 'clerk',
+        label: 'Auth (Clerk)',
+        description: 'Authentication with Clerk.',
+        envVars: [
+            {
+                key: 'CLERK_PUBLISHABLE_KEY',
+                description: 'Clerk publishable key',
+                url: 'https://dashboard.clerk.com'
+            },
+            {
+                key: 'CLERK_SECRET_KEY',
+                description: 'Clerk secret key',
+                url: 'https://dashboard.clerk.com'
+            }
+        ],
+        packages: {
+            nextjs: ['@clerk/nextjs'],
+            expo: ['@clerk/clerk-expo']
+        }
+    },
+    {
+        id: 'payload',
+        label: 'CMS (Payload)',
+        description: 'Headless CMS using Payload.',
+        envVars: [
+            {
+                key: 'PAYLOAD_SECRET',
+                description: 'Payload secret (generate a long random string)',
+                url: 'https://payloadcms.com/docs'
+            },
+            {
+                key: 'DATABASE_URL',
+                description: 'Database connection string',
+                url: 'https://payloadcms.com/docs'
+            }
+        ],
+        packages: {
+            nextjs: ['payload'],
+            expo: ['payload']
+        }
+    },
+    {
+        id: 'stripe',
+        label: 'Payments (Stripe)',
+        description: 'Payments via Stripe SDK.',
+        envVars: [
+            {
+                key: 'STRIPE_SECRET_KEY',
+                description: 'Stripe secret key',
+                url: 'https://dashboard.stripe.com/apikeys'
+            },
+            {
+                key: 'STRIPE_WEBHOOK_SECRET',
+                description: 'Stripe webhook signing secret',
+                url: 'https://dashboard.stripe.com/webhooks'
+            }
+        ],
+        packages: {
+            nextjs: ['stripe'],
+            expo: ['stripe']
+        }
+    }
+];
+export function getModuleDefinition(id) {
+    const module = modules.find((item) => item.id === id);
+    if (!module) {
+        throw new Error(`Unknown module: ${id}`);
+    }
+    return module;
+}
+export function getModulePackages(moduleIds, framework) {
+    const packages = new Set();
+    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) {
+    const envVars = new Set();
+    for (const id of moduleIds) {
+        const module = getModuleDefinition(id);
+        for (const envVar of module.envVars) {
+            envVars.add(envVar.key);
+        }
+    }
+    return Array.from(envVars).sort();
+}
+export function getModuleEnvHelp(moduleIds) {
+    const map = new Map();
+    for (const id of moduleIds) {
+        const module = getModuleDefinition(id);
+        for (const envVar of module.envVars) {
+            if (!map.has(envVar.key)) {
+                map.set(envVar.key, envVar);
+            }
+        }
+    }
+    return Array.from(map.values());
+}

package/dist/engine/env.js

@@ -0,0 +1,10 @@
+import path from 'path';
+import { promises as fs } from 'fs';
+import { getModuleEnvVars } from '../config/modules.js';
+export async function writeEnvExample(moduleIds, targetDir) {
+    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/dist/engine/installers.js

@@ -0,0 +1,36 @@
+import { execa } from 'execa';
+import { getModulePackages } from '../config/modules.js';
+const baseEnv = {
+    ...process.env,
+    CI: '1'
+};
+export async function installBaseDependencies(targetDir, extraPackages = []) {
+    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, moduleIds, targetDir) {
+    const packages = getModulePackages(moduleIds, framework);
+    if (packages.length === 0) {
+        return;
+    }
+    await execa('bun', ['add', ...packages], {
+        cwd: targetDir,
+        stdio: 'inherit',
+        env: baseEnv,
+        shell: false
+    });
+}

package/dist/engine/scaffold.js

@@ -0,0 +1,253 @@
+import path from 'path';
+import { promises as fs } from 'fs';
+import { execa } from 'execa';
+import { getFrameworkDefinition } from '../config/frameworks.js';
+import { getModuleEnvHelp } from '../config/modules.js';
+import { installBaseDependencies, installModulePackages } from './installers.js';
+import { writeEnvExample } from './env.js';
+import { buildNextTemplateFiles, buildExpoTemplateFiles, componentsJsonTemplate } from './templates.js';
+const baseEnv = {
+    ...process.env,
+    CI: '1'
+};
+export async function scaffoldProject(config) {
+    const directoryInput = config.directory.trim().length === 0 ? '.' : config.directory.trim();
+    const targetDir = path.resolve(process.cwd(), directoryInput);
+    await ensureEmptyTargetDir(targetDir);
+    const framework = getFrameworkDefinition(config.framework);
+    console.log(`Scaffolding ${framework.label}...`);
+    await runScaffoldCommand(framework.scaffold.command, framework.scaffold.packageName, directoryInput, framework.scaffold.argSets);
+    console.log('Applying framework templates...');
+    if (config.framework === 'nextjs') {
+        await applyNextTemplates(config, targetDir);
+    }
+    else {
+        await applyExpoTemplates(config, 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 = directoryInput === '.' ? '.' : directoryInput.includes(' ') ? `"${directoryInput}"` : directoryInput;
+    console.log(`\nNext steps:\n  1) cd ${cdTarget}\n  2) bun run dev`);
+}
+async function ensureEmptyTargetDir(targetDir) {
+    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, packageName, directoryInput, argSets) {
+    const errors = [];
+    const targetArg = directoryInput === '.' ? '.' : directoryInput;
+    for (const args of argSets) {
+        try {
+            await execa(command, [packageName, targetArg, ...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(config, targetDir) {
+    const srcAppDir = path.join(targetDir, 'src', 'app');
+    const usesSrcDir = await pathExists(srcAppDir);
+    const basePath = usesSrcDir ? 'src' : '';
+    const envHelp = getModuleEnvHelp(config.modules);
+    const files = buildNextTemplateFiles({
+        appName: config.appName,
+        domain: config.domain,
+        envVars: envHelp,
+        basePath
+    });
+    await writeTemplateFiles(targetDir, files);
+    const globalsPath = usesSrcDir ? 'src/app/globals.css' : 'app/globals.css';
+    const tailwindConfig = await detectTailwindConfig(targetDir);
+    const componentsJson = componentsJsonTemplate(globalsPath, tailwindConfig ?? 'tailwind.config.ts');
+    await fs.writeFile(path.join(targetDir, 'components.json'), componentsJson, 'utf8');
+    await ensureNextTurbo(targetDir);
+    await ensurePackageName(targetDir, config.appName);
+}
+async function applyExpoTemplates(config, targetDir) {
+    const envHelp = getModuleEnvHelp(config.modules);
+    const files = buildExpoTemplateFiles({
+        appName: config.appName,
+        domain: config.domain,
+        envVars: envHelp,
+        basePath: ''
+    });
+    await writeTemplateFiles(targetDir, files);
+    await ensureExpoConfig(targetDir, config.appName);
+    await ensurePackageName(targetDir, config.appName);
+}
+async function ensureExpoConfig(targetDir, appName) {
+    const appJsonPath = path.join(targetDir, 'app.json');
+    const appJson = await readJson(appJsonPath, { expo: {} });
+    if (!appJson.expo || typeof appJson.expo !== 'object') {
+        appJson.expo = {};
+    }
+    appJson.expo.name = appName;
+    appJson.expo.slug = toSlug(appName);
+    if (!Array.isArray(appJson.expo.platforms)) {
+        appJson.expo.platforms = ['ios', 'android', 'macos', 'windows'];
+    }
+    else {
+        const current = appJson.expo.platforms.filter((value) => 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) => 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(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);
+}
+async function ensureNextTurbo(targetDir) {
+    const packageJsonPath = path.join(targetDir, 'package.json');
+    const packageJson = await readJson(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);
+}
+async function ensurePackageName(targetDir, appName) {
+    const packageJsonPath = path.join(targetDir, 'package.json');
+    const packageJson = await readJson(packageJsonPath, {});
+    packageJson.name = toPackageName(appName);
+    await writeJson(packageJsonPath, packageJson);
+}
+async function writeTemplateFiles(targetDir, files) {
+    for (const file of files) {
+        const fullPath = path.join(targetDir, ...file.path.split('/'));
+        await fs.mkdir(path.dirname(fullPath), { recursive: true });
+        await fs.writeFile(fullPath, file.content, 'utf8');
+    }
+}
+function mergeUnique(values, additions) {
+    const set = new Set(values);
+    for (const value of additions) {
+        set.add(value);
+    }
+    return Array.from(set);
+}
+async function detectTailwindConfig(targetDir) {
+    const candidates = [
+        'tailwind.config.ts',
+        'tailwind.config.js',
+        'tailwind.config.cjs',
+        'tailwind.config.mjs'
+    ];
+    for (const filename of candidates) {
+        const fullPath = path.join(targetDir, filename);
+        if (await pathExists(fullPath)) {
+            return filename;
+        }
+    }
+    return null;
+}
+async function readJson(filePath, fallback) {
+    try {
+        const data = await fs.readFile(filePath, 'utf8');
+        return JSON.parse(data);
+    }
+    catch (error) {
+        if (isErrnoException(error) && error.code === 'ENOENT') {
+            return fallback;
+        }
+        throw error;
+    }
+}
+async function writeJson(filePath, value) {
+    const data = JSON.stringify(value, null, 2);
+    await fs.writeFile(filePath, `${data}\n`, 'utf8');
+}
+function formatError(error) {
+    if (error instanceof Error) {
+        return error.message;
+    }
+    return String(error);
+}
+function isErrnoException(error) {
+    return error instanceof Error && 'code' in error;
+}
+async function pathExists(targetPath) {
+    try {
+        await fs.stat(targetPath);
+        return true;
+    }
+    catch (error) {
+        if (isErrnoException(error) && error.code === 'ENOENT') {
+            return false;
+        }
+        throw error;
+    }
+}
+function toPackageName(name) {
+    const cleaned = name
+        .trim()
+        .toLowerCase()
+        .replace(/[^a-z0-9-._]/g, '-')
+        .replace(/-+/g, '-')
+        .replace(/^[-_.]+|[-_.]+$/g, '');
+    return cleaned || 'aexis-zero-app';
+}
+function toSlug(name) {
+    return name
+        .trim()
+        .toLowerCase()
+        .replace(/[^a-z0-9-]/g, '-')
+        .replace(/-+/g, '-')
+        .replace(/^-|-$/g, '') || 'aexis-zero-app';
+}