create-loadout 1.0.0

package/dist/generate-readme.js

@@ -0,0 +1,160 @@
+import fs from 'fs/promises';
+import path from 'path';
+const integrationNames = {
+    clerk: 'Clerk',
+    'neon-drizzle': 'Neon + Drizzle',
+    'ai-sdk': 'Vercel AI SDK',
+    resend: 'Resend',
+    firecrawl: 'Firecrawl',
+    inngest: 'Inngest',
+    uploadthing: 'UploadThing',
+    stripe: 'Stripe',
+    posthog: 'PostHog',
+    sentry: 'Sentry',
+};
+export async function generateReadme(projectPath, config) {
+    let content = `# ${config.name}
+
+A Next.js application scaffolded with [create-loadout](https://github.com/your-org/create-loadout).
+
+## Getting Started
+
+1. Install dependencies:
+   \`\`\`bash
+   npm install
+   \`\`\`
+
+2. Copy the environment file and configure your API keys:
+   \`\`\`bash
+   cp .env.example .env.local
+   \`\`\`
+
+3. Start the development server:
+   \`\`\`bash
+   npm run dev
+   \`\`\`
+
+4. Open [http://localhost:3000](http://localhost:3000) in your browser.
+
+## Tech Stack
+
+- [Next.js](https://nextjs.org/) - React framework
+- [TypeScript](https://www.typescriptlang.org/) - Type safety
+- [Tailwind CSS](https://tailwindcss.com/) - Styling
+- [shadcn/ui](https://ui.shadcn.com/) - UI components
+- [Zod](https://zod.dev/) - Schema validation
+`;
+    if (config.integrations.length > 0) {
+        content += `\n### Integrations\n\n`;
+        for (const id of config.integrations) {
+            content += `- ${integrationNames[id]}\n`;
+        }
+    }
+    content += `
+## Scripts
+
+\`\`\`bash
+npm run dev       # Start development server
+npm run build     # Build for production
+npm run start     # Start production server
+npm run lint      # Run ESLint
+\`\`\`
+`;
+    if (config.integrations.includes('neon-drizzle')) {
+        content += `
+### Database
+
+\`\`\`bash
+npm run db:generate  # Generate migrations
+npm run db:migrate   # Run migrations
+npm run db:studio    # Open Drizzle Studio
+\`\`\`
+`;
+    }
+    if (config.integrations.includes('inngest')) {
+        content += `
+### Background Jobs
+
+\`\`\`bash
+npm run inngest:dev  # Start Inngest dev server
+\`\`\`
+`;
+    }
+    content += `
+## Project Structure
+
+\`\`\`
+├── app/           # Next.js App Router
+├── components/    # React components
+├── lib/           # Utilities and clients
+├── services/      # Business logic
+`;
+    if (config.integrations.includes('resend')) {
+        content += `├── emails/        # Email templates\n`;
+    }
+    content += `└── public/        # Static assets
+\`\`\`
+
+## Environment Variables
+
+See \`.env.example\` for all required environment variables.
+
+## Learn More
+
+- [Next.js Documentation](https://nextjs.org/docs)
+- [CLAUDE.md](./CLAUDE.md) - AI assistant context file
+`;
+    await fs.writeFile(path.join(projectPath, 'README.md'), content);
+}
+export async function generateGitignore(projectPath) {
+    const content = `# Dependencies
+node_modules/
+.pnp/
+.pnp.js
+
+# Build
+.next/
+out/
+build/
+dist/
+
+# Environment
+.env
+.env.local
+.env.development.local
+.env.test.local
+.env.production.local
+
+# Testing
+coverage/
+
+# IDE
+.vscode/
+.idea/
+*.swp
+*.swo
+
+# OS
+.DS_Store
+Thumbs.db
+
+# Debug
+npm-debug.log*
+yarn-debug.log*
+yarn-error.log*
+
+# Vercel
+.vercel
+
+# TypeScript
+*.tsbuildinfo
+next-env.d.ts
+
+# Drizzle
+drizzle/
+
+# Sentry
+.sentryclirc
+`;
+    await fs.writeFile(path.join(projectPath, '.gitignore'), content);
+}

package/dist/index.d.ts

@@ -0,0 +1,2 @@
+#!/usr/bin/env node
+export {};

package/dist/index.js

@@ -0,0 +1,3 @@
+#!/usr/bin/env node
+import { main } from './cli.js';
+main();

package/dist/instrumentation.d.ts

@@ -0,0 +1,3 @@
+import type { ProjectConfig } from './types.js';
+export declare function generateInstrumentationClient(projectPath: string, config: ProjectConfig): Promise<void>;
+export declare function generateInstrumentation(projectPath: string, config: ProjectConfig): Promise<void>;

package/dist/instrumentation.js

@@ -0,0 +1,95 @@
+import fs from 'fs/promises';
+import path from 'path';
+// Generate instrumentation-client.ts content based on selected integrations
+export async function generateInstrumentationClient(projectPath, config) {
+    const hasPostHog = config.integrations.includes('posthog');
+    const hasSentry = config.integrations.includes('sentry');
+    if (!hasPostHog && !hasSentry)
+        return;
+    let content = '';
+    const imports = [];
+    // PostHog initialization
+    if (hasPostHog) {
+        imports.push("import posthog from 'posthog-js';");
+        imports.push("import { POSTHOG_KEY, POSTHOG_HOST } from '@/lib/config';");
+    }
+    // Sentry initialization
+    if (hasSentry) {
+        imports.push("import * as Sentry from '@sentry/nextjs';");
+        imports.push("import { SENTRY_DSN } from '@/lib/config';");
+    }
+    content += imports.join('\n') + '\n\n';
+    // PostHog init
+    if (hasPostHog) {
+        content += `// PostHog analytics
+posthog.init(POSTHOG_KEY, {
+  api_host: POSTHOG_HOST,
+  defaults: '2025-11-30',
+});
+`;
+    }
+    // Sentry init
+    if (hasSentry) {
+        if (hasPostHog)
+            content += '\n';
+        content += `// Sentry error tracking
+Sentry.init({
+  dsn: SENTRY_DSN,
+  environment: process.env.NODE_ENV,
+  sendDefaultPii: false,
+
+  tracesSampleRate: process.env.NODE_ENV === 'production' ? 0.1 : 0,
+  replaysSessionSampleRate: 0.1,
+  replaysOnErrorSampleRate: 1.0,
+
+  integrations: [
+    Sentry.replayIntegration({
+      maskAllText: true,
+      blockAllMedia: true,
+    }),
+  ],
+
+  beforeSend(event) {
+    if (process.env.NODE_ENV === 'development') return null;
+
+    // Scrub PII
+    if (event.user) {
+      delete event.user.email;
+      delete event.user.ip_address;
+      delete event.user.username;
+    }
+    if (event.request?.headers) {
+      delete event.request.headers['authorization'];
+      delete event.request.headers['cookie'];
+    }
+    return event;
+  },
+});
+
+// Instrument router navigations for performance
+export const onRouterTransitionStart = Sentry.captureRouterTransitionStart;
+`;
+    }
+    await fs.writeFile(path.join(projectPath, 'instrumentation-client.ts'), content);
+}
+// Generate instrumentation.ts for server-side (Sentry only currently)
+export async function generateInstrumentation(projectPath, config) {
+    if (!config.integrations.includes('sentry'))
+        return;
+    const content = `import * as Sentry from '@sentry/nextjs';
+
+export async function register() {
+  if (process.env.NEXT_RUNTIME === 'nodejs') {
+    await import('./sentry.server.config');
+  }
+
+  if (process.env.NEXT_RUNTIME === 'edge') {
+    await import('./sentry.edge.config');
+  }
+}
+
+// Capture errors from Server Components, middleware, and proxies
+export const onRequestError = Sentry.captureRequestError;
+`;
+    await fs.writeFile(path.join(projectPath, 'instrumentation.ts'), content);
+}

package/dist/integrations/ai-sdk.d.ts

@@ -0,0 +1,3 @@
+import type { Integration, AIProviderChoice } from '../types.js';
+export declare function createAiSdkIntegration(provider?: AIProviderChoice): Integration;
+export declare const aiSdkIntegration: Integration;

package/dist/integrations/ai-sdk.js

@@ -0,0 +1,20 @@
+import fs from 'fs/promises';
+import path from 'path';
+import { getAiServiceTemplate, getAiPackages, getAiEnvVar } from '../templates/ai-sdk.js';
+export function createAiSdkIntegration(provider = 'openai') {
+    const envVar = getAiEnvVar(provider);
+    return {
+        id: 'ai-sdk',
+        name: 'Vercel AI SDK',
+        description: 'AI integration with structured generation',
+        packages: getAiPackages(provider),
+        envVars: [envVar],
+        setup: async (projectPath) => {
+            // Create AI service
+            await fs.mkdir(path.join(projectPath, 'services'), { recursive: true });
+            await fs.writeFile(path.join(projectPath, 'services/ai.service.ts'), getAiServiceTemplate(provider));
+        },
+    };
+}
+// Default export for backwards compatibility
+export const aiSdkIntegration = createAiSdkIntegration('openai');

package/dist/integrations/clerk.d.ts

@@ -0,0 +1,2 @@
+import type { Integration } from '../types.js';
+export declare const clerkIntegration: Integration;

package/dist/integrations/clerk.js

@@ -0,0 +1,50 @@
+import fs from 'fs/promises';
+import path from 'path';
+import { clerkTemplates } from '../templates/clerk.js';
+export const clerkIntegration = {
+    id: 'clerk',
+    name: 'Clerk',
+    description: 'Authentication and user management',
+    packages: ['@clerk/nextjs'],
+    envVars: [
+        {
+            key: 'NEXT_PUBLIC_CLERK_PUBLISHABLE_KEY',
+            description: 'Clerk publishable key',
+            example: 'pk_test_...',
+            isPublic: true,
+        },
+        {
+            key: 'CLERK_SECRET_KEY',
+            description: 'Clerk secret key',
+            example: 'sk_test_...',
+        },
+        {
+            key: 'NEXT_PUBLIC_CLERK_SIGN_IN_URL',
+            description: 'Sign in URL',
+            example: '/sign-in',
+            isPublic: true,
+        },
+        {
+            key: 'NEXT_PUBLIC_CLERK_SIGN_UP_URL',
+            description: 'Sign up URL',
+            example: '/sign-up',
+            isPublic: true,
+        },
+    ],
+    setup: async (projectPath) => {
+        // Create services directory
+        await fs.mkdir(path.join(projectPath, 'services'), { recursive: true });
+        // Create user service
+        await fs.writeFile(path.join(projectPath, 'services/user.service.ts'), clerkTemplates.userService);
+        // Create proxy.ts (Next.js 16+)
+        await fs.writeFile(path.join(projectPath, 'proxy.ts'), clerkTemplates.proxy);
+        // Create auth components
+        await fs.mkdir(path.join(projectPath, 'components'), { recursive: true });
+        await fs.writeFile(path.join(projectPath, 'components/auth-buttons.tsx'), clerkTemplates.authComponents);
+        // Update layout.tsx to include ClerkProvider
+        const layoutPath = path.join(projectPath, 'app/layout.tsx');
+        const layoutContent = await fs.readFile(layoutPath, 'utf-8');
+        const updatedLayout = clerkTemplates.wrapLayout(layoutContent);
+        await fs.writeFile(layoutPath, updatedLayout);
+    },
+};

package/dist/integrations/firecrawl.d.ts

@@ -0,0 +1,2 @@
+import type { Integration } from '../types.js';
+export declare const firecrawlIntegration: Integration;

package/dist/integrations/firecrawl.js

@@ -0,0 +1,26 @@
+import fs from 'fs/promises';
+import path from 'path';
+import { firecrawlTemplates } from '../templates/firecrawl.js';
+export const firecrawlIntegration = {
+    id: 'firecrawl',
+    name: 'Firecrawl',
+    description: 'Web scraping',
+    packages: ['@mendable/firecrawl-js'],
+    envVars: [
+        {
+            key: 'FIRECRAWL_API_KEY',
+            description: 'Firecrawl API key',
+            example: 'fc-...',
+        },
+    ],
+    setup: async (projectPath) => {
+        // Create scrape service
+        await fs.mkdir(path.join(projectPath, 'services'), { recursive: true });
+        await fs.writeFile(path.join(projectPath, 'services/scrape.service.ts'), firecrawlTemplates.scrapeService);
+        // Create API route
+        await fs.mkdir(path.join(projectPath, 'app/api/scrape'), {
+            recursive: true,
+        });
+        await fs.writeFile(path.join(projectPath, 'app/api/scrape/route.ts'), firecrawlTemplates.scrapeRoute);
+    },
+};

package/dist/integrations/index.d.ts

@@ -0,0 +1,4 @@
+import type { Integration, IntegrationId, EnvVar, ProjectConfig } from '../types.js';
+export declare function installIntegrations(projectPath: string, config: ProjectConfig): Promise<void>;
+export declare function getEnvVars(config: ProjectConfig): EnvVar[];
+export declare const integrations: Partial<Record<IntegrationId, Integration>>;

package/dist/integrations/index.js

@@ -0,0 +1,64 @@
+import { execa } from 'execa';
+import { clerkIntegration } from './clerk.js';
+import { neonDrizzleIntegration } from './neon-drizzle.js';
+import { createAiSdkIntegration } from './ai-sdk.js';
+import { resendIntegration } from './resend.js';
+import { firecrawlIntegration } from './firecrawl.js';
+import { inngestIntegration } from './inngest.js';
+import { uploadthingIntegration } from './uploadthing.js';
+import { stripeIntegration } from './stripe.js';
+import { posthogIntegration } from './posthog.js';
+import { sentryIntegration } from './sentry.js';
+// Static integrations (don't need config)
+const staticIntegrations = {
+    clerk: clerkIntegration,
+    'neon-drizzle': neonDrizzleIntegration,
+    resend: resendIntegration,
+    firecrawl: firecrawlIntegration,
+    inngest: inngestIntegration,
+    uploadthing: uploadthingIntegration,
+    stripe: stripeIntegration,
+    posthog: posthogIntegration,
+    sentry: sentryIntegration,
+};
+// Get integration, with dynamic ones using config
+function getIntegration(id, config) {
+    if (id === 'ai-sdk') {
+        return createAiSdkIntegration(config.aiProvider ?? 'openai');
+    }
+    return staticIntegrations[id];
+}
+export async function installIntegrations(projectPath, config) {
+    const allPackages = [];
+    const allDevPackages = [];
+    // Collect all packages
+    for (const id of config.integrations) {
+        const integration = getIntegration(id, config);
+        allPackages.push(...integration.packages);
+        if (integration.devPackages) {
+            allDevPackages.push(...integration.devPackages);
+        }
+    }
+    // Install all packages at once
+    if (allPackages.length > 0) {
+        await execa('npm', ['install', ...allPackages], { cwd: projectPath });
+    }
+    if (allDevPackages.length > 0) {
+        await execa('npm', ['install', '-D', ...allDevPackages], { cwd: projectPath });
+    }
+    // Run setup for each integration
+    for (const id of config.integrations) {
+        const integration = getIntegration(id, config);
+        await integration.setup(projectPath);
+    }
+}
+export function getEnvVars(config) {
+    const envVars = [];
+    for (const id of config.integrations) {
+        const integration = getIntegration(id, config);
+        envVars.push(...integration.envVars);
+    }
+    return envVars;
+}
+// Export for backwards compatibility
+export const integrations = staticIntegrations;

package/dist/integrations/inngest.d.ts

@@ -0,0 +1,2 @@
+import type { Integration } from '../types.js';
+export declare const inngestIntegration: Integration;

package/dist/integrations/inngest.js

@@ -0,0 +1,45 @@
+import fs from 'fs/promises';
+import path from 'path';
+import { inngestTemplates } from '../templates/inngest.js';
+export const inngestIntegration = {
+    id: 'inngest',
+    name: 'Inngest',
+    description: 'Background jobs and workflows',
+    packages: ['inngest'],
+    envVars: [
+        {
+            key: 'INNGEST_EVENT_KEY',
+            description: 'Inngest event key',
+            example: '...',
+        },
+        {
+            key: 'INNGEST_SIGNING_KEY',
+            description: 'Inngest signing key',
+            example: '...',
+        },
+    ],
+    setup: async (projectPath) => {
+        // Create lib directory
+        await fs.mkdir(path.join(projectPath, 'lib'), { recursive: true });
+        // Create Inngest client
+        await fs.writeFile(path.join(projectPath, 'lib/inngest.client.ts'), inngestTemplates.inngestClient);
+        // Create Inngest functions
+        await fs.writeFile(path.join(projectPath, 'lib/inngest.functions.ts'), inngestTemplates.inngestFunctions);
+        // Create jobs service
+        await fs.mkdir(path.join(projectPath, 'services'), { recursive: true });
+        await fs.writeFile(path.join(projectPath, 'services/jobs.service.ts'), inngestTemplates.jobsService);
+        // Create API route
+        await fs.mkdir(path.join(projectPath, 'app/api/inngest'), {
+            recursive: true,
+        });
+        await fs.writeFile(path.join(projectPath, 'app/api/inngest/route.ts'), inngestTemplates.inngestRoute);
+        // Update package.json with inngest script
+        const pkgPath = path.join(projectPath, 'package.json');
+        const pkg = JSON.parse(await fs.readFile(pkgPath, 'utf-8'));
+        pkg.scripts = {
+            ...pkg.scripts,
+            'inngest:dev': 'npx inngest-cli@latest dev',
+        };
+        await fs.writeFile(pkgPath, JSON.stringify(pkg, null, 2));
+    },
+};

package/dist/integrations/neon-drizzle.d.ts

@@ -0,0 +1,2 @@
+import type { Integration } from '../types.js';
+export declare const neonDrizzleIntegration: Integration;

package/dist/integrations/neon-drizzle.js

@@ -0,0 +1,56 @@
+import fs from 'fs/promises';
+import path from 'path';
+import { neonDrizzleTemplates } from '../templates/neon-drizzle.js';
+export const neonDrizzleIntegration = {
+    id: 'neon-drizzle',
+    name: 'Neon + Drizzle',
+    description: 'Serverless Postgres with TypeScript ORM',
+    packages: ['drizzle-orm', '@neondatabase/serverless'],
+    devPackages: ['drizzle-kit'],
+    envVars: [
+        {
+            key: 'DATABASE_URL',
+            description: 'Neon database connection string',
+            example: 'postgresql://user:pass@host/db?sslmode=require',
+        },
+    ],
+    setup: async (projectPath) => {
+        // Create drizzle.config.ts
+        await fs.writeFile(path.join(projectPath, 'drizzle.config.ts'), neonDrizzleTemplates.drizzleConfig);
+        // Create lib/db directory
+        await fs.mkdir(path.join(projectPath, 'lib/db'), { recursive: true });
+        await fs.writeFile(path.join(projectPath, 'lib/db/client.ts'), neonDrizzleTemplates.dbClient);
+        await fs.writeFile(path.join(projectPath, 'lib/db/schema.ts'), neonDrizzleTemplates.schema);
+        await fs.writeFile(path.join(projectPath, 'lib/db/index.ts'), neonDrizzleTemplates.dbIndex);
+        // Create models directory
+        await fs.mkdir(path.join(projectPath, 'models'), { recursive: true });
+        await fs.writeFile(path.join(projectPath, 'models/todo.dto.ts'), neonDrizzleTemplates.todoDto);
+        await fs.writeFile(path.join(projectPath, 'models/todo.view.ts'), neonDrizzleTemplates.todoView);
+        await fs.writeFile(path.join(projectPath, 'models/todoCreate.schema.ts'), neonDrizzleTemplates.todoCreateSchema);
+        await fs.writeFile(path.join(projectPath, 'models/todoCreate.state.ts'), neonDrizzleTemplates.todoCreateState);
+        await fs.writeFile(path.join(projectPath, 'models/todoUpdate.schema.ts'), neonDrizzleTemplates.todoUpdateSchema);
+        await fs.writeFile(path.join(projectPath, 'models/todoUpdate.state.ts'), neonDrizzleTemplates.todoUpdateState);
+        // Create dao directory
+        await fs.mkdir(path.join(projectPath, 'dao'), { recursive: true });
+        await fs.writeFile(path.join(projectPath, 'dao/todo.dao.ts'), neonDrizzleTemplates.todoDao);
+        // Create mappers directory
+        await fs.mkdir(path.join(projectPath, 'mappers'), { recursive: true });
+        await fs.writeFile(path.join(projectPath, 'mappers/todo.mapper.ts'), neonDrizzleTemplates.todoMapper);
+        // Create services directory
+        await fs.mkdir(path.join(projectPath, 'services'), { recursive: true });
+        await fs.writeFile(path.join(projectPath, 'services/todo.service.ts'), neonDrizzleTemplates.todoService);
+        // Create actions directory
+        await fs.mkdir(path.join(projectPath, 'actions'), { recursive: true });
+        await fs.writeFile(path.join(projectPath, 'actions/todo.actions.ts'), neonDrizzleTemplates.todoActions);
+        // Update package.json with db scripts
+        const pkgPath = path.join(projectPath, 'package.json');
+        const pkg = JSON.parse(await fs.readFile(pkgPath, 'utf-8'));
+        pkg.scripts = {
+            ...pkg.scripts,
+            'db:generate': 'drizzle-kit generate',
+            'db:migrate': 'drizzle-kit migrate',
+            'db:studio': 'drizzle-kit studio',
+        };
+        await fs.writeFile(pkgPath, JSON.stringify(pkg, null, 2));
+    },
+};

package/dist/integrations/posthog.d.ts

@@ -0,0 +1,2 @@
+import type { Integration } from '../types.js';
+export declare const posthogIntegration: Integration;

package/dist/integrations/posthog.js

@@ -0,0 +1,25 @@
+export const posthogIntegration = {
+    id: 'posthog',
+    name: 'PostHog',
+    description: 'Product analytics',
+    packages: ['posthog-js'],
+    envVars: [
+        {
+            key: 'NEXT_PUBLIC_POSTHOG_KEY',
+            description: 'PostHog project API key',
+            example: 'phc_...',
+            isPublic: true,
+        },
+        {
+            key: 'NEXT_PUBLIC_POSTHOG_HOST',
+            description: 'PostHog host',
+            example: 'https://us.i.posthog.com',
+            isPublic: true,
+        },
+    ],
+    setup: async () => {
+        // instrumentation-client.ts is generated centrally in cli.ts
+        // Client components then just: import posthog from 'posthog-js'
+        // No service needed - PostHog is client-side only
+    },
+};

package/dist/integrations/resend.d.ts

@@ -0,0 +1,2 @@
+import type { Integration } from '../types.js';
+export declare const resendIntegration: Integration;

package/dist/integrations/resend.js

@@ -0,0 +1,34 @@
+import fs from 'fs/promises';
+import path from 'path';
+import { resendTemplates } from '../templates/resend.js';
+export const resendIntegration = {
+    id: 'resend',
+    name: 'Resend',
+    description: 'Email API',
+    packages: ['resend'],
+    envVars: [
+        {
+            key: 'RESEND_API_KEY',
+            description: 'Resend API key',
+            example: 're_...',
+        },
+        {
+            key: 'RESEND_FROM_EMAIL',
+            description: 'Default from email address',
+            example: 'onboarding@resend.dev',
+        },
+    ],
+    setup: async (projectPath) => {
+        // Create email service
+        await fs.mkdir(path.join(projectPath, 'services'), { recursive: true });
+        await fs.writeFile(path.join(projectPath, 'services/email.service.ts'), resendTemplates.emailService);
+        // Create email templates in components/emails
+        await fs.mkdir(path.join(projectPath, 'components/emails'), { recursive: true });
+        await fs.writeFile(path.join(projectPath, 'components/emails/welcome.tsx'), resendTemplates.welcomeEmail);
+        // Create API route
+        await fs.mkdir(path.join(projectPath, 'app/api/email/send'), {
+            recursive: true,
+        });
+        await fs.writeFile(path.join(projectPath, 'app/api/email/send/route.ts'), resendTemplates.sendRoute);
+    },
+};

package/dist/integrations/sentry.d.ts

@@ -0,0 +1,2 @@
+import type { Integration } from '../types.js';
+export declare const sentryIntegration: Integration;