@creatorem/cli 0.0.1 → 1.0.4

package/src/commands/create-mobile.tsx

@@ -0,0 +1,555 @@
+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 { mobileFeatures } from '../mobile-features/index.js';
+import { processFeature, processFeatureRepo, writeFeatureSelectionManifest } from '../mobile-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;
+    }
+};
+
+const copyApiAppFromTemplateRepo = async (repoUrl: string, targetApiDir: string) => {
+    const tmpDir = path.join(os.tmpdir(), `creatorem-api-template-${Date.now()}`);
+    try {
+        await execa('git', ['clone', '--depth', '1', repoUrl, tmpDir], { stdio: 'pipe' });
+
+        const sourceApiDir = path.join(tmpDir, 'apps', 'api');
+        if (!fs.existsSync(sourceApiDir)) {
+            throw new Error('Template repo does not contain apps/api — please report this issue.');
+        }
+
+        await fs.ensureDir(path.dirname(targetApiDir));
+        await fs.copy(sourceApiDir, targetApiDir, {
+            filter: (src) => !src.includes('node_modules') && !src.includes('.next') && !src.includes('.turbo'),
+        });
+    } finally {
+        if (fs.existsSync(tmpDir)) {
+            await fs.remove(tmpDir).catch(() => { });
+        }
+    }
+};
+
+/** Capitalises the first letter of a string (used for import variable names). */
+const capitalizeFirst = (s: string): string => s.charAt(0).toUpperCase() + s.slice(1);
+
+/** Collect the i18n namespace prefixes declared by a list of features. */
+export 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 `namespaces: [...]` array in
+ * `{mobileAppDir}/config/i18n.config.ts`.
+ * No-op when the array or the file cannot be found.
+ */
+export const updateMobileI18nNamespaces = async (
+    mobileAppDir: string,
+    namespacesToRemove: string[],
+): Promise<void> => {
+    if (namespacesToRemove.length === 0) return;
+
+    const i18nConfigPath = path.join(mobileAppDir, 'config', 'i18n.config.ts');
+    if (!fs.existsSync(i18nConfigPath)) return;
+
+    let content = await fs.readFile(i18nConfigPath, 'utf-8');
+
+    content = content.replace(
+        /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));
+            return `namespaces: [${kept.map((s: string) => `'${s}'`).join(', ')}]`;
+        },
+    );
+
+    await fs.writeFile(i18nConfigPath, content, 'utf-8');
+};
+
+/**
+ * Updates the mobile app's i18n.config.ts to match `selectedLanguages`.
+ * - Removes locale imports and translation entries for excluded languages.
+ * - Adds locale imports and translation entries for newly-added languages.
+ * - Optionally removes namespaces from the `namespaces: [...]` array.
+ * Assumes `{mobileAppDir}/locales/en/` always exists.
+ */
+export const updateMobileI18nConfig = async (
+    mobileAppDir: string,
+    selectedLanguages: string[],
+    namespacesToRemove: string[] = [],
+): Promise<void> => {
+    const i18nConfigPath = path.join(mobileAppDir, 'config', 'i18n.config.ts');
+    if (!fs.existsSync(i18nConfigPath)) return;
+
+    const localesEnDir = path.join(mobileAppDir, 'locales', 'en');
+    if (!fs.existsSync(localesEnDir)) return;
+
+    // Discover namespaces from en locale dir (e.g. common, notification)
+    const namespaces = (await fs.readdir(localesEnDir))
+        .filter((f: string) => f.endsWith('.json'))
+        .map((f: string) => path.basename(f, '.json'));
+
+    // Build locale import statements
+    const newLocaleImports = selectedLanguages
+        .flatMap(lang =>
+            namespaces.map(
+                ns => `import ${lang}${capitalizeFirst(ns)} from '../locales/${lang}/${ns}.json';`,
+            ),
+        )
+        .join('\n');
+
+    // Build translations object entries
+    const translationsEntries = selectedLanguages
+        .map(lang => {
+            const nsEntries = namespaces
+                .map(ns => `        ${ns}: ${lang}${capitalizeFirst(ns)},`)
+                .join('\n');
+            return `    ${lang}: {\n${nsEntries}\n    },`;
+        })
+        .join('\n');
+
+    let content = await fs.readFile(i18nConfigPath, 'utf-8');
+
+    // 1. Strip all existing locale JSON imports
+    content = content.replace(
+        /^import \w+ from '\.\.\/locales\/[^']+\.json';\n?/gm,
+        '',
+    );
+
+    // 2. Replace the translations const block
+    content = content.replace(
+        /const translations = \{[\s\S]*?\n\};/,
+        `const translations = {\n${translationsEntries}\n};`,
+    );
+
+    // 3. Re-insert locale imports just before the translations comment
+    content = content.replace(
+        /\n(\/\/ Create a mapping object)/,
+        `\n${newLocaleImports}\n\n$1`,
+    );
+
+    await fs.writeFile(i18nConfigPath, content, 'utf-8');
+
+    // 4. Remove feature-driven namespaces from the namespaces array
+    await updateMobileI18nNamespaces(mobileAppDir, namespacesToRemove);
+};
+
+interface CreateMobileProps {
+    args: string[];
+    flags?: Record<string, any>;
+}
+
+export const CreateMobile: React.FC<CreateMobileProps> = ({ args, flags = {} }) => {
+    const { exit } = useApp();
+
+    const isEditMode = flags.edit || args.includes('--edit');
+    const editDefaultName = isEditMode ? 'mobile' : '';
+    const [projectName, setProjectName] = useState(args[0] || editDefaultName);
+
+    const initialStep = (args[0] || editDefaultName)
+        ? (flags.features !== undefined ? 'processing' : 'features')
+        : 'name';
+
+    const [step, setStep] = useState<'name' | 'features' | 'processing' | 'done' | 'error'>(initialStep);
+
+    const [selectedFeatures, setSelectedFeatures] = useState<string[]>(() => {
+        if (flags.features !== undefined) {
+            return typeof flags.features === 'string' && flags.features !== ''
+                ? flags.features.split(',').map((f: string) => 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: (typeof mobileFeatures)[number]) =>
+        feature.cliUI.title;
+
+    const allFeatures = mobileFeatures.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[]) => {
+        setSelectedFeatures(selected);
+        setStep('processing');
+
+        try {
+            await createAndModifyProject(projectName, selected);
+            setStep('done');
+            setTimeout(() => { exit(); }, 100);
+        } catch (err: any) {
+            setError(err.message);
+            setStep('error');
+            exit(err);
+        }
+    };
+
+    const createAndModifyProject = async (name: string, selected: string[]) => {
+        const targetDir = path.resolve(process.cwd(), name);
+        const selectedFeatureKeys = mobileFeatures
+            .filter(feature => selected.includes(feature.key))
+            .map(feature => feature.key);
+        const featuresToRemove = mobileFeatures.filter(f => !selectedFeatureKeys.includes(f.key));
+        const repoScope = flags['repo-scope'] || flags.repoScope;
+
+        const existingMonoRoot = findCreatoreMonorepoRoot(process.cwd());
+
+        if (existingMonoRoot) {
+            setDetectedUserType('premium');
+            // ── BRANCH A: inside a Creatorem monorepo ─────────────────────
+            const mobileSource = path.join(existingMonoRoot, 'apps', 'mobile');
+            if (!fs.existsSync(mobileSource)) {
+                throw new Error(`Could not find apps/mobile at ${mobileSource}`);
+            }
+            const dashboardAppDir = path.join(existingMonoRoot, 'apps', 'dashboard');
+            const hasDashboardApp = fs.existsSync(dashboardAppDir);
+
+            const appTargetDir = isEditMode ? mobileSource : targetDir;
+
+            if (!isEditMode && appTargetDir !== mobileSource) {
+                if (fs.existsSync(appTargetDir)) await fs.remove(appTargetDir);
+                setCurrentAction(`Copying mobile app to ${name}...`);
+                await fs.copy(mobileSource, appTargetDir, {
+                    filter: (src) => !src.includes('node_modules') && !src.includes('.expo') && !src.includes('.turbo'),
+                });
+            }
+
+            // Apply app-level feature removals
+            for (const feature of featuresToRemove) {
+                setCurrentAction(`Removing feature: ${getFeatureTitle(feature)}...`);
+                await processFeature(feature, appTargetDir, 'mobile');
+            }
+
+            // If --repo-scope is active, always remove packages/pco-shared,
+            // then run feature-driven repo cleanup when dashboard exists.
+            if (repoScope) {
+                const pcoSharedPackageDir = path.join(existingMonoRoot, 'packages', 'pco-shared');
+                if (fs.existsSync(pcoSharedPackageDir)) {
+                    setCurrentAction('[repo-scope] Removing packages/pco-shared...');
+                    await fs.remove(pcoSharedPackageDir);
+                }
+
+                if (hasDashboardApp) {
+                    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 */ }
+                    }
+
+                    for (const feature of featuresToRemove) {
+                        setCurrentAction(`[repo-scope] Cleaning kit/${feature.key}...`);
+                        await processFeatureRepo(feature, existingMonoRoot);
+                    }
+                } else {
+                    setCurrentAction('[repo-scope] Skipping feature repo cleanup (apps/api backend mode)...');
+                }
+            }
+
+            // 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, 'mobile', selectedFeatureKeys);
+
+            const removedNamespacesA = collectFeatureNamespaces(featuresToRemove);
+            if (removedNamespacesA.length > 0) {
+                setCurrentAction('Updating i18n namespaces...');
+                await updateMobileI18nNamespaces(appTargetDir, removedNamespacesA);
+            }
+
+            if (!hasDashboardApp) {
+                const apiAppDir = path.join(existingMonoRoot, 'apps', 'api');
+                if (!fs.existsSync(apiAppDir)) {
+                    setCurrentAction('No dashboard found. Adding apps/api backend...');
+                    const hasPro = await checkProAccess();
+                    const repoUrl = hasPro ? PRO_REPO : OSS_REPO;
+                    await copyApiAppFromTemplateRepo(repoUrl, apiAppDir);
+                }
+
+                const trpcRoutePath = path.join(apiAppDir, 'app', 'api', 'trpc', '[trpc]', 'route.ts');
+                if (!fs.existsSync(trpcRoutePath)) {
+                    throw new Error('apps/api is missing app/api/trpc/[trpc]/route.ts in template repo.');
+                }
+
+                for (const feature of featuresToRemove) {
+                    setCurrentAction(`[api] Removing feature: ${getFeatureTitle(feature)}...`);
+                    await processFeature(feature, apiAppDir, 'dashboard');
+                }
+
+                setCurrentAction('[api] Generating .env.template...');
+                await generateDashboardEnvTemplate(apiAppDir, existingMonoRoot, {
+                    createEnvFile: true,
+                    fallbackMonoRoot: process.cwd(),
+                });
+            }
+
+            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 ────────────────────
+            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 clonedMobile = path.join(tmpDir, 'apps', 'mobile');
+                if (!fs.existsSync(clonedMobile)) {
+                    throw new Error('Template repo does not contain apps/mobile — please report this issue.');
+                }
+                const clonedApi = path.join(tmpDir, 'apps', 'api');
+                if (!fs.existsSync(clonedApi)) {
+                    throw new Error('Template repo does not contain apps/api — please report this issue.');
+                }
+                const trpcRoutePath = path.join(clonedApi, 'app', 'api', 'trpc', '[trpc]', 'route.ts');
+                if (!fs.existsSync(trpcRoutePath)) {
+                    throw new Error('apps/api is missing app/api/trpc/[trpc]/route.ts in template repo.');
+                }
+
+                // 1. Delete all apps/* except apps/mobile and apps/api
+                setCurrentAction('Removing apps except mobile and api...');
+                const appsDir = path.join(tmpDir, 'apps');
+                const appEntries = await fs.readdir(appsDir);
+                for (const entry of appEntries) {
+                    if (entry !== 'mobile' && entry !== 'api') {
+                        await fs.remove(path.join(appsDir, entry));
+                    }
+                }
+
+                // 2. Apply app-level feature removals on mobile + api apps
+                for (const feature of featuresToRemove) {
+                    setCurrentAction(`Removing feature: ${getFeatureTitle(feature)}...`);
+                    await processFeature(feature, clonedMobile, 'mobile');
+                }
+                for (const feature of featuresToRemove) {
+                    setCurrentAction(`[api] Removing feature: ${getFeatureTitle(feature)}...`);
+                    await processFeature(feature, clonedApi, 'dashboard');
+                }
+
+                // Generate .env.template from the (now-trimmed) envs.ts
+                setCurrentAction('Generating .env.template...');
+                await generateDashboardEnvTemplate(clonedMobile, tmpDir, {
+                    createEnvFile: true,
+                    fallbackMonoRoot: process.cwd(),
+                });
+                setCurrentAction('[api] Generating .env.template...');
+                await generateDashboardEnvTemplate(clonedApi, tmpDir, {
+                    createEnvFile: true,
+                    fallbackMonoRoot: process.cwd(),
+                });
+
+                setCurrentAction('Saving selected features metadata...');
+                await writeFeatureSelectionManifest(clonedMobile, 'mobile', selectedFeatureKeys);
+
+                const removedNamespacesB = collectFeatureNamespaces(featuresToRemove);
+                if (removedNamespacesB.length > 0) {
+                    setCurrentAction('Updating i18n namespaces...');
+                    await updateMobileI18nNamespaces(clonedMobile, removedNamespacesB);
+                }
+
+                if (repoScope) {
+                    const pcoSharedPackageDir = path.join(tmpDir, 'packages', 'pco-shared');
+                    if (fs.existsSync(pcoSharedPackageDir)) {
+                        setCurrentAction('[repo-scope] Removing packages/pco-shared...');
+                        await fs.remove(pcoSharedPackageDir);
+                    }
+                }
+
+                // 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) {
+                if (fs.existsSync(tmpDir)) await fs.remove(tmpDir).catch(() => { });
+                throw err;
+            }
+        }
+
+        setCurrentAction('Done.');
+    };
+
+    // Auto-exec when initialized directly in processing state (via --features flag)
+    useEffect(() => {
+        if (initialStep === 'processing' && flags.features !== undefined) {
+            const run = async () => {
+                try {
+                    const featuresToSelect = typeof flags.features === 'string' && flags.features !== ''
+                        ? flags.features.split(',').map((f: string) => f.trim())
+                        : [];
+                    await createAndModifyProject(projectName, featuresToSelect);
+                    setStep('done');
+                    setTimeout(() => { exit(); }, 100);
+                } catch (err: any) {
+                    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!`
+                            : `Mobile app "${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 CreateMobile;