@aex.is/zero 0.1.1 → 0.1.3

package/README.md

@@ -8,6 +8,12 @@ A cross-platform interactive CLI for scaffolding modern apps with a terminal UI.
 npm install -g @aex.is/zero
 ```
 
+## Install (Homebrew)
+
+```sh
+brew install aexis-gh/homebrew-zero/zero
+```
+
 ## Usage
 
 ```sh

package/dist/config/frameworks.js

@@ -0,0 +1,95 @@
+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',
+            '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,69 @@
+export const modules = [
+    {
+        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) {
+    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);
+        }
+    }
+    return Array.from(envVars).sort();
+}

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,251 @@
+import path from 'path';
+import { promises as fs } from 'fs';
+import { execa } from 'execa';
+import { getFrameworkDefinition } from '../config/frameworks.js';
+import { installBaseDependencies, installModulePackages } from './installers.js';
+import { writeEnvExample } from './env.js';
+import { nextLayoutTemplate, nextPageTemplate, shadcnUtilsTemplate, componentsJsonTemplate, tamaguiConfigTemplate, metroConfigTemplate, expoLayoutTemplate, expoIndexTemplate } from './templates.js';
+const baseEnv = {
+    ...process.env,
+    CI: '1'
+};
+export async function scaffoldProject(config) {
+    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) {
+    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, appName, argSets) {
+    const errors = [];
+    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) {
+    const rootAppDir = path.join(targetDir, 'app');
+    const srcAppDir = path.join(targetDir, 'src', 'app');
+    const usesSrcDir = await pathExists(srcAppDir);
+    const appDir = usesSrcDir ? srcAppDir : rootAppDir;
+    const projectSrcBase = usesSrcDir ? path.join(targetDir, 'src') : targetDir;
+    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 ensureShadcnSetup(targetDir, projectSrcBase, usesSrcDir);
+    await ensureNextTurbo(targetDir);
+}
+async function applyExpoTemplates(targetDir) {
+    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);
+    await ensureExpoTamagui(targetDir);
+}
+async function ensureExpoConfig(targetDir) {
+    const appJsonPath = path.join(targetDir, 'app.json');
+    const appJson = await readJson(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) => 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);
+}
+function mergeUnique(values, additions) {
+    const set = new Set(values);
+    for (const value of additions) {
+        set.add(value);
+    }
+    return Array.from(set);
+}
+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;
+    }
+}
+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 ensureShadcnSetup(targetDir, projectSrcBase, usesSrcDir) {
+    const libDir = path.join(projectSrcBase, 'lib');
+    await fs.mkdir(libDir, { recursive: true });
+    await fs.writeFile(path.join(libDir, 'utils.ts'), shadcnUtilsTemplate, 'utf8');
+    const globalsPath = usesSrcDir ? 'src/app/globals.css' : 'app/globals.css';
+    const tailwindConfigPath = await detectTailwindConfig(targetDir);
+    const componentsJson = componentsJsonTemplate(globalsPath, tailwindConfigPath ?? 'tailwind.config.ts');
+    await fs.writeFile(path.join(targetDir, 'components.json'), componentsJson, 'utf8');
+}
+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 ensureExpoTamagui(targetDir) {
+    const configPath = path.join(targetDir, 'tamagui.config.ts');
+    await fs.writeFile(configPath, tamaguiConfigTemplate, 'utf8');
+    const metroPath = path.join(targetDir, 'metro.config.js');
+    await fs.writeFile(metroPath, metroConfigTemplate, 'utf8');
+    await ensureBabelTamagui(targetDir);
+}
+async function ensureBabelTamagui(targetDir) {
+    const babelPath = path.join(targetDir, 'babel.config.js');
+    let content = '';
+    if (await pathExists(babelPath)) {
+        content = await fs.readFile(babelPath, 'utf8');
+    }
+    if (!content) {
+        const defaultConfig = `module.exports = function (api) {\n  api.cache(true);\n  return {\n    presets: ['babel-preset-expo'],\n    plugins: [\n      'expo-router/babel',\n      [\n        '@tamagui/babel-plugin',\n        {\n          config: './tamagui.config.ts',\n          components: ['tamagui']\n        }\n      ]\n    ]\n  };\n};\n`;
+        await fs.writeFile(babelPath, defaultConfig, 'utf8');
+        return;
+    }
+    if (content.includes('@tamagui/babel-plugin')) {
+        return;
+    }
+    const pluginSnippet = `[\n        '@tamagui/babel-plugin',\n        {\n          config: './tamagui.config.ts',\n          components: ['tamagui']\n        }\n      ]`;
+    const pluginsRegex = /plugins:\\s*\\[(.*)\\]/s;
+    if (pluginsRegex.test(content)) {
+        content = content.replace(pluginsRegex, (match, inner) => {
+            const trimmed = inner.trim();
+            const updatedInner = trimmed.length > 0 ? `${trimmed},\n      ${pluginSnippet}` : pluginSnippet;
+            return `plugins: [${updatedInner}]`;
+        });
+    }
+    else {
+        content = content.replace(/return\\s*\\{/, (match) => `${match}\n    plugins: [${pluginSnippet}],`);
+    }
+    await fs.writeFile(babelPath, content, 'utf8');
+}

package/{src/engine/templates.ts → dist/engine/templates.js}

@@ -17,12 +17,10 @@ export default function RootLayout({
   );
 }
 `;
-
 export const nextPageTemplate = `export default function Home() {
   return <main />;
 }
 `;
-
 export const shadcnUtilsTemplate = `import { clsx, type ClassValue } from 'clsx';
 import { twMerge } from 'tailwind-merge';
 
@@ -30,8 +28,7 @@ export function cn(...inputs: ClassValue[]) {
   return twMerge(clsx(inputs));
 }
 `;
-
-export const componentsJsonTemplate = (globalsPath: string, tailwindConfigPath: string) => `{
+export const componentsJsonTemplate = (globalsPath, tailwindConfigPath) => `{
   "$schema": "https://ui.shadcn.com/schema.json",
   "style": "default",
   "rsc": true,
@@ -48,12 +45,10 @@ export const componentsJsonTemplate = (globalsPath: string, tailwindConfigPath:
   }
 }
 `;
-
 export const tamaguiConfigTemplate = `import { config } from '@tamagui/config/v3';
 
 export default config;
 `;
-
 export const metroConfigTemplate = `const { getDefaultConfig } = require('expo/metro-config');
 const { withTamagui } = require('@tamagui/metro-plugin');
 
@@ -65,7 +60,6 @@ module.exports = withTamagui(config, {
   outputCSS: './tamagui-web.css'
 });
 `;
-
 export const expoLayoutTemplate = `import { Stack } from 'expo-router';
 import { TamaguiProvider } from 'tamagui';
 import config from '../tamagui.config';
@@ -78,7 +72,6 @@ export default function RootLayout() {
   );
 }
 `;
-
 export const expoIndexTemplate = `import { Button, H1, YStack } from 'tamagui';
 
 export default function Home() {

package/dist/env/detect.js

@@ -0,0 +1,36 @@
+import which from 'which';
+export function detectPlatform() {
+    switch (process.platform) {
+        case 'darwin':
+            return 'macos';
+        case 'win32':
+            return 'windows';
+        case 'linux':
+            return 'linux';
+        default:
+            return 'linux';
+    }
+}
+export function detectShell(platform = detectPlatform()) {
+    return platform === 'windows' ? 'powershell' : 'posix';
+}
+export async function isBunAvailable() {
+    try {
+        await which('bun');
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+export async function assertBunAvailable() {
+    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/dist/index.js

@@ -0,0 +1,39 @@
+#!/usr/bin/env node
+import { jsx as _jsx } from "react/jsx-runtime";
+import { render } from 'ink';
+import { App } from './ui/App.js';
+import { assertBunAvailable } from './env/detect.js';
+import { scaffoldProject } from './engine/scaffold.js';
+async function main() {
+    try {
+        await assertBunAvailable();
+    }
+    catch (error) {
+        const message = error instanceof Error ? error.message : String(error);
+        console.error(message);
+        process.exitCode = 1;
+        return;
+    }
+    let config = null;
+    const { waitUntilExit } = render(_jsx(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/dist/types.js

@@ -0,0 +1 @@
+export {};

package/dist/ui/App.js

@@ -0,0 +1,75 @@
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import { useCallback, useRef, useState } from 'react';
+import { Box, Text, useApp } from 'ink';
+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 } from './screens/Confirm.js';
+export function App({ onComplete }) {
+    const { exit } = useApp();
+    const [step, setStep] = useState('intro');
+    const [resumeStep, setResumeStep] = useState(null);
+    const [name, setName] = useState('');
+    const [domain, setDomain] = useState('');
+    const [framework, setFramework] = useState('nextjs');
+    const [modules, setModules] = useState([]);
+    const completedRef = useRef(false);
+    const finish = useCallback((config) => {
+        if (completedRef.current) {
+            return;
+        }
+        completedRef.current = true;
+        onComplete(config);
+        exit();
+    }, [exit, onComplete]);
+    const goNext = useCallback((next) => {
+        if (resumeStep) {
+            setStep(resumeStep);
+            setResumeStep(null);
+            return;
+        }
+        setStep(next);
+    }, [resumeStep]);
+    const handleConfirmAction = useCallback((action) => {
+        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 (_jsxs(Box, { flexDirection: "column", children: [step === 'intro' ? null : (_jsx(Text, { color: "cyan", children: "Aexis Zero" })), step === 'intro' ? (_jsx(Intro, { onContinue: () => setStep('name') })) : null, step === 'name' ? (_jsx(NamePrompt, { initialValue: name, onSubmit: (value) => {
+                    setName(value);
+                    goNext('domain');
+                } })) : null, step === 'domain' ? (_jsx(DomainPrompt, { initialValue: domain, onSubmit: (value) => {
+                    setDomain(value);
+                    goNext('framework');
+                } })) : null, step === 'framework' ? (_jsx(FrameworkSelect, { value: framework, onChange: setFramework, onConfirm: () => goNext('modules') })) : null, step === 'modules' ? (_jsx(ModuleSelect, { value: modules, onChange: setModules, onConfirm: () => goNext('confirm') })) : null, step === 'confirm' ? (_jsx(Confirm, { name: name, domain: domain, framework: framework, modules: modules, onAction: handleConfirmAction })) : null] }));
+}