@creatorem/cli 0.0.1 → 1.0.5

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

@@ -0,0 +1,349 @@
+import { FeatureRemover } from '../types.js';
+import { createProject, loadFile, removeImport } from '../../utils/ast.js';
+import fs from 'fs-extra';
+import path from 'path';
+
+export const BillingFeature: FeatureRemover = {
+    key: 'billing',
+    cliUI: {
+        'title': 'Billing',
+        'features': [
+            'Settings billing UI',
+            'Support for Stripe & Lemon Squeezy',
+            'One time payment / Subscription',
+            'Credit wallet implementation',
+        ]
+    },
+    dependenciesToRemove: [
+        '@kit/billing'
+    ],
+    i18nNamespacePrefix: 'p_billing',
+    useFilters: 'useBillingFilters',
+    crossEnvFilter: 'initBillingFilters',
+    filesToDelete: [
+        'config/billing.config.stripe.ts',
+        'config/billing.config.lemon-squeezy.ts',
+        'config/billing.config.ts',
+        'app/api/billing',
+        'app/dashboard/[slug]/settings/organization/billing'
+    ],
+    apply: async (projectRoot: string) => {
+        const dashboardRoot = projectRoot;
+
+        // 1. Update use-filters.ts — remove billingConfig import and its usage in useAIFilters
+        const useFiltersPath = path.join(dashboardRoot, 'hooks/use-filters.ts');
+        if (fs.existsSync(useFiltersPath)) {
+            const project = createProject();
+            const sourceFile = loadFile(project, useFiltersPath);
+            removeImport(sourceFile, '~/config/billing.config');
+            let text = sourceFile.getFullText();
+            // Remove billingConfig from useAIFilters call
+            text = text.replace(/\s*billingConfig,?\n?/g, (match, offset, str) => {
+                // Only remove if inside the useAIFilters block
+                return match.includes('billingConfig') ? '' : match;
+            });
+            // Clean up empty object: useAIFilters({,\n  aiConfig,\n}) -> useAIFilters({ aiConfig })
+            text = text.replace(/useAIFilters\(\{\s*,?\s*([\w]+),?\s*\}\)/g, 'useAIFilters({\n        $1,\n    })');
+            sourceFile.replaceWithText(text);
+            await sourceFile.save();
+        }
+
+        // 2. Update nav-user.tsx
+        const navUserPath = path.join(dashboardRoot, 'components/dashboard/nav-user.tsx');
+        if (fs.existsSync(navUserPath)) {
+            const project = createProject();
+            const sourceFile = loadFile(project, navUserPath);
+
+            // Remove handleNavigateToBillingPage usages
+            let text = sourceFile.getFullText();
+            text = text.replace(/const handleNavigateToBillingPage\s*=\s*\(\):\s*void\s*=>\s*\{[\s\S]*?dashboardRoutes\.paths\.dashboard\.slug\.settings\.organization\.billing\)\);\s*\};\n?/g, '');
+            text = text.replace(/b:\s*\{\s*action:\s*handleNavigateToBillingPage,\s*shift:\s*true\s*\},\n?/g, '');
+            text = text.replace(/<DropdownMenuItem\s+className="cursor-pointer"\s+onClick=\{handleNavigateToBillingPage\}>[\s\S]*?<\/DropdownMenuItem>\n?/g, '');
+
+            sourceFile.replaceWithText(text);
+            await sourceFile.save();
+        }
+    },
+    router: {
+        importName: 'billingRouter',
+        importPath: '@kit/billing/router',
+    },
+    repo: {
+        apply: async (repoRoot: string) => {
+            const kitAiRoot = path.join(repoRoot, 'kit', 'ai');
+            if (!fs.existsSync(kitAiRoot)) return;
+
+            // 1. Remove @kit/billing from kit/ai/package.json
+            const kitAiPkgPath = path.join(kitAiRoot, 'package.json');
+            if (fs.existsSync(kitAiPkgPath)) {
+                const pkg = await fs.readJson(kitAiPkgPath);
+                delete pkg.dependencies?.['@kit/billing'];
+                delete pkg.peerDependencies?.['@kit/billing'];
+                await fs.writeJson(kitAiPkgPath, pkg, { spaces: 4 });
+            }
+
+            // 2. Delete billing-dependent source files
+            for (const file of [
+                'src/components/settings/user-wallet.tsx',
+                'src/components/settings/user-ai-plan-usage.tsx',
+                'src/components/settings/ai-usage-chart.tsx',
+                'src/router/get-ai-usage.ts',
+            ]) {
+                const p = path.join(kitAiRoot, file);
+                if (fs.existsSync(p)) await fs.remove(p);
+            }
+
+            // 3. Rewrite router.ts — remove getAiUsage endpoint
+            const routerPath = path.join(kitAiRoot, 'src/router/router.ts');
+            if (fs.existsSync(routerPath)) {
+                await fs.writeFile(routerPath, `import { CtxRouter } from '@creatorem/next-trpc';
+import { AppClient } from '@kit/db';
+import { createThreadAction, createThreadSchema } from './create-thread';
+import { deleteThreadAction, deleteThreadSchema } from './delete-thread';
+import { selectThreadsAction, selectThreadsSchema } from './select-threads';
+import { updateThreadAction, updateThreadSchema } from './update-thread';
+
+const ctx = new CtxRouter<{ db: AppClient }>();
+
+export const aiRouter = ctx.router({
+    // Thread management
+    createThread: ctx.endpoint.input(createThreadSchema).action(createThreadAction),
+    selectThreads: ctx.endpoint.input(selectThreadsSchema).action(selectThreadsAction),
+    updateThread: ctx.endpoint.input(updateThreadSchema).action(updateThreadAction),
+    deleteThread: ctx.endpoint.input(deleteThreadSchema).action(deleteThreadAction),
+});
+`);
+            }
+
+            // 4. Rewrite ai-usage-manager.ts — remove all billing dependencies, return allowed:true always
+            const usageManagerPath = path.join(kitAiRoot, 'src/server/ai-usage-manager.ts');
+            if (fs.existsSync(usageManagerPath)) {
+                await fs.writeFile(usageManagerPath, `import { AiConfig } from '@kit/ai/config';
+import { AppClient } from '@kit/db';
+
+export interface UsageLimitValidationResult {
+    allowed: boolean;
+    reason?: string;
+    errorMessage?: string;
+    includedAmount?: string;
+    source?: 'plan' | 'wallet' | 'no-limit';
+}
+
+class AiUsageManager {
+    constructor(private db: AppClient, private aiConfig: AiConfig) {}
+
+    async validateUsageLimit(): Promise<UsageLimitValidationResult> {
+        return { allowed: true, source: 'no-limit' };
+    }
+
+    async handleWalletDeduction(): Promise<void> {
+        // Billing removed — no-op
+    }
+}
+
+export function createAiUsageManager(db: AppClient, aiConfig: AiConfig): AiUsageManager {
+    return new AiUsageManager(db, aiConfig);
+}
+`);
+            }
+
+            // 5. Rewrite get-record-ai-usage-handlers.ts — remove billing/subscription checks
+            const handlersPath = path.join(kitAiRoot, 'src/server/get-record-ai-usage-handlers.ts');
+            if (fs.existsSync(handlersPath)) {
+                await fs.writeFile(handlersPath, `import { getDBClient } from '@kit/supabase-server';
+import { eq, sql } from 'drizzle-orm';
+import { aiMessage, aiThread, aiUsage } from '@kit/drizzle';
+import { logger } from '@kit/utils';
+import { AiConfig } from '../config';
+import { StreamTextOnFinishCallback, ToolSet } from 'ai';
+import type { AppClient } from '@kit/db';
+
+const createThread = async (
+    db: AppClient,
+    userId: string,
+    title?: string,
+    metadata?: Record<string, unknown>,
+): Promise<string> => {
+    const metadataJson = JSON.stringify(metadata ?? {});
+    const result = await db.rls.transaction(async (tx) => {
+        const inserted = await tx
+            .insert(aiThread)
+            .values({ userId, title: title ?? null, metadata: JSON.parse(metadataJson) })
+            .returning({ id: aiThread.id });
+        return inserted;
+    });
+    const threadId = result?.[0]?.id;
+    if (!threadId) throw new Error('Failed to create thread');
+    return threadId;
+};
+
+const calculateAiUsageCost = (
+    aiConfig: AiConfig,
+    modelId: string,
+    tokenUsage: { inputTokens?: number; outputTokens?: number; reasoningTokens?: number; cachedInputTokens?: number },
+): number => {
+    const modelPricing = aiConfig.pricing[modelId];
+    if (!modelPricing) {
+        logger.warn({ modelId }, '[AI Usage] No pricing found for model');
+        return 0;
+    }
+    return (
+        ((tokenUsage.inputTokens || 0) / 1_000_000) * modelPricing.inputTokens +
+        ((tokenUsage.outputTokens || 0) / 1_000_000) * modelPricing.outputTokens +
+        ((tokenUsage.reasoningTokens || 0) / 1_000_000) * modelPricing.reasoningTokens +
+        ((tokenUsage.cachedInputTokens || 0) / 1_000_000) * modelPricing.cachedInputTokens
+    );
+};
+
+export const getRecordAiUsageHandlers = async ({
+    aiConfig,
+    body,
+}: {
+    aiConfig: AiConfig;
+    body: { threadId?: string; title?: string; metadata?: Record<string, unknown> };
+}) => {
+    const db = await getDBClient();
+    const user = await db.user.require();
+
+    const effectiveThreadId = body.threadId ?? (await createThread(db, user.id, body.title, body.metadata));
+
+    const onStreamTextFinish: StreamTextOnFinishCallback<ToolSet> = async (result) => {
+        try {
+            const assistantText =
+                typeof result.text === 'string' ? result.text : JSON.stringify(result.text ?? '');
+            await db.rls.transaction(async (tx) => {
+                await tx.insert(aiMessage).values({
+                    threadId: effectiveThreadId!,
+                    userId: user.id,
+                    role: 'assistant',
+                    content: assistantText,
+                });
+                await tx
+                    .update(aiThread)
+                    .set({ updatedAt: sql\`now()\` })
+                    .where(eq(aiThread.id, effectiveThreadId!));
+                if (result.totalUsage) {
+                    const modelId = result.response?.modelId || 'unknown';
+                    const cost = calculateAiUsageCost(aiConfig, modelId, result.totalUsage);
+                    await tx.insert(aiUsage).values({
+                        userId: user.id,
+                        inputTokens: result.totalUsage.inputTokens || 0,
+                        outputTokens: result.totalUsage.outputTokens || 0,
+                        reasoningTokens: result.totalUsage.reasoningTokens || 0,
+                        cachedInputTokens: result.totalUsage.cachedInputTokens || 0,
+                        modelId,
+                        cost: cost.toString(),
+                        aiTimestamp: result.response?.timestamp
+                            ? new Date(result.response.timestamp).toISOString()
+                            : new Date().toISOString(),
+                    });
+                }
+            });
+        } catch (persistErr) {
+            logger.warn({ error: persistErr }, 'Failed to persist assistant message or AI usage');
+        }
+    };
+
+    return { effectiveThreadId, onStreamTextFinish };
+};
+`);
+            }
+
+            // 6. Rewrite use-filters.ts — remove billingConfig param and BillingConfig import
+            const useFiltersPath = path.join(kitAiRoot, 'src/www/filters/use-filters.ts');
+            if (fs.existsSync(useFiltersPath)) {
+                await fs.writeFile(useFiltersPath, `'use client';
+
+import { useSettingsFilters } from './use-filters/use-settings-filters';
+import { AiConfig } from '../../config';
+
+export default function useAiFilters({ aiConfig }: { aiConfig: AiConfig }) {
+    useSettingsFilters({ aiConfig });
+}
+`);
+            }
+
+            // 7. Rewrite use-settings-filters.tsx — remove UserWallet, billingRouter, BillingConfig and wallet section
+            const useSettingsFiltersPath = path.join(kitAiRoot, 'src/www/filters/use-filters/use-settings-filters.tsx');
+            if (fs.existsSync(useSettingsFiltersPath)) {
+                await fs.writeFile(useSettingsFiltersPath, `'use client';
+
+import type { TrpcClientWithQuery } from '@creatorem/next-trpc/query-client';
+import { Muted } from '@kit/ui/text';
+import { FilterCallback, useEnqueueFilter } from '@kit/utils/filters';
+import { useTranslation } from 'react-i18next';
+import { AiConfig } from '../../../config';
+import { aiRouter } from '../../../router/router';
+import { UserAiPlanUsage } from '../../../components/settings/user-ai-plan-usage';
+
+export function useSettingsFilters({ aiConfig }: { aiConfig: AiConfig }) {
+    const { t } = useTranslation('p_ai');
+
+    const ADD_AI_SETTINGS_UI_CONFIG = 'addAiSettingsUIConfig';
+    const addAiSettingsUIConfig: FilterCallback<'get_settings_ui_config'> = (
+        settingsSchema,
+        { clientTrpc },
+    ) => {
+        const otherGroups = settingsSchema.ui.slice(0, -1);
+        const lastGroup = settingsSchema.ui.at(-1);
+
+        return {
+            ui: [
+                ...otherGroups,
+                ...(lastGroup
+                    ? ([
+                        {
+                            ...lastGroup,
+                            settingsPages: [
+                                ...lastGroup.settingsPages,
+                                {
+                                    slug: 'usage',
+                                    title: t('usage.title'),
+                                    icon: 'ChartNoAxesCombined',
+                                    description: t('usage.description'),
+                                    settings: [
+                                        {
+                                            type: 'wrapper',
+                                            settings: [
+                                                {
+                                                    type: 'ui',
+                                                    render: (
+                                                        <div className="space-y-4">
+                                                            <div className="flex flex-col gap-2">
+                                                                <div className="text-2xl font-bold">
+                                                                    {t('usage.aiUsage.title')}
+                                                                </div>
+                                                                <Muted>{t('usage.aiUsage.description')}</Muted>
+                                                            </div>
+                                                            <UserAiPlanUsage
+                                                                clientTrpc={
+                                                                    clientTrpc as TrpcClientWithQuery<typeof aiRouter>
+                                                                }
+                                                                aiConfig={aiConfig}
+                                                            />
+                                                        </div>
+                                                    ),
+                                                },
+                                            ],
+                                        },
+                                    ],
+                                },
+                            ],
+                        },
+                    ] as ReturnType<FilterCallback<'get_settings_ui_config'>>['ui'])
+                    : []),
+            ],
+        };
+    };
+
+    useEnqueueFilter('get_settings_ui_config', {
+        name: ADD_AI_SETTINGS_UI_CONFIG,
+        fn: addAiSettingsUIConfig,
+        priority: 40,
+    });
+}
+`);
+            }
+        },      // closes apply
+    },      // closes repo: {}
+};

package/src/dashboard-features/content-type/index.ts

@@ -0,0 +1,64 @@
+import { FeatureRemover } from '../types.js';
+import fs from 'fs-extra';
+import path from 'path';
+
+const PLACEHOLDER_FILE = `'use client';
+
+import NiceModal, { useModal } from '@ebay/nice-modal-react';
+
+const ContentSearchModal = NiceModal.create(() => {
+    const modal = useModal();
+
+    if (!modal.visible) return null;
+
+    return (
+        <div
+            className="fixed inset-0 z-50 flex items-center justify-center"
+            onClick={() => modal.hide()}
+        >
+            <div
+                className="bg-background border rounded-xl shadow-lg p-8 max-w-md w-full text-center"
+                onClick={(e) => e.stopPropagation()}
+            >
+                <p className="text-muted-foreground text-sm">
+                    Implement your content search component here.
+                </p>
+            </div>
+        </div>
+    );
+});
+
+export const showContentTypeCmdSearch = () => {
+    NiceModal.show(ContentSearchModal);
+};
+`;
+
+export const ContentTypeFeature: FeatureRemover = {
+    key: 'content-type',
+    cliUI: {
+        title: 'Content-type',
+        description: 'Add premade UI & logic around your app tables',
+        'features': [
+            'Premade analytics components',
+            'Search tools helpers',
+            'Archive, edit form components, ...'
+        ]
+    },
+    dependenciesToRemove: [
+        '@kit/content-type'
+    ],
+    filesToDelete: [],
+    apply: async (projectRoot: string) => {
+        const dashboardRoot = projectRoot;
+
+        // Replace lib/show-content-type-cmd-search.tsx with a NiceModal placeholder
+        const showCmdSearchPath = path.join(dashboardRoot, 'lib/show-content-type-cmd-search.tsx');
+        if (fs.existsSync(showCmdSearchPath)) {
+            await fs.writeFile(showCmdSearchPath, PLACEHOLDER_FILE);
+        }
+    },
+    router: {
+        importName: 'contentTypeRouter',
+        importPath: '@kit/content-type/router',
+    },
+};

package/src/dashboard-features/email-templates/index.ts

@@ -0,0 +1,17 @@
+import { FeatureRemover } from '../types.js';
+
+export const EmailTemplatesFeature: FeatureRemover = {
+    key: 'email-templates',
+    cliUI: {
+        title: 'Email templates',
+        description: 'Built with react-email, templates for authentication emails and more.'
+    },
+    dependenciesToRemove: [
+        '@kit/email-templates',
+    ],
+    repo: {
+        filesToDelete: [
+            'kit/email/email-templates',
+        ],
+    },
+};

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

@@ -0,0 +1,27 @@
+import { FeatureRemover } from '../types.js';
+
+export const EmailerFeature: FeatureRemover = {
+    key: 'emailer',
+    // description: 'Emailer (transactional email sending)',
+    'cliUI': {
+        title: 'Email sending',
+        'description': 'Send emails using one of the following providers :',
+        'features': [
+            'Nodemailer (self hosted solution)',
+            'Postmark',
+            'Resend',
+            'Sendgrid'
+        ]
+    },
+    dependenciesToRemove: [
+        '@kit/emailer',
+    ],
+    filesToDelete: [
+        'app/api/auth-email-webhook',
+    ],
+    repo: {
+        filesToDelete: [
+            'kit/email/emailer',
+        ],
+    },
+};

package/src/dashboard-features/index.ts

@@ -0,0 +1,28 @@
+import { FeatureRemover } from './types.js';
+import { OrganizationFeature } from './organization/index.js';
+import { KeybindingsFeature } from './keybindings/index.js';
+import { AnalyticsFeature } from './analytics/index.js';
+import { MonitoringFeature } from './monitoring/index.js';
+import { AIFeature } from './ai/index.js';
+import { NotificationFeature } from './notification/index.js';
+import { BillingFeature } from './billing/index.js';
+import { ContentTypeFeature } from './content-type/index.js';
+import { OnboardingFeature } from './onboarding/index.js';
+import { EmailTemplatesFeature } from './email-templates/index.js';
+import { EmailerFeature } from './emailer/index.js';
+
+export const features: FeatureRemover[] = [
+    OrganizationFeature,
+    KeybindingsFeature,
+    AnalyticsFeature,
+    MonitoringFeature,
+    AIFeature,
+    NotificationFeature,
+    BillingFeature,
+    ContentTypeFeature,
+    OnboardingFeature,
+    EmailTemplatesFeature,
+    EmailerFeature,
+];
+
+export const getFeature = (key: string) => features.find(f => f.key === key);

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

@@ -0,0 +1,52 @@
+import { FeatureRemover } from '../types.js';
+import { createProject, loadFile, removeImport, removeInlineJSX, removePropertyAssignment } from '../../utils/ast.js';
+import fs from 'fs-extra';
+import path from 'path';
+
+export const KeybindingsFeature: FeatureRemover = {
+    key: 'keybindings',
+    cliUI: {
+        title: 'Keybindings',
+        features: [
+            'Settings UI table to set keybindings',
+            'React hooks to register and display keybindings',
+            'Local storage support'
+        ]
+    },
+    // description: 'Keyboard shortcuts support',
+    dependenciesToRemove: ['@kit/keybindings'],
+    i18nNamespacePrefix: 'p_keybindings',
+    useFilters: 'useKeybindingsFilters',
+    crossEnvFilter: 'initKeybindingsFilters',
+    serverFilter: 'initKeybindingsServerFilters',
+    filesToDelete: [
+        '@types/keybindings.d.ts',
+        'config/keybindings.config.ts',
+        'components/providers/keybindings-handlers.tsx',
+    ],
+    apply: async (projectRoot: string) => {
+        const dashboardRoot = projectRoot;
+
+        // Update layout-client.tsx
+        const layoutClientPath = path.join(dashboardRoot, 'app/dashboard/[slug]/layout-client.tsx');
+        if (fs.existsSync(layoutClientPath)) {
+            const project = createProject();
+            const sourceFile = loadFile(project, layoutClientPath);
+
+            removeImport(sourceFile, '~/components/providers/keybindings-handlers');
+            removeImport(sourceFile, '~/config/keybindings.config');
+
+            // Remove <KeybindingsHandlers />
+            removeInlineJSX(sourceFile, 'KeybindingsHandlers');
+
+            // Remove keybindingsModel from options
+            removePropertyAssignment(sourceFile, 'keybindingsModel');
+
+            await sourceFile.save();
+        }
+    },
+    router: {
+        importName: 'getKeybindingsRouter',
+        importPath: '@kit/keybindings/router',
+    },
+};