@creatorem/cli 0.0.1 → 1.0.4

package/src/dashboard-features/manager.ts

@@ -0,0 +1,349 @@
+
+import { FeatureRemover } from './types.js';
+import {
+    createProject,
+    loadFile,
+    removeImport,
+    removeHookCall,
+    removeObjectFromArray,
+    removeI18nNamespace,
+    removeInternalPackages,
+    unwrapDefaultExport,
+    removeSpreadFromObject,
+    removeEnvExtendsByModuleSpecifiers
+} from '../utils/ast.js';
+import fs from 'fs-extra';
+import path from 'path';
+import { SyntaxKind } from 'ts-morph';
+
+interface FeaturesManifest {
+    appType: 'dashboard' | 'mobile';
+    selectedFeatures: string[];
+}
+
+const matchesNamespacePrefix = (value: string, prefixes: string[]) =>
+    prefixes.some(prefix => value === prefix || value.startsWith(`${prefix}-`));
+
+const removeMatchingNamespacesFromArray = (arrayLiteral: any, prefixes: string[]) => {
+    const elements = arrayLiteral.getElements();
+    for (let i = elements.length - 1; i >= 0; i -= 1) {
+        const element = elements[i];
+        if (element.getKind() !== SyntaxKind.StringLiteral) continue;
+        const literalText = element.asKind(SyntaxKind.StringLiteral)?.getLiteralText();
+        if (literalText && matchesNamespacePrefix(literalText, prefixes)) {
+            arrayLiteral.removeElement(i);
+        }
+    }
+};
+
+const cleanupI18nConfig = async (appRoot: string, namespacePrefixes: string[]) => {
+    if (namespacePrefixes.length === 0) return;
+
+    const i18nConfigPath = path.join(appRoot, 'config', 'i18n.config.ts');
+    if (!fs.existsSync(i18nConfigPath)) return;
+
+    const project = createProject();
+    const sourceFile = loadFile(project, i18nConfigPath);
+
+    const removedImportIdentifiers = new Set<string>();
+
+    for (const importDeclaration of sourceFile.getImportDeclarations()) {
+        const moduleSpecifier = importDeclaration.getModuleSpecifierValue();
+        if (!moduleSpecifier.endsWith('.json')) continue;
+
+        const namespace = path.basename(moduleSpecifier, '.json').replace(/['"]/g, '');
+        if (!matchesNamespacePrefix(namespace, namespacePrefixes)) continue;
+
+        const defaultImport = importDeclaration.getDefaultImport();
+        if (defaultImport) {
+            removedImportIdentifiers.add(defaultImport.getText());
+        }
+
+        importDeclaration.remove();
+    }
+
+    const propertyAssignments = sourceFile.getDescendantsOfKind(SyntaxKind.PropertyAssignment);
+    for (const assignment of propertyAssignments) {
+        const initializer = assignment.getInitializer();
+        if (initializer && removedImportIdentifiers.has(initializer.getText())) {
+            assignment.remove();
+            continue;
+        }
+
+        const propertyName = assignment.getNameNode().getText().replace(/['"]/g, '');
+        if (matchesNamespacePrefix(propertyName, namespacePrefixes)) {
+            assignment.remove();
+        }
+    }
+
+    const parseI18nConfigCall = sourceFile
+        .getDescendantsOfKind(SyntaxKind.CallExpression)
+        .find(callExpression => callExpression.getExpression().getText() === 'parseI18nConfig');
+
+    const optionsArg = parseI18nConfigCall?.getArguments()[0];
+    const optionsObject =
+        optionsArg?.getKind() === SyntaxKind.ObjectLiteralExpression
+            ? optionsArg.asKind(SyntaxKind.ObjectLiteralExpression)
+            : undefined;
+    const namespacesProperty = optionsObject?.getProperty('namespaces');
+    const namespacesInitializer =
+        namespacesProperty?.getKind() === SyntaxKind.PropertyAssignment
+            ? namespacesProperty.asKind(SyntaxKind.PropertyAssignment)?.getInitializer()
+            : undefined;
+
+    if (namespacesInitializer?.getKind() === SyntaxKind.ArrayLiteralExpression) {
+        removeMatchingNamespacesFromArray(
+            namespacesInitializer.asKind(SyntaxKind.ArrayLiteralExpression),
+            namespacePrefixes,
+        );
+    } else if (namespacesInitializer?.getKind() === SyntaxKind.Identifier) {
+        const namespacesVar = sourceFile.getVariableDeclaration(namespacesInitializer.getText());
+        const namespacesVarInitializer = namespacesVar?.getInitializer();
+
+        if (namespacesVarInitializer?.getKind() === SyntaxKind.ArrayLiteralExpression) {
+            removeMatchingNamespacesFromArray(
+                namespacesVarInitializer.asKind(SyntaxKind.ArrayLiteralExpression),
+                namespacePrefixes,
+            );
+        } else if (namespacesVarInitializer?.getKind() === SyntaxKind.CallExpression) {
+            const namespacesVarCall = namespacesVarInitializer.asKind(SyntaxKind.CallExpression);
+            for (const arg of namespacesVarCall?.getArguments() ?? []) {
+                if (arg.getKind() === SyntaxKind.ArrayLiteralExpression) {
+                    removeMatchingNamespacesFromArray(
+                        arg.asKind(SyntaxKind.ArrayLiteralExpression),
+                        namespacePrefixes,
+                    );
+                }
+            }
+        }
+    }
+
+    await sourceFile.save();
+};
+
+export const processFeature = async (feature: FeatureRemover, projectRoot: string, appType: 'dashboard' | 'mobile' = 'dashboard') => {
+    const dashboardRoot = projectRoot;
+    const namespacePrefixes = feature.i18nNamespacePrefix
+        ? (Array.isArray(feature.i18nNamespacePrefix)
+            ? feature.i18nNamespacePrefix
+            : [feature.i18nNamespacePrefix])
+        : [];
+
+    // 1. Remove dependencies from package.json
+    if (feature.dependenciesToRemove && feature.dependenciesToRemove.length > 0) {
+        const packageJsonPath = path.join(dashboardRoot, 'package.json');
+        if (fs.existsSync(packageJsonPath)) {
+            const packageJson = await fs.readJson(packageJsonPath);
+            let modified = false;
+            for (const dep of feature.dependenciesToRemove) {
+                if (packageJson.dependencies && packageJson.dependencies[dep]) {
+                    delete packageJson.dependencies[dep];
+                    modified = true;
+                }
+                if (packageJson.devDependencies && packageJson.devDependencies[dep]) {
+                    delete packageJson.devDependencies[dep];
+                    modified = true;
+                }
+            }
+            if (modified) {
+                await fs.writeJson(packageJsonPath, packageJson, { spaces: 4 });
+            }
+        }
+
+        // 2. Remove dependencies from next.config.ts (INTERNAL_PACKAGES)
+        const nextConfigPath = path.join(dashboardRoot, 'next.config.ts');
+        if (fs.existsSync(nextConfigPath)) {
+            const project = createProject();
+            const sourceFile = loadFile(project, nextConfigPath);
+            removeInternalPackages(sourceFile, feature.dependenciesToRemove);
+
+            // Handle nextConfigProvider if present
+            if (feature.nextConfigProvider) {
+                const importPath = `@kit/${feature.key}/provider`;
+                removeImport(sourceFile, importPath);
+                unwrapDefaultExport(sourceFile, feature.nextConfigProvider);
+            }
+
+            await sourceFile.save();
+        }
+
+        // 2b. Remove env imports and extends callbacks from envs.ts
+        const envsPath = path.join(dashboardRoot, 'envs.ts');
+        if (fs.existsSync(envsPath)) {
+            const project = createProject();
+            const sourceFile = loadFile(project, envsPath);
+            removeEnvExtendsByModuleSpecifiers(sourceFile, feature.dependenciesToRemove);
+            await sourceFile.save();
+        }
+    }
+
+    // 3. Remove i18n namespace
+    if (feature.i18nNamespacePrefix) {
+        const i18nPath = path.join(dashboardRoot, '@types/i18next.d.ts');
+        if (fs.existsSync(i18nPath)) {
+            const project = createProject();
+            const sourceFile = loadFile(project, i18nPath);
+
+            for (const prefix of namespacePrefixes) {
+                removeI18nNamespace(sourceFile, prefix);
+            }
+
+            await sourceFile.save();
+        }
+
+        await cleanupI18nConfig(dashboardRoot, namespacePrefixes);
+    }
+
+    // 4. Remove useFilters (hooks/use-filters.ts)
+    if (feature.useFilters) {
+        const useFiltersPath = path.join(dashboardRoot, 'hooks/use-filters.ts');
+        if (fs.existsSync(useFiltersPath)) {
+            const project = createProject();
+            const sourceFile = loadFile(project, useFiltersPath);
+
+            const hookModule = appType === 'mobile' ? 'native' : 'www';
+            const importPath = `@kit/${feature.key}/${hookModule}/use-filters`;
+            removeImport(sourceFile, importPath);
+            removeHookCall(sourceFile, feature.useFilters);
+
+            await sourceFile.save();
+        }
+    }
+
+    // 5. Remove proxy (proxy.ts)
+    if (feature.proxy) {
+        const proxyPath = path.join(dashboardRoot, 'proxy.ts');
+        if (fs.existsSync(proxyPath)) {
+            const project = createProject();
+            const sourceFile = loadFile(project, proxyPath);
+
+            const proxyModule = appType === 'mobile' ? 'native' : 'www';
+            const importPath = `@kit/${feature.key}/${proxyModule}/proxy`;
+            removeImport(sourceFile, importPath);
+
+            // Assume callProxies array contains objects with 'proxy' property matching the variable name
+            removeObjectFromArray(sourceFile, 'callProxies', 'proxy', feature.proxy);
+
+            await sourceFile.save();
+        }
+    }
+
+    // 6. Remove cross-env filters (lib/init-cross-env-filters.ts)
+    if (feature.crossEnvFilter) {
+        const initFiltersPath = path.join(dashboardRoot, 'lib/init-cross-env-filters.ts');
+        if (fs.existsSync(initFiltersPath)) {
+            const project = createProject();
+            const sourceFile = loadFile(project, initFiltersPath);
+
+            const importPath = `@kit/${feature.key}/www/cross-env-filters`;
+            removeImport(sourceFile, importPath);
+            removeHookCall(sourceFile, feature.crossEnvFilter);
+
+            await sourceFile.save();
+        }
+    }
+
+    // 7. Remove server filters (lib/init-server-filters.ts)
+    if (feature.serverFilter) {
+        const initServerFiltersPath = path.join(dashboardRoot, 'lib/init-server-filters.ts');
+        if (fs.existsSync(initServerFiltersPath)) {
+            const project = createProject();
+            const sourceFile = loadFile(project, initServerFiltersPath);
+
+            const importPath = `@kit/${feature.key}/www/server-filters`;
+            removeImport(sourceFile, importPath);
+            removeHookCall(sourceFile, feature.serverFilter);
+
+            await sourceFile.save();
+        }
+    }
+
+    // 8. Delete files/directories
+    if (feature.filesToDelete && feature.filesToDelete.length > 0) {
+        for (const fileOrDir of feature.filesToDelete) {
+            const targetPath = path.join(dashboardRoot, fileOrDir);
+            if (fs.existsSync(targetPath)) {
+                await fs.remove(targetPath);
+            }
+        }
+    }
+
+    // 9. Remove router entry from shared appRouter file
+    if (feature.router) {
+        // The router file path is relative to the monorepo root, not the app root.
+        // Walk up from dashboardRoot to find the monorepo root.
+        const monoMarkers = ['pnpm-workspace.yaml', 'turbo.json', 'lerna.json', 'nx.json'];
+        let monoRoot: string | null = null;
+        let cur = dashboardRoot;
+        while (true) {
+            if (monoMarkers.some(m => fs.existsSync(path.join(cur, m)))) {
+                monoRoot = cur;
+                break;
+            }
+            const parent = path.dirname(cur);
+            if (parent === cur) break;
+            cur = parent;
+        }
+        const resolveRoot = monoRoot ?? dashboardRoot;
+        const routerFilePath = path.join(resolveRoot, feature.router.routerFile ?? 'packages/shared/src/server/router.ts');
+        if (fs.existsSync(routerFilePath)) {
+            const project = createProject();
+            const sourceFile = loadFile(project, routerFilePath);
+            removeImport(sourceFile, feature.router.importPath);
+            removeSpreadFromObject(sourceFile, 'appRouter', feature.router.importName);
+            await sourceFile.save();
+        }
+    }
+
+    // 10. Run custom apply logic if exists
+    if (feature.apply) {
+        await feature.apply(projectRoot, appType);
+    }
+};
+
+/**
+ * Handles repo-wide cleanup for a feature when --repo-scope is active.
+ * Deletes the kit/{feature.key} package directory (if it exists) and calls
+ * feature.repoApply() for any additional custom cleanup.
+ */
+export const processFeatureRepo = async (feature: FeatureRemover, repoRoot: string) => {
+    // Delete the kit package directory for this feature
+    const kitPackageDir = path.join(repoRoot, 'kit', feature.key);
+    if (fs.existsSync(kitPackageDir)) {
+        await fs.remove(kitPackageDir);
+    }
+
+    // Delete declarative repo-level files/directories
+    if (feature.repo?.filesToDelete && feature.repo.filesToDelete.length > 0) {
+        for (const fileOrDir of feature.repo.filesToDelete) {
+            const targetPath = path.join(repoRoot, fileOrDir);
+            if (fs.existsSync(targetPath)) {
+                await fs.remove(targetPath);
+            }
+        }
+    }
+
+    // Run any custom repo-level cleanup
+    if (feature.repo?.apply) {
+        await feature.repo.apply(repoRoot);
+    }
+};
+
+export const writeFeatureSelectionManifest = async (
+    projectRoot: string,
+    appType: 'dashboard' | 'mobile',
+    selectedFeatures: string[],
+) => {
+    const normalizedFeatures = Array.from(
+        new Set(selectedFeatures.map(key => key.trim()).filter(Boolean)),
+    );
+
+    const manifest: FeaturesManifest = {
+        appType,
+        selectedFeatures: normalizedFeatures,
+    };
+
+    const metadataDir = path.join(projectRoot, '.creatorem');
+    await fs.ensureDir(metadataDir);
+    await fs.writeJson(path.join(metadataDir, 'features.json'), manifest, { spaces: 2 });
+};

package/src/dashboard-features/monitoring/index.ts

@@ -0,0 +1,16 @@
+import { FeatureRemover } from '../types.js';
+
+export const MonitoringFeature: FeatureRemover = {
+    key: 'monitoring',
+    cliUI: {
+        title: 'Monitoring',
+        'description': 'Monitor your app with Sentry'
+    },
+    dependenciesToRemove: ['@kit/monitoring'],
+    useFilters: 'useMonitoringFilters',
+    filesToDelete: [
+        'instrumentation.ts',
+        'instrumentation-client.ts'
+    ],
+    nextConfigProvider: 'MonitoringProvider.withConfig',
+};

package/src/dashboard-features/notification/index.ts

@@ -0,0 +1,40 @@
+import { FeatureRemover } from '../types.js';
+import { createProject, loadFile, removeImport, removeInlineJSX } from '../../utils/ast.js';
+import fs from 'fs-extra';
+import path from 'path';
+
+export const NotificationFeature: FeatureRemover = {
+    key: 'notification',
+    cliUI: {
+        title: 'Notification',
+        features: [
+            'Add notification UI to your dashboard',
+            'Database implementation',
+            'Logic to create notification when you desire'
+        ]
+    },
+    dependenciesToRemove: ['@kit/notification'],
+    useFilters: 'useNotificationFilters',
+    filesToDelete: [
+        'app/(app)/screens/notifications.tsx',
+        "supabase/schemas/023-notifications.sql"
+    ],
+    apply: async (projectRoot: string, appType: 'dashboard' | 'mobile') => {
+        const dashboardRoot = projectRoot;
+        const actionGroupPath = path.join(dashboardRoot, 'components/dashboard/dashboard-action-group.tsx');
+
+        if (fs.existsSync(actionGroupPath)) {
+            const project = createProject();
+            const sourceFile = loadFile(project, actionGroupPath);
+
+            removeImport(sourceFile, '@kit/notification/www/ui/notification-button');
+            removeInlineJSX(sourceFile, 'NotificationButton');
+
+            await sourceFile.save();
+        }
+    },
+    router: {
+        importName: 'notificationRouter',
+        importPath: '@kit/notification/router',
+    },
+};

package/src/dashboard-features/onboarding/index.ts

@@ -0,0 +1,65 @@
+import { FeatureRemover } from '../types.js';
+import fs from 'fs-extra';
+import path from 'path';
+
+export const OnboardingFeature: FeatureRemover = {
+    key: 'onboarding',
+    cliUI: {
+        title: 'Onboarding',
+        description: 'Collect additional informations after subscription.'
+    },
+    dependenciesToRemove: [],
+    i18nNamespacePrefix: ['onboarding', 'p_org-onboarding'],
+    filesToDelete: [
+        'app/onboarding',
+        'config/onboarding.config.tsx',
+        'public/locales/en/onboarding.json',
+        'public/locales/fr/onboarding.json',
+    ],
+    apply: async (projectRoot: string) => {
+        const dashboardRoot = projectRoot;
+
+        // 1. Remove 'onboarding' from i18n namespace array in config/i18n.config.ts
+        const i18nConfigPath = path.join(dashboardRoot, 'config/i18n.config.ts');
+        if (fs.existsSync(i18nConfigPath)) {
+            let content = await fs.readFile(i18nConfigPath, 'utf-8');
+            // Remove the 'onboarding' entry from the namespaces array
+            content = content.replace(/\n?\s*'onboarding',?/g, '');
+            await fs.writeFile(i18nConfigPath, content);
+        }
+
+        // 2. Remove completedOnboarding redirect from app/dashboard/layout.tsx
+        const dashboardLayoutPath = path.join(dashboardRoot, 'app/dashboard/layout.tsx');
+        if (fs.existsSync(dashboardLayoutPath)) {
+            let content = await fs.readFile(dashboardLayoutPath, 'utf-8');
+            // Remove the completedOnboarding redirect block
+            content = content.replace(/\n?\s*if \(!user\.completedOnboarding\) \{[^}]*\}\n?/g, '');
+            await fs.writeFile(dashboardLayoutPath, content);
+        }
+
+        // 3. Update authConfig: remove |onboarding from the private scope pattern string
+        const authConfigPath = path.join(dashboardRoot, 'config/auth.config.ts');
+        if (fs.existsSync(authConfigPath)) {
+            let content = await fs.readFile(authConfigPath, 'utf-8');
+            // Remove |onboarding (or onboarding|) from the scopePatterns.private value
+            content = content.replace(/\|onboarding/g, '');
+            content = content.replace(/onboarding\|/g, '');
+            await fs.writeFile(authConfigPath, content);
+        }
+
+        // 4. Clean up @types/i18next.d.ts
+        const i18nextDtsPath = path.join(dashboardRoot, '@types/i18next.d.ts');
+        if (fs.existsSync(i18nextDtsPath)) {
+            let content = await fs.readFile(i18nextDtsPath, 'utf-8');
+            // Remove the onboarding locale import
+            content = content.replace(/import onboarding from '\.\.\/public\/locales\/en\/onboarding\.json';\n?/g, '');
+            // Remove the p_org-onboarding kit import
+            content = content.replace(/import enOrgOnboarding from '\.\.\/.\.\/\.\.\/(kit|packages)\/organization\/src\/i18n\/locales\/en\/p_org-onboarding\.json';\n?/g, '');
+            // Remove 'onboarding: typeof onboarding;' resource type
+            content = content.replace(/\n?\s*onboarding: typeof onboarding;/g, '');
+            // Remove "'p_org-onboarding': typeof enOrgOnboarding;" resource type
+            content = content.replace(/\n?\s*'p_org-onboarding': typeof enOrgOnboarding;/g, '');
+            await fs.writeFile(i18nextDtsPath, content);
+        }
+    }
+};

package/src/dashboard-features/organization/index.ts

@@ -0,0 +1,38 @@
+import { FeatureRemover } from '../types.js';
+
+export const OrganizationFeature: FeatureRemover = {
+    key: 'organization',
+    cliUI: {
+        title: 'Organization',
+        features: [
+            'Database implementation',
+            'Role management',
+            'Member management',
+            'Built React logic (useOrganization, <OrganizationSwitcher />, ...)'
+        ]
+    },
+    dependenciesToRemove: [
+        '@kit/organization',
+    ],
+    i18nNamespacePrefix: 'p_org',
+    useFilters: 'useOrgFilters',
+    proxy: 'organizationProxy',
+    crossEnvFilter: 'initOrgFilters',
+    serverFilter: 'initOrgServerFilters',
+    router: {
+        importName: 'organizationRouter',
+        importPath: '@kit/organization/router',
+    },
+    repo: {
+        filesToDelete: [
+            'supabase/schemas/030-organization-enums.sql',
+            'supabase/schemas/031-kit-org.sql',
+            'supabase/schemas/032-organization.sql',
+            'supabase/schemas/033-organization-roles.sql',
+            'supabase/schemas/034-organization-members.sql',
+            'supabase/schemas/035-organization-invitations.sql',
+            'supabase/schemas/036-organization-settings.sql',
+            'supabase/schemas/037-organization-notifications.sql',
+        ],
+    },
+};

package/src/dashboard-features/types.ts

@@ -0,0 +1,41 @@
+export interface FeatureRemover {
+    key: string;
+    cliUI: {
+        title: string;
+        description?: string;
+        features?: string[]
+    }
+    dependenciesToRemove: string[];
+    i18nNamespacePrefix?: string | string[];
+
+    // Declarative properties
+    useFilters?: string; // Name of the hook. Import inferred: @kit/{key}/www/use-filters
+    proxy?: string; // Name of the proxy variable. Import inferred: @kit/{key}/www/proxy
+    crossEnvFilter?: string; // Name of the filter. Import inferred: @kit/{key}/www/cross-env-filters
+    serverFilter?: string; // Name of the filter. Import inferred: @kit/{key}/www/server-filters
+    nextConfigProvider?: string; // Name of the provider to unwrap in next.config.ts. Import inferred: @kit/{key}/provider
+
+    filesToDelete?: string[]; // Files or directories to delete (relative to app root)
+
+    /**
+     * Router to remove from the shared appRouter.
+     * importName: the exported identifier (e.g. 'aiRouter', 'getKeybindingsRouter')
+     * routerFile: path to the file containing appRouter, relative to app root
+     *             (defaults to 'lib/server/router.ts' if omitted)
+     */
+    router?: {
+        importName: string; // e.g. 'aiRouter' | 'getKeybindingsRouter'
+        importPath: string; // e.g. '@kit/ai/router'
+        routerFile?: string; // relative to app root, default: 'lib/server/router.ts'
+    };
+
+    apply?: (projectRoot: string, appType: 'dashboard' | 'mobile') => Promise<void>;
+
+    /** Repo-scope cleanup, applied when --repo-scope is active. */
+    repo?: {
+        /** Files or directories to delete relative to the monorepo root. */
+        filesToDelete?: string[];
+        /** Custom monorepo-level cleanup (kit packages, supabase schemas, etc.). */
+        apply?: (repoRoot: string) => Promise<void>;
+    };
+}

package/src/mobile-features/index.ts

@@ -0,0 +1,12 @@
+import { FeatureRemover } from './types.js';
+import { MobileOrganizationFeature } from './organization/index.js';
+import { MobileNotificationFeature } from './notification/index.js';
+import { MobileOnboardingFeature } from './onboarding/index.js';
+
+export const mobileFeatures: FeatureRemover[] = [
+    MobileOrganizationFeature,
+    MobileNotificationFeature,
+    MobileOnboardingFeature,
+];
+
+export const getMobileFeature = (key: string) => mobileFeatures.find(f => f.key === key);

package/src/mobile-features/manager.ts

@@ -0,0 +1 @@
+export { processFeature, processFeatureRepo, writeFeatureSelectionManifest } from '../dashboard-features/manager.js';

package/src/mobile-features/notification/index.ts

@@ -0,0 +1,41 @@
+import { FeatureRemover } from '../types.js';
+import { createProject, loadFile, removeImport, removeInlineJSX } from '../../utils/ast.js';
+import fs from 'fs-extra';
+import path from 'path';
+
+export const MobileNotificationFeature: FeatureRemover = {
+    key: 'notification',
+    cliUI: {
+        title: 'Notification',
+        features: [
+            'Add notification UI to your dashboard',
+            'Database implementation',
+            'Logic to create notification when you desire'
+        ]
+    },
+    dependenciesToRemove: ['@kit/notification'],
+    i18nNamespacePrefix: 'notification',
+    router: {
+        importName: 'notificationRouter',
+        importPath: '@kit/notification/router',
+    },
+    filesToDelete: [
+        'app/(app)/screens/notifications.tsx',
+        'components/notification-icon.tsx',
+        'locales/en/notification.json',
+        'locales/fr/notification.json',
+        "supabase/schemas/023-notifications.sql"
+    ],
+    apply: async (projectRoot: string) => {
+        const homeTabsPath = path.join(projectRoot, 'app/(app)/(tabs)/index.tsx');
+        if (!fs.existsSync(homeTabsPath)) return;
+
+        const project = createProject();
+        const sourceFile = loadFile(project, homeTabsPath);
+
+        removeImport(sourceFile, '~/components/notification-icon');
+        removeInlineJSX(sourceFile, 'NotificationIcon');
+
+        await sourceFile.save();
+    },
+};

package/src/mobile-features/onboarding/index.ts

@@ -0,0 +1,35 @@
+import { FeatureRemover } from '../types.js';
+import { createProject, loadFile } from '../../utils/ast.js';
+import { SyntaxKind } from 'ts-morph';
+import fs from 'fs-extra';
+import path from 'path';
+
+export const MobileOnboardingFeature: FeatureRemover = {
+    key: 'onboarding',
+    cliUI: {
+        title: 'Onboarding',
+        description: 'Collect additional informations after subscription.'
+    },
+    dependenciesToRemove: [],
+    i18nNamespacePrefix: ['p_org-onboarding'],
+    filesToDelete: [
+        'app/onboarding',
+        'config/onboarding.config.tsx',
+    ],
+    apply: async (projectRoot: string) => {
+        const appLayoutPath = path.join(projectRoot, 'app/(app)/_layout.tsx');
+        if (!fs.existsSync(appLayoutPath)) return;
+
+        const project = createProject();
+        const sourceFile = loadFile(project, appLayoutPath);
+
+        const ifStatements = sourceFile.getDescendantsOfKind(SyntaxKind.IfStatement);
+        for (const ifStatement of ifStatements) {
+            if (ifStatement.getExpression().getText() === '!user.data.completedOnboarding') {
+                ifStatement.remove();
+            }
+        }
+
+        await sourceFile.save();
+    },
+};